commit f2fd85be92f048fd964dbc9fe86cce24c829a503
parent af032995af12f4b3e575224514abb2288fa19499
Author: triesap <tyson@radroots.org>
Date: Fri, 9 Oct 2026 02:36:44 +0000
messages: implement bounded exact-artifact private retries (HCP-087)
- Requalify stored pair custody from genuine authenticated self recovery
- Retry unchanged persisted1059 artifacts within one bounded network action
- Skip current accepted targets and retain canonical named outcomes
- Preserve recovered state across successful same-owner observations
Diffstat:
10 files changed, 1564 insertions(+), 16 deletions(-)
diff --git a/web/src/lib/messaging/resume-preparation.ts b/web/src/lib/messaging/resume-preparation.ts
@@ -24,12 +24,21 @@ import {
stopRumorPlan,
type RumorPlan
} from './rumor-plan.ts';
-import { restoreRecoveredSendIdentity } from './send-identity.ts';
+import {
+ restoreRecoveredSendIdentity,
+ type ReservedSendIdentity
+} from './send-identity.ts';
+import {
+ acknowledgeRecoveredPairedDelivery,
+ type PairedDeliveryCommitResult
+} from '../persistence/private-sends.ts';
import { verifyRecoveredSelfEnvelope } from '../nostr/verify-outbound-envelope.ts';
import {
captureSelfRecoveryPreparation,
prepareSelfRecovery,
preparePairedDelivery,
+ preparedSelfRecovery,
+ preparedPairedDelivery,
stopSelfRecoveryPreparation,
type SelfRecoveryPreparation,
type PairedDeliveryContext,
@@ -66,6 +75,10 @@ type Controller = {
): Promise<ResumePreparationResult>;
snapshot(): Snapshot | undefined;
rumor(): RumorPlan | undefined;
+ qualify(
+ context: PairedDeliveryContext,
+ review: unknown
+ ): Promise<PairedDeliveryCommitResult | Readonly<{ status: 'busy' }>>;
stop(expired: boolean): void;
};
const resumes = new WeakMap<ResumePreparation, Controller>();
@@ -92,6 +105,7 @@ export function captureResumePreparation(
reader: SelfRecoveryReader | undefined,
plan: RumorPlan | undefined,
preparation: SelfRecoveryPreparation | undefined,
+ recoveredIdentity: ReservedSendIdentity | undefined,
alreadyPaired = false,
peerOnly = false,
originalWire: string | undefined,
@@ -110,6 +124,7 @@ export function captureResumePreparation(
preparation = undefined;
plan = undefined;
originalWire = undefined;
+ recoveredIdentity = undefined;
unsubscribe();
unsubscribe = () => {};
}
@@ -190,6 +205,7 @@ export function captureResumePreparation(
return { status: 'stopped' };
}
originalWire = source.storedWire;
+ recoveredIdentity = reserved;
alreadyPaired =
!!source.record.peerArtifact && !!source.record.deliveryPlan;
peerOnly = !!source.record.peerArtifact && !source.record.deliveryPlan;
@@ -268,9 +284,44 @@ export function captureResumePreparation(
run,
snapshot,
rumor: () => (current() ? plan : undefined),
+ async qualify(context, review) {
+ if (review !== 'reviewed_stored_private_retry')
+ return { status: 'invalid' };
+ if (!current()) return { status: 'stopped' };
+ if (busy) return { status: 'busy' };
+ if (!preparation || !recoveredIdentity) return { status: 'invalid' };
+ busy = true;
+ try {
+ const freshPair = preparedPairedDelivery(preparation);
+ if (freshPair) return { status: 'existing', receipt: freshPair };
+ if (!alreadyPaired) return { status: 'invalid' };
+ const saved = await prepareSelfRecovery(
+ preparation,
+ 'reviewed_self_recovery'
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!['saved', 'existing', 'reconciled'].includes(saved.status))
+ return { status: saved.status === 'stopped' ? 'stopped' : 'invalid' };
+ const self = preparedSelfRecovery(preparation);
+ if (!self) return { status: 'invalid' };
+ const qualified = await acknowledgeRecoveredPairedDelivery(
+ repository,
+ session,
+ recoveredIdentity,
+ self,
+ context,
+ review
+ );
+ return current() ? qualified : { status: 'stopped' };
+ } finally {
+ busy = false;
+ }
+ },
stop
});
- unsubscribe = subscribeIdentityInvalidation(session, () => stop(false));
+ unsubscribe = subscribeIdentityInvalidation(session, () => {
+ if (!ownership.current()) stop(false);
+ });
return current() ? token : undefined;
}
export function resumeEncryptedPreparation(
@@ -283,6 +334,16 @@ export function resumeEncryptedPreparation(
Promise.resolve({ status: 'invalid' })
);
}
+export function qualifyRecoveredPrivatePair(
+ token: ResumePreparation,
+ context: PairedDeliveryContext,
+ review: unknown
+): Promise<PairedDeliveryCommitResult | Readonly<{ status: 'busy' }>> {
+ return (
+ resumes.get(token)?.qualify(context, review) ??
+ Promise.resolve({ status: 'invalid' })
+ );
+}
export function resumePreparationSnapshot(token: ResumePreparation) {
return resumes.get(token)?.snapshot();
}
diff --git a/web/src/lib/messaging/retry-send.ts b/web/src/lib/messaging/retry-send.ts
@@ -0,0 +1,283 @@
+import {
+ privateRecordSnapshot,
+ type PrivateRecordHandle
+} from '../persistence/private-records.ts';
+import {
+ loadPrivateRecord,
+ type PrivateStorageRepository
+} from '../persistence/private-storage.ts';
+import {
+ pairedDeliveryAcknowledgementSnapshot,
+ pairedDeliveryRecordMatches,
+ pairedDeliveryTargetAccepted,
+ verifyPairedDeliveryAcknowledgement,
+ commitPairedDeliveryReceipt,
+ type PairedDeliveryAcknowledgement
+} from '../persistence/private-sends.ts';
+import {
+ privateSessionOwnership,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import {
+ capturePrivatePublicationAction,
+ capturePrivatePublication
+} from '../nostr/private-publisher.ts';
+import {
+ publishPrivateGiftWrapAttempt,
+ type PrivatePool
+} from '../nostr/private-pool.ts';
+import { PRIVATE_PUBLICATION_BUDGETS } from '../config/budgets.ts';
+import type { PairedDeliveryContext } from './prepare-send.ts';
+// Codec readback metadata alone is not a qualified authenticated remote query.
+// Only named acceptance suppresses retry here; separate readback remains visible.
+export function privateRetryTargets(
+ handle: PrivateRecordHandle,
+ owner: unknown,
+ id: unknown
+) {
+ const row = privateRecordSnapshot(handle, owner, id);
+ if (
+ !row ||
+ row.family !== 'private_send_operation' ||
+ !row.peerArtifact ||
+ !row.deliveryPlan
+ )
+ return undefined;
+ const pair = row.peerArtifact;
+ return [
+ row.deliveryPlan.routes.peer,
+ row.deliveryPlan.routes.archive
+ ].flatMap((route) => {
+ const eventId = route.role === 'peer' ? pair.eventId : row.self.eventId;
+ return route.targets
+ .filter(
+ (origin) =>
+ !(row.receipts ?? []).some(
+ (f) =>
+ f.role === route.role &&
+ f.origin === origin &&
+ f.eventId === eventId &&
+ f.status === 'accepted'
+ )
+ )
+ .map((origin) => ({ role: route.role, origin, eventId }));
+ });
+}
+declare const retryBrand: unique symbol;
+export type PrivateRetry = Readonly<{ [retryBrand]: true }>;
+type Result = Readonly<{
+ status: 'completed' | 'needs_action' | 'stopped' | 'invalid' | 'busy';
+}>;
+type Controller = {
+ run(review: unknown): Promise<Result>;
+ stop(): void;
+ snapshot(): Readonly<{
+ owner: string;
+ command: string;
+ state: Result['status'] | 'ready';
+ attempts: number;
+ }>;
+};
+const retries = new WeakMap<PrivateRetry, Controller>();
+// Capture is explicit, memory-only and opens no socket. Genuine custody and
+// actual whole-wire readback are rechecked before every externally visible step.
+export function capturePrivateRetry(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ receipt: PairedDeliveryAcknowledgement,
+ context: PairedDeliveryContext,
+ pool: PrivatePool,
+ review: unknown
+): PrivateRetry | undefined {
+ if (typeof window === 'undefined' || review !== 'reviewed_private_retry')
+ return undefined;
+ const ownership = privateSessionOwnership(session),
+ row = pairedDeliveryAcknowledgementSnapshot(receipt);
+ if (!ownership?.current() || !row || row.owner !== ownership.owner)
+ return undefined;
+ const action = capturePrivatePublicationAction(
+ repository,
+ session,
+ receipt,
+ context,
+ review
+ );
+ if (!action) return undefined;
+ const abort = new AbortController();
+ let consumed = false,
+ busy = false,
+ attempts = 0,
+ state: Result['status'] | 'ready' = 'ready';
+ const token = Object.freeze({}) as PrivateRetry;
+ function finish(status: Result['status']): Result {
+ state = status;
+ return { status };
+ }
+ retries.set(token, {
+ stop() {
+ abort.abort();
+ state = 'stopped';
+ },
+ snapshot() {
+ return { owner: row.owner, command: row.id, state, attempts };
+ },
+ async run(reviewed) {
+ if (reviewed !== 'reviewed_private_retry') return { status: 'invalid' };
+ if (abort.signal.aborted || !ownership.current())
+ return finish('stopped');
+ if (busy) return { status: 'busy' };
+ if (consumed) return { status: 'invalid' };
+ consumed = true;
+ busy = true;
+ try {
+ if (!(await verifyPairedDeliveryAcknowledgement(repository, receipt)))
+ return finish('needs_action');
+ const loaded = await loadPrivateRecord(
+ repository,
+ 'private_sends',
+ row.id
+ );
+ if (abort.signal.aborted || !ownership.current())
+ return finish('stopped');
+ if (
+ !loaded.ok ||
+ !pairedDeliveryRecordMatches(receipt, loaded.value) ||
+ !(await verifyPairedDeliveryAcknowledgement(repository, receipt))
+ )
+ return finish('needs_action');
+ if (abort.signal.aborted || !ownership.current())
+ return finish('stopped');
+ const targets =
+ loaded.ok && privateRetryTargets(loaded.value, row.owner, row.id);
+ if (!targets) return finish('needs_action');
+ for (const target of targets) {
+ let accepted = false;
+ for (
+ let index = 0;
+ index < PRIVATE_PUBLICATION_BUDGETS.attemptsPerTargetAction;
+ index++
+ ) {
+ if (abort.signal.aborted || !ownership.current())
+ return finish('stopped');
+ if (
+ pairedDeliveryTargetAccepted(
+ receipt,
+ target.role,
+ target.origin,
+ target.eventId
+ )
+ ) {
+ if (
+ !(await verifyPairedDeliveryAcknowledgement(
+ repository,
+ receipt
+ ))
+ )
+ return finish('needs_action');
+ if (abort.signal.aborted || !ownership.current())
+ return finish('stopped');
+ accepted = true;
+ break;
+ }
+ const permission = capturePrivatePublication(
+ repository,
+ session,
+ receipt,
+ context,
+ target.role,
+ target.origin,
+ 'reviewed_private_delivery',
+ action
+ );
+ if (!permission) return finish('needs_action');
+ const result = await publishPrivateGiftWrapAttempt(
+ pool,
+ permission,
+ abort.signal
+ );
+ if (abort.signal.aborted || !ownership.current())
+ return finish('stopped');
+ if (
+ !result.actionId &&
+ pairedDeliveryTargetAccepted(
+ receipt,
+ target.role,
+ target.origin,
+ target.eventId
+ ) &&
+ (await verifyPairedDeliveryAcknowledgement(repository, receipt))
+ ) {
+ if (abort.signal.aborted || !ownership.current())
+ return finish('stopped');
+ accepted = true;
+ break;
+ }
+ if (
+ !result.actionId ||
+ !result.attempt ||
+ result.role !== target.role ||
+ result.origin !== target.origin ||
+ result.eventId !== target.eventId
+ )
+ return finish('needs_action');
+ attempts++;
+ const observedAtMilliseconds = Date.now();
+ if (
+ !Number.isSafeInteger(observedAtMilliseconds) ||
+ observedAtMilliseconds < 0
+ )
+ return finish('needs_action');
+ const saved = await commitPairedDeliveryReceipt(
+ repository,
+ receipt,
+ JSON.stringify({
+ actionId: result.actionId,
+ role: target.role,
+ origin: target.origin,
+ eventId: target.eventId,
+ attempt: result.attempt,
+ status: result.status,
+ observedAtMilliseconds,
+ readbackWire: null
+ })
+ );
+ if (abort.signal.aborted || !ownership.current())
+ return finish('stopped');
+ if (!('record' in saved)) return finish('needs_action');
+ if (result.status === 'accepted') {
+ accepted = true;
+ break;
+ }
+ if (result.status === 'refused' || result.status === 'stopped')
+ return finish('needs_action');
+ }
+ if (!accepted) return finish('needs_action');
+ }
+ return finish('completed');
+ } catch {
+ return finish(
+ abort.signal.aborted || !ownership.current()
+ ? 'stopped'
+ : 'needs_action'
+ );
+ } finally {
+ busy = false;
+ }
+ }
+ });
+ return token;
+}
+export function runPrivateRetry(
+ token: PrivateRetry,
+ review: unknown
+): Promise<Result> {
+ return (
+ retries.get(token)?.run(review) ?? Promise.resolve({ status: 'invalid' })
+ );
+}
+export function stopPrivateRetry(token: PrivateRetry): void {
+ retries.get(token)?.stop();
+}
+export function privateRetrySnapshot(token: PrivateRetry) {
+ return retries.get(token)?.snapshot();
+}
diff --git a/web/src/lib/messaging/rumor-plan.ts b/web/src/lib/messaging/rumor-plan.ts
@@ -117,9 +117,9 @@ export function restoreRecoveredRumor(
const token = Object.freeze({}) as RumorPlan;
const current = () =>
ownership.current() && !!recoveredSelfEnvelopeSnapshot(recovered);
- const unsubscribe = subscribeIdentityInvalidation(session, () =>
- stopRumorPlan(token)
- );
+ const unsubscribe = subscribeIdentityInvalidation(session, () => {
+ if (!current()) stopRumorPlan(token);
+ });
plans.set(token, {
owner: snapshot.record.owner,
peer: snapshot.record.peer,
diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts
@@ -39,6 +39,8 @@ export type PrivateGiftWrapAttemptResult = Readonly<{
role?: PrivateDeliveryRole;
origin?: string;
eventId?: string;
+ actionId?: string;
+ attempt?: number;
}>;
export type PrivatePageMessage =
| Readonly<{ type: 'candidate'; from: string; wire: string }>
@@ -215,6 +217,9 @@ export function getPrivatePool(
!admitted.current()
)
return { status: 'stopped' as const };
+ const network = admitted.beginNetwork();
+ if (admitted.networkMetered && !network)
+ return { status: 'stopped' as const };
return await new Promise<PrivateGiftWrapAttemptResult>(
(resolve) => {
let ended = false,
@@ -225,6 +230,7 @@ export function getPrivatePool(
) {
if (ended) return;
ended = true;
+ network?.finish();
clearTimeout(timer);
if (fenceTimer !== undefined) clearTimeout(fenceTimer);
signal.removeEventListener('abort', stop);
@@ -239,7 +245,10 @@ export function getPrivatePool(
status,
role: admitted!.role,
origin: admitted!.origin,
- eventId: admitted!.eventId
+ eventId: admitted!.eventId,
+ ...(network
+ ? { actionId: network.actionId, attempt: network.attempt }
+ : {})
});
}
function stop() {
@@ -252,6 +261,10 @@ export function getPrivatePool(
}
function fence() {
if (ended) return;
+ if (network && network.remaining() <= 0) {
+ finish('timed_out');
+ return;
+ }
if (
closed ||
signal.aborted ||
@@ -264,13 +277,13 @@ export function getPrivatePool(
fenceTimer = setTimeout(() => fence(), 50);
}
const relay = sdk.relay(view.origin);
+ const allowance =
+ network?.remaining() ??
+ PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds;
const timeout =
Number.isFinite(relay.eventTimeout) && relay.eventTimeout > 0
- ? Math.min(
- PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds,
- relay.eventTimeout
- )
- : PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds;
+ ? Math.min(allowance, relay.eventTimeout)
+ : allowance;
const timer = setTimeout(() => finish('timed_out'), timeout);
signal.addEventListener('abort', stop, { once: true });
publicationStops.set(stop, true);
@@ -291,6 +304,10 @@ export function getPrivatePool(
.subscribe({
next(response) {
if (ended) return;
+ if (network && network.remaining() <= 0) {
+ finish('timed_out');
+ return;
+ }
if (
(response.from !== view.origin &&
response.from !== view.origin + '/') ||
diff --git a/web/src/lib/nostr/private-publisher.ts b/web/src/lib/nostr/private-publisher.ts
@@ -4,6 +4,7 @@ import {
} from '../runtime/private-session.ts';
import {
pairedDeliveryAcknowledgementSnapshot,
+ pairedDeliveryTargetAccepted,
verifyPairedDeliveryAcknowledgement,
type PairedDeliveryAcknowledgement
} from '../persistence/private-sends.ts';
@@ -14,7 +15,11 @@ import {
recheckInboxRoutePlan
} from '../messaging/inbox-routing.ts';
import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts';
-import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
+import {
+ PRIVATE_TRANSPORT_BUDGETS,
+ PRIVATE_PUBLICATION_BUDGETS
+} from '../config/budgets.ts';
+import { newLocalId } from '../private-handles.ts';
import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
import {
verifyEnvelope,
@@ -23,6 +28,158 @@ import {
declare const publicationBrand: unique symbol;
export type PrivatePublication = Readonly<{ [publicationBrand]: true }>;
export type PrivateDeliveryRole = 'peer' | 'self_archive';
+declare const actionBrand: unique symbol;
+export type PrivatePublicationAction = Readonly<{ [actionBrand]: true }>;
+type NetworkAttempt = Readonly<{
+ actionId: string;
+ attempt: number;
+ remaining(): number;
+ finish(): void;
+}>;
+type Action = {
+ session: PrivateSession;
+ receipt: PairedDeliveryAcknowledgement;
+ context: PairedDeliveryContext;
+ current(): boolean;
+ begin(
+ role: PrivateDeliveryRole,
+ origin: string,
+ eventId: string
+ ): NetworkAttempt | undefined;
+};
+const actions = new WeakMap<PrivatePublicationAction, Action>();
+function immutablePair(receipt: PairedDeliveryAcknowledgement) {
+ const row = pairedDeliveryAcknowledgementSnapshot(receipt);
+ return (
+ row &&
+ JSON.stringify({
+ owner: row.owner,
+ id: row.id,
+ peer: row.peer,
+ rumorHash: row.rumorHash,
+ createdAt: row.createdAt,
+ self: row.self,
+ peerArtifact: row.peerArtifact,
+ deliveryPlan: row.deliveryPlan
+ })
+ );
+}
+// One explicit action has one network meter, including all artifacts/targets.
+// SDK identity approval and persisted readback happen before an attempt starts.
+export function capturePrivatePublicationAction(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ receipt: PairedDeliveryAcknowledgement,
+ context: PairedDeliveryContext,
+ review: unknown
+): PrivatePublicationAction | undefined {
+ if (review !== 'reviewed_private_retry') return undefined;
+ const row = pairedDeliveryAcknowledgementSnapshot(receipt),
+ original = immutablePair(receipt),
+ ownership = privateSessionOwnership(session);
+ if (!row || !original || !ownership?.current()) return undefined;
+ for (const route of [
+ row.deliveryPlan.routes.peer,
+ row.deliveryPlan.routes.archive
+ ])
+ for (const origin of route.targets) {
+ if (
+ !capturePrivatePublication(
+ repository,
+ session,
+ receipt,
+ context,
+ route.role,
+ origin,
+ 'reviewed_private_delivery'
+ )
+ )
+ return undefined;
+ }
+ const actionId = newLocalId();
+ if (!actionId) return undefined;
+ const counts = new Map<string, number>();
+ let used = 0,
+ running = false,
+ broken = false,
+ last = -1;
+ function clock() {
+ const now = performance.now();
+ if (!Number.isFinite(now) || now < 0 || now < last) {
+ broken = true;
+ return undefined;
+ }
+ last = now;
+ return now;
+ }
+ function current() {
+ return (
+ !broken &&
+ ownership!.current() &&
+ immutablePair(receipt) === original &&
+ recheckInboxRoutePlan(
+ context.plan,
+ context.policy,
+ context.own,
+ context.other
+ ) === 'unchanged'
+ );
+ }
+ const token = Object.freeze({}) as PrivatePublicationAction;
+ actions.set(token, {
+ session,
+ receipt,
+ context,
+ current,
+ begin(role, origin, eventId) {
+ if (
+ !current() ||
+ running ||
+ used >= PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds
+ )
+ return undefined;
+ const key = JSON.stringify([role, origin, eventId]),
+ count = counts.get(key) ?? 0;
+ if (count >= PRIVATE_PUBLICATION_BUDGETS.attemptsPerTargetAction)
+ return undefined;
+ const start = clock();
+ if (start === undefined) return undefined;
+ counts.set(key, count + 1);
+ running = true;
+ let finished = false;
+ function remaining() {
+ const now = clock();
+ return finished || now === undefined || !current()
+ ? 0
+ : Math.max(
+ 0,
+ PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds -
+ used -
+ (now - start!)
+ );
+ }
+ return {
+ actionId,
+ attempt: count + 1,
+ remaining,
+ finish() {
+ if (finished) return;
+ const now = clock();
+ finished = true;
+ running = false;
+ used =
+ now === undefined
+ ? PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds
+ : Math.min(
+ PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds,
+ used + now - start
+ );
+ }
+ };
+ }
+ });
+ return token;
+}
type Admission = {
session: PrivateSession;
policy: RelayPolicy;
@@ -37,6 +194,7 @@ type Admission = {
destination: string;
current(): boolean;
take(): boolean;
+ action?: Action;
};
const permissions = new WeakMap<PrivatePublication, Admission>();
// Genuine current local pair custody plus its frozen routes is necessary, but
@@ -49,7 +207,8 @@ export function capturePrivatePublication(
context: PairedDeliveryContext,
role: PrivateDeliveryRole,
origin: string,
- review: unknown
+ review: unknown,
+ action?: PrivatePublicationAction
): PrivatePublication | undefined {
if (
typeof window === 'undefined' ||
@@ -60,7 +219,17 @@ export function capturePrivatePublication(
return undefined;
try {
const ownership = privateSessionOwnership(session),
- saved = pairedDeliveryAcknowledgementSnapshot(receipt);
+ saved = pairedDeliveryAcknowledgementSnapshot(receipt),
+ budget = action && actions.get(action);
+ if (
+ action &&
+ (!budget ||
+ budget.session !== session ||
+ budget.receipt !== receipt ||
+ budget.context !== context ||
+ !budget.current())
+ )
+ return undefined;
if (!ownership || !saved || ownership.owner !== saved.owner)
return undefined;
const policy = context.policy,
@@ -131,6 +300,7 @@ export function capturePrivatePublication(
wire: artifact.wire,
destination,
current,
+ ...(budget ? { action: budget } : {}),
take() {
if (consumed) return false;
consumed = true;
@@ -182,6 +352,16 @@ export async function takePrivatePublication(
!saved.current()
)
return undefined;
+ if (
+ saved.action &&
+ pairedDeliveryTargetAccepted(
+ saved.receipt,
+ saved.role,
+ saved.origin,
+ saved.eventId
+ )
+ )
+ return undefined;
const verified = verifyEnvelope(saved.wire),
event = verified.ok && verifiedEnvelopeSnapshot(verified.value);
if (
@@ -202,7 +382,12 @@ export async function takePrivatePublication(
command: saved.command,
role: saved.role,
origin: saved.origin,
- eventId: saved.eventId
+ eventId: saved.eventId,
+ beginNetwork: () =>
+ saved.action
+ ? saved.action.begin(saved.role, saved.origin, saved.eventId)
+ : undefined,
+ networkMetered: !!saved.action
};
} catch {
return undefined;
diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts
@@ -321,7 +321,9 @@ export function captureSelfRecoveryReader(
}
const token = Object.freeze({}) as SelfRecoveryReader;
readers.set(token, { run, stop });
- unsubscribe = subscribeIdentityInvalidation(session, () => stop(false));
+ unsubscribe = subscribeIdentityInvalidation(session, () => {
+ if (!ownership.current()) stop(false);
+ });
return current() ? token : undefined;
}
export function readSelfRecoveryEnvelope(
diff --git a/web/src/lib/persistence/private-sends.ts b/web/src/lib/persistence/private-sends.ts
@@ -1,5 +1,6 @@
import {
identityMessagingOwnership,
+ recheckIdentityOwner,
type IdentitySession
} from '../runtime/identity-session.ts';
import {
@@ -25,8 +26,10 @@ import {
} from './private-records.ts';
import {
inboxRoutePlanSnapshot,
+ recheckInboxRoutePlan,
type InboxRoutePlan
} from '../messaging/inbox-routing.ts';
+import type { PairedDeliveryContext } from '../messaging/prepare-send.ts';
import {
loadPrivateRecord,
commitPrivateRecord,
@@ -316,6 +319,108 @@ const pairedAcknowledgements = new WeakMap<
PairedDeliveryAcknowledgement,
Paired
>();
+// Explicit restart admission authenticates the self recovery copy and verifies
+// exact durable pair custody. It does not decrypt or newly authenticate the
+// nested peer ciphertext, regenerate either artifact, or perform publication.
+export async function acknowledgeRecoveredPairedDelivery(
+ repository: PrivateStorageRepository,
+ session: IdentitySession,
+ reserved: ReservedSendIdentity,
+ self: SelfRecoveryAcknowledgement,
+ context: PairedDeliveryContext,
+ review: unknown
+): Promise<PairedDeliveryCommitResult> {
+ if (
+ typeof window === 'undefined' ||
+ review !== 'reviewed_stored_private_retry' ||
+ !navigator.locks?.request
+ )
+ return { status: 'invalid' };
+ const saved = acknowledgements.get(self),
+ original = reservedSendSnapshot(reserved),
+ ownership = identityMessagingOwnership(session);
+ if (
+ !saved?.current() ||
+ !original ||
+ !ownership?.current() ||
+ JSON.stringify(saved.record) !== JSON.stringify(original) ||
+ original.owner !== ownership.owner
+ )
+ return { status: 'invalid' };
+ const current = () =>
+ ownership.current() &&
+ saved.current() &&
+ !!reservedSendSnapshot(reserved) &&
+ recheckInboxRoutePlan(
+ context.plan,
+ context.policy,
+ context.own,
+ context.other
+ ) === 'unchanged';
+ try {
+ const checked = await recheckIdentityOwner(session);
+ if (
+ checked.state !== 'messaging_capable' ||
+ checked.publicKey !== ownership.owner ||
+ checked.admission === 'busy' ||
+ !current()
+ )
+ return { status: 'stopped' };
+ return await navigator.locks.request(
+ 'harvestcircle:owner:' + ownership.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock) => {
+ if (!lock || !current()) return { status: 'stopped' as const };
+ const loaded = await loadPrivateRecord(
+ repository,
+ 'private_sends',
+ original.id
+ );
+ if (!current()) return { status: 'stopped' as const };
+ if (!loaded.ok) return { status: loaded.reason };
+ const row = privateRecordSnapshot(
+ loaded.value,
+ original.owner,
+ original.id
+ ),
+ wire = privateRecordWire(loaded.value, original.owner, original.id),
+ routes = inboxRoutePlanSnapshot(context.plan);
+ if (
+ !row ||
+ row.family !== 'private_send_operation' ||
+ !row.peerArtifact ||
+ !row.deliveryPlan ||
+ !wire ||
+ wire !== saved.wire ||
+ JSON.stringify(row.deliveryPlan.routes) !== JSON.stringify(routes)
+ )
+ return { status: 'conflict' as const };
+ const verified = verifyEnvelope(row.peerArtifact.wire),
+ event = verified.ok && verifiedEnvelopeSnapshot(verified.value);
+ if (
+ !event ||
+ event.kind !== 1059 ||
+ event.id !== row.peerArtifact.eventId ||
+ event.tags.length !== 1 ||
+ event.tags[0].length !== 2 ||
+ event.tags[0][0] !== 'p' ||
+ event.tags[0][1] !== row.peer ||
+ !current()
+ )
+ return { status: 'invalid' as const };
+ const receipt = Object.freeze({}) as PairedDeliveryAcknowledgement;
+ pairedAcknowledgements.set(receipt, {
+ record: row,
+ wire,
+ current: () => ownership.current()
+ });
+ return { status: 'existing' as const, receipt };
+ }
+ );
+ } catch {
+ return { status: current() ? 'unavailable' : 'stopped' };
+ }
+}
export type PairedDeliveryCommitResult =
| Readonly<{
status: 'prepared' | 'existing' | 'reconciled';
@@ -525,6 +630,40 @@ export async function verifyPairedDeliveryAcknowledgement(
saved.wire
);
}
+// A separately decoded row cannot supply acceptance facts merely because the
+// owner and local ID match. Require the full wire acknowledged by this genuine
+// current custody, then let the workflow recheck actual storage before use.
+export function pairedDeliveryRecordMatches(
+ receipt: PairedDeliveryAcknowledgement,
+ record: PrivateRecordHandle
+): boolean {
+ const saved = pairedAcknowledgements.get(receipt);
+ return (
+ !!saved?.current() &&
+ privateRecordWire(record, saved.record.owner, saved.record.id) ===
+ saved.wire
+ );
+}
+// Pure genuine custody metadata. A workflow must still verify full readback
+// under the owner lock before suppressing or admitting a network effect.
+export function pairedDeliveryTargetAccepted(
+ receipt: PairedDeliveryAcknowledgement,
+ role: 'peer' | 'self_archive',
+ origin: string,
+ eventId: string
+): boolean {
+ const saved = pairedAcknowledgements.get(receipt);
+ return (
+ !!saved?.current() &&
+ (saved.record.receipts ?? []).some(
+ (fact) =>
+ fact.role === role &&
+ fact.origin === origin &&
+ fact.eventId === eventId &&
+ fact.status === 'accepted'
+ )
+ );
+}
// Only the already genuine current pair can renew its exact custody after a
// controlled append of named receipt metadata. A decoded namespace row alone
// cannot mint this acknowledgment. Earlier permissions invalidate on revision.
diff --git a/web/tests/e2e/harness/retry-send.ts b/web/tests/e2e/harness/retry-send.ts
@@ -0,0 +1,217 @@
+import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts';
+import {
+ validateRelayPolicy,
+ readRelayPolicy
+} from '../../../src/lib/config/relays.ts';
+import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts';
+import {
+ createPrivateSession,
+ closePrivateSession
+} from '../../../src/lib/runtime/private-session.ts';
+import {
+ getPrivatePool,
+ closePrivatePool
+} from '../../../src/lib/nostr/private-pool.ts';
+import {
+ resumeEncryptedPreparation,
+ qualifyRecoveredPrivatePair,
+ resumePreparationSnapshot,
+ resumeRecoveredRumor,
+ stopResumePreparation
+} from '../../../src/lib/messaging/resume-preparation.ts';
+import { rumorPlanSnapshot } from '../../../src/lib/messaging/rumor-plan.ts';
+import { decodePrivateRecord } from '../../../src/lib/persistence/private-records.ts';
+import {
+ capturePrivateRetry,
+ runPrivateRetry,
+ stopPrivateRetry,
+ privateRetrySnapshot,
+ type PrivateRetry
+} from '../../../src/lib/messaging/retry-send.ts';
+import {
+ pairedDeliveryAcknowledgementSnapshot,
+ commitPairedDeliveryReceipt,
+ type PairedDeliveryAcknowledgement
+} from '../../../src/lib/persistence/private-sends.ts';
+export async function makeFixture(initialise = true) {
+ const f = await makeRecoveryFixture(initialise);
+ const policy = validateRelayPolicy(
+ JSON.stringify({
+ ...readRelayPolicy(f.context.policy),
+ messagingEnabled: true
+ })
+ );
+ if (!policy) throw Error('invalid private fixture policy');
+ const plan = createInboxRoutePlan(
+ policy,
+ f.owner,
+ f.peer,
+ f.context.own,
+ f.context.other
+ );
+ if (!plan) throw Error('missing private route plan');
+ const context = { ...f.context, policy, plan };
+ const session = await createPrivateSession(
+ f.identity,
+ 'reviewed_private_session'
+ );
+ if (!session) throw Error('missing genuine private session');
+ const pool = getPrivatePool(session, policy, [
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ]);
+ if (!pool) throw Error('missing private pool');
+ const resume = f.capture();
+ let receipt: PairedDeliveryAcknowledgement | undefined,
+ retry: PrivateRetry | undefined;
+ let restoreFault = () => {},
+ injected = 0;
+ async function prepare() {
+ const recovered = await resumeEncryptedPreparation(
+ resume,
+ context,
+ 'reviewed_private_resume'
+ );
+ if (!['prepared', 'already_prepared'].includes(recovered.status))
+ return recovered;
+ const qualified = await qualifyRecoveredPrivatePair(
+ resume,
+ context,
+ 'reviewed_stored_private_retry'
+ );
+ if ('receipt' in qualified) receipt = qualified.receipt;
+ return { status: qualified.status };
+ }
+ function capture(review: unknown = 'reviewed_private_retry') {
+ retry = receipt
+ ? capturePrivateRetry(
+ f.repository,
+ session!,
+ receipt,
+ context,
+ pool!,
+ review
+ )
+ : undefined;
+ return !!retry;
+ }
+ return {
+ ...f,
+ async row() {
+ const value = await f.row();
+ if (!value) throw Error('missing actual paired row');
+ return value;
+ },
+ prepare,
+ capture,
+ run: (review: unknown = 'reviewed_private_retry') =>
+ retry
+ ? runPrivateRetry(retry, review)
+ : Promise.resolve({ status: 'invalid' as const }),
+ snapshot: () => retry && privateRetrySnapshot(retry),
+ proof: () => receipt && pairedDeliveryAcknowledgementSnapshot(receipt),
+ recovered: () => ({
+ snapshot: resumePreparationSnapshot(resume),
+ rumor: !!rumorPlanSnapshot(resumeRecoveredRumor(resume)!)
+ }),
+ stop: () => {
+ if (retry) stopPrivateRetry(retry);
+ },
+ clearRecovery: () => stopResumePreparation(resume),
+ countsValue: () => f.counts(),
+ async controlledArchiveSuccessor() {
+ if (!receipt) throw Error('missing genuine custody');
+ const row = (await f.row())?.record;
+ if (!row) throw Error('missing actual ciphertext');
+ // Controlled metadata race, not a claim of an additional relay ACK.
+ return commitPairedDeliveryReceipt(
+ f.repository,
+ receipt,
+ JSON.stringify({
+ actionId: '12345678-1234-4234-8234-123456789abe',
+ role: 'self_archive',
+ origin: 'wss://archive.example.org',
+ attempt: 1,
+ eventId: row.self.eventId,
+ status: 'accepted',
+ observedAtMilliseconds: 100,
+ readbackWire: null
+ })
+ );
+ },
+ async injectUnacknowledgedSuccessBetweenReads() {
+ const stored = await f.row();
+ if (!stored?.record.peerArtifact || !stored.record.deliveryPlan)
+ throw Error('missing real paired record');
+ const row = stored.record;
+ const facts = [
+ row.deliveryPlan!.routes.peer,
+ row.deliveryPlan!.routes.archive
+ ].flatMap((route) =>
+ route.targets.map((origin) => ({
+ actionId: '12345678-1234-4234-8234-123456789abf',
+ role: route.role,
+ origin,
+ attempt: 1,
+ eventId:
+ route.role === 'peer'
+ ? row.peerArtifact!.eventId
+ : row.self.eventId,
+ status: 'accepted',
+ observedAtMilliseconds: 100,
+ readbackWire: null
+ }))
+ );
+ const wire = JSON.stringify({
+ ...row,
+ revision: row.revision + 1,
+ receipts: [...(row.receipts ?? []), ...facts]
+ });
+ if (!decodePrivateRecord(wire, f.owner, f.command).ok)
+ throw Error('invalid controlled race row');
+ const native = Reflect.get<IDBIndex, 'openCursor'>(
+ IDBIndex.prototype,
+ 'openCursor'
+ );
+ IDBIndex.prototype.openCursor = function (
+ ...args: Parameters<IDBIndex['openCursor']>
+ ) {
+ const request = native.apply(this, args);
+ if (this.objectStore.name === 'private_sends' && injected === 0) {
+ injected++;
+ // Queue real RW behind first genuine verification and ahead of the
+ // next load. No opaque acknowledgement is renewed by this mutation.
+ const transaction = this.objectStore.transaction.db.transaction(
+ ['private_sends'],
+ 'readwrite'
+ );
+ transaction
+ .objectStore('private_sends')
+ .put({ owner: f.owner, id: f.command, wire });
+ }
+ return request;
+ };
+ restoreFault = () => {
+ IDBIndex.prototype.openCursor = native;
+ };
+ return {
+ originalWire: stored.wire,
+ changedWire: wire,
+ revision: row.revision
+ };
+ },
+ injected: () => injected,
+ clearFault() {
+ restoreFault();
+ restoreFault = () => {};
+ },
+ close() {
+ restoreFault();
+ if (retry) stopPrivateRetry(retry);
+ stopResumePreparation(resume);
+ closePrivatePool(pool);
+ closePrivateSession(session);
+ f.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/retry-send.spec.ts b/web/tests/e2e/retry-send.spec.ts
@@ -0,0 +1,500 @@
+import { test, expect } from '@playwright/test';
+import { build } from 'vite';
+import { fileURLToPath } from 'node:url';
+import { once } from 'node:events';
+import { WebSocketServer } from 'ws';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Fixture from './harness/retry-send.ts';
+declare global {
+ interface Window {
+ hcp087: typeof Fixture;
+ hcp087Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>;
+ hcp087Pending: ReturnType<
+ Awaited<ReturnType<typeof Fixture.makeFixture>>['run']
+ >;
+ hcp087Advance: () => void;
+ hcp087Release: () => void;
+ hcp087Waiting: boolean;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string;
+let events: { origin: string; wire: string }[] = [],
+ response: 'accepted' | 'refused' | 'unknown' | 'silent' = 'accepted';
+let archiveResponse: 'accepted' | 'refused' | 'unknown' | 'silent' | undefined;
+let pendingAcks: { socket: import('ws').WebSocket; id: string }[] = [];
+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('loopback unavailable');
+ endpoint = 'ws://127.0.0.1:' + address.port;
+ sockets.on('connection', (socket, request) =>
+ socket.on('message', (bytes) => {
+ const raw = Buffer.isBuffer(bytes)
+ ? bytes
+ : Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.from(bytes),
+ frame = JSON.parse(raw.toString()) as unknown[];
+ if (frame[0] !== 'EVENT') return;
+ const event = frame[1] as { id: string };
+ pendingAcks.push({ socket, id: event.id });
+ events.push({
+ origin: new URL(request.url!, 'http://localhost').searchParams.get(
+ 'origin'
+ )!,
+ wire: JSON.stringify(event)
+ });
+ const outcome =
+ events.at(-1)!.origin === 'wss://archive.example.org'
+ ? (archiveResponse ?? response)
+ : response;
+ if (outcome !== 'silent')
+ socket.send(
+ JSON.stringify([
+ 'OK',
+ event.id,
+ outcome === 'accepted',
+ outcome === 'unknown'
+ ? 'Timeout'
+ : outcome === 'refused'
+ ? 'auth-required: fixture refusal'
+ : ''
+ ])
+ );
+ })
+ );
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/retry-send.ts', import.meta.url)
+ ),
+ name: 'hcp087',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('bundle unavailable');
+ 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();
+});
+async function load(page: import('@playwright/test').Page, initialise = true) {
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async (initialise) => {
+ window.hcp087Fixture = await window.hcp087.makeFixture(initialise);
+ }, initialise);
+}
+test.beforeEach(async ({ page }) => {
+ events = [];
+ response = 'accepted';
+ archiveResponse = undefined;
+ pendingAcks = [];
+ await page.addInitScript(
+ ({ endpoint }) => {
+ const Native = window.WebSocket;
+ window.WebSocket = class extends Native {
+ constructor(url: string | URL, protocols?: string | string[]) {
+ const origin = new URL(String(url)).origin;
+ if (
+ !['wss://peer.example.org', 'wss://archive.example.org'].includes(
+ origin
+ )
+ )
+ throw Error('unapproved destination');
+ super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
+ }
+ };
+ },
+ { endpoint }
+ );
+ await load(page);
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(() => window.hcp087Fixture?.close());
+});
+test('successful same-owner observations preserve recovered rumor and both original artifacts', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture,
+ prepared = await f.prepare();
+ f.capture();
+ const before = f.countsValue(),
+ result = await f.run();
+ return {
+ prepared,
+ result,
+ before,
+ after: f.countsValue(),
+ recovered: f.recovered(),
+ row: await f.row()
+ };
+ });
+ expect(r.prepared.status).toBe('existing');
+ expect(r.result.status).toBe('completed');
+ expect(r.recovered.rumor).toBe(true);
+ expect(r.after.encrypts).toBe(r.before.encrypts);
+ expect(r.after.signs).toBe(r.before.signs);
+ expect(events.map((e) => e.wire)).toEqual([
+ r.row.record.peerArtifact!.wire,
+ r.row.record.self.wire
+ ]);
+});
+test('actual reload retries only the remaining original artifact with no re-sign or rewrap', async ({
+ page
+}) => {
+ archiveResponse = 'unknown';
+ const original = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ const result = await f.run();
+ if (result.status !== 'needs_action')
+ throw Error('missing real archive uncertainty');
+ return (await f.row()).record;
+ });
+ await page.evaluate(() => window.hcp087Fixture.close());
+ await page.reload();
+ await load(page, false);
+ response = 'accepted';
+ archiveResponse = undefined;
+ events = [];
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture,
+ baseline = f.countsValue(),
+ prepared = await f.prepare();
+ f.capture();
+ const before = f.countsValue(),
+ result = await f.run();
+ return {
+ prepared,
+ result,
+ baseline,
+ before,
+ after: f.countsValue(),
+ row: (await f.row()).record
+ };
+ });
+ expect(r.result.status).toBe('completed');
+ // The existing fixture's genuine capability probe already exercised crypto.
+ // Recovery and publication must add no encryption/signing to that baseline.
+ expect(r.before.encrypts).toBe(r.baseline.encrypts);
+ expect(r.before.signs).toBe(r.baseline.signs);
+ expect(r.before.decrypts - r.baseline.decrypts).toBe(2);
+ expect(r.after.encrypts).toBe(r.baseline.encrypts);
+ expect(r.after.signs).toBe(r.baseline.signs);
+ expect(r.row.self).toEqual(original.self);
+ expect(r.row.peerArtifact).toEqual(original.peerArtifact);
+ expect(events.map((e) => e.wire)).toEqual([original.self.wire]);
+ expect(r.row.receipts).toHaveLength(5);
+});
+test('a second explicit action performs no duplicate accepted target work', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ const first = await f.run();
+ f.capture();
+ const second = await f.run();
+ return { first, second, row: (await f.row()).record };
+ });
+ expect(r.first.status).toBe('completed');
+ expect(r.second.status).toBe('completed');
+ expect(events).toHaveLength(2);
+ expect(r.row.receipts).toHaveLength(2);
+});
+test('three real unknown attempts share one action and never schedule a fourth', async ({
+ page
+}) => {
+ response = 'unknown';
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ return { result: await f.run(), row: (await f.row()).record };
+ });
+ expect(r.result.status).toBe('needs_action');
+ expect(events).toHaveLength(3);
+ expect(new Set(events.map((e) => e.wire)).size).toBe(1);
+ expect(r.row.receipts?.map((r) => r.attempt)).toEqual([1, 2, 3]);
+ expect(new Set(r.row.receipts?.map((r) => r.actionId)).size).toBe(1);
+});
+test('authoritative auth refusal pauses without spinning or touching archive', async ({
+ page
+}) => {
+ response = 'refused';
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ return { result: await f.run(), row: (await f.row()).record };
+ });
+ expect(r.result.status).toBe('needs_action');
+ expect(events).toHaveLength(1);
+ expect(r.row.receipts?.[0].status).toBe('refused');
+});
+test('wrong review and reused completed action cannot silently start another effect', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ const wrong = f.capture('unreviewed');
+ f.capture();
+ const refused = await f.run('unreviewed');
+ const first = await f.run();
+ const second = await f.run();
+ return { wrong, refused, first, second };
+ });
+ expect(r.wrong).toBe(false);
+ expect(r.refused.status).toBe('invalid');
+ expect(r.first.status).toBe('completed');
+ expect(r.second.status).toBe('invalid');
+ expect(events).toHaveLength(2);
+});
+test('changed stored revision prevents all retry effects', async ({ page }) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ await f.write('revision');
+ return f.run();
+ });
+ expect(r.status).toBe('needs_action');
+ expect(events).toEqual([]);
+});
+test('Stop before execution fences every effect and preserves ciphertext', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ const before = await f.row();
+ f.stop();
+ return { result: await f.run(), before, after: await f.row() };
+ });
+ expect(r.result.status).toBe('stopped');
+ expect(r.after.wire).toBe(r.before.wire);
+ expect(events).toEqual([]);
+});
+test('actual changed owner retires recovered private body before any EVENT', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ f.mode('changed_key');
+ return { result: await f.run(), recovered: f.recovered() };
+ });
+ expect(r.result.status).toBe('stopped');
+ expect(r.recovered.rumor).toBe(false);
+ expect(events).toEqual([]);
+});
+test('missing persisted ciphertext cannot become a successful retry', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ await f.write('erase');
+ return f.run();
+ });
+ expect(r.status).toBe('needs_action');
+ expect(events).toEqual([]);
+});
+test('the shared 45 second network budget ends a real silent attempt without another EVENT', async ({
+ page
+}) => {
+ response = 'silent';
+ await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ const native = performance.now.bind(performance);
+ let offset = 0;
+ Object.defineProperty(performance, 'now', {
+ configurable: true,
+ value: () => native() + offset
+ });
+ window.hcp087Advance = () => {
+ offset += 45001;
+ };
+ window.hcp087Pending = f.run();
+ });
+ await expect.poll(() => events.length).toBe(1);
+ await page.evaluate(() => window.hcp087Advance());
+ const r = await page.evaluate(() => window.hcp087Pending);
+ expect(r.status).toBe('needs_action');
+ expect(events).toHaveLength(1);
+});
+test('time spent awaiting the genuine provider observation is outside network budget', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ const native = performance.now.bind(performance);
+ let offset = 0;
+ Object.defineProperty(performance, 'now', {
+ configurable: true,
+ value: () => native() + offset
+ });
+ const provider = window.nostr as { getPublicKey(): Promise<string> };
+ const original = provider.getPublicKey.bind(provider);
+ let held = true;
+ provider.getPublicKey = async () => {
+ if (held) {
+ held = false;
+ window.hcp087Waiting = true;
+ await new Promise<void>((resolve) => {
+ window.hcp087Release = resolve;
+ });
+ }
+ return original();
+ };
+ window.hcp087Advance = () => {
+ offset += 60000;
+ };
+ window.hcp087Pending = f.run();
+ });
+ await expect.poll(() => page.evaluate(() => window.hcp087Waiting)).toBe(true);
+ expect(events).toEqual([]);
+ await page.evaluate(() => {
+ window.hcp087Advance();
+ window.hcp087Release();
+ });
+ const r = await page.evaluate(() => window.hcp087Pending);
+ expect(r.status).toBe('completed');
+ expect(events).toHaveLength(2);
+});
+test('a controlled genuine receipt successor accepted during key wait suppresses duplicate target publication', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ const provider = window.nostr as { getPublicKey(): Promise<string> },
+ original = provider.getPublicKey.bind(provider);
+ let calls = 0;
+ provider.getPublicKey = async () => {
+ calls++;
+ if (calls === 2) {
+ window.hcp087Waiting = true;
+ await new Promise<void>((resolve) => {
+ window.hcp087Release = resolve;
+ });
+ }
+ return original();
+ };
+ window.hcp087Pending = f.run();
+ });
+ await expect.poll(() => page.evaluate(() => window.hcp087Waiting)).toBe(true);
+ expect(events).toHaveLength(1);
+ const successor = await page.evaluate(() =>
+ window.hcp087Fixture.controlledArchiveSuccessor()
+ );
+ expect(successor.status).toBe('saved');
+ await page.evaluate(() => window.hcp087Release());
+ const result = await page.evaluate(() => window.hcp087Pending);
+ expect(result.status).toBe('completed');
+ expect(events).toHaveLength(1);
+});
+test('network time consumed by earlier real attempts reduces the remaining action allowance', async ({
+ page
+}) => {
+ response = 'silent';
+ await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ const native = performance.now.bind(performance);
+ let offset = 0;
+ Object.defineProperty(performance, 'now', {
+ configurable: true,
+ value: () => native() + offset
+ });
+ window.hcp087Advance = () => {
+ offset += 30000;
+ };
+ window.hcp087Pending = f.run();
+ });
+ await expect.poll(() => events.length).toBe(1);
+ await page.evaluate(() => window.hcp087Advance());
+ pendingAcks[0].socket.send(
+ JSON.stringify(['OK', pendingAcks[0].id, false, 'Timeout'])
+ );
+ await expect.poll(() => events.length).toBe(2);
+ await page.evaluate(() => window.hcp087Advance());
+ pendingAcks[1].socket.send(
+ JSON.stringify(['OK', pendingAcks[1].id, false, 'Timeout'])
+ );
+ const r = await page.evaluate(async () => ({
+ result: await window.hcp087Pending,
+ row: (await window.hcp087Fixture.row()).record
+ }));
+ expect(r.result.status).toBe('needs_action');
+ expect(events).toHaveLength(2);
+ expect(events[1].wire).toBe(events[0].wire);
+ expect(r.row.receipts?.map((f) => f.status)).toEqual([
+ 'unknown',
+ 'timed_out'
+ ]);
+});
+test('a codec-valid success row inserted between verification and load cannot claim genuine completion', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp087Fixture;
+ await f.prepare();
+ f.capture();
+ const mutation = await f.injectUnacknowledgedSuccessBetweenReads(),
+ proofBefore = f.proof(),
+ result = await f.run(),
+ injected = f.injected();
+ f.clearFault();
+ return {
+ mutation,
+ proofBefore,
+ proofAfter: f.proof(),
+ result,
+ injected,
+ row: await f.row()
+ };
+ });
+ expect(r.injected).toBe(1);
+ expect(r.row.wire).toBe(r.mutation.changedWire);
+ expect(r.proofAfter).toEqual(r.proofBefore);
+ expect(r.proofAfter?.revision).toBe(r.mutation.revision);
+ expect(r.result.status).toBe('needs_action');
+ expect(events).toEqual([]);
+});
diff --git a/web/tests/unit/retry-send.test.ts b/web/tests/unit/retry-send.test.ts
@@ -0,0 +1,144 @@
+import { describe, it, expect } from 'vitest';
+import {
+ generateSecretKey,
+ getPublicKey,
+ finalizeEvent
+} from 'applesauce-core/helpers';
+import { nip44 } from 'applesauce-core/helpers/encryption';
+import {
+ decodePrivateRecord,
+ type PrivateRecordHandle
+} from '../../src/lib/persistence/private-records.ts';
+import {
+ privateRetryTargets,
+ runPrivateRetry,
+ type PrivateRetry
+} from '../../src/lib/messaging/retry-send.ts';
+function fixture(status?: string, role = 'peer') {
+ const key = generateSecretKey(),
+ other = generateSecretKey();
+ try {
+ const owner = getPublicKey(key),
+ peer = getPublicKey(other),
+ id = '12345678-1234-4234-8234-123456789abc';
+ function artifact(destination: string) {
+ const conversation = nip44.v2.utils.getConversationKey(key, destination);
+ try {
+ const event = finalizeEvent(
+ {
+ kind: 1059,
+ created_at: 1700000000,
+ tags: [['p', destination]],
+ content: nip44.v2.encrypt('Structural fixture only', conversation)
+ },
+ key
+ );
+ return { eventId: event.id, wire: JSON.stringify(event) };
+ } finally {
+ conversation.fill(0);
+ }
+ }
+ function route(author: string, role: string, origin: string) {
+ return {
+ author,
+ role,
+ targets: [origin],
+ knownBase: { author, id: 'b'.repeat(64), createdAt: 1 },
+ sources: [{ source: 'wss://discovery.example.org', state: 'eose' }]
+ };
+ }
+ const self = artifact(owner),
+ peerArtifact = artifact(peer);
+ const row = {
+ schema: 1,
+ family: 'private_send_operation',
+ owner,
+ id,
+ revision: 2,
+ peer,
+ rumorHash: 'a'.repeat(64),
+ createdAt: 1700000000,
+ self,
+ peerArtifact,
+ deliveryPlan: {
+ state: 'prepared',
+ routes: {
+ peer: route(peer, 'peer', 'wss://peer.example.org'),
+ archive: route(owner, 'self_archive', 'wss://archive.example.org')
+ }
+ },
+ ...(status
+ ? {
+ receipts: [
+ {
+ actionId: '12345678-1234-4234-8234-123456789abd',
+ role,
+ origin:
+ role === 'peer'
+ ? 'wss://peer.example.org'
+ : 'wss://archive.example.org',
+ attempt: 1,
+ eventId: role === 'peer' ? peerArtifact.eventId : self.eventId,
+ status,
+ observedAtMilliseconds: 100,
+ readbackWire: status === 'readback' ? peerArtifact.wire : null
+ }
+ ]
+ }
+ : {})
+ };
+ const decoded = decodePrivateRecord(JSON.stringify(row), owner, id);
+ if (!decoded.ok) throw Error('invalid structural fixture');
+ return { owner, id, handle: decoded.value, row };
+ } finally {
+ key.fill(0);
+ other.fill(0);
+ }
+}
+describe('explicit exact-artifact retry target selection', () => {
+ it('retains the exact stored role event IDs and target order', () => {
+ const f = fixture();
+ expect(privateRetryTargets(f.handle, f.owner, f.id)).toEqual([
+ {
+ role: 'peer',
+ origin: 'wss://peer.example.org',
+ eventId: f.row.peerArtifact.eventId
+ },
+ {
+ role: 'self_archive',
+ origin: 'wss://archive.example.org',
+ eventId: f.row.self.eventId
+ }
+ ]);
+ });
+ it('skips only the exact accepted role and preserves the other artifact target', () => {
+ for (const role of ['peer', 'self_archive']) {
+ const f = fixture('accepted', role),
+ targets = privateRetryTargets(f.handle, f.owner, f.id)!;
+ expect(targets).toHaveLength(1);
+ expect(targets[0].role).toBe(role === 'peer' ? 'self_archive' : 'peer');
+ }
+ });
+ it('codec-only readback does not impersonate authenticated remote retrieval or ACK', () => {
+ const f = fixture('readback');
+ expect(privateRetryTargets(f.handle, f.owner, f.id)).toHaveLength(2);
+ });
+ it('unknown timeout refusal and stopped facts do not supply success', () => {
+ for (const status of ['unknown', 'timed_out', 'refused', 'stopped']) {
+ const f = fixture(status);
+ expect(privateRetryTargets(f.handle, f.owner, f.id)).toHaveLength(2);
+ }
+ });
+ it('forged handles and a foreign owner cannot select private targets', () => {
+ const f = fixture();
+ expect(
+ privateRetryTargets({} as PrivateRecordHandle, f.owner, f.id)
+ ).toBeUndefined();
+ expect(privateRetryTargets(f.handle, 'b'.repeat(64), f.id)).toBeUndefined();
+ });
+ it('an arbitrary object cannot start a retry or cause an implicit action', async () => {
+ expect(
+ await runPrivateRetry({} as PrivateRetry, 'reviewed_private_retry')
+ ).toEqual({ status: 'invalid' });
+ });
+});