inbox-probe-retry.spec.ts (58347B)
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-retry.ts'; 8 declare global { 9 interface Window { 10 pt: typeof Fixture; 11 ptFixture: Awaited<ReturnType<typeof Fixture.makeRetryFixture>>; 12 ptPending?: Promise<unknown>; 13 ptRelease?: () => void; 14 ptRestore?: () => void; 15 ptClock?: ReturnType<Window['ptFixture']['installNetworkClock']>; 16 ptAbort?: AbortController; 17 ptDelayClose?: boolean; 18 ptFailClose?: boolean; 19 ptHeldClose?: (() => void)[]; 20 ptCloseCalls?: number; 21 } 22 } 23 let server: Awaited<ReturnType<typeof createStaticHarness>>, 24 sockets: WebSocketServer, 25 endpoint: string, 26 bundle: string, 27 head = '', 28 holdEvent = false, 29 holdRead = false, 30 challenge = false, 31 holdAuth = false; 32 const origins = [ 33 'wss://inbox.example.org', 34 'wss://peer.example.org', 35 'wss://archive.example.org' 36 ]; 37 const physical = new Set<WebSocket>(), 38 archived = new Map<string, unknown>(), 39 frames: { origin: string; frame: unknown[] }[] = []; 40 test.beforeAll(async () => { 41 server = await createStaticHarness(); 42 sockets = new WebSocketServer({ 43 host: '127.0.0.1', 44 port: 0, 45 maxPayload: 65536 46 }); 47 await once(sockets, 'listening'); 48 const address = sockets.address(); 49 if (!address || typeof address === 'string') 50 throw Error('actual loopback endpoint'); 51 endpoint = 'ws://127.0.0.1:' + address.port; 52 sockets.on('connection', (socket, request) => { 53 physical.add(socket); 54 socket.on('close', () => physical.delete(socket)); 55 const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get( 56 'origin' 57 )!; 58 if (challenge && origin !== 'wss://discovery.example.org') 59 socket.send(JSON.stringify(['AUTH', 'c2b-actual-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 const 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 archived.set(JSON.stringify([origin, event.id]), event); 82 if (!holdEvent) socket.send(JSON.stringify(['OK', event.id, true, ''])); 83 } else if (frame[0] === 'AUTH') { 84 const event = frame[1] as { id: string }; 85 if (!holdAuth) socket.send(JSON.stringify(['OK', event.id, true, ''])); 86 } 87 }); 88 }); 89 const result = await build({ 90 configFile: false, 91 logLevel: 'silent', 92 build: { 93 write: false, 94 minify: false, 95 lib: { 96 entry: fileURLToPath( 97 new URL('./harness/inbox-probe-retry.ts', import.meta.url) 98 ), 99 name: 'pt', 100 formats: ['iife'] 101 } 102 } 103 }); 104 const output = Array.isArray(result) ? result[0] : result; 105 if (!('output' in output)) throw Error('actual compiled retry harness'); 106 const chunks = output.output.filter((x) => x.type === 'chunk'); 107 expect(chunks).toHaveLength(1); 108 bundle = chunks[0].code; 109 }); 110 test.afterAll(async () => { 111 for (const socket of sockets.clients) socket.terminate(); 112 await new Promise<void>((resolve) => sockets.close(() => resolve())); 113 await server.close(); 114 }); 115 test.beforeEach(async ({ page }) => { 116 await expect.poll(() => physical.size).toBe(0); 117 head = ''; 118 frames.length = 0; 119 archived.clear(); 120 holdEvent = false; 121 holdRead = false; 122 challenge = false; 123 holdAuth = false; 124 await page.addInitScript( 125 ({ endpoint, origins }) => { 126 const Native = window.WebSocket; 127 window.WebSocket = class extends Native { 128 constructor(url: string | URL, protocols?: string | string[]) { 129 const origin = new URL(String(url)).origin; 130 if (!['wss://discovery.example.org', ...origins].includes(origin)) 131 throw Error('unapproved fixture origin'); 132 super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols); 133 } 134 override close(code?: number, reason?: string) { 135 window.ptCloseCalls = (window.ptCloseCalls ?? 0) + 1; 136 if (window.ptFailClose) 137 throw Error('actual controlled physical close failure'); 138 if (window.ptDelayClose) 139 (window.ptHeldClose ??= []).push(() => super.close(code, reason)); 140 else super.close(code, reason); 141 } 142 }; 143 }, 144 { endpoint, origins } 145 ); 146 await page.goto(server.url + '/search'); 147 await page.addScriptTag({ content: bundle }); 148 head = await page.evaluate(async (origins) => { 149 window.ptFixture = await window.pt.makeRetryFixture(); 150 return window.ptFixture.host.preferenceWire(origins); 151 }, origins); 152 await page.evaluate(async () => { 153 const f = window.ptFixture; 154 await f.open(); 155 if ((await f.prepareOriginal()).status !== 'prepared') 156 throw Error('actual original S3/R1 setup'); 157 }); 158 }); 159 test.afterEach(async ({ page }) => { 160 if (!page.isClosed()) 161 await page.evaluate(() => { 162 window.ptRestore?.(); 163 window.ptRelease?.(); 164 window.ptDelayClose = false; 165 window.ptFailClose = false; 166 for (const release of window.ptHeldClose ?? []) release(); 167 window.ptFixture.host.settle(); 168 window.ptFixture.close(); 169 }); 170 }); 171 async function recover(page: Page, fresh = false) { 172 expect( 173 await page.evaluate(async (fresh) => { 174 const f = window.ptFixture; 175 if (fresh) await f.freshSession(); 176 return (await f.recover())?.status; 177 }, fresh) 178 ).toBe('recovered'); 179 } 180 async function adopt(page: Page) { 181 expect( 182 await page.evaluate(async () => (await window.ptFixture.adopt()).status) 183 ).toBe('adopted'); 184 } 185 async function action(page: Page) { 186 expect( 187 await page.evaluate(async () => !!(await window.ptFixture.captureAction())) 188 ).toBe(true); 189 } 190 const privateFrames = () => 191 frames.filter((x) => x.origin !== 'wss://discovery.example.org'); 192 const events = () => privateFrames().filter((x) => x.frame[0] === 'EVENT'); 193 async function nativeWire(page: Page) { 194 return page.evaluate(async () => { 195 const f = window.ptFixture; 196 return (await f.host.stored()).find((x) => x.id === f.command())!.wire; 197 }); 198 } 199 200 test('cold original ciphertext recovery adopts readonly then observes actual same-artifact PUB READ native facts', async ({ 201 page 202 }) => { 203 const original = await nativeWire(page); 204 await recover(page, true); 205 const before = await page.evaluate(() => window.ptFixture.host.counts()); 206 await adopt(page); 207 await action(page); 208 expect(await nativeWire(page)).toBe(original); 209 expect(privateFrames()).toHaveLength(0); 210 expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual( 211 before 212 ); 213 const result = await page.evaluate(async () => { 214 const f = window.ptFixture, 215 pub = await f.publish(); 216 if (!pub) throw Error('actual publication missing'); 217 const appended = await f.append(pub), 218 read = await f.read(); 219 if (!read) throw Error('actual readback missing'); 220 const saved = await f.appendRead(read); 221 return { 222 pub, 223 appended, 224 read, 225 saved, 226 row: f.snapshot()?.record, 227 originalBinding: f.originalBinding() === undefined 228 }; 229 }); 230 expect(result.pub.status).toBe('accepted'); 231 expect(result.read.status).toBe('readback'); 232 expect(result.appended.status).toBe('saved'); 233 expect(result.saved.status).toBe('saved'); 234 expect(result.originalBinding).toBe(true); 235 const old = JSON.parse(original) as Record<string, unknown>; 236 expect(result.row?.id).toBe(old.id); 237 expect(result.row?.self).toEqual(old.self); 238 expect(result.row?.rumorHash).toBe(old.rumorHash); 239 expect(result.row?.createdAt).toBe(old.createdAt); 240 expect(result.row?.receipts.map((x) => x.role)).toEqual([ 241 'access_archive', 242 'access_readback' 243 ]); 244 expect(events()).toHaveLength(1); 245 const req = privateFrames().find((x) => x.frame[0] === 'REQ')!.frame[2]; 246 expect(req).toEqual({ 247 kinds: [1059], 248 ids: [result.row!.self!.eventId], 249 '#p': [result.row!.owner], 250 limit: 1 251 }); 252 expect( 253 await page.evaluate(() => { 254 const f = window.ptFixture, 255 a = f.actors(); 256 return !!window.pt.captureInboxProbeSealOperation( 257 a.session, 258 f.proof() as unknown as Parameters< 259 typeof window.pt.captureInboxProbeSealOperation 260 >[1], 261 'reviewed_inbox_probe_seal' 262 ); 263 }) 264 ).toBe(false); 265 }); 266 267 test('repeated adoption and capture retain actual acknowledgement action and native revision', async ({ 268 page 269 }) => { 270 await recover(page); 271 await adopt(page); 272 await action(page); 273 const wire = await nativeWire(page); 274 const result = await page.evaluate(async () => { 275 const f = window.ptFixture, 276 ack = f.acknowledgement(), 277 act = f.action(), 278 again = await f.adopt(), 279 next = await f.captureAction(); 280 return { 281 status: again.status, 282 sameAck: 'acknowledgement' in again && again.acknowledgement === ack, 283 sameAction: next === act 284 }; 285 }); 286 expect(result).toEqual({ 287 status: 'existing', 288 sameAck: true, 289 sameAction: true 290 }); 291 expect(await nativeWire(page)).toBe(wire); 292 expect(privateFrames()).toHaveLength(0); 293 }); 294 295 test('actual original and recovered permissions share combined per-origin three-attempt meter', async ({ 296 page 297 }) => { 298 const first = await page.evaluate(async () => { 299 const f = window.ptFixture, 300 result = await f.originalPublish(); 301 if (!result) throw Error('actual original effect'); 302 await f.append(result); 303 return result; 304 }); 305 expect(first.status).toBe('accepted'); 306 expect(first.attempt).toBe(1); 307 await recover(page); 308 await adopt(page); 309 await action(page); 310 const results = await page.evaluate(async () => { 311 const f = window.ptFixture, 312 read = await f.read(); 313 if (!read) throw Error('actual second action read'); 314 await f.appendRead(read); 315 const pub = await f.publish(); 316 if (!pub) throw Error('actual third action event'); 317 await f.append(pub); 318 const before = f.host.counts(), 319 exhausted = await f.publish(); 320 return { 321 read, 322 pub, 323 exhausted: exhausted === undefined, 324 before, 325 after: f.host.counts() 326 }; 327 }); 328 expect(results.read.attempt).toBe(2); 329 expect(results.pub.attempt).toBe(3); 330 expect(results.read.actionId).toBe(first.actionId); 331 expect(results.pub.actionId).toBe(first.actionId); 332 expect(results.exhausted).toBe(true); 333 expect(results.after).toEqual(results.before); 334 expect(events()).toHaveLength(2); 335 }); 336 337 test('new explicit controller recovery action replaces only ended clean action with same artifact', async ({ 338 page 339 }) => { 340 await recover(page); 341 await adopt(page); 342 await action(page); 343 const first = await page.evaluate(async () => { 344 const f = window.ptFixture, 345 result = await f.publish(); 346 if (!result) throw Error('actual first effect'); 347 await f.append(result); 348 return result; 349 }); 350 const source = JSON.parse(await nativeWire(page)) as Record<string, unknown>; 351 expect( 352 await page.evaluate( 353 async () => !!(await window.ptFixture.replaceController()) 354 ) 355 ).toBe(true); 356 await recover(page); 357 await adopt(page); 358 await action(page); 359 const second = await page.evaluate(async () => { 360 const f = window.ptFixture, 361 result = await f.publish(); 362 if (!result) throw Error('actual new action effect'); 363 await f.append(result); 364 return { result, row: f.snapshot()?.record }; 365 }); 366 expect(second.result.status).toBe('accepted'); 367 expect(second.result.attempt).toBe(1); 368 expect(second.result.actionId).not.toBe(first.actionId); 369 expect(second.row?.id).toBe(source.id); 370 expect(second.row?.self).toEqual(source.self); 371 expect(second.row?.receipts).toHaveLength(2); 372 }); 373 374 for (const phase of ['adoption', 'action'] as const) 375 test(`${phase} rejects exact-native physical alias before any provider or traffic`, async ({ 376 page 377 }) => { 378 await recover(page); 379 if (phase === 'action') await adopt(page); 380 const before = await page.evaluate(() => window.ptFixture.host.counts()); 381 await page.evaluate(async () => { 382 const f = window.ptFixture, 383 rows = await f.host.stored(); 384 const row = rows.find((x) => x.id === f.command())!; 385 await f.host.inject([{ ...row, wire: ' ' + row.wire }]); 386 }); 387 const refused = await page.evaluate(async (phase) => { 388 const f = window.ptFixture; 389 return phase === 'adoption' 390 ? !('acknowledgement' in (await f.adopt())) 391 : (await f.captureAction()) === undefined; 392 }, phase); 393 expect(refused).toBe(true); 394 expect(privateFrames()).toHaveLength(0); 395 expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual( 396 before 397 ); 398 }); 399 400 test('handwritten historical labels grant no native adoption or remote effect without original proof', async ({ 401 page 402 }) => { 403 const result = await page.evaluate(async () => { 404 const f = window.ptFixture, 405 a = f.actors(), 406 before = f.host.counts(); 407 const fake = { nonce_verified: true, accepted: true, current: () => true }; 408 const adoption = await window.pt.adoptRecoveredInboxProbe( 409 f.repository, 410 a.session, 411 a.access, 412 f.host.policy, 413 f.host.qualification, 414 fake as unknown as Parameters< 415 typeof window.pt.adoptRecoveredInboxProbe 416 >[5], 417 'reviewed_original_inbox_probe_retry' 418 ); 419 return { 420 refused: !('acknowledgement' in adoption), 421 before, 422 after: f.host.counts() 423 }; 424 }); 425 expect(result.refused).toBe(true); 426 expect(result.after).toEqual(result.before); 427 expect(privateFrames()).toHaveLength(0); 428 }); 429 430 test('actual native append of one genuine effect is idempotent without duplicate revision', async ({ 431 page 432 }) => { 433 await recover(page); 434 await adopt(page); 435 await action(page); 436 const result = await page.evaluate(async () => { 437 const f = window.ptFixture, 438 effect = await f.publish(); 439 if (!effect) throw Error('actual effect missing'); 440 const first = await f.append(effect), 441 revision = f.snapshot()?.record.revision, 442 again = await f.append(effect); 443 return { 444 first, 445 again, 446 revision, 447 after: f.snapshot()?.record.revision, 448 receipts: f.snapshot()?.record.receipts.length 449 }; 450 }); 451 expect(result.first.status).toBe('saved'); 452 expect(result.again.status).toBe('existing'); 453 expect(result.after).toBe(result.revision); 454 expect(result.receipts).toBe(1); 455 expect(events()).toHaveLength(1); 456 }); 457 458 test('real pending original key job blocks recovered action before any new key or meter', async ({ 459 page 460 }) => { 461 await recover(page); 462 await adopt(page); 463 await page.evaluate(() => { 464 const f = window.ptFixture; 465 f.host.mode('hold_key'); 466 window.ptPending = f.originalPublish(); 467 }); 468 await expect 469 .poll(() => page.evaluate(() => window.ptFixture.host.waiting())) 470 .toBe('key'); 471 const result = await page.evaluate(async () => { 472 const f = window.ptFixture, 473 before = f.host.counts(), 474 unavailable = await f.captureAction(); 475 return { 476 unavailable: unavailable === undefined, 477 before, 478 after: f.host.counts() 479 }; 480 }); 481 expect(result.unavailable).toBe(true); 482 expect(result.after).toEqual(result.before); 483 expect(events()).toHaveLength(0); 484 await page.evaluate(async () => { 485 window.ptFixture.host.mode('normal'); 486 window.ptFixture.host.settle(); 487 const effect = await window.ptPending; 488 if ( 489 !effect || 490 typeof effect !== 'object' || 491 !('status' in effect) || 492 effect.status !== 'accepted' 493 ) 494 throw Error('actual original publication did not settle accepted'); 495 }); 496 await action(page); 497 expect(events()).toHaveLength(1); 498 }); 499 500 test('actual pending AUTH acknowledgement retains shared SDK slot and blocks new Retry action', async ({ 501 page 502 }) => { 503 await recover(page); 504 await adopt(page); 505 challenge = true; 506 holdAuth = true; 507 await page.evaluate(async () => { 508 const f = window.ptFixture; 509 await window.pt.authenticateInboxAccess( 510 f.actors().access, 511 'wss://inbox.example.org', 512 'reviewed_inbox_connection_auth' 513 ); 514 }); 515 await expect 516 .poll(() => 517 page.evaluate(() => { 518 const f = window.ptFixture; 519 return window.pt.inboxAccessControllerSnapshot(f.actors().access) 520 ?.auth[0]?.state; 521 }) 522 ) 523 .toBe('challenge'); 524 await page.evaluate(() => { 525 const f = window.ptFixture; 526 window.ptPending = window.pt.respondInboxAccessAuthentication( 527 f.actors().access, 528 'wss://inbox.example.org', 529 'reviewed_inbox_auth_response' 530 ); 531 }); 532 await expect 533 .poll(() => privateFrames().filter((x) => x.frame[0] === 'AUTH').length) 534 .toBe(1); 535 const result = await page.evaluate(async () => { 536 const f = window.ptFixture, 537 before = f.host.counts(), 538 selected = await f.captureAction(); 539 return { refused: selected === undefined, before, after: f.host.counts() }; 540 }); 541 expect(result.refused).toBe(true); 542 expect(result.after).toEqual(result.before); 543 expect(events()).toHaveLength(0); 544 for (const socket of physical) { 545 const auth = privateFrames().find((x) => x.frame[0] === 'AUTH') 546 ?.frame[1] as { id: string }; 547 if (auth) socket.send(JSON.stringify(['OK', auth.id, true, ''])); 548 } 549 expect(await page.evaluate(() => window.ptPending)).toBe('accepted'); 550 await action(page); 551 }); 552 553 test('forged original wrap cannot retry actual retained failed private cleanup', async ({ 554 page 555 }) => { 556 const result = await page.evaluate(async () => { 557 const f = window.ptFixture, 558 a = f.actors(); 559 let calls = 0; 560 const off = window.pt.subscribePrivateSessionClose(a.session, () => { 561 calls++; 562 throw Error('controlled actual retained cleanup'); 563 }); 564 window.pt.closePrivateSession(a.session); 565 const before = calls; 566 const refused = await window.pt.commitInboxProbe( 567 f.repository, 568 a.session, 569 {} as Parameters<typeof window.pt.commitInboxProbe>[2], 570 'reviewed_inbox_probe_commit' 571 ); 572 const after = calls; 573 off(); 574 return { before, after, refused: !('acknowledgement' in refused) }; 575 }); 576 expect(result.before).toBe(1); 577 expect(result.after).toBe(1); 578 expect(result.refused).toBe(true); 579 expect(privateFrames()).toHaveLength(0); 580 }); 581 582 for (const scope of [ 583 'foreign_repository', 584 'same_owner_repository', 585 'copied_policy', 586 'copied_operator', 587 'other_controller', 588 'other_session', 589 'stale_head', 590 'original_identity', 591 'original_acknowledgement', 592 'unreviewed' 593 ] as const) 594 test(`genuine recovered adoption refuses ${scope} without provider native or network effects`, async ({ 595 page 596 }) => { 597 await recover(page); 598 const wire = await nativeWire(page); 599 const result = await page.evaluate(async (scope) => { 600 const f = window.ptFixture, 601 a = f.actors(); 602 let repository = f.repository, 603 session = a.session, 604 access = a.access, 605 policy = f.host.policy, 606 operator = f.host.qualification, 607 proof = f.proof(), 608 review: unknown = 'reviewed_original_inbox_probe_retry'; 609 const other = 610 scope === 'other_controller' || scope === 'other_session' 611 ? await f.alternateController(true) 612 : undefined; 613 const before = f.host.counts(); 614 if (scope === 'foreign_repository') 615 repository = f.host.foreignRepository(); 616 if (scope === 'same_owner_repository') repository = a.repository; 617 if (scope === 'copied_policy') policy = f.host.copiedPolicy(); 618 if (scope === 'copied_operator') { 619 const copy = window.pt.validateInboxOperatorQualification( 620 window.pt.inboxOperatorQualificationWire(operator, policy)! 621 ); 622 if (!copy) throw Error('actual same-wire operator'); 623 operator = copy; 624 } 625 if (other && scope === 'other_controller') access = other.access; 626 if (scope === 'other_session') { 627 session = other!.session; 628 } 629 if (scope === 'stale_head') a.churnHead(); 630 if (scope === 'original_identity') 631 proof = f.originalIdentity() as unknown as typeof proof; 632 if (scope === 'original_acknowledgement') 633 proof = f.originalAck() as unknown as typeof proof; 634 if (scope === 'unreviewed') review = 'reviewed_inbox_probe_network'; 635 const selected = await window.pt.adoptRecoveredInboxProbe( 636 repository, 637 session, 638 access, 639 policy, 640 operator, 641 proof!, 642 review 643 ); 644 other?.close(); 645 if (session !== a.session) window.pt.closePrivateSession(session); 646 return { 647 refused: !('acknowledgement' in selected), 648 before, 649 after: f.host.counts() 650 }; 651 }, scope); 652 expect(result.refused).toBe(true); 653 expect(result.after).toEqual(result.before); 654 expect(await nativeWire(page)).toBe(wire); 655 expect(privateFrames()).toHaveLength(0); 656 }); 657 658 for (const scope of [ 659 'foreign_repository', 660 'same_owner_repository', 661 'copied_policy', 662 'original_acknowledgement', 663 'proof', 664 'unreviewed', 665 'stale_head' 666 ] as const) 667 test(`recovered Retry capture refuses ${scope} before any provider or traffic`, async ({ 668 page 669 }) => { 670 await recover(page); 671 await adopt(page); 672 const wire = await nativeWire(page); 673 const result = await page.evaluate(async (scope) => { 674 const f = window.ptFixture, 675 a = f.actors(), 676 before = f.host.counts(); 677 let repository = f.repository, 678 policy = f.host.policy, 679 acknowledgement = f.acknowledgement(), 680 review: unknown = 'reviewed_original_inbox_probe_retry'; 681 if (scope === 'foreign_repository') 682 repository = f.host.foreignRepository(); 683 if (scope === 'same_owner_repository') repository = a.repository; 684 if (scope === 'copied_policy') policy = f.host.copiedPolicy(); 685 if (scope === 'original_acknowledgement') 686 acknowledgement = f.originalAck(); 687 if (scope === 'proof') 688 acknowledgement = f.proof() as unknown as typeof acknowledgement; 689 if (scope === 'unreviewed') review = 'reviewed_inbox_probe_network'; 690 if (scope === 'stale_head') a.churnHead(); 691 const selected = await window.pt.captureRecoveredInboxProbeRetryAction( 692 repository, 693 a.session, 694 policy, 695 acknowledgement!, 696 review 697 ); 698 return { refused: !selected, before, after: f.host.counts() }; 699 }, scope); 700 expect(result.refused).toBe(true); 701 expect(result.after).toEqual(result.before); 702 expect(await nativeWire(page)).toBe(wire); 703 expect(privateFrames()).toHaveLength(0); 704 }); 705 706 for (const phase of ['adoption', 'action'] as const) 707 for (const mutation of [ 708 'r0', 709 'unknown_tail', 710 'foreign_tail', 711 'missing', 712 'corrupt' 713 ] as const) 714 test(`${phase} observes complete physical owner scope with ${mutation}`, async ({ 715 page 716 }) => { 717 await recover(page); 718 if (phase === 'action') await adopt(page); 719 const before = await page.evaluate(() => window.ptFixture.host.counts()); 720 await page.evaluate(async (mutation) => { 721 const f = window.ptFixture, 722 row = (await f.host.stored()).find((x) => x.id === f.command())!; 723 if (mutation === 'missing') await f.removeFixtureRow(); 724 else if (mutation === 'corrupt') 725 await f.host.inject([{ ...row, wire: '{}' }]); 726 else if (mutation === 'r0') { 727 const record = JSON.parse(row.wire) as { 728 self: unknown; 729 revision: number; 730 }; 731 record.self = null; 732 record.revision = 0; 733 await f.host.inject([{ ...row, wire: JSON.stringify(record) }]); 734 } else 735 await f.host.inject([ 736 { 737 owner: mutation === 'foreign_tail' ? 'f'.repeat(64) : row.owner, 738 id: crypto.randomUUID(), 739 wire: '{"unrecognized":true}' 740 } 741 ]); 742 }, mutation); 743 const raw = await page.evaluate(() => window.ptFixture.host.stored()); 744 const accepted = await page.evaluate(async (phase) => { 745 const f = window.ptFixture; 746 return phase === 'adoption' 747 ? 'acknowledgement' in (await f.adopt()) 748 : !!(await f.captureAction()); 749 }, phase); 750 expect(accepted).toBe(mutation === 'foreign_tail'); 751 expect(await page.evaluate(() => window.ptFixture.host.stored())).toEqual( 752 raw 753 ); 754 expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual( 755 before 756 ); 757 expect(privateFrames()).toHaveLength(0); 758 }); 759 760 for (const phase of ['adoption', 'action'] as const) 761 for (const hit of phase === 'action' ? [1, 2] : [1]) 762 for (const fault of ['before', 'after'] as const) 763 test(`${phase} refuses actual readonly${hit} ${fault} native abort`, async ({ 764 page 765 }) => { 766 await recover(page); 767 if (phase === 'action') await adopt(page); 768 const wire = await nativeWire(page); 769 const result = await page.evaluate( 770 async ({ phase, hit, fault }) => { 771 const f = window.ptFixture, 772 before = f.host.counts(), 773 original = Object.getOwnPropertyDescriptor( 774 IDBIndex.prototype, 775 'openCursor' 776 )!.value as IDBIndex['openCursor']; 777 let selected = 0, 778 aborts = 0; 779 IDBIndex.prototype.openCursor = function ( 780 ...args: Parameters<IDBIndex['openCursor']> 781 ) { 782 const request = original.apply(this, args); 783 if ( 784 this.objectStore.name === 'private_sends' && 785 this.objectStore.transaction.mode === 'readonly' && 786 ++selected === hit 787 ) { 788 const tx = this.objectStore.transaction; 789 if (fault === 'before') { 790 aborts++; 791 tx.abort(); 792 } else 793 request.addEventListener( 794 'success', 795 () => { 796 aborts++; 797 tx.abort(); 798 }, 799 { once: true } 800 ); 801 } 802 return request; 803 }; 804 window.ptRestore = () => { 805 IDBIndex.prototype.openCursor = original; 806 }; 807 const refused = 808 phase === 'adoption' 809 ? !('acknowledgement' in (await f.adopt())) 810 : !(await f.captureAction()); 811 window.ptRestore(); 812 return { refused, aborts, before, after: f.host.counts() }; 813 }, 814 { phase, hit, fault } 815 ); 816 expect(result.refused).toBe(true); 817 expect(result.aborts).toBe(1); 818 expect(result.after).toEqual(result.before); 819 expect(await nativeWire(page)).toBe(wire); 820 expect(privateFrames()).toHaveLength(0); 821 }); 822 823 for (const phase of ['adoption', 'action'] as const) 824 test(`${phase} actual owner lock contention is inert and permits later explicit admission`, async ({ 825 page 826 }) => { 827 await recover(page); 828 if (phase === 'action') await adopt(page); 829 await page.evaluate(() => { 830 const f = window.ptFixture; 831 window.ptPending = navigator.locks.request( 832 'harvestcircle:owner:' + f.host.owner, 833 async () => { 834 await new Promise<void>((resolve) => { 835 window.ptRelease = resolve; 836 }); 837 } 838 ); 839 }); 840 await expect.poll(() => page.evaluate(() => !!window.ptRelease)).toBe(true); 841 const result = await page.evaluate(async (phase) => { 842 const f = window.ptFixture, 843 before = f.host.counts(); 844 const refused = 845 phase === 'adoption' 846 ? !('acknowledgement' in (await f.adopt())) 847 : !(await f.captureAction()); 848 return { refused, before, after: f.host.counts() }; 849 }, phase); 850 expect(result.refused).toBe(true); 851 expect(result.after).toEqual(result.before); 852 expect(privateFrames()).toHaveLength(0); 853 await page.evaluate(async () => { 854 window.ptRelease!(); 855 await window.ptPending; 856 }); 857 if (phase === 'adoption') await adopt(page); 858 else await action(page); 859 }); 860 861 test('concurrent readonly adoption and Retry capture return only one actual token without regeneration', async ({ 862 page 863 }) => { 864 await recover(page); 865 const result = await page.evaluate(async () => { 866 const f = window.ptFixture, 867 before = f.host.counts(); 868 const first = f.adopt(), 869 second = f.adopt(); 870 const [one, two] = await Promise.all([first, second]); 871 if (!('acknowledgement' in one)) throw Error('actual first adoption'); 872 const [action, reentry] = await Promise.all([ 873 f.captureAction(), 874 f.captureAction() 875 ]); 876 return { 877 first: one.status, 878 second: two.status, 879 action: !!action, 880 reentry: !reentry, 881 before, 882 after: f.host.counts() 883 }; 884 }); 885 expect(result.first).toBe('adopted'); 886 expect(result.second).toBe('busy'); 887 expect(result.action).toBe(true); 888 expect(result.reentry).toBe(true); 889 expect(result.after).toEqual(result.before); 890 expect(privateFrames()).toHaveLength(0); 891 }); 892 893 for (const callback of ['reentry', 'native_mutation', 'stale_head'] as const) 894 test(`actual action UUID ${callback} callback cannot mint competing or stale Retry authority`, async ({ 895 page 896 }) => { 897 await recover(page); 898 await adopt(page); 899 const result = await page.evaluate(async (callback) => { 900 const f = window.ptFixture, 901 before = f.host.counts(), 902 original = crypto.randomUUID.bind(crypto); 903 let callbacks = 0; 904 let other: Promise<unknown> | undefined; 905 const row = (await f.host.stored()).find((x) => x.id === f.command())!; 906 crypto.randomUUID = () => { 907 callbacks++; 908 if (callback === 'reentry') other = f.captureAction(); 909 else if (callback === 'native_mutation') 910 other = f.host.inject([{ ...row, wire: ' ' + row.wire }]); 911 else f.actors().churnHead(); 912 return original(); 913 }; 914 window.ptRestore = () => { 915 crypto.randomUUID = original; 916 }; 917 const selected = await f.captureAction(); 918 window.ptRestore(); 919 const reentered = await other; 920 return { 921 callbacks, 922 selected: !!selected, 923 reentered: !!reentered, 924 before, 925 after: f.host.counts() 926 }; 927 }, callback); 928 expect(result.callbacks).toBe(1); 929 expect(result.selected).toBe(callback === 'reentry'); 930 expect(result.reentered).toBe(false); 931 expect(result.after).toEqual(result.before); 932 expect(privateFrames()).toHaveLength(0); 933 }); 934 935 for (const pending of ['EVENT', 'REQ'] as const) 936 test(`actual pending ${pending} blocks new Retry action and pure pool observation until original settles`, async ({ 937 page 938 }) => { 939 await recover(page); 940 await adopt(page); 941 if (pending === 'EVENT') { 942 holdEvent = true; 943 await page.evaluate(() => { 944 window.ptPending = window.ptFixture.originalPublish(); 945 }); 946 } else { 947 expect( 948 await page.evaluate( 949 async () => (await window.ptFixture.originalPublish())?.status 950 ) 951 ).toBe('accepted'); 952 holdRead = true; 953 await page.evaluate(() => { 954 window.ptPending = window.ptFixture.originalRead(); 955 }); 956 } 957 await expect 958 .poll(() => privateFrames().filter((x) => x.frame[0] === pending).length) 959 .toBe(1); 960 const result = await page.evaluate(async () => { 961 const f = window.ptFixture, 962 before = f.host.counts(), 963 idle = f.idle(), 964 selected = await f.captureAction(); 965 return { idle, refused: !selected, before, after: f.host.counts() }; 966 }); 967 expect(result.idle).toBe(false); 968 expect(result.refused).toBe(true); 969 expect(result.after).toEqual(result.before); 970 if (pending === 'EVENT') { 971 const id = (events()[0].frame[1] as { id: string }).id; 972 for (const socket of physical) 973 socket.send(JSON.stringify(['OK', id, true, ''])); 974 } else { 975 const frame = privateFrames().find((x) => x.frame[0] === 'REQ')!; 976 const id = (frame.frame[2] as { ids: string[] }).ids[0]; 977 for (const socket of physical) { 978 socket.send( 979 JSON.stringify([ 980 'EVENT', 981 frame.frame[1], 982 archived.get(JSON.stringify([frame.origin, id])) 983 ]) 984 ); 985 socket.send(JSON.stringify(['EOSE', frame.frame[1]])); 986 } 987 } 988 expect( 989 ((await page.evaluate(() => window.ptPending)) as { status: string }) 990 .status 991 ).toBe(pending === 'EVENT' ? 'accepted' : 'readback'); 992 await action(page); 993 }); 994 995 test('genuine same-scope controller recapture retains the original controller and action meter', async ({ 996 page 997 }) => { 998 const first = await page.evaluate(() => window.ptFixture.originalPublish()); 999 expect(first?.status).toBe('accepted'); 1000 const result = await page.evaluate(async () => { 1001 const f = window.ptFixture, 1002 a = f.actors(), 1003 other = await f.alternateController(); 1004 const reader = window.pt.captureInboxProbeRecoveryReader( 1005 f.repository, 1006 a.identity, 1007 a.session, 1008 f.host.policy, 1009 other.access, 1010 f.host.qualification, 1011 f.command(), 1012 'reviewed_inbox_probe_recovery' 1013 ); 1014 if (!reader) throw Error('actual alternate recovery reader'); 1015 const proof = await window.pt.recoverInboxProbe(reader); 1016 if (!('proof' in proof)) throw Error('actual alternate proof'); 1017 const adopted = await window.pt.adoptRecoveredInboxProbe( 1018 f.repository, 1019 a.session, 1020 other.access, 1021 f.host.policy, 1022 f.host.qualification, 1023 proof.proof, 1024 'reviewed_original_inbox_probe_retry' 1025 ); 1026 if (!('acknowledgement' in adopted)) 1027 throw Error('actual alternate readonly adoption'); 1028 const before = f.host.counts(), 1029 selected = await window.pt.captureRecoveredInboxProbeRetryAction( 1030 f.repository, 1031 a.session, 1032 f.host.policy, 1033 adopted.acknowledgement, 1034 'reviewed_original_inbox_probe_retry' 1035 ); 1036 const permission = 1037 selected && 1038 window.pt.captureInboxProbePublication( 1039 f.repository, 1040 a.session, 1041 f.host.policy, 1042 adopted.acknowledgement, 1043 selected, 1044 'wss://inbox.example.org', 1045 'reviewed_inbox_probe_publication' 1046 ); 1047 const effect = 1048 permission && 1049 (await window.pt.publishInboxProbeArchiveAttempt( 1050 f.pool()!, 1051 permission, 1052 new AbortController().signal 1053 )); 1054 window.pt.stopInboxProbeRecoveryReader(reader); 1055 other.close(); 1056 return { 1057 sameController: other.access === a.access, 1058 effect, 1059 providerCalls: f.host.counts().keys - before.keys 1060 }; 1061 }); 1062 expect(result.sameController).toBe(true); 1063 expect(result.effect).toMatchObject({ 1064 status: 'accepted', 1065 attempt: 2, 1066 actionId: first!.actionId 1067 }); 1068 expect(result.providerCalls).toBe(1); 1069 expect(events()).toHaveLength(2); 1070 }); 1071 1072 test('same action has independent bounded three-attempt counters across exactly three frozen origins', async ({ 1073 page 1074 }) => { 1075 await recover(page); 1076 await adopt(page); 1077 await action(page); 1078 const result = await page.evaluate(async (origins) => { 1079 const f = window.ptFixture, 1080 effects = []; 1081 for (const origin of origins) { 1082 for (let i = 0; i < 3; i++) { 1083 const effect = await f.publish(origin); 1084 if (!effect) throw Error('actual permitted original artifact attempt'); 1085 await f.append(effect); 1086 effects.push({ 1087 status: effect.status, 1088 attempt: effect.attempt, 1089 actionId: effect.actionId 1090 }); 1091 } 1092 if (await f.read(origin)) 1093 throw Error('exhausted combined archive/read origin admitted'); 1094 } 1095 const before = f.host.counts(), 1096 foreign = await f.publish('wss://foreign.example.org'); 1097 return { effects, foreign: !foreign, before, after: f.host.counts() }; 1098 }, origins); 1099 expect(result.effects.map((x) => x.attempt)).toEqual([ 1100 1, 2, 3, 1, 2, 3, 1, 2, 3 1101 ]); 1102 expect(new Set(result.effects.map((x) => x.actionId)).size).toBe(1); 1103 expect(result.effects.every((x) => x.status === 'accepted')).toBe(true); 1104 expect(result.foreign).toBe(true); 1105 expect(result.after).toEqual(result.before); 1106 expect(events()).toHaveLength(9); 1107 expect(physical.size).toBeLessThanOrEqual(4); // Three private plus public discovery. 1108 }); 1109 1110 test('100 genuine command slots remain protected at source registry capacity without fixture deletion granting authority', async ({ 1111 page 1112 }) => { 1113 const result = await page.evaluate(async () => { 1114 const f = window.ptFixture, 1115 a = f.actors(), 1116 saved = []; 1117 for (let i = 0; i < 100; i++) { 1118 if (i) { 1119 if (!(await f.replaceController())) 1120 throw Error('actual next source controller'); 1121 if ((await f.prepareOriginal()).status !== 'prepared') 1122 throw Error('actual next original S3/R1'); 1123 } 1124 const action = window.pt.captureInboxProbePublicationAction( 1125 f.repository, 1126 a.session, 1127 f.host.policy, 1128 f.originalAck()!, 1129 'reviewed_inbox_probe_network' 1130 ); 1131 if (!action) throw Error('actual bounded command slot ' + i); 1132 saved.push(action); 1133 await f.removeFixtureRow(); 1134 } 1135 if (!(await f.replaceController())) 1136 throw Error('actual capacity controller'); 1137 if ((await f.prepareOriginal()).status !== 'prepared') 1138 throw Error('actual capacity original'); 1139 const row = (await f.host.stored()).find((x) => x.id === f.command())!; 1140 const before = f.host.counts(); 1141 const refused = !window.pt.captureInboxProbePublicationAction( 1142 f.repository, 1143 a.session, 1144 f.host.policy, 1145 f.originalAck()!, 1146 'reviewed_inbox_probe_network' 1147 ); 1148 if ((await f.recover())?.status !== 'recovered') 1149 throw Error('actual capacity recovery'); 1150 if (!('acknowledgement' in (await f.adopt()))) 1151 throw Error('actual capacity readonly adoption'); 1152 const afterRecovery = f.host.counts(), 1153 retryRefused = !(await f.captureAction()); 1154 return { 1155 slots: saved.length, 1156 refused, 1157 retryRefused, 1158 before, 1159 afterRecovery, 1160 after: f.host.counts(), 1161 wire: row.wire, 1162 current: (await f.host.stored()).find((x) => x.id === f.command())!.wire 1163 }; 1164 }); 1165 expect(result.slots).toBe(100); 1166 expect(result.refused).toBe(true); 1167 expect(result.retryRefused).toBe(true); 1168 expect(result.after).toEqual(result.afterRecovery); 1169 expect(result.current).toBe(result.wire); 1170 expect(privateFrames()).toHaveLength(0); 1171 }); 1172 1173 for (const lane of ['page', 'live'] as const) 1174 test(`actual foreground ${lane} owner blocks new Retry without disturbing its subscription`, async ({ 1175 page 1176 }) => { 1177 await recover(page); 1178 await adopt(page); 1179 holdRead = true; 1180 await page.evaluate((lane) => { 1181 const f = window.ptFixture, 1182 a = f.actors(); 1183 const pool = window.pt.getPrivatePool( 1184 a.session, 1185 f.host.policy, 1186 ['wss://inbox.example.org'], 1187 Object.freeze({}), 1188 'receive' 1189 ); 1190 if (!pool) throw Error('actual foreground pool scope'); 1191 const stop = 1192 lane === 'page' 1193 ? window.pt.subscribePrivatePage(pool, 1, () => {}) 1194 : window.pt.subscribePrivateLive(pool, () => {}); 1195 window.ptRelease = () => { 1196 stop(); 1197 }; 1198 }, lane); 1199 await expect 1200 .poll(() => privateFrames().filter((x) => x.frame[0] === 'REQ').length) 1201 .toBe(1); 1202 const framesBefore = privateFrames().slice(); 1203 const result = await page.evaluate(async () => { 1204 const f = window.ptFixture, 1205 before = f.host.counts(), 1206 idle = f.idle(), 1207 selected = await f.captureAction(); 1208 return { idle, refused: !selected, before, after: f.host.counts() }; 1209 }); 1210 expect(result.idle).toBe(false); 1211 expect(result.refused).toBe(true); 1212 expect(result.after).toEqual(result.before); 1213 expect(privateFrames()).toEqual(framesBefore); 1214 await page.evaluate(() => window.ptRelease!()); 1215 await expect 1216 .poll(() => page.evaluate(() => window.ptFixture.idle())) 1217 .toBe(true); 1218 await action(page); 1219 }); 1220 1221 test('actual B1 B2 predecessor facts survive fresh-session recovery and never skip new named effects', async ({ 1222 page 1223 }) => { 1224 const prior = await page.evaluate(async () => { 1225 const f = window.ptFixture, 1226 pub = await f.originalPublish(); 1227 if (!pub) throw Error('actual old B1'); 1228 await f.append(pub); 1229 const read = await f.originalRead(); 1230 if (!read) throw Error('actual old B2'); 1231 await f.appendRead(read); 1232 return { pub, read }; 1233 }); 1234 const predecessor = await nativeWire(page); 1235 await recover(page, true); 1236 await adopt(page); 1237 await action(page); 1238 expect(await nativeWire(page)).toBe(predecessor); 1239 expect(events()).toHaveLength(1); 1240 const fresh = await page.evaluate(async () => { 1241 const f = window.ptFixture, 1242 pub = await f.publish(); 1243 if (!pub) throw Error('actual fresh B1'); 1244 await f.append(pub); 1245 const read = await f.read(); 1246 if (!read) throw Error('actual fresh B2'); 1247 await f.appendRead(read); 1248 return { 1249 pub, 1250 read, 1251 row: f.snapshot()?.record, 1252 readiness: window.pt.inboxAccessControllerSnapshot(f.actors().access) 1253 ?.readiness 1254 }; 1255 }); 1256 expect(fresh.pub.status).toBe('accepted'); 1257 expect(fresh.read.status).toBe('readback'); 1258 expect(fresh.pub.actionId).not.toBe(prior.pub.actionId); 1259 expect(fresh.row?.receipts.slice(0, 2)).toEqual( 1260 (JSON.parse(predecessor) as { receipts: unknown[] }).receipts 1261 ); 1262 expect(fresh.row?.receipts).toHaveLength(4); 1263 expect(fresh.readiness).toBe('unavailable'); 1264 expect(events()).toHaveLength(2); 1265 }); 1266 1267 test('historical unknown labels remain unknown through adoption and require a new genuine observed effect', async ({ 1268 page 1269 }) => { 1270 await page.evaluate(async () => { 1271 const f = window.ptFixture, 1272 effect = await f.originalPublish(); 1273 if (!effect) throw Error('actual predecessor fixture'); 1274 await f.append(effect); 1275 const row = (await f.host.stored()).find((x) => x.id === f.command())!, 1276 record = JSON.parse(row.wire) as { receipts: { status: string }[] }; 1277 record.receipts[0].status = 'unknown'; 1278 await f.host.inject([{ ...row, wire: JSON.stringify(record) }]); 1279 }); 1280 const wire = await nativeWire(page); 1281 await recover(page, true); 1282 await adopt(page); 1283 await action(page); 1284 expect(await nativeWire(page)).toBe(wire); 1285 const result = await page.evaluate(async () => { 1286 const f = window.ptFixture, 1287 effect = await f.publish(); 1288 if (!effect) throw Error('actual fresh named effect'); 1289 await f.append(effect); 1290 return { effect, row: f.snapshot()?.record }; 1291 }); 1292 expect(result.effect.status).toBe('accepted'); 1293 expect(result.row?.receipts.map((x) => x.status)).toEqual([ 1294 'unknown', 1295 'accepted' 1296 ]); 1297 expect(events()).toHaveLength(2); 1298 }); 1299 1300 test('genuine original C1 nonce capability is isolated from recovered Retry and recovered readback cannot issue C1 proof', async ({ 1301 page 1302 }) => { 1303 await page.evaluate(async () => { 1304 const f = window.ptFixture, 1305 a = f.actors(); 1306 if (!(await f.originalPublish())) 1307 throw Error('actual original publication'); 1308 const read = await f.originalRead(); 1309 if (!read) throw Error('actual original read'); 1310 const reader = window.pt.captureInboxProbeNonceReader( 1311 f.repository, 1312 a.identity, 1313 a.session, 1314 f.host.policy, 1315 read, 1316 'reviewed_inbox_probe_nonce_decryption' 1317 ); 1318 if (!reader) throw Error('actual original C1 reader'); 1319 const proof = await window.pt.readInboxProbeNonce(reader); 1320 if (!('proof' in proof)) throw Error('actual original C1 proof'); 1321 const before = f.host.counts(); 1322 const selected = await window.pt.adoptRecoveredInboxProbe( 1323 f.repository, 1324 a.session, 1325 a.access, 1326 f.host.policy, 1327 f.host.qualification, 1328 proof.proof as unknown as Parameters< 1329 typeof window.pt.adoptRecoveredInboxProbe 1330 >[5], 1331 'reviewed_original_inbox_probe_retry' 1332 ); 1333 if ( 1334 'acknowledgement' in selected || 1335 JSON.stringify(before) !== JSON.stringify(f.host.counts()) 1336 ) 1337 throw Error('C1 crossed recovered Retry authority'); 1338 window.pt.stopInboxProbeNonceReader(reader); 1339 }); 1340 await recover(page); 1341 await adopt(page); 1342 await action(page); 1343 const result = await page.evaluate(async () => { 1344 const f = window.ptFixture, 1345 a = f.actors(), 1346 read = await f.read(); 1347 if (!read) throw Error('actual recovered readback'); 1348 const before = f.host.counts(); 1349 const reader = window.pt.captureInboxProbeNonceReader( 1350 f.repository, 1351 a.identity, 1352 a.session, 1353 f.host.policy, 1354 read, 1355 'reviewed_inbox_probe_nonce_decryption' 1356 ); 1357 return { refused: !reader, before, after: f.host.counts(), read }; 1358 }); 1359 expect(result.refused).toBe(true); 1360 expect(result.after).toEqual(result.before); 1361 expect(result.read.status).toBe('readback'); 1362 expect(result.read.attempt).toBe(3); 1363 }); 1364 1365 test('actual measured cumulative 45-second network allowance stays exhausted across original recovery', async ({ 1366 page 1367 }) => { 1368 await page.evaluate(() => { 1369 const f = window.ptFixture; 1370 window.ptClock = f.installNetworkClock(); 1371 window.ptRestore = () => window.ptClock!.restore(); 1372 }); 1373 holdEvent = true; 1374 await page.evaluate(() => { 1375 window.ptPending = window.ptFixture.originalPublish(); 1376 }); 1377 await expect.poll(() => events().length).toBe(1); 1378 await page.evaluate(() => window.ptClock!.advance(30000)); 1379 const id = (events()[0].frame[1] as { id: string }).id; 1380 for (const socket of physical) 1381 socket.send(JSON.stringify(['OK', id, true, ''])); 1382 expect( 1383 ((await page.evaluate(() => window.ptPending)) as { status: string }).status 1384 ).toBe('accepted'); 1385 await recover(page); 1386 await adopt(page); 1387 await action(page); 1388 holdRead = true; 1389 await page.evaluate(() => { 1390 window.ptPending = window.ptFixture.read(); 1391 }); 1392 await expect 1393 .poll(() => privateFrames().filter((x) => x.frame[0] === 'REQ').length) 1394 .toBe(1); 1395 await page.evaluate(() => window.ptClock!.advance(15001)); 1396 const timed = (await page.evaluate(() => window.ptPending)) as { 1397 status: string; 1398 attempt: number; 1399 }; 1400 expect(timed).toMatchObject({ status: 'timed_out', attempt: 2 }); 1401 const result = await page.evaluate(async () => { 1402 const f = window.ptFixture, 1403 before = f.host.counts(), 1404 refused = !(await f.publish()); 1405 return { 1406 refused, 1407 before, 1408 after: f.host.counts(), 1409 observations: window.ptClock!.observations() 1410 }; 1411 }); 1412 expect(result.refused).toBe(true); 1413 expect(result.after).toEqual(result.before); 1414 expect(result.observations).toBeGreaterThan(0); 1415 expect(events()).toHaveLength(1); 1416 }); 1417 1418 for (const fault of ['held', 'failed'] as const) 1419 test(`actual original ${fault} physical cleanup blocks recovered authority without retrying cleanup implicitly`, async ({ 1420 page 1421 }) => { 1422 await recover(page); 1423 await adopt(page); 1424 holdEvent = true; 1425 await page.evaluate(() => { 1426 window.ptAbort = new AbortController(); 1427 window.ptPending = window.ptFixture.originalPublish( 1428 undefined, 1429 window.ptAbort.signal 1430 ); 1431 }); 1432 await expect.poll(() => events().length).toBe(1); 1433 const result = await page.evaluate(async (fault) => { 1434 const f = window.ptFixture, 1435 acknowledgement = f.acknowledgement()!; 1436 window.ptDelayClose = fault === 'held'; 1437 window.ptFailClose = fault === 'failed'; 1438 window.ptAbort!.abort(); 1439 let failed = false; 1440 try { 1441 f.stop(); 1442 } catch { 1443 failed = true; 1444 } 1445 const effect = await window.ptPending, 1446 applied = await f.append(effect as Parameters<typeof f.append>[0]); 1447 if (!['saved', 'existing', 'reconciled'].includes(applied.status)) 1448 throw Error( 1449 'actual stopped archive native bookkeeping ' + applied.status 1450 ); 1451 const before = f.host.counts(), 1452 held = window.ptHeldClose?.length ?? 0; 1453 const idle = f.idle(), 1454 selected = await window.pt.captureRecoveredInboxProbeRetryAction( 1455 f.repository, 1456 f.actors().session, 1457 f.host.policy, 1458 acknowledgement, 1459 'reviewed_original_inbox_probe_retry' 1460 ); 1461 return { 1462 effect, 1463 failed, 1464 idle, 1465 refused: !selected, 1466 held, 1467 afterHeld: window.ptHeldClose?.length ?? 0, 1468 before, 1469 after: f.host.counts() 1470 }; 1471 }, fault); 1472 expect(result.effect).toMatchObject({ status: 'stopped', attempt: 1 }); 1473 expect(result.idle).toBe(false); 1474 expect(result.refused).toBe(true); 1475 expect(result.afterHeld).toBe(result.held); 1476 expect(result.after).toEqual(result.before); 1477 if (fault === 'failed') expect(result.failed).toBe(true); 1478 else expect(result.held).toBeGreaterThan(0); 1479 const observed = await page.evaluate(async () => { 1480 const before = window.ptCloseCalls ?? 0, 1481 replacement = await window.ptFixture.replacementWhilePending(); 1482 return { replacement, before, after: window.ptCloseCalls ?? 0 }; 1483 }); 1484 const replacement = observed.replacement; 1485 console.info( 1486 JSON.stringify({ 1487 fixture: 'C2B_ACTUAL_FRESH_REPLACEMENT_PHYSICAL_GATE', 1488 fault, 1489 gate: replacement.gate, 1490 genuineCurrentBinding: 1491 replacement.gate === 'actual_retry_admission' 1492 ? replacement.genuineCurrentBinding 1493 : null, 1494 uuidCalls: 1495 replacement.gate === 'actual_retry_admission' 1496 ? replacement.uuids 1497 : null 1498 }) 1499 ); 1500 expect(replacement.gate).toBe('actual_retry_admission'); 1501 if (replacement.gate !== 'actual_retry_admission') 1502 throw Error('genuine fresh Retry must reach the original physical gate'); 1503 expect(replacement.genuineCurrentBinding).toBe(true); 1504 expect(replacement.refused).toBe(true); 1505 expect(replacement.uuids).toBe(0); 1506 expect(replacement.after).toEqual(replacement.before); 1507 expect(replacement.closesAfter).toBe(replacement.closesBefore); 1508 expect(events()).toHaveLength(1); 1509 await page.evaluate(() => { 1510 window.ptDelayClose = false; 1511 window.ptFailClose = false; 1512 for (const release of window.ptHeldClose ?? []) release(); 1513 // A real failed close has no held callback to release: explicitly retry 1514 // its ORIGINAL Stop before waiting for the resulting native close. 1515 try { 1516 window.ptFixture.stop(); 1517 } catch (error) { 1518 if ( 1519 !(error instanceof Error) || 1520 !['private_pool_close_pending', 'private_pool_close_failed'].includes( 1521 error.message 1522 ) 1523 ) 1524 throw error; 1525 } 1526 }); 1527 await expect.poll(() => events().length).toBe(1); 1528 await expect.poll(() => physical.size).toBeLessThanOrEqual(1); 1529 await page.evaluate(() => window.ptFixture.stop()); 1530 holdEvent = false; 1531 expect( 1532 await page.evaluate( 1533 async () => !!(await window.ptFixture.replaceController()) 1534 ) 1535 ).toBe(true); 1536 await recover(page); 1537 await adopt(page); 1538 await action(page); 1539 const next = await page.evaluate(() => window.ptFixture.publish()); 1540 expect(next).toMatchObject({ status: 'accepted', attempt: 1 }); 1541 expect(next!.actionId).not.toBe( 1542 (result.effect as { actionId: string }).actionId 1543 ); 1544 expect(events()).toHaveLength(2); 1545 expect(events()[1].frame[1]).toEqual(events()[0].frame[1]); 1546 }); 1547 1548 test('actual failed original SDK teardown stays protected without implicit Retry cleanup', async ({ 1549 page 1550 }) => { 1551 await recover(page); 1552 await adopt(page); 1553 holdEvent = true; 1554 await page.evaluate(() => { 1555 const f = window.ptFixture, 1556 fault = f.installAttemptTeardownFailure(); 1557 window.ptRestore = fault.restore; 1558 window.ptAbort = new AbortController(); 1559 window.ptPending = f.originalPublish(undefined, window.ptAbort.signal); 1560 }); 1561 await expect.poll(() => events().length).toBe(1); 1562 const result = await page.evaluate(async () => { 1563 const f = window.ptFixture; 1564 window.ptAbort!.abort(); 1565 const effect = await window.ptPending; 1566 const before = f.host.counts(), 1567 idle = f.idle(), 1568 selected = await f.captureAction(); 1569 return { effect, idle, refused: !selected, before, after: f.host.counts() }; 1570 }); 1571 expect(result.effect).toMatchObject({ status: 'unknown', attempt: 1 }); 1572 expect(result.idle).toBe(false); 1573 expect(result.refused).toBe(true); 1574 expect(result.after).toEqual(result.before); 1575 expect(events()).toHaveLength(1); 1576 await page.evaluate(() => { 1577 window.ptRestore!(); 1578 window.ptFixture.stop(); 1579 }); 1580 }); 1581 1582 for (const fault of ['aborted', 'uncertain', 'changed_successor'] as const) 1583 test(`actual recovered native append ${fault} preserves strict original successor evidence`, async ({ 1584 page 1585 }) => { 1586 await recover(page); 1587 await adopt(page); 1588 await action(page); 1589 const result = await page.evaluate(async (fault) => { 1590 const f = window.ptFixture, 1591 effect = await f.publish(); 1592 if (!effect) throw Error('actual recovered SDK effect'); 1593 const before = await f.host.stored(), 1594 control = f.installCommitFault(fault); 1595 window.ptRestore = control.restore; 1596 const first = await f.append(effect); 1597 control.restore(); 1598 const afterFirst = await f.host.stored(), 1599 second = await f.append(effect); 1600 return { first, second, before, afterFirst, native: control.counts() }; 1601 }, fault); 1602 if (fault === 'aborted') { 1603 expect(result.first.status).toBe('aborted'); 1604 expect(result.afterFirst).toEqual(result.before); 1605 expect(result.second.status).toBe('saved'); 1606 expect(result.native).toMatchObject({ 1607 putSuccess: 1, 1608 complete: 0, 1609 aborted: 1 1610 }); 1611 } else { 1612 expect(result.native).toMatchObject({ 1613 putSuccess: 1, 1614 complete: 1, 1615 aborted: 0 1616 }); 1617 expect(result.native.abortRefused).toBeGreaterThan(0); 1618 if (fault === 'uncertain') { 1619 expect(result.first.status).toBe('reconciled'); 1620 expect(result.second.status).toBe('existing'); 1621 } else { 1622 expect(result.native.changed).toBe(1); 1623 expect(['conflict', 'unknown_completion']).toContain( 1624 result.first.status 1625 ); 1626 expect(result.second.status).not.toBe('saved'); 1627 } 1628 } 1629 expect(events()).toHaveLength(1); 1630 }); 1631 1632 test('actual recovered effect bookkeeping remains eligible after controller loss without restoring authority', async ({ 1633 page 1634 }) => { 1635 await recover(page); 1636 await adopt(page); 1637 await action(page); 1638 const result = await page.evaluate(async () => { 1639 const f = window.ptFixture, 1640 effect = await f.publish(); 1641 if (!effect) throw Error('actual recovered accepted effect'); 1642 window.pt.closeInboxAccessController(f.actors().access); 1643 const before = f.host.counts(), 1644 appended = await f.append(effect), 1645 refused = !(await f.captureAction()); 1646 const row = (await f.host.stored()).find((x) => x.id === f.command())!; 1647 return { 1648 appended, 1649 refused, 1650 before, 1651 after: f.host.counts(), 1652 row: JSON.parse(row.wire) as { receipts: { status: string }[] } 1653 }; 1654 }); 1655 expect(result.appended.status).toBe('saved'); 1656 expect(result.refused).toBe(true); 1657 expect(result.after).toEqual(result.before); 1658 expect(result.row.receipts[0].status).toBe('accepted'); 1659 expect(events()).toHaveLength(1); 1660 }); 1661 1662 test('genuine ordinary recovery capability cannot supply original-probe Retry provenance', async ({ 1663 page 1664 }) => { 1665 await recover(page); 1666 const result = await page.evaluate(async () => { 1667 const f = window.ptFixture, 1668 a = f.actors(), 1669 provider = Object.getOwnPropertyDescriptor(window, 'nostr')!; 1670 const ordinary = await window.pt.makeOrdinaryRecoveryFixture(); 1671 const token = ordinary.capture(); 1672 Object.defineProperty(window, 'nostr', provider); 1673 const before = f.host.counts(), 1674 raw = await f.host.stored(); 1675 try { 1676 const selected = await window.pt.adoptRecoveredInboxProbe( 1677 f.repository, 1678 a.session, 1679 a.access, 1680 f.host.policy, 1681 f.host.qualification, 1682 token as unknown as Parameters< 1683 typeof window.pt.adoptRecoveredInboxProbe 1684 >[5], 1685 'reviewed_original_inbox_probe_retry' 1686 ); 1687 const action = await window.pt.captureRecoveredInboxProbeRetryAction( 1688 f.repository, 1689 a.session, 1690 f.host.policy, 1691 token as unknown as Parameters< 1692 typeof window.pt.captureRecoveredInboxProbeRetryAction 1693 >[3], 1694 'reviewed_original_inbox_probe_retry' 1695 ); 1696 return { 1697 refused: !('acknowledgement' in selected) && !action, 1698 before, 1699 after: f.host.counts(), 1700 unchanged: JSON.stringify(raw) === JSON.stringify(await f.host.stored()) 1701 }; 1702 } finally { 1703 ordinary.close(); 1704 Object.defineProperty(window, 'nostr', provider); 1705 } 1706 }); 1707 expect(result.refused).toBe(true); 1708 expect(result.after).toEqual(result.before); 1709 expect(result.unchanged).toBe(true); 1710 expect(privateFrames()).toHaveLength(0); 1711 });