app

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

unlocked-session.ts (7929B)


      1 import {
      2   privateSessionOwnership,
      3   subscribePrivateSessionClose,
      4   type PrivateSession
      5 } from '../runtime/private-session.ts';
      6 import {
      7   getPrivateCacheScope,
      8   retainPrivateCacheWire,
      9   privateCacheWire,
     10   privateCacheSnapshot,
     11   clearPrivateCacheScope
     12 } from '../nostr/private-cache-scope.ts';
     13 import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts';
     14 import {
     15   conversationSnapshot,
     16   conversationOwnership,
     17   type AdmittedConversation,
     18   type ConversationData
     19 } from './admit-conversation.ts';
     20 declare const unlockedBrand: unique symbol;
     21 export type UnlockedSession = Readonly<{ [unlockedBrand]: true }>;
     22 export type UnlockedAdmission =
     23   'added' | 'duplicate' | 'conflict' | 'rejected' | 'limit' | 'closed';
     24 type View = Readonly<{
     25   status: 'ready' | 'conflict' | 'closed' | 'rejected';
     26   messages: readonly ConversationData[];
     27 }>;
     28 type Snapshot = Readonly<{ closed: boolean; count: number; bytes: number }>;
     29 type Controller = {
     30   current(): boolean;
     31   ownership(): ReturnType<typeof privateSessionOwnership>;
     32   contains(room: AdmittedConversation): boolean;
     33   accept(room: AdmittedConversation): UnlockedAdmission;
     34   read(): View;
     35   snapshot(): Snapshot;
     36   close(): void;
     37 };
     38 const closeObservers = new WeakMap<UnlockedSession, Map<() => void, true>>();
     39 const controllers = new WeakMap<UnlockedSession, Controller>(),
     40   sessions = new WeakMap<PrivateSession, UnlockedSession>();
     41 // Explicit owner-generation memory scope only. No decryption, shared SDK
     42 // memoized helpers, public EventStore, persistence or network side effect.
     43 export function captureUnlockedSession(
     44   session: PrivateSession,
     45   review: unknown
     46 ): UnlockedSession | undefined {
     47   if (typeof window === 'undefined' || review !== 'reviewed_messages_unlock')
     48     return undefined;
     49   const observed = privateSessionOwnership(session);
     50   if (!observed) return undefined;
     51   const capture = observed;
     52   const previous = sessions.get(session);
     53   if (previous && controllers.get(previous)?.current()) return previous;
     54   let observedCache;
     55   try {
     56     observedCache = getPrivateCacheScope(session, 'projection_ownership');
     57   } catch {
     58     return undefined;
     59   }
     60   if (!observedCache) return undefined;
     61   const cache = observedCache;
     62   const token = Object.freeze({}) as UnlockedSession,
     63     entries = new Map<string, string>();
     64   let closed = false,
     65     bytes = 0,
     66     off = () => {};
     67   function close() {
     68     if (closed) return;
     69     closed = true;
     70     const callbacks = closeObservers.get(token);
     71     closeObservers.delete(token);
     72     if (callbacks)
     73       for (const callback of callbacks.keys()) {
     74         try {
     75           callback();
     76         } catch {
     77           /* Continue original cache disposal. */
     78         }
     79       }
     80     entries.clear();
     81     bytes = 0;
     82     clearPrivateCacheScope(cache);
     83     off();
     84     // Drop our reachable private refs. Detached caller copies and JavaScript
     85     // heap/garbage-collection timing cannot be securely zeroized or recalled.
     86     controllers.set(token, {
     87       current: () => false,
     88       ownership: () => undefined,
     89       contains: () => false,
     90       accept: () => 'closed',
     91       read: () => ({ status: 'closed', messages: [] }),
     92       snapshot: () => ({ closed: true, count: 0, bytes: 0 }),
     93       close: () => {}
     94     });
     95   }
     96   function current() {
     97     if (closed || !capture.current() || privateCacheSnapshot(cache).closed) {
     98       close();
     99       return false;
    100     }
    101     return true;
    102   }
    103   const state: Controller = {
    104     current,
    105     ownership: () => (current() ? { ...capture, current } : undefined),
    106     contains(room) {
    107       if (!current()) return false;
    108       const own = conversationOwnership(room),
    109         data = conversationSnapshot(room);
    110       if (
    111         !own?.current() ||
    112         own.owner !== capture.owner ||
    113         own.session !== capture.session ||
    114         !data
    115       )
    116         return false;
    117       const wire = JSON.stringify(data);
    118       return (
    119         current() &&
    120         entries.get(data.rumorId) === wire &&
    121         privateCacheWire(cache, data.rumorId) === wire
    122       );
    123     },
    124     accept(room) {
    125       if (!current()) return 'closed';
    126       // Authenticate original room and generation before even a dedup lookup.
    127       const ownership = conversationOwnership(room);
    128       if (
    129         !ownership?.current() ||
    130         ownership.owner !== capture.owner ||
    131         ownership.session !== capture.session
    132       )
    133         return 'rejected';
    134       const data = conversationSnapshot(room);
    135       if (
    136         !data ||
    137         data.owner !== capture.owner ||
    138         !current() ||
    139         !ownership.current()
    140       )
    141         return 'rejected';
    142       const wire = JSON.stringify(data),
    143         size = new TextEncoder().encode(wire).length,
    144         existing = entries.get(data.rumorId);
    145       if (existing !== undefined)
    146         return existing === wire &&
    147           privateCacheWire(cache, data.rumorId) === wire
    148           ? 'duplicate'
    149           : 'conflict';
    150       if (
    151         entries.size >= LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes ||
    152         size > LOCAL_PERSISTENCE_BUDGETS.receivedCiphertextBytes - bytes
    153       )
    154         return 'limit';
    155       const result = retainPrivateCacheWire(cache, data.rumorId, wire);
    156       if (result !== 'accepted' && result !== 'duplicate') return result;
    157       if (!current() || !ownership.current()) return 'closed';
    158       if (privateCacheWire(cache, data.rumorId) !== wire) return 'conflict';
    159       entries.set(data.rumorId, wire);
    160       bytes += size;
    161       return 'added';
    162     },
    163     read() {
    164       if (!current()) return { status: 'closed', messages: [] };
    165       for (const [id, wire] of entries) {
    166         // A generic internal cache port is not projection authority. Exact own
    167         // immutable bytes must agree; poisoning never substitutes another row.
    168         if (privateCacheWire(cache, id) !== wire)
    169           return { status: 'conflict', messages: [] };
    170       }
    171       const messages = Array.from(
    172         entries.values(),
    173         (wire) => JSON.parse(wire) as ConversationData
    174       );
    175       return current()
    176         ? { status: 'ready', messages }
    177         : { status: 'closed', messages: [] };
    178     },
    179     snapshot: () =>
    180       current()
    181         ? { closed: false, count: entries.size, bytes }
    182         : { closed: true, count: 0, bytes: 0 },
    183     close
    184   };
    185   controllers.set(token, state);
    186   sessions.set(session, token);
    187   off = subscribePrivateSessionClose(session, close);
    188   return current() ? token : undefined;
    189 }
    190 export function acceptUnlockedConversation(
    191   scope: UnlockedSession,
    192   room: AdmittedConversation
    193 ): UnlockedAdmission {
    194   return controllers.get(scope)?.accept(room) ?? 'rejected';
    195 }
    196 export function readUnlockedMessages(scope: UnlockedSession): View {
    197   return controllers.get(scope)?.read() ?? { status: 'rejected', messages: [] };
    198 }
    199 export function unlockedSessionSnapshot(scope: UnlockedSession): Snapshot {
    200   return (
    201     controllers.get(scope)?.snapshot() ?? { closed: true, count: 0, bytes: 0 }
    202   );
    203 }
    204 export function closeUnlockedSession(scope: UnlockedSession): void {
    205   controllers.get(scope)?.close();
    206 }
    207 
    208 // Original accepted-cache custody observations only. Copies are not authority.
    209 export function unlockedSessionOwnership(scope: UnlockedSession) {
    210   return controllers.get(scope)?.ownership();
    211 }
    212 export function unlockedConversationCurrent(
    213   scope: UnlockedSession,
    214   room: AdmittedConversation
    215 ): boolean {
    216   return controllers.get(scope)?.contains(room) ?? false;
    217 }
    218 
    219 // Original opaque controller lifetime only, not a copied snapshot capability.
    220 export function subscribeUnlockedSessionClose(
    221   scope: UnlockedSession,
    222   callback: () => void
    223 ): () => void {
    224   if (!controllers.get(scope)?.current()) {
    225     callback();
    226     return () => {};
    227   }
    228   let observers = closeObservers.get(scope);
    229   if (!observers) {
    230     observers = new Map();
    231     closeObservers.set(scope, observers);
    232   }
    233   observers.set(callback, true);
    234   const captured = observers;
    235   return () => {
    236     captured.delete(callback);
    237   };
    238 }