inbox-probe-retry.ts (23233B)
1 import { 2 makeRecoveryFixture, 3 openRecoveryContext 4 } from './inbox-probe-recovery.ts'; 5 import { RelayPool } from 'applesauce-relay'; 6 import { finalize } from 'rxjs'; 7 import { 8 createPublicRuntimeContext, 9 mountPublicRuntime, 10 closePublicRuntime, 11 createPublicView, 12 beginPublicViewRun, 13 disposePublicView 14 } from '../../../src/lib/runtime/public-runtime.ts'; 15 import { 16 resolveInboxPreference, 17 settleInboxResolver, 18 inboxResolutionSnapshot 19 } from '../../../src/lib/messaging/resolve-inbox.ts'; 20 import { 21 createInboxAccessController, 22 closeInboxAccessController, 23 inboxAccessControllerSnapshot, 24 type InboxAccessController 25 } from '../../../src/lib/messaging/inbox-access-controller.ts'; 26 import { privateSessionSnapshot } from '../../../src/lib/runtime/private-session.ts'; 27 import { 28 openBrowserDatabase, 29 closeBrowserDatabase, 30 browserDatabaseTransaction 31 } from '../../../src/lib/persistence/database.ts'; 32 import { 33 reserveInboxProbeIdentity, 34 inboxProbeSnapshot, 35 type InboxProbeIdentity 36 } from '../../../src/lib/nostr/inbox-access.ts'; 37 import { 38 captureInboxProbeSealOperation, 39 buildInboxProbeSeal 40 } from '../../../src/lib/nostr/seal-builder.ts'; 41 import { buildInboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts'; 42 import { 43 commitInboxProbe, 44 adoptRecoveredInboxProbe, 45 inboxProbeAcknowledgementSnapshot, 46 inboxProbePublicationBinding, 47 recoveredInboxProbePublicationBinding, 48 commitInboxProbeArchiveAttempt, 49 commitInboxProbeReadbackAttempt, 50 type InboxProbeAcknowledgement 51 } from '../../../src/lib/persistence/inbox-probes.ts'; 52 import { 53 captureInboxProbeRecoveryReader, 54 recoverInboxProbe, 55 stopInboxProbeRecoveryReader, 56 type InboxProbeRecoveryReader, 57 type RecoveredInboxProbe 58 } from '../../../src/lib/nostr/self-recovery-reader.ts'; 59 import { 60 captureInboxProbePublicationAction, 61 captureRecoveredInboxProbeRetryAction, 62 captureInboxProbePublication, 63 captureInboxProbeReadback, 64 type InboxProbePublicationAction 65 } from '../../../src/lib/nostr/private-publisher.ts'; 66 import { 67 getPrivatePool, 68 closePrivatePool, 69 privatePoolProbeRetryIdle, 70 publishInboxProbeArchiveAttempt, 71 readInboxProbeAttempt, 72 type PrivatePool, 73 type InboxProbeArchiveAttemptResult, 74 type InboxProbeReadbackAttemptResult 75 } from '../../../src/lib/nostr/private-pool.ts'; 76 export * from './inbox-probe-recovery.ts'; 77 export { 78 makeFixture as makeOrdinaryRecoveryFixture, 79 resumeEncryptedPreparation, 80 resumeRecoveredRumor 81 } from './resume-preparation.ts'; 82 export { 83 adoptRecoveredInboxProbe, 84 captureRecoveredInboxProbeRetryAction, 85 recoveredInboxProbePublicationBinding, 86 inboxProbePublicationBinding, 87 privatePoolProbeRetryIdle, 88 commitInboxProbe, 89 captureInboxProbePublicationAction, 90 captureInboxProbePublication, 91 captureInboxProbeReadback 92 }; 93 export { 94 authenticateInboxAccess, 95 respondInboxAccessAuthentication, 96 inboxAccessControllerSnapshot 97 } from '../../../src/lib/messaging/inbox-access-controller.ts'; 98 export { 99 closePrivateSession, 100 subscribePrivateSessionClose, 101 withIdlePrivateLocalStorage 102 } from '../../../src/lib/runtime/private-session.ts'; 103 104 // Every actor and durable effect below is an actual source factory. The reused 105 // host owns only ephemeral test crypto/native fixture access, never readiness. 106 export async function makeRetryFixture() { 107 const host = await makeRecoveryFixture(), 108 publicContext = createPublicRuntimeContext(), 109 runtime = mountPublicRuntime(publicContext, host.policy); 110 if (!runtime) throw Error('actual shared public discovery'); 111 const shared = { context: publicContext, runtime }; 112 let actor: Awaited<ReturnType<typeof openRecoveryContext>> | undefined, 113 access: InboxAccessController | undefined, 114 replacementView: ReturnType<typeof createPublicView> | undefined, 115 originalIdentity: InboxProbeIdentity | undefined, 116 originalAck: InboxProbeAcknowledgement | undefined, 117 originalAction: InboxProbePublicationAction | undefined, 118 reader: InboxProbeRecoveryReader | undefined, 119 proof: RecoveredInboxProbe | undefined, 120 acknowledgement: InboxProbeAcknowledgement | undefined, 121 action: InboxProbePublicationAction | undefined, 122 command: string | undefined, 123 pool: PrivatePool | undefined; 124 const repository = host.repository; 125 function currentActor() { 126 if (!actor || !access) throw Error('actual current private actors missing'); 127 return { ...actor, access }; 128 } 129 function acquire() { 130 const a = currentActor(); 131 pool ??= getPrivatePool( 132 a.session, 133 host.policy, 134 [ 135 'wss://inbox.example.org', 136 'wss://peer.example.org', 137 'wss://archive.example.org' 138 ], 139 access, 140 'access' 141 ); 142 if (!pool) throw Error('actual current private scope unavailable'); 143 return pool; 144 } 145 function stopCurrentController() { 146 if (reader) stopInboxProbeRecoveryReader(reader); 147 if (access) closeInboxAccessController(access); 148 if (pool) closePrivatePool(pool); 149 pool = undefined; 150 if (replacementView) disposePublicView(replacementView); 151 replacementView = undefined; 152 reader = undefined; 153 proof = undefined; 154 acknowledgement = undefined; 155 action = undefined; 156 } 157 return { 158 host, 159 repository, 160 actors: currentActor, 161 sharedPublicRuntime: () => runtime, 162 originalIdentity: () => originalIdentity, 163 originalAck: () => originalAck, 164 proof: () => proof, 165 acknowledgement: () => acknowledgement, 166 action: () => action, 167 command: () => command, 168 pool: () => pool, 169 async open() { 170 actor = await openRecoveryContext( 171 host.owner, 172 host.policy, 173 host.qualification, 174 crypto.randomUUID(), 175 shared 176 ); 177 access = actor.access; 178 }, 179 async prepareOriginal() { 180 if (reader) stopInboxProbeRecoveryReader(reader); 181 reader = undefined; 182 proof = undefined; 183 acknowledgement = undefined; 184 action = undefined; 185 const a = currentActor(), 186 reserved = await reserveInboxProbeIdentity( 187 repository, 188 a.session, 189 host.policy, 190 a.access, 191 host.qualification, 192 'reviewed_inbox_probe_reservation' 193 ); 194 if (!('identity' in reserved)) return reserved; 195 originalIdentity = reserved.identity; 196 const selected = inboxProbeSnapshot(originalIdentity); 197 if (!selected) throw Error('actual original reserved identity'); 198 command = selected.id; 199 const operation = captureInboxProbeSealOperation( 200 a.session, 201 originalIdentity, 202 'reviewed_inbox_probe_seal' 203 ); 204 if (!operation) throw Error('actual original seal admission'); 205 const sealed = await buildInboxProbeSeal(operation); 206 if (!('seal' in sealed)) return sealed; 207 const wrap = buildInboxProbeGiftwrap( 208 sealed.seal, 209 'reviewed_inbox_probe_wrap' 210 ); 211 if (!wrap) throw Error('actual original wrap admission'); 212 const result = await commitInboxProbe( 213 repository, 214 a.session, 215 wrap, 216 'reviewed_inbox_probe_commit' 217 ); 218 if ('acknowledgement' in result) originalAck = result.acknowledgement; 219 originalAction = undefined; 220 return result; 221 }, 222 async recover() { 223 const a = currentActor(); 224 if (!command) throw Error('actual original selection missing'); 225 reader ??= captureInboxProbeRecoveryReader( 226 repository, 227 a.identity, 228 a.session, 229 host.policy, 230 a.access, 231 host.qualification, 232 command, 233 'reviewed_inbox_probe_recovery' 234 ); 235 if (!reader) return undefined; 236 const result = await recoverInboxProbe(reader); 237 if ('proof' in result) proof = result.proof; 238 return result; 239 }, 240 async adopt(review: unknown = 'reviewed_original_inbox_probe_retry') { 241 const a = currentActor(); 242 if (!proof) throw Error('actual recovered proof missing'); 243 const result = await adoptRecoveredInboxProbe( 244 repository, 245 a.session, 246 a.access, 247 host.policy, 248 host.qualification, 249 proof, 250 review 251 ); 252 if ('acknowledgement' in result) acknowledgement = result.acknowledgement; 253 return result; 254 }, 255 async captureAction( 256 review: unknown = 'reviewed_original_inbox_probe_retry' 257 ) { 258 const a = currentActor(); 259 if (!acknowledgement) 260 throw Error('actual recovered acknowledgement missing'); 261 const selected = await captureRecoveredInboxProbeRetryAction( 262 repository, 263 a.session, 264 host.policy, 265 acknowledgement, 266 review 267 ); 268 if (selected) action = selected; 269 return selected; 270 }, 271 async originalPublish( 272 origin = 'wss://inbox.example.org', 273 signal = new AbortController().signal 274 ) { 275 const a = currentActor(); 276 if (!originalAck) throw Error('actual original acknowledgement missing'); 277 originalAction ??= captureInboxProbePublicationAction( 278 repository, 279 a.session, 280 host.policy, 281 originalAck, 282 'reviewed_inbox_probe_network' 283 ); 284 const permission = 285 originalAction && 286 captureInboxProbePublication( 287 repository, 288 a.session, 289 host.policy, 290 originalAck, 291 originalAction, 292 origin, 293 'reviewed_inbox_probe_publication' 294 ); 295 return permission 296 ? publishInboxProbeArchiveAttempt(acquire(), permission, signal) 297 : undefined; 298 }, 299 async originalRead(origin = 'wss://inbox.example.org') { 300 const a = currentActor(); 301 if (!originalAck || !originalAction) return undefined; 302 const permission = captureInboxProbeReadback( 303 repository, 304 a.session, 305 host.policy, 306 originalAck, 307 originalAction, 308 origin, 309 'reviewed_inbox_probe_readback' 310 ); 311 return permission 312 ? readInboxProbeAttempt( 313 acquire(), 314 permission, 315 new AbortController().signal 316 ) 317 : undefined; 318 }, 319 async publish( 320 origin = 'wss://inbox.example.org', 321 signal = new AbortController().signal 322 ) { 323 const a = currentActor(); 324 if (!acknowledgement || !action) return undefined; 325 const permission = captureInboxProbePublication( 326 repository, 327 a.session, 328 host.policy, 329 acknowledgement, 330 action, 331 origin, 332 'reviewed_inbox_probe_publication' 333 ); 334 return permission 335 ? publishInboxProbeArchiveAttempt(acquire(), permission, signal) 336 : undefined; 337 }, 338 async read( 339 origin = 'wss://inbox.example.org', 340 signal = new AbortController().signal 341 ) { 342 const a = currentActor(); 343 if (!acknowledgement || !action) return undefined; 344 const permission = captureInboxProbeReadback( 345 repository, 346 a.session, 347 host.policy, 348 acknowledgement, 349 action, 350 origin, 351 'reviewed_inbox_probe_readback' 352 ); 353 return permission 354 ? readInboxProbeAttempt(acquire(), permission, signal) 355 : undefined; 356 }, 357 append: (result: InboxProbeArchiveAttemptResult) => 358 commitInboxProbeArchiveAttempt(repository, result), 359 appendRead: (result: InboxProbeReadbackAttemptResult) => 360 commitInboxProbeReadbackAttempt(repository, result), 361 snapshot: () => 362 acknowledgement && inboxProbeAcknowledgementSnapshot(acknowledgement), 363 originalBinding: () => 364 acknowledgement && 365 inboxProbePublicationBinding( 366 repository, 367 currentActor().session, 368 acknowledgement, 369 host.policy 370 ), 371 recoveredBinding: () => 372 acknowledgement && 373 recoveredInboxProbePublicationBinding( 374 repository, 375 currentActor().session, 376 acknowledgement, 377 host.policy 378 ), 379 idle: () => privatePoolProbeRetryIdle(currentActor().session, host.policy), 380 installNetworkClock() { 381 const original = performance.now.bind(performance); 382 let now = original(), 383 observations = 0; 384 performance.now = () => { 385 if (/at clock(?:\d+)? \(/.test(new Error().stack ?? '')) { 386 observations++; 387 return now; 388 } 389 return original(); 390 }; 391 return { 392 advance: (value: number) => { 393 now += value; 394 }, 395 observations: () => observations, 396 restore: () => { 397 performance.now = original; 398 } 399 }; 400 }, 401 installAttemptTeardownFailure() { 402 const original = Object.getOwnPropertyDescriptor( 403 RelayPool.prototype, 404 'relay' 405 )!.value as RelayPool['relay'], 406 restorations: (() => void)[] = []; 407 let failing = true, 408 faults = 0; 409 RelayPool.prototype.relay = function ( 410 ...args: Parameters<RelayPool['relay']> 411 ) { 412 const relay = original.apply(this, args), 413 event = relay.event.bind(relay); 414 relay.event = (...args: Parameters<typeof relay.event>) => 415 event(...args).pipe( 416 finalize(() => { 417 if (failing) { 418 faults++; 419 throw Error('actual controlled SDK teardown failure'); 420 } 421 }) 422 ); 423 restorations.push(() => { 424 relay.event = event; 425 }); 426 return relay; 427 }; 428 return { 429 faults: () => faults, 430 restore: () => { 431 failing = false; 432 RelayPool.prototype.relay = original; 433 for (const restore of restorations) restore(); 434 } 435 }; 436 }, 437 installCommitFault(mode: 'aborted' | 'uncertain' | 'changed_successor') { 438 const put = Object.getOwnPropertyDescriptor( 439 IDBObjectStore.prototype, 440 'put' 441 )!.value as IDBObjectStore['put'], 442 abort = Object.getOwnPropertyDescriptor( 443 IDBTransaction.prototype, 444 'abort' 445 )!.value as IDBTransaction['abort'], 446 transaction = Object.getOwnPropertyDescriptor( 447 IDBDatabase.prototype, 448 'transaction' 449 )!.value as IDBDatabase['transaction']; 450 let selected: IDBTransaction | undefined, 451 putSuccess = 0, 452 complete = 0, 453 aborted = 0, 454 abortRefused = 0, 455 changed = 0; 456 IDBDatabase.prototype.transaction = function ( 457 ...args: Parameters<IDBDatabase['transaction']> 458 ) { 459 // Queue a genuine competing write BEFORE the first final readonly 460 // transaction. A later complete listener can run after its admission. 461 if ( 462 mode === 'changed_successor' && 463 selected?.db === this && 464 !changed && 465 args[1] === 'readonly' 466 ) { 467 changed++; 468 const next = transaction.call(this, ['private_sends'], 'readwrite'), 469 store = next.objectStore('private_sends'), 470 row = store.get([host.owner, command!]); 471 row.addEventListener('success', () => { 472 const current = row.result as { 473 owner: string; 474 id: string; 475 wire: string; 476 }, 477 record = JSON.parse(current.wire) as { revision: number }; 478 record.revision++; 479 put.call(store, { ...current, wire: JSON.stringify(record) }); 480 }); 481 } 482 return transaction.apply(this, args); 483 }; 484 IDBTransaction.prototype.abort = function ( 485 ...args: Parameters<IDBTransaction['abort']> 486 ) { 487 if (this === selected && mode !== 'aborted') { 488 abortRefused++; 489 throw Error('actual controlled abort refusal'); 490 } 491 return abort.apply(this, args); 492 }; 493 IDBObjectStore.prototype.put = function ( 494 ...args: Parameters<IDBObjectStore['put']> 495 ) { 496 const request = put.apply(this, args); 497 if (!selected && this.name === 'private_sends') { 498 selected = this.transaction; 499 selected.addEventListener('complete', () => { 500 complete++; 501 }); 502 selected.addEventListener('abort', () => { 503 aborted++; 504 }); 505 request.addEventListener('success', () => { 506 putSuccess++; 507 if (mode === 'aborted') selected!.abort(); 508 }); 509 if (mode !== 'aborted') 510 throw Error('actual controlled failure after native put admission'); 511 } 512 return request; 513 }; 514 return { 515 counts: () => ({ 516 putSuccess, 517 complete, 518 aborted, 519 abortRefused, 520 changed 521 }), 522 restore: () => { 523 IDBObjectStore.prototype.put = put; 524 IDBTransaction.prototype.abort = abort; 525 IDBDatabase.prototype.transaction = transaction; 526 } 527 }; 528 }, 529 async alternateController(foreignSession = false) { 530 if (foreignSession) { 531 const other = await openRecoveryContext( 532 host.owner, 533 host.policy, 534 host.qualification, 535 command!, 536 shared 537 ); 538 return { 539 access: other.access, 540 session: other.session, 541 close: () => other.close() 542 }; 543 } 544 const view = createPublicView(runtime), 545 run = beginPublicViewRun(view), 546 resolver = resolveInboxPreference(view, run, host.owner); 547 await settleInboxResolver(resolver); 548 const other = createInboxAccessController( 549 currentActor().session, 550 host.policy, 551 resolver 552 ); 553 if (!other) throw Error('actual alternate controller'); 554 return { 555 access: other, 556 session: currentActor().session, 557 close() { 558 if (other !== access) closeInboxAccessController(other); 559 disposePublicView(view); 560 } 561 }; 562 }, 563 async replacementWhilePending() { 564 const a = currentActor(), 565 view = createPublicView(runtime), 566 run = beginPublicViewRun(view), 567 resolver = resolveInboxPreference(view, run, host.owner); 568 await settleInboxResolver(resolver); 569 if (inboxResolutionSnapshot(resolver).status !== 'ready') 570 throw Error('replacement must have actual ready discovery metadata'); 571 let other: InboxAccessController | undefined, 572 recovery: InboxProbeRecoveryReader | undefined; 573 try { 574 other = createInboxAccessController(a.session, host.policy, resolver); 575 if (!other) 576 return { 577 gate: 'actual_controller_factory' as const, 578 privateCurrent: privateSessionSnapshot(a.session)?.current === true, 579 originalController: inboxAccessControllerSnapshot(a.access) 580 }; 581 recovery = captureInboxProbeRecoveryReader( 582 repository, 583 a.identity, 584 a.session, 585 host.policy, 586 other, 587 host.qualification, 588 command!, 589 'reviewed_inbox_probe_recovery' 590 ); 591 if (!recovery) 592 return { 593 gate: 'actual_recovery_factory' as const, 594 currentController: inboxAccessControllerSnapshot(other) 595 }; 596 const recovered = await recoverInboxProbe(recovery); 597 if (!('proof' in recovered)) 598 return { 599 gate: 'actual_recovery_execution' as const, 600 status: recovered.status, 601 currentController: inboxAccessControllerSnapshot(other) 602 }; 603 const adopted = await adoptRecoveredInboxProbe( 604 repository, 605 a.session, 606 other, 607 host.policy, 608 host.qualification, 609 recovered.proof, 610 'reviewed_original_inbox_probe_retry' 611 ); 612 if (!('acknowledgement' in adopted)) 613 return { 614 gate: 'actual_adoption' as const, 615 status: adopted.status, 616 currentController: inboxAccessControllerSnapshot(other) 617 }; 618 const binding = recoveredInboxProbePublicationBinding( 619 repository, 620 a.session, 621 adopted.acknowledgement, 622 host.policy 623 ); 624 if (!binding?.current()) 625 throw Error( 626 'fresh genuine recovered binding must be current before Retry' 627 ); 628 const before = host.counts(), 629 original = crypto.randomUUID.bind(crypto), 630 closesBefore = Number(Reflect.get(window, 'ptCloseCalls') ?? 0); 631 let uuids = 0; 632 crypto.randomUUID = () => { 633 uuids++; 634 return original(); 635 }; 636 try { 637 const selected = await captureRecoveredInboxProbeRetryAction( 638 repository, 639 a.session, 640 host.policy, 641 adopted.acknowledgement, 642 'reviewed_original_inbox_probe_retry' 643 ); 644 return { 645 gate: 'actual_retry_admission' as const, 646 genuineCurrentBinding: binding.current(), 647 refused: !selected, 648 uuids, 649 before, 650 after: host.counts(), 651 closesBefore, 652 closesAfter: Number(Reflect.get(window, 'ptCloseCalls') ?? 0), 653 currentController: inboxAccessControllerSnapshot(other) 654 }; 655 } finally { 656 crypto.randomUUID = original; 657 } 658 } finally { 659 if (recovery) stopInboxProbeRecoveryReader(recovery); 660 if (other) closeInboxAccessController(other); 661 disposePublicView(view); 662 } 663 }, 664 // Test-only physical deletion frees the existing native quota to test the 665 // independent source meter bound. This is never product cleanup evidence. 666 async removeFixtureRow() { 667 const opened = await openBrowserDatabase(); 668 if (opened.state !== 'ready' || !command) 669 throw Error('actual fixture deletion inputs'); 670 try { 671 const tx = browserDatabaseTransaction( 672 opened.owner, 673 ['private_sends'], 674 'readwrite' 675 ); 676 tx.objectStore('private_sends').delete([host.owner, command]); 677 await new Promise<void>((resolve, reject) => { 678 tx.addEventListener('complete', () => resolve()); 679 tx.addEventListener('abort', () => 680 reject(Error('fixture delete abort')) 681 ); 682 }); 683 } finally { 684 closeBrowserDatabase(opened.owner); 685 } 686 }, 687 async replaceController() { 688 const a = currentActor(); 689 stopCurrentController(); 690 replacementView = createPublicView(runtime); 691 const run = beginPublicViewRun(replacementView), 692 resolver = resolveInboxPreference(replacementView, run, host.owner); 693 await settleInboxResolver(resolver); 694 access = createInboxAccessController(a.session, host.policy, resolver); 695 return access; 696 }, 697 async freshSession() { 698 stopCurrentController(); 699 actor?.close(); 700 actor = await openRecoveryContext( 701 host.owner, 702 host.policy, 703 host.qualification, 704 command ?? crypto.randomUUID(), 705 shared 706 ); 707 access = actor.access; 708 return actor; 709 }, 710 stop: stopCurrentController, 711 close() { 712 stopCurrentController(); 713 actor?.close(); 714 closePublicRuntime(publicContext); 715 host.close(); 716 } 717 }; 718 }