app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

self-recovery-reader.ts (50570B)


      1 import type { RelayPolicy } from '../config/relays.ts';
      2 import {
      3   privateSessionOwnership,
      4   subscribePrivateSessionClose,
      5   type PrivateSession
      6 } from '../runtime/private-session.ts';
      7 import {
      8   inboxProbeReadbackAttemptEvidence,
      9   type InboxProbeReadbackAttemptResult
     10 } from './private-pool.ts';
     11 import {
     12   inboxProbePublicationBinding,
     13   recoveredInboxProbePublicationBinding,
     14   type InboxProbeAcknowledgement
     15 } from '../persistence/inbox-probes.ts';
     16 import { inboxProbeRumorWire, inboxProbeRumorMatches } from './inbox-access.ts';
     17 import {
     18   inboxAccessConstructionBinding,
     19   subscribeInboxAccessControllerClose,
     20   type InboxAccessController
     21 } from '../messaging/inbox-access-controller.ts';
     22 import {
     23   inboxOperatorQualificationWire,
     24   inboxOperatorQualificationSnapshot,
     25   type InboxOperatorQualification
     26 } from '../config/inbox-operators.ts';
     27 import { readRelayPolicy } from '../config/relays.ts';
     28 import { inboxProbeReadbackMatches } from '../persistence/private-records.ts';
     29 import { ExtensionSigner } from 'applesauce-signers';
     30 import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
     31 import { canonicalLocalId } from '../private-handles.ts';
     32 import { exactLocalFields } from '../contracts/local-records.ts';
     33 import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
     34 import {
     35   identityMessagingOwnership,
     36   subscribeIdentityInvalidation,
     37   disconnectIdentity,
     38   type IdentitySession
     39 } from '../runtime/identity-session.ts';
     40 import {
     41   loadPrivateRecord,
     42   observePrivateRecord,
     43   privateStorageOwner,
     44   type PrivateStorageRepository,
     45   type PrivateStorageFailure
     46 } from '../persistence/private-storage.ts';
     47 import {
     48   privateRecordSnapshot,
     49   privateRecordWire,
     50   type PrivateSendOperation,
     51   type PrivateAccessProbe,
     52   type PrivateRecordHandle
     53 } from '../persistence/private-records.ts';
     54 import {
     55   verifyEnvelope,
     56   verifiedEnvelopeSnapshot
     57 } from './verified-envelope.ts';
     58 import { verifyOutboundLayerData } from './outbound-envelope-layers.ts';
     59 import { sealCiphertextV2 } from './seal-template.ts';
     60 import {
     61   browserExtensionScheduler,
     62   runExtensionAction,
     63   callExtension,
     64   stopExtensionAction,
     65   markExtensionWaitExpired,
     66   type ExtensionAction
     67 } from './extension-scheduler.ts';
     68 // Module-private strict self-layer SDK engine. Only the factory-owned reader
     69 // scopes below provide ownership/currentness; no caller cipher/event port exists.
     70 function strictSelfDecryptor(
     71   identity: IdentitySession,
     72   owner: string,
     73   current: () => boolean
     74 ) {
     75   function port() {
     76     try {
     77       if (!current()) return undefined;
     78       const cipher = new ExtensionSigner().nip44;
     79       if (!current() || !cipher) return undefined;
     80       const method = cipher.decrypt;
     81       if (!current() || typeof method !== 'function') return undefined;
     82       const decrypt = method.bind(cipher);
     83       return current() ? { decrypt } : undefined;
     84     } catch {
     85       return undefined;
     86     }
     87   }
     88   async function fresh(action: ExtensionAction) {
     89     if (!current()) return false;
     90     const result = await callExtension(action, 'key', () =>
     91       new ExtensionSigner().getPublicKey()
     92     );
     93     if (!current()) return false;
     94     if (
     95       result.status !== 'settled' ||
     96       !result.current ||
     97       result.value !== owner
     98     ) {
     99       disconnectIdentity(identity);
    100       return false;
    101     }
    102     const cipher = port();
    103     // A callback may revoke only this scope. That cannot grant authority to
    104     // disconnect an otherwise current identity and its independent consumers.
    105     if (!current()) return false;
    106     if (!cipher) {
    107       disconnectIdentity(identity);
    108       return false;
    109     }
    110     return current();
    111   }
    112   async function open(
    113     action: ExtensionAction,
    114     outer: import('applesauce-core/helpers').NostrEvent
    115   ): Promise<
    116     | Readonly<{ status: 'opened'; rumorWire: string; sealWire: string }>
    117     | Readonly<{ status: 'stopped' | 'refused' | 'mismatch' }>
    118   > {
    119     if (!(await fresh(action))) return { status: 'stopped' };
    120     const outerPort = port();
    121     if (!outerPort || !current()) return { status: 'stopped' };
    122     const opened = await callExtension(action, 'decrypt', () =>
    123       outerPort.decrypt(outer.pubkey, outer.content)
    124     );
    125     if (!current()) return { status: 'stopped' };
    126     if (opened.status !== 'settled' || !opened.current)
    127       return { status: opened.status === 'denied' ? 'refused' : 'stopped' };
    128     if (
    129       typeof opened.value !== 'string' ||
    130       !boundedUtf8(opened.value, PRIVATE_TRANSPORT_BUDGETS.sealBytes)
    131     )
    132       return { status: 'mismatch' };
    133     const sealWire = opened.value,
    134       verified = verifyEnvelope(sealWire),
    135       seal = verified.ok && verifiedEnvelopeSnapshot(verified.value);
    136     if (
    137       !seal ||
    138       seal.pubkey !== owner ||
    139       seal.kind !== 13 ||
    140       seal.tags.length !== 0 ||
    141       !exactLocalFields(seal, [
    142         'id',
    143         'pubkey',
    144         'created_at',
    145         'kind',
    146         'tags',
    147         'content',
    148         'sig'
    149       ]) ||
    150       JSON.stringify(JSON.parse(sealWire)) !== sealWire ||
    151       !sealCiphertextV2(seal.content)
    152     )
    153       return { status: 'mismatch' };
    154     if (!(await fresh(action))) return { status: 'stopped' };
    155     const innerPort = port();
    156     if (!innerPort || !current()) return { status: 'stopped' };
    157     const decrypted = await callExtension(action, 'decrypt', () =>
    158       innerPort.decrypt(seal.pubkey, seal.content)
    159     );
    160     if (!current()) return { status: 'stopped' };
    161     if (decrypted.status !== 'settled' || !decrypted.current)
    162       return { status: decrypted.status === 'denied' ? 'refused' : 'stopped' };
    163     if (
    164       typeof decrypted.value !== 'string' ||
    165       !boundedUtf8(decrypted.value, PRIVATE_TRANSPORT_BUDGETS.rumorBytes)
    166     )
    167       return { status: 'mismatch' };
    168     return { status: 'opened', rumorWire: decrypted.value, sealWire };
    169   }
    170   return { fresh, open };
    171 }
    172 
    173 declare const readerBrand: unique symbol;
    174 declare const recoveredBrand: unique symbol;
    175 export type SelfRecoveryReader = Readonly<{ [readerBrand]: true }>;
    176 export type RecoveredSelfEnvelope = Readonly<{ [recoveredBrand]: true }>;
    177 type Snapshot = Readonly<{
    178   record: PrivateSendOperation;
    179   storedWire: string;
    180   rumorWire: string;
    181   sealWire: string;
    182 }>;
    183 export type SelfRecoveryReadResult =
    184   | Readonly<{ status: 'recovered'; envelope: RecoveredSelfEnvelope }>
    185   | Readonly<{
    186       status:
    187         | PrivateStorageFailure
    188         | 'invalid'
    189         | 'stopped'
    190         | 'busy'
    191         | 'refused'
    192         | 'mismatch'
    193         | 'lost_evidence';
    194     }>;
    195 type Reader = {
    196   run(): Promise<SelfRecoveryReadResult>;
    197   stop(expired: boolean): void;
    198 };
    199 const readers = new WeakMap<SelfRecoveryReader, Reader>(),
    200   recovered = new WeakMap<
    201     RecoveredSelfEnvelope,
    202     { snapshot: Snapshot; current(): boolean }
    203   >();
    204 // Actual owner-scoped storage and guarded SDK decryption are the only issuer.
    205 // Detached JSON, metadata, SDK cache symbols and snapshots cannot mint this
    206 // memory-only authenticated recovery proof or authorize a private relay effect.
    207 export function captureSelfRecoveryReader(
    208   repository: PrivateStorageRepository,
    209   session: IdentitySession,
    210   localId: unknown,
    211   review: unknown
    212 ): SelfRecoveryReader | undefined {
    213   if (typeof window === 'undefined' || review !== 'reviewed_self_decryption')
    214     return undefined;
    215   const inputId = canonicalLocalId(localId),
    216     inputOwnership = identityMessagingOwnership(session);
    217   if (!inputId || !inputOwnership?.current()) return undefined;
    218   const id = inputId,
    219     ownership = inputOwnership;
    220   let stopped = false,
    221     started = false,
    222     active: ExtensionAction | undefined,
    223     proof: RecoveredSelfEnvelope | undefined,
    224     unsubscribe = () => {};
    225   const current = () => !stopped && ownership.current();
    226   function stop(expired: boolean) {
    227     stopped = true;
    228     if (active) {
    229       if (expired) markExtensionWaitExpired(active);
    230       else stopExtensionAction(active);
    231     }
    232     if (proof) recovered.delete(proof);
    233     proof = undefined;
    234     unsubscribe();
    235     unsubscribe = () => {};
    236   }
    237   const decryptor = strictSelfDecryptor(session, ownership.owner, current);
    238   const fresh = (action: ExtensionAction) => decryptor.fresh(action);
    239   async function run(): Promise<SelfRecoveryReadResult> {
    240     if (started || !current()) return { status: 'stopped' };
    241     started = true;
    242     if (!navigator.locks?.request) return { status: 'unavailable' };
    243     try {
    244       return await navigator.locks.request(
    245         'harvestcircle:owner:' + ownership.owner,
    246         { mode: 'exclusive', ifAvailable: true },
    247         async (lock): Promise<SelfRecoveryReadResult> => {
    248           if (!lock) return { status: 'busy' };
    249           if (!current()) return { status: 'stopped' };
    250           // Complete the readonly transaction before any extension await.
    251           const loaded = await loadPrivateRecord(
    252             repository,
    253             'private_sends',
    254             id
    255           );
    256           if (!current()) return { status: 'stopped' };
    257           if (!loaded.ok)
    258             return {
    259               status:
    260                 loaded.reason === 'invalid_record'
    261                   ? 'lost_evidence'
    262                   : loaded.reason
    263             };
    264           const record = privateRecordSnapshot(
    265               loaded.value,
    266               ownership.owner,
    267               id
    268             ),
    269             storedWire = privateRecordWire(loaded.value, ownership.owner, id);
    270           if (
    271             !record ||
    272             !storedWire ||
    273             (record.family !== 'private_send_reservation' &&
    274               record.family !== 'private_send_operation')
    275           )
    276             return { status: 'invalid_scope' };
    277           if (record.family !== 'private_send_operation')
    278             return { status: 'lost_evidence' };
    279           const verified = verifyEnvelope(record.self.wire),
    280             outer = verified.ok && verifiedEnvelopeSnapshot(verified.value);
    281           if (
    282             !outer ||
    283             outer.id !== record.self.eventId ||
    284             outer.kind !== 1059 ||
    285             JSON.stringify(outer.tags) !==
    286               JSON.stringify([['p', record.owner]]) ||
    287             !exactLocalFields(outer, [
    288               'id',
    289               'pubkey',
    290               'created_at',
    291               'kind',
    292               'tags',
    293               'content',
    294               'sig'
    295             ]) ||
    296             !sealCiphertextV2(outer.content)
    297           )
    298             return { status: 'mismatch' };
    299           const scheduler = browserExtensionScheduler();
    300           if (!scheduler) return { status: 'unavailable' };
    301           const result = await runExtensionAction(
    302             scheduler,
    303             {
    304               owner: ownership.owner,
    305               session: ownership.session,
    306               operation: Symbol()
    307             },
    308             current,
    309             async (action): Promise<SelfRecoveryReadResult> => {
    310               active = action;
    311               const opened = await decryptor.open(action, outer);
    312               if (!current()) return { status: 'stopped' };
    313               if (opened.status !== 'opened') return opened;
    314               const { rumorWire, sealWire } = opened;
    315               if (
    316                 !verifyOutboundLayerData(
    317                   rumorWire,
    318                   rumorWire,
    319                   sealWire,
    320                   record.self.wire,
    321                   record.owner,
    322                   record.peer,
    323                   'self'
    324                 )
    325               )
    326                 return { status: 'mismatch' };
    327               const rumor = JSON.parse(rumorWire) as {
    328                 id: string;
    329                 created_at: number;
    330               };
    331               if (
    332                 JSON.stringify(JSON.parse(rumorWire)) !== rumorWire ||
    333                 rumor.id !== record.rumorHash ||
    334                 rumor.created_at !== record.createdAt
    335               )
    336                 return { status: 'mismatch' };
    337               if (!(await fresh(action))) return { status: 'stopped' };
    338               const readback = await loadPrivateRecord(
    339                 repository,
    340                 'private_sends',
    341                 id
    342               );
    343               if (!current()) return { status: 'stopped' };
    344               if (!readback.ok)
    345                 return {
    346                   status:
    347                     readback.reason === 'invalid_record'
    348                       ? 'lost_evidence'
    349                       : readback.reason
    350                 };
    351               if (
    352                 privateRecordWire(readback.value, record.owner, id) !==
    353                 storedWire
    354               )
    355                 return { status: 'conflict' };
    356               if (!(await fresh(action))) return { status: 'stopped' };
    357               const token = Object.freeze({}) as RecoveredSelfEnvelope;
    358               recovered.set(token, {
    359                 snapshot: { record, storedWire, rumorWire, sealWire },
    360                 current
    361               });
    362               proof = token;
    363               return { status: 'recovered', envelope: token };
    364             }
    365           );
    366           if (!current()) return { status: 'stopped' };
    367           if (result.status === 'busy') return { status: 'busy' };
    368           return result.status === 'completed' &&
    369             'value' in result &&
    370             result.value
    371             ? result.value
    372             : { status: result.status === 'denied' ? 'refused' : 'stopped' };
    373         }
    374       );
    375     } catch {
    376       return { status: current() ? 'refused' : 'stopped' };
    377     } finally {
    378       active = undefined;
    379     }
    380   }
    381   const token = Object.freeze({}) as SelfRecoveryReader;
    382   readers.set(token, { run, stop });
    383   unsubscribe = subscribeIdentityInvalidation(session, () => {
    384     if (!ownership.current()) stop(false);
    385   });
    386   return current() ? token : undefined;
    387 }
    388 export function readSelfRecoveryEnvelope(
    389   reader: SelfRecoveryReader
    390 ): Promise<SelfRecoveryReadResult> {
    391   return readers.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' });
    392 }
    393 export function stopSelfRecoveryReader(reader: SelfRecoveryReader): void {
    394   readers.get(reader)?.stop(false);
    395 }
    396 export function expireSelfRecoveryReaderWait(reader: SelfRecoveryReader): void {
    397   readers.get(reader)?.stop(true);
    398 }
    399 export function recoveredSelfEnvelopeSnapshot(
    400   token: RecoveredSelfEnvelope
    401 ): Snapshot | undefined {
    402   const saved = recovered.get(token);
    403   return saved?.current()
    404     ? (JSON.parse(JSON.stringify(saved.snapshot)) as Snapshot)
    405     : undefined;
    406 }
    407 
    408 declare const probeNonceReaderBrand: unique symbol;
    409 export type InboxProbeNonceReader = Readonly<{ [probeNonceReaderBrand]: true }>;
    410 declare const probeNonceProofBrand: unique symbol;
    411 export type InboxProbeNonceProof = Readonly<{ [probeNonceProofBrand]: true }>;
    412 export type InboxProbeNonceResult =
    413   | Readonly<{ status: 'nonce_verified'; proof: InboxProbeNonceProof }>
    414   | Readonly<{
    415       status:
    416         | PrivateStorageFailure
    417         | 'invalid'
    418         | 'stopped'
    419         | 'busy'
    420         | 'refused'
    421         | 'mismatch'
    422         | 'lost_evidence';
    423     }>;
    424 declare const recoveredProbeNonceReaderBrand: unique symbol;
    425 export type RecoveredInboxProbeNonceReader = Readonly<{
    426   [recoveredProbeNonceReaderBrand]: true;
    427 }>;
    428 declare const recoveredProbeNonceProofBrand: unique symbol;
    429 export type RecoveredInboxProbeNonceProof = Readonly<{
    430   [recoveredProbeNonceProofBrand]: true;
    431 }>;
    432 export type RecoveredInboxProbeNonceResult =
    433   | Exclude<InboxProbeNonceResult, { status: 'nonce_verified' }>
    434   | Readonly<{
    435       status: 'nonce_verified';
    436       proof: RecoveredInboxProbeNonceProof;
    437     }>;
    438 type NonceResult = InboxProbeNonceResult | RecoveredInboxProbeNonceResult;
    439 type NonceReader = InboxProbeNonceReader | RecoveredInboxProbeNonceReader;
    440 type NonceProof = InboxProbeNonceProof | RecoveredInboxProbeNonceProof;
    441 type NonceSource = 'construction' | 'recovered';
    442 type ProbeReader = {
    443   source: NonceSource;
    444   run(): Promise<NonceResult>;
    445   stop(expired: boolean): void;
    446 };
    447 const probeReaders = new WeakMap<NonceReader, ProbeReader>();
    448 const probeObservationReaders = new WeakMap<
    449   InboxProbeReadbackAttemptResult,
    450   Readonly<{
    451     repository: PrivateStorageRepository;
    452     identity: IdentitySession;
    453     session: PrivateSession;
    454     policy: RelayPolicy;
    455     source: NonceSource;
    456     reader: NonceReader;
    457   }>
    458 >();
    459 type SavedNonceProof = Readonly<{
    460   repository: PrivateStorageRepository;
    461   session: PrivateSession;
    462   policy: RelayPolicy;
    463   observation: InboxProbeReadbackAttemptResult;
    464   acknowledgement: InboxProbeAcknowledgement;
    465   original: string;
    466   verifiedAtMilliseconds: number;
    467   current(): boolean;
    468   dispose(): void;
    469 }>;
    470 const probeNonceProofs = new WeakMap<InboxProbeNonceProof, SavedNonceProof>();
    471 const recoveredNonceProofs = new WeakMap<
    472   RecoveredInboxProbeNonceProof,
    473   SavedNonceProof
    474 >();
    475 function immutableProbe(
    476   record: import('../persistence/private-records.ts').PrivateAccessProbe
    477 ) {
    478   return JSON.stringify({
    479     owner: record.owner,
    480     id: record.id,
    481     rumorHash: record.rumorHash,
    482     createdAt: record.createdAt,
    483     binding: record.binding,
    484     self: record.self
    485   });
    486 }
    487 // Genuine positive source transport, actual identity/private session, original
    488 // nonce and native custody are all required. Capture never calls the provider.
    489 function captureProbeNonceReader(
    490   source: NonceSource,
    491   repository: PrivateStorageRepository,
    492   identity: IdentitySession,
    493   session: PrivateSession,
    494   policy: RelayPolicy,
    495   observation: InboxProbeReadbackAttemptResult,
    496   review: unknown
    497 ): NonceReader | undefined {
    498   if (
    499     typeof window === 'undefined' ||
    500     review !== 'reviewed_inbox_probe_nonce_decryption'
    501   )
    502     return undefined;
    503   try {
    504     const effect = inboxProbeReadbackAttemptEvidence(observation);
    505     if (!effect || effect.repository !== repository) return undefined;
    506     const acknowledgement = effect.acknowledgement,
    507       lookup =
    508         source === 'construction'
    509           ? inboxProbePublicationBinding
    510           : recoveredInboxProbePublicationBinding,
    511       binding = lookup(repository, session, acknowledgement, policy);
    512     if (!binding?.record.self) return undefined;
    513     function expectedRumor(): string | undefined {
    514       if (source === 'construction')
    515         return inboxProbeRumorWire(
    516           binding!.identity as Parameters<typeof inboxProbeRumorWire>[0],
    517           session
    518         );
    519       const recovered = binding!.identity as RecoveredInboxProbe,
    520         original = recoveredProbes.get(recovered);
    521       if (!original || original.identity !== identity) return undefined;
    522       return recoveredInboxProbeRumorWire(
    523         recovered,
    524         repository,
    525         session,
    526         original.access,
    527         policy,
    528         original.operator
    529       );
    530     }
    531     // Strong recovered associations precede passive private-session ownership.
    532     if (!expectedRumor()) return undefined;
    533     const identityOwner = identityMessagingOwnership(identity);
    534     if (
    535       !identityOwner?.current() ||
    536       binding.record.owner !== identityOwner.owner
    537     )
    538       return undefined;
    539     const privateOwner = privateSessionOwnership(session);
    540     if (
    541       !privateOwner?.current() ||
    542       identityOwner.owner !== privateOwner.owner ||
    543       identityOwner.session !== privateOwner.session
    544     )
    545       return undefined;
    546     const fact = JSON.parse(
    547       effect.receiptWire
    548     ) as import('../persistence/private-records.ts').PrivateAccessProbeReceipt;
    549     if (
    550       fact.role !== 'access_readback' ||
    551       fact.status !== 'readback' ||
    552       fact.eventId !== binding.record.self.eventId ||
    553       !binding.record.binding.readTargets.includes(fact.origin) ||
    554       !inboxProbeReadbackMatches(
    555         binding.record.self,
    556         binding.record.owner,
    557         fact.readbackWire
    558       ) ||
    559       !expectedRumor()
    560     )
    561       return undefined;
    562     const previous = probeObservationReaders.get(observation);
    563     if (previous)
    564       return previous.source === source &&
    565         previous.repository === repository &&
    566         previous.identity === identity &&
    567         previous.session === session &&
    568         previous.policy === policy
    569         ? previous.reader
    570         : undefined;
    571     const original = immutableProbe(binding.record),
    572       token = Object.freeze({}) as NonceReader;
    573     let stopped = false,
    574       started = false,
    575       pending = false,
    576       active: ExtensionAction | undefined,
    577       proof: NonceProof | undefined,
    578       last: NonceResult | undefined;
    579     const listeners = new Map<symbol, () => void>();
    580     function current() {
    581       const fresh = lookup(repository, session, acknowledgement, policy);
    582       return (
    583         !stopped &&
    584         identityOwner!.current() &&
    585         privateOwner!.current() &&
    586         !!fresh &&
    587         fresh.identity === binding!.identity &&
    588         immutableProbe(fresh.record) === original &&
    589         !!expectedRumor()
    590       );
    591     }
    592     function stop(expired: boolean) {
    593       stopped = true;
    594       if (active) {
    595         if (expired) markExtensionWaitExpired(active);
    596         else stopExtensionAction(active);
    597       }
    598       if (proof) {
    599         probeNonceProofs.delete(proof as InboxProbeNonceProof);
    600         recoveredNonceProofs.delete(proof as RecoveredInboxProbeNonceProof);
    601       }
    602       proof = undefined;
    603       for (const [id, off] of listeners) {
    604         off();
    605         listeners.delete(id);
    606       }
    607     }
    608     function retain(register: () => () => void) {
    609       const off = register();
    610       if (stopped) off();
    611       else listeners.set(Symbol(), off);
    612     }
    613     const decryptor = strictSelfDecryptor(
    614       identity,
    615       identityOwner.owner,
    616       current
    617     );
    618     async function run(): Promise<NonceResult> {
    619       if (!current()) {
    620         stop(false);
    621         return { status: 'stopped' };
    622       }
    623       if (pending) return { status: 'busy' };
    624       if (started) return last ?? { status: 'stopped' };
    625       started = true;
    626       pending = true;
    627       try {
    628         if (!navigator.locks?.request)
    629           return (last = { status: 'unavailable' });
    630         last = await navigator.locks.request(
    631           'harvestcircle:owner:' + identityOwner!.owner,
    632           { mode: 'exclusive', ifAvailable: true },
    633           async (lock): Promise<NonceResult> => {
    634             if (!lock) return { status: 'busy' };
    635             if (!current()) return { status: 'stopped' };
    636             const captured = lookup(
    637               repository,
    638               session,
    639               acknowledgement,
    640               policy
    641             );
    642             if (!captured?.record.self) return { status: 'stopped' };
    643             const loaded = await observePrivateRecord(
    644               repository,
    645               'private_sends',
    646               captured.record.id
    647             );
    648             if (!current()) return { status: 'stopped' };
    649             if (!loaded.ok) return { status: loaded.reason };
    650             if (
    651               loaded.value.wire !== captured.wire ||
    652               privateRecordWire(
    653                 loaded.value.handle,
    654                 captured.record.owner,
    655                 captured.record.id
    656               ) !== captured.wire ||
    657               lookup(repository, session, acknowledgement, policy)?.wire !==
    658                 captured.wire
    659             )
    660               return { status: 'conflict' };
    661             const checked = verifyEnvelope(captured.record.self.wire),
    662               outer = checked.ok && verifiedEnvelopeSnapshot(checked.value);
    663             if (
    664               !outer ||
    665               outer.kind !== 1059 ||
    666               outer.id !== captured.record.self.eventId ||
    667               JSON.stringify(outer.tags) !==
    668                 JSON.stringify([['p', captured.record.owner]]) ||
    669               !exactLocalFields(outer, [
    670                 'id',
    671                 'pubkey',
    672                 'created_at',
    673                 'kind',
    674                 'tags',
    675                 'content',
    676                 'sig'
    677               ]) ||
    678               !sealCiphertextV2(outer.content)
    679             )
    680               return { status: 'mismatch' };
    681             const scheduler = browserExtensionScheduler();
    682             if (!scheduler) return { status: 'unavailable' };
    683             const result = await runExtensionAction(
    684               scheduler,
    685               {
    686                 owner: identityOwner!.owner,
    687                 session: identityOwner!.session,
    688                 operation: Symbol()
    689               },
    690               current,
    691               async (action): Promise<NonceResult> => {
    692                 active = action;
    693                 const opened = await decryptor.open(action, outer);
    694                 if (!current()) return { status: 'stopped' };
    695                 if (opened.status !== 'opened') return opened;
    696                 const expected = expectedRumor();
    697                 if (!expected || opened.rumorWire !== expected)
    698                   return { status: 'mismatch' };
    699                 const rumor = JSON.parse(opened.rumorWire) as {
    700                   id: string;
    701                   created_at: number;
    702                   pubkey: string;
    703                 };
    704                 if (
    705                   rumor.id !== captured.record.rumorHash ||
    706                   rumor.created_at !== captured.record.createdAt ||
    707                   rumor.pubkey !== captured.record.owner
    708                 )
    709                   return { status: 'mismatch' };
    710                 // All callback-capable provider/cipher work finishes before the
    711                 // final physical read. No extension callback follows that read.
    712                 if (!(await decryptor.fresh(action)))
    713                   return { status: 'stopped' };
    714                 const verifiedAtMilliseconds = Date.now();
    715                 if (!current()) return { status: 'stopped' };
    716                 if (
    717                   !Number.isSafeInteger(verifiedAtMilliseconds) ||
    718                   verifiedAtMilliseconds < 0
    719                 )
    720                   return { status: 'mismatch' };
    721                 const after = await observePrivateRecord(
    722                   repository,
    723                   'private_sends',
    724                   captured.record.id
    725                 );
    726                 if (!current()) return { status: 'stopped' };
    727                 if (!after.ok) return { status: after.reason };
    728                 if (
    729                   after.value.wire !== captured.wire ||
    730                   privateRecordWire(
    731                     after.value.handle,
    732                     captured.record.owner,
    733                     captured.record.id
    734                   ) !== captured.wire ||
    735                   lookup(repository, session, acknowledgement, policy)?.wire !==
    736                     captured.wire
    737                 )
    738                   return { status: 'conflict' };
    739                 if (!current() || expectedRumor() !== expected)
    740                   return { status: 'stopped' };
    741                 const issued = Object.freeze({}) as NonceProof;
    742                 const saved = {
    743                   repository,
    744                   session,
    745                   policy,
    746                   observation,
    747                   acknowledgement,
    748                   original,
    749                   verifiedAtMilliseconds,
    750                   current,
    751                   dispose: () => stop(false)
    752                 };
    753                 if (source === 'construction')
    754                   probeNonceProofs.set(issued as InboxProbeNonceProof, saved);
    755                 else
    756                   recoveredNonceProofs.set(
    757                     issued as RecoveredInboxProbeNonceProof,
    758                     saved
    759                   );
    760                 proof = issued;
    761                 return source === 'construction'
    762                   ? {
    763                       status: 'nonce_verified',
    764                       proof: issued as InboxProbeNonceProof
    765                     }
    766                   : {
    767                       status: 'nonce_verified',
    768                       proof: issued as RecoveredInboxProbeNonceProof
    769                     };
    770               }
    771             );
    772             if (!current()) return { status: 'stopped' };
    773             if (result.status === 'busy') return { status: 'busy' };
    774             return result.status === 'completed' &&
    775               'value' in result &&
    776               result.value
    777               ? result.value
    778               : { status: result.status === 'denied' ? 'refused' : 'stopped' };
    779           }
    780         );
    781         return last;
    782       } catch {
    783         return (last = { status: current() ? 'refused' : 'stopped' });
    784       } finally {
    785         active = undefined;
    786         pending = false;
    787       }
    788     }
    789     probeReaders.set(token, { source, run, stop });
    790     // Reserve before callback-capable subscriptions; reentrant capture reuses
    791     // this exact original reader and cannot reset or start another SDK action.
    792     probeObservationReaders.set(observation, {
    793       source,
    794       repository,
    795       identity,
    796       session,
    797       policy,
    798       reader: token
    799     });
    800     retain(() =>
    801       subscribeIdentityInvalidation(identity, () => {
    802         if (!identityOwner.current()) stop(false);
    803       })
    804     );
    805     retain(() => subscribePrivateSessionClose(session, () => stop(false)));
    806     return current() ? token : undefined;
    807   } catch {
    808     return undefined;
    809   }
    810 }
    811 export function captureInboxProbeNonceReader(
    812   repository: PrivateStorageRepository,
    813   identity: IdentitySession,
    814   session: PrivateSession,
    815   policy: RelayPolicy,
    816   observation: InboxProbeReadbackAttemptResult,
    817   review: unknown
    818 ): InboxProbeNonceReader | undefined {
    819   return captureProbeNonceReader(
    820     'construction',
    821     repository,
    822     identity,
    823     session,
    824     policy,
    825     observation,
    826     review
    827   ) as InboxProbeNonceReader | undefined;
    828 }
    829 export function captureRecoveredInboxProbeNonceReader(
    830   repository: PrivateStorageRepository,
    831   identity: IdentitySession,
    832   session: PrivateSession,
    833   policy: RelayPolicy,
    834   observation: InboxProbeReadbackAttemptResult,
    835   review: unknown
    836 ): RecoveredInboxProbeNonceReader | undefined {
    837   return captureProbeNonceReader(
    838     'recovered',
    839     repository,
    840     identity,
    841     session,
    842     policy,
    843     observation,
    844     review
    845   ) as RecoveredInboxProbeNonceReader | undefined;
    846 }
    847 export function readInboxProbeNonce(
    848   reader: InboxProbeNonceReader
    849 ): Promise<InboxProbeNonceResult> {
    850   const saved = probeReaders.get(reader);
    851   return saved?.source === 'construction'
    852     ? (saved.run() as Promise<InboxProbeNonceResult>)
    853     : Promise.resolve({ status: 'invalid' });
    854 }
    855 export function stopInboxProbeNonceReader(reader: InboxProbeNonceReader) {
    856   const saved = probeReaders.get(reader);
    857   if (saved?.source === 'construction') saved.stop(false);
    858 }
    859 export function expireInboxProbeNonceReaderWait(reader: InboxProbeNonceReader) {
    860   const saved = probeReaders.get(reader);
    861   if (saved?.source === 'construction') saved.stop(true);
    862 }
    863 export function readRecoveredInboxProbeNonce(
    864   reader: RecoveredInboxProbeNonceReader
    865 ): Promise<RecoveredInboxProbeNonceResult> {
    866   const saved = probeReaders.get(reader);
    867   return saved?.source === 'recovered'
    868     ? (saved.run() as Promise<RecoveredInboxProbeNonceResult>)
    869     : Promise.resolve({ status: 'invalid' });
    870 }
    871 export function stopRecoveredInboxProbeNonceReader(
    872   reader: RecoveredInboxProbeNonceReader
    873 ) {
    874   const saved = probeReaders.get(reader);
    875   if (saved?.source === 'recovered') saved.stop(false);
    876 }
    877 export function expireRecoveredInboxProbeNonceReaderWait(
    878   reader: RecoveredInboxProbeNonceReader
    879 ) {
    880   const saved = probeReaders.get(reader);
    881   if (saved?.source === 'recovered') saved.stop(true);
    882 }
    883 export function inboxProbeNonceProofBinding(
    884   proof: InboxProbeNonceProof,
    885   repository: PrivateStorageRepository,
    886   session: PrivateSession,
    887   policy: RelayPolicy
    888 ) {
    889   const saved = probeNonceProofs.get(proof);
    890   if (
    891     !saved ||
    892     saved.repository !== repository ||
    893     saved.session !== session ||
    894     saved.policy !== policy ||
    895     !saved.current()
    896   )
    897     return undefined;
    898   const binding = inboxProbePublicationBinding(
    899     repository,
    900     session,
    901     saved.acknowledgement,
    902     policy
    903   );
    904   if (!binding || immutableProbe(binding.record) !== saved.original)
    905     return undefined;
    906   return {
    907     acknowledgement: saved.acknowledgement,
    908     observation: saved.observation,
    909     identity: binding.identity,
    910     owner: binding.record.owner,
    911     command: binding.record.id,
    912     rumorHash: binding.record.rumorHash,
    913     eventId: binding.record.self!.eventId,
    914     current: () => saved.current()
    915   };
    916 }
    917 
    918 export function recoveredInboxProbeNonceProofBinding(
    919   proof: RecoveredInboxProbeNonceProof,
    920   repository: PrivateStorageRepository,
    921   session: PrivateSession,
    922   policy: RelayPolicy
    923 ) {
    924   const saved = recoveredNonceProofs.get(proof);
    925   if (
    926     !saved ||
    927     saved.repository !== repository ||
    928     saved.session !== session ||
    929     saved.policy !== policy ||
    930     !saved.current()
    931   )
    932     return undefined;
    933   const binding = recoveredInboxProbePublicationBinding(
    934     repository,
    935     session,
    936     saved.acknowledgement,
    937     policy
    938   );
    939   if (!binding || immutableProbe(binding.record) !== saved.original)
    940     return undefined;
    941   return {
    942     acknowledgement: saved.acknowledgement,
    943     observation: saved.observation,
    944     identity: binding.identity,
    945     owner: binding.record.owner,
    946     command: binding.record.id,
    947     rumorHash: binding.record.rumorHash,
    948     eventId: binding.record.self!.eventId,
    949     current: () => saved.current()
    950   };
    951 }
    952 // Local genuine nonce verification only; caller copies of this projection are
    953 // never accepted by the append owner in place of the original opaque proof.
    954 export function inboxProbeNonceVerificationEvidence(
    955   proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof,
    956   repository: PrivateStorageRepository,
    957   session: PrivateSession,
    958   policy: RelayPolicy
    959 ) {
    960   const original = probeNonceProofs.get(proof as InboxProbeNonceProof),
    961     recovered = recoveredNonceProofs.get(
    962       proof as RecoveredInboxProbeNonceProof
    963     ),
    964     saved = original ?? recovered,
    965     binding = original
    966       ? inboxProbeNonceProofBinding(
    967           proof as InboxProbeNonceProof,
    968           repository,
    969           session,
    970           policy
    971         )
    972       : recovered
    973         ? recoveredInboxProbeNonceProofBinding(
    974             proof as RecoveredInboxProbeNonceProof,
    975             repository,
    976             session,
    977             policy
    978           )
    979         : undefined;
    980   return saved && binding && binding.current()
    981     ? { ...binding, verifiedAtMilliseconds: saved.verifiedAtMilliseconds }
    982     : undefined;
    983 }
    984 
    985 // A genuine selected source proof can clear its own reader after native local
    986 // removal. This grants no removal, signing, replacement identity or readiness.
    987 export function disposeInboxProbeNonceProof(
    988   proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof,
    989   repository: PrivateStorageRepository,
    990   session: PrivateSession,
    991   policy: RelayPolicy
    992 ): boolean {
    993   const saved =
    994     probeNonceProofs.get(proof as InboxProbeNonceProof) ??
    995     recoveredNonceProofs.get(proof as RecoveredInboxProbeNonceProof);
    996   if (
    997     !saved ||
    998     saved.repository !== repository ||
    999     saved.session !== session ||
   1000     saved.policy !== policy
   1001   )
   1002     return false;
   1003   saved.dispose();
   1004   return true;
   1005 }
   1006 
   1007 declare const probeRecoveryReaderBrand: unique symbol;
   1008 export type InboxProbeRecoveryReader = Readonly<{
   1009   [probeRecoveryReaderBrand]: true;
   1010 }>;
   1011 declare const recoveredProbeBrand: unique symbol;
   1012 export type RecoveredInboxProbe = Readonly<{ [recoveredProbeBrand]: true }>;
   1013 export type InboxProbeRecoveryResult =
   1014   | Readonly<{ status: 'recovered'; proof: RecoveredInboxProbe }>
   1015   | Readonly<{
   1016       status:
   1017         | PrivateStorageFailure
   1018         | 'invalid'
   1019         | 'stopped'
   1020         | 'busy'
   1021         | 'refused'
   1022         | 'mismatch'
   1023         | 'lost_evidence';
   1024     }>;
   1025 type ProbeRecoveryReader = {
   1026   run(): Promise<InboxProbeRecoveryResult>;
   1027   stop(expired: boolean): void;
   1028 };
   1029 const recoveryCaptures = new WeakMap<InboxAccessController, true>();
   1030 const recoveryReaders = new WeakMap<
   1031   InboxProbeRecoveryReader,
   1032   ProbeRecoveryReader
   1033 >();
   1034 const accessRecoveryReaders = new WeakMap<
   1035   InboxAccessController,
   1036   Readonly<{
   1037     repository: PrivateStorageRepository;
   1038     identity: IdentitySession;
   1039     session: PrivateSession;
   1040     policy: RelayPolicy;
   1041     operator: InboxOperatorQualification;
   1042     id: string;
   1043     reader: InboxProbeRecoveryReader;
   1044   }>
   1045 >();
   1046 const recoveredProbes = new WeakMap<
   1047   RecoveredInboxProbe,
   1048   Readonly<{
   1049     repository: PrivateStorageRepository;
   1050     identity: IdentitySession;
   1051     session: PrivateSession;
   1052     access: InboxAccessController;
   1053     policy: RelayPolicy;
   1054     operator: InboxOperatorQualification;
   1055     record: PrivateAccessProbe;
   1056     handle: PrivateRecordHandle;
   1057     storedWire: string;
   1058     rumor(): string | undefined;
   1059     current(): boolean;
   1060   }>
   1061 >();
   1062 
   1063 // Capture supplies no key, native read or socket. Explicit run decrypts only the
   1064 // stored original under genuine owner/controller/configuration authorization.
   1065 export function captureInboxProbeRecoveryReader(
   1066   repository: PrivateStorageRepository,
   1067   identity: IdentitySession,
   1068   session: PrivateSession,
   1069   policy: RelayPolicy,
   1070   access: InboxAccessController,
   1071   operator: InboxOperatorQualification,
   1072   localId: unknown,
   1073   review: unknown
   1074 ): InboxProbeRecoveryReader | undefined {
   1075   if (
   1076     typeof window === 'undefined' ||
   1077     review !== 'reviewed_inbox_probe_recovery'
   1078   )
   1079     return undefined;
   1080   if (
   1081     (typeof access !== 'object' && typeof access !== 'function') ||
   1082     access === null ||
   1083     recoveryCaptures.has(access)
   1084   )
   1085     return undefined;
   1086   recoveryCaptures.set(access, true);
   1087   try {
   1088     const id = canonicalLocalId(localId),
   1089       configuredWire = inboxOperatorQualificationWire(operator, policy),
   1090       manifest = inboxOperatorQualificationSnapshot(operator),
   1091       owner = privateStorageOwner(repository);
   1092     if (
   1093       !id ||
   1094       !owner ||
   1095       !configuredWire ||
   1096       !manifest ||
   1097       manifest.authority === 'unconfigured'
   1098     )
   1099       return undefined;
   1100     const identityOwner = identityMessagingOwnership(identity);
   1101     if (!identityOwner?.current() || identityOwner.owner !== owner)
   1102       return undefined;
   1103     // The controller's genuine session/policy association is checked before
   1104     // passive session ownership, including its retained failed-cleanup retry.
   1105     const metadata = inboxAccessConstructionBinding(access, session, policy);
   1106     if (
   1107       !metadata ||
   1108       metadata.owner !== owner ||
   1109       !metadata.current() ||
   1110       ![...metadata.readTargets, ...metadata.archiveTargets].every((origin) => {
   1111         const row = manifest.relays.find((x) => x.origin === origin);
   1112         return (
   1113           row &&
   1114           row.auth !== 'unsupported' &&
   1115           row.recipientRead === 'supported' &&
   1116           row.namedArchiveAck === 'supported' &&
   1117           row.exactReadback === 'supported' &&
   1118           row.retention === 'operator_defined'
   1119         );
   1120       })
   1121     )
   1122       return undefined;
   1123     if (!identityOwner.current() || identityOwner.session !== metadata.session)
   1124       return undefined;
   1125     const privateOwner = privateSessionOwnership(session);
   1126     if (
   1127       !privateOwner?.current() ||
   1128       privateOwner.owner !== owner ||
   1129       privateOwner.session !== identityOwner.session
   1130     )
   1131       return undefined;
   1132     const previous = accessRecoveryReaders.get(access);
   1133     if (previous)
   1134       return previous.repository === repository &&
   1135         previous.identity === identity &&
   1136         previous.session === session &&
   1137         previous.policy === policy &&
   1138         previous.operator === operator &&
   1139         previous.id === id
   1140         ? previous.reader
   1141         : undefined;
   1142     const expectedBinding = JSON.stringify({
   1143       preferenceId: metadata.preferenceId,
   1144       preferenceCreatedAt: metadata.preferenceCreatedAt,
   1145       readTargets: metadata.readTargets,
   1146       archiveTargets: metadata.archiveTargets,
   1147       policyWire: JSON.stringify(readRelayPolicy(policy)),
   1148       operatorWire: configuredWire
   1149     });
   1150     const token = Object.freeze({}) as InboxProbeRecoveryReader;
   1151     const operation = Symbol();
   1152     let stopped = false,
   1153       consumed = false,
   1154       pending = false,
   1155       selectedWire: string | undefined,
   1156       active: ExtensionAction | undefined,
   1157       recovered: RecoveredInboxProbe | undefined,
   1158       rumorWire: string | undefined,
   1159       last: InboxProbeRecoveryResult | undefined;
   1160     const listeners = new Map<symbol, () => void>();
   1161     function current() {
   1162       if (stopped) return false;
   1163       const fresh =
   1164         identityOwner!.current() &&
   1165         privateOwner!.current() &&
   1166         inboxAccessConstructionBinding(access, session, policy);
   1167       const valid =
   1168         !!fresh &&
   1169         fresh.current() &&
   1170         fresh.owner === owner &&
   1171         fresh.session === identityOwner!.session &&
   1172         inboxOperatorQualificationWire(operator, policy) === configuredWire &&
   1173         JSON.stringify({
   1174           preferenceId: fresh.preferenceId,
   1175           preferenceCreatedAt: fresh.preferenceCreatedAt,
   1176           readTargets: fresh.readTargets,
   1177           archiveTargets: fresh.archiveTargets,
   1178           policyWire: JSON.stringify(readRelayPolicy(policy)),
   1179           operatorWire: configuredWire
   1180         }) === expectedBinding;
   1181       if (!valid) stop(false);
   1182       return valid && !stopped;
   1183     }
   1184     function stop(expired: boolean) {
   1185       stopped = true;
   1186       rumorWire = undefined;
   1187       if (recovered) recoveredProbes.delete(recovered);
   1188       recovered = undefined;
   1189       if (active) {
   1190         if (expired) markExtensionWaitExpired(active);
   1191         else stopExtensionAction(active);
   1192       }
   1193       for (const [id, off] of listeners) {
   1194         off();
   1195         listeners.delete(id);
   1196       }
   1197     }
   1198     function retain(register: () => () => void) {
   1199       const off = register();
   1200       if (stopped) off();
   1201       else listeners.set(Symbol(), off);
   1202     }
   1203     const decryptor = strictSelfDecryptor(identity, owner, current);
   1204     async function run(): Promise<InboxProbeRecoveryResult> {
   1205       if (!current()) {
   1206         stop(false);
   1207         return { status: 'stopped' };
   1208       }
   1209       if (pending) return { status: 'busy' };
   1210       if (consumed) return last ?? { status: 'stopped' };
   1211       pending = true;
   1212       try {
   1213         if (!navigator.locks?.request)
   1214           return (last = { status: 'unavailable' });
   1215         last = await navigator.locks.request(
   1216           'harvestcircle:owner:' + owner,
   1217           { mode: 'exclusive', ifAvailable: true },
   1218           async (lock): Promise<InboxProbeRecoveryResult> => {
   1219             if (!lock) return { status: 'busy' };
   1220             if (!current()) return { status: 'stopped' };
   1221             const loaded = await observePrivateRecord(
   1222               repository,
   1223               'private_sends',
   1224               id
   1225             );
   1226             if (!current()) return { status: 'stopped' };
   1227             if (!loaded.ok)
   1228               return {
   1229                 status:
   1230                   loaded.reason === 'invalid_record'
   1231                     ? 'lost_evidence'
   1232                     : loaded.reason
   1233               };
   1234             const record = privateRecordSnapshot(
   1235                 loaded.value.handle,
   1236                 owner,
   1237                 id
   1238               ),
   1239               storedWire = loaded.value.wire;
   1240             if (selectedWire !== undefined && selectedWire !== storedWire)
   1241               return { status: 'conflict' };
   1242             if (!record || record.family !== 'private_access_probe')
   1243               return { status: 'invalid_scope' };
   1244             if (!record.self || record.revision === 0)
   1245               return { status: 'lost_evidence' };
   1246             if (
   1247               privateRecordWire(loaded.value.handle, owner, id) !==
   1248                 storedWire ||
   1249               JSON.stringify(record.binding) !== expectedBinding
   1250             )
   1251               return { status: 'conflict' };
   1252             const checked = verifyEnvelope(record.self.wire),
   1253               outer = checked.ok && verifiedEnvelopeSnapshot(checked.value);
   1254             if (
   1255               !outer ||
   1256               outer.kind !== 1059 ||
   1257               outer.id !== record.self.eventId ||
   1258               JSON.stringify(outer.tags) !== JSON.stringify([['p', owner]]) ||
   1259               !exactLocalFields(outer, [
   1260                 'id',
   1261                 'pubkey',
   1262                 'created_at',
   1263                 'kind',
   1264                 'tags',
   1265                 'content',
   1266                 'sig'
   1267               ]) ||
   1268               !sealCiphertextV2(outer.content)
   1269             )
   1270               return { status: 'mismatch' };
   1271             selectedWire ??= storedWire;
   1272             const scheduler = browserExtensionScheduler();
   1273             if (!scheduler) return { status: 'unavailable' };
   1274             const result = await runExtensionAction<InboxProbeRecoveryResult>(
   1275               scheduler,
   1276               {
   1277                 owner: identityOwner!.owner,
   1278                 session: identityOwner!.session,
   1279                 operation
   1280               },
   1281               current,
   1282               async (action): Promise<InboxProbeRecoveryResult> => {
   1283                 consumed = true;
   1284                 active = action;
   1285                 const opened = await decryptor.open(action, outer);
   1286                 if (!current()) return { status: 'stopped' };
   1287                 if (opened.status !== 'opened') return opened;
   1288                 if (
   1289                   !inboxProbeRumorMatches(
   1290                     opened.rumorWire,
   1291                     owner,
   1292                     record.rumorHash,
   1293                     record.createdAt
   1294                   )
   1295                 )
   1296                   return { status: 'mismatch' };
   1297                 // No callback-capable provider work follows this last fresh-key
   1298                 // step. Final complete native physical read precedes proof mint.
   1299                 if (!(await decryptor.fresh(action)))
   1300                   return { status: 'stopped' };
   1301                 const after = await observePrivateRecord(
   1302                   repository,
   1303                   'private_sends',
   1304                   id
   1305                 );
   1306                 if (!current()) return { status: 'stopped' };
   1307                 if (!after.ok) return { status: after.reason };
   1308                 if (
   1309                   after.value.wire !== storedWire ||
   1310                   privateRecordWire(after.value.handle, owner, id) !==
   1311                     storedWire
   1312                 )
   1313                   return { status: 'conflict' };
   1314                 rumorWire = opened.rumorWire;
   1315                 const proof = Object.freeze({}) as RecoveredInboxProbe;
   1316                 recoveredProbes.set(proof, {
   1317                   repository,
   1318                   identity,
   1319                   session,
   1320                   access,
   1321                   policy,
   1322                   operator,
   1323                   record,
   1324                   handle: after.value.handle,
   1325                   storedWire,
   1326                   rumor: () => (current() ? rumorWire : undefined),
   1327                   current
   1328                 });
   1329                 recovered = proof;
   1330                 return { status: 'recovered', proof };
   1331               }
   1332             );
   1333             if (!current()) {
   1334               stop(false);
   1335               return { status: 'stopped' };
   1336             }
   1337             if (result.status === 'busy') return { status: 'busy' };
   1338             return result.status === 'completed' &&
   1339               'value' in result &&
   1340               result.value
   1341               ? result.value
   1342               : { status: result.status === 'denied' ? 'refused' : 'stopped' };
   1343           }
   1344         );
   1345         return last;
   1346       } catch {
   1347         return (last = { status: current() ? 'refused' : 'stopped' });
   1348       } finally {
   1349         active = undefined;
   1350         pending = false;
   1351       }
   1352     }
   1353     recoveryReaders.set(token, { run, stop });
   1354     accessRecoveryReaders.set(access, {
   1355       repository,
   1356       identity,
   1357       session,
   1358       policy,
   1359       operator,
   1360       id,
   1361       reader: token
   1362     });
   1363     retain(() =>
   1364       subscribeIdentityInvalidation(identity, () => {
   1365         if (!identityOwner.current()) stop(false);
   1366       })
   1367     );
   1368     retain(() => subscribePrivateSessionClose(session, () => stop(false)));
   1369     retain(() =>
   1370       subscribeInboxAccessControllerClose(access, () => stop(false))
   1371     );
   1372     return current() ? token : undefined;
   1373   } catch {
   1374     return undefined;
   1375   } finally {
   1376     recoveryCaptures.delete(access);
   1377   }
   1378 }
   1379 export function recoverInboxProbe(
   1380   reader: InboxProbeRecoveryReader
   1381 ): Promise<InboxProbeRecoveryResult> {
   1382   return (
   1383     recoveryReaders.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' })
   1384   );
   1385 }
   1386 export function stopInboxProbeRecoveryReader(reader: InboxProbeRecoveryReader) {
   1387   recoveryReaders.get(reader)?.stop(false);
   1388 }
   1389 export function expireInboxProbeRecoveryReaderWait(
   1390   reader: InboxProbeRecoveryReader
   1391 ) {
   1392   recoveryReaders.get(reader)?.stop(true);
   1393 }
   1394 // Metadata and strong original associations only, not live native/network
   1395 // authority. Later effect owners must independently reread exact physical wire.
   1396 export function recoveredInboxProbeBinding(
   1397   proof: RecoveredInboxProbe,
   1398   repository: PrivateStorageRepository,
   1399   session: PrivateSession,
   1400   access: InboxAccessController,
   1401   policy: RelayPolicy,
   1402   operator: InboxOperatorQualification
   1403 ) {
   1404   const saved = recoveredProbes.get(proof);
   1405   if (
   1406     !saved ||
   1407     saved.repository !== repository ||
   1408     saved.session !== session ||
   1409     saved.access !== access ||
   1410     saved.policy !== policy ||
   1411     saved.operator !== operator ||
   1412     !saved.current() ||
   1413     !saved.rumor()
   1414   )
   1415     return undefined;
   1416   return {
   1417     owner: saved.record.owner,
   1418     command: saved.record.id,
   1419     rumorHash: saved.record.rumorHash,
   1420     eventId: saved.record.self!.eventId,
   1421     handle: saved.handle,
   1422     storedWire: saved.storedWire,
   1423     current: () => saved.current() && !!saved.rumor()
   1424   };
   1425 }
   1426 // Only genuine recovered proof and exact current original scope can expose the
   1427 // private original rumor to a later separate source-owned probe admission.
   1428 export function recoveredInboxProbeRumorWire(
   1429   proof: RecoveredInboxProbe,
   1430   repository: PrivateStorageRepository,
   1431   session: PrivateSession,
   1432   access: InboxAccessController,
   1433   policy: RelayPolicy,
   1434   operator: InboxOperatorQualification
   1435 ): string | undefined {
   1436   return recoveredInboxProbeBinding(
   1437     proof,
   1438     repository,
   1439     session,
   1440     access,
   1441     policy,
   1442     operator
   1443   )
   1444     ? recoveredProbes.get(proof)?.rumor()
   1445     : undefined;
   1446 }
   1447 
   1448 export function disposeRecoveredInboxProbe(
   1449   proof: RecoveredInboxProbe,
   1450   repository: PrivateStorageRepository,
   1451   session: PrivateSession,
   1452   policy: RelayPolicy
   1453 ): boolean {
   1454   const saved = recoveredProbes.get(proof);
   1455   if (
   1456     !saved ||
   1457     saved.repository !== repository ||
   1458     saved.session !== session ||
   1459     saved.policy !== policy
   1460   )
   1461     return false;
   1462   const original = accessRecoveryReaders.get(saved.access);
   1463   if (
   1464     !original ||
   1465     original.repository !== repository ||
   1466     original.session !== session ||
   1467     original.policy !== policy
   1468   )
   1469     return false;
   1470   recoveryReaders.get(original.reader)?.stop(false);
   1471   return !recoveredProbes.has(proof);
   1472 }