app

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

commit 10a1687be5a3291df996f5a0ad008cd53c932120
parent ad243e60d819ec37f5242ecb2089a1d2dcaa255e
Author: triesap <tyson@radroots.org>
Date:   Sun, 11 Oct 2026 04:03:07 +0000

feat(web): implement owner-local private peer blocking

- Bind reversible blocks to verified inner peers and original account custody.
- Preserve native evidence and fail closed on conflicting or uncertain preferences.
- Fence private views, captured actions and bounded decrypt continuation.
- Verify browser regressions and retain exact compiler source admission.

Diffstat:
Mweb/src/lib/components/ConversationOptions.svelte | 62+++++++++++++++++++++++++++++++++++++++++++++++++++-----------
Mweb/src/lib/components/ConversationThread.svelte | 7+++++++
Mweb/src/lib/components/InboxStatus.svelte | 4++++
Mweb/src/lib/messaging/cited-product.ts | 6++++++
Mweb/src/lib/messaging/decryption-queue.ts | 67+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Mweb/src/lib/messaging/inbox-view.ts | 91+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
Aweb/src/lib/persistence/local-private-blocks.ts | 701+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/routes/+layout.svelte | 10++++++++++
Mweb/src/routes/privacy/+page.svelte | 76++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/capability-gate.spec.ts | 1+
Mweb/tests/e2e/harness/conversation-thread.ts | 1+
Mweb/tests/e2e/harness/decryption-queue.ts | 62++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/private-blocks-panel.svelte | 5+++++
Aweb/tests/e2e/harness/private-blocks.ts | 517+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/private-blocks.spec.ts | 662+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/integration/loopback.test.ts | 7++++++-
Mweb/tests/provenance/output.test.mjs | 104++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
Mweb/tests/unit/inbox-view.test.ts | 21+++++++++++++++++++++
Aweb/tests/unit/private-blocks.test.ts | 42++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/unit/route-inventory.test.ts | 8+++++++-
Mweb/tools/check-output.mjs | 417++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
21 files changed, 2840 insertions(+), 31 deletions(-)

diff --git a/web/src/lib/components/ConversationOptions.svelte b/web/src/lib/components/ConversationOptions.svelte @@ -2,6 +2,7 @@ import { onMount } from 'svelte'; import { subscribeInboxView, + blockInboxConversation, type InboxView } from '../messaging/inbox-view.ts'; import { @@ -20,6 +21,24 @@ onreport?: (peer: string) => void; } = $props(); let revision = $state(0); + let reviewing = $state(false), + busy = $state(false), + notice = $state<string | undefined>(); + async function confirmBlock() { + if (!reviewing || busy) return; + busy = true; + const result = await blockInboxConversation( + controller, + conversationId, + 'reviewed_local_private_block' + ); + busy = false; + reviewing = false; + notice = + result.status === 'saved' || result.status === 'existing' + ? 'Person blocked in this browser.' + : 'Block was not confirmed. Existing local data has not been reset.'; + } const actual = $derived.by(() => { void revision; return conversationOptionsSnapshot(controller, conversationId); @@ -35,19 +54,40 @@ <details> <summary>Identity and conversation options</summary> <p>Authenticated conversation peer: {actual.peer}</p> - {#if onblock}<button + <button + type="button" + onclick={() => { + if (onblock) + requestConversationOption( + controller, + conversationId, + 'block', + onblock, + 'reviewed_conversation_option' + ); + else reviewing = true; + }}>Block person</button + > + {#if reviewing} + <p> + Blocking hides messages and previews for this account in this browser + and may discard unsaved private text. Encrypted evidence, delivery + receipts and remote copies remain. It sends no report or sender + notification and does not accept or reject an order. Undo is available + in Privacy. + </p> + <button type="button" disabled={busy} onclick={() => void confirmBlock()} + >Confirm local block</button + > + <button type="button" + disabled={busy} onclick={() => { - if (onblock) - requestConversationOption( - controller, - conversationId, - 'block', - onblock, - 'reviewed_conversation_option' - ); - }}>Block person</button - >{/if} + reviewing = false; + }}>Cancel</button + > + {/if} + {#if notice}<p role="status">{notice}</p>{/if} {#if onreport}<button type="button" onclick={() => { diff --git a/web/src/lib/components/ConversationThread.svelte b/web/src/lib/components/ConversationThread.svelte @@ -37,6 +37,7 @@ closeInboxView, inboxThreadSnapshot, inboxThreadRevision, + inboxConversationBlocked, markInboxConversationDisplayed, type InboxView } from '../messaging/inbox-view.ts'; @@ -204,6 +205,12 @@ controller={reply} focusScope="conversation" />{/key}{/if} + {:else if owned && inboxConversationBlocked(owned, conversationId)} + <p> + This person is blocked locally. Messages and previews are hidden; + encrypted evidence and remote copies remain. + </p> + <a href="/privacy">Review local blocks and Undo</a> {:else}<p> This conversation is unavailable until it is unlocked in the matching browser and account. diff --git a/web/src/lib/components/InboxStatus.svelte b/web/src/lib/components/InboxStatus.svelte @@ -152,6 +152,10 @@ panel.owner ? panel.identity : identity.identity ); const reasons: Record<string, string> = { + local_preferences_unavailable: + 'Local private block preferences could not be checked. Private messages and decryption continuation are unavailable; encrypted evidence is preserved.', + local_block_changed: + 'Local block preferences changed during this batch. Further decryption needs another explicit reviewed action.', access_unavailable: 'Inbox access has not been qualified and exercised. Unlocked local copies do not prove a successful relay check.', storage_unavailable: diff --git a/web/src/lib/messaging/cited-product.ts b/web/src/lib/messaging/cited-product.ts @@ -5,6 +5,7 @@ import { inboxMessageSnapshot, inboxReplyOwnership, inboxThreadSnapshot, + subscribeInboxView, type InboxReplyOwnership, type InboxView } from './inbox-view.ts'; @@ -136,12 +137,14 @@ export function captureCitedProduct( let privateScope: InboxReplyOwnership | undefined = original; const requests = new Map<PublicRequest, true>(); let offPrivate = () => {}, + offInbox = () => {}, offIdentity = () => {}; function close() { if (closed) return; closed = true; privateScope = undefined; offPrivate(); + offInbox(); offIdentity(); try { closeHeadResolver(resolver); @@ -211,6 +214,9 @@ export function captureCitedProduct( }); offPrivate = subscribePrivateSessionClose(original.session, close); offIdentity = subscribeIdentityInvalidation(original.identity, close); + offInbox = subscribeInboxView(inbox, () => { + if (!owned()) close(); + }); function admit( proof: Parameters<typeof createPublicHeadCandidate>[0], exactOnly: boolean diff --git a/web/src/lib/messaging/decryption-queue.ts b/web/src/lib/messaging/decryption-queue.ts @@ -1,5 +1,11 @@ import { planDecryptBatch } from './inbox-state.ts'; import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { + privateBlocksForIdentity, + mountLocalPrivateBlocks, + localPrivateBlocksSnapshot, + localPrivatePeerAllowed +} from '../persistence/local-private-blocks.ts'; import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; import { privateSessionOwnership, @@ -86,6 +92,8 @@ export function captureDecryptionQueue( const capture = observed, identityOwner = owner, unlockedOwner = cache; + const preferences = privateBlocksForIdentity(identity); + if (!preferences) return; let visibility; try { visibility = getPrivateVisibilityScope(session); @@ -114,6 +122,7 @@ export function captureDecryptionQueue( let active: ReceivedUnwrap | undefined, off = () => {}, unlockOff = () => {}; + const excluded = new Map<string, string>(); function current() { return ( !stopped && @@ -134,6 +143,7 @@ export function captureDecryptionQueue( accepted = []; pending = []; processed = []; + excluded.clear(); off(); unlockOff(); if (sessions.get(session) === token) sessions.delete(session); @@ -188,7 +198,15 @@ export function captureDecryptionQueue( invalid, busy }), - rooms: () => (current() ? accepted.slice() : []), + rooms: () => + current() + ? accepted.filter((room) => { + const message = conversationSnapshot(room); + return ( + !!message && localPrivatePeerAllowed(preferences, message.peer) + ); + }) + : [], stop, expire, async refresh() { @@ -222,6 +240,23 @@ export function captureDecryptionQueue( admitted = 0; invalid = 0; try { + await mountLocalPrivateBlocks(preferences); + const initial = localPrivateBlocksSnapshot(preferences); + if (!current() || initial.state !== 'ready') { + pause('local_preferences_unavailable'); + return false; + } + // Undo alone does nothing. Only this newly reviewed batch may revisit + // previously identified ciphertext, without resetting unrelated IDs. + for (const [id, peer] of excluded) { + if ( + localPrivatePeerAllowed(preferences, peer) && + !exclusions.includes(peer) + ) { + processed = processed.filter((value) => value !== id); + excluded.delete(id); + } + } if (!(await load()) || paused || !current()) return false; const plan = planDecryptBatch(pending); for (const id of plan.selected) { @@ -230,6 +265,18 @@ export function captureDecryptionQueue( return false; } if (paused) return false; + const before = localPrivateBlocksSnapshot(preferences); + if ( + before.state !== 'ready' || + before.revision !== initial.revision + ) { + pause( + before.state === 'ready' + ? 'local_block_changed' + : 'local_preferences_unavailable' + ); + return false; + } // Cost reservation occurs before unwrap/admission/dedup/blocked sender. attempted++; active = captureReceivedUnwrap( @@ -261,8 +308,12 @@ export function captureDecryptionQueue( if (!room || !message) { invalid++; stopReceivedUnwrap(reader); - } else if (exclusions.includes(message.peer)) { + } else if ( + exclusions.includes(message.peer) || + !localPrivatePeerAllowed(preferences, message.peer) + ) { blocked++; + excluded.set(id, message.peer); stopReceivedUnwrap(reader); } else { const projection = acceptUnlockedConversation(unlocked, room); @@ -294,6 +345,18 @@ export function captureDecryptionQueue( if (!current() || paused) return false; processed = processed.concat(id); pending = pending.filter((next) => next !== id); + const actual = localPrivateBlocksSnapshot(preferences); + if ( + actual.state !== 'ready' || + actual.revision !== initial.revision + ) { + pause( + actual.state === 'ready' + ? 'local_block_changed' + : 'local_preferences_unavailable' + ); + return false; + } } if (!(await load()) || paused || !current()) return false; state = pending.length ? 'needs_action' : 'idle'; diff --git a/web/src/lib/messaging/inbox-view.ts b/web/src/lib/messaging/inbox-view.ts @@ -5,6 +5,15 @@ import { type ThreadMessage } from './conversation-thread.ts'; import type { PrivateRecordHandle } from '../persistence/private-records.ts'; +import { + privateBlocksForIdentity, + mountLocalPrivateBlocks, + localPrivateBlocksSnapshot, + localPrivatePeerAllowed, + subscribeLocalPrivateBlocks, + blockLocalPrivatePeer, + type PrivateBlockResult +} from '../persistence/local-private-blocks.ts'; import { canonicalPublicKey } from '../contracts/public-key.ts'; import { groupInboxMessages, @@ -135,6 +144,8 @@ export type InboxReplyOwnership = Readonly<{ ): Promise<boolean>; }>; type Controller = { + block(id: unknown, review: unknown): Promise<PrivateBlockResult>; + blocked(id: unknown): boolean; reply(id: unknown, rumor: unknown): InboxReplyOwnership | undefined; snapshot(): InboxViewSnapshot; thread(id: unknown): ThreadSnapshot; @@ -186,6 +197,9 @@ export function createInboxView(input: Inputs): InboxView | undefined { return; const capture = original, token = Object.freeze({}) as InboxView; + const capturedPreferences = privateBlocksForIdentity(input.identity); + if (!capturedPreferences) return; + const preferences = capturedPreferences; let closed = false, busy = false, epoch = 0, @@ -224,6 +238,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { let off = () => {}, privateOff = () => {}, setupOff = () => {}, + preferencesOff = () => {}, pendingCleanup = Array.from<() => void>([]); const listeners = new Map<symbol, (view: InboxViewSnapshot) => void>(); function current(generation = epoch) { @@ -249,6 +264,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { if ( id !== threadId || !threadPeer || + !localPrivatePeerAllowed(preferences, threadPeer) || !privateCurrent() || !unlocked || !queue @@ -307,6 +323,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { !actual || actual.owner !== capture.owner || actual.peer !== threadPeer || + !localPrivatePeerAllowed(preferences, actual.peer) || actual.rumorId !== rumor ) return; @@ -330,6 +347,25 @@ export function createInboxView(input: Inputs): InboxView | undefined { messages: messages.filter((row) => row !== undefined) }; } + async function block( + id: unknown, + review: unknown + ): Promise<PrivateBlockResult> { + const room = threadRooms(id)?.[0]; + if (!room || !unlocked || review !== 'reviewed_local_private_block') + return { status: 'invalid' }; + return blockLocalPrivatePeer(preferences, room, unlocked, review); + } + function blocked(id: unknown): boolean { + const actual = localPrivateBlocksSnapshot(preferences); + return ( + current() && + id === threadId && + !!threadPeer && + actual.state === 'ready' && + actual.peers.includes(threadPeer) + ); + } function replyOwnership( id: unknown, rumor: unknown @@ -485,6 +521,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { !actual || actual.owner !== capture.owner || actual.peer !== peer || + !localPrivatePeerAllowed(preferences, actual.peer) || actual.rumorId !== proof.data.latest.rumorId ) return; @@ -495,8 +532,14 @@ export function createInboxView(input: Inputs): InboxView | undefined { return { status: 'locked', requests: [], conversations: [] }; if (list.status !== 'ready') return { status: list.status, requests: [], conversations: [] }; - const requests = list.requests.map((row) => rowSnapshot(row.peer)), - conversations = list.conversations.map((row) => rowSnapshot(row.peer)); + if (localPrivateBlocksSnapshot(preferences).state !== 'ready') + return { status: 'unavailable', requests: [], conversations: [] }; + const requests = list.requests + .filter((row) => localPrivatePeerAllowed(preferences, row.peer)) + .map((row) => rowSnapshot(row.peer)), + conversations = list.conversations + .filter((row) => localPrivatePeerAllowed(preferences, row.peer)) + .map((row) => rowSnapshot(row.peer)); if (requests.some((row) => !row) || conversations.some((row) => !row)) return { status: 'unavailable', requests: [], conversations: [] }; return { @@ -540,7 +583,9 @@ export function createInboxView(input: Inputs): InboxView | undefined { } list = groupInboxMessages( capture.owner, - cached.messages, + cached.messages.filter((message) => + localPrivatePeerAllowed(preferences, message.peer) + ), local.readRumors ); rowProofs.clear(); @@ -605,6 +650,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { !canonicalPublicKey(peer) ) return; + if (!localPrivatePeerAllowed(preferences, peer as string)) return; const room = decryptionQueueConversations(queue).find( (value) => conversationSnapshot(value)?.peer === peer ); @@ -706,6 +752,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { ).ownAccess === 'qualified_exercised'; if (!privateCurrent()) return unavailable(); const partial = + localPrivateBlocksSnapshot(preferences).state !== 'ready' || reason !== null || !exercised || cached.status !== 'ready' || @@ -726,6 +773,9 @@ export function createInboxView(input: Inputs): InboxView | undefined { ? 'empty' : 'ready', reason: + (localPrivateBlocksSnapshot(preferences).state !== 'ready' + ? 'local_preferences_unavailable' + : null) ?? reason ?? listReason ?? paging?.reason ?? @@ -736,7 +786,9 @@ export function createInboxView(input: Inputs): InboxView | undefined { owner: capture.owner, identity, queued: decrypt.queued, - count: cached.messages.length, + count: cached.messages.filter((message) => + localPrivatePeerAllowed(preferences, message.peer) + ).length, lastCheckedAt, historyComplete: false, cleanupRequired: pendingCleanup.length > 0 @@ -927,6 +979,14 @@ export function createInboxView(input: Inputs): InboxView | undefined { const generation = epoch; notify(); try { + await mountLocalPrivateBlocks(preferences); + if ( + !current(generation) || + localPrivateBlocksSnapshot(preferences).state !== 'ready' + ) { + reason = 'local_preferences_unavailable'; + return false; + } await unlockInboxSetupView(input.setup); if (!current(generation)) return false; const original = inboxSetupViewOwnership(input.setup), @@ -1074,6 +1134,8 @@ export function createInboxView(input: Inputs): InboxView | undefined { return current(generation) && privateCurrent(); } views.set(token, { + block, + blocked, reply: replyOwnership, snapshot, thread: threadSnapshot, @@ -1110,6 +1172,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { clearInterval(timer); off(); setupOff(); + preferencesOff(); } releasePrivate(); // Cleanup retains the original genuine setup independently of current @@ -1141,6 +1204,11 @@ export function createInboxView(input: Inputs): InboxView | undefined { } }); setupOff = subscribeInboxSetupView(input.setup, notify); + preferencesOff = subscribeLocalPrivateBlocks(preferences, () => { + refreshThread(); + listRevision++; + notify(); + }); const timer = setInterval(() => { void sample(); }, 200); @@ -1273,3 +1341,18 @@ export function inboxReplyOwnership( ): InboxReplyOwnership | undefined { return views.get(token)?.reply(id, rumor); } +export function blockInboxConversation( + view: InboxView, + id: unknown, + review: unknown +): Promise<PrivateBlockResult> { + return ( + views.get(view)?.block(id, review) ?? Promise.resolve({ status: 'invalid' }) + ); +} +export function inboxConversationBlocked( + view: InboxView | undefined, + id: unknown +): boolean { + return !!view && !!views.get(view)?.blocked(id); +} diff --git a/web/src/lib/persistence/local-private-blocks.ts b/web/src/lib/persistence/local-private-blocks.ts @@ -0,0 +1,701 @@ +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { exactLocalFields } from '../contracts/local-records.ts'; +import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; +import { + conversationSnapshot, + type AdmittedConversation +} from '../messaging/admit-conversation.ts'; +import { + unlockedConversationCurrent, + unlockedSessionOwnership, + type UnlockedSession +} from '../messaging/unlocked-session.ts'; +import { + identityLocalOwnership, + subscribeIdentityInvalidation, + type IdentitySession +} from '../runtime/identity-session.ts'; +import { + identityViewSession, + subscribeIdentityView, + type IdentityViewContext +} from '../runtime/view-context.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseState, + browserDatabaseTransaction, + type BrowserDatabase +} from './database.ts'; + +declare const blocksBrand: unique symbol; +export type LocalPrivateBlocks = Readonly<{ [blocksBrand]: true }>; +export const LOCAL_PRIVATE_BLOCKS_CONTEXT = + 'harvestcircle_local_private_blocks'; +export const PRIVATE_BLOCK_DISCLOSURE = + '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.'; +type Failure = + | 'invalid' + | 'stopped' + | 'busy' + | 'unavailable' + | 'aborted' + | 'unknown_completion' + | 'corrupt_record' + | 'conflict' + | 'capacity'; +export type PrivateBlocksSnapshot = + | Readonly<{ state: 'guest' | 'loading' }> + | Readonly<{ state: 'unavailable'; reason?: Failure }> + | Readonly<{ + state: 'ready'; + owner: string; + revision: number; + peers: readonly string[]; + }>; +type Result<T> = + Readonly<{ ok: true; value: T }> | Readonly<{ ok: false; reason: Failure }>; +type Row = { + schema: 1; + family: 'private_blocks'; + owner: string; + id: 'private_blocks'; + revision: number; + peers: string[]; +}; +type Stored = { row: Row; wire: string | null }; +type Scope = { owner: string; database: BrowserDatabase; current(): boolean }; +export type PrivateBlockResult = Readonly<{ + status: 'saved' | 'existing' | Failure; +}>; +type Controller = { + snapshot(): PrivateBlocksSnapshot; + mount(): Promise<void>; + refresh(): Promise<void>; + block( + room: AdmittedConversation, + unlocked: UnlockedSession, + review: unknown + ): Promise<PrivateBlockResult>; + current(): boolean; + undo(peer: unknown, review: unknown): Promise<PrivateBlockResult>; + subscribe(listener: () => void): () => void; + close(): void; +}; +const controllers = new WeakMap<LocalPrivateBlocks, Controller>(); +const failed = (reason: Failure): Result<never> => ({ ok: false, reason }); +function decode(value: unknown, owner: string): Stored | undefined { + if (value === undefined) + return { + row: { + schema: 1, + family: 'private_blocks', + owner, + id: 'private_blocks', + revision: 0, + peers: [] + }, + wire: null + }; + if ( + !exactLocalFields(value, ['owner', 'id', 'wire']) || + value.owner !== owner || + value.id !== 'private_blocks' || + typeof value.wire !== 'string' || + new TextEncoder().encode(value.wire).length > + LOCAL_PERSISTENCE_BUDGETS.receivedCiphertextBytes + ) + return; + let row: unknown; + try { + row = JSON.parse(value.wire); + } catch { + return; + } + if ( + !exactLocalFields(row, [ + 'schema', + 'family', + 'owner', + 'id', + 'revision', + 'peers' + ]) || + row.schema !== 1 || + row.family !== 'private_blocks' || + row.owner !== owner || + row.id !== 'private_blocks' || + !Number.isSafeInteger(row.revision) || + typeof row.revision !== 'number' || + row.revision < 1 || + !Array.isArray(row.peers) || + row.peers.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes || + row.peers.some( + (key: unknown) => + typeof key !== 'string' || canonicalPublicKey(key) !== key + ) || + new Set(row.peers).size !== row.peers.length || + row.peers.some( + (key: string, index: number, peers: string[]) => + index > 0 && key <= peers[index - 1] + ) + ) + return; + const admitted: Row = { + schema: 1, + family: 'private_blocks', + owner, + id: 'private_blocks', + revision: row.revision, + peers: row.peers.slice() as string[] + }; + return JSON.stringify(admitted) === value.wire + ? { row: admitted, wire: value.wire } + : undefined; +} +// One fixed owner/key record, with bounded peer entries. This avoids +// scanning or adopting the independent public-hide preferences in the same store. +function transaction<T>( + scope: Scope, + mode: 'readonly' | 'readwrite', + apply: (stored: Stored, tx: IDBTransaction) => Result<T> +): Promise<Result<T>> { + if (!scope.current()) return Promise.resolve(failed('stopped')); + let tx: IDBTransaction; + try { + tx = browserDatabaseTransaction( + scope.database, + ['local_preferences'], + mode + ); + } catch { + return Promise.resolve(failed('unavailable')); + } + return new Promise((resolve) => { + let result: Result<T> | undefined; + const refuse = (reason: Failure) => { + result = failed(reason); + try { + tx.abort(); + } catch { + result = failed('unknown_completion'); + } + }; + tx.addEventListener('complete', () => + resolve( + scope.current() + ? (result ?? failed('unknown_completion')) + : failed('stopped') + ) + ); + tx.addEventListener('abort', () => + resolve( + !scope.current() + ? failed('stopped') + : result && !result.ok && result.reason !== 'unknown_completion' + ? result + : failed('aborted') + ) + ); + try { + const request = tx + .objectStore('local_preferences') + .get([scope.owner, 'private_blocks']); + request.addEventListener('success', () => { + if (!scope.current()) { + refuse('stopped'); + return; + } + try { + const row = decode(request.result, scope.owner); + if (!row) { + refuse('corrupt_record'); + return; + } + result = apply(row, tx); + if (!result.ok) refuse(result.reason); + } catch { + refuse('aborted'); + } + }); + } catch { + refuse('aborted'); + } + }); +} +// Construction has no browser effect and holds no server-global account state. +function capturePrivateBlocks( + identity: IdentitySession +): LocalPrivateBlocks | undefined { + const observed = identityLocalOwnership(identity); + if (!observed?.current()) return; + const capture = observed; + const owned = () => !closed && capture.current(); + const token = Object.freeze({}) as LocalPrivateBlocks; + const listeners = new Map<symbol, () => void>(); + let state: PrivateBlocksSnapshot, + mounted = false, + closed = false; + state = { state: 'loading' }; + let scope: Scope | undefined, + generation = Symbol(), + cancel: AbortController | undefined; + let offInvalidation = () => {}; + function notify() { + for (const listener of listeners.values()) { + try { + listener(); + } catch { + /* Isolate presentation. */ + } + } + } + function retire() { + generation = Symbol(); + cancel?.abort(); + cancel = undefined; + offInvalidation(); + offInvalidation = () => {}; + if (scope) closeBrowserDatabase(scope.database); + scope = undefined; + state = { state: 'unavailable', reason: 'stopped' }; + } + function snapshot(): PrivateBlocksSnapshot { + if (closed) return { state: 'unavailable', reason: 'stopped' }; + if (!owned() || (scope && !scope.current())) + return { state: 'unavailable', reason: 'stopped' }; + return state.state === 'ready' + ? { ...state, peers: state.peers.slice() } + : { ...state }; + } + async function refresh() { + retire(); + notify(); + if (!mounted || closed) return; + if (!owned()) return; + const original = generation; + const current = () => + !closed && mounted && original === generation && capture.current(); + state = { state: 'loading' }; + notify(); + cancel = new AbortController(); + offInvalidation = subscribeIdentityInvalidation(identity, () => { + // Observations also fan out after a successful same-owner recheck. + // Retire only actual ownership loss; another explicit private-session + // acquisition must not close this still-current preference generation. + if (!capture.current()) { + retire(); + notify(); + } + }); + const opened = await openBrowserDatabase(cancel.signal); + if (!current()) { + if (opened.state === 'ready') closeBrowserDatabase(opened.owner); + return; + } + if (opened.state !== 'ready') { + state = { state: 'unavailable', reason: 'unavailable' }; + notify(); + return; + } + const acquired: Scope = { + owner: capture.owner, + database: opened.owner, + current: () => + current() && browserDatabaseState(opened.owner).state === 'ready' + }; + scope = acquired; + const read = await transaction(acquired, 'readonly', (stored) => ({ + ok: true, + value: stored + })); + if (!acquired.current()) return; + state = read.ok + ? { + state: 'ready', + owner: acquired.owner, + revision: read.value.row.revision, + peers: read.value.row.peers.slice() + } + : { state: 'unavailable', reason: read.reason }; + notify(); + } + async function change( + peer: string, + hidden: boolean, + original: Scope + ): Promise<PrivateBlockResult> { + if (!original.current()) return { status: 'stopped' }; + if (!navigator.locks?.request) return { status: 'unavailable' }; + try { + return await navigator.locks.request( + 'harvestcircle:owner:' + original.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock) => { + if (!lock) return { status: 'busy' as const }; + if (!original.current()) return { status: 'stopped' as const }; + const loaded = await transaction(original, 'readonly', (stored) => ({ + ok: true, + value: stored + })); + if (!original.current()) return { status: 'stopped' as const }; + if (!loaded.ok) { + state = { state: 'unavailable', reason: loaded.reason }; + notify(); + return { status: loaded.reason }; + } + const before = loaded.value; + if (before.row.peers.includes(peer) === hidden) { + // Another controller may have acknowledged this complete native + // row. Reconcile all preferences without another write/revision. + state = { + state: 'ready', + owner: original.owner, + revision: before.row.revision, + peers: before.row.peers.slice() + }; + notify(); + return { status: 'existing' as const }; + } + if ( + before.row.revision >= Number.MAX_SAFE_INTEGER || + (hidden && + before.row.peers.length >= + LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) + ) + return { status: 'capacity' as const }; + const next: Row = { + ...before.row, + revision: before.row.revision + 1, + peers: hidden + ? before.row.peers.concat(peer).sort() + : before.row.peers.filter((key) => key !== peer) + }; + const wire = JSON.stringify(next); + const written = await transaction<boolean>( + original, + 'readwrite', + (stored, tx) => { + if (stored.wire !== before.wire) return failed('conflict'); + tx.objectStore('local_preferences').put({ + owner: original.owner, + id: 'private_blocks', + wire + }); + return { ok: true, value: true }; + } + ); + if (!original.current()) return { status: 'stopped' as const }; + if (!written.ok) { + if ( + written.reason === 'conflict' || + written.reason === 'unknown_completion' + ) { + state = { state: 'unavailable', reason: written.reason }; + notify(); + } + return { status: written.reason }; + } + const readback = await transaction( + original, + 'readonly', + (stored) => ({ ok: true, value: stored }) + ); + if (!original.current()) return { status: 'stopped' as const }; + if (!readback.ok) { + state = { state: 'unavailable', reason: 'unknown_completion' }; + notify(); + return { status: 'unknown_completion' as const }; + } + if (readback.value.wire !== wire) { + state = { state: 'unavailable', reason: 'conflict' }; + notify(); + return { status: 'conflict' as const }; + } + state = { + state: 'ready', + owner: original.owner, + revision: next.revision, + peers: next.peers.slice() + }; + notify(); + return { status: 'saved' as const }; + } + ); + } catch { + if (!original.current()) return { status: 'stopped' }; + state = { state: 'unavailable', reason: 'unknown_completion' }; + notify(); + return { status: 'unknown_completion' }; + } + } + controllers.set(token, { + current: owned, + snapshot, + async mount() { + if (closed || mounted || typeof window === 'undefined') return; + mounted = true; + await refresh(); + }, + refresh, + async block(room, unlocked, review) { + const message = conversationSnapshot(room); + const cache = unlockedSessionOwnership(unlocked); + const original = scope; + if ( + !message || + !cache?.current() || + cache.owner !== capture.owner || + cache.session !== capture.session || + message.owner !== capture.owner || + !canonicalPublicKey(message.peer) || + review !== 'reviewed_local_private_block' || + !unlockedConversationCurrent(unlocked, room) + ) + return { status: 'invalid' }; + if (!original || state.state !== 'ready') + return { status: 'unavailable' }; + return change(message.peer, true, { + ...original, + current: () => + original.current() && + cache.current() && + unlockedConversationCurrent(unlocked, room) + }); + }, + async undo(peer, review) { + const key = canonicalPublicKey(peer); + if (!key || review !== 'reviewed_local_private_undo') + return { status: 'invalid' }; + const original = scope; + if (!original || state.state !== 'ready') + return { status: 'unavailable' }; + if (!state.peers.includes(key)) return { status: 'invalid' }; + return change(key, false, original); + }, + subscribe(listener) { + if (closed) return () => {}; + const id = Symbol(); + listeners.set(id, listener); + return () => { + listeners.delete(id); + }; + }, + close() { + if (closed) return; + closed = true; + retire(); + notify(); + listeners.clear(); + } + }); + return token; +} +export function localPrivateBlocksSnapshot( + token: LocalPrivateBlocks +): PrivateBlocksSnapshot { + return controllers.get(token)?.snapshot() ?? { state: 'unavailable' }; +} +export function localPrivatePeerAllowed( + token: LocalPrivateBlocks, + peer: string +): boolean { + const owned = controllers.get(token); + if (!owned) return false; + const state = owned.snapshot(); + return state.state === 'ready' && !state.peers.includes(peer); +} +export function mountLocalPrivateBlocks( + token: LocalPrivateBlocks +): Promise<void> { + return controllers.get(token)?.mount() ?? Promise.resolve(); +} +export function refreshLocalPrivateBlocks( + token: LocalPrivateBlocks +): Promise<void> { + return controllers.get(token)?.refresh() ?? Promise.resolve(); +} +export function subscribeLocalPrivateBlocks( + token: LocalPrivateBlocks, + listener: () => void +): () => void { + return controllers.get(token)?.subscribe(listener) ?? (() => {}); +} +export function blockLocalPrivatePeer( + token: LocalPrivateBlocks, + room: AdmittedConversation, + unlocked: UnlockedSession, + review: unknown +): Promise<PrivateBlockResult> { + return ( + controllers.get(token)?.block(room, unlocked, review) ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function undoLocalPrivatePeer( + token: LocalPrivateBlocks, + peer: unknown, + review: unknown +): Promise<PrivateBlockResult> { + return ( + controllers.get(token)?.undo(peer, review) ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function closeLocalPrivateBlocks(token: LocalPrivateBlocks): void { + controllers.get(token)?.close(); +} + +const identityControllers = new WeakMap<IdentitySession, LocalPrivateBlocks>(); +export function privateBlocksForIdentity( + identity: IdentitySession +): LocalPrivateBlocks | undefined { + const prior = identityControllers.get(identity); + if (prior && controllers.get(prior)?.current()) return prior; + if (prior) closeLocalPrivateBlocks(prior); + const token = capturePrivateBlocks(identity); + if (token) identityControllers.set(identity, token); + return token; +} +declare const viewBrand: unique symbol; +export type LocalPrivateBlocksView = Readonly<{ [viewBrand]: true }>; +const viewControllers = new WeakMap< + LocalPrivateBlocksView, + { + snapshot(): PrivateBlocksSnapshot; + mount(): Promise<void>; + subscribe(listener: () => void): () => void; + undo(peer: unknown, review: unknown): Promise<PrivateBlockResult>; + close(): void; + } +>(); +// Root construction stays SSR-pure. Original identity sessions share the same +// preference owner with Inbox controllers; route disposal cannot close another view. +export function createLocalPrivateBlocks( + context: IdentityViewContext +): LocalPrivateBlocksView { + return createPrivateBlocksView( + () => identityViewSession(context), + (listener) => { + let initial = true; + return subscribeIdentityView(context, () => { + if (initial) { + initial = false; + return; + } + listener(); + }); + } + ); +} +// Original identity-owned consumers use the same registry as the root context; +// a copied session still cannot acquire an account or preference controller. +export function createIdentityLocalPrivateBlocksView( + identity: IdentitySession +): LocalPrivateBlocksView { + return createPrivateBlocksView( + () => identity, + (listener) => subscribeIdentityInvalidation(identity, listener) + ); +} +function createPrivateBlocksView( + sessionOf: () => IdentitySession | undefined, + observe: (listener: () => void) => () => void +): LocalPrivateBlocksView { + const view = Object.freeze({}) as LocalPrivateBlocksView; + const listeners = new Map<symbol, () => void>(); + let token: LocalPrivateBlocks | undefined, + mounted = false, + closed = false; + let off = () => {}, + offToken = () => {}; + const notify = () => { + for (const listener of listeners.values()) { + try { + listener(); + } catch { + /* Isolate presentation. */ + } + } + }; + async function bind() { + offToken(); + offToken = () => {}; + const session = sessionOf(); + token = session ? privateBlocksForIdentity(session) : undefined; + if (token) { + const original = token; + offToken = subscribeLocalPrivateBlocks(original, notify); + await mountLocalPrivateBlocks(original); + } + if (!closed) notify(); + } + viewControllers.set(view, { + snapshot: () => + closed + ? { state: 'unavailable', reason: 'stopped' } + : token + ? localPrivateBlocksSnapshot(token) + : { state: 'guest' }, + async mount() { + if (closed || mounted || typeof window === 'undefined') return; + mounted = true; + off = observe(() => { + void bind(); + }); + await bind(); + }, + subscribe(listener) { + const key = Symbol(); + listeners.set(key, listener); + return () => { + listeners.delete(key); + }; + }, + undo: (peer, review) => + token + ? undoLocalPrivatePeer(token, peer, review) + : Promise.resolve({ status: 'invalid' }), + close() { + if (closed) return; + closed = true; + off(); + offToken(); + token = undefined; + notify(); + listeners.clear(); + } + }); + return view; +} +export function mountLocalPrivateBlocksView( + view: LocalPrivateBlocksView +): Promise<void> { + return viewControllers.get(view)?.mount() ?? Promise.resolve(); +} +export function localPrivateBlocksViewSnapshot( + view: LocalPrivateBlocksView +): PrivateBlocksSnapshot { + return viewControllers.get(view)?.snapshot() ?? { state: 'unavailable' }; +} +export function subscribeLocalPrivateBlocksView( + view: LocalPrivateBlocksView, + listener: () => void +): () => void { + return viewControllers.get(view)?.subscribe(listener) ?? (() => {}); +} +export function undoLocalPrivateBlocksView( + view: LocalPrivateBlocksView, + peer: unknown, + review: unknown +): Promise<PrivateBlockResult> { + return ( + viewControllers.get(view)?.undo(peer, review) ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function closeLocalPrivateBlocksView( + view: LocalPrivateBlocksView +): void { + viewControllers.get(view)?.close(); +} diff --git a/web/src/routes/+layout.svelte b/web/src/routes/+layout.svelte @@ -29,6 +29,14 @@ LOCAL_PUBLIC_HIDES_CONTEXT } from '../lib/persistence/local-public-hides.ts'; const identityContext = createIdentityViewContext(); + import { + createLocalPrivateBlocks, + mountLocalPrivateBlocksView, + closeLocalPrivateBlocksView, + LOCAL_PRIVATE_BLOCKS_CONTEXT + } from '../lib/persistence/local-private-blocks.ts'; + const privateBlocks = createLocalPrivateBlocks(identityContext); + setContext(LOCAL_PRIVATE_BLOCKS_CONTEXT, privateBlocks); const publicHides = createLocalPublicHides(identityContext); setContext(LOCAL_PUBLIC_HIDES_CONTEXT, publicHides); setContext(IDENTITY_VIEW_CONTEXT, identityContext); @@ -62,8 +70,10 @@ const runtime = mountPublicRuntime(publicContext); if (runtime) bindPublicRuntimeHides(runtime, publicHides); void mountLocalPublicHides(publicHides); + void mountLocalPrivateBlocksView(privateBlocks); return () => { closeLocalPublicHides(publicHides); + closeLocalPrivateBlocksView(privateBlocks); closePublicRuntime(publicContext); }; }); diff --git a/web/src/routes/privacy/+page.svelte b/web/src/routes/privacy/+page.svelte @@ -12,6 +12,50 @@ const hides = getContext<LocalPublicHides | undefined>( LOCAL_PUBLIC_HIDES_CONTEXT ); + import { + LOCAL_PRIVATE_BLOCKS_CONTEXT, + PRIVATE_BLOCK_DISCLOSURE, + localPrivateBlocksViewSnapshot, + subscribeLocalPrivateBlocksView, + undoLocalPrivateBlocksView, + type LocalPrivateBlocksView + } from '../../lib/persistence/local-private-blocks.ts'; + const blocks = getContext<LocalPrivateBlocksView | undefined>( + LOCAL_PRIVATE_BLOCKS_CONTEXT + ); + let privateSnapshot = $state.raw( + blocks + ? localPrivateBlocksViewSnapshot(blocks) + : { state: 'guest' as const } + ); + let privateNotice = $state<string | undefined>(); + let privateBusy = $state(false); + onMount(() => { + if (!blocks) return; + privateSnapshot = localPrivateBlocksViewSnapshot(blocks); + return subscribeLocalPrivateBlocksView(blocks, () => { + privateSnapshot = localPrivateBlocksViewSnapshot(blocks); + privateNotice = undefined; + }); + }); + async function undoBlock(peer: string) { + if (!blocks || privateBusy || privateSnapshot.state !== 'ready') return; + const owner = privateSnapshot.owner; + privateBusy = true; + const result = await undoLocalPrivateBlocksView( + blocks, + peer, + 'reviewed_local_private_undo' + ); + if (!alive) return; + privateBusy = false; + const current = localPrivateBlocksViewSnapshot(blocks); + if (current.state !== 'ready' || current.owner !== owner) return; + privateNotice = + result.status === 'saved' || result.status === 'existing' + ? 'Block undone. Eligible local views can be shown again. Another explicit bounded decryption action may be needed; Undo starts no message work.' + : 'Undo was not confirmed. Existing local data has not been reset.'; + } let snapshot = $state.raw( hides ? localPublicHidesSnapshot(hides) : { state: 'guest' as const } ); @@ -91,4 +135,36 @@ </p> {/if} {#if notice}<p role="status">{notice}</p>{/if} + <p>{PRIVATE_BLOCK_DISCLOSURE}</p> + <h2>Local private blocks</h2> + {#if privateSnapshot.state === 'ready'} + {#if privateSnapshot.peers.length} + <ul class="stack"> + {#each privateSnapshot.peers as peer (peer)} + <li class="stack"> + <p class="key">{peer}</p> + <Button + label="Undo block" + onclick={() => undoBlock(peer)} + disabled={privateBusy} + /> + </li> + {/each} + </ul> + {:else}<p>No people blocked for this account in this browser.</p>{/if} + {:else if privateSnapshot.state === 'guest'} + <p> + Connect to review account-local blocks. Guest browsing does not expose a + private inventory. + </p> + {:else if privateSnapshot.state === 'loading'} + <p>Checking local private block preferences…</p> + {:else} + <p class="notice"> + Local private preferences could not be checked. Previous blocks are + unconfirmed; private rendering and decryption continuation are + unavailable. Existing local data has not been reset. + </p> + {/if} + {#if privateNotice}<p role="status">{privateNotice}</p>{/if} </div> diff --git a/web/tests/e2e/capability-gate.spec.ts b/web/tests/e2e/capability-gate.spec.ts @@ -307,6 +307,7 @@ test.describe('actual shared inline capability component', () => { 'src/lib/runtime/identity-session.ts', 'src/lib/runtime/public-runtime.ts', 'src/lib/persistence/local-public-hides.ts', + 'src/lib/persistence/local-private-blocks.ts', 'src/lib/components/AppShell.svelte', 'src/lib/components/AccountGate.svelte', 'src/lib/components/InboxSetup.svelte', diff --git a/web/tests/e2e/harness/conversation-thread.ts b/web/tests/e2e/harness/conversation-thread.ts @@ -365,6 +365,7 @@ export async function renderFixture( readLockPending = undefined; } return { + identity: f.identity, holdReadLock, releaseRead, controller, diff --git a/web/tests/e2e/harness/decryption-queue.ts b/web/tests/e2e/harness/decryption-queue.ts @@ -7,6 +7,25 @@ import { expireDecryptionQueueWait, type DecryptionQueue } from '../../../src/lib/messaging/decryption-queue.ts'; +import { decryptionQueueConversations } from '../../../src/lib/messaging/decryption-queue.ts'; +import { + privateBlocksForIdentity, + mountLocalPrivateBlocks, + blockLocalPrivatePeer, + undoLocalPrivatePeer, + localPrivateBlocksSnapshot +} from '../../../src/lib/persistence/local-private-blocks.ts'; +import { + captureReceivedUnwrap, + unwrapReceivedEnvelope, + stopReceivedUnwrap, + type ReceivedUnwrap +} from '../../../src/lib/nostr/unwrap-admission.ts'; +import { + admitReceivedConversation, + conversationSnapshot +} from '../../../src/lib/messaging/admit-conversation.ts'; +import { acceptUnlockedConversation } from '../../../src/lib/messaging/unlocked-session.ts'; import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; import { createPrivateSession, @@ -147,10 +166,52 @@ export async function makeFixture(count = 21, unknownSender = false) { const originalReceived = JSON.stringify(await retained()), baseline = f.counts(); let queue: DecryptionQueue | undefined; + let warmReader: ReceivedUnwrap | undefined; + const blocks = privateBlocksForIdentity(f.identity); + if (!blocks) throw Error('original native preference owner unavailable'); + const preferences = blocks; return { ...f, stranger, disposable, + async persistInnerBlock() { + await mountLocalPrivateBlocks(preferences); + const rows = await listPrivateReceivedRecords(f.repository); + const record = + rows.ok && rows.value[0] && privateRecordIdentity(rows.value[0]); + if (!record) throw Error('original opaque ciphertext unavailable'); + warmReader = captureReceivedUnwrap( + f.repository, + f.identity, + record.id, + 'reviewed_inbox_unlock' + ); + if (!warmReader) throw Error('original nested reader unavailable'); + const result = await unwrapReceivedEnvelope(warmReader); + const room = + result.status === 'authenticated' && + (admitReceivedConversation(result.envelope, 'inbound') ?? + admitReceivedConversation(result.envelope, 'self_archive')); + if (!room || acceptUnlockedConversation(unlocked, room) !== 'added') + throw Error('original inner room unavailable'); + return blockLocalPrivatePeer( + preferences, + room, + unlocked, + 'reviewed_local_private_block' + ); + }, + undoInnerBlock: () => + undoLocalPrivatePeer( + preferences, + unknownSender ? stranger : f.peer, + 'reviewed_local_private_undo' + ), + preferences: () => localPrivateBlocksSnapshot(preferences), + visibleRooms: () => + queue + ? decryptionQueueConversations(queue).map(conversationSnapshot) + : [], capture(review: unknown = 'reviewed_inbox_unlock') { queue = captureDecryptionQueue( f.repository, @@ -255,6 +316,7 @@ export async function makeFixture(count = 21, unknownSender = false) { ); }, close() { + if (warmReader) stopReceivedUnwrap(warmReader); if (queue) stopDecryptionQueue(queue); closePrivateSession(session); f.close(); diff --git a/web/tests/e2e/harness/private-blocks-panel.svelte b/web/tests/e2e/harness/private-blocks-panel.svelte @@ -0,0 +1,5 @@ +<script lang="ts"> + import Privacy from '../../../src/routes/privacy/+page.svelte'; +</script> + +<div id="hcp123-preferences"><Privacy /></div> diff --git a/web/tests/e2e/harness/private-blocks.ts b/web/tests/e2e/harness/private-blocks.ts @@ -0,0 +1,517 @@ +import { getPublicKey } from 'applesauce-core/helpers'; +import { inboxSetupViewOwnership } from '../../../src/lib/messaging/inbox-setup-view.ts'; +import { + createPublicRuntimeContext, + mountPublicRuntime, + closePublicRuntime +} from '../../../src/lib/runtime/public-runtime.ts'; +import { + captureCitedProduct, + citedProductSnapshot, + closeCitedProduct +} from '../../../src/lib/messaging/cited-product.ts'; +import { + createReplyController, + updateReplyText, + replySnapshot, + replyText, + sendReply, + closeReplyController +} from '../../../src/lib/messaging/reply-controller.ts'; +// HC_TEST_ONLY_RELAY: original identity, signed nested crypto and native IDB. +import { mount, unmount } from 'svelte'; +import Panel from './private-blocks-panel.svelte'; +export { makeFixture as createQueueFixture } from './decryption-queue.ts'; +import { renderFixture, type Scenario } from './conversation-thread.ts'; +import { + privateBlocksForIdentity, + createIdentityLocalPrivateBlocksView, + mountLocalPrivateBlocksView, + localPrivateBlocksSnapshot, + refreshLocalPrivateBlocks, + blockLocalPrivatePeer, + closeLocalPrivateBlocksView, + closeLocalPrivateBlocks, + mountLocalPrivateBlocks, + LOCAL_PRIVATE_BLOCKS_CONTEXT +} from '../../../src/lib/persistence/local-private-blocks.ts'; +import { + blockInboxConversation, + inboxListSnapshot, + inboxReplyOwnership, + inboxMessageSnapshot, + markInboxConversationDisplayed +} from '../../../src/lib/messaging/inbox-view.ts'; +import { + openBrowserDatabase, + browserDatabaseTransaction, + closeBrowserDatabase +} from '../../../src/lib/persistence/database.ts'; +import type { AdmittedConversation } from '../../../src/lib/messaging/admit-conversation.ts'; +import type { UnlockedSession } from '../../../src/lib/messaging/unlocked-session.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +export async function createFixture(kind: Scenario = 'inbound') { + const thread = await renderFixture(kind); + const blocks = privateBlocksForIdentity(thread.identity); + if (!blocks) throw Error('original block owner unavailable'); + const token = blocks; + const view = createIdentityLocalPrivateBlocksView(thread.identity); + await mountLocalPrivateBlocksView(view); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') + throw Error('native fixture database unavailable'); + const database = opened.owner; + const target = document.createElement('div'); + document.body.append(target); + const panel = mount(Panel, { + target, + context: new Map([[LOCAL_PRIVATE_BLOCKS_CONTEXT, view]]) + }); + async function rows() { + const tx = browserDatabaseTransaction( + database, + ['local_preferences'], + 'readonly' + ); + const request = tx.objectStore('local_preferences').getAll(); + return await new Promise<unknown[]>((resolve, reject) => { + tx.addEventListener('complete', () => + resolve( + (request.result as { owner: string; id: string }[]).filter( + (row) => row.owner === thread.owner && row.id === 'private_blocks' + ) + ) + ); + tx.addEventListener('abort', () => + reject(Error('native preference scan aborted')) + ); + }); + } + async function corrupt() { + const tx = browserDatabaseTransaction( + database, + ['local_preferences'], + 'readwrite' + ); + tx.objectStore('local_preferences').put({ + owner: thread.owner, + id: 'private_blocks', + wire: 'corrupt' + }); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('native corrupt fixture aborted')) + ); + }); + await refreshLocalPrivateBlocks(token); + } + const block = () => + blockInboxConversation( + thread.controller, + thread.conversationId, + 'reviewed_local_private_block' + ); + async function foreignGeneration() { + const proof = inboxReplyOwnership( + thread.controller, + thread.conversationId, + thread.firstRumor + ); + if (!proof?.current()) throw Error('original genuine proof unavailable'); + const other = createIdentitySession(); + await connectIdentity(other); + await probeIdentityMessaging(other, 'reviewed_self_copy'); + const foreign = privateBlocksForIdentity(other); + if (!foreign) throw Error('second original identity unavailable'); + try { + await mountLocalPrivateBlocks(foreign); + return await blockLocalPrivatePeer( + foreign, + proof.room, + proof.unlocked, + 'reviewed_local_private_block' + ); + } finally { + closeLocalPrivateBlocks(foreign); + disconnectIdentity(other); + } + } + async function disposeSibling() { + const sibling = createIdentityLocalPrivateBlocksView(thread.identity); + await mountLocalPrivateBlocksView(sibling); + closeLocalPrivateBlocksView(sibling); + return localPrivateBlocksSnapshot(token); + } + let releaseInventory: (() => void) | undefined; + function holdInventory() { + const native = Reflect.get<IDBTransaction, 'addEventListener'>( + IDBTransaction.prototype, + 'addEventListener' + ); + let held = false; + IDBTransaction.prototype.addEventListener = function ( + type: string, + listener: EventListenerOrEventListenerObject | null, + options?: boolean | AddEventListenerOptions + ) { + if ( + !held && + type === 'complete' && + this.mode === 'readonly' && + this.objectStoreNames.length === 1 && + this.objectStoreNames.contains('received_envelopes') && + listener + ) { + held = true; + native.call( + this, + type, + (event: Event) => { + releaseInventory = () => { + releaseInventory = undefined; + if (typeof listener === 'function') listener.call(this, event); + else listener.handleEvent(event); + }; + }, + options + ); + IDBTransaction.prototype.addEventListener = native; + } else if (listener) native.call(this, type, listener, options); + }; + } + async function abortWrite() { + const prototype = IDBObjectStore.prototype, + original = Reflect.get<IDBObjectStore, 'put'>(prototype, 'put'); + prototype.put = function (value: unknown, key?: IDBValidKey) { + const request = original.call(this, value, key); + if (this.name === 'local_preferences') this.transaction.abort(); + return request; + }; + try { + return await block(); + } finally { + prototype.put = original; + } + } + async function failReadback() { + const prototype = IDBDatabase.prototype, + original = Reflect.get<IDBDatabase, 'transaction'>( + prototype, + 'transaction' + ); + let written = false; + prototype.transaction = function ( + storeNames: string | string[], + mode?: IDBTransactionMode, + options?: IDBTransactionOptions + ) { + const names = typeof storeNames === 'string' ? [storeNames] : storeNames; + if (names.includes('local_preferences') && mode === 'readonly' && written) + throw Error('actual readback unavailable'); + const tx = original.call(this, storeNames, mode, options); + if (names.includes('local_preferences') && mode === 'readwrite') + tx.addEventListener('complete', () => { + written = true; + }); + return tx; + }; + try { + return await block(); + } finally { + prototype.transaction = original; + } + } + async function writePreferences(peers: readonly string[], revision: number) { + const wire = JSON.stringify({ + schema: 1, + family: 'private_blocks', + owner: thread.owner, + id: 'private_blocks', + revision, + peers: peers.slice().sort() + }); + const tx = browserDatabaseTransaction( + database, + ['local_preferences'], + 'readwrite' + ); + tx.objectStore('local_preferences').put({ + owner: thread.owner, + id: 'private_blocks', + wire + }); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('actual competing preference write aborted')) + ); + }); + return wire; + } + const unrelatedPeer = getPublicKey(new Uint8Array(32).fill(88)); + async function matchingNativeRow() { + const wire = await writePreferences([thread.peer, unrelatedPeer], 17); + const before = await rows(); + const prototype = IDBDatabase.prototype; + const native = Reflect.get<IDBDatabase, 'transaction'>( + prototype, + 'transaction' + ); + let writes = 0; + prototype.transaction = function ( + names: string | string[], + mode?: IDBTransactionMode, + options?: IDBTransactionOptions + ) { + const stores = typeof names === 'string' ? [names] : names; + if (mode === 'readwrite' && stores.includes('local_preferences')) + writes++; + return native.call(this, names, mode, options); + }; + try { + const result = await block(); + return { + wire, + before, + after: await rows(), + result, + snapshot: localPrivateBlocksSnapshot(token), + unrelatedPeer, + writes + }; + } finally { + prototype.transaction = native; + } + } + async function competingNativeRow() { + const prototype = IDBDatabase.prototype; + const native = Reflect.get<IDBDatabase, 'transaction'>( + prototype, + 'transaction' + ); + let intercepted = false, + completion: Promise<string> | undefined; + prototype.transaction = function ( + names: string | string[], + mode?: IDBTransactionMode, + options?: IDBTransactionOptions + ) { + const stores = typeof names === 'string' ? [names] : names; + if ( + !intercepted && + mode === 'readwrite' && + stores.includes('local_preferences') + ) { + intercepted = true; + // Queue a genuine independent native write before the producer's CAS + // transaction. The actual IndexedDB scheduler orders both transactions. + completion = writePreferences([unrelatedPeer], 19); + } + return native.call(this, names, mode, options); + }; + try { + const result = await block(); + await completion; + if (!intercepted) throw Error('actual CAS seam was not reached'); + return { + result, + rows: await rows(), + snapshot: localPrivateBlocksSnapshot(token), + unrelatedPeer + }; + } finally { + prototype.transaction = native; + } + } + async function reloadOwners() { + thread.logout(); + const snapshots = []; + for (const changed of [false, true, false]) { + thread.mode(changed ? 'changed_key' : 'normal'); + const identity = createIdentitySession(); + await connectIdentity(identity); + const fresh = privateBlocksForIdentity(identity); + if (!fresh) throw Error('new original observed owner unavailable'); + const before = thread.delta(); + try { + await mountLocalPrivateBlocks(fresh); + snapshots.push({ + snapshot: localPrivateBlocksSnapshot(fresh), + before, + after: thread.delta() + }); + } finally { + closeLocalPrivateBlocks(fresh); + disconnectIdentity(identity); + } + } + thread.mode('normal'); + return { + snapshots, + old: localPrivateBlocksSnapshot(token), + rows: await rows() + }; + } + let captured: + | (() => Promise<{ + current: boolean; + citation: unknown; + message: unknown; + reply: unknown; + text: unknown; + send: Awaited<ReturnType<typeof sendReply>>; + displayed: boolean; + }>) + | undefined, + closeCaptured = () => {}; + function captureActions() { + if (captured) throw Error('original handles already captured'); + const message = thread + .thread() + .messages.find((row) => + row.citations.some((ref) => ref.naddr === thread.carrots) + ); + if (!message) throw Error('actual authenticated cited message unavailable'); + const proof = inboxReplyOwnership( + thread.controller, + thread.conversationId, + message.data.rumorId + ); + const setup = proof && inboxSetupViewOwnership(proof.setup); + if (!proof?.current() || !setup) + throw Error('original current ownership unavailable'); + const context = createPublicRuntimeContext(); + const runtime = mountPublicRuntime(context, setup.policy); + if (!runtime) throw Error('original public runtime unavailable'); + const citation = captureCitedProduct( + thread.controller, + thread.conversationId, + message.data.rumorId, + thread.carrots, + runtime, + 'reviewed_product_citation' + ); + const reply = createReplyController( + thread.controller, + thread.conversationId, + message.data.rumorId + ); + if (!citation || !reply) { + closePublicRuntime(context); + throw Error('original actions unavailable'); + } + if ( + !updateReplyText( + reply, + 'HCP123_OLD_REPLY_MEMORY_ONLY', + 'reviewed_private_text' + ) + ) + throw Error('original reply text unavailable'); + closeCaptured = () => { + closeCitedProduct(citation); + closeReplyController(reply); + closePublicRuntime(context); + }; + captured = async () => ({ + current: proof.current(), + citation: citedProductSnapshot(citation), + message: inboxMessageSnapshot( + thread.controller, + thread.conversationId, + message.data.rumorId + ), + reply: replySnapshot(reply), + text: replyText(reply), + send: await sendReply(reply, 'reviewed_reply_send'), + displayed: await markInboxConversationDisplayed( + thread.controller, + thread.conversationId, + [message.data.rumorId], + 'reviewed_displayed_conversation' + ) + }); + return { + current: proof.current(), + citation: citedProductSnapshot(citation), + text: replyText(reply) + }; + } + async function failLockCompletion() { + const locks = navigator.locks; + const native = Reflect.get<LockManager, 'request'>(locks, 'request'); + const descriptor = Object.getOwnPropertyDescriptor(locks, 'request'); + Object.defineProperty(locks, 'request', { + configurable: true, + value: async (...args: unknown[]) => { + // Execute the actual owner WebLock and original native write/readback; + // then lose the caller's completion channel, without fabricating a row. + await Reflect.apply(native, locks, args); + throw Error('controlled owner-lock completion channel unavailable'); + } + }); + try { + return await block(); + } finally { + if (descriptor) Object.defineProperty(locks, 'request', descriptor); + else Reflect.deleteProperty(locks, 'request'); + } + } + return { + ...thread, + rows, + corrupt, + abortWrite, + failReadback, + block, + foreignGeneration, + matchingNativeRow, + competingNativeRow, + reloadOwners, + captureActions, + failLockCompletion, + capturedActions: () => { + if (!captured) throw Error('original handles not captured'); + return captured(); + }, + disposeSibling, + waitOwner: () => + navigator.locks.request('harvestcircle:owner:' + thread.owner, () => + Promise.resolve() + ), + holdInventory, + inventoryHeld: () => !!releaseInventory, + releaseInventory: () => releaseInventory?.(), + preferences: () => localPrivateBlocksSnapshot(token), + list: () => inboxListSnapshot(thread.controller), + refresh: () => refreshLocalPrivateBlocks(token), + fake: () => { + const room = inboxReplyOwnership( + thread.controller, + thread.conversationId, + thread.firstRumor + ); + return blockLocalPrivatePeer( + token, + { ...(room?.room ?? {}) } as AdmittedConversation, + room?.unlocked ?? ({} as UnlockedSession), + 'reviewed_local_private_block' + ); + }, + async close() { + closeCaptured(); + releaseInventory?.(); + await unmount(panel); + target.remove(); + closeLocalPrivateBlocksView(view); + closeBrowserDatabase(database); + await thread.close(); + } + }; +} diff --git a/web/tests/e2e/private-blocks.spec.ts b/web/tests/e2e/private-blocks.spec.ts @@ -0,0 +1,662 @@ +import { expect, test, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { svelte } from '@sveltejs/vite-plugin-svelte'; +import { fileURLToPath } from 'node:url'; +import { once } from 'node:events'; +import { WebSocketServer } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/private-blocks.ts'; +declare global { + interface Window { + hcp123: typeof Fixture; + hcp123Fixture: Awaited<ReturnType<typeof Fixture.createFixture>>; + hcp123Pending?: Promise<boolean>; + hcp123Queue?: Awaited<ReturnType<typeof Fixture.createQueueFixture>>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string | undefined; +let holdRequests = false; +const heldReplies: (() => void)[] = []; +let events: unknown[][] = [], + queries: unknown[][] = []; +test.beforeAll(async () => { + server = await createStaticHarness(); + sockets = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 262144 + }); + await once(sockets, 'listening'); + const address = sockets.address(); + if (!address || typeof address === 'string') + throw Error('loopback unavailable'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket) => + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes + : Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.from(bytes); + const frame = JSON.parse(raw.toString()) as unknown[]; + if (frame[0] === 'EVENT' || frame[0] === 'AUTH') events.push(frame); + if (frame[0] === 'REQ') { + queries.push(frame); + const finish = () => { + if (socket.readyState === 1) + socket.send(JSON.stringify(['EOSE', frame[1]])); + }; + if (holdRequests) heldReplies.push(finish); + else finish(); + } + }) + ); +}); +test.afterAll(async () => { + for (const socket of sockets?.clients ?? []) socket.terminate(); + if (sockets) + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server?.close(); +}); +test.beforeEach(async ({ page }) => { + events = []; + queries = []; + holdRequests = false; + heldReplies.length = 0; + await page.addInitScript((endpoint) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + if ( + ![ + 'wss://peer.example.org', + 'wss://archive.example.org', + 'wss://discovery.example.org' + ].includes(new URL(String(url)).origin) + ) + throw Error('no live relay authorization'); + super(endpoint, protocols); + } + }; + }, endpoint); +}); +test.afterEach(async ({ page }) => { + holdRequests = false; + for (const finish of heldReplies.splice(0)) finish(); + if (!page.isClosed()) + await page.evaluate(async () => { + window.hcp123Fixture?.mode('normal'); + window.hcp123Fixture?.settle(); + window.hcp123Fixture?.releaseInventory(); + window.hcp123Queue?.mode('normal'); + window.hcp123Queue?.settle(); + await window.hcp123Pending; + await window.hcp123Fixture?.close(); + window.hcp123Queue?.close(); + }); +}); +async function start( + page: Page, + scenario: 'inbound' | 'backfill' | 'contexts' = 'inbound' +) { + await loadFixtureScripts(page); + await page.evaluate(async (scenario) => { + window.hcp123Fixture = await window.hcp123.createFixture(scenario); + }, scenario); +} +async function loadFixtureScripts(page: Page) { + await page.goto(server.url + '/privacy'); + if (!bundle) { + const built = await build({ + configFile: false, + logLevel: 'silent', + plugins: [svelte({ configFile: false })], + resolve: { + conditions: ['browser'], + alias: { + '$app/navigation': fileURLToPath( + new URL('./harness/conversation-thread.ts', import.meta.url) + ) + } + }, + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/private-blocks.ts', import.meta.url) + ), + name: 'hcp123', + formats: ['iife'] + } + } + }); + const result = Array.isArray(built) ? built[0] : built; + if (!('output' in result)) throw Error('fixture bundle unavailable'); + const chunks = result.output.filter((row) => row.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; + } + await page.addScriptTag({ content: bundle }); +} +async function unlocked(page: Page) { + await page.evaluate(() => window.hcp123Fixture.checkSetup()); + const result = await page.evaluate(async () => { + const success = await window.hcp123Fixture.unlock(); + const { state, reason, queued, count } = window.hcp123Fixture.snapshot(); + const preferences = window.hcp123Fixture.preferences(); + return { + success, + diagnostic: { + state, + reason, + queued, + count, + preferences: preferences.state + } + }; + }); + expect(result.success, JSON.stringify(result.diagnostic)).toBe(true); + await expect(page.locator('[data-message-id]')).not.toHaveCount(0); + // Wait for the original displayed-read transaction to release its native + // owner lock before explicitly testing another independent owner mutation. + const displayed = await page.locator('[data-message-id]').count(); + await expect + .poll(async () => { + const native = await page.evaluate(() => window.hcp123Fixture.native()); + return native.received.filter( + (row) => + (JSON.parse((row as { wire: string }).wire) as { read: unknown }) + .read !== null + ).length; + }) + .toBe(displayed); + await page.evaluate(() => window.hcp123Fixture.waitOwner()); +} +test('HCP123 SSR privacy discloses reversible local blocking without account inventory', async ({ + page +}) => { + await page.goto(server.url + '/privacy'); + expect(await page.locator('main').innerText()).toContain( + 'Blocking a person is local' + ); + await expect(page.getByRole('button', { name: 'Undo block' })).toHaveCount(0); + expect(events).toEqual([]); + expect(queries).toEqual([]); +}); +test('HCP123 genuine authenticated inner peer block removes thread and list previews while retaining evidence', async ({ + page +}) => { + await start(page); + await unlocked(page); + const before = await page.evaluate(() => window.hcp123Fixture.native()); + await page + .getByText('Identity and conversation options', { exact: true }) + .click(); + await page.getByRole('button', { name: 'Block person', exact: true }).click(); + await expect( + page.getByText(/Blocking hides messages and previews/) + ).toBeVisible(); + await page + .getByRole('button', { name: 'Confirm local block', exact: true }) + .click(); + await expect(page.locator('[data-message-id]')).toHaveCount(0); + expect(await page.evaluate(() => window.hcp123Fixture.list())).toMatchObject({ + requests: [], + conversations: [] + }); + expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual( + before + ); + expect( + await page.evaluate(() => window.hcp123Fixture.preferences()) + ).toMatchObject({ + state: 'ready', + peers: [await page.evaluate(() => window.hcp123Fixture.peer)] + }); + expect(events).toEqual([]); + expect(queries).toEqual([]); +}); +test('HCP123 Privacy Undo starts no decrypt signer or relay work and restores eligible cached projection', async ({ + page +}) => { + await start(page); + await unlocked(page); + expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({ + status: 'saved' + }); + const before = await page.evaluate(() => window.hcp123Fixture.delta()); + await page.getByRole('button', { name: 'Undo block', exact: true }).click(); + await expect(page.locator('[data-message-id]')).toHaveCount(1); + expect(await page.evaluate(() => window.hcp123Fixture.delta())).toEqual( + before + ); + expect(events).toEqual([]); + expect(queries).toEqual([]); +}); +test('HCP123 copied room or displayed peer cannot authorize a private block', async ({ + page +}) => { + await start(page); + await unlocked(page); + expect(await page.evaluate(() => window.hcp123Fixture.fake())).toEqual({ + status: 'invalid' + }); + expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual([]); + await expect(page.locator('[data-message-id]')).toHaveCount(1); +}); +test('HCP123 corrupt preferences fail closed without resetting stored facts', async ({ + page +}) => { + await start(page); + await unlocked(page); + await page.evaluate(() => window.hcp123Fixture.corrupt()); + await expect(page.locator('[data-message-id]')).toHaveCount(0); + expect(await page.evaluate(() => window.hcp123Fixture.rows())).toHaveLength( + 1 + ); + expect(await page.evaluate(() => window.hcp123Fixture.next())).toBe(false); + await expect( + page.getByRole('button', { name: 'Undo block', exact: true }) + ).toHaveCount(0); +}); +test('HCP123 actual native abort gives no Saved or enforced block', async ({ + page +}) => { + await start(page); + await unlocked(page); + expect(await page.evaluate(() => window.hcp123Fixture.abortWrite())).toEqual({ + status: 'aborted' + }); + expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual([]); + await expect(page.locator('[data-message-id]')).toHaveCount(1); +}); +test('HCP123 failed readback after completed native write is unknown until explicit reconciliation', async ({ + page +}) => { + await start(page); + await unlocked(page); + expect( + await page.evaluate(() => window.hcp123Fixture.failReadback()) + ).toEqual({ status: 'unknown_completion' }); + expect(await page.evaluate(() => window.hcp123Fixture.rows())).toHaveLength( + 1 + ); + await page.evaluate(() => window.hcp123Fixture.refresh()); + await expect(page.locator('[data-message-id]')).toHaveCount(0); +}); +test('HCP123 logout retires current private inventory without deleting preference or encrypted evidence', async ({ + page +}) => { + await start(page); + await unlocked(page); + await page.evaluate(() => window.hcp123Fixture.block()); + const settled = await page.evaluate(async () => ({ + rows: await window.hcp123Fixture.rows(), + native: await window.hcp123Fixture.native() + })); + await page.evaluate(() => window.hcp123Fixture.logout()); + expect( + await page.evaluate(() => window.hcp123Fixture.preferences()) + ).toMatchObject({ state: 'unavailable' }); + expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual( + settled.rows + ); + expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual( + settled.native + ); + await expect( + page.getByRole('button', { name: 'Undo block', exact: true }) + ).toHaveCount(0); +}); +test('HCP123 live block fences an already pending authentic decrypt and subsequent automatic continuation', async ({ + page +}) => { + await start(page, 'backfill'); + await unlocked(page); + await page.evaluate(() => { + window.hcp123Fixture.mode('hold_decrypt'); + window.hcp123Pending = window.hcp123Fixture.next(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp123Fixture.pending())) + .toBe(true); + const before = await page.evaluate(() => window.hcp123Fixture.native()); + expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({ + status: 'saved' + }); + await page.evaluate(() => { + window.hcp123Fixture.mode('normal'); + window.hcp123Fixture.settle(); + }); + await page.evaluate(() => window.hcp123Pending); + await expect(page.locator('[data-message-id]')).toHaveCount(0); + expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual( + before + ); + expect(events).toEqual([]); + expect(queries).toEqual([]); +}); +for (const width of [320, 1024]) + test(`HCP123 ${width}px consequences and Undo remain operable`, async ({ + page + }) => { + await page.setViewportSize({ width, height: 800 }); + await start(page); + await unlocked(page); + await page + .getByText('Identity and conversation options', { exact: true }) + .click(); + await page + .getByRole('button', { name: 'Block person', exact: true }) + .click(); + await page + .getByRole('button', { name: 'Confirm local block', exact: true }) + .click(); + await expect( + page.getByRole('button', { name: 'Undo block', exact: true }) + ).toBeVisible(); + expect( + await page.evaluate( + () => document.documentElement.scrollWidth > window.innerWidth + ) + ).toBe(false); + }); + +test('HCP123 a second genuine same-owner generation cannot import the original room custody', async ({ + page +}) => { + await start(page); + await unlocked(page); + expect( + await page.evaluate(() => window.hcp123Fixture.foreignGeneration()) + ).toEqual({ status: 'invalid' }); + expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual([]); +}); +test('HCP123 disposing one genuine preference view preserves its sibling and current Inbox owner', async ({ + page +}) => { + await start(page); + await unlocked(page); + expect( + await page.evaluate(() => window.hcp123Fixture.disposeSibling()) + ).toMatchObject({ state: 'ready', revision: 0, peers: [] }); + await expect(page.locator('[data-message-id]')).toHaveCount(1); + expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({ + status: 'saved' + }); +}); +test('HCP123 block acknowledged during native inventory loading starts no subsequent unwrap', async ({ + page +}) => { + await start(page, 'backfill'); + await unlocked(page); + const before = await page.evaluate(() => window.hcp123Fixture.delta()); + await page.evaluate(() => { + window.hcp123Fixture.holdInventory(); + window.hcp123Pending = window.hcp123Fixture.next(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp123Fixture.inventoryHeld())) + .toBe(true); + expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({ + status: 'saved' + }); + await page.evaluate(() => window.hcp123Fixture.releaseInventory()); + expect(await page.evaluate(() => window.hcp123Pending)).toBe(false); + expect(await page.evaluate(() => window.hcp123Fixture.delta())).toEqual( + before + ); + await expect(page.locator('[data-message-id]')).toHaveCount(0); +}); +test('HCP123 persisted authenticated unknown peer block still charges twenty opaque envelopes and Undo starts no work', async ({ + page +}) => { + await loadFixtureScripts(page); + const result = await page.evaluate(async () => { + const f = await window.hcp123.createQueueFixture(21, true); + window.hcp123Queue = f; + const saved = await f.persistInnerBlock(); + const before = f.delta(); + const captured = f.capture(); + const batch = await f.batch(); + const after = f.delta(); + const snapshot = f.snapshot(); + const unchanged = await f.encryptedUnchanged(); + const publicContains = await f.publicContains(); + const rooms = f.visibleRooms(); + const undo = await f.undoInnerBlock(); + const afterUndo = f.delta(); + const next = await f.batch(); + const afterNext = f.delta(); + return { + saved, + captured, + batch, + before, + after, + snapshot, + unchanged, + publicContains, + rooms, + undo, + afterUndo, + next, + afterNext + }; + }); + expect(result.saved).toEqual({ status: 'saved' }); + expect(result.captured).toBe(true); + expect(result.batch).toBe(true); + expect(result.snapshot).toMatchObject({ + attempted: 20, + blocked: 20, + admitted: 0, + queued: 1, + state: 'needs_action' + }); + expect(result.after.decrypts - result.before.decrypts).toBe(40); + expect(result.after.signs - result.before.signs).toBe(0); + expect(result.after.encrypts - result.before.encrypts).toBe(0); + expect(result.rooms).toEqual([]); + expect(result.unchanged).toBe(true); + expect(result.publicContains).toBe(false); + expect(result.undo).toEqual({ status: 'saved' }); + expect(result.afterUndo).toEqual(result.after); + expect(result.next).toBe(true); + expect(result.afterNext.decrypts - result.afterUndo.decrypts).toBe(40); + expect(events).toEqual([]); + expect(queries).toEqual([]); +}); + +test('HCP123 actual owner lock contention acknowledges no block or native write', async ({ + page +}) => { + await start(page); + await unlocked(page); + const before = await page.evaluate(() => window.hcp123Fixture.native()); + await page.evaluate(() => window.hcp123Fixture.holdReadLock()); + expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({ + status: 'busy' + }); + expect( + await page.evaluate(() => window.hcp123Fixture.preferences()) + ).toMatchObject({ state: 'ready', revision: 0, peers: [] }); + expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual([]); + expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual( + before + ); + await expect(page.locator('[data-message-id]')).toHaveCount(1); + await page.evaluate(() => window.hcp123Fixture.releaseRead()); +}); +test('HCP123 existing acknowledged native peer row reconciles the whole revision without another write', async ({ + page +}) => { + await start(page); + await unlocked(page); + const result = await page.evaluate(() => + window.hcp123Fixture.matchingNativeRow() + ); + expect(result.result).toEqual({ status: 'existing' }); + expect(result.after).toEqual(result.before); + expect(result.writes).toBe(0); + expect(result.snapshot).toMatchObject({ state: 'ready', revision: 17 }); + if (result.snapshot.state !== 'ready') + throw Error('no current native preferences'); + expect(result.snapshot.peers).toEqual( + [ + await page.evaluate(() => window.hcp123Fixture.peer), + result.unrelatedPeer + ].sort() + ); + await expect(page.locator('[data-message-id]')).toHaveCount(0); + expect(await page.evaluate(() => window.hcp123Fixture.list())).toMatchObject({ + requests: [], + conversations: [] + }); +}); +test('HCP123 genuine competing native transaction fails full-wire CAS and preserves unrelated peer facts', async ({ + page +}) => { + await start(page); + await unlocked(page); + const result = await page.evaluate(() => + window.hcp123Fixture.competingNativeRow() + ); + expect(result.result).toEqual({ status: 'conflict' }); + expect(result.rows).toHaveLength(1); + const wire = JSON.parse((result.rows[0] as { wire: string }).wire) as { + revision: number; + peers: string[]; + }; + expect(wire).toMatchObject({ revision: 19, peers: [result.unrelatedPeer] }); + expect(result.snapshot).toMatchObject({ + state: 'unavailable', + reason: 'conflict' + }); + await expect(page.locator('[data-message-id]')).toHaveCount(0); + const counts = await page.evaluate(() => window.hcp123Fixture.delta()); + expect(await page.evaluate(() => window.hcp123Fixture.next())).toBe(false); + expect(await page.evaluate(() => window.hcp123Fixture.delta())).toEqual( + counts + ); + await page.evaluate(() => window.hcp123Fixture.refresh()); + expect( + await page.evaluate(() => window.hcp123Fixture.preferences()) + ).toMatchObject({ + state: 'ready', + revision: 19, + peers: [result.unrelatedPeer] + }); +}); +test('HCP123 acknowledged block reloads for the original account and stays isolated from another observed owner', async ({ + page +}) => { + await start(page); + await unlocked(page); + expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({ + status: 'saved' + }); + const native = await page.evaluate(() => window.hcp123Fixture.native()); + const rows = await page.evaluate(() => window.hcp123Fixture.rows()); + const result = await page.evaluate(() => window.hcp123Fixture.reloadOwners()); + expect(result.snapshots).toHaveLength(3); + const [same, other, returned] = result.snapshots; + if (!same || !other || !returned) + throw Error('actual owner reload sequence incomplete'); + expect(same.snapshot).toMatchObject({ + state: 'ready', + owner: await page.evaluate(() => window.hcp123Fixture.owner), + revision: 1, + peers: [await page.evaluate(() => window.hcp123Fixture.peer)] + }); + expect(other.snapshot).toMatchObject({ + state: 'ready', + owner: await page.evaluate(() => window.hcp123Fixture.peer), + revision: 0, + peers: [] + }); + expect(returned.snapshot).toEqual(same.snapshot); + for (const row of result.snapshots) expect(row.after).toEqual(row.before); + expect(result.old).toMatchObject({ state: 'unavailable', reason: 'stopped' }); + expect(result.rows).toEqual(rows); + expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual( + native + ); +}); +test('HCP123 block retires captured genuine reply citation and read actions before late citation completion', async ({ + page +}) => { + await start(page, 'contexts'); + await unlocked(page); + holdRequests = true; + const before = await page.evaluate(() => + window.hcp123Fixture.captureActions() + ); + expect(before.current).toBe(true); + expect(before.citation).toBeDefined(); + expect(before.text).toBe('HCP123_OLD_REPLY_MEMORY_ONLY'); + await expect.poll(() => queries.length).toBeGreaterThan(0); + expect(await page.evaluate(() => window.hcp123Fixture.block())).toEqual({ + status: 'saved' + }); + const native = await page.evaluate(() => window.hcp123Fixture.native()); + const counts = await page.evaluate(() => window.hcp123Fixture.delta()); + const old = await page.evaluate(() => window.hcp123Fixture.capturedActions()); + expect(old).toMatchObject({ + current: false, + send: { status: 'stopped' }, + displayed: false + }); + expect(old.citation).toBeUndefined(); + expect(old.message).toBeUndefined(); + expect(old.reply).toBeUndefined(); + expect(old.text).toBeUndefined(); + const queryCount = queries.length; + holdRequests = false; + for (const release of heldReplies.splice(0)) release(); + expect( + await page.evaluate(() => window.hcp123Fixture.capturedActions()) + ).toEqual(old); + expect(await page.evaluate(() => window.hcp123Fixture.native())).toEqual( + native + ); + expect(await page.evaluate(() => window.hcp123Fixture.delta())).toEqual( + counts + ); + expect(queries).toHaveLength(queryCount); + expect(events).toEqual([]); + await expect( + page.getByText('HCP123_OLD_REPLY_MEMORY_ONLY', { exact: true }) + ).toHaveCount(0); +}); +test('HCP123 lost completion channel after genuine native block fails closed until explicit reconciliation', async ({ + page +}) => { + await start(page); + await unlocked(page); + expect( + await page.evaluate(() => window.hcp123Fixture.failLockCompletion()) + ).toEqual({ status: 'unknown_completion' }); + const rows = await page.evaluate(() => window.hcp123Fixture.rows()); + expect(rows).toHaveLength(1); + expect(JSON.parse((rows[0] as { wire: string }).wire)).toMatchObject({ + revision: 1, + peers: [await page.evaluate(() => window.hcp123Fixture.peer)] + }); + expect( + await page.evaluate(() => window.hcp123Fixture.preferences()) + ).toMatchObject({ state: 'unavailable', reason: 'unknown_completion' }); + await page.evaluate(() => window.hcp123Fixture.refresh()); + expect( + await page.evaluate(() => window.hcp123Fixture.preferences()) + ).toMatchObject({ + state: 'ready', + revision: 1, + peers: [await page.evaluate(() => window.hcp123Fixture.peer)] + }); + expect(await page.evaluate(() => window.hcp123Fixture.rows())).toEqual(rows); +}); diff --git a/web/tests/integration/loopback.test.ts b/web/tests/integration/loopback.test.ts @@ -99,6 +99,11 @@ await test('navigation fallback serves actual separate output and preserves miss const privacy = prerendered.get('/privacy'); assert.ok(privacy); assert.match(privacy, /Hiding a publisher is local/); + assert.match(privacy, /Blocking a person is local/); + assert.match( + privacy, + /Private messages have no forward secrecy or post-compromise security\./ + ); assert.match( privacy, /does not delete listings, remote copies or your publication receipts/ @@ -107,7 +112,7 @@ await test('navigation fallback serves actual separate output and preserves miss privacy, /Guest browsing\s+does not expose an account inventory/ ); - assert.doesNotMatch(privacy, /Undo hide|[0-9a-f]{64}/); + assert.doesNotMatch(privacy, /Undo hide|Undo block|[0-9a-f]{64}/); const document = { accept: 'text/html', 'sec-fetch-dest': 'document' }; const server = await createStaticHarness(); try { diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -186,6 +186,44 @@ import { auditOutput } from '../../tools/check-output.mjs'; '1766ce7a732264f24a82b3a7a1e999a3496cc57af8ce3f9624a32c8c37527454' } }, + ...{ + 'src/lib/messaging/decryption-queue.ts': { + source: + "import { planDecryptBatch } from './inbox-state.ts';\nimport { canonicalPublicKey } from '../contracts/public-key.ts';\nimport { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts';\nimport {\n privateSessionOwnership,\n subscribePrivateSessionClose,\n type PrivateSession\n} from '../runtime/private-session.ts';\nimport {\n identityMessagingOwnership,\n type IdentitySession\n} from '../runtime/identity-session.ts';\nimport {\n getPrivateVisibilityScope,\n privateVisibilitySnapshot\n} from '../runtime/dispose.ts';\nimport {\n listPrivateReceivedRecords,\n type PrivateStorageRepository\n} from '../persistence/private-storage.ts';\nimport { privateRecordIdentity } from '../persistence/private-records.ts';\nimport {\n captureReceivedUnwrap,\n unwrapReceivedEnvelope,\n stopReceivedUnwrap,\n expireReceivedUnwrapWait,\n type ReceivedUnwrap\n} from '../nostr/unwrap-admission.ts';\nimport {\n admitReceivedConversation,\n conversationSnapshot,\n type AdmittedConversation\n} from './admit-conversation.ts';\nimport {\n unlockedSessionOwnership,\n subscribeUnlockedSessionClose,\n acceptUnlockedConversation,\n type UnlockedSession\n} from './unlocked-session.ts';\ndeclare const queueBrand: unique symbol;\nexport type DecryptionQueue = Readonly<{ [queueBrand]: true }>;\ntype View = Readonly<{\n state: string;\n reason: string | null;\n queued: number;\n attempted: number;\n blocked: number;\n admitted: number;\n invalid: number;\n busy: boolean;\n}>;\ntype Controller = {\n refresh(): Promise<boolean>;\n run(review: unknown, blocked: readonly string[]): Promise<boolean>;\n snapshot(): View;\n rooms(): readonly AdmittedConversation[];\n stop(): void;\n expire(): void;\n};\nconst controllers = new WeakMap<DecryptionQueue, Controller>(),\n sessions = new WeakMap<PrivateSession, DecryptionQueue>();\n// Only original current owner-generation and actual explicit Messages unlock\n// admit a controller. Construction/refresh never invoke an extension operation.\nexport function captureDecryptionQueue(\n repository: PrivateStorageRepository,\n session: PrivateSession,\n identity: IdentitySession,\n unlocked: UnlockedSession,\n review: unknown\n): DecryptionQueue | undefined {\n if (typeof window === 'undefined' || review !== 'reviewed_inbox_unlock')\n return undefined;\n const observed = privateSessionOwnership(session),\n owner = identityMessagingOwnership(identity),\n cache = unlockedSessionOwnership(unlocked);\n if (\n !observed?.current() ||\n !owner?.current() ||\n !cache?.current() ||\n observed.owner !== owner.owner ||\n observed.owner !== cache.owner ||\n observed.session !== owner.session ||\n observed.session !== cache.session\n )\n return undefined;\n const capture = observed,\n identityOwner = owner,\n unlockedOwner = cache;\n let visibility;\n try {\n visibility = getPrivateVisibilityScope(session);\n } catch {\n return undefined;\n }\n if (!visibility || !privateVisibilitySnapshot(visibility).active)\n return undefined;\n const visible = visibility;\n const prior = sessions.get(session);\n if (prior) return prior;\n const token = Object.freeze({}) as DecryptionQueue;\n let stopped = false,\n busy = false,\n paused = false,\n state = 'ready',\n reason: string | null = null,\n attempted = 0,\n blocked = 0,\n admitted = 0,\n invalid = 0;\n let pending = Array.from<string>([]),\n processed = Array.from<string>([]),\n accepted = Array.from<AdmittedConversation>([]),\n readers = Array.from<ReceivedUnwrap>([]);\n let active: ReceivedUnwrap | undefined,\n off = () => {},\n unlockOff = () => {};\n function current() {\n return (\n !stopped &&\n capture.current() &&\n identityOwner.current() &&\n unlockedOwner.current() &&\n privateVisibilitySnapshot(visible).active\n );\n }\n function stop() {\n if (stopped) return;\n stopped = true;\n state = 'stopped';\n reason = 'stopped';\n if (active) stopReceivedUnwrap(active);\n for (const reader of readers) stopReceivedUnwrap(reader);\n readers = [];\n accepted = [];\n pending = [];\n processed = [];\n off();\n unlockOff();\n if (sessions.get(session) === token) sessions.delete(session);\n // Actual pending SDK promise retains the shared slot until its settlement.\n }\n function expire() {\n if (stopped || !busy) return;\n paused = true;\n state = 'paused';\n reason = 'wait_expired';\n if (active) expireReceivedUnwrapWait(active);\n }\n function pause(why: string) {\n paused = true;\n state = 'paused';\n reason = why;\n }\n async function load() {\n if (!current()) {\n stop();\n return false;\n }\n const result = await listPrivateReceivedRecords(repository);\n if (!current()) {\n stop();\n return false;\n }\n if (!result.ok) {\n pause(result.reason);\n return false;\n }\n let ids = Array.from<string>([]);\n for (const handle of result.value) {\n const record = privateRecordIdentity(handle);\n if (record?.owner !== capture.owner) {\n pause('invalid_scope');\n return false;\n }\n if (!processed.includes(record.id)) ids = ids.concat(record.id);\n }\n pending = ids;\n return true;\n }\n const controller: Controller = {\n snapshot: () => ({\n state,\n reason,\n queued: pending.length,\n attempted,\n blocked,\n admitted,\n invalid,\n busy\n }),\n rooms: () => (current() ? accepted.slice() : []),\n stop,\n expire,\n async refresh() {\n if (busy || !current()) return false;\n try {\n return await load();\n } catch {\n pause('unavailable');\n return false;\n }\n },\n async run(reviewed, blockedPeers) {\n if (reviewed !== 'reviewed_decrypt_batch' || busy || !current())\n return false;\n // Detached block values can only suppress an already authenticated inner\n // peer's local projection; they never bypass envelope cost or confer SDK access.\n if (\n !Array.isArray(blockedPeers) ||\n blockedPeers.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes\n )\n return false;\n const exclusions = blockedPeers.slice();\n for (const peer of exclusions)\n if (canonicalPublicKey(peer) !== peer) return false;\n busy = true;\n paused = false;\n state = 'running';\n reason = null;\n attempted = 0;\n blocked = 0;\n admitted = 0;\n invalid = 0;\n try {\n if (!(await load()) || paused || !current()) return false;\n const plan = planDecryptBatch(pending);\n for (const id of plan.selected) {\n if (!current()) {\n stop();\n return false;\n }\n if (paused) return false;\n // Cost reservation occurs before unwrap/admission/dedup/blocked sender.\n attempted++;\n active = captureReceivedUnwrap(\n repository,\n identity,\n id,\n 'reviewed_inbox_unlock'\n );\n if (!active) {\n pause('unavailable');\n return false;\n }\n const reader = active,\n result = await unwrapReceivedEnvelope(reader);\n if (!current()) {\n stopReceivedUnwrap(reader);\n stop();\n return false;\n }\n if (paused) {\n stopReceivedUnwrap(reader);\n return false;\n }\n if (result.status === 'authenticated') {\n const room =\n admitReceivedConversation(result.envelope, 'inbound') ??\n admitReceivedConversation(result.envelope, 'self_archive');\n const message = room && conversationSnapshot(room);\n if (!room || !message) {\n invalid++;\n stopReceivedUnwrap(reader);\n } else if (exclusions.includes(message.peer)) {\n blocked++;\n stopReceivedUnwrap(reader);\n } else {\n const projection = acceptUnlockedConversation(unlocked, room);\n if (projection === 'added') {\n accepted = accepted.concat(room);\n readers = readers.concat(reader);\n admitted++;\n } else if (projection === 'duplicate') {\n admitted++;\n stopReceivedUnwrap(reader);\n } else {\n stopReceivedUnwrap(reader);\n pause(projection);\n return false;\n }\n }\n } else if (\n result.status === 'mismatch' ||\n result.status === 'invalid'\n ) {\n invalid++;\n stopReceivedUnwrap(reader);\n } else {\n stopReceivedUnwrap(reader);\n pause(result.status);\n return false;\n }\n active = undefined;\n if (!current() || paused) return false;\n processed = processed.concat(id);\n pending = pending.filter((next) => next !== id);\n }\n if (!(await load()) || paused || !current()) return false;\n state = pending.length ? 'needs_action' : 'idle';\n return true;\n } catch {\n if (current() && !paused) pause('unavailable');\n return false;\n } finally {\n active = undefined;\n busy = false;\n }\n }\n };\n controllers.set(token, controller);\n sessions.set(session, token);\n off = subscribePrivateSessionClose(session, stop);\n unlockOff = subscribeUnlockedSessionClose(unlocked, stop);\n if (!current()) {\n stop();\n return undefined;\n }\n return token;\n}\nexport function refreshDecryptionQueue(\n token: DecryptionQueue\n): Promise<boolean> {\n return controllers.get(token)?.refresh() ?? Promise.resolve(false);\n}\nexport function runDecryptionBatch(\n token: DecryptionQueue,\n review: unknown,\n blockedPeers: readonly string[] = []\n): Promise<boolean> {\n return (\n controllers.get(token)?.run(review, blockedPeers) ?? Promise.resolve(false)\n );\n}\nexport function decryptionQueueSnapshot(token: DecryptionQueue): View {\n return (\n controllers.get(token)?.snapshot() ?? {\n state: 'stopped',\n reason: 'invalid',\n queued: 0,\n attempted: 0,\n blocked: 0,\n admitted: 0,\n invalid: 0,\n busy: false\n }\n );\n}\nexport function decryptionQueueConversations(\n token: DecryptionQueue\n): readonly AdmittedConversation[] {\n return controllers.get(token)?.rooms() ?? [];\n}\nexport function stopDecryptionQueue(token: DecryptionQueue): void {\n controllers.get(token)?.stop();\n}\nexport function expireDecryptionQueueWait(token: DecryptionQueue): void {\n controllers.get(token)?.expire();\n}\n", + sha256: + '07661a883ee360e9fd7bd411893d637fd6b4b70aecb20101b826fe41b7ca4810' + }, + 'src/lib/messaging/inbox-view.ts': { + source: + "import {\n projectConversationThread,\n unavailableThread,\n type ThreadSnapshot,\n type ThreadMessage\n} from './conversation-thread.ts';\nimport type { PrivateRecordHandle } from '../persistence/private-records.ts';\nimport { canonicalPublicKey } from '../contracts/public-key.ts';\nimport {\n groupInboxMessages,\n type InboxListSnapshot,\n type InboxListRow\n} from './inbox-list.ts';\nimport {\n captureMessageMetadata,\n messageMetadataSnapshot,\n markDisplayedMessage,\n type MessageMetadata\n} from '../persistence/message-metadata.ts';\nimport {\n captureConversationDirectory,\n rememberAdmittedConversation,\n closeConversationDirectory,\n resolveLocalConversation,\n type ConversationDirectory\n} from './conversation-directory.ts';\nimport {\n conversationSnapshot,\n type AdmittedConversation\n} from './admit-conversation.ts';\nimport { decryptionQueueConversations } from './decryption-queue.ts';\nimport {\n captureOlderInbox,\n loadOlderInbox,\n stopOlderInbox,\n olderInboxSnapshot,\n type OlderInbox\n} from './history-pagination.ts';\nimport {\n identityMessagingOwnership,\n identitySessionSnapshot,\n subscribeIdentityInvalidation,\n type IdentitySession,\n type IdentitySnapshot\n} from '../runtime/identity-session.ts';\nimport {\n privateSessionOwnership,\n subscribePrivateSessionClose,\n closePrivateSession,\n type PrivateSession\n} from '../runtime/private-session.ts';\nimport {\n inboxSetupViewOwnership,\n inboxSetupViewSnapshot,\n subscribeInboxSetupView,\n closeInboxSetupView,\n unlockInboxSetupView,\n observeInboxSetupView,\n type InboxSetupView\n} from './inbox-setup-view.ts';\nimport {\n openBrowserDatabase,\n closeBrowserDatabase,\n type BrowserDatabase\n} from '../persistence/database.ts';\nimport {\n createPrivateStorageRepository,\n listPrivateSendRecords,\n type PrivateStorageRepository\n} from '../persistence/private-storage.ts';\nimport {\n captureUnlockedSession,\n closeUnlockedSession,\n readUnlockedMessages,\n unlockedConversationCurrent,\n type UnlockedSession\n} from './unlocked-session.ts';\nimport {\n captureDecryptionQueue,\n refreshDecryptionQueue,\n runDecryptionBatch,\n decryptionQueueSnapshot,\n stopDecryptionQueue,\n type DecryptionQueue\n} from './decryption-queue.ts';\nimport {\n captureInboxSync,\n startInboxSync,\n refreshInboxSync,\n inboxSyncSnapshot,\n inboxSyncHistoryOwnership,\n stopInboxSync,\n type InboxSync\n} from './inbox-sync.ts';\nimport { messagingReadinessSnapshot } from './readiness.ts';\nimport {\n selfRecoveryAcknowledgementSnapshot,\n verifySelfRecoveryAcknowledgement,\n type SelfRecoveryAcknowledgement\n} from '../persistence/private-sends.ts';\ndeclare const inboxViewBrand: unique symbol;\nexport type InboxView = Readonly<{ [inboxViewBrand]: true }>;\nexport type InboxViewSnapshot = Readonly<{\n state: string;\n reason: string | null;\n busy: boolean;\n owner?: string;\n identity: IdentitySnapshot;\n queued: number;\n count: number;\n lastCheckedAt: number | null;\n historyComplete: false;\n cleanupRequired: boolean;\n}>;\ntype Inputs = Readonly<{\n identity: IdentitySession;\n setup: InboxSetupView;\n conversationId?: string;\n}>;\nexport type InboxReplyOwnership = Readonly<{\n owner: string;\n identity: IdentitySession;\n session: PrivateSession;\n database: BrowserDatabase;\n repository: PrivateStorageRepository;\n unlocked: UnlockedSession;\n room: AdmittedConversation;\n setup: InboxSetupView;\n peer: string;\n parent: string;\n current(): boolean;\n acceptLocalReply(\n receipt: SelfRecoveryAcknowledgement,\n review: unknown\n ): Promise<boolean>;\n}>;\ntype Controller = {\n reply(id: unknown, rumor: unknown): InboxReplyOwnership | undefined;\n snapshot(): InboxViewSnapshot;\n thread(id: unknown): ThreadSnapshot;\n threadRevision(): number;\n message(id: unknown, rumor: unknown): ThreadMessage | undefined;\n resolve(id: unknown, review: unknown): Promise<boolean>;\n displayed(\n id: unknown,\n rumors: readonly string[],\n review: unknown\n ): Promise<boolean>;\n setup(): InboxSetupView | undefined;\n list(): InboxListSnapshot;\n row(peer: unknown): InboxListRow | undefined;\n revision(): number;\n open(peer: unknown, review: unknown): Promise<string | undefined>;\n older(review: unknown): Promise<boolean>;\n olderAvailable(): boolean;\n subscribe(listener: (view: InboxViewSnapshot) => void): () => void;\n unlock(review: unknown): Promise<boolean>;\n check(review: unknown): Promise<boolean>;\n read(review: unknown): Promise<boolean>;\n stop(): void;\n close(): boolean;\n};\nconst views = new WeakMap<InboxView, Controller>();\nconst unavailable = (): InboxViewSnapshot => ({\n state: 'unavailable',\n reason: null,\n busy: false,\n identity: { state: 'guest', reason: 'unavailable' },\n queued: 0,\n count: 0,\n lastCheckedAt: null,\n historyComplete: false,\n cleanupRequired: false\n});\n// The original setup/identity objects, not their copied readiness projections,\n// own this per-page orchestration. Mounting/subscribing never prompts or sends.\nexport function createInboxView(input: Inputs): InboxView | undefined {\n if (typeof window === 'undefined') return;\n const original = identityMessagingOwnership(input.identity),\n setup = inboxSetupViewOwnership(input.setup);\n if (\n !original?.current() ||\n !setup?.current() ||\n setup.identity !== input.identity\n )\n return;\n const capture = original,\n token = Object.freeze({}) as InboxView;\n let closed = false,\n busy = false,\n epoch = 0,\n reason: string | null = null,\n lastCheckedAt: number | null = null,\n checkPending = false,\n sampling = false,\n refreshedRetained = -1;\n let session: PrivateSession | undefined,\n database: BrowserDatabase | undefined,\n repository: PrivateStorageRepository | undefined,\n unlocked: UnlockedSession | undefined,\n queue: DecryptionQueue | undefined,\n sync: InboxSync | undefined;\n let metadata: MessageMetadata | undefined,\n directory: ConversationDirectory | undefined,\n older: OlderInbox | undefined;\n let list: InboxListSnapshot = groupInboxMessages('', [], []);\n let threadId: string | undefined,\n threadPeer: string | undefined,\n threadEpoch = 0;\n let threadModel: ThreadSnapshot = unavailableThread();\n const threadProofs = new Map<\n string,\n Readonly<{ room: AdmittedConversation; message: ThreadMessage }>\n >();\n let sendRecords: readonly PrivateRecordHandle[] =\n Array.from<PrivateRecordHandle>([]);\n let listReason: string | null = null;\n let repliedPeers = Array.from<string>([]);\n let listRevision = 0;\n const rowProofs = new Map<\n string,\n Readonly<{ data: InboxListRow; room: AdmittedConversation }>\n >();\n let off = () => {},\n privateOff = () => {},\n setupOff = () => {},\n pendingCleanup = Array.from<() => void>([]);\n const listeners = new Map<symbol, (view: InboxViewSnapshot) => void>();\n function current(generation = epoch) {\n const owner = inboxSetupViewOwnership(input.setup);\n return (\n !closed &&\n generation === epoch &&\n capture.current() &&\n owner?.identity === input.identity &&\n owner.current()\n );\n }\n function privateCurrent() {\n const owner = session && privateSessionOwnership(session);\n return (\n !!owner?.current() &&\n owner.owner === capture.owner &&\n owner.session === capture.session &&\n current()\n );\n }\n function threadRooms(id: unknown) {\n if (\n id !== threadId ||\n !threadPeer ||\n !privateCurrent() ||\n !unlocked ||\n !queue\n )\n return;\n const rooms = decryptionQueueConversations(queue).filter((room) => {\n const data = conversationSnapshot(room);\n return (\n data?.owner === capture.owner &&\n data.peer === threadPeer &&\n unlockedConversationCurrent(unlocked!, room)\n );\n });\n return rooms;\n }\n function refreshThread() {\n threadProofs.clear();\n threadModel = unavailableThread();\n const rooms = threadRooms(threadId);\n if (!rooms || !threadPeer) return;\n const data = rooms.map(conversationSnapshot);\n if (data.some((row) => !row)) return;\n threadModel = projectConversationThread(\n capture.owner,\n threadPeer,\n data.filter((row) => row !== undefined),\n sendRecords\n );\n if (threadModel.status !== 'ready') return;\n const byRumor = new Map<string, AdmittedConversation>();\n for (const room of rooms) {\n const row = conversationSnapshot(room);\n if (row) byRumor.set(row.rumorId, room);\n }\n for (const message of threadModel.messages) {\n const room = byRumor.get(message.data.rumorId);\n if (room) threadProofs.set(message.data.rumorId, { room, message });\n }\n }\n function messageSnapshot(\n id: unknown,\n rumor: unknown\n ): ThreadMessage | undefined {\n if (\n id !== threadId ||\n typeof rumor !== 'string' ||\n !privateCurrent() ||\n !unlocked ||\n threadModel.status !== 'ready'\n )\n return;\n const proof = threadProofs.get(rumor);\n if (!proof || !unlockedConversationCurrent(unlocked, proof.room)) return;\n const actual = conversationSnapshot(proof.room);\n if (\n !actual ||\n actual.owner !== capture.owner ||\n actual.peer !== threadPeer ||\n actual.rumorId !== rumor\n )\n return;\n return {\n data: { ...actual },\n citations: proof.message.citations.map((row) => ({ ...row })),\n parent: proof.message.parent,\n delivery: proof.message.delivery?.slice() ?? null\n };\n }\n function threadSnapshot(id: unknown): ThreadSnapshot {\n if (id !== threadId || !privateCurrent() || threadModel.status !== 'ready')\n return unavailableThread();\n const messages = threadModel.messages.map((row) =>\n messageSnapshot(id, row.data.rumorId)\n );\n return messages.some((row) => !row)\n ? unavailableThread()\n : {\n status: 'ready',\n messages: messages.filter((row) => row !== undefined)\n };\n }\n function replyOwnership(\n id: unknown,\n rumor: unknown\n ): InboxReplyOwnership | undefined {\n if (\n typeof rumor !== 'string' ||\n !messageSnapshot(id, rumor) ||\n !session ||\n !database ||\n !repository ||\n !unlocked\n )\n return;\n const proof = threadProofs.get(rumor);\n if (!proof) return;\n const data = conversationSnapshot(proof.room);\n if (!data) return;\n const generation = epoch,\n selection = threadEpoch,\n originalSession = session,\n originalRepository = repository,\n originalCache = unlocked,\n originalDatabase = database;\n const admitted = () =>\n current(generation) &&\n privateCurrent() &&\n selection === threadEpoch &&\n id === threadId &&\n threadPeer === data.peer &&\n session === originalSession &&\n repository === originalRepository &&\n unlocked === originalCache &&\n !!messageSnapshot(id, rumor) &&\n unlockedConversationCurrent(originalCache, proof.room);\n if (!admitted()) return;\n return {\n owner: capture.owner,\n identity: input.identity,\n session: originalSession,\n database: originalDatabase,\n repository: originalRepository,\n unlocked: originalCache,\n room: proof.room,\n setup: input.setup,\n peer: data.peer,\n parent: data.rumorId,\n current: admitted,\n async acceptLocalReply(receipt, review) {\n const saved = selfRecoveryAcknowledgementSnapshot(receipt);\n if (\n review !== 'reviewed_local_reply' ||\n !admitted() ||\n saved?.owner !== capture.owner ||\n saved.peer !== data.peer ||\n !(await verifySelfRecoveryAcknowledgement(\n originalRepository,\n receipt\n )) ||\n !admitted()\n )\n return false;\n // Presentation in this unlocked view only, backed by the actual native\n // self receipt. No order/notification or persistent acceptance field.\n if (!repliedPeers.includes(data.peer))\n repliedPeers = repliedPeers.concat(data.peer);\n listRevision++;\n await refreshList(generation);\n if (!admitted()) return false;\n notify();\n return true;\n }\n };\n }\n async function resolve(id: unknown, review: unknown) {\n if (review !== 'reviewed_conversation_navigation') return false;\n const selection = ++threadEpoch,\n generation = epoch;\n threadId = undefined;\n threadPeer = undefined;\n threadProofs.clear();\n threadModel = unavailableThread();\n notify();\n if (!directory || !privateCurrent()) return false;\n const result = await resolveLocalConversation(directory, id);\n if (\n selection !== threadEpoch ||\n !current(generation) ||\n !privateCurrent() ||\n result.status !== 'resolved' ||\n result.owner !== capture.owner\n )\n return false;\n threadId = result.conversationId;\n threadPeer = result.peer;\n refreshThread();\n notify();\n return true;\n }\n async function displayed(\n id: unknown,\n rumors: readonly string[],\n review: unknown\n ) {\n if (\n review !== 'reviewed_displayed_conversation' ||\n !Array.isArray(rumors) ||\n !metadata\n )\n return false;\n const rooms = threadRooms(id),\n selection = threadEpoch,\n generation = epoch,\n originalMetadata = metadata;\n if (!rooms || rumors.length > 2000) return false;\n for (const rumor of rumors) {\n const room = rooms.find(\n (value) => conversationSnapshot(value)?.rumorId === rumor\n );\n if (\n !room ||\n selection !== threadEpoch ||\n !current(generation) ||\n !privateCurrent() ||\n id !== threadId\n )\n return false;\n const result = await markDisplayedMessage(\n originalMetadata,\n room,\n 'displayed_message'\n );\n if (result.status !== 'saved' && result.status !== 'existing')\n return false;\n }\n if (selection !== threadEpoch || !current(generation) || !privateCurrent())\n return false;\n await refreshList(generation);\n return selection === threadEpoch && current(generation) && privateCurrent();\n }\n function rowSnapshot(peer: unknown): InboxListRow | undefined {\n if (\n typeof peer !== 'string' ||\n !privateCurrent() ||\n !unlocked ||\n !queue ||\n list.status !== 'ready'\n )\n return;\n const proof = rowProofs.get(peer);\n if (!proof || !unlockedConversationCurrent(unlocked, proof.room)) return;\n const actual = conversationSnapshot(proof.room);\n if (\n !actual ||\n actual.owner !== capture.owner ||\n actual.peer !== peer ||\n actual.rumorId !== proof.data.latest.rumorId\n )\n return;\n return { ...proof.data, latest: { ...actual } };\n }\n function listSnapshot(): InboxListSnapshot {\n if (!privateCurrent() || !unlocked || !queue)\n return { status: 'locked', requests: [], conversations: [] };\n if (list.status !== 'ready')\n return { status: list.status, requests: [], conversations: [] };\n const requests = list.requests.map((row) => rowSnapshot(row.peer)),\n conversations = list.conversations.map((row) => rowSnapshot(row.peer));\n if (requests.some((row) => !row) || conversations.some((row) => !row))\n return { status: 'unavailable', requests: [], conversations: [] };\n return {\n status: 'ready',\n requests: requests\n .filter((row) => row !== undefined)\n .filter((row) => !repliedPeers.includes(row.peer)),\n conversations: conversations\n .filter((row) => row !== undefined)\n .concat(\n requests\n .filter((row) => row !== undefined)\n .filter((row) => repliedPeers.includes(row.peer))\n )\n .sort(\n (a, b) =>\n b.latest.createdAt - a.latest.createdAt ||\n b.latest.rumorId.localeCompare(a.latest.rumorId) ||\n a.peer.localeCompare(b.peer)\n )\n };\n }\n async function refreshList(generation = epoch) {\n if (!privateCurrent() || !unlocked || !metadata) return false;\n try {\n const local = await messageMetadataSnapshot(metadata);\n const sends = repository && (await listPrivateSendRecords(repository));\n if (!current(generation) || !privateCurrent() || !unlocked) return false;\n sendRecords = sends?.ok ? sends.value : [];\n const cached = readUnlockedMessages(unlocked);\n if (\n local.status !== 'ready' ||\n local.owner !== capture.owner ||\n cached.status !== 'ready'\n ) {\n list = { status: 'unavailable', requests: [], conversations: [] };\n rowProofs.clear();\n listRevision++;\n listReason = 'storage_unavailable';\n return false;\n }\n list = groupInboxMessages(\n capture.owner,\n cached.messages,\n local.readRumors\n );\n rowProofs.clear();\n const rooms = queue && decryptionQueueConversations(queue),\n byRumor = new Map<string, AdmittedConversation>();\n for (const room of rooms ?? []) {\n const observed = conversationSnapshot(room);\n if (observed) byRumor.set(observed.rumorId, room);\n }\n for (const row of list.requests.concat(list.conversations)) {\n const room = byRumor.get(row.latest.rumorId);\n if (room) rowProofs.set(row.peer, { data: row, room });\n }\n refreshThread();\n listRevision++;\n listReason = list.status === 'ready' ? null : 'unavailable';\n return list.status === 'ready';\n } catch {\n if (current(generation) && privateCurrent()) {\n list = { status: 'unavailable', requests: [], conversations: [] };\n rowProofs.clear();\n listRevision++;\n listReason = 'storage_unavailable';\n }\n return false;\n }\n }\n function olderAvailable() {\n if (busy || !privateCurrent() || !unlocked || !repository || !sync)\n return false;\n const transport = inboxSyncSnapshot(sync),\n ownership = inboxSyncHistoryOwnership(sync),\n own = inboxSetupViewOwnership(input.setup),\n original = session && privateSessionOwnership(session);\n if (\n !own?.current() ||\n !own.resolver ||\n !original?.current() ||\n !ownership?.current() ||\n transport?.backfill !== 'complete' ||\n transport.pending !== 0\n )\n return false;\n return (\n messagingReadinessSnapshot(\n input.identity,\n session,\n own.policy,\n own.resolver,\n undefined,\n own.observeAccess\n ).ownAccess === 'qualified_exercised'\n );\n }\n async function open(peer: unknown, review: unknown) {\n if (\n review !== 'reviewed_admitted_conversation_navigation' ||\n busy ||\n !privateCurrent() ||\n !queue ||\n !directory ||\n !canonicalPublicKey(peer)\n )\n return;\n const room = decryptionQueueConversations(queue).find(\n (value) => conversationSnapshot(value)?.peer === peer\n );\n if (!room) return;\n const generation = epoch;\n busy = true;\n notify();\n try {\n const result = await rememberAdmittedConversation(\n directory,\n room,\n review\n );\n if (!current(generation) || !privateCurrent()) return;\n if (result.status !== 'saved' && result.status !== 'existing') {\n reason = 'unavailable';\n return;\n }\n await refreshList(generation);\n if (!current(generation) || !privateCurrent()) return;\n return '/messages/' + result.conversationId;\n } catch {\n if (current(generation)) reason = 'unavailable';\n return;\n } finally {\n if (current(generation)) {\n busy = false;\n notify();\n }\n }\n }\n async function loadOlder(review: unknown) {\n if (\n review !== 'reviewed_load_older' ||\n !olderAvailable() ||\n !sync ||\n !queue\n )\n return false;\n older ??= captureOlderInbox(sync, review);\n if (!older) return false;\n const generation = epoch;\n busy = true;\n notify();\n try {\n const result = await loadOlderInbox(older, review);\n if (!current(generation) || !privateCurrent() || !queue) return false;\n await refreshDecryptionQueue(queue);\n if (!current(generation) || !privateCurrent()) return false;\n await refreshList(generation);\n return current(generation) && privateCurrent() && result;\n } catch {\n if (current(generation)) reason = 'unavailable';\n return false;\n } finally {\n if (current(generation)) {\n busy = false;\n notify();\n }\n }\n }\n function snapshot(): InboxViewSnapshot {\n if (!current())\n return { ...unavailable(), cleanupRequired: pendingCleanup.length > 0 };\n const identity = identitySessionSnapshot(input.identity),\n setupState = inboxSetupViewSnapshot(input.setup);\n if (!privateCurrent() || !unlocked || !queue)\n return {\n ...unavailable(),\n owner: capture.owner,\n identity,\n state: busy\n ? 'unlocking'\n : [\n 'compatible',\n 'compatible_existing',\n 'access_unavailable',\n 'verified'\n ].includes(setupState.status)\n ? 'locked'\n : 'setup',\n reason,\n busy: busy || setupState.busy\n };\n const cached = readUnlockedMessages(unlocked),\n decrypt = decryptionQueueSnapshot(queue),\n paging = older && olderInboxSnapshot(older),\n transport = sync && inboxSyncSnapshot(sync);\n const scope = inboxSetupViewOwnership(input.setup);\n const exercised =\n !!scope?.resolver &&\n messagingReadinessSnapshot(\n input.identity,\n session,\n scope.policy,\n scope.resolver,\n undefined,\n scope.observeAccess\n ).ownAccess === 'qualified_exercised';\n if (!privateCurrent()) return unavailable();\n const partial =\n reason !== null ||\n !exercised ||\n cached.status !== 'ready' ||\n list.status === 'unavailable' ||\n !!paging?.reason ||\n decrypt.state === 'paused' ||\n transport?.state === 'needs_action' ||\n transport?.state === 'stopped';\n const checked =\n lastCheckedAt !== null && !!sync && !!inboxSyncHistoryOwnership(sync);\n return {\n state:\n busy || decrypt.busy\n ? 'unlocking'\n : partial\n ? 'partial'\n : checked && decrypt.queued === 0 && cached.messages.length === 0\n ? 'empty'\n : 'ready',\n reason:\n reason ??\n listReason ??\n paging?.reason ??\n decrypt.reason ??\n transport?.reason ??\n (!exercised ? 'access_unavailable' : null),\n busy: busy || decrypt.busy || setupState.busy,\n owner: capture.owner,\n identity,\n queued: decrypt.queued,\n count: cached.messages.length,\n lastCheckedAt,\n historyComplete: false,\n cleanupRequired: pendingCleanup.length > 0\n };\n }\n function notify() {\n for (const listener of listeners.values())\n try {\n listener(snapshot());\n } catch {\n /* Isolate presentation. */\n }\n }\n function releasePrivate() {\n privateOff();\n privateOff = () => {};\n const originalQueue = queue,\n originalSync = sync,\n originalUnlocked = unlocked,\n originalSession = session,\n originalDatabase = database,\n originalDirectory = directory,\n originalOlder = older;\n const tasks = pendingCleanup.concat([\n () => {\n if (originalOlder) stopOlderInbox(originalOlder);\n },\n () => {\n if (originalDirectory) closeConversationDirectory(originalDirectory);\n },\n () => {\n if (originalQueue) stopDecryptionQueue(originalQueue);\n },\n () => {\n if (originalSync) stopInboxSync(originalSync);\n },\n () => {\n if (originalUnlocked) closeUnlockedSession(originalUnlocked);\n },\n () => {\n if (originalSession && !closePrivateSession(originalSession))\n throw Error('private_cleanup_required');\n },\n () => {\n if (originalDatabase) closeBrowserDatabase(originalDatabase);\n }\n ]);\n pendingCleanup = [];\n for (const cleanup of tasks)\n try {\n cleanup();\n } catch {\n pendingCleanup = pendingCleanup.concat(cleanup);\n }\n if (pendingCleanup.length > 0) reason = 'cleanup_required';\n threadEpoch++;\n threadProofs.clear();\n threadModel = unavailableThread();\n threadId = undefined;\n threadPeer = undefined;\n sendRecords = [];\n repliedPeers = [];\n metadata = undefined;\n directory = undefined;\n older = undefined;\n list = { status: 'locked', requests: [], conversations: [] };\n listReason = null;\n rowProofs.clear();\n listRevision++;\n queue = undefined;\n sync = undefined;\n unlocked = undefined;\n session = undefined;\n repository = undefined;\n database = undefined;\n lastCheckedAt = null;\n checkPending = false;\n }\n function stop() {\n epoch++;\n reason = 'stopped';\n releasePrivate();\n busy = false;\n notify();\n }\n async function sample() {\n if (sampling || closed) return;\n if (!current()) {\n notify();\n return;\n }\n observeInboxSetupView(input.setup);\n if (!queue || !privateCurrent()) {\n notify();\n return;\n }\n sampling = true;\n const generation = epoch;\n try {\n const transport = sync && inboxSyncSnapshot(sync);\n // Read native ciphertext only after actual ingress changes, never on\n // every idle presentation tick and never as automatic SDK decryption.\n if (\n transport &&\n transport.pending === 0 &&\n transport.retained !== refreshedRetained &&\n !decryptionQueueSnapshot(queue).busy\n ) {\n const retained = transport.retained;\n const refreshed = await refreshDecryptionQueue(queue);\n if (!current(generation) || !privateCurrent()) return;\n refreshedRetained = retained;\n if (!refreshed) {\n notify();\n return;\n }\n }\n if (!current(generation) || !privateCurrent()) return;\n if (\n checkPending &&\n sync &&\n transport?.backfill === 'complete' &&\n transport.pending === 0 &&\n inboxSyncHistoryOwnership(sync)?.current()\n ) {\n const checked = Date.now();\n if (\n current(generation) &&\n privateCurrent() &&\n inboxSyncHistoryOwnership(sync)?.current()\n ) {\n lastCheckedAt = checked;\n checkPending = false;\n }\n }\n notify();\n } catch {\n if (current(generation)) {\n reason = 'unavailable';\n notify();\n }\n } finally {\n sampling = false;\n }\n }\n async function read(reviewed: unknown) {\n if (\n reviewed !== 'reviewed_decrypt_batch' ||\n (input.conversationId !== undefined &&\n (threadId !== input.conversationId || !threadPeer)) ||\n busy ||\n !queue ||\n !privateCurrent()\n )\n return false;\n busy = true;\n reason = null;\n const generation = epoch;\n notify();\n try {\n const result = await runDecryptionBatch(queue, reviewed);\n if (!current(generation) || !privateCurrent()) return false;\n await refreshList(generation);\n return current(generation) && privateCurrent() && result;\n } finally {\n if (current(generation)) {\n busy = false;\n notify();\n }\n }\n }\n async function unlock(reviewed: unknown) {\n if (reviewed !== 'reviewed_messages_unlock' || busy || !current())\n return false;\n if (queue && privateCurrent()) return await read('reviewed_decrypt_batch');\n const setupState = inboxSetupViewSnapshot(input.setup);\n if (\n ![\n 'compatible',\n 'compatible_existing',\n 'access_unavailable',\n 'verified'\n ].includes(setupState.status)\n )\n return false;\n busy = true;\n reason = null;\n const generation = epoch;\n notify();\n try {\n await unlockInboxSetupView(input.setup);\n if (!current(generation)) return false;\n const original = inboxSetupViewOwnership(input.setup),\n acquired = original?.session,\n owner = acquired && privateSessionOwnership(acquired);\n if (\n !original?.resolver ||\n !acquired ||\n !owner?.current() ||\n owner.owner !== capture.owner ||\n owner.session !== capture.session ||\n !original.current()\n )\n return false;\n session = acquired;\n const opened = await openBrowserDatabase();\n if (!current(generation) || !privateCurrent()) {\n if (opened.state === 'ready') closeBrowserDatabase(opened.owner);\n return false;\n }\n if (opened.state !== 'ready') {\n reason = 'storage_unavailable';\n return false;\n }\n database = opened.owner;\n repository = createPrivateStorageRepository(database, capture.owner);\n unlocked = captureUnlockedSession(session, reviewed);\n queue =\n repository &&\n unlocked &&\n captureDecryptionQueue(\n repository,\n session,\n input.identity,\n unlocked,\n 'reviewed_inbox_unlock'\n );\n if (!queue || !unlocked) {\n reason = 'unavailable';\n return false;\n }\n metadata = captureMessageMetadata(\n database,\n session,\n unlocked,\n 'reviewed_local_message_metadata'\n );\n directory =\n metadata &&\n captureConversationDirectory(\n session,\n metadata,\n 'reviewed_conversation_directory'\n );\n if (!metadata || !directory) {\n reason = 'storage_unavailable';\n return false;\n }\n privateOff = subscribePrivateSessionClose(session, () => {\n epoch++;\n releasePrivate();\n busy = false;\n notify();\n if (pendingCleanup.length > 0)\n queueMicrotask(() => {\n releasePrivate();\n notify();\n });\n });\n if (!privateCurrent()) return false;\n if (\n input.conversationId !== undefined &&\n !(await resolve(\n input.conversationId,\n 'reviewed_conversation_navigation'\n ))\n ) {\n reason = 'unavailable';\n return false;\n }\n const result = await runDecryptionBatch(queue, 'reviewed_decrypt_batch');\n if (!current(generation) || !privateCurrent()) return false;\n await refreshList(generation);\n return current(generation) && privateCurrent() && result;\n } catch {\n if (current(generation)) reason = 'unavailable';\n return false;\n } finally {\n if (current(generation)) {\n busy = false;\n notify();\n }\n }\n }\n async function check(reviewed: unknown) {\n if (\n reviewed !== 'reviewed_foreground_inbox' ||\n busy ||\n !privateCurrent() ||\n !session ||\n !repository ||\n !unlocked\n )\n return false;\n const scope = inboxSetupViewOwnership(input.setup);\n if (!scope?.resolver || !scope.current() || !scope.observeAccess) {\n reason = 'access_unavailable';\n notify();\n return false;\n }\n const generation = epoch;\n reason = null;\n if (sync) {\n if (\n !refreshInboxSync(\n sync,\n reviewed,\n lastCheckedAt === null ? undefined : Math.floor(lastCheckedAt / 1000)\n )\n ) {\n reason = inboxSyncSnapshot(sync)?.reason ?? 'check_incomplete';\n notify();\n return false;\n }\n } else {\n sync = captureInboxSync(\n repository,\n session,\n scope.policy,\n scope.resolver,\n unlocked,\n scope.observeAccess,\n reviewed\n );\n if (!sync || !startInboxSync(sync, reviewed)) {\n reason = 'access_unavailable';\n notify();\n return false;\n }\n }\n checkPending = true;\n notify();\n await sample();\n if (current(generation) && privateCurrent()) await refreshList(generation);\n return current(generation) && privateCurrent();\n }\n views.set(token, {\n reply: replyOwnership,\n snapshot,\n thread: threadSnapshot,\n threadRevision: () => (privateCurrent() ? listRevision + threadEpoch : -1),\n message: messageSnapshot,\n resolve,\n displayed,\n list: listSnapshot,\n row: rowSnapshot,\n revision: () => (privateCurrent() ? listRevision : -1),\n open,\n older: loadOlder,\n olderAvailable,\n setup: () => (current() ? input.setup : undefined),\n subscribe(listener) {\n const key = Symbol();\n listeners.set(key, listener);\n listener(snapshot());\n return () => {\n listeners.delete(key);\n };\n },\n unlock,\n check,\n read,\n stop,\n close() {\n // Retain this first terminal fanout before cleanup can reenter Close or\n // unsubscribe another observer. Authority is revoked before callbacks.\n const terminalListeners = closed ? [] : Array.from(listeners.values());\n if (!closed) {\n closed = true;\n epoch++;\n clearInterval(timer);\n off();\n setupOff();\n }\n releasePrivate();\n // Cleanup retains the original genuine setup independently of current\n // admission. Logout hides effect access, while disposal still closes\n // its identity observer, database and runtime public-view owner.\n try {\n closeInboxSetupView(input.setup);\n } catch {\n pendingCleanup = pendingCleanup.concat(() =>\n closeInboxSetupView(input.setup)\n );\n }\n listeners.clear();\n for (const listener of terminalListeners)\n try {\n listener(snapshot());\n } catch {\n /* Isolate terminal presentation without stranding other observers. */\n }\n return pendingCleanup.length === 0;\n }\n });\n off = subscribeIdentityInvalidation(input.identity, () => {\n if (!capture.current()) {\n epoch++;\n releasePrivate();\n busy = false;\n notify();\n }\n });\n setupOff = subscribeInboxSetupView(input.setup, notify);\n const timer = setInterval(() => {\n void sample();\n }, 200);\n if (!current()) {\n views.get(token)?.close();\n return;\n }\n return token;\n}\nexport function inboxViewSnapshot(\n token: InboxView | undefined\n): InboxViewSnapshot {\n return (token && views.get(token)?.snapshot()) || unavailable();\n}\nexport function inboxViewSetup(\n token: InboxView | undefined\n): InboxSetupView | undefined {\n return token && views.get(token)?.setup();\n}\nexport function subscribeInboxView(\n token: InboxView | undefined,\n listener: (view: InboxViewSnapshot) => void\n): () => void {\n return (token && views.get(token)?.subscribe(listener)) || (() => {});\n}\nexport function unlockInboxView(\n token: InboxView,\n review: unknown\n): Promise<boolean> {\n return views.get(token)?.unlock(review) ?? Promise.resolve(false);\n}\nexport function checkInboxView(\n token: InboxView,\n review: unknown\n): Promise<boolean> {\n return views.get(token)?.check(review) ?? Promise.resolve(false);\n}\nexport function readNewInboxView(\n token: InboxView,\n review: unknown\n): Promise<boolean> {\n return views.get(token)?.read(review) ?? Promise.resolve(false);\n}\nexport function stopInboxView(token: InboxView): void {\n views.get(token)?.stop();\n}\nexport function closeInboxView(token: InboxView): boolean {\n return views.get(token)?.close() ?? true;\n}\n\n// Fresh genuine original cache observation. Returned rows are detached and\n// never replace the original room/native authority used by explicit Open.\nexport function inboxListSnapshot(\n token: InboxView | undefined\n): InboxListSnapshot {\n return (\n (token && views.get(token)?.list()) || {\n status: 'unavailable',\n requests: [],\n conversations: []\n }\n );\n}\nexport function openInboxConversation(\n token: InboxView,\n peer: unknown,\n review: unknown\n): Promise<string | undefined> {\n return views.get(token)?.open(peer, review) ?? Promise.resolve(undefined);\n}\nexport function loadOlderInboxView(\n token: InboxView,\n review: unknown\n): Promise<boolean> {\n return views.get(token)?.older(review) ?? Promise.resolve(false);\n}\nexport function inboxViewOlderAvailable(token: InboxView | undefined): boolean {\n return !!token && !!views.get(token)?.olderAvailable();\n}\n\nexport function inboxConversationRow(\n token: InboxView | undefined,\n peer: unknown\n): InboxListRow | undefined {\n return token ? views.get(token)?.row(peer) : undefined;\n}\nexport function inboxListRevision(token: InboxView | undefined): number {\n return token ? (views.get(token)?.revision() ?? -1) : -1;\n}\n\nexport function inboxThreadSnapshot(\n token: InboxView | undefined,\n id: unknown\n): ThreadSnapshot {\n return (token && views.get(token)?.thread(id)) || unavailableThread();\n}\nexport function inboxMessageSnapshot(\n token: InboxView,\n id: unknown,\n rumor: unknown\n): ThreadMessage | undefined {\n return views.get(token)?.message(id, rumor);\n}\nexport function resolveInboxConversation(\n token: InboxView,\n id: unknown,\n review: unknown\n): Promise<boolean> {\n return views.get(token)?.resolve(id, review) ?? Promise.resolve(false);\n}\nexport function markInboxConversationDisplayed(\n token: InboxView,\n id: unknown,\n rumors: readonly string[],\n review: unknown\n): Promise<boolean> {\n return (\n views.get(token)?.displayed(id, rumors, review) ?? Promise.resolve(false)\n );\n}\n\nexport function inboxThreadRevision(token: InboxView | undefined): number {\n return token ? (views.get(token)?.threadRevision() ?? -1) : -1;\n}\n\nexport function inboxReplyOwnership(\n token: InboxView,\n id: unknown,\n rumor: unknown\n): InboxReplyOwnership | undefined {\n return views.get(token)?.reply(id, rumor);\n}\n", + sha256: + 'f725d1e122550232efa52b26139d3047d3bbfd6d3d11b1ef0a110b5e4b4410dc' + }, + 'src/lib/messaging/cited-product.ts': { + source: + "import { includedProductVersion } from '../nostr/enquiry-references.ts';\nimport { PUBLIC_QUERY_BUDGETS } from '../config/budgets.ts';\nimport { decodeProductReference } from '../nostr/references.ts';\nimport {\n inboxMessageSnapshot,\n inboxReplyOwnership,\n inboxThreadSnapshot,\n type InboxReplyOwnership,\n type InboxView\n} from './inbox-view.ts';\nimport {\n createPublicView,\n beginPublicViewRun,\n disposePublicView,\n publicViewRunCurrent,\n publicViewOwnsRun,\n publicViewProjectionAvailable,\n subscribePublicView,\n type PublicView,\n type PublicRuntime\n} from '../runtime/public-runtime.ts';\nimport {\n publicRequestScopeSnapshot,\n type PublicRequest\n} from '../nostr/request-scope.ts';\nimport {\n createPublicHeadCandidate,\n publicHeadSnapshot,\n selectPublicHead,\n type PublicHead\n} from '../catalog/heads.ts';\nimport {\n createPublicViewHeadResolver,\n headResolutionSnapshot,\n resolveHeads,\n closeHeadResolver\n} from '../catalog/resolve-head.ts';\nimport { subscribePrivateSessionClose } from '../runtime/private-session.ts';\nimport { subscribeIdentityInvalidation } from '../runtime/identity-session.ts';\nimport type { FoodProjection } from '../contracts/food-availability-v1/read.ts';\n\ndeclare const citedBrand: unique symbol;\nexport type CitedProduct = Readonly<{ [citedBrand]: true }>;\ntype Snapshot = Readonly<{\n outcome: 'checking' | 'unresolved' | 'active' | 'sold' | 'withdrawn';\n food?: FoodProjection;\n lastKnownFood?: FoodProjection;\n includedVersion: 'none' | 'unverified' | 'matched' | 'different';\n}>;\nconst owners = new WeakMap<\n CitedProduct,\n { snapshot(): Snapshot | undefined; close(): void }\n>();\n\nexport function conversationOptionsSnapshot(\n view: InboxView,\n id: string\n): Readonly<{ peer: string }> | undefined {\n const thread = inboxThreadSnapshot(view, id);\n for (const row of thread.messages) {\n const original = inboxReplyOwnership(view, id, row.data.rumorId);\n if (original?.current()) return { peer: original.peer };\n }\n return undefined;\n}\nexport function requestConversationOption(\n view: InboxView,\n id: string,\n action: 'block' | 'report',\n invoke: (peer: string) => void,\n review: unknown\n): boolean {\n if (\n review !== 'reviewed_conversation_option' ||\n (action !== 'block' && action !== 'report')\n )\n return false;\n const actual = conversationOptionsSnapshot(view, id);\n if (!actual) return false;\n invoke(actual.peer);\n return true;\n}\n\n// Neither a copied row nor a body pointer is authority. Resolve the selector\n// against the current original private room before allocating an anonymous view.\nexport function captureCitedProduct(\n inbox: InboxView,\n id: string,\n rumor: string,\n value: unknown,\n runtime: PublicRuntime,\n review: unknown\n): CitedProduct | undefined {\n if (typeof window === 'undefined' || review !== 'reviewed_product_citation')\n return undefined;\n const original = inboxReplyOwnership(inbox, id, rumor),\n message = inboxMessageSnapshot(inbox, id, rumor),\n decoded = decodeProductReference(value);\n if (\n !original?.current() ||\n !message ||\n !decoded ||\n !message.citations.some((row) => row.naddr === decoded.naddr) ||\n ![original.owner, original.peer].includes(decoded.pubkey)\n )\n return undefined;\n const reference = decoded;\n const privateIds = inboxThreadSnapshot(inbox, id).messages.flatMap((row) => [\n row.data.rumorId,\n ...(row.data.replyTo ? [row.data.replyTo] : [])\n ]);\n if (privateIds.includes(reference.identifier)) return undefined;\n let versions = Array.from<string>([]);\n for (const match of message.data.content.matchAll(\n /\\b(nevent1[023456789acdefghjklmnpqrstuvwxyz]+)\\b/gi\n )) {\n const version = includedProductVersion(match[1], reference.pubkey);\n if (version && !privateIds.includes(version) && !versions.includes(version))\n versions = versions.concat(version);\n }\n const exactId = versions.length === 1 ? versions[0] : undefined;\n let view: PublicView;\n try {\n view = createPublicView(runtime);\n } catch {\n return undefined;\n }\n const run = beginPublicViewRun(view),\n resolver = createPublicViewHeadResolver(view, run, {\n nowSeconds: () => Math.floor(Date.now() / 1000)\n });\n let closed = false,\n failed = false,\n head: PublicHead | undefined,\n exact: string | undefined;\n let privateScope: InboxReplyOwnership | undefined = original;\n const requests = new Map<PublicRequest, true>();\n let offPrivate = () => {},\n offIdentity = () => {};\n function close() {\n if (closed) return;\n closed = true;\n privateScope = undefined;\n offPrivate();\n offIdentity();\n try {\n closeHeadResolver(resolver);\n } finally {\n disposePublicView(view);\n }\n }\n const owned = () =>\n !closed &&\n !!privateScope?.current() &&\n !!inboxMessageSnapshot(inbox, id, rumor) &&\n publicViewProjectionAvailable(view) &&\n publicViewOwnsRun(view, run);\n const current = () => owned() && publicViewRunCurrent(view, run);\n const token = Object.freeze({}) as CitedProduct;\n owners.set(token, {\n close,\n snapshot() {\n if (!owned()) {\n close();\n return undefined;\n }\n const row = headResolutionSnapshot(resolver)[0],\n scopes = Array.from(requests.keys(), publicRequestScopeSnapshot);\n const pending =\n current() &&\n [\n ...scopes,\n ...(row?.headSources ? [row.headSources] : []),\n ...(row?.deletionSources ? [row.deletionSources] : [])\n ].some((scope) => scope.state === 'active');\n const suppressed = row?.deletion.outcome === 'suppressed';\n // A retained signed head is not a completed coordinate/withdrawal read.\n // Original source coverage must remain honest after ordinary run expiry.\n const complete =\n row?.coverage === 'bounded-eose' &&\n !row.lastKnown &&\n scopes.length > 0 &&\n scopes.every(\n (scope) =>\n scope.state === 'eose' && scope.result.coverage === 'bounded-eose'\n );\n const food =\n !suppressed && !pending && !failed && complete\n ? row?.state.food\n : undefined;\n return {\n outcome: suppressed\n ? 'withdrawn'\n : pending\n ? 'checking'\n : food\n ? food.status\n : 'unresolved',\n food,\n lastKnownFood:\n !suppressed && !pending && !food ? row?.state.food : undefined,\n includedVersion: !exactId\n ? 'none'\n : !exact || !food\n ? 'unverified'\n : exact === row?.state.head.id\n ? 'matched'\n : 'different'\n };\n }\n });\n offPrivate = subscribePrivateSessionClose(original.session, close);\n offIdentity = subscribeIdentityInvalidation(original.identity, close);\n function admit(\n proof: Parameters<typeof createPublicHeadCandidate>[0],\n exactOnly: boolean\n ) {\n if (!current()) return;\n const candidate = createPublicHeadCandidate(proof);\n if (!candidate) return;\n const data = publicHeadSnapshot(candidate);\n if (\n data.kind !== 30402 ||\n data.pubkey !== reference.pubkey ||\n data.identifier !== reference.identifier\n )\n return;\n if (exactOnly) {\n if (data.id === exactId) exact = data.id;\n return;\n }\n head = selectPublicHead(head, candidate).head;\n try {\n resolveHeads(resolver, [head]);\n } catch {\n failed = true;\n }\n }\n try {\n const request = subscribePublicView(\n view,\n run,\n 'head',\n [\n {\n kinds: [30402],\n authors: [reference.pubkey],\n '#d': [reference.identifier],\n limit: PUBLIC_QUERY_BUDGETS.requestedPerRelay\n }\n ],\n (proof) => admit(proof, false)\n );\n requests.set(request, true);\n if (exactId && current())\n requests.set(\n subscribePublicView(\n view,\n run,\n 'head',\n [\n {\n kinds: [30402],\n authors: [reference.pubkey],\n ids: [exactId],\n limit: PUBLIC_QUERY_BUDGETS.requestedPerRelay\n }\n ],\n (proof) => admit(proof, true)\n ),\n true\n );\n } catch {\n failed = true;\n }\n return token;\n}\nexport function citedProductSnapshot(\n token: CitedProduct\n): Snapshot | undefined {\n return owners.get(token)?.snapshot();\n}\nexport function closeCitedProduct(token: CitedProduct): void {\n owners.get(token)?.close();\n}\n", + sha256: + 'b4a43fad9b020cf647350350e5d0195df9a80d772ab6910e0e9fb8c11b4b0e48' + }, + 'src/lib/components/ConversationOptions.svelte': { + source: + "<script lang=\"ts\">\n import { onMount } from 'svelte';\n import {\n subscribeInboxView,\n type InboxView\n } from '../messaging/inbox-view.ts';\n import {\n conversationOptionsSnapshot,\n requestConversationOption\n } from '../messaging/cited-product.ts';\n let {\n controller,\n conversationId,\n onblock,\n onreport\n }: {\n controller: InboxView;\n conversationId: string;\n onblock?: (peer: string) => void;\n onreport?: (peer: string) => void;\n } = $props();\n let revision = $state(0);\n const actual = $derived.by(() => {\n void revision;\n return conversationOptionsSnapshot(controller, conversationId);\n });\n onMount(() =>\n subscribeInboxView(controller, () => {\n revision++;\n })\n );\n</script>\n\n{#if actual}\n <details>\n <summary>Identity and conversation options</summary>\n <p>Authenticated conversation peer: {actual.peer}</p>\n {#if onblock}<button\n type=\"button\"\n onclick={() => {\n if (onblock)\n requestConversationOption(\n controller,\n conversationId,\n 'block',\n onblock,\n 'reviewed_conversation_option'\n );\n }}>Block person</button\n >{/if}\n {#if onreport}<button\n type=\"button\"\n onclick={() => {\n if (onreport)\n requestConversationOption(\n controller,\n conversationId,\n 'report',\n onreport,\n 'reviewed_conversation_option'\n );\n }}>Report conversation</button\n >{/if}\n </details>\n{/if}\n", + sha256: + 'a33d9ffb13e28ce985799fa69342c8fa63816da70e1f9383d4e8e82f5a393c6d' + }, + 'src/lib/components/ConversationThread.svelte': { + source: + "<script lang=\"ts\">\n import { getContext, onMount, tick } from 'svelte';\n import InboxStatus from './InboxStatus.svelte';\n import Button from './primitives/Button.svelte';\n import MessageItem from './MessageItem.svelte';\n import ConversationOptions from './ConversationOptions.svelte';\n import MessageComposer from './MessageComposer.svelte';\n import {\n createReplyController,\n createRuntimeReplyController,\n selectReplyParent,\n replySnapshot,\n closeReplyController,\n type ReplyController\n } from '../messaging/reply-controller.ts';\n import {\n IDENTITY_VIEW_CONTEXT,\n identityViewSession,\n subscribeIdentityView,\n type IdentityViewContext\n } from '../runtime/view-context.ts';\n import {\n PUBLIC_RUNTIME_CONTEXT,\n publicRuntimeReady,\n type PublicRuntimeContext,\n type PublicRuntime\n } from '../runtime/public-runtime.ts';\n import {\n createRuntimeInboxSetupView,\n closeInboxSetupView\n } from '../messaging/inbox-setup-view.ts';\n import {\n createInboxView,\n inboxViewSnapshot,\n inboxViewSetup,\n subscribeInboxView,\n closeInboxView,\n inboxThreadSnapshot,\n inboxThreadRevision,\n markInboxConversationDisplayed,\n type InboxView\n } from '../messaging/inbox-view.ts';\n let {\n controller,\n conversationId\n }: { controller?: InboxView; conversationId: string } = $props();\n const identity = getContext<IdentityViewContext>(IDENTITY_VIEW_CONTEXT),\n publicContext = getContext<PublicRuntimeContext>(PUBLIC_RUNTIME_CONTEXT);\n let owned = $state.raw<InboxView | undefined>(),\n reply = $state.raw<ReplyController | undefined>(),\n model = $state(inboxThreadSnapshot(undefined, '')),\n announcement = $state(''),\n readProblem = $state(false),\n retryRevision = $state(0),\n displayedPending = $state(false);\n let runtime = $state.raw<PublicRuntime | undefined>();\n let off = () => {},\n initialized = false,\n previous = Array.from<string>([]),\n attempted = Array.from<string>([]),\n disposed = false;\n function captureReply(parent: string) {\n if (!owned) return;\n return runtime\n ? createRuntimeReplyController(owned, conversationId, parent, runtime)\n : createReplyController(owned, conversationId, parent);\n }\n function replyTo(parent: string) {\n if (reply && replySnapshot(reply)?.dirty) {\n selectReplyParent(reply, parent, 'reviewed_reply_parent');\n return;\n }\n if (reply) closeReplyController(reply);\n reply = captureReply(parent);\n }\n onMount(() => {\n let observedRevision = -2,\n observedMode = '';\n function acquire() {\n if (disposed) return;\n if (owned && inboxViewSnapshot(owned).owner) return;\n off();\n if (owned && !controller) closeInboxView(owned);\n owned = controller;\n if (!owned && runtime) {\n const session = identityViewSession(identity),\n setup = createRuntimeInboxSetupView(identity, runtime);\n if (session && setup) {\n owned = createInboxView({ identity: session, setup, conversationId });\n if (!owned) closeInboxSetupView(setup);\n }\n }\n observedRevision = -2;\n off = subscribeInboxView(owned, (panel) => {\n const revision = inboxThreadRevision(owned),\n mode = panel.state + ':' + panel.count + ':' + (panel.reason ?? '');\n if (revision === observedRevision && mode === observedMode) return;\n observedRevision = revision;\n observedMode = mode;\n const next = inboxThreadSnapshot(owned, conversationId);\n if (next.status !== 'ready') {\n if (reply) closeReplyController(reply);\n reply = undefined;\n model = next;\n announcement = '';\n readProblem = false;\n initialized = false;\n previous = [];\n attempted = [];\n return;\n }\n const ids = next.messages.map((row) => row.data.rumorId),\n added = ids.filter((id) => !previous.includes(id)).length;\n if (ids.length > 0 && initialized && added)\n announcement =\n added + (added === 1 ? ' message added.' : ' messages added.');\n if (ids.length > 0) initialized = true;\n previous = ids;\n model = next;\n if (!reply && ids.length) reply = captureReply(ids[ids.length - 1]);\n });\n }\n const identityOff = identity\n ? subscribeIdentityView(identity, acquire)\n : () => {};\n acquire();\n if (!controller && publicContext)\n void publicRuntimeReady(publicContext)\n .then((value) => {\n if (!disposed) {\n runtime = value;\n acquire();\n }\n })\n .catch(() => {});\n return () => {\n disposed = true;\n identityOff();\n off();\n if (reply) closeReplyController(reply);\n if (owned && !controller) {\n const setup = inboxViewSetup(owned);\n closeInboxView(owned);\n if (setup) closeInboxSetupView(setup);\n }\n };\n });\n $effect(() => {\n const original = owned,\n selected = conversationId,\n rows = model.messages;\n void retryRevision;\n if (!original || model.status !== 'ready' || displayedPending) return;\n const ids = rows\n .map((row) => row.data.rumorId)\n .filter((id) => !attempted.includes(id));\n if (!ids.length) return;\n attempted = attempted.concat(ids);\n displayedPending = true;\n void tick()\n .then(async () => {\n if (disposed || owned !== original || conversationId !== selected)\n return;\n const actual = inboxThreadSnapshot(original, selected);\n if (\n actual.status !== 'ready' ||\n ids.some(\n (id) => !actual.messages.some((row) => row.data.rumorId === id)\n )\n )\n return;\n const result = await markInboxConversationDisplayed(\n original,\n selected,\n ids,\n 'reviewed_displayed_conversation'\n );\n if (!disposed && owned === original && conversationId === selected)\n readProblem = !result;\n })\n .finally(() => {\n displayedPending = false;\n });\n });\n</script>\n\n{#if owned}<InboxStatus\n controller={owned}\n showLists={false}\n manageController={false}\n />{:else}<InboxStatus showLists={false} manageController={false} />{/if}\n<div class=\"page page--reading stack\">\n <h2>Conversation</h2>\n {#if owned && model.status === 'ready'}\n <ConversationOptions controller={owned} {conversationId} />\n {#each model.messages as message (message.data.rumorId)}<MessageItem\n controller={owned}\n {conversationId}\n {message}\n {runtime}\n onreply={replyTo}\n />{/each}\n {#if reply}{#key reply}<MessageComposer\n controller={reply}\n focusScope=\"conversation\"\n />{/key}{/if}\n {:else}<p>\n This conversation is unavailable until it is unlocked in the matching\n browser and account.\n </p>{/if}\n {#if readProblem}<p class=\"notice\">\n Local read status could not be confirmed. Encrypted copies are preserved.\n </p>\n <Button\n label=\"Retry local read status\"\n disabled={displayedPending}\n onclick={() => {\n attempted = [];\n readProblem = false;\n retryRevision++;\n }}\n />{/if}\n <p role=\"status\" aria-live=\"polite\" data-thread-announcement>\n {announcement}\n </p>\n <a href=\"/messages\">Back to messages</a>\n</div>\n", + sha256: + 'ae59e6c06c0c5a86a58f49abed0ac9702631a694605b2c6686dfa65db0359080' + }, + 'src/lib/components/InboxStatus.svelte': { + source: + "<script lang=\"ts\">\n import { getContext, onMount } from 'svelte';\n import { goto } from '$app/navigation';\n import { internalHref } from '../navigation-url.ts';\n import ConversationRow from './ConversationRow.svelte';\n import CapabilityGate from './CapabilityGate.svelte';\n import InboxSetup from './InboxSetup.svelte';\n import Button from './primitives/Button.svelte';\n import {\n IDENTITY_VIEW_CONTEXT,\n identityViewSnapshot,\n identityViewSession,\n subscribeIdentityView,\n connectIdentityView,\n probeIdentityViewMessaging,\n disconnectIdentityView,\n type IdentityViewContext\n } from '../runtime/view-context.ts';\n import {\n PUBLIC_RUNTIME_CONTEXT,\n publicRuntimeReady,\n type PublicRuntimeContext,\n type PublicRuntime\n } from '../runtime/public-runtime.ts';\n import {\n createRuntimeInboxSetupView,\n closeInboxSetupView\n } from '../messaging/inbox-setup-view.ts';\n import {\n createInboxView,\n inboxViewSnapshot,\n inboxListSnapshot,\n inboxListRevision,\n openInboxConversation,\n loadOlderInboxView,\n inboxViewOlderAvailable,\n inboxViewSetup,\n subscribeInboxView,\n unlockInboxView,\n checkInboxView,\n readNewInboxView,\n stopInboxView,\n closeInboxView,\n type InboxView\n } from '../messaging/inbox-view.ts';\n let {\n controller,\n showLists = true,\n manageController = true\n }: {\n controller?: InboxView;\n showLists?: boolean;\n manageController?: boolean;\n } = $props();\n const identityContext = getContext<IdentityViewContext>(\n IDENTITY_VIEW_CONTEXT\n ),\n publicContext = getContext<PublicRuntimeContext>(PUBLIC_RUNTIME_CONTEXT);\n let identity = $state(identityViewSnapshot(identityContext)),\n panel = $state(inboxViewSnapshot(undefined)),\n list = $state(inboxListSnapshot(undefined)),\n olderAvailable = $state(false),\n owned = $state.raw<InboxView | undefined>();\n let runtime: PublicRuntime | undefined,\n off = () => {};\n const setup = $derived(inboxViewSetup(owned));\n onMount(() => {\n let observedRevision = -2,\n observedMode = '';\n function updateList() {\n const revision = inboxListRevision(owned),\n mode = panel.state + ':' + panel.count + ':' + (panel.reason ?? '');\n if (revision !== observedRevision || mode !== observedMode) {\n list = inboxListSnapshot(owned);\n observedRevision = revision;\n observedMode = mode;\n }\n }\n let disposed = false;\n function acquire() {\n if (disposed) return;\n identity = identityViewSnapshot(identityContext);\n if (owned && inboxViewSnapshot(owned).owner) return;\n off();\n if (owned && !controller) {\n const oldSetup = inboxViewSetup(owned);\n closeInboxView(owned);\n if (oldSetup) closeInboxSetupView(oldSetup);\n }\n owned = controller;\n if (\n !owned &&\n runtime &&\n identity.identity.state === 'messaging_capable'\n ) {\n const session = identityViewSession(identityContext),\n originalSetup = createRuntimeInboxSetupView(identityContext, runtime);\n if (session && originalSetup) {\n owned = createInboxView({ identity: session, setup: originalSetup });\n if (!owned) closeInboxSetupView(originalSetup);\n }\n }\n panel = inboxViewSnapshot(owned);\n observedRevision = -2;\n updateList();\n olderAvailable = inboxViewOlderAvailable(owned);\n off = subscribeInboxView(owned, (next) => {\n panel = next;\n updateList();\n olderAvailable = inboxViewOlderAvailable(owned);\n });\n }\n const identityOff = identityContext\n ? subscribeIdentityView(identityContext, acquire)\n : () => {};\n acquire();\n if (manageController && !controller && publicContext)\n void publicRuntimeReady(publicContext)\n .then((value) => {\n if (disposed) return;\n runtime = value;\n acquire();\n })\n .catch(() => {\n /* Keep genuine unavailable state. */\n });\n return () => {\n disposed = true;\n identityOff();\n off();\n if (owned && !controller) {\n const originalSetup = inboxViewSetup(owned);\n closeInboxView(owned);\n if (originalSetup) closeInboxSetupView(originalSetup);\n }\n };\n });\n async function openConversation(peer: string) {\n const original = owned;\n if (!original) return;\n const result = await openInboxConversation(\n original,\n peer,\n 'reviewed_admitted_conversation_navigation'\n );\n const href = internalHref(result);\n if (owned !== original || inboxListSnapshot(original).status !== 'ready')\n return;\n if (href) void goto(href);\n }\n const effectiveIdentity = $derived(\n panel.owner ? panel.identity : identity.identity\n );\n const reasons: Record<string, string> = {\n access_unavailable:\n 'Inbox access has not been qualified and exercised. Unlocked local copies do not prove a successful relay check.',\n storage_unavailable:\n 'Browser storage is unavailable. Your inbox has not been checked.',\n unavailable:\n 'The message check could not complete. Existing encrypted copies are preserved.',\n elapsed:\n 'The bounded inbox check reached its active work limit. Existing encrypted copies are preserved.',\n budget:\n 'The bounded inbox check reached its item or size limit. Continue only after reviewing the limit.',\n declined:\n 'Your extension did not approve decryption. Choose Read new messages to try another explicit batch.',\n refused:\n 'Your extension did not approve decryption. Choose Read new messages to try another explicit batch.',\n stopped: 'Messages are locked. Existing encrypted copies are preserved.',\n wait_expired:\n 'Decryption is paused. Wait for the original extension request to settle before another explicit batch.'\n };\n const checked = $derived(\n panel.lastCheckedAt === null\n ? null\n : new Date(panel.lastCheckedAt).toLocaleTimeString()\n );\n</script>\n\n<svelte:head\n ><title>HarvestCircle</title><meta\n name=\"robots\"\n content=\"noindex\"\n /></svelte:head\n>\n<div class=\"page page--reading stack\">\n <h1>\n {effectiveIdentity.state === 'guest' ||\n effectiveIdentity.state === 'pending'\n ? 'Connect or unlock'\n : 'Messages'}\n </h1>\n {#if panel.cleanupRequired}<p class=\"notice\">\n Private resource cleanup is incomplete. Wait before reconnecting or\n starting another message action.\n </p>{/if}\n <CapabilityGate\n identity={effectiveIdentity}\n required=\"messaging\"\n focusTarget=\"protected\"\n onconnect={identity.mounted\n ? () => connectIdentityView(identityContext)\n : undefined}\n onprobe={identity.mounted\n ? () => probeIdentityViewMessaging(identityContext, 'reviewed_self_copy')\n : undefined}\n ondisconnect={() => disconnectIdentityView(identityContext)}\n />\n {#if panel.state === 'locked' || panel.state === 'unlocking'}\n <h2>Unlock your messages</h2>\n <p>\n Your extension will be asked to decrypt your messages. Each explicit batch\n checks up to 20 encrypted envelopes and may require two decryption\n approvals for each envelope. Further batches need another explicit action.\n </p>\n <Button\n label=\"Unlock messages\"\n disabled={!owned || panel.busy}\n onclick={() => {\n if (owned) void unlockInboxView(owned, 'reviewed_messages_unlock');\n }}\n />\n {/if}\n {#if panel.state === 'partial' || panel.state === 'ready' || panel.state === 'empty' || panel.state === 'unlocking'}\n <p role=\"status\" aria-live=\"polite\">\n {panel.state === 'unlocking'\n ? 'Waiting for your explicit extension approvals.'\n : panel.state === 'empty'\n ? 'No messages found in the checked inbox history.'\n : panel.state === 'partial'\n ? 'Your unlocked local messages are available with limitations.'\n : 'Messages are unlocked. Check here for replies.'}\n </p>\n {#if panel.reason}<p class=\"notice\">\n {reasons[panel.reason] ??\n 'The check is partial. Existing encrypted copies are preserved; review the limitation before continuing.'}\n </p>{/if}\n <Button\n label=\"Check for messages\"\n disabled={!owned || panel.busy}\n onclick={() => {\n if (owned) void checkInboxView(owned, 'reviewed_foreground_inbox');\n }}\n />\n {#if checked}<p>\n Last checked at {checked}. This was a bounded foreground check, not\n complete inbox history.\n </p>{/if}\n {#if panel.queued > 0}\n <p>\n {panel.queued} encrypted envelopes await an explicit decryption batch. Your\n extension will be asked to decrypt them; up to 20 envelopes are attempted\n per batch.\n </p>\n <Button\n label={'Read new messages (' + panel.queued + ')'}\n disabled={!owned || panel.busy}\n onclick={() => {\n if (owned) void readNewInboxView(owned, 'reviewed_decrypt_batch');\n }}\n />\n {/if}\n {#if showLists && owned && list.status === 'ready'}\n {#if list.requests.length > 0}<section\n class=\"stack\"\n aria-label=\"Message requests\"\n >\n <h2>Message requests</h2>\n {#each list.requests as row (row.peer)}<ConversationRow\n controller={owned}\n {row}\n onopen={openConversation}\n />{/each}\n </section>{/if}\n {#if list.conversations.length > 0}<section\n class=\"stack\"\n aria-label=\"Conversations\"\n >\n <h2>Conversations</h2>\n {#each list.conversations as row (row.peer)}<ConversationRow\n controller={owned}\n {row}\n onopen={openConversation}\n />{/each}\n </section>{/if}\n <p class=\"text-small\">\n New means locally unread in this browser. No remote read receipt or\n background message awareness is implied.\n </p>\n {/if}\n <Button\n label=\"Load older messages\"\n disabled={!owned || panel.busy || !olderAvailable}\n onclick={() => {\n if (owned) void loadOlderInboxView(owned, 'reviewed_load_older');\n }}\n />\n <Button\n label=\"Lock messages\"\n disabled={!owned}\n onclick={() => {\n if (owned) stopInboxView(owned);\n }}\n />\n {/if}\n {#key setup}<InboxSetup controller={setup} />{/key}\n <p>\n Check here for replies. This prototype does not send push or email\n notifications.\n </p>\n</div>\n", + sha256: + '29f17df1ccece671ea2ba57578dc028fa541ce924e1cdc4b3e7753da500da53f' + } + }, ...historicalPublicProducerClosure, ...historicalWithdrawalProducerClosure, 'src/routes/selling/+page.svelte': { @@ -645,7 +683,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; const f = await fixture(t); const files = await f.audit(); // Exact eleven-route module/page/static admission; CSS stays once-imported. - assert.equal(files.length, 54); + assert.equal(files.length, 55); // The actual SDK payload crosses the reader scratch boundary; a reused // scratch buffer must still preserve every compiler/static byte exactly. const sizes = await Promise.all( @@ -714,7 +752,10 @@ import { auditOutput } from '../../tools/check-output.mjs'; // Match the actual altered source identity before probing the // independent exact producer pin. The stale identity guard stays. await refresh(f); - await assert.rejects(f.audit, /inbox presentation source/); + await assert.rejects( + f.audit, + /inbox presentation source|Invalid owned private blocking source/ + ); } ); for (const mutation of [ @@ -887,7 +928,10 @@ import { auditOutput } from '../../tools/check-output.mjs'; (await readFile(file, 'utf8')) + '\n// changed source\n' ); await refresh(f); - await assert.rejects(f.audit, /inbox compiler source/); + await assert.rejects( + f.audit, + /inbox compiler source|Invalid owned private blocking source/ + ); } ); for (const name of [ @@ -929,7 +973,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; assert.ok(Buffer.byteLength(expanded) > 64 * 1024); await writeFile(file, expanded); await refresh(f); - assert.equal((await f.audit()).length, 54); + assert.equal((await f.audit()).length, 55); } ); @@ -1566,7 +1610,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned listing editor source|Invalid owned public hiding source/ + /Invalid owned listing editor source|Invalid owned public hiding source|Invalid owned private blocking source/ ); } ); @@ -1588,7 +1632,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned selling workspace source|Invalid owned public hiding source/ + /Invalid owned selling workspace source|Invalid owned public hiding source|Invalid owned private blocking source/ ); } ); @@ -1618,7 +1662,45 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned (public hiding source|root runtime activation)/ + /Invalid owned (public hiding source|private blocking source|root runtime activation)/ + ); + } + ); + } + await check( + 'private blocking rejects missing actual private-session producer', + async (t) => { + const f = await fixture(t); + await rm(path.join(f.web, 'src/lib/runtime/private-session.ts')); + await refresh(f); + await assert.rejects(f.audit); + } + ); + for (const producer of [ + 'src/lib/persistence/local-private-blocks.ts', + 'src/lib/runtime/private-session.ts', + 'src/lib/messaging/decryption-queue.ts', + 'src/lib/messaging/inbox-view.ts', + 'src/lib/messaging/cited-product.ts', + 'src/lib/components/ConversationOptions.svelte', + 'src/lib/components/ConversationThread.svelte', + 'src/lib/components/InboxStatus.svelte', + 'src/routes/privacy/+page.svelte' + ]) { + await check( + 'private blocking rejects changed owned producer ' + producer, + async (t) => { + const f = await fixture(t); + const file = path.join(f.web, producer); + await writeFile( + file, + (await readFile(file, 'utf8')) + + '\n// private blocking source mutation\n' + ); + await refresh(f); + await assert.rejects( + f.audit, + /Invalid owned (private blocking source|root runtime activation)/ ); } ); @@ -1641,7 +1723,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned listing editor activation|Invalid owned public hiding source/ + /Invalid owned listing editor activation|Invalid owned public hiding source|Invalid owned private blocking source/ ); } ); @@ -1677,8 +1759,8 @@ import { auditOutput } from '../../tools/check-output.mjs'; await assert.rejects( f.audit, producer === 'src/lib/runtime/public-runtime.ts' - ? /Invalid owned (product presentation|listing editor) source|Invalid owned public hiding source/ - : /Invalid owned product presentation source|Invalid owned public hiding source/ + ? /Invalid owned (product presentation|listing editor) source|Invalid owned public hiding source|Invalid owned private blocking source/ + : /Invalid owned product presentation source|Invalid owned public hiding source|Invalid owned private blocking source/ ); } ); @@ -1856,7 +1938,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned search presentation source|Invalid owned public hiding source/ + /Invalid owned search presentation source|Invalid owned public hiding source|Invalid owned private blocking source/ ); } ); diff --git a/web/tests/unit/inbox-view.test.ts b/web/tests/unit/inbox-view.test.ts @@ -7,6 +7,8 @@ import { readNewInboxView, inboxViewSetup, closeInboxView, + blockInboxConversation, + inboxConversationBlocked, type InboxView } from '../../src/lib/messaging/inbox-view.ts'; import { createIdentitySession } from '../../src/lib/runtime/identity-session.ts'; @@ -52,6 +54,25 @@ describe('inbox page requires original browser owners', () => { await readNewInboxView({} as InboxView, 'reviewed_decrypt_batch') ).toBe(false); }); + it('copied controllers cannot import a peer block or a private block inventory', async () => { + const copied = { ...inboxViewSnapshot(undefined) } as unknown as InboxView; + expect( + await blockInboxConversation( + copied, + '12345678-1234-4234-8234-123456789abc', + 'reviewed_local_private_block' + ) + ).toEqual({ status: 'invalid' }); + expect( + inboxConversationBlocked(copied, '12345678-1234-4234-8234-123456789abc') + ).toBe(false); + expect( + inboxConversationBlocked( + undefined, + '12345678-1234-4234-8234-123456789abc' + ) + ).toBe(false); + }); it('copied or absent owners cannot expose the shared setup token', () => { expect(inboxViewSetup(undefined)).toBeUndefined(); expect(inboxViewSetup({} as InboxView)).toBeUndefined(); diff --git a/web/tests/unit/private-blocks.test.ts b/web/tests/unit/private-blocks.test.ts @@ -0,0 +1,42 @@ +import { expect, test } from 'vitest'; +import { + createLocalPrivateBlocks, + localPrivateBlocksViewSnapshot, + closeLocalPrivateBlocksView, + localPrivateBlocksSnapshot, + localPrivatePeerAllowed, + blockLocalPrivatePeer, + undoLocalPrivatePeer, + type LocalPrivateBlocks +} from '../../src/lib/persistence/local-private-blocks.ts'; +import { createIdentityViewContext } from '../../src/lib/runtime/view-context.ts'; +import type { AdmittedConversation } from '../../src/lib/messaging/admit-conversation.ts'; +import type { UnlockedSession } from '../../src/lib/messaging/unlocked-session.ts'; + +test('SSR private preferences expose no account and acquire no browser storage', () => { + const view = createLocalPrivateBlocks(createIdentityViewContext()); + expect(localPrivateBlocksViewSnapshot(view)).toEqual({ state: 'guest' }); + closeLocalPrivateBlocksView(view); +}); + +for (const copied of [undefined, null, {}, { state: 'ready', peers: [] }]) + test(`copied private preference token has no custody: ${JSON.stringify(copied)}`, async () => { + const token = copied as LocalPrivateBlocks; + expect(localPrivateBlocksSnapshot(token)).toEqual({ state: 'unavailable' }); + expect(localPrivatePeerAllowed(token, 'a'.repeat(64))).toBe(false); + expect( + await blockLocalPrivatePeer( + token, + {} as AdmittedConversation, + {} as UnlockedSession, + 'reviewed_local_private_block' + ) + ).toEqual({ status: 'invalid' }); + expect( + await undoLocalPrivatePeer( + token, + 'a'.repeat(64), + 'reviewed_local_private_undo' + ) + ).toEqual({ status: 'invalid' }); + }); diff --git a/web/tests/unit/route-inventory.test.ts b/web/tests/unit/route-inventory.test.ts @@ -156,10 +156,16 @@ describe('thin protected route SSR', () => { } expect(render(About).body).toContain('unavailable during development.'); expect(render(Privacy).body).toContain('Hiding a publisher is local'); + expect(render(Privacy).body).toContain('Blocking a person is local'); + expect(render(Privacy).body.replace(/\s+/g, ' ')).toContain( + 'Private messages have no forward secrecy or post-compromise security.' + ); expect(render(Privacy).body.replace(/\s+/g, ' ')).toContain( 'Guest browsing does not expose an account inventory' ); - expect(render(Privacy).body).not.toMatch(/Undo hide|[0-9a-f]{64}/); + expect(render(Privacy).body).not.toMatch( + /Undo hide|Undo block|[0-9a-f]{64}/ + ); expect(render(About).body).toContain('id="help"'); const details = render(Product); expect(details.body).toContain('This food reference is invalid.'); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -231,7 +231,184 @@ export function publicHideRootIdentity(bytes) { // Compiler admission follows actual root bindings, never copied files or text // matches. This is the deliberately fixed lifecycle shape owned by HCP032. /** @param {string} web */ +async function privateBlockingAdmission(web) { + const root = publicText(await readOwned(web, 'src/routes/+layout.svelte')); + if (!root.includes('../lib/persistence/local-private-blocks.ts')) + return false; + /** @type {Record<string,string>} */ + const producers = { + 'src/lib/catalog/observations.ts': + '7386470e698156f2480de1d6c9fcffacab507f97d2f4006df926db467327120c', + 'src/lib/catalog/product-view.ts': + '3558230c9f7cd17666e27c032de4ba6f30d2fb6b4d54149a69e5b8f5dc5d5363', + 'src/lib/catalog/search-run.ts': + '213a58cf897456a0dc0e99e46594cba013952ff08212802fb471f0d323c38573', + 'src/lib/catalog/search-view.ts': + 'bc4d0160574084a547d54d5ca582b15382f44d4649c255743ebdb4c8b398f795', + 'src/lib/components/ConfirmPanel.svelte': + '9e25745303bdf408a14df5153a28e9579bfa019ab083225acb7d874e93a17d59', + 'src/lib/components/ConflictNotice.svelte': + 'f0a71cab9e8f1f12a3421402e3bc3b2f96c2ddb35ad8949c6e9599b850c3a17c', + 'src/lib/components/ConversationOptions.svelte': + 'b40915c0b11456fbc852d67591fd4c629a33d5b271e79b79dd042fcf2c0f74cb', + 'src/lib/components/ConversationRow.svelte': + 'c5d0926ac9cdda18a6befe365227dfe62405f71598f59964ff36af9a0e85d743', + 'src/lib/components/ConversationThread.svelte': + '07d7421ca00f5f0c6e68b38b790f863ca5c0d01de6567ac3875ef719b83462f4', + 'src/lib/components/InboxStatus.svelte': + 'a1015aac1d6c9ebb7a54bd5746e4cbcb4b93e376a30a2cbd7f7df212713fc930', + 'src/lib/components/ListingEditor.svelte': + '060f4863f6f4f2a4fb1471bb0d5eeedf31ab13b5c83d894f47757cf5a68099e6', + 'src/lib/components/ListingReview.svelte': + 'deee41ca6c60b346afc7ed5e62e3101ee03b04fdd2a9aa8fa3f3dec585e3863b', + 'src/lib/components/MessageComposer.svelte': + 'bc8ac0e2123b60957f1c289acbb2b8740e171097029f640f657cd79f5aa8423b', + 'src/lib/components/MessageItem.svelte': + '5c9af10ece18deeddd85e11453239c2a0b8e741cb84529e15c4ad87864704517', + 'src/lib/components/OperationStatus.svelte': + 'ca3a007899996f6331fadd2ead4c55dc7116c273626ecd2f36bcd4701065ae5f', + 'src/lib/components/PublisherHide.svelte': + '0fa30a68b44e9de68c3bb1edc9ed2c7fedefc2dc8a916c0a1df1f15440248927', + 'src/lib/components/SellingRow.svelte': + 'ce00de1bd033860b9c0a85a49c90c8a4d5b8a8223cfd5c0872572e548e79331d', + 'src/lib/config/budgets.ts': + 'e61806f1c2b580340e862b8dc7dd8063e90f74e03c64c721a7d112b0872f935d', + 'src/lib/config/deployment-relays.ts': + '14443151ff819a11a4f9c71e4ff756d1fbdd7cf6c36242ac712c378e68583aa2', + 'src/lib/config/relays.ts': + 'f54a4e91c6561cf02e5aebfb7b62a7913faa4416a5664f2d14d2e3f3f9886f55', + 'src/lib/contracts/local-records.ts': + '04ddd51339a439665a94d4a4de7b23c2257d4a673873a672d4427e9764d21f3f', + 'src/lib/contracts/public-key.ts': + 'd36d4001c2f4835e24d50f00460a35c9cf9fa6b86cc3b4a6937d8b4e10afdeb9', + 'src/lib/messaging/admit-conversation.ts': + '3e1b0044c2269eb62fa0485db61d3159e4e779e36c309278863d56cba9f677c3', + 'src/lib/messaging/cited-product.ts': + 'bed076c0902f6453971f88f107766c331b5737e488cb8c3c5f6c941e3428778d', + 'src/lib/messaging/conversation-thread.ts': + '7367f0e6d96a9f249514f66c2459274e856eb83462523e37264d4cd97d2e36d1', + 'src/lib/messaging/decryption-queue.ts': + 'be704e6cbe777722c3eb80ec9843f00afd7bac8c52af0c2af7294f2437414553', + 'src/lib/messaging/inbox-list.ts': + '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5', + 'src/lib/messaging/inbox-setup-view.ts': + '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', + 'src/lib/messaging/inbox-sync.ts': + '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', + 'src/lib/messaging/inbox-view.ts': + '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', + 'src/lib/messaging/reply-controller.ts': + 'c13f1395b5317febcd23396babbcc116065ff96e8cbeb29c8eadfdfc14e45c2d', + 'src/lib/messaging/rumor-plan.ts': + '8ecfa4b8238027f9011a657015da10cc2cc3691d03afa32b9a5064a6ccc56cd9', + 'src/lib/messaging/unlocked-session.ts': + 'b7ecc1acea5ed210b39cfe9ec82b3d02c75f6092c5c31dd3e0f79946b319ef4e', + 'src/lib/nostr/enquiry-references.ts': + 'a17175337ee53279f898a7c6fa1af7e77ad26c0d2c0da46f26a9766fa701d365', + 'src/lib/nostr/envelope-bounds.ts': + 'b1e1d4a0d0673f358321c978726747ddaba3ebf94dd65e67adac408bb6574dae', + 'src/lib/nostr/exports.ts': + '683fc933fadc515bd9999ddd337d85b408e0ad4fe891832f2825c35ffbe26f89', + 'src/lib/nostr/ingress.ts': + 'c433d459ad650c1fa9aa81aca24ddfaad8c251de9e43f92502e83fd5b673e772', + 'src/lib/nostr/listing-publisher.ts': + '10032c32482a766158d8a69027056e6a822a16b5f68ab9754b0f1cf42d0608f9', + 'src/lib/nostr/public-pool.ts': + '220b0b9ca0cea20c1a2e1a08a82fc4b68a1ba4dd6ffff1f45154b54735233806', + 'src/lib/nostr/public-store.ts': + '330f7599f601956ed44795df1e016945e3564bbb7da6491c48f628d407de3d14', + 'src/lib/nostr/request-result.ts': + '9bed0e13f94d38c3db471c0e750ef18d685776cb8832fedf7ddb7f92f663c2ac', + 'src/lib/nostr/request-scope.ts': + 'c6aa1005264e8ded37870c95f937d891afe67b8e07ef62dd137097c4ebb2388b', + 'src/lib/nostr/verified-envelope.ts': + '01eb6224ece812fcafed5203c2cd117058a3d45cb8a2175b370e8cd74cdc0f77', + 'src/lib/persistence/artifact-records.ts': + 'e3b235c5aaf19558b557feb6e17a35b2b1de39c1aa49cb2ef14084d670138d16', + 'src/lib/persistence/database.ts': + 'd37d53378f531de376fb6d1b307b9b99e54736299a04eff56a66b4036261e170', + 'src/lib/persistence/local-private-blocks.ts': + 'd7e76c1122ff5479f261293db458a3240438ce0471c788c2f07ffaf854449cbc', + 'src/lib/persistence/local-public-hides.ts': + '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', + 'src/lib/persistence/private-storage.ts': + 'e45a95c9b12e8534a6ab0a4ec8ee1c86e730bba2f252dc1947954439720f2bfc', + 'src/lib/persistence/public-publications.ts': + 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', + 'src/lib/persistence/public-receipts.ts': + '10743a9d855c4f573eb42ca90a13c550dee9620e4ad3aac322858c696152e564', + 'src/lib/persistence/quota.ts': + 'e261a7c9c81d0685021663639b1bb543192e65580edb64fa58ccbb9a4a04cc95', + 'src/lib/publishing/edit-source.ts': + '1432a8ada3d822cc9f634d40a7847a4d6d02c202ecfe59a9634543d57202f56b', + 'src/lib/publishing/editor-workflow.ts': + 'c87e4f46793fd9beeedb5027cdbb06d533cf7e5df7378c030355c4608738e0f6', + 'src/lib/publishing/listing-editor.ts': + 'fe067bc1609f783aeee8ad5a0f3178cff50cae81085377b2bbec7874b5f4349d', + 'src/lib/publishing/listing-operation-view.ts': + '07f94625c0231a62f25c1db98c9459f8939c32505453633b58d2f72a894858ce', + 'src/lib/publishing/mark-sold.ts': + '80beaf8ad38b396154d5556e50e2cf5cd9f327bcdbc05f0db1ce190bf29f7234', + 'src/lib/publishing/new-listing-readiness.ts': + 'ba76be4d7309b1a6beb0c8e0f19b89f2595049e94709486b79eff38953e68893', + 'src/lib/publishing/prepare-listing.ts': + '00b922e8b0bfc73cf5ac59857472e8dd627c8df62d28f1c646c5d7c76ce5ede9', + 'src/lib/publishing/revise-listing.ts': + '1f03d43f460feb12a02489226131ec2f7b95df5f534fcbb0b49ccc686a1b0c06', + 'src/lib/publishing/selling-view.ts': + '7d1f07c5b128512d3ed19a73409f1c64ada9988d77ac9bf60799352261797f5b', + 'src/lib/publishing/sign-listing.ts': + 'a1c123c40a190699b57378c5569fcbbfbc5e23ab4d4c0df499ca40ff82fe1a10', + 'src/lib/publishing/withdraw-listing.ts': + '168064a7ce271f8342c7b7cbbf996bd96f8968e405eee0bb3e3dba1bdaf346fb', + 'src/lib/runtime/effect-ownership.ts': + 'a181d1fa8b18d45b3e143de19af4dfdaab91779ac44df972d22e7fada645778b', + 'src/lib/runtime/identity-session.ts': + '7d665f6872bdc780f1f2b56245730adcc90f32cf1fed6997f7e2e44ea2447b49', + 'src/lib/runtime/private-session.ts': + '4ba4250e2a96c077b19144517b1f091934a124916108afe73871ccb00d9b47ab', + 'src/lib/runtime/public-runtime.ts': + '679aa4cd51a1dfdc81459bdfccb29441ac60edfa8b1ddd579425787c85b5cff4', + 'src/lib/runtime/view-context.ts': + 'e2329113e29db35e983270217c47d38a44d4e0491fd710395e008786b5ae7033', + 'src/routes/+layout.svelte': + 'b013d2d2bba40ee894c122fbb352dc78110e35ad17ec7ebb830a4556d3204ff7', + 'src/routes/messages/+page.svelte': + '8279a92770f38858e197e790839bc98b4d7889214ebecdf47e542d632afbc84f', + 'src/routes/messages/[conversationId=local_id]/+page.svelte': + 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7', + 'src/routes/privacy/+page.svelte': + 'b16f21dddcff172b837ab9980a5d8e93b59d5ddb5fa15ce463e07affdee79547', + 'src/routes/products/[naddr=naddr]/+page.svelte': + 'd3afe029ad6ed6384a300ad6719f32c324a1841271eddf9baee5b8f31f54e680', + 'src/routes/products/[naddr=naddr]/edit/+page.svelte': + '09c3a6bde766045319cd36a00a82ca565f9f3b5cd5322982be9482836f312998', + 'src/routes/sell/+page.svelte': + '97f22f9a0309621e9acb5f1b328d3376bc9c5affbe5a7ea1b85ece76097b9c08', + 'src/routes/selling/+page.svelte': + '65d982bdf3f625a38b6c886a31a2a699c92e9231636debc16d501e78d7c8faa0', + 'src/routes/selling/drafts/[draftId=local_id]/+page.svelte': + '1df59a753fbef2bc2ebf77890a79cbd3d7a5bb0dcef34c219df1b5e8043cf787' + }; + for (const [name, pin] of Object.entries(producers)) { + const bytes = await readOwned(web, name); + publicText(bytes); + const identity = + name === 'src/routes/+layout.svelte' + ? publicHideRootIdentity(bytes) + : createHash('sha256').update(bytes).digest('hex'); + if (identity !== pin) + throw new Error( + name === 'src/routes/+layout.svelte' + ? 'Invalid owned root runtime activation' + : 'Invalid owned private blocking source' + ); + } + return true; +} +/** @param {string} web */ async function publicHidingAdmission(web) { + if (await privateBlockingAdmission(web)) return true; const root = publicText(await readOwned(web, 'src/routes/+layout.svelte')); if (!root.includes('../lib/persistence/local-public-hides.ts')) return false; /** @type {Record<string,string>} */ @@ -331,6 +508,7 @@ async function publicHidingAdmission(web) { } /** @param {string} web */ async function hasOwnedPublicRuntime(web) { + if (await privateBlockingAdmission(web)) return 'public_identity'; const hasHiding = await publicHidingAdmission(web); const layout = publicText(await readOwned(web, 'src/routes/+layout.svelte')); const component = parseSvelte(layout); @@ -1257,7 +1435,10 @@ async function inboxPresentationAdmission(web) { for (const [name, pin] of Object.entries(producers)) { const bytes = await readOwned(web, name); publicText(bytes); - if (createHash('sha256').update(bytes).digest('hex') !== pin) + if ( + createHash('sha256').update(bytes).digest('hex') !== pin && + !(await privateBlockingAdmission(web)) + ) throw new Error('Invalid owned inbox presentation source'); } return true; @@ -1354,6 +1535,8 @@ export async function auditOutput(webDirectory) { ]) await readOwned(web, name); } + const hasPrivateBlocking = + hasFullRoutes && (await privateBlockingAdmission(web)); const hasPublicHiding = hasFullRoutes && (await publicHidingAdmission(web)); const hasPublicRuntime = await hasOwnedPublicRuntime(web); if (hasPublicRuntime && !hasFullRoutes) @@ -1521,6 +1704,11 @@ export async function auditOutput(webDirectory) { names.add('local-public-hides'); names.add('public-key'); } + if (hasPrivateBlocking) { + names.delete('local-public-hides'); + names.add('local-private-blocks'); + names.add('private-session'); + } const admitted = new Map([['build-info.json', expectedMetadata]]); const seen = new Set(); for (const [key, record] of Object.entries(manifest)) { @@ -3842,6 +4030,233 @@ export async function auditOutput(webDirectory) { } }); } + if (hasPrivateBlocking) { + delete expected['local-public-hides']; + Object.assign(expected, { + InboxSetup: { + file: '_app/immutable/chunks/HASH.js', + name: 'InboxSetup', + imports: ['private-session', 'client', 'Button', 'public-runtime'] + }, + InboxStatus: { + file: '_app/immutable/chunks/HASH.js', + name: 'InboxStatus', + imports: [ + 'private-session', + 'client', + 'Button', + 'public-runtime', + 'navigation', + 'CapabilityGate', + 'InboxSetup', + 'inbox-view' + ] + }, + ListingEditor: { + file: '_app/immutable/chunks/HASH.js', + name: 'ListingEditor', + imports: [ + 'public-key', + 'private-session', + 'references', + 'client', + 'Button', + 'public-runtime', + 'CapabilityGate', + 'InboxSetup', + 'OperationStatus' + ] + }, + MessageComposer: { + file: '_app/immutable/chunks/HASH.js', + name: 'MessageComposer', + imports: [ + 'public-key', + 'private-session', + 'references', + 'client', + 'Button', + 'public-runtime', + 'navigation', + 'local-private-blocks', + 'inbox-view', + 'publishers' + ] + }, + OperationStatus: { + file: '_app/immutable/chunks/HASH.js', + name: 'OperationStatus', + imports: ['public-key', 'private-session', 'client', 'public-runtime'] + }, + 'inbox-view': { + file: '_app/immutable/chunks/HASH.js', + name: 'inbox-view', + imports: [ + 'public-key', + 'private-session', + 'references', + 'Button', + 'public-runtime', + 'local-private-blocks' + ] + }, + 'local-private-blocks': { + file: '_app/immutable/chunks/HASH.js', + name: 'local-private-blocks', + imports: ['public-key', 'private-session', 'Button'] + }, + negentropy: { + file: '_app/immutable/chunks/HASH.js', + name: 'negentropy', + src: 'node_modules/.pnpm/applesauce-relay@6.2.1_typescript@6.0.3/node_modules/applesauce-relay/dist/negentropy.js', + isDynamicEntry: true, + imports: ['private-session', 'public-runtime'] + }, + 'nodes/0': { + file: '_app/immutable/nodes/0.HASH.js', + name: 'nodes/0', + src: '.svelte-kit/generated/build/client-optimized/nodes/0.js', + isEntry: true, + imports: [ + 'public-key', + 'private-session', + 'client', + 'Button', + 'public-runtime', + 'client.svelte', + 'state', + 'CapabilityGate', + 'Disclosure', + 'local-private-blocks' + ], + css: ['_app/immutable/assets/0.HASH.css'] + }, + 'nodes/11': { + file: '_app/immutable/nodes/11.HASH.js', + name: 'nodes/11', + src: '.svelte-kit/generated/build/client-optimized/nodes/11.js', + isEntry: true, + imports: [ + 'private-session', + 'references', + 'client', + 'Button', + 'public-runtime', + 'CapabilityGate', + 'Disclosure', + 'InboxSetup', + 'OperationStatus' + ] + }, + 'nodes/4': { + file: '_app/immutable/nodes/4.HASH.js', + name: 'nodes/4', + src: '.svelte-kit/generated/build/client-optimized/nodes/4.js', + isEntry: true, + imports: [ + 'private-session', + 'client', + 'CapabilityGate', + 'InboxSetup', + 'InboxStatus' + ] + }, + 'nodes/5': { + file: '_app/immutable/nodes/5.HASH.js', + name: 'nodes/5', + src: '.svelte-kit/generated/build/client-optimized/nodes/5.js', + isEntry: true, + imports: [ + 'public-key', + 'private-session', + 'references', + 'client', + 'Button', + 'public-runtime', + 'client.svelte', + 'state', + 'legacy', + 'inbox-view', + 'InboxStatus', + 'MessageComposer' + ] + }, + 'nodes/6': { + file: '_app/immutable/nodes/6.HASH.js', + name: 'nodes/6', + src: '.svelte-kit/generated/build/client-optimized/nodes/6.js', + isEntry: true, + imports: [ + 'private-session', + 'client', + 'Button', + 'local-private-blocks' + ] + }, + 'nodes/7': { + file: '_app/immutable/nodes/7.HASH.js', + name: 'nodes/7', + src: '.svelte-kit/generated/build/client-optimized/nodes/7.js', + isEntry: true, + imports: [ + 'public-key', + 'private-session', + 'references', + 'client', + 'Button', + 'public-runtime', + 'client.svelte', + 'state', + 'CapabilityGate', + 'Disclosure', + 'InboxSetup', + 'MessageComposer' + ] + }, + 'nodes/9': { + file: '_app/immutable/nodes/9.HASH.js', + name: 'nodes/9', + src: '.svelte-kit/generated/build/client-optimized/nodes/9.js', + isEntry: true, + imports: [ + 'private-session', + 'references', + 'client', + 'Button', + 'public-runtime', + 'client.svelte', + 'navigation', + 'state', + 'Disclosure', + 'SearchForm', + 'routes', + 'publishers' + ] + }, + 'private-session': { + file: '_app/immutable/chunks/HASH.js', + name: 'private-session', + imports: ['public-key', 'Button'] + }, + 'public-runtime': { + file: '_app/immutable/chunks/HASH.js', + name: 'public-runtime', + imports: [ + 'public-key', + 'preload-helper', + 'private-session', + 'references', + 'Button' + ], + dynamicImports: ['negentropy'] + }, + publishers: { + file: '_app/immutable/chunks/HASH.js', + name: 'publishers', + imports: ['public-key', 'private-session', 'Button', 'public-runtime'] + } + }); + } for (const record of Object.values(manifest)) { const actual = { ...record }; actual.file = actual.file.includes('/chunks/')