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 }