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 }