commit 1bc436861d733b73797ee29a3f8456e0f7315ff5
parent ab68842e98d974d52c8a0169d556efe27d124e02
Author: triesap <tyson@radroots.org>
Date: Wed, 14 Oct 2026 18:14:36 +0000
web: Recover original persisted inbox access probes
- Validate the stored self artifact under fresh exact owner and route bindings
- Keep recovered nonce proofs opaque and revoke them before lifecycle cleanup
- Reject invalid controller associations before passive private session access
- Cover native custody, actual SDK boundaries and browser reload recovery
Diffstat:
8 files changed, 2775 insertions(+), 16 deletions(-)
diff --git a/web/src/lib/messaging/inbox-access-controller.ts b/web/src/lib/messaging/inbox-access-controller.ts
@@ -359,16 +359,16 @@ export function inboxAccessConstructionBinding(
session: PrivateSession,
policy: RelayPolicy
): Readonly<Binding & { session: symbol; current(): boolean }> | undefined {
- const state = controllers.get(token),
- ownership = privateSessionOwnership(session);
+ const state = controllers.get(token);
if (
!state ||
+ state.closed() ||
state.session !== session ||
- state.policy !== policy ||
- !ownership?.current() ||
- !state.current()
+ state.policy !== policy
)
return undefined;
+ const ownership = privateSessionOwnership(session);
+ if (!ownership?.current() || !state.current()) return undefined;
const captured = state.snapshot();
if (
captured.owner !== ownership.owner ||
diff --git a/web/src/lib/nostr/inbox-access.ts b/web/src/lib/nostr/inbox-access.ts
@@ -1,3 +1,6 @@
+import { canonicalPublicKey } from '../contracts/public-key.ts';
+import { exactLocalFields } from '../contracts/local-records.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers';
import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts';
import {
@@ -214,6 +217,10 @@ export async function reserveInboxProbeIdentity(
}
if (!wire || !actorCurrent()) return refuse('stopped');
const rumorHash = (JSON.parse(wire) as { id: string }).id;
+ if (
+ !inboxProbeRumorMatches(wire, owner.owner, rumorHash, createdAt)
+ )
+ return refuse('invalid_record');
const record: PrivateAccessProbe = {
schema: 1,
family: 'private_access_probe',
@@ -372,3 +379,58 @@ export function inboxProbePolicyMatches(
saved.current()
);
}
+
+// Detached inspection only. Actual SDK decryption and original native/current
+// associations are necessary to issue a recovered probe capability.
+export function inboxProbeRumorMatches(
+ raw: unknown,
+ owner: unknown,
+ hash: unknown,
+ createdAt: unknown
+): boolean {
+ const author = canonicalPublicKey(owner);
+ if (
+ !author ||
+ typeof hash !== 'string' ||
+ !/^[0-9a-f]{64}$/.test(hash) ||
+ safeUnsignedInteger(createdAt) === undefined ||
+ typeof raw !== 'string' ||
+ !boundedUtf8(raw, 8192)
+ )
+ return false;
+ try {
+ const rumor: unknown = JSON.parse(raw);
+ if (
+ !exactLocalFields(rumor, [
+ 'id',
+ 'pubkey',
+ 'created_at',
+ 'kind',
+ 'tags',
+ 'content'
+ ]) ||
+ rumor.id !== hash ||
+ rumor.pubkey !== author ||
+ rumor.created_at !== createdAt ||
+ rumor.kind !== 14 ||
+ JSON.stringify(rumor.tags) !== JSON.stringify([['p', author]]) ||
+ typeof rumor.content !== 'string' ||
+ !rumor.content.startsWith(diagnostic) ||
+ !/^[0-9a-f]{64}$/.test(rumor.content.slice(diagnostic.length))
+ )
+ return false;
+ const event: UnsignedEvent = {
+ pubkey: author,
+ created_at: createdAt as number,
+ kind: 14,
+ tags: [['p', author]],
+ content: rumor.content
+ };
+ return (
+ getEventHash(event) === hash &&
+ JSON.stringify({ id: hash, ...event }) === raw
+ );
+ } catch {
+ return false;
+ }
+}
diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts
@@ -12,7 +12,18 @@ import {
inboxProbePublicationBinding,
type InboxProbeAcknowledgement
} from '../persistence/inbox-probes.ts';
-import { inboxProbeRumorWire } from './inbox-access.ts';
+import { inboxProbeRumorWire, inboxProbeRumorMatches } from './inbox-access.ts';
+import {
+ inboxAccessConstructionBinding,
+ subscribeInboxAccessControllerClose,
+ type InboxAccessController
+} from '../messaging/inbox-access-controller.ts';
+import {
+ inboxOperatorQualificationWire,
+ inboxOperatorQualificationSnapshot,
+ type InboxOperatorQualification
+} from '../config/inbox-operators.ts';
+import { readRelayPolicy } from '../config/relays.ts';
import { inboxProbeReadbackMatches } from '../persistence/private-records.ts';
import { ExtensionSigner } from 'applesauce-signers';
import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
@@ -28,13 +39,16 @@ import {
import {
loadPrivateRecord,
observePrivateRecord,
+ privateStorageOwner,
type PrivateStorageRepository,
type PrivateStorageFailure
} from '../persistence/private-storage.ts';
import {
privateRecordSnapshot,
privateRecordWire,
- type PrivateSendOperation
+ type PrivateSendOperation,
+ type PrivateAccessProbe,
+ type PrivateRecordHandle
} from '../persistence/private-records.ts';
import {
verifyEnvelope,
@@ -50,7 +64,7 @@ import {
markExtensionWaitExpired,
type ExtensionAction
} from './extension-scheduler.ts';
-// Module-private strict self-layer SDK engine. Only the two factory-owned reader
+// Module-private strict self-layer SDK engine. Only the factory-owned reader
// scopes below provide ownership/currentness; no caller cipher/event port exists.
function strictSelfDecryptor(
identity: IdentitySession,
@@ -786,3 +800,444 @@ export function inboxProbeNonceProofBinding(
current: () => saved.current()
};
}
+
+declare const probeRecoveryReaderBrand: unique symbol;
+export type InboxProbeRecoveryReader = Readonly<{
+ [probeRecoveryReaderBrand]: true;
+}>;
+declare const recoveredProbeBrand: unique symbol;
+export type RecoveredInboxProbe = Readonly<{ [recoveredProbeBrand]: true }>;
+export type InboxProbeRecoveryResult =
+ | Readonly<{ status: 'recovered'; proof: RecoveredInboxProbe }>
+ | Readonly<{
+ status:
+ | PrivateStorageFailure
+ | 'invalid'
+ | 'stopped'
+ | 'busy'
+ | 'refused'
+ | 'mismatch'
+ | 'lost_evidence';
+ }>;
+type ProbeRecoveryReader = {
+ run(): Promise<InboxProbeRecoveryResult>;
+ stop(expired: boolean): void;
+};
+const recoveryCaptures = new WeakMap<InboxAccessController, true>();
+const recoveryReaders = new WeakMap<
+ InboxProbeRecoveryReader,
+ ProbeRecoveryReader
+>();
+const accessRecoveryReaders = new WeakMap<
+ InboxAccessController,
+ Readonly<{
+ repository: PrivateStorageRepository;
+ identity: IdentitySession;
+ session: PrivateSession;
+ policy: RelayPolicy;
+ operator: InboxOperatorQualification;
+ id: string;
+ reader: InboxProbeRecoveryReader;
+ }>
+>();
+const recoveredProbes = new WeakMap<
+ RecoveredInboxProbe,
+ Readonly<{
+ repository: PrivateStorageRepository;
+ identity: IdentitySession;
+ session: PrivateSession;
+ access: InboxAccessController;
+ policy: RelayPolicy;
+ operator: InboxOperatorQualification;
+ record: PrivateAccessProbe;
+ handle: PrivateRecordHandle;
+ storedWire: string;
+ rumor(): string | undefined;
+ current(): boolean;
+ }>
+>();
+
+// Capture supplies no key, native read or socket. Explicit run decrypts only the
+// stored original under genuine owner/controller/configuration authorization.
+export function captureInboxProbeRecoveryReader(
+ repository: PrivateStorageRepository,
+ identity: IdentitySession,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ access: InboxAccessController,
+ operator: InboxOperatorQualification,
+ localId: unknown,
+ review: unknown
+): InboxProbeRecoveryReader | undefined {
+ if (
+ typeof window === 'undefined' ||
+ review !== 'reviewed_inbox_probe_recovery'
+ )
+ return undefined;
+ if (
+ (typeof access !== 'object' && typeof access !== 'function') ||
+ access === null ||
+ recoveryCaptures.has(access)
+ )
+ return undefined;
+ recoveryCaptures.set(access, true);
+ try {
+ const id = canonicalLocalId(localId),
+ configuredWire = inboxOperatorQualificationWire(operator, policy),
+ manifest = inboxOperatorQualificationSnapshot(operator),
+ owner = privateStorageOwner(repository);
+ if (
+ !id ||
+ !owner ||
+ !configuredWire ||
+ !manifest ||
+ manifest.authority === 'unconfigured'
+ )
+ return undefined;
+ const identityOwner = identityMessagingOwnership(identity);
+ if (!identityOwner?.current() || identityOwner.owner !== owner)
+ return undefined;
+ // The controller's genuine session/policy association is checked before
+ // passive session ownership, including its retained failed-cleanup retry.
+ const metadata = inboxAccessConstructionBinding(access, session, policy);
+ if (
+ !metadata ||
+ metadata.owner !== owner ||
+ !metadata.current() ||
+ ![...metadata.readTargets, ...metadata.archiveTargets].every((origin) => {
+ const row = manifest.relays.find((x) => x.origin === origin);
+ return (
+ row &&
+ row.auth !== 'unsupported' &&
+ row.recipientRead === 'supported' &&
+ row.namedArchiveAck === 'supported' &&
+ row.exactReadback === 'supported' &&
+ row.retention === 'operator_defined'
+ );
+ })
+ )
+ return undefined;
+ if (!identityOwner.current() || identityOwner.session !== metadata.session)
+ return undefined;
+ const privateOwner = privateSessionOwnership(session);
+ if (
+ !privateOwner?.current() ||
+ privateOwner.owner !== owner ||
+ privateOwner.session !== identityOwner.session
+ )
+ return undefined;
+ const previous = accessRecoveryReaders.get(access);
+ if (previous)
+ return previous.repository === repository &&
+ previous.identity === identity &&
+ previous.session === session &&
+ previous.policy === policy &&
+ previous.operator === operator &&
+ previous.id === id
+ ? previous.reader
+ : undefined;
+ const expectedBinding = JSON.stringify({
+ preferenceId: metadata.preferenceId,
+ preferenceCreatedAt: metadata.preferenceCreatedAt,
+ readTargets: metadata.readTargets,
+ archiveTargets: metadata.archiveTargets,
+ policyWire: JSON.stringify(readRelayPolicy(policy)),
+ operatorWire: configuredWire
+ });
+ const token = Object.freeze({}) as InboxProbeRecoveryReader;
+ const operation = Symbol();
+ let stopped = false,
+ consumed = false,
+ pending = false,
+ selectedWire: string | undefined,
+ active: ExtensionAction | undefined,
+ recovered: RecoveredInboxProbe | undefined,
+ rumorWire: string | undefined,
+ last: InboxProbeRecoveryResult | undefined;
+ const listeners = new Map<symbol, () => void>();
+ function current() {
+ if (stopped) return false;
+ const fresh =
+ identityOwner!.current() &&
+ privateOwner!.current() &&
+ inboxAccessConstructionBinding(access, session, policy);
+ const valid =
+ !!fresh &&
+ fresh.current() &&
+ fresh.owner === owner &&
+ fresh.session === identityOwner!.session &&
+ inboxOperatorQualificationWire(operator, policy) === configuredWire &&
+ JSON.stringify({
+ preferenceId: fresh.preferenceId,
+ preferenceCreatedAt: fresh.preferenceCreatedAt,
+ readTargets: fresh.readTargets,
+ archiveTargets: fresh.archiveTargets,
+ policyWire: JSON.stringify(readRelayPolicy(policy)),
+ operatorWire: configuredWire
+ }) === expectedBinding;
+ if (!valid) stop(false);
+ return valid && !stopped;
+ }
+ function stop(expired: boolean) {
+ stopped = true;
+ rumorWire = undefined;
+ if (recovered) recoveredProbes.delete(recovered);
+ recovered = undefined;
+ if (active) {
+ if (expired) markExtensionWaitExpired(active);
+ else stopExtensionAction(active);
+ }
+ for (const [id, off] of listeners) {
+ off();
+ listeners.delete(id);
+ }
+ }
+ function retain(register: () => () => void) {
+ const off = register();
+ if (stopped) off();
+ else listeners.set(Symbol(), off);
+ }
+ const decryptor = strictSelfDecryptor(identity, owner, current);
+ async function run(): Promise<InboxProbeRecoveryResult> {
+ if (!current()) {
+ stop(false);
+ return { status: 'stopped' };
+ }
+ if (pending) return { status: 'busy' };
+ if (consumed) return last ?? { status: 'stopped' };
+ pending = true;
+ try {
+ if (!navigator.locks?.request)
+ return (last = { status: 'unavailable' });
+ last = await navigator.locks.request(
+ 'harvestcircle:owner:' + owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock): Promise<InboxProbeRecoveryResult> => {
+ if (!lock) return { status: 'busy' };
+ if (!current()) return { status: 'stopped' };
+ const loaded = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!loaded.ok)
+ return {
+ status:
+ loaded.reason === 'invalid_record'
+ ? 'lost_evidence'
+ : loaded.reason
+ };
+ const record = privateRecordSnapshot(
+ loaded.value.handle,
+ owner,
+ id
+ ),
+ storedWire = loaded.value.wire;
+ if (selectedWire !== undefined && selectedWire !== storedWire)
+ return { status: 'conflict' };
+ if (!record || record.family !== 'private_access_probe')
+ return { status: 'invalid_scope' };
+ if (!record.self || record.revision === 0)
+ return { status: 'lost_evidence' };
+ if (
+ privateRecordWire(loaded.value.handle, owner, id) !==
+ storedWire ||
+ JSON.stringify(record.binding) !== expectedBinding
+ )
+ return { status: 'conflict' };
+ const checked = verifyEnvelope(record.self.wire),
+ outer = checked.ok && verifiedEnvelopeSnapshot(checked.value);
+ if (
+ !outer ||
+ outer.kind !== 1059 ||
+ outer.id !== record.self.eventId ||
+ JSON.stringify(outer.tags) !== JSON.stringify([['p', owner]]) ||
+ !exactLocalFields(outer, [
+ 'id',
+ 'pubkey',
+ 'created_at',
+ 'kind',
+ 'tags',
+ 'content',
+ 'sig'
+ ]) ||
+ !sealCiphertextV2(outer.content)
+ )
+ return { status: 'mismatch' };
+ selectedWire ??= storedWire;
+ const scheduler = browserExtensionScheduler();
+ if (!scheduler) return { status: 'unavailable' };
+ const result = await runExtensionAction<InboxProbeRecoveryResult>(
+ scheduler,
+ {
+ owner: identityOwner!.owner,
+ session: identityOwner!.session,
+ operation
+ },
+ current,
+ async (action): Promise<InboxProbeRecoveryResult> => {
+ consumed = true;
+ active = action;
+ const opened = await decryptor.open(action, outer);
+ if (!current()) return { status: 'stopped' };
+ if (opened.status !== 'opened') return opened;
+ if (
+ !inboxProbeRumorMatches(
+ opened.rumorWire,
+ owner,
+ record.rumorHash,
+ record.createdAt
+ )
+ )
+ return { status: 'mismatch' };
+ // No callback-capable provider work follows this last fresh-key
+ // step. Final complete native physical read precedes proof mint.
+ if (!(await decryptor.fresh(action)))
+ return { status: 'stopped' };
+ const after = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!after.ok) return { status: after.reason };
+ if (
+ after.value.wire !== storedWire ||
+ privateRecordWire(after.value.handle, owner, id) !==
+ storedWire
+ )
+ return { status: 'conflict' };
+ rumorWire = opened.rumorWire;
+ const proof = Object.freeze({}) as RecoveredInboxProbe;
+ recoveredProbes.set(proof, {
+ repository,
+ identity,
+ session,
+ access,
+ policy,
+ operator,
+ record,
+ handle: after.value.handle,
+ storedWire,
+ rumor: () => (current() ? rumorWire : undefined),
+ current
+ });
+ recovered = proof;
+ return { status: 'recovered', proof };
+ }
+ );
+ if (!current()) {
+ stop(false);
+ return { status: 'stopped' };
+ }
+ if (result.status === 'busy') return { status: 'busy' };
+ return result.status === 'completed' &&
+ 'value' in result &&
+ result.value
+ ? result.value
+ : { status: result.status === 'denied' ? 'refused' : 'stopped' };
+ }
+ );
+ return last;
+ } catch {
+ return (last = { status: current() ? 'refused' : 'stopped' });
+ } finally {
+ active = undefined;
+ pending = false;
+ }
+ }
+ recoveryReaders.set(token, { run, stop });
+ accessRecoveryReaders.set(access, {
+ repository,
+ identity,
+ session,
+ policy,
+ operator,
+ id,
+ reader: token
+ });
+ retain(() =>
+ subscribeIdentityInvalidation(identity, () => {
+ if (!identityOwner.current()) stop(false);
+ })
+ );
+ retain(() => subscribePrivateSessionClose(session, () => stop(false)));
+ retain(() =>
+ subscribeInboxAccessControllerClose(access, () => stop(false))
+ );
+ return current() ? token : undefined;
+ } catch {
+ return undefined;
+ } finally {
+ recoveryCaptures.delete(access);
+ }
+}
+export function recoverInboxProbe(
+ reader: InboxProbeRecoveryReader
+): Promise<InboxProbeRecoveryResult> {
+ return (
+ recoveryReaders.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' })
+ );
+}
+export function stopInboxProbeRecoveryReader(reader: InboxProbeRecoveryReader) {
+ recoveryReaders.get(reader)?.stop(false);
+}
+export function expireInboxProbeRecoveryReaderWait(
+ reader: InboxProbeRecoveryReader
+) {
+ recoveryReaders.get(reader)?.stop(true);
+}
+// Metadata and strong original associations only, not live native/network
+// authority. Later effect owners must independently reread exact physical wire.
+export function recoveredInboxProbeBinding(
+ proof: RecoveredInboxProbe,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ access: InboxAccessController,
+ policy: RelayPolicy,
+ operator: InboxOperatorQualification
+) {
+ const saved = recoveredProbes.get(proof);
+ if (
+ !saved ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ saved.access !== access ||
+ saved.policy !== policy ||
+ saved.operator !== operator ||
+ !saved.current() ||
+ !saved.rumor()
+ )
+ return undefined;
+ return {
+ owner: saved.record.owner,
+ command: saved.record.id,
+ rumorHash: saved.record.rumorHash,
+ eventId: saved.record.self!.eventId,
+ handle: saved.handle,
+ storedWire: saved.storedWire,
+ current: () => saved.current() && !!saved.rumor()
+ };
+}
+// Only genuine recovered proof and exact current original scope can expose the
+// private original rumor to a later separate source-owned probe admission.
+export function recoveredInboxProbeRumorWire(
+ proof: RecoveredInboxProbe,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ access: InboxAccessController,
+ policy: RelayPolicy,
+ operator: InboxOperatorQualification
+): string | undefined {
+ return recoveredInboxProbeBinding(
+ proof,
+ repository,
+ session,
+ access,
+ policy,
+ operator
+ )
+ ? recoveredProbes.get(proof)?.rumor()
+ : undefined;
+}
diff --git a/web/tests/e2e/harness/inbox-probe-recovery.ts b/web/tests/e2e/harness/inbox-probe-recovery.ts
@@ -0,0 +1,762 @@
+import { makeFixture as makeCryptoFixture } from './approved-signing.ts';
+import {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ disconnectIdentity
+} from '../../../src/lib/runtime/identity-session.ts';
+import {
+ createPrivateSession,
+ closePrivateSession
+} from '../../../src/lib/runtime/private-session.ts';
+import {
+ createPublicRuntimeContext,
+ mountPublicRuntime,
+ closePublicRuntime,
+ createPublicView,
+ beginPublicViewRun,
+ disposePublicView
+} from '../../../src/lib/runtime/public-runtime.ts';
+import {
+ resolveInboxPreference,
+ settleInboxResolver
+} from '../../../src/lib/messaging/resolve-inbox.ts';
+import {
+ createInboxAccessController,
+ closeInboxAccessController
+} from '../../../src/lib/messaging/inbox-access-controller.ts';
+import {
+ openBrowserDatabase,
+ closeBrowserDatabase,
+ browserDatabaseTransaction
+} from '../../../src/lib/persistence/database.ts';
+import { createPrivateStorageRepository } from '../../../src/lib/persistence/private-storage.ts';
+import {
+ captureInboxProbeRecoveryReader,
+ recoverInboxProbe,
+ recoveredInboxProbeBinding,
+ stopInboxProbeRecoveryReader,
+ type InboxProbeRecoveryReader,
+ type RecoveredInboxProbe
+} from '../../../src/lib/nostr/self-recovery-reader.ts';
+import {
+ reserveInboxProbeIdentity,
+ inboxProbeSnapshot
+} from '../../../src/lib/nostr/inbox-access.ts';
+import {
+ captureInboxProbeSealOperation,
+ buildInboxProbeSeal
+} from '../../../src/lib/nostr/seal-builder.ts';
+import { buildInboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts';
+import {
+ commitInboxProbe,
+ inboxProbeAcknowledgementSnapshot,
+ commitInboxProbeArchiveAttempt,
+ commitInboxProbeReadbackAttempt,
+ type InboxProbeAcknowledgement
+} from '../../../src/lib/persistence/inbox-probes.ts';
+import {
+ getPrivatePool,
+ closePrivatePool,
+ publishInboxProbeArchiveAttempt,
+ readInboxProbeAttempt,
+ type PrivatePool,
+ type InboxProbeArchiveAttemptResult,
+ type InboxProbeReadbackAttemptResult
+} from '../../../src/lib/nostr/private-pool.ts';
+import {
+ captureInboxProbePublicationAction,
+ captureInboxProbePublication,
+ captureInboxProbeReadback,
+ type InboxProbePublicationAction
+} from '../../../src/lib/nostr/private-publisher.ts';
+import {
+ captureInboxProbeNonceReader,
+ readInboxProbeNonce,
+ stopInboxProbeNonceReader,
+ type InboxProbeNonceReader
+} from '../../../src/lib/nostr/self-recovery-reader.ts';
+import type { InboxProbeIdentity } from '../../../src/lib/nostr/inbox-access.ts';
+import type { InboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts';
+import {
+ readRelayPolicy,
+ validateRelayPolicy,
+ type RelayPolicy
+} from '../../../src/lib/config/relays.ts';
+import {
+ inboxOperatorQualificationWire,
+ validateInboxOperatorQualification,
+ type InboxOperatorQualification
+} from '../../../src/lib/config/inbox-operators.ts';
+import type { UnsignedEvent } from 'applesauce-core/helpers';
+export * from './inbox-probe-nonce.ts';
+export {
+ readRelayPolicy,
+ validateRelayPolicy,
+ inboxOperatorQualificationWire,
+ validateInboxOperatorQualification
+};
+
+// All actors are actual source factories. The emulated extension may outlive a
+// product realm, as a real extension does; no secret leaves its test closure.
+function createRecoveryPublicScope(policy: RelayPolicy) {
+ const context = createPublicRuntimeContext(),
+ runtime = mountPublicRuntime(context, policy);
+ if (!runtime) throw Error('actual public discovery scope');
+ return { context, runtime };
+}
+export async function openRecoveryContext(
+ owner: string,
+ policy: RelayPolicy,
+ operator: InboxOperatorQualification,
+ localId: string,
+ shared?: ReturnType<typeof createRecoveryPublicScope>
+) {
+ const identity = createIdentitySession();
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ const session = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ const opened = await openBrowserDatabase();
+ if (!session || opened.state !== 'ready')
+ throw Error('fresh actual recovery actors');
+ const repository = createPrivateStorageRepository(opened.owner, owner);
+ if (!repository) throw Error('actual original native namespace');
+ const { context, runtime } = shared ?? createRecoveryPublicScope(policy);
+ const view = createPublicView(runtime),
+ run = beginPublicViewRun(view),
+ resolver = resolveInboxPreference(view, run, owner);
+ await settleInboxResolver(resolver);
+ const access = createInboxAccessController(session, policy, resolver);
+ if (!access) throw Error('fresh actual recovery controller');
+ let selected: InboxProbeRecoveryReader | undefined,
+ proof: RecoveredInboxProbe | undefined;
+ function capture(
+ review: unknown = 'reviewed_inbox_probe_recovery',
+ id: unknown = localId
+ ) {
+ return captureInboxProbeRecoveryReader(
+ repository!,
+ identity,
+ session!,
+ policy,
+ access!,
+ operator,
+ id,
+ review
+ );
+ }
+ return {
+ owner,
+ identity,
+ session,
+ repository,
+ policy,
+ operator,
+ access,
+ localId,
+ capture,
+ reader: () => selected,
+ proof: () => proof,
+ binding: () =>
+ proof &&
+ recoveredInboxProbeBinding(
+ proof,
+ repository,
+ session,
+ access,
+ policy,
+ operator
+ ),
+ async recover(reader = (selected ??= capture())) {
+ if (!reader) return { status: 'invalid' as const };
+ selected ??= reader;
+ const result = await recoverInboxProbe(reader);
+ if ('proof' in result) proof = result.proof;
+ return result;
+ },
+ churnHead: () => beginPublicViewRun(view),
+ close() {
+ if (selected) stopInboxProbeRecoveryReader(selected);
+ closeInboxAccessController(access);
+ closePrivateSession(session);
+ disconnectIdentity(identity);
+ disposePublicView(view);
+ if (!shared) closePublicRuntime(context);
+ closeBrowserDatabase(opened.owner);
+ }
+ };
+}
+export async function makeRecoveryFixture() {
+ const host = createHostedProvider();
+ const opened = await openBrowserDatabase();
+ if (opened.state !== 'ready') throw Error('actual original native database');
+ const database = opened.owner,
+ repository = createPrivateStorageRepository(database, host.owner);
+ if (!repository) throw Error('actual original native namespace');
+ const policy = validateRelayPolicy(
+ JSON.stringify({
+ schemaVersion: 1,
+ public: [
+ {
+ origin: 'wss://discovery.example.org',
+ read: true,
+ write: true,
+ nip50: false
+ }
+ ],
+ inbox: [
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ].map((origin) => ({ origin, read: true, write: true })),
+ postingEnabled: true,
+ messagingEnabled: true,
+ operatorDenylist: []
+ })
+ );
+ if (!policy) throw Error('actual fixture policy');
+ function operator(unsupported = false, unconfigured = false) {
+ const result = validateInboxOperatorQualification(
+ JSON.stringify({
+ schemaVersion: 1,
+ revision: 1,
+ authority: unconfigured ? 'unconfigured' : 'source_fixture',
+ policyWire: JSON.stringify(readRelayPolicy(policy!)),
+ evidenceSha256: unconfigured ? null : 'a'.repeat(64),
+ relays: unconfigured
+ ? []
+ : readRelayPolicy(policy!).inbox.map(({ origin }) => ({
+ origin,
+ auth: 'not_required',
+ recipientRead: 'supported',
+ namedArchiveAck: 'supported',
+ exactReadback: unsupported ? 'unsupported' : 'supported',
+ retention: 'operator_defined'
+ }))
+ })
+ );
+ if (!result) throw Error('source-labelled supported operator fixture');
+ return result;
+ }
+ const qualification = operator();
+ let publicOwner: ReturnType<typeof createRecoveryPublicScope> | undefined,
+ original: Awaited<ReturnType<typeof openRecoveryContext>> | undefined,
+ recovery: Awaited<ReturnType<typeof openRecoveryContext>> | undefined;
+ let originalId: string | undefined;
+ let probe: InboxProbeIdentity | undefined,
+ wrap: InboxProbeGiftwrap | undefined,
+ acknowledgement: InboxProbeAcknowledgement | undefined,
+ action: InboxProbePublicationAction | undefined,
+ pool: PrivatePool | undefined,
+ lastRead: InboxProbeReadbackAttemptResult | undefined,
+ nonceReader: InboxProbeNonceReader | undefined;
+ function context() {
+ if (!original) throw Error('actual original context missing');
+ return original;
+ }
+ function acquire() {
+ const r = context();
+ pool ??= getPrivatePool(
+ r.session,
+ policy!,
+ ['wss://inbox.example.org'],
+ Object.freeze({}),
+ 'access'
+ );
+ if (!pool) throw Error('actual original probe pool');
+ return pool;
+ }
+ return {
+ ...host,
+ repository,
+ policy,
+ qualification,
+ operator,
+ get identity() {
+ return context().identity;
+ },
+ get session() {
+ return context().session;
+ },
+ controller: () => original?.access,
+ probeIdentity: () => probe,
+ async capture() {
+ publicOwner ??= createRecoveryPublicScope(policy);
+ original ??= await openRecoveryContext(
+ host.owner,
+ policy,
+ qualification,
+ crypto.randomUUID(),
+ publicOwner
+ );
+ return original.access;
+ },
+ async reserve() {
+ const r = context(),
+ result = await reserveInboxProbeIdentity(
+ repository,
+ r.session,
+ policy,
+ r.access,
+ qualification,
+ 'reviewed_inbox_probe_reservation'
+ );
+ if ('identity' in result) {
+ probe = result.identity;
+ originalId = inboxProbeSnapshot(probe)?.id;
+ if (!originalId)
+ throw Error('genuine reserved command metadata missing');
+ }
+ return result;
+ },
+ async prepare() {
+ const r = context();
+ if (!probe) throw Error('actual R0 missing');
+ const operation = captureInboxProbeSealOperation(
+ r.session,
+ probe,
+ 'reviewed_inbox_probe_seal'
+ );
+ if (!operation) throw Error('actual seal admission');
+ const result = await buildInboxProbeSeal(operation);
+ if (!('seal' in result)) return result.status;
+ wrap = buildInboxProbeGiftwrap(result.seal, 'reviewed_inbox_probe_wrap');
+ return wrap ? 'wrapped' : 'invalid';
+ },
+ async commitOriginal() {
+ if (!wrap) throw Error('actual original wrap missing');
+ const result = await commitInboxProbe(
+ repository,
+ context().session,
+ wrap,
+ 'reviewed_inbox_probe_commit'
+ );
+ if ('acknowledgement' in result) acknowledgement = result.acknowledgement;
+ return result;
+ },
+ snapshot: () =>
+ acknowledgement && inboxProbeAcknowledgementSnapshot(acknowledgement),
+ async publish() {
+ const r = context();
+ if (!acknowledgement) throw Error('actual original ACK missing');
+ action ??= captureInboxProbePublicationAction(
+ repository,
+ r.session,
+ policy,
+ acknowledgement,
+ 'reviewed_inbox_probe_network'
+ );
+ const permission =
+ action &&
+ captureInboxProbePublication(
+ repository,
+ r.session,
+ policy,
+ acknowledgement,
+ action,
+ 'wss://inbox.example.org',
+ 'reviewed_inbox_probe_publication'
+ );
+ if (!permission) throw Error('actual original PUB admission');
+ return publishInboxProbeArchiveAttempt(
+ acquire(),
+ permission,
+ new AbortController().signal
+ );
+ },
+ append: (result: InboxProbeArchiveAttemptResult) =>
+ commitInboxProbeArchiveAttempt(repository, result),
+ async read() {
+ const r = context();
+ if (!acknowledgement || !action)
+ throw Error('actual original PUB action missing');
+ const permission = captureInboxProbeReadback(
+ repository,
+ r.session,
+ policy,
+ acknowledgement,
+ action,
+ 'wss://inbox.example.org',
+ 'reviewed_inbox_probe_readback'
+ );
+ if (!permission) throw Error('actual original read admission');
+ return (lastRead = await readInboxProbeAttempt(
+ acquire(),
+ permission,
+ new AbortController().signal
+ ));
+ },
+ appendRead: (result: InboxProbeReadbackAttemptResult) =>
+ commitInboxProbeReadbackAttempt(repository, result),
+ nonceCapture() {
+ const r = context();
+ return (
+ lastRead &&
+ captureInboxProbeNonceReader(
+ repository,
+ r.identity,
+ r.session,
+ policy,
+ lastRead,
+ 'reviewed_inbox_probe_nonce_decryption'
+ )
+ );
+ },
+ async nonce() {
+ const r = context();
+ nonceReader ??=
+ lastRead &&
+ captureInboxProbeNonceReader(
+ repository,
+ r.identity,
+ r.session,
+ policy,
+ lastRead,
+ 'reviewed_inbox_probe_nonce_decryption'
+ );
+ return nonceReader
+ ? readInboxProbeNonce(nonceReader)
+ : { status: 'invalid' as const };
+ },
+ nonceReader: () => nonceReader,
+ foreignRepository() {
+ const fixture = makeCryptoFixture();
+ const other = createPrivateStorageRepository(database, fixture.owner);
+ fixture.close();
+ if (!other) throw Error('actual other namespace');
+ return other;
+ },
+ copiedPolicy() {
+ const other = validateRelayPolicy(
+ JSON.stringify(readRelayPolicy(policy))
+ );
+ if (!other) throw Error('actual copied policy');
+ return other;
+ },
+ async stored() {
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readonly'
+ ),
+ request = tx.objectStore('private_sends').getAll();
+ return new Promise<{ owner: string; id: string; wire: string }[]>(
+ (resolve, reject) => {
+ tx.addEventListener('complete', () =>
+ resolve(
+ request.result as { owner: string; id: string; wire: string }[]
+ )
+ );
+ tx.addEventListener('abort', () =>
+ reject(Error('actual fixture read abort'))
+ );
+ }
+ );
+ },
+ async inject(rows: { owner: string; id: string; wire: string }[]) {
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readwrite'
+ );
+ for (const row of rows) tx.objectStore('private_sends').put(row);
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('actual fixture write abort'))
+ );
+ });
+ },
+ async removeOriginal() {
+ if (!originalId) throw Error('original command metadata missing');
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readwrite'
+ );
+ tx.objectStore('private_sends').delete([host.owner, originalId]);
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('actual native deletion abort'))
+ );
+ });
+ },
+ async fresh() {
+ // Recovery explicitly permits expired original memory authority. Only the
+ // original genuine reserved ID survives as inert selection metadata.
+ if (!originalId) throw Error('original command metadata missing');
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readonly'
+ );
+ const request = tx
+ .objectStore('private_sends')
+ .get([host.owner, originalId]);
+ const row = await new Promise<unknown>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve(request.result));
+ tx.addEventListener('abort', () =>
+ reject(Error('actual original selection abort'))
+ );
+ });
+ if (!row) throw Error('stored original selection missing');
+ if (pool) closePrivatePool(pool);
+ original!.close();
+ if (inboxProbeSnapshot(probe!)) throw Error('old nonce still visible');
+ recovery = await openRecoveryContext(
+ host.owner,
+ policy,
+ qualification,
+ originalId,
+ publicOwner
+ );
+ return recovery;
+ },
+ close() {
+ if (nonceReader) stopInboxProbeNonceReader(nonceReader);
+ if (pool) closePrivatePool(pool);
+ recovery?.close();
+ original?.close();
+ if (publicOwner) closePublicRuntime(publicOwner.context);
+ closeBrowserDatabase(database);
+ host.close();
+ }
+ };
+}
+
+// A parent-realm test extension host supports actual child-frame destruction and
+// reload without persisting/exposing its random key. It is controlled evidence,
+// not installed-extension or operator qualification.
+export function createHostedProvider() {
+ const cryptoFixture = makeCryptoFixture(10050);
+ let keys = 0,
+ signs = 0,
+ encrypts = 0,
+ decrypts = 0,
+ mode:
+ | 'normal'
+ | 'hold_key'
+ | 'hold_decrypt'
+ | 'wrong_key'
+ | 'refuse_decrypt'
+ | 'wrong_decrypt' = 'normal',
+ waiting = '',
+ release: (() => void) | undefined;
+ const restorations = new Map<symbol, () => void>();
+ function retain(off: () => void) {
+ const id = Symbol();
+ restorations.set(id, off);
+ return () => {
+ off();
+ restorations.delete(id);
+ };
+ }
+ async function pause(stage: string) {
+ if (mode !== 'hold_' + stage) return;
+ waiting = stage;
+ await new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ waiting = '';
+ release = undefined;
+ }
+ const cipher = {
+ encrypt: (target: string, wire: string) => {
+ encrypts++;
+ return Promise.resolve(cryptoFixture.encrypt(target, wire));
+ },
+ decrypt: async (target: string, wire: string) => {
+ decrypts++;
+ await pause('decrypt');
+ if (mode === 'refuse_decrypt')
+ throw Error('controlled actual provider refusal');
+ return mode === 'wrong_decrypt'
+ ? 'substituted plaintext'
+ : cryptoFixture.decrypt(target, wire);
+ }
+ };
+ const provider = {
+ getPublicKey: async () => {
+ keys++;
+ await pause('key');
+ return mode === 'wrong_key' ? 'f'.repeat(64) : cryptoFixture.owner;
+ },
+ signEvent: (input: UnsignedEvent) => {
+ signs++;
+ return Promise.resolve(cryptoFixture.sign(input));
+ },
+ nip44: cipher
+ };
+ Object.defineProperty(window, 'nostr', {
+ configurable: true,
+ value: provider
+ });
+ return {
+ owner: cryptoFixture.owner,
+ preferenceWire: (origins: string[]) =>
+ JSON.stringify(
+ cryptoFixture.sign({
+ kind: 10050,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: origins.map((origin) => ['relay', origin]),
+ content: ''
+ })
+ ),
+ head: () =>
+ JSON.stringify(
+ cryptoFixture.sign({
+ kind: 10050,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: [['relay', 'wss://inbox.example.org']],
+ content: ''
+ })
+ ),
+ counts: () => ({ keys, signs, encrypts, decrypts }),
+ mode: (next: typeof mode) => {
+ mode = next;
+ },
+ waiting: () => waiting,
+ settle: () => release?.(),
+ keyCallback(hit: number, callback: () => void | Promise<void>) {
+ const original = provider.getPublicKey.bind(provider);
+ let n = 0;
+ provider.getPublicKey = async () => {
+ if (++n === hit) await callback();
+ return original();
+ };
+ return retain(() => {
+ provider.getPublicKey = original;
+ });
+ },
+ cipherGetter(callback: () => void) {
+ const descriptor = Object.getOwnPropertyDescriptor(provider, 'nip44')!;
+ Object.defineProperty(provider, 'nip44', {
+ configurable: true,
+ get() {
+ callback();
+ return cipher;
+ }
+ });
+ return retain(() => {
+ Object.defineProperty(provider, 'nip44', descriptor);
+ });
+ },
+ decryptCallback(
+ hit: number,
+ transform: (wire: string) => string | Promise<string>
+ ) {
+ const original = cipher.decrypt.bind(cipher),
+ descriptor = Object.getOwnPropertyDescriptor(cipher, 'decrypt')!;
+ let n = 0,
+ receivers = 0;
+ Object.defineProperty(cipher, 'decrypt', {
+ configurable: true,
+ value: async function (
+ this: typeof cipher,
+ target: string,
+ wire: string
+ ) {
+ if (this !== cipher) throw Error('wrong actual SDK cipher receiver');
+ receivers++;
+ const opened = await original(target, wire);
+ return ++n === hit ? transform(opened) : opened;
+ }
+ });
+ return {
+ receivers: () => receivers,
+ restore: retain(() => {
+ Object.defineProperty(cipher, 'decrypt', descriptor);
+ })
+ };
+ },
+ signSeal(wire: string, change: Record<string, unknown>) {
+ const seal = JSON.parse(wire) as UnsignedEvent;
+ return JSON.stringify(
+ cryptoFixture.sign({
+ kind: seal.kind,
+ created_at: seal.created_at,
+ tags: seal.tags,
+ content: seal.content,
+ ...change
+ })
+ );
+ },
+ close() {
+ for (const [id, off] of restorations) {
+ off();
+ restorations.delete(id);
+ }
+ cryptoFixture.close();
+ }
+ };
+}
+
+// Extension messages return data in the requesting document's realm. Direct
+// parent objects fail the stock SDK's instanceof-Object event admission. Clone
+// only the signed public event response; account key custody stays in the host.
+export function installHostedProvider() {
+ type Port = {
+ getPublicKey(): Promise<string>;
+ signEvent(input: UnsignedEvent): Promise<Record<string, unknown>>;
+ nip44: {
+ encrypt(target: string, wire: string): Promise<string>;
+ decrypt(target: string, wire: string): Promise<string>;
+ };
+ };
+ const host = Reflect.get(window.parent, 'nostr') as Port;
+ const cipher = host.nip44;
+ Object.defineProperty(window, 'nostr', {
+ configurable: true,
+ value: {
+ getPublicKey: host.getPublicKey.bind(host),
+ signEvent: async (input: UnsignedEvent) => {
+ const signed = await host.signEvent(input);
+ return JSON.parse(JSON.stringify(signed)) as Record<string, unknown>;
+ },
+ nip44: {
+ encrypt: cipher.encrypt.bind(cipher),
+ decrypt: cipher.decrypt.bind(cipher)
+ }
+ }
+ });
+}
+
+export async function prepareHostedOriginal(
+ context: Awaited<ReturnType<typeof openRecoveryContext>>
+) {
+ const { repository, session, policy, access, operator } = context;
+ const reserved = await reserveInboxProbeIdentity(
+ repository,
+ session,
+ policy,
+ access,
+ operator,
+ 'reviewed_inbox_probe_reservation'
+ );
+ if (!('identity' in reserved)) throw Error('actual hosted R0');
+ const operation = captureInboxProbeSealOperation(
+ session,
+ reserved.identity,
+ 'reviewed_inbox_probe_seal'
+ );
+ if (!operation) throw Error('actual hosted seal operation');
+ const sealed = await buildInboxProbeSeal(operation);
+ if (!('seal' in sealed)) throw Error('actual hosted seal');
+ const wrapped = buildInboxProbeGiftwrap(
+ sealed.seal,
+ 'reviewed_inbox_probe_wrap'
+ );
+ if (!wrapped) throw Error('actual hosted wrap');
+ const committed = await commitInboxProbe(
+ repository,
+ session,
+ wrapped,
+ 'reviewed_inbox_probe_commit'
+ );
+ if (!('acknowledgement' in committed)) throw Error('actual hosted native R1');
+ return inboxProbeAcknowledgementSnapshot(committed.acknowledgement)!.record;
+}
diff --git a/web/tests/e2e/inbox-probe-recovery.spec.ts b/web/tests/e2e/inbox-probe-recovery.spec.ts
@@ -0,0 +1,1306 @@
+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-recovery.ts';
+declare global {
+ interface Window {
+ pr: typeof Fixture;
+ prFixture: Awaited<ReturnType<typeof Fixture.makeRecoveryFixture>>;
+ prFresh: Awaited<ReturnType<typeof Fixture.openRecoveryContext>>;
+ prPending?: Promise<unknown>;
+ prRelease?: () => void;
+ prRestore?: () => void;
+ prHosted?: ReturnType<typeof Fixture.createHostedProvider>;
+ prHostedContext?: Awaited<ReturnType<typeof Fixture.openRecoveryContext>>;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string,
+ head = '';
+const physical = new Set<WebSocket>(),
+ archived = new Map<string, Record<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 fixture');
+ 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'
+ )!;
+ socket.on('message', (bytes) => {
+ const raw = Buffer.isBuffer(bytes)
+ ? bytes
+ : Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.from(bytes);
+ const frame = JSON.parse(raw.toString()) as unknown[];
+ 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)) {
+ const event = archived.get(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 };
+ archived.set(event.id, event);
+ socket.send(JSON.stringify(['OK', event.id, true, '']));
+ }
+ });
+ });
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/inbox-probe-recovery.ts', import.meta.url)
+ ),
+ name: 'pr',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('compiled actual source fixture');
+ 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);
+ head = '';
+ frames.length = 0;
+ archived.clear();
+ await page.addInitScript(
+ ({ endpoint }) => {
+ 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',
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ].includes(origin)
+ )
+ throw Error('unapproved fixture origin');
+ super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
+ }
+ };
+ },
+ { endpoint }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ head = await page.evaluate(async () => {
+ window.prFixture = await window.pr.makeRecoveryFixture();
+ return window.prFixture.preferenceWire(['wss://inbox.example.org']);
+ });
+ await page.evaluate(async () => {
+ const f = window.prFixture;
+ await f.capture();
+ if (
+ (await f.reserve()).status !== 'reserved' ||
+ (await f.prepare()) !== 'wrapped' ||
+ (await f.commitOriginal()).status !== 'prepared'
+ )
+ throw Error('actual cold stored original');
+ });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(() => {
+ window.prRestore?.();
+ window.prRelease?.();
+ window.prHostedContext?.close();
+ window.prHosted?.close();
+ window.prFixture.close();
+ });
+});
+async function fresh(page: Page) {
+ await page.evaluate(async () => {
+ window.prFresh = await window.prFixture.fresh();
+ });
+}
+function privateFrames() {
+ return frames.filter((x) => x.origin !== 'wss://discovery.example.org');
+}
+async function originalReadback(page: Page) {
+ await page.evaluate(async () => {
+ const f = window.prFixture,
+ publication = await f.publish();
+ if (
+ publication.status !== 'accepted' ||
+ (await f.append(publication)).status !== 'saved'
+ )
+ throw Error('actual original B1');
+ const readback = await f.read();
+ if (
+ readback.status !== 'readback' ||
+ (await f.appendRead(readback)).status !== 'saved'
+ )
+ throw Error('actual original B2');
+ });
+}
+test('genuine ordinary and C1 readers/proofs cannot cross into recovered-probe families', async ({
+ page
+}) => {
+ await originalReadback(page);
+ const result = await page.evaluate(async () => {
+ const f = window.prFixture,
+ nonce = await f.nonce();
+ if (!('proof' in nonce)) throw Error('genuine current C1 proof');
+ const id = f.snapshot()!.record.id;
+ const ordinary = window.pr.captureSelfRecoveryReader(
+ f.repository,
+ f.identity,
+ id,
+ 'reviewed_self_decryption'
+ )!;
+ const recovery = window.pr.captureInboxProbeRecoveryReader(
+ f.repository,
+ f.identity,
+ f.session,
+ f.policy,
+ f.controller()!,
+ f.qualification,
+ id,
+ 'reviewed_inbox_probe_recovery'
+ )!;
+ const before = f.counts();
+ const c1Reader = await window.pr.recoverInboxProbe(
+ f.nonceReader()! as unknown as Parameters<
+ typeof window.pr.recoverInboxProbe
+ >[0]
+ );
+ const ordinaryReader = await window.pr.recoverInboxProbe(
+ ordinary as unknown as Parameters<typeof window.pr.recoverInboxProbe>[0]
+ );
+ const c1Proof = window.pr.recoveredInboxProbeBinding(
+ nonce.proof as unknown as Parameters<
+ typeof window.pr.recoveredInboxProbeBinding
+ >[0],
+ f.repository,
+ f.session,
+ f.controller()!,
+ f.policy,
+ f.qualification
+ );
+ const noEffects = JSON.stringify(before) === JSON.stringify(f.counts());
+ const recovered = await window.pr.recoverInboxProbe(recovery);
+ const wrongC1 = await window.pr.readInboxProbeNonce(
+ recovery as unknown as Parameters<typeof window.pr.readInboxProbeNonce>[0]
+ );
+ return {
+ ordinaryGenuine: !!ordinary,
+ c1Reader,
+ ordinaryReader,
+ c1Proof: !!c1Proof,
+ noEffects,
+ recovery: recovered.status,
+ wrongC1
+ };
+ });
+ expect(result).toEqual({
+ ordinaryGenuine: true,
+ c1Reader: { status: 'invalid' },
+ ordinaryReader: { status: 'invalid' },
+ c1Proof: false,
+ noEffects: true,
+ recovery: 'recovered',
+ wrongC1: { status: 'invalid' }
+ });
+});
+test('genuine current C1 memory proof cannot replace actual original stored ciphertext decryption', async ({
+ page
+}) => {
+ await originalReadback(page);
+ const result = await page.evaluate(async () => {
+ const f = window.prFixture,
+ nonce = await f.nonce();
+ if (!('proof' in nonce)) throw Error('genuine current C1 proof');
+ const reader = window.pr.captureInboxProbeRecoveryReader(
+ f.repository,
+ f.identity,
+ f.session,
+ f.policy,
+ f.controller()!,
+ f.qualification,
+ f.snapshot()!.record.id,
+ 'reviewed_inbox_probe_recovery'
+ )!;
+ f.mode('wrong_decrypt');
+ const before = await f.stored(),
+ result = await window.pr.recoverInboxProbe(reader);
+ return {
+ status: result.status,
+ same: JSON.stringify(before) === JSON.stringify(await f.stored())
+ };
+ });
+ expect(result).toEqual({ status: 'mismatch', same: true });
+});
+for (const alias of ['whitespace', 'key-order'])
+ for (const phase of ['before', 'final-key'])
+ test(`physical ${alias} alias at ${phase} cannot pass canonical-only native comparison`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate(
+ async ({ alias, phase }) => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ row = (await f.stored()).find((x) => x.id === r.localId)!;
+ const decoded = window.pr.decodePrivateRecord(
+ row.wire,
+ row.owner,
+ row.id
+ );
+ if (!decoded.ok) throw Error('original strict native row');
+ const record = JSON.parse(row.wire) as Record<string, unknown>;
+ const wire =
+ alias === 'whitespace'
+ ? JSON.stringify(record, null, 1)
+ : JSON.stringify(
+ Object.fromEntries(Object.entries(record).reverse())
+ );
+ const alternate = window.pr.decodePrivateRecord(
+ wire,
+ row.owner,
+ row.id
+ );
+ if (
+ !alternate.ok ||
+ window.pr.privateRecordWire(alternate.value, row.owner, row.id) !==
+ window.pr.privateRecordWire(decoded.value, row.owner, row.id)
+ )
+ throw Error('actual canonical-equivalent physical alias');
+ if (phase === 'before') await f.inject([{ ...row, wire }]);
+ else
+ window.prRestore = f.keyCallback(3, () =>
+ f.inject([{ ...row, wire }])
+ );
+ const result = await r.recover();
+ return {
+ status: result.status,
+ proof: !!r.binding(),
+ aliasRetained:
+ (await f.stored()).find((x) => x.id === r.localId)?.wire === wire
+ };
+ },
+ { alias, phase }
+ );
+ expect(result.status).not.toBe('recovered');
+ expect(result.proof).toBe(false);
+ expect(result.aliasRetained).toBe(true);
+ });
+test('actual B1/B2 then memory teardown recovers the immutable original with no ordinary send, new artifact, native growth or traffic', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = window.prFixture;
+ const pub = await f.publish();
+ if (pub.status !== 'accepted' || (await f.append(pub)).status !== 'saved')
+ throw Error('actual B1');
+ const read = await f.read();
+ if (
+ read.status !== 'readback' ||
+ (await f.appendRead(read)).status !== 'saved'
+ )
+ throw Error('actual B2');
+ });
+ await fresh(page);
+ const traffic = privateFrames().length;
+ const result = await page.evaluate(async () => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ before = f.counts(),
+ rows = await f.stored(),
+ reader = r.capture()!,
+ repeat = r.capture();
+ const inert = f.counts(),
+ receiver = f.decryptCallback(0, (wire) => wire);
+ const originalRandom = crypto.getRandomValues.bind(crypto),
+ originalUuid = crypto.randomUUID.bind(crypto);
+ let randomness = 0;
+ crypto.getRandomValues = () => {
+ randomness++;
+ throw Error('new recovery randomness');
+ };
+ crypto.randomUUID = () => {
+ randomness++;
+ throw Error('new recovery command');
+ };
+ let recovered: Awaited<ReturnType<typeof r.recover>>;
+ try {
+ recovered = await r.recover(reader);
+ } finally {
+ crypto.getRandomValues = originalRandom;
+ crypto.randomUUID = originalUuid;
+ }
+ const again = await r.recover(reader),
+ binding = r.binding(),
+ after = f.counts();
+ return {
+ status: recovered.status,
+ again: again.status,
+ sameProof:
+ 'proof' in recovered &&
+ 'proof' in again &&
+ recovered.proof === again.proof,
+ sameReader: reader === repeat,
+ before,
+ inert,
+ after,
+ rowsSame: JSON.stringify(rows) === JSON.stringify(await f.stored()),
+ receivers: receiver.receivers(),
+ randomness,
+ binding: binding && {
+ command: binding.command,
+ rumorHash: binding.rumorHash,
+ eventId: binding.eventId,
+ keys: Object.keys(binding)
+ },
+ oldNonceGone: !window.pr.inboxProbeRumorWire(
+ f.probeIdentity()!,
+ f.session
+ ),
+ readiness: window.pr.inboxAccessControllerSnapshot(r.access)?.readiness
+ };
+ });
+ expect(result.status).toBe('recovered');
+ expect(result.again).toBe('recovered');
+ expect(result.sameProof).toBe(true);
+ expect(result.sameReader).toBe(true);
+ expect(result.inert).toEqual(result.before);
+ expect(result.after.decrypts - result.before.decrypts).toBe(2);
+ expect(result.after.keys - result.before.keys).toBe(3);
+ expect(result.after.signs).toBe(result.before.signs);
+ expect(result.after.encrypts).toBe(result.before.encrypts);
+ expect(result.randomness).toBe(0);
+ expect(result.receivers).toBe(2);
+ expect(result.rowsSame).toBe(true);
+ expect(result.oldNonceGone).toBe(true);
+ expect(result.readiness).toBe('unavailable');
+ expect(result.binding?.keys).not.toContain('rumorWire');
+ expect(privateFrames()).toHaveLength(traffic);
+});
+for (const bad of [
+ 'review',
+ 'id',
+ 'repository',
+ 'identity',
+ 'session',
+ 'policy',
+ 'controller',
+ 'operator',
+ 'unconfigured',
+ 'unsupported',
+ 'copy'
+])
+ test(`inert recovery capture rejects ${bad} before provider or native work`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate((bad) => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ before = f.counts();
+ let native = 0;
+ const original = Object.getOwnPropertyDescriptor(
+ IDBDatabase.prototype,
+ 'transaction'
+ )!.value as IDBDatabase['transaction'];
+ IDBDatabase.prototype.transaction = function (
+ ...args: Parameters<IDBDatabase['transaction']>
+ ) {
+ native++;
+ return original.apply(this, args);
+ };
+ let reader;
+ try {
+ reader = window.pr.captureInboxProbeRecoveryReader(
+ bad === 'repository' ? f.foreignRepository() : r.repository,
+ bad === 'identity' ? f.identity : r.identity,
+ bad === 'session' ? f.session : r.session,
+ bad === 'policy' ? f.copiedPolicy() : r.policy,
+ bad === 'controller'
+ ? f.controller()!
+ : bad === 'copy'
+ ? { ...r.access }
+ : r.access,
+ bad === 'operator'
+ ? ({} as typeof r.operator)
+ : bad === 'unconfigured'
+ ? f.operator(false, true)
+ : bad === 'unsupported'
+ ? f.operator(true)
+ : r.operator,
+ bad === 'id' ? 'not-original' : r.localId,
+ bad === 'review' ? true : 'reviewed_inbox_probe_recovery'
+ );
+ } finally {
+ IDBDatabase.prototype.transaction = original;
+ }
+ return { admitted: !!reader, before, after: f.counts(), native };
+ }, bad);
+ expect(result.admitted).toBe(false);
+ expect(result.after).toEqual(result.before);
+ expect(result.native).toBe(0);
+ });
+test('invalid controller/session/policy associations never retry actual retained failed private cleanup', async ({
+ page
+}) => {
+ const result = await page.evaluate(() => {
+ const f = window.prFixture;
+ let retries = 0;
+ const off = window.pr.subscribePrivateSessionClose(f.session, () => {
+ retries++;
+ throw Error('retained original cleanup');
+ });
+ window.pr.closePrivateSession(f.session);
+ const before = retries;
+ const fake = {} as Parameters<
+ typeof window.pr.inboxAccessConstructionBinding
+ >[0];
+ const absent = window.pr.inboxAccessConstructionBinding(
+ fake,
+ f.session,
+ f.policy
+ ),
+ wrongPolicy = window.pr.inboxAccessConstructionBinding(
+ f.controller()!,
+ f.session,
+ f.copiedPolicy()
+ ),
+ wrongSession = window.pr.inboxAccessConstructionBinding(
+ f.controller()!,
+ fake as unknown as Parameters<
+ typeof window.pr.inboxAccessConstructionBinding
+ >[1],
+ f.policy
+ );
+ const matching = window.pr.inboxAccessConstructionBinding(
+ f.controller()!,
+ f.session,
+ f.policy
+ );
+ const wrongIdentity = {} as typeof f.identity;
+ const refused = window.pr.captureInboxProbeRecoveryReader(
+ f.repository,
+ wrongIdentity,
+ f.session,
+ f.policy,
+ f.controller()!,
+ f.qualification,
+ '11111111-1111-4111-8111-111111111111',
+ 'reviewed_inbox_probe_recovery'
+ );
+ const correctIdentity = window.pr.captureInboxProbeRecoveryReader(
+ f.repository,
+ f.identity,
+ f.session,
+ f.policy,
+ f.controller()!,
+ f.qualification,
+ '11111111-1111-4111-8111-111111111111',
+ 'reviewed_inbox_probe_recovery'
+ );
+ const after = retries,
+ retained = window.pr.privateSessionCleanupRequired(f.session);
+ off();
+ window.pr.closePrivateSession(f.session);
+ return {
+ before,
+ after,
+ retained,
+ admitted: !!(
+ absent ||
+ wrongPolicy ||
+ wrongSession ||
+ matching ||
+ refused ||
+ correctIdentity
+ )
+ };
+ });
+ expect(result.before).toBeGreaterThan(0);
+ expect(result.after).toBe(result.before);
+ expect(result.retained).toBe(true);
+ expect(result.admitted).toBe(false);
+});
+test('one selected original reader prevents second-command/reset and copied/cross-family capability admission', async ({
+ page
+}) => {
+ await fresh(page);
+ const result = await page.evaluate(async () => {
+ const r = window.prFresh,
+ reader = r.capture()!,
+ other = r.capture('reviewed_inbox_probe_recovery', crypto.randomUUID());
+ const recovered = await r.recover(reader);
+ if (!('proof' in recovered)) throw Error('genuine recovered family');
+ const copies = await window.pr.recoverInboxProbe({ ...reader }),
+ ordinary = window.pr.recoveredSelfEnvelopeSnapshot(
+ recovered.proof as unknown as Parameters<
+ typeof window.pr.recoveredSelfEnvelopeSnapshot
+ >[0]
+ ),
+ nonce = window.pr.inboxProbeNonceProofBinding(
+ recovered.proof as unknown as Parameters<
+ typeof window.pr.inboxProbeNonceProofBinding
+ >[0],
+ r.repository,
+ r.session,
+ r.policy
+ ),
+ copied = window.pr.recoveredInboxProbeBinding(
+ { ...recovered.proof },
+ r.repository,
+ r.session,
+ r.access,
+ r.policy,
+ r.operator
+ );
+ return {
+ other: !!other,
+ copies,
+ ordinary: !!ordinary,
+ nonce: !!nonce,
+ copied: !!copied
+ };
+ });
+ expect(result).toEqual({
+ other: false,
+ copies: { status: 'invalid' },
+ ordinary: false,
+ nonce: false,
+ copied: false
+ });
+});
+for (const mutation of [
+ 'r0',
+ 'missing-self',
+ 'ordinary',
+ 'corrupt',
+ 'alias',
+ 'tail',
+ 'binding',
+ 'hash',
+ 'time',
+ 'disappeared'
+])
+ test(`actual native ${mutation} cannot substitute original recovery custody`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate(async (mutation) => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ row = (await f.stored()).find((x) => x.id === r.localId)!,
+ record = JSON.parse(row.wire) as Record<string, unknown>,
+ before = f.counts();
+ if (mutation === 'r0') {
+ record.revision = 0;
+ record.self = null;
+ record.receipts = [];
+ }
+ if (mutation === 'missing-self') record.self = null;
+ if (mutation === 'ordinary') {
+ record.family = 'private_send_reservation';
+ delete record.binding;
+ delete record.self;
+ delete record.receipts;
+ record.revision = 0;
+ record.peer = f.owner;
+ }
+ if (mutation === 'binding')
+ (record.binding as { preferenceId: string }).preferenceId = 'f'.repeat(
+ 64
+ );
+ if (mutation === 'hash') record.rumorHash = 'f'.repeat(64);
+ if (mutation === 'time') record.createdAt = Number(record.createdAt) + 1;
+ if (mutation === 'alias')
+ await f.inject([{ ...row, id: crypto.randomUUID() }]);
+ else if (mutation === 'tail')
+ await f.inject([
+ { owner: row.owner, id: crypto.randomUUID(), wire: '{' }
+ ]);
+ else if (mutation === 'disappeared') await f.removeOriginal();
+ else
+ await f.inject([
+ {
+ ...row,
+ wire: mutation === 'corrupt' ? '{' : JSON.stringify(record)
+ }
+ ]);
+ const rows = await f.stored(),
+ recovered = await r.recover();
+ return {
+ status: recovered.status,
+ before,
+ after: f.counts(),
+ rowsSame: JSON.stringify(rows) === JSON.stringify(await f.stored()),
+ proof: !!r.binding()
+ };
+ }, mutation);
+ expect(result.status).not.toBe('recovered');
+ expect(result.rowsSame).toBe(true);
+ expect(result.proof).toBe(false);
+ expect(result.after.signs).toBe(result.before.signs);
+ expect(result.after.encrypts).toBe(result.before.encrypts);
+ if (!['hash', 'time'].includes(mutation))
+ expect(result.after.decrypts).toBe(result.before.decrypts);
+ });
+test('valid handwritten prior unknown/network labels permit only local decryption and confer no remote readiness', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = window.prFixture;
+ const result = await f.publish();
+ await f.append(result);
+ });
+ await fresh(page);
+ const result = await page.evaluate(async () => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ row = (await f.stored()).find((x) => x.id === r.localId)!,
+ record = JSON.parse(row.wire) as { receipts: { status: string }[] };
+ record.receipts[0].status = 'unknown';
+ await f.inject([{ ...row, wire: JSON.stringify(record) }]);
+ const rows = await f.stored(),
+ result = await r.recover();
+ return {
+ status: result.status,
+ same: JSON.stringify(rows) === JSON.stringify(await f.stored()),
+ readiness: window.pr.inboxAccessControllerSnapshot(r.access)?.readiness
+ };
+ });
+ expect(result).toEqual({
+ status: 'recovered',
+ same: true,
+ readiness: 'unavailable'
+ });
+});
+for (const mode of ['wrong_key', 'refuse_decrypt', 'wrong_decrypt'] as const)
+ test(`actual provider ${mode} consumes the original action without a repeated prompt`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.prFixture,
+ r = window.prFresh;
+ f.mode(mode);
+ const before = f.counts(),
+ first = await r.recover(),
+ after = f.counts();
+ f.mode('normal');
+ const again = await r.recover();
+ return {
+ first: first.status,
+ again: again.status,
+ before,
+ after,
+ final: f.counts()
+ };
+ }, mode);
+ expect(result.first).not.toBe('recovered');
+ expect(result.again).not.toBe('recovered');
+ expect(result.final).toEqual(result.after);
+ if (mode === 'wrong_key')
+ expect(result.after.decrypts).toBe(result.before.decrypts);
+ });
+for (const stage of ['key', 'decrypt'] as const)
+ for (const loss of [
+ 'stop',
+ 'expire',
+ 'head',
+ 'controller',
+ 'private',
+ 'identity'
+ ] as const)
+ test(`pending real ${stage} ${loss} hides recovery and retains the actual shared occupied slot until settlement`, async ({
+ page
+ }) => {
+ await fresh(page);
+ await page.evaluate((stage) => {
+ window.prFixture.mode(stage === 'key' ? 'hold_key' : 'hold_decrypt');
+ window.prPending = window.prFresh.recover();
+ }, stage);
+ await expect
+ .poll(() => page.evaluate(() => window.prFixture.waiting()))
+ .toBe(stage);
+ const result = await page.evaluate(async (loss) => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ reader = r.reader()!;
+ if (loss === 'stop') window.pr.stopInboxProbeRecoveryReader(reader);
+ if (loss === 'expire')
+ window.pr.expireInboxProbeRecoveryReaderWait(reader);
+ if (loss === 'head') r.churnHead();
+ if (loss === 'controller')
+ window.pr.closeInboxAccessController(r.access);
+ if (loss === 'private') window.pr.closePrivateSession(r.session);
+ if (loss === 'identity') window.pr.disconnectIdentity(r.identity);
+ const occupied = window.pr.extensionSchedulerSnapshot(
+ window.pr.browserExtensionScheduler()!
+ )?.state;
+ const busy = await window.pr.runExtensionAction(
+ window.pr.browserExtensionScheduler()!,
+ { owner: r.owner, session: Symbol(), operation: Symbol() },
+ () => true,
+ () => Promise.resolve('foreign')
+ );
+ f.mode('normal');
+ f.settle();
+ const result = await window.prPending;
+ const after = f.counts();
+ const repeated = await r.recover(reader);
+ return {
+ occupied,
+ busy: busy.status,
+ result,
+ repeated: repeated.status,
+ unchanged: JSON.stringify(after) === JSON.stringify(f.counts()),
+ proof: !!r.binding(),
+ final: window.pr.extensionSchedulerSnapshot(
+ window.pr.browserExtensionScheduler()!
+ )?.state
+ };
+ }, loss);
+ expect(result.occupied).toBe('active');
+ expect(result.busy).toBe('busy');
+ expect(result.result).not.toMatchObject({ status: 'recovered' });
+ expect(result.repeated).not.toBe('recovered');
+ expect(result.proof).toBe(false);
+ expect(result.unchanged).toBe(true);
+ expect(result.final).toBe('idle');
+ });
+test('actual owner lock busy admits zero SDK calls and explicit same-reader execution recovers after release', async ({
+ page
+}) => {
+ await fresh(page);
+ await page.evaluate(() => {
+ const r = window.prFresh;
+ window.prPending = navigator.locks.request(
+ 'harvestcircle:owner:' + r.owner,
+ () =>
+ new Promise<void>((resolve) => {
+ window.prRelease = resolve;
+ })
+ );
+ });
+ await expect.poll(() => page.evaluate(() => !!window.prRelease)).toBe(true);
+ const first = await page.evaluate(async () => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ reader = r.capture()!,
+ before = f.counts(),
+ result = await r.recover(reader);
+ return {
+ result,
+ equal: JSON.stringify(before) === JSON.stringify(f.counts()),
+ same: reader === r.capture()
+ };
+ });
+ expect(first).toEqual({
+ result: { status: 'busy' },
+ equal: true,
+ same: true
+ });
+ await page.evaluate(async () => {
+ window.prRelease!();
+ await window.prPending;
+ });
+ expect(
+ await page.evaluate(async () => (await window.prFresh.recover()).status)
+ ).toBe('recovered');
+});
+test('actual shared scheduler busy permits one explicit original-operation run after release', async ({
+ page
+}) => {
+ await fresh(page);
+ await page.evaluate(() => {
+ window.prPending = window.pr.runExtensionAction(
+ window.pr.browserExtensionScheduler()!,
+ { owner: window.prFresh.owner, session: Symbol(), operation: Symbol() },
+ () => true,
+ () =>
+ new Promise<void>((resolve) => {
+ window.prRelease = resolve;
+ })
+ );
+ });
+ await expect.poll(() => page.evaluate(() => !!window.prRelease)).toBe(true);
+ const result = await page.evaluate(async () => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ before = f.counts(),
+ first = await r.recover();
+ return {
+ first: first.status,
+ same: r.reader() === r.capture(),
+ equal: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ });
+ expect(result).toEqual({ first: 'busy', same: true, equal: true });
+ await page.evaluate(async () => {
+ window.prRelease!();
+ await window.prPending;
+ });
+ expect(
+ await page.evaluate(async () => (await window.prFresh.recover()).status)
+ ).toBe('recovered');
+});
+for (const hit of [1, 2, 3])
+ for (const loss of ['native', 'head', 'controller', 'private', 'identity'])
+ test(`actual fresh-key${hit} ${loss} mutation cannot precede a stale recovered proof`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate(
+ async ({ hit, loss }) => {
+ const f = window.prFixture,
+ r = window.prFresh;
+ window.prRestore = f.keyCallback(hit, async () => {
+ if (loss === 'native') {
+ const row = (await f.stored()).find((x) => x.id === r.localId)!,
+ record = JSON.parse(row.wire) as {
+ binding: { preferenceId: string };
+ };
+ record.binding.preferenceId = 'f'.repeat(64);
+ await f.inject([{ ...row, wire: JSON.stringify(record) }]);
+ }
+ if (loss === 'head') r.churnHead();
+ if (loss === 'controller')
+ window.pr.closeInboxAccessController(r.access);
+ if (loss === 'private') window.pr.closePrivateSession(r.session);
+ if (loss === 'identity') window.pr.disconnectIdentity(r.identity);
+ });
+ const result = await r.recover();
+ return { status: result.status, proof: !!r.binding() };
+ },
+ { hit, loss }
+ );
+ expect(result.status).not.toBe('recovered');
+ expect(result.proof).toBe(false);
+ });
+test('cipher getter scope loss preserves current identity and independent private session', async ({
+ page
+}) => {
+ await fresh(page);
+ const result = await page.evaluate(async () => {
+ const f = window.prFixture,
+ r = window.prFresh;
+ window.prRestore = f.cipherGetter(() =>
+ window.pr.closeInboxAccessController(r.access)
+ );
+ const before = f.counts(),
+ result = await r.recover();
+ return {
+ status: result.status,
+ noDecrypt: before.decrypts === f.counts().decrypts,
+ identity:
+ window.pr.identityMessagingOwnership(r.identity)?.current() ?? false,
+ session: window.pr.privateSessionSnapshot(r.session)?.current ?? false
+ };
+ });
+ expect(result.status).not.toBe('recovered');
+ expect(result.noDecrypt).toBe(true);
+ expect(result.identity).toBe(true);
+ expect(result.session).toBe(true);
+});
+test('invalid fresh key never acquires the cipher getter', async ({ page }) => {
+ await fresh(page);
+ const result = await page.evaluate(async () => {
+ const f = window.prFixture,
+ r = window.prFresh;
+ let getters = 0;
+ window.prRestore = f.cipherGetter(() => {
+ getters++;
+ });
+ f.mode('wrong_key');
+ const before = f.counts(),
+ result = await r.recover();
+ return {
+ status: result.status,
+ getters,
+ decrypts: f.counts().decrypts - before.decrypts
+ };
+ });
+ expect(result.status).not.toBe('recovered');
+ expect(result.getters).toBe(0);
+ expect(result.decrypts).toBe(0);
+});
+test('pending duplicate/reentrant capture keeps the same reader and admits no second SDK action', async ({
+ page
+}) => {
+ await fresh(page);
+ await page.evaluate(() => {
+ window.prFixture.mode('hold_decrypt');
+ window.prPending = window.prFresh.recover();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.prFixture.waiting()))
+ .toBe('decrypt');
+ const result = await page.evaluate(async () => {
+ const f = window.prFixture,
+ r = window.prFresh,
+ before = f.counts(),
+ reader = r.reader(),
+ duplicate = await r.recover();
+ const same = reader === r.capture(),
+ inert = JSON.stringify(before) === JSON.stringify(f.counts());
+ f.mode('normal');
+ f.settle();
+ const original = await window.prPending;
+ return {
+ duplicate: duplicate.status,
+ same,
+ inert,
+ original,
+ decrypts: f.counts().decrypts - before.decrypts
+ };
+ });
+ expect(result.duplicate).toBe('busy');
+ expect(result.same).toBe(true);
+ expect(result.inert).toBe(true);
+ expect(result.original).toMatchObject({ status: 'recovered' });
+ expect(result.decrypts).toBe(1);
+});
+for (const loss of [
+ 'stop',
+ 'expire',
+ 'head',
+ 'controller',
+ 'private',
+ 'identity'
+])
+ test(`genuine recovered proof revokes all original rumor visibility on ${loss}`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate(async (loss) => {
+ const r = window.prFresh,
+ result = await r.recover();
+ if (!('proof' in result)) throw Error('actual recovered proof');
+ const visible = !!window.pr.recoveredInboxProbeRumorWire(
+ result.proof,
+ r.repository,
+ r.session,
+ r.access,
+ r.policy,
+ r.operator
+ );
+ if (loss === 'stop') window.pr.stopInboxProbeRecoveryReader(r.reader()!);
+ if (loss === 'expire')
+ window.pr.expireInboxProbeRecoveryReaderWait(r.reader()!);
+ if (loss === 'head') r.churnHead();
+ if (loss === 'controller') window.pr.closeInboxAccessController(r.access);
+ if (loss === 'private') window.pr.closePrivateSession(r.session);
+ if (loss === 'identity') window.pr.disconnectIdentity(r.identity);
+ return {
+ visible,
+ binding: !!r.binding(),
+ rumor: !!window.pr.recoveredInboxProbeRumorWire(
+ result.proof,
+ r.repository,
+ r.session,
+ r.access,
+ r.policy,
+ r.operator
+ )
+ };
+ }, loss);
+ expect(result).toEqual({ visible: true, binding: false, rumor: false });
+ });
+for (const malformed of [
+ 'id',
+ 'author',
+ 'time',
+ 'kind',
+ 'recipient',
+ 'prefix',
+ 'nonce',
+ 'extra',
+ 'duplicate',
+ 'numeric',
+ 'oversized'
+])
+ test(`actual SDK recovered diagnostic ${malformed} cannot mint original proof`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate(async (malformed) => {
+ const f = window.prFixture,
+ r = window.prFresh;
+ const control = f.decryptCallback(2, (wire) => {
+ const rumor = JSON.parse(wire) as Record<string, unknown>;
+ if (malformed === 'id') rumor.id = 'f'.repeat(64);
+ if (malformed === 'author') rumor.pubkey = 'f'.repeat(64);
+ if (malformed === 'time')
+ rumor.created_at = Number(rumor.created_at) + 1;
+ if (malformed === 'kind') rumor.kind = 1;
+ if (malformed === 'recipient') rumor.tags = [['p', 'f'.repeat(64)]];
+ if (malformed === 'prefix')
+ rumor.content = String(rumor.content).replace(
+ 'Harvestcircle',
+ 'Other'
+ );
+ if (malformed === 'nonce')
+ rumor.content = String(rumor.content).slice(0, -1) + 'Z';
+ if (malformed === 'extra') rumor.extra = true;
+ if (malformed === 'oversized') rumor.content = 'x'.repeat(8193);
+ const changed = JSON.stringify(rumor);
+ return malformed === 'duplicate'
+ ? changed.replace('"kind":14', '"kind":14,"kind":14')
+ : malformed === 'numeric'
+ ? changed.replace('"kind":14', '"kind":1.4e1')
+ : changed;
+ });
+ window.prRestore = control.restore;
+ const before = await f.stored(),
+ result = await r.recover();
+ return {
+ status: result.status,
+ proof: !!r.binding(),
+ same: JSON.stringify(before) === JSON.stringify(await f.stored()),
+ receivers: control.receivers()
+ };
+ }, malformed);
+ expect(result.status).toBe('mismatch');
+ expect(result.proof).toBe(false);
+ expect(result.same).toBe(true);
+ expect(result.receivers).toBe(2);
+ });
+for (const malformed of ['tags', 'kind', 'ciphertext'])
+ test(`actual independently signed inner seal ${malformed} is rejected`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate(async (malformed) => {
+ const f = window.prFixture,
+ r = window.prFresh;
+ const control = f.decryptCallback(1, (wire) =>
+ f.signSeal(
+ wire,
+ malformed === 'tags'
+ ? { tags: [['p', f.owner]] }
+ : malformed === 'kind'
+ ? { kind: 1 }
+ : { content: 'unsupported ciphertext' }
+ )
+ );
+ window.prRestore = control.restore;
+ const result = await r.recover();
+ return {
+ status: result.status,
+ proof: !!r.binding(),
+ receivers: control.receivers()
+ };
+ }, malformed);
+ expect(result.status).toBe('mismatch');
+ expect(result.proof).toBe(false);
+ expect(result.receivers).toBe(1);
+ });
+for (const hit of [1, 2])
+ for (const fault of ['before', 'after'])
+ test(`actual native readonly${hit} ${fault} abort refuses recovered authority`, async ({
+ page
+ }) => {
+ await fresh(page);
+ const result = await page.evaluate(
+ async ({ hit, fault }) => {
+ const original = Object.getOwnPropertyDescriptor(
+ IDBIndex.prototype,
+ 'openCursor'
+ )!.value as IDBIndex['openCursor'];
+ let selected = 0,
+ aborts = 0;
+ IDBIndex.prototype.openCursor = function (
+ ...args: Parameters<IDBIndex['openCursor']>
+ ) {
+ const request = original.apply(this, args);
+ if (
+ this.objectStore.name === 'private_sends' &&
+ this.objectStore.transaction.mode === 'readonly' &&
+ ++selected === hit
+ ) {
+ const tx = this.objectStore.transaction;
+ if (fault === 'before') {
+ aborts++;
+ tx.abort();
+ } else
+ request.addEventListener(
+ 'success',
+ () => {
+ aborts++;
+ tx.abort();
+ },
+ { once: true }
+ );
+ }
+ return request;
+ };
+ window.prRestore = () => {
+ IDBIndex.prototype.openCursor = original;
+ };
+ const result = await window.prFresh.recover();
+ return {
+ status: result.status,
+ aborts,
+ proof: !!window.prFresh.binding()
+ };
+ },
+ { hit, fault }
+ );
+ expect(result.status).not.toBe('recovered');
+ expect(result.aborts).toBe(1);
+ expect(result.proof).toBe(false);
+ });
+test('actual same-origin child reload recovers stored ciphertext through a fresh source realm and extension-host closure', async ({
+ page
+}) => {
+ await page.evaluate(() => window.prFixture.close());
+ head = await page.evaluate(() => {
+ window.prHosted = window.pr.createHostedProvider();
+ return window.prHosted.head();
+ });
+ const setup = await page.evaluate(() => {
+ const policyWire = JSON.stringify({
+ schemaVersion: 1,
+ public: [
+ {
+ origin: 'wss://discovery.example.org',
+ read: true,
+ write: true,
+ nip50: false
+ }
+ ],
+ inbox: [{ origin: 'wss://inbox.example.org', read: true, write: true }],
+ postingEnabled: true,
+ messagingEnabled: true,
+ operatorDenylist: []
+ });
+ const operatorWire = JSON.stringify({
+ schemaVersion: 1,
+ revision: 1,
+ authority: 'source_fixture',
+ policyWire,
+ evidenceSha256: 'a'.repeat(64),
+ relays: [
+ {
+ origin: 'wss://inbox.example.org',
+ auth: 'not_required',
+ recipientRead: 'supported',
+ namedArchiveAck: 'supported',
+ exactReadback: 'supported',
+ retention: 'operator_defined'
+ }
+ ]
+ });
+ return { owner: window.prHosted!.owner, policyWire, operatorWire };
+ });
+ await page.evaluate((url) => {
+ const iframe = document.createElement('iframe');
+ iframe.id = 'recovery-realm';
+ iframe.src = url;
+ document.body.append(iframe);
+ }, server.url + '/search');
+ const frame = await (
+ await page.locator('#recovery-realm').elementHandle()
+ ).contentFrame();
+ if (!frame) throw Error('actual same-origin child');
+ await frame.waitForLoadState();
+ await frame.addScriptTag({ content: bundle });
+ const original = await frame.evaluate(async (setup) => {
+ window.pr.installHostedProvider();
+ const policy = window.pr.validateRelayPolicy(setup.policyWire)!,
+ operator = window.pr.validateInboxOperatorQualification(
+ setup.operatorWire
+ )!;
+ window.prHostedContext = await window.pr.openRecoveryContext(
+ setup.owner,
+ policy,
+ operator,
+ crypto.randomUUID()
+ );
+ const record = await window.pr.prepareHostedOriginal(
+ window.prHostedContext
+ );
+ window.prHostedContext.close();
+ return {
+ owner: record.owner,
+ id: record.id,
+ hash: record.rumorHash,
+ eventId: record.self!.eventId,
+ policyWire: setup.policyWire,
+ operatorWire: setup.operatorWire
+ };
+ }, setup);
+ for (let cycle = 0; cycle < 2; cycle++) {
+ await frame.goto(server.url + '/search');
+ await frame.addScriptTag({ content: bundle });
+ const before = await page.evaluate(() => window.prHosted!.counts());
+ const result = await frame.evaluate(async (setup) => {
+ window.pr.installHostedProvider();
+ const policy = window.pr.validateRelayPolicy(setup.policyWire)!,
+ operator = window.pr.validateInboxOperatorQualification(
+ setup.operatorWire
+ )!;
+ window.prFresh = await window.pr.openRecoveryContext(
+ setup.owner,
+ policy,
+ operator,
+ setup.id
+ );
+ const result = await window.prFresh.recover(),
+ binding = window.prFresh.binding();
+ const output = {
+ status: result.status,
+ command: binding?.command,
+ hash: binding?.rumorHash,
+ eventId: binding?.eventId
+ };
+ window.prFresh.close();
+ return output;
+ }, original);
+ expect(result).toEqual({
+ status: 'recovered',
+ command: original.id,
+ hash: original.hash,
+ eventId: original.eventId
+ });
+ const after = await page.evaluate(() => window.prHosted!.counts());
+ expect(after.signs).toBe(before.signs);
+ expect(after.encrypts - before.encrypts).toBe(1); // Actual fresh capability probe; recovery creates no artifact.
+ expect(after.decrypts - before.decrypts).toBe(3); // Fresh capability probe plus original two-layer recovery.
+ }
+});
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -1976,8 +1976,8 @@ import { auditOutput } from '../../tools/check-output.mjs';
'src/lib/nostr/giftwrap-builder.ts',
'src/lib/config/inbox-operators.ts',
'src/lib/persistence/private-sends.ts',
- // CR008-S4C1: both current admissions bind the actual shared guarded
- // self reader and distinct original-observation nonce proof owner.
+ // CR008-S4C2A: current admissions bind the shared guarded self
+ // engine, distinct persisted-probe recovery and controller admission.
'src/lib/nostr/self-recovery-reader.ts',
'src/lib/config/operation-flags.ts',
'src/lib/nostr/private-pool.ts',
diff --git a/web/tests/unit/inbox-probe-recovery.test.ts b/web/tests/unit/inbox-probe-recovery.test.ts
@@ -0,0 +1,174 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers';
+import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts';
+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';
+import type { InboxOperatorQualification } from '../../src/lib/config/inbox-operators.ts';
+import type { InboxAccessController } from '../../src/lib/messaging/inbox-access-controller.ts';
+import type {
+ InboxProbeRecoveryReader,
+ RecoveredInboxProbe,
+ InboxProbeNonceProof
+} from '../../src/lib/nostr/self-recovery-reader.ts';
+import { inboxProbeRumorMatches } from '../../src/lib/nostr/inbox-access.ts';
+
+afterEach(() => vi.unstubAllGlobals());
+const owner =
+ '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+ time = 1700000000;
+const event: UnsignedEvent = {
+ pubkey: owner,
+ created_at: time,
+ kind: 14,
+ tags: [['p', owner]],
+ content: 'Harvestcircle private inbox access check v1: ' + 'b'.repeat(64)
+};
+const hash = getEventHash(event),
+ raw = JSON.stringify({ id: hash, ...event });
+it('the canonical pure diagnostic validator admits only exact original own hash/time/nonce', () => {
+ expect(inboxProbeRumorMatches(raw, owner, hash, time)).toBe(true);
+ expect(inboxProbeRumorMatches(raw, owner.toUpperCase(), hash, time)).toBe(
+ false
+ );
+ for (const malformed of [
+ undefined,
+ null,
+ false,
+ {},
+ raw + ' ',
+ '{',
+ raw.replace('"kind":14', '"kind":1.4e1'),
+ raw.replace('"kind":14', '"kind":14,"kind":14'),
+ raw.replace('"id":', '"extra":0,"id":'),
+ raw.replace('"content":', '"\\u0063ontent":')
+ ])
+ expect(inboxProbeRumorMatches(malformed, owner, hash, time)).toBe(false);
+ for (const change of [
+ { kind: 1 },
+ { pubkey: 'c'.repeat(64) },
+ { created_at: time + 1 },
+ { tags: [] },
+ { tags: [['p', 'c'.repeat(64)]] },
+ {
+ tags: [
+ ['p', owner],
+ ['p', owner]
+ ]
+ },
+ { content: 'ordinary message' },
+ { content: event.content + 'b' },
+ { content: event.content.slice(0, -1) + 'B' },
+ { content: 'x'.repeat(8193) }
+ ]) {
+ const altered = { ...event, ...change };
+ const id = getEventHash(altered);
+ expect(
+ inboxProbeRumorMatches(
+ JSON.stringify({ id, ...altered }),
+ owner,
+ id,
+ time
+ )
+ ).toBe(false);
+ }
+ for (const bad of [
+ -1,
+ 1.5,
+ Number.MAX_SAFE_INTEGER + 1,
+ NaN,
+ Infinity,
+ String(time),
+ null
+ ])
+ expect(inboxProbeRumorMatches(raw, owner, hash, bad)).toBe(false);
+ for (const bad of ['A'.repeat(64), 'c'.repeat(64), 'a'.repeat(63), null])
+ expect(inboxProbeRumorMatches(raw, owner, bad, time)).toBe(false);
+});
+for (const browser of [false, true])
+ it(`cold ${browser ? 'browser-shaped' : 'SSR'} recovery rejects fabricated families before effects`, async () => {
+ vi.resetModules();
+ let effects = 0;
+ const trap = () => {
+ effects++;
+ throw Error('unadmitted effect');
+ };
+ if (browser) {
+ vi.stubGlobal('window', {
+ get nostr() {
+ return trap();
+ }
+ });
+ vi.stubGlobal('navigator', {
+ get locks() {
+ return trap();
+ }
+ });
+ vi.stubGlobal('WebSocket', trap);
+ vi.stubGlobal('indexedDB', { open: trap });
+ }
+ const m = await import('../../src/lib/nostr/self-recovery-reader.ts');
+ const repository = {} as PrivateStorageRepository,
+ identity = {} as IdentitySession,
+ session = {} as PrivateSession,
+ policy = {} as RelayPolicy,
+ operator = {} as InboxOperatorQualification;
+ for (const fake of [
+ undefined,
+ null,
+ 0,
+ false,
+ '',
+ Symbol(),
+ {},
+ { current: () => true, nonce_verified: true },
+ { status: 'recovered', proof: {} }
+ ]) {
+ expect(
+ m.captureInboxProbeRecoveryReader(
+ repository,
+ identity,
+ session,
+ policy,
+ fake as InboxAccessController,
+ operator,
+ '11111111-1111-4111-8111-111111111111',
+ 'reviewed_inbox_probe_recovery'
+ )
+ ).toBeUndefined();
+ expect(
+ await m.recoverInboxProbe(fake as InboxProbeRecoveryReader)
+ ).toEqual({ status: 'invalid' });
+ expect(
+ m.recoveredInboxProbeBinding(
+ fake as RecoveredInboxProbe,
+ repository,
+ session,
+ fake as InboxAccessController,
+ policy,
+ operator
+ )
+ ).toBeUndefined();
+ expect(
+ m.recoveredInboxProbeRumorWire(
+ fake as RecoveredInboxProbe,
+ repository,
+ session,
+ fake as InboxAccessController,
+ policy,
+ operator
+ )
+ ).toBeUndefined();
+ expect(
+ m.inboxProbeNonceProofBinding(
+ fake as InboxProbeNonceProof,
+ repository,
+ session,
+ policy
+ )
+ ).toBeUndefined();
+ m.stopInboxProbeRecoveryReader(fake as InboxProbeRecoveryReader);
+ m.expireInboxProbeRecoveryReaderWait(fake as InboxProbeRecoveryReader);
+ }
+ expect(effects).toBe(0);
+ });
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -317,7 +317,7 @@ async function operationalFlagsAdmission(web) {
'src/lib/messaging/inbox-setup-operation.ts':
'245c6ce88b146dc731e7ace4f16dc9b5002a87a997f5568e4811b0c4a2daf035',
'src/lib/nostr/self-recovery-reader.ts':
- '806230d8082a48b9c2117a16060aff50312be270348d7b8c5b93d6d6368d31a1',
+ '51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b',
'src/lib/nostr/private-publisher.ts':
'2f939dda3504b760dbf3758632cda6ce38d3e16c6d142b814e40a0e295a77d90',
'src/lib/nostr/private-pool.ts':
@@ -327,13 +327,13 @@ async function operationalFlagsAdmission(web) {
'src/lib/persistence/inbox-probes.ts':
'b4d3089bcf08a5c9ac3a99dfcf8e2c2e2160a2c8996c19fccb2670614f7b4d7a',
'src/lib/nostr/inbox-access.ts':
- 'd39f218b66fb51833e962b20152a2df81adf3097ba434a4cf2172ee4a7c8e3bc',
+ '8a58978f3b535348165bc66f2b773e69a08f39a4a5741fb1d59ba546054aa1ce',
'src/lib/nostr/seal-builder.ts':
'3ccc967cc348e63857243ff6f0302c1a68da2afe85ca2c37e00d5a894785fc53',
'src/lib/nostr/giftwrap-builder.ts':
'faf54dd80a0995ac94b4b994d3cfd015516e5e201a1fbb6340e13c836ce49e98',
'src/lib/messaging/inbox-access-controller.ts':
- '103c22b4cd721f7e3371ff887f4e7ca5df6a535688b9e9d0c67241db21430f9a',
+ '2e0d551f1e373603422cd6ad6d17bc2f291b205fbcca9b2a3420649b1cd74975',
'src/lib/messaging/inbox-setup-view.ts':
'e85238d20f1bbcb23599b36e67910f3df784efa43f0fa0b0b7f3da7e7fd33c79',
'src/lib/messaging/inbox-setup.ts':
@@ -595,7 +595,7 @@ async function privacyDataAdmission(web) {
'src/lib/messaging/inbox-list.ts':
'9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5',
'src/lib/nostr/self-recovery-reader.ts':
- '806230d8082a48b9c2117a16060aff50312be270348d7b8c5b93d6d6368d31a1',
+ '51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b',
'src/lib/nostr/private-publisher.ts':
'2f939dda3504b760dbf3758632cda6ce38d3e16c6d142b814e40a0e295a77d90',
'src/lib/nostr/private-pool.ts':
@@ -605,13 +605,13 @@ async function privacyDataAdmission(web) {
'src/lib/persistence/inbox-probes.ts':
'b4d3089bcf08a5c9ac3a99dfcf8e2c2e2160a2c8996c19fccb2670614f7b4d7a',
'src/lib/nostr/inbox-access.ts':
- 'd39f218b66fb51833e962b20152a2df81adf3097ba434a4cf2172ee4a7c8e3bc',
+ '8a58978f3b535348165bc66f2b773e69a08f39a4a5741fb1d59ba546054aa1ce',
'src/lib/nostr/seal-builder.ts':
'3ccc967cc348e63857243ff6f0302c1a68da2afe85ca2c37e00d5a894785fc53',
'src/lib/nostr/giftwrap-builder.ts':
'faf54dd80a0995ac94b4b994d3cfd015516e5e201a1fbb6340e13c836ce49e98',
'src/lib/messaging/inbox-access-controller.ts':
- '103c22b4cd721f7e3371ff887f4e7ca5df6a535688b9e9d0c67241db21430f9a',
+ '2e0d551f1e373603422cd6ad6d17bc2f291b205fbcca9b2a3420649b1cd74975',
'src/lib/messaging/inbox-setup-view.ts':
'4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84',
'src/lib/messaging/inbox-sync.ts':