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:
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',