history-pagination.ts (12380B)
1 import { 2 inboxSyncHistoryOwnership, 3 type InboxSync, 4 type InboxHistoryOwnership 5 } from './inbox-sync.ts'; 6 import { 7 initialOuterCursor, 8 advanceOuterPage, 9 type OuterCursor 10 } from './inbox-state.ts'; 11 import { 12 readRetainedOuterMetadata, 13 type RetainedOuterMetadata 14 } from '../persistence/history-metadata-repository.ts'; 15 import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; 16 import { 17 createPrivateHistoryRun, 18 subscribePrivateSourcePage, 19 type PrivatePageMessage 20 } from '../nostr/private-pool.ts'; 21 import { 22 admitInboxEnvelope, 23 inboxEnvelopeOuterMetadata, 24 retainInboxEnvelope 25 } from '../persistence/inbox-envelope-repository.ts'; 26 import { 27 subscribePrivateSessionClose, 28 privateSessionOwnership 29 } from '../runtime/private-session.ts'; 30 declare const olderBrand: unique symbol; 31 export type OlderInbox = Readonly<{ [olderBrand]: true }>; 32 type View = Readonly<{ 33 ownerGenerationScoped: true; 34 state: string; 35 reason: string | null; 36 historyComplete: false; 37 cleanupRequired: boolean; 38 sources: readonly OuterCursor[]; 39 }>; 40 type Controller = { 41 start(review: unknown): Promise<boolean>; 42 stop(): void; 43 snapshot(): View; 44 }; 45 const controllers = new WeakMap<OlderInbox, Controller>(), 46 syncs = new WeakMap<InboxSync, OlderInbox>(); 47 export function captureOlderInbox( 48 sync: InboxSync, 49 review: unknown 50 ): OlderInbox | undefined { 51 if (review !== 'reviewed_load_older' || syncs.has(sync)) return undefined; 52 const ownership = inboxSyncHistoryOwnership(sync); 53 if (!ownership?.current()) return undefined; 54 const original: InboxHistoryOwnership = ownership; 55 const token = Object.freeze({}) as OlderInbox; 56 const cancellation = new AbortController(); 57 let stopped = false, 58 busy = false, 59 cleanupRequired = false, 60 state = 'ready', 61 reason: string | null = null; 62 let cursors = Array.from<OuterCursor>([]), 63 release = () => {}, 64 off = () => {}; 65 // Genuine excluded deliveries still have signed outer cursor facts. They 66 // are bounded observed-page memory, never retained rows or exclusion proof. 67 const excludedOuter = new Map<string, RetainedOuterMetadata>(); 68 let retainedOuter: readonly RetainedOuterMetadata[] = 69 Array.from<RetainedOuterMetadata>([]); 70 function mergedOuter( 71 retained: readonly RetainedOuterMetadata[], 72 extra?: RetainedOuterMetadata 73 ): RetainedOuterMetadata[] | undefined { 74 const rows = new Map<string, RetainedOuterMetadata>(), 75 ids = new Map<string, true>(); 76 for (const row of [ 77 ...retained, 78 ...excludedOuter.values(), 79 ...(extra ? [extra] : []) 80 ]) { 81 ids.set(row.outerId, true); 82 if (ids.size > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) 83 return undefined; 84 const key = JSON.stringify([row.source, row.outerId]), 85 previous = rows.get(key); 86 if (previous && previous.outerTime !== row.outerTime) return undefined; 87 if (!previous) rows.set(key, row); 88 } 89 return Array.from(rows.values()); 90 } 91 const current = () => { 92 const valid = !stopped && original.current(); 93 if (!valid) { 94 // These are only transient cursor facts. Observed generation loss must 95 // discard them even when the next explicit action is refused at entry. 96 excludedOuter.clear(); 97 retainedOuter = []; 98 cursors = []; 99 } 100 return valid; 101 }; 102 function stop() { 103 stopped = true; 104 cancellation.abort(); 105 state = 'stopped'; 106 let failure = false; 107 try { 108 off(); 109 } catch { 110 failure = true; 111 } 112 try { 113 release(); 114 } catch { 115 failure = true; 116 } 117 cursors = []; 118 excludedOuter.clear(); 119 retainedOuter = []; 120 cleanupRequired = failure; 121 if (!failure && syncs.get(sync) === token) syncs.delete(sync); 122 if (failure) throw Error('private_history_cleanup_required'); 123 } 124 async function page( 125 source: string, 126 until: number | undefined, 127 run: ReturnType<typeof createPrivateHistoryRun> 128 ): Promise<{ reason: string; deliveries: number; ids: readonly string[] }> { 129 return await new Promise((resolve) => { 130 let queue = Promise.resolve(), 131 finished = false, 132 failure: string | undefined; 133 const ids = new Map<string, true>(); 134 const pageRetained = new Map<string, RetainedOuterMetadata>(); 135 let acceptedDeliveries = 0; 136 function receive(message: PrivatePageMessage) { 137 if (finished) return; 138 if (message.type === 'end') { 139 finished = true; 140 void queue.then(() => 141 resolve({ 142 reason: 143 failure ?? 144 (message.reason === 'complete' && 145 acceptedDeliveries < (message.deliveries ?? acceptedDeliveries) 146 ? 'unsupported' 147 : message.reason), 148 deliveries: message.deliveries ?? ids.size, 149 ids: Array.from(ids.keys()) 150 }) 151 ); 152 return; 153 } 154 if (!current()) { 155 stop(); 156 return; 157 } 158 const origin = message.from.endsWith('/') 159 ? message.from.slice(0, -1) 160 : message.from; 161 // Obtain original admitted owner's namespace from the genuine sync session, 162 // never the random outer author. The actual repository enforces it too. 163 queue = queue 164 .then(async () => { 165 if (!current()) return; 166 if (failure === 'capacity') return; 167 const owner = privateOwner(); 168 const admitted = 169 owner && 170 admitInboxEnvelope(message.wire, owner, origin, Date.now()); 171 if (!admitted || origin !== source) { 172 failure = 'unsupported'; 173 return; 174 } 175 const retained = await retainInboxEnvelope( 176 original.repository, 177 original.session, 178 admitted, 179 cancellation.signal 180 ); 181 if (!current()) return; 182 if (retained.status === 'probe_excluded') { 183 const signed = inboxEnvelopeOuterMetadata(admitted); 184 if (!signed) { 185 failure = 'unsupported'; 186 return; 187 } 188 const fact = { 189 source, 190 outerId: signed.id, 191 outerTime: signed.createdAt 192 }; 193 if ( 194 !mergedOuter([...retainedOuter, ...pageRetained.values()], fact) 195 ) { 196 failure = 'capacity'; 197 return; 198 } 199 const key = JSON.stringify([source, signed.id]); 200 if (!excludedOuter.has(key)) excludedOuter.set(key, fact); 201 acceptedDeliveries++; 202 ids.set(signed.id, true); 203 return; 204 } 205 if ( 206 retained.status !== 'retained' && 207 retained.status !== 'duplicate' 208 ) { 209 failure = retained.status; 210 return; 211 } 212 const signed = inboxEnvelopeOuterMetadata(admitted); 213 if (!signed) { 214 failure = 'unsupported'; 215 return; 216 } 217 const fact = { 218 source, 219 outerId: signed.id, 220 outerTime: signed.createdAt 221 }; 222 if ( 223 !mergedOuter([...retainedOuter, ...pageRetained.values()], fact) 224 ) { 225 failure = 'capacity'; 226 return; 227 } 228 pageRetained.set(signed.id, fact); 229 acceptedDeliveries++; 230 ids.set(signed.id, true); 231 }) 232 .catch(() => { 233 failure = 'unknown_completion'; 234 }); 235 } 236 try { 237 release = subscribePrivateSourcePage( 238 original.pool, 239 run, 240 source, 241 until, 242 receive 243 ); 244 } catch { 245 resolve({ reason: 'error', deliveries: 0, ids: [] }); 246 } 247 }); 248 } 249 function privateOwner() { 250 return privateSessionOwnership(original.session)?.owner; 251 } 252 controllers.set(token, { 253 snapshot: () => { 254 current(); 255 return { 256 ownerGenerationScoped: true, 257 state, 258 reason, 259 historyComplete: false, 260 cleanupRequired, 261 sources: cursors.map((cursor) => ({ 262 ...cursor, 263 seen: cursor.seen.slice() 264 })) 265 }; 266 }, 267 stop, 268 async start(reviewed) { 269 if ( 270 reviewed !== 'reviewed_load_older' || 271 busy || 272 !current() || 273 cleanupRequired 274 ) 275 return false; 276 busy = true; 277 state = 'loading'; 278 reason = null; 279 try { 280 const initial = await readRetainedOuterMetadata( 281 original.repository, 282 original.session 283 ); 284 if (!current()) { 285 stop(); 286 return false; 287 } 288 if (!initial.ok) { 289 state = 'needs_action'; 290 reason = initial.reason; 291 return false; 292 } 293 const observed = mergedOuter(initial.rows); 294 if (!observed) { 295 state = 'needs_action'; 296 reason = 'capacity'; 297 return false; 298 } 299 retainedOuter = initial.rows; 300 cursors = original.targets.map((source) => { 301 const fresh = initialOuterCursor( 302 source, 303 observed.filter((row) => row.source === source) 304 ); 305 const previous = cursors.find((cursor) => cursor.source === source); 306 return previous && previous.until === fresh.until 307 ? { ...fresh, state: previous.state, partial: previous.partial } 308 : fresh; 309 }); 310 const run = createPrivateHistoryRun(original.pool); 311 let next = Array.from<OuterCursor>([]); 312 for (const cursor of cursors) { 313 if (!current()) { 314 stop(); 315 break; 316 } 317 if (cursor.state === 'saturated') { 318 next = next.concat(cursor); 319 continue; 320 } 321 const result = await page(cursor.source, cursor.until, run); 322 if (!current()) { 323 stop(); 324 break; 325 } 326 const stored = await readRetainedOuterMetadata( 327 original.repository, 328 original.session 329 ); 330 if (!current()) { 331 stop(); 332 break; 333 } 334 if (!stored.ok) { 335 state = 'needs_action'; 336 reason = stored.reason; 337 next = next.concat(cursor); 338 break; 339 } 340 const observed = mergedOuter(stored.rows); 341 if (!observed) { 342 state = 'needs_action'; 343 reason = 'capacity'; 344 next = next.concat(cursor); 345 break; 346 } 347 retainedOuter = stored.rows; 348 const rows = observed.filter( 349 (row) => 350 row.source === cursor.source && result.ids.includes(row.outerId) 351 ); 352 next = next.concat( 353 advanceOuterPage(cursor, rows, result.deliveries, result.reason) 354 ); 355 if ( 356 result.reason === 'budget' || 357 result.reason === 'elapsed' || 358 result.reason === 'capacity' 359 ) { 360 state = 'needs_action'; 361 reason = result.reason; 362 break; 363 } 364 } 365 if (!stopped) { 366 cursors = next.concat( 367 cursors.filter( 368 (cursor) => !next.some((row) => row.source === cursor.source) 369 ) 370 ); 371 if (state !== 'needs_action') 372 state = cursors.some((cursor) => cursor.partial) 373 ? 'partial' 374 : 'older_available'; 375 } 376 return current(); 377 } catch { 378 if (!stopped) { 379 state = 'needs_action'; 380 reason = 'unknown_completion'; 381 } 382 return false; 383 } finally { 384 busy = false; 385 } 386 } 387 }); 388 off = subscribePrivateSessionClose(original.session, stop); 389 syncs.set(sync, token); 390 return token; 391 } 392 export function loadOlderInbox( 393 token: OlderInbox, 394 review: unknown 395 ): Promise<boolean> { 396 return controllers.get(token)?.start(review) ?? Promise.resolve(false); 397 } 398 export function stopOlderInbox(token: OlderInbox): void { 399 controllers.get(token)?.stop(); 400 } 401 export function olderInboxSnapshot(token: OlderInbox): View | undefined { 402 return controllers.get(token)?.snapshot(); 403 }