app

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

private-sends.ts (32362B)


      1 import {
      2   identityMessagingOwnership,
      3   recheckIdentityOwner,
      4   type IdentitySession
      5 } from '../runtime/identity-session.ts';
      6 import {
      7   reservedSendSnapshot,
      8   type ReservedSendIdentity
      9 } from '../messaging/send-identity.ts';
     10 import {
     11   verifiedOutboundSnapshot,
     12   verifiedOutboundRecoverySource,
     13   type VerifiedOutboundEnvelope
     14 } from '../nostr/verify-outbound-envelope.ts';
     15 import {
     16   verifyEnvelope,
     17   verifiedEnvelopeSnapshot
     18 } from '../nostr/verified-envelope.ts';
     19 import {
     20   decodePrivateRecord,
     21   privateRecordSnapshot,
     22   privateRecordWire,
     23   type PrivateRecordHandle,
     24   type PrivateSendReservation,
     25   type PrivateSendOperation
     26 } from './private-records.ts';
     27 import {
     28   inboxRoutePlanSnapshot,
     29   createInboxRoutePlan,
     30   recheckInboxRoutePlan,
     31   type InboxRoutePlan
     32 } from '../messaging/inbox-routing.ts';
     33 import type { PairedDeliveryContext } from '../messaging/prepare-send.ts';
     34 import {
     35   loadPrivateRecord,
     36   commitPrivateRecord,
     37   type PrivateStorageRepository,
     38   type PrivateStorageFailure,
     39   type PrivateStorageResult
     40 } from './private-storage.ts';
     41 import {
     42   preparePrivateReceiptTransition,
     43   commitPrivateReceiptTransition,
     44   type PrivateReceiptCommitResult
     45 } from './private-receipts.ts';
     46 
     47 declare const acknowledgementBrand: unique symbol;
     48 export type SelfRecoveryAcknowledgement = Readonly<{
     49   [acknowledgementBrand]: true;
     50 }>;
     51 type Saved = Readonly<{
     52   record: PrivateSendReservation;
     53   revision: number;
     54   wire: string;
     55   self: Readonly<{ eventId: string; wire: string }>;
     56   current(): boolean;
     57 }>;
     58 const acknowledgements = new WeakMap<SelfRecoveryAcknowledgement, Saved>();
     59 export type SelfRecoveryCommitResult =
     60   | Readonly<{
     61       status: 'saved' | 'existing' | 'reconciled';
     62       receipt: SelfRecoveryAcknowledgement;
     63     }>
     64   | Readonly<{ status: PrivateStorageFailure | 'invalid' | 'stopped' }>;
     65 
     66 // A namespace read is not a crypto proof or acknowledgement. Defensive owner,
     67 // command and immutable-rumor matching precedes any future SDK preparation.
     68 export async function readSelfRecoveryBase(
     69   repository: PrivateStorageRepository,
     70   reserved: ReservedSendIdentity
     71 ): Promise<PrivateStorageResult<PrivateRecordHandle>> {
     72   const record = reservedSendSnapshot(reserved);
     73   if (!record) return { ok: false, reason: 'invalid_record' };
     74   const loaded = await loadPrivateRecord(
     75     repository,
     76     'private_sends',
     77     record.id
     78   );
     79   if (!loaded.ok)
     80     return {
     81       ok: false,
     82       reason: loaded.reason === 'invalid_scope' ? 'unavailable' : loaded.reason
     83     };
     84   const row = privateRecordSnapshot(loaded.value, record.owner, record.id);
     85   if (
     86     !row ||
     87     (row.family !== 'private_send_reservation' &&
     88       row.family !== 'private_send_operation') ||
     89     row.peer !== record.peer ||
     90     row.rumorHash !== record.rumorHash ||
     91     row.createdAt !== record.createdAt
     92   )
     93     return { ok: false, reason: 'invalid_record' };
     94   if (!reservedSendSnapshot(reserved))
     95     return { ok: false, reason: 'invalid_record' };
     96   return loaded;
     97 }
     98 
     99 function input(
    100   session: IdentitySession,
    101   reserved: ReservedSendIdentity,
    102   proof: VerifiedOutboundEnvelope
    103 ) {
    104   const record = reservedSendSnapshot(reserved),
    105     ownership = identityMessagingOwnership(session),
    106     observed = verifiedOutboundSnapshot(proof);
    107   if (
    108     !record ||
    109     !ownership?.current() ||
    110     !observed ||
    111     ownership.owner !== record.owner ||
    112     observed.role !== 'self' ||
    113     observed.destination !== record.owner ||
    114     observed.command !== record.id ||
    115     observed.owner !== record.owner ||
    116     observed.peer !== record.peer ||
    117     observed.rumorHash !== record.rumorHash
    118   )
    119     return undefined;
    120   const verified = verifyEnvelope(observed.wire),
    121     event = verified.ok && verifiedEnvelopeSnapshot(verified.value);
    122   if (!event || event.kind !== 1059) return undefined;
    123   const current = () => {
    124     const original = reservedSendSnapshot(reserved),
    125       outer = verifiedOutboundSnapshot(proof);
    126     return (
    127       ownership.current() &&
    128       original?.owner === record.owner &&
    129       original.id === record.id &&
    130       original.peer === record.peer &&
    131       original.rumorHash === record.rumorHash &&
    132       original.createdAt === record.createdAt &&
    133       outer?.role === 'self' &&
    134       outer.destination === record.owner &&
    135       outer.wire === observed.wire
    136     );
    137   };
    138   return current()
    139     ? {
    140         record,
    141         current,
    142         ownerCurrent: () => ownership.current(),
    143         self: { eventId: event.id, wire: observed.wire },
    144         recoveryWire: verifiedOutboundRecoverySource(proof)
    145       }
    146     : undefined;
    147 }
    148 
    149 // No signer/network await occurs in an IDB transaction. Only genuine current
    150 // factory association plus acknowledged exact ciphertext readback mints this
    151 // local fact. It grants no relay readiness, pair plan or transmission permission.
    152 export async function commitSelfRecovery(
    153   repository: PrivateStorageRepository,
    154   session: IdentitySession,
    155   reserved: ReservedSendIdentity,
    156   proof: VerifiedOutboundEnvelope,
    157   review: unknown
    158 ): Promise<SelfRecoveryCommitResult> {
    159   if (typeof window === 'undefined' || review !== 'reviewed_self_commit')
    160     return { status: 'invalid' };
    161   const captured = input(session, reserved, proof);
    162   if (!captured) return { status: 'invalid' };
    163   try {
    164     const loaded = await readSelfRecoveryBase(repository, reserved);
    165     if (!captured.current()) return { status: 'stopped' };
    166     if (!loaded.ok) return { status: loaded.reason };
    167     const base = privateRecordSnapshot(
    168       loaded.value,
    169       captured.record.owner,
    170       captured.record.id
    171     );
    172     if (
    173       !base ||
    174       (base.family !== 'private_send_reservation' &&
    175         base.family !== 'private_send_operation')
    176     )
    177       return { status: 'invalid_record' };
    178     if (
    179       captured.recoveryWire !== undefined &&
    180       privateRecordWire(
    181         loaded.value,
    182         captured.record.owner,
    183         captured.record.id
    184       ) !== captured.recoveryWire
    185     )
    186       return { status: 'conflict' };
    187     let expected: PrivateRecordHandle,
    188       status: 'saved' | 'existing' | 'reconciled';
    189     if (base.family === 'private_send_operation') {
    190       if (
    191         base.self.eventId !== captured.self.eventId ||
    192         base.self.wire !== captured.self.wire
    193       )
    194         return { status: 'conflict' };
    195       expected = loaded.value;
    196       status = 'existing';
    197     } else {
    198       const raw = JSON.stringify({
    199         schema: 1,
    200         family: 'private_send_operation',
    201         owner: base.owner,
    202         id: base.id,
    203         revision: base.revision + 1,
    204         peer: base.peer,
    205         rumorHash: base.rumorHash,
    206         createdAt: base.createdAt,
    207         self: { eventId: captured.self.eventId, wire: captured.self.wire },
    208         peerArtifact: null
    209       });
    210       const decoded = decodePrivateRecord(raw, base.owner, base.id);
    211       if (!decoded.ok) return { status: 'invalid_record' };
    212       expected = decoded.value;
    213       if (!captured.current()) return { status: 'stopped' };
    214       const committed = await commitPrivateRecord(
    215         repository,
    216         expected,
    217         loaded.value
    218       );
    219       if (!captured.current()) return { status: 'stopped' };
    220       if (!committed.ok && committed.reason !== 'unknown_completion')
    221         return { status: committed.reason };
    222       status = !committed.ok
    223         ? 'reconciled'
    224         : committed.value.state === 'existing'
    225           ? 'existing'
    226           : 'saved';
    227     }
    228     const expectedWire = privateRecordWire(
    229       expected,
    230       captured.record.owner,
    231       captured.record.id
    232     );
    233     const readback = await loadPrivateRecord(
    234       repository,
    235       'private_sends',
    236       captured.record.id
    237     );
    238     if (!captured.current()) return { status: 'stopped' };
    239     if (!readback.ok) return { status: 'unknown_completion' };
    240     const wire = privateRecordWire(
    241         readback.value,
    242         captured.record.owner,
    243         captured.record.id
    244       ),
    245       record = privateRecordSnapshot(
    246         readback.value,
    247         captured.record.owner,
    248         captured.record.id
    249       );
    250     if (
    251       !wire ||
    252       wire !== expectedWire ||
    253       !record ||
    254       record.family !== 'private_send_operation' ||
    255       record.self.eventId !== captured.self.eventId ||
    256       record.self.wire !== captured.self.wire
    257     )
    258       return { status: 'conflict' };
    259     const receipt = Object.freeze({}) as SelfRecoveryAcknowledgement;
    260     acknowledgements.set(receipt, {
    261       record: captured.record,
    262       revision: record.revision,
    263       wire,
    264       self: captured.self,
    265       // The acknowledged local fact survives clearing the crypto preparation.
    266       // Effect permission remains separately gated by the live workflow.
    267       current: captured.ownerCurrent
    268     });
    269     return { status, receipt };
    270   } catch {
    271     return { status: captured.current() ? 'unavailable' : 'stopped' };
    272   }
    273 }
    274 
    275 export function selfRecoveryAcknowledgementSnapshot(
    276   receipt: SelfRecoveryAcknowledgement
    277 ) {
    278   const saved = acknowledgements.get(receipt);
    279   return saved?.current()
    280     ? {
    281         owner: saved.record.owner,
    282         id: saved.record.id,
    283         peer: saved.record.peer,
    284         rumorHash: saved.record.rumorHash,
    285         createdAt: saved.record.createdAt,
    286         revision: saved.revision,
    287         self: { eventId: saved.self.eventId, wire: saved.self.wire },
    288         copy: 'Saved encrypted in this browser' as const,
    289         fact: 'acknowledged_local_ciphertext_only' as const
    290       }
    291     : undefined;
    292 }
    293 
    294 // Recheck exact local evidence before a workflow advances. This does not
    295 // promise retention after the read; clearing/eviction and later CAS remain real.
    296 export async function verifySelfRecoveryAcknowledgement(
    297   repository: PrivateStorageRepository,
    298   receipt: SelfRecoveryAcknowledgement
    299 ): Promise<boolean> {
    300   const saved = acknowledgements.get(receipt);
    301   if (!saved?.current()) return false;
    302   const loaded = await loadPrivateRecord(
    303     repository,
    304     'private_sends',
    305     saved.record.id
    306   );
    307   return (
    308     saved.current() &&
    309     loaded.ok &&
    310     privateRecordWire(loaded.value, saved.record.owner, saved.record.id) ===
    311       saved.wire
    312   );
    313 }
    314 
    315 declare const pairedAcknowledgementBrand: unique symbol;
    316 export type PairedDeliveryAcknowledgement = Readonly<{
    317   [pairedAcknowledgementBrand]: true;
    318 }>;
    319 type Paired = Readonly<{
    320   record: PrivateSendOperation;
    321   wire: string;
    322   current(): boolean;
    323 }>;
    324 const pairedAcknowledgements = new WeakMap<
    325   PairedDeliveryAcknowledgement,
    326   Paired
    327 >();
    328 declare const routingReviewBrand: unique symbol;
    329 export type PairedRoutingReview = Readonly<{ [routingReviewBrand]: true }>;
    330 type RoutingReview = Readonly<{
    331   repository: PrivateStorageRepository;
    332   session: IdentitySession;
    333   receipt: PairedDeliveryAcknowledgement;
    334   saved: Paired;
    335   context: PairedDeliveryContext;
    336   changed: boolean;
    337   current(): boolean;
    338 }>;
    339 const routingReviewStates = new WeakMap<PairedRoutingReview, RoutingReview>();
    340 const pendingRoutingReviews = new WeakMap<
    341   PairedDeliveryAcknowledgement,
    342   PairedRoutingReview
    343 >();
    344 // Genuine current discovery is a reviewed destination candidate, not Send.
    345 // Detection immediately fences previously captured retry/publication custody.
    346 export function capturePairedRoutingReview(
    347   repository: PrivateStorageRepository,
    348   session: IdentitySession,
    349   receipt: PairedDeliveryAcknowledgement,
    350   candidate: Pick<PairedDeliveryContext, 'policy' | 'own' | 'other'>,
    351   review: unknown
    352 ): PairedRoutingReview | undefined {
    353   if (
    354     typeof window === 'undefined' ||
    355     review !== 'reviewed_private_route_resolution'
    356   )
    357     return undefined;
    358   const saved = pairedAcknowledgements.get(receipt),
    359     ownership = identityMessagingOwnership(session);
    360   if (
    361     !saved?.current() ||
    362     !saved.record.deliveryPlan ||
    363     !saved.record.peerArtifact ||
    364     !ownership?.current() ||
    365     ownership.owner !== saved.record.owner
    366   )
    367     return undefined;
    368   // Unready current resolution must also fence the old destination. No
    369   // fallback capability survives merely because there is no new usable plan.
    370   const token = Object.freeze({}) as PairedRoutingReview;
    371   pendingRoutingReviews.set(receipt, token);
    372   const plan = createInboxRoutePlan(
    373     candidate.policy,
    374     saved.record.owner,
    375     saved.record.peer,
    376     candidate.own,
    377     candidate.other
    378   );
    379   if (!plan) return undefined;
    380   const context = {
    381     plan,
    382     policy: candidate.policy,
    383     own: candidate.own,
    384     other: candidate.other
    385   };
    386   const routes = inboxRoutePlanSnapshot(plan);
    387   if (
    388     !routes ||
    389     routes.peer.author !== saved.record.peer ||
    390     routes.archive.author !== saved.record.owner ||
    391     recheckInboxRoutePlan(
    392       context.plan,
    393       context.policy,
    394       context.own,
    395       context.other
    396     ) !== 'unchanged'
    397   )
    398     return undefined;
    399   const current = () =>
    400     saved.current() &&
    401     ownership.current() &&
    402     pendingRoutingReviews.get(receipt) === token &&
    403     recheckInboxRoutePlan(
    404       context.plan,
    405       context.policy,
    406       context.own,
    407       context.other
    408     ) === 'unchanged';
    409   routingReviewStates.set(token, {
    410     repository,
    411     session,
    412     receipt,
    413     saved,
    414     context,
    415     changed:
    416       JSON.stringify(routes) !==
    417       JSON.stringify(saved.record.deliveryPlan.routes),
    418     current
    419   });
    420   return token;
    421 }
    422 export function pairedRoutingReviewSnapshot(token: PairedRoutingReview) {
    423   const state = routingReviewStates.get(token);
    424   if (!state?.current() || !state.saved.record.deliveryPlan) return undefined;
    425   const previous = state.saved.record.deliveryPlan.routes,
    426     next = inboxRoutePlanSnapshot(state.context.plan);
    427   if (!next) return undefined;
    428   function changes(role: 'peer' | 'archive') {
    429     return {
    430       removed: previous[role].targets.filter(
    431         (origin) => !next![role].targets.includes(origin)
    432       ),
    433       added: next![role].targets.filter(
    434         (origin) => !previous[role].targets.includes(origin)
    435       )
    436     };
    437   }
    438   return {
    439     owner: state.saved.record.owner,
    440     peer: state.saved.record.peer,
    441     command: state.saved.record.id,
    442     status: state.changed
    443       ? ('review_required' as const)
    444       : ('unchanged' as const),
    445     previous: JSON.parse(JSON.stringify(previous)) as typeof previous,
    446     next,
    447     changes: { peer: changes('peer'), archive: changes('archive') },
    448     fact: 'destination_review_only' as const
    449   };
    450 }
    451 export type PairedRoutingResult =
    452   | Readonly<{
    453       status: 'updated' | 'unchanged';
    454       receipt: PairedDeliveryAcknowledgement;
    455     }>
    456   | Readonly<{ status: PrivateStorageFailure | 'invalid' | 'stopped' }>;
    457 export async function approvePairedRoutingReview(
    458   token: PairedRoutingReview,
    459   review: unknown
    460 ): Promise<PairedRoutingResult> {
    461   const state = routingReviewStates.get(token);
    462   if (
    463     !state ||
    464     review !== 'reviewed_private_destination_update' ||
    465     !navigator.locks?.request
    466   )
    467     return { status: 'invalid' };
    468   if (!state.current()) return { status: 'stopped' };
    469   const { repository, session, receipt, saved, context } = state;
    470   try {
    471     const owner = await recheckIdentityOwner(session);
    472     if (
    473       owner.state !== 'messaging_capable' ||
    474       owner.publicKey !== saved.record.owner ||
    475       owner.admission === 'busy' ||
    476       !state.current()
    477     )
    478       return { status: 'stopped' };
    479     return await navigator.locks.request(
    480       'harvestcircle:owner:' + saved.record.owner,
    481       { mode: 'exclusive', ifAvailable: true },
    482       async (lock) => {
    483         if (!lock || !state.current()) return { status: 'stopped' as const };
    484         const base = await loadPrivateRecord(
    485           repository,
    486           'private_sends',
    487           saved.record.id
    488         );
    489         if (!state.current()) return { status: 'stopped' as const };
    490         if (!base.ok) return { status: base.reason };
    491         if (
    492           privateRecordWire(base.value, saved.record.owner, saved.record.id) !==
    493           saved.wire
    494         )
    495           return { status: 'conflict' as const };
    496         const routes = inboxRoutePlanSnapshot(context.plan),
    497           row = saved.record;
    498         if (!routes || !row.deliveryPlan) return { status: 'invalid' as const };
    499         let expected = base.value;
    500         if (state.changed) {
    501           if (row.revision === Number.MAX_SAFE_INTEGER)
    502             return { status: 'invalid_record' as const };
    503           const decoded = decodePrivateRecord(
    504             JSON.stringify({
    505               ...row,
    506               revision: row.revision + 1,
    507               deliveryPlan: {
    508                 state: 'prepared',
    509                 routes,
    510                 previousRoutes: [
    511                   ...(row.deliveryPlan.previousRoutes ?? []),
    512                   row.deliveryPlan.routes
    513                 ]
    514               }
    515             }),
    516             row.owner,
    517             row.id
    518           );
    519           if (!decoded.ok) return { status: 'invalid_record' as const };
    520           expected = decoded.value;
    521           if (!state.current()) return { status: 'stopped' as const };
    522           const committed = await commitPrivateRecord(
    523             repository,
    524             expected,
    525             base.value
    526           );
    527           if (!state.current())
    528             return { status: 'unknown_completion' as const };
    529           if (!committed.ok) return { status: committed.reason };
    530         }
    531         const loaded = await loadPrivateRecord(
    532           repository,
    533           'private_sends',
    534           row.id
    535         );
    536         if (!state.current() || !loaded.ok)
    537           return { status: 'unknown_completion' as const };
    538         const wire = privateRecordWire(loaded.value, row.owner, row.id),
    539           next = privateRecordSnapshot(loaded.value, row.owner, row.id);
    540         if (
    541           !wire ||
    542           wire !== privateRecordWire(expected, row.owner, row.id) ||
    543           !next ||
    544           next.family !== 'private_send_operation' ||
    545           JSON.stringify(next.self) !== JSON.stringify(row.self) ||
    546           JSON.stringify(next.peerArtifact) !== JSON.stringify(row.peerArtifact)
    547         )
    548           return { status: 'conflict' as const };
    549         pairedAcknowledgements.set(receipt, {
    550           record: next,
    551           wire,
    552           current: saved.current
    553         });
    554         pendingRoutingReviews.delete(receipt);
    555         routingReviewStates.delete(token);
    556         return {
    557           status: state.changed ? ('updated' as const) : ('unchanged' as const),
    558           receipt
    559         };
    560       }
    561     );
    562   } catch {
    563     return { status: state.current() ? 'unavailable' : 'stopped' };
    564   }
    565 }
    566 // Explicit restart admission authenticates the self recovery copy and verifies
    567 // exact durable pair custody. It does not decrypt or newly authenticate the
    568 // nested peer ciphertext, regenerate either artifact, or perform publication.
    569 export async function acknowledgeRecoveredPairedDelivery(
    570   repository: PrivateStorageRepository,
    571   session: IdentitySession,
    572   reserved: ReservedSendIdentity,
    573   self: SelfRecoveryAcknowledgement,
    574   context: PairedDeliveryContext,
    575   review: unknown
    576 ): Promise<PairedDeliveryCommitResult> {
    577   if (
    578     typeof window === 'undefined' ||
    579     review !== 'reviewed_stored_private_retry' ||
    580     !navigator.locks?.request
    581   )
    582     return { status: 'invalid' };
    583   const saved = acknowledgements.get(self),
    584     original = reservedSendSnapshot(reserved),
    585     ownership = identityMessagingOwnership(session);
    586   if (
    587     !saved?.current() ||
    588     !original ||
    589     !ownership?.current() ||
    590     JSON.stringify(saved.record) !== JSON.stringify(original) ||
    591     original.owner !== ownership.owner
    592   )
    593     return { status: 'invalid' };
    594   const current = () =>
    595     ownership.current() &&
    596     saved.current() &&
    597     !!reservedSendSnapshot(reserved) &&
    598     recheckInboxRoutePlan(
    599       context.plan,
    600       context.policy,
    601       context.own,
    602       context.other
    603     ) === 'unchanged';
    604   try {
    605     const checked = await recheckIdentityOwner(session);
    606     if (
    607       checked.state !== 'messaging_capable' ||
    608       checked.publicKey !== ownership.owner ||
    609       checked.admission === 'busy' ||
    610       !current()
    611     )
    612       return { status: 'stopped' };
    613     return await navigator.locks.request(
    614       'harvestcircle:owner:' + ownership.owner,
    615       { mode: 'exclusive', ifAvailable: true },
    616       async (lock) => {
    617         if (!lock || !current()) return { status: 'stopped' as const };
    618         const loaded = await loadPrivateRecord(
    619           repository,
    620           'private_sends',
    621           original.id
    622         );
    623         if (!current()) return { status: 'stopped' as const };
    624         if (!loaded.ok) return { status: loaded.reason };
    625         const row = privateRecordSnapshot(
    626             loaded.value,
    627             original.owner,
    628             original.id
    629           ),
    630           wire = privateRecordWire(loaded.value, original.owner, original.id),
    631           routes = inboxRoutePlanSnapshot(context.plan);
    632         if (
    633           !row ||
    634           row.family !== 'private_send_operation' ||
    635           !row.peerArtifact ||
    636           !row.deliveryPlan ||
    637           !wire ||
    638           wire !== saved.wire ||
    639           JSON.stringify(row.deliveryPlan.routes) !== JSON.stringify(routes)
    640         )
    641           return { status: 'conflict' as const };
    642         const verified = verifyEnvelope(row.peerArtifact.wire),
    643           event = verified.ok && verifiedEnvelopeSnapshot(verified.value);
    644         if (
    645           !event ||
    646           event.kind !== 1059 ||
    647           event.id !== row.peerArtifact.eventId ||
    648           event.tags.length !== 1 ||
    649           event.tags[0].length !== 2 ||
    650           event.tags[0][0] !== 'p' ||
    651           event.tags[0][1] !== row.peer ||
    652           !current()
    653         )
    654           return { status: 'invalid' as const };
    655         const receipt = Object.freeze({}) as PairedDeliveryAcknowledgement;
    656         pairedAcknowledgements.set(receipt, {
    657           record: row,
    658           wire,
    659           current: () => ownership.current()
    660         });
    661         return { status: 'existing' as const, receipt };
    662       }
    663     );
    664   } catch {
    665     return { status: current() ? 'unavailable' : 'stopped' };
    666   }
    667 }
    668 export type PairedDeliveryCommitResult =
    669   | Readonly<{
    670       status: 'prepared' | 'existing' | 'reconciled';
    671       receipt: PairedDeliveryAcknowledgement;
    672     }>
    673   | Readonly<{ status: PrivateStorageFailure | 'invalid' | 'stopped' }>;
    674 
    675 // Requires genuine current self acknowledgement, peer factory proof and route
    676 // capture. Structural local record admission alone cannot mint this receipt.
    677 // Caller owns WebLock and current route recheck; this function owns short CAS.
    678 export async function commitPairedDelivery(
    679   repository: PrivateStorageRepository,
    680   session: IdentitySession,
    681   reserved: ReservedSendIdentity,
    682   self: SelfRecoveryAcknowledgement,
    683   peer: VerifiedOutboundEnvelope,
    684   plan: InboxRoutePlan,
    685   review: unknown
    686 ): Promise<PairedDeliveryCommitResult> {
    687   if (typeof window === 'undefined' || review !== 'reviewed_pair_commit')
    688     return { status: 'invalid' };
    689   const savedSelf = acknowledgements.get(self),
    690     original = reservedSendSnapshot(reserved),
    691     ownership = identityMessagingOwnership(session),
    692     proof = verifiedOutboundSnapshot(peer),
    693     routes = inboxRoutePlanSnapshot(plan);
    694   if (
    695     !savedSelf?.current() ||
    696     !original ||
    697     !ownership?.current() ||
    698     !proof ||
    699     !routes ||
    700     original.owner !== ownership.owner ||
    701     savedSelf.record.owner !== original.owner ||
    702     savedSelf.record.id !== original.id ||
    703     savedSelf.record.peer !== original.peer ||
    704     savedSelf.record.rumorHash !== original.rumorHash ||
    705     savedSelf.record.createdAt !== original.createdAt ||
    706     proof.role !== 'peer' ||
    707     proof.destination !== original.peer ||
    708     proof.owner !== original.owner ||
    709     proof.command !== original.id ||
    710     proof.peer !== original.peer ||
    711     proof.rumorHash !== original.rumorHash ||
    712     routes.peer.author !== original.peer ||
    713     routes.archive.author !== original.owner
    714   )
    715     return { status: 'invalid' };
    716   const verified = verifyEnvelope(proof.wire),
    717     event = verified.ok && verifiedEnvelopeSnapshot(verified.value);
    718   if (!event || event.kind !== 1059) return { status: 'invalid' };
    719   const current = () => {
    720     const fresh = reservedSendSnapshot(reserved),
    721       peerNow = verifiedOutboundSnapshot(peer);
    722     return (
    723       ownership.current() &&
    724       savedSelf.current() &&
    725       fresh?.owner === original.owner &&
    726       fresh.id === original.id &&
    727       fresh.peer === original.peer &&
    728       fresh.rumorHash === original.rumorHash &&
    729       fresh.createdAt === original.createdAt &&
    730       peerNow?.role === 'peer' &&
    731       peerNow.wire === proof.wire
    732     );
    733   };
    734   try {
    735     const loaded = await readSelfRecoveryBase(repository, reserved);
    736     if (!current()) return { status: 'stopped' };
    737     if (!loaded.ok) return { status: loaded.reason };
    738     const base = privateRecordSnapshot(
    739         loaded.value,
    740         original.owner,
    741         original.id
    742       ),
    743       baseWire = privateRecordWire(loaded.value, original.owner, original.id);
    744     if (
    745       !base ||
    746       base.family !== 'private_send_operation' ||
    747       base.self.eventId !== savedSelf.self.eventId ||
    748       base.self.wire !== savedSelf.self.wire
    749     )
    750       return { status: 'conflict' };
    751     const peerArtifact = { eventId: event.id, wire: proof.wire },
    752       deliveryPlan = { state: 'prepared' as const, routes };
    753     let expected: PrivateRecordHandle,
    754       status: 'prepared' | 'existing' | 'reconciled';
    755     if (base.peerArtifact || base.deliveryPlan) {
    756       if (
    757         base.peerArtifact?.eventId !== peerArtifact.eventId ||
    758         base.peerArtifact.wire !== peerArtifact.wire ||
    759         JSON.stringify(base.deliveryPlan) !== JSON.stringify(deliveryPlan)
    760       )
    761         return { status: 'conflict' };
    762       expected = loaded.value;
    763       status = 'existing';
    764     } else {
    765       if (baseWire !== savedSelf.wire) return { status: 'conflict' };
    766       const decoded = decodePrivateRecord(
    767         JSON.stringify({
    768           schema: 1,
    769           family: 'private_send_operation',
    770           owner: base.owner,
    771           id: base.id,
    772           revision: base.revision + 1,
    773           peer: base.peer,
    774           rumorHash: base.rumorHash,
    775           createdAt: base.createdAt,
    776           self: { eventId: base.self.eventId, wire: base.self.wire },
    777           peerArtifact,
    778           deliveryPlan
    779         }),
    780         base.owner,
    781         base.id
    782       );
    783       if (!decoded.ok) return { status: 'invalid_record' };
    784       expected = decoded.value;
    785       if (!current()) return { status: 'stopped' };
    786       const committed = await commitPrivateRecord(
    787         repository,
    788         expected,
    789         loaded.value
    790       );
    791       if (!current()) return { status: 'stopped' };
    792       if (!committed.ok && committed.reason !== 'unknown_completion')
    793         return { status: committed.reason };
    794       status = !committed.ok
    795         ? 'reconciled'
    796         : committed.value.state === 'existing'
    797           ? 'existing'
    798           : 'prepared';
    799     }
    800     const wire = privateRecordWire(expected, original.owner, original.id),
    801       readback = await loadPrivateRecord(
    802         repository,
    803         'private_sends',
    804         original.id
    805       );
    806     if (!current()) return { status: 'stopped' };
    807     if (!readback.ok) return { status: 'unknown_completion' };
    808     const observed = privateRecordSnapshot(
    809       readback.value,
    810       original.owner,
    811       original.id
    812     );
    813     if (
    814       !wire ||
    815       privateRecordWire(readback.value, original.owner, original.id) !== wire ||
    816       !observed ||
    817       observed.family !== 'private_send_operation' ||
    818       !observed.peerArtifact ||
    819       !observed.deliveryPlan
    820     )
    821       return { status: 'conflict' };
    822     const receipt = Object.freeze({}) as PairedDeliveryAcknowledgement;
    823     pairedAcknowledgements.set(receipt, {
    824       record: observed,
    825       wire,
    826       current: () => ownership.current()
    827     });
    828     return { status, receipt };
    829   } catch {
    830     return { status: current() ? 'unavailable' : 'stopped' };
    831   }
    832 }
    833 export function pairedDeliveryAcknowledgementSnapshot(
    834   receipt: PairedDeliveryAcknowledgement
    835 ) {
    836   const saved = pairedAcknowledgements.get(receipt);
    837   if (
    838     !saved?.current() ||
    839     pendingRoutingReviews.has(receipt) ||
    840     !saved.record.peerArtifact ||
    841     !saved.record.deliveryPlan
    842   )
    843     return undefined;
    844   const row = saved.record;
    845   return {
    846     owner: row.owner,
    847     id: row.id,
    848     revision: row.revision,
    849     peer: row.peer,
    850     rumorHash: row.rumorHash,
    851     createdAt: row.createdAt,
    852     self: { ...row.self },
    853     peerArtifact: { ...saved.record.peerArtifact },
    854     deliveryPlan: JSON.parse(
    855       JSON.stringify(saved.record.deliveryPlan)
    856     ) as NonNullable<PrivateSendOperation['deliveryPlan']>,
    857     fact: 'acknowledged_local_pair_only' as const
    858   };
    859 }
    860 export async function verifyPairedDeliveryAcknowledgement(
    861   repository: PrivateStorageRepository,
    862   receipt: PairedDeliveryAcknowledgement
    863 ): Promise<boolean> {
    864   const saved = pairedAcknowledgements.get(receipt);
    865   if (!saved?.current() || pendingRoutingReviews.has(receipt)) return false;
    866   const loaded = await loadPrivateRecord(
    867     repository,
    868     'private_sends',
    869     saved.record.id
    870   );
    871   return (
    872     saved.current() &&
    873     !pendingRoutingReviews.has(receipt) &&
    874     loaded.ok &&
    875     privateRecordWire(loaded.value, saved.record.owner, saved.record.id) ===
    876       saved.wire
    877   );
    878 }
    879 // A separately decoded row cannot supply acceptance facts merely because the
    880 // owner and local ID match. Require the full wire acknowledged by this genuine
    881 // current custody, then let the workflow recheck actual storage before use.
    882 export function pairedDeliveryRecordMatches(
    883   receipt: PairedDeliveryAcknowledgement,
    884   record: PrivateRecordHandle
    885 ): boolean {
    886   const saved = pairedAcknowledgements.get(receipt);
    887   return (
    888     !!saved?.current() &&
    889     !pendingRoutingReviews.has(receipt) &&
    890     privateRecordWire(record, saved.record.owner, saved.record.id) ===
    891       saved.wire
    892   );
    893 }
    894 // Pure genuine custody metadata. A workflow must still verify full readback
    895 // under the owner lock before suppressing or admitting a network effect.
    896 export function pairedDeliveryTargetAccepted(
    897   receipt: PairedDeliveryAcknowledgement,
    898   role: 'peer' | 'self_archive',
    899   origin: string,
    900   eventId: string
    901 ): boolean {
    902   const saved = pairedAcknowledgements.get(receipt);
    903   return (
    904     !!saved?.current() &&
    905     !pendingRoutingReviews.has(receipt) &&
    906     (saved.record.receipts ?? []).some(
    907       (fact) =>
    908         fact.role === role &&
    909         fact.origin === origin &&
    910         fact.eventId === eventId &&
    911         fact.status === 'accepted'
    912     )
    913   );
    914 }
    915 // Only the already genuine current pair can renew its exact custody after a
    916 // controlled append of named receipt metadata. A decoded namespace row alone
    917 // cannot mint this acknowledgment. Earlier permissions invalidate on revision.
    918 export async function commitPairedDeliveryReceipt(
    919   repository: PrivateStorageRepository,
    920   receipt: PairedDeliveryAcknowledgement,
    921   receiptWire: unknown
    922 ): Promise<PrivateReceiptCommitResult> {
    923   const saved = pairedAcknowledgements.get(receipt);
    924   if (!saved?.current() || pendingRoutingReviews.has(receipt))
    925     return { status: 'invalid' };
    926   try {
    927     const loaded = await loadPrivateRecord(
    928       repository,
    929       'private_sends',
    930       saved.record.id
    931     );
    932     if (!loaded.ok) return { status: loaded.reason };
    933     if (
    934       !saved.current() ||
    935       privateRecordWire(loaded.value, saved.record.owner, saved.record.id) !==
    936         saved.wire
    937     )
    938       return { status: 'conflict' };
    939     const transition = preparePrivateReceiptTransition(
    940       loaded.value,
    941       saved.record.owner,
    942       saved.record.id,
    943       receiptWire
    944     );
    945     if (!transition.ok) return { status: 'invalid' };
    946     const committed = await commitPrivateReceiptTransition(
    947       repository,
    948       transition.value
    949     );
    950     if (!('record' in committed)) return committed;
    951     const row = privateRecordSnapshot(
    952         committed.record,
    953         saved.record.owner,
    954         saved.record.id
    955       ),
    956       wire = privateRecordWire(
    957         committed.record,
    958         saved.record.owner,
    959         saved.record.id
    960       );
    961     if (!saved.current()) return { status: 'unknown_completion' };
    962     if (
    963       !row ||
    964       row.family !== 'private_send_operation' ||
    965       !wire ||
    966       !row.peerArtifact ||
    967       !row.deliveryPlan
    968     )
    969       return { status: 'conflict' };
    970     pairedAcknowledgements.set(receipt, {
    971       record: row,
    972       wire,
    973       current: saved.current
    974     });
    975     return committed;
    976   } catch {
    977     return { status: 'unknown_completion' };
    978   }
    979 }