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