local-data-review.ts (20385B)
1 import { 2 identityViewSession, 3 subscribeIdentityView, 4 type IdentityViewContext 5 } from '../runtime/view-context.ts'; 6 import { 7 identityLocalOwnership, 8 identitySessionSnapshot, 9 subscribeIdentityInvalidation 10 } from '../runtime/identity-session.ts'; 11 import { createPrivateSession } from '../runtime/private-session.ts'; 12 import { 13 openBrowserDatabase, 14 closeBrowserDatabase, 15 type BrowserDatabase 16 } from './database.ts'; 17 import { 18 createPublicQuotaRepository, 19 inspectPublicStorage, 20 publicInventorySnapshot, 21 reviewPublicCleanup, 22 commitPublicCleanup, 23 type PublicQuotaRepository, 24 type PublicInventory, 25 type PublicCleanup 26 } from './quota.ts'; 27 import { 28 createPrivateStorageRepository, 29 listPrivateSendRecords, 30 listPrivateReceivedRecords, 31 type PrivateStorageRepository 32 } from './private-storage.ts'; 33 import { 34 privateRecordIdentity, 35 privateRecordWire, 36 privateRecordSnapshot, 37 type PrivateRecordHandle 38 } from './private-records.ts'; 39 import { 40 capturePrivateOutboxCleanup, 41 deleteReviewedSettledSends, 42 stopPrivateOutboxCleanup, 43 type PrivateOutboxCleanup 44 } from './private-outbox-cleanup.ts'; 45 import { 46 captureReceivedCleanup, 47 deleteReviewedReceivedCopies, 48 stopReceivedCleanup, 49 type ReceivedCleanup 50 } from './inbox-retention.ts'; 51 import { 52 PUBLIC_CLEANUP_CONSEQUENCES, 53 PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES, 54 privateInventoryRow, 55 type PublicInventoryRow, 56 type PrivateInventoryRow 57 } from './local-inventory.ts'; 58 import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; 59 60 declare const reviewBrand: unique symbol; 61 export type LocalDataReview = Readonly<{ [reviewBrand]: true }>; 62 type Category = 'public' | 'received' | 'outbox'; 63 type Preview = Readonly<{ 64 category: Category; 65 selected: number; 66 consequences: string; 67 }>; 68 type Inventory = Readonly<{ 69 owner: string; 70 publicRows: readonly PublicInventoryRow[]; 71 received: readonly Readonly<{ id: string; logicalBytes: number }>[]; 72 outbox: Readonly<{ count: number; bytes: number }>; 73 outboxRows: readonly PrivateInventoryRow[]; 74 receivedRemoval: boolean; 75 }>; 76 export type LocalDataReviewSnapshot = 77 | Readonly<{ state: 'guest' | 'closed' }> 78 | Readonly<{ state: 'loading' }> 79 | Readonly<{ state: 'unavailable'; notice: string }> 80 | (Inventory & 81 Readonly<{ 82 state: 'ready'; 83 busy: boolean; 84 preview?: Preview; 85 notice?: string; 86 }>); 87 type Controller = { 88 snapshot(): LocalDataReviewSnapshot; 89 review(consent: unknown): Promise<void>; 90 preview(category: unknown, selection: unknown): Promise<boolean>; 91 confirm(consent: unknown): Promise<boolean>; 92 cancel(): void; 93 close(): void; 94 subscribe(listener: () => void): () => void; 95 }; 96 const reviews = new WeakMap<LocalDataReview, Controller>(); 97 const receivedConsequences = 98 'Removing selected encrypted copies loses those local messages. Relay recovery is not guaranteed. Other participants and relays may retain copies. Outbox recovery records stay unchanged. Browser-local storage is not a backup.'; 99 const unavailable = 100 'Local inventory or removal was not confirmed. Existing local data has not been reset. You can still browse public food. Review current data before trying again; an unknown completion may have changed selected local copies.'; 101 102 function outboxInventory( 103 handles: readonly PrivateRecordHandle[], 104 owner: string 105 ): PrivateInventoryRow[] { 106 return handles.map((handle) => { 107 const identity = privateRecordIdentity(handle), 108 record = identity && privateRecordSnapshot(handle, owner, identity.id), 109 wire = identity && privateRecordWire(handle, owner, identity.id); 110 if (!record || !wire) throw Error('outbox inventory unavailable'); 111 return privateInventoryRow( 112 record, 113 new TextEncoder().encode(JSON.stringify({ owner, id: record.id, wire })) 114 .length 115 ); 116 }); 117 } 118 119 function selection(value: unknown, maximum: number): string[] | undefined { 120 if ( 121 typeof value !== 'string' || 122 new TextEncoder().encode(value).length > 160000 123 ) 124 return; 125 try { 126 const parsed: unknown = JSON.parse(value); 127 if ( 128 !Array.isArray(parsed) || 129 !parsed.length || 130 parsed.length > maximum || 131 !parsed.every((id: unknown) => typeof id === 'string') || 132 new Set(parsed).size !== parsed.length 133 ) 134 return; 135 return parsed.slice(); 136 } catch { 137 return; 138 } 139 } 140 141 // Pure per-view construction. Merely visiting Privacy never opens the inventory, 142 // acquires an extension permission, probes messaging or creates a private socket. 143 export function createLocalDataReview( 144 context: IdentityViewContext 145 ): LocalDataReview { 146 const token = Object.freeze({}) as LocalDataReview; 147 const listeners = new Map<symbol, () => void>(); 148 let closed = false, 149 generation = Symbol(), 150 busy = false; 151 // Whole immutable snapshots are replaced; no caller object is mutated. 152 let state: LocalDataReviewSnapshot; 153 state = { state: 'guest' }; 154 let ownership: ReturnType<typeof identityLocalOwnership>; 155 let database: BrowserDatabase | undefined, 156 cancellation: AbortController | undefined; 157 let publicRepository: PublicQuotaRepository | undefined, 158 inventory: PublicInventory | undefined; 159 let privateRepository: PrivateStorageRepository | undefined; 160 let publicCleanup: PublicCleanup | undefined, 161 receivedCleanup: ReceivedCleanup | undefined; 162 let outboxCleanup: PrivateOutboxCleanup | undefined; 163 let offIdentity = () => {}; 164 function notify() { 165 for (const listener of listeners.values()) { 166 try { 167 listener(); 168 } catch { 169 /* Presentation cannot interrupt storage settlement. */ 170 } 171 } 172 } 173 function cancelPreview() { 174 publicCleanup = undefined; 175 if (receivedCleanup) stopReceivedCleanup(receivedCleanup); 176 receivedCleanup = undefined; 177 if (outboxCleanup) stopPrivateOutboxCleanup(outboxCleanup); 178 outboxCleanup = undefined; 179 if (state.state === 'ready') state = { ...state, preview: undefined }; 180 } 181 function retire() { 182 generation = Symbol(); 183 cancellation?.abort(); 184 cancellation = undefined; 185 cancelPreview(); 186 if (database) closeBrowserDatabase(database); 187 database = undefined; 188 publicRepository = undefined; 189 privateRepository = undefined; 190 inventory = undefined; 191 ownership = undefined; 192 busy = false; 193 offIdentity(); 194 offIdentity = () => {}; 195 state = closed ? { state: 'closed' } : { state: 'guest' }; 196 } 197 function current(original: symbol) { 198 return !closed && generation === original && ownership?.current() === true; 199 } 200 function observe() { 201 if (ownership && !ownership.current()) { 202 retire(); 203 notify(); 204 } 205 } 206 const offView = subscribeIdentityView(context, observe); 207 async function review(consent: unknown) { 208 if (closed || busy || consent !== 'reviewed_local_inventory') return; 209 retire(); 210 const identity = identityViewSession(context); 211 const captured = identity && identityLocalOwnership(identity); 212 if (!identity || !captured?.current() || typeof window === 'undefined') { 213 notify(); 214 return; 215 } 216 ownership = captured; 217 busy = true; 218 cancellation = new AbortController(); 219 const original = generation; 220 offIdentity = subscribeIdentityInvalidation(identity, observe); 221 state = { state: 'loading' }; 222 notify(); 223 try { 224 const opened = await openBrowserDatabase(cancellation.signal); 225 if (!current(original)) { 226 if (opened.state === 'ready') closeBrowserDatabase(opened.owner); 227 return; 228 } 229 if (opened.state !== 'ready') throw Error('local storage unavailable'); 230 database = opened.owner; 231 const pub = createPublicQuotaRepository(database, captured.owner), 232 priv = createPrivateStorageRepository(database, captured.owner); 233 if (!pub || !priv) throw Error('local owner namespace unavailable'); 234 const scan = await inspectPublicStorage(pub); 235 if (!current(original)) return; 236 if (!scan.ok) throw Error('public inventory unavailable'); 237 const publicState = publicInventorySnapshot(pub, scan.value); 238 const received = await listPrivateReceivedRecords(priv); 239 if (!current(original)) return; 240 const outbox = await listPrivateSendRecords(priv); 241 if (!current(original)) return; 242 if (!publicState || !received.ok || !outbox.ok) 243 throw Error('private inventory unavailable'); 244 const copies = received.value.map((handle) => { 245 const row = privateRecordIdentity(handle), 246 wire = row && privateRecordWire(handle, captured.owner, row.id); 247 if (!row || row.owner !== captured.owner || !wire) 248 throw Error('received inventory unavailable'); 249 return { 250 id: row.id, 251 logicalBytes: new TextEncoder().encode( 252 JSON.stringify({ owner: captured.owner, id: row.id, wire }) 253 ).length 254 }; 255 }); 256 const outboxRows = outboxInventory(outbox.value, captured.owner); 257 publicRepository = pub; 258 privateRepository = priv; 259 inventory = scan.value; 260 state = { 261 state: 'ready', 262 busy: false, 263 owner: captured.owner, 264 publicRows: publicState.rows, 265 received: copies, 266 outbox: { 267 count: outboxRows.length, 268 bytes: outboxRows.reduce((sum, row) => sum + row.logicalBytes, 0) 269 }, 270 outboxRows, 271 receivedRemoval: 272 identitySessionSnapshot(identity).state === 'messaging_capable' 273 }; 274 } catch { 275 if (current(original)) { 276 retire(); 277 state = { state: 'unavailable', notice: unavailable }; 278 } 279 } finally { 280 if (generation === original) busy = false; 281 notify(); 282 } 283 } 284 reviews.set(token, { 285 snapshot() { 286 observe(); 287 return state.state === 'ready' 288 ? { 289 ...state, 290 publicRows: state.publicRows.map((row) => ({ ...row })), 291 received: state.received.map((row) => ({ ...row })), 292 outbox: { ...state.outbox }, 293 outboxRows: state.outboxRows.map((row) => ({ ...row })), 294 preview: state.preview && { ...state.preview } 295 } 296 : { ...state }; 297 }, 298 review, 299 async preview(category, serialized) { 300 observe(); 301 if (closed || busy || state.state !== 'ready' || !ownership?.current()) 302 return false; 303 const ids = selection( 304 serialized, 305 category === 'public' 306 ? LOCAL_PERSISTENCE_BUDGETS.publicDrafts + 307 LOCAL_PERSISTENCE_BUDGETS.publicOperations 308 : category === 'outbox' 309 ? LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends 310 : LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes 311 ); 312 cancelPreview(); 313 if (!ids) { 314 notify(); 315 return false; 316 } 317 const original = generation; 318 if (category === 'public' && publicRepository && inventory) { 319 const captured = reviewPublicCleanup(publicRepository, inventory, ids); 320 if (!captured.ok) { 321 notify(); 322 return false; 323 } 324 publicCleanup = captured.value; 325 state = { 326 ...state, 327 preview: { 328 category, 329 selected: ids.length, 330 consequences: PUBLIC_CLEANUP_CONSEQUENCES 331 }, 332 notice: undefined 333 }; 334 notify(); 335 return true; 336 } 337 if ( 338 (category !== 'received' && category !== 'outbox') || 339 !privateRepository || 340 !state.receivedRemoval || 341 !ids.every( 342 (id) => 343 state.state === 'ready' && 344 (category === 'received' 345 ? state.received.some((row) => row.id === id) 346 : state.outboxRows.some( 347 (row) => row.id === id && row.state === 'settled' 348 )) 349 ) 350 ) { 351 notify(); 352 return false; 353 } 354 const identity = identityViewSession(context); 355 if (!identity) return false; 356 busy = true; 357 state = { ...state, busy: true }; 358 notify(); 359 try { 360 const session = await createPrivateSession( 361 identity, 362 'reviewed_private_session' 363 ); 364 if (!session || !current(original)) return false; 365 if (category === 'outbox') { 366 const cleanup = await capturePrivateOutboxCleanup( 367 privateRepository, 368 session, 369 ids, 370 'reviewed_settled_outbox_selection' 371 ); 372 if (!current(original)) { 373 if (cleanup) stopPrivateOutboxCleanup(cleanup); 374 return false; 375 } 376 if (!cleanup || state.state !== 'ready') return false; 377 outboxCleanup = cleanup; 378 state = { 379 ...state, 380 preview: { 381 category: 'outbox', 382 selected: ids.length, 383 consequences: PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES 384 }, 385 notice: undefined 386 }; 387 return true; 388 } 389 const cleanup = await captureReceivedCleanup( 390 privateRepository, 391 session, 392 ids, 393 'reviewed_received_cleanup_selection' 394 ); 395 if (!current(original)) { 396 if (cleanup) stopReceivedCleanup(cleanup); 397 return false; 398 } 399 if (!cleanup || state.state !== 'ready') return false; 400 receivedCleanup = cleanup; 401 state = { 402 ...state, 403 preview: { 404 category: 'received', 405 selected: ids.length, 406 consequences: receivedConsequences 407 }, 408 notice: undefined 409 }; 410 return true; 411 } catch { 412 return false; 413 } finally { 414 if (generation === original) { 415 busy = false; 416 if (state.state === 'ready') state = { ...state, busy: false }; 417 } 418 notify(); 419 } 420 }, 421 async confirm(consent) { 422 observe(); 423 if ( 424 closed || 425 busy || 426 consent !== 'reviewed_local_removal' || 427 state.state !== 'ready' || 428 !state.preview || 429 !ownership?.current() || 430 !cancellation 431 ) 432 return false; 433 const original = generation, 434 preview = state.preview, 435 owner = ownership.owner; 436 const pub = publicCleanup, 437 received = receivedCleanup, 438 outbox = outboxCleanup, 439 repo = publicRepository, 440 signal = cancellation.signal; 441 publicCleanup = undefined; 442 receivedCleanup = undefined; 443 outboxCleanup = undefined; 444 busy = true; 445 state = { ...state, busy: true, preview: undefined }; 446 notify(); 447 let confirmed = false; 448 try { 449 if ( 450 preview.category === 'public' && 451 pub && 452 repo && 453 navigator.locks?.request 454 ) { 455 confirmed = await navigator.locks.request( 456 'harvestcircle:owner:' + owner, 457 { mode: 'exclusive', ifAvailable: true }, 458 async (lock) => { 459 if (!lock || !current(original)) return false; 460 const committed = await commitPublicCleanup(repo, pub, signal); 461 if (!committed.ok || !current(original)) return false; 462 const checked = await inspectPublicStorage(repo); 463 if (!checked.ok || !current(original)) return false; 464 const remaining = publicInventorySnapshot(repo, checked.value); 465 if ( 466 !remaining || 467 committed.value.some((key) => 468 remaining.rows.some((row) => row.key === key) 469 ) 470 ) 471 return false; 472 inventory = checked.value; 473 if (state.state === 'ready') 474 state = { ...state, publicRows: remaining.rows }; 475 return true; 476 } 477 ); 478 } else if (preview.category === 'outbox' && outbox) { 479 outboxCleanup = outbox; 480 const result = await deleteReviewedSettledSends( 481 outbox, 482 'reviewed_delete_local_settled_sends' 483 ); 484 if ( 485 result.status === 'removed' && 486 current(original) && 487 privateRepository 488 ) { 489 const scan = await listPrivateSendRecords(privateRepository); 490 if (scan.ok && current(original) && state.state === 'ready') { 491 const remaining = outboxInventory(scan.value, owner); 492 state = { 493 ...state, 494 outboxRows: remaining, 495 outbox: { 496 count: remaining.length, 497 bytes: remaining.reduce( 498 (sum, row) => sum + row.logicalBytes, 499 0 500 ) 501 } 502 }; 503 confirmed = true; 504 } 505 } 506 } else if (preview.category === 'received' && received) { 507 // Keep the owned action available to synchronous retirement while running. 508 receivedCleanup = received; 509 const result = await deleteReviewedReceivedCopies( 510 received, 511 'reviewed_delete_local_received_copies' 512 ); 513 if ( 514 result.status === 'removed' && 515 current(original) && 516 privateRepository 517 ) { 518 const scan = await listPrivateReceivedRecords(privateRepository); 519 if (scan.ok && current(original) && state.state === 'ready') { 520 state = { 521 ...state, 522 received: state.received.filter((row) => 523 scan.value.some( 524 (handle) => privateRecordIdentity(handle)?.id === row.id 525 ) 526 ) 527 }; 528 confirmed = true; 529 } 530 } 531 } 532 } catch { 533 confirmed = false; 534 } finally { 535 if (received) stopReceivedCleanup(received); 536 if (receivedCleanup === received) receivedCleanup = undefined; 537 if (outbox) stopPrivateOutboxCleanup(outbox); 538 if (outboxCleanup === outbox) outboxCleanup = undefined; 539 if (generation === original) { 540 busy = false; 541 if (state.state === 'ready') 542 state = { 543 ...state, 544 busy: false, 545 notice: confirmed 546 ? 'Removed ' + 547 preview.selected + 548 (preview.category === 'public' 549 ? ' selected public record' 550 : preview.category === 'outbox' 551 ? ' selected settled send record' 552 : ' selected received encrypted copy') + 553 (preview.selected === 1 ? '.' : ' entries.') + 554 ' Other local categories and remote copies are unchanged.' 555 : unavailable 556 }; 557 } 558 notify(); 559 } 560 return confirmed; 561 }, 562 cancel() { 563 if (busy) return; 564 cancelPreview(); 565 notify(); 566 }, 567 close() { 568 if (closed) return; 569 closed = true; 570 retire(); 571 offView(); 572 notify(); 573 listeners.clear(); 574 }, 575 subscribe(listener) { 576 if (closed) return () => {}; 577 const id = Symbol(); 578 listeners.set(id, listener); 579 return () => { 580 listeners.delete(id); 581 }; 582 } 583 }); 584 return token; 585 } 586 export function localDataReviewSnapshot( 587 token: LocalDataReview 588 ): LocalDataReviewSnapshot { 589 return reviews.get(token)?.snapshot() ?? { state: 'closed' }; 590 } 591 export async function reviewLocalData( 592 token: LocalDataReview, 593 consent: unknown 594 ): Promise<void> { 595 await reviews.get(token)?.review(consent); 596 } 597 export function previewLocalDataRemoval( 598 token: LocalDataReview, 599 category: unknown, 600 selection: unknown 601 ): Promise<boolean> { 602 return ( 603 reviews.get(token)?.preview(category, selection) ?? Promise.resolve(false) 604 ); 605 } 606 export function confirmLocalDataRemoval( 607 token: LocalDataReview, 608 consent: unknown 609 ): Promise<boolean> { 610 return reviews.get(token)?.confirm(consent) ?? Promise.resolve(false); 611 } 612 export function cancelLocalDataRemoval(token: LocalDataReview): void { 613 reviews.get(token)?.cancel(); 614 } 615 export function closeLocalDataReview(token: LocalDataReview): void { 616 reviews.get(token)?.close(); 617 } 618 export function subscribeLocalDataReview( 619 token: LocalDataReview, 620 listener: () => void 621 ): () => void { 622 return reviews.get(token)?.subscribe(listener) ?? (() => {}); 623 }