app

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

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:
Mweb/src/lib/nostr/private-publisher.ts | 319+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Mweb/src/lib/nostr/self-recovery-reader.ts | 52+++++++++++++++++++++++++++++++++++++++++++++++++++-
Aweb/src/lib/persistence/inbox-probe-cleanup.ts | 371+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/persistence/inbox-probes.ts | 292+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Mweb/src/lib/persistence/private-storage.ts | 138+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/inbox-probe-cleanup.ts | 614+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/inbox-probe-cleanup.spec.ts | 1859+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/inbox-probe-retry.spec.ts | 7++++++-
Mweb/tests/provenance/output.test.mjs | 8+++++---
Aweb/tests/unit/inbox-probe-cleanup.test.ts | 148+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 466+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
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/')