app

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

commit 4aa071680a994c2e6c66d6d9fa120ef5cc9e90bd
parent 82dfe48073286eb4f01172341c0d25f8fc6700b7
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 01:20:14 +0000

harvestcircle: add reviewed settled outbox removal

- Protect unsettled and unresolved exact delivery attempts.
- Recheck owners and compare complete records before local deletion.
- Hold owner and SDK slots through completion and absence checks.
- Verify capacity recovery, cross-tab exclusion and unknown outcomes.

Diffstat:
Mweb/src/lib/components/LocalDataReview.svelte | 68++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------
Mweb/src/lib/persistence/local-data-review.ts | 125++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
Mweb/src/lib/persistence/local-inventory.ts | 70++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/persistence/private-outbox-cleanup.ts | 192+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/persistence/private-storage.ts | 86+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/runtime/private-session.ts | 28++++++++++++++++++++++++++++
Mweb/tests/e2e/harness/approved-signing.ts | 17+++++++++++++++++
Mweb/tests/e2e/harness/local-data-review.ts | 455+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Mweb/tests/e2e/local-data-review.spec.ts | 187+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 45++++++++++++++++++++++++++++++++++++++++++++-
Aweb/tests/unit/private-outbox-settlement.test.ts | 193+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 35++++++++++++++++++++---------------
12 files changed, 1455 insertions(+), 46 deletions(-)

diff --git a/web/src/lib/components/LocalDataReview.svelte b/web/src/lib/components/LocalDataReview.svelte @@ -13,7 +13,8 @@ let { review }: { review: LocalDataReview } = $props(); let snapshot = $state.raw(untrack(() => localDataReviewSnapshot(review))); let selectedPublic = $state.raw<string[]>([]), - selectedReceived = $state.raw<string[]>([]); + selectedReceived = $state.raw<string[]>([]), + selectedOutbox = $state.raw<string[]>([]); let feedback = $state<string | undefined>(); const family = (value: string) => value === 'public_draft' @@ -24,6 +25,7 @@ function reset() { selectedPublic = []; selectedReceived = []; + selectedOutbox = []; feedback = undefined; } onMount(() => { @@ -33,26 +35,36 @@ if (snapshot.state !== 'ready') reset(); }); }); - function toggle(category: 'public' | 'received', id: string) { + function toggle(category: 'public' | 'received' | 'outbox', id: string) { feedback = undefined; if (category === 'public') selectedPublic = selectedPublic.includes(id) ? selectedPublic.filter((value) => value !== id) : [...selectedPublic, id]; - else + else if (category === 'received') selectedReceived = selectedReceived.includes(id) ? selectedReceived.filter((value) => value !== id) : [...selectedReceived, id]; + else + selectedOutbox = selectedOutbox.includes(id) + ? selectedOutbox.filter((value) => value !== id) + : [...selectedOutbox, id]; } async function inspect() { reset(); await reviewLocalData(review, 'reviewed_local_inventory'); } - async function preview(category: 'public' | 'received') { + async function preview(category: 'public' | 'received' | 'outbox') { const result = await previewLocalDataRemoval( review, category, - JSON.stringify(category === 'public' ? selectedPublic : selectedReceived) + JSON.stringify( + category === 'public' + ? selectedPublic + : category === 'received' + ? selectedReceived + : selectedOutbox + ) ); feedback = result ? undefined @@ -99,7 +111,9 @@ {snapshot.preview.selected} selected {snapshot.preview.category === 'public' ? 'public records' - : 'encrypted received copies'}. + : snapshot.preview.category === 'outbox' + ? 'settled send records' + : 'encrypted received copies'}. </p> <p>{snapshot.preview.consequences}</p> <div class="row"> @@ -171,11 +185,45 @@ /> <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. + {snapshot.outbox.count} retained records · {snapshot.outbox.bytes} logical + bytes. This browser retains at most 100 send records. Settled records also + occupy that capacity. Unsettled send records stay protected. </p> + {#if !snapshot.receivedRemoval}<p> + Enable messaging explicitly before reviewing settled-send removal. + Reviewing data does not probe or enable messaging. + </p>{/if} + {#if snapshot.outboxRows.length} + <ul class="stack"> + {#each snapshot.outboxRows as row (row.id)} + <li class="stack"> + <label class="row" + ><input + type="checkbox" + checked={selectedOutbox.includes(row.id)} + onchange={() => toggle('outbox', row.id)} + disabled={!snapshot.receivedRemoval || + row.state === 'protected' || + snapshot.busy} + />Encrypted send recovery · {row.logicalBytes} logical bytes · {row.state === + 'protected' + ? 'Protected' + : 'Eligible settled send'}</label + > + <p class="key">{row.id}</p> + </li> + {/each} + </ul> + {:else}<p> + No private send recovery records for this account in this browser. + </p>{/if} + <Button + label="Review settled send removal" + onclick={() => preview('outbox')} + disabled={!snapshot.receivedRemoval || + !selectedOutbox.length || + snapshot.busy} + /> {/if} {#if snapshot.busy}<p role="status"> Checking the selected local action… diff --git a/web/src/lib/persistence/local-data-review.ts b/web/src/lib/persistence/local-data-review.ts @@ -26,11 +26,22 @@ import { } from './quota.ts'; import { createPrivateStorageRepository, - inspectPrivateStorage, + listPrivateSendRecords, listPrivateReceivedRecords, type PrivateStorageRepository } from './private-storage.ts'; -import { privateRecordIdentity, privateRecordWire } from './private-records.ts'; +import { + privateRecordIdentity, + privateRecordWire, + privateRecordSnapshot, + type PrivateRecordHandle +} from './private-records.ts'; +import { + capturePrivateOutboxCleanup, + deleteReviewedSettledSends, + stopPrivateOutboxCleanup, + type PrivateOutboxCleanup +} from './private-outbox-cleanup.ts'; import { captureReceivedCleanup, deleteReviewedReceivedCopies, @@ -39,13 +50,16 @@ import { } from './inbox-retention.ts'; import { PUBLIC_CLEANUP_CONSEQUENCES, - type PublicInventoryRow + PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES, + privateInventoryRow, + type PublicInventoryRow, + type PrivateInventoryRow } 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 Category = 'public' | 'received' | 'outbox'; type Preview = Readonly<{ category: Category; selected: number; @@ -56,6 +70,7 @@ type Inventory = Readonly<{ publicRows: readonly PublicInventoryRow[]; received: readonly Readonly<{ id: string; logicalBytes: number }>[]; outbox: Readonly<{ count: number; bytes: number }>; + outboxRows: readonly PrivateInventoryRow[]; receivedRemoval: boolean; }>; export type LocalDataReviewSnapshot = @@ -84,6 +99,23 @@ const receivedConsequences = 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 outboxInventory( + handles: readonly PrivateRecordHandle[], + owner: string +): PrivateInventoryRow[] { + return handles.map((handle) => { + const identity = privateRecordIdentity(handle), + record = identity && privateRecordSnapshot(handle, owner, identity.id), + wire = identity && privateRecordWire(handle, owner, identity.id); + if (!record || !wire) throw Error('outbox inventory unavailable'); + return privateInventoryRow( + record, + new TextEncoder().encode(JSON.stringify({ owner, id: record.id, wire })) + .length + ); + }); +} + function selection(value: unknown, maximum: number): string[] | undefined { if ( typeof value !== 'string' || @@ -127,6 +159,7 @@ export function createLocalDataReview( let privateRepository: PrivateStorageRepository | undefined; let publicCleanup: PublicCleanup | undefined, receivedCleanup: ReceivedCleanup | undefined; + let outboxCleanup: PrivateOutboxCleanup | undefined; let offIdentity = () => {}; function notify() { for (const listener of listeners.values()) { @@ -141,6 +174,8 @@ export function createLocalDataReview( publicCleanup = undefined; if (receivedCleanup) stopReceivedCleanup(receivedCleanup); receivedCleanup = undefined; + if (outboxCleanup) stopPrivateOutboxCleanup(outboxCleanup); + outboxCleanup = undefined; if (state.state === 'ready') state = { ...state, preview: undefined }; } function retire() { @@ -202,7 +237,7 @@ export function createLocalDataReview( const publicState = publicInventorySnapshot(pub, scan.value); const received = await listPrivateReceivedRecords(priv); if (!current(original)) return; - const outbox = await inspectPrivateStorage(priv, 'private_sends'); + const outbox = await listPrivateSendRecords(priv); if (!current(original)) return; if (!publicState || !received.ok || !outbox.ok) throw Error('private inventory unavailable'); @@ -218,6 +253,7 @@ export function createLocalDataReview( ).length }; }); + const outboxRows = outboxInventory(outbox.value, captured.owner); publicRepository = pub; privateRepository = priv; inventory = scan.value; @@ -227,7 +263,11 @@ export function createLocalDataReview( owner: captured.owner, publicRows: publicState.rows, received: copies, - outbox: outbox.value, + outbox: { + count: outboxRows.length, + bytes: outboxRows.reduce((sum, row) => sum + row.logicalBytes, 0) + }, + outboxRows, receivedRemoval: identitySessionSnapshot(identity).state === 'messaging_capable' }; @@ -250,6 +290,7 @@ export function createLocalDataReview( publicRows: state.publicRows.map((row) => ({ ...row })), received: state.received.map((row) => ({ ...row })), outbox: { ...state.outbox }, + outboxRows: state.outboxRows.map((row) => ({ ...row })), preview: state.preview && { ...state.preview } } : { ...state }; @@ -264,7 +305,9 @@ export function createLocalDataReview( category === 'public' ? LOCAL_PERSISTENCE_BUDGETS.publicDrafts + LOCAL_PERSISTENCE_BUDGETS.publicOperations - : LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes + : category === 'outbox' + ? LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends + : LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes ); cancelPreview(); if (!ids) { @@ -292,13 +335,17 @@ export function createLocalDataReview( return true; } if ( - category !== 'received' || + (category !== 'received' && category !== 'outbox') || !privateRepository || !state.receivedRemoval || !ids.every( (id) => state.state === 'ready' && - state.received.some((row) => row.id === id) + (category === 'received' + ? state.received.some((row) => row.id === id) + : state.outboxRows.some( + (row) => row.id === id && row.state === 'settled' + )) ) ) { notify(); @@ -315,6 +362,30 @@ export function createLocalDataReview( 'reviewed_private_session' ); if (!session || !current(original)) return false; + if (category === 'outbox') { + const cleanup = await capturePrivateOutboxCleanup( + privateRepository, + session, + ids, + 'reviewed_settled_outbox_selection' + ); + if (!current(original)) { + if (cleanup) stopPrivateOutboxCleanup(cleanup); + return false; + } + if (!cleanup || state.state !== 'ready') return false; + outboxCleanup = cleanup; + state = { + ...state, + preview: { + category: 'outbox', + selected: ids.length, + consequences: PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES + }, + notice: undefined + }; + return true; + } const cleanup = await captureReceivedCleanup( privateRepository, session, @@ -364,10 +435,12 @@ export function createLocalDataReview( owner = ownership.owner; const pub = publicCleanup, received = receivedCleanup, + outbox = outboxCleanup, repo = publicRepository, signal = cancellation.signal; publicCleanup = undefined; receivedCleanup = undefined; + outboxCleanup = undefined; busy = true; state = { ...state, busy: true, preview: undefined }; notify(); @@ -402,6 +475,34 @@ export function createLocalDataReview( return true; } ); + } else if (preview.category === 'outbox' && outbox) { + outboxCleanup = outbox; + const result = await deleteReviewedSettledSends( + outbox, + 'reviewed_delete_local_settled_sends' + ); + if ( + result.status === 'removed' && + current(original) && + privateRepository + ) { + const scan = await listPrivateSendRecords(privateRepository); + if (scan.ok && current(original) && state.state === 'ready') { + const remaining = outboxInventory(scan.value, owner); + state = { + ...state, + outboxRows: remaining, + outbox: { + count: remaining.length, + bytes: remaining.reduce( + (sum, row) => sum + row.logicalBytes, + 0 + ) + } + }; + confirmed = true; + } + } } else if (preview.category === 'received' && received) { // Keep the owned action available to synchronous retirement while running. receivedCleanup = received; @@ -433,6 +534,8 @@ export function createLocalDataReview( } finally { if (received) stopReceivedCleanup(received); if (receivedCleanup === received) receivedCleanup = undefined; + if (outbox) stopPrivateOutboxCleanup(outbox); + if (outboxCleanup === outbox) outboxCleanup = undefined; if (generation === original) { busy = false; if (state.state === 'ready') @@ -444,7 +547,9 @@ export function createLocalDataReview( preview.selected + (preview.category === 'public' ? ' selected public record' - : ' selected received encrypted copy') + + : preview.category === 'outbox' + ? ' selected settled send record' + : ' selected received encrypted copy') + (preview.selected === 1 ? '.' : ' entries.') + ' Other local categories and remote copies are unchanged.' : unavailable diff --git a/web/src/lib/persistence/local-inventory.ts b/web/src/lib/persistence/local-inventory.ts @@ -1,4 +1,5 @@ import type { PublicRecord } from '../contracts/local-records.ts'; +import type { PrivateRecord, PrivateTargetReceipt } from './private-records.ts'; export type PublicInventoryRow = Readonly<{ key: string; family: PublicRecord['family']; @@ -42,3 +43,72 @@ export function publicInventoryRow( } export const PUBLIC_CLEANUP_CONSEQUENCES = 'Removing selected records loses their local drafts or recovery receipts. It does not delete remote copies or reverse accepted effects. Pending or uncertain work is protected. Browser-local storage is not a backup.'; + +export type PrivateInventoryRow = Readonly<{ + id: string; + revision: number; + logicalBytes: number; + state: 'settled' | 'protected'; +}>; +// Strict decoded local bookkeeping only, never a new sender, remote receipt or +// replay capability. A later named acceptance resolves only its exact binding. +export function privateRecordSettlement( + record: PrivateRecord +): 'settled' | 'protected' { + if ( + record.family !== 'private_send_operation' || + !record.peerArtifact || + !record.deliveryPlan || + !record.receipts?.length + ) + return 'protected'; + const facts = record.receipts; + const sameTarget = (a: PrivateTargetReceipt, b: PrivateTargetReceipt) => + a.role === b.role && a.origin === b.origin && a.eventId === b.eventId; + if ( + facts.some( + (fact, index) => + ['unknown', 'timed_out', 'stopped'].includes(fact.status) && + !facts.some( + (later, laterIndex) => + laterIndex > index && + later.status === 'accepted' && + sameTarget(fact, later) + ) + ) + ) + return 'protected'; + return [ + record.deliveryPlan.routes.peer, + record.deliveryPlan.routes.archive + ].every((route) => { + const eventId = + route.role === 'peer' + ? record.peerArtifact!.eventId + : record.self.eventId; + return route.targets.every((origin) => + facts.some( + (fact) => + fact.status === 'accepted' && + fact.role === route.role && + fact.origin === origin && + fact.eventId === eventId + ) + ); + }) + ? 'settled' + : 'protected'; +} +export function privateInventoryRow( + record: PrivateRecord, + logicalBytes: number +): PrivateInventoryRow { + return { + id: record.id, + revision: record.revision, + logicalBytes, + state: privateRecordSettlement(record) + }; +} +export const PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES = + 'Removing selected settled sends loses their local encrypted recovery, delivery status and duplicate-prevention evidence. Other local messages, participants and relays may retain copies. It does not erase remote messages or guarantee that a deliberately repeated message cannot be sent again. Browser-local storage is not a backup.'; diff --git a/web/src/lib/persistence/private-outbox-cleanup.ts b/web/src/lib/persistence/private-outbox-cleanup.ts @@ -0,0 +1,192 @@ +import { canonicalLocalId } from '../private-handles.ts'; +import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; +import { + privateSessionOwnership, + recheckPrivateSession, + subscribePrivateSessionClose, + withIdlePrivateLocalStorage, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + privateRecordIdentity, + privateRecordSnapshot, + privateRecordWire, + type PrivateRecordHandle +} from './private-records.ts'; +import { + listPrivateSendRecords, + removePrivateSettledSendRecords, + type PrivateStorageRepository, + type PrivateStorageFailure +} from './private-storage.ts'; +import { privateRecordSettlement } from './local-inventory.ts'; +declare const cleanupBrand: unique symbol; +export type PrivateOutboxCleanup = Readonly<{ [cleanupBrand]: true }>; +type Result = Readonly<{ + status: 'removed' | 'invalid' | 'busy' | 'stopped' | PrivateStorageFailure; + removed?: number; +}>; +type Controller = { run(review: unknown): Promise<Result>; stop(): void }; +const actions = new WeakMap<PrivateOutboxCleanup, Controller>(); +function selectIds(selection: unknown): string[] | undefined { + try { + if ( + !Array.isArray(selection) || + !selection.length || + selection.length > LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends + ) + return undefined; + const ids = Array.from<unknown>(selection).map(canonicalLocalId); + return ids.some((id) => !id) || new Set(ids).size !== ids.length + ? undefined + : (ids as string[]); + } catch { + return undefined; + } +} +// Explicit current-owner whole-wire preview. Ciphertext handles remain private +// to this one-use action; copied IDs/objects never grant local deletion. +export async function capturePrivateOutboxCleanup( + repository: PrivateStorageRepository, + session: PrivateSession, + selection: unknown, + review: unknown +): Promise<PrivateOutboxCleanup | undefined> { + const ownership = privateSessionOwnership(session), + ids = selectIds(selection); + if ( + typeof window === 'undefined' || + !navigator.locks?.request || + review !== 'reviewed_settled_outbox_selection' || + !ownership?.current() || + !ids + ) + return undefined; + try { + const scan = await listPrivateSendRecords(repository); + if (!scan.ok || !ownership.current()) return undefined; + const selected = ids.map((id) => { + const handle = scan.value.find( + (row) => privateRecordIdentity(row)?.id === id + ), + record = handle && privateRecordSnapshot(handle, ownership.owner, id), + wire = handle && privateRecordWire(handle, ownership.owner, id); + if ( + !handle || + !record || + !wire || + privateRecordSettlement(record) !== 'settled' + ) + return undefined; + return handle; + }); + if (selected.some((handle) => !handle)) return undefined; + const token = Object.freeze({}) as PrivateOutboxCleanup, + cancellation = new AbortController(); + let captured = selected as PrivateRecordHandle[], + stopped = false, + used = false, + off = () => {}; + function stop() { + if (stopped) return; + stopped = true; + cancellation.abort(); + captured = []; + off(); + } + actions.set(token, { + stop, + async run(consent) { + if (stopped || !ownership.current()) return { status: 'stopped' }; + if (consent !== 'reviewed_delete_local_settled_sends' || used) + return { status: 'invalid' }; + used = true; + const original = captured.slice(); + try { + if ( + !(await recheckPrivateSession(session)) || + stopped || + !ownership.current() + ) + return { + status: stopped || !ownership.current() ? 'stopped' : 'busy' + }; + return await navigator.locks.request( + 'harvestcircle:owner:' + ownership.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock): Promise<Result> => { + if (!lock) return { status: 'busy' }; + if (stopped || !ownership.current()) return { status: 'stopped' }; + let attempted = false; + const job = await withIdlePrivateLocalStorage<Result>( + session, + async () => { + if (stopped || !ownership.current()) + return { status: 'stopped' }; + attempted = true; + const committed = await removePrivateSettledSendRecords( + repository, + session, + original, + consent, + cancellation.signal + ); + if (!committed.ok) return { status: committed.reason }; + const readback = await listPrivateSendRecords(repository); + if ( + !readback.ok || + stopped || + !ownership.current() || + readback.value.some( + (row) => + !privateRecordIdentity(row) || + ids.includes(privateRecordIdentity(row)!.id) + ) + ) + return { status: 'unknown_completion' }; + return { + status: 'removed', + removed: committed.value.removed + }; + } + ); + return job.ok + ? job.value + : { + status: attempted + ? 'unknown_completion' + : stopped || !ownership.current() + ? 'stopped' + : 'busy' + }; + } + ); + } catch { + return { status: 'unknown_completion' }; + } finally { + captured = []; + off(); + } + } + }); + off = subscribePrivateSessionClose(session, stop); + if (!ownership.current()) { + stop(); + return undefined; + } + return token; + } catch { + return undefined; + } +} +export function deleteReviewedSettledSends( + token: PrivateOutboxCleanup, + review: unknown +): Promise<Result> { + return ( + actions.get(token)?.run(review) ?? Promise.resolve({ status: 'invalid' }) + ); +} +export function stopPrivateOutboxCleanup(token: PrivateOutboxCleanup): void { + actions.get(token)?.stop(); +} diff --git a/web/src/lib/persistence/private-storage.ts b/web/src/lib/persistence/private-storage.ts @@ -6,6 +6,7 @@ import { import { canonicalPublicKey } from '../contracts/public-key.ts'; import { exactLocalFields } from '../contracts/local-records.ts'; import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; +import { privateRecordSettlement } from './local-inventory.ts'; import { browserDatabaseState, browserDatabaseTransaction, @@ -499,3 +500,88 @@ export function removePrivateReceivedRecords( } ); } + +// Reviewed settled-send loss only; the cleanup owner holds the owner WebLock +// and idle SDK slot. Revalidate the full namespace and immutable selection in +// the same short transaction; native complete requires separate absence proof. +export function removePrivateSettledSendRecords( + repository: PrivateStorageRepository, + session: PrivateSession, + handles: readonly PrivateRecordHandle[], + review: unknown, + cancellation?: AbortSignal +): Promise<PrivateStorageResult<Readonly<{ removed: number }>>> { + const scope = scopeOf(repository), + ownership = privateSessionOwnership(session); + if ( + review !== 'reviewed_delete_local_settled_sends' || + !scope || + cancellation?.aborted || + !ownership?.current() || + scope.owner !== ownership.owner + ) + return Promise.resolve(failed('invalid_scope')); + if ( + !Array.isArray(handles) || + !handles.length || + handles.length > LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends + ) + return Promise.resolve(failed('invalid_record')); + const selected = handles.map((handle: PrivateRecordHandle) => { + const identity = privateRecordIdentity(handle), + record = + identity && privateRecordSnapshot(handle, scope.owner, identity.id), + wire = identity && privateRecordWire(handle, scope.owner, identity.id); + return identity && + record && + privateRecordSettlement(record) === 'settled' && + wire + ? { id: identity.id, wire } + : undefined; + }); + if ( + selected.some((x) => !x) || + new Set(selected.map((x) => x?.id)).size !== selected.length + ) + return Promise.resolve(failed('invalid_record')); + return transaction<Readonly<{ removed: number }>>( + scope, + 'private_sends', + 'readwrite', + (rows, tx, refuse) => { + if (!ownership.current() || cancellation?.aborted) { + refuse('invalid_scope'); + return; + } + for (const item of selected) { + const actual = item && rows.find((row) => row.record.id === item.id); + if ( + !item || + actual?.wire !== item.wire || + privateRecordSettlement(actual.record) !== 'settled' + ) { + refuse('conflict'); + return; + } + } + if (!ownership.current() || cancellation?.aborted) { + refuse('invalid_scope'); + return; + } + for (const item of selected) + if (item) + tx.objectStore('private_sends').delete([scope.owner, item.id]); + return { ok: true, value: { removed: selected.length } }; + }, + (refuse) => { + const abort = () => refuse('invalid_scope'), + off = subscribePrivateSessionClose(session, abort); + cancellation?.addEventListener('abort', abort, { once: true }); + if (cancellation?.aborted) abort(); + return () => { + off(); + cancellation?.removeEventListener('abort', abort); + }; + } + ); +} diff --git a/web/src/lib/runtime/private-session.ts b/web/src/lib/runtime/private-session.ts @@ -6,6 +6,10 @@ import { type IdentitySession } from './identity-session.ts'; import type { PublicEffectCapture } from './effect-ownership.ts'; +import { + browserExtensionScheduler, + runExtensionAction +} from '../nostr/extension-scheduler.ts'; declare const privateBrand: unique symbol; export type PrivateSession = Readonly<{ [privateBrand]: true }>; type Controller = { @@ -167,3 +171,27 @@ export async function recheckPrivateSession( checked.admission !== 'busy' ); } + +// A short local-storage action reserves the actual shared SDK slot without +// invoking the provider. No permission/network work belongs inside this job. +export async function withIdlePrivateLocalStorage<T>( + token: PrivateSession, + work: (this: void) => Promise<T> +): Promise<Readonly<{ ok: true; value: T }> | Readonly<{ ok: false }>> { + const state = sessions.get(token), + scheduler = browserExtensionScheduler(); + if (!state?.current() || !scheduler) return { ok: false }; + const result = await runExtensionAction( + scheduler, + { + owner: state.capture.owner, + session: state.capture.session, + operation: Symbol() + }, + () => state.current(), + () => work() + ); + return result.status === 'completed' && 'value' in result && state.current() + ? { ok: true, value: result.value as T } + : { ok: false }; +} diff --git a/web/tests/e2e/harness/approved-signing.ts b/web/tests/e2e/harness/approved-signing.ts @@ -4,6 +4,7 @@ import { verifiedSymbol, type EventTemplate } from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; import { decodePublicRecord, publicRecordSnapshot, @@ -176,6 +177,22 @@ export function makeFixture(kind: 30402 | 5 | 10050 = 30402) { owner: row.owner, id, template, + encrypt(peer: string, text: string) { + const conversation = nip44.v2.utils.getConversationKey(key, peer); + try { + return nip44.v2.encrypt(text, conversation); + } finally { + conversation.fill(0); + } + }, + decrypt(peer: string, ciphertext: string) { + const conversation = nip44.v2.utils.getConversationKey(key, peer); + try { + return nip44.v2.decrypt(ciphertext, conversation); + } finally { + conversation.fill(0); + } + }, sign(input: EventTemplate, mode: Mode = 'exact') { if (mode === 'denied') throw new Error('test-only refusal'); const copy = { ...input, tags: input.tags.map((tag) => [...tag]) }; diff --git a/web/tests/e2e/harness/local-data-review.ts b/web/tests/e2e/harness/local-data-review.ts @@ -1,9 +1,36 @@ // 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 { validateRelayPolicy } from '../../../src/lib/config/relays.ts'; +import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; +import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts'; +import { + captureEnquiryRumor, + stopRumorPlan +} from '../../../src/lib/messaging/rumor-plan.ts'; +import { + reserveSendIdentity, + reservedSendSnapshot +} from '../../../src/lib/messaging/send-identity.ts'; +import { + captureSelfRecoveryPreparation, + prepareSelfRecovery, + preparePairedDelivery, + preparedPairedDelivery, + stopSelfRecoveryPreparation +} from '../../../src/lib/messaging/prepare-send.ts'; +import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; +import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts'; +import { + createPublicScheduler, + createPublicRun, + openInboxRequest, + closePublicScheduler +} from '../../../src/lib/nostr/request-scope.ts'; + import Panel from '../../../src/lib/components/LocalDataReview.svelte'; import { makeFixture } from './approved-signing.ts'; -import { finalizeEvent } from 'applesauce-core/helpers'; +import { finalizeEvent, getEventHash } from 'applesauce-core/helpers'; import { nip44 } from 'applesauce-core/helpers/encryption'; import { createIdentityViewContext, @@ -38,6 +65,10 @@ import { } from '../../../src/lib/persistence/quota.ts'; import { identityLocalOwnership } from '../../../src/lib/runtime/identity-session.ts'; import { + createPrivateSession, + withIdlePrivateLocalStorage +} from '../../../src/lib/runtime/private-session.ts'; +import { createPrivateSendReservationRepository, reservePrivateSendReservation } from '../../../src/lib/persistence/private-send-reservations.ts'; @@ -49,7 +80,8 @@ import { import { decodePrivateRecord, privateRecordIdentity, - privateRecordSnapshot + privateRecordSnapshot, + type PrivateSendOperation } from '../../../src/lib/persistence/private-records.ts'; export async function createFixture(mode = 'normal') { @@ -57,26 +89,27 @@ export async function createFixture(mode = 'normal') { foreign = makeFixture(), owner = signer.owner; const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); + let changedKey = false; let counts = { reads: 0, signs: 0, encrypts: 0, decrypts: 0 }; Object.defineProperty(window, 'nostr', { configurable: true, value: { getPublicKey() { counts.reads++; - return Promise.resolve(owner); + return Promise.resolve(changedKey ? foreign.owner : owner); }, signEvent(template: Parameters<typeof signer.sign>[0]) { counts.signs++; return Promise.resolve(signer.sign(template)); }, nip44: { - encrypt(_peer: string, text: string) { + encrypt(peer: string, text: string) { counts.encrypts++; - return Promise.resolve('controlled:' + text); + return Promise.resolve(signer.encrypt(peer, text)); }, - decrypt(_peer: string, text: string) { + decrypt(peer: string, text: string) { counts.decrypts++; - return Promise.resolve(text.slice('controlled:'.length)); + return Promise.resolve(signer.decrypt(peer, text)); } } } @@ -84,7 +117,7 @@ export async function createFixture(mode = 'normal') { const identity = createIdentityViewContext(); mountIdentityView(identity); await connectIdentityView(identity); - if (mode === 'messaging') + if (mode === 'messaging' || mode === 'outbox') await probeIdentityViewMessaging(identity, 'reviewed_self_copy'); if (!identityViewSession(identity)) throw Error('original connected identity absent'); @@ -189,9 +222,10 @@ export async function createFixture(mode = 'normal') { const originalIdentity = identityViewSession(identity); const ownership = originalIdentity && identityLocalOwnership(originalIdentity); + if (!reservationRepository || !ownership) + throw Error('original outbox scope absent'); if ( - !reservationRepository || - !ownership || + mode !== 'outbox' && !( await reservePrivateSendReservation( reservationRepository, @@ -202,6 +236,127 @@ export async function createFixture(mode = 'normal') { ).ok ) throw Error('original protected outbox absent'); + const settledIds = Array.from<string>([]); + function pairedRecord(index: number): PrivateSendOperation { + const id = crypto.randomUUID(), + rumorTemplate = { + pubkey: owner, + kind: 14, + created_at: 1700000000 + index, + tags: [['p', foreign.owner]], + content: 'CR004_TEST_ONLY_nested_capacity_' + index + }, + rumor = { ...rumorTemplate, id: getEventHash(rumorTemplate) }; + const artifact = (destination: string) => { + const seal = signer.sign({ + kind: 13, + created_at: 1700000000 + index, + tags: [], + content: signer.encrypt(destination, JSON.stringify(rumor)) + }); + const wrapper = crypto.getRandomValues(new Uint8Array(32)), + conversation = nip44.v2.utils.getConversationKey(wrapper, destination); + try { + const outer = finalizeEvent( + { + kind: 1059, + created_at: 1700000000 + index, + tags: [['p', destination]], + content: nip44.v2.encrypt(JSON.stringify(seal), conversation) + }, + wrapper + ); + return { eventId: outer.id, wire: JSON.stringify(outer) }; + } finally { + wrapper.fill(0); + conversation.fill(0); + } + }; + const self = artifact(owner), + peerArtifact = artifact(foreign.owner); + const route = ( + role: 'peer' | 'self_archive', + author: string, + origin: string + ) => ({ + role, + author, + targets: [origin], + knownBase: { author, id: 'c'.repeat(64), createdAt: 100 }, + sources: [ + { + source: 'wss://discovery.example.org', + state: 'eose' as const, + head: { id: 'c'.repeat(64), createdAt: 100 } + } + ] + }); + // Seeded local receipt bookkeeping only, not genuine remote ACK/operator Q. + return { + schema: 1, + family: 'private_send_operation', + owner, + id, + revision: 1, + peer: foreign.owner, + rumorHash: rumor.id, + createdAt: rumor.created_at, + self, + peerArtifact, + deliveryPlan: { + state: 'prepared', + routes: { + peer: route('peer', foreign.owner, 'wss://peer.example.org'), + archive: route('self_archive', owner, 'wss://archive.example.org') + } + }, + receipts: [ + { + actionId: crypto.randomUUID(), + origin: 'wss://peer.example.org', + role: 'peer', + attempt: 1, + eventId: peerArtifact.eventId, + status: 'accepted', + observedAtMilliseconds: 1700000000000, + readbackWire: null + }, + { + actionId: crypto.randomUUID(), + origin: 'wss://archive.example.org', + role: 'self_archive', + attempt: 1, + eventId: self.eventId, + status: 'accepted', + observedAtMilliseconds: 1700000000000, + readbackWire: null + } + ] + }; + } + if (mode === 'outbox') { + const rows = Array.from({ length: 100 }, (_, index) => pairedRecord(index)); + for (const row of rows) { + if (!decodePrivateRecord(JSON.stringify(row), owner, row.id).ok) + throw Error('strict nested-pair journal fixture rejected'); + settledIds.push(row.id); + } + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readwrite' + ); + for (const row of rows) + tx.objectStore('private_sends').put({ + owner, + id: row.id, + wire: JSON.stringify(row) + }); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => reject(Error('capacity seed abort'))); + }); + } const corruptId = crypto.randomUUID(); async function transactionRows() { const tx = browserDatabaseTransaction( @@ -264,6 +419,286 @@ export async function createFixture(mode = 'normal') { confirmLocalDataRemoval(review, 'reviewed_local_removal'); return { owner, + settledIds: () => settledIds.slice(), + async reviewAndPreviewOutbox() { + await inspect(); + return previewLocalDataRemoval( + review, + 'outbox', + JSON.stringify([settledIds[0]]) + ); + }, + // Actual local sender factories; controlled discovery/SDK inputs are not + // remote delivery, an installed extension, or operator qualification. + async freshSend() { + const session = identityViewSession(identity); + if (!session) throw Error('original sender identity absent'); + const food = foreign.sign({ + kind: 30402, + created_at: Math.floor(Date.now() / 1000), + content: 'Fresh capacity fixture carrots', + tags: [ + ['d', 'capacity-carrots'], + ['title', 'Carrots'], + ['summary', 'Fresh carrots'], + ['published_at', '1700000000'], + ['location', 'Victoria'], + ['price', '3.5', 'CAD'], + ['radroots:price_unit', 'lb'], + ['status', 'active'] + ] + }); + const verified = verifyEnvelope(JSON.stringify(food)), + context = verified.ok && captureEnquiryContext(verified.value), + rumor = + context && + captureEnquiryRumor( + session, + context, + 'CR004 fresh factory send', + Math.floor(Date.now() / 1000) + ); + if (!rumor) throw Error('genuine fresh rumor absent'); + const schedulers: ReturnType<typeof createPublicScheduler>[] = []; + let preparation: ReturnType<typeof captureSelfRecoveryPreparation>; + try { + const reserved = await reserveSendIdentity( + reservationRepository, + session, + crypto.randomUUID(), + rumor, + 'reviewed_private_intent' + ); + if (!('identity' in reserved)) return { reservation: reserved.status }; + const id = reservedSendSnapshot(reserved.identity)?.id; + preparation = captureSelfRecoveryPreparation( + priv, + session, + reserved.identity, + 'reviewed_self_recovery' + ); + if (!preparation) throw Error('actual self-first factory absent'); + const self = await prepareSelfRecovery( + preparation, + 'reviewed_self_recovery' + ); + const discovery = 'wss://discovery.example.org', + peerOrigin = 'wss://peer.example.org', + archiveOrigin = 'wss://archive.example.org'; + const policy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: [ + { origin: discovery, read: true, write: false, nip50: false } + ], + inbox: [peerOrigin, archiveOrigin].map((origin) => ({ + origin, + read: true, + write: true + })), + postingEnabled: false, + messagingEnabled: true, + operatorDenylist: [] + }) + ); + if (!policy) throw Error('controlled discovery policy absent'); + function resolve(signer: typeof foreign, origin: string) { + const event = signer.sign({ + kind: 10050, + created_at: Math.floor(Date.now() / 1000), + tags: [['relay', origin]], + content: '' + }), + scheduler = createPublicScheduler(), + run = createPublicRun(scheduler, policy!); + schedulers.push(scheduler); + return createInboxResolver( + run, + signer.owner, + (next) => + openInboxRequest( + run, + signer.owner, + (sink) => { + sink({ + type: 'EVENT', + from: discovery, + id: 'CR004_TEST_ONLY', + event + }); + sink({ + type: 'EOSE', + from: discovery, + id: 'CR004_TEST_ONLY' + }); + return () => {}; + }, + next + ), + () => ownership?.current() === true + ); + } + const own = resolve(signer, archiveOrigin), + other = resolve(foreign, peerOrigin), + plan = createInboxRoutePlan(policy, owner, foreign.owner, own, other); + if (!plan) throw Error('actual reviewed route plan absent'); + const pair = await preparePairedDelivery( + preparation, + { policy, own, other, plan }, + 'reviewed_pair_preparation' + ); + return { + reservation: reserved.status, + self: self.status, + pair: pair.status, + paired: !!preparedPairedDelivery(preparation), + id + }; + } finally { + if (preparation) stopSelfRecoveryPreparation(preparation); + stopRumorPlan(rumor); + for (const scheduler of schedulers) closePublicScheduler(scheduler); + } + }, + async reserveNext() { + const result = await reservePrivateSendReservation( + reservationRepository, + JSON.stringify({ + schema: 1, + family: 'private_send_reservation', + owner, + id: crypto.randomUUID(), + revision: 0, + peer: foreign.owner, + rumorHash: '8'.repeat(64), + createdAt: 1700000000 + }), + 1700000000, + ownership.current + ); + return result.ok ? 'reserved' : result.reason; + }, + async changeOutbox() { + const stored = (await transactionRows())[3].find( + (row) => row.id === settledIds[0] + ); + if (!stored) throw Error('original outbox row absent'); + const decoded = decodePrivateRecord(stored.wire, owner, stored.id), + record = + decoded.ok && privateRecordSnapshot(decoded.value, owner, stored.id); + if ( + !decoded.ok || + !record || + record.family !== 'private_send_operation' || + !record.receipts?.length + ) + throw Error('original paired record absent'); + const next = decodePrivateRecord( + JSON.stringify({ + ...record, + revision: record.revision + 1, + receipts: [ + ...record.receipts, + { + ...record.receipts[0], + actionId: crypto.randomUUID(), + status: 'unknown' + } + ] + }), + owner, + record.id + ); + if ( + !next.ok || + !(await commitPrivateRecord(priv, next.value, decoded.value)).ok + ) + throw Error('actual outbox CAS change absent'); + }, + switchKey: () => { + changedKey = true; + }, + async confirmWhileSdkBusy() { + const original = identityViewSession(identity); + if (!original) throw Error('actual identity absent'); + const session = await createPrivateSession( + original, + 'reviewed_private_session' + ); + if (!session) throw Error('actual private session absent'); + let entered = () => {}, + release = () => {}; + const ready = new Promise<void>((resolve) => { + entered = resolve; + }); + const held = withIdlePrivateLocalStorage( + session, + () => + new Promise<void>((resolve) => { + release = resolve; + entered(); + }) + ); + await ready; + try { + return await confirm(); + } finally { + release(); + await held; + } + }, + async abortOutboxDelete(unknown = false) { + const descriptor = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'delete' + ); + if (!descriptor) throw Error('actual delete descriptor absent'); + const nativeDelete = descriptor.value as IDBObjectStore['delete'], + nativeAbort = Reflect.get<IDBTransaction, 'abort'>( + IDBTransaction.prototype, + 'abort' + ); + let deletes = 0, + aborts = 0; + let terminal: Promise<'abort' | 'complete'> | undefined; + IDBObjectStore.prototype.delete = function (...args) { + const request = Reflect.apply(nativeDelete, this, args); + if (this.name === 'private_sends') { + const transaction = this.transaction; + terminal = new Promise((resolve) => { + transaction.addEventListener('abort', () => { + aborts++; + resolve('abort'); + }); + transaction.addEventListener('complete', () => resolve('complete')); + }); + if (unknown) { + this.transaction.abort = () => { + throw Error('controlled lost abort capability'); + }; + throw Error( + 'controlled lost delete result after actual queued request' + ); + } + request.addEventListener( + 'success', + () => { + deletes++; + Reflect.apply(nativeAbort, this.transaction, []); + }, + { once: true } + ); + } + return request; + }; + try { + const confirmed = await confirm(), + nativeTerminal = terminal && (await terminal); + return { confirmed, deletes, aborts, nativeTerminal }; + } finally { + Object.defineProperty(IDBObjectStore.prototype, 'delete', descriptor); + } + }, effects: () => ({ ...counts }), snapshot: () => localDataReviewSnapshot(review), review: inspect, diff --git a/web/tests/e2e/local-data-review.spec.ts b/web/tests/e2e/local-data-review.spec.ts @@ -396,4 +396,191 @@ test.describe('HCP125 original local data workflow and native storage', () => { ) ).toBe(true); }); + + test('CR004 reviewed settled removal frees actual capacity while preserving other namespaces', async ({ + page + }) => { + await load(page, 'outbox'); + const before = await page.evaluate(() => window.hcp125Fixture.rows()); + expect(before).toMatchObject({ + outbox: 100, + publicDrafts: 2, + publicOperations: 1, + received: 2, + foreignReceived: 1 + }); + expect(await page.evaluate(() => window.hcp125Fixture.reserveNext())).toBe( + 'capacity' + ); + await page + .getByRole('button', { name: 'Review data in this browser', exact: true }) + .click(); + await expect( + page.getByRole('checkbox', { name: /Eligible settled send/ }) + ).toHaveCount(100); + await page + .getByRole('checkbox', { name: /Eligible settled send/ }) + .first() + .check(); + await page + .getByRole('button', { name: 'Review settled send removal', exact: true }) + .click(); + await expect( + page.getByText('duplicate-prevention evidence', { exact: false }) + ).toBeVisible(); + await page + .getByRole('button', { name: 'Confirm removal', exact: true }) + .click(); + await expect(page.getByRole('status').last()).toContainText( + 'Removed 1 selected settled send record' + ); + const removed = await page.evaluate(() => window.hcp125Fixture.rows()); + expect(removed).toEqual({ ...before, outbox: 99 }); + expect( + await page.evaluate(() => window.hcp125Fixture.effects()) + ).toMatchObject({ signs: 0, encrypts: 0, decrypts: 0 }); + const fresh = await page.evaluate(() => window.hcp125Fixture.freshSend()); + expect(fresh).toMatchObject({ + reservation: 'reserved', + self: 'saved', + pair: 'prepared', + paired: true + }); + expect( + await page.evaluate(() => window.hcp125Fixture.settledIds()) + ).not.toContain(fresh.id); + expect( + await page.evaluate(() => window.hcp125Fixture.effects()) + ).toMatchObject({ signs: 2, encrypts: 2 }); + expect(await page.evaluate(() => window.hcp125Fixture.rows())).toEqual( + before + ); + expect(await page.evaluate(() => window.hcp125Fixture.reserveNext())).toBe( + 'capacity' + ); + }); + + test('CR004 a second same-origin tab holding the actual owner lock prevents cleanup', async ({ + page, + context + }) => { + await load(page, 'outbox'); + expect( + await page.evaluate(() => window.hcp125Fixture.reviewAndPreviewOutbox()) + ).toBe(true); + const owner = await page.evaluate(() => window.hcp125Fixture.owner), + other = await context.newPage(); + try { + await other.goto(server.url + '/about'); + await other.evaluate(async (owner) => { + const state = window as typeof window & { + cr004Release?: () => void; + cr004Held?: Promise<void>; + }; + let entered = () => {}; + const ready = new Promise<void>((resolve) => { + entered = resolve; + }); + state.cr004Held = navigator.locks.request( + 'harvestcircle:owner:' + owner, + async () => { + entered(); + await new Promise<void>((resolve) => { + state.cr004Release = resolve; + }); + } + ); + await ready; + }, owner); + expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe( + false + ); + expect( + (await page.evaluate(() => window.hcp125Fixture.rows())).outbox + ).toBe(100); + expect( + await page.evaluate(() => window.hcp125Fixture.effects()) + ).toMatchObject({ signs: 0, encrypts: 0, decrypts: 0 }); + } finally { + if (!other.isClosed()) { + await other.evaluate(async () => { + const state = window as typeof window & { + cr004Release?: () => void; + cr004Held?: Promise<void>; + }; + state.cr004Release?.(); + await state.cr004Held; + }); + await other.close(); + } + } + }); + + for (const outcome of [ + 'changed', + 'lock_busy', + 'sdk_busy', + 'key_changed', + 'aborted', + 'unknown' + ] as const) + test( + 'CR004 actual ' + + outcome + + ' cannot certify removal of the reviewed original', + async ({ page }) => { + await load(page, 'outbox'); + expect( + await page.evaluate(() => + window.hcp125Fixture.reviewAndPreviewOutbox() + ) + ).toBe(true); + const result = await page.evaluate(async (outcome) => { + const f = window.hcp125Fixture; + if (outcome === 'changed') await f.changeOutbox(); + if (outcome === 'key_changed') f.switchKey(); + const fault = + outcome === 'aborted' || outcome === 'unknown' + ? await f.abortOutboxDelete(outcome === 'unknown') + : undefined; + const confirmed = + fault?.confirmed ?? + (outcome === 'lock_busy' + ? await f.confirmWhileLocked() + : outcome === 'sdk_busy' + ? await f.confirmWhileSdkBusy() + : await f.confirm()); + return { + confirmed, + fault, + rows: await f.rows(), + effects: f.effects() + }; + }, outcome); + expect(result.confirmed).toBe(false); + expect(result.rows.outbox).toBe(outcome === 'unknown' ? 99 : 100); + expect(result.rows).toMatchObject({ + publicDrafts: 2, + publicOperations: 1, + received: 2, + foreignReceived: 1 + }); + expect(result.effects).toMatchObject({ + signs: 0, + encrypts: 0, + decrypts: 0 + }); + if (outcome === 'aborted') + expect(result.fault).toMatchObject({ + deletes: 1, + aborts: 1, + nativeTerminal: 'abort' + }); + if (outcome === 'unknown') + expect(result.fault).toMatchObject({ + aborts: 0, + nativeTerminal: 'complete' + }); + } + ); }); diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -1953,7 +1953,13 @@ import { auditOutput } from '../../tools/check-output.mjs'; 'src/lib/nostr/inbox-preference-publication.ts', 'src/lib/nostr/incoming-wire.ts', 'src/lib/messaging/send-identity.ts', - 'src/lib/persistence/private-send-reservations.ts' + 'src/lib/persistence/private-send-reservations.ts', + 'src/lib/persistence/local-data-review.ts', + 'src/lib/persistence/local-inventory.ts', + 'src/lib/persistence/private-storage.ts', + 'src/lib/persistence/private-outbox-cleanup.ts', + 'src/lib/runtime/private-session.ts', + 'src/lib/components/LocalDataReview.svelte' ]) { await check( 'operational flags rejects changed owned producer ' + producer, @@ -1982,6 +1988,43 @@ import { auditOutput } from '../../tools/check-output.mjs'; } ); } + for (const mutation of [ + 'missing-owner', + 'duplicate-owner', + 'dynamic-edge' + ]) + await check( + 'settled cleanup compiler rejects ' + mutation, + async (t) => { + const f = await fixture(t), + file = path.join( + f.web, + '.svelte-kit/output/client/.vite/manifest.json' + ), + manifest = JSON.parse(await readFile(file, 'utf8')), + row = Object.values(manifest).find( + (record) => record.name === 'nodes/6' + ), + owner = Object.entries(manifest).find( + ([, record]) => record.name === 'public-key' + )?.[0]; + assert.ok(row && owner && row.imports.includes(owner)); + if (mutation === 'missing-owner') + row.imports = row.imports.filter( + (/** @type {string} */ key) => key !== owner + ); + if (mutation === 'duplicate-owner') + row.imports = [...row.imports, owner]; + if (mutation === 'dynamic-edge') row.dynamicImports = [owner]; + await writeFile(file, JSON.stringify(manifest)); + await assert.rejects( + f.audit, + mutation === 'duplicate-owner' + ? /Invalid compiler references/ + : /Invalid owned listing editor compiler graph/ + ); + } + ); for (const route of [ 'src/routes/sell/+page.svelte', 'src/routes/selling/drafts/[draftId=local_id]/+page.svelte', diff --git a/web/tests/unit/private-outbox-settlement.test.ts b/web/tests/unit/private-outbox-settlement.test.ts @@ -0,0 +1,193 @@ +import { describe, expect, it } from 'vitest'; +import type { + PrivateSendOperation, + PrivateTargetReceipt +} from '../../src/lib/persistence/private-records.ts'; +import { + privateRecordSettlement, + privateInventoryRow, + PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES +} from '../../src/lib/persistence/local-inventory.ts'; +const owner = 'a'.repeat(64), + peer = 'b'.repeat(64), + id = '12345678-1234-4234-8234-123456789abc'; +const route = (role: 'peer' | 'self_archive', origin: string) => ({ + role, + author: role === 'peer' ? peer : owner, + targets: [origin], + knownBase: { + author: role === 'peer' ? peer : owner, + id: 'c'.repeat(64), + createdAt: 100 + }, + sources: [{ source: 'wss://discovery.example.org', state: 'eose' as const }] +}); +const routes = { + peer: route('peer', 'wss://peer.example.org'), + archive: route('self_archive', 'wss://archive.example.org') +}; +function fact( + role: 'peer' | 'self_archive', + status: PrivateTargetReceipt['status'] = 'accepted', + origin = role === 'peer' ? routes.peer.targets[0] : routes.archive.targets[0] +): PrivateTargetReceipt { + return { + actionId: id, + origin, + role, + attempt: 1, + eventId: role === 'peer' ? 'd'.repeat(64) : 'e'.repeat(64), + status, + observedAtMilliseconds: 1000, + readbackWire: null + }; +} +// Pure structural bookkeeping inputs only. These objects cannot admit storage, +// mint genuine sender/relay receipts, authorize deletion or qualify delivery. +const operation: PrivateSendOperation = { + schema: 1, + family: 'private_send_operation', + owner, + peer, + id, + revision: 1, + rumorHash: 'f'.repeat(64), + createdAt: 100, + self: { eventId: 'e'.repeat(64), wire: 'controlled' }, + peerArtifact: { eventId: 'd'.repeat(64), wire: 'controlled' }, + deliveryPlan: { state: 'prepared', routes }, + receipts: [fact('peer'), fact('self_archive')] +}; +describe('conservative settled private-outbox eligibility', () => { + it('requires both artifacts, an exact prepared route and every current named acceptance', () => { + expect(privateRecordSettlement(operation)).toBe('settled'); + expect(privateRecordSettlement({ ...operation, peerArtifact: null })).toBe( + 'protected' + ); + expect( + privateRecordSettlement({ ...operation, deliveryPlan: undefined }) + ).toBe('protected'); + expect(privateRecordSettlement({ ...operation, receipts: [] })).toBe( + 'protected' + ); + expect( + privateRecordSettlement({ ...operation, receipts: [fact('peer')] }) + ).toBe('protected'); + expect( + privateRecordSettlement({ + ...operation, + family: 'private_send_reservation', + revision: 0 + }) + ).toBe('protected'); + }); + for (const status of [ + 'refused', + 'readback', + 'unknown', + 'timed_out', + 'stopped' + ] as const) + it('a current ' + status + ' target is not acceptance', () => { + expect( + privateRecordSettlement({ + ...operation, + receipts: [fact('peer', status), fact('self_archive')] + }) + ).toBe('protected'); + }); + it('a different event, role or origin cannot satisfy the current target', () => { + for (const changed of [ + { eventId: '1'.repeat(64) }, + { role: 'self_archive' as const }, + { origin: 'wss://other.example.org' } + ]) + expect( + privateRecordSettlement({ + ...operation, + receipts: [{ ...fact('peer'), ...changed }, fact('self_archive')] + }) + ).toBe('protected'); + }); + for (const status of ['unknown', 'timed_out', 'stopped'] as const) + it( + 'later exact acceptance resolves ' + + status + + ' while a later uncertainty stays protected', + () => { + expect( + privateRecordSettlement({ + ...operation, + receipts: [fact('peer', status), ...operation.receipts!] + }) + ).toBe('settled'); + expect( + privateRecordSettlement({ + ...operation, + receipts: [...operation.receipts!, fact('peer', status)] + }) + ).toBe('protected'); + } + ); + it('changing routes or using readback does not resolve an uncertain old target', () => { + const uncertain = fact('peer', 'unknown', 'wss://old.example.org'); + const changed = { + ...operation, + deliveryPlan: { + ...operation.deliveryPlan!, + previousRoutes: [{ ...routes, peer: route('peer', uncertain.origin) }] + } + }; + expect( + privateRecordSettlement({ + ...changed, + receipts: [uncertain, ...operation.receipts!] + }) + ).toBe('protected'); + expect( + privateRecordSettlement({ + ...changed, + receipts: [ + uncertain, + fact('peer', 'readback', uncertain.origin), + ...operation.receipts! + ] + }) + ).toBe('protected'); + expect( + privateRecordSettlement({ + ...changed, + receipts: [ + uncertain, + fact('peer', 'accepted', uncertain.origin), + ...operation.receipts! + ] + }) + ).toBe('settled'); + }); + it('an earlier definitive refusal on an old route does not create an unresolved effect', () => { + expect( + privateRecordSettlement({ + ...operation, + receipts: [ + fact('peer', 'refused', 'wss://old.example.org'), + ...operation.receipts! + ] + }) + ).toBe('settled'); + }); + it('inventory exposes only local bounded status and discloses recovery/deduplication loss', () => { + expect(privateInventoryRow(operation, 321)).toEqual({ + id, + revision: 1, + logicalBytes: 321, + state: 'settled' + }); + expect(PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES).toContain( + 'duplicate-prevention' + ); + expect(PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES).toContain( + 'does not erase remote' + ); + }); +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -269,7 +269,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/components/ListingReview.svelte': 'deee41ca6c60b346afc7ed5e62e3101ee03b04fdd2a9aa8fa3f3dec585e3863b', 'src/lib/components/LocalDataReview.svelte': - '662e77b3c7df48baeed317628c848bfc50f0b5643145e04cdaf017a1cc078ff5', + '63b259ed2c7daa552a6c54665da74f45275ec45c60b415207a008a4ac1aa5b37', 'src/lib/components/MessageComposer.svelte': 'c3ab09ae9a2dc5ac8268cc45218140c5480dcb9bcf8b8bce54d2ae35ffdb2d14', 'src/lib/components/MessageItem.svelte': @@ -365,9 +365,11 @@ async function operationalFlagsAdmission(web) { 'src/lib/persistence/inbox-retention.ts': '8bcc73be03321e60a6fbbe7ba58de14eb8fb34db5d5cdce0adee31b5467d7bb9', 'src/lib/persistence/local-data-review.ts': - '80c786bcce36f84b79775eea1710611ea77a1ee666fedb0067be4341949eb5df', + '90379b183d0a1d8885076fbfc593d7c9ac1e351b16ce7800890107014e5cb0e4', + 'src/lib/persistence/private-outbox-cleanup.ts': + '13f4e7d771b3a8d4ec7703f2026a1c8ff71582a2d2a810b9d402d58684b2e2b6', 'src/lib/persistence/local-inventory.ts': - '2ff3ca31cee4eec65b56a8f87d8ecdd0238cb86ef4bbe18d74518f299570adc1', + 'cd44ed47548453f0443400894c57c364b544781c028c4dba6e9fa096034c5965', 'src/lib/persistence/local-private-blocks.ts': 'd7e76c1122ff5479f261293db458a3240438ce0471c788c2f07ffaf854449cbc', 'src/lib/persistence/local-public-hides.ts': @@ -375,7 +377,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/persistence/private-records.ts': '3389fe2fc5b9b84b292b4340fe1edda16a2eb365c1b0fb00d965827dd9b02ce6', 'src/lib/persistence/private-storage.ts': - 'e45a95c9b12e8534a6ab0a4ec8ee1c86e730bba2f252dc1947954439720f2bfc', + 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -413,7 +415,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/runtime/identity-session.ts': '7d665f6872bdc780f1f2b56245730adcc90f32cf1fed6997f7e2e44ea2447b49', 'src/lib/runtime/private-session.ts': - '4ba4250e2a96c077b19144517b1f091934a124916108afe73871ccb00d9b47ab', + 'ecffe8a4a735478669f46e666e96add6d4b32c615e3741fcc2277a07ca2ef6c3', 'src/lib/runtime/public-runtime.ts': '679aa4cd51a1dfdc81459bdfccb29441ac60edfa8b1ddd579425787c85b5cff4', 'src/lib/runtime/view-context.ts': @@ -521,7 +523,7 @@ async function privacyDataAdmission(web) { 'src/lib/components/ListingReview.svelte': 'deee41ca6c60b346afc7ed5e62e3101ee03b04fdd2a9aa8fa3f3dec585e3863b', 'src/lib/components/LocalDataReview.svelte': - '662e77b3c7df48baeed317628c848bfc50f0b5643145e04cdaf017a1cc078ff5', + '63b259ed2c7daa552a6c54665da74f45275ec45c60b415207a008a4ac1aa5b37', 'src/lib/components/MessageComposer.svelte': 'bc8ac0e2123b60957f1c289acbb2b8740e171097029f640f657cd79f5aa8423b', 'src/lib/components/MessageItem.svelte': @@ -607,9 +609,11 @@ async function privacyDataAdmission(web) { 'src/lib/persistence/inbox-retention.ts': '8bcc73be03321e60a6fbbe7ba58de14eb8fb34db5d5cdce0adee31b5467d7bb9', 'src/lib/persistence/local-data-review.ts': - '80c786bcce36f84b79775eea1710611ea77a1ee666fedb0067be4341949eb5df', + '90379b183d0a1d8885076fbfc593d7c9ac1e351b16ce7800890107014e5cb0e4', + 'src/lib/persistence/private-outbox-cleanup.ts': + '13f4e7d771b3a8d4ec7703f2026a1c8ff71582a2d2a810b9d402d58684b2e2b6', 'src/lib/persistence/local-inventory.ts': - '2ff3ca31cee4eec65b56a8f87d8ecdd0238cb86ef4bbe18d74518f299570adc1', + 'cd44ed47548453f0443400894c57c364b544781c028c4dba6e9fa096034c5965', 'src/lib/persistence/local-private-blocks.ts': 'd7e76c1122ff5479f261293db458a3240438ce0471c788c2f07ffaf854449cbc', 'src/lib/persistence/local-public-hides.ts': @@ -617,7 +621,7 @@ async function privacyDataAdmission(web) { 'src/lib/persistence/private-records.ts': '3389fe2fc5b9b84b292b4340fe1edda16a2eb365c1b0fb00d965827dd9b02ce6', 'src/lib/persistence/private-storage.ts': - 'e45a95c9b12e8534a6ab0a4ec8ee1c86e730bba2f252dc1947954439720f2bfc', + 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -651,7 +655,7 @@ async function privacyDataAdmission(web) { 'src/lib/runtime/identity-session.ts': '7d665f6872bdc780f1f2b56245730adcc90f32cf1fed6997f7e2e44ea2447b49', 'src/lib/runtime/private-session.ts': - '4ba4250e2a96c077b19144517b1f091934a124916108afe73871ccb00d9b47ab', + 'ecffe8a4a735478669f46e666e96add6d4b32c615e3741fcc2277a07ca2ef6c3', 'src/lib/runtime/public-runtime.ts': '679aa4cd51a1dfdc81459bdfccb29441ac60edfa8b1ddd579425787c85b5cff4', 'src/lib/runtime/view-context.ts': @@ -820,7 +824,7 @@ async function supportReportingAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-storage.ts': - 'e45a95c9b12e8534a6ab0a4ec8ee1c86e730bba2f252dc1947954439720f2bfc', + 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -854,7 +858,7 @@ async function supportReportingAdmission(web) { 'src/lib/runtime/identity-session.ts': '7d665f6872bdc780f1f2b56245730adcc90f32cf1fed6997f7e2e44ea2447b49', 'src/lib/runtime/private-session.ts': - '4ba4250e2a96c077b19144517b1f091934a124916108afe73871ccb00d9b47ab', + 'ecffe8a4a735478669f46e666e96add6d4b32c615e3741fcc2277a07ca2ef6c3', 'src/lib/runtime/public-runtime.ts': '679aa4cd51a1dfdc81459bdfccb29441ac60edfa8b1ddd579425787c85b5cff4', 'src/lib/runtime/view-context.ts': @@ -1007,7 +1011,7 @@ async function privateBlockingAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-storage.ts': - 'e45a95c9b12e8534a6ab0a4ec8ee1c86e730bba2f252dc1947954439720f2bfc', + 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -1041,7 +1045,7 @@ async function privateBlockingAdmission(web) { 'src/lib/runtime/identity-session.ts': '7d665f6872bdc780f1f2b56245730adcc90f32cf1fed6997f7e2e44ea2447b49', 'src/lib/runtime/private-session.ts': - '4ba4250e2a96c077b19144517b1f091934a124916108afe73871ccb00d9b47ab', + 'ecffe8a4a735478669f46e666e96add6d4b32c615e3741fcc2277a07ca2ef6c3', 'src/lib/runtime/public-runtime.ts': '679aa4cd51a1dfdc81459bdfccb29441ac60edfa8b1ddd579425787c85b5cff4', 'src/lib/runtime/view-context.ts': @@ -2130,7 +2134,7 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/conversation-thread.ts': '7367f0e6d96a9f249514f66c2459274e856eb83462523e37264d4cd97d2e36d1', 'src/lib/persistence/private-storage.ts': - 'e45a95c9b12e8534a6ab0a4ec8ee1c86e730bba2f252dc1947954439720f2bfc', + 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', 'src/routes/messages/[conversationId=local_id]/+page.svelte': 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7', 'src/lib/components/MessageComposer.svelte': @@ -5293,6 +5297,7 @@ export async function auditOutput(webDirectory) { src: '.svelte-kit/generated/build/client-optimized/nodes/6.js', isEntry: true, imports: [ + ...(hasOperationalFlags ? ['public-key'] : []), 'private-session', 'client', 'navigation-url',