app

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

inbox-probe-nonce-facts.spec.ts (44402B)


      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-nonce-facts.ts';
      8 declare global {
      9   interface Window {
     10     nf: typeof Fixture;
     11     nfFixture: Awaited<ReturnType<typeof Fixture.makeNonceFactsFixture>>;
     12     nfPending?: Promise<unknown>;
     13     nfRestore?: () => void;
     14   }
     15 }
     16 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     17   sockets: WebSocketServer,
     18   endpoint: string,
     19   bundle: string,
     20   head = '';
     21 const origins = [
     22     'wss://inbox.example.org',
     23     'wss://peer.example.org',
     24     'wss://archive.example.org'
     25   ],
     26   physical = new Set<WebSocket>(),
     27   archived = new Map<string, unknown>(),
     28   frames: { origin: string; frame: unknown[] }[] = [];
     29 test.beforeAll(async () => {
     30   server = await createStaticHarness();
     31   sockets = new WebSocketServer({
     32     host: '127.0.0.1',
     33     port: 0,
     34     maxPayload: 65536
     35   });
     36   await once(sockets, 'listening');
     37   const address = sockets.address();
     38   if (!address || typeof address === 'string')
     39     throw Error('actual loopback endpoint');
     40   endpoint = 'ws://127.0.0.1:' + address.port;
     41   sockets.on('connection', (socket, request) => {
     42     physical.add(socket);
     43     socket.on('close', () => physical.delete(socket));
     44     const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
     45       'origin'
     46     )!;
     47     socket.on('message', (bytes) => {
     48       const raw = Buffer.isBuffer(bytes)
     49           ? bytes
     50           : Array.isArray(bytes)
     51             ? Buffer.concat(bytes)
     52             : Buffer.from(bytes),
     53         frame = JSON.parse(raw.toString()) as unknown[];
     54       if (frames.length >= 1000) throw Error('controlled fixture frame bound');
     55       frames.push({ origin, frame });
     56       if (frame[0] === 'REQ') {
     57         const filter = frame[2] as { kinds?: number[]; ids?: string[] };
     58         if (filter.kinds?.includes(10050) && head)
     59           socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
     60         if (filter.kinds?.includes(1059)) {
     61           const event = archived.get(JSON.stringify([origin, filter.ids?.[0]]));
     62           if (event) socket.send(JSON.stringify(['EVENT', frame[1], event]));
     63         }
     64         socket.send(JSON.stringify(['EOSE', frame[1]]));
     65       } else if (frame[0] === 'EVENT') {
     66         const event = frame[1] as { id: string };
     67         archived.set(JSON.stringify([origin, event.id]), event);
     68         socket.send(JSON.stringify(['OK', event.id, true, '']));
     69       }
     70     });
     71   });
     72   const result = await build({
     73     configFile: false,
     74     logLevel: 'silent',
     75     build: {
     76       write: false,
     77       minify: false,
     78       lib: {
     79         entry: fileURLToPath(
     80           new URL('./harness/inbox-probe-nonce-facts.ts', import.meta.url)
     81         ),
     82         name: 'nf',
     83         formats: ['iife']
     84       }
     85     }
     86   });
     87   const output = Array.isArray(result) ? result[0] : result;
     88   if (!('output' in output)) throw Error('actual compiled nonce-facts harness');
     89   const chunks = output.output.filter((x) => x.type === 'chunk');
     90   expect(chunks).toHaveLength(1);
     91   bundle = chunks[0].code;
     92 });
     93 test.afterAll(async () => {
     94   for (const socket of sockets.clients) socket.terminate();
     95   await new Promise<void>((resolve) => sockets.close(() => resolve()));
     96   await server.close();
     97 });
     98 test.beforeEach(async ({ page }) => {
     99   await expect.poll(() => physical.size).toBe(0);
    100   archived.clear();
    101   frames.length = 0;
    102   head = '';
    103   await page.addInitScript(
    104     ({ endpoint, origins }) => {
    105       const Native = window.WebSocket;
    106       window.WebSocket = class extends Native {
    107         constructor(url: string | URL, protocols?: string | string[]) {
    108           const origin = new URL(String(url)).origin;
    109           if (!['wss://discovery.example.org', ...origins].includes(origin))
    110             throw Error('unapproved fixture origin');
    111           super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
    112         }
    113       };
    114     },
    115     { endpoint, origins }
    116   );
    117   await page.goto(server.url + '/search');
    118   await page.addScriptTag({ content: bundle });
    119   head = await page.evaluate(async (origins) => {
    120     window.nfFixture = await window.nf.makeNonceFactsFixture();
    121     return window.nfFixture.host.preferenceWire(origins);
    122   }, origins);
    123   await page.evaluate(async () => {
    124     const f = window.nfFixture;
    125     await f.open();
    126     if ((await f.prepareOriginal()).status !== 'prepared')
    127       throw Error('actual original S3/R1');
    128   });
    129 });
    130 test.afterEach(async ({ page }) => {
    131   if (!page.isClosed())
    132     await page.evaluate(async () => {
    133       window.nfRestore?.();
    134       window.nfFixture.host.mode('normal');
    135       window.nfFixture.host.settle();
    136       window.nfFixture.close();
    137       await window.nfPending;
    138     });
    139 });
    140 async function setup(page: Page, recovered = true, apply = true) {
    141   expect(
    142     await page.evaluate(
    143       async ({ recovered, apply }) =>
    144         (await window.nfFixture.prepareRead(recovered, apply)).status,
    145       { recovered, apply }
    146     )
    147   ).toBe('readback');
    148 }
    149 async function verify(page: Page) {
    150   expect(
    151     await page.evaluate(async () => (await window.nfFixture.nonce()).status)
    152   ).toBe('nonce_verified');
    153 }
    154 async function wire(page: Page) {
    155   return page.evaluate(async () => (await window.nfFixture.storedRow()).wire);
    156 }
    157 const traffic = () =>
    158   frames.filter(
    159     (x) =>
    160       x.origin !== 'wss://discovery.example.org' &&
    161       ['EVENT', 'REQ', 'AUTH'].includes(String(x.frame[0]))
    162   );
    163 
    164 for (const recovered of [false, true]) {
    165   test(`${recovered ? 'recovered' : 'current-original'} genuine nonce fact has exact native lineage, idempotence and separate opaque acknowledgement`, async ({
    166     page
    167   }) => {
    168     await setup(page, recovered);
    169     const predecessor = await wire(page),
    170       net = traffic().length;
    171     const result = await page.evaluate(async (recovered) => {
    172       const f = window.nfFixture,
    173         before = f.host.counts(),
    174         first = f.captureNonce()!,
    175         second = f.captureNonce(),
    176         read = await f.nonce(first),
    177         afterRead = f.host.counts(),
    178         again = await f.nonce(first),
    179         firstSave = await f.appendNonce(),
    180         afterSave = (await f.storedRow()).wire,
    181         secondSave = await f.appendNonce(),
    182         binding = f.nonceBinding(),
    183         proof = f.nonceProof()!,
    184         ack = f.nonceAcknowledgement()!,
    185         a = f.actors();
    186       return {
    187         sameReader: first === second,
    188         read: read.status,
    189         again: again.status,
    190         before,
    191         afterRead,
    192         afterSaveCounts: f.host.counts(),
    193         firstSave: firstSave.status,
    194         secondSave: secondSave.status,
    195         sameAck: firstSave.acknowledgement === secondSave.acknowledgement,
    196         provenance: firstSave.provenance,
    197         afterSave,
    198         final: (await f.storedRow()).wire,
    199         proofKeys: Object.keys(proof),
    200         ackKeys: Object.keys(ack),
    201         current: binding?.current(),
    202         copy: !!window.nf.inboxProbeNonceAcknowledgementBinding(
    203           f.repository,
    204           a.session,
    205           { ...ack },
    206           f.host.policy
    207         ),
    208         crossReader: recovered
    209           ? (
    210               await window.nf.readInboxProbeNonce(
    211                 first as unknown as Parameters<
    212                   typeof window.nf.readInboxProbeNonce
    213                 >[0]
    214               )
    215             ).status
    216           : (
    217               await window.nf.readRecoveredInboxProbeNonce(
    218                 first as unknown as Parameters<
    219                   typeof window.nf.readRecoveredInboxProbeNonce
    220                 >[0]
    221               )
    222             ).status,
    223         crossProof: recovered
    224           ? !!window.nf.inboxProbeNonceProofBinding(
    225               proof as unknown as Parameters<
    226                 typeof window.nf.inboxProbeNonceProofBinding
    227               >[0],
    228               f.repository,
    229               a.session,
    230               f.host.policy
    231             )
    232           : !!window.nf.recoveredInboxProbeNonceProofBinding(
    233               proof as unknown as Parameters<
    234                 typeof window.nf.recoveredInboxProbeNonceProofBinding
    235               >[0],
    236               f.repository,
    237               a.session,
    238               f.host.policy
    239             ),
    240         crossCapture: recovered
    241           ? !!window.nf.captureInboxProbeNonceReader(
    242               f.repository,
    243               a.identity,
    244               a.session,
    245               f.host.policy,
    246               f.observation()!,
    247               'reviewed_inbox_probe_nonce_decryption'
    248             )
    249           : !!window.nf.captureRecoveredInboxProbeNonceReader(
    250               f.repository,
    251               a.identity,
    252               a.session,
    253               f.host.policy,
    254               f.observation()!,
    255               'reviewed_inbox_probe_nonce_decryption'
    256             ),
    257         settlement: window.nf.privateRecordSettlement(binding!.record),
    258         ordinaryCleanup: !!(await window.nf.capturePrivateOutboxCleanup(
    259           f.repository,
    260           a.session,
    261           [f.command()],
    262           'reviewed_settled_outbox_selection'
    263         )),
    264         readiness: window.nf.inboxAccessControllerSnapshot(a.access)?.readiness
    265       };
    266     }, recovered);
    267     const before = JSON.parse(predecessor) as {
    268         revision: number;
    269         receipts: Record<string, unknown>[];
    270         self: unknown;
    271       },
    272       after = JSON.parse(result.final) as typeof before;
    273     expect(result.sameReader && result.sameAck && result.current).toBe(true);
    274     expect(result.read).toBe('nonce_verified');
    275     expect(result.again).toBe('nonce_verified');
    276     expect(result.firstSave).toBe('saved');
    277     expect(result.secondSave).toBe('existing');
    278     expect(result.provenance).toBe('current');
    279     expect(result.afterRead).toEqual({
    280       ...result.before,
    281       keys: result.before.keys + 3,
    282       decrypts: result.before.decrypts + 2
    283     });
    284     expect(result.afterSaveCounts).toEqual(result.afterRead);
    285     expect(result.afterSave).toBe(result.final);
    286     expect(after).toEqual({
    287       ...before,
    288       revision: before.revision + 1,
    289       receipts: [
    290         ...before.receipts,
    291         {
    292           ...before.receipts.at(-1),
    293           status: 'nonce_verified',
    294           observedAtMilliseconds: expect.any(Number)
    295         }
    296       ]
    297     });
    298     expect(result.proofKeys).toEqual([]);
    299     expect(result.ackKeys).toEqual([]);
    300     expect(
    301       result.copy ||
    302         result.crossProof ||
    303         result.crossCapture ||
    304         result.ordinaryCleanup
    305     ).toBe(false);
    306     expect(result.crossReader).toBe('invalid');
    307     expect(result.settlement).toBe('protected');
    308     expect(result.readiness).toBe('unavailable');
    309     expect(traffic()).toHaveLength(net);
    310   });
    311 
    312   test(`${recovered ? 'recovered' : 'original'} genuinely decrypted but un-applied B2 cannot append until that exact source observation commits`, async ({
    313     page
    314   }) => {
    315     await setup(page, recovered, false);
    316     await verify(page);
    317     const predecessor = await wire(page);
    318     const first = await page.evaluate(async () => {
    319       const f = window.nfFixture,
    320         before = f.host.counts(),
    321         result = await f.appendNonce();
    322       return {
    323         status: result.status,
    324         ack: !!result.acknowledgement,
    325         before,
    326         after: f.host.counts()
    327       };
    328     });
    329     expect(first.status).toBe('invalid');
    330     expect(first.ack).toBe(false);
    331     expect(first.after).toEqual(first.before);
    332     expect(await wire(page)).toBe(predecessor);
    333     expect(
    334       await page.evaluate(
    335         async () => (await window.nfFixture.applyRead())?.status
    336       )
    337     ).toBe('saved');
    338     expect(
    339       await page.evaluate(
    340         async () => (await window.nfFixture.appendNonce()).status
    341       )
    342     ).toBe('saved');
    343   });
    344 }
    345 
    346 for (const review of [undefined, null, false, 'reviewed_private_decryption'])
    347   test(`recovered nonce capture refuses wrong explicit consent ${String(review)}`, async ({
    348     page
    349   }) => {
    350     await setup(page);
    351     const result = await page.evaluate((review) => {
    352       const f = window.nfFixture,
    353         a = f.actors(),
    354         before = f.host.counts();
    355       return {
    356         accepted: !!window.nf.captureRecoveredInboxProbeNonceReader(
    357           f.repository,
    358           a.identity,
    359           a.session,
    360           f.host.policy,
    361           f.observation()!,
    362           review
    363         ),
    364         before,
    365         after: f.host.counts()
    366       };
    367     }, review);
    368     expect(result.accepted).toBe(false);
    369     expect(result.after).toEqual(result.before);
    370   });
    371 
    372 for (const recovered of [false, true])
    373   for (const fault of ['repository', 'session', 'policy'] as const)
    374     test(`${recovered ? 'recovered' : 'original'} genuine nonce proof and acknowledgement reject foreign ${fault} at the actual issuer`, async ({
    375       page
    376     }) => {
    377       await setup(page, recovered);
    378       await verify(page);
    379       const predecessor = await wire(page),
    380         net = traffic().length;
    381       const result = await page.evaluate(async (fault) => {
    382         const f = window.nfFixture,
    383           a = f.actors(),
    384           identity = window.nf.createIdentitySession();
    385         await window.nf.connectIdentity(identity);
    386         await window.nf.probeIdentityMessaging(identity, 'reviewed_self_copy');
    387         const foreignSession = await window.nf.createPrivateSession(
    388           identity,
    389           'reviewed_private_session'
    390         );
    391         if (!foreignSession) throw Error('actual foreign same-owner session');
    392         const repository = fault === 'repository' ? a.repository : f.repository,
    393           session = fault === 'session' ? foreignSession : a.session,
    394           policy = fault === 'policy' ? f.host.copiedPolicy() : f.host.policy,
    395           before = f.host.counts(),
    396           writes = f.nativeWriteHook(() => {});
    397         window.nfRestore = writes.restore;
    398         const refused = await window.nf.commitInboxProbeNonceVerification(
    399             repository,
    400             session,
    401             policy,
    402             f.nonceProof()!
    403           ),
    404           refusedWire = (await f.storedRow()).wire,
    405           refusedWrites = writes.hits(),
    406           saved = await f.appendNonce(),
    407           acknowledgement = f.nonceAcknowledgement();
    408         if (!acknowledgement)
    409           throw Error('actual legitimate nonce acknowledgement');
    410         const wrong = window.nf.inboxProbeNonceAcknowledgementBinding(
    411             repository,
    412             session,
    413             acknowledgement,
    414             policy
    415           ),
    416           copied = window.nf.inboxProbeNonceAcknowledgementBinding(
    417             f.repository,
    418             a.session,
    419             { ...acknowledgement },
    420             f.host.policy
    421           ),
    422           current = f.nonceBinding()?.current(),
    423           after = f.host.counts(),
    424           totalWrites = writes.hits();
    425         writes.restore();
    426         window.nf.closePrivateSession(foreignSession);
    427         window.nf.disconnectIdentity(identity);
    428         return {
    429           refused: refused.status,
    430           refusedAck: !!refused.acknowledgement,
    431           refusedWire,
    432           refusedWrites,
    433           saved: saved.status,
    434           wrong: !!wrong,
    435           copied: !!copied,
    436           current,
    437           before,
    438           after,
    439           totalWrites
    440         };
    441       }, fault);
    442       expect(result.refused).toBe('invalid');
    443       expect(result.refusedAck || result.wrong || result.copied).toBe(false);
    444       expect(result.refusedWire).toBe(predecessor);
    445       expect(result.refusedWrites).toBe(0);
    446       expect(result.saved).toBe('saved');
    447       expect(result.totalWrites).toBe(1);
    448       expect(result.current).toBe(true);
    449       expect(result.after).toEqual(result.before);
    450       expect(traffic()).toHaveLength(net);
    451     });
    452 
    453 test('copied proof, C2A recovery proof, recovered ACK and nonce status labels have no nonce-fact authority', async ({
    454   page
    455 }) => {
    456   await setup(page);
    457   await verify(page);
    458   const predecessor = await wire(page),
    459     net = traffic().length;
    460   const result = await page.evaluate(async () => {
    461     const f = window.nfFixture,
    462       before = f.host.counts(),
    463       answers: boolean[] = [];
    464     for (const fake of [
    465       { ...f.nonceProof()! },
    466       f.proof(),
    467       f.acknowledgement(),
    468       { status: 'nonce_verified', proof: f.nonceProof(), current: () => true }
    469     ]) {
    470       const result = await window.nf.commitInboxProbeNonceVerification(
    471         f.repository,
    472         f.actors().session,
    473         f.host.policy,
    474         fake as Parameters<
    475           typeof window.nf.commitInboxProbeNonceVerification
    476         >[3]
    477       );
    478       answers.push(
    479         !!result.acknowledgement ||
    480           ['saved', 'reconciled', 'existing'].includes(result.status)
    481       );
    482     }
    483     return { answers, before, after: f.host.counts() };
    484   });
    485   expect(result.answers).toEqual([false, false, false, false]);
    486   expect(result.after).toEqual(result.before);
    487   expect(await wire(page)).toBe(predecessor);
    488   expect(traffic()).toHaveLength(net);
    489 });
    490 
    491 for (const fault of ['repository', 'policy', 'identity', 'session'] as const)
    492   test(`genuine recovered observation rejects same-owner foreign ${fault} association`, async ({
    493     page
    494   }) => {
    495     await setup(page);
    496     const result = await page.evaluate(async (fault) => {
    497       const f = window.nfFixture,
    498         a = f.actors(),
    499         identity = window.nf.createIdentitySession();
    500       await window.nf.connectIdentity(identity);
    501       await window.nf.probeIdentityMessaging(identity, 'reviewed_self_copy');
    502       const session = await window.nf.createPrivateSession(
    503         identity,
    504         'reviewed_private_session'
    505       );
    506       if (!session) throw Error('genuine foreign same-owner private session');
    507       const before = f.host.counts();
    508       const reader = window.nf.captureRecoveredInboxProbeNonceReader(
    509         fault === 'repository' ? a.repository : f.repository,
    510         fault === 'identity' ? identity : a.identity,
    511         fault === 'session' ? session : a.session,
    512         fault === 'policy' ? f.host.copiedPolicy() : f.host.policy,
    513         f.observation()!,
    514         'reviewed_inbox_probe_nonce_decryption'
    515       );
    516       const after = f.host.counts();
    517       window.nf.closePrivateSession(session);
    518       window.nf.disconnectIdentity(identity);
    519       return { accepted: !!reader, before, after };
    520     }, fault);
    521     expect(result.accepted).toBe(false);
    522     expect(result.after).toEqual(result.before);
    523   });
    524 
    525 for (const mode of ['wrong_key', 'refuse_decrypt', 'wrong_decrypt'] as const)
    526   test(`recovered nonce provider ${mode} cannot issue proof or fact`, async ({
    527     page
    528   }) => {
    529     await setup(page);
    530     const predecessor = await wire(page);
    531     const result = await page.evaluate(async (mode) => {
    532       const f = window.nfFixture,
    533         reader = f.captureNonce()!;
    534       f.host.mode(mode);
    535       const result = await f.nonce(reader);
    536       return { status: result.status, proof: !!f.nonceProof() };
    537     }, mode);
    538     expect(result.status).not.toBe('nonce_verified');
    539     expect(result.proof).toBe(false);
    540     expect(await wire(page)).toBe(predecessor);
    541   });
    542 
    543 for (const fault of [
    544   'seal_tags',
    545   'seal_kind',
    546   'seal_signature',
    547   'rumor_nonce',
    548   'rumor_hash',
    549   'rumor_time',
    550   'rumor_owner',
    551   'rumor_serialization'
    552 ] as const)
    553   test(`actual recovered decrypted ${fault} refuses nonce proof`, async ({
    554     page
    555   }) => {
    556     await setup(page);
    557     const predecessor = await wire(page);
    558     const result = await page.evaluate(async (fault) => {
    559       const f = window.nfFixture,
    560         restore = f.host.decryptCallback(
    561           fault.startsWith('seal_') ? 1 : 2,
    562           (wire) => {
    563             if (fault === 'seal_tags')
    564               return f.host.signSeal(wire, { tags: [['p', f.host.owner]] });
    565             if (fault === 'seal_kind')
    566               return f.host.signSeal(wire, { kind: 14 });
    567             if (fault === 'rumor_serialization') return wire + '\n';
    568             const data = JSON.parse(wire) as {
    569               sig?: string;
    570               content?: string;
    571               id?: string;
    572               created_at?: number;
    573               pubkey?: string;
    574             };
    575             if (fault === 'seal_signature') data.sig = '0'.repeat(128);
    576             if (fault === 'rumor_nonce')
    577               data.content = 'different diagnostic nonce';
    578             if (fault === 'rumor_hash') data.id = 'f'.repeat(64);
    579             if (fault === 'rumor_time')
    580               data.created_at = (data.created_at ?? 0) + 1;
    581             if (fault === 'rumor_owner') data.pubkey = 'f'.repeat(64);
    582             return JSON.stringify(data);
    583           }
    584         );
    585       window.nfRestore = () => restore.restore();
    586       return {
    587         status: (await f.nonce()).status,
    588         proof: !!f.nonceProof(),
    589         receivers: restore.receivers()
    590       };
    591     }, fault);
    592     expect(result.status).not.toBe('nonce_verified');
    593     expect(result.proof).toBe(false);
    594     expect(result.receivers).toBeGreaterThan(0);
    595     expect(await wire(page)).toBe(predecessor);
    596   });
    597 
    598 for (const mutation of [
    599   'alias',
    600   'own_tail',
    601   'foreign_tail',
    602   'missing'
    603 ] as const)
    604   test(`nonce initial complete physical namespace handles ${mutation}`, async ({
    605     page
    606   }) => {
    607     await setup(page);
    608     const result = await page.evaluate(async (mutation) => {
    609       const f = window.nfFixture,
    610         reader = f.captureNonce()!,
    611         row = await f.storedRow();
    612       if (mutation === 'alias')
    613         await f.host.inject([{ ...row, wire: row.wire + '\n' }]);
    614       else if (mutation === 'own_tail' || mutation === 'foreign_tail')
    615         await f.host.inject([
    616           {
    617             owner: mutation === 'own_tail' ? row.owner : 'f'.repeat(64),
    618             id: crypto.randomUUID(),
    619             wire: 'unknown owner tail'
    620           }
    621         ]);
    622       else {
    623         const opened = await window.nf.openBrowserDatabase();
    624         if (opened.state !== 'ready')
    625           throw Error('actual fixture native deletion');
    626         const tx = window.nf.browserDatabaseTransaction(
    627           opened.owner,
    628           ['private_sends'],
    629           'readwrite'
    630         );
    631         tx.objectStore('private_sends').delete([row.owner, row.id]);
    632         await new Promise<void>((resolve, reject) => {
    633           tx.addEventListener('complete', () => resolve());
    634           tx.addEventListener('abort', () =>
    635             reject(Error('actual fixture delete abort'))
    636           );
    637         });
    638         window.nf.closeBrowserDatabase(opened.owner);
    639       }
    640       const before = f.host.counts(),
    641         raw = await f.host.stored(),
    642         result = await f.nonce(reader);
    643       return {
    644         status: result.status,
    645         before,
    646         after: f.host.counts(),
    647         raw,
    648         final: await f.host.stored()
    649       };
    650     }, mutation);
    651     expect(result.status === 'nonce_verified').toBe(
    652       mutation === 'foreign_tail'
    653     );
    654     if (mutation !== 'foreign_tail')
    655       expect(result.after).toEqual(result.before);
    656     expect(result.final).toEqual(result.raw);
    657   });
    658 
    659 for (const hit of [1, 2, 3])
    660   for (const fault of ['head', 'session', 'native'] as const)
    661     test(`recovered nonce actual key${hit} ${fault} churn fences proof mint`, async ({
    662       page
    663     }) => {
    664       await setup(page);
    665       const result = await page.evaluate(
    666         async ({ hit, fault }) => {
    667           const f = window.nfFixture,
    668             row = await f.storedRow(),
    669             reader = f.captureNonce()!;
    670           window.nfRestore = f.host.keyCallback(hit, async () => {
    671             if (fault === 'native')
    672               await f.host.inject([{ ...row, wire: row.wire + '\n' }]);
    673             else f.lose(fault);
    674           });
    675           return {
    676             status: (await f.nonce(reader)).status,
    677             proof: !!f.nonceProof()
    678           };
    679         },
    680         { hit, fault }
    681       );
    682       expect(result.status).not.toBe('nonce_verified');
    683       expect(result.proof).toBe(false);
    684     });
    685 
    686 for (const hit of [1, 2])
    687   for (const fault of ['before_abort', 'after_abort'] as const)
    688     test(`recovered nonce readonly${hit} ${fault} requires actual native completion`, async ({
    689       page
    690     }) => {
    691       await setup(page);
    692       const predecessor = await wire(page);
    693       const result = await page.evaluate(
    694         async ({ hit, fault }) => {
    695           const f = window.nfFixture,
    696             reader = f.captureNonce()!,
    697             hook = f.nativeReadonlyHook(hit, fault);
    698           window.nfRestore = hook.restore;
    699           return {
    700             status: (await f.nonce(reader)).status,
    701             proof: !!f.nonceProof(),
    702             faults: hook.faults()
    703           };
    704         },
    705         { hit, fault }
    706       );
    707       expect(result.faults).toBe(1);
    708       expect(result.status).not.toBe('nonce_verified');
    709       expect(result.proof).toBe(false);
    710       expect(await wire(page)).toBe(predecessor);
    711     });
    712 
    713 for (const kind of [
    714   'reader',
    715   'expiry',
    716   'controller',
    717   'head',
    718   'session'
    719 ] as const) {
    720   test(`stopped ${kind} proof BEFORE append admission has zero native write`, async ({
    721     page
    722   }) => {
    723     await setup(page);
    724     await verify(page);
    725     const predecessor = await wire(page);
    726     const result = await page.evaluate(async (kind) => {
    727       const f = window.nfFixture,
    728         before = f.host.counts();
    729       f.lose(kind);
    730       const saved = await f.appendNonce();
    731       return {
    732         status: saved.status,
    733         ack: !!saved.acknowledgement,
    734         before,
    735         after: f.host.counts()
    736       };
    737     }, kind);
    738     expect(['saved', 'existing', 'reconciled']).not.toContain(result.status);
    739     expect(result.ack).toBe(false);
    740     expect(result.after).toEqual(result.before);
    741     expect(await wire(page)).toBe(predecessor);
    742   });
    743   test(`actual ${kind} loss AFTER native append admission can retain history but no current acknowledgement`, async ({
    744     page
    745   }) => {
    746     await setup(page);
    747     await verify(page);
    748     const result = await page.evaluate(async (kind) => {
    749       const f = window.nfFixture,
    750         hook = f.nativeWriteHook(() => f.lose(kind));
    751       window.nfRestore = hook.restore;
    752       const saved = await f.appendNonce(),
    753         row = JSON.parse((await f.storedRow()).wire) as {
    754           receipts: { status: string }[];
    755         };
    756       return {
    757         status: saved.status,
    758         ack: !!saved.acknowledgement,
    759         binding: !!f.nonceBinding(),
    760         provenance: saved.provenance,
    761         last: row.receipts.at(-1)?.status,
    762         hits: hook.hits()
    763       };
    764     }, kind);
    765     expect(result.hits).toBe(1);
    766     expect(result.last).toBe('nonce_verified');
    767     expect(result.ack || result.binding).toBe(false);
    768     expect(result.provenance).not.toBe('current');
    769   });
    770   test(`actual ${kind} loss DURING initial native read precedes append admission and has zero put`, async ({
    771     page
    772   }) => {
    773     await setup(page);
    774     await verify(page);
    775     const predecessor = await wire(page);
    776     const result = await page.evaluate(async (kind) => {
    777       const f = window.nfFixture,
    778         genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence(
    779           f.nonceProof()!,
    780           f.repository,
    781           f.actors().session,
    782           f.host.policy
    783         ),
    784         before = f.host.counts(),
    785         writes = f.nativeWriteHook(() => {}),
    786         read = f.nativeReadonlyHook(1, 'callback', () => f.lose(kind));
    787       window.nfRestore = () => {
    788         read.restore();
    789         writes.restore();
    790       };
    791       const result = await f.appendNonce();
    792       read.restore();
    793       const after = f.host.counts(),
    794         puts = writes.hits();
    795       writes.restore();
    796       return {
    797         genuineBefore,
    798         faults: read.faults(),
    799         puts,
    800         status: result.status,
    801         ack: !!result.acknowledgement,
    802         binding: !!f.nonceBinding(),
    803         before,
    804         after
    805       };
    806     }, kind);
    807     expect(result.genuineBefore).toBe(true);
    808     expect(result.faults).toBe(1);
    809     expect(result.puts).toBe(0);
    810     expect(result.ack || result.binding).toBe(false);
    811     expect(['saved', 'reconciled', 'existing']).not.toContain(result.status);
    812     expect(result.after).toEqual(result.before);
    813     expect(await wire(page)).toBe(predecessor);
    814   });
    815 }
    816 
    817 for (const timing of ['after_confirmed_abort', 'between_read_and_cas'] as const)
    818   test(`exact handwritten nonce successor ${timing} cannot acquire genuine operation provenance`, async ({
    819     page
    820   }) => {
    821     await setup(page);
    822     await verify(page);
    823     const predecessor = await wire(page),
    824       net = traffic().length;
    825     const result = await page.evaluate(async (timing) => {
    826       const f = window.nfFixture,
    827         candidate = await f.handwrittenNonceSuccessor(),
    828         before = f.host.counts();
    829       let aborted = 0,
    830         firstWire: string | undefined,
    831         readHook: ReturnType<typeof f.nativeReadonlyHook> | undefined;
    832       if (timing === 'after_confirmed_abort') {
    833         const hook = f.installCommitFault('aborted');
    834         window.nfRestore = hook.restore;
    835         const first = await f.appendNonce();
    836         hook.restore();
    837         if (first.acknowledgement)
    838           throw Error('aborted append cannot acknowledge');
    839         firstWire = (await f.storedRow()).wire;
    840         // The port can report failure before native abort dispatch. Observe
    841         // the following real readonly completion before sampling its event.
    842         aborted = hook.counts().aborted;
    843         await f.host.inject([candidate]);
    844       } else {
    845         readHook = f.nativeReadonlyHook(1, 'callback', () => {
    846           window.nfPending = f.host.inject([candidate]);
    847         });
    848         window.nfRestore = readHook.restore;
    849       }
    850       const genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence(
    851           f.nonceProof()!,
    852           f.repository,
    853           f.actors().session,
    854           f.host.policy
    855         ),
    856         saved = await f.appendNonce();
    857       await window.nfPending;
    858       window.nfRestore?.();
    859       return {
    860         genuineBefore,
    861         aborted,
    862         firstWire,
    863         faults: readHook?.faults(),
    864         status: saved.status,
    865         ack: !!saved.acknowledgement,
    866         binding: !!f.nonceBinding(),
    867         candidate: candidate.wire,
    868         actual: (await f.storedRow()).wire,
    869         before,
    870         after: f.host.counts()
    871       };
    872     }, timing);
    873     expect(result.genuineBefore).toBe(true);
    874     if (timing === 'after_confirmed_abort') {
    875       expect(result.aborted).toBe(1);
    876       expect(result.firstWire).toBe(predecessor);
    877     } else expect(result.faults).toBe(1);
    878     expect(result.status).toBe('conflict');
    879     expect(result.ack || result.binding).toBe(false);
    880     expect(result.actual).toBe(result.candidate);
    881     expect(result.actual).not.toBe(predecessor);
    882     expect(result.after).toEqual(result.before);
    883     expect(traffic()).toHaveLength(net);
    884   });
    885 
    886 for (const fault of ['aborted', 'uncertain', 'changed_successor'] as const)
    887   test(`nonce append actual native ${fault} preserves exact outcome and genuine reconciliation`, async ({
    888     page
    889   }) => {
    890     await setup(page);
    891     await verify(page);
    892     const predecessor = await wire(page);
    893     const result = await page.evaluate(async (fault) => {
    894       const f = window.nfFixture,
    895         hook = f.installCommitFault(fault);
    896       window.nfRestore = hook.restore;
    897       const result = await f.appendNonce();
    898       hook.restore();
    899       const first = (await f.storedRow()).wire,
    900         again = await f.appendNonce();
    901       return {
    902         status: result.status,
    903         ack: !!result.acknowledgement,
    904         provenance: result.provenance,
    905         first,
    906         counts: hook.counts(),
    907         again: again.status,
    908         againAck: !!again.acknowledgement
    909       };
    910     }, fault);
    911     expect(result.counts.putSuccess).toBe(1);
    912     if (fault === 'aborted') {
    913       expect(result.ack).toBe(false);
    914       expect(result.first).toBe(predecessor);
    915       expect(result.counts.aborted).toBe(1);
    916       expect(result.again).toBe('saved');
    917       expect(result.againAck).toBe(true);
    918     } else if (fault === 'uncertain') {
    919       expect(result.status).toBe('reconciled');
    920       expect(result.ack).toBe(true);
    921       expect(result.counts.complete).toBe(1);
    922       expect(result.again).toBe('existing');
    923       expect(result.againAck).toBe(true);
    924     } else {
    925       expect(result.status).toBe('conflict');
    926       expect(result.ack || result.againAck).toBe(false);
    927     }
    928   });
    929 
    930 for (const hit of [1, 2])
    931   for (const fault of ['before_abort', 'after_abort'] as const)
    932     test(`nonce fact readonly${hit} ${fault} cannot fabricate completion and later exact operation may reconcile`, async ({
    933       page
    934     }) => {
    935       await setup(page);
    936       await verify(page);
    937       const predecessor = await wire(page);
    938       const result = await page.evaluate(
    939         async ({ hit, fault }) => {
    940           const f = window.nfFixture,
    941             hook = f.nativeReadonlyHook(hit, fault);
    942           window.nfRestore = hook.restore;
    943           const result = await f.appendNonce();
    944           hook.restore();
    945           const first = (await f.storedRow()).wire,
    946             next = await f.appendNonce();
    947           return {
    948             status: result.status,
    949             ack: !!result.acknowledgement,
    950             first,
    951             faults: hook.faults(),
    952             next: next.status,
    953             nextAck: !!next.acknowledgement
    954           };
    955         },
    956         { hit, fault }
    957       );
    958       expect(result.faults).toBe(1);
    959       expect(result.ack).toBe(false);
    960       if (hit === 1) {
    961         expect(result.first).toBe(predecessor);
    962         expect(result.next).toBe('saved');
    963       } else {
    964         expect(result.first).not.toBe(predecessor);
    965         expect(result.next).toBe('reconciled');
    966       }
    967       expect(result.nextAck).toBe(true);
    968     });
    969 
    970 for (const recovered of [false, true])
    971   for (const contention of ['owner_lock', 'shared_sdk_job'] as const)
    972     test(`${recovered ? 'recovered' : 'original'} genuine nonce append respects actual occupied ${contention} and preserves explicit same-proof retry`, async ({
    973       page
    974     }) => {
    975       await setup(page, recovered);
    976       await verify(page);
    977       const predecessor = await wire(page),
    978         net = traffic().length;
    979       const result = await page.evaluate(async (contention) => {
    980         const f = window.nfFixture,
    981           a = f.actors(),
    982           proof = f.nonceProof()!;
    983         let entered: (() => void) | undefined,
    984           release: (() => void) | undefined;
    985         const ready = new Promise<void>((resolve) => {
    986           entered = resolve;
    987         });
    988         async function hold() {
    989           entered?.();
    990           await new Promise<void>((resolve) => {
    991             release = resolve;
    992           });
    993         }
    994         const held =
    995           contention === 'owner_lock'
    996             ? navigator.locks.request(
    997                 'harvestcircle:owner:' + f.host.owner,
    998                 { mode: 'exclusive' },
    999                 hold
   1000               )
   1001             : window.nf.withIdlePrivateLocalStorage(a.session, hold);
   1002         window.nfPending = held;
   1003         await ready;
   1004         const genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence(
   1005             proof,
   1006             f.repository,
   1007             a.session,
   1008             f.host.policy
   1009           ),
   1010           before = f.host.counts(),
   1011           reads = f.nativeReadonlyHook(1, 'callback'),
   1012           writes = f.nativeWriteHook(() => {});
   1013         window.nfRestore = () => {
   1014           reads.restore();
   1015           writes.restore();
   1016           release?.();
   1017         };
   1018         let refused;
   1019         try {
   1020           const saved = await f.appendNonce();
   1021           refused = {
   1022             status: saved.status,
   1023             ack: !!saved.acknowledgement,
   1024             binding: !!f.nonceBinding(),
   1025             reads: reads.faults(),
   1026             puts: writes.hits(),
   1027             after: f.host.counts()
   1028           };
   1029         } finally {
   1030           reads.restore();
   1031           writes.restore();
   1032           release?.();
   1033           await held;
   1034         }
   1035         const refusedWire = (await f.storedRow()).wire,
   1036           sameProof =
   1037             f.nonceProof() === proof &&
   1038             !!window.nf.inboxProbeNonceVerificationEvidence(
   1039               proof,
   1040               f.repository,
   1041               a.session,
   1042               f.host.policy
   1043             ),
   1044           writesAfterRelease = f.nativeWriteHook(() => {});
   1045         window.nfRestore = writesAfterRelease.restore;
   1046         const first = await f.appendNonce(),
   1047           again = await f.appendNonce(),
   1048           putsAfterRelease = writesAfterRelease.hits();
   1049         writesAfterRelease.restore();
   1050         return {
   1051           genuineBefore,
   1052           before,
   1053           refused,
   1054           refusedWire,
   1055           sameProof,
   1056           first: first.status,
   1057           again: again.status,
   1058           sameAck: first.acknowledgement === again.acknowledgement,
   1059           current: f.nonceBinding()?.current(),
   1060           putsAfterRelease,
   1061           after: f.host.counts()
   1062         };
   1063       }, contention);
   1064       expect(result.genuineBefore && result.sameProof).toBe(true);
   1065       expect(result.refused).toEqual({
   1066         status: 'busy',
   1067         ack: false,
   1068         binding: false,
   1069         reads: 0,
   1070         puts: 0,
   1071         after: result.before
   1072       });
   1073       expect(result.refusedWire).toBe(predecessor);
   1074       expect(result.first).toBe('saved');
   1075       expect(result.again).toBe('existing');
   1076       expect(result.sameAck && result.current).toBe(true);
   1077       expect(result.putsAfterRelease).toBe(1);
   1078       expect(result.after).toEqual(result.before);
   1079       expect(traffic()).toHaveLength(net);
   1080     });
   1081 
   1082 test('genuine proof and native admission serialize parallel nonce append without extra SDK work', async ({
   1083   page
   1084 }) => {
   1085   await setup(page);
   1086   await verify(page);
   1087   const result = await page.evaluate(async () => {
   1088     const f = window.nfFixture,
   1089       before = f.host.counts(),
   1090       pair = await Promise.all([f.appendNonce(), f.appendNonce()]),
   1091       row = JSON.parse((await f.storedRow()).wire) as {
   1092         receipts: { status: string }[];
   1093       };
   1094     return {
   1095       states: pair.map((x) => x.status).sort(),
   1096       facts: row.receipts.filter((x) => x.status === 'nonce_verified').length,
   1097       before,
   1098       after: f.host.counts()
   1099     };
   1100   });
   1101   expect(result.states).toEqual(['busy', 'saved']);
   1102   expect(result.facts).toBe(1);
   1103   expect(result.after).toEqual(result.before);
   1104 });
   1105 
   1106 for (const loss of ['reader', 'head', 'session'] as const)
   1107   test(`actual pending decrypt ${loss} loss keeps original slot until settlement and never revives nonce proof`, async ({
   1108     page
   1109   }) => {
   1110     await setup(page);
   1111     await page.evaluate(() => {
   1112       const f = window.nfFixture;
   1113       f.host.mode('hold_decrypt');
   1114       window.nfPending = f.nonce();
   1115     });
   1116     await expect
   1117       .poll(() => page.evaluate(() => window.nfFixture.host.waiting()))
   1118       .toBe('decrypt');
   1119     const result = await page.evaluate(async (loss) => {
   1120       const f = window.nfFixture;
   1121       f.lose(loss);
   1122       const before = f.host.counts(),
   1123         busy = await window.nf.withIdlePrivateLocalStorage(
   1124           f.actors().session,
   1125           () => Promise.resolve('unreachable')
   1126         );
   1127       const after = f.host.counts();
   1128       f.host.mode('normal');
   1129       f.host.settle();
   1130       await window.nfPending;
   1131       return {
   1132         busy: busy.ok,
   1133         before,
   1134         after,
   1135         proof: !!f.nonceProof(),
   1136         binding: !!f.nonceBinding()
   1137       };
   1138     }, loss);
   1139     expect(result.busy || result.proof || result.binding).toBe(false);
   1140     expect(result.after).toEqual(result.before);
   1141   });
   1142 
   1143 for (const kind of ['head', 'native', 'reentry'] as const)
   1144   test(`actual final nonce clock ${kind} callback is fenced before physical read and proof mint`, async ({
   1145     page
   1146   }) => {
   1147     await setup(page);
   1148     const result = await page.evaluate(async (kind) => {
   1149       const f = window.nfFixture,
   1150         row = await f.storedRow(),
   1151         reader = f.captureNonce()!;
   1152       let same = false;
   1153       const hook = f.clockHook(() => {
   1154         if (kind === 'head') f.lose('head');
   1155         else if (kind === 'native')
   1156           window.nfPending = f.host.inject([{ ...row, wire: row.wire + '\n' }]);
   1157         else same = f.captureNonce() === reader;
   1158       });
   1159       window.nfRestore = hook.restore;
   1160       const result = await f.nonce(reader);
   1161       await window.nfPending;
   1162       return {
   1163         status: result.status,
   1164         proof: !!f.nonceProof(),
   1165         hits: hook.hits(),
   1166         same
   1167       };
   1168     }, kind);
   1169     expect(result.hits).toBeGreaterThan(0);
   1170     expect(result.status === 'nonce_verified').toBe(kind === 'reentry');
   1171     expect(result.proof).toBe(kind === 'reentry');
   1172     if (kind === 'reentry') expect(result.same).toBe(true);
   1173   });
   1174 
   1175 test('nonce append at full100 native rows preserves all protected rows and no automatic cleanup', async ({
   1176   page
   1177 }) => {
   1178   await setup(page);
   1179   await verify(page);
   1180   const result = await page.evaluate(async () => {
   1181     const f = window.nfFixture,
   1182       row = await f.storedRow(),
   1183       record = JSON.parse(row.wire) as { id: string; receipts: unknown[] },
   1184       others = Array.from({ length: 99 }, () => {
   1185         const id = crypto.randomUUID();
   1186         return {
   1187           ...row,
   1188           id,
   1189           wire: JSON.stringify({ ...record, id, receipts: [] })
   1190         };
   1191       });
   1192     await f.host.inject(others);
   1193     const saved = await f.appendNonce(),
   1194       final = await f.host.stored();
   1195     return {
   1196       status: saved.status,
   1197       ack: !!saved.acknowledgement,
   1198       count: final.length,
   1199       preserved: others.every((x) =>
   1200         final.some((y) => y.id === x.id && y.wire === x.wire)
   1201       )
   1202     };
   1203   });
   1204   expect(result).toEqual({
   1205     status: 'saved',
   1206     ack: true,
   1207     count: 100,
   1208     preserved: true
   1209   });
   1210 });
   1211 
   1212 test('actual8MiB capacity refuses nonce growth while preserving current proof and every original wire', async ({
   1213   page
   1214 }) => {
   1215   await setup(page);
   1216   await verify(page);
   1217   const result = await page.evaluate(async () => {
   1218     const f = window.nfFixture,
   1219       row = await f.storedRow(),
   1220       record = JSON.parse(row.wire) as {
   1221         id: string;
   1222         receipts: Record<string, unknown>[];
   1223       },
   1224       cap = 8 * 1024 * 1024,
   1225       bytes = (x: unknown) =>
   1226         new TextEncoder().encode(JSON.stringify(x)).length,
   1227       id = crypto.randomUUID(),
   1228       fact = { ...record.receipts[0], status: 'unknown' },
   1229       make = (n: number) => ({
   1230         ...row,
   1231         id,
   1232         wire: JSON.stringify({
   1233           ...record,
   1234           id,
   1235           receipts: Array.from({ length: n }, () => fact)
   1236         })
   1237       }),
   1238       zero = bytes(make(0)),
   1239       one = bytes(make(1)),
   1240       increment = bytes(make(2)) - one,
   1241       nonceDelta =
   1242         bytes({
   1243           ...row,
   1244           wire: JSON.stringify({
   1245             ...record,
   1246             receipts: [
   1247               ...record.receipts,
   1248               { ...record.receipts.at(-1), status: 'nonce_verified' }
   1249             ]
   1250           })
   1251         }) - bytes(row),
   1252       n = Math.floor((cap - bytes(row) - nonceDelta / 2 - one) / increment) + 1,
   1253       filler = make(n),
   1254       remaining = cap - bytes(row) - bytes(filler);
   1255     if (!(remaining > 0 && remaining < nonceDelta && zero < one))
   1256       throw Error('actual bounded native quota fixture');
   1257     await f.host.inject([filler]);
   1258     const saved = await f.appendNonce(),
   1259       final = await f.host.stored();
   1260     return {
   1261       status: saved.status,
   1262       ack: !!saved.acknowledgement,
   1263       remaining,
   1264       nonceDelta,
   1265       preserved:
   1266         final.some((x) => x.id === row.id && x.wire === row.wire) &&
   1267         final.some((x) => x.id === filler.id && x.wire === filler.wire)
   1268     };
   1269   });
   1270   expect(result.status).toBe('capacity');
   1271   expect(result.ack).toBe(false);
   1272   expect(result.preserved).toBe(true);
   1273   expect(result.remaining).toBeLessThan(result.nonceDelta);
   1274 });
   1275 
   1276 test('actual maximum revision cannot append a nonce fact after genuine recovered PUB and B2', async ({
   1277   page
   1278 }) => {
   1279   await page.evaluate(async () => {
   1280     const f = window.nfFixture,
   1281       row = await f.storedRow(),
   1282       record = JSON.parse(row.wire) as { revision: number };
   1283     record.revision = Number.MAX_SAFE_INTEGER - 2;
   1284     await f.host.inject([{ ...row, wire: JSON.stringify(record) }]);
   1285   });
   1286   await setup(page);
   1287   await verify(page);
   1288   const predecessor = await wire(page);
   1289   const result = await page.evaluate(async () => {
   1290     const saved = await window.nfFixture.appendNonce();
   1291     return { status: saved.status, ack: !!saved.acknowledgement };
   1292   });
   1293   expect(result).toEqual({ status: 'invalid_record', ack: false });
   1294   expect(await wire(page)).toBe(predecessor);
   1295 });