inbox-sync.ts (14650B)
1 import { inboxRecoveryChoices } from './inbox-budget.ts'; 2 import { outerHistoryPlan } from './history-cursor.ts'; 3 import { 4 unlockedSessionOwnership, 5 subscribeUnlockedSessionClose, 6 type UnlockedSession 7 } from './unlocked-session.ts'; 8 import { 9 getPrivateVisibilityScope, 10 privateVisibilitySnapshot, 11 closePrivateVisibilityScope 12 } from '../runtime/dispose.ts'; 13 import { 14 readRelayPolicy, 15 inboxRelayTargets, 16 publicRelayTargets, 17 type RelayPolicy 18 } from '../config/relays.ts'; 19 import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts'; 20 import { inboxPreferenceSnapshot } from '../nostr/inbox-preferences.ts'; 21 import { 22 inboxResolutionSnapshot, 23 inboxResolverCurrentAfterSample, 24 type InboxResolver 25 } from '../messaging/resolve-inbox.ts'; 26 import type { ObserveInboxAccess } from '../messaging/readiness.ts'; 27 import { 28 privateSessionOwnership, 29 subscribePrivateSessionClose, 30 type PrivateSession 31 } from '../runtime/private-session.ts'; 32 import { 33 getPrivatePool, 34 subscribePrivateHistory, 35 subscribePrivateLive, 36 type PrivatePageMessage, 37 closePrivatePool 38 } from '../nostr/private-pool.ts'; 39 import { 40 admitInboxEnvelope, 41 retainInboxEnvelope 42 } from '../persistence/inbox-envelope-repository.ts'; 43 import type { PrivateStorageRepository } from '../persistence/private-storage.ts'; 44 declare const ingressBrand: unique symbol; 45 export type InboxSync = Readonly<{ [ingressBrand]: true }>; 46 type State = 'ready' | 'running' | 'live' | 'stopped' | 'needs_action'; 47 type Snapshot = Readonly<{ 48 owner: string; 49 state: State; 50 candidates: number; 51 bytes: number; 52 retained: number; 53 duplicates: number; 54 excludedProbes: number; 55 rejected: number; 56 reason: string | null; 57 pending: number; 58 cleanupRequired: boolean; 59 backfill: string; 60 historyComplete: false; 61 foregroundOnly: true; 62 recoveryChoices: readonly string[]; 63 }>; 64 export type InboxHistoryOwnership = Readonly<{ 65 session: PrivateSession; 66 repository: PrivateStorageRepository; 67 pool: NonNullable<ReturnType<typeof getPrivatePool>>; 68 targets: readonly string[]; 69 current: () => boolean; 70 }>; 71 type Controller = { 72 history(): InboxHistoryOwnership | undefined; 73 start(review: unknown): boolean; 74 refresh(review: unknown, previousOuterCheck?: unknown): boolean; 75 stop(): void; 76 snapshot(): Snapshot; 77 }; 78 const ingress = new WeakMap<InboxSync, Controller>(); 79 const sessions = new WeakMap<PrivateSession, InboxSync>(); 80 // Explicit foreground live-before-finite receive admission. A remembered key, allowlist or EOSE alone 81 // is not exercised own inbox access. No production observation port is supplied 82 // here; controlled fixtures do not qualify real operator relay/AUTH access. 83 // No closed-tab notification, unattended decrypt or complete-inbox promise. 84 export function captureInboxSync( 85 repository: PrivateStorageRepository, 86 session: PrivateSession, 87 policy: RelayPolicy, 88 own: InboxResolver, 89 unlocked: UnlockedSession, 90 observeAccess: ObserveInboxAccess | undefined, 91 review: unknown, 92 previousOuterCheck?: unknown 93 ): InboxSync | undefined { 94 if ( 95 typeof window === 'undefined' || 96 review !== 'reviewed_foreground_inbox' || 97 !observeAccess 98 ) 99 return undefined; 100 try { 101 const history = outerHistoryPlan( 102 Math.floor(Date.now() / 1000), 103 previousOuterCheck 104 ); 105 const previous = sessions.get(session); 106 if (previous && ingress.get(previous)?.snapshot().state !== 'stopped') 107 return undefined; 108 const observedOwnership = privateSessionOwnership(session), 109 manifest = readRelayPolicy(policy), 110 resolution = inboxResolutionSnapshot(own); 111 if ( 112 !observedOwnership?.current() || 113 !manifest.messagingEnabled || 114 resolution.author !== observedOwnership.owner || 115 resolution.status !== 'ready' || 116 resolution.coverage !== 'bounded-eose' || 117 !resolution.head || 118 !resolution.knownBase 119 ) 120 return undefined; 121 const ownership = observedOwnership; 122 const preference = inboxPreferenceSnapshot(resolution.head), 123 discovery = publicRelayTargets(policy, 'read'); 124 if ( 125 !preference || 126 preference.status !== 'supported' || 127 preference.author !== ownership.owner || 128 preference.id !== resolution.knownBase.id || 129 !discovery.length || 130 discovery.length !== resolution.sources.length || 131 !discovery.every((origin) => 132 resolution.sources.some( 133 (source) => source.source === origin && source.state === 'eose' 134 ) 135 ) 136 ) 137 return undefined; 138 const targets = inboxRelayTargets(policy, preference.relays, 'read'), 139 archive = inboxRelayTargets(policy, preference.relays, 'write'); 140 if (!targets.length || !archive.length) return undefined; 141 const access = observeAccess({ 142 owner: ownership.owner, 143 session: ownership.session, 144 preferenceId: preference.id, 145 readTargets: targets.slice(), 146 archiveTargets: archive.slice() 147 }); 148 if ( 149 !access || 150 access.owner !== ownership.owner || 151 access.session !== ownership.session || 152 access.preferenceId !== preference.id || 153 access.receive !== 'qualified_exercised' || 154 access.archive !== 'qualified_exercised' || 155 JSON.stringify(access.readTargets) !== JSON.stringify(targets) || 156 JSON.stringify(access.archiveTargets) !== JSON.stringify(archive) 157 ) 158 return undefined; 159 const cache = unlockedSessionOwnership(unlocked); 160 if ( 161 !cache?.current() || 162 cache.owner !== ownership.owner || 163 cache.session !== ownership.session 164 ) 165 return undefined; 166 const observedVisibility = getPrivateVisibilityScope(session); 167 if (!observedVisibility) return undefined; 168 const visibility = observedVisibility; 169 const current = () => { 170 const latest = inboxResolutionSnapshot(own); 171 return ( 172 privateVisibilitySnapshot(visibility).active && 173 unlockedSessionOwnership(unlocked)?.session === ownership.session && 174 !!unlockedSessionOwnership(unlocked)?.current() && 175 latest.status === 'ready' && 176 latest.coverage === 'bounded-eose' && 177 latest.author === ownership.owner && 178 latest.knownBase?.id === preference.id && 179 access.current() && 180 ownership.current() && 181 inboxResolverCurrentAfterSample(own) 182 ); 183 }; 184 if (!current()) return undefined; 185 const token = Object.freeze({}) as InboxSync; 186 const pool = getPrivatePool( 187 session, 188 policy, 189 targets, 190 token, 191 'receive', 192 current 193 ); 194 if (!pool) return undefined; 195 let state: State = 'ready', 196 candidates = 0, 197 bytes = 0, 198 retained = 0, 199 duplicates = 0, 200 excludedProbes = 0, 201 rejected = 0, 202 pending = 0, 203 reason: string | null = null, 204 consumed = false, 205 stopped = false, 206 backfill = 'not_started', 207 pendingBytes = 0, 208 failed = false, 209 cleaned = false, 210 cleanupRequired = false; 211 let release = () => {}, 212 releaseLive = () => {}, 213 offUnlock = () => {}, 214 off = () => {}; 215 let queue = Promise.resolve(); 216 function releaseOwners() { 217 let failure = false; 218 for (const cleanup of [ 219 release, 220 releaseLive, 221 () => closePrivatePool(pool!) 222 ]) { 223 try { 224 cleanup(); 225 } catch { 226 failure = true; 227 } 228 } 229 cleanupRequired = failure; 230 if (failure) throw Error('private_inbox_cleanup_required'); 231 } 232 function stop() { 233 if (cleaned) return; 234 stopped = true; 235 state = 'stopped'; 236 off(); 237 offUnlock(); 238 let failure = false; 239 try { 240 releaseOwners(); 241 } catch { 242 failure = true; 243 } 244 try { 245 if (!closePrivateVisibilityScope(visibility)) failure = true; 246 } catch { 247 failure = true; 248 } 249 cleanupRequired = failure; 250 if (!failure) cleaned = true; 251 else throw Error('private_inbox_cleanup_required'); 252 } 253 function pause(why: string) { 254 if (stopped || failed) return; 255 failed = true; 256 state = 'needs_action'; 257 reason = why; 258 try { 259 releaseOwners(); 260 } catch { 261 cleanupRequired = true; 262 } 263 } 264 function receive(message: PrivatePageMessage) { 265 if (stopped || failed) return; 266 if (!current()) { 267 stop(); 268 return; 269 } 270 if (message.type === 'end') { 271 backfill = message.reason; 272 if (message.reason !== 'complete') pause(message.reason); 273 return; 274 } 275 candidates++; 276 const size = new TextEncoder().encode(message.wire).length; 277 bytes += size; 278 // Bound outstanding ciphertext work across both lanes before queuing. 279 if ( 280 pending >= PRIVATE_TRANSPORT_BUDGETS.deliveries || 281 pendingBytes + size > PRIVATE_TRANSPORT_BUDGETS.processedBytes 282 ) { 283 pause('budget'); 284 return; 285 } 286 const origin = message.from.endsWith('/') 287 ? message.from.slice(0, -1) 288 : message.from; 289 if (!targets.includes(origin)) { 290 rejected++; 291 return; 292 } 293 const envelope = admitInboxEnvelope( 294 message.wire, 295 ownership.owner, 296 origin, 297 Date.now() 298 ); 299 if (!envelope) { 300 rejected++; 301 return; 302 } 303 pending++; 304 pendingBytes += size; 305 queue = queue 306 .then(async () => { 307 if (stopped || failed) return; 308 if (!current()) { 309 stop(); 310 return; 311 } 312 const result = await retainInboxEnvelope( 313 repository, 314 session, 315 envelope 316 ); 317 if (stopped || failed || !current()) { 318 if (!stopped && !failed) stop(); 319 return; 320 } 321 if (result.status === 'retained') retained++; 322 else if (result.status === 'duplicate') duplicates++; 323 else if (result.status === 'probe_excluded') excludedProbes++; 324 else pause(result.status); 325 }) 326 .catch(() => pause('unknown_completion')) 327 .finally(() => { 328 pending--; 329 pendingBytes -= size; 330 }); 331 } 332 ingress.set(token, { 333 refresh(reviewed, previousOuterCheck) { 334 if ( 335 reviewed !== 'reviewed_foreground_inbox' || 336 !current() || 337 stopped || 338 failed || 339 state !== 'live' || 340 backfill !== 'complete' || 341 pending !== 0 342 ) 343 return false; 344 const plan = outerHistoryPlan( 345 Math.floor(Date.now() / 1000), 346 previousOuterCheck 347 ); 348 if (!current()) return false; 349 backfill = 'running'; 350 try { 351 release(); 352 release = subscribePrivateHistory(pool, plan.overlap.since, receive); 353 return true; 354 } catch { 355 pause('backfill_unavailable'); 356 return false; 357 } 358 }, 359 history() { 360 return current() && 361 !stopped && 362 !failed && 363 state === 'live' && 364 backfill === 'complete' && 365 pending === 0 366 ? { session, repository, pool, targets: targets.slice(), current } 367 : undefined; 368 }, 369 snapshot: () => ({ 370 owner: ownership.owner, 371 state, 372 candidates, 373 bytes, 374 retained, 375 duplicates, 376 excludedProbes, 377 rejected, 378 reason, 379 pending, 380 cleanupRequired, 381 backfill, 382 historyComplete: false, 383 foregroundOnly: true, 384 recoveryChoices: inboxRecoveryChoices(reason) 385 }), 386 stop, 387 start(reviewed) { 388 if ( 389 reviewed !== 'reviewed_foreground_inbox' || 390 consumed || 391 stopped || 392 !current() 393 ) 394 return false; 395 consumed = true; 396 state = 'running'; 397 try { 398 releaseLive = subscribePrivateLive(pool, (message) => { 399 if (stopped || failed) return; 400 if (!current()) { 401 stop(); 402 return; 403 } 404 if (message.type === 'open') { 405 // Actual SDK OPEN follows its REQ send. Defer so synchronous cached 406 // connections cannot begin backfill before the live release binds. 407 if (backfill !== 'not_started') return; 408 backfill = 'running'; 409 queueMicrotask(() => { 410 if (stopped || failed) return; 411 if (!current()) { 412 try { 413 stop(); 414 } catch { 415 /* Original incomplete cleanup remains retryable. */ 416 } 417 return; 418 } 419 state = 'live'; 420 try { 421 release = subscribePrivateHistory( 422 pool, 423 history.overlap.since, 424 receive 425 ); 426 } catch { 427 pause('backfill_unavailable'); 428 } 429 }); 430 } else if (message.type === 'end') pause(message.reason); 431 else receive(message); 432 }); 433 } catch { 434 state = 'needs_action'; 435 reason = 'live_unavailable'; 436 return false; 437 } 438 return true; 439 } 440 }); 441 sessions.set(session, token); 442 off = subscribePrivateSessionClose(session, stop); 443 offUnlock = subscribeUnlockedSessionClose(unlocked, stop); 444 if (!current()) { 445 stop(); 446 return undefined; 447 } 448 return token; 449 } catch { 450 return undefined; 451 } 452 } 453 export function startInboxSync(token: InboxSync, review: unknown): boolean { 454 return ingress.get(token)?.start(review) ?? false; 455 } 456 export function stopInboxSync(token: InboxSync): void { 457 ingress.get(token)?.stop(); 458 } 459 export function inboxSyncSnapshot(token: InboxSync): Snapshot | undefined { 460 return ingress.get(token)?.snapshot(); 461 } 462 463 // Original genuine sync only. Detached snapshots/query hints cannot mint this 464 // original owner-generation/visibility/access transport and storage boundary. 465 export function inboxSyncHistoryOwnership( 466 token: InboxSync 467 ): InboxHistoryOwnership | undefined { 468 return ingress.get(token)?.history(); 469 } 470 471 // Repeating a checked foreground window requires the same original current 472 // access/live owner and a fresh explicit review. No recreated live subscription, 473 // automatic AUTH/retry, decryption or copied snapshot authority. 474 export function refreshInboxSync( 475 token: InboxSync, 476 review: unknown, 477 previousOuterCheck?: unknown 478 ): boolean { 479 return ingress.get(token)?.refresh(review, previousOuterCheck) ?? false; 480 }