app

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

inbox-readback.ts (6142B)


      1 import { publicRelayTargets, type RelayPolicy } from '../config/relays.ts';
      2 import {
      3   publicRecordSnapshot,
      4   type PublicRecordHandle
      5 } from '../persistence/records.ts';
      6 import {
      7   verifyEnvelope,
      8   verifiedEnvelopeSnapshot,
      9   verifiedEnvelopeWire
     10 } from './verified-envelope.ts';
     11 import {
     12   publicViewRunCurrent,
     13   publicViewOwnsRun,
     14   subscribeInboxPreference,
     15   type PublicView
     16 } from '../runtime/public-runtime.ts';
     17 import { publicRequestScopeSnapshot, type PublicRun } from './request-scope.ts';
     18 import {
     19   createInboxResolver,
     20   inboxResolutionSnapshot,
     21   inboxResolverCurrentAfterSample,
     22   closeInboxResolver,
     23   type InboxResolver
     24 } from '../messaging/resolve-inbox.ts';
     25 declare const readbackBrand: unique symbol;
     26 export type InboxReadback = Readonly<{ [readbackBrand]: true }>;
     27 type Owner = Readonly<{
     28   owner: string;
     29   id: string;
     30   record: PublicRecordHandle;
     31   policy: RelayPolicy;
     32   resolver: InboxResolver;
     33   wires: Map<string, string>;
     34   current(): boolean;
     35   closed(): boolean;
     36   close(): void;
     37   use(): boolean;
     38 }>;
     39 const owners = new WeakMap<InboxReadback, Owner>();
     40 const reserved = new WeakMap<PublicRun, true>();
     41 // Read only through the existing bounded anonymous inbox request. No raw SDK,
     42 // arbitrary relay/filter, event publication or inferred seen-relay provenance.
     43 export function resolveInboxReadback(
     44   view: PublicView,
     45   run: PublicRun,
     46   record: PublicRecordHandle,
     47   owner: string,
     48   id: string,
     49   policy: RelayPolicy
     50 ): InboxReadback | undefined {
     51   try {
     52     if (typeof window === 'undefined' || reserved.has(run)) return undefined;
     53     reserved.set(run, true);
     54     const row = publicRecordSnapshot(record, owner, id);
     55     if (
     56       row?.family !== 'preference_operation' ||
     57       !row.artifact ||
     58       row.revision < 2 ||
     59       !publicViewRunCurrent(view, run)
     60     )
     61       return undefined;
     62     const verified = verifyEnvelope(row.artifact.wire);
     63     if (!verified.ok) return undefined;
     64     const exact = JSON.stringify(verifiedEnvelopeSnapshot(verified.value));
     65     const sources = publicRelayTargets(policy, 'read'),
     66       wires = new Map<string, string>();
     67     let closed = false,
     68       used = false;
     69     const resolver = createInboxResolver(
     70       run,
     71       owner,
     72       (next) =>
     73         subscribeInboxPreference(view, run, owner, (proof, source) => {
     74           if (closed || !publicViewOwnsRun(view, run)) return;
     75           // This source comes from admitted request dispatch, bound to this exact
     76           // proof, not a journal that knows only an ID or a local artifact copy.
     77           if (
     78             source !== undefined &&
     79             sources.includes(source) &&
     80             JSON.stringify(verifiedEnvelopeSnapshot(proof)) === exact
     81           ) {
     82             const wire = verifiedEnvelopeWire(proof);
     83             if (wire !== undefined) wires.set(source, wire);
     84           }
     85           next(proof);
     86         }),
     87       () => !closed && publicViewOwnsRun(view, run)
     88     );
     89     const token = Object.freeze({}) as InboxReadback;
     90     owners.set(token, {
     91       owner,
     92       id,
     93       record,
     94       policy,
     95       resolver,
     96       wires,
     97       current: () =>
     98         !closed &&
     99         publicViewOwnsRun(view, run) &&
    100         inboxResolverCurrentAfterSample(resolver),
    101       closed: () => closed,
    102       close() {
    103         closed = true;
    104         closeInboxResolver(resolver);
    105       },
    106       use() {
    107         if (closed || used) return false;
    108         used = true;
    109         return true;
    110       }
    111     });
    112     return token;
    113   } catch {
    114     return undefined;
    115   }
    116 }
    117 export function inboxReadbackSnapshot(token: InboxReadback) {
    118   try {
    119     const saved = owners.get(token);
    120     if (!saved || saved.closed()) return undefined;
    121     const row = publicRecordSnapshot(saved.record, saved.owner, saved.id);
    122     if (row?.family !== 'preference_operation' || !row.artifact)
    123       return undefined;
    124     const resolution = inboxResolutionSnapshot(saved.resolver),
    125       scope = publicRequestScopeSnapshot(resolution.request);
    126     const sources = publicRelayTargets(saved.policy, 'read');
    127     const complete =
    128       resolution.coverage === 'bounded-eose' &&
    129       scope.inboxSettled === true &&
    130       resolution.author === saved.owner &&
    131       sources.length > 0 &&
    132       sources.length === resolution.sources.length &&
    133       sources.every((source) =>
    134         resolution.sources.some(
    135           (row) => row.source === source && row.state === 'eose'
    136         )
    137       );
    138     const knownHead = resolution.knownBase && {
    139       id: resolution.knownBase.id,
    140       createdAt: resolution.knownBase.createdAt
    141     };
    142     const current = saved.current();
    143     return {
    144       owner: saved.owner,
    145       id: saved.id,
    146       artifactId: row.artifact.eventId,
    147       knownHead,
    148       status: !current
    149         ? ('unknown' as const)
    150         : scope.state === 'active'
    151           ? ('pending' as const)
    152           : !complete
    153             ? ('unknown' as const)
    154             : knownHead && knownHead.id !== row.artifact.eventId
    155               ? ('conflict' as const)
    156               : knownHead?.id === row.artifact.eventId && saved.wires.size > 0
    157                 ? ('readback' as const)
    158                 : ('missing' as const),
    159       sources: Array.from(saved.wires.keys()),
    160       complete: complete && current,
    161       coverage: resolution.coverage,
    162       definitiveAbsence: false as const
    163     };
    164   } catch {
    165     return undefined;
    166   }
    167 }
    168 // Internal genuine owner observation. Wire is public, independently verified
    169 // exact signed readback; this confers no signing or network permission.
    170 export function inboxReadbackEvidence(token: InboxReadback) {
    171   const saved = owners.get(token),
    172     snapshot = inboxReadbackSnapshot(token);
    173   if (!saved || !snapshot || !snapshot.complete || !saved.current())
    174     return undefined;
    175   return {
    176     ...snapshot,
    177     record: saved.record,
    178     policy: saved.policy,
    179     resolver: saved.resolver,
    180     wires: Array.from(saved.wires, ([origin, wire]) => ({ origin, wire })),
    181     current: saved.current
    182   };
    183 }
    184 export function useInboxReadback(token: InboxReadback): boolean {
    185   return owners.get(token)?.use() ?? false;
    186 }
    187 export function closeInboxReadback(token: InboxReadback): void {
    188   owners.get(token)?.close();
    189 }