app

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

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:
Mweb/src/lib/nostr/inbox-access.ts | 15+++++++++++++++
Mweb/src/lib/nostr/private-pool.ts | 29+++++++++++++++++++++++++++++
Mweb/src/lib/nostr/private-publisher.ts | 247+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------
Mweb/src/lib/persistence/inbox-probes.ts | 253++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
Aweb/tests/e2e/harness/inbox-probe-retry.ts | 717+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/inbox-probe-retry.spec.ts | 1706+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 4++--
Mweb/tests/provenance/source-boundaries.test.mjs | 6++++--
Aweb/tests/unit/inbox-probe-retry.test.ts | 84+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 18+++++++++---------
Mweb/tools/source-boundaries.mjs | 2+-
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,