app

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

inbox-access-controller.spec.ts (24106B)


      1 import { test, expect, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { fileURLToPath } from 'node:url';
      4 import { once } from 'node:events';
      5 import { WebSocketServer, type WebSocket } from 'ws';
      6 import { createStaticHarness } from '../integration/harness/static.ts';
      7 import type * as Fixture from './harness/inbox-access-controller.ts';
      8 declare global {
      9   interface Window {
     10     cr007: typeof Fixture;
     11     cr007Fixture: Awaited<ReturnType<typeof Fixture.makeControllerFixture>>;
     12     cr007Controller: NonNullable<
     13       Awaited<ReturnType<Window['cr007Fixture']['capture']>>
     14     >;
     15     cr007Pending?: Promise<string>;
     16     cr007Release?: () => void;
     17     cr007Waiting?: boolean;
     18     cr007Open?: boolean;
     19     cr007StopLive?: () => void;
     20     cr007StopPage?: () => void;
     21     cr007PageEnd?: string;
     22     cr007LiveEvents?: number;
     23     cr007DelayClose?: boolean;
     24     cr007HeldClose?: (() => void)[];
     25     cr007ThrowConstructor?: string;
     26     cr007Reconnected?: boolean;
     27     cr007Fault?: ReturnType<typeof Fixture.installCloseFailure>;
     28   }
     29 }
     30 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     31   sockets: WebSocketServer,
     32   endpoint: string,
     33   bundle: string;
     34 let head = '',
     35   accept = true;
     36 const frames: { origin: string; frame: unknown[] }[] = [];
     37 const connections = new Map<WebSocket, string>();
     38 let peakPrivateConnections = 0,
     39   constructedPrivateConnections = 0;
     40 test.beforeAll(async () => {
     41   server = await createStaticHarness();
     42   sockets = new WebSocketServer({
     43     host: '127.0.0.1',
     44     port: 0,
     45     maxPayload: 65536
     46   });
     47   await once(sockets, 'listening');
     48   const address = sockets.address();
     49   if (!address || typeof address === 'string') throw Error('owned loopback');
     50   endpoint = 'ws://127.0.0.1:' + address.port;
     51   sockets.on('connection', (socket, request) => {
     52     const origin =
     53       new URL(request.url ?? '/', endpoint).searchParams.get('origin') ?? '';
     54     connections.set(socket, origin);
     55     if (origin !== 'wss://discovery.example.org') {
     56       constructedPrivateConnections++;
     57       peakPrivateConnections = Math.max(
     58         peakPrivateConnections,
     59         [...connections.values()].filter(
     60           (from) => from !== 'wss://discovery.example.org'
     61         ).length
     62       );
     63     }
     64     socket.on('close', () => connections.delete(socket));
     65     socket.send(JSON.stringify(['AUTH', 'cr007-controlled-challenge']));
     66     socket.on('message', (bytes) => {
     67       const raw = Buffer.isBuffer(bytes)
     68         ? bytes
     69         : Array.isArray(bytes)
     70           ? Buffer.concat(bytes)
     71           : Buffer.from(bytes);
     72       const frame = JSON.parse(raw.toString()) as unknown[];
     73       frames.push({ origin, frame });
     74       if (frame[0] === 'AUTH')
     75         socket.send(
     76           JSON.stringify([
     77             'OK',
     78             (frame[1] as { id: string }).id,
     79             accept,
     80             accept ? '' : 'blocked: controlled refusal'
     81           ])
     82         );
     83       if (frame[0] === 'REQ' && origin === 'wss://discovery.example.org') {
     84         const filter = frame[2] as { kinds?: number[] };
     85         if (filter.kinds?.includes(10050) && head)
     86           socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
     87         socket.send(JSON.stringify(['EOSE', frame[1]]));
     88       }
     89     });
     90   });
     91   const result = await build({
     92     configFile: false,
     93     logLevel: 'silent',
     94     build: {
     95       write: false,
     96       minify: false,
     97       lib: {
     98         entry: fileURLToPath(
     99           new URL('./harness/inbox-access-controller.ts', import.meta.url)
    100         ),
    101         name: 'cr007',
    102         formats: ['iife']
    103       }
    104     }
    105   });
    106   const output = Array.isArray(result) ? result[0] : result;
    107   if (!('output' in output)) throw Error('actual fixture bundle');
    108   const chunks = output.output.filter((chunk) => chunk.type === 'chunk');
    109   expect(chunks).toHaveLength(1);
    110   bundle = chunks[0].code;
    111 });
    112 test.afterAll(async () => {
    113   for (const socket of sockets.clients) socket.terminate();
    114   await new Promise<void>((resolve) => sockets.close(() => resolve()));
    115   await server.close();
    116 });
    117 test.beforeEach(async ({ page }) => {
    118   await expect.poll(() => connections.size).toBe(0);
    119   peakPrivateConnections = 0;
    120   constructedPrivateConnections = 0;
    121   head = '';
    122   accept = true;
    123   frames.length = 0;
    124   await page.addInitScript(
    125     ({ endpoint }) => {
    126       const Native = window.WebSocket;
    127       window.WebSocket = class extends Native {
    128         constructor(url: string | URL, protocols?: string | string[]) {
    129           const origin = new URL(String(url)).origin;
    130           if (
    131             ![
    132               'wss://discovery.example.org',
    133               'wss://inbox.example.org',
    134               'wss://peer.example.org',
    135               'wss://archive.example.org'
    136             ].includes(origin)
    137           )
    138             throw Error('unexpected fixture egress');
    139           if (window.cr007ThrowConstructor === origin) {
    140             window.cr007ThrowConstructor = undefined;
    141             throw Error('controlled native constructor failure before super');
    142           }
    143           super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
    144         }
    145         override close(code?: number, reason?: string) {
    146           if (
    147             window.cr007DelayClose &&
    148             !this.url.includes(
    149               encodeURIComponent('wss://discovery.example.org')
    150             )
    151           ) {
    152             (window.cr007HeldClose ??= []).push(() =>
    153               super.close(code, reason)
    154             );
    155           } else super.close(code, reason);
    156         }
    157       };
    158     },
    159     { endpoint }
    160   );
    161   await page.goto(server.url + '/search');
    162   await page.addScriptTag({ content: bundle });
    163   head = await page.evaluate(async () => {
    164     window.cr007Fixture = await window.cr007.makeControllerFixture();
    165     return window.cr007Fixture.preferenceWire([window.cr007.origins[0]]);
    166   });
    167   await page.evaluate(async () => {
    168     window.cr007Controller = await window.cr007Fixture.capture();
    169   });
    170 });
    171 test.afterEach(async ({ page }) => {
    172   if (!page.isClosed())
    173     await page.evaluate(() => {
    174       window.cr007Fault?.restore();
    175       window.cr007Release?.();
    176       window.cr007StopPage?.();
    177       window.cr007StopLive?.();
    178       window.cr007DelayClose = false;
    179       for (const release of window.cr007HeldClose ?? []) release();
    180       window.cr007Fixture.close();
    181     });
    182 });
    183 async function challenge(page: Page) {
    184   await page.evaluate(() =>
    185     window.cr007.authenticateInboxAccess(
    186       window.cr007Controller,
    187       window.cr007.origins[0],
    188       'reviewed_inbox_connection_auth'
    189     )
    190   );
    191   await expect
    192     .poll(() =>
    193       page.evaluate(
    194         () =>
    195           window.cr007.inboxAccessControllerSnapshot(window.cr007Controller)
    196             ?.auth[0]?.state
    197       )
    198     )
    199     .toBe('challenge');
    200 }
    201 test('genuine controller capture has no private connection or sign and never claims readiness', async ({
    202   page
    203 }) => {
    204   expect(
    205     [...connections.values()].filter(
    206       (origin) => origin !== 'wss://discovery.example.org'
    207     )
    208   ).toHaveLength(0);
    209   const result = await page.evaluate(async () => ({
    210     snapshot: window.cr007.inboxAccessControllerSnapshot(
    211       window.cr007Controller
    212     ),
    213     signs: window.cr007Fixture.signs(),
    214     wrong: await window.cr007.authenticateInboxAccess(
    215       window.cr007Controller,
    216       window.cr007.origins[0],
    217       'wrong-review'
    218     )
    219   }));
    220   expect(result.signs).toBe(0);
    221   expect(result.wrong).toBe('unavailable');
    222   expect(result.snapshot?.readiness).toBe('unavailable');
    223   expect(
    224     frames.some(({ frame }) => ['AUTH', 'EVENT'].includes(String(frame[0])))
    225   ).toBe(false);
    226 });
    227 test('explicit current owner AUTH sends real signed22242 only and duplicate initiation cannot reset it', async ({
    228   page
    229 }) => {
    230   await challenge(page);
    231   expect(
    232     await page.evaluate(() =>
    233       window.cr007.respondInboxAccessAuthentication(
    234         window.cr007Controller,
    235         window.cr007.origins[0],
    236         'reviewed_inbox_auth_response'
    237       )
    238     )
    239   ).toBe('accepted');
    240   expect(
    241     await page.evaluate(() =>
    242       window.cr007.authenticateInboxAccess(
    243         window.cr007Controller,
    244         window.cr007.origins[0],
    245         'reviewed_inbox_connection_auth'
    246       )
    247     )
    248   ).toBe('accepted');
    249   const sent = frames.filter(({ frame }) => frame[0] === 'AUTH');
    250   expect(sent).toHaveLength(1);
    251   expect(sent[0].frame[1]).toMatchObject({
    252     kind: 22242,
    253     pubkey: await page.evaluate(() => window.cr007Fixture.owner),
    254     tags: [
    255       ['relay', 'wss://inbox.example.org/'],
    256       ['challenge', 'cr007-controlled-challenge']
    257     ]
    258   });
    259   expect(frames.some(({ frame }) => frame[0] === 'EVENT')).toBe(false);
    260   expect(
    261     await page.evaluate(
    262       () =>
    263         window.cr007.inboxAccessControllerSnapshot(window.cr007Controller)
    264           ?.readiness
    265     )
    266   ).toBe('unavailable');
    267 });
    268 test('actual discovery generation churn during pending signing cannot emit late AUTH', async ({
    269   page
    270 }) => {
    271   await challenge(page);
    272   await page.evaluate(() => {
    273     window.cr007Fixture.beforeSign(
    274       () =>
    275         new Promise<void>((resolve) => {
    276           window.cr007Waiting = true;
    277           window.cr007Release = resolve;
    278         })
    279     );
    280     window.cr007Pending = window.cr007.respondInboxAccessAuthentication(
    281       window.cr007Controller,
    282       window.cr007.origins[0],
    283       'reviewed_inbox_auth_response'
    284     );
    285   });
    286   await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true);
    287   await page.evaluate(() => {
    288     window.cr007Fixture.churnHead();
    289     window.cr007Release?.();
    290   });
    291   expect(await page.evaluate(() => window.cr007Pending)).toBe('stopped');
    292   expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(0);
    293 });
    294 test('actual discovery churn during pending fresh key cannot open an AUTH socket', async ({
    295   page
    296 }) => {
    297   await page.evaluate(() => {
    298     window.cr007Fixture.beforeKey(
    299       () =>
    300         new Promise<void>((resolve) => {
    301           window.cr007Waiting = true;
    302           window.cr007Release = resolve;
    303         })
    304     );
    305     window.cr007Pending = window.cr007.authenticateInboxAccess(
    306       window.cr007Controller,
    307       window.cr007.origins[0],
    308       'reviewed_inbox_connection_auth'
    309     );
    310   });
    311   await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true);
    312   await page.evaluate(() => {
    313     window.cr007Fixture.churnHead();
    314     window.cr007Release?.();
    315   });
    316   expect(await page.evaluate(() => window.cr007Pending)).not.toBe('accepted');
    317   expect(
    318     [...connections.values()].filter(
    319       (origin) => origin !== 'wss://discovery.example.org'
    320     )
    321   ).toHaveLength(0);
    322   expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(0);
    323 });
    324 test('selected live receive scope reaches OPEN while a delivery scope cannot borrow reads', async ({
    325   page
    326 }) => {
    327   const result = await page.evaluate(() => {
    328     const receive = window.cr007Fixture.scope(
    329       [window.cr007.origins[2]],
    330       'receive'
    331     );
    332     window.cr007StopLive = window.cr007Fixture.live(receive, () => {
    333       window.cr007Open = true;
    334     });
    335     const delivery = window.cr007Fixture.scope(
    336       [window.cr007.origins[1]],
    337       'delivery'
    338     );
    339     let refused = false;
    340     try {
    341       window.cr007Fixture.page(delivery);
    342     } catch {
    343       refused = true;
    344     }
    345     return refused;
    346   });
    347   expect(result).toBe(true);
    348   await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
    349   expect(
    350     frames.filter(
    351       ({ origin, frame }) =>
    352         origin === 'wss://peer.example.org' && frame[0] === 'REQ'
    353     )
    354   ).toHaveLength(0);
    355 });
    356 test('closing AUTH controller leaves independent other-origin receive and anonymous discovery intact', async ({
    357   page
    358 }) => {
    359   await challenge(page);
    360   await page.evaluate(() => {
    361     const receive = window.cr007Fixture.scope(
    362       [window.cr007.origins[2]],
    363       'receive'
    364     );
    365     window.cr007StopLive = window.cr007Fixture.live(receive, () => {
    366       window.cr007Open = true;
    367     });
    368   });
    369   await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
    370   await expect
    371     .poll(
    372       () =>
    373         [...connections.values()].filter(
    374           (origin) => origin === 'wss://archive.example.org'
    375         ).length
    376     )
    377     .toBe(1);
    378   await page.evaluate(() =>
    379     window.cr007.closeInboxAccessController(window.cr007Controller)
    380   );
    381   await expect
    382     .poll(
    383       () =>
    384         [...connections.values()].filter(
    385           (origin) => origin === 'wss://inbox.example.org'
    386         ).length
    387     )
    388     .toBe(0);
    389   expect(
    390     [...connections.values()].filter(
    391       (origin) => origin === 'wss://archive.example.org'
    392     )
    393   ).toHaveLength(1);
    394   expect(await page.evaluate(() => window.cr007Open)).toBe(true);
    395 });
    396 
    397 test('scope-only current-head page invalidation leaves another origin live', async ({
    398   page
    399 }) => {
    400   await page.evaluate(() => {
    401     const receive = window.cr007Fixture.scope(
    402       [window.cr007.origins[2]],
    403       'receive'
    404     );
    405     window.cr007LiveEvents = 0;
    406     window.cr007StopLive = window.cr007Fixture.live(
    407       receive,
    408       () => {
    409         window.cr007Open = true;
    410       },
    411       () => {
    412         window.cr007LiveEvents = (window.cr007LiveEvents ?? 0) + 1;
    413       }
    414     );
    415   });
    416   await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
    417   await expect
    418     .poll(
    419       () =>
    420         [...connections.values()].filter(
    421           (origin) => origin === 'wss://archive.example.org'
    422         ).length
    423     )
    424     .toBe(1);
    425   await page.evaluate(() => {
    426     const pageScope = window.cr007Fixture.scope(
    427       [window.cr007.origins[0]],
    428       'receive',
    429       true
    430     );
    431     window.cr007StopPage = window.cr007Fixture.page(pageScope, (reason) => {
    432       window.cr007PageEnd = reason;
    433     });
    434   });
    435   await expect
    436     .poll(
    437       () =>
    438         frames.filter(
    439           ({ origin, frame }) =>
    440             origin === 'wss://inbox.example.org' && frame[0] === 'REQ'
    441         ).length
    442     )
    443     .toBe(1);
    444   await page.evaluate(() => window.cr007Fixture.churnHead());
    445   const request = frames.find(
    446     ({ origin, frame }) =>
    447       origin === 'wss://inbox.example.org' && frame[0] === 'REQ'
    448   );
    449   expect(request).toBeDefined();
    450   for (const [socket, origin] of connections) {
    451     if (origin === 'wss://inbox.example.org')
    452       socket.send(JSON.stringify(['EOSE', request!.frame[1]]));
    453     if (origin === 'wss://archive.example.org') {
    454       const live = frames.find(
    455         ({ origin: from, frame }) => from === origin && frame[0] === 'REQ'
    456       );
    457       socket.send(
    458         JSON.stringify([
    459           'EVENT',
    460           live!.frame[1],
    461           {
    462             id: '1'.repeat(64),
    463             pubkey: '2'.repeat(64),
    464             kind: 1059,
    465             created_at: 1,
    466             tags: [],
    467             content: '',
    468             sig: '3'.repeat(128)
    469           }
    470         ])
    471       );
    472     }
    473   }
    474   await expect
    475     .poll(() => page.evaluate(() => window.cr007PageEnd))
    476     .toBe('stale');
    477   await expect.poll(() => page.evaluate(() => window.cr007LiveEvents)).toBe(1);
    478   expect(
    479     [...connections.values()].filter(
    480       (origin) => origin === 'wss://archive.example.org'
    481     )
    482   ).toHaveLength(1);
    483 });
    484 test('pending receive fresh-key wait is fenced by genuine discovery-head churn', async ({
    485   page
    486 }) => {
    487   await page.evaluate(() => {
    488     window.cr007Fixture.beforeKey(
    489       () =>
    490         new Promise<void>((resolve) => {
    491           window.cr007Waiting = true;
    492           window.cr007Release = resolve;
    493         })
    494     );
    495     const receive = window.cr007Fixture.scope(
    496       [window.cr007.origins[0]],
    497       'receive',
    498       true
    499     );
    500     window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => {
    501       window.cr007PageEnd = reason;
    502     });
    503   });
    504   await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true);
    505   await page.evaluate(() => {
    506     window.cr007Fixture.churnHead();
    507     window.cr007Release?.();
    508   });
    509   await expect
    510     .poll(() => page.evaluate(() => window.cr007PageEnd))
    511     .toBe('stale');
    512   expect(
    513     frames.filter(
    514       ({ origin, frame }) =>
    515         origin === 'wss://inbox.example.org' && frame[0] === 'REQ'
    516     )
    517   ).toHaveLength(0);
    518   expect(
    519     [...connections.values()].filter(
    520       (origin) => origin !== 'wss://discovery.example.org'
    521     )
    522   ).toHaveLength(0);
    523 });
    524 test('AUTH retirement blocks a pending same-origin receive until actual physical close', async ({
    525   page
    526 }) => {
    527   await challenge(page);
    528   await page.evaluate(() => {
    529     window.cr007DelayClose = true;
    530     window.cr007Fixture.beforeKey(
    531       () =>
    532         new Promise<void>((resolve) => {
    533           window.cr007Waiting = true;
    534           window.cr007Release = resolve;
    535         })
    536     );
    537     const receive = window.cr007Fixture.scope(
    538       [window.cr007.origins[0]],
    539       'receive'
    540     );
    541     window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => {
    542       window.cr007PageEnd = reason;
    543     });
    544   });
    545   await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true);
    546   await page.evaluate(() => {
    547     window.cr007.closeInboxAccessController(window.cr007Controller);
    548     window.cr007Release?.();
    549   });
    550   await expect
    551     .poll(() => page.evaluate(() => window.cr007PageEnd))
    552     .toBe('stale');
    553   expect(
    554     frames.filter(
    555       ({ origin, frame }) =>
    556         origin === 'wss://inbox.example.org' && frame[0] === 'REQ'
    557     )
    558   ).toHaveLength(0);
    559   expect(
    560     [...connections.values()].filter(
    561       (origin) => origin === 'wss://inbox.example.org'
    562     )
    563   ).toHaveLength(1);
    564   expect(
    565     await page.evaluate(() => {
    566       try {
    567         window.cr007Fixture.scope([window.cr007.origins[0]], 'receive');
    568         return false;
    569       } catch {
    570         return true;
    571       }
    572     })
    573   ).toBe(true);
    574   await page.evaluate(() => {
    575     window.cr007DelayClose = false;
    576     for (const release of window.cr007HeldClose ?? []) release();
    577   });
    578   await expect
    579     .poll(
    580       () =>
    581         [...connections.values()].filter(
    582           (origin) => origin === 'wss://inbox.example.org'
    583         ).length
    584     )
    585     .toBe(0);
    586 });
    587 test('ordinary three-socket session teardown blocks replacement until actual close', async ({
    588   page
    589 }) => {
    590   await page.evaluate(() => {
    591     const receive = window.cr007Fixture.scope(window.cr007.origins, 'receive');
    592     window.cr007StopLive = window.cr007Fixture.live(receive, () => {
    593       window.cr007Open = true;
    594     });
    595   });
    596   await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
    597   await expect
    598     .poll(
    599       () =>
    600         [...connections.values()].filter(
    601           (origin) => origin !== 'wss://discovery.example.org'
    602         ).length
    603     )
    604     .toBe(3);
    605   expect(
    606     [...connections.values()].filter(
    607       (origin) => origin !== 'wss://discovery.example.org'
    608     )
    609   ).toHaveLength(3);
    610   const originalSockets = [...connections.keys()].filter(
    611     (socket) => connections.get(socket) !== 'wss://discovery.example.org'
    612   );
    613   const result = await page.evaluate(async () => {
    614     window.cr007DelayClose = true;
    615     const closed = window.cr007Fixture.closeSession();
    616     try {
    617       await window.cr007Fixture.successorScope();
    618       return { closed, blocked: false };
    619     } catch {
    620       return { closed, blocked: true };
    621     }
    622   });
    623   expect(result).toEqual({ closed: false, blocked: true });
    624   expect(
    625     [...connections.keys()].filter(
    626       (socket) => connections.get(socket) !== 'wss://discovery.example.org'
    627     )
    628   ).toEqual(originalSockets);
    629   expect(constructedPrivateConnections).toBe(3);
    630   expect(peakPrivateConnections).toBe(3);
    631   expect(
    632     [...connections.values()].filter(
    633       (origin) => origin !== 'wss://discovery.example.org'
    634     )
    635   ).toHaveLength(3);
    636   await page.evaluate(() => {
    637     window.cr007DelayClose = false;
    638     for (const release of window.cr007HeldClose ?? []) release();
    639   });
    640   await expect
    641     .poll(
    642       () =>
    643         [...connections.values()].filter(
    644           (origin) => origin !== 'wss://discovery.example.org'
    645         ).length
    646     )
    647     .toBe(0);
    648   await page.evaluate(async () => {
    649     const receive = await window.cr007Fixture.successorScope();
    650     window.cr007StopLive = window.cr007Fixture.live(receive, () => {
    651       window.cr007Reconnected = true;
    652     });
    653   });
    654   await expect
    655     .poll(() => page.evaluate(() => window.cr007Reconnected))
    656     .toBe(true);
    657   await expect
    658     .poll(
    659       () =>
    660         [...connections.values()].filter(
    661           (origin) => origin !== 'wss://discovery.example.org'
    662         ).length
    663     )
    664     .toBe(3);
    665   expect(
    666     [...connections.values()].filter(
    667       (origin) => origin !== 'wss://discovery.example.org'
    668     )
    669   ).toHaveLength(3);
    670   await expect.poll(() => constructedPrivateConnections).toBe(6);
    671   expect(peakPrivateConnections).toBe(3);
    672 });
    673 test('synchronous native constructor failure retires the original metadata and permits actual retry', async ({
    674   page
    675 }) => {
    676   await page.evaluate(() => {
    677     window.cr007ThrowConstructor = window.cr007.origins[0];
    678     const receive = window.cr007Fixture.scope(
    679       [window.cr007.origins[0]],
    680       'receive'
    681     );
    682     window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => {
    683       window.cr007PageEnd = reason;
    684     });
    685   });
    686   await expect
    687     .poll(() => page.evaluate(() => window.cr007PageEnd))
    688     .toBe('error');
    689   expect(
    690     [...connections.values()].filter(
    691       (origin) => origin !== 'wss://discovery.example.org'
    692     )
    693   ).toHaveLength(0);
    694   await page.evaluate(() => {
    695     const receive = window.cr007Fixture.scope(
    696       [window.cr007.origins[0]],
    697       'receive'
    698     );
    699     window.cr007StopLive = window.cr007Fixture.live(receive, () => {
    700       window.cr007Open = true;
    701     });
    702   });
    703   await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
    704   await expect
    705     .poll(
    706       () =>
    707         [...connections.values()].filter(
    708           (origin) => origin !== 'wss://discovery.example.org'
    709         ).length
    710     )
    711     .toBe(1);
    712   expect(
    713     [...connections.values()].filter(
    714       (origin) => origin !== 'wss://discovery.example.org'
    715     )
    716   ).toHaveLength(1);
    717 });
    718 
    719 test('AUTH startup native constructor failure releases the exact origin before explicit retry', async ({
    720   page
    721 }) => {
    722   const first = await page.evaluate(async () => {
    723     window.cr007ThrowConstructor = window.cr007.origins[0];
    724     return window.cr007.authenticateInboxAccess(
    725       window.cr007Controller,
    726       window.cr007.origins[0],
    727       'reviewed_inbox_connection_auth'
    728     );
    729   });
    730   expect(first).toBe('unavailable');
    731   expect(
    732     [...connections.values()].filter(
    733       (origin) => origin !== 'wss://discovery.example.org'
    734     )
    735   ).toHaveLength(0);
    736   await challenge(page);
    737   expect(
    738     await page.evaluate(() =>
    739       window.cr007.respondInboxAccessAuthentication(
    740         window.cr007Controller,
    741         window.cr007.origins[0],
    742         'reviewed_inbox_auth_response'
    743       )
    744     )
    745   ).toBe('accepted');
    746   expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(1);
    747 });
    748 
    749 test('failed AUTH startup cleanup stays with its original scope and retries after removal recovers', async ({
    750   page
    751 }) => {
    752   const first = await page.evaluate(async () => {
    753     window.cr007ThrowConstructor = window.cr007.origins[0];
    754     window.cr007Fault = window.cr007.installCloseFailure();
    755     return window.cr007.authenticateInboxAccess(
    756       window.cr007Controller,
    757       window.cr007.origins[0],
    758       'reviewed_inbox_connection_auth'
    759     );
    760   });
    761   expect(first).toBe('unavailable');
    762   expect(
    763     await page.evaluate(() =>
    764       window.cr007.closeInboxAccessController(window.cr007Controller)
    765     )
    766   ).toBe(false);
    767   await page.evaluate(() => window.cr007Fault?.allow());
    768   expect(
    769     await page.evaluate(() =>
    770       window.cr007.closeInboxAccessController(window.cr007Controller)
    771     )
    772   ).toBe(true);
    773   await page.evaluate(async () => {
    774     window.cr007Fault?.restore();
    775     window.cr007Controller = await window.cr007Fixture.capture();
    776   });
    777   await challenge(page);
    778   expect(
    779     await page.evaluate(() =>
    780       window.cr007.respondInboxAccessAuthentication(
    781         window.cr007Controller,
    782         window.cr007.origins[0],
    783         'reviewed_inbox_auth_response'
    784       )
    785     )
    786   ).toBe('accepted');
    787   expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(1);
    788 });