app

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

inbox-sync.ts (14650B)


      1 import { inboxRecoveryChoices } from './inbox-budget.ts';
      2 import { outerHistoryPlan } from './history-cursor.ts';
      3 import {
      4   unlockedSessionOwnership,
      5   subscribeUnlockedSessionClose,
      6   type UnlockedSession
      7 } from './unlocked-session.ts';
      8 import {
      9   getPrivateVisibilityScope,
     10   privateVisibilitySnapshot,
     11   closePrivateVisibilityScope
     12 } from '../runtime/dispose.ts';
     13 import {
     14   readRelayPolicy,
     15   inboxRelayTargets,
     16   publicRelayTargets,
     17   type RelayPolicy
     18 } from '../config/relays.ts';
     19 import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
     20 import { inboxPreferenceSnapshot } from '../nostr/inbox-preferences.ts';
     21 import {
     22   inboxResolutionSnapshot,
     23   inboxResolverCurrentAfterSample,
     24   type InboxResolver
     25 } from '../messaging/resolve-inbox.ts';
     26 import type { ObserveInboxAccess } from '../messaging/readiness.ts';
     27 import {
     28   privateSessionOwnership,
     29   subscribePrivateSessionClose,
     30   type PrivateSession
     31 } from '../runtime/private-session.ts';
     32 import {
     33   getPrivatePool,
     34   subscribePrivateHistory,
     35   subscribePrivateLive,
     36   type PrivatePageMessage,
     37   closePrivatePool
     38 } from '../nostr/private-pool.ts';
     39 import {
     40   admitInboxEnvelope,
     41   retainInboxEnvelope
     42 } from '../persistence/inbox-envelope-repository.ts';
     43 import type { PrivateStorageRepository } from '../persistence/private-storage.ts';
     44 declare const ingressBrand: unique symbol;
     45 export type InboxSync = Readonly<{ [ingressBrand]: true }>;
     46 type State = 'ready' | 'running' | 'live' | 'stopped' | 'needs_action';
     47 type Snapshot = Readonly<{
     48   owner: string;
     49   state: State;
     50   candidates: number;
     51   bytes: number;
     52   retained: number;
     53   duplicates: number;
     54   excludedProbes: number;
     55   rejected: number;
     56   reason: string | null;
     57   pending: number;
     58   cleanupRequired: boolean;
     59   backfill: string;
     60   historyComplete: false;
     61   foregroundOnly: true;
     62   recoveryChoices: readonly string[];
     63 }>;
     64 export type InboxHistoryOwnership = Readonly<{
     65   session: PrivateSession;
     66   repository: PrivateStorageRepository;
     67   pool: NonNullable<ReturnType<typeof getPrivatePool>>;
     68   targets: readonly string[];
     69   current: () => boolean;
     70 }>;
     71 type Controller = {
     72   history(): InboxHistoryOwnership | undefined;
     73   start(review: unknown): boolean;
     74   refresh(review: unknown, previousOuterCheck?: unknown): boolean;
     75   stop(): void;
     76   snapshot(): Snapshot;
     77 };
     78 const ingress = new WeakMap<InboxSync, Controller>();
     79 const sessions = new WeakMap<PrivateSession, InboxSync>();
     80 // Explicit foreground live-before-finite receive admission. A remembered key, allowlist or EOSE alone
     81 // is not exercised own inbox access. No production observation port is supplied
     82 // here; controlled fixtures do not qualify real operator relay/AUTH access.
     83 // No closed-tab notification, unattended decrypt or complete-inbox promise.
     84 export function captureInboxSync(
     85   repository: PrivateStorageRepository,
     86   session: PrivateSession,
     87   policy: RelayPolicy,
     88   own: InboxResolver,
     89   unlocked: UnlockedSession,
     90   observeAccess: ObserveInboxAccess | undefined,
     91   review: unknown,
     92   previousOuterCheck?: unknown
     93 ): InboxSync | undefined {
     94   if (
     95     typeof window === 'undefined' ||
     96     review !== 'reviewed_foreground_inbox' ||
     97     !observeAccess
     98   )
     99     return undefined;
    100   try {
    101     const history = outerHistoryPlan(
    102       Math.floor(Date.now() / 1000),
    103       previousOuterCheck
    104     );
    105     const previous = sessions.get(session);
    106     if (previous && ingress.get(previous)?.snapshot().state !== 'stopped')
    107       return undefined;
    108     const observedOwnership = privateSessionOwnership(session),
    109       manifest = readRelayPolicy(policy),
    110       resolution = inboxResolutionSnapshot(own);
    111     if (
    112       !observedOwnership?.current() ||
    113       !manifest.messagingEnabled ||
    114       resolution.author !== observedOwnership.owner ||
    115       resolution.status !== 'ready' ||
    116       resolution.coverage !== 'bounded-eose' ||
    117       !resolution.head ||
    118       !resolution.knownBase
    119     )
    120       return undefined;
    121     const ownership = observedOwnership;
    122     const preference = inboxPreferenceSnapshot(resolution.head),
    123       discovery = publicRelayTargets(policy, 'read');
    124     if (
    125       !preference ||
    126       preference.status !== 'supported' ||
    127       preference.author !== ownership.owner ||
    128       preference.id !== resolution.knownBase.id ||
    129       !discovery.length ||
    130       discovery.length !== resolution.sources.length ||
    131       !discovery.every((origin) =>
    132         resolution.sources.some(
    133           (source) => source.source === origin && source.state === 'eose'
    134         )
    135       )
    136     )
    137       return undefined;
    138     const targets = inboxRelayTargets(policy, preference.relays, 'read'),
    139       archive = inboxRelayTargets(policy, preference.relays, 'write');
    140     if (!targets.length || !archive.length) return undefined;
    141     const access = observeAccess({
    142       owner: ownership.owner,
    143       session: ownership.session,
    144       preferenceId: preference.id,
    145       readTargets: targets.slice(),
    146       archiveTargets: archive.slice()
    147     });
    148     if (
    149       !access ||
    150       access.owner !== ownership.owner ||
    151       access.session !== ownership.session ||
    152       access.preferenceId !== preference.id ||
    153       access.receive !== 'qualified_exercised' ||
    154       access.archive !== 'qualified_exercised' ||
    155       JSON.stringify(access.readTargets) !== JSON.stringify(targets) ||
    156       JSON.stringify(access.archiveTargets) !== JSON.stringify(archive)
    157     )
    158       return undefined;
    159     const cache = unlockedSessionOwnership(unlocked);
    160     if (
    161       !cache?.current() ||
    162       cache.owner !== ownership.owner ||
    163       cache.session !== ownership.session
    164     )
    165       return undefined;
    166     const observedVisibility = getPrivateVisibilityScope(session);
    167     if (!observedVisibility) return undefined;
    168     const visibility = observedVisibility;
    169     const current = () => {
    170       const latest = inboxResolutionSnapshot(own);
    171       return (
    172         privateVisibilitySnapshot(visibility).active &&
    173         unlockedSessionOwnership(unlocked)?.session === ownership.session &&
    174         !!unlockedSessionOwnership(unlocked)?.current() &&
    175         latest.status === 'ready' &&
    176         latest.coverage === 'bounded-eose' &&
    177         latest.author === ownership.owner &&
    178         latest.knownBase?.id === preference.id &&
    179         access.current() &&
    180         ownership.current() &&
    181         inboxResolverCurrentAfterSample(own)
    182       );
    183     };
    184     if (!current()) return undefined;
    185     const token = Object.freeze({}) as InboxSync;
    186     const pool = getPrivatePool(
    187       session,
    188       policy,
    189       targets,
    190       token,
    191       'receive',
    192       current
    193     );
    194     if (!pool) return undefined;
    195     let state: State = 'ready',
    196       candidates = 0,
    197       bytes = 0,
    198       retained = 0,
    199       duplicates = 0,
    200       excludedProbes = 0,
    201       rejected = 0,
    202       pending = 0,
    203       reason: string | null = null,
    204       consumed = false,
    205       stopped = false,
    206       backfill = 'not_started',
    207       pendingBytes = 0,
    208       failed = false,
    209       cleaned = false,
    210       cleanupRequired = false;
    211     let release = () => {},
    212       releaseLive = () => {},
    213       offUnlock = () => {},
    214       off = () => {};
    215     let queue = Promise.resolve();
    216     function releaseOwners() {
    217       let failure = false;
    218       for (const cleanup of [
    219         release,
    220         releaseLive,
    221         () => closePrivatePool(pool!)
    222       ]) {
    223         try {
    224           cleanup();
    225         } catch {
    226           failure = true;
    227         }
    228       }
    229       cleanupRequired = failure;
    230       if (failure) throw Error('private_inbox_cleanup_required');
    231     }
    232     function stop() {
    233       if (cleaned) return;
    234       stopped = true;
    235       state = 'stopped';
    236       off();
    237       offUnlock();
    238       let failure = false;
    239       try {
    240         releaseOwners();
    241       } catch {
    242         failure = true;
    243       }
    244       try {
    245         if (!closePrivateVisibilityScope(visibility)) failure = true;
    246       } catch {
    247         failure = true;
    248       }
    249       cleanupRequired = failure;
    250       if (!failure) cleaned = true;
    251       else throw Error('private_inbox_cleanup_required');
    252     }
    253     function pause(why: string) {
    254       if (stopped || failed) return;
    255       failed = true;
    256       state = 'needs_action';
    257       reason = why;
    258       try {
    259         releaseOwners();
    260       } catch {
    261         cleanupRequired = true;
    262       }
    263     }
    264     function receive(message: PrivatePageMessage) {
    265       if (stopped || failed) return;
    266       if (!current()) {
    267         stop();
    268         return;
    269       }
    270       if (message.type === 'end') {
    271         backfill = message.reason;
    272         if (message.reason !== 'complete') pause(message.reason);
    273         return;
    274       }
    275       candidates++;
    276       const size = new TextEncoder().encode(message.wire).length;
    277       bytes += size;
    278       // Bound outstanding ciphertext work across both lanes before queuing.
    279       if (
    280         pending >= PRIVATE_TRANSPORT_BUDGETS.deliveries ||
    281         pendingBytes + size > PRIVATE_TRANSPORT_BUDGETS.processedBytes
    282       ) {
    283         pause('budget');
    284         return;
    285       }
    286       const origin = message.from.endsWith('/')
    287         ? message.from.slice(0, -1)
    288         : message.from;
    289       if (!targets.includes(origin)) {
    290         rejected++;
    291         return;
    292       }
    293       const envelope = admitInboxEnvelope(
    294         message.wire,
    295         ownership.owner,
    296         origin,
    297         Date.now()
    298       );
    299       if (!envelope) {
    300         rejected++;
    301         return;
    302       }
    303       pending++;
    304       pendingBytes += size;
    305       queue = queue
    306         .then(async () => {
    307           if (stopped || failed) return;
    308           if (!current()) {
    309             stop();
    310             return;
    311           }
    312           const result = await retainInboxEnvelope(
    313             repository,
    314             session,
    315             envelope
    316           );
    317           if (stopped || failed || !current()) {
    318             if (!stopped && !failed) stop();
    319             return;
    320           }
    321           if (result.status === 'retained') retained++;
    322           else if (result.status === 'duplicate') duplicates++;
    323           else if (result.status === 'probe_excluded') excludedProbes++;
    324           else pause(result.status);
    325         })
    326         .catch(() => pause('unknown_completion'))
    327         .finally(() => {
    328           pending--;
    329           pendingBytes -= size;
    330         });
    331     }
    332     ingress.set(token, {
    333       refresh(reviewed, previousOuterCheck) {
    334         if (
    335           reviewed !== 'reviewed_foreground_inbox' ||
    336           !current() ||
    337           stopped ||
    338           failed ||
    339           state !== 'live' ||
    340           backfill !== 'complete' ||
    341           pending !== 0
    342         )
    343           return false;
    344         const plan = outerHistoryPlan(
    345           Math.floor(Date.now() / 1000),
    346           previousOuterCheck
    347         );
    348         if (!current()) return false;
    349         backfill = 'running';
    350         try {
    351           release();
    352           release = subscribePrivateHistory(pool, plan.overlap.since, receive);
    353           return true;
    354         } catch {
    355           pause('backfill_unavailable');
    356           return false;
    357         }
    358       },
    359       history() {
    360         return current() &&
    361           !stopped &&
    362           !failed &&
    363           state === 'live' &&
    364           backfill === 'complete' &&
    365           pending === 0
    366           ? { session, repository, pool, targets: targets.slice(), current }
    367           : undefined;
    368       },
    369       snapshot: () => ({
    370         owner: ownership.owner,
    371         state,
    372         candidates,
    373         bytes,
    374         retained,
    375         duplicates,
    376         excludedProbes,
    377         rejected,
    378         reason,
    379         pending,
    380         cleanupRequired,
    381         backfill,
    382         historyComplete: false,
    383         foregroundOnly: true,
    384         recoveryChoices: inboxRecoveryChoices(reason)
    385       }),
    386       stop,
    387       start(reviewed) {
    388         if (
    389           reviewed !== 'reviewed_foreground_inbox' ||
    390           consumed ||
    391           stopped ||
    392           !current()
    393         )
    394           return false;
    395         consumed = true;
    396         state = 'running';
    397         try {
    398           releaseLive = subscribePrivateLive(pool, (message) => {
    399             if (stopped || failed) return;
    400             if (!current()) {
    401               stop();
    402               return;
    403             }
    404             if (message.type === 'open') {
    405               // Actual SDK OPEN follows its REQ send. Defer so synchronous cached
    406               // connections cannot begin backfill before the live release binds.
    407               if (backfill !== 'not_started') return;
    408               backfill = 'running';
    409               queueMicrotask(() => {
    410                 if (stopped || failed) return;
    411                 if (!current()) {
    412                   try {
    413                     stop();
    414                   } catch {
    415                     /* Original incomplete cleanup remains retryable. */
    416                   }
    417                   return;
    418                 }
    419                 state = 'live';
    420                 try {
    421                   release = subscribePrivateHistory(
    422                     pool,
    423                     history.overlap.since,
    424                     receive
    425                   );
    426                 } catch {
    427                   pause('backfill_unavailable');
    428                 }
    429               });
    430             } else if (message.type === 'end') pause(message.reason);
    431             else receive(message);
    432           });
    433         } catch {
    434           state = 'needs_action';
    435           reason = 'live_unavailable';
    436           return false;
    437         }
    438         return true;
    439       }
    440     });
    441     sessions.set(session, token);
    442     off = subscribePrivateSessionClose(session, stop);
    443     offUnlock = subscribeUnlockedSessionClose(unlocked, stop);
    444     if (!current()) {
    445       stop();
    446       return undefined;
    447     }
    448     return token;
    449   } catch {
    450     return undefined;
    451   }
    452 }
    453 export function startInboxSync(token: InboxSync, review: unknown): boolean {
    454   return ingress.get(token)?.start(review) ?? false;
    455 }
    456 export function stopInboxSync(token: InboxSync): void {
    457   ingress.get(token)?.stop();
    458 }
    459 export function inboxSyncSnapshot(token: InboxSync): Snapshot | undefined {
    460   return ingress.get(token)?.snapshot();
    461 }
    462 
    463 // Original genuine sync only. Detached snapshots/query hints cannot mint this
    464 // original owner-generation/visibility/access transport and storage boundary.
    465 export function inboxSyncHistoryOwnership(
    466   token: InboxSync
    467 ): InboxHistoryOwnership | undefined {
    468   return ingress.get(token)?.history();
    469 }
    470 
    471 // Repeating a checked foreground window requires the same original current
    472 // access/live owner and a fresh explicit review. No recreated live subscription,
    473 // automatic AUTH/retry, decryption or copied snapshot authority.
    474 export function refreshInboxSync(
    475   token: InboxSync,
    476   review: unknown,
    477   previousOuterCheck?: unknown
    478 ): boolean {
    479   return ingress.get(token)?.refresh(review, previousOuterCheck) ?? false;
    480 }