app

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

inbox-probe-retry.spec.ts (58347B)


      1 import { test, expect, type Page } 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-retry.ts';
      8 declare global {
      9   interface Window {
     10     pt: typeof Fixture;
     11     ptFixture: Awaited<ReturnType<typeof Fixture.makeRetryFixture>>;
     12     ptPending?: Promise<unknown>;
     13     ptRelease?: () => void;
     14     ptRestore?: () => void;
     15     ptClock?: ReturnType<Window['ptFixture']['installNetworkClock']>;
     16     ptAbort?: AbortController;
     17     ptDelayClose?: boolean;
     18     ptFailClose?: boolean;
     19     ptHeldClose?: (() => void)[];
     20     ptCloseCalls?: number;
     21   }
     22 }
     23 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     24   sockets: WebSocketServer,
     25   endpoint: string,
     26   bundle: string,
     27   head = '',
     28   holdEvent = false,
     29   holdRead = false,
     30   challenge = false,
     31   holdAuth = false;
     32 const origins = [
     33   'wss://inbox.example.org',
     34   'wss://peer.example.org',
     35   'wss://archive.example.org'
     36 ];
     37 const physical = new Set<WebSocket>(),
     38   archived = new Map<string, unknown>(),
     39   frames: { origin: string; frame: unknown[] }[] = [];
     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')
     50     throw Error('actual loopback endpoint');
     51   endpoint = 'ws://127.0.0.1:' + address.port;
     52   sockets.on('connection', (socket, request) => {
     53     physical.add(socket);
     54     socket.on('close', () => physical.delete(socket));
     55     const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
     56       'origin'
     57     )!;
     58     if (challenge && origin !== 'wss://discovery.example.org')
     59       socket.send(JSON.stringify(['AUTH', 'c2b-actual-source-challenge']));
     60     socket.on('message', (bytes) => {
     61       const raw = Buffer.isBuffer(bytes)
     62         ? bytes
     63         : Array.isArray(bytes)
     64           ? Buffer.concat(bytes)
     65           : Buffer.from(bytes);
     66       const frame = JSON.parse(raw.toString()) as unknown[];
     67       if (frames.length >= 1000) throw Error('controlled fixture frame bound');
     68       frames.push({ origin, frame });
     69       if (frame[0] === 'REQ') {
     70         const filter = frame[2] as { kinds?: number[]; ids?: string[] };
     71         if (filter.kinds?.includes(10050) && head)
     72           socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
     73         if (filter.kinds?.includes(1059)) {
     74           if (holdRead) return;
     75           const event = archived.get(JSON.stringify([origin, filter.ids?.[0]]));
     76           if (event) socket.send(JSON.stringify(['EVENT', frame[1], event]));
     77         }
     78         socket.send(JSON.stringify(['EOSE', frame[1]]));
     79       } else if (frame[0] === 'EVENT') {
     80         const event = frame[1] as { id: string };
     81         archived.set(JSON.stringify([origin, event.id]), event);
     82         if (!holdEvent) socket.send(JSON.stringify(['OK', event.id, true, '']));
     83       } else if (frame[0] === 'AUTH') {
     84         const event = frame[1] as { id: string };
     85         if (!holdAuth) socket.send(JSON.stringify(['OK', event.id, true, '']));
     86       }
     87     });
     88   });
     89   const result = await build({
     90     configFile: false,
     91     logLevel: 'silent',
     92     build: {
     93       write: false,
     94       minify: false,
     95       lib: {
     96         entry: fileURLToPath(
     97           new URL('./harness/inbox-probe-retry.ts', import.meta.url)
     98         ),
     99         name: 'pt',
    100         formats: ['iife']
    101       }
    102     }
    103   });
    104   const output = Array.isArray(result) ? result[0] : result;
    105   if (!('output' in output)) throw Error('actual compiled retry harness');
    106   const chunks = output.output.filter((x) => x.type === 'chunk');
    107   expect(chunks).toHaveLength(1);
    108   bundle = chunks[0].code;
    109 });
    110 test.afterAll(async () => {
    111   for (const socket of sockets.clients) socket.terminate();
    112   await new Promise<void>((resolve) => sockets.close(() => resolve()));
    113   await server.close();
    114 });
    115 test.beforeEach(async ({ page }) => {
    116   await expect.poll(() => physical.size).toBe(0);
    117   head = '';
    118   frames.length = 0;
    119   archived.clear();
    120   holdEvent = false;
    121   holdRead = false;
    122   challenge = false;
    123   holdAuth = false;
    124   await page.addInitScript(
    125     ({ endpoint, origins }) => {
    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 (!['wss://discovery.example.org', ...origins].includes(origin))
    131             throw Error('unapproved fixture origin');
    132           super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
    133         }
    134         override close(code?: number, reason?: string) {
    135           window.ptCloseCalls = (window.ptCloseCalls ?? 0) + 1;
    136           if (window.ptFailClose)
    137             throw Error('actual controlled physical close failure');
    138           if (window.ptDelayClose)
    139             (window.ptHeldClose ??= []).push(() => super.close(code, reason));
    140           else super.close(code, reason);
    141         }
    142       };
    143     },
    144     { endpoint, origins }
    145   );
    146   await page.goto(server.url + '/search');
    147   await page.addScriptTag({ content: bundle });
    148   head = await page.evaluate(async (origins) => {
    149     window.ptFixture = await window.pt.makeRetryFixture();
    150     return window.ptFixture.host.preferenceWire(origins);
    151   }, origins);
    152   await page.evaluate(async () => {
    153     const f = window.ptFixture;
    154     await f.open();
    155     if ((await f.prepareOriginal()).status !== 'prepared')
    156       throw Error('actual original S3/R1 setup');
    157   });
    158 });
    159 test.afterEach(async ({ page }) => {
    160   if (!page.isClosed())
    161     await page.evaluate(() => {
    162       window.ptRestore?.();
    163       window.ptRelease?.();
    164       window.ptDelayClose = false;
    165       window.ptFailClose = false;
    166       for (const release of window.ptHeldClose ?? []) release();
    167       window.ptFixture.host.settle();
    168       window.ptFixture.close();
    169     });
    170 });
    171 async function recover(page: Page, fresh = false) {
    172   expect(
    173     await page.evaluate(async (fresh) => {
    174       const f = window.ptFixture;
    175       if (fresh) await f.freshSession();
    176       return (await f.recover())?.status;
    177     }, fresh)
    178   ).toBe('recovered');
    179 }
    180 async function adopt(page: Page) {
    181   expect(
    182     await page.evaluate(async () => (await window.ptFixture.adopt()).status)
    183   ).toBe('adopted');
    184 }
    185 async function action(page: Page) {
    186   expect(
    187     await page.evaluate(async () => !!(await window.ptFixture.captureAction()))
    188   ).toBe(true);
    189 }
    190 const privateFrames = () =>
    191   frames.filter((x) => x.origin !== 'wss://discovery.example.org');
    192 const events = () => privateFrames().filter((x) => x.frame[0] === 'EVENT');
    193 async function nativeWire(page: Page) {
    194   return page.evaluate(async () => {
    195     const f = window.ptFixture;
    196     return (await f.host.stored()).find((x) => x.id === f.command())!.wire;
    197   });
    198 }
    199 
    200 test('cold original ciphertext recovery adopts readonly then observes actual same-artifact PUB READ native facts', async ({
    201   page
    202 }) => {
    203   const original = await nativeWire(page);
    204   await recover(page, true);
    205   const before = await page.evaluate(() => window.ptFixture.host.counts());
    206   await adopt(page);
    207   await action(page);
    208   expect(await nativeWire(page)).toBe(original);
    209   expect(privateFrames()).toHaveLength(0);
    210   expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual(
    211     before
    212   );
    213   const result = await page.evaluate(async () => {
    214     const f = window.ptFixture,
    215       pub = await f.publish();
    216     if (!pub) throw Error('actual publication missing');
    217     const appended = await f.append(pub),
    218       read = await f.read();
    219     if (!read) throw Error('actual readback missing');
    220     const saved = await f.appendRead(read);
    221     return {
    222       pub,
    223       appended,
    224       read,
    225       saved,
    226       row: f.snapshot()?.record,
    227       originalBinding: f.originalBinding() === undefined
    228     };
    229   });
    230   expect(result.pub.status).toBe('accepted');
    231   expect(result.read.status).toBe('readback');
    232   expect(result.appended.status).toBe('saved');
    233   expect(result.saved.status).toBe('saved');
    234   expect(result.originalBinding).toBe(true);
    235   const old = JSON.parse(original) as Record<string, unknown>;
    236   expect(result.row?.id).toBe(old.id);
    237   expect(result.row?.self).toEqual(old.self);
    238   expect(result.row?.rumorHash).toBe(old.rumorHash);
    239   expect(result.row?.createdAt).toBe(old.createdAt);
    240   expect(result.row?.receipts.map((x) => x.role)).toEqual([
    241     'access_archive',
    242     'access_readback'
    243   ]);
    244   expect(events()).toHaveLength(1);
    245   const req = privateFrames().find((x) => x.frame[0] === 'REQ')!.frame[2];
    246   expect(req).toEqual({
    247     kinds: [1059],
    248     ids: [result.row!.self!.eventId],
    249     '#p': [result.row!.owner],
    250     limit: 1
    251   });
    252   expect(
    253     await page.evaluate(() => {
    254       const f = window.ptFixture,
    255         a = f.actors();
    256       return !!window.pt.captureInboxProbeSealOperation(
    257         a.session,
    258         f.proof() as unknown as Parameters<
    259           typeof window.pt.captureInboxProbeSealOperation
    260         >[1],
    261         'reviewed_inbox_probe_seal'
    262       );
    263     })
    264   ).toBe(false);
    265 });
    266 
    267 test('repeated adoption and capture retain actual acknowledgement action and native revision', async ({
    268   page
    269 }) => {
    270   await recover(page);
    271   await adopt(page);
    272   await action(page);
    273   const wire = await nativeWire(page);
    274   const result = await page.evaluate(async () => {
    275     const f = window.ptFixture,
    276       ack = f.acknowledgement(),
    277       act = f.action(),
    278       again = await f.adopt(),
    279       next = await f.captureAction();
    280     return {
    281       status: again.status,
    282       sameAck: 'acknowledgement' in again && again.acknowledgement === ack,
    283       sameAction: next === act
    284     };
    285   });
    286   expect(result).toEqual({
    287     status: 'existing',
    288     sameAck: true,
    289     sameAction: true
    290   });
    291   expect(await nativeWire(page)).toBe(wire);
    292   expect(privateFrames()).toHaveLength(0);
    293 });
    294 
    295 test('actual original and recovered permissions share combined per-origin three-attempt meter', async ({
    296   page
    297 }) => {
    298   const first = await page.evaluate(async () => {
    299     const f = window.ptFixture,
    300       result = await f.originalPublish();
    301     if (!result) throw Error('actual original effect');
    302     await f.append(result);
    303     return result;
    304   });
    305   expect(first.status).toBe('accepted');
    306   expect(first.attempt).toBe(1);
    307   await recover(page);
    308   await adopt(page);
    309   await action(page);
    310   const results = await page.evaluate(async () => {
    311     const f = window.ptFixture,
    312       read = await f.read();
    313     if (!read) throw Error('actual second action read');
    314     await f.appendRead(read);
    315     const pub = await f.publish();
    316     if (!pub) throw Error('actual third action event');
    317     await f.append(pub);
    318     const before = f.host.counts(),
    319       exhausted = await f.publish();
    320     return {
    321       read,
    322       pub,
    323       exhausted: exhausted === undefined,
    324       before,
    325       after: f.host.counts()
    326     };
    327   });
    328   expect(results.read.attempt).toBe(2);
    329   expect(results.pub.attempt).toBe(3);
    330   expect(results.read.actionId).toBe(first.actionId);
    331   expect(results.pub.actionId).toBe(first.actionId);
    332   expect(results.exhausted).toBe(true);
    333   expect(results.after).toEqual(results.before);
    334   expect(events()).toHaveLength(2);
    335 });
    336 
    337 test('new explicit controller recovery action replaces only ended clean action with same artifact', async ({
    338   page
    339 }) => {
    340   await recover(page);
    341   await adopt(page);
    342   await action(page);
    343   const first = await page.evaluate(async () => {
    344     const f = window.ptFixture,
    345       result = await f.publish();
    346     if (!result) throw Error('actual first effect');
    347     await f.append(result);
    348     return result;
    349   });
    350   const source = JSON.parse(await nativeWire(page)) as Record<string, unknown>;
    351   expect(
    352     await page.evaluate(
    353       async () => !!(await window.ptFixture.replaceController())
    354     )
    355   ).toBe(true);
    356   await recover(page);
    357   await adopt(page);
    358   await action(page);
    359   const second = await page.evaluate(async () => {
    360     const f = window.ptFixture,
    361       result = await f.publish();
    362     if (!result) throw Error('actual new action effect');
    363     await f.append(result);
    364     return { result, row: f.snapshot()?.record };
    365   });
    366   expect(second.result.status).toBe('accepted');
    367   expect(second.result.attempt).toBe(1);
    368   expect(second.result.actionId).not.toBe(first.actionId);
    369   expect(second.row?.id).toBe(source.id);
    370   expect(second.row?.self).toEqual(source.self);
    371   expect(second.row?.receipts).toHaveLength(2);
    372 });
    373 
    374 for (const phase of ['adoption', 'action'] as const)
    375   test(`${phase} rejects exact-native physical alias before any provider or traffic`, async ({
    376     page
    377   }) => {
    378     await recover(page);
    379     if (phase === 'action') await adopt(page);
    380     const before = await page.evaluate(() => window.ptFixture.host.counts());
    381     await page.evaluate(async () => {
    382       const f = window.ptFixture,
    383         rows = await f.host.stored();
    384       const row = rows.find((x) => x.id === f.command())!;
    385       await f.host.inject([{ ...row, wire: ' ' + row.wire }]);
    386     });
    387     const refused = await page.evaluate(async (phase) => {
    388       const f = window.ptFixture;
    389       return phase === 'adoption'
    390         ? !('acknowledgement' in (await f.adopt()))
    391         : (await f.captureAction()) === undefined;
    392     }, phase);
    393     expect(refused).toBe(true);
    394     expect(privateFrames()).toHaveLength(0);
    395     expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual(
    396       before
    397     );
    398   });
    399 
    400 test('handwritten historical labels grant no native adoption or remote effect without original proof', async ({
    401   page
    402 }) => {
    403   const result = await page.evaluate(async () => {
    404     const f = window.ptFixture,
    405       a = f.actors(),
    406       before = f.host.counts();
    407     const fake = { nonce_verified: true, accepted: true, current: () => true };
    408     const adoption = await window.pt.adoptRecoveredInboxProbe(
    409       f.repository,
    410       a.session,
    411       a.access,
    412       f.host.policy,
    413       f.host.qualification,
    414       fake as unknown as Parameters<
    415         typeof window.pt.adoptRecoveredInboxProbe
    416       >[5],
    417       'reviewed_original_inbox_probe_retry'
    418     );
    419     return {
    420       refused: !('acknowledgement' in adoption),
    421       before,
    422       after: f.host.counts()
    423     };
    424   });
    425   expect(result.refused).toBe(true);
    426   expect(result.after).toEqual(result.before);
    427   expect(privateFrames()).toHaveLength(0);
    428 });
    429 
    430 test('actual native append of one genuine effect is idempotent without duplicate revision', async ({
    431   page
    432 }) => {
    433   await recover(page);
    434   await adopt(page);
    435   await action(page);
    436   const result = await page.evaluate(async () => {
    437     const f = window.ptFixture,
    438       effect = await f.publish();
    439     if (!effect) throw Error('actual effect missing');
    440     const first = await f.append(effect),
    441       revision = f.snapshot()?.record.revision,
    442       again = await f.append(effect);
    443     return {
    444       first,
    445       again,
    446       revision,
    447       after: f.snapshot()?.record.revision,
    448       receipts: f.snapshot()?.record.receipts.length
    449     };
    450   });
    451   expect(result.first.status).toBe('saved');
    452   expect(result.again.status).toBe('existing');
    453   expect(result.after).toBe(result.revision);
    454   expect(result.receipts).toBe(1);
    455   expect(events()).toHaveLength(1);
    456 });
    457 
    458 test('real pending original key job blocks recovered action before any new key or meter', async ({
    459   page
    460 }) => {
    461   await recover(page);
    462   await adopt(page);
    463   await page.evaluate(() => {
    464     const f = window.ptFixture;
    465     f.host.mode('hold_key');
    466     window.ptPending = f.originalPublish();
    467   });
    468   await expect
    469     .poll(() => page.evaluate(() => window.ptFixture.host.waiting()))
    470     .toBe('key');
    471   const result = await page.evaluate(async () => {
    472     const f = window.ptFixture,
    473       before = f.host.counts(),
    474       unavailable = await f.captureAction();
    475     return {
    476       unavailable: unavailable === undefined,
    477       before,
    478       after: f.host.counts()
    479     };
    480   });
    481   expect(result.unavailable).toBe(true);
    482   expect(result.after).toEqual(result.before);
    483   expect(events()).toHaveLength(0);
    484   await page.evaluate(async () => {
    485     window.ptFixture.host.mode('normal');
    486     window.ptFixture.host.settle();
    487     const effect = await window.ptPending;
    488     if (
    489       !effect ||
    490       typeof effect !== 'object' ||
    491       !('status' in effect) ||
    492       effect.status !== 'accepted'
    493     )
    494       throw Error('actual original publication did not settle accepted');
    495   });
    496   await action(page);
    497   expect(events()).toHaveLength(1);
    498 });
    499 
    500 test('actual pending AUTH acknowledgement retains shared SDK slot and blocks new Retry action', async ({
    501   page
    502 }) => {
    503   await recover(page);
    504   await adopt(page);
    505   challenge = true;
    506   holdAuth = true;
    507   await page.evaluate(async () => {
    508     const f = window.ptFixture;
    509     await window.pt.authenticateInboxAccess(
    510       f.actors().access,
    511       'wss://inbox.example.org',
    512       'reviewed_inbox_connection_auth'
    513     );
    514   });
    515   await expect
    516     .poll(() =>
    517       page.evaluate(() => {
    518         const f = window.ptFixture;
    519         return window.pt.inboxAccessControllerSnapshot(f.actors().access)
    520           ?.auth[0]?.state;
    521       })
    522     )
    523     .toBe('challenge');
    524   await page.evaluate(() => {
    525     const f = window.ptFixture;
    526     window.ptPending = window.pt.respondInboxAccessAuthentication(
    527       f.actors().access,
    528       'wss://inbox.example.org',
    529       'reviewed_inbox_auth_response'
    530     );
    531   });
    532   await expect
    533     .poll(() => privateFrames().filter((x) => x.frame[0] === 'AUTH').length)
    534     .toBe(1);
    535   const result = await page.evaluate(async () => {
    536     const f = window.ptFixture,
    537       before = f.host.counts(),
    538       selected = await f.captureAction();
    539     return { refused: selected === undefined, before, after: f.host.counts() };
    540   });
    541   expect(result.refused).toBe(true);
    542   expect(result.after).toEqual(result.before);
    543   expect(events()).toHaveLength(0);
    544   for (const socket of physical) {
    545     const auth = privateFrames().find((x) => x.frame[0] === 'AUTH')
    546       ?.frame[1] as { id: string };
    547     if (auth) socket.send(JSON.stringify(['OK', auth.id, true, '']));
    548   }
    549   expect(await page.evaluate(() => window.ptPending)).toBe('accepted');
    550   await action(page);
    551 });
    552 
    553 test('forged original wrap cannot retry actual retained failed private cleanup', async ({
    554   page
    555 }) => {
    556   const result = await page.evaluate(async () => {
    557     const f = window.ptFixture,
    558       a = f.actors();
    559     let calls = 0;
    560     const off = window.pt.subscribePrivateSessionClose(a.session, () => {
    561       calls++;
    562       throw Error('controlled actual retained cleanup');
    563     });
    564     window.pt.closePrivateSession(a.session);
    565     const before = calls;
    566     const refused = await window.pt.commitInboxProbe(
    567       f.repository,
    568       a.session,
    569       {} as Parameters<typeof window.pt.commitInboxProbe>[2],
    570       'reviewed_inbox_probe_commit'
    571     );
    572     const after = calls;
    573     off();
    574     return { before, after, refused: !('acknowledgement' in refused) };
    575   });
    576   expect(result.before).toBe(1);
    577   expect(result.after).toBe(1);
    578   expect(result.refused).toBe(true);
    579   expect(privateFrames()).toHaveLength(0);
    580 });
    581 
    582 for (const scope of [
    583   'foreign_repository',
    584   'same_owner_repository',
    585   'copied_policy',
    586   'copied_operator',
    587   'other_controller',
    588   'other_session',
    589   'stale_head',
    590   'original_identity',
    591   'original_acknowledgement',
    592   'unreviewed'
    593 ] as const)
    594   test(`genuine recovered adoption refuses ${scope} without provider native or network effects`, async ({
    595     page
    596   }) => {
    597     await recover(page);
    598     const wire = await nativeWire(page);
    599     const result = await page.evaluate(async (scope) => {
    600       const f = window.ptFixture,
    601         a = f.actors();
    602       let repository = f.repository,
    603         session = a.session,
    604         access = a.access,
    605         policy = f.host.policy,
    606         operator = f.host.qualification,
    607         proof = f.proof(),
    608         review: unknown = 'reviewed_original_inbox_probe_retry';
    609       const other =
    610         scope === 'other_controller' || scope === 'other_session'
    611           ? await f.alternateController(true)
    612           : undefined;
    613       const before = f.host.counts();
    614       if (scope === 'foreign_repository')
    615         repository = f.host.foreignRepository();
    616       if (scope === 'same_owner_repository') repository = a.repository;
    617       if (scope === 'copied_policy') policy = f.host.copiedPolicy();
    618       if (scope === 'copied_operator') {
    619         const copy = window.pt.validateInboxOperatorQualification(
    620           window.pt.inboxOperatorQualificationWire(operator, policy)!
    621         );
    622         if (!copy) throw Error('actual same-wire operator');
    623         operator = copy;
    624       }
    625       if (other && scope === 'other_controller') access = other.access;
    626       if (scope === 'other_session') {
    627         session = other!.session;
    628       }
    629       if (scope === 'stale_head') a.churnHead();
    630       if (scope === 'original_identity')
    631         proof = f.originalIdentity() as unknown as typeof proof;
    632       if (scope === 'original_acknowledgement')
    633         proof = f.originalAck() as unknown as typeof proof;
    634       if (scope === 'unreviewed') review = 'reviewed_inbox_probe_network';
    635       const selected = await window.pt.adoptRecoveredInboxProbe(
    636         repository,
    637         session,
    638         access,
    639         policy,
    640         operator,
    641         proof!,
    642         review
    643       );
    644       other?.close();
    645       if (session !== a.session) window.pt.closePrivateSession(session);
    646       return {
    647         refused: !('acknowledgement' in selected),
    648         before,
    649         after: f.host.counts()
    650       };
    651     }, scope);
    652     expect(result.refused).toBe(true);
    653     expect(result.after).toEqual(result.before);
    654     expect(await nativeWire(page)).toBe(wire);
    655     expect(privateFrames()).toHaveLength(0);
    656   });
    657 
    658 for (const scope of [
    659   'foreign_repository',
    660   'same_owner_repository',
    661   'copied_policy',
    662   'original_acknowledgement',
    663   'proof',
    664   'unreviewed',
    665   'stale_head'
    666 ] as const)
    667   test(`recovered Retry capture refuses ${scope} before any provider or traffic`, async ({
    668     page
    669   }) => {
    670     await recover(page);
    671     await adopt(page);
    672     const wire = await nativeWire(page);
    673     const result = await page.evaluate(async (scope) => {
    674       const f = window.ptFixture,
    675         a = f.actors(),
    676         before = f.host.counts();
    677       let repository = f.repository,
    678         policy = f.host.policy,
    679         acknowledgement = f.acknowledgement(),
    680         review: unknown = 'reviewed_original_inbox_probe_retry';
    681       if (scope === 'foreign_repository')
    682         repository = f.host.foreignRepository();
    683       if (scope === 'same_owner_repository') repository = a.repository;
    684       if (scope === 'copied_policy') policy = f.host.copiedPolicy();
    685       if (scope === 'original_acknowledgement')
    686         acknowledgement = f.originalAck();
    687       if (scope === 'proof')
    688         acknowledgement = f.proof() as unknown as typeof acknowledgement;
    689       if (scope === 'unreviewed') review = 'reviewed_inbox_probe_network';
    690       if (scope === 'stale_head') a.churnHead();
    691       const selected = await window.pt.captureRecoveredInboxProbeRetryAction(
    692         repository,
    693         a.session,
    694         policy,
    695         acknowledgement!,
    696         review
    697       );
    698       return { refused: !selected, before, after: f.host.counts() };
    699     }, scope);
    700     expect(result.refused).toBe(true);
    701     expect(result.after).toEqual(result.before);
    702     expect(await nativeWire(page)).toBe(wire);
    703     expect(privateFrames()).toHaveLength(0);
    704   });
    705 
    706 for (const phase of ['adoption', 'action'] as const)
    707   for (const mutation of [
    708     'r0',
    709     'unknown_tail',
    710     'foreign_tail',
    711     'missing',
    712     'corrupt'
    713   ] as const)
    714     test(`${phase} observes complete physical owner scope with ${mutation}`, async ({
    715       page
    716     }) => {
    717       await recover(page);
    718       if (phase === 'action') await adopt(page);
    719       const before = await page.evaluate(() => window.ptFixture.host.counts());
    720       await page.evaluate(async (mutation) => {
    721         const f = window.ptFixture,
    722           row = (await f.host.stored()).find((x) => x.id === f.command())!;
    723         if (mutation === 'missing') await f.removeFixtureRow();
    724         else if (mutation === 'corrupt')
    725           await f.host.inject([{ ...row, wire: '{}' }]);
    726         else if (mutation === 'r0') {
    727           const record = JSON.parse(row.wire) as {
    728             self: unknown;
    729             revision: number;
    730           };
    731           record.self = null;
    732           record.revision = 0;
    733           await f.host.inject([{ ...row, wire: JSON.stringify(record) }]);
    734         } else
    735           await f.host.inject([
    736             {
    737               owner: mutation === 'foreign_tail' ? 'f'.repeat(64) : row.owner,
    738               id: crypto.randomUUID(),
    739               wire: '{"unrecognized":true}'
    740             }
    741           ]);
    742       }, mutation);
    743       const raw = await page.evaluate(() => window.ptFixture.host.stored());
    744       const accepted = await page.evaluate(async (phase) => {
    745         const f = window.ptFixture;
    746         return phase === 'adoption'
    747           ? 'acknowledgement' in (await f.adopt())
    748           : !!(await f.captureAction());
    749       }, phase);
    750       expect(accepted).toBe(mutation === 'foreign_tail');
    751       expect(await page.evaluate(() => window.ptFixture.host.stored())).toEqual(
    752         raw
    753       );
    754       expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual(
    755         before
    756       );
    757       expect(privateFrames()).toHaveLength(0);
    758     });
    759 
    760 for (const phase of ['adoption', 'action'] as const)
    761   for (const hit of phase === 'action' ? [1, 2] : [1])
    762     for (const fault of ['before', 'after'] as const)
    763       test(`${phase} refuses actual readonly${hit} ${fault} native abort`, async ({
    764         page
    765       }) => {
    766         await recover(page);
    767         if (phase === 'action') await adopt(page);
    768         const wire = await nativeWire(page);
    769         const result = await page.evaluate(
    770           async ({ phase, hit, fault }) => {
    771             const f = window.ptFixture,
    772               before = f.host.counts(),
    773               original = Object.getOwnPropertyDescriptor(
    774                 IDBIndex.prototype,
    775                 'openCursor'
    776               )!.value as IDBIndex['openCursor'];
    777             let selected = 0,
    778               aborts = 0;
    779             IDBIndex.prototype.openCursor = function (
    780               ...args: Parameters<IDBIndex['openCursor']>
    781             ) {
    782               const request = original.apply(this, args);
    783               if (
    784                 this.objectStore.name === 'private_sends' &&
    785                 this.objectStore.transaction.mode === 'readonly' &&
    786                 ++selected === hit
    787               ) {
    788                 const tx = this.objectStore.transaction;
    789                 if (fault === 'before') {
    790                   aborts++;
    791                   tx.abort();
    792                 } else
    793                   request.addEventListener(
    794                     'success',
    795                     () => {
    796                       aborts++;
    797                       tx.abort();
    798                     },
    799                     { once: true }
    800                   );
    801               }
    802               return request;
    803             };
    804             window.ptRestore = () => {
    805               IDBIndex.prototype.openCursor = original;
    806             };
    807             const refused =
    808               phase === 'adoption'
    809                 ? !('acknowledgement' in (await f.adopt()))
    810                 : !(await f.captureAction());
    811             window.ptRestore();
    812             return { refused, aborts, before, after: f.host.counts() };
    813           },
    814           { phase, hit, fault }
    815         );
    816         expect(result.refused).toBe(true);
    817         expect(result.aborts).toBe(1);
    818         expect(result.after).toEqual(result.before);
    819         expect(await nativeWire(page)).toBe(wire);
    820         expect(privateFrames()).toHaveLength(0);
    821       });
    822 
    823 for (const phase of ['adoption', 'action'] as const)
    824   test(`${phase} actual owner lock contention is inert and permits later explicit admission`, async ({
    825     page
    826   }) => {
    827     await recover(page);
    828     if (phase === 'action') await adopt(page);
    829     await page.evaluate(() => {
    830       const f = window.ptFixture;
    831       window.ptPending = navigator.locks.request(
    832         'harvestcircle:owner:' + f.host.owner,
    833         async () => {
    834           await new Promise<void>((resolve) => {
    835             window.ptRelease = resolve;
    836           });
    837         }
    838       );
    839     });
    840     await expect.poll(() => page.evaluate(() => !!window.ptRelease)).toBe(true);
    841     const result = await page.evaluate(async (phase) => {
    842       const f = window.ptFixture,
    843         before = f.host.counts();
    844       const refused =
    845         phase === 'adoption'
    846           ? !('acknowledgement' in (await f.adopt()))
    847           : !(await f.captureAction());
    848       return { refused, before, after: f.host.counts() };
    849     }, phase);
    850     expect(result.refused).toBe(true);
    851     expect(result.after).toEqual(result.before);
    852     expect(privateFrames()).toHaveLength(0);
    853     await page.evaluate(async () => {
    854       window.ptRelease!();
    855       await window.ptPending;
    856     });
    857     if (phase === 'adoption') await adopt(page);
    858     else await action(page);
    859   });
    860 
    861 test('concurrent readonly adoption and Retry capture return only one actual token without regeneration', async ({
    862   page
    863 }) => {
    864   await recover(page);
    865   const result = await page.evaluate(async () => {
    866     const f = window.ptFixture,
    867       before = f.host.counts();
    868     const first = f.adopt(),
    869       second = f.adopt();
    870     const [one, two] = await Promise.all([first, second]);
    871     if (!('acknowledgement' in one)) throw Error('actual first adoption');
    872     const [action, reentry] = await Promise.all([
    873       f.captureAction(),
    874       f.captureAction()
    875     ]);
    876     return {
    877       first: one.status,
    878       second: two.status,
    879       action: !!action,
    880       reentry: !reentry,
    881       before,
    882       after: f.host.counts()
    883     };
    884   });
    885   expect(result.first).toBe('adopted');
    886   expect(result.second).toBe('busy');
    887   expect(result.action).toBe(true);
    888   expect(result.reentry).toBe(true);
    889   expect(result.after).toEqual(result.before);
    890   expect(privateFrames()).toHaveLength(0);
    891 });
    892 
    893 for (const callback of ['reentry', 'native_mutation', 'stale_head'] as const)
    894   test(`actual action UUID ${callback} callback cannot mint competing or stale Retry authority`, async ({
    895     page
    896   }) => {
    897     await recover(page);
    898     await adopt(page);
    899     const result = await page.evaluate(async (callback) => {
    900       const f = window.ptFixture,
    901         before = f.host.counts(),
    902         original = crypto.randomUUID.bind(crypto);
    903       let callbacks = 0;
    904       let other: Promise<unknown> | undefined;
    905       const row = (await f.host.stored()).find((x) => x.id === f.command())!;
    906       crypto.randomUUID = () => {
    907         callbacks++;
    908         if (callback === 'reentry') other = f.captureAction();
    909         else if (callback === 'native_mutation')
    910           other = f.host.inject([{ ...row, wire: ' ' + row.wire }]);
    911         else f.actors().churnHead();
    912         return original();
    913       };
    914       window.ptRestore = () => {
    915         crypto.randomUUID = original;
    916       };
    917       const selected = await f.captureAction();
    918       window.ptRestore();
    919       const reentered = await other;
    920       return {
    921         callbacks,
    922         selected: !!selected,
    923         reentered: !!reentered,
    924         before,
    925         after: f.host.counts()
    926       };
    927     }, callback);
    928     expect(result.callbacks).toBe(1);
    929     expect(result.selected).toBe(callback === 'reentry');
    930     expect(result.reentered).toBe(false);
    931     expect(result.after).toEqual(result.before);
    932     expect(privateFrames()).toHaveLength(0);
    933   });
    934 
    935 for (const pending of ['EVENT', 'REQ'] as const)
    936   test(`actual pending ${pending} blocks new Retry action and pure pool observation until original settles`, async ({
    937     page
    938   }) => {
    939     await recover(page);
    940     await adopt(page);
    941     if (pending === 'EVENT') {
    942       holdEvent = true;
    943       await page.evaluate(() => {
    944         window.ptPending = window.ptFixture.originalPublish();
    945       });
    946     } else {
    947       expect(
    948         await page.evaluate(
    949           async () => (await window.ptFixture.originalPublish())?.status
    950         )
    951       ).toBe('accepted');
    952       holdRead = true;
    953       await page.evaluate(() => {
    954         window.ptPending = window.ptFixture.originalRead();
    955       });
    956     }
    957     await expect
    958       .poll(() => privateFrames().filter((x) => x.frame[0] === pending).length)
    959       .toBe(1);
    960     const result = await page.evaluate(async () => {
    961       const f = window.ptFixture,
    962         before = f.host.counts(),
    963         idle = f.idle(),
    964         selected = await f.captureAction();
    965       return { idle, refused: !selected, before, after: f.host.counts() };
    966     });
    967     expect(result.idle).toBe(false);
    968     expect(result.refused).toBe(true);
    969     expect(result.after).toEqual(result.before);
    970     if (pending === 'EVENT') {
    971       const id = (events()[0].frame[1] as { id: string }).id;
    972       for (const socket of physical)
    973         socket.send(JSON.stringify(['OK', id, true, '']));
    974     } else {
    975       const frame = privateFrames().find((x) => x.frame[0] === 'REQ')!;
    976       const id = (frame.frame[2] as { ids: string[] }).ids[0];
    977       for (const socket of physical) {
    978         socket.send(
    979           JSON.stringify([
    980             'EVENT',
    981             frame.frame[1],
    982             archived.get(JSON.stringify([frame.origin, id]))
    983           ])
    984         );
    985         socket.send(JSON.stringify(['EOSE', frame.frame[1]]));
    986       }
    987     }
    988     expect(
    989       ((await page.evaluate(() => window.ptPending)) as { status: string })
    990         .status
    991     ).toBe(pending === 'EVENT' ? 'accepted' : 'readback');
    992     await action(page);
    993   });
    994 
    995 test('genuine same-scope controller recapture retains the original controller and action meter', async ({
    996   page
    997 }) => {
    998   const first = await page.evaluate(() => window.ptFixture.originalPublish());
    999   expect(first?.status).toBe('accepted');
   1000   const result = await page.evaluate(async () => {
   1001     const f = window.ptFixture,
   1002       a = f.actors(),
   1003       other = await f.alternateController();
   1004     const reader = window.pt.captureInboxProbeRecoveryReader(
   1005       f.repository,
   1006       a.identity,
   1007       a.session,
   1008       f.host.policy,
   1009       other.access,
   1010       f.host.qualification,
   1011       f.command(),
   1012       'reviewed_inbox_probe_recovery'
   1013     );
   1014     if (!reader) throw Error('actual alternate recovery reader');
   1015     const proof = await window.pt.recoverInboxProbe(reader);
   1016     if (!('proof' in proof)) throw Error('actual alternate proof');
   1017     const adopted = await window.pt.adoptRecoveredInboxProbe(
   1018       f.repository,
   1019       a.session,
   1020       other.access,
   1021       f.host.policy,
   1022       f.host.qualification,
   1023       proof.proof,
   1024       'reviewed_original_inbox_probe_retry'
   1025     );
   1026     if (!('acknowledgement' in adopted))
   1027       throw Error('actual alternate readonly adoption');
   1028     const before = f.host.counts(),
   1029       selected = await window.pt.captureRecoveredInboxProbeRetryAction(
   1030         f.repository,
   1031         a.session,
   1032         f.host.policy,
   1033         adopted.acknowledgement,
   1034         'reviewed_original_inbox_probe_retry'
   1035       );
   1036     const permission =
   1037       selected &&
   1038       window.pt.captureInboxProbePublication(
   1039         f.repository,
   1040         a.session,
   1041         f.host.policy,
   1042         adopted.acknowledgement,
   1043         selected,
   1044         'wss://inbox.example.org',
   1045         'reviewed_inbox_probe_publication'
   1046       );
   1047     const effect =
   1048       permission &&
   1049       (await window.pt.publishInboxProbeArchiveAttempt(
   1050         f.pool()!,
   1051         permission,
   1052         new AbortController().signal
   1053       ));
   1054     window.pt.stopInboxProbeRecoveryReader(reader);
   1055     other.close();
   1056     return {
   1057       sameController: other.access === a.access,
   1058       effect,
   1059       providerCalls: f.host.counts().keys - before.keys
   1060     };
   1061   });
   1062   expect(result.sameController).toBe(true);
   1063   expect(result.effect).toMatchObject({
   1064     status: 'accepted',
   1065     attempt: 2,
   1066     actionId: first!.actionId
   1067   });
   1068   expect(result.providerCalls).toBe(1);
   1069   expect(events()).toHaveLength(2);
   1070 });
   1071 
   1072 test('same action has independent bounded three-attempt counters across exactly three frozen origins', async ({
   1073   page
   1074 }) => {
   1075   await recover(page);
   1076   await adopt(page);
   1077   await action(page);
   1078   const result = await page.evaluate(async (origins) => {
   1079     const f = window.ptFixture,
   1080       effects = [];
   1081     for (const origin of origins) {
   1082       for (let i = 0; i < 3; i++) {
   1083         const effect = await f.publish(origin);
   1084         if (!effect) throw Error('actual permitted original artifact attempt');
   1085         await f.append(effect);
   1086         effects.push({
   1087           status: effect.status,
   1088           attempt: effect.attempt,
   1089           actionId: effect.actionId
   1090         });
   1091       }
   1092       if (await f.read(origin))
   1093         throw Error('exhausted combined archive/read origin admitted');
   1094     }
   1095     const before = f.host.counts(),
   1096       foreign = await f.publish('wss://foreign.example.org');
   1097     return { effects, foreign: !foreign, before, after: f.host.counts() };
   1098   }, origins);
   1099   expect(result.effects.map((x) => x.attempt)).toEqual([
   1100     1, 2, 3, 1, 2, 3, 1, 2, 3
   1101   ]);
   1102   expect(new Set(result.effects.map((x) => x.actionId)).size).toBe(1);
   1103   expect(result.effects.every((x) => x.status === 'accepted')).toBe(true);
   1104   expect(result.foreign).toBe(true);
   1105   expect(result.after).toEqual(result.before);
   1106   expect(events()).toHaveLength(9);
   1107   expect(physical.size).toBeLessThanOrEqual(4); // Three private plus public discovery.
   1108 });
   1109 
   1110 test('100 genuine command slots remain protected at source registry capacity without fixture deletion granting authority', async ({
   1111   page
   1112 }) => {
   1113   const result = await page.evaluate(async () => {
   1114     const f = window.ptFixture,
   1115       a = f.actors(),
   1116       saved = [];
   1117     for (let i = 0; i < 100; i++) {
   1118       if (i) {
   1119         if (!(await f.replaceController()))
   1120           throw Error('actual next source controller');
   1121         if ((await f.prepareOriginal()).status !== 'prepared')
   1122           throw Error('actual next original S3/R1');
   1123       }
   1124       const action = window.pt.captureInboxProbePublicationAction(
   1125         f.repository,
   1126         a.session,
   1127         f.host.policy,
   1128         f.originalAck()!,
   1129         'reviewed_inbox_probe_network'
   1130       );
   1131       if (!action) throw Error('actual bounded command slot ' + i);
   1132       saved.push(action);
   1133       await f.removeFixtureRow();
   1134     }
   1135     if (!(await f.replaceController()))
   1136       throw Error('actual capacity controller');
   1137     if ((await f.prepareOriginal()).status !== 'prepared')
   1138       throw Error('actual capacity original');
   1139     const row = (await f.host.stored()).find((x) => x.id === f.command())!;
   1140     const before = f.host.counts();
   1141     const refused = !window.pt.captureInboxProbePublicationAction(
   1142       f.repository,
   1143       a.session,
   1144       f.host.policy,
   1145       f.originalAck()!,
   1146       'reviewed_inbox_probe_network'
   1147     );
   1148     if ((await f.recover())?.status !== 'recovered')
   1149       throw Error('actual capacity recovery');
   1150     if (!('acknowledgement' in (await f.adopt())))
   1151       throw Error('actual capacity readonly adoption');
   1152     const afterRecovery = f.host.counts(),
   1153       retryRefused = !(await f.captureAction());
   1154     return {
   1155       slots: saved.length,
   1156       refused,
   1157       retryRefused,
   1158       before,
   1159       afterRecovery,
   1160       after: f.host.counts(),
   1161       wire: row.wire,
   1162       current: (await f.host.stored()).find((x) => x.id === f.command())!.wire
   1163     };
   1164   });
   1165   expect(result.slots).toBe(100);
   1166   expect(result.refused).toBe(true);
   1167   expect(result.retryRefused).toBe(true);
   1168   expect(result.after).toEqual(result.afterRecovery);
   1169   expect(result.current).toBe(result.wire);
   1170   expect(privateFrames()).toHaveLength(0);
   1171 });
   1172 
   1173 for (const lane of ['page', 'live'] as const)
   1174   test(`actual foreground ${lane} owner blocks new Retry without disturbing its subscription`, async ({
   1175     page
   1176   }) => {
   1177     await recover(page);
   1178     await adopt(page);
   1179     holdRead = true;
   1180     await page.evaluate((lane) => {
   1181       const f = window.ptFixture,
   1182         a = f.actors();
   1183       const pool = window.pt.getPrivatePool(
   1184         a.session,
   1185         f.host.policy,
   1186         ['wss://inbox.example.org'],
   1187         Object.freeze({}),
   1188         'receive'
   1189       );
   1190       if (!pool) throw Error('actual foreground pool scope');
   1191       const stop =
   1192         lane === 'page'
   1193           ? window.pt.subscribePrivatePage(pool, 1, () => {})
   1194           : window.pt.subscribePrivateLive(pool, () => {});
   1195       window.ptRelease = () => {
   1196         stop();
   1197       };
   1198     }, lane);
   1199     await expect
   1200       .poll(() => privateFrames().filter((x) => x.frame[0] === 'REQ').length)
   1201       .toBe(1);
   1202     const framesBefore = privateFrames().slice();
   1203     const result = await page.evaluate(async () => {
   1204       const f = window.ptFixture,
   1205         before = f.host.counts(),
   1206         idle = f.idle(),
   1207         selected = await f.captureAction();
   1208       return { idle, refused: !selected, before, after: f.host.counts() };
   1209     });
   1210     expect(result.idle).toBe(false);
   1211     expect(result.refused).toBe(true);
   1212     expect(result.after).toEqual(result.before);
   1213     expect(privateFrames()).toEqual(framesBefore);
   1214     await page.evaluate(() => window.ptRelease!());
   1215     await expect
   1216       .poll(() => page.evaluate(() => window.ptFixture.idle()))
   1217       .toBe(true);
   1218     await action(page);
   1219   });
   1220 
   1221 test('actual B1 B2 predecessor facts survive fresh-session recovery and never skip new named effects', async ({
   1222   page
   1223 }) => {
   1224   const prior = await page.evaluate(async () => {
   1225     const f = window.ptFixture,
   1226       pub = await f.originalPublish();
   1227     if (!pub) throw Error('actual old B1');
   1228     await f.append(pub);
   1229     const read = await f.originalRead();
   1230     if (!read) throw Error('actual old B2');
   1231     await f.appendRead(read);
   1232     return { pub, read };
   1233   });
   1234   const predecessor = await nativeWire(page);
   1235   await recover(page, true);
   1236   await adopt(page);
   1237   await action(page);
   1238   expect(await nativeWire(page)).toBe(predecessor);
   1239   expect(events()).toHaveLength(1);
   1240   const fresh = await page.evaluate(async () => {
   1241     const f = window.ptFixture,
   1242       pub = await f.publish();
   1243     if (!pub) throw Error('actual fresh B1');
   1244     await f.append(pub);
   1245     const read = await f.read();
   1246     if (!read) throw Error('actual fresh B2');
   1247     await f.appendRead(read);
   1248     return {
   1249       pub,
   1250       read,
   1251       row: f.snapshot()?.record,
   1252       readiness: window.pt.inboxAccessControllerSnapshot(f.actors().access)
   1253         ?.readiness
   1254     };
   1255   });
   1256   expect(fresh.pub.status).toBe('accepted');
   1257   expect(fresh.read.status).toBe('readback');
   1258   expect(fresh.pub.actionId).not.toBe(prior.pub.actionId);
   1259   expect(fresh.row?.receipts.slice(0, 2)).toEqual(
   1260     (JSON.parse(predecessor) as { receipts: unknown[] }).receipts
   1261   );
   1262   expect(fresh.row?.receipts).toHaveLength(4);
   1263   expect(fresh.readiness).toBe('unavailable');
   1264   expect(events()).toHaveLength(2);
   1265 });
   1266 
   1267 test('historical unknown labels remain unknown through adoption and require a new genuine observed effect', async ({
   1268   page
   1269 }) => {
   1270   await page.evaluate(async () => {
   1271     const f = window.ptFixture,
   1272       effect = await f.originalPublish();
   1273     if (!effect) throw Error('actual predecessor fixture');
   1274     await f.append(effect);
   1275     const row = (await f.host.stored()).find((x) => x.id === f.command())!,
   1276       record = JSON.parse(row.wire) as { receipts: { status: string }[] };
   1277     record.receipts[0].status = 'unknown';
   1278     await f.host.inject([{ ...row, wire: JSON.stringify(record) }]);
   1279   });
   1280   const wire = await nativeWire(page);
   1281   await recover(page, true);
   1282   await adopt(page);
   1283   await action(page);
   1284   expect(await nativeWire(page)).toBe(wire);
   1285   const result = await page.evaluate(async () => {
   1286     const f = window.ptFixture,
   1287       effect = await f.publish();
   1288     if (!effect) throw Error('actual fresh named effect');
   1289     await f.append(effect);
   1290     return { effect, row: f.snapshot()?.record };
   1291   });
   1292   expect(result.effect.status).toBe('accepted');
   1293   expect(result.row?.receipts.map((x) => x.status)).toEqual([
   1294     'unknown',
   1295     'accepted'
   1296   ]);
   1297   expect(events()).toHaveLength(2);
   1298 });
   1299 
   1300 test('genuine original C1 nonce capability is isolated from recovered Retry and recovered readback cannot issue C1 proof', async ({
   1301   page
   1302 }) => {
   1303   await page.evaluate(async () => {
   1304     const f = window.ptFixture,
   1305       a = f.actors();
   1306     if (!(await f.originalPublish()))
   1307       throw Error('actual original publication');
   1308     const read = await f.originalRead();
   1309     if (!read) throw Error('actual original read');
   1310     const reader = window.pt.captureInboxProbeNonceReader(
   1311       f.repository,
   1312       a.identity,
   1313       a.session,
   1314       f.host.policy,
   1315       read,
   1316       'reviewed_inbox_probe_nonce_decryption'
   1317     );
   1318     if (!reader) throw Error('actual original C1 reader');
   1319     const proof = await window.pt.readInboxProbeNonce(reader);
   1320     if (!('proof' in proof)) throw Error('actual original C1 proof');
   1321     const before = f.host.counts();
   1322     const selected = await window.pt.adoptRecoveredInboxProbe(
   1323       f.repository,
   1324       a.session,
   1325       a.access,
   1326       f.host.policy,
   1327       f.host.qualification,
   1328       proof.proof as unknown as Parameters<
   1329         typeof window.pt.adoptRecoveredInboxProbe
   1330       >[5],
   1331       'reviewed_original_inbox_probe_retry'
   1332     );
   1333     if (
   1334       'acknowledgement' in selected ||
   1335       JSON.stringify(before) !== JSON.stringify(f.host.counts())
   1336     )
   1337       throw Error('C1 crossed recovered Retry authority');
   1338     window.pt.stopInboxProbeNonceReader(reader);
   1339   });
   1340   await recover(page);
   1341   await adopt(page);
   1342   await action(page);
   1343   const result = await page.evaluate(async () => {
   1344     const f = window.ptFixture,
   1345       a = f.actors(),
   1346       read = await f.read();
   1347     if (!read) throw Error('actual recovered readback');
   1348     const before = f.host.counts();
   1349     const reader = window.pt.captureInboxProbeNonceReader(
   1350       f.repository,
   1351       a.identity,
   1352       a.session,
   1353       f.host.policy,
   1354       read,
   1355       'reviewed_inbox_probe_nonce_decryption'
   1356     );
   1357     return { refused: !reader, before, after: f.host.counts(), read };
   1358   });
   1359   expect(result.refused).toBe(true);
   1360   expect(result.after).toEqual(result.before);
   1361   expect(result.read.status).toBe('readback');
   1362   expect(result.read.attempt).toBe(3);
   1363 });
   1364 
   1365 test('actual measured cumulative 45-second network allowance stays exhausted across original recovery', async ({
   1366   page
   1367 }) => {
   1368   await page.evaluate(() => {
   1369     const f = window.ptFixture;
   1370     window.ptClock = f.installNetworkClock();
   1371     window.ptRestore = () => window.ptClock!.restore();
   1372   });
   1373   holdEvent = true;
   1374   await page.evaluate(() => {
   1375     window.ptPending = window.ptFixture.originalPublish();
   1376   });
   1377   await expect.poll(() => events().length).toBe(1);
   1378   await page.evaluate(() => window.ptClock!.advance(30000));
   1379   const id = (events()[0].frame[1] as { id: string }).id;
   1380   for (const socket of physical)
   1381     socket.send(JSON.stringify(['OK', id, true, '']));
   1382   expect(
   1383     ((await page.evaluate(() => window.ptPending)) as { status: string }).status
   1384   ).toBe('accepted');
   1385   await recover(page);
   1386   await adopt(page);
   1387   await action(page);
   1388   holdRead = true;
   1389   await page.evaluate(() => {
   1390     window.ptPending = window.ptFixture.read();
   1391   });
   1392   await expect
   1393     .poll(() => privateFrames().filter((x) => x.frame[0] === 'REQ').length)
   1394     .toBe(1);
   1395   await page.evaluate(() => window.ptClock!.advance(15001));
   1396   const timed = (await page.evaluate(() => window.ptPending)) as {
   1397     status: string;
   1398     attempt: number;
   1399   };
   1400   expect(timed).toMatchObject({ status: 'timed_out', attempt: 2 });
   1401   const result = await page.evaluate(async () => {
   1402     const f = window.ptFixture,
   1403       before = f.host.counts(),
   1404       refused = !(await f.publish());
   1405     return {
   1406       refused,
   1407       before,
   1408       after: f.host.counts(),
   1409       observations: window.ptClock!.observations()
   1410     };
   1411   });
   1412   expect(result.refused).toBe(true);
   1413   expect(result.after).toEqual(result.before);
   1414   expect(result.observations).toBeGreaterThan(0);
   1415   expect(events()).toHaveLength(1);
   1416 });
   1417 
   1418 for (const fault of ['held', 'failed'] as const)
   1419   test(`actual original ${fault} physical cleanup blocks recovered authority without retrying cleanup implicitly`, async ({
   1420     page
   1421   }) => {
   1422     await recover(page);
   1423     await adopt(page);
   1424     holdEvent = true;
   1425     await page.evaluate(() => {
   1426       window.ptAbort = new AbortController();
   1427       window.ptPending = window.ptFixture.originalPublish(
   1428         undefined,
   1429         window.ptAbort.signal
   1430       );
   1431     });
   1432     await expect.poll(() => events().length).toBe(1);
   1433     const result = await page.evaluate(async (fault) => {
   1434       const f = window.ptFixture,
   1435         acknowledgement = f.acknowledgement()!;
   1436       window.ptDelayClose = fault === 'held';
   1437       window.ptFailClose = fault === 'failed';
   1438       window.ptAbort!.abort();
   1439       let failed = false;
   1440       try {
   1441         f.stop();
   1442       } catch {
   1443         failed = true;
   1444       }
   1445       const effect = await window.ptPending,
   1446         applied = await f.append(effect as Parameters<typeof f.append>[0]);
   1447       if (!['saved', 'existing', 'reconciled'].includes(applied.status))
   1448         throw Error(
   1449           'actual stopped archive native bookkeeping ' + applied.status
   1450         );
   1451       const before = f.host.counts(),
   1452         held = window.ptHeldClose?.length ?? 0;
   1453       const idle = f.idle(),
   1454         selected = await window.pt.captureRecoveredInboxProbeRetryAction(
   1455           f.repository,
   1456           f.actors().session,
   1457           f.host.policy,
   1458           acknowledgement,
   1459           'reviewed_original_inbox_probe_retry'
   1460         );
   1461       return {
   1462         effect,
   1463         failed,
   1464         idle,
   1465         refused: !selected,
   1466         held,
   1467         afterHeld: window.ptHeldClose?.length ?? 0,
   1468         before,
   1469         after: f.host.counts()
   1470       };
   1471     }, fault);
   1472     expect(result.effect).toMatchObject({ status: 'stopped', attempt: 1 });
   1473     expect(result.idle).toBe(false);
   1474     expect(result.refused).toBe(true);
   1475     expect(result.afterHeld).toBe(result.held);
   1476     expect(result.after).toEqual(result.before);
   1477     if (fault === 'failed') expect(result.failed).toBe(true);
   1478     else expect(result.held).toBeGreaterThan(0);
   1479     const observed = await page.evaluate(async () => {
   1480       const before = window.ptCloseCalls ?? 0,
   1481         replacement = await window.ptFixture.replacementWhilePending();
   1482       return { replacement, before, after: window.ptCloseCalls ?? 0 };
   1483     });
   1484     const replacement = observed.replacement;
   1485     console.info(
   1486       JSON.stringify({
   1487         fixture: 'C2B_ACTUAL_FRESH_REPLACEMENT_PHYSICAL_GATE',
   1488         fault,
   1489         gate: replacement.gate,
   1490         genuineCurrentBinding:
   1491           replacement.gate === 'actual_retry_admission'
   1492             ? replacement.genuineCurrentBinding
   1493             : null,
   1494         uuidCalls:
   1495           replacement.gate === 'actual_retry_admission'
   1496             ? replacement.uuids
   1497             : null
   1498       })
   1499     );
   1500     expect(replacement.gate).toBe('actual_retry_admission');
   1501     if (replacement.gate !== 'actual_retry_admission')
   1502       throw Error('genuine fresh Retry must reach the original physical gate');
   1503     expect(replacement.genuineCurrentBinding).toBe(true);
   1504     expect(replacement.refused).toBe(true);
   1505     expect(replacement.uuids).toBe(0);
   1506     expect(replacement.after).toEqual(replacement.before);
   1507     expect(replacement.closesAfter).toBe(replacement.closesBefore);
   1508     expect(events()).toHaveLength(1);
   1509     await page.evaluate(() => {
   1510       window.ptDelayClose = false;
   1511       window.ptFailClose = false;
   1512       for (const release of window.ptHeldClose ?? []) release();
   1513       // A real failed close has no held callback to release: explicitly retry
   1514       // its ORIGINAL Stop before waiting for the resulting native close.
   1515       try {
   1516         window.ptFixture.stop();
   1517       } catch (error) {
   1518         if (
   1519           !(error instanceof Error) ||
   1520           !['private_pool_close_pending', 'private_pool_close_failed'].includes(
   1521             error.message
   1522           )
   1523         )
   1524           throw error;
   1525       }
   1526     });
   1527     await expect.poll(() => events().length).toBe(1);
   1528     await expect.poll(() => physical.size).toBeLessThanOrEqual(1);
   1529     await page.evaluate(() => window.ptFixture.stop());
   1530     holdEvent = false;
   1531     expect(
   1532       await page.evaluate(
   1533         async () => !!(await window.ptFixture.replaceController())
   1534       )
   1535     ).toBe(true);
   1536     await recover(page);
   1537     await adopt(page);
   1538     await action(page);
   1539     const next = await page.evaluate(() => window.ptFixture.publish());
   1540     expect(next).toMatchObject({ status: 'accepted', attempt: 1 });
   1541     expect(next!.actionId).not.toBe(
   1542       (result.effect as { actionId: string }).actionId
   1543     );
   1544     expect(events()).toHaveLength(2);
   1545     expect(events()[1].frame[1]).toEqual(events()[0].frame[1]);
   1546   });
   1547 
   1548 test('actual failed original SDK teardown stays protected without implicit Retry cleanup', async ({
   1549   page
   1550 }) => {
   1551   await recover(page);
   1552   await adopt(page);
   1553   holdEvent = true;
   1554   await page.evaluate(() => {
   1555     const f = window.ptFixture,
   1556       fault = f.installAttemptTeardownFailure();
   1557     window.ptRestore = fault.restore;
   1558     window.ptAbort = new AbortController();
   1559     window.ptPending = f.originalPublish(undefined, window.ptAbort.signal);
   1560   });
   1561   await expect.poll(() => events().length).toBe(1);
   1562   const result = await page.evaluate(async () => {
   1563     const f = window.ptFixture;
   1564     window.ptAbort!.abort();
   1565     const effect = await window.ptPending;
   1566     const before = f.host.counts(),
   1567       idle = f.idle(),
   1568       selected = await f.captureAction();
   1569     return { effect, idle, refused: !selected, before, after: f.host.counts() };
   1570   });
   1571   expect(result.effect).toMatchObject({ status: 'unknown', attempt: 1 });
   1572   expect(result.idle).toBe(false);
   1573   expect(result.refused).toBe(true);
   1574   expect(result.after).toEqual(result.before);
   1575   expect(events()).toHaveLength(1);
   1576   await page.evaluate(() => {
   1577     window.ptRestore!();
   1578     window.ptFixture.stop();
   1579   });
   1580 });
   1581 
   1582 for (const fault of ['aborted', 'uncertain', 'changed_successor'] as const)
   1583   test(`actual recovered native append ${fault} preserves strict original successor evidence`, async ({
   1584     page
   1585   }) => {
   1586     await recover(page);
   1587     await adopt(page);
   1588     await action(page);
   1589     const result = await page.evaluate(async (fault) => {
   1590       const f = window.ptFixture,
   1591         effect = await f.publish();
   1592       if (!effect) throw Error('actual recovered SDK effect');
   1593       const before = await f.host.stored(),
   1594         control = f.installCommitFault(fault);
   1595       window.ptRestore = control.restore;
   1596       const first = await f.append(effect);
   1597       control.restore();
   1598       const afterFirst = await f.host.stored(),
   1599         second = await f.append(effect);
   1600       return { first, second, before, afterFirst, native: control.counts() };
   1601     }, fault);
   1602     if (fault === 'aborted') {
   1603       expect(result.first.status).toBe('aborted');
   1604       expect(result.afterFirst).toEqual(result.before);
   1605       expect(result.second.status).toBe('saved');
   1606       expect(result.native).toMatchObject({
   1607         putSuccess: 1,
   1608         complete: 0,
   1609         aborted: 1
   1610       });
   1611     } else {
   1612       expect(result.native).toMatchObject({
   1613         putSuccess: 1,
   1614         complete: 1,
   1615         aborted: 0
   1616       });
   1617       expect(result.native.abortRefused).toBeGreaterThan(0);
   1618       if (fault === 'uncertain') {
   1619         expect(result.first.status).toBe('reconciled');
   1620         expect(result.second.status).toBe('existing');
   1621       } else {
   1622         expect(result.native.changed).toBe(1);
   1623         expect(['conflict', 'unknown_completion']).toContain(
   1624           result.first.status
   1625         );
   1626         expect(result.second.status).not.toBe('saved');
   1627       }
   1628     }
   1629     expect(events()).toHaveLength(1);
   1630   });
   1631 
   1632 test('actual recovered effect bookkeeping remains eligible after controller loss without restoring authority', async ({
   1633   page
   1634 }) => {
   1635   await recover(page);
   1636   await adopt(page);
   1637   await action(page);
   1638   const result = await page.evaluate(async () => {
   1639     const f = window.ptFixture,
   1640       effect = await f.publish();
   1641     if (!effect) throw Error('actual recovered accepted effect');
   1642     window.pt.closeInboxAccessController(f.actors().access);
   1643     const before = f.host.counts(),
   1644       appended = await f.append(effect),
   1645       refused = !(await f.captureAction());
   1646     const row = (await f.host.stored()).find((x) => x.id === f.command())!;
   1647     return {
   1648       appended,
   1649       refused,
   1650       before,
   1651       after: f.host.counts(),
   1652       row: JSON.parse(row.wire) as { receipts: { status: string }[] }
   1653     };
   1654   });
   1655   expect(result.appended.status).toBe('saved');
   1656   expect(result.refused).toBe(true);
   1657   expect(result.after).toEqual(result.before);
   1658   expect(result.row.receipts[0].status).toBe('accepted');
   1659   expect(events()).toHaveLength(1);
   1660 });
   1661 
   1662 test('genuine ordinary recovery capability cannot supply original-probe Retry provenance', async ({
   1663   page
   1664 }) => {
   1665   await recover(page);
   1666   const result = await page.evaluate(async () => {
   1667     const f = window.ptFixture,
   1668       a = f.actors(),
   1669       provider = Object.getOwnPropertyDescriptor(window, 'nostr')!;
   1670     const ordinary = await window.pt.makeOrdinaryRecoveryFixture();
   1671     const token = ordinary.capture();
   1672     Object.defineProperty(window, 'nostr', provider);
   1673     const before = f.host.counts(),
   1674       raw = await f.host.stored();
   1675     try {
   1676       const selected = await window.pt.adoptRecoveredInboxProbe(
   1677         f.repository,
   1678         a.session,
   1679         a.access,
   1680         f.host.policy,
   1681         f.host.qualification,
   1682         token as unknown as Parameters<
   1683           typeof window.pt.adoptRecoveredInboxProbe
   1684         >[5],
   1685         'reviewed_original_inbox_probe_retry'
   1686       );
   1687       const action = await window.pt.captureRecoveredInboxProbeRetryAction(
   1688         f.repository,
   1689         a.session,
   1690         f.host.policy,
   1691         token as unknown as Parameters<
   1692           typeof window.pt.captureRecoveredInboxProbeRetryAction
   1693         >[3],
   1694         'reviewed_original_inbox_probe_retry'
   1695       );
   1696       return {
   1697         refused: !('acknowledgement' in selected) && !action,
   1698         before,
   1699         after: f.host.counts(),
   1700         unchanged: JSON.stringify(raw) === JSON.stringify(await f.host.stored())
   1701       };
   1702     } finally {
   1703       ordinary.close();
   1704       Object.defineProperty(window, 'nostr', provider);
   1705     }
   1706   });
   1707   expect(result.refused).toBe(true);
   1708   expect(result.after).toEqual(result.before);
   1709   expect(result.unchanged).toBe(true);
   1710   expect(privateFrames()).toHaveLength(0);
   1711 });