commit 1bcdb56ed84aaa84b8c047a229f39147f92d3c73
parent e4e61993484bff26f5a64c9d12b2eae9010e0a6b
Author: triesap <tyson@radroots.org>
Date: Wed, 14 Oct 2026 21:49:34 +0000
web: Persist genuine inbox probe nonce facts
- Verify recovered probes through the shared strict nonce reader.
- Bind nonce facts to genuine applied readback lineage and native completion.
- Preserve protected outcomes and reject forged or stale acknowledgements.
- Cover original and recovered flows with native browser regressions.
Diffstat:
6 files changed, 2330 insertions(+), 74 deletions(-)
diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts
@@ -10,6 +10,7 @@ import {
} from './private-pool.ts';
import {
inboxProbePublicationBinding,
+ recoveredInboxProbePublicationBinding,
type InboxProbeAcknowledgement
} from '../persistence/inbox-probes.ts';
import { inboxProbeRumorWire, inboxProbeRumorMatches } from './inbox-access.ts';
@@ -420,11 +421,30 @@ export type InboxProbeNonceResult =
| 'mismatch'
| 'lost_evidence';
}>;
+declare const recoveredProbeNonceReaderBrand: unique symbol;
+export type RecoveredInboxProbeNonceReader = Readonly<{
+ [recoveredProbeNonceReaderBrand]: true;
+}>;
+declare const recoveredProbeNonceProofBrand: unique symbol;
+export type RecoveredInboxProbeNonceProof = Readonly<{
+ [recoveredProbeNonceProofBrand]: true;
+}>;
+export type RecoveredInboxProbeNonceResult =
+ | Exclude<InboxProbeNonceResult, { status: 'nonce_verified' }>
+ | Readonly<{
+ status: 'nonce_verified';
+ proof: RecoveredInboxProbeNonceProof;
+ }>;
+type NonceResult = InboxProbeNonceResult | RecoveredInboxProbeNonceResult;
+type NonceReader = InboxProbeNonceReader | RecoveredInboxProbeNonceReader;
+type NonceProof = InboxProbeNonceProof | RecoveredInboxProbeNonceProof;
+type NonceSource = 'construction' | 'recovered';
type ProbeReader = {
- run(): Promise<InboxProbeNonceResult>;
+ source: NonceSource;
+ run(): Promise<NonceResult>;
stop(expired: boolean): void;
};
-const probeReaders = new WeakMap<InboxProbeNonceReader, ProbeReader>();
+const probeReaders = new WeakMap<NonceReader, ProbeReader>();
const probeObservationReaders = new WeakMap<
InboxProbeReadbackAttemptResult,
Readonly<{
@@ -432,20 +452,24 @@ const probeObservationReaders = new WeakMap<
identity: IdentitySession;
session: PrivateSession;
policy: RelayPolicy;
- reader: InboxProbeNonceReader;
+ source: NonceSource;
+ reader: NonceReader;
}>
>();
-const probeNonceProofs = new WeakMap<
- InboxProbeNonceProof,
- Readonly<{
- repository: PrivateStorageRepository;
- session: PrivateSession;
- policy: RelayPolicy;
- observation: InboxProbeReadbackAttemptResult;
- acknowledgement: InboxProbeAcknowledgement;
- original: string;
- current(): boolean;
- }>
+type SavedNonceProof = Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ policy: RelayPolicy;
+ observation: InboxProbeReadbackAttemptResult;
+ acknowledgement: InboxProbeAcknowledgement;
+ original: string;
+ verifiedAtMilliseconds: number;
+ current(): boolean;
+}>;
+const probeNonceProofs = new WeakMap<InboxProbeNonceProof, SavedNonceProof>();
+const recoveredNonceProofs = new WeakMap<
+ RecoveredInboxProbeNonceProof,
+ SavedNonceProof
>();
function immutableProbe(
record: import('../persistence/private-records.ts').PrivateAccessProbe
@@ -461,14 +485,15 @@ function immutableProbe(
}
// Genuine positive source transport, actual identity/private session, original
// nonce and native custody are all required. Capture never calls the provider.
-export function captureInboxProbeNonceReader(
+function captureProbeNonceReader(
+ source: NonceSource,
repository: PrivateStorageRepository,
identity: IdentitySession,
session: PrivateSession,
policy: RelayPolicy,
observation: InboxProbeReadbackAttemptResult,
review: unknown
-): InboxProbeNonceReader | undefined {
+): NonceReader | undefined {
if (
typeof window === 'undefined' ||
review !== 'reviewed_inbox_probe_nonce_decryption'
@@ -478,13 +503,32 @@ export function captureInboxProbeNonceReader(
const effect = inboxProbeReadbackAttemptEvidence(observation);
if (!effect || effect.repository !== repository) return undefined;
const acknowledgement = effect.acknowledgement,
- binding = inboxProbePublicationBinding(
+ lookup =
+ source === 'construction'
+ ? inboxProbePublicationBinding
+ : recoveredInboxProbePublicationBinding,
+ binding = lookup(repository, session, acknowledgement, policy);
+ if (!binding?.record.self) return undefined;
+ function expectedRumor(): string | undefined {
+ if (source === 'construction')
+ return inboxProbeRumorWire(
+ binding!.identity as Parameters<typeof inboxProbeRumorWire>[0],
+ session
+ );
+ const recovered = binding!.identity as RecoveredInboxProbe,
+ original = recoveredProbes.get(recovered);
+ if (!original || original.identity !== identity) return undefined;
+ return recoveredInboxProbeRumorWire(
+ recovered,
repository,
session,
- acknowledgement,
- policy
+ original.access,
+ policy,
+ original.operator
);
- if (!binding?.record.self) return undefined;
+ }
+ // Strong recovered associations precede passive private-session ownership.
+ if (!expectedRumor()) return undefined;
const identityOwner = identityMessagingOwnership(identity);
if (
!identityOwner?.current() ||
@@ -511,33 +555,29 @@ export function captureInboxProbeNonceReader(
binding.record.owner,
fact.readbackWire
) ||
- !inboxProbeRumorWire(binding.identity, session)
+ !expectedRumor()
)
return undefined;
const previous = probeObservationReaders.get(observation);
if (previous)
- return previous.repository === repository &&
+ return previous.source === source &&
+ previous.repository === repository &&
previous.identity === identity &&
previous.session === session &&
previous.policy === policy
? previous.reader
: undefined;
const original = immutableProbe(binding.record),
- token = Object.freeze({}) as InboxProbeNonceReader;
+ token = Object.freeze({}) as NonceReader;
let stopped = false,
started = false,
pending = false,
active: ExtensionAction | undefined,
- proof: InboxProbeNonceProof | undefined,
- last: InboxProbeNonceResult | undefined;
+ proof: NonceProof | undefined,
+ last: NonceResult | undefined;
const listeners = new Map<symbol, () => void>();
function current() {
- const fresh = inboxProbePublicationBinding(
- repository,
- session,
- acknowledgement,
- policy
- );
+ const fresh = lookup(repository, session, acknowledgement, policy);
return (
!stopped &&
identityOwner!.current() &&
@@ -545,7 +585,7 @@ export function captureInboxProbeNonceReader(
!!fresh &&
fresh.identity === binding!.identity &&
immutableProbe(fresh.record) === original &&
- !!inboxProbeRumorWire(fresh.identity, session)
+ !!expectedRumor()
);
}
function stop(expired: boolean) {
@@ -554,7 +594,10 @@ export function captureInboxProbeNonceReader(
if (expired) markExtensionWaitExpired(active);
else stopExtensionAction(active);
}
- if (proof) probeNonceProofs.delete(proof);
+ if (proof) {
+ probeNonceProofs.delete(proof as InboxProbeNonceProof);
+ recoveredNonceProofs.delete(proof as RecoveredInboxProbeNonceProof);
+ }
proof = undefined;
for (const [id, off] of listeners) {
off();
@@ -571,7 +614,7 @@ export function captureInboxProbeNonceReader(
identityOwner.owner,
current
);
- async function run(): Promise<InboxProbeNonceResult> {
+ async function run(): Promise<NonceResult> {
if (!current()) {
stop(false);
return { status: 'stopped' };
@@ -586,10 +629,10 @@ export function captureInboxProbeNonceReader(
last = await navigator.locks.request(
'harvestcircle:owner:' + identityOwner!.owner,
{ mode: 'exclusive', ifAvailable: true },
- async (lock): Promise<InboxProbeNonceResult> => {
+ async (lock): Promise<NonceResult> => {
if (!lock) return { status: 'busy' };
if (!current()) return { status: 'stopped' };
- const captured = inboxProbePublicationBinding(
+ const captured = lookup(
repository,
session,
acknowledgement,
@@ -610,12 +653,8 @@ export function captureInboxProbeNonceReader(
captured.record.owner,
captured.record.id
) !== captured.wire ||
- inboxProbePublicationBinding(
- repository,
- session,
- acknowledgement,
- policy
- )?.wire !== captured.wire
+ lookup(repository, session, acknowledgement, policy)?.wire !==
+ captured.wire
)
return { status: 'conflict' };
const checked = verifyEnvelope(captured.record.self.wire),
@@ -648,15 +687,12 @@ export function captureInboxProbeNonceReader(
operation: Symbol()
},
current,
- async (action): Promise<InboxProbeNonceResult> => {
+ async (action): Promise<NonceResult> => {
active = action;
const opened = await decryptor.open(action, outer);
if (!current()) return { status: 'stopped' };
if (opened.status !== 'opened') return opened;
- const expected = inboxProbeRumorWire(
- captured.identity,
- session
- );
+ const expected = expectedRumor();
if (!expected || opened.rumorWire !== expected)
return { status: 'mismatch' };
const rumor = JSON.parse(opened.rumorWire) as {
@@ -674,6 +710,13 @@ export function captureInboxProbeNonceReader(
// final physical read. No extension callback follows that read.
if (!(await decryptor.fresh(action)))
return { status: 'stopped' };
+ const verifiedAtMilliseconds = Date.now();
+ if (!current()) return { status: 'stopped' };
+ if (
+ !Number.isSafeInteger(verifiedAtMilliseconds) ||
+ verifiedAtMilliseconds < 0
+ )
+ return { status: 'mismatch' };
const after = await observePrivateRecord(
repository,
'private_sends',
@@ -688,31 +731,40 @@ export function captureInboxProbeNonceReader(
captured.record.owner,
captured.record.id
) !== captured.wire ||
- inboxProbePublicationBinding(
- repository,
- session,
- acknowledgement,
- policy
- )?.wire !== captured.wire
+ lookup(repository, session, acknowledgement, policy)?.wire !==
+ captured.wire
)
return { status: 'conflict' };
- if (
- !current() ||
- inboxProbeRumorWire(captured.identity, session) !== expected
- )
+ if (!current() || expectedRumor() !== expected)
return { status: 'stopped' };
- const issued = Object.freeze({}) as InboxProbeNonceProof;
- probeNonceProofs.set(issued, {
+ const issued = Object.freeze({}) as NonceProof;
+ const saved = {
repository,
session,
policy,
observation,
acknowledgement,
original,
+ verifiedAtMilliseconds,
current
- });
+ };
+ if (source === 'construction')
+ probeNonceProofs.set(issued as InboxProbeNonceProof, saved);
+ else
+ recoveredNonceProofs.set(
+ issued as RecoveredInboxProbeNonceProof,
+ saved
+ );
proof = issued;
- return { status: 'nonce_verified', proof: issued };
+ return source === 'construction'
+ ? {
+ status: 'nonce_verified',
+ proof: issued as InboxProbeNonceProof
+ }
+ : {
+ status: 'nonce_verified',
+ proof: issued as RecoveredInboxProbeNonceProof
+ };
}
);
if (!current()) return { status: 'stopped' };
@@ -732,10 +784,11 @@ export function captureInboxProbeNonceReader(
pending = false;
}
}
- probeReaders.set(token, { run, stop });
+ probeReaders.set(token, { source, run, stop });
// Reserve before callback-capable subscriptions; reentrant capture reuses
// this exact original reader and cannot reset or start another SDK action.
probeObservationReaders.set(observation, {
+ source,
repository,
identity,
session,
@@ -753,18 +806,77 @@ export function captureInboxProbeNonceReader(
return undefined;
}
}
+export function captureInboxProbeNonceReader(
+ repository: PrivateStorageRepository,
+ identity: IdentitySession,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ observation: InboxProbeReadbackAttemptResult,
+ review: unknown
+): InboxProbeNonceReader | undefined {
+ return captureProbeNonceReader(
+ 'construction',
+ repository,
+ identity,
+ session,
+ policy,
+ observation,
+ review
+ ) as InboxProbeNonceReader | undefined;
+}
+export function captureRecoveredInboxProbeNonceReader(
+ repository: PrivateStorageRepository,
+ identity: IdentitySession,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ observation: InboxProbeReadbackAttemptResult,
+ review: unknown
+): RecoveredInboxProbeNonceReader | undefined {
+ return captureProbeNonceReader(
+ 'recovered',
+ repository,
+ identity,
+ session,
+ policy,
+ observation,
+ review
+ ) as RecoveredInboxProbeNonceReader | undefined;
+}
export function readInboxProbeNonce(
reader: InboxProbeNonceReader
): Promise<InboxProbeNonceResult> {
- return (
- probeReaders.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' })
- );
+ const saved = probeReaders.get(reader);
+ return saved?.source === 'construction'
+ ? (saved.run() as Promise<InboxProbeNonceResult>)
+ : Promise.resolve({ status: 'invalid' });
}
export function stopInboxProbeNonceReader(reader: InboxProbeNonceReader) {
- probeReaders.get(reader)?.stop(false);
+ const saved = probeReaders.get(reader);
+ if (saved?.source === 'construction') saved.stop(false);
}
export function expireInboxProbeNonceReaderWait(reader: InboxProbeNonceReader) {
- probeReaders.get(reader)?.stop(true);
+ const saved = probeReaders.get(reader);
+ if (saved?.source === 'construction') saved.stop(true);
+}
+export function readRecoveredInboxProbeNonce(
+ reader: RecoveredInboxProbeNonceReader
+): Promise<RecoveredInboxProbeNonceResult> {
+ const saved = probeReaders.get(reader);
+ return saved?.source === 'recovered'
+ ? (saved.run() as Promise<RecoveredInboxProbeNonceResult>)
+ : Promise.resolve({ status: 'invalid' });
+}
+export function stopRecoveredInboxProbeNonceReader(
+ reader: RecoveredInboxProbeNonceReader
+) {
+ const saved = probeReaders.get(reader);
+ if (saved?.source === 'recovered') saved.stop(false);
+}
+export function expireRecoveredInboxProbeNonceReaderWait(
+ reader: RecoveredInboxProbeNonceReader
+) {
+ const saved = probeReaders.get(reader);
+ if (saved?.source === 'recovered') saved.stop(true);
}
export function inboxProbeNonceProofBinding(
proof: InboxProbeNonceProof,
@@ -801,6 +913,73 @@ export function inboxProbeNonceProofBinding(
};
}
+export function recoveredInboxProbeNonceProofBinding(
+ proof: RecoveredInboxProbeNonceProof,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy
+) {
+ const saved = recoveredNonceProofs.get(proof);
+ if (
+ !saved ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ saved.policy !== policy ||
+ !saved.current()
+ )
+ return undefined;
+ const binding = recoveredInboxProbePublicationBinding(
+ repository,
+ session,
+ saved.acknowledgement,
+ policy
+ );
+ if (!binding || immutableProbe(binding.record) !== saved.original)
+ return undefined;
+ return {
+ acknowledgement: saved.acknowledgement,
+ observation: saved.observation,
+ identity: binding.identity,
+ owner: binding.record.owner,
+ command: binding.record.id,
+ rumorHash: binding.record.rumorHash,
+ eventId: binding.record.self!.eventId,
+ current: () => saved.current()
+ };
+}
+// Local genuine nonce verification only; caller copies of this projection are
+// never accepted by the append owner in place of the original opaque proof.
+export function inboxProbeNonceVerificationEvidence(
+ proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy
+) {
+ const original = probeNonceProofs.get(proof as InboxProbeNonceProof),
+ recovered = recoveredNonceProofs.get(
+ proof as RecoveredInboxProbeNonceProof
+ ),
+ saved = original ?? recovered,
+ binding = original
+ ? inboxProbeNonceProofBinding(
+ proof as InboxProbeNonceProof,
+ repository,
+ session,
+ policy
+ )
+ : recovered
+ ? recoveredInboxProbeNonceProofBinding(
+ proof as RecoveredInboxProbeNonceProof,
+ repository,
+ session,
+ policy
+ )
+ : undefined;
+ return saved && binding && binding.current()
+ ? { ...binding, verifiedAtMilliseconds: saved.verifiedAtMilliseconds }
+ : undefined;
+}
+
declare const probeRecoveryReaderBrand: unique symbol;
export type InboxProbeRecoveryReader = Readonly<{
[probeRecoveryReaderBrand]: true;
diff --git a/web/src/lib/persistence/inbox-probes.ts b/web/src/lib/persistence/inbox-probes.ts
@@ -7,7 +7,10 @@ import {
import { inboxProbePolicyMatches } from '../nostr/inbox-access.ts';
import {
recoveredInboxProbeBinding,
- type RecoveredInboxProbe
+ inboxProbeNonceVerificationEvidence,
+ type RecoveredInboxProbe,
+ type InboxProbeNonceProof,
+ type RecoveredInboxProbeNonceProof
} from '../nostr/self-recovery-reader.ts';
import type { InboxAccessController } from '../messaging/inbox-access-controller.ts';
import type { InboxOperatorQualification } from '../config/inbox-operators.ts';
@@ -40,7 +43,9 @@ import {
decodePrivateRecord,
privateRecordWire,
privateRecordSnapshot,
- type PrivateAccessProbe
+ type PrivateAccessProbe,
+ type PrivateAccessProbeReceipt,
+ type PrivateRecordHandle
} from './private-records.ts';
import {
verifyEnvelope,
@@ -794,3 +799,378 @@ export function commitInboxProbeReadbackAttempt(
): Promise<InboxProbeArchiveCommitResult> {
return commitProbeAttempt(repository, result, 'access_readback');
}
+
+declare const nonceAcknowledgementBrand: unique symbol;
+export type InboxProbeNonceAcknowledgement = Readonly<{
+ [nonceAcknowledgementBrand]: true;
+}>;
+export type InboxProbeNonceCommitResult = Readonly<{
+ status:
+ | 'saved'
+ | 'existing'
+ | 'reconciled'
+ | PrivateStorageFailure
+ | 'invalid'
+ | 'busy'
+ | 'stopped';
+ disposition: 'original_protected';
+ acknowledgement?: InboxProbeNonceAcknowledgement;
+ provenance?: 'current' | 'historical_only';
+}>;
+type NonceProof = InboxProbeNonceProof | RecoveredInboxProbeNonceProof;
+type NonceOperationInput = Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ policy: RelayPolicy;
+ proof: NonceProof;
+ acknowledgement: InboxProbeAcknowledgement;
+ observation: InboxProbeReadbackAttemptResult;
+ lineage: Lineage;
+ baseWire: string;
+ nextWire: string;
+ nextRecord: PrivateAccessProbe;
+ nextHandle: PrivateRecordHandle;
+}>;
+type NonceOperation = NonceOperationInput &
+ Readonly<{
+ uncertain(): boolean;
+ applied(): boolean;
+ markAttempted(): void;
+ markDefiniteFailure(): void;
+ markApplied(): void;
+ acknowledgementToken(): InboxProbeNonceAcknowledgement | undefined;
+ issueAcknowledgement(): InboxProbeNonceAcknowledgement;
+ }>;
+function createNonceOperation(input: NonceOperationInput): NonceOperation {
+ let uncertain = false,
+ applied = false,
+ acknowledgement: InboxProbeNonceAcknowledgement | undefined;
+ return {
+ ...input,
+ uncertain: () => uncertain,
+ applied: () => applied,
+ markAttempted() {
+ uncertain = true;
+ },
+ markDefiniteFailure() {
+ uncertain = false;
+ },
+ markApplied() {
+ applied = true;
+ },
+ acknowledgementToken: () => acknowledgement,
+ issueAcknowledgement() {
+ return (acknowledgement ??= Object.freeze(
+ {}
+ ) as InboxProbeNonceAcknowledgement);
+ }
+ };
+}
+const nonceOperations = new WeakMap<NonceProof, NonceOperation>();
+const nonceAcknowledgements = new WeakMap<
+ InboxProbeNonceAcknowledgement,
+ NonceOperation
+>();
+function currentNonceOperation(operation: NonceOperation): boolean {
+ const evidence = inboxProbeNonceVerificationEvidence(
+ operation.proof,
+ operation.repository,
+ operation.session,
+ operation.policy
+ );
+ return (
+ !!evidence &&
+ evidence.acknowledgement === operation.acknowledgement &&
+ evidence.observation === operation.observation &&
+ evidence.current() &&
+ acknowledgements.get(evidence.acknowledgement)?.lineage ===
+ operation.lineage &&
+ appliedArchiveEvidence.get(evidence.observation) === operation.lineage
+ );
+}
+function nonceSuccess(
+ operation: NonceOperation,
+ status: 'saved' | 'existing' | 'reconciled'
+): InboxProbeNonceCommitResult {
+ if (!currentNonceOperation(operation))
+ return {
+ status,
+ disposition: 'original_protected',
+ provenance: 'historical_only'
+ };
+ let acknowledgement = operation.acknowledgementToken();
+ if (!acknowledgement) {
+ acknowledgement = operation.issueAcknowledgement();
+ nonceAcknowledgements.set(acknowledgement, operation);
+ }
+ return {
+ status,
+ disposition: 'original_protected',
+ provenance: 'current',
+ acknowledgement
+ };
+}
+
+// Persist a genuine local nonce observation, never a caller receipt/status.
+// A source-admitted native operation may settle after loss as history only.
+export async function commitInboxProbeNonceVerification(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ proof: NonceProof
+): Promise<InboxProbeNonceCommitResult> {
+ const refuse = (
+ status: InboxProbeNonceCommitResult['status']
+ ): InboxProbeNonceCommitResult => ({
+ status,
+ disposition: 'original_protected'
+ });
+ try {
+ if (typeof window === 'undefined') return refuse('invalid');
+ const evidence = inboxProbeNonceVerificationEvidence(
+ proof,
+ repository,
+ session,
+ policy
+ ),
+ saved = evidence && acknowledgements.get(evidence.acknowledgement),
+ effect =
+ evidence && inboxProbeReadbackAttemptEvidence(evidence.observation);
+ // All strong nonce/read/ACK associations precede passive ownership or DB.
+ if (
+ !evidence ||
+ !saved ||
+ !effect ||
+ effect.repository !== repository ||
+ effect.acknowledgement !== evidence.acknowledgement ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ appliedArchiveEvidence.get(evidence.observation) !== saved.lineage ||
+ !evidence.current()
+ )
+ return refuse('invalid');
+ const fact = JSON.parse(effect.receiptWire) as PrivateAccessProbeReceipt;
+ const lineage = saved.lineage;
+ if (
+ fact.role !== 'access_readback' ||
+ fact.status !== 'readback' ||
+ fact.eventId !== evidence.eventId ||
+ !lineage.record().self ||
+ evidence.command !== lineage.record().id ||
+ evidence.owner !== lineage.record().owner ||
+ !Number.isSafeInteger(evidence.verifiedAtMilliseconds) ||
+ evidence.verifiedAtMilliseconds < 0
+ )
+ return refuse('invalid');
+ const original = lineage;
+ if (!original.begin()) return refuse('busy');
+ // Only the owner that actually acquired begin may finish this lineage.
+ try {
+ if (!navigator.locks?.request) return refuse('unavailable');
+ return await navigator.locks.request(
+ 'harvestcircle:owner:' + evidence.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock): Promise<InboxProbeNonceCommitResult> => {
+ if (!lock) return refuse('busy');
+ if (!evidence.current()) return refuse('stopped');
+ const job = await withIdlePrivateLocalStorage(
+ session,
+ async (): Promise<InboxProbeNonceCommitResult> => {
+ if (!evidence.current()) return refuse('stopped');
+ const observed = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ evidence.command
+ );
+ if (!evidence.current()) return refuse('stopped');
+ if (!observed.ok) return refuse(observed.reason);
+ let operation = nonceOperations.get(proof);
+ if (
+ operation &&
+ (operation.repository !== repository ||
+ operation.session !== session ||
+ operation.policy !== policy ||
+ operation.lineage !== original ||
+ operation.acknowledgement !== evidence.acknowledgement ||
+ operation.observation !== evidence.observation)
+ )
+ return refuse('invalid_scope');
+ if (
+ privateRecordWire(
+ observed.value.handle,
+ evidence.owner,
+ evidence.command
+ ) !== observed.value.wire
+ )
+ return refuse('conflict');
+ if (operation?.applied()) {
+ if (observed.value.wire !== original.wire())
+ return refuse('conflict');
+ return nonceSuccess(operation, 'existing');
+ }
+ if (
+ operation?.uncertain() &&
+ observed.value.wire === operation.nextWire
+ ) {
+ if (original.wire() !== operation.baseWire)
+ return refuse('conflict');
+ original.admit(operation.nextRecord, operation.nextWire);
+ operation.markApplied();
+ return nonceSuccess(operation, 'reconciled');
+ }
+ if (
+ observed.value.wire !== original.wire() ||
+ (operation && operation.baseWire !== original.wire())
+ )
+ return refuse('conflict');
+ if (!operation) {
+ if (original.record().revision === Number.MAX_SAFE_INTEGER)
+ return refuse('invalid_record');
+ const candidate = decodePrivateRecord(
+ JSON.stringify({
+ ...original.record(),
+ revision: original.record().revision + 1,
+ receipts: [
+ ...original.record().receipts,
+ {
+ ...fact,
+ status: 'nonce_verified',
+ observedAtMilliseconds: evidence.verifiedAtMilliseconds
+ }
+ ]
+ }),
+ evidence.owner,
+ evidence.command
+ );
+ if (!candidate.ok) return refuse('invalid_record');
+ const nextWire = privateRecordWire(
+ candidate.value,
+ evidence.owner,
+ evidence.command
+ ),
+ nextRecord = privateRecordSnapshot(
+ candidate.value,
+ evidence.owner,
+ evidence.command
+ );
+ if (
+ !nextWire ||
+ !nextRecord ||
+ nextRecord.family !== 'private_access_probe'
+ )
+ return refuse('invalid_record');
+ operation = createNonceOperation({
+ repository,
+ session,
+ policy,
+ proof,
+ acknowledgement: evidence.acknowledgement,
+ observation: evidence.observation,
+ lineage: original,
+ baseWire: original.wire(),
+ nextWire,
+ nextRecord,
+ nextHandle: candidate.value
+ });
+ }
+ // This is the actual append-admission boundary. Before it, stale
+ // proof has no write. After it, only bounded history may settle.
+ if (!currentNonceOperation(operation)) return refuse('stopped');
+ nonceOperations.set(proof, operation);
+ const previousUncertainty = operation.uncertain();
+ operation.markAttempted();
+ const committed = await commitPrivateRecord(
+ repository,
+ operation.nextHandle,
+ observed.value.handle
+ );
+ if (!committed.ok && committed.reason !== 'unknown_completion') {
+ operation.markDefiniteFailure();
+ return refuse(committed.reason);
+ }
+ if (
+ committed.ok &&
+ committed.value.state === 'existing' &&
+ !previousUncertainty
+ ) {
+ // A matching handwritten successor is not our completed append.
+ operation.markDefiniteFailure();
+ return refuse('conflict');
+ }
+ const after = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ evidence.command
+ );
+ if (!after.ok) return refuse('unknown_completion');
+ if (
+ after.value.wire !== operation.nextWire ||
+ privateRecordWire(
+ after.value.handle,
+ evidence.owner,
+ evidence.command
+ ) !== operation.nextWire
+ )
+ return refuse('conflict');
+ original.admit(operation.nextRecord, operation.nextWire);
+ operation.markApplied();
+ return nonceSuccess(
+ operation,
+ !committed.ok
+ ? 'reconciled'
+ : committed.value.state === 'existing'
+ ? 'existing'
+ : 'saved'
+ );
+ }
+ );
+ if (!job.ok) return refuse(evidence.current() ? 'busy' : 'stopped');
+ if (job.value.acknowledgement && !evidence.current())
+ return {
+ status: job.value.status,
+ disposition: 'original_protected',
+ provenance: 'historical_only'
+ };
+ return job.value;
+ }
+ );
+ } finally {
+ original.finish();
+ }
+ } catch {
+ return refuse('unknown_completion');
+ }
+}
+
+// Local source provenance only. Later cleanup/readiness must independently
+// reobserve native custody and all required genuine current target effects.
+export function inboxProbeNonceAcknowledgementBinding(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ acknowledgement: InboxProbeNonceAcknowledgement,
+ policy: RelayPolicy
+) {
+ const saved = nonceAcknowledgements.get(acknowledgement);
+ if (
+ !saved ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ saved.policy !== policy ||
+ !saved.applied() ||
+ !currentNonceOperation(saved)
+ )
+ return undefined;
+ return {
+ owner: saved.lineage.record().owner,
+ command: saved.lineage.record().id,
+ eventId: saved.lineage.record().self!.eventId,
+ probeAcknowledgement: saved.acknowledgement,
+ proof: saved.proof,
+ observation: saved.observation,
+ record: JSON.parse(
+ JSON.stringify(saved.lineage.record())
+ ) as PrivateAccessProbe,
+ wire: saved.lineage.wire(),
+ current: () => currentNonceOperation(saved)
+ };
+}
diff --git a/web/tests/e2e/harness/inbox-probe-nonce-facts.ts b/web/tests/e2e/harness/inbox-probe-nonce-facts.ts
@@ -0,0 +1,298 @@
+import { makeRetryFixture } from './inbox-probe-retry.ts';
+import {
+ captureInboxProbeNonceReader,
+ captureRecoveredInboxProbeNonceReader,
+ readInboxProbeNonce,
+ readRecoveredInboxProbeNonce,
+ stopInboxProbeNonceReader,
+ stopRecoveredInboxProbeNonceReader,
+ expireInboxProbeNonceReaderWait,
+ expireRecoveredInboxProbeNonceReaderWait,
+ type InboxProbeNonceReader,
+ type RecoveredInboxProbeNonceReader,
+ type InboxProbeNonceProof,
+ type RecoveredInboxProbeNonceProof
+} from '../../../src/lib/nostr/self-recovery-reader.ts';
+import { inboxProbeNonceVerificationEvidence } from '../../../src/lib/nostr/self-recovery-reader.ts';
+import { inboxProbeReadbackAttemptEvidence } from '../../../src/lib/nostr/private-pool.ts';
+import {
+ decodePrivateRecord,
+ privateRecordWire,
+ type PrivateAccessProbeReceipt
+} from '../../../src/lib/persistence/private-records.ts';
+import {
+ commitInboxProbeNonceVerification,
+ inboxProbeNonceAcknowledgementBinding,
+ type InboxProbeNonceAcknowledgement
+} from '../../../src/lib/persistence/inbox-probes.ts';
+import { closePrivateSession } from '../../../src/lib/runtime/private-session.ts';
+import type { InboxProbeReadbackAttemptResult } from '../../../src/lib/nostr/private-pool.ts';
+export * from './inbox-probe-retry.ts';
+export * from '../../../src/lib/nostr/self-recovery-reader.ts';
+export * from '../../../src/lib/persistence/inbox-probes.ts';
+export { createPrivateStorageRepository } from '../../../src/lib/persistence/private-storage.ts';
+export { privateRecordSettlement } from '../../../src/lib/persistence/local-inventory.ts';
+export { inboxProbeReadbackAttemptEvidence } from '../../../src/lib/nostr/private-pool.ts';
+export { capturePrivateOutboxCleanup } from '../../../src/lib/persistence/private-outbox-cleanup.ts';
+export {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ disconnectIdentity
+} from '../../../src/lib/runtime/identity-session.ts';
+export { createPrivateSession } from '../../../src/lib/runtime/private-session.ts';
+export {
+ openBrowserDatabase,
+ closeBrowserDatabase,
+ browserDatabaseTransaction
+} from '../../../src/lib/persistence/database.ts';
+
+export async function makeNonceFactsFixture() {
+ const base = await makeRetryFixture();
+ let recovered = false,
+ observation: InboxProbeReadbackAttemptResult | undefined,
+ reader: InboxProbeNonceReader | RecoveredInboxProbeNonceReader | undefined,
+ proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof | undefined,
+ acknowledgement: InboxProbeNonceAcknowledgement | undefined;
+ const restores = new Set<() => void>();
+ function retain(off: () => void) {
+ restores.add(off);
+ return () => {
+ off();
+ restores.delete(off);
+ };
+ }
+ function capture(review: unknown = 'reviewed_inbox_probe_nonce_decryption') {
+ if (!observation) return undefined;
+ const a = base.actors();
+ return (
+ recovered
+ ? captureRecoveredInboxProbeNonceReader
+ : captureInboxProbeNonceReader
+ )(
+ base.repository,
+ a.identity,
+ a.session,
+ base.host.policy,
+ observation,
+ review
+ );
+ }
+ function stop(expired = false) {
+ if (!reader) return;
+ if (recovered) {
+ if (expired)
+ expireRecoveredInboxProbeNonceReaderWait(
+ reader as RecoveredInboxProbeNonceReader
+ );
+ else
+ stopRecoveredInboxProbeNonceReader(
+ reader as RecoveredInboxProbeNonceReader
+ );
+ } else if (expired)
+ expireInboxProbeNonceReaderWait(reader as InboxProbeNonceReader);
+ else stopInboxProbeNonceReader(reader as InboxProbeNonceReader);
+ }
+ function lose(kind: 'reader' | 'expiry' | 'controller' | 'head' | 'session') {
+ if (kind === 'reader' || kind === 'expiry') stop(kind === 'expiry');
+ else if (kind === 'head') base.actors().churnHead();
+ else if (kind === 'session') closePrivateSession(base.actors().session);
+ else base.stop();
+ }
+ return {
+ ...base,
+ observation: () => observation,
+ nonceReader: () => reader,
+ nonceProof: () => proof,
+ nonceAcknowledgement: () => acknowledgement,
+ captureNonce: capture,
+ lose,
+ async prepareRead(useRecovered: boolean, apply = true) {
+ stop();
+ reader = undefined;
+ proof = undefined;
+ acknowledgement = undefined;
+ recovered = useRecovered;
+ if (recovered) {
+ await base.freshSession();
+ if (
+ (await base.recover())?.status !== 'recovered' ||
+ (await base.adopt()).status !== 'adopted' ||
+ !(await base.captureAction())
+ )
+ throw Error('actual recovered original Retry setup');
+ }
+ const pub = recovered
+ ? await base.publish()
+ : await base.originalPublish();
+ if (
+ pub?.status !== 'accepted' ||
+ (await base.append(pub)).status !== 'saved'
+ )
+ throw Error('actual original archive effect and native append');
+ observation = recovered ? await base.read() : await base.originalRead();
+ if (observation?.status !== 'readback')
+ throw Error('actual original B2 readback');
+ if (apply && (await base.appendRead(observation)).status !== 'saved')
+ throw Error('actual original B2 native append');
+ return observation;
+ },
+ applyRead: () => observation && base.appendRead(observation),
+ async nonce(selected = (reader ??= capture())) {
+ if (!selected) return { status: 'invalid' as const };
+ reader ??= selected;
+ const result = recovered
+ ? await readRecoveredInboxProbeNonce(
+ selected as RecoveredInboxProbeNonceReader
+ )
+ : await readInboxProbeNonce(selected as InboxProbeNonceReader);
+ if ('proof' in result) proof = result.proof;
+ return result;
+ },
+ async appendNonce() {
+ if (!proof) throw Error('actual nonce proof required');
+ const result = await commitInboxProbeNonceVerification(
+ base.repository,
+ base.actors().session,
+ base.host.policy,
+ proof
+ );
+ if (result.acknowledgement) acknowledgement = result.acknowledgement;
+ return result;
+ },
+ nonceBinding: () =>
+ acknowledgement &&
+ inboxProbeNonceAcknowledgementBinding(
+ base.repository,
+ base.actors().session,
+ acknowledgement,
+ base.host.policy
+ ),
+ async storedRow() {
+ const row = (await base.host.stored()).find(
+ (x) => x.id === base.command()
+ );
+ if (!row) throw Error('actual selected native row missing');
+ return row;
+ },
+ async handwrittenNonceSuccessor() {
+ if (!proof || !observation)
+ throw Error('actual genuine nonce and read evidence required');
+ const evidence = inboxProbeNonceVerificationEvidence(
+ proof,
+ base.repository,
+ base.actors().session,
+ base.host.policy
+ ),
+ effect = inboxProbeReadbackAttemptEvidence(observation),
+ row = (await base.host.stored()).find((x) => x.id === base.command());
+ if (!evidence || !effect || !row)
+ throw Error('actual current fixture source associations');
+ const record = JSON.parse(row.wire) as {
+ revision: number;
+ receipts: PrivateAccessProbeReceipt[];
+ },
+ fact = JSON.parse(effect.receiptWire) as PrivateAccessProbeReceipt,
+ candidate = decodePrivateRecord(
+ JSON.stringify({
+ ...record,
+ revision: record.revision + 1,
+ receipts: [
+ ...record.receipts,
+ {
+ ...fact,
+ status: 'nonce_verified',
+ observedAtMilliseconds: evidence.verifiedAtMilliseconds
+ }
+ ]
+ }),
+ row.owner,
+ row.id
+ );
+ if (!candidate.ok)
+ throw Error('actual strict codec handwritten successor');
+ const wire = privateRecordWire(candidate.value, row.owner, row.id);
+ if (!wire) throw Error('actual strict canonical successor wire');
+ return { ...row, wire };
+ },
+ nativeReadonlyHook(
+ hit: number,
+ kind: 'before_abort' | 'after_abort' | 'callback',
+ callback = () => {}
+ ) {
+ const original = Object.getOwnPropertyDescriptor(
+ IDBIndex.prototype,
+ 'openCursor'
+ )!.value as IDBIndex['openCursor'];
+ let hits = 0,
+ faults = 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' &&
+ ++hits === hit
+ ) {
+ faults++;
+ const tx = this.objectStore.transaction;
+ if (kind === 'before_abort') tx.abort();
+ else if (kind === 'after_abort')
+ request.addEventListener('success', () => {
+ if (!request.result) tx.abort();
+ });
+ else callback();
+ }
+ return request;
+ };
+ return {
+ faults: () => faults,
+ restore: retain(() => {
+ IDBIndex.prototype.openCursor = original;
+ })
+ };
+ },
+ nativeWriteHook(callback: () => void) {
+ const original = Object.getOwnPropertyDescriptor(
+ IDBObjectStore.prototype,
+ 'put'
+ )!.value as IDBObjectStore['put'];
+ let hits = 0;
+ IDBObjectStore.prototype.put = function (
+ ...args: Parameters<IDBObjectStore['put']>
+ ) {
+ const request = original.apply(this, args);
+ if (this.name === 'private_sends' && !hits++)
+ request.addEventListener('success', callback, { once: true });
+ return request;
+ };
+ return {
+ hits: () => hits,
+ restore: retain(() => {
+ IDBObjectStore.prototype.put = original;
+ })
+ };
+ },
+ clockHook(callback: () => void) {
+ const original = Date.now;
+ let hits = 0;
+ Date.now = () => {
+ if (!hits++) callback();
+ return original();
+ };
+ return {
+ hits: () => hits,
+ restore: retain(() => {
+ Date.now = original;
+ })
+ };
+ },
+ close() {
+ for (const off of restores) off();
+ restores.clear();
+ stop();
+ base.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/inbox-probe-nonce-facts.spec.ts b/web/tests/e2e/inbox-probe-nonce-facts.spec.ts
@@ -0,0 +1,1295 @@
+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-nonce-facts.ts';
+declare global {
+ interface Window {
+ nf: typeof Fixture;
+ nfFixture: Awaited<ReturnType<typeof Fixture.makeNonceFactsFixture>>;
+ nfPending?: Promise<unknown>;
+ nfRestore?: () => void;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string,
+ head = '';
+const origins = [
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ],
+ physical = new Set<WebSocket>(),
+ 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'
+ )!;
+ 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)) {
+ 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 };
+ archived.set(JSON.stringify([origin, 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-nonce-facts.ts', import.meta.url)
+ ),
+ name: 'nf',
+ 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);
+ 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);
+ }
+ };
+ },
+ { endpoint, origins }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ head = await page.evaluate(async (origins) => {
+ window.nfFixture = await window.nf.makeNonceFactsFixture();
+ return window.nfFixture.host.preferenceWire(origins);
+ }, origins);
+ await page.evaluate(async () => {
+ const f = window.nfFixture;
+ 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.nfRestore?.();
+ window.nfFixture.host.mode('normal');
+ window.nfFixture.host.settle();
+ window.nfFixture.close();
+ await window.nfPending;
+ });
+});
+async function setup(page: Page, recovered = true, apply = true) {
+ expect(
+ await page.evaluate(
+ async ({ recovered, apply }) =>
+ (await window.nfFixture.prepareRead(recovered, apply)).status,
+ { recovered, apply }
+ )
+ ).toBe('readback');
+}
+async function verify(page: Page) {
+ expect(
+ await page.evaluate(async () => (await window.nfFixture.nonce()).status)
+ ).toBe('nonce_verified');
+}
+async function wire(page: Page) {
+ return page.evaluate(async () => (await window.nfFixture.storedRow()).wire);
+}
+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'} genuine nonce fact has exact native lineage, idempotence and separate opaque acknowledgement`, async ({
+ page
+ }) => {
+ await setup(page, recovered);
+ const predecessor = await wire(page),
+ net = traffic().length;
+ const result = await page.evaluate(async (recovered) => {
+ const f = window.nfFixture,
+ before = f.host.counts(),
+ first = f.captureNonce()!,
+ second = f.captureNonce(),
+ read = await f.nonce(first),
+ afterRead = f.host.counts(),
+ again = await f.nonce(first),
+ firstSave = await f.appendNonce(),
+ afterSave = (await f.storedRow()).wire,
+ secondSave = await f.appendNonce(),
+ binding = f.nonceBinding(),
+ proof = f.nonceProof()!,
+ ack = f.nonceAcknowledgement()!,
+ a = f.actors();
+ return {
+ sameReader: first === second,
+ read: read.status,
+ again: again.status,
+ before,
+ afterRead,
+ afterSaveCounts: f.host.counts(),
+ firstSave: firstSave.status,
+ secondSave: secondSave.status,
+ sameAck: firstSave.acknowledgement === secondSave.acknowledgement,
+ provenance: firstSave.provenance,
+ afterSave,
+ final: (await f.storedRow()).wire,
+ proofKeys: Object.keys(proof),
+ ackKeys: Object.keys(ack),
+ current: binding?.current(),
+ copy: !!window.nf.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ a.session,
+ { ...ack },
+ f.host.policy
+ ),
+ crossReader: recovered
+ ? (
+ await window.nf.readInboxProbeNonce(
+ first as unknown as Parameters<
+ typeof window.nf.readInboxProbeNonce
+ >[0]
+ )
+ ).status
+ : (
+ await window.nf.readRecoveredInboxProbeNonce(
+ first as unknown as Parameters<
+ typeof window.nf.readRecoveredInboxProbeNonce
+ >[0]
+ )
+ ).status,
+ crossProof: recovered
+ ? !!window.nf.inboxProbeNonceProofBinding(
+ proof as unknown as Parameters<
+ typeof window.nf.inboxProbeNonceProofBinding
+ >[0],
+ f.repository,
+ a.session,
+ f.host.policy
+ )
+ : !!window.nf.recoveredInboxProbeNonceProofBinding(
+ proof as unknown as Parameters<
+ typeof window.nf.recoveredInboxProbeNonceProofBinding
+ >[0],
+ f.repository,
+ a.session,
+ f.host.policy
+ ),
+ crossCapture: recovered
+ ? !!window.nf.captureInboxProbeNonceReader(
+ f.repository,
+ a.identity,
+ a.session,
+ f.host.policy,
+ f.observation()!,
+ 'reviewed_inbox_probe_nonce_decryption'
+ )
+ : !!window.nf.captureRecoveredInboxProbeNonceReader(
+ f.repository,
+ a.identity,
+ a.session,
+ f.host.policy,
+ f.observation()!,
+ 'reviewed_inbox_probe_nonce_decryption'
+ ),
+ settlement: window.nf.privateRecordSettlement(binding!.record),
+ ordinaryCleanup: !!(await window.nf.capturePrivateOutboxCleanup(
+ f.repository,
+ a.session,
+ [f.command()],
+ 'reviewed_settled_outbox_selection'
+ )),
+ readiness: window.nf.inboxAccessControllerSnapshot(a.access)?.readiness
+ };
+ }, recovered);
+ const before = JSON.parse(predecessor) as {
+ revision: number;
+ receipts: Record<string, unknown>[];
+ self: unknown;
+ },
+ after = JSON.parse(result.final) as typeof before;
+ expect(result.sameReader && result.sameAck && result.current).toBe(true);
+ expect(result.read).toBe('nonce_verified');
+ expect(result.again).toBe('nonce_verified');
+ expect(result.firstSave).toBe('saved');
+ expect(result.secondSave).toBe('existing');
+ expect(result.provenance).toBe('current');
+ expect(result.afterRead).toEqual({
+ ...result.before,
+ keys: result.before.keys + 3,
+ decrypts: result.before.decrypts + 2
+ });
+ expect(result.afterSaveCounts).toEqual(result.afterRead);
+ expect(result.afterSave).toBe(result.final);
+ expect(after).toEqual({
+ ...before,
+ revision: before.revision + 1,
+ receipts: [
+ ...before.receipts,
+ {
+ ...before.receipts.at(-1),
+ status: 'nonce_verified',
+ observedAtMilliseconds: expect.any(Number)
+ }
+ ]
+ });
+ expect(result.proofKeys).toEqual([]);
+ expect(result.ackKeys).toEqual([]);
+ expect(
+ result.copy ||
+ result.crossProof ||
+ result.crossCapture ||
+ result.ordinaryCleanup
+ ).toBe(false);
+ expect(result.crossReader).toBe('invalid');
+ expect(result.settlement).toBe('protected');
+ expect(result.readiness).toBe('unavailable');
+ expect(traffic()).toHaveLength(net);
+ });
+
+ test(`${recovered ? 'recovered' : 'original'} genuinely decrypted but un-applied B2 cannot append until that exact source observation commits`, async ({
+ page
+ }) => {
+ await setup(page, recovered, false);
+ await verify(page);
+ const predecessor = await wire(page);
+ const first = await page.evaluate(async () => {
+ const f = window.nfFixture,
+ before = f.host.counts(),
+ result = await f.appendNonce();
+ return {
+ status: result.status,
+ ack: !!result.acknowledgement,
+ before,
+ after: f.host.counts()
+ };
+ });
+ expect(first.status).toBe('invalid');
+ expect(first.ack).toBe(false);
+ expect(first.after).toEqual(first.before);
+ expect(await wire(page)).toBe(predecessor);
+ expect(
+ await page.evaluate(
+ async () => (await window.nfFixture.applyRead())?.status
+ )
+ ).toBe('saved');
+ expect(
+ await page.evaluate(
+ async () => (await window.nfFixture.appendNonce()).status
+ )
+ ).toBe('saved');
+ });
+}
+
+for (const review of [undefined, null, false, 'reviewed_private_decryption'])
+ test(`recovered nonce capture refuses wrong explicit consent ${String(review)}`, async ({
+ page
+ }) => {
+ await setup(page);
+ const result = await page.evaluate((review) => {
+ const f = window.nfFixture,
+ a = f.actors(),
+ before = f.host.counts();
+ return {
+ accepted: !!window.nf.captureRecoveredInboxProbeNonceReader(
+ f.repository,
+ a.identity,
+ a.session,
+ f.host.policy,
+ f.observation()!,
+ review
+ ),
+ before,
+ after: f.host.counts()
+ };
+ }, review);
+ expect(result.accepted).toBe(false);
+ expect(result.after).toEqual(result.before);
+ });
+
+for (const recovered of [false, true])
+ for (const fault of ['repository', 'session', 'policy'] as const)
+ test(`${recovered ? 'recovered' : 'original'} genuine nonce proof and acknowledgement reject foreign ${fault} at the actual issuer`, async ({
+ page
+ }) => {
+ await setup(page, recovered);
+ await verify(page);
+ const predecessor = await wire(page),
+ net = traffic().length;
+ const result = await page.evaluate(async (fault) => {
+ const f = window.nfFixture,
+ a = f.actors(),
+ identity = window.nf.createIdentitySession();
+ await window.nf.connectIdentity(identity);
+ await window.nf.probeIdentityMessaging(identity, 'reviewed_self_copy');
+ const foreignSession = await window.nf.createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ if (!foreignSession) throw Error('actual foreign same-owner session');
+ const repository = fault === 'repository' ? a.repository : f.repository,
+ session = fault === 'session' ? foreignSession : a.session,
+ policy = fault === 'policy' ? f.host.copiedPolicy() : f.host.policy,
+ before = f.host.counts(),
+ writes = f.nativeWriteHook(() => {});
+ window.nfRestore = writes.restore;
+ const refused = await window.nf.commitInboxProbeNonceVerification(
+ repository,
+ session,
+ policy,
+ f.nonceProof()!
+ ),
+ refusedWire = (await f.storedRow()).wire,
+ refusedWrites = writes.hits(),
+ saved = await f.appendNonce(),
+ acknowledgement = f.nonceAcknowledgement();
+ if (!acknowledgement)
+ throw Error('actual legitimate nonce acknowledgement');
+ const wrong = window.nf.inboxProbeNonceAcknowledgementBinding(
+ repository,
+ session,
+ acknowledgement,
+ policy
+ ),
+ copied = window.nf.inboxProbeNonceAcknowledgementBinding(
+ f.repository,
+ a.session,
+ { ...acknowledgement },
+ f.host.policy
+ ),
+ current = f.nonceBinding()?.current(),
+ after = f.host.counts(),
+ totalWrites = writes.hits();
+ writes.restore();
+ window.nf.closePrivateSession(foreignSession);
+ window.nf.disconnectIdentity(identity);
+ return {
+ refused: refused.status,
+ refusedAck: !!refused.acknowledgement,
+ refusedWire,
+ refusedWrites,
+ saved: saved.status,
+ wrong: !!wrong,
+ copied: !!copied,
+ current,
+ before,
+ after,
+ totalWrites
+ };
+ }, fault);
+ expect(result.refused).toBe('invalid');
+ expect(result.refusedAck || result.wrong || result.copied).toBe(false);
+ expect(result.refusedWire).toBe(predecessor);
+ expect(result.refusedWrites).toBe(0);
+ expect(result.saved).toBe('saved');
+ expect(result.totalWrites).toBe(1);
+ expect(result.current).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(traffic()).toHaveLength(net);
+ });
+
+test('copied proof, C2A recovery proof, recovered ACK and nonce status labels have no nonce-fact authority', async ({
+ page
+}) => {
+ await setup(page);
+ await verify(page);
+ const predecessor = await wire(page),
+ net = traffic().length;
+ const result = await page.evaluate(async () => {
+ const f = window.nfFixture,
+ before = f.host.counts(),
+ answers: boolean[] = [];
+ for (const fake of [
+ { ...f.nonceProof()! },
+ f.proof(),
+ f.acknowledgement(),
+ { status: 'nonce_verified', proof: f.nonceProof(), current: () => true }
+ ]) {
+ const result = await window.nf.commitInboxProbeNonceVerification(
+ f.repository,
+ f.actors().session,
+ f.host.policy,
+ fake as Parameters<
+ typeof window.nf.commitInboxProbeNonceVerification
+ >[3]
+ );
+ answers.push(
+ !!result.acknowledgement ||
+ ['saved', 'reconciled', 'existing'].includes(result.status)
+ );
+ }
+ return { answers, before, after: f.host.counts() };
+ });
+ expect(result.answers).toEqual([false, false, false, false]);
+ expect(result.after).toEqual(result.before);
+ expect(await wire(page)).toBe(predecessor);
+ expect(traffic()).toHaveLength(net);
+});
+
+for (const fault of ['repository', 'policy', 'identity', 'session'] as const)
+ test(`genuine recovered observation rejects same-owner foreign ${fault} association`, async ({
+ page
+ }) => {
+ await setup(page);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.nfFixture,
+ a = f.actors(),
+ identity = window.nf.createIdentitySession();
+ await window.nf.connectIdentity(identity);
+ await window.nf.probeIdentityMessaging(identity, 'reviewed_self_copy');
+ const session = await window.nf.createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ if (!session) throw Error('genuine foreign same-owner private session');
+ const before = f.host.counts();
+ const reader = window.nf.captureRecoveredInboxProbeNonceReader(
+ fault === 'repository' ? a.repository : f.repository,
+ fault === 'identity' ? identity : a.identity,
+ fault === 'session' ? session : a.session,
+ fault === 'policy' ? f.host.copiedPolicy() : f.host.policy,
+ f.observation()!,
+ 'reviewed_inbox_probe_nonce_decryption'
+ );
+ const after = f.host.counts();
+ window.nf.closePrivateSession(session);
+ window.nf.disconnectIdentity(identity);
+ return { accepted: !!reader, before, after };
+ }, fault);
+ expect(result.accepted).toBe(false);
+ expect(result.after).toEqual(result.before);
+ });
+
+for (const mode of ['wrong_key', 'refuse_decrypt', 'wrong_decrypt'] as const)
+ test(`recovered nonce provider ${mode} cannot issue proof or fact`, async ({
+ page
+ }) => {
+ await setup(page);
+ const predecessor = await wire(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.nfFixture,
+ reader = f.captureNonce()!;
+ f.host.mode(mode);
+ const result = await f.nonce(reader);
+ return { status: result.status, proof: !!f.nonceProof() };
+ }, mode);
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.proof).toBe(false);
+ expect(await wire(page)).toBe(predecessor);
+ });
+
+for (const fault of [
+ 'seal_tags',
+ 'seal_kind',
+ 'seal_signature',
+ 'rumor_nonce',
+ 'rumor_hash',
+ 'rumor_time',
+ 'rumor_owner',
+ 'rumor_serialization'
+] as const)
+ test(`actual recovered decrypted ${fault} refuses nonce proof`, async ({
+ page
+ }) => {
+ await setup(page);
+ const predecessor = await wire(page);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.nfFixture,
+ restore = f.host.decryptCallback(
+ fault.startsWith('seal_') ? 1 : 2,
+ (wire) => {
+ if (fault === 'seal_tags')
+ return f.host.signSeal(wire, { tags: [['p', f.host.owner]] });
+ if (fault === 'seal_kind')
+ return f.host.signSeal(wire, { kind: 14 });
+ if (fault === 'rumor_serialization') return wire + '\n';
+ const data = JSON.parse(wire) as {
+ sig?: string;
+ content?: string;
+ id?: string;
+ created_at?: number;
+ pubkey?: string;
+ };
+ if (fault === 'seal_signature') data.sig = '0'.repeat(128);
+ if (fault === 'rumor_nonce')
+ data.content = 'different diagnostic nonce';
+ if (fault === 'rumor_hash') data.id = 'f'.repeat(64);
+ if (fault === 'rumor_time')
+ data.created_at = (data.created_at ?? 0) + 1;
+ if (fault === 'rumor_owner') data.pubkey = 'f'.repeat(64);
+ return JSON.stringify(data);
+ }
+ );
+ window.nfRestore = () => restore.restore();
+ return {
+ status: (await f.nonce()).status,
+ proof: !!f.nonceProof(),
+ receivers: restore.receivers()
+ };
+ }, fault);
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.proof).toBe(false);
+ expect(result.receivers).toBeGreaterThan(0);
+ expect(await wire(page)).toBe(predecessor);
+ });
+
+for (const mutation of [
+ 'alias',
+ 'own_tail',
+ 'foreign_tail',
+ 'missing'
+] as const)
+ test(`nonce initial complete physical namespace handles ${mutation}`, async ({
+ page
+ }) => {
+ await setup(page);
+ const result = await page.evaluate(async (mutation) => {
+ const f = window.nfFixture,
+ reader = f.captureNonce()!,
+ row = await f.storedRow();
+ if (mutation === 'alias')
+ await f.host.inject([{ ...row, wire: row.wire + '\n' }]);
+ else if (mutation === 'own_tail' || mutation === 'foreign_tail')
+ await f.host.inject([
+ {
+ owner: mutation === 'own_tail' ? row.owner : 'f'.repeat(64),
+ id: crypto.randomUUID(),
+ wire: 'unknown owner tail'
+ }
+ ]);
+ else {
+ const opened = await window.nf.openBrowserDatabase();
+ if (opened.state !== 'ready')
+ throw Error('actual fixture native deletion');
+ const tx = window.nf.browserDatabaseTransaction(
+ opened.owner,
+ ['private_sends'],
+ 'readwrite'
+ );
+ tx.objectStore('private_sends').delete([row.owner, row.id]);
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('actual fixture delete abort'))
+ );
+ });
+ window.nf.closeBrowserDatabase(opened.owner);
+ }
+ const before = f.host.counts(),
+ raw = await f.host.stored(),
+ result = await f.nonce(reader);
+ return {
+ status: result.status,
+ before,
+ after: f.host.counts(),
+ raw,
+ final: await f.host.stored()
+ };
+ }, mutation);
+ expect(result.status === 'nonce_verified').toBe(
+ mutation === 'foreign_tail'
+ );
+ if (mutation !== 'foreign_tail')
+ expect(result.after).toEqual(result.before);
+ expect(result.final).toEqual(result.raw);
+ });
+
+for (const hit of [1, 2, 3])
+ for (const fault of ['head', 'session', 'native'] as const)
+ test(`recovered nonce actual key${hit} ${fault} churn fences proof mint`, async ({
+ page
+ }) => {
+ await setup(page);
+ const result = await page.evaluate(
+ async ({ hit, fault }) => {
+ const f = window.nfFixture,
+ row = await f.storedRow(),
+ reader = f.captureNonce()!;
+ window.nfRestore = f.host.keyCallback(hit, async () => {
+ if (fault === 'native')
+ await f.host.inject([{ ...row, wire: row.wire + '\n' }]);
+ else f.lose(fault);
+ });
+ return {
+ status: (await f.nonce(reader)).status,
+ proof: !!f.nonceProof()
+ };
+ },
+ { hit, fault }
+ );
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.proof).toBe(false);
+ });
+
+for (const hit of [1, 2])
+ for (const fault of ['before_abort', 'after_abort'] as const)
+ test(`recovered nonce readonly${hit} ${fault} requires actual native completion`, async ({
+ page
+ }) => {
+ await setup(page);
+ const predecessor = await wire(page);
+ const result = await page.evaluate(
+ async ({ hit, fault }) => {
+ const f = window.nfFixture,
+ reader = f.captureNonce()!,
+ hook = f.nativeReadonlyHook(hit, fault);
+ window.nfRestore = hook.restore;
+ return {
+ status: (await f.nonce(reader)).status,
+ proof: !!f.nonceProof(),
+ faults: hook.faults()
+ };
+ },
+ { hit, fault }
+ );
+ expect(result.faults).toBe(1);
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.proof).toBe(false);
+ expect(await wire(page)).toBe(predecessor);
+ });
+
+for (const kind of [
+ 'reader',
+ 'expiry',
+ 'controller',
+ 'head',
+ 'session'
+] as const) {
+ test(`stopped ${kind} proof BEFORE append admission has zero native write`, async ({
+ page
+ }) => {
+ await setup(page);
+ await verify(page);
+ const predecessor = await wire(page);
+ const result = await page.evaluate(async (kind) => {
+ const f = window.nfFixture,
+ before = f.host.counts();
+ f.lose(kind);
+ const saved = await f.appendNonce();
+ return {
+ status: saved.status,
+ ack: !!saved.acknowledgement,
+ before,
+ after: f.host.counts()
+ };
+ }, kind);
+ expect(['saved', 'existing', 'reconciled']).not.toContain(result.status);
+ expect(result.ack).toBe(false);
+ expect(result.after).toEqual(result.before);
+ expect(await wire(page)).toBe(predecessor);
+ });
+ test(`actual ${kind} loss AFTER native append admission can retain history but no current acknowledgement`, async ({
+ page
+ }) => {
+ await setup(page);
+ await verify(page);
+ const result = await page.evaluate(async (kind) => {
+ const f = window.nfFixture,
+ hook = f.nativeWriteHook(() => f.lose(kind));
+ window.nfRestore = hook.restore;
+ const saved = await f.appendNonce(),
+ row = JSON.parse((await f.storedRow()).wire) as {
+ receipts: { status: string }[];
+ };
+ return {
+ status: saved.status,
+ ack: !!saved.acknowledgement,
+ binding: !!f.nonceBinding(),
+ provenance: saved.provenance,
+ last: row.receipts.at(-1)?.status,
+ hits: hook.hits()
+ };
+ }, kind);
+ expect(result.hits).toBe(1);
+ expect(result.last).toBe('nonce_verified');
+ expect(result.ack || result.binding).toBe(false);
+ expect(result.provenance).not.toBe('current');
+ });
+ test(`actual ${kind} loss DURING initial native read precedes append admission and has zero put`, async ({
+ page
+ }) => {
+ await setup(page);
+ await verify(page);
+ const predecessor = await wire(page);
+ const result = await page.evaluate(async (kind) => {
+ const f = window.nfFixture,
+ genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence(
+ f.nonceProof()!,
+ f.repository,
+ f.actors().session,
+ f.host.policy
+ ),
+ before = f.host.counts(),
+ writes = f.nativeWriteHook(() => {}),
+ read = f.nativeReadonlyHook(1, 'callback', () => f.lose(kind));
+ window.nfRestore = () => {
+ read.restore();
+ writes.restore();
+ };
+ const result = await f.appendNonce();
+ read.restore();
+ const after = f.host.counts(),
+ puts = writes.hits();
+ writes.restore();
+ return {
+ genuineBefore,
+ faults: read.faults(),
+ puts,
+ status: result.status,
+ ack: !!result.acknowledgement,
+ binding: !!f.nonceBinding(),
+ before,
+ after
+ };
+ }, kind);
+ expect(result.genuineBefore).toBe(true);
+ expect(result.faults).toBe(1);
+ expect(result.puts).toBe(0);
+ expect(result.ack || result.binding).toBe(false);
+ expect(['saved', 'reconciled', 'existing']).not.toContain(result.status);
+ expect(result.after).toEqual(result.before);
+ expect(await wire(page)).toBe(predecessor);
+ });
+}
+
+for (const timing of ['after_confirmed_abort', 'between_read_and_cas'] as const)
+ test(`exact handwritten nonce successor ${timing} cannot acquire genuine operation provenance`, async ({
+ page
+ }) => {
+ await setup(page);
+ await verify(page);
+ const predecessor = await wire(page),
+ net = traffic().length;
+ const result = await page.evaluate(async (timing) => {
+ const f = window.nfFixture,
+ candidate = await f.handwrittenNonceSuccessor(),
+ before = f.host.counts();
+ let aborted = 0,
+ firstWire: string | undefined,
+ readHook: ReturnType<typeof f.nativeReadonlyHook> | undefined;
+ if (timing === 'after_confirmed_abort') {
+ const hook = f.installCommitFault('aborted');
+ window.nfRestore = hook.restore;
+ const first = await f.appendNonce();
+ hook.restore();
+ if (first.acknowledgement)
+ throw Error('aborted append cannot acknowledge');
+ firstWire = (await f.storedRow()).wire;
+ // The port can report failure before native abort dispatch. Observe
+ // the following real readonly completion before sampling its event.
+ aborted = hook.counts().aborted;
+ await f.host.inject([candidate]);
+ } else {
+ readHook = f.nativeReadonlyHook(1, 'callback', () => {
+ window.nfPending = f.host.inject([candidate]);
+ });
+ window.nfRestore = readHook.restore;
+ }
+ const genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence(
+ f.nonceProof()!,
+ f.repository,
+ f.actors().session,
+ f.host.policy
+ ),
+ saved = await f.appendNonce();
+ await window.nfPending;
+ window.nfRestore?.();
+ return {
+ genuineBefore,
+ aborted,
+ firstWire,
+ faults: readHook?.faults(),
+ status: saved.status,
+ ack: !!saved.acknowledgement,
+ binding: !!f.nonceBinding(),
+ candidate: candidate.wire,
+ actual: (await f.storedRow()).wire,
+ before,
+ after: f.host.counts()
+ };
+ }, timing);
+ expect(result.genuineBefore).toBe(true);
+ if (timing === 'after_confirmed_abort') {
+ expect(result.aborted).toBe(1);
+ expect(result.firstWire).toBe(predecessor);
+ } else expect(result.faults).toBe(1);
+ expect(result.status).toBe('conflict');
+ expect(result.ack || result.binding).toBe(false);
+ expect(result.actual).toBe(result.candidate);
+ expect(result.actual).not.toBe(predecessor);
+ expect(result.after).toEqual(result.before);
+ expect(traffic()).toHaveLength(net);
+ });
+
+for (const fault of ['aborted', 'uncertain', 'changed_successor'] as const)
+ test(`nonce append actual native ${fault} preserves exact outcome and genuine reconciliation`, async ({
+ page
+ }) => {
+ await setup(page);
+ await verify(page);
+ const predecessor = await wire(page);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.nfFixture,
+ hook = f.installCommitFault(fault);
+ window.nfRestore = hook.restore;
+ const result = await f.appendNonce();
+ hook.restore();
+ const first = (await f.storedRow()).wire,
+ again = await f.appendNonce();
+ return {
+ status: result.status,
+ ack: !!result.acknowledgement,
+ provenance: result.provenance,
+ first,
+ counts: hook.counts(),
+ again: again.status,
+ againAck: !!again.acknowledgement
+ };
+ }, fault);
+ expect(result.counts.putSuccess).toBe(1);
+ if (fault === 'aborted') {
+ expect(result.ack).toBe(false);
+ expect(result.first).toBe(predecessor);
+ expect(result.counts.aborted).toBe(1);
+ expect(result.again).toBe('saved');
+ expect(result.againAck).toBe(true);
+ } else if (fault === 'uncertain') {
+ expect(result.status).toBe('reconciled');
+ expect(result.ack).toBe(true);
+ expect(result.counts.complete).toBe(1);
+ expect(result.again).toBe('existing');
+ expect(result.againAck).toBe(true);
+ } else {
+ expect(result.status).toBe('conflict');
+ expect(result.ack || result.againAck).toBe(false);
+ }
+ });
+
+for (const hit of [1, 2])
+ for (const fault of ['before_abort', 'after_abort'] as const)
+ test(`nonce fact readonly${hit} ${fault} cannot fabricate completion and later exact operation may reconcile`, async ({
+ page
+ }) => {
+ await setup(page);
+ await verify(page);
+ const predecessor = await wire(page);
+ const result = await page.evaluate(
+ async ({ hit, fault }) => {
+ const f = window.nfFixture,
+ hook = f.nativeReadonlyHook(hit, fault);
+ window.nfRestore = hook.restore;
+ const result = await f.appendNonce();
+ hook.restore();
+ const first = (await f.storedRow()).wire,
+ next = await f.appendNonce();
+ return {
+ status: result.status,
+ ack: !!result.acknowledgement,
+ first,
+ faults: hook.faults(),
+ next: next.status,
+ nextAck: !!next.acknowledgement
+ };
+ },
+ { hit, fault }
+ );
+ expect(result.faults).toBe(1);
+ expect(result.ack).toBe(false);
+ if (hit === 1) {
+ expect(result.first).toBe(predecessor);
+ expect(result.next).toBe('saved');
+ } else {
+ expect(result.first).not.toBe(predecessor);
+ expect(result.next).toBe('reconciled');
+ }
+ expect(result.nextAck).toBe(true);
+ });
+
+for (const recovered of [false, true])
+ for (const contention of ['owner_lock', 'shared_sdk_job'] as const)
+ test(`${recovered ? 'recovered' : 'original'} genuine nonce append respects actual occupied ${contention} and preserves explicit same-proof retry`, async ({
+ page
+ }) => {
+ await setup(page, recovered);
+ await verify(page);
+ const predecessor = await wire(page),
+ net = traffic().length;
+ const result = await page.evaluate(async (contention) => {
+ const f = window.nfFixture,
+ a = f.actors(),
+ proof = f.nonceProof()!;
+ let entered: (() => void) | undefined,
+ release: (() => void) | undefined;
+ const ready = new Promise<void>((resolve) => {
+ entered = resolve;
+ });
+ async function hold() {
+ entered?.();
+ await new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ }
+ const held =
+ contention === 'owner_lock'
+ ? navigator.locks.request(
+ 'harvestcircle:owner:' + f.host.owner,
+ { mode: 'exclusive' },
+ hold
+ )
+ : window.nf.withIdlePrivateLocalStorage(a.session, hold);
+ window.nfPending = held;
+ await ready;
+ const genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence(
+ proof,
+ f.repository,
+ a.session,
+ f.host.policy
+ ),
+ before = f.host.counts(),
+ reads = f.nativeReadonlyHook(1, 'callback'),
+ writes = f.nativeWriteHook(() => {});
+ window.nfRestore = () => {
+ reads.restore();
+ writes.restore();
+ release?.();
+ };
+ let refused;
+ try {
+ const saved = await f.appendNonce();
+ refused = {
+ status: saved.status,
+ ack: !!saved.acknowledgement,
+ binding: !!f.nonceBinding(),
+ reads: reads.faults(),
+ puts: writes.hits(),
+ after: f.host.counts()
+ };
+ } finally {
+ reads.restore();
+ writes.restore();
+ release?.();
+ await held;
+ }
+ const refusedWire = (await f.storedRow()).wire,
+ sameProof =
+ f.nonceProof() === proof &&
+ !!window.nf.inboxProbeNonceVerificationEvidence(
+ proof,
+ f.repository,
+ a.session,
+ f.host.policy
+ ),
+ writesAfterRelease = f.nativeWriteHook(() => {});
+ window.nfRestore = writesAfterRelease.restore;
+ const first = await f.appendNonce(),
+ again = await f.appendNonce(),
+ putsAfterRelease = writesAfterRelease.hits();
+ writesAfterRelease.restore();
+ return {
+ genuineBefore,
+ before,
+ refused,
+ refusedWire,
+ sameProof,
+ first: first.status,
+ again: again.status,
+ sameAck: first.acknowledgement === again.acknowledgement,
+ current: f.nonceBinding()?.current(),
+ putsAfterRelease,
+ after: f.host.counts()
+ };
+ }, contention);
+ expect(result.genuineBefore && result.sameProof).toBe(true);
+ expect(result.refused).toEqual({
+ status: 'busy',
+ ack: false,
+ binding: false,
+ reads: 0,
+ puts: 0,
+ after: result.before
+ });
+ expect(result.refusedWire).toBe(predecessor);
+ expect(result.first).toBe('saved');
+ expect(result.again).toBe('existing');
+ expect(result.sameAck && result.current).toBe(true);
+ expect(result.putsAfterRelease).toBe(1);
+ expect(result.after).toEqual(result.before);
+ expect(traffic()).toHaveLength(net);
+ });
+
+test('genuine proof and native admission serialize parallel nonce append without extra SDK work', async ({
+ page
+}) => {
+ await setup(page);
+ await verify(page);
+ const result = await page.evaluate(async () => {
+ const f = window.nfFixture,
+ before = f.host.counts(),
+ pair = await Promise.all([f.appendNonce(), f.appendNonce()]),
+ row = JSON.parse((await f.storedRow()).wire) as {
+ receipts: { status: string }[];
+ };
+ return {
+ states: pair.map((x) => x.status).sort(),
+ facts: row.receipts.filter((x) => x.status === 'nonce_verified').length,
+ before,
+ after: f.host.counts()
+ };
+ });
+ expect(result.states).toEqual(['busy', 'saved']);
+ expect(result.facts).toBe(1);
+ expect(result.after).toEqual(result.before);
+});
+
+for (const loss of ['reader', 'head', 'session'] as const)
+ test(`actual pending decrypt ${loss} loss keeps original slot until settlement and never revives nonce proof`, async ({
+ page
+ }) => {
+ await setup(page);
+ await page.evaluate(() => {
+ const f = window.nfFixture;
+ f.host.mode('hold_decrypt');
+ window.nfPending = f.nonce();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.nfFixture.host.waiting()))
+ .toBe('decrypt');
+ const result = await page.evaluate(async (loss) => {
+ const f = window.nfFixture;
+ f.lose(loss);
+ const before = f.host.counts(),
+ busy = await window.nf.withIdlePrivateLocalStorage(
+ f.actors().session,
+ () => Promise.resolve('unreachable')
+ );
+ const after = f.host.counts();
+ f.host.mode('normal');
+ f.host.settle();
+ await window.nfPending;
+ return {
+ busy: busy.ok,
+ before,
+ after,
+ proof: !!f.nonceProof(),
+ binding: !!f.nonceBinding()
+ };
+ }, loss);
+ expect(result.busy || result.proof || result.binding).toBe(false);
+ expect(result.after).toEqual(result.before);
+ });
+
+for (const kind of ['head', 'native', 'reentry'] as const)
+ test(`actual final nonce clock ${kind} callback is fenced before physical read and proof mint`, async ({
+ page
+ }) => {
+ await setup(page);
+ const result = await page.evaluate(async (kind) => {
+ const f = window.nfFixture,
+ row = await f.storedRow(),
+ reader = f.captureNonce()!;
+ let same = false;
+ const hook = f.clockHook(() => {
+ if (kind === 'head') f.lose('head');
+ else if (kind === 'native')
+ window.nfPending = f.host.inject([{ ...row, wire: row.wire + '\n' }]);
+ else same = f.captureNonce() === reader;
+ });
+ window.nfRestore = hook.restore;
+ const result = await f.nonce(reader);
+ await window.nfPending;
+ return {
+ status: result.status,
+ proof: !!f.nonceProof(),
+ hits: hook.hits(),
+ same
+ };
+ }, kind);
+ expect(result.hits).toBeGreaterThan(0);
+ expect(result.status === 'nonce_verified').toBe(kind === 'reentry');
+ expect(result.proof).toBe(kind === 'reentry');
+ if (kind === 'reentry') expect(result.same).toBe(true);
+ });
+
+test('nonce append at full100 native rows preserves all protected rows and no automatic cleanup', async ({
+ page
+}) => {
+ await setup(page);
+ await verify(page);
+ const result = await page.evaluate(async () => {
+ const f = window.nfFixture,
+ row = await f.storedRow(),
+ record = JSON.parse(row.wire) as { id: string; receipts: unknown[] },
+ others = Array.from({ length: 99 }, () => {
+ const id = crypto.randomUUID();
+ return {
+ ...row,
+ id,
+ wire: JSON.stringify({ ...record, id, receipts: [] })
+ };
+ });
+ await f.host.inject(others);
+ const saved = await f.appendNonce(),
+ final = await f.host.stored();
+ return {
+ status: saved.status,
+ ack: !!saved.acknowledgement,
+ count: final.length,
+ preserved: others.every((x) =>
+ final.some((y) => y.id === x.id && y.wire === x.wire)
+ )
+ };
+ });
+ expect(result).toEqual({
+ status: 'saved',
+ ack: true,
+ count: 100,
+ preserved: true
+ });
+});
+
+test('actual8MiB capacity refuses nonce growth while preserving current proof and every original wire', async ({
+ page
+}) => {
+ await setup(page);
+ await verify(page);
+ const result = await page.evaluate(async () => {
+ const f = window.nfFixture,
+ row = await f.storedRow(),
+ record = JSON.parse(row.wire) as {
+ id: string;
+ receipts: Record<string, unknown>[];
+ },
+ cap = 8 * 1024 * 1024,
+ bytes = (x: unknown) =>
+ new TextEncoder().encode(JSON.stringify(x)).length,
+ id = crypto.randomUUID(),
+ fact = { ...record.receipts[0], status: 'unknown' },
+ make = (n: number) => ({
+ ...row,
+ id,
+ wire: JSON.stringify({
+ ...record,
+ id,
+ receipts: Array.from({ length: n }, () => fact)
+ })
+ }),
+ zero = bytes(make(0)),
+ one = bytes(make(1)),
+ increment = bytes(make(2)) - one,
+ nonceDelta =
+ bytes({
+ ...row,
+ wire: JSON.stringify({
+ ...record,
+ receipts: [
+ ...record.receipts,
+ { ...record.receipts.at(-1), status: 'nonce_verified' }
+ ]
+ })
+ }) - bytes(row),
+ n = Math.floor((cap - bytes(row) - nonceDelta / 2 - one) / increment) + 1,
+ filler = make(n),
+ remaining = cap - bytes(row) - bytes(filler);
+ if (!(remaining > 0 && remaining < nonceDelta && zero < one))
+ throw Error('actual bounded native quota fixture');
+ await f.host.inject([filler]);
+ const saved = await f.appendNonce(),
+ final = await f.host.stored();
+ return {
+ status: saved.status,
+ ack: !!saved.acknowledgement,
+ remaining,
+ nonceDelta,
+ preserved:
+ final.some((x) => x.id === row.id && x.wire === row.wire) &&
+ final.some((x) => x.id === filler.id && x.wire === filler.wire)
+ };
+ });
+ expect(result.status).toBe('capacity');
+ expect(result.ack).toBe(false);
+ expect(result.preserved).toBe(true);
+ expect(result.remaining).toBeLessThan(result.nonceDelta);
+});
+
+test('actual maximum revision cannot append a nonce fact after genuine recovered PUB and B2', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = window.nfFixture,
+ row = await f.storedRow(),
+ record = JSON.parse(row.wire) as { revision: number };
+ record.revision = Number.MAX_SAFE_INTEGER - 2;
+ await f.host.inject([{ ...row, wire: JSON.stringify(record) }]);
+ });
+ await setup(page);
+ await verify(page);
+ const predecessor = await wire(page);
+ const result = await page.evaluate(async () => {
+ const saved = await window.nfFixture.appendNonce();
+ return { status: saved.status, ack: !!saved.acknowledgement };
+ });
+ expect(result).toEqual({ status: 'invalid_record', ack: false });
+ expect(await wire(page)).toBe(predecessor);
+});
diff --git a/web/tests/unit/inbox-probe-nonce-facts.test.ts b/web/tests/unit/inbox-probe-nonce-facts.test.ts
@@ -0,0 +1,104 @@
+import { afterEach, expect, it, vi } from 'vitest';
+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 {
+ InboxProbeNonceProof,
+ RecoveredInboxProbeNonceProof,
+ InboxProbeNonceReader,
+ RecoveredInboxProbeNonceReader
+} from '../../src/lib/nostr/self-recovery-reader.ts';
+import type { InboxProbeReadbackAttemptResult } from '../../src/lib/nostr/private-pool.ts';
+import type { InboxProbeNonceAcknowledgement } from '../../src/lib/persistence/inbox-probes.ts';
+
+afterEach(() => vi.unstubAllGlobals());
+for (const browser of [false, true])
+ it(`cold ${browser ? 'browser-shaped' : 'SSR'} nonce facts reject forged provenance before native SDK or cleanup work`, async () => {
+ vi.resetModules();
+ let effects = 0;
+ const trap = () => {
+ effects++;
+ throw Error('unadmitted nonce 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 reader = await import('../../src/lib/nostr/self-recovery-reader.ts'),
+ journal = await import('../../src/lib/persistence/inbox-probes.ts');
+ const repository = {} as PrivateStorageRepository,
+ identity = {} as IdentitySession,
+ session = {} as PrivateSession,
+ policy = {} as RelayPolicy;
+ for (const fake of [
+ undefined,
+ null,
+ false,
+ 0,
+ '',
+ Symbol(),
+ {},
+ { status: 'nonce_verified', proof: {}, current: () => true },
+ { source: 'recovered', acknowledgement: {}, nonce_verified: true }
+ ]) {
+ expect(
+ reader.captureRecoveredInboxProbeNonceReader(
+ repository,
+ identity,
+ session,
+ policy,
+ fake as InboxProbeReadbackAttemptResult,
+ 'reviewed_inbox_probe_nonce_decryption'
+ )
+ ).toBeUndefined();
+ expect(
+ await reader.readInboxProbeNonce(fake as InboxProbeNonceReader)
+ ).toEqual({ status: 'invalid' });
+ expect(
+ await reader.readRecoveredInboxProbeNonce(
+ fake as RecoveredInboxProbeNonceReader
+ )
+ ).toEqual({ status: 'invalid' });
+ expect(
+ reader.inboxProbeNonceVerificationEvidence(
+ fake as InboxProbeNonceProof | RecoveredInboxProbeNonceProof,
+ repository,
+ session,
+ policy
+ )
+ ).toBeUndefined();
+ const result = await journal.commitInboxProbeNonceVerification(
+ repository,
+ session,
+ policy,
+ fake as InboxProbeNonceProof | RecoveredInboxProbeNonceProof
+ );
+ expect('acknowledgement' in result).toBe(false);
+ expect(
+ journal.inboxProbeNonceAcknowledgementBinding(
+ repository,
+ session,
+ fake as InboxProbeNonceAcknowledgement,
+ policy
+ )
+ ).toBeUndefined();
+ reader.stopRecoveredInboxProbeNonceReader(
+ fake as RecoveredInboxProbeNonceReader
+ );
+ reader.expireRecoveredInboxProbeNonceReaderWait(
+ fake as RecoveredInboxProbeNonceReader
+ );
+ }
+ 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':
- '51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b',
+ 'a7a5b0e874c65620cd80ccb9a6a50f82a31833adb496a88f9f0daa5b74c06dfd',
'src/lib/nostr/private-publisher.ts':
'e02cdbba35b8a9c7fc5f805c8c21432d4f6eab42c6d098411613189cb6ac7caf',
'src/lib/nostr/private-pool.ts':
@@ -325,7 +325,7 @@ async function operationalFlagsAdmission(web) {
'src/lib/nostr/inbox-ingress.ts':
'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
'src/lib/persistence/inbox-probes.ts':
- '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8',
+ '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0',
'src/lib/nostr/inbox-access.ts':
'16eef55d0ffcf2c3291573ddcb0b6a1432bb77abce0017a69e9b6f82414609a7',
'src/lib/nostr/seal-builder.ts':
@@ -595,7 +595,7 @@ async function privacyDataAdmission(web) {
'src/lib/messaging/inbox-list.ts':
'9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5',
'src/lib/nostr/self-recovery-reader.ts':
- '51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b',
+ 'a7a5b0e874c65620cd80ccb9a6a50f82a31833adb496a88f9f0daa5b74c06dfd',
'src/lib/nostr/private-publisher.ts':
'e02cdbba35b8a9c7fc5f805c8c21432d4f6eab42c6d098411613189cb6ac7caf',
'src/lib/nostr/private-pool.ts':
@@ -603,7 +603,7 @@ async function privacyDataAdmission(web) {
'src/lib/nostr/inbox-ingress.ts':
'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
'src/lib/persistence/inbox-probes.ts':
- '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8',
+ '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0',
'src/lib/nostr/inbox-access.ts':
'16eef55d0ffcf2c3291573ddcb0b6a1432bb77abce0017a69e9b6f82414609a7',
'src/lib/nostr/seal-builder.ts':
@@ -2171,7 +2171,7 @@ async function inboxProbeStorageAdmission(web) {
'src/lib/persistence/private-storage.ts':
'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91',
'src/lib/persistence/inbox-probes.ts':
- '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8'
+ '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0'
};
for (const [name, pin] of Object.entries(producers)) {
const bytes = await readOwned(web, name);