app

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

inbox-ingress.ts (9729B)


      1 import {
      2   readRelayPolicy,
      3   inboxRelayTargets,
      4   publicRelayTargets,
      5   type RelayPolicy
      6 } from '../config/relays.ts';
      7 import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
      8 import { inboxPreferenceSnapshot } from './inbox-preferences.ts';
      9 import {
     10   inboxResolutionSnapshot,
     11   inboxResolverCurrentAfterSample,
     12   type InboxResolver
     13 } from '../messaging/resolve-inbox.ts';
     14 import type { ObserveInboxAccess } from '../messaging/readiness.ts';
     15 import {
     16   privateSessionOwnership,
     17   subscribePrivateSessionClose,
     18   type PrivateSession
     19 } from '../runtime/private-session.ts';
     20 import {
     21   getPrivatePool,
     22   subscribePrivatePage,
     23   closePrivatePool
     24 } from './private-pool.ts';
     25 import {
     26   admitInboxEnvelope,
     27   retainInboxEnvelope
     28 } from '../persistence/inbox-envelope-repository.ts';
     29 import type { PrivateStorageRepository } from '../persistence/private-storage.ts';
     30 declare const ingressBrand: unique symbol;
     31 export type InboxIngress = Readonly<{ [ingressBrand]: true }>;
     32 type State =
     33   'ready' | 'running' | 'finite_page_ended' | 'stopped' | 'needs_action';
     34 type Snapshot = Readonly<{
     35   owner: string;
     36   state: State;
     37   candidates: number;
     38   bytes: number;
     39   retained: number;
     40   duplicates: number;
     41   excludedProbes: number;
     42   rejected: number;
     43   reason: string | null;
     44   pending: number;
     45   cleanupRequired: boolean;
     46 }>;
     47 type Controller = {
     48   start(review: unknown): boolean;
     49   stop(): void;
     50   snapshot(): Snapshot;
     51 };
     52 const ingress = new WeakMap<InboxIngress, Controller>();
     53 // Explicit finite receive admission. A remembered key, allowlist or EOSE alone
     54 // is not exercised own inbox access. No production observation port is supplied
     55 // here; controlled fixtures do not qualify real operator relay/AUTH access.
     56 export function captureInboxIngress(
     57   repository: PrivateStorageRepository,
     58   session: PrivateSession,
     59   policy: RelayPolicy,
     60   own: InboxResolver,
     61   observeAccess: ObserveInboxAccess | undefined,
     62   review: unknown
     63 ): InboxIngress | undefined {
     64   if (
     65     typeof window === 'undefined' ||
     66     review !== 'reviewed_private_inbox_receive' ||
     67     !observeAccess
     68   )
     69     return undefined;
     70   try {
     71     const ownership = privateSessionOwnership(session),
     72       manifest = readRelayPolicy(policy),
     73       resolution = inboxResolutionSnapshot(own);
     74     if (
     75       !ownership?.current() ||
     76       !manifest.messagingEnabled ||
     77       resolution.author !== ownership.owner ||
     78       resolution.status !== 'ready' ||
     79       resolution.coverage !== 'bounded-eose' ||
     80       !resolution.head ||
     81       !resolution.knownBase
     82     )
     83       return undefined;
     84     const preference = inboxPreferenceSnapshot(resolution.head),
     85       discovery = publicRelayTargets(policy, 'read');
     86     if (
     87       !preference ||
     88       preference.status !== 'supported' ||
     89       preference.author !== ownership.owner ||
     90       preference.id !== resolution.knownBase.id ||
     91       !discovery.length ||
     92       discovery.length !== resolution.sources.length ||
     93       !discovery.every((origin) =>
     94         resolution.sources.some(
     95           (source) => source.source === origin && source.state === 'eose'
     96         )
     97       )
     98     )
     99       return undefined;
    100     const targets = inboxRelayTargets(policy, preference.relays, 'read'),
    101       archive = inboxRelayTargets(policy, preference.relays, 'write');
    102     if (!targets.length || !archive.length) return undefined;
    103     const access = observeAccess({
    104       owner: ownership.owner,
    105       session: ownership.session,
    106       preferenceId: preference.id,
    107       readTargets: targets.slice(),
    108       archiveTargets: archive.slice()
    109     });
    110     if (
    111       !access ||
    112       access.owner !== ownership.owner ||
    113       access.session !== ownership.session ||
    114       access.preferenceId !== preference.id ||
    115       access.receive !== 'qualified_exercised' ||
    116       access.archive !== 'qualified_exercised' ||
    117       JSON.stringify(access.readTargets) !== JSON.stringify(targets) ||
    118       JSON.stringify(access.archiveTargets) !== JSON.stringify(archive)
    119     )
    120       return undefined;
    121     const current = () => {
    122       const latest = inboxResolutionSnapshot(own);
    123       return (
    124         latest.status === 'ready' &&
    125         latest.coverage === 'bounded-eose' &&
    126         latest.author === ownership.owner &&
    127         latest.knownBase?.id === preference.id &&
    128         access.current() &&
    129         ownership.current() &&
    130         inboxResolverCurrentAfterSample(own)
    131       );
    132     };
    133     if (!current()) return undefined;
    134     const token = Object.freeze({}) as InboxIngress;
    135     const pool = getPrivatePool(
    136       session,
    137       policy,
    138       targets,
    139       token,
    140       'receive',
    141       current
    142     );
    143     if (!pool) return undefined;
    144     let state: State = 'ready',
    145       candidates = 0,
    146       bytes = 0,
    147       retained = 0,
    148       duplicates = 0,
    149       excludedProbes = 0,
    150       rejected = 0,
    151       pending = 0,
    152       reason: string | null = null,
    153       consumed = false,
    154       stopped = false,
    155       ended = false,
    156       failed = false,
    157       cleaned = false,
    158       cleanupRequired = false;
    159     let release = () => {},
    160       off = () => {};
    161     let queue = Promise.resolve();
    162     function stop() {
    163       if (cleaned) return;
    164       stopped = true;
    165       state = 'stopped';
    166       let failure = false;
    167       try {
    168         release();
    169       } catch {
    170         failure = true;
    171       }
    172       try {
    173         closePrivatePool(pool!);
    174       } catch {
    175         failure = true;
    176       }
    177       cleanupRequired = failure;
    178       if (!failure) {
    179         cleaned = true;
    180         off();
    181       } else throw new Error('private_inbox_cleanup_required');
    182     }
    183     function settled() {
    184       if (ended && pending === 0 && !stopped && state === 'running')
    185         state = 'finite_page_ended';
    186     }
    187     ingress.set(token, {
    188       snapshot: () => ({
    189         owner: ownership.owner,
    190         state,
    191         candidates,
    192         bytes,
    193         retained,
    194         duplicates,
    195         excludedProbes,
    196         rejected,
    197         reason,
    198         pending,
    199         cleanupRequired
    200       }),
    201       stop,
    202       start(reviewed) {
    203         if (
    204           reviewed !== 'reviewed_private_inbox_receive' ||
    205           consumed ||
    206           stopped ||
    207           !current()
    208         )
    209           return false;
    210         consumed = true;
    211         state = 'running';
    212         release = subscribePrivatePage(
    213           pool,
    214           PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay,
    215           (message) => {
    216             if (stopped) return;
    217             if (!current()) {
    218               stop();
    219               return;
    220             }
    221             if (message.type === 'end') {
    222               ended = true;
    223               if (state !== 'needs_action') reason = message.reason;
    224               settled();
    225               return;
    226             }
    227             if (failed) return;
    228             candidates++;
    229             const size = new TextEncoder().encode(message.wire).length;
    230             bytes += size;
    231             // Existing private SDK page also charges every candidate BEFORE
    232             // crypto/dedup and enforces finite deliveries/bytes/network elapsed.
    233             if (
    234               candidates > PRIVATE_TRANSPORT_BUDGETS.deliveries ||
    235               bytes > PRIVATE_TRANSPORT_BUDGETS.processedBytes
    236             ) {
    237               state = 'needs_action';
    238               reason = 'budget';
    239               release();
    240               return;
    241             }
    242             const origin = message.from.endsWith('/')
    243               ? message.from.slice(0, -1)
    244               : message.from;
    245             if (!targets.includes(origin)) {
    246               rejected++;
    247               return;
    248             }
    249             const envelope = admitInboxEnvelope(
    250               message.wire,
    251               ownership.owner,
    252               origin,
    253               Date.now()
    254             );
    255             if (!envelope) {
    256               rejected++;
    257               return;
    258             }
    259             pending++;
    260             queue = queue
    261               .then(async () => {
    262                 if (failed || stopped) return;
    263                 if (!current()) {
    264                   stop();
    265                   return;
    266                 }
    267                 const result = await retainInboxEnvelope(
    268                   repository,
    269                   session,
    270                   envelope
    271                 );
    272                 if (stopped || !current()) {
    273                   if (!stopped) stop();
    274                   return;
    275                 }
    276                 if (result.status === 'retained') retained++;
    277                 else if (result.status === 'duplicate') duplicates++;
    278                 else if (result.status === 'probe_excluded') excludedProbes++;
    279                 else {
    280                   failed = true;
    281                   state = 'needs_action';
    282                   reason = result.status;
    283                   release();
    284                 }
    285               })
    286               .catch(() => {
    287                 failed = true;
    288                 state = stopped ? 'stopped' : 'needs_action';
    289                 reason = 'unknown_completion';
    290                 try {
    291                   release();
    292                 } catch {
    293                   cleanupRequired = true;
    294                 }
    295               })
    296               .finally(() => {
    297                 pending--;
    298                 settled();
    299               });
    300           }
    301         );
    302         return true;
    303       }
    304     });
    305     off = subscribePrivateSessionClose(session, stop);
    306     if (!current()) {
    307       stop();
    308       return undefined;
    309     }
    310     return token;
    311   } catch {
    312     return undefined;
    313   }
    314 }
    315 export function startInboxIngress(
    316   token: InboxIngress,
    317   review: unknown
    318 ): boolean {
    319   return ingress.get(token)?.start(review) ?? false;
    320 }
    321 export function stopInboxIngress(token: InboxIngress): void {
    322   ingress.get(token)?.stop();
    323 }
    324 export function inboxIngressSnapshot(
    325   token: InboxIngress
    326 ): Snapshot | undefined {
    327   return ingress.get(token)?.snapshot();
    328 }