app

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

conversation-directory.ts (5625B)


      1 import { canonicalLocalId } from '../private-handles.ts';
      2 import {
      3   privateSessionOwnership,
      4   subscribePrivateSessionClose,
      5   type PrivateSession
      6 } from '../runtime/private-session.ts';
      7 import {
      8   messageMetadataOwnership,
      9   messageMetadataSnapshot,
     10   rememberMessageConversation,
     11   type MessageMetadata
     12 } from '../persistence/message-metadata.ts';
     13 import type { AdmittedConversation } from './admit-conversation.ts';
     14 declare const directoryBrand: unique symbol;
     15 export type ConversationDirectory = Readonly<{ [directoryBrand]: true }>;
     16 export const CONVERSATION_DIRECTORY_CONTEXT =
     17   'harvestcircle_conversation_directory';
     18 type Resolution =
     19   | Readonly<{ status: 'unavailable' }>
     20   | Readonly<{
     21       status: 'resolved';
     22       owner: string;
     23       peer: string;
     24       conversationId: string;
     25       href: string;
     26     }>;
     27 type Remembered =
     28   | Awaited<ReturnType<typeof rememberMessageConversation>>
     29   | Readonly<{ status: 'unavailable' }>;
     30 type Controller = {
     31   resolve(id: unknown): Promise<Resolution>;
     32   remember(room: AdmittedConversation, review: unknown): Promise<Remembered>;
     33   subscribe(listener: () => void): () => void;
     34   close(): void;
     35 };
     36 const directories = new WeakMap<ConversationDirectory, Controller>();
     37 const unavailable = (): Resolution => ({ status: 'unavailable' });
     38 // Pure syntax projection, never authorization. Owner/peer/product/body do not
     39 // occur in the path; IDs from another browser may have no local mapping.
     40 export function canonicalConversationHref(id: unknown): string | undefined {
     41   const valid = canonicalLocalId(id);
     42   return valid ? '/messages/' + valid : undefined;
     43 }
     44 export function captureConversationDirectory(
     45   session: PrivateSession,
     46   metadata: MessageMetadata,
     47   review: unknown
     48 ): ConversationDirectory | undefined {
     49   if (
     50     typeof window === 'undefined' ||
     51     review !== 'reviewed_conversation_directory'
     52   )
     53     return;
     54   const privateOwner = privateSessionOwnership(session),
     55     localOwner = messageMetadataOwnership(metadata);
     56   if (
     57     !privateOwner?.current() ||
     58     !localOwner?.current() ||
     59     privateOwner.owner !== localOwner.owner ||
     60     privateOwner.session !== localOwner.session
     61   )
     62     return;
     63   const original = privateOwner,
     64     local = localOwner;
     65   let closed = false,
     66     off = () => {};
     67   const listeners = new Map<symbol, () => void>();
     68   const token = Object.freeze({}) as ConversationDirectory;
     69   function close() {
     70     if (closed) return;
     71     closed = true;
     72     off();
     73     directories.set(token, {
     74       resolve: () => Promise.resolve(unavailable()),
     75       remember: () => Promise.resolve({ status: 'unavailable' }),
     76       subscribe: () => () => {},
     77       close: () => {}
     78     });
     79     for (const listener of listeners.values()) {
     80       try {
     81         listener();
     82       } catch {
     83         /* Presentation observer cannot retain private custody. */
     84       }
     85     }
     86     listeners.clear();
     87   }
     88   function current() {
     89     if (closed || !original.current() || !local.current()) {
     90       close();
     91       return false;
     92     }
     93     return true;
     94   }
     95   directories.set(token, {
     96     async resolve(id) {
     97       const canonical = canonicalLocalId(id),
     98         href = canonicalConversationHref(id);
     99       if (!canonical || !href || !current()) return unavailable();
    100       try {
    101         const snapshot = await messageMetadataSnapshot(metadata);
    102         if (
    103           !current() ||
    104           snapshot.status !== 'ready' ||
    105           snapshot.owner !== original.owner
    106         )
    107           return unavailable();
    108         const pair = snapshot.pairs.find((row) => row.id === canonical);
    109         return pair
    110           ? {
    111               status: 'resolved',
    112               owner: original.owner,
    113               peer: pair.peer,
    114               conversationId: canonical,
    115               href
    116             }
    117           : unavailable();
    118       } catch {
    119         return unavailable();
    120       }
    121     },
    122     async remember(room, reviewed) {
    123       if (!current()) return { status: 'unavailable' };
    124       const result = await rememberMessageConversation(
    125         metadata,
    126         room,
    127         reviewed
    128       );
    129       // A settled native write on an expired owner cannot disclose a room.
    130       return current() ? result : { status: 'unavailable' };
    131     },
    132     subscribe(listener) {
    133       if (!current()) return () => {};
    134       const key = Symbol();
    135       listeners.set(key, listener);
    136       return () => {
    137         listeners.delete(key);
    138       };
    139     },
    140     close
    141   });
    142   off = subscribePrivateSessionClose(session, close);
    143   return current() ? token : undefined;
    144 }
    145 // Read-only lookup of genuine owner metadata. Returned peer is a local
    146 // projection, never cryptographic room/reply permission or navigation effects.
    147 export function resolveLocalConversation(
    148   directory: ConversationDirectory,
    149   id: unknown
    150 ): Promise<Resolution> {
    151   return (
    152     directories.get(directory)?.resolve(id) ?? Promise.resolve(unavailable())
    153   );
    154 }
    155 // Explicit admitted cached exchange only; copied snapshots/unknown GET cannot
    156 // create a mapping. Product compose admission is wired by its later slice.
    157 export function rememberAdmittedConversation(
    158   directory: ConversationDirectory,
    159   room: AdmittedConversation,
    160   review: unknown
    161 ): Promise<Remembered> {
    162   return (
    163     directories.get(directory)?.remember(room, review) ??
    164     Promise.resolve({ status: 'unavailable' })
    165   );
    166 }
    167 export function subscribeConversationDirectory(
    168   directory: ConversationDirectory,
    169   listener: () => void
    170 ): () => void {
    171   return directories.get(directory)?.subscribe(listener) ?? (() => {});
    172 }
    173 export function closeConversationDirectory(
    174   directory: ConversationDirectory
    175 ): void {
    176   directories.get(directory)?.close();
    177 }