app

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

inbox-probe-readback.spec.ts (43677B)


      1 import { test, expect } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { once } from 'node:events';
      4 import { fileURLToPath } from 'node:url';
      5 import { WebSocketServer, type WebSocket } from 'ws';
      6 import { createStaticHarness } from '../integration/harness/static.ts';
      7 import type * as Fixture from './harness/inbox-probe-readback.ts';
      8 declare global {
      9   interface Window {
     10     rb: typeof Fixture;
     11     rbFixture: Awaited<ReturnType<typeof Fixture.makeReadbackFixture>>;
     12     rbPending?: Promise<unknown>;
     13     rbAbort?: AbortController;
     14     rbOtherPool?: Fixture.PrivatePool;
     15     rbRestore?: () => void;
     16     rbAdvancePage?: () => void;
     17     rbAdvanceOnSocket?: 'network' | 'page';
     18     rbClock?: number;
     19     rbNetworkClock?: ReturnType<Window['rbFixture']['installNetworkClock']>;
     20     rbDelayClose?: boolean;
     21     rbFailClose?: boolean;
     22     rbInvalidateOnSocket?: boolean;
     23     rbNestedCleanup?: number;
     24     rbNestedFailure?: number;
     25     rbHeldClose?: (() => void)[];
     26   }
     27 }
     28 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     29   sockets: WebSocketServer,
     30   endpoint: string,
     31   bundle: string;
     32 let readMode = 'exact';
     33 const archived = new Map<string, Record<string, unknown>>();
     34 let head = '',
     35   response: 'accepted' | 'refused' | 'unknown' | 'wrong' | 'auth_required' =
     36     'accepted',
     37   auth = false;
     38 const frames: { origin: string; frame: unknown[] }[] = [],
     39   physical = new Set<WebSocket>();
     40 let peak = 0,
     41   privatePeak = 0;
     42 const privatePhysical = new Set<WebSocket>();
     43 const privateConnections = new Map<string, number>();
     44 test.beforeAll(async () => {
     45   server = await createStaticHarness();
     46   sockets = new WebSocketServer({
     47     host: '127.0.0.1',
     48     port: 0,
     49     maxPayload: 65536
     50   });
     51   await once(sockets, 'listening');
     52   const address = sockets.address();
     53   if (!address || typeof address === 'string')
     54     throw Error('actual loorback fixture');
     55   endpoint = 'ws://127.0.0.1:' + address.port;
     56   sockets.on('connection', (socket, request) => {
     57     physical.add(socket);
     58     peak = Math.max(peak, physical.size);
     59     socket.on('close', () => physical.delete(socket));
     60     const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
     61       'origin'
     62     )!;
     63     if (origin !== 'wss://discovery.example.org') {
     64       privatePhysical.add(socket);
     65       privateConnections.set(origin, (privateConnections.get(origin) ?? 0) + 1);
     66       privatePeak = Math.max(privatePeak, privatePhysical.size);
     67       socket.on('close', () => privatePhysical.delete(socket));
     68     }
     69     if (auth && origin === 'wss://inbox.example.org')
     70       socket.send(JSON.stringify(['AUTH', 'probe-challenge']));
     71     socket.on('message', (bytes) => {
     72       const raw = Buffer.isBuffer(bytes)
     73         ? bytes
     74         : Array.isArray(bytes)
     75           ? Buffer.concat(bytes)
     76           : Buffer.from(bytes);
     77       const frame = JSON.parse(raw.toString()) as unknown[];
     78       frames.push({ origin, frame });
     79       if (frame[0] === 'REQ') {
     80         const filter = frame[2] as { kinds?: number[]; ids?: string[] };
     81         if (filter.kinds?.includes(10050) && head)
     82           socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
     83         if (filter.kinds?.includes(1059)) {
     84           if (readMode === 'refused' || readMode === 'auth_required') {
     85             socket.send(
     86               JSON.stringify([
     87                 'CLOSED',
     88                 frame[1],
     89                 readMode === 'auth_required'
     90                   ? 'auth-required: source fixture'
     91                   : 'blocked source fixture'
     92               ])
     93             );
     94             return;
     95           }
     96           if (readMode === 'unknown') return;
     97           const original = archived.get(filter.ids?.[0] ?? '');
     98           if (original && readMode !== 'empty') {
     99             const event: Record<string, unknown> =
    100               readMode === 'metadata'
    101                 ? {
    102                     sig: original.sig,
    103                     content: original.content,
    104                     tags: original.tags,
    105                     created_at: original.created_at,
    106                     kind: original.kind,
    107                     pubkey: original.pubkey,
    108                     id: original.id,
    109                     observation: { fixture: true }
    110                   }
    111                 : { ...original };
    112             if (readMode === 'wrong_id') event.id = 'f'.repeat(64);
    113             if (readMode === 'wrong_sig') {
    114               event.sig = '0'.repeat(128);
    115               event.verified = true;
    116             }
    117             if (readMode === 'wrong_recipient')
    118               event.tags = [['p', 'f'.repeat(64)]];
    119             if (readMode === 'wrong_content')
    120               event.content = String(event.content) + 'a';
    121             if (readMode === 'oversized' || readMode === 'flood_bytes')
    122               event.content = 'x'.repeat(
    123                 readMode === 'oversized' ? 40000 : 31000
    124               );
    125             if (readMode === 'flood_deliveries')
    126               event.content = String(event.content) + 'a';
    127             let wire = JSON.stringify(['EVENT', frame[1], event]);
    128             if (readMode === 'sdk_duplicate')
    129               wire = wire.replace('"kind":1059', '"kind":1059,"kind":1059');
    130             if (readMode === 'sdk_numeric_alias')
    131               wire = wire.replace('"kind":1059', '"kind":1.059e3');
    132             for (let n = 0; n < (readMode.startsWith('flood_') ? 501 : 1); n++)
    133               socket.send(wire);
    134           }
    135         }
    136         socket.send(JSON.stringify(['EOSE', frame[1]]));
    137       } else if (frame[0] === 'AUTH') {
    138         socket.send(
    139           JSON.stringify(['OK', (frame[1] as { id: string }).id, true, ''])
    140         );
    141       } else if (frame[0] === 'EVENT' && response !== 'unknown') {
    142         archived.set(
    143           (frame[1] as { id: string }).id,
    144           frame[1] as Record<string, unknown>
    145         );
    146         socket.send(
    147           JSON.stringify([
    148             'OK',
    149             response === 'wrong'
    150               ? 'f'.repeat(64)
    151               : (frame[1] as { id: string }).id,
    152             response !== 'refused' && response !== 'auth_required',
    153             response === 'auth_required'
    154               ? 'auth-required: source fixture'
    155               : response === 'refused'
    156                 ? 'blocked: source fixture'
    157                 : ''
    158           ])
    159         );
    160       }
    161     });
    162   });
    163   const result = await build({
    164     configFile: false,
    165     logLevel: 'silent',
    166     build: {
    167       write: false,
    168       minify: false,
    169       lib: {
    170         entry: fileURLToPath(
    171           new URL('./harness/inbox-probe-readback.ts', import.meta.url)
    172         ),
    173         name: 'rb',
    174         formats: ['iife']
    175       }
    176     }
    177   });
    178   const output = Array.isArray(result) ? result[0] : result;
    179   if (!('output' in output)) throw Error('compiled fixture');
    180   const chunks = output.output.filter((x) => x.type === 'chunk');
    181   expect(chunks).toHaveLength(1);
    182   bundle = chunks[0].code;
    183 });
    184 test.afterAll(async () => {
    185   for (const socket of sockets.clients) socket.terminate();
    186   await new Promise<void>((resolve) => sockets.close(() => resolve()));
    187   await server.close();
    188 });
    189 test.beforeEach(async ({ page }, testInfo) => {
    190   await expect.poll(() => physical.size).toBe(0);
    191   head = '';
    192   readMode = 'exact';
    193   archived.clear();
    194   response = 'accepted';
    195   auth = false;
    196   peak = 0;
    197   privatePeak = 0;
    198   privateConnections.clear();
    199   frames.length = 0;
    200   await page.addInitScript(
    201     ({ endpoint }) => {
    202       const Native = window.WebSocket;
    203       window.WebSocket = class extends Native {
    204         constructor(url: string | URL, protocols?: string | string[]) {
    205           const origin = new URL(String(url)).origin;
    206           if (
    207             ![
    208               'wss://discovery.example.org',
    209               'wss://inbox.example.org',
    210               'wss://peer.example.org',
    211               'wss://archive.example.org'
    212             ].includes(origin)
    213           )
    214             throw Error('unapproved fixture origin');
    215           super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
    216           if (
    217             origin === 'wss://inbox.example.org' &&
    218             window.rbAdvanceOnSocket
    219           ) {
    220             if (window.rbAdvanceOnSocket === 'network')
    221               window.rbNetworkClock!.advance(45001);
    222             else window.rbAdvancePage!();
    223           }
    224           if (
    225             window.rbInvalidateOnSocket &&
    226             origin === 'wss://inbox.example.org'
    227           )
    228             window.rb.closeInboxAccessController(
    229               window.rbFixture.controller()!
    230             );
    231         }
    232         override close(code?: number, reason?: string) {
    233           if (window.rbFailClose)
    234             throw Error('actual controlled disposal failure');
    235           if (window.rbDelayClose)
    236             (window.rbHeldClose ??= []).push(() => super.close(code, reason));
    237           else super.close(code, reason);
    238         }
    239       };
    240     },
    241     { endpoint }
    242   );
    243   await page.goto(server.url + '/search');
    244   await page.addScriptTag({ content: bundle });
    245   head = await page.evaluate(async (multi) => {
    246     window.rbFixture = await window.rb.makeReadbackFixture();
    247     return window.rbFixture.preferenceWire(
    248       multi
    249         ? [
    250             'wss://inbox.example.org',
    251             'wss://peer.example.org',
    252             'wss://archive.example.org'
    253           ]
    254         : ['wss://inbox.example.org']
    255     );
    256   }, testInfo.title.includes('three-origin'));
    257   await page.evaluate(async () => {
    258     const f = window.rbFixture;
    259     await f.capture();
    260     if (
    261       (await f.reserve()).status !== 'reserved' ||
    262       (await f.prepare()) !== 'wrapped' ||
    263       (await f.commitOriginal()).status !== 'prepared'
    264     )
    265       throw Error('genuine cold native original setup');
    266   });
    267 });
    268 test.afterEach(async ({ page }) => {
    269   if (!page.isClosed())
    270     await page.evaluate(() => {
    271       window.rbRestore?.();
    272       window.rbFailClose = false;
    273       window.rbDelayClose = false;
    274       for (const release of window.rbHeldClose ?? []) release();
    275       window.rbFixture.close();
    276     });
    277 });
    278 function privateEvents() {
    279   return frames.filter(
    280     (x) => x.origin !== 'wss://discovery.example.org' && x.frame[0] === 'EVENT'
    281   );
    282 }
    283 function privateReads() {
    284   return frames.filter(
    285     (x) => x.origin !== 'wss://discovery.example.org' && x.frame[0] === 'REQ'
    286   );
    287 }
    288 
    289 async function publishOriginal(page: import('@playwright/test').Page) {
    290   return page.evaluate(async () => {
    291     const f = window.rbFixture,
    292       result = await f.publish();
    293     await f.append(result);
    294     return result;
    295   });
    296 }
    297 test('cold actual archived artifact is fetched by exact recipient REQ; original PUB and readback share action and immutable native lineage', async ({
    298   page
    299 }) => {
    300   expect(privateReads()).toHaveLength(0);
    301   const published = await publishOriginal(page);
    302   readMode = 'metadata';
    303   const observed = await page.evaluate(async () => {
    304     const f = window.rbFixture,
    305       before = f.snapshot()!.record,
    306       action = f.action(),
    307       token = f.readPermission()!,
    308       result = await f.read(token);
    309     const forged = await f.appendRead({ ...result }),
    310       saved = await f.appendRead(result),
    311       duplicate = await f.appendRead(result),
    312       recommit = await f.commitOriginal();
    313     const second = await f.read();
    314     await f.appendRead(second);
    315     const fourth = await f.publish();
    316     return {
    317       before,
    318       result,
    319       forged,
    320       saved,
    321       duplicate,
    322       recommit: recommit.status,
    323       second,
    324       fourth,
    325       same: f.action() === action,
    326       row: f.snapshot()!.record,
    327       readEvidence: !!window.rb.inboxProbeReadbackAttemptEvidence(result),
    328       archiveEvidence: !!window.rb.inboxProbeArchiveAttemptEvidence(
    329         result as unknown as Parameters<
    330           typeof window.rb.inboxProbeArchiveAttemptEvidence
    331         >[0]
    332       ),
    333       readiness: window.rb.inboxAccessControllerSnapshot(f.controller()!)
    334         ?.readiness
    335     };
    336   });
    337   expect(observed.result).toMatchObject({
    338     status: 'readback',
    339     attempt: 2,
    340     actionId: published.actionId,
    341     deliveries: 1
    342   });
    343   expect(observed.second).toMatchObject({
    344     status: 'readback',
    345     attempt: 3,
    346     actionId: published.actionId
    347   });
    348   expect(observed.fourth).toEqual({ status: 'stopped' });
    349   expect(observed.same).toBe(true);
    350   expect(observed.forged.status).toBe('invalid');
    351   expect(observed.saved.status).toBe('saved');
    352   expect(observed.duplicate.status).toBe('existing');
    353   expect(observed.recommit).toBe('existing');
    354   expect(observed.readEvidence).toBe(true);
    355   expect(observed.archiveEvidence).toBe(false);
    356   expect(observed.readiness).toBe('unavailable');
    357   expect(observed.row.self).toEqual(observed.before.self);
    358   expect(observed.row.receipts).toHaveLength(3);
    359   const receipt = observed.row.receipts[1];
    360   expect(receipt.status).toBe('readback');
    361   expect(receipt.readbackWire).not.toBe(observed.before.self!.wire);
    362   expect(JSON.parse(receipt.readbackWire!)).toMatchObject({
    363     ...(JSON.parse(observed.before.self!.wire) as Record<string, unknown>),
    364     observation: { fixture: true }
    365   });
    366   for (const read of privateReads())
    367     expect(read.frame[2]).toEqual({
    368       kinds: [1059],
    369       ids: [observed.row.self!.eventId],
    370       '#p': [observed.row.owner],
    371       limit: 1
    372     });
    373   expect(privateEvents()).toHaveLength(1);
    374   expect(privateReads()).toHaveLength(2);
    375   expect(privateConnections.get('wss://inbox.example.org')).toBe(1);
    376   expect(privatePeak).toBe(1);
    377   expect(peak).toBeGreaterThan(0);
    378 });
    379 for (const mode of [
    380   'empty',
    381   'refused',
    382   'wrong_id',
    383   'wrong_sig',
    384   'wrong_recipient',
    385   'wrong_content',
    386   'oversized',
    387   'flood_deliveries',
    388   'flood_bytes',
    389   'sdk_duplicate',
    390   'sdk_numeric_alias'
    391 ])
    392   test(`actual SDK ${mode} preserves truthful bounded observed readback disposition`, async ({
    393     page
    394   }) => {
    395     await publishOriginal(page);
    396     readMode = mode;
    397     const observed = await page.evaluate(async () => {
    398       const f = window.rbFixture,
    399         result = await f.read(),
    400         appended = await f.appendRead(result);
    401       return {
    402         result,
    403         appended,
    404         row: f.snapshot()!.record,
    405         proof: !!window.rb.inboxProbeReadbackAttemptEvidence(result)
    406       };
    407     });
    408     const positive = mode.startsWith('sdk_');
    409     expect(observed.result.status).toBe(
    410       positive
    411         ? 'readback'
    412         : mode.startsWith('flood_')
    413           ? 'budget'
    414           : mode === 'refused'
    415             ? 'refused'
    416             : 'empty'
    417     );
    418     expect(observed.proof).toBe(positive);
    419     expect(observed.appended.status).toBe(positive ? 'saved' : 'invalid');
    420     expect(observed.row.receipts).toHaveLength(positive ? 2 : 1);
    421     if (mode === 'flood_deliveries')
    422       expect(observed.result.deliveries).toBe(501);
    423     if (mode === 'flood_bytes') {
    424       expect(observed.result.deliveries).toBeGreaterThan(200);
    425       expect(observed.result.deliveries).toBeLessThan(500);
    426     }
    427     if (positive) {
    428       const wire = observed.row.receipts[1].readbackWire!;
    429       expect(wire).not.toContain('1.059e3');
    430       expect(wire.match(/"kind"/g)).toHaveLength(1);
    431     }
    432   });
    433 test('separate genuine publication/read permissions reject cross-family calls before REQ or extra fresh-key work', async ({
    434   page
    435 }) => {
    436   const result = await page.evaluate(async () => {
    437     const f = window.rbFixture,
    438       api = window.rb,
    439       before = f.counts(),
    440       publication = f.permission()!,
    441       read = f.readPermission()!;
    442     const wrongRead = await api.readInboxProbeAttempt(
    443       f.readPool(),
    444       publication as unknown as Parameters<typeof api.readInboxProbeAttempt>[1],
    445       new AbortController().signal
    446     );
    447     const wrongWrite = await api.publishInboxProbeArchiveAttempt(
    448       f.pool(),
    449       read as unknown as Parameters<
    450         typeof api.publishInboxProbeArchiveAttempt
    451       >[1],
    452       new AbortController().signal
    453     );
    454     const copied = await f.read({ ...read }),
    455       policy = api.captureInboxProbeReadback(
    456         f.repository,
    457         f.session,
    458         f.copiedPolicy(),
    459         f.acknowledgement()!,
    460         f.action()!,
    461         'wss://inbox.example.org',
    462         'reviewed_inbox_probe_readback'
    463       );
    464     return {
    465       wrongRead,
    466       wrongWrite,
    467       copied,
    468       policy: !!policy,
    469       before,
    470       after: f.counts()
    471     };
    472   });
    473   expect(result.wrongRead).toEqual({ status: 'stopped' });
    474   expect(result.wrongWrite).toEqual({ status: 'stopped' });
    475   expect(result.copied).toEqual({ status: 'stopped' });
    476   expect(result.policy).toBe(false);
    477   expect(result.after).toEqual(result.before);
    478   expect(privateReads()).toHaveLength(0);
    479   expect(privateEvents()).toHaveLength(0);
    480 });
    481 for (const mode of ['alias', 'forged_fact', 'removed', 'corrupt_tail'])
    482   test(`actual native ${mode} blocks read before original REQ`, async ({
    483     page
    484   }) => {
    485     await publishOriginal(page);
    486     const result = await page.evaluate(async (mode) => {
    487       const f = window.rbFixture,
    488         token = f.readPermission()!,
    489         rows = await f.stored(),
    490         own = rows[0];
    491       if (mode === 'removed') await f.removeOriginal();
    492       else if (mode === 'corrupt_tail')
    493         await f.inject([
    494           { owner: f.owner, id: crypto.randomUUID(), wire: '{bad' }
    495         ]);
    496       else if (mode === 'alias')
    497         await f.inject([{ ...own, wire: own.wire + '\n' }]);
    498       else {
    499         const row = JSON.parse(
    500           own.wire
    501         ) as import('../../src/lib/persistence/private-records.ts').PrivateAccessProbe;
    502         await f.inject([
    503           {
    504             ...own,
    505             wire: JSON.stringify({
    506               ...row,
    507               revision: row.revision + 1,
    508               receipts: [
    509                 ...row.receipts,
    510                 { ...row.receipts[0], actionId: crypto.randomUUID() }
    511               ]
    512             })
    513           }
    514         ]);
    515       }
    516       const before = await f.stored(),
    517         read = await f.read(token);
    518       return {
    519         read,
    520         unchanged: JSON.stringify(await f.stored()) === JSON.stringify(before)
    521       };
    522     }, mode);
    523     expect(result.read).toEqual({ status: 'stopped' });
    524     expect(result.unchanged).toBe(true);
    525     expect(privateReads()).toHaveLength(0);
    526   });
    527 test('provider waiting stays outside original network meter and does not regenerate crypto or artifact', async ({
    528   page
    529 }) => {
    530   const pub = await publishOriginal(page);
    531   readMode = 'exact';
    532   const before = await page.evaluate(() => {
    533     const f = window.rbFixture;
    534     window.rbNetworkClock = f.installNetworkClock();
    535     window.rbRestore = () => window.rbNetworkClock!.restore();
    536     f.mode('hold_key');
    537     const before = f.counts();
    538     window.rbPending = f.read();
    539     return before;
    540   });
    541   await expect
    542     .poll(() => page.evaluate(() => window.rbFixture.waiting()))
    543     .toBe('key');
    544   expect(privateReads()).toHaveLength(0);
    545   await page.evaluate(() => {
    546     window.rbNetworkClock!.advance(90000);
    547     window.rbFixture.mode('normal');
    548     window.rbFixture.settle();
    549   });
    550   expect(await page.evaluate(async () => window.rbPending)).toMatchObject({
    551     status: 'readback',
    552     attempt: 2,
    553     actionId: pub.actionId
    554   });
    555   const after = await page.evaluate(() => window.rbFixture.counts());
    556   expect(after.encrypts).toBe(before.encrypts);
    557   expect(after.decrypts).toBe(before.decrypts);
    558   expect(after.signs).toBe(before.signs);
    559 });
    560 test('actual learned read AUTH requirement refuses before subsequent key prompt, then explicit original AUTH permits the same action', async ({
    561   page
    562 }) => {
    563   auth = true;
    564   await publishOriginal(page);
    565   readMode = 'auth_required';
    566   const first = await page.evaluate(() => window.rbFixture.read());
    567   expect(first).toMatchObject({ status: 'refused', attempt: 2 });
    568   const denied = await page.evaluate(async () => {
    569     const f = window.rbFixture,
    570       before = f.counts();
    571     f.mode('hold_key');
    572     const result = await f.read();
    573     return { result, before, after: f.counts(), waiting: f.waiting() };
    574   });
    575   expect(denied.result).toEqual({ status: 'stopped' });
    576   expect(denied.after).toEqual(denied.before);
    577   expect(denied.waiting).toBe('');
    578   expect(privateReads()).toHaveLength(1);
    579   readMode = 'exact';
    580   await page.evaluate(() => {
    581     const f = window.rbFixture;
    582     f.mode('normal');
    583     return window.rb.authenticateInboxAccess(
    584       f.controller()!,
    585       'wss://inbox.example.org',
    586       'reviewed_inbox_connection_auth'
    587     );
    588   });
    589   await expect
    590     .poll(() =>
    591       page.evaluate(
    592         () =>
    593           window.rb.inboxAccessControllerSnapshot(
    594             window.rbFixture.controller()!
    595           )?.auth[0]?.state
    596       )
    597     )
    598     .toBe('challenge');
    599   expect(
    600     await page.evaluate(() =>
    601       window.rb.respondInboxAccessAuthentication(
    602         window.rbFixture.controller()!,
    603         'wss://inbox.example.org',
    604         'reviewed_inbox_auth_response'
    605       )
    606     )
    607   ).toBe('accepted');
    608   expect(await page.evaluate(() => window.rbFixture.read())).toMatchObject({
    609     status: 'readback',
    610     attempt: 3,
    611     actionId: first.actionId
    612   });
    613   expect(frames.filter((x) => x.frame[0] === 'AUTH')).toHaveLength(1);
    614   expect(privateReads()).toHaveLength(2);
    615 });
    616 test('actual shared forty-five-second network allowance spans archive and recipient readback without reset', async ({
    617   page
    618 }) => {
    619   await publishOriginal(page);
    620   readMode = 'unknown';
    621   await page.evaluate(() => {
    622     const f = window.rbFixture;
    623     window.rbNetworkClock = f.installNetworkClock();
    624     window.rbRestore = () => window.rbNetworkClock!.restore();
    625     window.rbPending = f.read();
    626   });
    627   await expect.poll(() => privateReads().length).toBe(1);
    628   await page.evaluate(() => window.rbNetworkClock!.advance(45001));
    629   expect(await page.evaluate(async () => window.rbPending)).toMatchObject({
    630     status: 'timed_out',
    631     attempt: 2
    632   });
    633   readMode = 'exact';
    634   expect(await page.evaluate(() => window.rbFixture.read())).toEqual({
    635     status: 'stopped'
    636   });
    637   expect(await page.evaluate(() => window.rbFixture.publish())).toEqual({
    638     status: 'stopped'
    639   });
    640   expect(privateReads()).toHaveLength(1);
    641   expect(privateEvents()).toHaveLength(1);
    642 });
    643 test('actual Stop sends original CLOSE and retains ciphertext with no readback fact or readiness', async ({
    644   page
    645 }) => {
    646   await publishOriginal(page);
    647   readMode = 'unknown';
    648   await page.evaluate(() => {
    649     window.rbAbort = new AbortController();
    650     window.rbPending = window.rbFixture.read(undefined, window.rbAbort.signal);
    651   });
    652   await expect.poll(() => privateReads().length).toBe(1);
    653   await page.evaluate(() => window.rbAbort!.abort());
    654   expect(await page.evaluate(async () => window.rbPending)).toMatchObject({
    655     status: 'stopped',
    656     attempt: 2
    657   });
    658   await expect
    659     .poll(
    660       () =>
    661         frames.filter(
    662           (x) =>
    663             x.origin === 'wss://inbox.example.org' && x.frame[0] === 'CLOSE'
    664         ).length
    665     )
    666     .toBeGreaterThan(0);
    667   expect(
    668     await page.evaluate(() => window.rbFixture.snapshot()!.record.receipts)
    669   ).toHaveLength(1);
    670 });
    671 test('actual readback evidence settles only against original lineage after owner loss and cannot restore traffic', async ({
    672   page
    673 }) => {
    674   await publishOriginal(page);
    675   const result = await page.evaluate(async () => {
    676     const f = window.rbFixture,
    677       result = await f.read();
    678     window.rb.closeInboxAccessController(f.controller()!);
    679     return {
    680       result,
    681       append: await f.appendRead(result),
    682       later: await f.read(),
    683       rows: await f.stored()
    684     };
    685   });
    686   expect(result.result.status).toBe('readback');
    687   expect(result.append.status).toBe('saved');
    688   expect(result.later).toEqual({ status: 'stopped' });
    689   expect(
    690     (
    691       JSON.parse(
    692         result.rows[0].wire
    693       ) as import('../../src/lib/persistence/private-records.ts').PrivateAccessProbe
    694     ).receipts
    695   ).toHaveLength(2);
    696   expect(privateReads()).toHaveLength(1);
    697 });
    698 for (const nested of [false, true])
    699   test(`actual original REQ teardown ${nested ? 'reentrant Stop' : 'failure'} retains retry custody and another original archive scope`, async ({
    700     page
    701   }) => {
    702     await publishOriginal(page);
    703     const result = await page.evaluate(async (nested) => {
    704       const f = window.rbFixture;
    705       window.rbNestedFailure = 0;
    706       const failure = f.installReadTeardownFailure(
    707         nested
    708           ? () => {
    709               try {
    710                 f.stopRead();
    711               } catch {
    712                 window.rbNestedFailure!++;
    713               }
    714             }
    715           : undefined
    716       );
    717       window.rbRestore = failure.restore;
    718       const read = await f.read(),
    719         required = window.rb.privatePoolCleanupRequired(f.readPool()),
    720         faults = failure.faults();
    721       failure.restore();
    722       f.stopRead();
    723       const retainedArchive = await f.publish();
    724       return {
    725         read,
    726         required,
    727         faults,
    728         nested: window.rbNestedFailure,
    729         retainedArchive
    730       };
    731     }, nested);
    732     expect(result.read).toMatchObject({ status: 'unknown', attempt: 2 });
    733     expect(result.required).toBe(true);
    734     expect(result.faults).toBeGreaterThan(0);
    735     if (nested) expect(result.nested).toBeGreaterThan(0);
    736     expect(result.retainedArchive).toMatchObject({
    737       status: 'accepted',
    738       attempt: 3
    739     });
    740     expect(privateConnections.get('wss://inbox.example.org')).toBe(1);
    741     expect(privateEvents()).toHaveLength(2);
    742     expect(privateReads()).toHaveLength(1);
    743   });
    744 
    745 for (const mode of ['aborted', 'uncertain'] as const)
    746   test(`actual native readback ${mode} CAS preserves original evidence and exact idempotent retry`, async ({
    747     page
    748   }) => {
    749     await publishOriginal(page);
    750     const result = await page.evaluate(async (mode) => {
    751       const f = window.rbFixture,
    752         read = await f.read(),
    753         before = await f.stored(),
    754         uncertain =
    755           mode === 'uncertain' ? f.installUncertainCommit() : undefined,
    756         restore =
    757           mode === 'aborted'
    758             ? f.installNativeAbort()
    759             : () => uncertain!.restore();
    760       let first: Awaited<ReturnType<typeof f.appendRead>>;
    761       try {
    762         first = await f.appendRead(read);
    763       } finally {
    764         restore();
    765       }
    766       const afterFirst = await f.stored(),
    767         second = await f.appendRead(read),
    768         third = await f.appendRead(read);
    769       return {
    770         first,
    771         before,
    772         afterFirst,
    773         second,
    774         third,
    775         row: f.snapshot()!.record,
    776         native: uncertain?.counts()
    777       };
    778     }, mode);
    779     expect(result.first.status).toBe(
    780       mode === 'aborted' ? 'aborted' : 'reconciled'
    781     );
    782     if (mode === 'aborted') expect(result.afterFirst).toEqual(result.before);
    783     expect(result.second.status).toBe(
    784       mode === 'aborted' ? 'saved' : 'existing'
    785     );
    786     expect(result.third.status).toBe('existing');
    787     expect(result.row.receipts).toHaveLength(2);
    788     if (mode === 'uncertain')
    789       expect(result.native).toMatchObject({
    790         nativeComplete: 1,
    791         nativeAbort: 0,
    792         putSuccess: 1,
    793         abortRefused: 1
    794       });
    795   });
    796 test('native full hundred-row namespace supports only existing original readback growth and serial duplicate evidence', async ({
    797   page
    798 }) => {
    799   await publishOriginal(page);
    800   const result = await page.evaluate(async () => {
    801     const f = window.rbFixture;
    802     await f.fillCapacity(99);
    803     const read = await f.read(),
    804       concurrent = await Promise.all([f.appendRead(read), f.appendRead(read)]),
    805       final = await f.appendRead(read);
    806     return {
    807       read,
    808       concurrent,
    809       final,
    810       rows: (await f.stored()).length,
    811       row: f.snapshot()!.record
    812     };
    813   });
    814   expect(result.read.status).toBe('readback');
    815   expect(result.rows).toBe(100);
    816   expect(result.concurrent.map((x) => x.status).sort()).toEqual([
    817     'busy',
    818     'saved'
    819   ]);
    820   expect(result.final.status).toBe('existing');
    821   expect(result.row.receipts).toHaveLength(2);
    822 });
    823 test('native eight-MiB joint namespace refuses observed readback growth without adopting metadata or losing original ciphertext', async ({
    824   page
    825 }) => {
    826   await publishOriginal(page);
    827   const result = await page.evaluate(async () => {
    828     const f = window.rbFixture,
    829       actual = await f.read(),
    830       original = await f.stored(),
    831       template = JSON.parse(
    832         original[0].wire
    833       ) as import('../../src/lib/persistence/private-records.ts').PrivateAccessProbe,
    834       id = crypto.randomUUID(),
    835       fact = {
    836         ...template.receipts[0],
    837         actionId: crypto.randomUUID(),
    838         observedAtMilliseconds: 1
    839       };
    840     const row = (count: number) => ({
    841       owner: f.owner,
    842       id,
    843       wire: JSON.stringify({
    844         ...template,
    845         id,
    846         receipts: Array.from({ length: count }, () => fact)
    847       })
    848     });
    849     const bytes = (rows: typeof original) =>
    850       rows.reduce(
    851         (sum, x) => sum + new TextEncoder().encode(JSON.stringify(x)).length,
    852         0
    853       );
    854     const empty = bytes([...original, row(0)]),
    855       step = bytes([row(1)]) - bytes([row(0)]),
    856       limit = 8 * 1024 * 1024;
    857     await f.inject([row(Math.floor((limit - empty + 1) / (step + 1)))]);
    858     const before = await f.stored(),
    859       appended = await f.appendRead(actual);
    860     return {
    861       appended,
    862       unchanged: JSON.stringify(await f.stored()) === JSON.stringify(before),
    863       headroom: limit - bytes(before),
    864       row: f.snapshot()!.record,
    865       evidence: !!window.rb.inboxProbeReadbackAttemptEvidence(actual)
    866     };
    867   });
    868   expect(result.headroom).toBeGreaterThanOrEqual(0);
    869   expect(result.appended.status).toBe('capacity');
    870   expect(result.unchanged).toBe(true);
    871   expect(result.evidence).toBe(true);
    872   expect(result.row.receipts).toHaveLength(1);
    873 });
    874 test('actual read page expires at existing fifteen-second bound before the shared action allowance', async ({
    875   page
    876 }) => {
    877   await publishOriginal(page);
    878   readMode = 'unknown';
    879   await page.evaluate(() => {
    880     const original = performance.now.bind(performance);
    881     let offset = 0;
    882     performance.now = () =>
    883       /at remainingPage(?:\d+)? \(/.test(new Error().stack ?? '')
    884         ? original() + offset
    885         : original();
    886     window.rbRestore = () => {
    887       performance.now = original;
    888     };
    889     window.rbAdvancePage = () => {
    890       offset = 15001;
    891     };
    892     window.rbPending = window.rbFixture.read();
    893   });
    894   await expect.poll(() => privateReads().length).toBe(1);
    895   await page.evaluate(() => window.rbAdvancePage!());
    896   expect(await page.evaluate(async () => window.rbPending)).toMatchObject({
    897     status: 'timed_out',
    898     attempt: 2
    899   });
    900   await page.evaluate(() => window.rbRestore!());
    901   readMode = 'exact';
    902   expect(await page.evaluate(() => window.rbFixture.read())).toMatchObject({
    903     status: 'readback',
    904     attempt: 3
    905   });
    906 });
    907 for (const stop of ['abort', 'scope'] as const)
    908   test(`actual original SDK OPEN-time ${stop} retains installing cleanup with no uncaught page error`, async ({
    909     page
    910   }) => {
    911     await publishOriginal(page);
    912     const errors: string[] = [];
    913     page.on('pageerror', (error) => errors.push(error.message));
    914     const result = await page.evaluate(async (stop) => {
    915       const f = window.rbFixture,
    916         abort = new AbortController();
    917       let pending = 0;
    918       const restore = f.installReadInstallation(() => {
    919         if (stop === 'abort') abort.abort();
    920         else
    921           try {
    922             f.stopRead();
    923           } catch {
    924             pending++;
    925           }
    926       });
    927       window.rbRestore = restore;
    928       const read = await f.read(undefined, abort.signal);
    929       restore();
    930       if (stop === 'scope') f.stopRead();
    931       return { read, pending, archive: await f.publish() };
    932     }, stop);
    933     expect(result.read).toMatchObject({ status: 'stopped', attempt: 2 });
    934     expect(result.archive).toMatchObject({ status: 'accepted', attempt: 3 });
    935     if (stop === 'scope') expect(result.pending).toBeGreaterThan(0);
    936     expect(errors).toEqual([]);
    937   });
    938 test('known original C7 AUTH signer wait consumes no read key prompt, network meter or recipient REQ', async ({
    939   page
    940 }) => {
    941   auth = true;
    942   await publishOriginal(page);
    943   await page.evaluate(() =>
    944     window.rb.authenticateInboxAccess(
    945       window.rbFixture.controller()!,
    946       'wss://inbox.example.org',
    947       'reviewed_inbox_connection_auth'
    948     )
    949   );
    950   await expect
    951     .poll(() =>
    952       page.evaluate(
    953         () =>
    954           window.rb.inboxAccessControllerSnapshot(
    955             window.rbFixture.controller()!
    956           )?.auth[0]?.state
    957       )
    958     )
    959     .toBe('challenge');
    960   await page.evaluate(() => {
    961     const f = window.rbFixture;
    962     window.rbNetworkClock = f.installNetworkClock();
    963     window.rbRestore = () => window.rbNetworkClock!.restore();
    964     f.mode('hold_sign');
    965     window.rbPending = window.rb.respondInboxAccessAuthentication(
    966       f.controller()!,
    967       'wss://inbox.example.org',
    968       'reviewed_inbox_auth_response'
    969     );
    970   });
    971   await expect
    972     .poll(() => page.evaluate(() => window.rbFixture.waiting()))
    973     .toBe('sign');
    974   const denied = await page.evaluate(async () => {
    975     const before = window.rbFixture.counts();
    976     return {
    977       read: await window.rbFixture.read(),
    978       before,
    979       after: window.rbFixture.counts()
    980     };
    981   });
    982   expect(denied.read).toEqual({ status: 'stopped' });
    983   expect(denied.after).toEqual(denied.before);
    984   expect(privateReads()).toHaveLength(0);
    985   await page.evaluate(() => {
    986     window.rbNetworkClock!.advance(90000);
    987     window.rbFixture.mode('normal');
    988     window.rbFixture.settle();
    989   });
    990   expect(await page.evaluate(async () => window.rbPending)).toBe('accepted');
    991   expect(await page.evaluate(() => window.rbFixture.read())).toMatchObject({
    992     status: 'readback',
    993     attempt: 2
    994   });
    995 });
    996 test('three-origin original PUB and REQ action has nine total admissions and at most three original physical connections', async ({
    997   page
    998 }) => {
    999   const origins = [
   1000     'wss://inbox.example.org',
   1001     'wss://peer.example.org',
   1002     'wss://archive.example.org'
   1003   ];
   1004   const result = await page.evaluate(async (origins) => {
   1005     const f = window.rbFixture,
   1006       action = f.action(),
   1007       results: Awaited<ReturnType<typeof f.read>>[] = [];
   1008     for (const origin of origins) {
   1009       const pub = await f.publish(f.permission(origin));
   1010       await f.append(pub);
   1011     }
   1012     for (let round = 0; round < 2; round++)
   1013       for (const origin of origins) {
   1014         const read = await f.read(f.readPermission(origin));
   1015         results.push(read);
   1016         await f.appendRead(read);
   1017         await f.commitOriginal();
   1018       }
   1019     return {
   1020       results,
   1021       extra: await f.read(f.readPermission(origins[2])),
   1022       same: f.action() === action,
   1023       row: f.snapshot()!.record
   1024     };
   1025   }, origins);
   1026   expect(result.same).toBe(true);
   1027   expect(result.extra).toEqual({ status: 'stopped' });
   1028   expect(result.results.every((x) => x.status === 'readback')).toBe(true);
   1029   expect(new Set(result.results.map((x) => x.actionId)).size).toBe(1);
   1030   expect(result.row.receipts).toHaveLength(9);
   1031   expect(privatePeak).toBe(3);
   1032   expect(privateReads()).toHaveLength(6);
   1033   expect(privateEvents()).toHaveLength(3);
   1034   for (const origin of origins) expect(privateConnections.get(origin)).toBe(1);
   1035 });
   1036 for (const clock of [NaN, Infinity, -1, 0])
   1037   test(`actual read meter invalid clock ${String(clock)} permanently refuses original action without recipient traffic`, async ({
   1038     page
   1039   }) => {
   1040     await publishOriginal(page);
   1041     const result = await page.evaluate(async (clock) => {
   1042       const f = window.rbFixture,
   1043         controlled = f.installNetworkClock();
   1044       window.rbRestore = controlled.restore;
   1045       controlled.set(clock);
   1046       const read = await f.read(),
   1047         retry = await f.read();
   1048       return { read, retry, action: !!f.action(), row: f.snapshot()!.record };
   1049     }, clock);
   1050     expect(result.read).toEqual({ status: 'stopped' });
   1051     expect(result.retry).toEqual({ status: 'stopped' });
   1052     expect(result.action).toBe(false);
   1053     expect(privateReads()).toHaveLength(0);
   1054     expect(result.row.receipts).toHaveLength(1);
   1055   });
   1056 
   1057 for (const clock of ['network', 'page'] as const)
   1058   test(`actual original socket startup exhausts ${clock} deadline before REQ or attempted read evidence`, async ({
   1059     page
   1060   }) => {
   1061     const result = await page.evaluate(async (clock) => {
   1062       const f = window.rbFixture;
   1063       if (clock === 'network') {
   1064         window.rbNetworkClock = f.installNetworkClock();
   1065         window.rbRestore = () => window.rbNetworkClock!.restore();
   1066       } else {
   1067         const original = performance.now.bind(performance);
   1068         let offset = 0;
   1069         performance.now = () =>
   1070           /at remainingPage(?:\d+)? \(/.test(new Error().stack ?? '')
   1071             ? original() + offset
   1072             : original();
   1073         window.rbRestore = () => {
   1074           performance.now = original;
   1075         };
   1076         window.rbAdvancePage = () => {
   1077           offset = 15001;
   1078         };
   1079       }
   1080       window.rbAdvanceOnSocket = clock;
   1081       const read = await f.read();
   1082       return {
   1083         read,
   1084         proof: !!window.rb.inboxProbeReadbackAttemptEvidence(read),
   1085         row: f.snapshot()!.record
   1086       };
   1087     }, clock);
   1088     expect(result.read).toMatchObject({ status: 'stopped' });
   1089     expect(result.read.attempt).toBeUndefined();
   1090     expect(result.proof).toBe(false);
   1091     expect(result.row.receipts).toHaveLength(0);
   1092     expect(privateReads()).toHaveLength(0);
   1093     expect(privateEvents()).toHaveLength(0);
   1094   });
   1095 test('actual original socket startup closing controller refuses before recipient REQ', async ({
   1096   page
   1097 }) => {
   1098   const result = await page.evaluate(async () => {
   1099     window.rbInvalidateOnSocket = true;
   1100     const f = window.rbFixture,
   1101       read = await f.read();
   1102     return { read, rows: await f.stored() };
   1103   });
   1104   expect(result.read).toMatchObject({ status: 'stopped' });
   1105   expect(result.read.attempt).toBeUndefined();
   1106   expect(privateReads()).toHaveLength(0);
   1107   expect(
   1108     JSON.parse(result.rows[0].wire) as Record<string, unknown>
   1109   ).toHaveProperty('family', 'private_access_probe');
   1110 });
   1111 test('actual same SDK request with foreign observation source cannot mint readback provenance', async ({
   1112   page
   1113 }) => {
   1114   await publishOriginal(page);
   1115   const result = await page.evaluate(async () => {
   1116     const f = window.rbFixture,
   1117       restore = f.installWrongReadSource();
   1118     window.rbRestore = restore;
   1119     const read = await f.read();
   1120     restore();
   1121     return {
   1122       read,
   1123       append: await f.appendRead(read),
   1124       row: f.snapshot()!.record
   1125     };
   1126   });
   1127   expect(result.read.status).toBe('error');
   1128   expect(result.read.deliveries).toBe(1);
   1129   expect(result.append.status).toBe('invalid');
   1130   expect(result.row.receipts).toHaveLength(1);
   1131 });
   1132 
   1133 for (const status of ['readback', 'nonce_verified'] as const)
   1134   test(`handwritten strictly valid ${status} labels cannot replace original read permission or admit lineage`, async ({
   1135     page
   1136   }) => {
   1137     await publishOriginal(page);
   1138     const result = await page.evaluate(async (status) => {
   1139       const f = window.rbFixture,
   1140         token = f.readPermission()!,
   1141         original = (await f.stored())[0],
   1142         row = JSON.parse(
   1143           original.wire
   1144         ) as import('../../src/lib/persistence/private-records.ts').PrivateAccessProbe,
   1145         fake = {
   1146           ...row,
   1147           revision: row.revision + 1,
   1148           receipts: [
   1149             ...row.receipts,
   1150             {
   1151               actionId: crypto.randomUUID(),
   1152               origin: 'wss://inbox.example.org',
   1153               role: 'access_readback',
   1154               eventId: row.self!.eventId,
   1155               attempt: 1,
   1156               status,
   1157               observedAtMilliseconds: Date.now(),
   1158               readbackWire: row.self!.wire
   1159             }
   1160           ]
   1161         },
   1162         wire = JSON.stringify(fake);
   1163       const valid = window.rb.decodePrivateRecord(wire, row.owner, row.id).ok;
   1164       await f.inject([{ ...original, wire }]);
   1165       const read = await f.read(token),
   1166         commit = await f.commitOriginal();
   1167       return {
   1168         valid,
   1169         read,
   1170         commit: commit.status,
   1171         unchanged: (await f.stored())[0].wire === wire,
   1172         live: !!f.snapshot()
   1173       };
   1174     }, status);
   1175     expect(result.valid).toBe(true);
   1176     expect(result.read).toEqual({ status: 'stopped' });
   1177     expect(result.commit).toBe('conflict');
   1178     expect(result.unchanged).toBe(true);
   1179     expect(result.live).toBe(false);
   1180     expect(privateReads()).toHaveLength(0);
   1181   });
   1182 for (const fault of ['held', 'failed'] as const)
   1183   test(`actual original read-only ${fault} physical close blocks replacement until actual original retry and close`, async ({
   1184     page
   1185   }) => {
   1186     const first = await page.evaluate(() => window.rbFixture.read());
   1187     expect(first.status).toBe('empty');
   1188     await expect.poll(() => privatePhysical.size).toBe(1);
   1189     const stopped = await page.evaluate((fault) => {
   1190       const f = window.rbFixture;
   1191       window.rbDelayClose = fault === 'held';
   1192       window.rbFailClose = fault === 'failed';
   1193       let failed = false;
   1194       try {
   1195         f.stopRead();
   1196       } catch {
   1197         failed = true;
   1198       }
   1199       let replacement = false;
   1200       try {
   1201         replacement = !!window.rb.getPrivatePool(
   1202           f.session,
   1203           f.policy,
   1204           ['wss://inbox.example.org'],
   1205           Object.freeze({}),
   1206           'access'
   1207         );
   1208       } catch {
   1209         /* Actual original cleanup pending. */
   1210       }
   1211       return {
   1212         failed,
   1213         replacement,
   1214         required: window.rb.privatePoolCleanupRequired(f.readPool())
   1215       };
   1216     }, fault);
   1217     expect(stopped.required).toBe(true);
   1218     expect(stopped.replacement).toBe(false);
   1219     if (fault === 'failed') expect(stopped.failed).toBe(true);
   1220     await page.evaluate(() => {
   1221       window.rbDelayClose = false;
   1222       window.rbFailClose = false;
   1223       for (const release of window.rbHeldClose ?? []) release();
   1224       window.rbFixture.stopRead();
   1225     });
   1226     await expect.poll(() => privatePhysical.size).toBe(0);
   1227     await expect
   1228       .poll(() =>
   1229         page.evaluate(() =>
   1230           window.rb.privatePoolCleanupRequired(window.rbFixture.readPool())
   1231         )
   1232       )
   1233       .toBe(false);
   1234     const next = await page.evaluate(async () => {
   1235       const f = window.rbFixture;
   1236       window.rbOtherPool = window.rb.getPrivatePool(
   1237         f.session,
   1238         f.policy,
   1239         ['wss://inbox.example.org'],
   1240         Object.freeze({}),
   1241         'access'
   1242       )!;
   1243       const result = await window.rb.readInboxProbeAttempt(
   1244         window.rbOtherPool,
   1245         f.readPermission()!,
   1246         new AbortController().signal
   1247       );
   1248       window.rb.closePrivatePool(window.rbOtherPool);
   1249       return result;
   1250     });
   1251     expect(next).toMatchObject({
   1252       status: 'empty',
   1253       attempt: 2,
   1254       actionId: first.actionId
   1255     });
   1256     expect(privateReads()).toHaveLength(2);
   1257     expect(privateConnections.get('wss://inbox.example.org')).toBe(2);
   1258   });
   1259 test('three-origin failed recipient cleanup preserves other original archive connection and scope', async ({
   1260   page
   1261 }) => {
   1262   const result = await page.evaluate(async () => {
   1263     const f = window.rbFixture;
   1264     const first = await f.publish();
   1265     await f.append(first);
   1266     const other = await f.publish(f.permission('wss://peer.example.org'));
   1267     await f.append(other);
   1268     const failure = f.installReadTeardownFailure();
   1269     window.rbRestore = failure.restore;
   1270     const read = await f.read();
   1271     failure.restore();
   1272     f.stopRead();
   1273     const next = await f.publish(f.permission('wss://peer.example.org'));
   1274     return { read, next, other, before: first.actionId };
   1275   });
   1276   expect(result.read).toMatchObject({ status: 'unknown', attempt: 2 });
   1277   expect(result.next).toMatchObject({
   1278     status: 'accepted',
   1279     attempt: 2,
   1280     actionId: result.other.actionId
   1281   });
   1282   expect(result.next.actionId).toBe(result.before);
   1283   expect(privateConnections.get('wss://peer.example.org')).toBe(1);
   1284   expect(privateEvents()).toHaveLength(3);
   1285 });