app

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

inbox-probe-cleanup.spec.ts (61840B)


      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-cleanup.ts';
      8 import type { PrivateAccessProbe } from '../../src/lib/persistence/private-records.ts';
      9 declare global {
     10   interface Window {
     11     pc: typeof Fixture;
     12     pcFixture: Awaited<ReturnType<typeof Fixture.makeCleanupFixture>>;
     13     pcPending?: Promise<unknown>;
     14     pcRestore?: () => void;
     15     pcFinishAttempt?: () => Promise<string>;
     16     pcRelease?: () => void;
     17     pcCloseMode?: 'hold' | 'fail';
     18     pcHeldClose?: (() => void)[];
     19     pcCloseCalls?: number;
     20   }
     21 }
     22 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     23   sockets: WebSocketServer,
     24   endpoint: string,
     25   bundle: string,
     26   head = '';
     27 let ackMode: 'accept' | 'refuse' | 'hold' = 'accept';
     28 let holdRead = false,
     29   challenge = false;
     30 const origins = [
     31     'wss://inbox.example.org',
     32     'wss://peer.example.org',
     33     'wss://archive.example.org'
     34   ],
     35   physical = new Set<WebSocket>(),
     36   physicalOrigins = new WeakMap<WebSocket, string>(),
     37   archived = new Map<string, unknown>(),
     38   frames: { origin: string; frame: unknown[] }[] = [];
     39 test.beforeAll(async () => {
     40   server = await createStaticHarness();
     41   sockets = new WebSocketServer({
     42     host: '127.0.0.1',
     43     port: 0,
     44     maxPayload: 65536
     45   });
     46   await once(sockets, 'listening');
     47   const address = sockets.address();
     48   if (!address || typeof address === 'string')
     49     throw Error('actual loopback endpoint');
     50   endpoint = 'ws://127.0.0.1:' + address.port;
     51   sockets.on('connection', (socket, request) => {
     52     physical.add(socket);
     53     socket.on('close', () => physical.delete(socket));
     54     const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
     55       'origin'
     56     )!;
     57     physicalOrigins.set(socket, origin);
     58     if (challenge && origin !== 'wss://discovery.example.org')
     59       socket.send(JSON.stringify(['AUTH', 'c3b-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         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         if (ackMode === 'accept')
     82           archived.set(JSON.stringify([origin, event.id]), event);
     83         if (ackMode !== 'hold')
     84           socket.send(
     85             JSON.stringify([
     86               'OK',
     87               event.id,
     88               ackMode === 'accept',
     89               'controlled refusal'
     90             ])
     91           );
     92       }
     93     });
     94   });
     95   const result = await build({
     96     configFile: false,
     97     logLevel: 'silent',
     98     build: {
     99       write: false,
    100       minify: false,
    101       lib: {
    102         entry: fileURLToPath(
    103           new URL('./harness/inbox-probe-cleanup.ts', import.meta.url)
    104         ),
    105         name: 'pc',
    106         formats: ['iife']
    107       }
    108     }
    109   });
    110   const output = Array.isArray(result) ? result[0] : result;
    111   if (!('output' in output)) throw Error('actual compiled nonce-facts harness');
    112   const chunks = output.output.filter((x) => x.type === 'chunk');
    113   expect(chunks).toHaveLength(1);
    114   bundle = chunks[0].code;
    115 });
    116 test.afterAll(async () => {
    117   for (const socket of sockets.clients) socket.terminate();
    118   await new Promise<void>((resolve) => sockets.close(() => resolve()));
    119   await server.close();
    120 });
    121 test.beforeEach(async ({ page }) => {
    122   await expect.poll(() => physical.size).toBe(0);
    123   ackMode = 'accept';
    124   holdRead = false;
    125   challenge = false;
    126   archived.clear();
    127   frames.length = 0;
    128   head = '';
    129   await page.addInitScript(
    130     ({ endpoint, origins }) => {
    131       const Native = window.WebSocket;
    132       window.WebSocket = class extends Native {
    133         constructor(url: string | URL, protocols?: string | string[]) {
    134           const origin = new URL(String(url)).origin;
    135           if (!['wss://discovery.example.org', ...origins].includes(origin))
    136             throw Error('unapproved fixture origin');
    137           super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
    138         }
    139         override close(code?: number, reason?: string) {
    140           window.pcCloseCalls = (window.pcCloseCalls ?? 0) + 1;
    141           if (window.pcCloseMode === 'fail')
    142             throw Error('actual controlled physical close failure');
    143           if (window.pcCloseMode === 'hold')
    144             (window.pcHeldClose ??= []).push(() => super.close(code, reason));
    145           else super.close(code, reason);
    146         }
    147       };
    148     },
    149     { endpoint, origins }
    150   );
    151   await page.goto(server.url + '/search');
    152   await page.addScriptTag({ content: bundle });
    153   head = await page.evaluate(async (origins) => {
    154     window.pcFixture = await window.pc.makeCleanupFixture();
    155     return window.pcFixture.host.preferenceWire(origins);
    156   }, origins);
    157   await page.evaluate(async () => {
    158     const f = window.pcFixture;
    159     await f.open();
    160     if ((await f.prepareOriginal()).status !== 'prepared')
    161       throw Error('actual original S3/R1');
    162   });
    163 });
    164 test.afterEach(async ({ page }) => {
    165   if (!page.isClosed())
    166     await page.evaluate(async () => {
    167       window.pcRestore?.();
    168       window.pcCloseMode = undefined;
    169       for (const release of window.pcHeldClose ?? []) release();
    170       window.pcRelease?.();
    171       window.pcFixture.host.mode('normal');
    172       window.pcFixture.host.settle();
    173       window.pcFixture.close();
    174       await window.pcPending;
    175     });
    176 });
    177 
    178 async function qualify(page: Page, recovered = false, skip: string[] = []) {
    179   expect(
    180     await page.evaluate(
    181       async ({ recovered, skip }) =>
    182         (await window.pcFixture.qualify(recovered, { skip })).status,
    183       { recovered, skip }
    184     )
    185   ).toBe('saved');
    186 }
    187 async function select(page: Page) {
    188   expect(
    189     await page.evaluate(async () => !!(await window.pcFixture.select()))
    190   ).toBe(true);
    191 }
    192 const traffic = () =>
    193   frames.filter(
    194     (x) =>
    195       x.origin !== 'wss://discovery.example.org' &&
    196       ['EVENT', 'REQ', 'AUTH'].includes(String(x.frame[0]))
    197   );
    198 
    199 for (const recovered of [false, true]) {
    200   test(`${recovered ? 'recovered' : 'current-original'} reviewed genuine cleanup has native completion, fresh absence, exact disposal and independent removal provenance`, async ({
    201     page
    202   }) => {
    203     await qualify(page, recovered);
    204     const before = traffic().length;
    205     const result = await page.evaluate(async (recovered) => {
    206       const f = window.pcFixture,
    207         a = f.actors(),
    208         record = (await f.host.stored())[0],
    209         nonce = f.nonce()!,
    210         proof = f.nonceProof()!,
    211         original = f.originalIdentity(),
    212         oldAck = recovered ? f.acknowledgement()! : f.originalAck()!,
    213         controller = window.pc.inboxAccessConstructionBinding(
    214           a.access,
    215           a.session,
    216           f.host.policy
    217         ),
    218         counts = f.host.counts();
    219       const selected = await f.select();
    220       const capturedCounts = f.host.counts(),
    221         capturedRows = await f.host.stored();
    222       const hook = f.nativeFault('wire_race');
    223       hook.restore();
    224       const removed = await f.remove(),
    225         after = await f.host.stored(),
    226         binding = f.removalBinding(),
    227         nonceBinding = window.pc.inboxProbeNonceAcknowledgementBinding(
    228           f.repository,
    229           a.session,
    230           nonce,
    231           f.host.policy
    232         ),
    233         proofBinding = window.pc.inboxProbeNonceVerificationEvidence(
    234           proof,
    235           f.repository,
    236           a.session,
    237           f.host.policy
    238         ),
    239         oldBinding = recovered
    240           ? window.pc.recoveredInboxProbePublicationBinding(
    241               f.repository,
    242               a.session,
    243               oldAck,
    244               f.host.policy
    245             )
    246           : window.pc.inboxProbePublicationBinding(
    247               f.repository,
    248               a.session,
    249               oldAck,
    250               f.host.policy
    251             );
    252       return {
    253         selected: !!selected,
    254         counts,
    255         capturedCounts,
    256         capturedSame:
    257           capturedRows.length === 1 && capturedRows[0].wire === record.wire,
    258         status: removed.status,
    259         removed: removed.removed,
    260         after: after.length,
    261         nonceCurrent: !!nonceBinding,
    262         proofCurrent: !!proofBinding,
    263         oldAckCurrent: !!oldBinding,
    264         originalNonce: original
    265           ? !!window.pc.inboxProbeRumorWire(original, a.session)
    266           : false,
    267         controller: controller?.current(),
    268         removal: binding?.current(),
    269         command: binding?.command,
    270         expected: record.id,
    271         keys: removed.acknowledgement && Object.keys(removed.acknowledgement),
    272         copy: !!window.pc.inboxProbeRemovalAcknowledgementBinding(
    273           { ...removed.acknowledgement! },
    274           f.repository,
    275           a.session,
    276           f.host.policy
    277         ),
    278         again: (await f.remove()).status,
    279         afterCounts: f.host.counts()
    280       };
    281     }, recovered);
    282     expect(result).toMatchObject({
    283       selected: true,
    284       capturedSame: true,
    285       status: 'removed',
    286       removed: 1,
    287       after: 0,
    288       nonceCurrent: false,
    289       proofCurrent: false,
    290       oldAckCurrent: false,
    291       originalNonce: false,
    292       controller: true,
    293       removal: true,
    294       keys: [],
    295       copy: false,
    296       again: 'invalid'
    297     });
    298     expect(result.command).toBe(result.expected);
    299     expect(result.capturedCounts).toEqual(result.counts);
    300     expect(result.afterCounts).toEqual({
    301       ...result.counts,
    302       keys: result.counts.keys + 1
    303     });
    304     expect(traffic()).toHaveLength(before);
    305     const reads = traffic().filter((x) => x.frame[0] === 'REQ');
    306     expect(new Set(reads.map((x) => x.origin))).toEqual(new Set([origins[0]]));
    307     expect(
    308       traffic()
    309         .filter((x) => x.frame[0] === 'EVENT')
    310         .map((x) => x.origin)
    311         .sort()
    312     ).toEqual(origins.slice().sort());
    313   });
    314 
    315   for (const missing of origins.slice(1))
    316     test(`${recovered ? 'recovered' : 'original'} every archive ACK is required even with genuine nonce on one approved read path: ${missing}`, async ({
    317       page
    318     }) => {
    319       await qualify(page, recovered, [missing]);
    320       const result = await page.evaluate(async () => {
    321         const f = window.pcFixture,
    322           before = await f.host.stored(),
    323           counts = f.host.counts(),
    324           token = await f.select();
    325         return {
    326           selected: !!token,
    327           same:
    328             JSON.stringify(before) === JSON.stringify(await f.host.stored()),
    329           counts,
    330           after: f.host.counts()
    331         };
    332       });
    333       expect(result.selected).toBe(false);
    334       expect(result.same).toBe(true);
    335       expect(result.after).toEqual(result.counts);
    336     });
    337 
    338   for (const held of ['lock', 'SDK'] as const)
    339     test(`${recovered ? 'recovered' : 'original'} genuine cleanup under actual occupied ${held} preserves row and permits fresh explicit selection`, async ({
    340       page
    341     }) => {
    342       await qualify(page, recovered);
    343       await select(page);
    344       const before = traffic().length;
    345       const result = await page.evaluate(async (held) => {
    346         const f = window.pcFixture,
    347           row = JSON.stringify(await f.host.stored()),
    348           counts = f.host.counts();
    349         const denied = await f.withHeld(held, () => f.remove());
    350         const after = f.host.counts(),
    351           same = JSON.stringify(await f.host.stored()) === row;
    352         await f.select();
    353         const later = await f.remove();
    354         return {
    355           denied: denied.status,
    356           later: later.status,
    357           counts,
    358           after,
    359           same
    360         };
    361       }, held);
    362       expect(result).toMatchObject({
    363         denied: 'busy',
    364         later: 'removed',
    365         same: true
    366       });
    367       expect(result.after).toEqual(result.counts);
    368       expect(traffic()).toHaveLength(before);
    369     });
    370 
    371   for (const mode of ['initial_read_abort', 'abort', 'wire_race'] as const)
    372     test(`${recovered ? 'recovered' : 'original'} definite native ${mode} never removes or retires and remains explicitly protected`, async ({
    373       page
    374     }) => {
    375       await qualify(page, recovered);
    376       await select(page);
    377       const result = await page.evaluate(async (mode) => {
    378         const f = window.pcFixture,
    379           before = (await f.host.stored())[0].wire,
    380           hook = f.nativeFault(mode);
    381         try {
    382           const denied = await f.remove();
    383           hook.restore();
    384           const rows = await f.host.stored();
    385           const selected = await f.select();
    386           return {
    387             status: denied.status,
    388             ack: !!denied.acknowledgement,
    389             count: rows.length,
    390             same: rows[0]?.wire === before,
    391             counts: hook.counts(),
    392             selected: !!selected,
    393             next: selected ? (await f.remove()).status : undefined
    394           };
    395         } finally {
    396           hook.restore();
    397         }
    398       }, mode);
    399       expect(result.ack).toBe(false);
    400       expect(result.count).toBe(1);
    401       if (mode === 'wire_race')
    402         expect(result).toMatchObject({
    403           status: 'conflict',
    404           selected: false,
    405           counts: { deletes: 0, races: 1 }
    406         });
    407       else {
    408         expect(result.same).toBe(true);
    409         expect(result.selected).toBe(true);
    410         expect(result.next).toBe('removed');
    411       }
    412       if (mode === 'abort')
    413         expect(result.counts).toMatchObject({
    414           deletes: 1,
    415           completes: 0,
    416           aborts: 1
    417         });
    418     });
    419 
    420   for (const mode of ['uncertain', 'read_before', 'read_after'] as const)
    421     test(`${recovered ? 'recovered' : 'original'} native ${mode} keeps conservative lease and never invents removal provenance`, async ({
    422       page
    423     }) => {
    424       await qualify(page, recovered);
    425       await select(page);
    426       const result = await page.evaluate(
    427         async ({ mode, recovered }) => {
    428           const f = window.pcFixture,
    429             a = f.actors(),
    430             ack = recovered ? f.acknowledgement()! : f.originalAck()!,
    431             action = recovered
    432               ? f.action()!
    433               : window.pc.captureInboxProbePublicationAction(
    434                   f.repository,
    435                   a.session,
    436                   f.host.policy,
    437                   ack,
    438                   'reviewed_inbox_probe_network'
    439                 )!,
    440             hook = f.nativeFault(mode);
    441           try {
    442             const removed = await f.remove();
    443             hook.restore();
    444             const rows = (await f.host.stored()).length;
    445             return {
    446               status: removed.status,
    447               ack: !!removed.acknowledgement,
    448               counts: hook.counts(),
    449               rows,
    450               binding: !!f.removalBinding(),
    451               permission: !!window.pc.captureInboxProbePublication(
    452                 f.repository,
    453                 a.session,
    454                 f.host.policy,
    455                 ack,
    456                 action,
    457                 originsForBrowser()[0],
    458                 'reviewed_inbox_probe_publication'
    459               )
    460             };
    461           } finally {
    462             hook.restore();
    463           }
    464           function originsForBrowser() {
    465             return ['wss://inbox.example.org'];
    466           }
    467         },
    468         { mode, recovered }
    469       );
    470       expect(result).toMatchObject({
    471         status: 'unknown_completion',
    472         ack: false,
    473         rows: 0,
    474         binding: false,
    475         permission: false,
    476         counts: { deletes: 1, completes: 1 }
    477       });
    478       if (mode === 'uncertain')
    479         expect(result.counts.refused).toBeGreaterThan(0);
    480     });
    481 
    482   for (const mode of [
    483     'read_loss',
    484     'native_pre_delete_loss',
    485     'delete_loss',
    486     'complete_loss'
    487   ] as const)
    488     test(`${recovered ? 'recovered' : 'original'} Stop at actual ${mode} cannot mint current removal or resurrect nonce authority`, async ({
    489       page
    490     }) => {
    491       await qualify(page, recovered);
    492       await select(page);
    493       const result = await page.evaluate(async (mode) => {
    494         const f = window.pcFixture,
    495           hook = f.nativeFault(mode, () => f.stopCleanup());
    496         try {
    497           const removed = await f.remove();
    498           hook.restore();
    499           const rows = (await f.host.stored()).length;
    500           return {
    501             status: removed.status,
    502             ack: !!removed.acknowledgement,
    503             counts: hook.counts(),
    504             rows,
    505             removedBinding: !!f.removalBinding()
    506           };
    507         } finally {
    508           hook.restore();
    509         }
    510       }, mode);
    511       expect(result.ack).toBe(false);
    512       expect(result.removedBinding).toBe(false);
    513       if (mode === 'read_loss' || mode === 'native_pre_delete_loss') {
    514         expect(result.counts.deletes).toBe(0);
    515         expect(result.rows).toBe(1);
    516       } else if (mode === 'complete_loss') {
    517         expect(result).toMatchObject({
    518           status: 'unknown_completion',
    519           rows: 0,
    520           counts: { deletes: 1, completes: 1 }
    521         });
    522       } else
    523         expect(result).toMatchObject({
    524           rows: 1,
    525           counts: { deletes: 1, aborts: 1 }
    526         });
    527     });
    528 
    529   for (const loss of ['head', 'controller', 'session'] as const)
    530     test(`${recovered ? 'recovered' : 'original'} actual ${loss} loss after capture prevents deletion`, async ({
    531       page
    532     }) => {
    533       await qualify(page, recovered);
    534       await select(page);
    535       const result = await page.evaluate(async (loss) => {
    536         const f = window.pcFixture;
    537         if (loss === 'head') f.actors().churnHead();
    538         else if (loss === 'controller') f.stop();
    539         else window.pc.closePrivateSession(f.actors().session);
    540         const removed = await f.remove();
    541         return {
    542           status: removed.status,
    543           rows: (await f.host.stored()).length,
    544           ack: !!removed.acknowledgement
    545         };
    546       }, loss);
    547       expect(result).toEqual({ status: 'stopped', rows: 1, ack: false });
    548     });
    549 
    550   test(`${recovered ? 'recovered' : 'original'} exact command lease fences a previously captured permission and new capture before native deletion`, async ({
    551     page
    552   }) => {
    553     await qualify(page, recovered);
    554     await select(page);
    555     const before = traffic().length;
    556     const result = await page.evaluate(async (recovered) => {
    557       const f = window.pcFixture,
    558         a = f.actors(),
    559         ack = recovered ? f.acknowledgement()! : f.originalAck()!,
    560         action = recovered
    561           ? f.action()!
    562           : window.pc.captureInboxProbePublicationAction(
    563               f.repository,
    564               a.session,
    565               f.host.policy,
    566               ack,
    567               'reviewed_inbox_probe_network'
    568             )!,
    569         permission = window.pc.captureInboxProbePublication(
    570           f.repository,
    571           a.session,
    572           f.host.policy,
    573           ack,
    574           action,
    575           'wss://peer.example.org',
    576           'reviewed_inbox_probe_publication'
    577         )!;
    578       const before = !!window.pc.inboxProbePublicationSnapshot(permission),
    579         counts = f.host.counts();
    580       let during = true,
    581         newPermission = true,
    582         pending: Promise<unknown> | undefined;
    583       const hook = f.nativeFault('read_loss', () => {
    584         during = !!window.pc.inboxProbePublicationSnapshot(permission);
    585         newPermission = !!window.pc.captureInboxProbePublication(
    586           f.repository,
    587           a.session,
    588           f.host.policy,
    589           ack,
    590           action,
    591           'wss://peer.example.org',
    592           'reviewed_inbox_probe_publication'
    593         );
    594         pending = window.pc.publishInboxProbeArchiveAttempt(
    595           f.pool()!,
    596           permission,
    597           new AbortController().signal
    598         );
    599       });
    600       try {
    601         const removed = await f.remove();
    602         return {
    603           before,
    604           during,
    605           newPermission,
    606           status: removed.status,
    607           attempt: await pending,
    608           counts,
    609           after: f.host.counts(),
    610           afterPermission: !!window.pc.inboxProbePublicationSnapshot(permission)
    611         };
    612       } finally {
    613         hook.restore();
    614       }
    615     }, recovered);
    616     expect(result).toMatchObject({
    617       before: true,
    618       during: false,
    619       newPermission: false,
    620       status: 'removed',
    621       attempt: { status: 'stopped' },
    622       afterPermission: false
    623     });
    624     expect(result.after).toEqual({
    625       ...result.counts,
    626       keys: result.counts.keys + 1
    627     });
    628     expect(traffic()).toHaveLength(before);
    629   });
    630 }
    631 
    632 test('same actual C7 original and recovered actions share retirement and clear both genuine source identities without closing C7', async ({
    633   page
    634 }) => {
    635   await qualify(page, false);
    636   const result = await page.evaluate(async () => {
    637     const f = window.pcFixture,
    638       a = f.actors(),
    639       original = f.originalIdentity()!,
    640       ack = f.originalAck()!,
    641       proof = f.nonceProof()!;
    642     // A fresh recovered reader on the SAME controller/session, not teardown.
    643     const current = a.access;
    644     // Inbox already used archive+read; the shared three-attempt budget leaves
    645     // the second exact read on peer, which has only two archive attempts.
    646     await f.qualify(true, {
    647       fresh: false,
    648       readOrigin: 'wss://peer.example.org'
    649     });
    650     const same =
    651       f.actors().access === current && f.actors().session === a.session;
    652     await f.select();
    653     const removed = await f.remove();
    654     return {
    655       same,
    656       status: removed.status,
    657       originalNonce: !!window.pc.inboxProbeRumorWire(original, a.session),
    658       originalAck: !!window.pc.inboxProbePublicationBinding(
    659         f.repository,
    660         a.session,
    661         ack,
    662         f.host.policy
    663       ),
    664       originalProof: !!window.pc.inboxProbeNonceVerificationEvidence(
    665         proof,
    666         f.repository,
    667         a.session,
    668         f.host.policy
    669       ),
    670       recovered: !!f.recoveredBinding(),
    671       controller: !!window.pc.inboxAccessConstructionBinding(
    672         current,
    673         a.session,
    674         f.host.policy
    675       ),
    676       removal: f.removalBinding()?.current()
    677     };
    678   });
    679   expect(result).toEqual({
    680     same: true,
    681     status: 'removed',
    682     originalNonce: false,
    683     originalAck: false,
    684     originalProof: false,
    685     recovered: false,
    686     controller: true,
    687     removal: true
    688   });
    689 });
    690 
    691 test('100 genuine rows and command slots regain 101st admission only through actual cleanup in the SAME private session', async ({
    692   page
    693 }) => {
    694   const result = await page.evaluate(async () => {
    695     const f = window.pcFixture,
    696       full = await f.capacity();
    697     if (full.denied.status !== 'capacity')
    698       throw Error('actual native 101st admission must refuse at100');
    699     await f.qualify(true, { fresh: false });
    700     await f.select();
    701     const removed = await f.remove(),
    702       selected = f.command()!,
    703       after = await f.host.stored();
    704     const preserved =
    705       after.length === 99 &&
    706       after.every((row) => row.wire === full.originals.get(row.id)) &&
    707       !after.some((row) => row.id === selected);
    708     await f.replaceController();
    709     const next = await f.prepareOriginal();
    710     const action =
    711       'acknowledgement' in next &&
    712       window.pc.captureInboxProbePublicationAction(
    713         f.repository,
    714         f.actors().session,
    715         f.host.policy,
    716         next.acknowledgement,
    717         'reviewed_inbox_probe_network'
    718       );
    719     return {
    720       denied: full.denied.status,
    721       removed: removed.status,
    722       preserved,
    723       next: next.status,
    724       action: !!action,
    725       sameSession: f.actors().session === full.session,
    726       rows: (await f.host.stored()).length
    727     };
    728   });
    729   expect(result).toEqual({
    730     denied: 'capacity',
    731     removed: 'removed',
    732     preserved: true,
    733     next: 'prepared',
    734     action: true,
    735     sameSession: true,
    736     rows: 100
    737   });
    738 });
    739 
    740 for (const recovered of [false, true]) {
    741   test(`${recovered ? 'recovered' : 'original'} copied and wrong actual issuer scopes cannot capture cleanup or native removal authority`, async ({
    742     page
    743   }) => {
    744     await qualify(page, recovered);
    745     const result = await page.evaluate(async () => {
    746       const f = window.pcFixture,
    747         a = f.actors(),
    748         opened = await window.pc.openBrowserDatabase();
    749       if (opened.state !== 'ready')
    750         throw Error('actual second repository scope');
    751       const second = window.pc.createPrivateStorageRepository(
    752           opened.owner,
    753           f.host.owner
    754         )!,
    755         foreign = f.host.foreignRepository(),
    756         policy = f.host.copiedPolicy(),
    757         observations = f.observations(),
    758         nonce = f.nonce()!,
    759         before = await f.host.stored(),
    760         counts = f.host.counts();
    761       const transaction = Object.getOwnPropertyDescriptor(
    762         IDBDatabase.prototype,
    763         'transaction'
    764       )!.value as IDBDatabase['transaction'];
    765       let native = 0;
    766       IDBDatabase.prototype.transaction = function (
    767         ...args: Parameters<IDBDatabase['transaction']>
    768       ) {
    769         native++;
    770         return transaction.apply(this, args);
    771       };
    772       try {
    773         const candidates = [
    774           [f.repository, a.session, f.host.policy, { ...nonce }, observations],
    775           [
    776             f.repository,
    777             a.session,
    778             f.host.policy,
    779             nonce,
    780             observations.map((x) => ({ ...x }))
    781           ],
    782           [f.repository, a.session, f.host.policy, nonce, []],
    783           [second, a.session, f.host.policy, nonce, observations],
    784           [foreign, a.session, f.host.policy, nonce, observations],
    785           [f.repository, a.session, policy, nonce, observations],
    786           [
    787             f.repository,
    788             {} as typeof a.session,
    789             f.host.policy,
    790             nonce,
    791             observations
    792           ]
    793         ] as const;
    794         const admitted = [];
    795         for (const [repo, session, selectedPolicy, ack, effects] of candidates)
    796           admitted.push(
    797             !!(await window.pc.captureInboxProbeCleanup(
    798               repo,
    799               session,
    800               selectedPolicy,
    801               ack,
    802               effects,
    803               'reviewed_inbox_probe_cleanup_selection'
    804             ))
    805           );
    806         const nativeResult = await window.pc.removePrivateInboxProbe(
    807           f.repository,
    808           a.session,
    809           nonce as unknown as Parameters<
    810             typeof window.pc.removePrivateInboxProbe
    811           >[2]
    812         );
    813         return {
    814           admitted,
    815           native,
    816           nativeResult,
    817           counts,
    818           after: f.host.counts(),
    819           rows: before.length
    820         };
    821       } finally {
    822         IDBDatabase.prototype.transaction = transaction;
    823         window.pc.closeBrowserDatabase(opened.owner);
    824       }
    825     });
    826     expect(result.admitted).toEqual(Array(7).fill(false));
    827     expect(result.native).toBe(0);
    828     expect(result.nativeResult).toEqual({
    829       ok: false,
    830       reason: 'invalid_scope',
    831       disposition: 'not_removed'
    832     });
    833     expect(result.after).toEqual(result.counts);
    834     expect(result.rows).toBe(1);
    835   });
    836 
    837   test(`${recovered ? 'recovered' : 'original'} fully qualified probe remains protected from ordinary settled-send cleanup`, async ({
    838     page
    839   }) => {
    840     await qualify(page, recovered);
    841     const result = await page.evaluate(async () => {
    842       const f = window.pcFixture,
    843         a = f.actors(),
    844         row = (await f.host.stored())[0],
    845         record = JSON.parse(row.wire) as PrivateAccessProbe;
    846       const ordinary = await window.pc.capturePrivateOutboxCleanup(
    847         f.repository,
    848         a.session,
    849         [row.id],
    850         'reviewed_settled_outbox_selection'
    851       );
    852       return {
    853         settlement: window.pc.privateRecordSettlement(record),
    854         ordinary: !!ordinary,
    855         same: (await f.host.stored())[0].wire === row.wire
    856       };
    857     });
    858     expect(result).toEqual({
    859       settlement: 'protected',
    860       ordinary: false,
    861       same: true
    862     });
    863   });
    864 
    865   for (const mode of [
    866     'alias',
    867     'corrupt_tail',
    868     'missing',
    869     'foreign_tail'
    870   ] as const)
    871     test(`${recovered ? 'recovered' : 'original'} complete namespace ${mode} preserves exact native and authority boundaries`, async ({
    872       page
    873     }) => {
    874       await qualify(page, recovered);
    875       await select(page);
    876       const result = await page.evaluate(async (mode) => {
    877         const f = window.pcFixture,
    878           original = (await f.host.stored())[0];
    879         let foreign: typeof original | undefined;
    880         if (mode === 'missing') await f.removeFixtureRow();
    881         else {
    882           const owner =
    883             mode === 'foreign_tail' ? 'f'.repeat(64) : original.owner;
    884           const row = {
    885             owner,
    886             id: crypto.randomUUID(),
    887             wire: mode === 'alias' ? original.wire : '{}'
    888           };
    889           if (mode === 'foreign_tail') foreign = row;
    890           await f.host.inject([row]);
    891         }
    892         const removed = await f.remove(),
    893           rows = await f.host.stored();
    894         return {
    895           status: removed.status,
    896           ack: !!removed.acknowledgement,
    897           rows: rows.length,
    898           original: rows.some(
    899             (x) => x.id === original.id && x.wire === original.wire
    900           ),
    901           foreign: foreign
    902             ? rows.some((x) => JSON.stringify(x) === JSON.stringify(foreign))
    903             : false
    904         };
    905       }, mode);
    906       if (mode === 'foreign_tail')
    907         expect(result).toMatchObject({
    908           status: 'removed',
    909           ack: true,
    910           rows: 1,
    911           original: false,
    912           foreign: true
    913         });
    914       else if (mode === 'missing')
    915         expect(result).toMatchObject({ ack: false, rows: 0, original: false });
    916       else
    917         expect(result).toMatchObject({
    918           status: 'corrupt_record',
    919           ack: false,
    920           rows: 2,
    921           original: true
    922         });
    923     });
    924 
    925   test(`${recovered ? 'recovered' : 'original'} current removal provenance follows actual head loss after deliberate nonce disposal`, async ({
    926     page
    927   }) => {
    928     await qualify(page, recovered);
    929     await select(page);
    930     const result = await page.evaluate(async () => {
    931       const f = window.pcFixture,
    932         removed = await f.remove(),
    933         before = !!f.removalBinding();
    934       f.actors().churnHead();
    935       return { status: removed.status, before, after: !!f.removalBinding() };
    936     });
    937     expect(result).toEqual({ status: 'removed', before: true, after: false });
    938   });
    939 }
    940 
    941 for (const failure of ['refused', 'unknown', 'stopped', 'timed_out'] as const)
    942   test(`actual ${failure} archive history needs later genuine same-origin event acceptance before reviewed cleanup`, async ({
    943     page
    944   }) => {
    945     ackMode =
    946       failure === 'refused'
    947         ? 'refuse'
    948         : failure === 'unknown'
    949           ? 'accept'
    950           : 'hold';
    951     await page.evaluate((failure) => {
    952       const f = window.pcFixture,
    953         controller = new AbortController(),
    954         fault =
    955           failure === 'unknown' ? f.installAttemptTeardownFailure() : undefined,
    956         clock = failure === 'timed_out' ? f.installNetworkClock() : undefined;
    957       window.pcRestore = () => {
    958         fault?.restore();
    959         clock?.restore();
    960         controller.abort();
    961       };
    962       const pending = f.originalPublish(
    963         'wss://peer.example.org',
    964         controller.signal
    965       );
    966       window.pcFinishAttempt = async () => {
    967         if (failure === 'stopped') controller.abort();
    968         if (failure === 'timed_out') clock!.advance(45000);
    969         const result = await pending;
    970         clock?.restore();
    971         fault?.restore();
    972         if (!result) throw Error('actual original negative archive result');
    973         const saved = await f.append(result);
    974         if (saved.status !== 'saved')
    975           throw Error('actual negative native history ' + saved.status);
    976         return result.status;
    977       };
    978     }, failure);
    979     await expect
    980       .poll(() => traffic().filter((x) => x.frame[0] === 'EVENT').length)
    981       .toBe(1);
    982     expect(await page.evaluate(() => window.pcFinishAttempt!())).toBe(failure);
    983     ackMode = 'accept';
    984     const result = await page.evaluate(async (failure) => {
    985       const f = window.pcFixture,
    986         session = f.actors().session;
    987       await f.replaceController();
    988       await f.qualify(true, { fresh: false });
    989       const record = JSON.parse((await f.host.stored())[0].wire) as {
    990           receipts: {
    991             status: string;
    992             origin: string;
    993             role: string;
    994             eventId: string;
    995           }[];
    996         },
    997         negative = record.receipts.findIndex((x) => x.status === failure),
    998         first = record.receipts[negative],
    999         positive = record.receipts.findIndex(
   1000           (x, i) =>
   1001             i > negative &&
   1002             x.status === 'accepted' &&
   1003             x.origin === first.origin &&
   1004             x.role === first.role &&
   1005             x.eventId === first.eventId
   1006         );
   1007       const selected = await f.select(),
   1008         removed = await f.remove();
   1009       return {
   1010         sameSession: f.actors().session === session,
   1011         negative,
   1012         positive,
   1013         selected: !!selected,
   1014         status: removed.status
   1015       };
   1016     }, failure);
   1017     expect(result.negative).toBeGreaterThanOrEqual(0);
   1018     expect(result.positive).toBeGreaterThan(result.negative);
   1019     expect(result).toMatchObject({
   1020       sameSession: true,
   1021       selected: true,
   1022       status: 'removed'
   1023     });
   1024   });
   1025 
   1026 test('earlier genuine positive and later readback cannot resolve a subsequent refused archive for the same origin', async ({
   1027   page
   1028 }) => {
   1029   await qualify(page, false);
   1030   ackMode = 'refuse';
   1031   expect(
   1032     await page.evaluate(async () => {
   1033       const f = window.pcFixture,
   1034         result = await f.originalPublish('wss://peer.example.org');
   1035       if (!result || result.status !== 'refused')
   1036         throw Error('actual refused later publication');
   1037       return (await f.append(result)).status;
   1038     })
   1039   ).toBe('saved');
   1040   ackMode = 'accept';
   1041   const result = await page.evaluate(async () => {
   1042     const f = window.pcFixture,
   1043       observations = f.observations(),
   1044       read = await f.originalRead('wss://peer.example.org');
   1045     if (
   1046       !read ||
   1047       read.status !== 'readback' ||
   1048       (await f.appendRead(read)).status !== 'saved'
   1049     )
   1050       throw Error('actual different-role later read');
   1051     const earlier = await f.select(),
   1052       otherRole = await f.select('reviewed_inbox_probe_cleanup_selection', [
   1053         ...observations,
   1054         read
   1055       ]);
   1056     return {
   1057       earlier: !!earlier,
   1058       otherRole: !!otherRole,
   1059       rows: (await f.host.stored()).length
   1060     };
   1061   });
   1062   expect(result).toEqual({ earlier: false, otherRole: false, rows: 1 });
   1063 });
   1064 
   1065 test('unapplied later actual archive result blocks cleanup of an otherwise genuine current qualified probe', async ({
   1066   page
   1067 }) => {
   1068   await qualify(page, false);
   1069   await select(page);
   1070   ackMode = 'refuse';
   1071   expect(
   1072     await page.evaluate(async () => {
   1073       const f = window.pcFixture,
   1074         result = await f.originalPublish('wss://peer.example.org');
   1075       if (!result || result.status !== 'refused')
   1076         throw Error('actual later negative result');
   1077       // Deliberately do not commit this actual settled attempt to the journal.
   1078       const current = !!window.pc.inboxProbeNonceAcknowledgementBinding(
   1079           f.repository,
   1080           f.actors().session,
   1081           f.nonce()!,
   1082           f.host.policy
   1083         ),
   1084         idle = f.idle(),
   1085         before = f.host.counts(),
   1086         removed = await f.remove();
   1087       if (JSON.stringify(before) !== JSON.stringify(f.host.counts()))
   1088         throw Error('pending preflight must precede every provider request');
   1089       return {
   1090         current,
   1091         idle,
   1092         status: removed.status,
   1093         ack: !!removed.acknowledgement,
   1094         rows: (await f.host.stored()).length
   1095       };
   1096     })
   1097   ).toEqual({ current: true, idle: true, status: 'busy', ack: false, rows: 1 });
   1098 });
   1099 
   1100 test('unapplied archive survives genuine ended-controller replacement and failed or forged native bookkeeping', async ({
   1101   page
   1102 }) => {
   1103   await qualify(page);
   1104   await select(page);
   1105   ackMode = 'refuse';
   1106   const result = await page.evaluate(async () => {
   1107     const f = window.pcFixture,
   1108       a = f.actors(),
   1109       actual = await f.originalPublish('wss://peer.example.org');
   1110     if (!actual || actual.status !== 'refused') throw Error('actual negative');
   1111     const forged = await f.append({ ...actual }),
   1112       hook = f.nativeFault('initial_read_abort');
   1113     const failed = await f.append(actual);
   1114     hook.restore();
   1115     const before = f.host.counts(),
   1116       denied = await f.remove(),
   1117       after = f.host.counts();
   1118     await f.replaceController();
   1119     if (
   1120       (await f.recover())?.status !== 'recovered' ||
   1121       (await f.adopt()).status !== 'adopted'
   1122     )
   1123       throw Error('genuine same-session recovery');
   1124     const genuine = !!window.pc.recoveredInboxProbePublicationBinding(
   1125       f.repository,
   1126       a.session,
   1127       f.acknowledgement()!,
   1128       f.host.policy
   1129     );
   1130     let uuids = 0;
   1131     const original = Object.getOwnPropertyDescriptor(
   1132       Crypto.prototype,
   1133       'randomUUID'
   1134     )!.value as Crypto['randomUUID'];
   1135     crypto.randomUUID = () => {
   1136       uuids++;
   1137       return original.call(crypto);
   1138     };
   1139     let replaced: boolean;
   1140     try {
   1141       replaced = !!(await f.captureAction());
   1142     } finally {
   1143       crypto.randomUUID = original;
   1144     }
   1145     // Historical genuine native bookkeeping may settle after its controller.
   1146     const applied = await f.append(actual),
   1147       existing = await f.append(actual);
   1148     return {
   1149       forged: forged.status,
   1150       failed: failed.status,
   1151       denied: denied.status,
   1152       before,
   1153       after,
   1154       genuine,
   1155       replaced,
   1156       uuids,
   1157       applied: applied.status,
   1158       existing: existing.status,
   1159       sameSession: a.session === f.actors().session,
   1160       rows: (await f.host.stored()).length
   1161     };
   1162   });
   1163   expect(result).toMatchObject({
   1164     forged: 'invalid',
   1165     denied: 'busy',
   1166     genuine: true,
   1167     replaced: false,
   1168     uuids: 0,
   1169     applied: 'saved',
   1170     existing: 'existing',
   1171     sameSession: true,
   1172     rows: 1
   1173   });
   1174   expect(['saved', 'existing', 'reconciled']).not.toContain(result.failed);
   1175   expect(result.after).toEqual(result.before);
   1176 });
   1177 
   1178 for (const recovered of [false, true]) {
   1179   for (const lane of ['EVENT', 'REQ', 'page', 'live', 'AUTH'] as const)
   1180     test(`${recovered ? 'recovered' : 'original'} genuinely qualified cleanup refuses actual active ${lane} before provider or native removal`, async ({
   1181       page
   1182     }) => {
   1183       await qualify(page, recovered);
   1184       await select(page);
   1185       if (lane === 'EVENT') ackMode = 'hold';
   1186       if (lane === 'REQ' || lane === 'page' || lane === 'live') holdRead = true;
   1187       if (lane === 'AUTH') {
   1188         challenge = true;
   1189         const started = await page.evaluate(async () => {
   1190           const f = window.pcFixture;
   1191           const result = await window.pc.authenticateInboxAccess(
   1192             f.actors().access,
   1193             'wss://inbox.example.org',
   1194             'reviewed_inbox_connection_auth'
   1195           );
   1196           return {
   1197             result,
   1198             snapshot: window.pc.inboxAccessControllerSnapshot(f.actors().access)
   1199           };
   1200         });
   1201         console.info(
   1202           JSON.stringify({
   1203             fixture: 'C3B_ACTUAL_AUTH_START',
   1204             recovered,
   1205             started
   1206           })
   1207         );
   1208         expect(['waiting', 'challenge']).toContain(started.result);
   1209         // Qualification may already own an open SDK connection. Deliver the
   1210         // genuine relay challenge on that exact existing physical connection.
   1211         for (const socket of physical)
   1212           if (physicalOrigins.get(socket) === 'wss://inbox.example.org')
   1213             socket.send(JSON.stringify(['AUTH', 'c3b-source-challenge']));
   1214         await expect
   1215           .poll(() =>
   1216             page.evaluate(
   1217               () =>
   1218                 window.pc.inboxAccessControllerSnapshot(
   1219                   window.pcFixture.actors().access
   1220                 )?.auth[0]?.state
   1221             )
   1222           )
   1223           .toBe('challenge');
   1224       }
   1225       const trafficBefore = traffic().length;
   1226       await page.evaluate(
   1227         ({ lane, recovered }) => {
   1228           const f = window.pcFixture,
   1229             a = f.actors();
   1230           if (lane === 'EVENT')
   1231             window.pcPending = recovered
   1232               ? f.publish('wss://peer.example.org')
   1233               : f.originalPublish('wss://peer.example.org');
   1234           else if (lane === 'REQ')
   1235             window.pcPending = recovered
   1236               ? f.read('wss://peer.example.org')
   1237               : f.originalRead('wss://peer.example.org');
   1238           else if (lane === 'AUTH')
   1239             window.pcPending = window.pc.respondInboxAccessAuthentication(
   1240               a.access,
   1241               'wss://inbox.example.org',
   1242               'reviewed_inbox_auth_response'
   1243             );
   1244           else {
   1245             const pool = window.pc.getPrivatePool(
   1246               a.session,
   1247               f.host.policy,
   1248               ['wss://inbox.example.org'],
   1249               Object.freeze({}),
   1250               'receive'
   1251             );
   1252             if (!pool) throw Error('actual foreground consumer');
   1253             const stop =
   1254               lane === 'page'
   1255                 ? window.pc.subscribePrivatePage(pool, 1, () => {})
   1256                 : window.pc.subscribePrivateLive(pool, () => {});
   1257             window.pcRelease = () => {
   1258               stop();
   1259               window.pc.closePrivatePool(pool);
   1260             };
   1261           }
   1262         },
   1263         { lane, recovered }
   1264       );
   1265       await expect.poll(() => traffic().length).toBeGreaterThan(trafficBefore);
   1266       const framesBefore = frames.slice();
   1267       const result = await page.evaluate(async () => {
   1268         const f = window.pcFixture,
   1269           a = f.actors(),
   1270           current = !!window.pc.inboxProbeNonceAcknowledgementBinding(
   1271             f.repository,
   1272             a.session,
   1273             f.nonce()!,
   1274             f.host.policy
   1275           ),
   1276           before = f.host.counts(),
   1277           hook = f.nativeFault('abort'),
   1278           idle = f.idle();
   1279         try {
   1280           const removed = await f.remove();
   1281           return {
   1282             current,
   1283             idle,
   1284             controllerBusy: window.pc.inboxAccessControllerSnapshot(a.access)
   1285               ?.busy,
   1286             before,
   1287             after: f.host.counts(),
   1288             status: removed.status,
   1289             ack: !!removed.acknowledgement,
   1290             deletes: hook.counts().deletes,
   1291             rows: (await f.host.stored()).length
   1292           };
   1293         } finally {
   1294           hook.restore();
   1295         }
   1296       });
   1297       expect(result).toMatchObject({
   1298         current: true,
   1299         // AUTH occupies the actual C7/shared SDK job; the pool's independent
   1300         // network-idle observation intentionally remains true for this lane.
   1301         idle: lane === 'AUTH',
   1302         controllerBusy: lane === 'AUTH',
   1303         status: 'busy',
   1304         ack: false,
   1305         deletes: 0,
   1306         rows: 1
   1307       });
   1308       expect(result.after).toEqual(result.before);
   1309       expect(frames).toEqual(framesBefore);
   1310       // Release only this fixture's owned operation after the refusal check.
   1311       if (lane === 'EVENT' || lane === 'AUTH') {
   1312         const frame = traffic().findLast((x) => x.frame[0] === lane)
   1313           ?.frame[1] as { id: string };
   1314         for (const socket of physical)
   1315           socket.send(JSON.stringify(['OK', frame.id, true, '']));
   1316       } else if (lane === 'REQ') {
   1317         for (const item of traffic()
   1318           .slice(trafficBefore)
   1319           .filter((x) => x.frame[0] === 'REQ'))
   1320           for (const socket of physical)
   1321             socket.send(JSON.stringify(['EOSE', item.frame[1]]));
   1322       } else
   1323         await page.evaluate(() => {
   1324           window.pcRelease!();
   1325           window.pcRelease = undefined;
   1326         });
   1327       await page.evaluate(() => window.pcPending);
   1328     });
   1329 
   1330   for (const mode of ['hold', 'fail'] as const)
   1331     test(`${recovered ? 'recovered' : 'original'} genuine cleanup preserves actual ${mode} physical close and never retries it implicitly`, async ({
   1332       page
   1333     }) => {
   1334       await qualify(page, recovered);
   1335       await select(page);
   1336       await page.evaluate(async () => {
   1337         const f = window.pcFixture,
   1338           pool = window.pc.getPrivatePool(
   1339             f.actors().session,
   1340             f.host.policy,
   1341             ['wss://inbox.example.org'],
   1342             Object.freeze({}),
   1343             'receive'
   1344           );
   1345         if (!pool) throw Error('actual receive owner');
   1346         const auth = await window.pc.beginInboxAuthentication(
   1347           pool,
   1348           'wss://inbox.example.org',
   1349           'reviewed_connection_auth'
   1350         );
   1351         if (!auth) throw Error('actual independently owned AUTH connection');
   1352         window.pcRelease = () => {
   1353           window.pc.closeInboxAuthentication(auth);
   1354           window.pc.closePrivatePool(pool);
   1355         };
   1356       });
   1357       await expect
   1358         .poll(() =>
   1359           [...physical].some(
   1360             (socket) =>
   1361               physicalOrigins.get(socket) === 'wss://inbox.example.org'
   1362           )
   1363         )
   1364         .toBe(true);
   1365       const result = await page.evaluate(async (mode) => {
   1366         const f = window.pcFixture;
   1367         window.pcCloseMode = mode;
   1368         let failed = false;
   1369         try {
   1370           window.pcRelease!();
   1371         } catch {
   1372           failed = true;
   1373         }
   1374         const current = !!window.pc.inboxProbeNonceAcknowledgementBinding(
   1375             f.repository,
   1376             f.actors().session,
   1377             f.nonce()!,
   1378             f.host.policy
   1379           ),
   1380           idle = f.idle(),
   1381           before = f.host.counts(),
   1382           closes = window.pcCloseCalls ?? 0,
   1383           held = window.pcHeldClose?.length ?? 0;
   1384         const removed = await f.remove();
   1385         return {
   1386           current,
   1387           idle,
   1388           failed,
   1389           before,
   1390           after: f.host.counts(),
   1391           closes,
   1392           afterCloses: window.pcCloseCalls ?? 0,
   1393           held,
   1394           afterHeld: window.pcHeldClose?.length ?? 0,
   1395           status: removed.status,
   1396           rows: (await f.host.stored()).length,
   1397           ack: !!removed.acknowledgement
   1398         };
   1399       }, mode);
   1400       expect(result).toMatchObject({
   1401         current: true,
   1402         idle: false,
   1403         status: 'busy',
   1404         rows: 1,
   1405         ack: false
   1406       });
   1407       expect(result.after).toEqual(result.before);
   1408       expect(result.afterCloses).toBe(result.closes);
   1409       expect(result.afterHeld).toBe(result.held);
   1410       if (mode === 'fail') expect(result.failed).toBe(true);
   1411       else expect(result.held).toBeGreaterThan(0);
   1412       await page.evaluate(() => {
   1413         window.pcCloseMode = undefined;
   1414         for (const release of window.pcHeldClose ?? []) release();
   1415         try {
   1416           window.pcRelease!();
   1417         } catch (e) {
   1418           if (
   1419             !(e instanceof Error) ||
   1420             ![
   1421               'private_pool_close_pending',
   1422               'private_pool_close_failed'
   1423             ].includes(e.message)
   1424           )
   1425             throw e;
   1426         }
   1427       });
   1428       await expect
   1429         .poll(() => page.evaluate(() => window.pcFixture.idle()))
   1430         .toBe(true);
   1431       expect(
   1432         await page.evaluate(async () => {
   1433           await window.pcFixture.select();
   1434           return (await window.pcFixture.remove()).status;
   1435         })
   1436       ).toBe('removed');
   1437     });
   1438 
   1439   for (const loss of ['head', 'controller', 'session'] as const)
   1440     for (const at of ['delete_loss', 'complete_loss'] as const)
   1441       test(`${recovered ? 'recovered' : 'original'} actual ${loss} loss at native ${at} refuses current removal provenance`, async ({
   1442         page
   1443       }) => {
   1444         await qualify(page, recovered);
   1445         await select(page);
   1446         const result = await page.evaluate(
   1447           async ({ loss, at }) => {
   1448             const f = window.pcFixture,
   1449               hook = f.nativeFault(at, () => {
   1450                 if (loss === 'head') f.actors().churnHead();
   1451                 else if (loss === 'controller') f.stop();
   1452                 else window.pc.closePrivateSession(f.actors().session);
   1453               });
   1454             try {
   1455               const removed = await f.remove();
   1456               hook.restore();
   1457               const rows = (await f.host.stored()).length;
   1458               return {
   1459                 status: removed.status,
   1460                 ack: !!removed.acknowledgement,
   1461                 binding: !!f.removalBinding(),
   1462                 rows,
   1463                 counts: hook.counts()
   1464               };
   1465             } finally {
   1466               hook.restore();
   1467             }
   1468           },
   1469           { loss, at }
   1470         );
   1471         expect(result.ack).toBe(false);
   1472         expect(result.binding).toBe(false);
   1473         expect(result.counts.deletes).toBe(1);
   1474         // A head change has no synchronous cancellation notification. The
   1475         // already-admitted native delete may complete historically, but final
   1476         // source revalidation must withhold current provenance and retirement.
   1477         if (at === 'complete_loss' || loss === 'head')
   1478           expect(result).toMatchObject({
   1479             status: 'unknown_completion',
   1480             rows: 0,
   1481             counts: { completes: 1 }
   1482           });
   1483         else expect(result).toMatchObject({ rows: 1, counts: { aborts: 1 } });
   1484       });
   1485 
   1486   test(`${recovered ? 'recovered' : 'original'} exact cleanup preserves same-owner settled send, received envelope and unrelated protected probe bytes`, async ({
   1487     page
   1488   }) => {
   1489     await qualify(page, recovered);
   1490     const result = await page.evaluate(async () => {
   1491       const f = window.pcFixture,
   1492         preserved = await f.seedPreservedRecords();
   1493       await f.select();
   1494       const removed = await f.remove(),
   1495         sends = await f.host.stored(),
   1496         received = await f.receivedRows();
   1497       return { status: removed.status, preserved, sends, received };
   1498     });
   1499     expect(result.status).toBe('removed');
   1500     expect(result.sends).toEqual(
   1501       expect.arrayContaining(result.preserved.slice(0, 2))
   1502     );
   1503     expect(result.sends).toHaveLength(2);
   1504     expect(result.received).toEqual([result.preserved[2]]);
   1505   });
   1506 }
   1507 
   1508 test('same-C7 recovered-first network action removes genuine row while old unregistered original cannot recreate it or emit EVENT', async ({
   1509   page
   1510 }) => {
   1511   // Initial S3/R1 exists, but no original network action has ever been captured.
   1512   const result = await page.evaluate(async () => {
   1513     const f = window.pcFixture,
   1514       access = f.actors().access,
   1515       original = f.originalIdentity()!;
   1516     await f.qualify(true, { fresh: false });
   1517     await f.select();
   1518     const removed = await f.remove(),
   1519       before = f.host.counts(),
   1520       stillPrepared = !!window.pc.inboxProbeRumorWire(
   1521         original,
   1522         f.actors().session
   1523       ),
   1524       retry = await f.retryOriginalPreparation(),
   1525       publication = await f.originalPublish('wss://peer.example.org');
   1526     return {
   1527       sameC7: access === f.actors().access,
   1528       liveC7: !!window.pc
   1529         .inboxAccessConstructionBinding(
   1530           access,
   1531           f.actors().session,
   1532           f.host.policy
   1533         )
   1534         ?.current(),
   1535       removed: removed.status,
   1536       stillPrepared,
   1537       retry: retry.status,
   1538       retryAck: 'acknowledgement' in retry,
   1539       publication,
   1540       before,
   1541       after: f.host.counts(),
   1542       rows: (await f.host.stored()).length
   1543     };
   1544   });
   1545   expect(result).toMatchObject({
   1546     sameC7: true,
   1547     liveC7: true,
   1548     removed: 'removed',
   1549     stillPrepared: true,
   1550     retryAck: false,
   1551     rows: 0
   1552   });
   1553   // This original identity was never associated with the retired REC meter.
   1554   // Native absence rejects its real publication before EVENT admission.
   1555   expect(result.publication).toEqual({ status: 'stopped' });
   1556   expect(traffic().filter((x) => x.frame[0] === 'EVENT')).toHaveLength(3);
   1557   // Unregistered preparation is honestly retained until actual C7 teardown.
   1558   expect(
   1559     await page.evaluate(() => {
   1560       const f = window.pcFixture,
   1561         original = f.originalIdentity()!;
   1562       f.stop();
   1563       return !!window.pc.inboxProbeRumorWire(original, f.actors().session);
   1564     })
   1565   ).toBe(false);
   1566 });
   1567 
   1568 for (const recovered of [false, true]) {
   1569   test(`${recovered ? 'recovered' : 'original'} bounded genuine observation array never reads or consumes a custom iterator`, async ({
   1570     page
   1571   }) => {
   1572     await qualify(page, recovered);
   1573     const result = await page.evaluate(async () => {
   1574       const f = window.pcFixture,
   1575         values = f.observations();
   1576       let gets = 0,
   1577         bodies = 0,
   1578         steps = 0;
   1579       Object.defineProperty(values, Symbol.iterator, {
   1580         configurable: true,
   1581         get() {
   1582           gets++;
   1583           return function* () {
   1584             bodies++;
   1585             // Finite real regression, never an infinite/hanging iterator.
   1586             for (let index = 0; index < values.length + 2; index++) {
   1587               steps++;
   1588               yield values[index % values.length];
   1589             }
   1590           };
   1591         }
   1592       });
   1593       const before = f.host.counts(),
   1594         selected = await f.select(
   1595           'reviewed_inbox_probe_cleanup_selection',
   1596           values
   1597         );
   1598       return {
   1599         selected: !!selected,
   1600         gets,
   1601         bodies,
   1602         steps,
   1603         declaredLength: values.length,
   1604         before,
   1605         after: f.host.counts(),
   1606         rows: (await f.host.stored()).length
   1607       };
   1608     });
   1609     expect(result).toMatchObject({
   1610       selected: true,
   1611       gets: 0,
   1612       bodies: 0,
   1613       steps: 0,
   1614       declaredLength: 4,
   1615       rows: 1
   1616     });
   1617     expect(result.after).toEqual(result.before);
   1618   });
   1619 
   1620   for (const kind of [
   1621     'accessor',
   1622     'sparse',
   1623     'inherited',
   1624     'oversized',
   1625     'non_integer',
   1626     'unsafe_length'
   1627   ] as const)
   1628     test(`${recovered ? 'recovered' : 'original'} genuine cleanup refuses ${kind} observation data without native or provider work`, async ({
   1629       page
   1630     }) => {
   1631       await qualify(page, recovered);
   1632       const result = await page.evaluate(async (kind) => {
   1633         const f = window.pcFixture,
   1634           values = f.observations(),
   1635           first = values[0],
   1636           a = f.actors(),
   1637           record = JSON.parse((await f.host.stored())[0].wire) as {
   1638             receipts: unknown[];
   1639           };
   1640         let gets = 0,
   1641           lengthDescriptors = 0;
   1642         let input: typeof values = values;
   1643         if (kind === 'accessor')
   1644           Object.defineProperty(values, '0', {
   1645             configurable: true,
   1646             get() {
   1647               gets++;
   1648               return first;
   1649             }
   1650           });
   1651         else if (kind === 'sparse') Reflect.deleteProperty(values, '0');
   1652         else if (kind === 'inherited') {
   1653           Reflect.deleteProperty(values, '0');
   1654           const prototype: object = Object.create(Array.prototype) as object;
   1655           Object.defineProperty(prototype, '0', {
   1656             value: first,
   1657             configurable: true
   1658           });
   1659           Object.setPrototypeOf(values, prototype);
   1660         } else if (kind === 'oversized')
   1661           values.length = record.receipts.length + 1;
   1662         else
   1663           input = new Proxy(values, {
   1664             getOwnPropertyDescriptor(target, key) {
   1665               const field = Reflect.getOwnPropertyDescriptor(target, key);
   1666               if (key === 'length' && field) {
   1667                 lengthDescriptors++;
   1668                 return {
   1669                   ...field,
   1670                   value:
   1671                     kind === 'non_integer' ? 1.5 : Number.MAX_SAFE_INTEGER + 1
   1672                 };
   1673               }
   1674               return field;
   1675             }
   1676           });
   1677         const genuine = !!window.pc.inboxProbeNonceAcknowledgementBinding(
   1678             f.repository,
   1679             a.session,
   1680             f.nonce()!,
   1681             f.host.policy
   1682           ),
   1683           before = f.host.counts(),
   1684           hook = f.nativeFault('abort');
   1685         try {
   1686           const selected = await f.select(
   1687             'reviewed_inbox_probe_cleanup_selection',
   1688             input
   1689           );
   1690           hook.restore();
   1691           return {
   1692             genuine,
   1693             selected: !!selected,
   1694             gets,
   1695             lengthDescriptors,
   1696             counts: hook.counts(),
   1697             before,
   1698             after: f.host.counts(),
   1699             rows: (await f.host.stored()).length
   1700           };
   1701         } finally {
   1702           hook.restore();
   1703         }
   1704       }, kind);
   1705       expect(result).toMatchObject({
   1706         genuine: true,
   1707         selected: false,
   1708         gets: 0,
   1709         rows: 1,
   1710         counts: { readonly: 0, deletes: 0 }
   1711       });
   1712       expect(result.after).toEqual(result.before);
   1713       if (kind === 'non_integer' || kind === 'unsafe_length')
   1714         expect(result.lengthDescriptors).toBe(1);
   1715     });
   1716 
   1717   for (const loss of ['head', 'nonce'] as const)
   1718     test(`${recovered ? 'recovered' : 'original'} observation descriptor callback actual ${loss} loss is fenced after bounded inspection`, async ({
   1719       page
   1720     }) => {
   1721       await qualify(page, recovered);
   1722       const result = await page.evaluate(async (loss) => {
   1723         const f = window.pcFixture,
   1724           a = f.actors(),
   1725           original = (await f.host.stored())[0].wire,
   1726           values = f.observations();
   1727         let callbacks = 0,
   1728           descriptors = 0;
   1729         const input = new Proxy(values, {
   1730           getOwnPropertyDescriptor(target, key) {
   1731             descriptors++;
   1732             if (key === '0' && callbacks === 0) {
   1733               callbacks++;
   1734               if (loss === 'head') a.churnHead();
   1735               else
   1736                 window.pc.disposeInboxProbeNonceProof(
   1737                   f.nonceProof()!,
   1738                   f.repository,
   1739                   a.session,
   1740                   f.host.policy
   1741                 );
   1742             }
   1743             return Reflect.getOwnPropertyDescriptor(target, key);
   1744           }
   1745         });
   1746         const genuine = !!window.pc.inboxProbeNonceAcknowledgementBinding(
   1747             f.repository,
   1748             a.session,
   1749             f.nonce()!,
   1750             f.host.policy
   1751           ),
   1752           before = f.host.counts(),
   1753           hook = f.nativeFault('abort');
   1754         try {
   1755           const selected = await f.select(
   1756             'reviewed_inbox_probe_cleanup_selection',
   1757             input
   1758           );
   1759           hook.restore();
   1760           return {
   1761             genuine,
   1762             selected: !!selected,
   1763             callbacks,
   1764             descriptors,
   1765             limit: values.length + 1,
   1766             before,
   1767             after: f.host.counts(),
   1768             counts: hook.counts(),
   1769             same: (await f.host.stored())[0].wire === original
   1770           };
   1771         } finally {
   1772           hook.restore();
   1773         }
   1774       }, loss);
   1775       expect(result).toMatchObject({
   1776         genuine: true,
   1777         selected: false,
   1778         callbacks: 1,
   1779         same: true,
   1780         counts: { readonly: 0, deletes: 0 }
   1781       });
   1782       expect(result.descriptors).toBeLessThanOrEqual(result.limit);
   1783       expect(result.after).toEqual(result.before);
   1784     });
   1785 
   1786   test(`${recovered ? 'recovered' : 'original'} actual Lineage append started by a descriptor callback cannot authorize stale cleanup`, async ({
   1787     page
   1788   }) => {
   1789     await qualify(page, recovered);
   1790     const result = await page.evaluate(async (recovered) => {
   1791       const f = window.pcFixture,
   1792         a = f.actors(),
   1793         extra = await (recovered
   1794           ? f.publish('wss://peer.example.org')
   1795           : f.originalPublish('wss://peer.example.org'));
   1796       if (!extra || extra.status !== 'accepted')
   1797         throw Error('actual extra source result');
   1798       const values = f.observations(),
   1799         before = f.host.counts();
   1800       let pending: ReturnType<typeof f.append> | undefined,
   1801         callbacks = 0;
   1802       const input = new Proxy(values, {
   1803         getOwnPropertyDescriptor(target, key) {
   1804           if (key === '0' && !pending) {
   1805             callbacks++;
   1806             pending = f.append(extra);
   1807           }
   1808           return Reflect.getOwnPropertyDescriptor(target, key);
   1809         }
   1810       });
   1811       const genuine = !!window.pc.inboxProbeNonceAcknowledgementBinding(
   1812           f.repository,
   1813           a.session,
   1814           f.nonce()!,
   1815           f.host.policy
   1816         ),
   1817         hook = f.nativeFault('abort');
   1818       try {
   1819         const selected = await f.select(
   1820           'reviewed_inbox_probe_cleanup_selection',
   1821           input
   1822         );
   1823         if (!pending)
   1824           throw Error('actual bounded descriptor callback did not run');
   1825         const applied = await pending,
   1826           removed = await f.remove();
   1827         hook.restore();
   1828         const rows = await f.host.stored();
   1829         return {
   1830           genuine,
   1831           callbacks,
   1832           captured: !!selected,
   1833           applied: applied.status,
   1834           status: removed.status,
   1835           ack: !!removed.acknowledgement,
   1836           counts: hook.counts(),
   1837           before,
   1838           after: f.host.counts(),
   1839           rows: rows.length,
   1840           receipts: (JSON.parse(rows[0].wire) as { receipts: unknown[] })
   1841             .receipts.length
   1842         };
   1843       } finally {
   1844         hook.restore();
   1845       }
   1846     }, recovered);
   1847     expect(result).toMatchObject({
   1848       genuine: true,
   1849       callbacks: 1,
   1850       applied: 'saved',
   1851       ack: false,
   1852       rows: 1,
   1853       receipts: 6,
   1854       counts: { deletes: 0 }
   1855     });
   1856     expect(['invalid', 'stopped']).toContain(result.status);
   1857     expect(result.after).toEqual(result.before);
   1858   });
   1859 }