app

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

commit a5cbf6b0c98fbc60a8d9805c7d210608d23536ce
parent 981f655471aab9592ffc4ce0faccbd3f3668deff
Author: triesap <tyson@radroots.org>
Date:   Sun, 11 Oct 2026 08:35:24 +0000

web: implement privacy disclosures and scope-aware local clearing (HCP-125)

- Explain public, private and browser-local information limits.
- Review original-owner inventory before selected local deletion.
- Preserve protected pending data and retire stale cleanup actions.
- Verify native cancellation, lifecycle races and compiler provenance.

Diffstat:
Aweb/src/lib/components/LocalDataReview.svelte | 186+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/persistence/local-data-review.ts | 518+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/persistence/quota.ts | 92++++++++++++++++++++++++++++++++++++++++++++++---------------------------------
Mweb/src/routes/privacy/+page.svelte | 51+++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/local-data-review.ts | 483+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/local-data-review.spec.ts | 399+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/local-inventory.spec.ts | 47+++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 81++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------
Aweb/tests/unit/local-data-review.test.ts | 44++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 265++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
10 files changed, 2114 insertions(+), 52 deletions(-)

diff --git a/web/src/lib/components/LocalDataReview.svelte b/web/src/lib/components/LocalDataReview.svelte @@ -0,0 +1,186 @@ +<script lang="ts"> + import { onMount, untrack } from 'svelte'; + import Button from './primitives/Button.svelte'; + import { + localDataReviewSnapshot, + reviewLocalData, + previewLocalDataRemoval, + confirmLocalDataRemoval, + cancelLocalDataRemoval, + subscribeLocalDataReview, + type LocalDataReview + } from '../persistence/local-data-review.ts'; + let { review }: { review: LocalDataReview } = $props(); + let snapshot = $state.raw(untrack(() => localDataReviewSnapshot(review))); + let selectedPublic = $state.raw<string[]>([]), + selectedReceived = $state.raw<string[]>([]); + let feedback = $state<string | undefined>(); + const family = (value: string) => + value === 'public_draft' + ? 'Listing draft' + : value === 'public_operation' + ? 'Publication recovery record' + : 'Inbox preference recovery record'; + function reset() { + selectedPublic = []; + selectedReceived = []; + feedback = undefined; + } + onMount(() => { + snapshot = localDataReviewSnapshot(review); + return subscribeLocalDataReview(review, () => { + snapshot = localDataReviewSnapshot(review); + if (snapshot.state !== 'ready') reset(); + }); + }); + function toggle(category: 'public' | 'received', id: string) { + feedback = undefined; + if (category === 'public') + selectedPublic = selectedPublic.includes(id) + ? selectedPublic.filter((value) => value !== id) + : [...selectedPublic, id]; + else + selectedReceived = selectedReceived.includes(id) + ? selectedReceived.filter((value) => value !== id) + : [...selectedReceived, id]; + } + async function inspect() { + reset(); + await reviewLocalData(review, 'reviewed_local_inventory'); + } + async function preview(category: 'public' | 'received') { + const result = await previewLocalDataRemoval( + review, + category, + JSON.stringify(category === 'public' ? selectedPublic : selectedReceived) + ); + feedback = result + ? undefined + : 'Removal preview is unavailable. Review the current data and select only eligible records.'; + } + function keep() { + cancelLocalDataRemoval(review); + reset(); + } + async function confirm() { + reset(); + await confirmLocalDataRemoval(review, 'reviewed_local_removal'); + } +</script> + +<section class="stack" aria-label="Review local data"> + <h2>Local controls</h2> + <Button + label="Review data in this browser" + onclick={inspect} + disabled={snapshot.state === 'loading' || + (snapshot.state === 'ready' && snapshot.busy)} + /> + {#if snapshot.state === 'guest'} + <p> + Connect to review your account-local data. Guest browsing does not expose + an account inventory. + </p> + {:else if snapshot.state === 'loading'} + <p role="status">Checking this account’s local data…</p> + {:else if snapshot.state === 'unavailable'} + <p role="status">{snapshot.notice}</p> + {:else if snapshot.state === 'ready'} + <p>Account in this browser:</p> + <p class="key" data-local-data-owner>{snapshot.owner}</p> + <p> + Pending or uncertain work is protected. Logical byte counts describe + stored record text, not disk usage. No private message text is opened by + this inventory. + </p> + {#if snapshot.preview} + <h3>Review removal</h3> + <p> + {snapshot.preview.selected} selected {snapshot.preview.category === + 'public' + ? 'public records' + : 'encrypted received copies'}. + </p> + <p>{snapshot.preview.consequences}</p> + <div class="row"> + <Button + label="Keep data" + onclick={keep} + disabled={snapshot.busy} + /><Button + label="Confirm removal" + onclick={confirm} + disabled={snapshot.busy} + /> + </div> + {:else} + <h3>Listing drafts and publication records</h3> + {#if snapshot.publicRows.length} + <ul class="stack"> + {#each snapshot.publicRows as row (row.key)} + <li class="stack"> + <label class="row" + ><input + type="checkbox" + checked={selectedPublic.includes(row.key)} + onchange={() => toggle('public', row.key)} + disabled={row.state === 'protected' || snapshot.busy} + />{family(row.family)} · {row.logicalBytes} logical bytes · {row.state === + 'protected' + ? 'Protected' + : 'Eligible for reviewed removal'}</label + > + <p class="key">{row.id}</p> + </li> + {/each} + </ul> + {:else}<p>No public records for this account in this browser.</p>{/if} + <Button + label="Review public removal" + onclick={() => preview('public')} + disabled={!selectedPublic.length || snapshot.busy} + /> + <h3>Encrypted received copies</h3> + {#if !snapshot.receivedRemoval}<p> + Enable messaging explicitly before reviewing received-copy removal. + Reviewing data does not probe or enable messaging. + </p>{/if} + {#if snapshot.received.length} + <ul class="stack"> + {#each snapshot.received as row (row.id)}<li class="stack"> + <label class="row" + ><input + type="checkbox" + checked={selectedReceived.includes(row.id)} + onchange={() => toggle('received', row.id)} + disabled={!snapshot.receivedRemoval || snapshot.busy} + />Encrypted received copy · {row.logicalBytes} logical bytes</label + > + <p class="key">{row.id}</p> + </li>{/each} + </ul> + {:else}<p> + No encrypted received copies for this account in this browser. + </p>{/if} + <Button + label="Review received removal" + onclick={() => preview('received')} + disabled={!snapshot.receivedRemoval || + !selectedReceived.length || + snapshot.busy} + /> + <h3>Private send recovery</h3> + <p> + {snapshot.outbox.count} protected records · {snapshot.outbox.bytes} logical + bytes. This control preserves all private outbox recovery records, including + pending or uncertain work. Return to Messages for an explicit original-operation + review. + </p> + {/if} + {#if snapshot.busy}<p role="status"> + Checking the selected local action… + </p>{/if} + {#if snapshot.notice}<p role="status">{snapshot.notice}</p>{/if} + {/if} + {#if feedback}<p role="status">{feedback}</p>{/if} +</section> diff --git a/web/src/lib/persistence/local-data-review.ts b/web/src/lib/persistence/local-data-review.ts @@ -0,0 +1,518 @@ +import { + identityViewSession, + subscribeIdentityView, + type IdentityViewContext +} from '../runtime/view-context.ts'; +import { + identityLocalOwnership, + identitySessionSnapshot, + subscribeIdentityInvalidation +} from '../runtime/identity-session.ts'; +import { createPrivateSession } from '../runtime/private-session.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + type BrowserDatabase +} from './database.ts'; +import { + createPublicQuotaRepository, + inspectPublicStorage, + publicInventorySnapshot, + reviewPublicCleanup, + commitPublicCleanup, + type PublicQuotaRepository, + type PublicInventory, + type PublicCleanup +} from './quota.ts'; +import { + createPrivateStorageRepository, + inspectPrivateStorage, + listPrivateReceivedRecords, + type PrivateStorageRepository +} from './private-storage.ts'; +import { privateRecordIdentity, privateRecordWire } from './private-records.ts'; +import { + captureReceivedCleanup, + deleteReviewedReceivedCopies, + stopReceivedCleanup, + type ReceivedCleanup +} from './inbox-retention.ts'; +import { + PUBLIC_CLEANUP_CONSEQUENCES, + type PublicInventoryRow +} from './local-inventory.ts'; +import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; + +declare const reviewBrand: unique symbol; +export type LocalDataReview = Readonly<{ [reviewBrand]: true }>; +type Category = 'public' | 'received'; +type Preview = Readonly<{ + category: Category; + selected: number; + consequences: string; +}>; +type Inventory = Readonly<{ + owner: string; + publicRows: readonly PublicInventoryRow[]; + received: readonly Readonly<{ id: string; logicalBytes: number }>[]; + outbox: Readonly<{ count: number; bytes: number }>; + receivedRemoval: boolean; +}>; +export type LocalDataReviewSnapshot = + | Readonly<{ state: 'guest' | 'closed' }> + | Readonly<{ state: 'loading' }> + | Readonly<{ state: 'unavailable'; notice: string }> + | (Inventory & + Readonly<{ + state: 'ready'; + busy: boolean; + preview?: Preview; + notice?: string; + }>); +type Controller = { + snapshot(): LocalDataReviewSnapshot; + review(consent: unknown): Promise<void>; + preview(category: unknown, selection: unknown): Promise<boolean>; + confirm(consent: unknown): Promise<boolean>; + cancel(): void; + close(): void; + subscribe(listener: () => void): () => void; +}; +const reviews = new WeakMap<LocalDataReview, Controller>(); +const receivedConsequences = + 'Removing selected encrypted copies loses those local messages. Relay recovery is not guaranteed. Other participants and relays may retain copies. Outbox recovery records stay unchanged. Browser-local storage is not a backup.'; +const unavailable = + 'Local inventory or removal was not confirmed. Existing local data has not been reset. You can still browse public food. Review current data before trying again; an unknown completion may have changed selected local copies.'; + +function selection(value: unknown, maximum: number): string[] | undefined { + if ( + typeof value !== 'string' || + new TextEncoder().encode(value).length > 160000 + ) + return; + try { + const parsed: unknown = JSON.parse(value); + if ( + !Array.isArray(parsed) || + !parsed.length || + parsed.length > maximum || + !parsed.every((id: unknown) => typeof id === 'string') || + new Set(parsed).size !== parsed.length + ) + return; + return parsed.slice(); + } catch { + return; + } +} + +// Pure per-view construction. Merely visiting Privacy never opens the inventory, +// acquires an extension permission, probes messaging or creates a private socket. +export function createLocalDataReview( + context: IdentityViewContext +): LocalDataReview { + const token = Object.freeze({}) as LocalDataReview; + const listeners = new Map<symbol, () => void>(); + let closed = false, + generation = Symbol(), + busy = false; + // Whole immutable snapshots are replaced; no caller object is mutated. + let state: LocalDataReviewSnapshot; + state = { state: 'guest' }; + let ownership: ReturnType<typeof identityLocalOwnership>; + let database: BrowserDatabase | undefined, + cancellation: AbortController | undefined; + let publicRepository: PublicQuotaRepository | undefined, + inventory: PublicInventory | undefined; + let privateRepository: PrivateStorageRepository | undefined; + let publicCleanup: PublicCleanup | undefined, + receivedCleanup: ReceivedCleanup | undefined; + let offIdentity = () => {}; + function notify() { + for (const listener of listeners.values()) { + try { + listener(); + } catch { + /* Presentation cannot interrupt storage settlement. */ + } + } + } + function cancelPreview() { + publicCleanup = undefined; + if (receivedCleanup) stopReceivedCleanup(receivedCleanup); + receivedCleanup = undefined; + if (state.state === 'ready') state = { ...state, preview: undefined }; + } + function retire() { + generation = Symbol(); + cancellation?.abort(); + cancellation = undefined; + cancelPreview(); + if (database) closeBrowserDatabase(database); + database = undefined; + publicRepository = undefined; + privateRepository = undefined; + inventory = undefined; + ownership = undefined; + busy = false; + offIdentity(); + offIdentity = () => {}; + state = closed ? { state: 'closed' } : { state: 'guest' }; + } + function current(original: symbol) { + return !closed && generation === original && ownership?.current() === true; + } + function observe() { + if (ownership && !ownership.current()) { + retire(); + notify(); + } + } + const offView = subscribeIdentityView(context, observe); + async function review(consent: unknown) { + if (closed || busy || consent !== 'reviewed_local_inventory') return; + retire(); + const identity = identityViewSession(context); + const captured = identity && identityLocalOwnership(identity); + if (!identity || !captured?.current() || typeof window === 'undefined') { + notify(); + return; + } + ownership = captured; + busy = true; + cancellation = new AbortController(); + const original = generation; + offIdentity = subscribeIdentityInvalidation(identity, observe); + state = { state: 'loading' }; + notify(); + try { + const opened = await openBrowserDatabase(cancellation.signal); + if (!current(original)) { + if (opened.state === 'ready') closeBrowserDatabase(opened.owner); + return; + } + if (opened.state !== 'ready') throw Error('local storage unavailable'); + database = opened.owner; + const pub = createPublicQuotaRepository(database, captured.owner), + priv = createPrivateStorageRepository(database, captured.owner); + if (!pub || !priv) throw Error('local owner namespace unavailable'); + const scan = await inspectPublicStorage(pub); + if (!current(original)) return; + if (!scan.ok) throw Error('public inventory unavailable'); + const publicState = publicInventorySnapshot(pub, scan.value); + const received = await listPrivateReceivedRecords(priv); + if (!current(original)) return; + const outbox = await inspectPrivateStorage(priv, 'private_sends'); + if (!current(original)) return; + if (!publicState || !received.ok || !outbox.ok) + throw Error('private inventory unavailable'); + const copies = received.value.map((handle) => { + const row = privateRecordIdentity(handle), + wire = row && privateRecordWire(handle, captured.owner, row.id); + if (!row || row.owner !== captured.owner || !wire) + throw Error('received inventory unavailable'); + return { + id: row.id, + logicalBytes: new TextEncoder().encode( + JSON.stringify({ owner: captured.owner, id: row.id, wire }) + ).length + }; + }); + publicRepository = pub; + privateRepository = priv; + inventory = scan.value; + state = { + state: 'ready', + busy: false, + owner: captured.owner, + publicRows: publicState.rows, + received: copies, + outbox: outbox.value, + receivedRemoval: + identitySessionSnapshot(identity).state === 'messaging_capable' + }; + } catch { + if (current(original)) { + retire(); + state = { state: 'unavailable', notice: unavailable }; + } + } finally { + if (generation === original) busy = false; + notify(); + } + } + reviews.set(token, { + snapshot() { + observe(); + return state.state === 'ready' + ? { + ...state, + publicRows: state.publicRows.map((row) => ({ ...row })), + received: state.received.map((row) => ({ ...row })), + outbox: { ...state.outbox }, + preview: state.preview && { ...state.preview } + } + : { ...state }; + }, + review, + async preview(category, serialized) { + observe(); + if (closed || busy || state.state !== 'ready' || !ownership?.current()) + return false; + const ids = selection( + serialized, + category === 'public' + ? LOCAL_PERSISTENCE_BUDGETS.publicDrafts + + LOCAL_PERSISTENCE_BUDGETS.publicOperations + : LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes + ); + cancelPreview(); + if (!ids) { + notify(); + return false; + } + const original = generation; + if (category === 'public' && publicRepository && inventory) { + const captured = reviewPublicCleanup(publicRepository, inventory, ids); + if (!captured.ok) { + notify(); + return false; + } + publicCleanup = captured.value; + state = { + ...state, + preview: { + category, + selected: ids.length, + consequences: PUBLIC_CLEANUP_CONSEQUENCES + }, + notice: undefined + }; + notify(); + return true; + } + if ( + category !== 'received' || + !privateRepository || + !state.receivedRemoval || + !ids.every( + (id) => + state.state === 'ready' && + state.received.some((row) => row.id === id) + ) + ) { + notify(); + return false; + } + const identity = identityViewSession(context); + if (!identity) return false; + busy = true; + state = { ...state, busy: true }; + notify(); + try { + const session = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + if (!session || !current(original)) return false; + const cleanup = await captureReceivedCleanup( + privateRepository, + session, + ids, + 'reviewed_received_cleanup_selection' + ); + if (!current(original)) { + if (cleanup) stopReceivedCleanup(cleanup); + return false; + } + if (!cleanup || state.state !== 'ready') return false; + receivedCleanup = cleanup; + state = { + ...state, + preview: { + category: 'received', + selected: ids.length, + consequences: receivedConsequences + }, + notice: undefined + }; + return true; + } catch { + return false; + } finally { + if (generation === original) { + busy = false; + if (state.state === 'ready') state = { ...state, busy: false }; + } + notify(); + } + }, + async confirm(consent) { + observe(); + if ( + closed || + busy || + consent !== 'reviewed_local_removal' || + state.state !== 'ready' || + !state.preview || + !ownership?.current() || + !cancellation + ) + return false; + const original = generation, + preview = state.preview, + owner = ownership.owner; + const pub = publicCleanup, + received = receivedCleanup, + repo = publicRepository, + signal = cancellation.signal; + publicCleanup = undefined; + receivedCleanup = undefined; + busy = true; + state = { ...state, busy: true, preview: undefined }; + notify(); + let confirmed = false; + try { + if ( + preview.category === 'public' && + pub && + repo && + navigator.locks?.request + ) { + confirmed = await navigator.locks.request( + 'harvestcircle:owner:' + owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock) => { + if (!lock || !current(original)) return false; + const committed = await commitPublicCleanup(repo, pub, signal); + if (!committed.ok || !current(original)) return false; + const checked = await inspectPublicStorage(repo); + if (!checked.ok || !current(original)) return false; + const remaining = publicInventorySnapshot(repo, checked.value); + if ( + !remaining || + committed.value.some((key) => + remaining.rows.some((row) => row.key === key) + ) + ) + return false; + inventory = checked.value; + if (state.state === 'ready') + state = { ...state, publicRows: remaining.rows }; + return true; + } + ); + } else if (preview.category === 'received' && received) { + // Keep the owned action available to synchronous retirement while running. + receivedCleanup = received; + const result = await deleteReviewedReceivedCopies( + received, + 'reviewed_delete_local_received_copies' + ); + if ( + result.status === 'removed' && + current(original) && + privateRepository + ) { + const scan = await listPrivateReceivedRecords(privateRepository); + if (scan.ok && current(original) && state.state === 'ready') { + state = { + ...state, + received: state.received.filter((row) => + scan.value.some( + (handle) => privateRecordIdentity(handle)?.id === row.id + ) + ) + }; + confirmed = true; + } + } + } + } catch { + confirmed = false; + } finally { + if (received) stopReceivedCleanup(received); + if (receivedCleanup === received) receivedCleanup = undefined; + if (generation === original) { + busy = false; + if (state.state === 'ready') + state = { + ...state, + busy: false, + notice: confirmed + ? 'Removed ' + + preview.selected + + (preview.category === 'public' + ? ' selected public record' + : ' selected received encrypted copy') + + (preview.selected === 1 ? '.' : ' entries.') + + ' Other local categories and remote copies are unchanged.' + : unavailable + }; + } + notify(); + } + return confirmed; + }, + cancel() { + if (busy) return; + cancelPreview(); + notify(); + }, + close() { + if (closed) return; + closed = true; + retire(); + offView(); + notify(); + listeners.clear(); + }, + subscribe(listener) { + if (closed) return () => {}; + const id = Symbol(); + listeners.set(id, listener); + return () => { + listeners.delete(id); + }; + } + }); + return token; +} +export function localDataReviewSnapshot( + token: LocalDataReview +): LocalDataReviewSnapshot { + return reviews.get(token)?.snapshot() ?? { state: 'closed' }; +} +export async function reviewLocalData( + token: LocalDataReview, + consent: unknown +): Promise<void> { + await reviews.get(token)?.review(consent); +} +export function previewLocalDataRemoval( + token: LocalDataReview, + category: unknown, + selection: unknown +): Promise<boolean> { + return ( + reviews.get(token)?.preview(category, selection) ?? Promise.resolve(false) + ); +} +export function confirmLocalDataRemoval( + token: LocalDataReview, + consent: unknown +): Promise<boolean> { + return reviews.get(token)?.confirm(consent) ?? Promise.resolve(false); +} +export function cancelLocalDataRemoval(token: LocalDataReview): void { + reviews.get(token)?.cancel(); +} +export function closeLocalDataReview(token: LocalDataReview): void { + reviews.get(token)?.close(); +} +export function subscribeLocalDataReview( + token: LocalDataReview, + listener: () => void +): () => void { + return reviews.get(token)?.subscribe(listener) ?? (() => {}); +} diff --git a/web/src/lib/persistence/quota.ts b/web/src/lib/persistence/quota.ts @@ -146,8 +146,10 @@ function transaction<T>( rows: readonly Row[], transaction: IDBTransaction, refuse: (reason: PublicQuotaFailure) => void - ) => PublicQuotaResult<T> | undefined + ) => PublicQuotaResult<T> | undefined, + signal?: AbortSignal ): Promise<PublicQuotaResult<T>> { + if (signal?.aborted) return Promise.resolve(failed('aborted')); let active: IDBTransaction; try { active = browserDatabaseTransaction(scope.database, stores, mode); @@ -168,12 +170,20 @@ function transaction<T>( result = failed('unknown_completion'); } } - active.addEventListener('complete', () => - resolve(result ?? failed('unknown_completion')) - ); - active.addEventListener('abort', () => - resolve(result && !result.ok ? result : failed('aborted')) - ); + const cancel = () => refuse('aborted'); + signal?.addEventListener('abort', cancel, { once: true }); + active.addEventListener('complete', () => { + signal?.removeEventListener('abort', cancel); + resolve(result ?? failed('unknown_completion')); + }); + active.addEventListener('abort', () => { + signal?.removeEventListener('abort', cancel); + resolve(result && !result.ok ? result : failed('aborted')); + }); + if (signal?.aborted) { + cancel(); + return; + } function scan(index: number): void { try { const store = stores[index]; @@ -597,42 +607,48 @@ export function publicCleanupSnapshot( } export function commitPublicCleanup( repository: PublicQuotaRepository, - handle: PublicCleanup + handle: PublicCleanup, + signal?: AbortSignal ): Promise<PublicQuotaResult<readonly string[]>> { const cleanup = cleanups.get(handle), scope = scopeOf(repository); if (!scope || cleanup?.inventory.repository !== repository) return Promise.resolve(failed('invalid_scope')); - return transaction(scope, 'readwrite', (rows, active, refuse) => { - const before = cleanup.inventory.rows; - if ( - rows.length !== before.length || - rows.some( - (row, i) => - row.store !== before[i].store || - row.record.id !== before[i].record.id || - row.wire !== before[i].wire - ) - ) { - refuse('conflict'); - return; - } - const selected = rows.filter((row) => - cleanup.selected.includes(publicInventoryRow(row.record, row.bytes).key) - ); - if ( - selected.length !== cleanup.selected.length || - selected.some( - (row) => publicInventoryRow(row.record, row.bytes).state !== 'settled' - ) - ) { - refuse('protected'); - return; - } - for (const row of selected) - active.objectStore(row.store).delete([scope.owner, row.record.id]); - return { ok: true, value: Array.from(cleanup.selected) }; - }); + return transaction( + scope, + 'readwrite', + (rows, active, refuse) => { + const before = cleanup.inventory.rows; + if ( + rows.length !== before.length || + rows.some( + (row, i) => + row.store !== before[i].store || + row.record.id !== before[i].record.id || + row.wire !== before[i].wire + ) + ) { + refuse('conflict'); + return; + } + const selected = rows.filter((row) => + cleanup.selected.includes(publicInventoryRow(row.record, row.bytes).key) + ); + if ( + selected.length !== cleanup.selected.length || + selected.some( + (row) => publicInventoryRow(row.record, row.bytes).state !== 'settled' + ) + ) { + refuse('protected'); + return; + } + for (const row of selected) + active.objectStore(row.store).delete([scope.owner, row.record.id]); + return { ok: true, value: Array.from(cleanup.selected) }; + }, + signal + ); } // No signer/network await exists inside this transaction. It consumes only a diff --git a/web/src/routes/privacy/+page.svelte b/web/src/routes/privacy/+page.svelte @@ -1,6 +1,19 @@ <script lang="ts"> import { getContext, onMount } from 'svelte'; import Button from '../../lib/components/primitives/Button.svelte'; + import LocalDataReview from '../../lib/components/LocalDataReview.svelte'; + import SupportLink from '../../lib/components/SupportLink.svelte'; + import { + IDENTITY_VIEW_CONTEXT, + type IdentityViewContext + } from '../../lib/runtime/view-context.ts'; + import { + createLocalDataReview, + closeLocalDataReview + } from '../../lib/persistence/local-data-review.ts'; + const identity = getContext<IdentityViewContext>(IDENTITY_VIEW_CONTEXT); + const dataReview = createLocalDataReview(identity); + onMount(() => () => closeLocalDataReview(dataReview)); import { LOCAL_PUBLIC_HIDES_CONTEXT, PUBLIC_HIDE_DISCLOSURE, @@ -99,11 +112,47 @@ <svelte:head><title>Privacy — HarvestCircle</title></svelte:head> <div class="page page--reading stack"> <h1>Privacy</h1> + <h2>Public listings</h2> + <p> + Listing descriptions, public areas and contact details that you choose to + add are public. + </p> + <h2>Private messages</h2> + <p> + Message contents are encrypted. Participants can retain or share what they + receive. Relay operators can still see connection and routing information, + including IP addresses and authentication identity when used. + </p> + <h2>In this browser</h2> + <p> + Listing drafts and publication records are stored locally. Saved messages + are encrypted copies with limited metadata that may expose peers and times + on this device. Unsent message text is not automatically saved. Browser data + can be cleared or lost; it is not a backup. + </p> + <h2>Removing information</h2> + <p> + Clearing browser data does not remove other people's copies or guarantee + removal from relays. Local deletion does not reverse an accepted publication + or send. Actual relay retention varies; this prototype makes no universal + retention guarantee. + </p> <p> Listings are public. Relay queries can reveal your search or publisher interest; search URLs may remain in browser history and hosting logs. This prototype uses no tracking analytics. </p> + <LocalDataReview review={dataReview} /> + <details> + <summary>Encryption and device limitations</summary> + <p> + Encryption is not anonymity or protection from a compromised device, + extension or key. Messages have no forward secrecy or post-compromise + security. JavaScript cannot guarantee secure zeroization. Logout discards + private session projections; copies already shared or copied outside this + site can remain. + </p> + </details> <p>{PUBLIC_HIDE_DISCLOSURE}</p> <h2>Local publisher controls</h2> {#if snapshot.state === 'ready'} @@ -167,4 +216,6 @@ </p> {/if} {#if privateNotice}<p role="status">{privateNotice}</p>{/if} + <p>Privacy questions?</p> + <SupportLink /> </div> diff --git a/web/tests/e2e/harness/local-data-review.ts b/web/tests/e2e/harness/local-data-review.ts @@ -0,0 +1,483 @@ +// HC_TEST_ONLY_RELAY: original production UI/storage with a controlled SDK. +// No loopback or controlled provider result represents live extension Q. +import { mount, unmount } from 'svelte'; +import Panel from '../../../src/lib/components/LocalDataReview.svelte'; +import { makeFixture } from './approved-signing.ts'; +import { finalizeEvent } from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { + createIdentityViewContext, + mountIdentityView, + connectIdentityView, + probeIdentityViewMessaging, + identityViewSession, + disconnectIdentityView, + closeIdentityView +} from '../../../src/lib/runtime/view-context.ts'; +import { + createLocalDataReview, + reviewLocalData, + localDataReviewSnapshot, + previewLocalDataRemoval, + confirmLocalDataRemoval, + closeLocalDataReview +} from '../../../src/lib/persistence/local-data-review.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; +import { + createPublicDraftRepository, + createPublicDraft, + savePublicDraft +} from '../../../src/lib/persistence/drafts.ts'; +import { + createPublicQuotaRepository, + admitPublicOperation +} from '../../../src/lib/persistence/quota.ts'; +import { identityLocalOwnership } from '../../../src/lib/runtime/identity-session.ts'; +import { + createPrivateSendReservationRepository, + reservePrivateSendReservation +} from '../../../src/lib/persistence/private-send-reservations.ts'; +import { + createPrivateStorageRepository, + commitPrivateRecord, + listPrivateReceivedRecords +} from '../../../src/lib/persistence/private-storage.ts'; +import { + decodePrivateRecord, + privateRecordIdentity, + privateRecordSnapshot +} from '../../../src/lib/persistence/private-records.ts'; + +export async function createFixture(mode = 'normal') { + const signer = makeFixture(), + foreign = makeFixture(), + owner = signer.owner; + const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); + let counts = { reads: 0, signs: 0, encrypts: 0, decrypts: 0 }; + Object.defineProperty(window, 'nostr', { + configurable: true, + value: { + getPublicKey() { + counts.reads++; + return Promise.resolve(owner); + }, + signEvent(template: Parameters<typeof signer.sign>[0]) { + counts.signs++; + return Promise.resolve(signer.sign(template)); + }, + nip44: { + encrypt(_peer: string, text: string) { + counts.encrypts++; + return Promise.resolve('controlled:' + text); + }, + decrypt(_peer: string, text: string) { + counts.decrypts++; + return Promise.resolve(text.slice('controlled:'.length)); + } + } + } + }); + const identity = createIdentityViewContext(); + mountIdentityView(identity); + await connectIdentityView(identity); + if (mode === 'messaging') + await probeIdentityViewMessaging(identity, 'reviewed_self_copy'); + if (!identityViewSession(identity)) + throw Error('original connected identity absent'); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') throw Error('native database absent'); + const database = opened.owner, + drafts = createPublicDraftRepository(database, owner), + foreignDrafts = createPublicDraftRepository(database, foreign.owner), + quota = createPublicQuotaRepository(database, owner), + priv = createPrivateStorageRepository(database, owner), + foreignPriv = createPrivateStorageRepository(database, foreign.owner); + if (!drafts || !foreignDrafts || !quota || !priv || !foreignPriv) + throw Error('original namespaces absent'); + const form = { + title: 'PUBLIC DRAFT BODY SENTINEL', + description: '', + location: '', + amount: '', + currency: '', + unit: '', + quantity: '', + contactType: '' as const, + contactValue: '' + }; + const first = await createPublicDraft(drafts, form), + second = await createPublicDraft(drafts, form), + other = await createPublicDraft(foreignDrafts, { + ...form, + title: 'PRIVATE OWNER B SENTINEL' + }); + if ( + !first.ok || + !second.ok || + !other.ok || + !(await admitPublicOperation(quota, signer.id, signer.record)).ok + ) + throw Error('original public data absent'); + const outerSecret = new Uint8Array(32).fill(69), + ids: string[] = []; + try { + for (const [target, repository, offset] of [ + [owner, priv, 0], + [owner, priv, 1], + [foreign.owner, foreignPriv, 2] + ] as const) { + const key = nip44.v2.utils.getConversationKey(outerSecret, target); + let content: string; + try { + content = nip44.v2.encrypt('controlled opaque seal bytes', key); + } finally { + key.fill(0); + } + const outer = finalizeEvent( + { + kind: 1059, + created_at: 1700000000 + offset, + tags: [['p', target]], + content + }, + outerSecret + ); + const row = decodePrivateRecord( + JSON.stringify({ + schema: 1, + family: 'received_envelope', + owner: target, + id: outer.id, + revision: 0, + outer: JSON.stringify(outer), + observedAtMilliseconds: 100, + sources: ['wss://archive.example.org'], + read: null + }), + target, + outer.id + ); + if ( + !row.ok || + !(await commitPrivateRecord(repository, row.value, null)).ok + ) + throw Error('real encrypted structural copy absent'); + if (target === owner) ids.push(outer.id); + } + } finally { + outerSecret.fill(0); + } + const reservationId = crypto.randomUUID(); + const reservationWire = JSON.stringify({ + schema: 1, + family: 'private_send_reservation', + owner, + id: reservationId, + revision: 0, + peer: foreign.owner, + rumorHash: 'b'.repeat(64), + createdAt: 1700000000 + }); + const reservationRepository = createPrivateSendReservationRepository( + database, + owner + ); + const originalIdentity = identityViewSession(identity); + const ownership = + originalIdentity && identityLocalOwnership(originalIdentity); + if ( + !reservationRepository || + !ownership || + !( + await reservePrivateSendReservation( + reservationRepository, + reservationWire, + 1700000000, + ownership.current + ) + ).ok + ) + throw Error('original protected outbox absent'); + const corruptId = crypto.randomUUID(); + async function transactionRows() { + const tx = browserDatabaseTransaction( + database, + [ + 'public_drafts', + 'public_operations', + 'received_envelopes', + 'private_sends' + ], + 'readonly' + ); + const requests = [ + 'public_drafts', + 'public_operations', + 'received_envelopes', + 'private_sends' + ].map((name) => tx.objectStore(name).getAll()); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('native observation abort')) + ); + }); + return requests.map( + (request) => + request.result as { owner: string; id: string; wire: string }[] + ); + } + if (mode === 'corrupt') { + const tx = browserDatabaseTransaction( + database, + ['public_operations'], + 'readwrite' + ); + tx.objectStore('public_operations').put({ + owner, + id: corruptId, + wire: '{"schema":99}' + }); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => reject(Error('fixture seed abort'))); + }); + } + counts = { reads: 0, signs: 0, encrypts: 0, decrypts: 0 }; + const review = createLocalDataReview(identity); + const target = document.createElement('div'); + target.id = 'hcp125-panel'; + document.body.append(target); + const component = mount(Panel, { target, props: { review } }); + const inspect = () => reviewLocalData(review, 'reviewed_local_inventory'); + const preview = () => + previewLocalDataRemoval( + review, + 'public', + JSON.stringify(['public_draft:' + first.value.id]) + ); + const confirm = () => + confirmLocalDataRemoval(review, 'reviewed_local_removal'); + return { + owner, + effects: () => ({ ...counts }), + snapshot: () => localDataReviewSnapshot(review), + review: inspect, + confirm, + async reviewAndPreview() { + await inspect(); + if (!(await preview())) throw Error('original public preview absent'); + }, + async reviewAndPreviewReceived() { + await inspect(); + if ( + !(await previewLocalDataRemoval( + review, + 'received', + JSON.stringify([ids[0]]) + )) + ) + throw Error('original received preview absent'); + }, + changeDraft: () => + savePublicDraft(drafts, first.value.id, 0, { + ...form, + title: 'new actual revision' + }), + async changeReceived() { + const scan = await listPrivateReceivedRecords(priv); + if (!scan.ok) throw Error('native scan absent'); + const handle = scan.value.find( + (row) => privateRecordIdentity(row)?.id === ids[0] + ); + const row = handle && privateRecordSnapshot(handle, owner, ids[0]); + if (!handle || row?.family !== 'received_envelope') + throw Error('native selected copy absent'); + const next = decodePrivateRecord( + JSON.stringify({ + ...row, + revision: row.revision + 1, + sources: [...row.sources, 'wss://other.example.org'] + }), + owner, + row.id + ); + if (!next.ok || !(await commitPrivateRecord(priv, next.value, handle)).ok) + throw Error('real received CAS change absent'); + }, + async rows() { + const [publicRows, operations, received, outbox] = + await transactionRows(); + return { + publicDrafts: publicRows.filter((row) => row.owner === owner).length, + foreignDrafts: publicRows.filter((row) => row.owner === foreign.owner) + .length, + publicOperations: operations.filter((row) => row.owner === owner) + .length, + received: received.filter((row) => row.owner === owner).length, + foreignReceived: received.filter((row) => row.owner === foreign.owner) + .length, + outbox: outbox.filter((row) => row.owner === owner).length + }; + }, + async rawCorrupt() { + return (await transactionRows())[1].find((row) => row.id === corruptId) + ?.wire; + }, + logout: () => disconnectIdentityView(identity), + dispose: () => closeLocalDataReview(review), + async hostileSelections() { + const key = 'public_draft:' + first.value.id; + const values = [ + 'not JSON', + '[]', + JSON.stringify([key, key]), + JSON.stringify(['public_operation:' + signer.id]), + JSON.stringify(['public_draft:' + other.value.id]) + ]; + const results: boolean[] = []; + for (const value of values) + results.push(await previewLocalDataRemoval(review, 'public', value)); + return results; + }, + async confirmWhileLocked() { + let release = () => {}, + entered = () => {}; + const ready = new Promise<void>((resolve) => { + entered = resolve; + }); + const held = navigator.locks.request( + 'harvestcircle:owner:' + owner, + async () => { + entered(); + await new Promise<void>((resolve) => { + release = resolve; + }); + } + ); + await ready; + try { + return await confirm(); + } finally { + release(); + await held; + } + }, + async abortDuringDelete() { + const descriptor = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'delete' + ); + if (!descriptor) throw Error('native delete descriptor absent'); + const nativeDelete = descriptor.value as IDBObjectStore['delete']; + let deleteSuccesses = 0, + nativeAborts = 0; + let terminal: Promise<'abort' | 'complete'> | undefined; + IDBObjectStore.prototype.delete = function (...args) { + const request = nativeDelete.apply(this, args); + if (this.name === 'public_drafts') { + const transaction = this.transaction; + terminal = new Promise((resolve) => { + transaction.addEventListener('abort', () => { + nativeAborts++; + resolve('abort'); + }); + transaction.addEventListener('complete', () => resolve('complete')); + }); + request.addEventListener('success', () => { + deleteSuccesses++; + disconnectIdentityView(identity); + }); + } + return request; + }; + try { + const confirmed = await confirm(); + const nativeTerminal = terminal && (await terminal); + return { confirmed, deleteSuccesses, nativeAborts, nativeTerminal }; + } finally { + Object.defineProperty(IDBObjectStore.prototype, 'delete', descriptor); + } + }, + async oldConfirmationThenNewPreview() { + await inspect(); + if ( + !(await previewLocalDataRemoval( + review, + 'received', + JSON.stringify([ids[0]]) + )) + ) + throw Error('old actual selection absent'); + const native = navigator.locks.request.bind(navigator.locks); + let release = () => {}, + markHeld = () => {}, + held = false; + const reached = new Promise<void>((resolve) => { + markHeld = resolve; + }); + const pause = new Promise<void>((resolve) => { + release = resolve; + }); + const originalMethod = Reflect.get<LockManager, 'request'>( + navigator.locks, + 'request' + ); + navigator.locks.request = ( + name: string, + options: LockOptions | LockGrantedCallback<unknown>, + callback?: LockGrantedCallback<unknown> + ) => { + if (typeof options === 'function') return native(name, options); + if (!callback) throw Error('real callback absent'); + return native(name, options, async (lock) => { + const result: unknown = await callback(lock); + if (!held && name === 'harvestcircle:owner:' + owner && lock) { + held = true; + markHeld(); + await pause; + } + return result; + }); + }; + let old: Promise<boolean> | undefined; + try { + old = confirm(); + await reached; + disconnectIdentityView(identity); + await connectIdentityView(identity); + await probeIdentityViewMessaging(identity, 'reviewed_self_copy'); + await inspect(); + const newer = await previewLocalDataRemoval( + review, + 'received', + JSON.stringify([ids[1]]) + ); + release(); + const oldConfirmed = await old; + const currentPreview = localDataReviewSnapshot(review); + const newConfirmed = await confirm(); + return { held, newer, oldConfirmed, currentPreview, newConfirmed }; + } finally { + release(); + if (old) await old; + navigator.locks.request = originalMethod; + } + }, + async close() { + closeLocalDataReview(review); + await unmount(component); + target.remove(); + closeIdentityView(identity); + closeBrowserDatabase(database); + signer.close(); + foreign.close(); + if (prior) Object.defineProperty(window, 'nostr', prior); + else Reflect.deleteProperty(window, 'nostr'); + } + }; +} diff --git a/web/tests/e2e/local-data-review.spec.ts b/web/tests/e2e/local-data-review.spec.ts @@ -0,0 +1,399 @@ +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 { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/local-data-review.ts'; +declare global { + interface Window { + hcp125: typeof Fixture; + hcp125Fixture: Awaited<ReturnType<typeof Fixture.createFixture>>; + } +} + +test('HCP125 first-level SSR privacy discloses public encrypted local and remote limits to guests', async ({ + page +}) => { + const server = await createStaticHarness(); + try { + await page.addInitScript(() => { + Object.defineProperty(window, 'nostr', { + configurable: true, + get() { + throw Error('guest extension effect'); + } + }); + }); + await page.goto(server.url + '/privacy'); + await expect( + page.getByRole('heading', { name: 'Privacy', exact: true }) + ).toBeVisible(); + expect(await page.getByRole('heading').allTextContents()).toEqual( + expect.arrayContaining([ + 'Public listings', + 'Private messages', + 'In this browser', + 'Removing information' + ]) + ); + await expect( + page.getByText('Unsent message text is not automatically saved.', { + exact: false + }) + ).toBeVisible(); + await expect( + page.getByText('does not remove other people', { exact: false }) + ).toBeVisible(); + await expect( + page.getByRole('button', { + name: 'Review data in this browser', + exact: true + }) + ).toBeVisible(); + await page + .getByRole('button', { name: 'Review data in this browser', exact: true }) + .click(); + await expect(page.locator('[data-local-data-owner]')).toHaveCount(0); + await expect( + page.getByRole('button', { name: 'Confirm removal', exact: true }) + ).toHaveCount(0); + await expect( + page.getByRole('button', { name: /clear everything/i }) + ).toHaveCount(0); + } finally { + await server.close(); + } +}); + +test.describe('HCP125 original local data workflow and native storage', () => { + let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; + test.beforeAll(async () => { + server = await createStaticHarness(); + const entry = fileURLToPath( + new URL('./harness/local-data-review.ts', import.meta.url) + ); + const result = await build({ + configFile: false, + logLevel: 'silent', + plugins: [svelte()], + build: { + write: false, + minify: false, + rolldownOptions: { input: entry }, + lib: { entry, name: 'hcp125', formats: ['iife'] } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('actual fixture output missing'); + const chunks = output.output.filter((item) => item.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; + }); + test.afterAll(async () => server?.close()); + async function load(page: Page, mode = 'normal') { + await page.goto(server.url + '/about'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async (mode) => { + window.hcp125Fixture = await window.hcp125.createFixture(mode); + }, mode); + } + test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(async () => window.hcp125Fixture?.close()); + }); + test('explicit review is owner scoped, starts with no selection, shows protected work and does not leak draft bodies', async ({ + page + }) => { + await load(page); + expect(await page.evaluate(() => window.hcp125Fixture.effects())).toEqual({ + reads: 0, + signs: 0, + encrypts: 0, + decrypts: 0 + }); + await page + .getByRole('button', { name: 'Review data in this browser', exact: true }) + .click(); + await expect(page.locator('[data-local-data-owner]')).toHaveText( + await page.evaluate(() => window.hcp125Fixture.owner) + ); + await expect( + page.getByText('Pending or uncertain work is protected.', { + exact: false + }) + ).toBeVisible(); + await expect(page.locator('#hcp125-panel input:checked')).toHaveCount(0); + await expect(page.locator('#hcp125-panel')).not.toContainText( + 'PRIVATE OWNER B SENTINEL' + ); + await expect(page.locator('#hcp125-panel')).not.toContainText( + 'PUBLIC DRAFT BODY SENTINEL' + ); + expect(await page.evaluate(() => window.hcp125Fixture.effects())).toEqual({ + reads: 0, + signs: 0, + encrypts: 0, + decrypts: 0 + }); + }); + test('selection preview is reversible; confirmation removes only the selected public draft', async ({ + page + }) => { + await load(page); + await page + .getByRole('button', { name: 'Review data in this browser', exact: true }) + .click(); + await page + .getByRole('checkbox', { name: /Listing draft/ }) + .first() + .check(); + await page + .getByRole('button', { name: 'Review public removal', exact: true }) + .click(); + await expect( + page.getByText('does not delete remote copies', { exact: false }) + ).toBeVisible(); + await page.getByRole('button', { name: 'Keep data', exact: true }).click(); + expect( + (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts + ).toBe(2); + await page + .getByRole('checkbox', { name: /Listing draft/ }) + .first() + .check(); + await page + .getByRole('button', { name: 'Review public removal', exact: true }) + .click(); + await page + .getByRole('button', { name: 'Confirm removal', exact: true }) + .click(); + await expect(page.getByRole('status').last()).toContainText( + 'Removed 1 selected public record' + ); + const rows = await page.evaluate(() => window.hcp125Fixture.rows()); + expect(rows.publicDrafts).toBe(1); + expect(rows.foreignDrafts).toBe(1); + expect(rows.publicOperations).toBe(1); + }); + test('changed inventory refuses selected removal without resetting local data', async ({ + page + }) => { + await load(page); + await page.evaluate(() => window.hcp125Fixture.reviewAndPreview()); + await page.evaluate(() => window.hcp125Fixture.changeDraft()); + expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe( + false + ); + expect( + (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts + ).toBe(2); + expect( + await page.evaluate(() => window.hcp125Fixture.snapshot()) + ).toMatchObject({ notice: expect.stringContaining('not confirmed') }); + }); + test('logout retires inventory and preview and prevents any subsequent deletion', async ({ + page + }) => { + await load(page); + await page.evaluate(() => window.hcp125Fixture.reviewAndPreview()); + await page.evaluate(() => window.hcp125Fixture.logout()); + expect(await page.evaluate(() => window.hcp125Fixture.snapshot())).toEqual({ + state: 'guest' + }); + expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe( + false + ); + expect( + (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts + ).toBe(2); + await expect(page.locator('[data-local-data-owner]')).toHaveCount(0); + }); + test('owner invalidation after a real delete request aborts the native transaction and preserves the row', async ({ + page + }) => { + await load(page); + await page.evaluate(() => window.hcp125Fixture.reviewAndPreview()); + expect( + await page.evaluate(() => window.hcp125Fixture.abortDuringDelete()) + ).toMatchObject({ + confirmed: false, + deleteSuccesses: 1, + nativeAborts: 1, + nativeTerminal: 'abort' + }); + expect( + (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts + ).toBe(2); + }); + test('busy real owner Web Lock refuses removal without queueing or deleting', async ({ + page + }) => { + await load(page); + await page.evaluate(() => window.hcp125Fixture.reviewAndPreview()); + expect( + await page.evaluate(() => window.hcp125Fixture.confirmWhileLocked()) + ).toBe(false); + expect( + (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts + ).toBe(2); + }); + test('corrupt records refuse inventory without reset and preserve the raw sentinel', async ({ + page + }) => { + await load(page, 'corrupt'); + await page + .getByRole('button', { name: 'Review data in this browser', exact: true }) + .click(); + await expect(page.getByRole('status').last()).toContainText( + 'Existing local data has not been reset' + ); + expect(await page.evaluate(() => window.hcp125Fixture.rawCorrupt())).toBe( + '{"schema":99}' + ); + await expect( + page.getByRole('button', { name: 'Confirm removal', exact: true }) + ).toHaveCount(0); + }); + test('disposal retires original selection and rejects confirmation', async ({ + page + }) => { + await load(page); + await page.evaluate(() => window.hcp125Fixture.reviewAndPreview()); + await page.evaluate(() => window.hcp125Fixture.dispose()); + expect(await page.evaluate(() => window.hcp125Fixture.snapshot())).toEqual({ + state: 'closed' + }); + expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe( + false + ); + expect( + (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts + ).toBe(2); + }); + test('malformed duplicate protected or cross-account selections cannot mint a cleanup preview', async ({ + page + }) => { + await load(page); + await page.evaluate(() => window.hcp125Fixture.review()); + expect( + await page.evaluate(() => window.hcp125Fixture.hostileSelections()) + ).toEqual([false, false, false, false, false]); + expect( + (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts + ).toBe(2); + }); + test('selected received encrypted copy removal preserves outbox other copies and other accounts without decrypting', async ({ + page + }) => { + await load(page, 'messaging'); + await page + .getByRole('button', { name: 'Review data in this browser', exact: true }) + .click(); + await page + .getByRole('checkbox', { name: /Encrypted received copy/ }) + .first() + .check(); + await page + .getByRole('button', { name: 'Review received removal', exact: true }) + .click(); + await expect( + page.getByText('Relay recovery is not guaranteed.', { exact: false }) + ).toBeVisible(); + await page + .getByRole('button', { name: 'Confirm removal', exact: true }) + .click(); + await expect(page.getByRole('status').last()).toContainText( + 'Removed 1 selected received encrypted copy' + ); + expect( + await page.evaluate(() => window.hcp125Fixture.rows()) + ).toMatchObject({ + received: 1, + foreignReceived: 1, + outbox: 1, + publicDrafts: 2 + }); + expect( + await page.evaluate(() => window.hcp125Fixture.effects()) + ).toMatchObject({ signs: 0, encrypts: 0, decrypts: 0 }); + }); + test('signing-only metadata review does not probe messaging or enable received removal', async ({ + page + }) => { + await load(page); + await page + .getByRole('button', { name: 'Review data in this browser', exact: true }) + .click(); + await expect( + page.getByText( + 'Enable messaging explicitly before reviewing received-copy removal.', + { exact: false } + ) + ).toBeVisible(); + await expect( + page.getByRole('checkbox', { name: /Encrypted received copy/ }).first() + ).toBeDisabled(); + expect(await page.evaluate(() => window.hcp125Fixture.effects())).toEqual({ + reads: 0, + signs: 0, + encrypts: 0, + decrypts: 0 + }); + }); + test('stale selected received full wire refuses deletion and preserves the changed copy', async ({ + page + }) => { + await load(page, 'messaging'); + await page.evaluate(() => window.hcp125Fixture.reviewAndPreviewReceived()); + await page.evaluate(() => window.hcp125Fixture.changeReceived()); + expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe( + false + ); + expect( + await page.evaluate(() => window.hcp125Fixture.rows()) + ).toMatchObject({ received: 2, foreignReceived: 1, outbox: 1 }); + }); + test('held old confirmation cannot retire a new original-generation received preview after reconnect', async ({ + page + }) => { + await load(page, 'messaging'); + const result = await page.evaluate(() => + window.hcp125Fixture.oldConfirmationThenNewPreview() + ); + expect(result).toMatchObject({ + held: true, + newer: true, + oldConfirmed: false, + newConfirmed: true, + currentPreview: { + state: 'ready', + preview: { category: 'received', selected: 1 } + } + }); + expect( + await page.evaluate(() => window.hcp125Fixture.rows()) + ).toMatchObject({ + received: 0, + foreignReceived: 1, + outbox: 1, + publicDrafts: 2 + }); + }); + for (const width of [320, 1024]) + test('local review fits viewport ' + width, async ({ page }) => { + await page.setViewportSize({ width, height: 900 }); + await load(page); + await page + .getByRole('button', { + name: 'Review data in this browser', + exact: true + }) + .click(); + await expect(page.locator('[data-local-data-owner]')).toBeVisible(); + expect( + await page.evaluate( + () => document.documentElement.scrollWidth <= window.innerWidth + ) + ).toBe(true); + }); +}); diff --git a/web/tests/e2e/local-inventory.spec.ts b/web/tests/e2e/local-inventory.spec.ts @@ -34,6 +34,53 @@ const form = { contactType: '' as const, contactValue: '' }; +test('explicit cleanup cancellation before admission acquires no transaction and retains the original draft', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async (form) => { + const api = window.hcp049; + const draft = await api.createPublicDraft(window.hcp049Repository, form); + if (!draft.ok) throw Error('original draft absent'); + const scan = await api.inspectPublicStorage(window.hcp049Quota); + if (!scan.ok) throw Error('original inventory absent'); + const cleanup = api.reviewPublicCleanup(window.hcp049Quota, scan.value, [ + 'public_draft:' + draft.value.id + ]); + if (!cleanup.ok) throw Error('original cleanup absent'); + const cancellation = new AbortController(); + cancellation.abort(); + const descriptor = Object.getOwnPropertyDescriptor( + IDBDatabase.prototype, + 'transaction' + ); + if (!descriptor) throw Error('native transaction method absent'); + const native = descriptor.value as IDBDatabase['transaction']; + let acquisitions = 0; + IDBDatabase.prototype.transaction = function (...args) { + acquisitions++; + return native.apply(this, args); + }; + let committed: Awaited<ReturnType<typeof api.commitPublicCleanup>>; + try { + committed = await api.commitPublicCleanup( + window.hcp049Quota, + cleanup.value, + cancellation.signal + ); + } finally { + Object.defineProperty(IDBDatabase.prototype, 'transaction', descriptor); + } + const retained = await api.readPublicDraft( + window.hcp049Repository, + draft.value.id + ); + return { committed, acquisitions, retained, original: draft }; + }, form); + expect(result.committed).toEqual({ ok: false, reason: 'aborted' }); + expect(result.acquisitions).toBe(0); + expect(result.retained).toEqual(result.original); +}); let server: Awaited<ReturnType<typeof createStaticHarness>>; let bundle: string; test.beforeAll(async () => { diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -131,6 +131,20 @@ import { auditOutput } from '../../tools/check-output.mjs'; async function restoreHistoricalPublicProducers(web) { for (const [name, value] of Object.entries({ ...{ + 'src/routes/privacy/+page.svelte': { + source: + "<script lang=\"ts\">\n import { getContext, onMount } from 'svelte';\n import Button from '../../lib/components/primitives/Button.svelte';\n import {\n LOCAL_PUBLIC_HIDES_CONTEXT,\n PUBLIC_HIDE_DISCLOSURE,\n localPublicHidesSnapshot,\n subscribeLocalPublicHides,\n undoLocalPublicPublisher,\n type LocalPublicHides\n } from '../../lib/persistence/local-public-hides.ts';\n const hides = getContext<LocalPublicHides | undefined>(\n LOCAL_PUBLIC_HIDES_CONTEXT\n );\n import {\n LOCAL_PRIVATE_BLOCKS_CONTEXT,\n PRIVATE_BLOCK_DISCLOSURE,\n localPrivateBlocksViewSnapshot,\n subscribeLocalPrivateBlocksView,\n undoLocalPrivateBlocksView,\n type LocalPrivateBlocksView\n } from '../../lib/persistence/local-private-blocks.ts';\n const blocks = getContext<LocalPrivateBlocksView | undefined>(\n LOCAL_PRIVATE_BLOCKS_CONTEXT\n );\n let privateSnapshot = $state.raw(\n blocks\n ? localPrivateBlocksViewSnapshot(blocks)\n : { state: 'guest' as const }\n );\n let privateNotice = $state<string | undefined>();\n let privateBusy = $state(false);\n onMount(() => {\n if (!blocks) return;\n privateSnapshot = localPrivateBlocksViewSnapshot(blocks);\n return subscribeLocalPrivateBlocksView(blocks, () => {\n privateSnapshot = localPrivateBlocksViewSnapshot(blocks);\n privateNotice = undefined;\n });\n });\n async function undoBlock(peer: string) {\n if (!blocks || privateBusy || privateSnapshot.state !== 'ready') return;\n const owner = privateSnapshot.owner;\n privateBusy = true;\n const result = await undoLocalPrivateBlocksView(\n blocks,\n peer,\n 'reviewed_local_private_undo'\n );\n if (!alive) return;\n privateBusy = false;\n const current = localPrivateBlocksViewSnapshot(blocks);\n if (current.state !== 'ready' || current.owner !== owner) return;\n privateNotice =\n result.status === 'saved' || result.status === 'existing'\n ? 'Block undone. Eligible local views can be shown again. Another explicit bounded decryption action may be needed; Undo starts no message work.'\n : 'Undo was not confirmed. Existing local data has not been reset.';\n }\n let snapshot = $state.raw(\n hides ? localPublicHidesSnapshot(hides) : { state: 'guest' as const }\n );\n let notice = $state<string | undefined>(),\n busy = $state(false);\n let alive = false;\n onMount(() => {\n alive = true;\n const off = hides\n ? subscribeLocalPublicHides(hides, () => {\n snapshot = localPublicHidesSnapshot(hides);\n notice = undefined;\n })\n : () => {};\n if (hides) snapshot = localPublicHidesSnapshot(hides);\n return () => {\n alive = false;\n off();\n };\n });\n async function undo(publisher: string) {\n if (!hides || busy || snapshot.state !== 'ready') return;\n const owner = snapshot.owner;\n busy = true;\n const result = await undoLocalPublicPublisher(\n hides,\n publisher,\n 'reviewed_local_public_undo'\n );\n if (!alive) return;\n busy = false;\n const current = localPublicHidesSnapshot(hides);\n if (current.state !== 'ready' || current.owner !== owner) return;\n notice =\n result.status === 'saved' || result.status === 'existing'\n ? 'Hide undone. Eligible public listings can be shown again; operator policy still applies.'\n : 'Undo was not confirmed. Existing local data has not been reset.';\n }\n</script>\n\n<svelte:head><title>Privacy \u2014 HarvestCircle</title></svelte:head>\n<div class=\"page page--reading stack\">\n <h1>Privacy</h1>\n <p>\n Listings are public. Relay queries can reveal your search or publisher\n interest; search URLs may remain in browser history and hosting logs. This\n prototype uses no tracking analytics.\n </p>\n <p>{PUBLIC_HIDE_DISCLOSURE}</p>\n <h2>Local publisher controls</h2>\n {#if snapshot.state === 'ready'}\n {#if snapshot.publishers.length}\n <ul class=\"stack\">\n {#each snapshot.publishers as publisher (publisher)}\n <li class=\"stack\">\n <p class=\"key\">{publisher}</p>\n <Button\n label=\"Undo hide\"\n onclick={() => undo(publisher)}\n disabled={busy}\n />\n </li>\n {/each}\n </ul>\n {:else}<p>No publishers hidden for this account in this browser.</p>{/if}\n {:else if snapshot.state === 'guest'}\n <p>\n Connect to review your account-local publisher preferences. Guest browsing\n does not expose an account inventory.\n </p>\n {:else if snapshot.state === 'loading'}\n <p>Checking local publisher preferences\u2026</p>\n {:else}\n <p class=\"notice\">\n Local preferences could not be checked. You can still browse public food.\n Existing local data has not been reset; previous hides are unconfirmed.\n </p>\n {/if}\n {#if notice}<p role=\"status\">{notice}</p>{/if}\n <p>{PRIVATE_BLOCK_DISCLOSURE}</p>\n <h2>Local private blocks</h2>\n {#if privateSnapshot.state === 'ready'}\n {#if privateSnapshot.peers.length}\n <ul class=\"stack\">\n {#each privateSnapshot.peers as peer (peer)}\n <li class=\"stack\">\n <p class=\"key\">{peer}</p>\n <Button\n label=\"Undo block\"\n onclick={() => undoBlock(peer)}\n disabled={privateBusy}\n />\n </li>\n {/each}\n </ul>\n {:else}<p>No people blocked for this account in this browser.</p>{/if}\n {:else if privateSnapshot.state === 'guest'}\n <p>\n Connect to review account-local blocks. Guest browsing does not expose a\n private inventory.\n </p>\n {:else if privateSnapshot.state === 'loading'}\n <p>Checking local private block preferences\u2026</p>\n {:else}\n <p class=\"notice\">\n Local private preferences could not be checked. Previous blocks are\n unconfirmed; private rendering and decryption continuation are\n unavailable. Existing local data has not been reset.\n </p>\n {/if}\n {#if privateNotice}<p role=\"status\">{privateNotice}</p>{/if}\n</div>\n", + sha256: + 'b16f21dddcff172b837ab9980a5d8e93b59d5ddb5fa15ce463e07affdee79547' + }, + 'src/lib/persistence/quota.ts': { + source: + "import { canonicalPublicKey } from '../contracts/public-key.ts';\nimport {\n exactLocalFields,\n type PublicRecord,\n type PublicDraftRecord\n} from '../contracts/local-records.ts';\nimport { canonicalLocalId } from '../private-handles.ts';\nimport { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts';\nimport {\n browserDatabaseState,\n browserDatabaseTransaction,\n type BrowserDatabase\n} from './database.ts';\nimport {\n decodePublicRecord,\n publicRecordSnapshot,\n publicRecordWire,\n type PublicRecordHandle\n} from './records.ts';\nimport {\n publicInventoryRow,\n PUBLIC_CLEANUP_CONSEQUENCES,\n type PublicInventoryRow\n} from './local-inventory.ts';\n\nimport {\n publicTransitionIdentity,\n publicTransitionSnapshot,\n type PublicOperationTransition\n} from './artifact-records.ts';\nimport { decideFrozenTransition } from './operation-transactions.ts';\nimport { inspectLocalTemplate } from '../nostr/local-template.ts';\n\ndeclare const repositoryBrand: unique symbol;\ndeclare const inventoryBrand: unique symbol;\ndeclare const cleanupBrand: unique symbol;\nexport type PublicQuotaRepository = Readonly<{ [repositoryBrand]: true }>;\nexport type PublicInventory = Readonly<{ [inventoryBrand]: true }>;\nexport type PublicCleanup = Readonly<{ [cleanupBrand]: true }>;\nexport type PublicQuotaFailure =\n | 'invalid_scope'\n | 'invalid_record'\n | 'invalid_selection'\n | 'protected'\n | 'conflict'\n | 'capacity'\n | 'corrupt_record'\n | 'unavailable'\n | 'aborted'\n | 'unknown_completion';\nexport type PublicQuotaResult<T> =\n | Readonly<{ ok: true; value: T }>\n | Readonly<{ ok: false; reason: PublicQuotaFailure }>;\ntype Scope = Readonly<{ database: BrowserDatabase; owner: string }>;\ntype Store = 'public_drafts' | 'public_operations' | 'preference_operations';\ntype Row = Readonly<{\n store: Store;\n wire: string;\n record: PublicRecord;\n bytes: number;\n}>;\ntype Inspection = Readonly<{\n repository: PublicQuotaRepository;\n rows: readonly Row[];\n}>;\ntype Cleanup = Readonly<{ inventory: Inspection; selected: readonly string[] }>;\nconst repositories = new WeakMap<PublicQuotaRepository, Scope>();\nconst inventories = new WeakMap<PublicInventory, Inspection>();\nconst cleanups = new WeakMap<PublicCleanup, Cleanup>();\nconst stores: readonly Store[] = [\n 'public_drafts',\n 'public_operations',\n 'preference_operations'\n];\nfunction failed(reason: PublicQuotaFailure): PublicQuotaResult<never> {\n return { ok: false, reason };\n}\nfunction scopeOf(repository: PublicQuotaRepository): Scope | undefined {\n const scope = repositories.get(repository);\n try {\n return scope && browserDatabaseState(scope.database).state === 'ready'\n ? scope\n : undefined;\n } catch {\n return undefined;\n }\n}\n// Metadata only; this does not grant installed-account or effect authority.\nexport function publicQuotaOwner(\n repository: PublicQuotaRepository\n): string | undefined {\n return scopeOf(repository)?.owner;\n}\n// A namespace capability only; installed-account authorization belongs to the\n// account workflow. This repository never acquires any private store.\nexport function createPublicQuotaRepository(\n database: BrowserDatabase,\n expectedOwner: unknown\n): PublicQuotaRepository | undefined {\n const owner = canonicalPublicKey(expectedOwner);\n try {\n if (!owner || browserDatabaseState(database).state !== 'ready')\n return undefined;\n const handle = Object.freeze({}) as PublicQuotaRepository;\n repositories.set(handle, { database, owner });\n return handle;\n } catch {\n return undefined;\n }\n}\nfunction stored(\n value: unknown,\n store: Store,\n owner: string,\n id: string\n): Row | undefined {\n if (\n !exactLocalFields(value, ['owner', 'id', 'wire']) ||\n value.owner !== owner ||\n value.id !== id ||\n typeof value.wire !== 'string'\n )\n return undefined;\n const admitted = decodePublicRecord(value.wire, owner, id);\n if (!admitted.ok) return undefined;\n const record = publicRecordSnapshot(admitted.value, owner, id);\n const family =\n store === 'public_drafts'\n ? 'public_draft'\n : store === 'public_operations'\n ? 'public_operation'\n : 'preference_operation';\n return record?.family === family\n ? {\n store,\n record,\n wire: value.wire,\n bytes: new TextEncoder().encode(value.wire).length\n }\n : undefined;\n}\nfunction transaction<T>(\n scope: Scope,\n mode: 'readonly' | 'readwrite',\n finish: (\n rows: readonly Row[],\n transaction: IDBTransaction,\n refuse: (reason: PublicQuotaFailure) => void\n ) => PublicQuotaResult<T> | undefined\n): Promise<PublicQuotaResult<T>> {\n let active: IDBTransaction;\n try {\n active = browserDatabaseTransaction(scope.database, stores, mode);\n } catch {\n return Promise.resolve(failed('unavailable'));\n }\n return new Promise((resolve) => {\n let result: PublicQuotaResult<T> | undefined;\n let rows = Array.from<Row>([]),\n draftCount = 0,\n operationCount = 0,\n operationBytes = 0;\n function refuse(reason: PublicQuotaFailure) {\n result = failed(reason);\n try {\n active.abort();\n } catch {\n result = failed('unknown_completion');\n }\n }\n active.addEventListener('complete', () =>\n resolve(result ?? failed('unknown_completion'))\n );\n active.addEventListener('abort', () =>\n resolve(result && !result.ok ? result : failed('aborted'))\n );\n function scan(index: number): void {\n try {\n const store = stores[index];\n if (store === undefined) {\n const finished = finish(rows, active, refuse);\n if (finished !== undefined) result = finished;\n return;\n }\n const request = active\n .objectStore(store)\n .index('by_owner')\n .openCursor(IDBKeyRange.only(scope.owner));\n request.addEventListener('success', () => {\n try {\n const cursor = request.result;\n if (!cursor) {\n scan(index + 1);\n return;\n }\n const key = cursor.primaryKey;\n const id =\n Array.isArray(key) && key.length === 2 && key[0] === scope.owner\n ? canonicalLocalId(key[1])\n : undefined;\n const row = id && stored(cursor.value, store, scope.owner, id);\n if (!row) {\n refuse('corrupt_record');\n return;\n }\n if (row.record.family === 'public_draft') draftCount++;\n else {\n operationCount++;\n operationBytes += row.bytes;\n }\n if (\n draftCount > LOCAL_PERSISTENCE_BUDGETS.publicDrafts ||\n operationCount > LOCAL_PERSISTENCE_BUDGETS.publicOperations ||\n operationBytes > LOCAL_PERSISTENCE_BUDGETS.publicOperationBytes\n ) {\n refuse('capacity');\n return;\n }\n rows = rows.concat(row);\n cursor.continue();\n } catch {\n refuse('aborted');\n }\n });\n } catch {\n refuse('aborted');\n }\n }\n scan(0);\n });\n}\n// Explicit new-row admission only. Artifact/CAS transitions retain HCP050.\n// Logical bytes include the exact stored record wire, not browser disk/heap use.\nexport function admitPublicOperation(\n repository: PublicQuotaRepository,\n expectedId: unknown,\n handle: PublicRecordHandle\n): Promise<PublicQuotaResult<Readonly<{ id: string; revision: number }>>> {\n const scope = scopeOf(repository),\n id = canonicalLocalId(expectedId);\n if (!scope) return Promise.resolve(failed('invalid_scope'));\n if (!id) return Promise.resolve(failed('invalid_record'));\n const record = publicRecordSnapshot(handle, scope.owner, id),\n wire = publicRecordWire(handle, scope.owner, id);\n if (\n !record ||\n !wire ||\n record.family === 'public_draft' ||\n record.revision !== 0\n )\n return Promise.resolve(failed('invalid_record'));\n const store: Store =\n record.family === 'public_operation'\n ? 'public_operations'\n : 'preference_operations';\n const bytes = new TextEncoder().encode(wire).length;\n return transaction(scope, 'readwrite', (rows, active, refuse) => {\n const previous = rows.find(\n (row) => row.store === store && row.record.id === id\n );\n if (previous)\n return previous.wire === wire\n ? { ok: true, value: { id, revision: 0 } }\n : (refuse('conflict'), undefined);\n const operations = rows.filter(\n (row) => row.record.family !== 'public_draft'\n );\n if (\n operations.length >= LOCAL_PERSISTENCE_BUDGETS.publicOperations ||\n operations.reduce((sum, row) => sum + row.bytes, bytes) >\n LOCAL_PERSISTENCE_BUDGETS.publicOperationBytes\n ) {\n refuse('capacity');\n return;\n }\n active.objectStore(store).put({ owner: scope.owner, id, wire });\n return { ok: true, value: { id, revision: 0 } };\n });\n}\n// Claim under the caller's origin/author Web Lock. A previous capture is never\n// overwritten or automatically signed again, even after a page lost its lock.\n// No extension/network await occurs inside the short transaction.\nexport function claimPublicOperation(\n repository: PublicQuotaRepository,\n expectedId: unknown,\n handle: PublicRecordHandle\n): Promise<\n PublicQuotaResult<\n Readonly<{ state: 'created' | 'existing'; record: PublicRecordHandle }>\n >\n> {\n return claimOperation(repository, expectedId, handle);\n}\ntype DraftAdmission = Readonly<{\n expected: PublicDraftRecord;\n current(this: void): boolean;\n draftCurrent(this: void): boolean;\n revisionBase?: Readonly<{ command: string; record: PublicRecordHandle }>;\n}>;\n// Storage-only atomic draft/CAS reservation. Current original account/review\n// ownership is supplied by the public listing command owner, never a UI flag.\n// Existing commands retain their original capture even after future draft edits.\nexport function claimPublicDraftOperation(\n repository: PublicQuotaRepository,\n expectedId: unknown,\n handle: PublicRecordHandle,\n admission: DraftAdmission\n): Promise<\n PublicQuotaResult<\n Readonly<{ state: 'created' | 'existing'; record: PublicRecordHandle }>\n >\n> {\n return claimOperation(repository, expectedId, handle, admission);\n}\nfunction claimOperation(\n repository: PublicQuotaRepository,\n expectedId: unknown,\n handle: PublicRecordHandle,\n draft?: DraftAdmission\n): Promise<\n PublicQuotaResult<\n Readonly<{ state: 'created' | 'existing'; record: PublicRecordHandle }>\n >\n> {\n const scope = scopeOf(repository),\n id = canonicalLocalId(expectedId);\n if (!scope) return Promise.resolve(failed('invalid_scope'));\n if (!id) return Promise.resolve(failed('invalid_record'));\n const record = publicRecordSnapshot(handle, scope.owner, id),\n wire = publicRecordWire(handle, scope.owner, id);\n if (\n !record ||\n !wire ||\n record.family === 'public_draft' ||\n record.revision !== 0 ||\n record.artifact !== null\n )\n return Promise.resolve(failed('invalid_record'));\n const store: Store =\n record.family === 'public_operation'\n ? 'public_operations'\n : 'preference_operations';\n const bytes = new TextEncoder().encode(wire).length;\n return transaction<\n Readonly<{ state: 'created' | 'existing'; record: PublicRecordHandle }>\n >(scope, 'readwrite', (rows, active, refuse) => {\n if (draft && !draft.current()) {\n refuse('unavailable');\n return;\n }\n const previous = rows.find(\n (row) => row.record.family !== 'public_draft' && row.record.id === id\n );\n if (previous) {\n const original = previous.record;\n if (\n original.family === 'public_draft' ||\n original.family !== record.family ||\n JSON.stringify(original.source) !== JSON.stringify(record.source) ||\n JSON.stringify(original.capture) !== JSON.stringify(record.capture) ||\n ('consent' in original ? original.consent : null) !==\n ('consent' in record ? record.consent : null)\n ) {\n refuse('conflict');\n return;\n }\n const decoded = decodePublicRecord(previous.wire, scope.owner, id);\n if (!decoded.ok) {\n refuse('corrupt_record');\n return;\n }\n return { ok: true, value: { state: 'existing', record: decoded.value } };\n }\n if (draft) {\n if (draft.revisionBase) {\n const revisionBase = draft.revisionBase;\n const witness = publicRecordSnapshot(\n revisionBase.record,\n scope.owner,\n revisionBase.command\n );\n const base = rows.find(\n (row) =>\n row.record.family === 'public_operation' &&\n row.record.id === revisionBase.command\n )?.record;\n const oldTemplate =\n witness?.family === 'public_operation' &&\n inspectLocalTemplate(witness.capture.wire, scope.owner, 30402);\n const nextTemplate =\n record.family === 'public_operation' &&\n inspectLocalTemplate(\n record.capture.wire,\n scope.owner,\n record.capture.kind\n );\n const tag = (\n template: NonNullable<ReturnType<typeof inspectLocalTemplate>>,\n key: string\n ) => template.tags.find((value) => value[0] === key)?.[1];\n if (\n !witness ||\n witness.family !== 'public_operation' ||\n !witness.artifact ||\n !base ||\n base.family !== 'public_operation' ||\n !oldTemplate ||\n !nextTemplate ||\n JSON.stringify(base.source) !== JSON.stringify(witness.source) ||\n JSON.stringify(base.capture) !== JSON.stringify(witness.capture) ||\n JSON.stringify(base.artifact) !== JSON.stringify(witness.artifact) ||\n (nextTemplate.kind === 5\n ? record.family !== 'public_operation' ||\n record.source.type !== 'public_head' ||\n record.source.wire !== witness.artifact.wire ||\n JSON.stringify(nextTemplate.tags) !==\n JSON.stringify([\n ['e', witness.artifact.eventId],\n ['a', `30402:${scope.owner}:${tag(oldTemplate, 'd')}`],\n ['k', '30402']\n ]) ||\n nextTemplate.content !== ''\n : tag(oldTemplate, 'd') !== tag(nextTemplate, 'd') ||\n tag(oldTemplate, 'published_at') !==\n tag(nextTemplate, 'published_at')) ||\n nextTemplate.created_at <= oldTemplate.created_at ||\n rows.some((row) => {\n if (\n row.record.family !== 'public_operation' ||\n row.record.id === base.id\n )\n return false;\n const other = inspectLocalTemplate(\n row.record.capture.wire,\n scope.owner,\n row.record.capture.kind\n );\n return (\n !!other &&\n (other.kind === 5\n ? other.tags.some(\n (value) =>\n (value[0] === 'e' &&\n value[1] === witness.artifact!.eventId) ||\n (value[0] === 'a' &&\n value[1] ===\n `30402:${scope.owner}:${tag(oldTemplate, 'd')}`)\n ) && other.created_at >= oldTemplate.created_at\n : tag(other, 'd') === tag(oldTemplate, 'd') &&\n other.created_at >= oldTemplate.created_at)\n );\n })\n ) {\n refuse('conflict');\n return;\n }\n }\n const source =\n record.family === 'public_operation' ? record.source : undefined;\n const previousDraft = rows.find(\n (row) =>\n row.record.family === 'public_draft' &&\n row.record.id === draft.expected.id\n );\n if (\n !source ||\n (source.type !== 'draft' &&\n !(\n source.type === 'public_head' &&\n record.family === 'public_operation' &&\n record.capture.kind === 5 &&\n draft.revisionBase\n )) ||\n draft.expected.owner !== scope.owner ||\n (source.type === 'draft' &&\n (source.id !== draft.expected.id ||\n source.revision !== draft.expected.revision)) ||\n !previousDraft ||\n JSON.stringify(previousDraft.record) !==\n JSON.stringify(draft.expected) ||\n !draft.draftCurrent()\n ) {\n refuse('conflict');\n return;\n }\n }\n const operations = rows.filter(\n (row) => row.record.family !== 'public_draft'\n );\n if (\n operations.length >= LOCAL_PERSISTENCE_BUDGETS.publicOperations ||\n operations.reduce((sum, row) => sum + row.bytes, bytes) >\n LOCAL_PERSISTENCE_BUDGETS.publicOperationBytes\n ) {\n refuse('capacity');\n return;\n }\n if (draft && (!draft.current() || !draft.draftCurrent())) {\n refuse('conflict');\n return;\n }\n active.objectStore(store).put({ owner: scope.owner, id, wire });\n return { ok: true, value: { state: 'created', record: handle } };\n });\n}\nexport function inspectPublicStorage(\n repository: PublicQuotaRepository\n): Promise<PublicQuotaResult<PublicInventory>> {\n const scope = scopeOf(repository);\n if (!scope) return Promise.resolve(failed('invalid_scope'));\n return transaction(scope, 'readonly', (rows) => {\n const handle = Object.freeze({}) as PublicInventory;\n inventories.set(handle, { repository, rows });\n return { ok: true, value: handle };\n });\n}\nexport function publicInventorySnapshot(\n repository: PublicQuotaRepository,\n handle: PublicInventory\n):\n | Readonly<{ rows: readonly PublicInventoryRow[]; consequences: string }>\n | undefined {\n const inventory = inventories.get(handle);\n return scopeOf(repository) && inventory?.repository === repository\n ? {\n rows: inventory.rows.map((row) =>\n publicInventoryRow(row.record, row.bytes)\n ),\n consequences: PUBLIC_CLEANUP_CONSEQUENCES\n }\n : undefined;\n}\nexport function reviewPublicCleanup(\n repository: PublicQuotaRepository,\n handle: PublicInventory,\n selection: unknown\n): PublicQuotaResult<PublicCleanup> {\n const inventory = inventories.get(handle);\n if (!scopeOf(repository) || inventory?.repository !== repository)\n return failed('invalid_scope');\n try {\n if (!Array.isArray(selection)) return failed('invalid_selection');\n const length = selection.length;\n if (\n !Number.isSafeInteger(length) ||\n length <= 0 ||\n length >\n LOCAL_PERSISTENCE_BUDGETS.publicDrafts +\n LOCAL_PERSISTENCE_BUDGETS.publicOperations\n )\n return failed('invalid_selection');\n let selected = Array.from<string>([]);\n for (let index = 0; index < length; index++) {\n const key: unknown = selection[index];\n if (typeof key !== 'string' || selected.includes(key))\n return failed('invalid_selection');\n const row = inventory.rows.find(\n (row) => publicInventoryRow(row.record, row.bytes).key === key\n );\n if (!row) return failed('invalid_selection');\n if (publicInventoryRow(row.record, row.bytes).state !== 'settled')\n return failed('protected');\n selected = selected.concat(key);\n }\n if (!scopeOf(repository)) return failed('invalid_scope');\n const token = Object.freeze({}) as PublicCleanup;\n cleanups.set(token, { inventory, selected });\n return { ok: true, value: token };\n } catch {\n return failed('invalid_selection');\n }\n}\nexport function publicCleanupSnapshot(\n repository: PublicQuotaRepository,\n handle: PublicCleanup\n):\n | Readonly<{\n selected: readonly PublicInventoryRow[];\n logicalBytesRemoved: number;\n consequences: string;\n }>\n | undefined {\n const cleanup = cleanups.get(handle);\n if (!scopeOf(repository) || cleanup?.inventory.repository !== repository)\n return undefined;\n const selected = cleanup.inventory.rows\n .map((row) => publicInventoryRow(row.record, row.bytes))\n .filter((row) => cleanup.selected.includes(row.key));\n return {\n selected,\n logicalBytesRemoved: selected.reduce(\n (sum, row) => sum + row.logicalBytes,\n 0\n ),\n consequences: PUBLIC_CLEANUP_CONSEQUENCES\n };\n}\nexport function commitPublicCleanup(\n repository: PublicQuotaRepository,\n handle: PublicCleanup\n): Promise<PublicQuotaResult<readonly string[]>> {\n const cleanup = cleanups.get(handle),\n scope = scopeOf(repository);\n if (!scope || cleanup?.inventory.repository !== repository)\n return Promise.resolve(failed('invalid_scope'));\n return transaction(scope, 'readwrite', (rows, active, refuse) => {\n const before = cleanup.inventory.rows;\n if (\n rows.length !== before.length ||\n rows.some(\n (row, i) =>\n row.store !== before[i].store ||\n row.record.id !== before[i].record.id ||\n row.wire !== before[i].wire\n )\n ) {\n refuse('conflict');\n return;\n }\n const selected = rows.filter((row) =>\n cleanup.selected.includes(publicInventoryRow(row.record, row.bytes).key)\n );\n if (\n selected.length !== cleanup.selected.length ||\n selected.some(\n (row) => publicInventoryRow(row.record, row.bytes).state !== 'settled'\n )\n ) {\n refuse('protected');\n return;\n }\n for (const row of selected)\n active.objectStore(row.store).delete([scope.owner, row.record.id]);\n return { ok: true, value: Array.from(cleanup.selected) };\n });\n}\n\n// No signer/network await exists inside this transaction. It consumes only a\n// genuine immutable typed transition captured before storage acquisition.\n// Exact owner-scoped actual stored preference, not a caller's structural row.\n// Read is bounded by the same complete quota/codec scan and transaction ack.\nexport function loadPreferenceOperation(\n repository: PublicQuotaRepository,\n expectedId: unknown\n): Promise<PublicQuotaResult<PublicRecordHandle>> {\n const scope = scopeOf(repository),\n id = canonicalLocalId(expectedId);\n if (!scope) return Promise.resolve(failed('invalid_scope'));\n if (!id) return Promise.resolve(failed('invalid_record'));\n return transaction(scope, 'readonly', (rows) => {\n const row = rows.find(\n (row) => row.store === 'preference_operations' && row.record.id === id\n );\n if (!row) return failed('invalid_record');\n const decoded = decodePublicRecord(row.wire, scope.owner, id);\n return decoded.ok ? decoded : failed('corrupt_record');\n });\n}\nexport function commitPublicOperationTransition(\n repository: PublicQuotaRepository,\n handle: PublicOperationTransition\n): Promise<PublicQuotaResult<Readonly<{ id: string; revision: number }>>> {\n const scope = scopeOf(repository);\n if (!scope) return Promise.resolve(failed('invalid_scope'));\n const identity = publicTransitionIdentity(handle);\n const command =\n identity && publicTransitionSnapshot(handle, scope.owner, identity.id);\n if (!command) return Promise.resolve(failed('invalid_record'));\n const store: Store =\n command.family === 'public_operation'\n ? 'public_operations'\n : 'preference_operations';\n return transaction(scope, 'readwrite', (rows, active, refuse) => {\n const previous = rows.find(\n (row) => row.store === store && row.record.id === command.id\n );\n const decision = decideFrozenTransition(\n previous?.wire,\n command.baseWire,\n command.nextWire\n );\n if (decision === 'conflict') {\n refuse('conflict');\n return;\n }\n if (decision === 'committed')\n return {\n ok: true,\n value: { id: command.id, revision: command.revision }\n };\n const operations = rows.filter(\n (row) => row.record.family !== 'public_draft'\n );\n const bytes =\n operations.reduce((sum, row) => sum + row.bytes, 0) -\n (previous?.bytes ?? 0) +\n new TextEncoder().encode(command.nextWire).length;\n if (bytes > LOCAL_PERSISTENCE_BUDGETS.publicOperationBytes) {\n refuse('capacity');\n return;\n }\n active\n .objectStore(store)\n .put({ owner: scope.owner, id: command.id, wire: command.nextWire });\n return { ok: true, value: { id: command.id, revision: command.revision } };\n });\n}\nexport async function observePublicOperationTransition(\n repository: PublicQuotaRepository,\n handle: PublicOperationTransition\n): Promise<\n | Readonly<{ state: 'committed'; id: string; revision: number }>\n | Readonly<{ state: 'base_observed' | 'conflict' | 'unavailable' }>\n> {\n const scope = scopeOf(repository),\n identity = publicTransitionIdentity(handle);\n const command =\n scope &&\n identity &&\n publicTransitionSnapshot(handle, scope.owner, identity.id);\n if (!scope || !command) return { state: 'unavailable' };\n const store: Store =\n command.family === 'public_operation'\n ? 'public_operations'\n : 'preference_operations';\n const read = await transaction(scope, 'readonly', (rows) => ({\n ok: true,\n value: decideFrozenTransition(\n rows.find((row) => row.store === store && row.record.id === command.id)\n ?.wire,\n command.baseWire,\n command.nextWire\n )\n }));\n if (!read.ok || !scopeOf(repository)) return { state: 'unavailable' };\n return read.value === 'committed'\n ? { state: 'committed', id: command.id, revision: command.revision }\n : { state: read.value };\n}\n", + sha256: + 'e261a7c9c81d0685021663639b1bb543192e65580edb64fa58ccbb9a4a04cc95' + } + }, + ...{ 'src/routes/about/+page.svelte': { source: '<svelte:head><title>About \u2014 HarvestCircle</title></svelte:head>\n<div class="page page--reading stack">\n <h1>About</h1>\n <p class="notice">\n Information about HarvestCircle is unavailable during development.\n </p>\n <section id="help">\n <h2>Help / report</h2>\n <p>Help and reporting are unavailable during development.</p>\n </section>\n</div>\n', @@ -703,7 +717,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, 57); + assert.equal(files.length, 58); // 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( @@ -774,7 +788,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /inbox presentation source|Invalid owned private blocking source|Invalid owned support reporting source/ + /inbox presentation source|Invalid owned private blocking source|Invalid owned support reporting source|Invalid owned privacy data source/ ); } ); @@ -950,7 +964,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /inbox compiler source|Invalid owned private blocking source|Invalid owned support reporting source/ + /inbox compiler source|Invalid owned private blocking source|Invalid owned support reporting source|Invalid owned privacy data source/ ); } ); @@ -993,7 +1007,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, 57); + assert.equal((await f.audit()).length, 58); } ); @@ -1623,7 +1637,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 private blocking source|Invalid owned support reporting source/ + /Invalid owned listing editor source|Invalid owned public hiding source|Invalid owned private blocking source|Invalid owned support reporting source|Invalid owned privacy data source/ ); } ); @@ -1645,7 +1659,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 private blocking source|Invalid owned support reporting source/ + /Invalid owned selling workspace source|Invalid owned public hiding source|Invalid owned private blocking source|Invalid owned support reporting source|Invalid owned privacy data source/ ); } ); @@ -1675,7 +1689,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned (public hiding source|private blocking source|support reporting source|root runtime activation)/ + /Invalid owned (public hiding source|private blocking source|support reporting source|privacy data source|root runtime activation)/ ); } ); @@ -1713,7 +1727,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned (private blocking source|support reporting source|root runtime activation)/ + /Invalid owned (private blocking source|support reporting source|privacy data source|root runtime activation)/ ); } ); @@ -1742,7 +1756,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned support reporting source/ + /Invalid owned support reporting source|Invalid owned privacy data source/ ); } ); @@ -1759,6 +1773,47 @@ import { auditOutput } from '../../tools/check-output.mjs'; } ); } + for (const producer of [ + 'src/routes/privacy/+page.svelte', + 'src/lib/components/LocalDataReview.svelte', + 'src/lib/persistence/local-data-review.ts', + 'src/lib/persistence/quota.ts', + 'src/lib/persistence/private-records.ts', + 'src/lib/persistence/inbox-retention.ts', + 'src/lib/persistence/local-inventory.ts' + ]) { + await check( + 'privacy data 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// changed privacy data producer\n' + ); + await refresh(f); + await assert.rejects( + f.audit, + /Invalid owned privacy data source/ + ); + } + ); + await check( + 'privacy data rejects missing owned producer ' + producer, + async (t) => { + const f = await fixture(t); + await rm(path.join(f.web, producer)); + await refresh(f); + await assert.rejects( + f.audit, + producer === 'src/routes/privacy/+page.svelte' + ? /Undeclared compiler module: incomplete route source/ + : /ENOENT|privacy data/ + ); + } + ); + } for (const route of [ 'src/routes/sell/+page.svelte', 'src/routes/selling/drafts/[draftId=local_id]/+page.svelte', @@ -1777,7 +1832,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 private blocking source|Invalid owned support reporting source/ + /Invalid owned listing editor activation|Invalid owned public hiding source|Invalid owned private blocking source|Invalid owned support reporting source|Invalid owned privacy data source/ ); } ); @@ -1813,8 +1868,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 private blocking source|Invalid owned support reporting source/ - : /Invalid owned product presentation source|Invalid owned public hiding source|Invalid owned private blocking source|Invalid owned support reporting source/ + ? /Invalid owned (product presentation|listing editor) source|Invalid owned public hiding source|Invalid owned private blocking source|Invalid owned support reporting source|Invalid owned privacy data source/ + : /Invalid owned product presentation source|Invalid owned public hiding source|Invalid owned private blocking source|Invalid owned support reporting source|Invalid owned privacy data source/ ); } ); @@ -1998,7 +2053,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 private blocking source|Invalid owned support reporting source/ + /Invalid owned search presentation source|Invalid owned public hiding source|Invalid owned private blocking source|Invalid owned support reporting source|Invalid owned privacy data source/ ); } ); diff --git a/web/tests/unit/local-data-review.test.ts b/web/tests/unit/local-data-review.test.ts @@ -0,0 +1,44 @@ +import { describe, expect, it } from 'vitest'; +import { + createLocalDataReview, + localDataReviewSnapshot, + reviewLocalData, + previewLocalDataRemoval, + confirmLocalDataRemoval, + closeLocalDataReview +} from '../../src/lib/persistence/local-data-review.ts'; +import { createIdentityViewContext } from '../../src/lib/runtime/view-context.ts'; + +describe('local data review without original browser account ownership', () => { + it('construction and SSR review expose no owner or inventory and start no effects', async () => { + const context = createIdentityViewContext(); + const review = createLocalDataReview(context); + expect(localDataReviewSnapshot(review)).toEqual({ state: 'guest' }); + await reviewLocalData(review, 'reviewed_local_inventory'); + expect(localDataReviewSnapshot(review)).toEqual({ state: 'guest' }); + expect(await previewLocalDataRemoval(review, 'public', '[]')).toBe(false); + expect( + await confirmLocalDataRemoval(review, 'reviewed_local_removal') + ).toBe(false); + closeLocalDataReview(review); + expect(localDataReviewSnapshot(review)).toEqual({ state: 'closed' }); + }); + it('copied and invented handles cannot acquire inventory or deletion authority', async () => { + const genuine = createLocalDataReview(createIdentityViewContext()); + const copied = { ...genuine }; + expect(localDataReviewSnapshot(copied)).toEqual({ state: 'closed' }); + await reviewLocalData(copied, 'reviewed_local_inventory'); + expect( + await previewLocalDataRemoval( + copied, + 'received', + '["' + 'a'.repeat(64) + '"]' + ) + ).toBe(false); + expect( + await confirmLocalDataRemoval(copied, 'reviewed_local_removal') + ).toBe(false); + expect(localDataReviewSnapshot(genuine)).toEqual({ state: 'guest' }); + closeLocalDataReview(genuine); + }); +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -231,7 +231,217 @@ 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 privacyDataAdmission(web) { + let privacy; + try { + privacy = publicText( + await readOwned(web, 'src/routes/privacy/+page.svelte') + ); + } catch (error) { + if (error instanceof Error && 'code' in error && error.code === 'ENOENT') + return false; + throw error; + } + if (!privacy.includes('../../lib/components/LocalDataReview.svelte')) + 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': + '032a5f49d19a43a8ee88495b92d5337f1bb2de5dc58bb600b579e1423c9dfab1', + '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/LocalDataReview.svelte': + '662e77b3c7df48baeed317628c848bfc50f0b5643145e04cdaf017a1cc078ff5', + '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/ReportPreview.svelte': + 'fe133c95d640d3fa306667c613940a81783ce821471f70394671bb474c96d767', + 'src/lib/components/SellingRow.svelte': + 'ce00de1bd033860b9c0a85a49c90c8a4d5b8a8223cfd5c0872572e548e79331d', + 'src/lib/components/SupportLink.svelte': + 'c8608221416a47055c6b0aabe7a9d8370d3bc26e3fcd3c65214275d99ea1927e', + 'src/lib/config/budgets.ts': + 'e61806f1c2b580340e862b8dc7dd8063e90f74e03c64c721a7d112b0872f935d', + 'src/lib/config/deployment-relays.ts': + '14443151ff819a11a4f9c71e4ff756d1fbdd7cf6c36242ac712c378e68583aa2', + 'src/lib/config/deployment-support.ts': + 'c698313143943749bb457674825b648f6af29477f07cae960f3435c035cd6bd8', + 'src/lib/config/relays.ts': + 'f54a4e91c6561cf02e5aebfb7b62a7913faa4416a5664f2d14d2e3f3f9886f55', + 'src/lib/config/support.ts': + 'a5b4c179db6f13ebf85081960e2f7c330c3e894666fbf8f0472edb1c5c818872', + '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/navigation-url.ts': + '4ce96334d7cf57ccba518132078278b71d3bf70f519202e491a5f6a8840f7b19', + '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/inbox-retention.ts': + '8bcc73be03321e60a6fbbe7ba58de14eb8fb34db5d5cdce0adee31b5467d7bb9', + 'src/lib/persistence/local-data-review.ts': + '80c786bcce36f84b79775eea1710611ea77a1ee666fedb0067be4341949eb5df', + 'src/lib/persistence/local-inventory.ts': + '2ff3ca31cee4eec65b56a8f87d8ecdd0238cb86ef4bbe18d74518f299570adc1', + 'src/lib/persistence/local-private-blocks.ts': + 'd7e76c1122ff5479f261293db458a3240438ce0471c788c2f07ffaf854449cbc', + 'src/lib/persistence/local-public-hides.ts': + '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', + 'src/lib/persistence/private-records.ts': + '5892589a11e7009d4f4c27620a7da7ca34913552d9aa513431941050742ff386', + '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': + 'd82858b3de51ddb55466eedb980f37ebe3f70db6c36d0abe5f39feed30d441fc', + '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/lib/support/report.ts': + 'd02ebbfa82cf415c1af192f691b5464fbbc51f898207263bf1422f049a5d9dec', + 'src/routes/+layout.svelte': + 'b013d2d2bba40ee894c122fbb352dc78110e35ad17ec7ebb830a4556d3204ff7', + 'src/routes/about/+page.svelte': + 'b89a886622bfaee20dc0bf3b8cb3f84bbdc94df249d746d690da4cf81619fcba', + 'src/routes/messages/+page.svelte': + '8279a92770f38858e197e790839bc98b4d7889214ebecdf47e542d632afbc84f', + 'src/routes/messages/[conversationId=local_id]/+page.svelte': + 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7', + 'src/routes/privacy/+page.svelte': + 'c6fdaeea02196067c111e839ec2d8ea3ba4bf21b81dbe23a2cad5ae9503aad44', + 'src/routes/products/[naddr=naddr]/+page.svelte': + '5f325300384e2156724f3f7ac3fa8512ac6b6090d11aef9e8e53f6aea9c51665', + '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 privacy data source' + ); + } + return true; +} +/** @param {string} web */ async function supportReportingAdmission(web) { + if (await privacyDataAdmission(web)) return true; let about; try { about = publicText(await readOwned(web, 'src/routes/about/+page.svelte')); @@ -1553,7 +1763,9 @@ async function listingEditorAdmission(web) { withdrawing && (createHash('sha256').update(bytes).digest('hex') === pin || (name === 'src/lib/runtime/public-runtime.ts' && - (await publicHidingAdmission(web)))); + (await publicHidingAdmission(web))) || + (name === 'src/lib/persistence/quota.ts' && + (await privacyDataAdmission(web)))); } if (withdrawing) return 'owned-withdrawal'; if (revising) return 'owned-revision'; @@ -1732,6 +1944,7 @@ export async function auditOutput(webDirectory) { ]) await readOwned(web, name); } + const hasPrivacyData = hasFullRoutes && (await privacyDataAdmission(web)); const hasSupportReporting = hasFullRoutes && (await supportReportingAdmission(web)); const hasPrivateBlocking = @@ -1912,6 +2125,7 @@ export async function auditOutput(webDirectory) { names.add('ReportPreview'); names.add('navigation-url'); } + if (hasPrivacyData) names.add('SupportLink'); const admitted = new Map([['build-info.json', expectedMetadata]]); const seen = new Set(); for (const [key, record] of Object.entries(manifest)) { @@ -4727,6 +4941,55 @@ export async function auditOutput(webDirectory) { imports: ['public-key', 'references', 'navigation-url'] } }); + if (hasPrivacyData) + Object.assign(expected, { + ReportPreview: { + file: '_app/immutable/chunks/HASH.js', + name: 'ReportPreview', + imports: [ + 'private-session', + 'references', + 'client', + 'navigation-url', + 'public-runtime', + 'SupportLink', + 'publishers', + 'inbox-view' + ] + }, + SupportLink: { + file: '_app/immutable/chunks/HASH.js', + name: 'SupportLink', + imports: ['private-session', 'client', 'navigation-url'] + }, + 'nodes/3': { + file: '_app/immutable/nodes/3.HASH.js', + name: 'nodes/3', + src: '.svelte-kit/generated/build/client-optimized/nodes/3.js', + isEntry: true, + imports: [ + 'private-session', + 'client', + 'public-runtime', + 'SupportLink', + 'ReportPreview' + ] + }, + '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', + 'navigation-url', + 'Button', + 'local-private-blocks', + 'SupportLink' + ] + } + }); for (const record of Object.values(manifest)) { const actual = { ...record }; actual.file = actual.file.includes('/chunks/')