commit ec6b02f162eb70d7c0980c75bef663bd991b9ec7
parent 1bcdb56ed84aaa84b8c047a229f39147f92d3c73
Author: triesap <tyson@radroots.org>
Date: Wed, 14 Oct 2026 23:50:02 +0000
web: gate reviewed probe cleanup on native removal evidence
- Bind cleanup to genuine current nonce, archive and readback lineage.
- Require exact native deletion, completion and fresh absence before retirement.
- Preserve unapplied archive outcomes and physical custody across retries.
- Cover original and recovered cleanup with native, capacity and output controls.
Diffstat:
11 files changed, 4247 insertions(+), 27 deletions(-)
diff --git a/web/src/lib/nostr/private-publisher.ts b/web/src/lib/nostr/private-publisher.ts
@@ -2,18 +2,28 @@ import {
inboxProbePublicationBinding,
recoveredInboxProbePublicationBinding,
verifyInboxProbeAcknowledgement,
+ inboxProbeCleanupSelectionBinding,
+ retireInboxProbeCleanupSelection,
+ appliedInboxProbeArchiveAdmission,
+ type InboxProbeCleanupSelection,
type InboxProbeAcknowledgement
} from '../persistence/inbox-probes.ts';
import {
inboxProbeActionOwner,
+ stopInboxProbeIdentity,
type InboxProbeIdentity
} from './inbox-access.ts';
-import type { RecoveredInboxProbe } from './self-recovery-reader.ts';
+import {
+ disposeRecoveredInboxProbe,
+ type RecoveredInboxProbe
+} from './self-recovery-reader.ts';
import {
inboxAccessControllerSnapshot,
+ inboxAccessConstructionBinding,
type InboxAccessController
} from '../messaging/inbox-access-controller.ts';
import { privatePoolProbeRetryIdle } from './private-pool.ts';
+import type { InboxProbeArchiveAttemptResult } from './private-pool.ts';
import {
privateSessionOwnership,
withIdlePrivateLocalStorage,
@@ -25,7 +35,11 @@ import {
verifyPairedDeliveryAcknowledgement,
type PairedDeliveryAcknowledgement
} from '../persistence/private-sends.ts';
-import type { PrivateStorageRepository } from '../persistence/private-storage.ts';
+import {
+ privateProbeRemovalEvidence,
+ type PrivateProbeRemovalProof,
+ type PrivateStorageRepository
+} from '../persistence/private-storage.ts';
import type { PairedDeliveryContext } from '../messaging/prepare-send.ts';
import {
inboxRoutePlanSnapshot,
@@ -88,6 +102,9 @@ function networkMeter(probe: boolean) {
const actionId = newLocalId();
if (!actionId) return undefined;
const counts = new Map<string, number>();
+ // Probe-only causal obligations survive finish and controller replacement.
+ // The existing three origins/three combined attempts bound this map to nine.
+ const pendingArchives = new Map<string, true>();
let used = 0,
running = false,
broken = false,
@@ -104,6 +121,18 @@ function networkMeter(probe: boolean) {
return {
current: () => !broken,
idle: () => !running,
+ archivesApplied: () => pendingArchives.size === 0,
+ applyArchive(
+ action: string,
+ origin: string,
+ eventId: string,
+ attempt: number
+ ) {
+ if (probe && action === actionId)
+ pendingArchives.delete(
+ JSON.stringify([action, origin, eventId, attempt])
+ );
+ },
probeAvailable: (origin: string, eventId: string) =>
probe &&
!broken &&
@@ -133,6 +162,11 @@ function networkMeter(probe: boolean) {
const start = clock();
if (start === undefined) return undefined;
counts.set(key, count + 1);
+ if (probe && role === 'access_archive')
+ pendingArchives.set(
+ JSON.stringify([actionId, origin, eventId, count + 1]),
+ true
+ );
running = true;
let finished = false;
function remaining() {
@@ -482,6 +516,15 @@ type ProbeMeterOwner = {
original: string;
meter: ProbeMeter;
current(): boolean;
+ held(): boolean;
+ claim(): boolean;
+ release(): void;
+ retain(
+ identity: InboxProbeIdentity | RecoveredInboxProbe,
+ source: ProbeAction['source'],
+ repository: PrivateStorageRepository
+ ): void;
+ dispose(session: PrivateSession, policy: RelayPolicy): void;
};
// Bounded within an actual private-session lifetime, never persisted authority.
// Retired action replacement reuses the slot; it cannot grow action history.
@@ -509,7 +552,9 @@ function probeMeter(
if (
!replace ||
previous.current() ||
+ previous.held() ||
!previous.meter.idle() ||
+ !previous.meter.archivesApplied() ||
retired?.state !== 'stopped' ||
retired.cleanupRequired ||
!privatePoolProbeRetryIdle(session, policy) ||
@@ -531,9 +576,259 @@ function probeMeter(
(replace && !privatePoolProbeRetryIdle(session, policy))
)
return undefined;
- registry.set(command, { access, original, meter, current });
+ let held = false;
+ // At most one original and one recovered identity per actual controller.
+ // This is the same bounded command entry, never a historical identity list.
+ const identities = new Map<
+ ProbeAction['source'],
+ Readonly<{
+ identity: InboxProbeIdentity | RecoveredInboxProbe;
+ repository: PrivateStorageRepository;
+ }>
+ >();
+ registry.set(command, {
+ access,
+ original,
+ meter,
+ current,
+ held: () => held,
+ claim() {
+ if (held) return false;
+ held = true;
+ return true;
+ },
+ release() {
+ held = false;
+ },
+ retain(identity, source, repository) {
+ identities.set(source, { identity, repository });
+ },
+ dispose(session, policy) {
+ for (const [source, saved] of identities) {
+ if (source === 'construction')
+ stopInboxProbeIdentity(saved.identity as InboxProbeIdentity);
+ else
+ disposeRecoveredInboxProbe(
+ saved.identity as RecoveredInboxProbe,
+ saved.repository,
+ session,
+ policy
+ );
+ }
+ identities.clear();
+ }
+ });
return meter;
}
+function probeCommandAvailable(
+ session: PrivateSession,
+ command: string,
+ meter: ProbeMeter
+) {
+ const saved = commandMeters.get(session)?.get(command);
+ return !!saved && saved.meter === meter && !saved.held();
+}
+
+declare const probeCleanupLeaseBrand: unique symbol;
+export type InboxProbeCleanupLease = Readonly<{
+ [probeCleanupLeaseBrand]: true;
+}>;
+type CleanupLease = Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ policy: RelayPolicy;
+ selection: InboxProbeCleanupSelection;
+ entry: ProbeMeterOwner;
+ command: string;
+ wire: string;
+ current(): boolean;
+ scopeCurrent(): boolean;
+ retired(): boolean;
+ markRetired(): void;
+}>;
+const cleanupLeases = new WeakMap<InboxProbeCleanupLease, CleanupLease>();
+
+// Only genuine native-applied source evidence can discharge an actual charge.
+// This works after controller loss without creating current network authority.
+export function reconcileInboxProbeArchiveAdmission(
+ result: InboxProbeArchiveAttemptResult
+): void {
+ const applied = appliedInboxProbeArchiveAdmission(result);
+ if (!applied) return;
+ commandMeters
+ .get(applied.session)
+ ?.get(applied.command)
+ ?.meter.applyArchive(
+ applied.actionId,
+ applied.origin,
+ applied.eventId,
+ applied.attempt
+ );
+}
+
+function cleanupLeaseBinding(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ selection: InboxProbeCleanupSelection
+) {
+ if (typeof window === 'undefined') return undefined;
+ try {
+ const binding = inboxProbeCleanupSelectionBinding(
+ selection,
+ repository,
+ session,
+ policy
+ );
+ if (!binding) return undefined;
+ const entry = commandMeters.get(session)?.get(binding.record.id),
+ action = identityActions.get(binding.identity),
+ scope = inboxAccessConstructionBinding(binding.access, session, policy);
+ if (
+ !entry ||
+ !action ||
+ !scope ||
+ entry.access !== binding.access ||
+ action.repository !== repository ||
+ action.session !== session ||
+ action.policy !== policy ||
+ action.meter !== entry.meter ||
+ action.original !== entry.original ||
+ entry.original !== probeImmutable(binding.record) ||
+ !entry.meter.idle() ||
+ !entry.meter.archivesApplied() ||
+ !entry.meter.current() ||
+ entry.held() ||
+ !binding.current()
+ )
+ return undefined;
+ function scopeCurrent() {
+ const snapshot = inboxAccessControllerSnapshot(binding!.access);
+ return (
+ scope!.current() &&
+ !!snapshot &&
+ !snapshot.busy &&
+ !snapshot.cleanupRequired &&
+ snapshot.state !== 'stopped' &&
+ privatePoolProbeRetryIdle(session, policy)
+ );
+ }
+ if (!scopeCurrent()) return undefined;
+ return { binding, entry, scopeCurrent };
+ } catch {
+ return undefined;
+ }
+}
+
+// Pure source/resource preflight before any fresh provider request. The lease
+// repeats admission after the callback-capable provider wait and native reads.
+export function inboxProbeCleanupReady(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ selection: InboxProbeCleanupSelection
+): boolean {
+ return !!cleanupLeaseBinding(repository, session, policy, selection);
+}
+
+export function acquireInboxProbeCleanupLease(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ selection: InboxProbeCleanupSelection
+): InboxProbeCleanupLease | undefined {
+ try {
+ const selected = cleanupLeaseBinding(
+ repository,
+ session,
+ policy,
+ selection
+ );
+ if (!selected || !selected.entry.claim()) return undefined;
+ const { binding, entry, scopeCurrent } = selected;
+ let retired = false;
+ const token = Object.freeze({}) as InboxProbeCleanupLease;
+ cleanupLeases.set(token, {
+ repository,
+ session,
+ policy,
+ selection,
+ entry,
+ command: binding.record.id,
+ wire: binding.wire,
+ scopeCurrent,
+ current: () =>
+ !retired &&
+ commandMeters.get(session)?.get(binding.record.id) === entry &&
+ entry.held() &&
+ entry.meter.idle() &&
+ entry.meter.archivesApplied() &&
+ entry.meter.current() &&
+ binding.current() &&
+ scopeCurrent(),
+ retired: () => retired,
+ markRetired() {
+ retired = true;
+ }
+ });
+ return token;
+ } catch {
+ return undefined;
+ }
+}
+export function inboxProbeCleanupLeaseCurrent(
+ lease: InboxProbeCleanupLease
+): boolean {
+ return cleanupLeases.get(lease)?.current() ?? false;
+}
+export function releaseInboxProbeCleanupLease(
+ lease: InboxProbeCleanupLease
+): void {
+ const saved = cleanupLeases.get(lease);
+ if (
+ saved &&
+ !saved.retired() &&
+ commandMeters.get(saved.session)?.get(saved.command) === saved.entry
+ ) {
+ saved.entry.release();
+ cleanupLeases.delete(lease);
+ }
+}
+export function retireInboxProbeCleanupLease(
+ lease: InboxProbeCleanupLease,
+ proof: PrivateProbeRemovalProof
+): boolean {
+ const saved = cleanupLeases.get(lease);
+ if (!saved?.current()) return false;
+ const removed = privateProbeRemovalEvidence(
+ proof,
+ saved.repository,
+ saved.session
+ );
+ if (
+ !removed ||
+ removed.selection !== saved.selection ||
+ removed.wire !== saved.wire ||
+ removed.id !== saved.command ||
+ !saved.current()
+ )
+ return false;
+ if (!retireInboxProbeCleanupSelection(saved.selection, proof)) return false;
+ saved.entry.dispose(saved.session, saved.policy);
+ // Deliberate nonce disposal invalidates old ACKs, not this actual C7 scope.
+ // Loss during disposal cannot free a protected slot or mint current success.
+ if (
+ !saved.scopeCurrent() ||
+ !saved.entry.meter.idle() ||
+ !saved.entry.meter.archivesApplied() ||
+ commandMeters.get(saved.session)?.get(saved.command) !== saved.entry
+ )
+ return false;
+ commandMeters.get(saved.session)!.delete(saved.command);
+ saved.markRetired();
+ cleanupLeases.delete(lease);
+ return true;
+}
function probeImmutable(
row: NonNullable<ReturnType<typeof inboxProbePublicationBinding>>['record']
) {
@@ -601,11 +896,18 @@ export function captureInboxProbePublicationAction(
policy,
identity: binding.identity,
original,
- current: () => meter.current() && binding.current(),
+ current: () =>
+ meter.current() &&
+ binding.current() &&
+ probeCommandAvailable(session, binding.record.id, meter),
meter
};
identityActions.set(binding.identity, captured);
probeActions.set(token, captured);
+ commandMeters
+ .get(session)
+ ?.get(binding.record.id)
+ ?.retain(binding.identity, 'construction', repository);
return token;
} catch {
return undefined;
@@ -712,11 +1014,18 @@ export async function captureRecoveredInboxProbeRetryAction(
policy,
identity: binding.identity,
original,
- current: () => meter.current() && binding.current(),
+ current: () =>
+ meter.current() &&
+ binding.current() &&
+ probeCommandAvailable(session, binding.record.id, meter),
meter
};
identityActions.set(binding.identity, captured);
probeActions.set(token, captured);
+ commandMeters
+ .get(session)
+ ?.get(binding.record.id)
+ ?.retain(binding.identity, 'recovered', repository);
return token;
});
if (!idle.ok) retryBusy = true;
diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts
@@ -465,6 +465,7 @@ type SavedNonceProof = Readonly<{
original: string;
verifiedAtMilliseconds: number;
current(): boolean;
+ dispose(): void;
}>;
const probeNonceProofs = new WeakMap<InboxProbeNonceProof, SavedNonceProof>();
const recoveredNonceProofs = new WeakMap<
@@ -746,7 +747,8 @@ function captureProbeNonceReader(
acknowledgement,
original,
verifiedAtMilliseconds,
- current
+ current,
+ dispose: () => stop(false)
};
if (source === 'construction')
probeNonceProofs.set(issued as InboxProbeNonceProof, saved);
@@ -980,6 +982,28 @@ export function inboxProbeNonceVerificationEvidence(
: undefined;
}
+// A genuine selected source proof can clear its own reader after native local
+// removal. This grants no removal, signing, replacement identity or readiness.
+export function disposeInboxProbeNonceProof(
+ proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy
+): boolean {
+ const saved =
+ probeNonceProofs.get(proof as InboxProbeNonceProof) ??
+ recoveredNonceProofs.get(proof as RecoveredInboxProbeNonceProof);
+ if (
+ !saved ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ saved.policy !== policy
+ )
+ return false;
+ saved.dispose();
+ return true;
+}
+
declare const probeRecoveryReaderBrand: unique symbol;
export type InboxProbeRecoveryReader = Readonly<{
[probeRecoveryReaderBrand]: true;
@@ -1420,3 +1444,29 @@ export function recoveredInboxProbeRumorWire(
? recoveredProbes.get(proof)?.rumor()
: undefined;
}
+
+export function disposeRecoveredInboxProbe(
+ proof: RecoveredInboxProbe,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy
+): boolean {
+ const saved = recoveredProbes.get(proof);
+ if (
+ !saved ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ saved.policy !== policy
+ )
+ return false;
+ const original = accessRecoveryReaders.get(saved.access);
+ if (
+ !original ||
+ original.repository !== repository ||
+ original.session !== session ||
+ original.policy !== policy
+ )
+ return false;
+ recoveryReaders.get(original.reader)?.stop(false);
+ return !recoveredProbes.has(proof);
+}
diff --git a/web/src/lib/persistence/inbox-probe-cleanup.ts b/web/src/lib/persistence/inbox-probe-cleanup.ts
@@ -0,0 +1,371 @@
+import type { RelayPolicy } from '../config/relays.ts';
+import {
+ inboxAccessConstructionBinding,
+ subscribeInboxAccessControllerClose
+} from '../messaging/inbox-access-controller.ts';
+import {
+ acquireInboxProbeCleanupLease,
+ inboxProbeCleanupReady,
+ inboxProbeCleanupLeaseCurrent,
+ releaseInboxProbeCleanupLease,
+ retireInboxProbeCleanupLease
+} from '../nostr/private-publisher.ts';
+import {
+ privateSessionOwnership,
+ recheckPrivateSession,
+ subscribePrivateSessionClose,
+ withIdlePrivateLocalStorage,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import {
+ captureInboxProbeCleanupSelection,
+ inboxProbeCleanupSelectionBinding,
+ type InboxProbeCleanupSelection,
+ type InboxProbeNonceAcknowledgement
+} from './inbox-probes.ts';
+import { privateRecordWire } from './private-records.ts';
+import {
+ observePrivateRecord,
+ removePrivateInboxProbe,
+ type PrivateStorageRepository,
+ type PrivateStorageFailure
+} from './private-storage.ts';
+
+declare const cleanupBrand: unique symbol;
+export type InboxProbeCleanup = Readonly<{ [cleanupBrand]: true }>;
+declare const nativeCleanupBrand: unique symbol;
+export type InboxProbeNativeCleanup = Readonly<{ [nativeCleanupBrand]: true }>;
+declare const removalAcknowledgementBrand: unique symbol;
+export type InboxProbeRemovalAcknowledgement = Readonly<{
+ [removalAcknowledgementBrand]: true;
+}>;
+export type InboxProbeCleanupResult = Readonly<{
+ status: 'removed' | 'invalid' | 'busy' | 'stopped' | PrivateStorageFailure;
+ removed?: 1;
+ acknowledgement?: InboxProbeRemovalAcknowledgement;
+}>;
+type NativeAdmission = Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ selection: InboxProbeCleanupSelection;
+ owner: string;
+ id: string;
+ wire: string;
+ signal: AbortSignal;
+ current(): boolean;
+ take(): boolean;
+}>;
+const nativeAdmissions = new WeakMap<
+ InboxProbeNativeCleanup,
+ NativeAdmission
+>();
+const actions = new WeakMap<
+ InboxProbeCleanup,
+ Readonly<{
+ run(review: unknown): Promise<InboxProbeCleanupResult>;
+ stop(): void;
+ }>
+>();
+const removals = new WeakMap<
+ InboxProbeRemovalAcknowledgement,
+ Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ policy: RelayPolicy;
+ owner: string;
+ command: string;
+ eventId: string;
+ preferenceId: string;
+ readTargets: readonly string[];
+ archiveTargets: readonly string[];
+ operatorWire: string;
+ current(): boolean;
+ }>
+>();
+
+// Only this module issues these tickets, while its actual owner WebLock and SDK
+// job are both held. No public capture returns a native ticket or raw validator.
+export function inboxProbeCleanupAdmission(
+ ticket: InboxProbeNativeCleanup,
+ repository: PrivateStorageRepository,
+ session: PrivateSession
+) {
+ const saved = nativeAdmissions.get(ticket);
+ return saved?.repository === repository &&
+ saved.session === session &&
+ saved.current()
+ ? saved
+ : undefined;
+}
+
+export async function captureInboxProbeCleanup(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ nonce: InboxProbeNonceAcknowledgement,
+ observations: unknown,
+ review: unknown
+): Promise<InboxProbeCleanup | undefined> {
+ const selection = captureInboxProbeCleanupSelection(
+ repository,
+ session,
+ policy,
+ nonce,
+ observations,
+ review
+ ),
+ selected =
+ selection &&
+ inboxProbeCleanupSelectionBinding(selection, repository, session, policy);
+ if (!selection || !selected) return undefined;
+ try {
+ const scope = inboxAccessConstructionBinding(
+ selected.access,
+ session,
+ policy
+ ),
+ ownership = privateSessionOwnership(session);
+ if (!scope || !ownership?.current()) return undefined;
+ const observed = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ selected.record.id
+ );
+ if (
+ !observed.ok ||
+ observed.value.wire !== selected.wire ||
+ !selected.current() ||
+ !scope.current() ||
+ !ownership.current()
+ )
+ return undefined;
+ const token = Object.freeze({}) as InboxProbeCleanup,
+ cancellation = new AbortController();
+ let stopped = false,
+ used = false;
+ const listeners = new Map<symbol, () => void>();
+ function forget() {
+ for (const [id, off] of listeners) {
+ off();
+ listeners.delete(id);
+ }
+ }
+ function stop() {
+ stopped = true;
+ cancellation.abort();
+ forget();
+ }
+ function current() {
+ return (
+ !stopped &&
+ !cancellation.signal.aborted &&
+ selected!.current() &&
+ scope!.current() &&
+ ownership!.current()
+ );
+ }
+ actions.set(token, {
+ stop,
+ async run(consent) {
+ if (consent !== 'reviewed_delete_local_inbox_probe' || used)
+ return { status: 'invalid' };
+ if (!current()) return { status: 'stopped' };
+ used = true;
+ let attempted = false;
+ try {
+ if (!navigator.locks?.request) return { status: 'unavailable' };
+ return await navigator.locks.request(
+ 'harvestcircle:owner:' + selected.record.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock): Promise<InboxProbeCleanupResult> => {
+ if (!lock) return { status: 'busy' };
+ if (!current()) return { status: 'stopped' };
+ if (
+ !inboxProbeCleanupReady(repository, session, policy, selection)
+ )
+ return { status: current() ? 'busy' : 'stopped' };
+ // No provider request is made while a foreign owner lock is held.
+ // The actual fresh key wait finishes before the short SDK/IDB job.
+ if (!(await recheckPrivateSession(session)))
+ return { status: current() ? 'busy' : 'stopped' };
+ if (!current()) return { status: 'stopped' };
+ const job =
+ await withIdlePrivateLocalStorage<InboxProbeCleanupResult>(
+ session,
+ async () => {
+ if (!current()) return { status: 'stopped' };
+ if (!selected.begin()) return { status: 'busy' };
+ const lease = acquireInboxProbeCleanupLease(
+ repository,
+ session,
+ policy,
+ selection
+ );
+ let ticket: InboxProbeNativeCleanup | undefined,
+ active = false,
+ taken = false;
+ try {
+ if (!lease)
+ return { status: current() ? 'busy' : 'stopped' };
+ const read = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ selected.record.id
+ );
+ if (!read.ok) {
+ if (current()) releaseInboxProbeCleanupLease(lease);
+ return { status: read.reason };
+ }
+ if (
+ read.value.wire !== selected.wire ||
+ privateRecordWire(
+ read.value.handle,
+ selected.record.owner,
+ selected.record.id
+ ) !== selected.wire
+ ) {
+ if (current()) releaseInboxProbeCleanupLease(lease);
+ return { status: 'conflict' };
+ }
+ if (!current() || !inboxProbeCleanupLeaseCurrent(lease))
+ return { status: 'stopped' };
+ active = true;
+ ticket = Object.freeze({}) as InboxProbeNativeCleanup;
+ nativeAdmissions.set(ticket, {
+ repository,
+ session,
+ selection,
+ owner: selected.record.owner,
+ id: selected.record.id,
+ wire: selected.wire,
+ signal: cancellation.signal,
+ current: () =>
+ active &&
+ current() &&
+ inboxProbeCleanupLeaseCurrent(lease),
+ take() {
+ if (taken) return false;
+ taken = true;
+ return true;
+ }
+ });
+ attempted = true;
+ const removed = await removePrivateInboxProbe(
+ repository,
+ session,
+ ticket
+ );
+ if (!removed.ok) {
+ if (removed.disposition === 'not_removed' && current())
+ releaseInboxProbeCleanupLease(lease);
+ return { status: removed.reason };
+ }
+ if (!current() || !inboxProbeCleanupLeaseCurrent(lease))
+ return { status: 'unknown_completion' };
+ if (!retireInboxProbeCleanupLease(lease, removed.value))
+ return { status: 'unknown_completion' };
+ // Old nonce/ACKs are now deliberately gone. The removal fact
+ // follows the separately captured real controller/session.
+ if (stopped || !scope.current() || !ownership.current())
+ return { status: 'unknown_completion' };
+ const acknowledgement = Object.freeze(
+ {}
+ ) as InboxProbeRemovalAcknowledgement;
+ removals.set(acknowledgement, {
+ repository,
+ session,
+ policy,
+ owner: selected.record.owner,
+ command: selected.record.id,
+ eventId: selected.record.self!.eventId,
+ preferenceId: selected.record.binding.preferenceId,
+ readTargets:
+ selected.record.binding.readTargets.slice(),
+ archiveTargets:
+ selected.record.binding.archiveTargets.slice(),
+ operatorWire: selected.record.binding.operatorWire,
+ current: () => scope.current() && ownership.current()
+ });
+ return { status: 'removed', removed: 1, acknowledgement };
+ } finally {
+ active = false;
+ if (ticket) nativeAdmissions.delete(ticket);
+ selected.finish();
+ }
+ }
+ );
+ return job.ok
+ ? job.value
+ : {
+ status: attempted
+ ? 'unknown_completion'
+ : current()
+ ? 'busy'
+ : 'stopped'
+ };
+ }
+ );
+ } catch {
+ return {
+ status: attempted
+ ? 'unknown_completion'
+ : current()
+ ? 'unavailable'
+ : 'stopped'
+ };
+ } finally {
+ forget();
+ }
+ }
+ });
+ const offSession = subscribePrivateSessionClose(session, stop);
+ listeners.set(Symbol(), offSession);
+ const offAccess = subscribeInboxAccessControllerClose(
+ selected.access,
+ stop
+ );
+ listeners.set(Symbol(), offAccess);
+ if (!current()) {
+ stop();
+ return undefined;
+ }
+ return token;
+ } catch {
+ return undefined;
+ }
+}
+
+export function deleteReviewedInboxProbe(
+ token: InboxProbeCleanup,
+ review: unknown
+): Promise<InboxProbeCleanupResult> {
+ return (
+ actions.get(token)?.run(review) ?? Promise.resolve({ status: 'invalid' })
+ );
+}
+export function stopInboxProbeCleanup(token: InboxProbeCleanup): void {
+ actions.get(token)?.stop();
+}
+export function inboxProbeRemovalAcknowledgementBinding(
+ acknowledgement: InboxProbeRemovalAcknowledgement,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy
+) {
+ const saved = removals.get(acknowledgement);
+ return saved?.repository === repository &&
+ saved.session === session &&
+ saved.policy === policy &&
+ saved.current()
+ ? {
+ owner: saved.owner,
+ command: saved.command,
+ eventId: saved.eventId,
+ preferenceId: saved.preferenceId,
+ readTargets: saved.readTargets.slice(),
+ archiveTargets: saved.archiveTargets.slice(),
+ operatorWire: saved.operatorWire,
+ current: saved.current
+ }
+ : undefined;
+}
diff --git a/web/src/lib/persistence/inbox-probes.ts b/web/src/lib/persistence/inbox-probes.ts
@@ -5,14 +5,20 @@ import {
type InboxProbeReadbackAttemptResult
} from '../nostr/private-pool.ts';
import { inboxProbePolicyMatches } from '../nostr/inbox-access.ts';
+import { reconcileInboxProbeArchiveAdmission } from '../nostr/private-publisher.ts';
import {
recoveredInboxProbeBinding,
inboxProbeNonceVerificationEvidence,
+ disposeInboxProbeNonceProof,
+ disposeRecoveredInboxProbe,
type RecoveredInboxProbe,
type InboxProbeNonceProof,
type RecoveredInboxProbeNonceProof
} from '../nostr/self-recovery-reader.ts';
-import type { InboxAccessController } from '../messaging/inbox-access-controller.ts';
+import {
+ inboxAccessConstructionBinding,
+ type InboxAccessController
+} from '../messaging/inbox-access-controller.ts';
import type { InboxOperatorQualification } from '../config/inbox-operators.ts';
import type { RelayPolicy } from '../config/relays.ts';
import {
@@ -25,6 +31,8 @@ import {
inboxProbeSnapshot,
inboxProbeRumorWire,
inboxProbeReservationHandle,
+ inboxProbeActionOwner,
+ stopInboxProbeIdentity,
type InboxProbeIdentity
} from '../nostr/inbox-access.ts';
import {
@@ -36,6 +44,8 @@ import {
privateStorageOwner,
commitPrivateRecord,
observePrivateRecord,
+ privateProbeRemovalEvidence,
+ type PrivateProbeRemovalProof,
type PrivateStorageRepository,
type PrivateStorageFailure
} from './private-storage.ts';
@@ -73,6 +83,8 @@ type Lineage = {
wire(): string;
begin(): boolean;
finish(): void;
+ active(): boolean;
+ retire(): void;
admit(record: PrivateAccessProbe, wire: string): void;
};
function createLineage(
@@ -84,7 +96,8 @@ function createLineage(
): Lineage {
let record = originalRecord,
wire = originalWire,
- pending = false;
+ pending = false,
+ retired = false;
return {
repository,
session,
@@ -92,13 +105,17 @@ function createLineage(
record: () => record,
wire: () => wire,
begin() {
- if (pending) return false;
+ if (pending || retired) return false;
pending = true;
return true;
},
finish() {
pending = false;
},
+ active: () => !retired,
+ retire() {
+ retired = true;
+ },
admit(next, nextWire) {
record = next;
wire = nextWire;
@@ -333,7 +350,7 @@ export async function commitInboxProbe(
session,
identity: original.identity,
lineage,
- current: () => !revoked && original.current(),
+ current: () => !revoked && lineage.active() && original.current(),
revoke: () => {
revoked = true;
}
@@ -593,7 +610,7 @@ export async function adoptRecoveredInboxProbe(
policy,
operator,
lineage,
- current: () => !revoked && current(),
+ current: () => !revoked && lineage.active() && current(),
revoke: () => {
revoked = true;
}
@@ -662,6 +679,31 @@ const appliedArchiveEvidence = new WeakMap<
InboxProbeArchiveAttemptResult | InboxProbeReadbackAttemptResult,
Lineage
>();
+// This query authenticates the exact result's native-applied Lineage. Labels,
+// cloned receipts and merely settled network attempts cannot release a charge.
+export function appliedInboxProbeArchiveAdmission(
+ result: InboxProbeArchiveAttemptResult
+) {
+ const effect = inboxProbeArchiveAttemptEvidence(result),
+ lineage = appliedArchiveEvidence.get(result);
+ if (!effect || !lineage || effect.repository !== lineage.repository)
+ return undefined;
+ const saved = acknowledgements.get(effect.acknowledgement);
+ if (!saved || saved.lineage !== lineage) return undefined;
+ const record = lineage.record(),
+ fact = record.receipts.find(
+ (receipt) => JSON.stringify(receipt) === effect.receiptWire
+ );
+ if (!fact || fact.role !== 'access_archive') return undefined;
+ return {
+ session: lineage.session,
+ command: record.id,
+ actionId: fact.actionId,
+ origin: fact.origin,
+ eventId: fact.eventId,
+ attempt: fact.attempt
+ };
+}
// Only actual SDK attempt observations can advance memory-only provenance.
// This bookkeeping can settle after owner loss, but cannot authorize traffic.
async function commitProbeAttempt(
@@ -716,8 +758,13 @@ async function commitProbeAttempt(
privateRecordWire(observed.value.handle, owner, id) !== lineage.wire()
)
return refuse('conflict');
- if (appliedArchiveEvidence.get(result) === lineage)
+ if (appliedArchiveEvidence.get(result) === lineage) {
+ if (role === 'access_archive')
+ reconcileInboxProbeArchiveAdmission(
+ result as InboxProbeArchiveAttemptResult
+ );
return refuse('existing');
+ }
if (
effect.predecessorWire !== lineage.wire() ||
lineage.record().revision === Number.MAX_SAFE_INTEGER
@@ -771,6 +818,10 @@ async function commitProbeAttempt(
// refresh live ACKs. A decoded receipt or metadata label never can.
lineage.admit(next, nextWire);
appliedArchiveEvidence.set(result, lineage);
+ if (role === 'access_archive')
+ reconcileInboxProbeArchiveAdmission(
+ result as InboxProbeArchiveAttemptResult
+ );
return refuse(
!committed.ok
? 'reconciled'
@@ -1174,3 +1225,232 @@ export function inboxProbeNonceAcknowledgementBinding(
current: () => currentNonceOperation(saved)
};
}
+
+declare const cleanupSelectionBrand: unique symbol;
+export type InboxProbeCleanupSelection = Readonly<{
+ [cleanupSelectionBrand]: true;
+}>;
+type CleanupSelection = Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ policy: RelayPolicy;
+ operation: NonceOperation;
+ access: InboxAccessController;
+ record: PrivateAccessProbe;
+ wire: string;
+ current(): boolean;
+}>;
+const cleanupSelections = new WeakMap<
+ InboxProbeCleanupSelection,
+ CleanupSelection
+>();
+
+// A positive label is not an effect. Only exact source results already applied
+// to this very Lineage can resolve a historical archive attempt or qualify a
+// required target. Array membership does not confer provenance.
+export function captureInboxProbeCleanupSelection(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ nonce: InboxProbeNonceAcknowledgement,
+ observations: unknown,
+ review: unknown
+): InboxProbeCleanupSelection | undefined {
+ if (
+ typeof window === 'undefined' ||
+ review !== 'reviewed_inbox_probe_cleanup_selection'
+ )
+ return undefined;
+ try {
+ const operation = nonceAcknowledgements.get(nonce);
+ if (
+ !operation ||
+ operation.repository !== repository ||
+ operation.session !== session ||
+ operation.policy !== policy ||
+ !operation.applied() ||
+ !currentNonceOperation(operation)
+ )
+ return undefined;
+ const saved = acknowledgements.get(operation.acknowledgement),
+ record = operation.lineage.record(),
+ wire = operation.lineage.wire();
+ if (!saved || !record.self || !Array.isArray(observations))
+ return undefined;
+ // Array length does not bound a custom iterator. Inspect only a fixed
+ // number of own data elements; descriptor traps may invalidate authority,
+ // so the exact Lineage/nonce/C7 fence below still follows every inspection.
+ function ownObservation(value: object, name: string): unknown {
+ const field = Object.getOwnPropertyDescriptor(value, name);
+ return field && 'value' in field ? field.value : undefined;
+ }
+ const length = ownObservation(observations, 'length');
+ if (
+ typeof length !== 'number' ||
+ !Number.isSafeInteger(length) ||
+ length < 1 ||
+ length > record.receipts.length
+ )
+ return undefined;
+ const positives = new Map<string, true>();
+ for (let index = 0; index < length; index++) {
+ const value = ownObservation(observations, String(index));
+ if (
+ !value ||
+ typeof value !== 'object' ||
+ appliedArchiveEvidence.get(value as InboxProbeArchiveAttemptResult) !==
+ operation.lineage
+ )
+ return undefined;
+ const effect =
+ inboxProbeArchiveAttemptEvidence(
+ value as InboxProbeArchiveAttemptResult
+ ) ??
+ inboxProbeReadbackAttemptEvidence(
+ value as InboxProbeReadbackAttemptResult
+ );
+ if (
+ !effect ||
+ effect.repository !== repository ||
+ acknowledgements.get(effect.acknowledgement)?.lineage !==
+ operation.lineage
+ )
+ return undefined;
+ positives.set(effect.receiptWire, true);
+ }
+ if (appliedArchiveEvidence.get(operation.observation) !== operation.lineage)
+ return undefined;
+ const nonceFact = operation.nextRecord.receipts.at(-1);
+ if (
+ !nonceFact ||
+ nonceFact.status !== 'nonce_verified' ||
+ !record.receipts.some(
+ (fact) => JSON.stringify(fact) === JSON.stringify(nonceFact)
+ )
+ )
+ return undefined;
+ const accepted = new Map<string, number>(),
+ unresolved = new Map<string, number>();
+ let read = false;
+ for (const [index, fact] of record.receipts.entries()) {
+ const key = JSON.stringify([fact.role, fact.origin, fact.eventId]);
+ if (fact.role === 'access_archive') {
+ if (fact.status === 'accepted') {
+ if (positives.has(JSON.stringify(fact))) accepted.set(key, index);
+ } else unresolved.set(key, index);
+ } else if (
+ fact.status === 'readback' &&
+ positives.has(JSON.stringify(fact)) &&
+ inboxProbeReadbackAttemptEvidence(operation.observation)
+ ?.receiptWire === JSON.stringify(fact)
+ ) {
+ read = true;
+ }
+ }
+ if (
+ !read ||
+ record.binding.archiveTargets.some(
+ (origin) =>
+ !accepted.has(
+ JSON.stringify(['access_archive', origin, record.self!.eventId])
+ )
+ )
+ )
+ return undefined;
+ for (const [key, index] of unresolved)
+ if ((accepted.get(key) ?? -1) <= index) return undefined;
+ const access =
+ saved.source === 'construction'
+ ? inboxProbeActionOwner(saved.identity, session, policy)
+ : saved.access,
+ scope = access && inboxAccessConstructionBinding(access, session, policy);
+ if (!access || !scope) return undefined;
+ function current() {
+ return (
+ operation!.lineage.active() &&
+ operation!.lineage.wire() === wire &&
+ currentNonceOperation(operation!) &&
+ scope!.current()
+ );
+ }
+ if (!current()) return undefined;
+ const token = Object.freeze({}) as InboxProbeCleanupSelection;
+ cleanupSelections.set(token, {
+ repository,
+ session,
+ policy,
+ operation,
+ access,
+ record: JSON.parse(JSON.stringify(record)) as PrivateAccessProbe,
+ wire,
+ current
+ });
+ return token;
+ } catch {
+ return undefined;
+ }
+}
+
+export function inboxProbeCleanupSelectionBinding(
+ token: InboxProbeCleanupSelection,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy
+) {
+ const saved = cleanupSelections.get(token);
+ if (
+ !saved ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ saved.policy !== policy ||
+ !saved.current()
+ )
+ return undefined;
+ return {
+ identity: saved.operation.lineage.identity,
+ source: acknowledgements.get(saved.operation.acknowledgement)!.source,
+ access: saved.access,
+ nonce: saved.operation.acknowledgementToken()!,
+ record: JSON.parse(JSON.stringify(saved.record)) as PrivateAccessProbe,
+ wire: saved.wire,
+ current: saved.current,
+ begin: () => saved.current() && saved.operation.lineage.begin(),
+ finish: () => saved.operation.lineage.finish()
+ };
+}
+
+// Native proof, not an absent ID or decoded row, permits disposal of this exact
+// genuine source lineage. No controller is closed and no readiness is granted.
+export function retireInboxProbeCleanupSelection(
+ token: InboxProbeCleanupSelection,
+ proof: PrivateProbeRemovalProof
+): boolean {
+ const saved = cleanupSelections.get(token);
+ if (!saved || !saved.current()) return false;
+ const removed = privateProbeRemovalEvidence(
+ proof,
+ saved.repository,
+ saved.session
+ );
+ if (!removed || removed.selection !== token || removed.wire !== saved.wire)
+ return false;
+ disposeInboxProbeNonceProof(
+ saved.operation.proof,
+ saved.repository,
+ saved.session,
+ saved.policy
+ );
+ const origin = acknowledgements.get(saved.operation.acknowledgement)!;
+ if (origin.source === 'construction') stopInboxProbeIdentity(origin.identity);
+ else
+ disposeRecoveredInboxProbe(
+ origin.identity,
+ saved.repository,
+ saved.session,
+ saved.policy
+ );
+ saved.operation.lineage.retire();
+ origin.revoke();
+ cleanupSelections.delete(token);
+ return true;
+}
diff --git a/web/src/lib/persistence/private-storage.ts b/web/src/lib/persistence/private-storage.ts
@@ -8,6 +8,11 @@ import { exactLocalFields } from '../contracts/local-records.ts';
import { LOCAL_PERSISTENCE_BUDGETS, RELAY_BUDGETS } from '../config/budgets.ts';
import { privateRecordSettlement } from './local-inventory.ts';
import {
+ inboxProbeCleanupAdmission,
+ type InboxProbeNativeCleanup
+} from './inbox-probe-cleanup.ts';
+import type { InboxProbeCleanupSelection } from './inbox-probes.ts';
+import {
browserDatabaseState,
browserDatabaseTransaction,
type BrowserDatabase
@@ -44,6 +49,34 @@ type Row = Readonly<{
bytes: number;
}>;
const repositories = new WeakMap<PrivateStorageRepository, Scope>();
+declare const probeRemovalBrand: unique symbol;
+export type PrivateProbeRemovalProof = Readonly<{ [probeRemovalBrand]: true }>;
+const probeRemovals = new WeakMap<
+ PrivateProbeRemovalProof,
+ Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ selection: InboxProbeCleanupSelection;
+ owner: string;
+ id: string;
+ wire: string;
+ }>
+>();
+export function privateProbeRemovalEvidence(
+ proof: PrivateProbeRemovalProof,
+ repository: PrivateStorageRepository,
+ session: PrivateSession
+) {
+ const saved = probeRemovals.get(proof);
+ return saved?.repository === repository && saved.session === session
+ ? {
+ selection: saved.selection,
+ owner: saved.owner,
+ id: saved.id,
+ wire: saved.wire
+ }
+ : undefined;
+}
type ValidatedWire = Readonly<{
wire: string;
handle: PrivateRecordHandle;
@@ -822,3 +855,108 @@ export function removePrivateSettledSendRecords(
}
);
}
+
+// The only admission is a genuine ticket minted inside the cleanup owner's
+// actual WebLock/idle SDK job. Ordinary settlement still protects all probes.
+// No asynchronous/provider work occurs inside the native readwrite transaction.
+export async function removePrivateInboxProbe(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ ticket: InboxProbeNativeCleanup
+): Promise<
+ | Readonly<{ ok: true; value: PrivateProbeRemovalProof }>
+ | Readonly<{
+ ok: false;
+ reason: PrivateStorageFailure;
+ disposition: 'not_removed' | 'may_have_removed';
+ }>
+> {
+ const denied = (reason: PrivateStorageFailure, uncertain = false) => ({
+ ok: false as const,
+ reason,
+ disposition: uncertain
+ ? ('may_have_removed' as const)
+ : ('not_removed' as const)
+ });
+ const admitted = inboxProbeCleanupAdmission(ticket, repository, session);
+ if (!admitted) return denied('invalid_scope');
+ const scope = scopeOf(repository),
+ ownership = privateSessionOwnership(session);
+ if (
+ !scope ||
+ !ownership?.current() ||
+ scope.owner !== ownership.owner ||
+ admitted.owner !== scope.owner ||
+ !admitted.current() ||
+ !admitted.take()
+ )
+ return denied('invalid_scope');
+ const committed = await transaction<Readonly<{ removed: number }>>(
+ scope,
+ 'private_sends',
+ 'readwrite',
+ (rows, tx, refuse) => {
+ if (
+ !admitted.current() ||
+ !ownership.current() ||
+ admitted.signal.aborted
+ ) {
+ refuse('invalid_scope');
+ return;
+ }
+ const selected = rows.find((row) => row.record.id === admitted.id);
+ if (
+ !selected ||
+ selected.record.family !== 'private_access_probe' ||
+ selected.wire !== admitted.wire
+ ) {
+ refuse('conflict');
+ return;
+ }
+ const store = tx.objectStore('private_sends'),
+ remove = store.delete.bind(store);
+ if (
+ !admitted.current() ||
+ !ownership.current() ||
+ admitted.signal.aborted
+ ) {
+ refuse('invalid_scope');
+ return;
+ }
+ remove([scope.owner, admitted.id]);
+ return { ok: true, value: { removed: 1 } };
+ },
+ (refuse) => {
+ const abort = () => refuse('invalid_scope'),
+ off = subscribePrivateSessionClose(session, abort);
+ admitted.signal.addEventListener('abort', abort, { once: true });
+ if (admitted.signal.aborted) abort();
+ return () => {
+ off();
+ admitted.signal.removeEventListener('abort', abort);
+ };
+ }
+ );
+ if (!committed.ok)
+ return denied(committed.reason, committed.reason === 'unknown_completion');
+ // Actual complete is necessary; separate complete-owner readonly absence is
+ // also necessary. Preexisting/manual absence can never reach proof issuance.
+ const readback = await listPrivateSendRecords(repository);
+ if (!readback.ok) return denied('unknown_completion', true);
+ if (
+ readback.value.some(
+ (handle) => privateRecordIdentity(handle)?.id === admitted.id
+ )
+ )
+ return denied('conflict', true);
+ const proof = Object.freeze({}) as PrivateProbeRemovalProof;
+ probeRemovals.set(proof, {
+ repository,
+ session,
+ selection: admitted.selection,
+ owner: admitted.owner,
+ id: admitted.id,
+ wire: admitted.wire
+ });
+ return { ok: true, value: proof };
+}
diff --git a/web/tests/e2e/harness/inbox-probe-cleanup.ts b/web/tests/e2e/harness/inbox-probe-cleanup.ts
@@ -0,0 +1,614 @@
+import { makeRetryFixture } from './inbox-probe-retry.ts';
+import {
+ captureInboxProbeNonceReader,
+ captureRecoveredInboxProbeNonceReader,
+ readInboxProbeNonce,
+ readRecoveredInboxProbeNonce,
+ type InboxProbeNonceProof,
+ type RecoveredInboxProbeNonceProof
+} from '../../../src/lib/nostr/self-recovery-reader.ts';
+import {
+ commitInboxProbeNonceVerification,
+ type InboxProbeNonceAcknowledgement
+} from '../../../src/lib/persistence/inbox-probes.ts';
+import {
+ captureInboxProbeCleanup,
+ deleteReviewedInboxProbe,
+ stopInboxProbeCleanup,
+ inboxProbeRemovalAcknowledgementBinding,
+ type InboxProbeCleanup,
+ type InboxProbeRemovalAcknowledgement
+} from '../../../src/lib/persistence/inbox-probe-cleanup.ts';
+import { captureInboxProbePublicationAction } from '../../../src/lib/nostr/private-publisher.ts';
+import type {
+ InboxProbeArchiveAttemptResult,
+ InboxProbeReadbackAttemptResult
+} from '../../../src/lib/nostr/private-pool.ts';
+import type { PrivateAccessProbe } from '../../../src/lib/persistence/private-records.ts';
+import { generateSecretKey, finalizeEvent } from 'applesauce-core/helpers';
+import { nip44 } from 'applesauce-core/helpers/encryption';
+import {
+ decodePrivateRecord,
+ privateRecordSnapshot
+} from '../../../src/lib/persistence/private-records.ts';
+import { privateRecordSettlement } from '../../../src/lib/persistence/local-inventory.ts';
+import {
+ openBrowserDatabase,
+ browserDatabaseTransaction,
+ closeBrowserDatabase
+} from '../../../src/lib/persistence/database.ts';
+import {
+ captureInboxProbeSealOperation,
+ buildInboxProbeSeal
+} from '../../../src/lib/nostr/seal-builder.ts';
+import { buildInboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts';
+import { commitInboxProbe } from '../../../src/lib/persistence/inbox-probes.ts';
+export * from './inbox-probe-nonce-facts.ts';
+export * from '../../../src/lib/persistence/inbox-probe-cleanup.ts';
+export {
+ removePrivateInboxProbe,
+ privateProbeRemovalEvidence
+} from '../../../src/lib/persistence/private-storage.ts';
+export {
+ acquireInboxProbeCleanupLease,
+ releaseInboxProbeCleanupLease,
+ retireInboxProbeCleanupLease,
+ inboxProbePublicationSnapshot,
+ inboxProbeReadbackSnapshot
+} from '../../../src/lib/nostr/private-publisher.ts';
+export {
+ publishInboxProbeArchiveAttempt,
+ readInboxProbeAttempt
+} from '../../../src/lib/nostr/private-pool.ts';
+export { inboxProbeRumorWire } from '../../../src/lib/nostr/inbox-access.ts';
+export { inboxAccessConstructionBinding } from '../../../src/lib/messaging/inbox-access-controller.ts';
+export {
+ getPrivatePool,
+ closePrivatePool,
+ subscribePrivatePage,
+ subscribePrivateLive
+} from '../../../src/lib/nostr/private-pool.ts';
+export {
+ beginInboxAuthentication,
+ closeInboxAuthentication
+} from '../../../src/lib/nostr/inbox-auth.ts';
+
+export async function makeCleanupFixture() {
+ const base = await makeRetryFixture();
+ let recovered = false,
+ nonce: InboxProbeNonceAcknowledgement | undefined,
+ proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof | undefined,
+ cleanup: InboxProbeCleanup | undefined,
+ removal: InboxProbeRemovalAcknowledgement | undefined,
+ observation: InboxProbeReadbackAttemptResult | undefined;
+ const observations: (
+ InboxProbeArchiveAttemptResult | InboxProbeReadbackAttemptResult
+ )[] = [],
+ restores = new Set<() => void>();
+ function retain(off: () => void) {
+ restores.add(off);
+ return () => {
+ off();
+ restores.delete(off);
+ };
+ }
+ const row = async () => {
+ const found = (await base.host.stored()).find(
+ (x) => x.id === base.command()
+ );
+ if (!found) throw Error('actual selected row missing');
+ return JSON.parse(found.wire) as PrivateAccessProbe;
+ };
+ return {
+ ...base,
+ observations: () => observations.slice(),
+ nonce: () => nonce,
+ nonceProof: () => proof,
+ cleanup: () => cleanup,
+ removal: () => removal,
+ observation: () => observation,
+ async retryOriginalPreparation() {
+ const identity = base.originalIdentity(),
+ a = base.actors();
+ if (!identity) throw Error('actual original identity');
+ const operation = captureInboxProbeSealOperation(
+ a.session,
+ identity,
+ 'reviewed_inbox_probe_seal'
+ );
+ if (!operation) return { status: 'capture_refused' };
+ const sealed = await buildInboxProbeSeal(operation);
+ if (!('seal' in sealed)) return sealed;
+ const wrapped = buildInboxProbeGiftwrap(
+ sealed.seal,
+ 'reviewed_inbox_probe_wrap'
+ );
+ return wrapped
+ ? commitInboxProbe(
+ base.repository,
+ a.session,
+ wrapped,
+ 'reviewed_inbox_probe_commit'
+ )
+ : { status: 'wrap_refused' };
+ },
+ async seedPreservedRecords() {
+ const selected = await row(),
+ owner = selected.owner,
+ peer =
+ 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5',
+ secret = generateSecretKey(),
+ conversation = nip44.v2.utils.getConversationKey(secret, peer);
+ let peerArtifact: { eventId: string; wire: string };
+ try {
+ const outer = finalizeEvent(
+ {
+ kind: 1059,
+ created_at: selected.createdAt,
+ tags: [['p', peer]],
+ content: nip44.v2.encrypt(
+ 'storage-only preservation fixture',
+ conversation
+ )
+ },
+ secret
+ );
+ peerArtifact = { eventId: outer.id, wire: JSON.stringify(outer) };
+ } finally {
+ conversation.fill(0);
+ secret.fill(0);
+ }
+ 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',
+ head: { id: 'c'.repeat(64), createdAt: 100 }
+ }
+ ]
+ });
+ // Strict native metadata fixtures, not sender capabilities or exchange Q.
+ const ordinary = {
+ schema: 1,
+ family: 'private_send_operation',
+ owner,
+ id: crypto.randomUUID(),
+ revision: 1,
+ peer,
+ rumorHash: selected.rumorHash,
+ createdAt: selected.createdAt,
+ self: selected.self!,
+ peerArtifact,
+ deliveryPlan: {
+ state: 'prepared',
+ routes: {
+ peer: route('peer', peer, '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: selected.self!.eventId,
+ status: 'accepted',
+ observedAtMilliseconds: 1700000000000,
+ readbackWire: null
+ }
+ ]
+ },
+ protectedProbe = { ...selected, id: crypto.randomUUID() },
+ received = {
+ schema: 1,
+ family: 'received_envelope',
+ owner,
+ id: selected.self!.eventId,
+ revision: 0,
+ outer: selected.self!.wire,
+ observedAtMilliseconds: 1700000000000,
+ sources: ['wss://inbox.example.org'],
+ read: null
+ };
+ const values = [ordinary, protectedProbe, received].map((value) => {
+ const wire = JSON.stringify(value),
+ decoded = decodePrivateRecord(wire, owner, value.id);
+ if (!decoded.ok) throw Error('strict preservation fixture rejected');
+ const record = privateRecordSnapshot(decoded.value, owner, value.id)!;
+ if (value === ordinary && privateRecordSettlement(record) !== 'settled')
+ throw Error('actual settled metadata required');
+ return { owner, id: value.id, wire };
+ });
+ const opened = await openBrowserDatabase();
+ if (opened.state !== 'ready') throw Error('actual preservation database');
+ const database = opened.owner;
+ try {
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends', 'received_envelopes'],
+ 'readwrite'
+ );
+ values.forEach((value, index) =>
+ tx
+ .objectStore(index === 2 ? 'received_envelopes' : 'private_sends')
+ .put(value)
+ );
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('preservation native seed abort'))
+ );
+ });
+ } finally {
+ closeBrowserDatabase(database);
+ }
+ return values;
+ },
+ async receivedRows() {
+ const opened = await openBrowserDatabase();
+ if (opened.state !== 'ready') throw Error('actual received database');
+ try {
+ const tx = browserDatabaseTransaction(
+ opened.owner,
+ ['received_envelopes'],
+ 'readonly'
+ ),
+ request = tx.objectStore('received_envelopes').getAll();
+ return await new Promise<{ owner: string; id: string; wire: string }[]>(
+ (resolve, reject) => {
+ tx.addEventListener('complete', () => resolve(request.result));
+ tx.addEventListener('abort', () =>
+ reject(Error('received native observation abort'))
+ );
+ }
+ );
+ } finally {
+ closeBrowserDatabase(opened.owner);
+ }
+ },
+ async qualify(
+ useRecovered = false,
+ options: { fresh?: boolean; skip?: string[]; readOrigin?: string } = {}
+ ) {
+ recovered = useRecovered;
+ observations.length = 0;
+ nonce = undefined;
+ proof = undefined;
+ cleanup = undefined;
+ removal = undefined;
+ if (recovered) {
+ if (options.fresh !== false) await base.freshSession();
+ if (
+ (await base.recover())?.status !== 'recovered' ||
+ (await base.adopt()).status !== 'adopted' ||
+ !(await base.captureAction())
+ )
+ throw Error('actual recovered cleanup setup');
+ }
+ const selected = await row();
+ for (const origin of selected.binding.archiveTargets) {
+ if (options.skip?.includes(origin)) continue;
+ const result = await (recovered
+ ? base.publish(origin)
+ : base.originalPublish(origin));
+ if (
+ !result ||
+ result.status !== 'accepted' ||
+ (await base.append(result)).status !== 'saved'
+ )
+ throw Error('actual named archive source and native append');
+ observations.push(result);
+ }
+ observation = await (recovered
+ ? base.read(options.readOrigin)
+ : base.originalRead(options.readOrigin));
+ if (
+ !observation ||
+ observation.status !== 'readback' ||
+ (await base.appendRead(observation)).status !== 'saved'
+ )
+ throw Error('actual source readback and native append');
+ observations.push(observation);
+ const a = base.actors(),
+ reader = (
+ recovered
+ ? captureRecoveredInboxProbeNonceReader
+ : captureInboxProbeNonceReader
+ )(
+ base.repository,
+ a.identity,
+ a.session,
+ base.host.policy,
+ observation,
+ 'reviewed_inbox_probe_nonce_decryption'
+ );
+ if (!reader) throw Error('actual nonce reader');
+ const verified = recovered
+ ? await readRecoveredInboxProbeNonce(
+ reader as Parameters<typeof readRecoveredInboxProbeNonce>[0]
+ )
+ : await readInboxProbeNonce(
+ reader as Parameters<typeof readInboxProbeNonce>[0]
+ );
+ if (!('proof' in verified))
+ throw Error('actual nonce verification ' + verified.status);
+ proof = verified.proof;
+ const saved = await commitInboxProbeNonceVerification(
+ base.repository,
+ a.session,
+ base.host.policy,
+ proof
+ );
+ if (!saved.acknowledgement)
+ throw Error('actual nonce native fact ' + saved.status);
+ nonce = saved.acknowledgement;
+ return saved;
+ },
+ async select(
+ review: unknown = 'reviewed_inbox_probe_cleanup_selection',
+ input: unknown = observations
+ ) {
+ cleanup = await captureInboxProbeCleanup(
+ base.repository,
+ base.actors().session,
+ base.host.policy,
+ nonce!,
+ input,
+ review
+ );
+ return cleanup;
+ },
+ async remove(
+ review: unknown = 'reviewed_delete_local_inbox_probe',
+ selected = cleanup
+ ) {
+ const result = await deleteReviewedInboxProbe(selected!, review);
+ if (result.acknowledgement) removal = result.acknowledgement;
+ return result;
+ },
+ stopCleanup() {
+ if (cleanup) stopInboxProbeCleanup(cleanup);
+ },
+ removalBinding: () =>
+ removal &&
+ inboxProbeRemovalAcknowledgementBinding(
+ removal,
+ base.repository,
+ base.actors().session,
+ base.host.policy
+ ),
+ async withHeld<T>(kind: 'lock' | 'SDK', work: () => Promise<T>) {
+ let release = () => {},
+ enter = () => {};
+ const entered = new Promise<void>((resolve) => {
+ enter = resolve;
+ }),
+ wait = new Promise<void>((resolve) => {
+ release = resolve;
+ }),
+ holder = async () => {
+ enter();
+ await wait;
+ },
+ held =
+ kind === 'lock'
+ ? navigator.locks.request(
+ 'harvestcircle:owner:' + base.host.owner,
+ holder
+ )
+ : (
+ await import('../../../src/lib/runtime/private-session.ts')
+ ).withIdlePrivateLocalStorage(base.actors().session, holder);
+ await entered;
+ try {
+ return await work();
+ } finally {
+ release();
+ await held;
+ }
+ },
+ async capacity() {
+ const session = base.actors().session,
+ originals = new Map<string, string>();
+ for (let index = 0; index < 100; index++) {
+ if (index) {
+ if (
+ !(await base.replaceController()) ||
+ (await base.prepareOriginal()).status !== 'prepared'
+ )
+ throw Error('actual protected capacity preparation ' + index);
+ }
+ if (
+ !captureInboxProbePublicationAction(
+ base.repository,
+ session,
+ base.host.policy,
+ base.originalAck()!,
+ 'reviewed_inbox_probe_network'
+ )
+ )
+ throw Error('actual protected command slot ' + index);
+ const selected = (await base.host.stored()).find(
+ (x) => x.id === base.command()
+ )!;
+ originals.set(selected.id, selected.wire);
+ }
+ const retained = await base.host.stored();
+ if (retained.length !== 100 || base.actors().session !== session)
+ throw Error('actual same-session full capacity');
+ await base.replaceController();
+ const denied = await base.prepareOriginal();
+ return { session, originals, denied };
+ },
+ // Actual native request/complete/abort instrumentation; no success labels.
+ nativeFault(
+ mode:
+ | 'abort'
+ | 'uncertain'
+ | 'complete_loss'
+ | 'read_before'
+ | 'read_after'
+ | 'read_loss'
+ | 'delete_loss'
+ | 'wire_race'
+ | 'initial_read_abort'
+ | 'native_pre_delete_loss',
+ callback = () => {}
+ ) {
+ const remove = Object.getOwnPropertyDescriptor(
+ IDBObjectStore.prototype,
+ 'delete'
+ )!.value as IDBObjectStore['delete'],
+ abort = Object.getOwnPropertyDescriptor(
+ IDBTransaction.prototype,
+ 'abort'
+ )!.value as IDBTransaction['abort'],
+ cursor = Object.getOwnPropertyDescriptor(
+ IDBIndex.prototype,
+ 'openCursor'
+ )!.value as IDBIndex['openCursor'],
+ transaction = Object.getOwnPropertyDescriptor(
+ IDBDatabase.prototype,
+ 'transaction'
+ )!.value as IDBDatabase['transaction'];
+ let selected: IDBTransaction | undefined,
+ readonly = 0,
+ deletes = 0,
+ completes = 0,
+ aborts = 0,
+ refused = 0,
+ races = 0;
+ IDBDatabase.prototype.transaction = function (
+ ...args: Parameters<IDBDatabase['transaction']>
+ ) {
+ if (
+ mode === 'wire_race' &&
+ !races &&
+ args[1] === 'readwrite' &&
+ Array.from(args[0] as string[]).includes('private_sends')
+ ) {
+ races++;
+ const other = transaction.call(this, ['private_sends'], 'readwrite'),
+ store = other.objectStore('private_sends'),
+ get = store.get([base.host.owner, base.command()!]);
+ get.addEventListener('success', () => {
+ const item = get.result as {
+ owner: string;
+ id: string;
+ wire: string;
+ },
+ record = JSON.parse(item.wire) as { revision: number };
+ record.revision++;
+ store.put({ ...item, wire: JSON.stringify(record) });
+ });
+ }
+ return transaction.apply(this, args);
+ };
+ IDBIndex.prototype.openCursor = function (
+ ...args: Parameters<IDBIndex['openCursor']>
+ ) {
+ const request = cursor.apply(this, args),
+ tx = this.objectStore.transaction;
+ if (
+ this.objectStore.name === 'private_sends' &&
+ tx.mode === 'readonly'
+ ) {
+ readonly++;
+ const hit = readonly;
+ if (mode === 'read_before' && hit === 2) tx.abort();
+ if (mode === 'read_after' && hit === 2)
+ request.addEventListener('success', () => {
+ if (!request.result) tx.abort();
+ });
+ if (mode === 'read_loss' && hit === 1)
+ request.addEventListener('success', () => {
+ if (!request.result) callback();
+ });
+ if (mode === 'initial_read_abort' && hit === 1) tx.abort();
+ }
+ if (
+ this.objectStore.name === 'private_sends' &&
+ tx.mode === 'readwrite' &&
+ mode === 'native_pre_delete_loss'
+ )
+ request.addEventListener('success', () => {
+ if (!request.result) callback();
+ });
+ return request;
+ };
+ IDBTransaction.prototype.abort = function (
+ ...args: Parameters<IDBTransaction['abort']>
+ ) {
+ if (this === selected && mode === 'uncertain') {
+ refused++;
+ throw Error('controlled actual abort refusal');
+ }
+ return abort.apply(this, args);
+ };
+ IDBObjectStore.prototype.delete = function (
+ ...args: Parameters<IDBObjectStore['delete']>
+ ) {
+ const request = remove.apply(this, args);
+ if (this.name === 'private_sends' && !selected) {
+ deletes++;
+ selected = this.transaction;
+ selected.addEventListener('complete', () => {
+ completes++;
+ if (mode === 'complete_loss') callback();
+ });
+ selected.addEventListener('abort', () => {
+ aborts++;
+ });
+ request.addEventListener('success', () => {
+ if (mode === 'abort') selected!.abort();
+ if (mode === 'delete_loss') callback();
+ });
+ if (mode === 'uncertain')
+ throw Error('controlled throw after actual delete admission');
+ }
+ return request;
+ };
+ return {
+ counts: () => ({
+ readonly,
+ deletes,
+ completes,
+ aborts,
+ refused,
+ races
+ }),
+ restore: retain(() => {
+ IDBObjectStore.prototype.delete = remove;
+ IDBTransaction.prototype.abort = abort;
+ IDBIndex.prototype.openCursor = cursor;
+ IDBDatabase.prototype.transaction = transaction;
+ })
+ };
+ },
+ close() {
+ for (const off of restores) off();
+ restores.clear();
+ if (cleanup) stopInboxProbeCleanup(cleanup);
+ base.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/inbox-probe-cleanup.spec.ts b/web/tests/e2e/inbox-probe-cleanup.spec.ts
@@ -0,0 +1,1859 @@
+import { test, expect, type Page } from '@playwright/test';
+import { build } from 'vite';
+import { once } from 'node:events';
+import { fileURLToPath } from 'node:url';
+import { WebSocketServer, type WebSocket } from 'ws';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Fixture from './harness/inbox-probe-cleanup.ts';
+import type { PrivateAccessProbe } from '../../src/lib/persistence/private-records.ts';
+declare global {
+ interface Window {
+ pc: typeof Fixture;
+ pcFixture: Awaited<ReturnType<typeof Fixture.makeCleanupFixture>>;
+ pcPending?: Promise<unknown>;
+ pcRestore?: () => void;
+ pcFinishAttempt?: () => Promise<string>;
+ pcRelease?: () => void;
+ pcCloseMode?: 'hold' | 'fail';
+ pcHeldClose?: (() => void)[];
+ pcCloseCalls?: number;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string,
+ head = '';
+let ackMode: 'accept' | 'refuse' | 'hold' = 'accept';
+let holdRead = false,
+ challenge = false;
+const origins = [
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ],
+ physical = new Set<WebSocket>(),
+ physicalOrigins = new WeakMap<WebSocket, string>(),
+ archived = new Map<string, unknown>(),
+ frames: { origin: string; frame: unknown[] }[] = [];
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ sockets = new WebSocketServer({
+ host: '127.0.0.1',
+ port: 0,
+ maxPayload: 65536
+ });
+ await once(sockets, 'listening');
+ const address = sockets.address();
+ if (!address || typeof address === 'string')
+ throw Error('actual loopback endpoint');
+ endpoint = 'ws://127.0.0.1:' + address.port;
+ sockets.on('connection', (socket, request) => {
+ physical.add(socket);
+ socket.on('close', () => physical.delete(socket));
+ const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
+ 'origin'
+ )!;
+ physicalOrigins.set(socket, origin);
+ if (challenge && origin !== 'wss://discovery.example.org')
+ socket.send(JSON.stringify(['AUTH', 'c3b-source-challenge']));
+ socket.on('message', (bytes) => {
+ const raw = Buffer.isBuffer(bytes)
+ ? bytes
+ : Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.from(bytes),
+ frame = JSON.parse(raw.toString()) as unknown[];
+ if (frames.length >= 1000) throw Error('controlled fixture frame bound');
+ frames.push({ origin, frame });
+ if (frame[0] === 'REQ') {
+ const filter = frame[2] as { kinds?: number[]; ids?: string[] };
+ if (filter.kinds?.includes(10050) && head)
+ socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
+ if (filter.kinds?.includes(1059)) {
+ if (holdRead) return;
+ const event = archived.get(JSON.stringify([origin, filter.ids?.[0]]));
+ if (event) socket.send(JSON.stringify(['EVENT', frame[1], event]));
+ }
+ socket.send(JSON.stringify(['EOSE', frame[1]]));
+ } else if (frame[0] === 'EVENT') {
+ const event = frame[1] as { id: string };
+ if (ackMode === 'accept')
+ archived.set(JSON.stringify([origin, event.id]), event);
+ if (ackMode !== 'hold')
+ socket.send(
+ JSON.stringify([
+ 'OK',
+ event.id,
+ ackMode === 'accept',
+ 'controlled refusal'
+ ])
+ );
+ }
+ });
+ });
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/inbox-probe-cleanup.ts', import.meta.url)
+ ),
+ name: 'pc',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('actual compiled nonce-facts harness');
+ const chunks = output.output.filter((x) => x.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => {
+ for (const socket of sockets.clients) socket.terminate();
+ await new Promise<void>((resolve) => sockets.close(() => resolve()));
+ await server.close();
+});
+test.beforeEach(async ({ page }) => {
+ await expect.poll(() => physical.size).toBe(0);
+ ackMode = 'accept';
+ holdRead = false;
+ challenge = false;
+ archived.clear();
+ frames.length = 0;
+ head = '';
+ await page.addInitScript(
+ ({ endpoint, origins }) => {
+ const Native = window.WebSocket;
+ window.WebSocket = class extends Native {
+ constructor(url: string | URL, protocols?: string | string[]) {
+ const origin = new URL(String(url)).origin;
+ if (!['wss://discovery.example.org', ...origins].includes(origin))
+ throw Error('unapproved fixture origin');
+ super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
+ }
+ override close(code?: number, reason?: string) {
+ window.pcCloseCalls = (window.pcCloseCalls ?? 0) + 1;
+ if (window.pcCloseMode === 'fail')
+ throw Error('actual controlled physical close failure');
+ if (window.pcCloseMode === 'hold')
+ (window.pcHeldClose ??= []).push(() => super.close(code, reason));
+ else super.close(code, reason);
+ }
+ };
+ },
+ { endpoint, origins }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ head = await page.evaluate(async (origins) => {
+ window.pcFixture = await window.pc.makeCleanupFixture();
+ return window.pcFixture.host.preferenceWire(origins);
+ }, origins);
+ await page.evaluate(async () => {
+ const f = window.pcFixture;
+ await f.open();
+ if ((await f.prepareOriginal()).status !== 'prepared')
+ throw Error('actual original S3/R1');
+ });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(async () => {
+ window.pcRestore?.();
+ window.pcCloseMode = undefined;
+ for (const release of window.pcHeldClose ?? []) release();
+ window.pcRelease?.();
+ window.pcFixture.host.mode('normal');
+ window.pcFixture.host.settle();
+ window.pcFixture.close();
+ await window.pcPending;
+ });
+});
+
+async function qualify(page: Page, recovered = false, skip: string[] = []) {
+ expect(
+ await page.evaluate(
+ async ({ recovered, skip }) =>
+ (await window.pcFixture.qualify(recovered, { skip })).status,
+ { recovered, skip }
+ )
+ ).toBe('saved');
+}
+async function select(page: Page) {
+ expect(
+ await page.evaluate(async () => !!(await window.pcFixture.select()))
+ ).toBe(true);
+}
+const traffic = () =>
+ frames.filter(
+ (x) =>
+ x.origin !== 'wss://discovery.example.org' &&
+ ['EVENT', 'REQ', 'AUTH'].includes(String(x.frame[0]))
+ );
+
+for (const recovered of [false, true]) {
+ test(`${recovered ? 'recovered' : 'current-original'} reviewed genuine cleanup has native completion, fresh absence, exact disposal and independent removal provenance`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ const before = traffic().length;
+ const result = await page.evaluate(async (recovered) => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ record = (await f.host.stored())[0],
+ nonce = f.nonce()!,
+ proof = f.nonceProof()!,
+ original = f.originalIdentity(),
+ oldAck = recovered ? f.acknowledgement()! : f.originalAck()!,
+ controller = window.pc.inboxAccessConstructionBinding(
+ a.access,
+ a.session,
+ f.host.policy
+ ),
+ counts = f.host.counts();
+ const selected = await f.select();
+ const capturedCounts = f.host.counts(),
+ capturedRows = await f.host.stored();
+ const hook = f.nativeFault('wire_race');
+ hook.restore();
+ const removed = await f.remove(),
+ after = await f.host.stored(),
+ binding = f.removalBinding(),
+ nonceBinding = window.pc.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ a.session,
+ nonce,
+ f.host.policy
+ ),
+ proofBinding = window.pc.inboxProbeNonceVerificationEvidence(
+ proof,
+ f.repository,
+ a.session,
+ f.host.policy
+ ),
+ oldBinding = recovered
+ ? window.pc.recoveredInboxProbePublicationBinding(
+ f.repository,
+ a.session,
+ oldAck,
+ f.host.policy
+ )
+ : window.pc.inboxProbePublicationBinding(
+ f.repository,
+ a.session,
+ oldAck,
+ f.host.policy
+ );
+ return {
+ selected: !!selected,
+ counts,
+ capturedCounts,
+ capturedSame:
+ capturedRows.length === 1 && capturedRows[0].wire === record.wire,
+ status: removed.status,
+ removed: removed.removed,
+ after: after.length,
+ nonceCurrent: !!nonceBinding,
+ proofCurrent: !!proofBinding,
+ oldAckCurrent: !!oldBinding,
+ originalNonce: original
+ ? !!window.pc.inboxProbeRumorWire(original, a.session)
+ : false,
+ controller: controller?.current(),
+ removal: binding?.current(),
+ command: binding?.command,
+ expected: record.id,
+ keys: removed.acknowledgement && Object.keys(removed.acknowledgement),
+ copy: !!window.pc.inboxProbeRemovalAcknowledgementBinding(
+ { ...removed.acknowledgement! },
+ f.repository,
+ a.session,
+ f.host.policy
+ ),
+ again: (await f.remove()).status,
+ afterCounts: f.host.counts()
+ };
+ }, recovered);
+ expect(result).toMatchObject({
+ selected: true,
+ capturedSame: true,
+ status: 'removed',
+ removed: 1,
+ after: 0,
+ nonceCurrent: false,
+ proofCurrent: false,
+ oldAckCurrent: false,
+ originalNonce: false,
+ controller: true,
+ removal: true,
+ keys: [],
+ copy: false,
+ again: 'invalid'
+ });
+ expect(result.command).toBe(result.expected);
+ expect(result.capturedCounts).toEqual(result.counts);
+ expect(result.afterCounts).toEqual({
+ ...result.counts,
+ keys: result.counts.keys + 1
+ });
+ expect(traffic()).toHaveLength(before);
+ const reads = traffic().filter((x) => x.frame[0] === 'REQ');
+ expect(new Set(reads.map((x) => x.origin))).toEqual(new Set([origins[0]]));
+ expect(
+ traffic()
+ .filter((x) => x.frame[0] === 'EVENT')
+ .map((x) => x.origin)
+ .sort()
+ ).toEqual(origins.slice().sort());
+ });
+
+ for (const missing of origins.slice(1))
+ test(`${recovered ? 'recovered' : 'original'} every archive ACK is required even with genuine nonce on one approved read path: ${missing}`, async ({
+ page
+ }) => {
+ await qualify(page, recovered, [missing]);
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ before = await f.host.stored(),
+ counts = f.host.counts(),
+ token = await f.select();
+ return {
+ selected: !!token,
+ same:
+ JSON.stringify(before) === JSON.stringify(await f.host.stored()),
+ counts,
+ after: f.host.counts()
+ };
+ });
+ expect(result.selected).toBe(false);
+ expect(result.same).toBe(true);
+ expect(result.after).toEqual(result.counts);
+ });
+
+ for (const held of ['lock', 'SDK'] as const)
+ test(`${recovered ? 'recovered' : 'original'} genuine cleanup under actual occupied ${held} preserves row and permits fresh explicit selection`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const before = traffic().length;
+ const result = await page.evaluate(async (held) => {
+ const f = window.pcFixture,
+ row = JSON.stringify(await f.host.stored()),
+ counts = f.host.counts();
+ const denied = await f.withHeld(held, () => f.remove());
+ const after = f.host.counts(),
+ same = JSON.stringify(await f.host.stored()) === row;
+ await f.select();
+ const later = await f.remove();
+ return {
+ denied: denied.status,
+ later: later.status,
+ counts,
+ after,
+ same
+ };
+ }, held);
+ expect(result).toMatchObject({
+ denied: 'busy',
+ later: 'removed',
+ same: true
+ });
+ expect(result.after).toEqual(result.counts);
+ expect(traffic()).toHaveLength(before);
+ });
+
+ for (const mode of ['initial_read_abort', 'abort', 'wire_race'] as const)
+ test(`${recovered ? 'recovered' : 'original'} definite native ${mode} never removes or retires and remains explicitly protected`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.pcFixture,
+ before = (await f.host.stored())[0].wire,
+ hook = f.nativeFault(mode);
+ try {
+ const denied = await f.remove();
+ hook.restore();
+ const rows = await f.host.stored();
+ const selected = await f.select();
+ return {
+ status: denied.status,
+ ack: !!denied.acknowledgement,
+ count: rows.length,
+ same: rows[0]?.wire === before,
+ counts: hook.counts(),
+ selected: !!selected,
+ next: selected ? (await f.remove()).status : undefined
+ };
+ } finally {
+ hook.restore();
+ }
+ }, mode);
+ expect(result.ack).toBe(false);
+ expect(result.count).toBe(1);
+ if (mode === 'wire_race')
+ expect(result).toMatchObject({
+ status: 'conflict',
+ selected: false,
+ counts: { deletes: 0, races: 1 }
+ });
+ else {
+ expect(result.same).toBe(true);
+ expect(result.selected).toBe(true);
+ expect(result.next).toBe('removed');
+ }
+ if (mode === 'abort')
+ expect(result.counts).toMatchObject({
+ deletes: 1,
+ completes: 0,
+ aborts: 1
+ });
+ });
+
+ for (const mode of ['uncertain', 'read_before', 'read_after'] as const)
+ test(`${recovered ? 'recovered' : 'original'} native ${mode} keeps conservative lease and never invents removal provenance`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const result = await page.evaluate(
+ async ({ mode, recovered }) => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ ack = recovered ? f.acknowledgement()! : f.originalAck()!,
+ action = recovered
+ ? f.action()!
+ : window.pc.captureInboxProbePublicationAction(
+ f.repository,
+ a.session,
+ f.host.policy,
+ ack,
+ 'reviewed_inbox_probe_network'
+ )!,
+ hook = f.nativeFault(mode);
+ try {
+ const removed = await f.remove();
+ hook.restore();
+ const rows = (await f.host.stored()).length;
+ return {
+ status: removed.status,
+ ack: !!removed.acknowledgement,
+ counts: hook.counts(),
+ rows,
+ binding: !!f.removalBinding(),
+ permission: !!window.pc.captureInboxProbePublication(
+ f.repository,
+ a.session,
+ f.host.policy,
+ ack,
+ action,
+ originsForBrowser()[0],
+ 'reviewed_inbox_probe_publication'
+ )
+ };
+ } finally {
+ hook.restore();
+ }
+ function originsForBrowser() {
+ return ['wss://inbox.example.org'];
+ }
+ },
+ { mode, recovered }
+ );
+ expect(result).toMatchObject({
+ status: 'unknown_completion',
+ ack: false,
+ rows: 0,
+ binding: false,
+ permission: false,
+ counts: { deletes: 1, completes: 1 }
+ });
+ if (mode === 'uncertain')
+ expect(result.counts.refused).toBeGreaterThan(0);
+ });
+
+ for (const mode of [
+ 'read_loss',
+ 'native_pre_delete_loss',
+ 'delete_loss',
+ 'complete_loss'
+ ] as const)
+ test(`${recovered ? 'recovered' : 'original'} Stop at actual ${mode} cannot mint current removal or resurrect nonce authority`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.pcFixture,
+ hook = f.nativeFault(mode, () => f.stopCleanup());
+ try {
+ const removed = await f.remove();
+ hook.restore();
+ const rows = (await f.host.stored()).length;
+ return {
+ status: removed.status,
+ ack: !!removed.acknowledgement,
+ counts: hook.counts(),
+ rows,
+ removedBinding: !!f.removalBinding()
+ };
+ } finally {
+ hook.restore();
+ }
+ }, mode);
+ expect(result.ack).toBe(false);
+ expect(result.removedBinding).toBe(false);
+ if (mode === 'read_loss' || mode === 'native_pre_delete_loss') {
+ expect(result.counts.deletes).toBe(0);
+ expect(result.rows).toBe(1);
+ } else if (mode === 'complete_loss') {
+ expect(result).toMatchObject({
+ status: 'unknown_completion',
+ rows: 0,
+ counts: { deletes: 1, completes: 1 }
+ });
+ } else
+ expect(result).toMatchObject({
+ rows: 1,
+ counts: { deletes: 1, aborts: 1 }
+ });
+ });
+
+ for (const loss of ['head', 'controller', 'session'] as const)
+ test(`${recovered ? 'recovered' : 'original'} actual ${loss} loss after capture prevents deletion`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const result = await page.evaluate(async (loss) => {
+ const f = window.pcFixture;
+ if (loss === 'head') f.actors().churnHead();
+ else if (loss === 'controller') f.stop();
+ else window.pc.closePrivateSession(f.actors().session);
+ const removed = await f.remove();
+ return {
+ status: removed.status,
+ rows: (await f.host.stored()).length,
+ ack: !!removed.acknowledgement
+ };
+ }, loss);
+ expect(result).toEqual({ status: 'stopped', rows: 1, ack: false });
+ });
+
+ test(`${recovered ? 'recovered' : 'original'} exact command lease fences a previously captured permission and new capture before native deletion`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const before = traffic().length;
+ const result = await page.evaluate(async (recovered) => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ ack = recovered ? f.acknowledgement()! : f.originalAck()!,
+ action = recovered
+ ? f.action()!
+ : window.pc.captureInboxProbePublicationAction(
+ f.repository,
+ a.session,
+ f.host.policy,
+ ack,
+ 'reviewed_inbox_probe_network'
+ )!,
+ permission = window.pc.captureInboxProbePublication(
+ f.repository,
+ a.session,
+ f.host.policy,
+ ack,
+ action,
+ 'wss://peer.example.org',
+ 'reviewed_inbox_probe_publication'
+ )!;
+ const before = !!window.pc.inboxProbePublicationSnapshot(permission),
+ counts = f.host.counts();
+ let during = true,
+ newPermission = true,
+ pending: Promise<unknown> | undefined;
+ const hook = f.nativeFault('read_loss', () => {
+ during = !!window.pc.inboxProbePublicationSnapshot(permission);
+ newPermission = !!window.pc.captureInboxProbePublication(
+ f.repository,
+ a.session,
+ f.host.policy,
+ ack,
+ action,
+ 'wss://peer.example.org',
+ 'reviewed_inbox_probe_publication'
+ );
+ pending = window.pc.publishInboxProbeArchiveAttempt(
+ f.pool()!,
+ permission,
+ new AbortController().signal
+ );
+ });
+ try {
+ const removed = await f.remove();
+ return {
+ before,
+ during,
+ newPermission,
+ status: removed.status,
+ attempt: await pending,
+ counts,
+ after: f.host.counts(),
+ afterPermission: !!window.pc.inboxProbePublicationSnapshot(permission)
+ };
+ } finally {
+ hook.restore();
+ }
+ }, recovered);
+ expect(result).toMatchObject({
+ before: true,
+ during: false,
+ newPermission: false,
+ status: 'removed',
+ attempt: { status: 'stopped' },
+ afterPermission: false
+ });
+ expect(result.after).toEqual({
+ ...result.counts,
+ keys: result.counts.keys + 1
+ });
+ expect(traffic()).toHaveLength(before);
+ });
+}
+
+test('same actual C7 original and recovered actions share retirement and clear both genuine source identities without closing C7', async ({
+ page
+}) => {
+ await qualify(page, false);
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ original = f.originalIdentity()!,
+ ack = f.originalAck()!,
+ proof = f.nonceProof()!;
+ // A fresh recovered reader on the SAME controller/session, not teardown.
+ const current = a.access;
+ // Inbox already used archive+read; the shared three-attempt budget leaves
+ // the second exact read on peer, which has only two archive attempts.
+ await f.qualify(true, {
+ fresh: false,
+ readOrigin: 'wss://peer.example.org'
+ });
+ const same =
+ f.actors().access === current && f.actors().session === a.session;
+ await f.select();
+ const removed = await f.remove();
+ return {
+ same,
+ status: removed.status,
+ originalNonce: !!window.pc.inboxProbeRumorWire(original, a.session),
+ originalAck: !!window.pc.inboxProbePublicationBinding(
+ f.repository,
+ a.session,
+ ack,
+ f.host.policy
+ ),
+ originalProof: !!window.pc.inboxProbeNonceVerificationEvidence(
+ proof,
+ f.repository,
+ a.session,
+ f.host.policy
+ ),
+ recovered: !!f.recoveredBinding(),
+ controller: !!window.pc.inboxAccessConstructionBinding(
+ current,
+ a.session,
+ f.host.policy
+ ),
+ removal: f.removalBinding()?.current()
+ };
+ });
+ expect(result).toEqual({
+ same: true,
+ status: 'removed',
+ originalNonce: false,
+ originalAck: false,
+ originalProof: false,
+ recovered: false,
+ controller: true,
+ removal: true
+ });
+});
+
+test('100 genuine rows and command slots regain 101st admission only through actual cleanup in the SAME private session', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ full = await f.capacity();
+ if (full.denied.status !== 'capacity')
+ throw Error('actual native 101st admission must refuse at100');
+ await f.qualify(true, { fresh: false });
+ await f.select();
+ const removed = await f.remove(),
+ selected = f.command()!,
+ after = await f.host.stored();
+ const preserved =
+ after.length === 99 &&
+ after.every((row) => row.wire === full.originals.get(row.id)) &&
+ !after.some((row) => row.id === selected);
+ await f.replaceController();
+ const next = await f.prepareOriginal();
+ const action =
+ 'acknowledgement' in next &&
+ window.pc.captureInboxProbePublicationAction(
+ f.repository,
+ f.actors().session,
+ f.host.policy,
+ next.acknowledgement,
+ 'reviewed_inbox_probe_network'
+ );
+ return {
+ denied: full.denied.status,
+ removed: removed.status,
+ preserved,
+ next: next.status,
+ action: !!action,
+ sameSession: f.actors().session === full.session,
+ rows: (await f.host.stored()).length
+ };
+ });
+ expect(result).toEqual({
+ denied: 'capacity',
+ removed: 'removed',
+ preserved: true,
+ next: 'prepared',
+ action: true,
+ sameSession: true,
+ rows: 100
+ });
+});
+
+for (const recovered of [false, true]) {
+ test(`${recovered ? 'recovered' : 'original'} copied and wrong actual issuer scopes cannot capture cleanup or native removal authority`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ opened = await window.pc.openBrowserDatabase();
+ if (opened.state !== 'ready')
+ throw Error('actual second repository scope');
+ const second = window.pc.createPrivateStorageRepository(
+ opened.owner,
+ f.host.owner
+ )!,
+ foreign = f.host.foreignRepository(),
+ policy = f.host.copiedPolicy(),
+ observations = f.observations(),
+ nonce = f.nonce()!,
+ before = await f.host.stored(),
+ counts = f.host.counts();
+ const transaction = Object.getOwnPropertyDescriptor(
+ IDBDatabase.prototype,
+ 'transaction'
+ )!.value as IDBDatabase['transaction'];
+ let native = 0;
+ IDBDatabase.prototype.transaction = function (
+ ...args: Parameters<IDBDatabase['transaction']>
+ ) {
+ native++;
+ return transaction.apply(this, args);
+ };
+ try {
+ const candidates = [
+ [f.repository, a.session, f.host.policy, { ...nonce }, observations],
+ [
+ f.repository,
+ a.session,
+ f.host.policy,
+ nonce,
+ observations.map((x) => ({ ...x }))
+ ],
+ [f.repository, a.session, f.host.policy, nonce, []],
+ [second, a.session, f.host.policy, nonce, observations],
+ [foreign, a.session, f.host.policy, nonce, observations],
+ [f.repository, a.session, policy, nonce, observations],
+ [
+ f.repository,
+ {} as typeof a.session,
+ f.host.policy,
+ nonce,
+ observations
+ ]
+ ] as const;
+ const admitted = [];
+ for (const [repo, session, selectedPolicy, ack, effects] of candidates)
+ admitted.push(
+ !!(await window.pc.captureInboxProbeCleanup(
+ repo,
+ session,
+ selectedPolicy,
+ ack,
+ effects,
+ 'reviewed_inbox_probe_cleanup_selection'
+ ))
+ );
+ const nativeResult = await window.pc.removePrivateInboxProbe(
+ f.repository,
+ a.session,
+ nonce as unknown as Parameters<
+ typeof window.pc.removePrivateInboxProbe
+ >[2]
+ );
+ return {
+ admitted,
+ native,
+ nativeResult,
+ counts,
+ after: f.host.counts(),
+ rows: before.length
+ };
+ } finally {
+ IDBDatabase.prototype.transaction = transaction;
+ window.pc.closeBrowserDatabase(opened.owner);
+ }
+ });
+ expect(result.admitted).toEqual(Array(7).fill(false));
+ expect(result.native).toBe(0);
+ expect(result.nativeResult).toEqual({
+ ok: false,
+ reason: 'invalid_scope',
+ disposition: 'not_removed'
+ });
+ expect(result.after).toEqual(result.counts);
+ expect(result.rows).toBe(1);
+ });
+
+ test(`${recovered ? 'recovered' : 'original'} fully qualified probe remains protected from ordinary settled-send cleanup`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ row = (await f.host.stored())[0],
+ record = JSON.parse(row.wire) as PrivateAccessProbe;
+ const ordinary = await window.pc.capturePrivateOutboxCleanup(
+ f.repository,
+ a.session,
+ [row.id],
+ 'reviewed_settled_outbox_selection'
+ );
+ return {
+ settlement: window.pc.privateRecordSettlement(record),
+ ordinary: !!ordinary,
+ same: (await f.host.stored())[0].wire === row.wire
+ };
+ });
+ expect(result).toEqual({
+ settlement: 'protected',
+ ordinary: false,
+ same: true
+ });
+ });
+
+ for (const mode of [
+ 'alias',
+ 'corrupt_tail',
+ 'missing',
+ 'foreign_tail'
+ ] as const)
+ test(`${recovered ? 'recovered' : 'original'} complete namespace ${mode} preserves exact native and authority boundaries`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.pcFixture,
+ original = (await f.host.stored())[0];
+ let foreign: typeof original | undefined;
+ if (mode === 'missing') await f.removeFixtureRow();
+ else {
+ const owner =
+ mode === 'foreign_tail' ? 'f'.repeat(64) : original.owner;
+ const row = {
+ owner,
+ id: crypto.randomUUID(),
+ wire: mode === 'alias' ? original.wire : '{}'
+ };
+ if (mode === 'foreign_tail') foreign = row;
+ await f.host.inject([row]);
+ }
+ const removed = await f.remove(),
+ rows = await f.host.stored();
+ return {
+ status: removed.status,
+ ack: !!removed.acknowledgement,
+ rows: rows.length,
+ original: rows.some(
+ (x) => x.id === original.id && x.wire === original.wire
+ ),
+ foreign: foreign
+ ? rows.some((x) => JSON.stringify(x) === JSON.stringify(foreign))
+ : false
+ };
+ }, mode);
+ if (mode === 'foreign_tail')
+ expect(result).toMatchObject({
+ status: 'removed',
+ ack: true,
+ rows: 1,
+ original: false,
+ foreign: true
+ });
+ else if (mode === 'missing')
+ expect(result).toMatchObject({ ack: false, rows: 0, original: false });
+ else
+ expect(result).toMatchObject({
+ status: 'corrupt_record',
+ ack: false,
+ rows: 2,
+ original: true
+ });
+ });
+
+ test(`${recovered ? 'recovered' : 'original'} current removal provenance follows actual head loss after deliberate nonce disposal`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ removed = await f.remove(),
+ before = !!f.removalBinding();
+ f.actors().churnHead();
+ return { status: removed.status, before, after: !!f.removalBinding() };
+ });
+ expect(result).toEqual({ status: 'removed', before: true, after: false });
+ });
+}
+
+for (const failure of ['refused', 'unknown', 'stopped', 'timed_out'] as const)
+ test(`actual ${failure} archive history needs later genuine same-origin event acceptance before reviewed cleanup`, async ({
+ page
+ }) => {
+ ackMode =
+ failure === 'refused'
+ ? 'refuse'
+ : failure === 'unknown'
+ ? 'accept'
+ : 'hold';
+ await page.evaluate((failure) => {
+ const f = window.pcFixture,
+ controller = new AbortController(),
+ fault =
+ failure === 'unknown' ? f.installAttemptTeardownFailure() : undefined,
+ clock = failure === 'timed_out' ? f.installNetworkClock() : undefined;
+ window.pcRestore = () => {
+ fault?.restore();
+ clock?.restore();
+ controller.abort();
+ };
+ const pending = f.originalPublish(
+ 'wss://peer.example.org',
+ controller.signal
+ );
+ window.pcFinishAttempt = async () => {
+ if (failure === 'stopped') controller.abort();
+ if (failure === 'timed_out') clock!.advance(45000);
+ const result = await pending;
+ clock?.restore();
+ fault?.restore();
+ if (!result) throw Error('actual original negative archive result');
+ const saved = await f.append(result);
+ if (saved.status !== 'saved')
+ throw Error('actual negative native history ' + saved.status);
+ return result.status;
+ };
+ }, failure);
+ await expect
+ .poll(() => traffic().filter((x) => x.frame[0] === 'EVENT').length)
+ .toBe(1);
+ expect(await page.evaluate(() => window.pcFinishAttempt!())).toBe(failure);
+ ackMode = 'accept';
+ const result = await page.evaluate(async (failure) => {
+ const f = window.pcFixture,
+ session = f.actors().session;
+ await f.replaceController();
+ await f.qualify(true, { fresh: false });
+ const record = JSON.parse((await f.host.stored())[0].wire) as {
+ receipts: {
+ status: string;
+ origin: string;
+ role: string;
+ eventId: string;
+ }[];
+ },
+ negative = record.receipts.findIndex((x) => x.status === failure),
+ first = record.receipts[negative],
+ positive = record.receipts.findIndex(
+ (x, i) =>
+ i > negative &&
+ x.status === 'accepted' &&
+ x.origin === first.origin &&
+ x.role === first.role &&
+ x.eventId === first.eventId
+ );
+ const selected = await f.select(),
+ removed = await f.remove();
+ return {
+ sameSession: f.actors().session === session,
+ negative,
+ positive,
+ selected: !!selected,
+ status: removed.status
+ };
+ }, failure);
+ expect(result.negative).toBeGreaterThanOrEqual(0);
+ expect(result.positive).toBeGreaterThan(result.negative);
+ expect(result).toMatchObject({
+ sameSession: true,
+ selected: true,
+ status: 'removed'
+ });
+ });
+
+test('earlier genuine positive and later readback cannot resolve a subsequent refused archive for the same origin', async ({
+ page
+}) => {
+ await qualify(page, false);
+ ackMode = 'refuse';
+ expect(
+ await page.evaluate(async () => {
+ const f = window.pcFixture,
+ result = await f.originalPublish('wss://peer.example.org');
+ if (!result || result.status !== 'refused')
+ throw Error('actual refused later publication');
+ return (await f.append(result)).status;
+ })
+ ).toBe('saved');
+ ackMode = 'accept';
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ observations = f.observations(),
+ read = await f.originalRead('wss://peer.example.org');
+ if (
+ !read ||
+ read.status !== 'readback' ||
+ (await f.appendRead(read)).status !== 'saved'
+ )
+ throw Error('actual different-role later read');
+ const earlier = await f.select(),
+ otherRole = await f.select('reviewed_inbox_probe_cleanup_selection', [
+ ...observations,
+ read
+ ]);
+ return {
+ earlier: !!earlier,
+ otherRole: !!otherRole,
+ rows: (await f.host.stored()).length
+ };
+ });
+ expect(result).toEqual({ earlier: false, otherRole: false, rows: 1 });
+});
+
+test('unapplied later actual archive result blocks cleanup of an otherwise genuine current qualified probe', async ({
+ page
+}) => {
+ await qualify(page, false);
+ await select(page);
+ ackMode = 'refuse';
+ expect(
+ await page.evaluate(async () => {
+ const f = window.pcFixture,
+ result = await f.originalPublish('wss://peer.example.org');
+ if (!result || result.status !== 'refused')
+ throw Error('actual later negative result');
+ // Deliberately do not commit this actual settled attempt to the journal.
+ const current = !!window.pc.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ f.actors().session,
+ f.nonce()!,
+ f.host.policy
+ ),
+ idle = f.idle(),
+ before = f.host.counts(),
+ removed = await f.remove();
+ if (JSON.stringify(before) !== JSON.stringify(f.host.counts()))
+ throw Error('pending preflight must precede every provider request');
+ return {
+ current,
+ idle,
+ status: removed.status,
+ ack: !!removed.acknowledgement,
+ rows: (await f.host.stored()).length
+ };
+ })
+ ).toEqual({ current: true, idle: true, status: 'busy', ack: false, rows: 1 });
+});
+
+test('unapplied archive survives genuine ended-controller replacement and failed or forged native bookkeeping', async ({
+ page
+}) => {
+ await qualify(page);
+ await select(page);
+ ackMode = 'refuse';
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ actual = await f.originalPublish('wss://peer.example.org');
+ if (!actual || actual.status !== 'refused') throw Error('actual negative');
+ const forged = await f.append({ ...actual }),
+ hook = f.nativeFault('initial_read_abort');
+ const failed = await f.append(actual);
+ hook.restore();
+ const before = f.host.counts(),
+ denied = await f.remove(),
+ after = f.host.counts();
+ await f.replaceController();
+ if (
+ (await f.recover())?.status !== 'recovered' ||
+ (await f.adopt()).status !== 'adopted'
+ )
+ throw Error('genuine same-session recovery');
+ const genuine = !!window.pc.recoveredInboxProbePublicationBinding(
+ f.repository,
+ a.session,
+ f.acknowledgement()!,
+ f.host.policy
+ );
+ let uuids = 0;
+ const original = Object.getOwnPropertyDescriptor(
+ Crypto.prototype,
+ 'randomUUID'
+ )!.value as Crypto['randomUUID'];
+ crypto.randomUUID = () => {
+ uuids++;
+ return original.call(crypto);
+ };
+ let replaced: boolean;
+ try {
+ replaced = !!(await f.captureAction());
+ } finally {
+ crypto.randomUUID = original;
+ }
+ // Historical genuine native bookkeeping may settle after its controller.
+ const applied = await f.append(actual),
+ existing = await f.append(actual);
+ return {
+ forged: forged.status,
+ failed: failed.status,
+ denied: denied.status,
+ before,
+ after,
+ genuine,
+ replaced,
+ uuids,
+ applied: applied.status,
+ existing: existing.status,
+ sameSession: a.session === f.actors().session,
+ rows: (await f.host.stored()).length
+ };
+ });
+ expect(result).toMatchObject({
+ forged: 'invalid',
+ denied: 'busy',
+ genuine: true,
+ replaced: false,
+ uuids: 0,
+ applied: 'saved',
+ existing: 'existing',
+ sameSession: true,
+ rows: 1
+ });
+ expect(['saved', 'existing', 'reconciled']).not.toContain(result.failed);
+ expect(result.after).toEqual(result.before);
+});
+
+for (const recovered of [false, true]) {
+ for (const lane of ['EVENT', 'REQ', 'page', 'live', 'AUTH'] as const)
+ test(`${recovered ? 'recovered' : 'original'} genuinely qualified cleanup refuses actual active ${lane} before provider or native removal`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ if (lane === 'EVENT') ackMode = 'hold';
+ if (lane === 'REQ' || lane === 'page' || lane === 'live') holdRead = true;
+ if (lane === 'AUTH') {
+ challenge = true;
+ const started = await page.evaluate(async () => {
+ const f = window.pcFixture;
+ const result = await window.pc.authenticateInboxAccess(
+ f.actors().access,
+ 'wss://inbox.example.org',
+ 'reviewed_inbox_connection_auth'
+ );
+ return {
+ result,
+ snapshot: window.pc.inboxAccessControllerSnapshot(f.actors().access)
+ };
+ });
+ console.info(
+ JSON.stringify({
+ fixture: 'C3B_ACTUAL_AUTH_START',
+ recovered,
+ started
+ })
+ );
+ expect(['waiting', 'challenge']).toContain(started.result);
+ // Qualification may already own an open SDK connection. Deliver the
+ // genuine relay challenge on that exact existing physical connection.
+ for (const socket of physical)
+ if (physicalOrigins.get(socket) === 'wss://inbox.example.org')
+ socket.send(JSON.stringify(['AUTH', 'c3b-source-challenge']));
+ await expect
+ .poll(() =>
+ page.evaluate(
+ () =>
+ window.pc.inboxAccessControllerSnapshot(
+ window.pcFixture.actors().access
+ )?.auth[0]?.state
+ )
+ )
+ .toBe('challenge');
+ }
+ const trafficBefore = traffic().length;
+ await page.evaluate(
+ ({ lane, recovered }) => {
+ const f = window.pcFixture,
+ a = f.actors();
+ if (lane === 'EVENT')
+ window.pcPending = recovered
+ ? f.publish('wss://peer.example.org')
+ : f.originalPublish('wss://peer.example.org');
+ else if (lane === 'REQ')
+ window.pcPending = recovered
+ ? f.read('wss://peer.example.org')
+ : f.originalRead('wss://peer.example.org');
+ else if (lane === 'AUTH')
+ window.pcPending = window.pc.respondInboxAccessAuthentication(
+ a.access,
+ 'wss://inbox.example.org',
+ 'reviewed_inbox_auth_response'
+ );
+ else {
+ const pool = window.pc.getPrivatePool(
+ a.session,
+ f.host.policy,
+ ['wss://inbox.example.org'],
+ Object.freeze({}),
+ 'receive'
+ );
+ if (!pool) throw Error('actual foreground consumer');
+ const stop =
+ lane === 'page'
+ ? window.pc.subscribePrivatePage(pool, 1, () => {})
+ : window.pc.subscribePrivateLive(pool, () => {});
+ window.pcRelease = () => {
+ stop();
+ window.pc.closePrivatePool(pool);
+ };
+ }
+ },
+ { lane, recovered }
+ );
+ await expect.poll(() => traffic().length).toBeGreaterThan(trafficBefore);
+ const framesBefore = frames.slice();
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ current = !!window.pc.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ a.session,
+ f.nonce()!,
+ f.host.policy
+ ),
+ before = f.host.counts(),
+ hook = f.nativeFault('abort'),
+ idle = f.idle();
+ try {
+ const removed = await f.remove();
+ return {
+ current,
+ idle,
+ controllerBusy: window.pc.inboxAccessControllerSnapshot(a.access)
+ ?.busy,
+ before,
+ after: f.host.counts(),
+ status: removed.status,
+ ack: !!removed.acknowledgement,
+ deletes: hook.counts().deletes,
+ rows: (await f.host.stored()).length
+ };
+ } finally {
+ hook.restore();
+ }
+ });
+ expect(result).toMatchObject({
+ current: true,
+ // AUTH occupies the actual C7/shared SDK job; the pool's independent
+ // network-idle observation intentionally remains true for this lane.
+ idle: lane === 'AUTH',
+ controllerBusy: lane === 'AUTH',
+ status: 'busy',
+ ack: false,
+ deletes: 0,
+ rows: 1
+ });
+ expect(result.after).toEqual(result.before);
+ expect(frames).toEqual(framesBefore);
+ // Release only this fixture's owned operation after the refusal check.
+ if (lane === 'EVENT' || lane === 'AUTH') {
+ const frame = traffic().findLast((x) => x.frame[0] === lane)
+ ?.frame[1] as { id: string };
+ for (const socket of physical)
+ socket.send(JSON.stringify(['OK', frame.id, true, '']));
+ } else if (lane === 'REQ') {
+ for (const item of traffic()
+ .slice(trafficBefore)
+ .filter((x) => x.frame[0] === 'REQ'))
+ for (const socket of physical)
+ socket.send(JSON.stringify(['EOSE', item.frame[1]]));
+ } else
+ await page.evaluate(() => {
+ window.pcRelease!();
+ window.pcRelease = undefined;
+ });
+ await page.evaluate(() => window.pcPending);
+ });
+
+ for (const mode of ['hold', 'fail'] as const)
+ test(`${recovered ? 'recovered' : 'original'} genuine cleanup preserves actual ${mode} physical close and never retries it implicitly`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ await page.evaluate(async () => {
+ const f = window.pcFixture,
+ pool = window.pc.getPrivatePool(
+ f.actors().session,
+ f.host.policy,
+ ['wss://inbox.example.org'],
+ Object.freeze({}),
+ 'receive'
+ );
+ if (!pool) throw Error('actual receive owner');
+ const auth = await window.pc.beginInboxAuthentication(
+ pool,
+ 'wss://inbox.example.org',
+ 'reviewed_connection_auth'
+ );
+ if (!auth) throw Error('actual independently owned AUTH connection');
+ window.pcRelease = () => {
+ window.pc.closeInboxAuthentication(auth);
+ window.pc.closePrivatePool(pool);
+ };
+ });
+ await expect
+ .poll(() =>
+ [...physical].some(
+ (socket) =>
+ physicalOrigins.get(socket) === 'wss://inbox.example.org'
+ )
+ )
+ .toBe(true);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.pcFixture;
+ window.pcCloseMode = mode;
+ let failed = false;
+ try {
+ window.pcRelease!();
+ } catch {
+ failed = true;
+ }
+ const current = !!window.pc.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ f.actors().session,
+ f.nonce()!,
+ f.host.policy
+ ),
+ idle = f.idle(),
+ before = f.host.counts(),
+ closes = window.pcCloseCalls ?? 0,
+ held = window.pcHeldClose?.length ?? 0;
+ const removed = await f.remove();
+ return {
+ current,
+ idle,
+ failed,
+ before,
+ after: f.host.counts(),
+ closes,
+ afterCloses: window.pcCloseCalls ?? 0,
+ held,
+ afterHeld: window.pcHeldClose?.length ?? 0,
+ status: removed.status,
+ rows: (await f.host.stored()).length,
+ ack: !!removed.acknowledgement
+ };
+ }, mode);
+ expect(result).toMatchObject({
+ current: true,
+ idle: false,
+ status: 'busy',
+ rows: 1,
+ ack: false
+ });
+ expect(result.after).toEqual(result.before);
+ expect(result.afterCloses).toBe(result.closes);
+ expect(result.afterHeld).toBe(result.held);
+ if (mode === 'fail') expect(result.failed).toBe(true);
+ else expect(result.held).toBeGreaterThan(0);
+ await page.evaluate(() => {
+ window.pcCloseMode = undefined;
+ for (const release of window.pcHeldClose ?? []) release();
+ try {
+ window.pcRelease!();
+ } catch (e) {
+ if (
+ !(e instanceof Error) ||
+ ![
+ 'private_pool_close_pending',
+ 'private_pool_close_failed'
+ ].includes(e.message)
+ )
+ throw e;
+ }
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.pcFixture.idle()))
+ .toBe(true);
+ expect(
+ await page.evaluate(async () => {
+ await window.pcFixture.select();
+ return (await window.pcFixture.remove()).status;
+ })
+ ).toBe('removed');
+ });
+
+ for (const loss of ['head', 'controller', 'session'] as const)
+ for (const at of ['delete_loss', 'complete_loss'] as const)
+ test(`${recovered ? 'recovered' : 'original'} actual ${loss} loss at native ${at} refuses current removal provenance`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ await select(page);
+ const result = await page.evaluate(
+ async ({ loss, at }) => {
+ const f = window.pcFixture,
+ hook = f.nativeFault(at, () => {
+ if (loss === 'head') f.actors().churnHead();
+ else if (loss === 'controller') f.stop();
+ else window.pc.closePrivateSession(f.actors().session);
+ });
+ try {
+ const removed = await f.remove();
+ hook.restore();
+ const rows = (await f.host.stored()).length;
+ return {
+ status: removed.status,
+ ack: !!removed.acknowledgement,
+ binding: !!f.removalBinding(),
+ rows,
+ counts: hook.counts()
+ };
+ } finally {
+ hook.restore();
+ }
+ },
+ { loss, at }
+ );
+ expect(result.ack).toBe(false);
+ expect(result.binding).toBe(false);
+ expect(result.counts.deletes).toBe(1);
+ // A head change has no synchronous cancellation notification. The
+ // already-admitted native delete may complete historically, but final
+ // source revalidation must withhold current provenance and retirement.
+ if (at === 'complete_loss' || loss === 'head')
+ expect(result).toMatchObject({
+ status: 'unknown_completion',
+ rows: 0,
+ counts: { completes: 1 }
+ });
+ else expect(result).toMatchObject({ rows: 1, counts: { aborts: 1 } });
+ });
+
+ test(`${recovered ? 'recovered' : 'original'} exact cleanup preserves same-owner settled send, received envelope and unrelated protected probe bytes`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ preserved = await f.seedPreservedRecords();
+ await f.select();
+ const removed = await f.remove(),
+ sends = await f.host.stored(),
+ received = await f.receivedRows();
+ return { status: removed.status, preserved, sends, received };
+ });
+ expect(result.status).toBe('removed');
+ expect(result.sends).toEqual(
+ expect.arrayContaining(result.preserved.slice(0, 2))
+ );
+ expect(result.sends).toHaveLength(2);
+ expect(result.received).toEqual([result.preserved[2]]);
+ });
+}
+
+test('same-C7 recovered-first network action removes genuine row while old unregistered original cannot recreate it or emit EVENT', async ({
+ page
+}) => {
+ // Initial S3/R1 exists, but no original network action has ever been captured.
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ access = f.actors().access,
+ original = f.originalIdentity()!;
+ await f.qualify(true, { fresh: false });
+ await f.select();
+ const removed = await f.remove(),
+ before = f.host.counts(),
+ stillPrepared = !!window.pc.inboxProbeRumorWire(
+ original,
+ f.actors().session
+ ),
+ retry = await f.retryOriginalPreparation(),
+ publication = await f.originalPublish('wss://peer.example.org');
+ return {
+ sameC7: access === f.actors().access,
+ liveC7: !!window.pc
+ .inboxAccessConstructionBinding(
+ access,
+ f.actors().session,
+ f.host.policy
+ )
+ ?.current(),
+ removed: removed.status,
+ stillPrepared,
+ retry: retry.status,
+ retryAck: 'acknowledgement' in retry,
+ publication,
+ before,
+ after: f.host.counts(),
+ rows: (await f.host.stored()).length
+ };
+ });
+ expect(result).toMatchObject({
+ sameC7: true,
+ liveC7: true,
+ removed: 'removed',
+ stillPrepared: true,
+ retryAck: false,
+ rows: 0
+ });
+ // This original identity was never associated with the retired REC meter.
+ // Native absence rejects its real publication before EVENT admission.
+ expect(result.publication).toEqual({ status: 'stopped' });
+ expect(traffic().filter((x) => x.frame[0] === 'EVENT')).toHaveLength(3);
+ // Unregistered preparation is honestly retained until actual C7 teardown.
+ expect(
+ await page.evaluate(() => {
+ const f = window.pcFixture,
+ original = f.originalIdentity()!;
+ f.stop();
+ return !!window.pc.inboxProbeRumorWire(original, f.actors().session);
+ })
+ ).toBe(false);
+});
+
+for (const recovered of [false, true]) {
+ test(`${recovered ? 'recovered' : 'original'} bounded genuine observation array never reads or consumes a custom iterator`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ const result = await page.evaluate(async () => {
+ const f = window.pcFixture,
+ values = f.observations();
+ let gets = 0,
+ bodies = 0,
+ steps = 0;
+ Object.defineProperty(values, Symbol.iterator, {
+ configurable: true,
+ get() {
+ gets++;
+ return function* () {
+ bodies++;
+ // Finite real regression, never an infinite/hanging iterator.
+ for (let index = 0; index < values.length + 2; index++) {
+ steps++;
+ yield values[index % values.length];
+ }
+ };
+ }
+ });
+ const before = f.host.counts(),
+ selected = await f.select(
+ 'reviewed_inbox_probe_cleanup_selection',
+ values
+ );
+ return {
+ selected: !!selected,
+ gets,
+ bodies,
+ steps,
+ declaredLength: values.length,
+ before,
+ after: f.host.counts(),
+ rows: (await f.host.stored()).length
+ };
+ });
+ expect(result).toMatchObject({
+ selected: true,
+ gets: 0,
+ bodies: 0,
+ steps: 0,
+ declaredLength: 4,
+ rows: 1
+ });
+ expect(result.after).toEqual(result.before);
+ });
+
+ for (const kind of [
+ 'accessor',
+ 'sparse',
+ 'inherited',
+ 'oversized',
+ 'non_integer',
+ 'unsafe_length'
+ ] as const)
+ test(`${recovered ? 'recovered' : 'original'} genuine cleanup refuses ${kind} observation data without native or provider work`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ const result = await page.evaluate(async (kind) => {
+ const f = window.pcFixture,
+ values = f.observations(),
+ first = values[0],
+ a = f.actors(),
+ record = JSON.parse((await f.host.stored())[0].wire) as {
+ receipts: unknown[];
+ };
+ let gets = 0,
+ lengthDescriptors = 0;
+ let input: typeof values = values;
+ if (kind === 'accessor')
+ Object.defineProperty(values, '0', {
+ configurable: true,
+ get() {
+ gets++;
+ return first;
+ }
+ });
+ else if (kind === 'sparse') Reflect.deleteProperty(values, '0');
+ else if (kind === 'inherited') {
+ Reflect.deleteProperty(values, '0');
+ const prototype: object = Object.create(Array.prototype) as object;
+ Object.defineProperty(prototype, '0', {
+ value: first,
+ configurable: true
+ });
+ Object.setPrototypeOf(values, prototype);
+ } else if (kind === 'oversized')
+ values.length = record.receipts.length + 1;
+ else
+ input = new Proxy(values, {
+ getOwnPropertyDescriptor(target, key) {
+ const field = Reflect.getOwnPropertyDescriptor(target, key);
+ if (key === 'length' && field) {
+ lengthDescriptors++;
+ return {
+ ...field,
+ value:
+ kind === 'non_integer' ? 1.5 : Number.MAX_SAFE_INTEGER + 1
+ };
+ }
+ return field;
+ }
+ });
+ const genuine = !!window.pc.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ a.session,
+ f.nonce()!,
+ f.host.policy
+ ),
+ before = f.host.counts(),
+ hook = f.nativeFault('abort');
+ try {
+ const selected = await f.select(
+ 'reviewed_inbox_probe_cleanup_selection',
+ input
+ );
+ hook.restore();
+ return {
+ genuine,
+ selected: !!selected,
+ gets,
+ lengthDescriptors,
+ counts: hook.counts(),
+ before,
+ after: f.host.counts(),
+ rows: (await f.host.stored()).length
+ };
+ } finally {
+ hook.restore();
+ }
+ }, kind);
+ expect(result).toMatchObject({
+ genuine: true,
+ selected: false,
+ gets: 0,
+ rows: 1,
+ counts: { readonly: 0, deletes: 0 }
+ });
+ expect(result.after).toEqual(result.before);
+ if (kind === 'non_integer' || kind === 'unsafe_length')
+ expect(result.lengthDescriptors).toBe(1);
+ });
+
+ for (const loss of ['head', 'nonce'] as const)
+ test(`${recovered ? 'recovered' : 'original'} observation descriptor callback actual ${loss} loss is fenced after bounded inspection`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ const result = await page.evaluate(async (loss) => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ original = (await f.host.stored())[0].wire,
+ values = f.observations();
+ let callbacks = 0,
+ descriptors = 0;
+ const input = new Proxy(values, {
+ getOwnPropertyDescriptor(target, key) {
+ descriptors++;
+ if (key === '0' && callbacks === 0) {
+ callbacks++;
+ if (loss === 'head') a.churnHead();
+ else
+ window.pc.disposeInboxProbeNonceProof(
+ f.nonceProof()!,
+ f.repository,
+ a.session,
+ f.host.policy
+ );
+ }
+ return Reflect.getOwnPropertyDescriptor(target, key);
+ }
+ });
+ const genuine = !!window.pc.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ a.session,
+ f.nonce()!,
+ f.host.policy
+ ),
+ before = f.host.counts(),
+ hook = f.nativeFault('abort');
+ try {
+ const selected = await f.select(
+ 'reviewed_inbox_probe_cleanup_selection',
+ input
+ );
+ hook.restore();
+ return {
+ genuine,
+ selected: !!selected,
+ callbacks,
+ descriptors,
+ limit: values.length + 1,
+ before,
+ after: f.host.counts(),
+ counts: hook.counts(),
+ same: (await f.host.stored())[0].wire === original
+ };
+ } finally {
+ hook.restore();
+ }
+ }, loss);
+ expect(result).toMatchObject({
+ genuine: true,
+ selected: false,
+ callbacks: 1,
+ same: true,
+ counts: { readonly: 0, deletes: 0 }
+ });
+ expect(result.descriptors).toBeLessThanOrEqual(result.limit);
+ expect(result.after).toEqual(result.before);
+ });
+
+ test(`${recovered ? 'recovered' : 'original'} actual Lineage append started by a descriptor callback cannot authorize stale cleanup`, async ({
+ page
+ }) => {
+ await qualify(page, recovered);
+ const result = await page.evaluate(async (recovered) => {
+ const f = window.pcFixture,
+ a = f.actors(),
+ extra = await (recovered
+ ? f.publish('wss://peer.example.org')
+ : f.originalPublish('wss://peer.example.org'));
+ if (!extra || extra.status !== 'accepted')
+ throw Error('actual extra source result');
+ const values = f.observations(),
+ before = f.host.counts();
+ let pending: ReturnType<typeof f.append> | undefined,
+ callbacks = 0;
+ const input = new Proxy(values, {
+ getOwnPropertyDescriptor(target, key) {
+ if (key === '0' && !pending) {
+ callbacks++;
+ pending = f.append(extra);
+ }
+ return Reflect.getOwnPropertyDescriptor(target, key);
+ }
+ });
+ const genuine = !!window.pc.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ a.session,
+ f.nonce()!,
+ f.host.policy
+ ),
+ hook = f.nativeFault('abort');
+ try {
+ const selected = await f.select(
+ 'reviewed_inbox_probe_cleanup_selection',
+ input
+ );
+ if (!pending)
+ throw Error('actual bounded descriptor callback did not run');
+ const applied = await pending,
+ removed = await f.remove();
+ hook.restore();
+ const rows = await f.host.stored();
+ return {
+ genuine,
+ callbacks,
+ captured: !!selected,
+ applied: applied.status,
+ status: removed.status,
+ ack: !!removed.acknowledgement,
+ counts: hook.counts(),
+ before,
+ after: f.host.counts(),
+ rows: rows.length,
+ receipts: (JSON.parse(rows[0].wire) as { receipts: unknown[] })
+ .receipts.length
+ };
+ } finally {
+ hook.restore();
+ }
+ }, recovered);
+ expect(result).toMatchObject({
+ genuine: true,
+ callbacks: 1,
+ applied: 'saved',
+ ack: false,
+ rows: 1,
+ receipts: 6,
+ counts: { deletes: 0 }
+ });
+ expect(['invalid', 'stopped']).toContain(result.status);
+ expect(result.after).toEqual(result.before);
+ });
+}
diff --git a/web/tests/e2e/inbox-probe-retry.spec.ts b/web/tests/e2e/inbox-probe-retry.spec.ts
@@ -1443,7 +1443,12 @@ for (const fault of ['held', 'failed'] as const)
failed = true;
}
const effect = await window.ptPending,
- before = f.host.counts(),
+ applied = await f.append(effect as Parameters<typeof f.append>[0]);
+ if (!['saved', 'existing', 'reconciled'].includes(applied.status))
+ throw Error(
+ 'actual stopped archive native bookkeeping ' + applied.status
+ );
+ const before = f.host.counts(),
held = window.ptHeldClose?.length ?? 0;
const idle = f.idle(),
selected = await window.pt.captureRecoveredInboxProbeRetryAction(
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -614,6 +614,7 @@ import { auditOutput } from '../../tools/check-output.mjs';
for (const producer of [
'src/lib/persistence/private-storage.ts',
'src/lib/persistence/inbox-probes.ts',
+ 'src/lib/persistence/inbox-probe-cleanup.ts',
'src/lib/persistence/private-records.ts'
]) {
for (const change of ['changed', 'missing']) {
@@ -823,7 +824,7 @@ import { auditOutput } from '../../tools/check-output.mjs';
const f = await fixture(t);
const files = await f.audit();
// Exact eleven-route module/page/static admission; CSS stays once-imported.
- assert.equal(files.length, 59);
+ assert.equal(files.length, 58);
// The actual SDK payload crosses the reader scratch boundary; a reused
// scratch buffer must still preserve every compiler/static byte exactly.
const sizes = await Promise.all(
@@ -1113,7 +1114,7 @@ import { auditOutput } from '../../tools/check-output.mjs';
assert.ok(Buffer.byteLength(expanded) > 64 * 1024);
await writeFile(file, expanded);
await refresh(f);
- assert.equal((await f.audit()).length, 59);
+ assert.equal((await f.audit()).length, 58);
}
);
@@ -1971,6 +1972,7 @@ import { auditOutput } from '../../tools/check-output.mjs';
for (const producer of [
'src/lib/nostr/private-publisher.ts',
'src/lib/persistence/inbox-probes.ts',
+ 'src/lib/persistence/inbox-probe-cleanup.ts',
'src/lib/nostr/inbox-access.ts',
'src/lib/nostr/seal-builder.ts',
'src/lib/nostr/giftwrap-builder.ts',
@@ -2057,7 +2059,7 @@ import { auditOutput } from '../../tools/check-output.mjs';
(record) => record.name === 'nodes/6'
),
owner = Object.entries(manifest).find(
- ([, record]) => record.name === 'public-key'
+ ([, record]) => record.name === 'public-runtime'
)?.[0];
assert.ok(row && owner && row.imports.includes(owner));
if (mutation === 'missing-owner')
diff --git a/web/tests/unit/inbox-probe-cleanup.test.ts b/web/tests/unit/inbox-probe-cleanup.test.ts
@@ -0,0 +1,148 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import type { PrivateSession } from '../../src/lib/runtime/private-session.ts';
+import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts';
+import type { RelayPolicy } from '../../src/lib/config/relays.ts';
+afterEach(() => vi.unstubAllGlobals());
+for (const browser of [false, true])
+ it(`cold ${browser ? 'browser-shaped' : 'SSR'} probe cleanup refuses forged source, native and retirement authority without effects`, async () => {
+ vi.resetModules();
+ let effects = 0;
+ const trap = () => {
+ effects++;
+ throw Error('unadmitted cleanup effect');
+ };
+ if (browser) {
+ vi.stubGlobal('window', {
+ get nostr() {
+ return trap();
+ }
+ });
+ vi.stubGlobal('navigator', {
+ get locks() {
+ return trap();
+ }
+ });
+ vi.stubGlobal('indexedDB', { open: trap });
+ vi.stubGlobal('WebSocket', trap);
+ }
+ const cleanup =
+ await import('../../src/lib/persistence/inbox-probe-cleanup.ts'),
+ journal = await import('../../src/lib/persistence/inbox-probes.ts'),
+ native = await import('../../src/lib/persistence/private-storage.ts'),
+ publisher = await import('../../src/lib/nostr/private-publisher.ts');
+ const repository = {} as PrivateStorageRepository,
+ session = {} as PrivateSession,
+ policy = {} as RelayPolicy;
+ for (const value of [
+ undefined,
+ null,
+ false,
+ 0,
+ '',
+ Symbol(),
+ {},
+ { status: 'nonce_verified', current: () => true },
+ { status: 'removed', removed: 1, selection: {} }
+ ]) {
+ expect(
+ await cleanup.captureInboxProbeCleanup(
+ repository,
+ session,
+ policy,
+ value as Parameters<typeof cleanup.captureInboxProbeCleanup>[3],
+ [],
+ 'reviewed_inbox_probe_cleanup_selection'
+ )
+ ).toBeUndefined();
+ expect(
+ await cleanup.deleteReviewedInboxProbe(
+ value as Parameters<typeof cleanup.deleteReviewedInboxProbe>[0],
+ 'reviewed_delete_local_inbox_probe'
+ )
+ ).toEqual({ status: 'invalid' });
+ expect(
+ cleanup.inboxProbeCleanupAdmission(
+ value as Parameters<typeof cleanup.inboxProbeCleanupAdmission>[0],
+ repository,
+ session
+ )
+ ).toBeUndefined();
+ expect(
+ await native.removePrivateInboxProbe(
+ repository,
+ session,
+ value as Parameters<typeof native.removePrivateInboxProbe>[2]
+ )
+ ).toEqual({
+ ok: false,
+ reason: 'invalid_scope',
+ disposition: 'not_removed'
+ });
+ expect(
+ native.privateProbeRemovalEvidence(
+ value as Parameters<typeof native.privateProbeRemovalEvidence>[0],
+ repository,
+ session
+ )
+ ).toBeUndefined();
+ expect(
+ publisher.acquireInboxProbeCleanupLease(
+ repository,
+ session,
+ policy,
+ value as Parameters<typeof publisher.acquireInboxProbeCleanupLease>[3]
+ )
+ ).toBeUndefined();
+ expect(
+ publisher.inboxProbeCleanupReady(
+ repository,
+ session,
+ policy,
+ value as Parameters<typeof publisher.inboxProbeCleanupReady>[3]
+ )
+ ).toBe(false);
+ expect(
+ journal.appliedInboxProbeArchiveAdmission(
+ value as Parameters<
+ typeof journal.appliedInboxProbeArchiveAdmission
+ >[0]
+ )
+ ).toBeUndefined();
+ publisher.reconcileInboxProbeArchiveAdmission(
+ value as Parameters<
+ typeof publisher.reconcileInboxProbeArchiveAdmission
+ >[0]
+ );
+ expect(
+ publisher.retireInboxProbeCleanupLease(
+ value as Parameters<typeof publisher.retireInboxProbeCleanupLease>[0],
+ {} as Parameters<typeof publisher.retireInboxProbeCleanupLease>[1]
+ )
+ ).toBe(false);
+ expect(
+ journal.retireInboxProbeCleanupSelection(
+ value as Parameters<
+ typeof journal.retireInboxProbeCleanupSelection
+ >[0],
+ {} as Parameters<typeof journal.retireInboxProbeCleanupSelection>[1]
+ )
+ ).toBe(false);
+ expect(
+ cleanup.inboxProbeRemovalAcknowledgementBinding(
+ value as Parameters<
+ typeof cleanup.inboxProbeRemovalAcknowledgementBinding
+ >[0],
+ repository,
+ session,
+ policy
+ )
+ ).toBeUndefined();
+ cleanup.stopInboxProbeCleanup(
+ value as Parameters<typeof cleanup.stopInboxProbeCleanup>[0]
+ );
+ publisher.releaseInboxProbeCleanupLease(
+ value as Parameters<typeof publisher.releaseInboxProbeCleanupLease>[0]
+ );
+ }
+ expect(effects).toBe(0);
+ });
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -317,15 +317,17 @@ async function operationalFlagsAdmission(web) {
'src/lib/messaging/inbox-setup-operation.ts':
'245c6ce88b146dc731e7ace4f16dc9b5002a87a997f5568e4811b0c4a2daf035',
'src/lib/nostr/self-recovery-reader.ts':
- 'a7a5b0e874c65620cd80ccb9a6a50f82a31833adb496a88f9f0daa5b74c06dfd',
+ 'e6bd782a80dedc2b8b0e5650f717af3e9516c4e66d15f2361b73adcb2763a3d5',
'src/lib/nostr/private-publisher.ts':
- 'e02cdbba35b8a9c7fc5f805c8c21432d4f6eab42c6d098411613189cb6ac7caf',
+ '13fba9d8c93e6c530d97bbac79debc60892069daaee47cabd879e3aa7ab4910a',
'src/lib/nostr/private-pool.ts':
'2ed123596f26bedb8aab5ec7694be6e264616429e00f745f1614c83f52de9825',
'src/lib/nostr/inbox-ingress.ts':
'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
'src/lib/persistence/inbox-probes.ts':
- '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0',
+ '3c891f5a540f2cae07bed29a53f73feb8cacc0bef3a75c8c22acb015c4b519fa',
+ 'src/lib/persistence/inbox-probe-cleanup.ts':
+ '44a7988b4a52e0a2c5971d7d9ee3c268ffa316d14c920cf2fb75be0d5a7fc375',
'src/lib/nostr/inbox-access.ts':
'16eef55d0ffcf2c3291573ddcb0b6a1432bb77abce0017a69e9b6f82414609a7',
'src/lib/nostr/seal-builder.ts':
@@ -405,7 +407,7 @@ async function operationalFlagsAdmission(web) {
'src/lib/persistence/private-sends.ts':
'6696f4179370cad373c06debf57b919598d53b3d25b6d2a6054a557608e4eb9c',
'src/lib/persistence/private-storage.ts':
- 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91',
+ '9cdac5a1f00678d83bdf4a9b7bfb7c8bd04dc234afb140fc19e0156ad4a064a3',
'src/lib/persistence/public-publications.ts':
'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194',
'src/lib/persistence/public-receipts.ts':
@@ -595,15 +597,17 @@ async function privacyDataAdmission(web) {
'src/lib/messaging/inbox-list.ts':
'9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5',
'src/lib/nostr/self-recovery-reader.ts':
- 'a7a5b0e874c65620cd80ccb9a6a50f82a31833adb496a88f9f0daa5b74c06dfd',
+ 'e6bd782a80dedc2b8b0e5650f717af3e9516c4e66d15f2361b73adcb2763a3d5',
'src/lib/nostr/private-publisher.ts':
- 'e02cdbba35b8a9c7fc5f805c8c21432d4f6eab42c6d098411613189cb6ac7caf',
+ '13fba9d8c93e6c530d97bbac79debc60892069daaee47cabd879e3aa7ab4910a',
'src/lib/nostr/private-pool.ts':
'2ed123596f26bedb8aab5ec7694be6e264616429e00f745f1614c83f52de9825',
'src/lib/nostr/inbox-ingress.ts':
'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
'src/lib/persistence/inbox-probes.ts':
- '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0',
+ '3c891f5a540f2cae07bed29a53f73feb8cacc0bef3a75c8c22acb015c4b519fa',
+ 'src/lib/persistence/inbox-probe-cleanup.ts':
+ '44a7988b4a52e0a2c5971d7d9ee3c268ffa316d14c920cf2fb75be0d5a7fc375',
'src/lib/nostr/inbox-access.ts':
'16eef55d0ffcf2c3291573ddcb0b6a1432bb77abce0017a69e9b6f82414609a7',
'src/lib/nostr/seal-builder.ts':
@@ -677,7 +681,7 @@ async function privacyDataAdmission(web) {
'src/lib/persistence/private-sends.ts':
'6696f4179370cad373c06debf57b919598d53b3d25b6d2a6054a557608e4eb9c',
'src/lib/persistence/private-storage.ts':
- 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91',
+ '9cdac5a1f00678d83bdf4a9b7bfb7c8bd04dc234afb140fc19e0156ad4a064a3',
'src/lib/persistence/public-publications.ts':
'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194',
'src/lib/persistence/public-receipts.ts':
@@ -2169,9 +2173,11 @@ async function inboxProbeStorageAdmission(web) {
'src/lib/persistence/private-records.ts':
'821ef96740cf644bff4ffe5c7816c6aa097aa419bd16b8b301809b963294dafe',
'src/lib/persistence/private-storage.ts':
- 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91',
+ '9cdac5a1f00678d83bdf4a9b7bfb7c8bd04dc234afb140fc19e0156ad4a064a3',
'src/lib/persistence/inbox-probes.ts':
- '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0'
+ '3c891f5a540f2cae07bed29a53f73feb8cacc0bef3a75c8c22acb015c4b519fa',
+ 'src/lib/persistence/inbox-probe-cleanup.ts':
+ '44a7988b4a52e0a2c5971d7d9ee3c268ffa316d14c920cf2fb75be0d5a7fc375'
};
for (const [name, pin] of Object.entries(producers)) {
const bytes = await readOwned(web, name);
@@ -2521,7 +2527,14 @@ export async function auditOutput(webDirectory) {
names.add('navigation-url');
}
if (hasPrivacyData) names.add('SupportLink');
- if (hasOperationalFlags) names.add('capabilities');
+ if (hasOperationalFlags) {
+ names.add('capabilities');
+ // The exact pinned probe-cleanup source cycle joins these shared owners.
+ // Admit its actual current compiler graph, not arbitrary extra modules.
+ names.delete('private-session');
+ names.delete('public-key');
+ names.add('rolldown-runtime');
+ }
const admitted = new Map([['build-info.json', expectedMetadata]]);
const seen = new Set();
for (const [key, record] of Object.entries(manifest)) {
@@ -5432,6 +5445,437 @@ export async function auditOutput(webDirectory) {
css: ['_app/immutable/assets/0.HASH.css']
}
});
+ // Exact current cleanup-source graph; predecessor profiles above stay fixed.
+ // Full names, flags, sources and ordered edges remain fail-closed.
+ if (hasOperationalFlags)
+ Object.assign(expected, {
+ 'entry/app': {
+ file: '_app/immutable/entry/app.HASH.js',
+ name: 'entry/app',
+ src: '.svelte-kit/generated/build/client-optimized/app.js',
+ isEntry: true,
+ imports: ['preload-helper', 'shared-errors', 'references'],
+ dynamicImports: [
+ 'nodes/0',
+ 'nodes/1',
+ 'nodes/2',
+ 'nodes/3',
+ 'nodes/4',
+ 'nodes/5',
+ 'nodes/6',
+ 'nodes/7',
+ 'nodes/8',
+ 'nodes/9',
+ 'nodes/10',
+ 'nodes/11',
+ 'nodes/12',
+ 'error-template'
+ ]
+ },
+ 'nodes/0': {
+ file: '_app/immutable/nodes/0.HASH.js',
+ name: 'nodes/0',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/0.js',
+ isEntry: true,
+ imports: [
+ 'rolldown-runtime',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'client.svelte',
+ 'state',
+ 'Button',
+ 'CapabilityGate',
+ 'Disclosure',
+ 'capabilities',
+ 'local-private-blocks'
+ ],
+ css: ['_app/immutable/assets/0.HASH.css']
+ },
+ 'nodes/1': {
+ file: '_app/immutable/nodes/1.HASH.js',
+ name: 'nodes/1',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/1.js',
+ isEntry: true,
+ imports: ['client', 'client.svelte', 'state', 'legacy']
+ },
+ 'nodes/10': {
+ file: '_app/immutable/nodes/10.HASH.js',
+ name: 'nodes/10',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/10.js',
+ isEntry: true,
+ imports: [
+ 'references',
+ 'client',
+ 'navigation-url',
+ 'client.svelte',
+ 'navigation',
+ 'state',
+ 'legacy',
+ 'routes',
+ 'ListingEditor'
+ ]
+ },
+ 'nodes/11': {
+ file: '_app/immutable/nodes/11.HASH.js',
+ name: 'nodes/11',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/11.js',
+ isEntry: true,
+ imports: [
+ 'references',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'CapabilityGate',
+ 'Disclosure',
+ 'InboxSetup',
+ 'OperationStatus'
+ ]
+ },
+ 'nodes/12': {
+ file: '_app/immutable/nodes/12.HASH.js',
+ name: 'nodes/12',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/12.js',
+ isEntry: true,
+ imports: [
+ 'rolldown-runtime',
+ 'client',
+ 'client.svelte',
+ 'navigation',
+ 'state',
+ 'ListingEditor'
+ ]
+ },
+ 'nodes/2': {
+ file: '_app/immutable/nodes/2.HASH.js',
+ name: 'nodes/2',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/2.js',
+ isEntry: true,
+ imports: ['client', 'navigation-url', 'SearchForm', 'routes']
+ },
+ 'nodes/3': {
+ file: '_app/immutable/nodes/3.HASH.js',
+ name: 'nodes/3',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/3.js',
+ isEntry: true,
+ imports: ['public-runtime', 'client', 'SupportLink', 'ReportPreview']
+ },
+ 'nodes/4': {
+ file: '_app/immutable/nodes/4.HASH.js',
+ name: 'nodes/4',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/4.js',
+ isEntry: true,
+ imports: [
+ 'public-runtime',
+ 'client',
+ 'CapabilityGate',
+ 'InboxSetup',
+ 'InboxStatus'
+ ]
+ },
+ 'nodes/5': {
+ file: '_app/immutable/nodes/5.HASH.js',
+ name: 'nodes/5',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/5.js',
+ isEntry: true,
+ imports: [
+ 'rolldown-runtime',
+ 'references',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'client.svelte',
+ 'state',
+ 'Button',
+ 'local-private-blocks',
+ 'legacy',
+ 'ReportPreview',
+ 'inbox-view',
+ 'InboxStatus',
+ 'MessageComposer'
+ ]
+ },
+ 'nodes/6': {
+ file: '_app/immutable/nodes/6.HASH.js',
+ name: 'nodes/6',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/6.js',
+ isEntry: true,
+ imports: [
+ 'references',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'Button',
+ 'local-private-blocks',
+ 'SupportLink'
+ ]
+ },
+ 'nodes/7': {
+ file: '_app/immutable/nodes/7.HASH.js',
+ name: 'nodes/7',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/7.js',
+ isEntry: true,
+ imports: [
+ 'rolldown-runtime',
+ 'references',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'client.svelte',
+ 'state',
+ 'Button',
+ 'CapabilityGate',
+ 'Disclosure',
+ 'ReportPreview',
+ 'InboxSetup',
+ 'MessageComposer'
+ ]
+ },
+ 'nodes/8': {
+ file: '_app/immutable/nodes/8.HASH.js',
+ name: 'nodes/8',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/8.js',
+ isEntry: true,
+ imports: [
+ 'rolldown-runtime',
+ 'client',
+ 'client.svelte',
+ 'navigation',
+ 'state',
+ 'ListingEditor'
+ ]
+ },
+ 'nodes/9': {
+ file: '_app/immutable/nodes/9.HASH.js',
+ name: 'nodes/9',
+ src: '.svelte-kit/generated/build/client-optimized/nodes/9.js',
+ isEntry: true,
+ imports: [
+ 'references',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'client.svelte',
+ 'navigation',
+ 'state',
+ 'Button',
+ 'Disclosure',
+ 'SearchForm',
+ 'routes',
+ 'publishers'
+ ]
+ },
+ 'error-template': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'error-template',
+ src: '.svelte-kit/generated/build/shared/error-template.js',
+ isDynamicEntry: true
+ },
+ SearchForm: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'SearchForm',
+ imports: ['client', 'Button']
+ },
+ capabilities: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'capabilities',
+ imports: ['public-runtime']
+ },
+ legacy: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'legacy',
+ imports: ['client']
+ },
+ InboxSetup: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'InboxSetup',
+ imports: ['public-runtime', 'client', 'Button']
+ },
+ 'preload-helper': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'preload-helper'
+ },
+ 'public-runtime': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'public-runtime',
+ imports: [
+ 'rolldown-runtime',
+ 'preload-helper',
+ 'references',
+ 'navigation-url'
+ ],
+ dynamicImports: ['negentropy']
+ },
+ Disclosure: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'Disclosure',
+ imports: ['client']
+ },
+ 'navigation-url': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'navigation-url'
+ },
+ 'inbox-view': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'inbox-view',
+ imports: [
+ 'references',
+ 'public-runtime',
+ 'navigation-url',
+ 'local-private-blocks'
+ ]
+ },
+ SupportLink: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'SupportLink',
+ imports: ['public-runtime', 'client', 'navigation-url']
+ },
+ state: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'state',
+ imports: ['client.svelte']
+ },
+ publishers: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'publishers',
+ imports: ['references', 'public-runtime', 'navigation-url']
+ },
+ ReportPreview: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'ReportPreview',
+ imports: [
+ 'references',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'SupportLink',
+ 'publishers',
+ 'inbox-view'
+ ]
+ },
+ Button: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'Button',
+ imports: ['client', 'navigation-url']
+ },
+ 'local-private-blocks': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'local-private-blocks',
+ imports: ['references', 'public-runtime', 'navigation-url']
+ },
+ ListingEditor: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'ListingEditor',
+ imports: [
+ 'references',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'CapabilityGate',
+ 'capabilities',
+ 'InboxSetup',
+ 'OperationStatus'
+ ]
+ },
+ navigation: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'navigation',
+ imports: ['entry/payload', 'shared-errors', 'client', 'client.svelte']
+ },
+ 'shared-errors': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'shared-errors'
+ },
+ InboxStatus: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'InboxStatus',
+ imports: [
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'navigation',
+ 'Button',
+ 'CapabilityGate',
+ 'inbox-view',
+ 'InboxSetup'
+ ]
+ },
+ CapabilityGate: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'CapabilityGate',
+ imports: ['client', 'navigation-url', 'Button']
+ },
+ 'client.svelte': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'client.svelte',
+ imports: ['entry/payload', 'shared-errors', 'client']
+ },
+ client: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'client'
+ },
+ routes: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'routes',
+ imports: ['references', 'navigation-url']
+ },
+ MessageComposer: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'MessageComposer',
+ imports: [
+ 'references',
+ 'public-runtime',
+ 'client',
+ 'navigation-url',
+ 'navigation',
+ 'local-private-blocks',
+ 'ReportPreview',
+ 'inbox-view'
+ ]
+ },
+ OperationStatus: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'OperationStatus',
+ imports: ['references', 'public-runtime', 'client']
+ },
+ 'rolldown-runtime': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'rolldown-runtime'
+ },
+ references: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'references',
+ imports: ['rolldown-runtime']
+ },
+ 'client-entry': {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'client-entry',
+ src: 'node_modules/.pnpm/@sveltejs+kit@3.0.0_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte@7.3.1_svelte@_6edc02734bfa45cbf85e92e62b52fb36/node_modules/@sveltejs/kit/src/runtime/client/client-entry.js',
+ isDynamicEntry: true,
+ imports: ['navigation']
+ },
+ 'entry/start': {
+ file: '_app/immutable/entry/start.HASH.js',
+ name: 'entry/start',
+ src: 'node_modules/.pnpm/@sveltejs+kit@3.0.0_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte@7.3.1_svelte@_6edc02734bfa45cbf85e92e62b52fb36/node_modules/@sveltejs/kit/src/runtime/client/entry.js',
+ isEntry: true,
+ imports: ['entry/payload', 'preload-helper'],
+ dynamicImports: ['client-entry']
+ },
+ 'entry/payload': {
+ file: '_app/immutable/entry/payload.HASH.js',
+ name: 'entry/payload',
+ src: 'node_modules/.pnpm/@sveltejs+kit@3.0.0_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte@7.3.1_svelte@_6edc02734bfa45cbf85e92e62b52fb36/node_modules/@sveltejs/kit/src/runtime/client/payload.js',
+ isEntry: true
+ },
+ negentropy: {
+ file: '_app/immutable/chunks/HASH.js',
+ name: 'negentropy',
+ src: 'node_modules/.pnpm/applesauce-relay@6.2.1_typescript@6.0.3/node_modules/applesauce-relay/dist/negentropy.js',
+ isDynamicEntry: true,
+ imports: ['public-runtime']
+ }
+ });
for (const record of Object.values(manifest)) {
const actual = { ...record };
actual.file = actual.file.includes('/chunks/')