inbox-ingress.ts (9729B)
1 import { 2 readRelayPolicy, 3 inboxRelayTargets, 4 publicRelayTargets, 5 type RelayPolicy 6 } from '../config/relays.ts'; 7 import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts'; 8 import { inboxPreferenceSnapshot } from './inbox-preferences.ts'; 9 import { 10 inboxResolutionSnapshot, 11 inboxResolverCurrentAfterSample, 12 type InboxResolver 13 } from '../messaging/resolve-inbox.ts'; 14 import type { ObserveInboxAccess } from '../messaging/readiness.ts'; 15 import { 16 privateSessionOwnership, 17 subscribePrivateSessionClose, 18 type PrivateSession 19 } from '../runtime/private-session.ts'; 20 import { 21 getPrivatePool, 22 subscribePrivatePage, 23 closePrivatePool 24 } from './private-pool.ts'; 25 import { 26 admitInboxEnvelope, 27 retainInboxEnvelope 28 } from '../persistence/inbox-envelope-repository.ts'; 29 import type { PrivateStorageRepository } from '../persistence/private-storage.ts'; 30 declare const ingressBrand: unique symbol; 31 export type InboxIngress = Readonly<{ [ingressBrand]: true }>; 32 type State = 33 'ready' | 'running' | 'finite_page_ended' | 'stopped' | 'needs_action'; 34 type Snapshot = Readonly<{ 35 owner: string; 36 state: State; 37 candidates: number; 38 bytes: number; 39 retained: number; 40 duplicates: number; 41 excludedProbes: number; 42 rejected: number; 43 reason: string | null; 44 pending: number; 45 cleanupRequired: boolean; 46 }>; 47 type Controller = { 48 start(review: unknown): boolean; 49 stop(): void; 50 snapshot(): Snapshot; 51 }; 52 const ingress = new WeakMap<InboxIngress, Controller>(); 53 // Explicit finite receive admission. A remembered key, allowlist or EOSE alone 54 // is not exercised own inbox access. No production observation port is supplied 55 // here; controlled fixtures do not qualify real operator relay/AUTH access. 56 export function captureInboxIngress( 57 repository: PrivateStorageRepository, 58 session: PrivateSession, 59 policy: RelayPolicy, 60 own: InboxResolver, 61 observeAccess: ObserveInboxAccess | undefined, 62 review: unknown 63 ): InboxIngress | undefined { 64 if ( 65 typeof window === 'undefined' || 66 review !== 'reviewed_private_inbox_receive' || 67 !observeAccess 68 ) 69 return undefined; 70 try { 71 const ownership = privateSessionOwnership(session), 72 manifest = readRelayPolicy(policy), 73 resolution = inboxResolutionSnapshot(own); 74 if ( 75 !ownership?.current() || 76 !manifest.messagingEnabled || 77 resolution.author !== ownership.owner || 78 resolution.status !== 'ready' || 79 resolution.coverage !== 'bounded-eose' || 80 !resolution.head || 81 !resolution.knownBase 82 ) 83 return undefined; 84 const preference = inboxPreferenceSnapshot(resolution.head), 85 discovery = publicRelayTargets(policy, 'read'); 86 if ( 87 !preference || 88 preference.status !== 'supported' || 89 preference.author !== ownership.owner || 90 preference.id !== resolution.knownBase.id || 91 !discovery.length || 92 discovery.length !== resolution.sources.length || 93 !discovery.every((origin) => 94 resolution.sources.some( 95 (source) => source.source === origin && source.state === 'eose' 96 ) 97 ) 98 ) 99 return undefined; 100 const targets = inboxRelayTargets(policy, preference.relays, 'read'), 101 archive = inboxRelayTargets(policy, preference.relays, 'write'); 102 if (!targets.length || !archive.length) return undefined; 103 const access = observeAccess({ 104 owner: ownership.owner, 105 session: ownership.session, 106 preferenceId: preference.id, 107 readTargets: targets.slice(), 108 archiveTargets: archive.slice() 109 }); 110 if ( 111 !access || 112 access.owner !== ownership.owner || 113 access.session !== ownership.session || 114 access.preferenceId !== preference.id || 115 access.receive !== 'qualified_exercised' || 116 access.archive !== 'qualified_exercised' || 117 JSON.stringify(access.readTargets) !== JSON.stringify(targets) || 118 JSON.stringify(access.archiveTargets) !== JSON.stringify(archive) 119 ) 120 return undefined; 121 const current = () => { 122 const latest = inboxResolutionSnapshot(own); 123 return ( 124 latest.status === 'ready' && 125 latest.coverage === 'bounded-eose' && 126 latest.author === ownership.owner && 127 latest.knownBase?.id === preference.id && 128 access.current() && 129 ownership.current() && 130 inboxResolverCurrentAfterSample(own) 131 ); 132 }; 133 if (!current()) return undefined; 134 const token = Object.freeze({}) as InboxIngress; 135 const pool = getPrivatePool( 136 session, 137 policy, 138 targets, 139 token, 140 'receive', 141 current 142 ); 143 if (!pool) return undefined; 144 let state: State = 'ready', 145 candidates = 0, 146 bytes = 0, 147 retained = 0, 148 duplicates = 0, 149 excludedProbes = 0, 150 rejected = 0, 151 pending = 0, 152 reason: string | null = null, 153 consumed = false, 154 stopped = false, 155 ended = false, 156 failed = false, 157 cleaned = false, 158 cleanupRequired = false; 159 let release = () => {}, 160 off = () => {}; 161 let queue = Promise.resolve(); 162 function stop() { 163 if (cleaned) return; 164 stopped = true; 165 state = 'stopped'; 166 let failure = false; 167 try { 168 release(); 169 } catch { 170 failure = true; 171 } 172 try { 173 closePrivatePool(pool!); 174 } catch { 175 failure = true; 176 } 177 cleanupRequired = failure; 178 if (!failure) { 179 cleaned = true; 180 off(); 181 } else throw new Error('private_inbox_cleanup_required'); 182 } 183 function settled() { 184 if (ended && pending === 0 && !stopped && state === 'running') 185 state = 'finite_page_ended'; 186 } 187 ingress.set(token, { 188 snapshot: () => ({ 189 owner: ownership.owner, 190 state, 191 candidates, 192 bytes, 193 retained, 194 duplicates, 195 excludedProbes, 196 rejected, 197 reason, 198 pending, 199 cleanupRequired 200 }), 201 stop, 202 start(reviewed) { 203 if ( 204 reviewed !== 'reviewed_private_inbox_receive' || 205 consumed || 206 stopped || 207 !current() 208 ) 209 return false; 210 consumed = true; 211 state = 'running'; 212 release = subscribePrivatePage( 213 pool, 214 PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay, 215 (message) => { 216 if (stopped) return; 217 if (!current()) { 218 stop(); 219 return; 220 } 221 if (message.type === 'end') { 222 ended = true; 223 if (state !== 'needs_action') reason = message.reason; 224 settled(); 225 return; 226 } 227 if (failed) return; 228 candidates++; 229 const size = new TextEncoder().encode(message.wire).length; 230 bytes += size; 231 // Existing private SDK page also charges every candidate BEFORE 232 // crypto/dedup and enforces finite deliveries/bytes/network elapsed. 233 if ( 234 candidates > PRIVATE_TRANSPORT_BUDGETS.deliveries || 235 bytes > PRIVATE_TRANSPORT_BUDGETS.processedBytes 236 ) { 237 state = 'needs_action'; 238 reason = 'budget'; 239 release(); 240 return; 241 } 242 const origin = message.from.endsWith('/') 243 ? message.from.slice(0, -1) 244 : message.from; 245 if (!targets.includes(origin)) { 246 rejected++; 247 return; 248 } 249 const envelope = admitInboxEnvelope( 250 message.wire, 251 ownership.owner, 252 origin, 253 Date.now() 254 ); 255 if (!envelope) { 256 rejected++; 257 return; 258 } 259 pending++; 260 queue = queue 261 .then(async () => { 262 if (failed || stopped) return; 263 if (!current()) { 264 stop(); 265 return; 266 } 267 const result = await retainInboxEnvelope( 268 repository, 269 session, 270 envelope 271 ); 272 if (stopped || !current()) { 273 if (!stopped) stop(); 274 return; 275 } 276 if (result.status === 'retained') retained++; 277 else if (result.status === 'duplicate') duplicates++; 278 else if (result.status === 'probe_excluded') excludedProbes++; 279 else { 280 failed = true; 281 state = 'needs_action'; 282 reason = result.status; 283 release(); 284 } 285 }) 286 .catch(() => { 287 failed = true; 288 state = stopped ? 'stopped' : 'needs_action'; 289 reason = 'unknown_completion'; 290 try { 291 release(); 292 } catch { 293 cleanupRequired = true; 294 } 295 }) 296 .finally(() => { 297 pending--; 298 settled(); 299 }); 300 } 301 ); 302 return true; 303 } 304 }); 305 off = subscribePrivateSessionClose(session, stop); 306 if (!current()) { 307 stop(); 308 return undefined; 309 } 310 return token; 311 } catch { 312 return undefined; 313 } 314 } 315 export function startInboxIngress( 316 token: InboxIngress, 317 review: unknown 318 ): boolean { 319 return ingress.get(token)?.start(review) ?? false; 320 } 321 export function stopInboxIngress(token: InboxIngress): void { 322 ingress.get(token)?.stop(); 323 } 324 export function inboxIngressSnapshot( 325 token: InboxIngress 326 ): Snapshot | undefined { 327 return ingress.get(token)?.snapshot(); 328 }