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 });