local-private-blocks.ts (21842B)
1 import { canonicalPublicKey } from '../contracts/public-key.ts'; 2 import { exactLocalFields } from '../contracts/local-records.ts'; 3 import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; 4 import { 5 conversationSnapshot, 6 type AdmittedConversation 7 } from '../messaging/admit-conversation.ts'; 8 import { 9 unlockedConversationCurrent, 10 unlockedSessionOwnership, 11 type UnlockedSession 12 } from '../messaging/unlocked-session.ts'; 13 import { 14 identityLocalOwnership, 15 subscribeIdentityInvalidation, 16 type IdentitySession 17 } from '../runtime/identity-session.ts'; 18 import { 19 identityViewSession, 20 subscribeIdentityView, 21 type IdentityViewContext 22 } from '../runtime/view-context.ts'; 23 import { 24 openBrowserDatabase, 25 closeBrowserDatabase, 26 browserDatabaseState, 27 browserDatabaseTransaction, 28 type BrowserDatabase 29 } from './database.ts'; 30 31 declare const blocksBrand: unique symbol; 32 export type LocalPrivateBlocks = Readonly<{ [blocksBrand]: true }>; 33 export const LOCAL_PRIVATE_BLOCKS_CONTEXT = 34 'harvestcircle_local_private_blocks'; 35 export const PRIVATE_BLOCK_DISCLOSURE = 36 'Blocking a person is local to this account in this browser. It hides their private messages and previews, stops future automatic continuation, and may discard unsaved private text. It does not delete encrypted evidence, remote copies or delivery receipts, reject an order, notify the sender or send a public report. Undo restores eligible local views; another explicit bounded decryption action may be needed. Browser storage is not a backup. Private messages have no forward secrecy or post-compromise security.'; 37 type Failure = 38 | 'invalid' 39 | 'stopped' 40 | 'busy' 41 | 'unavailable' 42 | 'aborted' 43 | 'unknown_completion' 44 | 'corrupt_record' 45 | 'conflict' 46 | 'capacity'; 47 export type PrivateBlocksSnapshot = 48 | Readonly<{ state: 'guest' | 'loading' }> 49 | Readonly<{ state: 'unavailable'; reason?: Failure }> 50 | Readonly<{ 51 state: 'ready'; 52 owner: string; 53 revision: number; 54 peers: readonly string[]; 55 }>; 56 type Result<T> = 57 Readonly<{ ok: true; value: T }> | Readonly<{ ok: false; reason: Failure }>; 58 type Row = { 59 schema: 1; 60 family: 'private_blocks'; 61 owner: string; 62 id: 'private_blocks'; 63 revision: number; 64 peers: string[]; 65 }; 66 type Stored = { row: Row; wire: string | null }; 67 type Scope = { owner: string; database: BrowserDatabase; current(): boolean }; 68 export type PrivateBlockResult = Readonly<{ 69 status: 'saved' | 'existing' | Failure; 70 }>; 71 type Controller = { 72 snapshot(): PrivateBlocksSnapshot; 73 mount(): Promise<void>; 74 refresh(): Promise<void>; 75 block( 76 room: AdmittedConversation, 77 unlocked: UnlockedSession, 78 review: unknown 79 ): Promise<PrivateBlockResult>; 80 current(): boolean; 81 undo(peer: unknown, review: unknown): Promise<PrivateBlockResult>; 82 subscribe(listener: () => void): () => void; 83 close(): void; 84 }; 85 const controllers = new WeakMap<LocalPrivateBlocks, Controller>(); 86 const failed = (reason: Failure): Result<never> => ({ ok: false, reason }); 87 function decode(value: unknown, owner: string): Stored | undefined { 88 if (value === undefined) 89 return { 90 row: { 91 schema: 1, 92 family: 'private_blocks', 93 owner, 94 id: 'private_blocks', 95 revision: 0, 96 peers: [] 97 }, 98 wire: null 99 }; 100 if ( 101 !exactLocalFields(value, ['owner', 'id', 'wire']) || 102 value.owner !== owner || 103 value.id !== 'private_blocks' || 104 typeof value.wire !== 'string' || 105 new TextEncoder().encode(value.wire).length > 106 LOCAL_PERSISTENCE_BUDGETS.receivedCiphertextBytes 107 ) 108 return; 109 let row: unknown; 110 try { 111 row = JSON.parse(value.wire); 112 } catch { 113 return; 114 } 115 if ( 116 !exactLocalFields(row, [ 117 'schema', 118 'family', 119 'owner', 120 'id', 121 'revision', 122 'peers' 123 ]) || 124 row.schema !== 1 || 125 row.family !== 'private_blocks' || 126 row.owner !== owner || 127 row.id !== 'private_blocks' || 128 !Number.isSafeInteger(row.revision) || 129 typeof row.revision !== 'number' || 130 row.revision < 1 || 131 !Array.isArray(row.peers) || 132 row.peers.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes || 133 row.peers.some( 134 (key: unknown) => 135 typeof key !== 'string' || canonicalPublicKey(key) !== key 136 ) || 137 new Set(row.peers).size !== row.peers.length || 138 row.peers.some( 139 (key: string, index: number, peers: string[]) => 140 index > 0 && key <= peers[index - 1] 141 ) 142 ) 143 return; 144 const admitted: Row = { 145 schema: 1, 146 family: 'private_blocks', 147 owner, 148 id: 'private_blocks', 149 revision: row.revision, 150 peers: row.peers.slice() as string[] 151 }; 152 return JSON.stringify(admitted) === value.wire 153 ? { row: admitted, wire: value.wire } 154 : undefined; 155 } 156 // One fixed owner/key record, with bounded peer entries. This avoids 157 // scanning or adopting the independent public-hide preferences in the same store. 158 function transaction<T>( 159 scope: Scope, 160 mode: 'readonly' | 'readwrite', 161 apply: (stored: Stored, tx: IDBTransaction) => Result<T> 162 ): Promise<Result<T>> { 163 if (!scope.current()) return Promise.resolve(failed('stopped')); 164 let tx: IDBTransaction; 165 try { 166 tx = browserDatabaseTransaction( 167 scope.database, 168 ['local_preferences'], 169 mode 170 ); 171 } catch { 172 return Promise.resolve(failed('unavailable')); 173 } 174 return new Promise((resolve) => { 175 let result: Result<T> | undefined; 176 const refuse = (reason: Failure) => { 177 result = failed(reason); 178 try { 179 tx.abort(); 180 } catch { 181 result = failed('unknown_completion'); 182 } 183 }; 184 tx.addEventListener('complete', () => 185 resolve( 186 scope.current() 187 ? (result ?? failed('unknown_completion')) 188 : failed('stopped') 189 ) 190 ); 191 tx.addEventListener('abort', () => 192 resolve( 193 !scope.current() 194 ? failed('stopped') 195 : result && !result.ok && result.reason !== 'unknown_completion' 196 ? result 197 : failed('aborted') 198 ) 199 ); 200 try { 201 const request = tx 202 .objectStore('local_preferences') 203 .get([scope.owner, 'private_blocks']); 204 request.addEventListener('success', () => { 205 if (!scope.current()) { 206 refuse('stopped'); 207 return; 208 } 209 try { 210 const row = decode(request.result, scope.owner); 211 if (!row) { 212 refuse('corrupt_record'); 213 return; 214 } 215 result = apply(row, tx); 216 if (!result.ok) refuse(result.reason); 217 } catch { 218 refuse('aborted'); 219 } 220 }); 221 } catch { 222 refuse('aborted'); 223 } 224 }); 225 } 226 // Construction has no browser effect and holds no server-global account state. 227 function capturePrivateBlocks( 228 identity: IdentitySession 229 ): LocalPrivateBlocks | undefined { 230 const observed = identityLocalOwnership(identity); 231 if (!observed?.current()) return; 232 const capture = observed; 233 const owned = () => !closed && capture.current(); 234 const token = Object.freeze({}) as LocalPrivateBlocks; 235 const listeners = new Map<symbol, () => void>(); 236 let state: PrivateBlocksSnapshot, 237 mounted = false, 238 closed = false; 239 state = { state: 'loading' }; 240 let scope: Scope | undefined, 241 generation = Symbol(), 242 cancel: AbortController | undefined; 243 let offInvalidation = () => {}; 244 function notify() { 245 for (const listener of listeners.values()) { 246 try { 247 listener(); 248 } catch { 249 /* Isolate presentation. */ 250 } 251 } 252 } 253 function retire() { 254 generation = Symbol(); 255 cancel?.abort(); 256 cancel = undefined; 257 offInvalidation(); 258 offInvalidation = () => {}; 259 if (scope) closeBrowserDatabase(scope.database); 260 scope = undefined; 261 state = { state: 'unavailable', reason: 'stopped' }; 262 } 263 function snapshot(): PrivateBlocksSnapshot { 264 if (closed) return { state: 'unavailable', reason: 'stopped' }; 265 if (!owned() || (scope && !scope.current())) 266 return { state: 'unavailable', reason: 'stopped' }; 267 return state.state === 'ready' 268 ? { ...state, peers: state.peers.slice() } 269 : { ...state }; 270 } 271 async function refresh() { 272 retire(); 273 notify(); 274 if (!mounted || closed) return; 275 if (!owned()) return; 276 const original = generation; 277 const current = () => 278 !closed && mounted && original === generation && capture.current(); 279 state = { state: 'loading' }; 280 notify(); 281 cancel = new AbortController(); 282 offInvalidation = subscribeIdentityInvalidation(identity, () => { 283 // Observations also fan out after a successful same-owner recheck. 284 // Retire only actual ownership loss; another explicit private-session 285 // acquisition must not close this still-current preference generation. 286 if (!capture.current()) { 287 retire(); 288 notify(); 289 } 290 }); 291 const opened = await openBrowserDatabase(cancel.signal); 292 if (!current()) { 293 if (opened.state === 'ready') closeBrowserDatabase(opened.owner); 294 return; 295 } 296 if (opened.state !== 'ready') { 297 state = { state: 'unavailable', reason: 'unavailable' }; 298 notify(); 299 return; 300 } 301 const acquired: Scope = { 302 owner: capture.owner, 303 database: opened.owner, 304 current: () => 305 current() && browserDatabaseState(opened.owner).state === 'ready' 306 }; 307 scope = acquired; 308 const read = await transaction(acquired, 'readonly', (stored) => ({ 309 ok: true, 310 value: stored 311 })); 312 if (!acquired.current()) return; 313 state = read.ok 314 ? { 315 state: 'ready', 316 owner: acquired.owner, 317 revision: read.value.row.revision, 318 peers: read.value.row.peers.slice() 319 } 320 : { state: 'unavailable', reason: read.reason }; 321 notify(); 322 } 323 async function change( 324 peer: string, 325 hidden: boolean, 326 original: Scope 327 ): Promise<PrivateBlockResult> { 328 if (!original.current()) return { status: 'stopped' }; 329 if (!navigator.locks?.request) return { status: 'unavailable' }; 330 try { 331 return await navigator.locks.request( 332 'harvestcircle:owner:' + original.owner, 333 { mode: 'exclusive', ifAvailable: true }, 334 async (lock) => { 335 if (!lock) return { status: 'busy' as const }; 336 if (!original.current()) return { status: 'stopped' as const }; 337 const loaded = await transaction(original, 'readonly', (stored) => ({ 338 ok: true, 339 value: stored 340 })); 341 if (!original.current()) return { status: 'stopped' as const }; 342 if (!loaded.ok) { 343 state = { state: 'unavailable', reason: loaded.reason }; 344 notify(); 345 return { status: loaded.reason }; 346 } 347 const before = loaded.value; 348 if (before.row.peers.includes(peer) === hidden) { 349 // Another controller may have acknowledged this complete native 350 // row. Reconcile all preferences without another write/revision. 351 state = { 352 state: 'ready', 353 owner: original.owner, 354 revision: before.row.revision, 355 peers: before.row.peers.slice() 356 }; 357 notify(); 358 return { status: 'existing' as const }; 359 } 360 if ( 361 before.row.revision >= Number.MAX_SAFE_INTEGER || 362 (hidden && 363 before.row.peers.length >= 364 LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) 365 ) 366 return { status: 'capacity' as const }; 367 const next: Row = { 368 ...before.row, 369 revision: before.row.revision + 1, 370 peers: hidden 371 ? before.row.peers.concat(peer).sort() 372 : before.row.peers.filter((key) => key !== peer) 373 }; 374 const wire = JSON.stringify(next); 375 const written = await transaction<boolean>( 376 original, 377 'readwrite', 378 (stored, tx) => { 379 if (stored.wire !== before.wire) return failed('conflict'); 380 tx.objectStore('local_preferences').put({ 381 owner: original.owner, 382 id: 'private_blocks', 383 wire 384 }); 385 return { ok: true, value: true }; 386 } 387 ); 388 if (!original.current()) return { status: 'stopped' as const }; 389 if (!written.ok) { 390 if ( 391 written.reason === 'conflict' || 392 written.reason === 'unknown_completion' 393 ) { 394 state = { state: 'unavailable', reason: written.reason }; 395 notify(); 396 } 397 return { status: written.reason }; 398 } 399 const readback = await transaction( 400 original, 401 'readonly', 402 (stored) => ({ ok: true, value: stored }) 403 ); 404 if (!original.current()) return { status: 'stopped' as const }; 405 if (!readback.ok) { 406 state = { state: 'unavailable', reason: 'unknown_completion' }; 407 notify(); 408 return { status: 'unknown_completion' as const }; 409 } 410 if (readback.value.wire !== wire) { 411 state = { state: 'unavailable', reason: 'conflict' }; 412 notify(); 413 return { status: 'conflict' as const }; 414 } 415 state = { 416 state: 'ready', 417 owner: original.owner, 418 revision: next.revision, 419 peers: next.peers.slice() 420 }; 421 notify(); 422 return { status: 'saved' as const }; 423 } 424 ); 425 } catch { 426 if (!original.current()) return { status: 'stopped' }; 427 state = { state: 'unavailable', reason: 'unknown_completion' }; 428 notify(); 429 return { status: 'unknown_completion' }; 430 } 431 } 432 controllers.set(token, { 433 current: owned, 434 snapshot, 435 async mount() { 436 if (closed || mounted || typeof window === 'undefined') return; 437 mounted = true; 438 await refresh(); 439 }, 440 refresh, 441 async block(room, unlocked, review) { 442 const message = conversationSnapshot(room); 443 const cache = unlockedSessionOwnership(unlocked); 444 const original = scope; 445 if ( 446 !message || 447 !cache?.current() || 448 cache.owner !== capture.owner || 449 cache.session !== capture.session || 450 message.owner !== capture.owner || 451 !canonicalPublicKey(message.peer) || 452 review !== 'reviewed_local_private_block' || 453 !unlockedConversationCurrent(unlocked, room) 454 ) 455 return { status: 'invalid' }; 456 if (!original || state.state !== 'ready') 457 return { status: 'unavailable' }; 458 return change(message.peer, true, { 459 ...original, 460 current: () => 461 original.current() && 462 cache.current() && 463 unlockedConversationCurrent(unlocked, room) 464 }); 465 }, 466 async undo(peer, review) { 467 const key = canonicalPublicKey(peer); 468 if (!key || review !== 'reviewed_local_private_undo') 469 return { status: 'invalid' }; 470 const original = scope; 471 if (!original || state.state !== 'ready') 472 return { status: 'unavailable' }; 473 if (!state.peers.includes(key)) return { status: 'invalid' }; 474 return change(key, false, original); 475 }, 476 subscribe(listener) { 477 if (closed) return () => {}; 478 const id = Symbol(); 479 listeners.set(id, listener); 480 return () => { 481 listeners.delete(id); 482 }; 483 }, 484 close() { 485 if (closed) return; 486 closed = true; 487 retire(); 488 notify(); 489 listeners.clear(); 490 } 491 }); 492 return token; 493 } 494 export function localPrivateBlocksSnapshot( 495 token: LocalPrivateBlocks 496 ): PrivateBlocksSnapshot { 497 return controllers.get(token)?.snapshot() ?? { state: 'unavailable' }; 498 } 499 export function localPrivatePeerAllowed( 500 token: LocalPrivateBlocks, 501 peer: string 502 ): boolean { 503 const owned = controllers.get(token); 504 if (!owned) return false; 505 const state = owned.snapshot(); 506 return state.state === 'ready' && !state.peers.includes(peer); 507 } 508 export function mountLocalPrivateBlocks( 509 token: LocalPrivateBlocks 510 ): Promise<void> { 511 return controllers.get(token)?.mount() ?? Promise.resolve(); 512 } 513 export function refreshLocalPrivateBlocks( 514 token: LocalPrivateBlocks 515 ): Promise<void> { 516 return controllers.get(token)?.refresh() ?? Promise.resolve(); 517 } 518 export function subscribeLocalPrivateBlocks( 519 token: LocalPrivateBlocks, 520 listener: () => void 521 ): () => void { 522 return controllers.get(token)?.subscribe(listener) ?? (() => {}); 523 } 524 export function blockLocalPrivatePeer( 525 token: LocalPrivateBlocks, 526 room: AdmittedConversation, 527 unlocked: UnlockedSession, 528 review: unknown 529 ): Promise<PrivateBlockResult> { 530 return ( 531 controllers.get(token)?.block(room, unlocked, review) ?? 532 Promise.resolve({ status: 'invalid' }) 533 ); 534 } 535 export function undoLocalPrivatePeer( 536 token: LocalPrivateBlocks, 537 peer: unknown, 538 review: unknown 539 ): Promise<PrivateBlockResult> { 540 return ( 541 controllers.get(token)?.undo(peer, review) ?? 542 Promise.resolve({ status: 'invalid' }) 543 ); 544 } 545 export function closeLocalPrivateBlocks(token: LocalPrivateBlocks): void { 546 controllers.get(token)?.close(); 547 } 548 549 const identityControllers = new WeakMap<IdentitySession, LocalPrivateBlocks>(); 550 export function privateBlocksForIdentity( 551 identity: IdentitySession 552 ): LocalPrivateBlocks | undefined { 553 const prior = identityControllers.get(identity); 554 if (prior && controllers.get(prior)?.current()) return prior; 555 if (prior) closeLocalPrivateBlocks(prior); 556 const token = capturePrivateBlocks(identity); 557 if (token) identityControllers.set(identity, token); 558 return token; 559 } 560 declare const viewBrand: unique symbol; 561 export type LocalPrivateBlocksView = Readonly<{ [viewBrand]: true }>; 562 const viewControllers = new WeakMap< 563 LocalPrivateBlocksView, 564 { 565 snapshot(): PrivateBlocksSnapshot; 566 mount(): Promise<void>; 567 subscribe(listener: () => void): () => void; 568 undo(peer: unknown, review: unknown): Promise<PrivateBlockResult>; 569 close(): void; 570 } 571 >(); 572 // Root construction stays SSR-pure. Original identity sessions share the same 573 // preference owner with Inbox controllers; route disposal cannot close another view. 574 export function createLocalPrivateBlocks( 575 context: IdentityViewContext 576 ): LocalPrivateBlocksView { 577 return createPrivateBlocksView( 578 () => identityViewSession(context), 579 (listener) => { 580 let initial = true; 581 return subscribeIdentityView(context, () => { 582 if (initial) { 583 initial = false; 584 return; 585 } 586 listener(); 587 }); 588 } 589 ); 590 } 591 // Original identity-owned consumers use the same registry as the root context; 592 // a copied session still cannot acquire an account or preference controller. 593 export function createIdentityLocalPrivateBlocksView( 594 identity: IdentitySession 595 ): LocalPrivateBlocksView { 596 return createPrivateBlocksView( 597 () => identity, 598 (listener) => subscribeIdentityInvalidation(identity, listener) 599 ); 600 } 601 function createPrivateBlocksView( 602 sessionOf: () => IdentitySession | undefined, 603 observe: (listener: () => void) => () => void 604 ): LocalPrivateBlocksView { 605 const view = Object.freeze({}) as LocalPrivateBlocksView; 606 const listeners = new Map<symbol, () => void>(); 607 let token: LocalPrivateBlocks | undefined, 608 mounted = false, 609 closed = false; 610 let off = () => {}, 611 offToken = () => {}; 612 const notify = () => { 613 for (const listener of listeners.values()) { 614 try { 615 listener(); 616 } catch { 617 /* Isolate presentation. */ 618 } 619 } 620 }; 621 async function bind() { 622 offToken(); 623 offToken = () => {}; 624 const session = sessionOf(); 625 token = session ? privateBlocksForIdentity(session) : undefined; 626 if (token) { 627 const original = token; 628 offToken = subscribeLocalPrivateBlocks(original, notify); 629 await mountLocalPrivateBlocks(original); 630 } 631 if (!closed) notify(); 632 } 633 viewControllers.set(view, { 634 snapshot: () => 635 closed 636 ? { state: 'unavailable', reason: 'stopped' } 637 : token 638 ? localPrivateBlocksSnapshot(token) 639 : { state: 'guest' }, 640 async mount() { 641 if (closed || mounted || typeof window === 'undefined') return; 642 mounted = true; 643 off = observe(() => { 644 void bind(); 645 }); 646 await bind(); 647 }, 648 subscribe(listener) { 649 const key = Symbol(); 650 listeners.set(key, listener); 651 return () => { 652 listeners.delete(key); 653 }; 654 }, 655 undo: (peer, review) => 656 token 657 ? undoLocalPrivatePeer(token, peer, review) 658 : Promise.resolve({ status: 'invalid' }), 659 close() { 660 if (closed) return; 661 closed = true; 662 off(); 663 offToken(); 664 token = undefined; 665 notify(); 666 listeners.clear(); 667 } 668 }); 669 return view; 670 } 671 export function mountLocalPrivateBlocksView( 672 view: LocalPrivateBlocksView 673 ): Promise<void> { 674 return viewControllers.get(view)?.mount() ?? Promise.resolve(); 675 } 676 export function localPrivateBlocksViewSnapshot( 677 view: LocalPrivateBlocksView 678 ): PrivateBlocksSnapshot { 679 return viewControllers.get(view)?.snapshot() ?? { state: 'unavailable' }; 680 } 681 export function subscribeLocalPrivateBlocksView( 682 view: LocalPrivateBlocksView, 683 listener: () => void 684 ): () => void { 685 return viewControllers.get(view)?.subscribe(listener) ?? (() => {}); 686 } 687 export function undoLocalPrivateBlocksView( 688 view: LocalPrivateBlocksView, 689 peer: unknown, 690 review: unknown 691 ): Promise<PrivateBlockResult> { 692 return ( 693 viewControllers.get(view)?.undo(peer, review) ?? 694 Promise.resolve({ status: 'invalid' }) 695 ); 696 } 697 export function closeLocalPrivateBlocksView( 698 view: LocalPrivateBlocksView 699 ): void { 700 viewControllers.get(view)?.close(); 701 }