app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

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 }