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