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:
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/')