app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

private-blocks.spec.ts (23409B)


      1 import { expect, test, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { svelte } from '@sveltejs/vite-plugin-svelte';
      4 import { fileURLToPath } from 'node:url';
      5 import { once } from 'node:events';
      6 import { WebSocketServer } from 'ws';
      7 import { createStaticHarness } from '../integration/harness/static.ts';
      8 import type * as Fixture from './harness/private-blocks.ts';
      9 declare global {
     10   interface Window {
     11     hcp123: typeof Fixture;
     12     hcp123Fixture: Awaited<ReturnType<typeof Fixture.createFixture>>;
     13     hcp123Pending?: Promise<boolean>;
     14     hcp123Queue?: Awaited<ReturnType<typeof Fixture.createQueueFixture>>;
     15   }
     16 }
     17 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     18   sockets: WebSocketServer,
     19   endpoint: string,
     20   bundle: string | undefined;
     21 let holdRequests = false;
     22 const heldReplies: (() => void)[] = [];
     23 let events: unknown[][] = [],
     24   queries: unknown[][] = [];
     25 test.beforeAll(async () => {
     26   server = await createStaticHarness();
     27   sockets = new WebSocketServer({
     28     host: '127.0.0.1',
     29     port: 0,
     30     maxPayload: 262144
     31   });
     32   await once(sockets, 'listening');
     33   const address = sockets.address();
     34   if (!address || typeof address === 'string')
     35     throw Error('loopback unavailable');
     36   endpoint = 'ws://127.0.0.1:' + address.port;
     37   sockets.on('connection', (socket) =>
     38     socket.on('message', (bytes) => {
     39       const raw = Buffer.isBuffer(bytes)
     40         ? bytes
     41         : Array.isArray(bytes)
     42           ? Buffer.concat(bytes)
     43           : Buffer.from(bytes);
     44       const frame = JSON.parse(raw.toString()) as unknown[];
     45       if (frame[0] === 'EVENT' || frame[0] === 'AUTH') events.push(frame);
     46       if (frame[0] === 'REQ') {
     47         queries.push(frame);
     48         const finish = () => {
     49           if (socket.readyState === 1)
     50             socket.send(JSON.stringify(['EOSE', frame[1]]));
     51         };
     52         if (holdRequests) heldReplies.push(finish);
     53         else finish();
     54       }
     55     })
     56   );
     57 });
     58 test.afterAll(async () => {
     59   for (const socket of sockets?.clients ?? []) socket.terminate();
     60   if (sockets)
     61     await new Promise<void>((resolve) => sockets.close(() => resolve()));
     62   await server?.close();
     63 });
     64 test.beforeEach(async ({ page }) => {
     65   events = [];
     66   queries = [];
     67   holdRequests = false;
     68   heldReplies.length = 0;
     69   await page.addInitScript((endpoint) => {
     70     const Native = window.WebSocket;
     71     window.WebSocket = class extends Native {
     72       constructor(url: string | URL, protocols?: string | string[]) {
     73         if (
     74           ![
     75             'wss://peer.example.org',
     76             'wss://archive.example.org',
     77             'wss://discovery.example.org'
     78           ].includes(new URL(String(url)).origin)
     79         )
     80           throw Error('no live relay authorization');
     81         super(endpoint, protocols);
     82       }
     83     };
     84   }, endpoint);
     85 });
     86 test.afterEach(async ({ page }) => {
     87   holdRequests = false;
     88   for (const finish of heldReplies.splice(0)) finish();
     89   if (!page.isClosed())
     90     await page.evaluate(async () => {
     91       window.hcp123Fixture?.mode('normal');
     92       window.hcp123Fixture?.settle();
     93       window.hcp123Fixture?.releaseInventory();
     94       window.hcp123Queue?.mode('normal');
     95       window.hcp123Queue?.settle();
     96       await window.hcp123Pending;
     97       await window.hcp123Fixture?.close();
     98       window.hcp123Queue?.close();
     99     });
    100 });
    101 async function start(
    102   page: Page,
    103   scenario: 'inbound' | 'backfill' | 'contexts' = 'inbound'
    104 ) {
    105   await loadFixtureScripts(page);
    106   await page.evaluate(async (scenario) => {
    107     window.hcp123Fixture = await window.hcp123.createFixture(scenario);
    108   }, scenario);
    109 }
    110 async function loadFixtureScripts(page: Page) {
    111   await page.goto(server.url + '/privacy');
    112   if (!bundle) {
    113     const built = await build({
    114       configFile: false,
    115       logLevel: 'silent',
    116       plugins: [svelte({ configFile: false })],
    117       resolve: {
    118         conditions: ['browser'],
    119         alias: {
    120           '$app/navigation': fileURLToPath(
    121             new URL('./harness/conversation-thread.ts', import.meta.url)
    122           )
    123         }
    124       },
    125       build: {
    126         write: false,
    127         minify: false,
    128         lib: {
    129           entry: fileURLToPath(
    130             new URL('./harness/private-blocks.ts', import.meta.url)
    131           ),
    132           name: 'hcp123',
    133           formats: ['iife']
    134         }
    135       }
    136     });
    137     const result = Array.isArray(built) ? built[0] : built;
    138     if (!('output' in result)) throw Error('fixture bundle unavailable');
    139     const chunks = result.output.filter((row) => row.type === 'chunk');
    140     expect(chunks).toHaveLength(1);
    141     bundle = chunks[0].code;
    142   }
    143   await page.addScriptTag({ content: bundle });
    144 }
    145 async function unlocked(page: Page) {
    146   await page.evaluate(() => window.hcp123Fixture.checkSetup());
    147   const result = await page.evaluate(async () => {
    148     const success = await window.hcp123Fixture.unlock();
    149     const { state, reason, queued, count } = window.hcp123Fixture.snapshot();
    150     const preferences = window.hcp123Fixture.preferences();
    151     return {
    152       success,
    153       diagnostic: {
    154         state,
    155         reason,
    156         queued,
    157         count,
    158         preferences: preferences.state
    159       }
    160     };
    161   });
    162   expect(result.success, JSON.stringify(result.diagnostic)).toBe(true);
    163   await expect(page.locator('[data-message-id]')).not.toHaveCount(0);
    164   // Wait for the original displayed-read transaction to release its native
    165   // owner lock before explicitly testing another independent owner mutation.
    166   const displayed = await page.locator('[data-message-id]').count();
    167   await expect
    168     .poll(async () => {
    169       const native = await page.evaluate(() => window.hcp123Fixture.native());
    170       return native.received.filter(
    171         (row) =>
    172           (JSON.parse((row as { wire: string }).wire) as { read: unknown })
    173             .read !== null
    174       ).length;
    175     })
    176     .toBe(displayed);
    177   await page.evaluate(() => window.hcp123Fixture.waitOwner());
    178 }
    179 test('HCP123 SSR privacy discloses reversible local blocking without account inventory', async ({
    180   page
    181 }) => {
    182   await page.goto(server.url + '/privacy');
    183   expect(await page.locator('main').innerText()).toContain(
    184     'Blocking a person is local'
    185   );
    186   await expect(page.getByRole('button', { name: 'Undo block' })).toHaveCount(0);
    187   expect(events).toEqual([]);
    188   expect(queries).toEqual([]);
    189 });
    190 test('HCP123 genuine authenticated inner peer block removes thread and list previews while retaining evidence', async ({
    191   page
    192 }) => {
    193   await start(page);
    194   await unlocked(page);
    195   const before = await page.evaluate(() => window.hcp123Fixture.native());
    196   await page
    197     .getByText('Identity and conversation options', { exact: true })
    198     .click();
    199   await page.getByRole('button', { name: 'Block person', exact: true }).click();
    200   await expect(
    201     page.getByText(/Blocking hides messages and previews/)
    202   ).toBeVisible();
    203   await page
    204     .getByRole('button', { name: 'Confirm local block', exact: true })
    205     .click();
    206   await expect(page.locator('[data-message-id]')).toHaveCount(0);
    207   expect(await page.evaluate(() => window.hcp123Fixture.list())).toMatchObject({
    208     requests: [],
    209     conversations: []
    210   });
    211   expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual(
    212     before
    213   );
    214   expect(
    215     await page.evaluate(() => window.hcp123Fixture.preferences())
    216   ).toMatchObject({
    217     state: 'ready',
    218     peers: [await page.evaluate(() => window.hcp123Fixture.peer)]
    219   });
    220   expect(events).toEqual([]);
    221   expect(queries).toEqual([]);
    222 });
    223 test('HCP123 Privacy Undo starts no decrypt signer or relay work and restores eligible cached projection', async ({
    224   page
    225 }) => {
    226   await start(page);
    227   await unlocked(page);
    228   expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({
    229     status: 'saved'
    230   });
    231   const before = await page.evaluate(() => window.hcp123Fixture.delta());
    232   await page.getByRole('button', { name: 'Undo block', exact: true }).click();
    233   await expect(page.locator('[data-message-id]')).toHaveCount(1);
    234   expect(await page.evaluate(() => window.hcp123Fixture.delta())).toEqual(
    235     before
    236   );
    237   expect(events).toEqual([]);
    238   expect(queries).toEqual([]);
    239 });
    240 test('HCP123 copied room or displayed peer cannot authorize a private block', async ({
    241   page
    242 }) => {
    243   await start(page);
    244   await unlocked(page);
    245   expect(await page.evaluate(() => window.hcp123Fixture.fake())).toEqual({
    246     status: 'invalid'
    247   });
    248   expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual([]);
    249   await expect(page.locator('[data-message-id]')).toHaveCount(1);
    250 });
    251 test('HCP123 corrupt preferences fail closed without resetting stored facts', async ({
    252   page
    253 }) => {
    254   await start(page);
    255   await unlocked(page);
    256   await page.evaluate(() => window.hcp123Fixture.corrupt());
    257   await expect(page.locator('[data-message-id]')).toHaveCount(0);
    258   expect(await page.evaluate(() => window.hcp123Fixture.rows())).toHaveLength(
    259     1
    260   );
    261   expect(await page.evaluate(() => window.hcp123Fixture.next())).toBe(false);
    262   await expect(
    263     page.getByRole('button', { name: 'Undo block', exact: true })
    264   ).toHaveCount(0);
    265 });
    266 test('HCP123 actual native abort gives no Saved or enforced block', async ({
    267   page
    268 }) => {
    269   await start(page);
    270   await unlocked(page);
    271   expect(await page.evaluate(() => window.hcp123Fixture.abortWrite())).toEqual({
    272     status: 'aborted'
    273   });
    274   expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual([]);
    275   await expect(page.locator('[data-message-id]')).toHaveCount(1);
    276 });
    277 test('HCP123 failed readback after completed native write is unknown until explicit reconciliation', async ({
    278   page
    279 }) => {
    280   await start(page);
    281   await unlocked(page);
    282   expect(
    283     await page.evaluate(() => window.hcp123Fixture.failReadback())
    284   ).toEqual({ status: 'unknown_completion' });
    285   expect(await page.evaluate(() => window.hcp123Fixture.rows())).toHaveLength(
    286     1
    287   );
    288   await page.evaluate(() => window.hcp123Fixture.refresh());
    289   await expect(page.locator('[data-message-id]')).toHaveCount(0);
    290 });
    291 test('HCP123 logout retires current private inventory without deleting preference or encrypted evidence', async ({
    292   page
    293 }) => {
    294   await start(page);
    295   await unlocked(page);
    296   await page.evaluate(() => window.hcp123Fixture.block());
    297   const settled = await page.evaluate(async () => ({
    298     rows: await window.hcp123Fixture.rows(),
    299     native: await window.hcp123Fixture.native()
    300   }));
    301   await page.evaluate(() => window.hcp123Fixture.logout());
    302   expect(
    303     await page.evaluate(() => window.hcp123Fixture.preferences())
    304   ).toMatchObject({ state: 'unavailable' });
    305   expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual(
    306     settled.rows
    307   );
    308   expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual(
    309     settled.native
    310   );
    311   await expect(
    312     page.getByRole('button', { name: 'Undo block', exact: true })
    313   ).toHaveCount(0);
    314 });
    315 test('HCP123 live block fences an already pending authentic decrypt and subsequent automatic continuation', async ({
    316   page
    317 }) => {
    318   await start(page, 'backfill');
    319   await unlocked(page);
    320   await page.evaluate(() => {
    321     window.hcp123Fixture.mode('hold_decrypt');
    322     window.hcp123Pending = window.hcp123Fixture.next();
    323   });
    324   await expect
    325     .poll(() => page.evaluate(() => window.hcp123Fixture.pending()))
    326     .toBe(true);
    327   const before = await page.evaluate(() => window.hcp123Fixture.native());
    328   expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({
    329     status: 'saved'
    330   });
    331   await page.evaluate(() => {
    332     window.hcp123Fixture.mode('normal');
    333     window.hcp123Fixture.settle();
    334   });
    335   await page.evaluate(() => window.hcp123Pending);
    336   await expect(page.locator('[data-message-id]')).toHaveCount(0);
    337   expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual(
    338     before
    339   );
    340   expect(events).toEqual([]);
    341   expect(queries).toEqual([]);
    342 });
    343 for (const width of [320, 1024])
    344   test(`HCP123 ${width}px consequences and Undo remain operable`, async ({
    345     page
    346   }) => {
    347     await page.setViewportSize({ width, height: 800 });
    348     await start(page);
    349     await unlocked(page);
    350     await page
    351       .getByText('Identity and conversation options', { exact: true })
    352       .click();
    353     await page
    354       .getByRole('button', { name: 'Block person', exact: true })
    355       .click();
    356     await page
    357       .getByRole('button', { name: 'Confirm local block', exact: true })
    358       .click();
    359     await expect(
    360       page.getByRole('button', { name: 'Undo block', exact: true })
    361     ).toBeVisible();
    362     expect(
    363       await page.evaluate(
    364         () => document.documentElement.scrollWidth > window.innerWidth
    365       )
    366     ).toBe(false);
    367   });
    368 
    369 test('HCP123 a second genuine same-owner generation cannot import the original room custody', async ({
    370   page
    371 }) => {
    372   await start(page);
    373   await unlocked(page);
    374   expect(
    375     await page.evaluate(() => window.hcp123Fixture.foreignGeneration())
    376   ).toEqual({ status: 'invalid' });
    377   expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual([]);
    378 });
    379 test('HCP123 disposing one genuine preference view preserves its sibling and current Inbox owner', async ({
    380   page
    381 }) => {
    382   await start(page);
    383   await unlocked(page);
    384   expect(
    385     await page.evaluate(() => window.hcp123Fixture.disposeSibling())
    386   ).toMatchObject({ state: 'ready', revision: 0, peers: [] });
    387   await expect(page.locator('[data-message-id]')).toHaveCount(1);
    388   expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({
    389     status: 'saved'
    390   });
    391 });
    392 test('HCP123 block acknowledged during native inventory loading starts no subsequent unwrap', async ({
    393   page
    394 }) => {
    395   await start(page, 'backfill');
    396   await unlocked(page);
    397   const before = await page.evaluate(() => window.hcp123Fixture.delta());
    398   await page.evaluate(() => {
    399     window.hcp123Fixture.holdInventory();
    400     window.hcp123Pending = window.hcp123Fixture.next();
    401   });
    402   await expect
    403     .poll(() => page.evaluate(() => window.hcp123Fixture.inventoryHeld()))
    404     .toBe(true);
    405   expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({
    406     status: 'saved'
    407   });
    408   await page.evaluate(() => window.hcp123Fixture.releaseInventory());
    409   expect(await page.evaluate(() => window.hcp123Pending)).toBe(false);
    410   expect(await page.evaluate(() => window.hcp123Fixture.delta())).toEqual(
    411     before
    412   );
    413   await expect(page.locator('[data-message-id]')).toHaveCount(0);
    414 });
    415 test('HCP123 persisted authenticated unknown peer block still charges twenty opaque envelopes and Undo starts no work', async ({
    416   page
    417 }) => {
    418   await loadFixtureScripts(page);
    419   const result = await page.evaluate(async () => {
    420     const f = await window.hcp123.createQueueFixture(21, true);
    421     window.hcp123Queue = f;
    422     const saved = await f.persistInnerBlock();
    423     const before = f.delta();
    424     const captured = f.capture();
    425     const batch = await f.batch();
    426     const after = f.delta();
    427     const snapshot = f.snapshot();
    428     const unchanged = await f.encryptedUnchanged();
    429     const publicContains = await f.publicContains();
    430     const rooms = f.visibleRooms();
    431     const undo = await f.undoInnerBlock();
    432     const afterUndo = f.delta();
    433     const next = await f.batch();
    434     const afterNext = f.delta();
    435     return {
    436       saved,
    437       captured,
    438       batch,
    439       before,
    440       after,
    441       snapshot,
    442       unchanged,
    443       publicContains,
    444       rooms,
    445       undo,
    446       afterUndo,
    447       next,
    448       afterNext
    449     };
    450   });
    451   expect(result.saved).toEqual({ status: 'saved' });
    452   expect(result.captured).toBe(true);
    453   expect(result.batch).toBe(true);
    454   expect(result.snapshot).toMatchObject({
    455     attempted: 20,
    456     blocked: 20,
    457     admitted: 0,
    458     queued: 1,
    459     state: 'needs_action'
    460   });
    461   expect(result.after.decrypts - result.before.decrypts).toBe(40);
    462   expect(result.after.signs - result.before.signs).toBe(0);
    463   expect(result.after.encrypts - result.before.encrypts).toBe(0);
    464   expect(result.rooms).toEqual([]);
    465   expect(result.unchanged).toBe(true);
    466   expect(result.publicContains).toBe(false);
    467   expect(result.undo).toEqual({ status: 'saved' });
    468   expect(result.afterUndo).toEqual(result.after);
    469   expect(result.next).toBe(true);
    470   expect(result.afterNext.decrypts - result.afterUndo.decrypts).toBe(40);
    471   expect(events).toEqual([]);
    472   expect(queries).toEqual([]);
    473 });
    474 
    475 test('HCP123 actual owner lock contention acknowledges no block or native write', async ({
    476   page
    477 }) => {
    478   await start(page);
    479   await unlocked(page);
    480   const before = await page.evaluate(() => window.hcp123Fixture.native());
    481   await page.evaluate(() => window.hcp123Fixture.holdReadLock());
    482   expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({
    483     status: 'busy'
    484   });
    485   expect(
    486     await page.evaluate(() => window.hcp123Fixture.preferences())
    487   ).toMatchObject({ state: 'ready', revision: 0, peers: [] });
    488   expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual([]);
    489   expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual(
    490     before
    491   );
    492   await expect(page.locator('[data-message-id]')).toHaveCount(1);
    493   await page.evaluate(() => window.hcp123Fixture.releaseRead());
    494 });
    495 test('HCP123 existing acknowledged native peer row reconciles the whole revision without another write', async ({
    496   page
    497 }) => {
    498   await start(page);
    499   await unlocked(page);
    500   const result = await page.evaluate(() =>
    501     window.hcp123Fixture.matchingNativeRow()
    502   );
    503   expect(result.result).toEqual({ status: 'existing' });
    504   expect(result.after).toEqual(result.before);
    505   expect(result.writes).toBe(0);
    506   expect(result.snapshot).toMatchObject({ state: 'ready', revision: 17 });
    507   if (result.snapshot.state !== 'ready')
    508     throw Error('no current native preferences');
    509   expect(result.snapshot.peers).toEqual(
    510     [
    511       await page.evaluate(() => window.hcp123Fixture.peer),
    512       result.unrelatedPeer
    513     ].sort()
    514   );
    515   await expect(page.locator('[data-message-id]')).toHaveCount(0);
    516   expect(await page.evaluate(() => window.hcp123Fixture.list())).toMatchObject({
    517     requests: [],
    518     conversations: []
    519   });
    520 });
    521 test('HCP123 genuine competing native transaction fails full-wire CAS and preserves unrelated peer facts', async ({
    522   page
    523 }) => {
    524   await start(page);
    525   await unlocked(page);
    526   const result = await page.evaluate(() =>
    527     window.hcp123Fixture.competingNativeRow()
    528   );
    529   expect(result.result).toEqual({ status: 'conflict' });
    530   expect(result.rows).toHaveLength(1);
    531   const wire = JSON.parse((result.rows[0] as { wire: string }).wire) as {
    532     revision: number;
    533     peers: string[];
    534   };
    535   expect(wire).toMatchObject({ revision: 19, peers: [result.unrelatedPeer] });
    536   expect(result.snapshot).toMatchObject({
    537     state: 'unavailable',
    538     reason: 'conflict'
    539   });
    540   await expect(page.locator('[data-message-id]')).toHaveCount(0);
    541   const counts = await page.evaluate(() => window.hcp123Fixture.delta());
    542   expect(await page.evaluate(() => window.hcp123Fixture.next())).toBe(false);
    543   expect(await page.evaluate(() => window.hcp123Fixture.delta())).toEqual(
    544     counts
    545   );
    546   await page.evaluate(() => window.hcp123Fixture.refresh());
    547   expect(
    548     await page.evaluate(() => window.hcp123Fixture.preferences())
    549   ).toMatchObject({
    550     state: 'ready',
    551     revision: 19,
    552     peers: [result.unrelatedPeer]
    553   });
    554 });
    555 test('HCP123 acknowledged block reloads for the original account and stays isolated from another observed owner', async ({
    556   page
    557 }) => {
    558   await start(page);
    559   await unlocked(page);
    560   expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({
    561     status: 'saved'
    562   });
    563   const native = await page.evaluate(() => window.hcp123Fixture.native());
    564   const rows = await page.evaluate(() => window.hcp123Fixture.rows());
    565   const result = await page.evaluate(() => window.hcp123Fixture.reloadOwners());
    566   expect(result.snapshots).toHaveLength(3);
    567   const [same, other, returned] = result.snapshots;
    568   if (!same || !other || !returned)
    569     throw Error('actual owner reload sequence incomplete');
    570   expect(same.snapshot).toMatchObject({
    571     state: 'ready',
    572     owner: await page.evaluate(() => window.hcp123Fixture.owner),
    573     revision: 1,
    574     peers: [await page.evaluate(() => window.hcp123Fixture.peer)]
    575   });
    576   expect(other.snapshot).toMatchObject({
    577     state: 'ready',
    578     owner: await page.evaluate(() => window.hcp123Fixture.peer),
    579     revision: 0,
    580     peers: []
    581   });
    582   expect(returned.snapshot).toEqual(same.snapshot);
    583   for (const row of result.snapshots) expect(row.after).toEqual(row.before);
    584   expect(result.old).toMatchObject({ state: 'unavailable', reason: 'stopped' });
    585   expect(result.rows).toEqual(rows);
    586   expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual(
    587     native
    588   );
    589 });
    590 test('HCP123 block retires captured genuine reply citation and read actions before late citation completion', async ({
    591   page
    592 }) => {
    593   await start(page, 'contexts');
    594   await unlocked(page);
    595   holdRequests = true;
    596   const before = await page.evaluate(() =>
    597     window.hcp123Fixture.captureActions()
    598   );
    599   expect(before.current).toBe(true);
    600   expect(before.citation).toBeDefined();
    601   expect(before.text).toBe('HCP123_OLD_REPLY_MEMORY_ONLY');
    602   await expect.poll(() => queries.length).toBeGreaterThan(0);
    603   expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({
    604     status: 'saved'
    605   });
    606   const native = await page.evaluate(() => window.hcp123Fixture.native());
    607   const counts = await page.evaluate(() => window.hcp123Fixture.delta());
    608   const old = await page.evaluate(() => window.hcp123Fixture.capturedActions());
    609   expect(old).toMatchObject({
    610     current: false,
    611     send: { status: 'stopped' },
    612     displayed: false
    613   });
    614   expect(old.citation).toBeUndefined();
    615   expect(old.message).toBeUndefined();
    616   expect(old.reply).toBeUndefined();
    617   expect(old.text).toBeUndefined();
    618   const queryCount = queries.length;
    619   holdRequests = false;
    620   for (const release of heldReplies.splice(0)) release();
    621   expect(
    622     await page.evaluate(() => window.hcp123Fixture.capturedActions())
    623   ).toEqual(old);
    624   expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual(
    625     native
    626   );
    627   expect(await page.evaluate(() => window.hcp123Fixture.delta())).toEqual(
    628     counts
    629   );
    630   expect(queries).toHaveLength(queryCount);
    631   expect(events).toEqual([]);
    632   await expect(
    633     page.getByText('HCP123_OLD_REPLY_MEMORY_ONLY', { exact: true })
    634   ).toHaveCount(0);
    635 });
    636 test('HCP123 lost completion channel after genuine native block fails closed until explicit reconciliation', async ({
    637   page
    638 }) => {
    639   await start(page);
    640   await unlocked(page);
    641   expect(
    642     await page.evaluate(() => window.hcp123Fixture.failLockCompletion())
    643   ).toEqual({ status: 'unknown_completion' });
    644   const rows = await page.evaluate(() => window.hcp123Fixture.rows());
    645   expect(rows).toHaveLength(1);
    646   expect(JSON.parse((rows[0] as { wire: string }).wire)).toMatchObject({
    647     revision: 1,
    648     peers: [await page.evaluate(() => window.hcp123Fixture.peer)]
    649   });
    650   expect(
    651     await page.evaluate(() => window.hcp123Fixture.preferences())
    652   ).toMatchObject({ state: 'unavailable', reason: 'unknown_completion' });
    653   await page.evaluate(() => window.hcp123Fixture.refresh());
    654   expect(
    655     await page.evaluate(() => window.hcp123Fixture.preferences())
    656   ).toMatchObject({
    657     state: 'ready',
    658     revision: 1,
    659     peers: [await page.evaluate(() => window.hcp123Fixture.peer)]
    660   });
    661   expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual(rows);
    662 });