commit e4e61993484bff26f5a64c9d12b2eae9010e0a6b
parent 1bc436861d733b73797ee29a3f8456e0f7315ff5
Author: triesap <tyson@radroots.org>
Date: Wed, 14 Oct 2026 20:27:45 +0000
web: Retry original recovered inbox probes
- Adopt genuine recovered probe ciphertext through exact native custody.
- Share bounded original action meters across recovered publication and readback.
- Refuse busy or failed cleanup scopes before new Retry authority.
- Verify genuine SDK, native transaction, lifecycle and capability isolation controls.
Diffstat:
11 files changed, 3043 insertions(+), 38 deletions(-)
diff --git a/web/src/lib/nostr/inbox-access.ts b/web/src/lib/nostr/inbox-access.ts
@@ -49,6 +49,7 @@ export type InboxProbeReservationResult =
}>;
type Saved = {
session: PrivateSession;
+ access: InboxAccessController;
policy: RelayPolicy;
record: PrivateAccessProbe;
handle: PrivateRecordHandle;
@@ -251,6 +252,7 @@ export async function reserveInboxProbeIdentity(
offAccess = () => {};
const saved: Saved = {
session,
+ access,
policy,
record,
handle: handle.value,
@@ -380,6 +382,19 @@ export function inboxProbePolicyMatches(
);
}
+// Only the genuine original construction chain can name its action owner.
+// Recovery has a separate proof family and cannot enter seal/wrap construction.
+export function inboxProbeActionOwner(
+ identity: InboxProbeIdentity,
+ session: PrivateSession,
+ policy: RelayPolicy
+): InboxAccessController | undefined {
+ const saved = identities.get(identity);
+ return saved && inboxProbePolicyMatches(identity, session, policy)
+ ? saved.access
+ : undefined;
+}
+
// Detached inspection only. Actual SDK decryption and original native/current
// associations are necessary to issue a recovered probe capability.
export function inboxProbeRumorMatches(
diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts
@@ -36,6 +36,7 @@ import {
} from '../config/budgets.ts';
import {
privateSessionOwnership,
+ privateSessionSnapshot,
subscribePrivateSessionClose,
recheckPrivateSession,
invalidatePrivateSessionGeneration,
@@ -261,6 +262,7 @@ type AuthControl = {
};
const authConnections = new WeakMap<PrivateAuthConnection, AuthControl>();
const pools = new WeakMap<PrivatePool, Owner>();
+const probeRetryIdle = new WeakMap<Owner, () => boolean>();
let lifetime: Owner | undefined;
type ScopeRole = 'receive' | 'delivery' | 'access';
const scopes = new WeakMap<Owner, WeakMap<object, Map<string, PrivatePool>>>();
@@ -2265,6 +2267,10 @@ export function getPrivatePool(
// Install ownership before observer registration; reentry cannot allocate a
// second private SDK. A failed close retains this unavailable page lifetime.
pools.set(token, owner);
+ probeRetryIdle.set(
+ owner,
+ () => !closed && !publishing && !busy && !liveBusy && !owner.unavailable()
+ );
lifetime = owner;
off = subscribePrivateSessionClose(session, () => owner.close());
if (!capture.current()) {
@@ -2278,6 +2284,29 @@ function ownerOf(token: PrivatePool): Owner {
if (!owner) throw new Error('private_pool_invalid');
return owner;
}
+
+// Read only the actual lifetime. This does not acquire a scope, invoke a
+// provider, reserve/start a connection or retry another owner's cleanup.
+export function privatePoolProbeRetryIdle(
+ session: PrivateSession,
+ policy: RelayPolicy
+): boolean {
+ try {
+ if (!privateSessionSnapshot(session)?.current) return false;
+ readRelayPolicy(policy);
+ const original = lifetime;
+ if (!original || original.cleaned()) return true;
+ return (
+ original.session === session &&
+ original.policy === policy &&
+ !original.closed() &&
+ !original.unavailable() &&
+ probeRetryIdle.get(original)?.() === true
+ );
+ } catch {
+ return false;
+ }
+}
export function privatePoolOrigins(token: PrivatePool): readonly string[] {
return [...ownerOf(token).origins];
}
diff --git a/web/src/lib/nostr/private-publisher.ts b/web/src/lib/nostr/private-publisher.ts
@@ -1,11 +1,22 @@
import {
inboxProbePublicationBinding,
+ recoveredInboxProbePublicationBinding,
verifyInboxProbeAcknowledgement,
type InboxProbeAcknowledgement
} from '../persistence/inbox-probes.ts';
-import type { InboxProbeIdentity } from './inbox-access.ts';
+import {
+ inboxProbeActionOwner,
+ type InboxProbeIdentity
+} from './inbox-access.ts';
+import type { RecoveredInboxProbe } from './self-recovery-reader.ts';
+import {
+ inboxAccessControllerSnapshot,
+ type InboxAccessController
+} from '../messaging/inbox-access-controller.ts';
+import { privatePoolProbeRetryIdle } from './private-pool.ts';
import {
privateSessionOwnership,
+ withIdlePrivateLocalStorage,
type PrivateSession
} from '../runtime/private-session.ts';
import {
@@ -23,7 +34,8 @@ import {
import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts';
import {
PRIVATE_TRANSPORT_BUDGETS,
- PRIVATE_PUBLICATION_BUDGETS
+ PRIVATE_PUBLICATION_BUDGETS,
+ LOCAL_PERSISTENCE_BUDGETS
} from '../config/budgets.ts';
import { newLocalId } from '../private-handles.ts';
import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
@@ -91,6 +103,14 @@ function networkMeter(probe: boolean) {
}
return {
current: () => !broken,
+ idle: () => !running,
+ probeAvailable: (origin: string, eventId: string) =>
+ probe &&
+ !broken &&
+ !running &&
+ used < PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds &&
+ (counts.get(JSON.stringify([origin, eventId])) ?? 0) <
+ PRIVATE_PUBLICATION_BUDGETS.attemptsPerTargetAction,
begin(
role: PrivateDeliveryRole | 'access_archive' | 'access_readback',
origin: string,
@@ -441,17 +461,79 @@ export type InboxProbePublicationAction = Readonly<{
declare const probePublicationBrand: unique symbol;
export type InboxProbePublication = Readonly<{ [probePublicationBrand]: true }>;
type ProbeAction = {
+ source: 'construction' | 'recovered';
token: InboxProbePublicationAction;
repository: PrivateStorageRepository;
session: PrivateSession;
policy: RelayPolicy;
- identity: InboxProbeIdentity;
+ identity: InboxProbeIdentity | RecoveredInboxProbe;
original: string;
current(): boolean;
meter: NonNullable<ReturnType<typeof networkMeter>>;
};
const probeActions = new WeakMap<InboxProbePublicationAction, ProbeAction>();
-const identityActions = new WeakMap<InboxProbeIdentity, ProbeAction | null>();
+const identityActions = new WeakMap<
+ InboxProbeIdentity | RecoveredInboxProbe,
+ ProbeAction | null
+>();
+type ProbeMeter = NonNullable<ReturnType<typeof networkMeter>>;
+type ProbeMeterOwner = {
+ access: InboxAccessController;
+ original: string;
+ meter: ProbeMeter;
+ current(): boolean;
+};
+// Bounded within an actual private-session lifetime, never persisted authority.
+// Retired action replacement reuses the slot; it cannot grow action history.
+const commandMeters = new WeakMap<
+ PrivateSession,
+ Map<string, ProbeMeterOwner | null>
+>();
+function probeMeter(
+ session: PrivateSession,
+ policy: RelayPolicy,
+ access: InboxAccessController,
+ command: string,
+ original: string,
+ current: () => boolean,
+ replace: boolean
+): ProbeMeter | undefined {
+ const registry =
+ commandMeters.get(session) ?? new Map<string, ProbeMeterOwner | null>();
+ commandMeters.set(session, registry);
+ const previous = registry.get(command);
+ if (registry.has(command)) {
+ if (!previous || previous.original !== original) return undefined;
+ if (previous.access === access) return previous.meter;
+ const retired = inboxAccessControllerSnapshot(previous.access);
+ if (
+ !replace ||
+ previous.current() ||
+ !previous.meter.idle() ||
+ retired?.state !== 'stopped' ||
+ retired.cleanupRequired ||
+ !privatePoolProbeRetryIdle(session, policy) ||
+ !current()
+ )
+ return undefined;
+ } else if (
+ registry.size >= LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends
+ ) {
+ return undefined;
+ }
+ // UUID creation can reenter. No parallel original or recovered capture may
+ // allocate another meter while this exact command's slot is reserved.
+ registry.set(command, null);
+ const meter = networkMeter(true);
+ if (
+ !meter ||
+ !current() ||
+ (replace && !privatePoolProbeRetryIdle(session, policy))
+ )
+ return undefined;
+ registry.set(command, { access, original, meter, current });
+ return meter;
+}
function probeImmutable(
row: NonNullable<ReturnType<typeof inboxProbePublicationBinding>>['record']
) {
@@ -484,6 +566,8 @@ export function captureInboxProbePublicationAction(
policy
);
if (!binding || !binding.record.self) return undefined;
+ const access = inboxProbeActionOwner(binding.identity, session, policy);
+ if (!access || !binding.current()) return undefined;
const original = probeImmutable(binding.record),
prior = identityActions.get(binding.identity);
if (identityActions.has(binding.identity))
@@ -498,10 +582,19 @@ export function captureInboxProbePublicationAction(
// Reserve this original identity before callback-capable UUID creation.
// Reentrant capture refuses; failed admission never grants a new meter.
identityActions.set(binding.identity, null);
- const meter = networkMeter(true);
+ const meter = probeMeter(
+ session,
+ policy,
+ access,
+ binding.record.id,
+ original,
+ binding.current,
+ false
+ );
if (!meter || !binding.current()) return undefined;
const token = Object.freeze({}) as InboxProbePublicationAction;
const captured: ProbeAction = {
+ source: 'construction',
token,
repository,
session,
@@ -518,6 +611,127 @@ export function captureInboxProbePublicationAction(
return undefined;
}
}
+
+// Fresh deliberate Retry adopts the same ciphertext, not a construction
+// identity. Admission is local readonly work; EVENT/REQ need later permissions.
+export async function captureRecoveredInboxProbeRetryAction(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ acknowledgement: InboxProbeAcknowledgement,
+ review: unknown
+): Promise<InboxProbePublicationAction | undefined> {
+ if (
+ typeof window === 'undefined' ||
+ review !== 'reviewed_original_inbox_probe_retry'
+ )
+ return undefined;
+ let identity: RecoveredInboxProbe | undefined,
+ retryBusy = false;
+ try {
+ const binding = recoveredInboxProbePublicationBinding(
+ repository,
+ session,
+ acknowledgement,
+ policy
+ );
+ if (!binding || !binding.record.self) return undefined;
+ identity = binding.identity;
+ const original = probeImmutable(binding.record),
+ previous = identityActions.get(identity);
+ if (identityActions.has(identity))
+ return previous &&
+ previous.repository === repository &&
+ previous.session === session &&
+ previous.policy === policy &&
+ previous.original === original &&
+ previous.current()
+ ? previous.token
+ : undefined;
+ identityActions.set(identity, null);
+ if (!navigator.locks?.request) return undefined;
+ const result = await navigator.locks.request(
+ 'harvestcircle:owner:' + binding.record.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock) => {
+ if (!lock) {
+ retryBusy = true;
+ return undefined;
+ }
+ if (!binding.current()) return undefined;
+ const idle = await withIdlePrivateLocalStorage(session, async () => {
+ if (!binding.current()) return undefined;
+ if (!privatePoolProbeRetryIdle(session, policy)) {
+ retryBusy = true;
+ return undefined;
+ }
+ if (
+ !(await verifyInboxProbeAcknowledgement(
+ repository,
+ session,
+ acknowledgement
+ )) ||
+ !binding.current() ||
+ !privatePoolProbeRetryIdle(session, policy)
+ )
+ return undefined;
+ const meter = probeMeter(
+ session,
+ policy,
+ binding.access,
+ binding.record.id,
+ original,
+ binding.current,
+ true
+ );
+ // UUID/currentness callbacks finish before separate final native
+ // custody observation. A failed admission cannot mint a permission.
+ if (
+ !meter ||
+ ![
+ ...binding.record.binding.archiveTargets,
+ ...binding.record.binding.readTargets
+ ].some((origin) =>
+ meter.probeAvailable(origin, binding.record.self!.eventId)
+ ) ||
+ !(await verifyInboxProbeAcknowledgement(
+ repository,
+ session,
+ acknowledgement
+ )) ||
+ !binding.current() ||
+ !privatePoolProbeRetryIdle(session, policy)
+ )
+ return undefined;
+ const token = Object.freeze({}) as InboxProbePublicationAction;
+ const captured: ProbeAction = {
+ source: 'recovered',
+ token,
+ repository,
+ session,
+ policy,
+ identity: binding.identity,
+ original,
+ current: () => meter.current() && binding.current(),
+ meter
+ };
+ identityActions.set(binding.identity, captured);
+ probeActions.set(token, captured);
+ return token;
+ });
+ if (!idle.ok) retryBusy = true;
+ return idle.ok ? idle.value : undefined;
+ }
+ );
+ return result;
+ } catch {
+ return undefined;
+ } finally {
+ // Only actual pre-admission busy can explicitly retry this same proof.
+ if (retryBusy && identity && identityActions.get(identity) === null)
+ identityActions.delete(identity);
+ }
+}
type ProbePermission = {
role: 'access_archive' | 'access_readback';
action: ProbeAction;
@@ -551,12 +765,11 @@ function captureProbePermission(
return undefined;
try {
const captured = probeActions.get(action),
- binding = inboxProbePublicationBinding(
- repository,
- session,
- acknowledgement,
- policy
- );
+ bind =
+ captured?.source === 'recovered'
+ ? recoveredInboxProbePublicationBinding
+ : inboxProbePublicationBinding,
+ binding = bind(repository, session, acknowledgement, policy);
if (
!captured ||
!binding ||
@@ -567,6 +780,8 @@ function captureProbePermission(
!captured.current() ||
captured.original !== probeImmutable(binding.record) ||
!binding.record.self ||
+ (captured.source === 'recovered' &&
+ !captured.meter.probeAvailable(origin, binding.record.self.eventId)) ||
!(
role === 'access_archive'
? binding.record.binding.archiveTargets
@@ -595,15 +810,13 @@ function captureProbePermission(
const predecessorWire = binding.wire;
let consumed = false;
function current() {
- const fresh = inboxProbePublicationBinding(
- repository,
- session,
- acknowledgement,
- policy
- );
+ const fresh = bind(repository, session, acknowledgement, policy);
return (
captured!.current() &&
!!fresh &&
+ (captured!.source !== 'recovered' ||
+ consumed ||
+ captured!.meter.probeAvailable(origin, artifact.eventId)) &&
fresh.identity === captured!.identity &&
fresh.wire === predecessorWire &&
probeImmutable(fresh.record) === captured!.original
diff --git a/web/src/lib/persistence/inbox-probes.ts b/web/src/lib/persistence/inbox-probes.ts
@@ -5,6 +5,12 @@ import {
type InboxProbeReadbackAttemptResult
} from '../nostr/private-pool.ts';
import { inboxProbePolicyMatches } from '../nostr/inbox-access.ts';
+import {
+ recoveredInboxProbeBinding,
+ type RecoveredInboxProbe
+} from '../nostr/self-recovery-reader.ts';
+import type { InboxAccessController } from '../messaging/inbox-access-controller.ts';
+import type { InboxOperatorQualification } from '../config/inbox-operators.ts';
import type { RelayPolicy } from '../config/relays.ts';
import {
inboxProbeGiftwrapSnapshot,
@@ -57,7 +63,7 @@ export type InboxProbeCommitResult =
type Lineage = {
repository: PrivateStorageRepository;
session: PrivateSession;
- identity: InboxProbeIdentity;
+ identity: InboxProbeIdentity | RecoveredInboxProbe;
record(): PrivateAccessProbe;
wire(): string;
begin(): boolean;
@@ -67,7 +73,7 @@ type Lineage = {
function createLineage(
repository: PrivateStorageRepository,
session: PrivateSession,
- identity: InboxProbeIdentity,
+ identity: InboxProbeIdentity | RecoveredInboxProbe,
originalRecord: PrivateAccessProbe,
originalWire: string
): Lineage {
@@ -98,11 +104,20 @@ const lineages = new WeakMap<InboxProbeIdentity, Lineage>();
type Saved = Readonly<{
repository: PrivateStorageRepository;
session: PrivateSession;
- identity: InboxProbeIdentity;
lineage: Lineage;
current(): boolean;
revoke(): void;
-}>;
+}> &
+ (
+ | Readonly<{ source: 'construction'; identity: InboxProbeIdentity }>
+ | Readonly<{
+ source: 'recovered';
+ identity: RecoveredInboxProbe;
+ access: InboxAccessController;
+ policy: RelayPolicy;
+ operator: InboxOperatorQualification;
+ }>
+ );
const acknowledgements = new WeakMap<InboxProbeAcknowledgement, Saved>();
const actions = new WeakMap<
InboxProbeGiftwrap,
@@ -127,15 +142,18 @@ function input(
seal = inboxProbeGiftwrapSeal(wrap),
identity = seal && inboxProbeSealIdentity(seal),
reservation = identity && inboxProbeSnapshot(identity),
- handle = identity && inboxProbeReservationHandle(identity),
- ownership = privateSessionOwnership(session);
+ handle = identity && inboxProbeReservationHandle(identity);
if (
!artifact ||
!identity ||
!reservation ||
!handle ||
+ !inboxProbeRumorWire(identity, session)
+ )
+ return undefined;
+ const ownership = privateSessionOwnership(session);
+ if (
!ownership?.current() ||
- !inboxProbeRumorWire(identity, session) ||
privateStorageOwner(repository) !== ownership.owner ||
reservation.owner !== ownership.owner ||
artifact.owner !== reservation.owner ||
@@ -305,6 +323,7 @@ export async function commitInboxProbe(
) as InboxProbeAcknowledgement;
let revoked = false;
acknowledgements.set(acknowledgement, {
+ source: 'construction',
repository,
session,
identity: original.identity,
@@ -387,6 +406,7 @@ export function inboxProbePublicationBinding(
const saved = acknowledgements.get(acknowledgement);
if (
!saved ||
+ saved.source !== 'construction' ||
saved.repository !== repository ||
saved.session !== session ||
!saved.current() ||
@@ -404,6 +424,225 @@ export function inboxProbePublicationBinding(
inboxProbePolicyMatches(saved.identity, session, policy)
};
}
+
+export type RecoveredInboxProbeAdoptionResult =
+ | Readonly<{
+ status: 'adopted' | 'existing';
+ acknowledgement: InboxProbeAcknowledgement;
+ }>
+ | Readonly<{
+ status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped';
+ disposition: 'original_protected';
+ }>;
+function createRecoveryAdoption() {
+ let pending = false,
+ result: RecoveredInboxProbeAdoptionResult | undefined;
+ return {
+ pending: () => pending,
+ result: () => result,
+ begin() {
+ pending = true;
+ },
+ finish() {
+ pending = false;
+ },
+ admit(value: RecoveredInboxProbeAdoptionResult) {
+ result = value;
+ return value;
+ }
+ };
+}
+type RecoveryAdoption = ReturnType<typeof createRecoveryAdoption>;
+const recoveredAdoptions = new WeakMap<RecoveredInboxProbe, RecoveryAdoption>();
+
+// A recovered proof is not a construction identity. Its acknowledgement adopts
+// only complete current native custody; old receipt labels remain unverified.
+export async function adoptRecoveredInboxProbe(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ access: InboxAccessController,
+ policy: RelayPolicy,
+ operator: InboxOperatorQualification,
+ proof: RecoveredInboxProbe,
+ review: unknown
+): Promise<RecoveredInboxProbeAdoptionResult> {
+ const refuse = (
+ status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped'
+ ): RecoveredInboxProbeAdoptionResult => ({
+ status,
+ disposition: 'original_protected'
+ });
+ if (
+ typeof window === 'undefined' ||
+ review !== 'reviewed_original_inbox_probe_retry'
+ )
+ return refuse('invalid');
+ let action: RecoveryAdoption | undefined,
+ issued: InboxProbeAcknowledgement | undefined;
+ try {
+ // Authenticate the proof and all lexical associations before any passive
+ // private ownership or callback-capable native/SDK admission.
+ const original = recoveredInboxProbeBinding(
+ proof,
+ repository,
+ session,
+ access,
+ policy,
+ operator
+ );
+ if (!original || privateStorageOwner(repository) !== original.owner)
+ return refuse('invalid_scope');
+ const previous = recoveredAdoptions.get(proof);
+ if (previous?.pending()) return refuse('busy');
+ const previousResult = previous?.result();
+ if (previousResult && !('acknowledgement' in previousResult))
+ return previousResult;
+ action = previous ?? createRecoveryAdoption();
+ action.begin();
+ recoveredAdoptions.set(proof, action);
+ const known = action.result();
+ const prior =
+ known && 'acknowledgement' in known ? known.acknowledgement : undefined;
+ const saved = prior && acknowledgements.get(prior);
+ function current() {
+ const now = recoveredInboxProbeBinding(
+ proof,
+ repository,
+ session,
+ access,
+ policy,
+ operator
+ );
+ return (
+ !!now &&
+ now.storedWire === original!.storedWire &&
+ now.command === original!.command &&
+ now.eventId === original!.eventId &&
+ (!saved || saved.current())
+ );
+ }
+ if (!current()) return action.admit(refuse('stopped'));
+ if (!navigator.locks?.request) return action.admit(refuse('unavailable'));
+ const result = await navigator.locks.request(
+ 'harvestcircle:owner:' + original.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock): Promise<RecoveredInboxProbeAdoptionResult> => {
+ if (!lock) return refuse('busy');
+ if (!current()) return refuse('stopped');
+ const idle = await withIdlePrivateLocalStorage(
+ session,
+ async (): Promise<RecoveredInboxProbeAdoptionResult> => {
+ if (!current()) return refuse('stopped');
+ const observed = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ original.command
+ );
+ if (!current()) return refuse('stopped');
+ if (!observed.ok) return refuse(observed.reason);
+ const expected = saved?.lineage.wire() ?? original.storedWire;
+ if (
+ observed.value.wire !== expected ||
+ privateRecordWire(
+ observed.value.handle,
+ original.owner,
+ original.command
+ ) !== expected
+ ) {
+ saved?.revoke();
+ return refuse('conflict');
+ }
+ if (prior) return { status: 'existing', acknowledgement: prior };
+ const record = privateRecordSnapshot(
+ observed.value.handle,
+ original.owner,
+ original.command
+ );
+ if (
+ !record ||
+ record.family !== 'private_access_probe' ||
+ !record.self ||
+ record.self.eventId !== original.eventId ||
+ record.rumorHash !== original.rumorHash ||
+ !current()
+ )
+ return refuse('invalid_record');
+ const lineage = createLineage(
+ repository,
+ session,
+ proof,
+ record,
+ expected
+ );
+ let revoked = false;
+ const acknowledgement = Object.freeze(
+ {}
+ ) as InboxProbeAcknowledgement;
+ issued = acknowledgement;
+ acknowledgements.set(acknowledgement, {
+ source: 'recovered',
+ repository,
+ session,
+ identity: proof,
+ access,
+ policy,
+ operator,
+ lineage,
+ current: () => !revoked && current(),
+ revoke: () => {
+ revoked = true;
+ }
+ });
+ return { status: 'adopted', acknowledgement };
+ }
+ );
+ return idle.ok ? idle.value : refuse(current() ? 'busy' : 'stopped');
+ }
+ );
+ // Busy before admission can retry this same original proof. No failed
+ // custody or stopped acknowledgement can be recaptured as a new lineage.
+ if (result.status !== 'busy') action.admit(result);
+ if (!('acknowledgement' in result) && issued)
+ acknowledgements.get(issued)?.revoke();
+ return result;
+ } catch {
+ if (issued) acknowledgements.get(issued)?.revoke();
+ const result = refuse('unavailable');
+ action?.admit(result);
+ return result;
+ } finally {
+ action?.finish();
+ }
+}
+
+// Separate recovered binding: unchanged original/C1 factories cannot accept it.
+// This is memory lineage only; every effect must reread exact native custody.
+export function recoveredInboxProbePublicationBinding(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ acknowledgement: InboxProbeAcknowledgement,
+ policy: RelayPolicy
+) {
+ const saved = acknowledgements.get(acknowledgement);
+ if (
+ !saved ||
+ saved.source !== 'recovered' ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ saved.policy !== policy ||
+ !saved.current()
+ )
+ return undefined;
+ return {
+ identity: saved.identity,
+ access: saved.access,
+ record: JSON.parse(
+ JSON.stringify(saved.lineage.record())
+ ) as PrivateAccessProbe,
+ wire: saved.lineage.wire(),
+ current: () => saved.current()
+ };
+}
export type InboxProbeArchiveCommitResult = Readonly<{
status:
| 'saved'
diff --git a/web/tests/e2e/harness/inbox-probe-retry.ts b/web/tests/e2e/harness/inbox-probe-retry.ts
@@ -0,0 +1,717 @@
+import {
+ makeRecoveryFixture,
+ openRecoveryContext
+} from './inbox-probe-recovery.ts';
+import { RelayPool } from 'applesauce-relay';
+import { finalize } from 'rxjs';
+import {
+ createPublicRuntimeContext,
+ mountPublicRuntime,
+ closePublicRuntime,
+ createPublicView,
+ beginPublicViewRun,
+ disposePublicView
+} from '../../../src/lib/runtime/public-runtime.ts';
+import {
+ resolveInboxPreference,
+ settleInboxResolver,
+ inboxResolutionSnapshot
+} from '../../../src/lib/messaging/resolve-inbox.ts';
+import {
+ createInboxAccessController,
+ closeInboxAccessController,
+ inboxAccessControllerSnapshot,
+ type InboxAccessController
+} from '../../../src/lib/messaging/inbox-access-controller.ts';
+import { privateSessionSnapshot } from '../../../src/lib/runtime/private-session.ts';
+import {
+ openBrowserDatabase,
+ closeBrowserDatabase,
+ browserDatabaseTransaction
+} from '../../../src/lib/persistence/database.ts';
+import {
+ reserveInboxProbeIdentity,
+ inboxProbeSnapshot,
+ type InboxProbeIdentity
+} 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,
+ adoptRecoveredInboxProbe,
+ inboxProbeAcknowledgementSnapshot,
+ inboxProbePublicationBinding,
+ recoveredInboxProbePublicationBinding,
+ commitInboxProbeArchiveAttempt,
+ commitInboxProbeReadbackAttempt,
+ type InboxProbeAcknowledgement
+} from '../../../src/lib/persistence/inbox-probes.ts';
+import {
+ captureInboxProbeRecoveryReader,
+ recoverInboxProbe,
+ stopInboxProbeRecoveryReader,
+ type InboxProbeRecoveryReader,
+ type RecoveredInboxProbe
+} from '../../../src/lib/nostr/self-recovery-reader.ts';
+import {
+ captureInboxProbePublicationAction,
+ captureRecoveredInboxProbeRetryAction,
+ captureInboxProbePublication,
+ captureInboxProbeReadback,
+ type InboxProbePublicationAction
+} from '../../../src/lib/nostr/private-publisher.ts';
+import {
+ getPrivatePool,
+ closePrivatePool,
+ privatePoolProbeRetryIdle,
+ publishInboxProbeArchiveAttempt,
+ readInboxProbeAttempt,
+ type PrivatePool,
+ type InboxProbeArchiveAttemptResult,
+ type InboxProbeReadbackAttemptResult
+} from '../../../src/lib/nostr/private-pool.ts';
+export * from './inbox-probe-recovery.ts';
+export {
+ makeFixture as makeOrdinaryRecoveryFixture,
+ resumeEncryptedPreparation,
+ resumeRecoveredRumor
+} from './resume-preparation.ts';
+export {
+ adoptRecoveredInboxProbe,
+ captureRecoveredInboxProbeRetryAction,
+ recoveredInboxProbePublicationBinding,
+ inboxProbePublicationBinding,
+ privatePoolProbeRetryIdle,
+ commitInboxProbe,
+ captureInboxProbePublicationAction,
+ captureInboxProbePublication,
+ captureInboxProbeReadback
+};
+export {
+ authenticateInboxAccess,
+ respondInboxAccessAuthentication,
+ inboxAccessControllerSnapshot
+} from '../../../src/lib/messaging/inbox-access-controller.ts';
+export {
+ closePrivateSession,
+ subscribePrivateSessionClose,
+ withIdlePrivateLocalStorage
+} from '../../../src/lib/runtime/private-session.ts';
+
+// Every actor and durable effect below is an actual source factory. The reused
+// host owns only ephemeral test crypto/native fixture access, never readiness.
+export async function makeRetryFixture() {
+ const host = await makeRecoveryFixture(),
+ publicContext = createPublicRuntimeContext(),
+ runtime = mountPublicRuntime(publicContext, host.policy);
+ if (!runtime) throw Error('actual shared public discovery');
+ const shared = { context: publicContext, runtime };
+ let actor: Awaited<ReturnType<typeof openRecoveryContext>> | undefined,
+ access: InboxAccessController | undefined,
+ replacementView: ReturnType<typeof createPublicView> | undefined,
+ originalIdentity: InboxProbeIdentity | undefined,
+ originalAck: InboxProbeAcknowledgement | undefined,
+ originalAction: InboxProbePublicationAction | undefined,
+ reader: InboxProbeRecoveryReader | undefined,
+ proof: RecoveredInboxProbe | undefined,
+ acknowledgement: InboxProbeAcknowledgement | undefined,
+ action: InboxProbePublicationAction | undefined,
+ command: string | undefined,
+ pool: PrivatePool | undefined;
+ const repository = host.repository;
+ function currentActor() {
+ if (!actor || !access) throw Error('actual current private actors missing');
+ return { ...actor, access };
+ }
+ function acquire() {
+ const a = currentActor();
+ pool ??= getPrivatePool(
+ a.session,
+ host.policy,
+ [
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ],
+ access,
+ 'access'
+ );
+ if (!pool) throw Error('actual current private scope unavailable');
+ return pool;
+ }
+ function stopCurrentController() {
+ if (reader) stopInboxProbeRecoveryReader(reader);
+ if (access) closeInboxAccessController(access);
+ if (pool) closePrivatePool(pool);
+ pool = undefined;
+ if (replacementView) disposePublicView(replacementView);
+ replacementView = undefined;
+ reader = undefined;
+ proof = undefined;
+ acknowledgement = undefined;
+ action = undefined;
+ }
+ return {
+ host,
+ repository,
+ actors: currentActor,
+ originalIdentity: () => originalIdentity,
+ originalAck: () => originalAck,
+ proof: () => proof,
+ acknowledgement: () => acknowledgement,
+ action: () => action,
+ command: () => command,
+ pool: () => pool,
+ async open() {
+ actor = await openRecoveryContext(
+ host.owner,
+ host.policy,
+ host.qualification,
+ crypto.randomUUID(),
+ shared
+ );
+ access = actor.access;
+ },
+ async prepareOriginal() {
+ if (reader) stopInboxProbeRecoveryReader(reader);
+ reader = undefined;
+ proof = undefined;
+ acknowledgement = undefined;
+ action = undefined;
+ const a = currentActor(),
+ reserved = await reserveInboxProbeIdentity(
+ repository,
+ a.session,
+ host.policy,
+ a.access,
+ host.qualification,
+ 'reviewed_inbox_probe_reservation'
+ );
+ if (!('identity' in reserved)) return reserved;
+ originalIdentity = reserved.identity;
+ const selected = inboxProbeSnapshot(originalIdentity);
+ if (!selected) throw Error('actual original reserved identity');
+ command = selected.id;
+ const operation = captureInboxProbeSealOperation(
+ a.session,
+ originalIdentity,
+ 'reviewed_inbox_probe_seal'
+ );
+ if (!operation) throw Error('actual original seal admission');
+ const sealed = await buildInboxProbeSeal(operation);
+ if (!('seal' in sealed)) return sealed;
+ const wrap = buildInboxProbeGiftwrap(
+ sealed.seal,
+ 'reviewed_inbox_probe_wrap'
+ );
+ if (!wrap) throw Error('actual original wrap admission');
+ const result = await commitInboxProbe(
+ repository,
+ a.session,
+ wrap,
+ 'reviewed_inbox_probe_commit'
+ );
+ if ('acknowledgement' in result) originalAck = result.acknowledgement;
+ originalAction = undefined;
+ return result;
+ },
+ async recover() {
+ const a = currentActor();
+ if (!command) throw Error('actual original selection missing');
+ reader ??= captureInboxProbeRecoveryReader(
+ repository,
+ a.identity,
+ a.session,
+ host.policy,
+ a.access,
+ host.qualification,
+ command,
+ 'reviewed_inbox_probe_recovery'
+ );
+ if (!reader) return undefined;
+ const result = await recoverInboxProbe(reader);
+ if ('proof' in result) proof = result.proof;
+ return result;
+ },
+ async adopt(review: unknown = 'reviewed_original_inbox_probe_retry') {
+ const a = currentActor();
+ if (!proof) throw Error('actual recovered proof missing');
+ const result = await adoptRecoveredInboxProbe(
+ repository,
+ a.session,
+ a.access,
+ host.policy,
+ host.qualification,
+ proof,
+ review
+ );
+ if ('acknowledgement' in result) acknowledgement = result.acknowledgement;
+ return result;
+ },
+ async captureAction(
+ review: unknown = 'reviewed_original_inbox_probe_retry'
+ ) {
+ const a = currentActor();
+ if (!acknowledgement)
+ throw Error('actual recovered acknowledgement missing');
+ const selected = await captureRecoveredInboxProbeRetryAction(
+ repository,
+ a.session,
+ host.policy,
+ acknowledgement,
+ review
+ );
+ if (selected) action = selected;
+ return selected;
+ },
+ async originalPublish(
+ origin = 'wss://inbox.example.org',
+ signal = new AbortController().signal
+ ) {
+ const a = currentActor();
+ if (!originalAck) throw Error('actual original acknowledgement missing');
+ originalAction ??= captureInboxProbePublicationAction(
+ repository,
+ a.session,
+ host.policy,
+ originalAck,
+ 'reviewed_inbox_probe_network'
+ );
+ const permission =
+ originalAction &&
+ captureInboxProbePublication(
+ repository,
+ a.session,
+ host.policy,
+ originalAck,
+ originalAction,
+ origin,
+ 'reviewed_inbox_probe_publication'
+ );
+ return permission
+ ? publishInboxProbeArchiveAttempt(acquire(), permission, signal)
+ : undefined;
+ },
+ async originalRead(origin = 'wss://inbox.example.org') {
+ const a = currentActor();
+ if (!originalAck || !originalAction) return undefined;
+ const permission = captureInboxProbeReadback(
+ repository,
+ a.session,
+ host.policy,
+ originalAck,
+ originalAction,
+ origin,
+ 'reviewed_inbox_probe_readback'
+ );
+ return permission
+ ? readInboxProbeAttempt(
+ acquire(),
+ permission,
+ new AbortController().signal
+ )
+ : undefined;
+ },
+ async publish(
+ origin = 'wss://inbox.example.org',
+ signal = new AbortController().signal
+ ) {
+ const a = currentActor();
+ if (!acknowledgement || !action) return undefined;
+ const permission = captureInboxProbePublication(
+ repository,
+ a.session,
+ host.policy,
+ acknowledgement,
+ action,
+ origin,
+ 'reviewed_inbox_probe_publication'
+ );
+ return permission
+ ? publishInboxProbeArchiveAttempt(acquire(), permission, signal)
+ : undefined;
+ },
+ async read(
+ origin = 'wss://inbox.example.org',
+ signal = new AbortController().signal
+ ) {
+ const a = currentActor();
+ if (!acknowledgement || !action) return undefined;
+ const permission = captureInboxProbeReadback(
+ repository,
+ a.session,
+ host.policy,
+ acknowledgement,
+ action,
+ origin,
+ 'reviewed_inbox_probe_readback'
+ );
+ return permission
+ ? readInboxProbeAttempt(acquire(), permission, signal)
+ : undefined;
+ },
+ append: (result: InboxProbeArchiveAttemptResult) =>
+ commitInboxProbeArchiveAttempt(repository, result),
+ appendRead: (result: InboxProbeReadbackAttemptResult) =>
+ commitInboxProbeReadbackAttempt(repository, result),
+ snapshot: () =>
+ acknowledgement && inboxProbeAcknowledgementSnapshot(acknowledgement),
+ originalBinding: () =>
+ acknowledgement &&
+ inboxProbePublicationBinding(
+ repository,
+ currentActor().session,
+ acknowledgement,
+ host.policy
+ ),
+ recoveredBinding: () =>
+ acknowledgement &&
+ recoveredInboxProbePublicationBinding(
+ repository,
+ currentActor().session,
+ acknowledgement,
+ host.policy
+ ),
+ idle: () => privatePoolProbeRetryIdle(currentActor().session, host.policy),
+ installNetworkClock() {
+ const original = performance.now.bind(performance);
+ let now = original(),
+ observations = 0;
+ performance.now = () => {
+ if (/at clock(?:\d+)? \(/.test(new Error().stack ?? '')) {
+ observations++;
+ return now;
+ }
+ return original();
+ };
+ return {
+ advance: (value: number) => {
+ now += value;
+ },
+ observations: () => observations,
+ restore: () => {
+ performance.now = original;
+ }
+ };
+ },
+ installAttemptTeardownFailure() {
+ const original = Object.getOwnPropertyDescriptor(
+ RelayPool.prototype,
+ 'relay'
+ )!.value as RelayPool['relay'],
+ restorations: (() => void)[] = [];
+ let failing = true,
+ faults = 0;
+ RelayPool.prototype.relay = function (
+ ...args: Parameters<RelayPool['relay']>
+ ) {
+ const relay = original.apply(this, args),
+ event = relay.event.bind(relay);
+ relay.event = (...args: Parameters<typeof relay.event>) =>
+ event(...args).pipe(
+ finalize(() => {
+ if (failing) {
+ faults++;
+ throw Error('actual controlled SDK teardown failure');
+ }
+ })
+ );
+ restorations.push(() => {
+ relay.event = event;
+ });
+ return relay;
+ };
+ return {
+ faults: () => faults,
+ restore: () => {
+ failing = false;
+ RelayPool.prototype.relay = original;
+ for (const restore of restorations) restore();
+ }
+ };
+ },
+ installCommitFault(mode: 'aborted' | 'uncertain' | 'changed_successor') {
+ const put = Object.getOwnPropertyDescriptor(
+ IDBObjectStore.prototype,
+ 'put'
+ )!.value as IDBObjectStore['put'],
+ abort = Object.getOwnPropertyDescriptor(
+ IDBTransaction.prototype,
+ 'abort'
+ )!.value as IDBTransaction['abort'],
+ transaction = Object.getOwnPropertyDescriptor(
+ IDBDatabase.prototype,
+ 'transaction'
+ )!.value as IDBDatabase['transaction'];
+ let selected: IDBTransaction | undefined,
+ putSuccess = 0,
+ complete = 0,
+ aborted = 0,
+ abortRefused = 0,
+ changed = 0;
+ IDBDatabase.prototype.transaction = function (
+ ...args: Parameters<IDBDatabase['transaction']>
+ ) {
+ // Queue a genuine competing write BEFORE the first final readonly
+ // transaction. A later complete listener can run after its admission.
+ if (
+ mode === 'changed_successor' &&
+ selected?.db === this &&
+ !changed &&
+ args[1] === 'readonly'
+ ) {
+ changed++;
+ const next = transaction.call(this, ['private_sends'], 'readwrite'),
+ store = next.objectStore('private_sends'),
+ row = store.get([host.owner, command!]);
+ row.addEventListener('success', () => {
+ const current = row.result as {
+ owner: string;
+ id: string;
+ wire: string;
+ },
+ record = JSON.parse(current.wire) as { revision: number };
+ record.revision++;
+ put.call(store, { ...current, wire: JSON.stringify(record) });
+ });
+ }
+ return transaction.apply(this, args);
+ };
+ IDBTransaction.prototype.abort = function (
+ ...args: Parameters<IDBTransaction['abort']>
+ ) {
+ if (this === selected && mode !== 'aborted') {
+ abortRefused++;
+ throw Error('actual controlled abort refusal');
+ }
+ return abort.apply(this, args);
+ };
+ IDBObjectStore.prototype.put = function (
+ ...args: Parameters<IDBObjectStore['put']>
+ ) {
+ const request = put.apply(this, args);
+ if (!selected && this.name === 'private_sends') {
+ selected = this.transaction;
+ selected.addEventListener('complete', () => {
+ complete++;
+ });
+ selected.addEventListener('abort', () => {
+ aborted++;
+ });
+ request.addEventListener('success', () => {
+ putSuccess++;
+ if (mode === 'aborted') selected!.abort();
+ });
+ if (mode !== 'aborted')
+ throw Error('actual controlled failure after native put admission');
+ }
+ return request;
+ };
+ return {
+ counts: () => ({
+ putSuccess,
+ complete,
+ aborted,
+ abortRefused,
+ changed
+ }),
+ restore: () => {
+ IDBObjectStore.prototype.put = put;
+ IDBTransaction.prototype.abort = abort;
+ IDBDatabase.prototype.transaction = transaction;
+ }
+ };
+ },
+ async alternateController(foreignSession = false) {
+ if (foreignSession) {
+ const other = await openRecoveryContext(
+ host.owner,
+ host.policy,
+ host.qualification,
+ command!,
+ shared
+ );
+ return {
+ access: other.access,
+ session: other.session,
+ close: () => other.close()
+ };
+ }
+ const view = createPublicView(runtime),
+ run = beginPublicViewRun(view),
+ resolver = resolveInboxPreference(view, run, host.owner);
+ await settleInboxResolver(resolver);
+ const other = createInboxAccessController(
+ currentActor().session,
+ host.policy,
+ resolver
+ );
+ if (!other) throw Error('actual alternate controller');
+ return {
+ access: other,
+ session: currentActor().session,
+ close() {
+ if (other !== access) closeInboxAccessController(other);
+ disposePublicView(view);
+ }
+ };
+ },
+ async replacementWhilePending() {
+ const a = currentActor(),
+ view = createPublicView(runtime),
+ run = beginPublicViewRun(view),
+ resolver = resolveInboxPreference(view, run, host.owner);
+ await settleInboxResolver(resolver);
+ if (inboxResolutionSnapshot(resolver).status !== 'ready')
+ throw Error('replacement must have actual ready discovery metadata');
+ let other: InboxAccessController | undefined,
+ recovery: InboxProbeRecoveryReader | undefined;
+ try {
+ other = createInboxAccessController(a.session, host.policy, resolver);
+ if (!other)
+ return {
+ gate: 'actual_controller_factory' as const,
+ privateCurrent: privateSessionSnapshot(a.session)?.current === true,
+ originalController: inboxAccessControllerSnapshot(a.access)
+ };
+ recovery = captureInboxProbeRecoveryReader(
+ repository,
+ a.identity,
+ a.session,
+ host.policy,
+ other,
+ host.qualification,
+ command!,
+ 'reviewed_inbox_probe_recovery'
+ );
+ if (!recovery)
+ return {
+ gate: 'actual_recovery_factory' as const,
+ currentController: inboxAccessControllerSnapshot(other)
+ };
+ const recovered = await recoverInboxProbe(recovery);
+ if (!('proof' in recovered))
+ return {
+ gate: 'actual_recovery_execution' as const,
+ status: recovered.status,
+ currentController: inboxAccessControllerSnapshot(other)
+ };
+ const adopted = await adoptRecoveredInboxProbe(
+ repository,
+ a.session,
+ other,
+ host.policy,
+ host.qualification,
+ recovered.proof,
+ 'reviewed_original_inbox_probe_retry'
+ );
+ if (!('acknowledgement' in adopted))
+ return {
+ gate: 'actual_adoption' as const,
+ status: adopted.status,
+ currentController: inboxAccessControllerSnapshot(other)
+ };
+ const binding = recoveredInboxProbePublicationBinding(
+ repository,
+ a.session,
+ adopted.acknowledgement,
+ host.policy
+ );
+ if (!binding?.current())
+ throw Error(
+ 'fresh genuine recovered binding must be current before Retry'
+ );
+ const before = host.counts(),
+ original = crypto.randomUUID.bind(crypto),
+ closesBefore = Number(Reflect.get(window, 'ptCloseCalls') ?? 0);
+ let uuids = 0;
+ crypto.randomUUID = () => {
+ uuids++;
+ return original();
+ };
+ try {
+ const selected = await captureRecoveredInboxProbeRetryAction(
+ repository,
+ a.session,
+ host.policy,
+ adopted.acknowledgement,
+ 'reviewed_original_inbox_probe_retry'
+ );
+ return {
+ gate: 'actual_retry_admission' as const,
+ genuineCurrentBinding: binding.current(),
+ refused: !selected,
+ uuids,
+ before,
+ after: host.counts(),
+ closesBefore,
+ closesAfter: Number(Reflect.get(window, 'ptCloseCalls') ?? 0),
+ currentController: inboxAccessControllerSnapshot(other)
+ };
+ } finally {
+ crypto.randomUUID = original;
+ }
+ } finally {
+ if (recovery) stopInboxProbeRecoveryReader(recovery);
+ if (other) closeInboxAccessController(other);
+ disposePublicView(view);
+ }
+ },
+ // Test-only physical deletion frees the existing native quota to test the
+ // independent source meter bound. This is never product cleanup evidence.
+ async removeFixtureRow() {
+ const opened = await openBrowserDatabase();
+ if (opened.state !== 'ready' || !command)
+ throw Error('actual fixture deletion inputs');
+ try {
+ const tx = browserDatabaseTransaction(
+ opened.owner,
+ ['private_sends'],
+ 'readwrite'
+ );
+ tx.objectStore('private_sends').delete([host.owner, command]);
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('fixture delete abort'))
+ );
+ });
+ } finally {
+ closeBrowserDatabase(opened.owner);
+ }
+ },
+ async replaceController() {
+ const a = currentActor();
+ stopCurrentController();
+ replacementView = createPublicView(runtime);
+ const run = beginPublicViewRun(replacementView),
+ resolver = resolveInboxPreference(replacementView, run, host.owner);
+ await settleInboxResolver(resolver);
+ access = createInboxAccessController(a.session, host.policy, resolver);
+ return access;
+ },
+ async freshSession() {
+ stopCurrentController();
+ actor?.close();
+ actor = await openRecoveryContext(
+ host.owner,
+ host.policy,
+ host.qualification,
+ command ?? crypto.randomUUID(),
+ shared
+ );
+ access = actor.access;
+ return actor;
+ },
+ stop: stopCurrentController,
+ close() {
+ stopCurrentController();
+ actor?.close();
+ closePublicRuntime(publicContext);
+ host.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/inbox-probe-retry.spec.ts b/web/tests/e2e/inbox-probe-retry.spec.ts
@@ -0,0 +1,1706 @@
+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-retry.ts';
+declare global {
+ interface Window {
+ pt: typeof Fixture;
+ ptFixture: Awaited<ReturnType<typeof Fixture.makeRetryFixture>>;
+ ptPending?: Promise<unknown>;
+ ptRelease?: () => void;
+ ptRestore?: () => void;
+ ptClock?: ReturnType<Window['ptFixture']['installNetworkClock']>;
+ ptAbort?: AbortController;
+ ptDelayClose?: boolean;
+ ptFailClose?: boolean;
+ ptHeldClose?: (() => void)[];
+ ptCloseCalls?: number;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string,
+ head = '',
+ holdEvent = false,
+ holdRead = false,
+ challenge = false,
+ holdAuth = false;
+const origins = [
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+];
+const 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'
+ )!;
+ if (challenge && origin !== 'wss://discovery.example.org')
+ socket.send(JSON.stringify(['AUTH', 'c2b-actual-source-challenge']));
+ 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[];
+ if (frames.length >= 1000) throw Error('controlled fixture frame bound');
+ frames.push({ origin, frame });
+ if (frame[0] === 'REQ') {
+ const filter = frame[2] as { kinds?: number[]; ids?: string[] };
+ if (filter.kinds?.includes(10050) && head)
+ socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
+ if (filter.kinds?.includes(1059)) {
+ if (holdRead) return;
+ const event = archived.get(JSON.stringify([origin, filter.ids?.[0]]));
+ if (event) socket.send(JSON.stringify(['EVENT', frame[1], event]));
+ }
+ socket.send(JSON.stringify(['EOSE', frame[1]]));
+ } else if (frame[0] === 'EVENT') {
+ const event = frame[1] as { id: string };
+ archived.set(JSON.stringify([origin, event.id]), event);
+ if (!holdEvent) socket.send(JSON.stringify(['OK', event.id, true, '']));
+ } else if (frame[0] === 'AUTH') {
+ const event = frame[1] as { id: string };
+ if (!holdAuth) 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-retry.ts', import.meta.url)
+ ),
+ name: 'pt',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('actual compiled retry 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);
+ head = '';
+ frames.length = 0;
+ archived.clear();
+ holdEvent = false;
+ holdRead = false;
+ challenge = false;
+ holdAuth = false;
+ await page.addInitScript(
+ ({ endpoint, origins }) => {
+ const Native = window.WebSocket;
+ window.WebSocket = class extends Native {
+ constructor(url: string | URL, protocols?: string | string[]) {
+ const origin = new URL(String(url)).origin;
+ if (!['wss://discovery.example.org', ...origins].includes(origin))
+ throw Error('unapproved fixture origin');
+ super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
+ }
+ override close(code?: number, reason?: string) {
+ window.ptCloseCalls = (window.ptCloseCalls ?? 0) + 1;
+ if (window.ptFailClose)
+ throw Error('actual controlled physical close failure');
+ if (window.ptDelayClose)
+ (window.ptHeldClose ??= []).push(() => super.close(code, reason));
+ else super.close(code, reason);
+ }
+ };
+ },
+ { endpoint, origins }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ head = await page.evaluate(async (origins) => {
+ window.ptFixture = await window.pt.makeRetryFixture();
+ return window.ptFixture.host.preferenceWire(origins);
+ }, origins);
+ await page.evaluate(async () => {
+ const f = window.ptFixture;
+ await f.open();
+ if ((await f.prepareOriginal()).status !== 'prepared')
+ throw Error('actual original S3/R1 setup');
+ });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(() => {
+ window.ptRestore?.();
+ window.ptRelease?.();
+ window.ptDelayClose = false;
+ window.ptFailClose = false;
+ for (const release of window.ptHeldClose ?? []) release();
+ window.ptFixture.host.settle();
+ window.ptFixture.close();
+ });
+});
+async function recover(page: Page, fresh = false) {
+ expect(
+ await page.evaluate(async (fresh) => {
+ const f = window.ptFixture;
+ if (fresh) await f.freshSession();
+ return (await f.recover())?.status;
+ }, fresh)
+ ).toBe('recovered');
+}
+async function adopt(page: Page) {
+ expect(
+ await page.evaluate(async () => (await window.ptFixture.adopt()).status)
+ ).toBe('adopted');
+}
+async function action(page: Page) {
+ expect(
+ await page.evaluate(async () => !!(await window.ptFixture.captureAction()))
+ ).toBe(true);
+}
+const privateFrames = () =>
+ frames.filter((x) => x.origin !== 'wss://discovery.example.org');
+const events = () => privateFrames().filter((x) => x.frame[0] === 'EVENT');
+async function nativeWire(page: Page) {
+ return page.evaluate(async () => {
+ const f = window.ptFixture;
+ return (await f.host.stored()).find((x) => x.id === f.command())!.wire;
+ });
+}
+
+test('cold original ciphertext recovery adopts readonly then observes actual same-artifact PUB READ native facts', async ({
+ page
+}) => {
+ const original = await nativeWire(page);
+ await recover(page, true);
+ const before = await page.evaluate(() => window.ptFixture.host.counts());
+ await adopt(page);
+ await action(page);
+ expect(await nativeWire(page)).toBe(original);
+ expect(privateFrames()).toHaveLength(0);
+ expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual(
+ before
+ );
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ pub = await f.publish();
+ if (!pub) throw Error('actual publication missing');
+ const appended = await f.append(pub),
+ read = await f.read();
+ if (!read) throw Error('actual readback missing');
+ const saved = await f.appendRead(read);
+ return {
+ pub,
+ appended,
+ read,
+ saved,
+ row: f.snapshot()?.record,
+ originalBinding: f.originalBinding() === undefined
+ };
+ });
+ expect(result.pub.status).toBe('accepted');
+ expect(result.read.status).toBe('readback');
+ expect(result.appended.status).toBe('saved');
+ expect(result.saved.status).toBe('saved');
+ expect(result.originalBinding).toBe(true);
+ const old = JSON.parse(original) as Record<string, unknown>;
+ expect(result.row?.id).toBe(old.id);
+ expect(result.row?.self).toEqual(old.self);
+ expect(result.row?.rumorHash).toBe(old.rumorHash);
+ expect(result.row?.createdAt).toBe(old.createdAt);
+ expect(result.row?.receipts.map((x) => x.role)).toEqual([
+ 'access_archive',
+ 'access_readback'
+ ]);
+ expect(events()).toHaveLength(1);
+ const req = privateFrames().find((x) => x.frame[0] === 'REQ')!.frame[2];
+ expect(req).toEqual({
+ kinds: [1059],
+ ids: [result.row!.self!.eventId],
+ '#p': [result.row!.owner],
+ limit: 1
+ });
+ expect(
+ await page.evaluate(() => {
+ const f = window.ptFixture,
+ a = f.actors();
+ return !!window.pt.captureInboxProbeSealOperation(
+ a.session,
+ f.proof() as unknown as Parameters<
+ typeof window.pt.captureInboxProbeSealOperation
+ >[1],
+ 'reviewed_inbox_probe_seal'
+ );
+ })
+ ).toBe(false);
+});
+
+test('repeated adoption and capture retain actual acknowledgement action and native revision', async ({
+ page
+}) => {
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const wire = await nativeWire(page);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ ack = f.acknowledgement(),
+ act = f.action(),
+ again = await f.adopt(),
+ next = await f.captureAction();
+ return {
+ status: again.status,
+ sameAck: 'acknowledgement' in again && again.acknowledgement === ack,
+ sameAction: next === act
+ };
+ });
+ expect(result).toEqual({
+ status: 'existing',
+ sameAck: true,
+ sameAction: true
+ });
+ expect(await nativeWire(page)).toBe(wire);
+ expect(privateFrames()).toHaveLength(0);
+});
+
+test('actual original and recovered permissions share combined per-origin three-attempt meter', async ({
+ page
+}) => {
+ const first = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ result = await f.originalPublish();
+ if (!result) throw Error('actual original effect');
+ await f.append(result);
+ return result;
+ });
+ expect(first.status).toBe('accepted');
+ expect(first.attempt).toBe(1);
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const results = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ read = await f.read();
+ if (!read) throw Error('actual second action read');
+ await f.appendRead(read);
+ const pub = await f.publish();
+ if (!pub) throw Error('actual third action event');
+ await f.append(pub);
+ const before = f.host.counts(),
+ exhausted = await f.publish();
+ return {
+ read,
+ pub,
+ exhausted: exhausted === undefined,
+ before,
+ after: f.host.counts()
+ };
+ });
+ expect(results.read.attempt).toBe(2);
+ expect(results.pub.attempt).toBe(3);
+ expect(results.read.actionId).toBe(first.actionId);
+ expect(results.pub.actionId).toBe(first.actionId);
+ expect(results.exhausted).toBe(true);
+ expect(results.after).toEqual(results.before);
+ expect(events()).toHaveLength(2);
+});
+
+test('new explicit controller recovery action replaces only ended clean action with same artifact', async ({
+ page
+}) => {
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const first = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ result = await f.publish();
+ if (!result) throw Error('actual first effect');
+ await f.append(result);
+ return result;
+ });
+ const source = JSON.parse(await nativeWire(page)) as Record<string, unknown>;
+ expect(
+ await page.evaluate(
+ async () => !!(await window.ptFixture.replaceController())
+ )
+ ).toBe(true);
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const second = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ result = await f.publish();
+ if (!result) throw Error('actual new action effect');
+ await f.append(result);
+ return { result, row: f.snapshot()?.record };
+ });
+ expect(second.result.status).toBe('accepted');
+ expect(second.result.attempt).toBe(1);
+ expect(second.result.actionId).not.toBe(first.actionId);
+ expect(second.row?.id).toBe(source.id);
+ expect(second.row?.self).toEqual(source.self);
+ expect(second.row?.receipts).toHaveLength(2);
+});
+
+for (const phase of ['adoption', 'action'] as const)
+ test(`${phase} rejects exact-native physical alias before any provider or traffic`, async ({
+ page
+ }) => {
+ await recover(page);
+ if (phase === 'action') await adopt(page);
+ const before = await page.evaluate(() => window.ptFixture.host.counts());
+ await page.evaluate(async () => {
+ const f = window.ptFixture,
+ rows = await f.host.stored();
+ const row = rows.find((x) => x.id === f.command())!;
+ await f.host.inject([{ ...row, wire: ' ' + row.wire }]);
+ });
+ const refused = await page.evaluate(async (phase) => {
+ const f = window.ptFixture;
+ return phase === 'adoption'
+ ? !('acknowledgement' in (await f.adopt()))
+ : (await f.captureAction()) === undefined;
+ }, phase);
+ expect(refused).toBe(true);
+ expect(privateFrames()).toHaveLength(0);
+ expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual(
+ before
+ );
+ });
+
+test('handwritten historical labels grant no native adoption or remote effect without original proof', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ a = f.actors(),
+ before = f.host.counts();
+ const fake = { nonce_verified: true, accepted: true, current: () => true };
+ const adoption = await window.pt.adoptRecoveredInboxProbe(
+ f.repository,
+ a.session,
+ a.access,
+ f.host.policy,
+ f.host.qualification,
+ fake as unknown as Parameters<
+ typeof window.pt.adoptRecoveredInboxProbe
+ >[5],
+ 'reviewed_original_inbox_probe_retry'
+ );
+ return {
+ refused: !('acknowledgement' in adoption),
+ before,
+ after: f.host.counts()
+ };
+ });
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(privateFrames()).toHaveLength(0);
+});
+
+test('actual native append of one genuine effect is idempotent without duplicate revision', async ({
+ page
+}) => {
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ effect = await f.publish();
+ if (!effect) throw Error('actual effect missing');
+ const first = await f.append(effect),
+ revision = f.snapshot()?.record.revision,
+ again = await f.append(effect);
+ return {
+ first,
+ again,
+ revision,
+ after: f.snapshot()?.record.revision,
+ receipts: f.snapshot()?.record.receipts.length
+ };
+ });
+ expect(result.first.status).toBe('saved');
+ expect(result.again.status).toBe('existing');
+ expect(result.after).toBe(result.revision);
+ expect(result.receipts).toBe(1);
+ expect(events()).toHaveLength(1);
+});
+
+test('real pending original key job blocks recovered action before any new key or meter', async ({
+ page
+}) => {
+ await recover(page);
+ await adopt(page);
+ await page.evaluate(() => {
+ const f = window.ptFixture;
+ f.host.mode('hold_key');
+ window.ptPending = f.originalPublish();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.ptFixture.host.waiting()))
+ .toBe('key');
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ before = f.host.counts(),
+ unavailable = await f.captureAction();
+ return {
+ unavailable: unavailable === undefined,
+ before,
+ after: f.host.counts()
+ };
+ });
+ expect(result.unavailable).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(events()).toHaveLength(0);
+ await page.evaluate(async () => {
+ window.ptFixture.host.mode('normal');
+ window.ptFixture.host.settle();
+ const effect = await window.ptPending;
+ if (
+ !effect ||
+ typeof effect !== 'object' ||
+ !('status' in effect) ||
+ effect.status !== 'accepted'
+ )
+ throw Error('actual original publication did not settle accepted');
+ });
+ await action(page);
+ expect(events()).toHaveLength(1);
+});
+
+test('actual pending AUTH acknowledgement retains shared SDK slot and blocks new Retry action', async ({
+ page
+}) => {
+ await recover(page);
+ await adopt(page);
+ challenge = true;
+ holdAuth = true;
+ await page.evaluate(async () => {
+ const f = window.ptFixture;
+ await window.pt.authenticateInboxAccess(
+ f.actors().access,
+ 'wss://inbox.example.org',
+ 'reviewed_inbox_connection_auth'
+ );
+ });
+ await expect
+ .poll(() =>
+ page.evaluate(() => {
+ const f = window.ptFixture;
+ return window.pt.inboxAccessControllerSnapshot(f.actors().access)
+ ?.auth[0]?.state;
+ })
+ )
+ .toBe('challenge');
+ await page.evaluate(() => {
+ const f = window.ptFixture;
+ window.ptPending = window.pt.respondInboxAccessAuthentication(
+ f.actors().access,
+ 'wss://inbox.example.org',
+ 'reviewed_inbox_auth_response'
+ );
+ });
+ await expect
+ .poll(() => privateFrames().filter((x) => x.frame[0] === 'AUTH').length)
+ .toBe(1);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ before = f.host.counts(),
+ selected = await f.captureAction();
+ return { refused: selected === undefined, before, after: f.host.counts() };
+ });
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(events()).toHaveLength(0);
+ for (const socket of physical) {
+ const auth = privateFrames().find((x) => x.frame[0] === 'AUTH')
+ ?.frame[1] as { id: string };
+ if (auth) socket.send(JSON.stringify(['OK', auth.id, true, '']));
+ }
+ expect(await page.evaluate(() => window.ptPending)).toBe('accepted');
+ await action(page);
+});
+
+test('forged original wrap cannot retry actual retained failed private cleanup', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ a = f.actors();
+ let calls = 0;
+ const off = window.pt.subscribePrivateSessionClose(a.session, () => {
+ calls++;
+ throw Error('controlled actual retained cleanup');
+ });
+ window.pt.closePrivateSession(a.session);
+ const before = calls;
+ const refused = await window.pt.commitInboxProbe(
+ f.repository,
+ a.session,
+ {} as Parameters<typeof window.pt.commitInboxProbe>[2],
+ 'reviewed_inbox_probe_commit'
+ );
+ const after = calls;
+ off();
+ return { before, after, refused: !('acknowledgement' in refused) };
+ });
+ expect(result.before).toBe(1);
+ expect(result.after).toBe(1);
+ expect(result.refused).toBe(true);
+ expect(privateFrames()).toHaveLength(0);
+});
+
+for (const scope of [
+ 'foreign_repository',
+ 'same_owner_repository',
+ 'copied_policy',
+ 'copied_operator',
+ 'other_controller',
+ 'other_session',
+ 'stale_head',
+ 'original_identity',
+ 'original_acknowledgement',
+ 'unreviewed'
+] as const)
+ test(`genuine recovered adoption refuses ${scope} without provider native or network effects`, async ({
+ page
+ }) => {
+ await recover(page);
+ const wire = await nativeWire(page);
+ const result = await page.evaluate(async (scope) => {
+ const f = window.ptFixture,
+ a = f.actors();
+ let repository = f.repository,
+ session = a.session,
+ access = a.access,
+ policy = f.host.policy,
+ operator = f.host.qualification,
+ proof = f.proof(),
+ review: unknown = 'reviewed_original_inbox_probe_retry';
+ const other =
+ scope === 'other_controller' || scope === 'other_session'
+ ? await f.alternateController(true)
+ : undefined;
+ const before = f.host.counts();
+ if (scope === 'foreign_repository')
+ repository = f.host.foreignRepository();
+ if (scope === 'same_owner_repository') repository = a.repository;
+ if (scope === 'copied_policy') policy = f.host.copiedPolicy();
+ if (scope === 'copied_operator') {
+ const copy = window.pt.validateInboxOperatorQualification(
+ window.pt.inboxOperatorQualificationWire(operator, policy)!
+ );
+ if (!copy) throw Error('actual same-wire operator');
+ operator = copy;
+ }
+ if (other && scope === 'other_controller') access = other.access;
+ if (scope === 'other_session') {
+ session = other!.session;
+ }
+ if (scope === 'stale_head') a.churnHead();
+ if (scope === 'original_identity')
+ proof = f.originalIdentity() as unknown as typeof proof;
+ if (scope === 'original_acknowledgement')
+ proof = f.originalAck() as unknown as typeof proof;
+ if (scope === 'unreviewed') review = 'reviewed_inbox_probe_network';
+ const selected = await window.pt.adoptRecoveredInboxProbe(
+ repository,
+ session,
+ access,
+ policy,
+ operator,
+ proof!,
+ review
+ );
+ other?.close();
+ if (session !== a.session) window.pt.closePrivateSession(session);
+ return {
+ refused: !('acknowledgement' in selected),
+ before,
+ after: f.host.counts()
+ };
+ }, scope);
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(await nativeWire(page)).toBe(wire);
+ expect(privateFrames()).toHaveLength(0);
+ });
+
+for (const scope of [
+ 'foreign_repository',
+ 'same_owner_repository',
+ 'copied_policy',
+ 'original_acknowledgement',
+ 'proof',
+ 'unreviewed',
+ 'stale_head'
+] as const)
+ test(`recovered Retry capture refuses ${scope} before any provider or traffic`, async ({
+ page
+ }) => {
+ await recover(page);
+ await adopt(page);
+ const wire = await nativeWire(page);
+ const result = await page.evaluate(async (scope) => {
+ const f = window.ptFixture,
+ a = f.actors(),
+ before = f.host.counts();
+ let repository = f.repository,
+ policy = f.host.policy,
+ acknowledgement = f.acknowledgement(),
+ review: unknown = 'reviewed_original_inbox_probe_retry';
+ if (scope === 'foreign_repository')
+ repository = f.host.foreignRepository();
+ if (scope === 'same_owner_repository') repository = a.repository;
+ if (scope === 'copied_policy') policy = f.host.copiedPolicy();
+ if (scope === 'original_acknowledgement')
+ acknowledgement = f.originalAck();
+ if (scope === 'proof')
+ acknowledgement = f.proof() as unknown as typeof acknowledgement;
+ if (scope === 'unreviewed') review = 'reviewed_inbox_probe_network';
+ if (scope === 'stale_head') a.churnHead();
+ const selected = await window.pt.captureRecoveredInboxProbeRetryAction(
+ repository,
+ a.session,
+ policy,
+ acknowledgement!,
+ review
+ );
+ return { refused: !selected, before, after: f.host.counts() };
+ }, scope);
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(await nativeWire(page)).toBe(wire);
+ expect(privateFrames()).toHaveLength(0);
+ });
+
+for (const phase of ['adoption', 'action'] as const)
+ for (const mutation of [
+ 'r0',
+ 'unknown_tail',
+ 'foreign_tail',
+ 'missing',
+ 'corrupt'
+ ] as const)
+ test(`${phase} observes complete physical owner scope with ${mutation}`, async ({
+ page
+ }) => {
+ await recover(page);
+ if (phase === 'action') await adopt(page);
+ const before = await page.evaluate(() => window.ptFixture.host.counts());
+ await page.evaluate(async (mutation) => {
+ const f = window.ptFixture,
+ row = (await f.host.stored()).find((x) => x.id === f.command())!;
+ if (mutation === 'missing') await f.removeFixtureRow();
+ else if (mutation === 'corrupt')
+ await f.host.inject([{ ...row, wire: '{}' }]);
+ else if (mutation === 'r0') {
+ const record = JSON.parse(row.wire) as {
+ self: unknown;
+ revision: number;
+ };
+ record.self = null;
+ record.revision = 0;
+ await f.host.inject([{ ...row, wire: JSON.stringify(record) }]);
+ } else
+ await f.host.inject([
+ {
+ owner: mutation === 'foreign_tail' ? 'f'.repeat(64) : row.owner,
+ id: crypto.randomUUID(),
+ wire: '{"unrecognized":true}'
+ }
+ ]);
+ }, mutation);
+ const raw = await page.evaluate(() => window.ptFixture.host.stored());
+ const accepted = await page.evaluate(async (phase) => {
+ const f = window.ptFixture;
+ return phase === 'adoption'
+ ? 'acknowledgement' in (await f.adopt())
+ : !!(await f.captureAction());
+ }, phase);
+ expect(accepted).toBe(mutation === 'foreign_tail');
+ expect(await page.evaluate(() => window.ptFixture.host.stored())).toEqual(
+ raw
+ );
+ expect(await page.evaluate(() => window.ptFixture.host.counts())).toEqual(
+ before
+ );
+ expect(privateFrames()).toHaveLength(0);
+ });
+
+for (const phase of ['adoption', 'action'] as const)
+ for (const hit of phase === 'action' ? [1, 2] : [1])
+ for (const fault of ['before', 'after'] as const)
+ test(`${phase} refuses actual readonly${hit} ${fault} native abort`, async ({
+ page
+ }) => {
+ await recover(page);
+ if (phase === 'action') await adopt(page);
+ const wire = await nativeWire(page);
+ const result = await page.evaluate(
+ async ({ phase, hit, fault }) => {
+ const f = window.ptFixture,
+ before = f.host.counts(),
+ 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.ptRestore = () => {
+ IDBIndex.prototype.openCursor = original;
+ };
+ const refused =
+ phase === 'adoption'
+ ? !('acknowledgement' in (await f.adopt()))
+ : !(await f.captureAction());
+ window.ptRestore();
+ return { refused, aborts, before, after: f.host.counts() };
+ },
+ { phase, hit, fault }
+ );
+ expect(result.refused).toBe(true);
+ expect(result.aborts).toBe(1);
+ expect(result.after).toEqual(result.before);
+ expect(await nativeWire(page)).toBe(wire);
+ expect(privateFrames()).toHaveLength(0);
+ });
+
+for (const phase of ['adoption', 'action'] as const)
+ test(`${phase} actual owner lock contention is inert and permits later explicit admission`, async ({
+ page
+ }) => {
+ await recover(page);
+ if (phase === 'action') await adopt(page);
+ await page.evaluate(() => {
+ const f = window.ptFixture;
+ window.ptPending = navigator.locks.request(
+ 'harvestcircle:owner:' + f.host.owner,
+ async () => {
+ await new Promise<void>((resolve) => {
+ window.ptRelease = resolve;
+ });
+ }
+ );
+ });
+ await expect.poll(() => page.evaluate(() => !!window.ptRelease)).toBe(true);
+ const result = await page.evaluate(async (phase) => {
+ const f = window.ptFixture,
+ before = f.host.counts();
+ const refused =
+ phase === 'adoption'
+ ? !('acknowledgement' in (await f.adopt()))
+ : !(await f.captureAction());
+ return { refused, before, after: f.host.counts() };
+ }, phase);
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(privateFrames()).toHaveLength(0);
+ await page.evaluate(async () => {
+ window.ptRelease!();
+ await window.ptPending;
+ });
+ if (phase === 'adoption') await adopt(page);
+ else await action(page);
+ });
+
+test('concurrent readonly adoption and Retry capture return only one actual token without regeneration', async ({
+ page
+}) => {
+ await recover(page);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ before = f.host.counts();
+ const first = f.adopt(),
+ second = f.adopt();
+ const [one, two] = await Promise.all([first, second]);
+ if (!('acknowledgement' in one)) throw Error('actual first adoption');
+ const [action, reentry] = await Promise.all([
+ f.captureAction(),
+ f.captureAction()
+ ]);
+ return {
+ first: one.status,
+ second: two.status,
+ action: !!action,
+ reentry: !reentry,
+ before,
+ after: f.host.counts()
+ };
+ });
+ expect(result.first).toBe('adopted');
+ expect(result.second).toBe('busy');
+ expect(result.action).toBe(true);
+ expect(result.reentry).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(privateFrames()).toHaveLength(0);
+});
+
+for (const callback of ['reentry', 'native_mutation', 'stale_head'] as const)
+ test(`actual action UUID ${callback} callback cannot mint competing or stale Retry authority`, async ({
+ page
+ }) => {
+ await recover(page);
+ await adopt(page);
+ const result = await page.evaluate(async (callback) => {
+ const f = window.ptFixture,
+ before = f.host.counts(),
+ original = crypto.randomUUID.bind(crypto);
+ let callbacks = 0;
+ let other: Promise<unknown> | undefined;
+ const row = (await f.host.stored()).find((x) => x.id === f.command())!;
+ crypto.randomUUID = () => {
+ callbacks++;
+ if (callback === 'reentry') other = f.captureAction();
+ else if (callback === 'native_mutation')
+ other = f.host.inject([{ ...row, wire: ' ' + row.wire }]);
+ else f.actors().churnHead();
+ return original();
+ };
+ window.ptRestore = () => {
+ crypto.randomUUID = original;
+ };
+ const selected = await f.captureAction();
+ window.ptRestore();
+ const reentered = await other;
+ return {
+ callbacks,
+ selected: !!selected,
+ reentered: !!reentered,
+ before,
+ after: f.host.counts()
+ };
+ }, callback);
+ expect(result.callbacks).toBe(1);
+ expect(result.selected).toBe(callback === 'reentry');
+ expect(result.reentered).toBe(false);
+ expect(result.after).toEqual(result.before);
+ expect(privateFrames()).toHaveLength(0);
+ });
+
+for (const pending of ['EVENT', 'REQ'] as const)
+ test(`actual pending ${pending} blocks new Retry action and pure pool observation until original settles`, async ({
+ page
+ }) => {
+ await recover(page);
+ await adopt(page);
+ if (pending === 'EVENT') {
+ holdEvent = true;
+ await page.evaluate(() => {
+ window.ptPending = window.ptFixture.originalPublish();
+ });
+ } else {
+ expect(
+ await page.evaluate(
+ async () => (await window.ptFixture.originalPublish())?.status
+ )
+ ).toBe('accepted');
+ holdRead = true;
+ await page.evaluate(() => {
+ window.ptPending = window.ptFixture.originalRead();
+ });
+ }
+ await expect
+ .poll(() => privateFrames().filter((x) => x.frame[0] === pending).length)
+ .toBe(1);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ before = f.host.counts(),
+ idle = f.idle(),
+ selected = await f.captureAction();
+ return { idle, refused: !selected, before, after: f.host.counts() };
+ });
+ expect(result.idle).toBe(false);
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ if (pending === 'EVENT') {
+ const id = (events()[0].frame[1] as { id: string }).id;
+ for (const socket of physical)
+ socket.send(JSON.stringify(['OK', id, true, '']));
+ } else {
+ const frame = privateFrames().find((x) => x.frame[0] === 'REQ')!;
+ const id = (frame.frame[2] as { ids: string[] }).ids[0];
+ for (const socket of physical) {
+ socket.send(
+ JSON.stringify([
+ 'EVENT',
+ frame.frame[1],
+ archived.get(JSON.stringify([frame.origin, id]))
+ ])
+ );
+ socket.send(JSON.stringify(['EOSE', frame.frame[1]]));
+ }
+ }
+ expect(
+ ((await page.evaluate(() => window.ptPending)) as { status: string })
+ .status
+ ).toBe(pending === 'EVENT' ? 'accepted' : 'readback');
+ await action(page);
+ });
+
+test('genuine same-scope controller recapture retains the original controller and action meter', async ({
+ page
+}) => {
+ const first = await page.evaluate(() => window.ptFixture.originalPublish());
+ expect(first?.status).toBe('accepted');
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ a = f.actors(),
+ other = await f.alternateController();
+ const reader = window.pt.captureInboxProbeRecoveryReader(
+ f.repository,
+ a.identity,
+ a.session,
+ f.host.policy,
+ other.access,
+ f.host.qualification,
+ f.command(),
+ 'reviewed_inbox_probe_recovery'
+ );
+ if (!reader) throw Error('actual alternate recovery reader');
+ const proof = await window.pt.recoverInboxProbe(reader);
+ if (!('proof' in proof)) throw Error('actual alternate proof');
+ const adopted = await window.pt.adoptRecoveredInboxProbe(
+ f.repository,
+ a.session,
+ other.access,
+ f.host.policy,
+ f.host.qualification,
+ proof.proof,
+ 'reviewed_original_inbox_probe_retry'
+ );
+ if (!('acknowledgement' in adopted))
+ throw Error('actual alternate readonly adoption');
+ const before = f.host.counts(),
+ selected = await window.pt.captureRecoveredInboxProbeRetryAction(
+ f.repository,
+ a.session,
+ f.host.policy,
+ adopted.acknowledgement,
+ 'reviewed_original_inbox_probe_retry'
+ );
+ const permission =
+ selected &&
+ window.pt.captureInboxProbePublication(
+ f.repository,
+ a.session,
+ f.host.policy,
+ adopted.acknowledgement,
+ selected,
+ 'wss://inbox.example.org',
+ 'reviewed_inbox_probe_publication'
+ );
+ const effect =
+ permission &&
+ (await window.pt.publishInboxProbeArchiveAttempt(
+ f.pool()!,
+ permission,
+ new AbortController().signal
+ ));
+ window.pt.stopInboxProbeRecoveryReader(reader);
+ other.close();
+ return {
+ sameController: other.access === a.access,
+ effect,
+ providerCalls: f.host.counts().keys - before.keys
+ };
+ });
+ expect(result.sameController).toBe(true);
+ expect(result.effect).toMatchObject({
+ status: 'accepted',
+ attempt: 2,
+ actionId: first!.actionId
+ });
+ expect(result.providerCalls).toBe(1);
+ expect(events()).toHaveLength(2);
+});
+
+test('same action has independent bounded three-attempt counters across exactly three frozen origins', async ({
+ page
+}) => {
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const result = await page.evaluate(async (origins) => {
+ const f = window.ptFixture,
+ effects = [];
+ for (const origin of origins) {
+ for (let i = 0; i < 3; i++) {
+ const effect = await f.publish(origin);
+ if (!effect) throw Error('actual permitted original artifact attempt');
+ await f.append(effect);
+ effects.push({
+ status: effect.status,
+ attempt: effect.attempt,
+ actionId: effect.actionId
+ });
+ }
+ if (await f.read(origin))
+ throw Error('exhausted combined archive/read origin admitted');
+ }
+ const before = f.host.counts(),
+ foreign = await f.publish('wss://foreign.example.org');
+ return { effects, foreign: !foreign, before, after: f.host.counts() };
+ }, origins);
+ expect(result.effects.map((x) => x.attempt)).toEqual([
+ 1, 2, 3, 1, 2, 3, 1, 2, 3
+ ]);
+ expect(new Set(result.effects.map((x) => x.actionId)).size).toBe(1);
+ expect(result.effects.every((x) => x.status === 'accepted')).toBe(true);
+ expect(result.foreign).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(events()).toHaveLength(9);
+ expect(physical.size).toBeLessThanOrEqual(4); // Three private plus public discovery.
+});
+
+test('100 genuine command slots remain protected at source registry capacity without fixture deletion granting authority', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ a = f.actors(),
+ saved = [];
+ for (let i = 0; i < 100; i++) {
+ if (i) {
+ if (!(await f.replaceController()))
+ throw Error('actual next source controller');
+ if ((await f.prepareOriginal()).status !== 'prepared')
+ throw Error('actual next original S3/R1');
+ }
+ const action = window.pt.captureInboxProbePublicationAction(
+ f.repository,
+ a.session,
+ f.host.policy,
+ f.originalAck()!,
+ 'reviewed_inbox_probe_network'
+ );
+ if (!action) throw Error('actual bounded command slot ' + i);
+ saved.push(action);
+ await f.removeFixtureRow();
+ }
+ if (!(await f.replaceController()))
+ throw Error('actual capacity controller');
+ if ((await f.prepareOriginal()).status !== 'prepared')
+ throw Error('actual capacity original');
+ const row = (await f.host.stored()).find((x) => x.id === f.command())!;
+ const before = f.host.counts();
+ const refused = !window.pt.captureInboxProbePublicationAction(
+ f.repository,
+ a.session,
+ f.host.policy,
+ f.originalAck()!,
+ 'reviewed_inbox_probe_network'
+ );
+ if ((await f.recover())?.status !== 'recovered')
+ throw Error('actual capacity recovery');
+ if (!('acknowledgement' in (await f.adopt())))
+ throw Error('actual capacity readonly adoption');
+ const afterRecovery = f.host.counts(),
+ retryRefused = !(await f.captureAction());
+ return {
+ slots: saved.length,
+ refused,
+ retryRefused,
+ before,
+ afterRecovery,
+ after: f.host.counts(),
+ wire: row.wire,
+ current: (await f.host.stored()).find((x) => x.id === f.command())!.wire
+ };
+ });
+ expect(result.slots).toBe(100);
+ expect(result.refused).toBe(true);
+ expect(result.retryRefused).toBe(true);
+ expect(result.after).toEqual(result.afterRecovery);
+ expect(result.current).toBe(result.wire);
+ expect(privateFrames()).toHaveLength(0);
+});
+
+for (const lane of ['page', 'live'] as const)
+ test(`actual foreground ${lane} owner blocks new Retry without disturbing its subscription`, async ({
+ page
+ }) => {
+ await recover(page);
+ await adopt(page);
+ holdRead = true;
+ await page.evaluate((lane) => {
+ const f = window.ptFixture,
+ a = f.actors();
+ const pool = window.pt.getPrivatePool(
+ a.session,
+ f.host.policy,
+ ['wss://inbox.example.org'],
+ Object.freeze({}),
+ 'receive'
+ );
+ if (!pool) throw Error('actual foreground pool scope');
+ const stop =
+ lane === 'page'
+ ? window.pt.subscribePrivatePage(pool, 1, () => {})
+ : window.pt.subscribePrivateLive(pool, () => {});
+ window.ptRelease = () => {
+ stop();
+ };
+ }, lane);
+ await expect
+ .poll(() => privateFrames().filter((x) => x.frame[0] === 'REQ').length)
+ .toBe(1);
+ const framesBefore = privateFrames().slice();
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ before = f.host.counts(),
+ idle = f.idle(),
+ selected = await f.captureAction();
+ return { idle, refused: !selected, before, after: f.host.counts() };
+ });
+ expect(result.idle).toBe(false);
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(privateFrames()).toEqual(framesBefore);
+ await page.evaluate(() => window.ptRelease!());
+ await expect
+ .poll(() => page.evaluate(() => window.ptFixture.idle()))
+ .toBe(true);
+ await action(page);
+ });
+
+test('actual B1 B2 predecessor facts survive fresh-session recovery and never skip new named effects', async ({
+ page
+}) => {
+ const prior = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ pub = await f.originalPublish();
+ if (!pub) throw Error('actual old B1');
+ await f.append(pub);
+ const read = await f.originalRead();
+ if (!read) throw Error('actual old B2');
+ await f.appendRead(read);
+ return { pub, read };
+ });
+ const predecessor = await nativeWire(page);
+ await recover(page, true);
+ await adopt(page);
+ await action(page);
+ expect(await nativeWire(page)).toBe(predecessor);
+ expect(events()).toHaveLength(1);
+ const fresh = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ pub = await f.publish();
+ if (!pub) throw Error('actual fresh B1');
+ await f.append(pub);
+ const read = await f.read();
+ if (!read) throw Error('actual fresh B2');
+ await f.appendRead(read);
+ return {
+ pub,
+ read,
+ row: f.snapshot()?.record,
+ readiness: window.pt.inboxAccessControllerSnapshot(f.actors().access)
+ ?.readiness
+ };
+ });
+ expect(fresh.pub.status).toBe('accepted');
+ expect(fresh.read.status).toBe('readback');
+ expect(fresh.pub.actionId).not.toBe(prior.pub.actionId);
+ expect(fresh.row?.receipts.slice(0, 2)).toEqual(
+ (JSON.parse(predecessor) as { receipts: unknown[] }).receipts
+ );
+ expect(fresh.row?.receipts).toHaveLength(4);
+ expect(fresh.readiness).toBe('unavailable');
+ expect(events()).toHaveLength(2);
+});
+
+test('historical unknown labels remain unknown through adoption and require a new genuine observed effect', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = window.ptFixture,
+ effect = await f.originalPublish();
+ if (!effect) throw Error('actual predecessor fixture');
+ await f.append(effect);
+ const row = (await f.host.stored()).find((x) => x.id === f.command())!,
+ record = JSON.parse(row.wire) as { receipts: { status: string }[] };
+ record.receipts[0].status = 'unknown';
+ await f.host.inject([{ ...row, wire: JSON.stringify(record) }]);
+ });
+ const wire = await nativeWire(page);
+ await recover(page, true);
+ await adopt(page);
+ await action(page);
+ expect(await nativeWire(page)).toBe(wire);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ effect = await f.publish();
+ if (!effect) throw Error('actual fresh named effect');
+ await f.append(effect);
+ return { effect, row: f.snapshot()?.record };
+ });
+ expect(result.effect.status).toBe('accepted');
+ expect(result.row?.receipts.map((x) => x.status)).toEqual([
+ 'unknown',
+ 'accepted'
+ ]);
+ expect(events()).toHaveLength(2);
+});
+
+test('genuine original C1 nonce capability is isolated from recovered Retry and recovered readback cannot issue C1 proof', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = window.ptFixture,
+ a = f.actors();
+ if (!(await f.originalPublish()))
+ throw Error('actual original publication');
+ const read = await f.originalRead();
+ if (!read) throw Error('actual original read');
+ const reader = window.pt.captureInboxProbeNonceReader(
+ f.repository,
+ a.identity,
+ a.session,
+ f.host.policy,
+ read,
+ 'reviewed_inbox_probe_nonce_decryption'
+ );
+ if (!reader) throw Error('actual original C1 reader');
+ const proof = await window.pt.readInboxProbeNonce(reader);
+ if (!('proof' in proof)) throw Error('actual original C1 proof');
+ const before = f.host.counts();
+ const selected = await window.pt.adoptRecoveredInboxProbe(
+ f.repository,
+ a.session,
+ a.access,
+ f.host.policy,
+ f.host.qualification,
+ proof.proof as unknown as Parameters<
+ typeof window.pt.adoptRecoveredInboxProbe
+ >[5],
+ 'reviewed_original_inbox_probe_retry'
+ );
+ if (
+ 'acknowledgement' in selected ||
+ JSON.stringify(before) !== JSON.stringify(f.host.counts())
+ )
+ throw Error('C1 crossed recovered Retry authority');
+ window.pt.stopInboxProbeNonceReader(reader);
+ });
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ a = f.actors(),
+ read = await f.read();
+ if (!read) throw Error('actual recovered readback');
+ const before = f.host.counts();
+ const reader = window.pt.captureInboxProbeNonceReader(
+ f.repository,
+ a.identity,
+ a.session,
+ f.host.policy,
+ read,
+ 'reviewed_inbox_probe_nonce_decryption'
+ );
+ return { refused: !reader, before, after: f.host.counts(), read };
+ });
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(result.read.status).toBe('readback');
+ expect(result.read.attempt).toBe(3);
+});
+
+test('actual measured cumulative 45-second network allowance stays exhausted across original recovery', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ const f = window.ptFixture;
+ window.ptClock = f.installNetworkClock();
+ window.ptRestore = () => window.ptClock!.restore();
+ });
+ holdEvent = true;
+ await page.evaluate(() => {
+ window.ptPending = window.ptFixture.originalPublish();
+ });
+ await expect.poll(() => events().length).toBe(1);
+ await page.evaluate(() => window.ptClock!.advance(30000));
+ const id = (events()[0].frame[1] as { id: string }).id;
+ for (const socket of physical)
+ socket.send(JSON.stringify(['OK', id, true, '']));
+ expect(
+ ((await page.evaluate(() => window.ptPending)) as { status: string }).status
+ ).toBe('accepted');
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ holdRead = true;
+ await page.evaluate(() => {
+ window.ptPending = window.ptFixture.read();
+ });
+ await expect
+ .poll(() => privateFrames().filter((x) => x.frame[0] === 'REQ').length)
+ .toBe(1);
+ await page.evaluate(() => window.ptClock!.advance(15001));
+ const timed = (await page.evaluate(() => window.ptPending)) as {
+ status: string;
+ attempt: number;
+ };
+ expect(timed).toMatchObject({ status: 'timed_out', attempt: 2 });
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ before = f.host.counts(),
+ refused = !(await f.publish());
+ return {
+ refused,
+ before,
+ after: f.host.counts(),
+ observations: window.ptClock!.observations()
+ };
+ });
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(result.observations).toBeGreaterThan(0);
+ expect(events()).toHaveLength(1);
+});
+
+for (const fault of ['held', 'failed'] as const)
+ test(`actual original ${fault} physical cleanup blocks recovered authority without retrying cleanup implicitly`, async ({
+ page
+ }) => {
+ await recover(page);
+ await adopt(page);
+ holdEvent = true;
+ await page.evaluate(() => {
+ window.ptAbort = new AbortController();
+ window.ptPending = window.ptFixture.originalPublish(
+ undefined,
+ window.ptAbort.signal
+ );
+ });
+ await expect.poll(() => events().length).toBe(1);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.ptFixture,
+ acknowledgement = f.acknowledgement()!;
+ window.ptDelayClose = fault === 'held';
+ window.ptFailClose = fault === 'failed';
+ window.ptAbort!.abort();
+ let failed = false;
+ try {
+ f.stop();
+ } catch {
+ failed = true;
+ }
+ const effect = await window.ptPending,
+ before = f.host.counts(),
+ held = window.ptHeldClose?.length ?? 0;
+ const idle = f.idle(),
+ selected = await window.pt.captureRecoveredInboxProbeRetryAction(
+ f.repository,
+ f.actors().session,
+ f.host.policy,
+ acknowledgement,
+ 'reviewed_original_inbox_probe_retry'
+ );
+ return {
+ effect,
+ failed,
+ idle,
+ refused: !selected,
+ held,
+ afterHeld: window.ptHeldClose?.length ?? 0,
+ before,
+ after: f.host.counts()
+ };
+ }, fault);
+ expect(result.effect).toMatchObject({ status: 'stopped', attempt: 1 });
+ expect(result.idle).toBe(false);
+ expect(result.refused).toBe(true);
+ expect(result.afterHeld).toBe(result.held);
+ expect(result.after).toEqual(result.before);
+ if (fault === 'failed') expect(result.failed).toBe(true);
+ else expect(result.held).toBeGreaterThan(0);
+ const observed = await page.evaluate(async () => {
+ const before = window.ptCloseCalls ?? 0,
+ replacement = await window.ptFixture.replacementWhilePending();
+ return { replacement, before, after: window.ptCloseCalls ?? 0 };
+ });
+ const replacement = observed.replacement;
+ console.info(
+ JSON.stringify({
+ fixture: 'C2B_ACTUAL_FRESH_REPLACEMENT_PHYSICAL_GATE',
+ fault,
+ gate: replacement.gate,
+ genuineCurrentBinding:
+ replacement.gate === 'actual_retry_admission'
+ ? replacement.genuineCurrentBinding
+ : null,
+ uuidCalls:
+ replacement.gate === 'actual_retry_admission'
+ ? replacement.uuids
+ : null
+ })
+ );
+ expect(replacement.gate).toBe('actual_retry_admission');
+ if (replacement.gate !== 'actual_retry_admission')
+ throw Error('genuine fresh Retry must reach the original physical gate');
+ expect(replacement.genuineCurrentBinding).toBe(true);
+ expect(replacement.refused).toBe(true);
+ expect(replacement.uuids).toBe(0);
+ expect(replacement.after).toEqual(replacement.before);
+ expect(replacement.closesAfter).toBe(replacement.closesBefore);
+ expect(events()).toHaveLength(1);
+ await page.evaluate(() => {
+ window.ptDelayClose = false;
+ window.ptFailClose = false;
+ for (const release of window.ptHeldClose ?? []) release();
+ // A real failed close has no held callback to release: explicitly retry
+ // its ORIGINAL Stop before waiting for the resulting native close.
+ try {
+ window.ptFixture.stop();
+ } catch (error) {
+ if (
+ !(error instanceof Error) ||
+ !['private_pool_close_pending', 'private_pool_close_failed'].includes(
+ error.message
+ )
+ )
+ throw error;
+ }
+ });
+ await expect.poll(() => events().length).toBe(1);
+ await expect.poll(() => physical.size).toBeLessThanOrEqual(1);
+ await page.evaluate(() => window.ptFixture.stop());
+ holdEvent = false;
+ expect(
+ await page.evaluate(
+ async () => !!(await window.ptFixture.replaceController())
+ )
+ ).toBe(true);
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const next = await page.evaluate(() => window.ptFixture.publish());
+ expect(next).toMatchObject({ status: 'accepted', attempt: 1 });
+ expect(next!.actionId).not.toBe(
+ (result.effect as { actionId: string }).actionId
+ );
+ expect(events()).toHaveLength(2);
+ expect(events()[1].frame[1]).toEqual(events()[0].frame[1]);
+ });
+
+test('actual failed original SDK teardown stays protected without implicit Retry cleanup', async ({
+ page
+}) => {
+ await recover(page);
+ await adopt(page);
+ holdEvent = true;
+ await page.evaluate(() => {
+ const f = window.ptFixture,
+ fault = f.installAttemptTeardownFailure();
+ window.ptRestore = fault.restore;
+ window.ptAbort = new AbortController();
+ window.ptPending = f.originalPublish(undefined, window.ptAbort.signal);
+ });
+ await expect.poll(() => events().length).toBe(1);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture;
+ window.ptAbort!.abort();
+ const effect = await window.ptPending;
+ const before = f.host.counts(),
+ idle = f.idle(),
+ selected = await f.captureAction();
+ return { effect, idle, refused: !selected, before, after: f.host.counts() };
+ });
+ expect(result.effect).toMatchObject({ status: 'unknown', attempt: 1 });
+ expect(result.idle).toBe(false);
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(events()).toHaveLength(1);
+ await page.evaluate(() => {
+ window.ptRestore!();
+ window.ptFixture.stop();
+ });
+});
+
+for (const fault of ['aborted', 'uncertain', 'changed_successor'] as const)
+ test(`actual recovered native append ${fault} preserves strict original successor evidence`, async ({
+ page
+ }) => {
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.ptFixture,
+ effect = await f.publish();
+ if (!effect) throw Error('actual recovered SDK effect');
+ const before = await f.host.stored(),
+ control = f.installCommitFault(fault);
+ window.ptRestore = control.restore;
+ const first = await f.append(effect);
+ control.restore();
+ const afterFirst = await f.host.stored(),
+ second = await f.append(effect);
+ return { first, second, before, afterFirst, native: control.counts() };
+ }, fault);
+ if (fault === 'aborted') {
+ expect(result.first.status).toBe('aborted');
+ expect(result.afterFirst).toEqual(result.before);
+ expect(result.second.status).toBe('saved');
+ expect(result.native).toMatchObject({
+ putSuccess: 1,
+ complete: 0,
+ aborted: 1
+ });
+ } else {
+ expect(result.native).toMatchObject({
+ putSuccess: 1,
+ complete: 1,
+ aborted: 0
+ });
+ expect(result.native.abortRefused).toBeGreaterThan(0);
+ if (fault === 'uncertain') {
+ expect(result.first.status).toBe('reconciled');
+ expect(result.second.status).toBe('existing');
+ } else {
+ expect(result.native.changed).toBe(1);
+ expect(['conflict', 'unknown_completion']).toContain(
+ result.first.status
+ );
+ expect(result.second.status).not.toBe('saved');
+ }
+ }
+ expect(events()).toHaveLength(1);
+ });
+
+test('actual recovered effect bookkeeping remains eligible after controller loss without restoring authority', async ({
+ page
+}) => {
+ await recover(page);
+ await adopt(page);
+ await action(page);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ effect = await f.publish();
+ if (!effect) throw Error('actual recovered accepted effect');
+ window.pt.closeInboxAccessController(f.actors().access);
+ const before = f.host.counts(),
+ appended = await f.append(effect),
+ refused = !(await f.captureAction());
+ const row = (await f.host.stored()).find((x) => x.id === f.command())!;
+ return {
+ appended,
+ refused,
+ before,
+ after: f.host.counts(),
+ row: JSON.parse(row.wire) as { receipts: { status: string }[] }
+ };
+ });
+ expect(result.appended.status).toBe('saved');
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(result.row.receipts[0].status).toBe('accepted');
+ expect(events()).toHaveLength(1);
+});
+
+test('genuine ordinary recovery capability cannot supply original-probe Retry provenance', async ({
+ page
+}) => {
+ await recover(page);
+ const result = await page.evaluate(async () => {
+ const f = window.ptFixture,
+ a = f.actors(),
+ provider = Object.getOwnPropertyDescriptor(window, 'nostr')!;
+ const ordinary = await window.pt.makeOrdinaryRecoveryFixture();
+ const token = ordinary.capture();
+ Object.defineProperty(window, 'nostr', provider);
+ const before = f.host.counts(),
+ raw = await f.host.stored();
+ try {
+ const selected = await window.pt.adoptRecoveredInboxProbe(
+ f.repository,
+ a.session,
+ a.access,
+ f.host.policy,
+ f.host.qualification,
+ token as unknown as Parameters<
+ typeof window.pt.adoptRecoveredInboxProbe
+ >[5],
+ 'reviewed_original_inbox_probe_retry'
+ );
+ const action = await window.pt.captureRecoveredInboxProbeRetryAction(
+ f.repository,
+ a.session,
+ f.host.policy,
+ token as unknown as Parameters<
+ typeof window.pt.captureRecoveredInboxProbeRetryAction
+ >[3],
+ 'reviewed_original_inbox_probe_retry'
+ );
+ return {
+ refused: !('acknowledgement' in selected) && !action,
+ before,
+ after: f.host.counts(),
+ unchanged: JSON.stringify(raw) === JSON.stringify(await f.host.stored())
+ };
+ } finally {
+ ordinary.close();
+ Object.defineProperty(window, 'nostr', provider);
+ }
+ });
+ expect(result.refused).toBe(true);
+ expect(result.after).toEqual(result.before);
+ expect(result.unchanged).toBe(true);
+ expect(privateFrames()).toHaveLength(0);
+});
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-S4C2A: current admissions bind the shared guarded self
- // engine, distinct persisted-probe recovery and controller admission.
+ // CR008-S4C2B: current admissions also bind genuine recovered
+ // lineage, shared Retry metering and actual private-pool idle state.
'src/lib/nostr/self-recovery-reader.ts',
'src/lib/config/operation-flags.ts',
'src/lib/nostr/private-pool.ts',
diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs
@@ -18,7 +18,7 @@ import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { test } from 'node:test';
-test('CR007 and CR008-S4B exact private SDK removal cannot become an arbitrary remove capability', async () => {
+test('CR007 and CR008-S4B exact private SDK removal and CR008-S4C2B Retry lifecycle cannot become an arbitrary remove capability', async () => {
await fixture(async ({ directory, put, execute }) => {
await isolateScriptDependencies(directory);
await cp(path.join(root, 'src'), path.join(directory, 'src'), {
@@ -28,11 +28,13 @@ test('CR007 and CR008-S4B exact private SDK removal cannot become an arbitrary r
const file = 'src/lib/nostr/private-pool.ts';
const source = await readFile(path.join(root, file), 'utf8');
assert.ok(source.includes('sdk.remove(relay)'));
+ assert.ok(source.includes('!publishing && !busy && !liveBusy'));
for (const mutation of [
source + '\n export const unreviewedChange=1;\n',
source.replace('sdk.remove(relay)', 'sdk["remove"](relay)'),
source.replace('sdk.remove(relay)', 'sdk.remove(document.body)'),
- source.replace('sdk.remove(relay)', '(sdk.remove)(relay)')
+ source.replace('sdk.remove(relay)', '(sdk.remove)(relay)'),
+ source.replace('!publishing && !busy && !liveBusy', 'true')
]) {
await put(file, mutation);
const result = execute();
diff --git a/web/tests/unit/inbox-probe-retry.test.ts b/web/tests/unit/inbox-probe-retry.test.ts
@@ -0,0 +1,84 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import type { PrivateSession } from '../../src/lib/runtime/private-session.ts';
+import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts';
+import type { RelayPolicy } from '../../src/lib/config/relays.ts';
+import type { InboxOperatorQualification } from '../../src/lib/config/inbox-operators.ts';
+import type { InboxAccessController } from '../../src/lib/messaging/inbox-access-controller.ts';
+import type { RecoveredInboxProbe } from '../../src/lib/nostr/self-recovery-reader.ts';
+import type { InboxProbeAcknowledgement } from '../../src/lib/persistence/inbox-probes.ts';
+
+afterEach(() => vi.unstubAllGlobals());
+for (const browser of [false, true])
+ it(`cold ${browser ? 'browser-shaped' : 'SSR'} Retry rejects forged families before native SDK or cleanup 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 storage = await import('../../src/lib/persistence/inbox-probes.ts'),
+ publisher = await import('../../src/lib/nostr/private-publisher.ts'),
+ pool = await import('../../src/lib/nostr/private-pool.ts');
+ const repository = {} as PrivateStorageRepository,
+ session = {} as PrivateSession,
+ access = {} as InboxAccessController,
+ policy = {} as RelayPolicy,
+ operator = {} as InboxOperatorQualification;
+ for (const fake of [
+ undefined,
+ null,
+ false,
+ 0,
+ '',
+ Symbol(),
+ {},
+ { source: 'recovered', current: () => true, nonce_verified: true },
+ { status: 'adopted', acknowledgement: {} }
+ ]) {
+ const result = await storage.adoptRecoveredInboxProbe(
+ repository,
+ session,
+ access,
+ policy,
+ operator,
+ fake as RecoveredInboxProbe,
+ 'reviewed_original_inbox_probe_retry'
+ );
+ expect('acknowledgement' in result).toBe(false);
+ expect(
+ await publisher.captureRecoveredInboxProbeRetryAction(
+ repository,
+ session,
+ policy,
+ fake as InboxProbeAcknowledgement,
+ 'reviewed_original_inbox_probe_retry'
+ )
+ ).toBeUndefined();
+ expect(
+ storage.recoveredInboxProbePublicationBinding(
+ repository,
+ session,
+ fake as InboxProbeAcknowledgement,
+ policy
+ )
+ ).toBeUndefined();
+ expect(
+ pool.privatePoolProbeRetryIdle(fake as PrivateSession, policy)
+ ).toBe(false);
+ }
+ expect(effects).toBe(0);
+ });
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -319,15 +319,15 @@ async function operationalFlagsAdmission(web) {
'src/lib/nostr/self-recovery-reader.ts':
'51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b',
'src/lib/nostr/private-publisher.ts':
- '2f939dda3504b760dbf3758632cda6ce38d3e16c6d142b814e40a0e295a77d90',
+ 'e02cdbba35b8a9c7fc5f805c8c21432d4f6eab42c6d098411613189cb6ac7caf',
'src/lib/nostr/private-pool.ts':
- 'c5d7884b33ea8dcde6aea495c92e7a53db12cf650f4476f2b66adc4165e771c2',
+ '2ed123596f26bedb8aab5ec7694be6e264616429e00f745f1614c83f52de9825',
'src/lib/nostr/inbox-ingress.ts':
'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
'src/lib/persistence/inbox-probes.ts':
- 'b4d3089bcf08a5c9ac3a99dfcf8e2c2e2160a2c8996c19fccb2670614f7b4d7a',
+ '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8',
'src/lib/nostr/inbox-access.ts':
- '8a58978f3b535348165bc66f2b773e69a08f39a4a5741fb1d59ba546054aa1ce',
+ '16eef55d0ffcf2c3291573ddcb0b6a1432bb77abce0017a69e9b6f82414609a7',
'src/lib/nostr/seal-builder.ts':
'3ccc967cc348e63857243ff6f0302c1a68da2afe85ca2c37e00d5a894785fc53',
'src/lib/nostr/giftwrap-builder.ts':
@@ -597,15 +597,15 @@ async function privacyDataAdmission(web) {
'src/lib/nostr/self-recovery-reader.ts':
'51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b',
'src/lib/nostr/private-publisher.ts':
- '2f939dda3504b760dbf3758632cda6ce38d3e16c6d142b814e40a0e295a77d90',
+ 'e02cdbba35b8a9c7fc5f805c8c21432d4f6eab42c6d098411613189cb6ac7caf',
'src/lib/nostr/private-pool.ts':
- 'c5d7884b33ea8dcde6aea495c92e7a53db12cf650f4476f2b66adc4165e771c2',
+ '2ed123596f26bedb8aab5ec7694be6e264616429e00f745f1614c83f52de9825',
'src/lib/nostr/inbox-ingress.ts':
'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
'src/lib/persistence/inbox-probes.ts':
- 'b4d3089bcf08a5c9ac3a99dfcf8e2c2e2160a2c8996c19fccb2670614f7b4d7a',
+ '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8',
'src/lib/nostr/inbox-access.ts':
- '8a58978f3b535348165bc66f2b773e69a08f39a4a5741fb1d59ba546054aa1ce',
+ '16eef55d0ffcf2c3291573ddcb0b6a1432bb77abce0017a69e9b6f82414609a7',
'src/lib/nostr/seal-builder.ts':
'3ccc967cc348e63857243ff6f0302c1a68da2afe85ca2c37e00d5a894785fc53',
'src/lib/nostr/giftwrap-builder.ts':
@@ -2171,7 +2171,7 @@ async function inboxProbeStorageAdmission(web) {
'src/lib/persistence/private-storage.ts':
'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91',
'src/lib/persistence/inbox-probes.ts':
- 'b4d3089bcf08a5c9ac3a99dfcf8e2c2e2160a2c8996c19fccb2670614f7b4d7a'
+ '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8'
};
for (const [name, pin] of Object.entries(producers)) {
const bytes = await readOwned(web, name);
diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs
@@ -1664,7 +1664,7 @@ export async function auditSource(root) {
const relayRemovalTrusted =
files.has(relayRemovalFile) &&
createHash('sha256').update(files.get(relayRemovalFile)).digest('hex') ===
- 'c5d7884b33ea8dcde6aea495c92e7a53db12cf650f4476f2b66adc4165e771c2';
+ '2ed123596f26bedb8aab5ec7694be6e264616429e00f745f1614c83f52de9825';
if (files.has(relayRemovalFile) && !relayRemovalTrusted)
complain(
relayRemovalFile,