commit c434293440106d19b73e8b8705f5a945602713b2
parent f67de70481779c3396f987637a334f146dc3de76
Author: triesap <tyson@radroots.org>
Date: Thu, 8 Oct 2026 23:34:18 +0000
messages: resume interrupted encrypted preparation explicitly (HCP-083)
- Authenticate stored self ciphertext through the guarded SDK scheduler.
- Restore original command and rumor without regeneration or silent recreation.
- Finish only missing peer preparation and retain already paired artifacts.
- Verify actual reload recovery with shared bounds and slow-host test allowances.
Diffstat:
13 files changed, 1815 insertions(+), 8 deletions(-)
diff --git a/web/playwright.config.ts b/web/playwright.config.ts
@@ -7,6 +7,7 @@ export default defineConfig({
workers: 1,
retries: 0,
timeout: 120_000,
+ expect: { timeout: 120_000 },
use: { browserName: 'chromium', headless: true, serviceWorkers: 'block' },
reporter: 'list'
});
diff --git a/web/src/lib/config/budgets.ts b/web/src/lib/config/budgets.ts
@@ -10,6 +10,8 @@ export const RELAY_BUDGETS = Object.freeze({
// Full history/live coordination has separate owners. These are logical
// post-SDK-parse limits, not browser WebSocket allocation guarantees.
export const PRIVATE_TRANSPORT_BUDGETS = Object.freeze({
+ rumorBytes: 8192,
+ sealBytes: 16384,
requestedPerRelay: 200,
deliveries: 500,
processedBytes: 8388608,
diff --git a/web/src/lib/messaging/envelope-preparation.ts b/web/src/lib/messaging/envelope-preparation.ts
@@ -24,7 +24,7 @@ declare const pairBrand: unique symbol;
export type EnvelopePreparation = Readonly<{ [pairBrand]: true }>;
type Role = 'self' | 'peer';
type Completed = Readonly<{
- operation: PrivateSealOperation;
+ operation?: PrivateSealOperation;
proof: VerifiedOutboundEnvelope;
}>;
export type EnvelopePreparationResult = Readonly<{
@@ -59,7 +59,8 @@ const pairs = new WeakMap<EnvelopePreparation, Controller>();
export function captureEnvelopePreparation(
session: IdentitySession,
reserved: ReservedSendIdentity,
- review: unknown
+ review: unknown,
+ recoveredSelf?: VerifiedOutboundEnvelope
): EnvelopePreparation | undefined {
if (review !== 'reviewed_envelope_pair') return undefined;
const inputRecord = reservedSendSnapshot(reserved),
@@ -82,6 +83,20 @@ export function captureEnvelopePreparation(
let self: Completed | undefined,
peer: Completed | undefined,
active: PrivateSealOperation | undefined;
+ if (recoveredSelf) {
+ const original = verifiedOutboundSnapshot(recoveredSelf);
+ if (
+ !original ||
+ original.role !== 'self' ||
+ original.destination !== record.owner ||
+ original.owner !== record.owner ||
+ original.peer !== record.peer ||
+ original.command !== record.id ||
+ original.rumorHash !== record.rumorHash
+ )
+ return undefined;
+ self = { proof: recoveredSelf };
+ }
let busy = false,
generation = 0,
unsubscribe = () => {};
@@ -98,8 +113,8 @@ export function captureEnvelopePreparation(
if (!retained) return;
retained = undefined;
stop(false);
- if (self) stopPrivateSeal(self.operation);
- if (peer) stopPrivateSeal(peer.operation);
+ if (self?.operation) stopPrivateSeal(self.operation);
+ if (peer?.operation) stopPrivateSeal(peer.operation);
self = undefined;
peer = undefined;
unsubscribe();
diff --git a/web/src/lib/messaging/prepare-send.ts b/web/src/lib/messaging/prepare-send.ts
@@ -7,6 +7,7 @@ import {
reservedSendSnapshot,
type ReservedSendIdentity
} from './send-identity.ts';
+import type { VerifiedOutboundEnvelope } from '../nostr/verify-outbound-envelope.ts';
import {
captureEnvelopePreparation,
prepareEnvelopeRole,
@@ -99,7 +100,8 @@ export function captureSelfRecoveryPreparation(
repository: PrivateStorageRepository,
session: IdentitySession,
reserved: ReservedSendIdentity,
- review: unknown
+ review: unknown,
+ recoveredSelf?: VerifiedOutboundEnvelope
): SelfRecoveryPreparation | undefined {
if (typeof window === 'undefined' || review !== 'reviewed_self_recovery')
return undefined;
@@ -114,7 +116,8 @@ export function captureSelfRecoveryPreparation(
const pairInput = captureEnvelopePreparation(
session,
reserved,
- 'reviewed_envelope_pair'
+ 'reviewed_envelope_pair',
+ recoveredSelf
);
if (!pairInput) return undefined;
const record = recordInput,
diff --git a/web/src/lib/messaging/resume-preparation.ts b/web/src/lib/messaging/resume-preparation.ts
@@ -0,0 +1,297 @@
+import { canonicalLocalId } from '../private-handles.ts';
+import {
+ identityMessagingOwnership,
+ subscribeIdentityInvalidation,
+ type IdentitySession
+} from '../runtime/identity-session.ts';
+import {
+ loadPrivateRecord,
+ type PrivateStorageRepository
+} from '../persistence/private-storage.ts';
+import { privateRecordWire } from '../persistence/private-records.ts';
+import {
+ captureSelfRecoveryReader,
+ readSelfRecoveryEnvelope,
+ recoveredSelfEnvelopeSnapshot,
+ stopSelfRecoveryReader,
+ expireSelfRecoveryReaderWait,
+ type SelfRecoveryReader,
+ type SelfRecoveryReadResult
+} from '../nostr/self-recovery-reader.ts';
+import {
+ restoreRecoveredRumor,
+ rumorPlanSnapshot,
+ stopRumorPlan,
+ type RumorPlan
+} from './rumor-plan.ts';
+import { restoreRecoveredSendIdentity } from './send-identity.ts';
+import { verifyRecoveredSelfEnvelope } from '../nostr/verify-outbound-envelope.ts';
+import {
+ captureSelfRecoveryPreparation,
+ prepareSelfRecovery,
+ preparePairedDelivery,
+ stopSelfRecoveryPreparation,
+ type SelfRecoveryPreparation,
+ type PairedDeliveryContext,
+ type PairedDeliveryPreparationResult
+} from './prepare-send.ts';
+declare const resumeBrand: unique symbol;
+export type ResumePreparation = Readonly<{ [resumeBrand]: true }>;
+export type ResumePreparationResult = Readonly<{
+ status:
+ | SelfRecoveryReadResult['status']
+ | PairedDeliveryPreparationResult['status']
+ | 'already_prepared';
+}>;
+type Snapshot = Readonly<{
+ owner: string;
+ command: string;
+ state:
+ | 'unsaved'
+ | 'recovering'
+ | 'recovered'
+ | 'prepared'
+ | 'lost'
+ | 'needs_action';
+ busy: boolean;
+ copy: string;
+ peer?: string;
+ rumorHash?: string;
+ createdAt?: number;
+}>;
+type Controller = {
+ run(
+ context: PairedDeliveryContext | undefined,
+ review: unknown
+ ): Promise<ResumePreparationResult>;
+ snapshot(): Snapshot | undefined;
+ rumor(): RumorPlan | undefined;
+ stop(expired: boolean): void;
+};
+const resumes = new WeakMap<ResumePreparation, Controller>();
+// Explicit memory-only recovery workflow. Capture/render performs no IO or
+// extension job; actual Resume cannot recreate lost ciphertext or send a relay
+// event. Original authenticated command/hash/time survive memory cache loss.
+export function captureResumePreparation(
+ repository: PrivateStorageRepository,
+ session: IdentitySession,
+ localId: unknown,
+ review: unknown
+): ResumePreparation | undefined {
+ if (typeof window === 'undefined' || review !== 'reviewed_private_resume')
+ return undefined;
+ const inputId = canonicalLocalId(localId),
+ inputOwnership = identityMessagingOwnership(session);
+ if (!inputId || !inputOwnership?.current()) return undefined;
+ const id = inputId,
+ ownership = inputOwnership;
+ let active = true,
+ busy = false,
+ generation = 0,
+ state: Snapshot['state'] = 'unsaved',
+ reader: SelfRecoveryReader | undefined,
+ plan: RumorPlan | undefined,
+ preparation: SelfRecoveryPreparation | undefined,
+ alreadyPaired = false,
+ peerOnly = false,
+ originalWire: string | undefined,
+ unsubscribe = () => {};
+ function stop(expired: boolean) {
+ if (!active) return;
+ active = false;
+ generation++;
+ if (reader) {
+ if (expired) expireSelfRecoveryReaderWait(reader);
+ else stopSelfRecoveryReader(reader);
+ }
+ if (preparation) stopSelfRecoveryPreparation(preparation);
+ if (plan) stopRumorPlan(plan);
+ reader = undefined;
+ preparation = undefined;
+ plan = undefined;
+ originalWire = undefined;
+ unsubscribe();
+ unsubscribe = () => {};
+ }
+ function current() {
+ if (!active || !ownership.current() || (plan && !rumorPlanSnapshot(plan))) {
+ stop(false);
+ return false;
+ }
+ return true;
+ }
+ function snapshot(): Snapshot | undefined {
+ if (!current()) return undefined;
+ const rumor = plan && rumorPlanSnapshot(plan);
+ return {
+ owner: ownership.owner,
+ command: id,
+ state,
+ busy,
+ copy:
+ state === 'lost'
+ ? 'Encrypted recovery evidence was lost. This message cannot be silently recreated.'
+ : state === 'needs_action'
+ ? 'Encrypted recovery needs your review; no message was sent.'
+ : rumor
+ ? 'Original encrypted message recovered in this browser; no delivery is claimed.'
+ : 'Resume is required to decrypt stored recovery evidence.',
+ ...(rumor
+ ? { peer: rumor.peer, rumorHash: rumor.id, createdAt: rumor.createdAt }
+ : {})
+ };
+ }
+ async function run(
+ context: PairedDeliveryContext | undefined,
+ reviewed: unknown
+ ): Promise<ResumePreparationResult> {
+ if (reviewed !== 'reviewed_private_resume') return { status: 'invalid' };
+ if (!current()) return { status: 'stopped' };
+ if (busy) return { status: 'busy' };
+ busy = true;
+ const attempt = generation,
+ admitted = () => current() && generation === attempt;
+ try {
+ if (!plan) {
+ state = 'recovering';
+ reader = captureSelfRecoveryReader(
+ repository,
+ session,
+ id,
+ 'reviewed_self_decryption'
+ );
+ if (!reader) {
+ state = 'needs_action';
+ return { status: 'stopped' };
+ }
+ const recovered = await readSelfRecoveryEnvelope(reader);
+ if (!admitted()) return { status: 'stopped' };
+ if (recovered.status !== 'recovered') {
+ state =
+ recovered.status === 'lost_evidence' ? 'lost' : 'needs_action';
+ stopSelfRecoveryReader(reader);
+ reader = undefined;
+ return { status: recovered.status };
+ }
+ const source = recoveredSelfEnvelopeSnapshot(recovered.envelope);
+ plan = restoreRecoveredRumor(session, recovered.envelope);
+ const reserved =
+ plan &&
+ restoreRecoveredSendIdentity(session, recovered.envelope, plan),
+ proof =
+ reserved &&
+ verifyRecoveredSelfEnvelope(
+ reserved,
+ recovered.envelope,
+ 'reviewed_recovered_self'
+ );
+ if (!source || !plan || !reserved || !proof || !admitted()) {
+ stop(false);
+ return { status: 'stopped' };
+ }
+ originalWire = source.storedWire;
+ alreadyPaired =
+ !!source.record.peerArtifact && !!source.record.deliveryPlan;
+ peerOnly = !!source.record.peerArtifact && !source.record.deliveryPlan;
+ preparation = captureSelfRecoveryPreparation(
+ repository,
+ session,
+ reserved,
+ 'reviewed_self_recovery',
+ proof
+ );
+ if (!preparation || !admitted()) {
+ stop(false);
+ return { status: 'stopped' };
+ }
+ }
+ if (!preparation || !admitted()) return { status: 'stopped' };
+ if (alreadyPaired || peerOnly) {
+ const stored = await loadPrivateRecord(repository, 'private_sends', id);
+ if (!admitted()) return { status: 'stopped' };
+ if (
+ !stored.ok ||
+ privateRecordWire(stored.value, ownership.owner, id) !== originalWire
+ ) {
+ state = stored.ok
+ ? 'needs_action'
+ : stored.reason === 'invalid_record'
+ ? 'lost'
+ : 'needs_action';
+ if (plan) stopRumorPlan(plan);
+ plan = undefined;
+ stopSelfRecoveryPreparation(preparation);
+ preparation = undefined;
+ if (reader) stopSelfRecoveryReader(reader);
+ reader = undefined;
+ return {
+ status: stored.ok
+ ? 'conflict'
+ : stored.reason === 'invalid_record'
+ ? 'lost_evidence'
+ : stored.reason
+ };
+ }
+ state = 'recovered';
+ return {
+ status: alreadyPaired ? 'already_prepared' : 'review_required'
+ };
+ }
+ const saved = await prepareSelfRecovery(
+ preparation,
+ 'reviewed_self_recovery'
+ );
+ if (!admitted()) return { status: 'stopped' };
+ if (!['saved', 'existing', 'reconciled'].includes(saved.status)) {
+ state = 'needs_action';
+ return { status: saved.status };
+ }
+ state = 'recovered';
+ if (!context) return { status: 'recovered' };
+ const paired = await preparePairedDelivery(
+ preparation,
+ context,
+ 'reviewed_pair_preparation'
+ );
+ if (!admitted()) return { status: 'stopped' };
+ state = paired.status === 'prepared' ? 'prepared' : 'needs_action';
+ return { status: paired.status };
+ } catch {
+ state = 'needs_action';
+ return { status: admitted() ? 'unavailable' : 'stopped' };
+ } finally {
+ busy = false;
+ }
+ }
+ const token = Object.freeze({}) as ResumePreparation;
+ resumes.set(token, {
+ run,
+ snapshot,
+ rumor: () => (current() ? plan : undefined),
+ stop
+ });
+ unsubscribe = subscribeIdentityInvalidation(session, () => stop(false));
+ return current() ? token : undefined;
+}
+export function resumeEncryptedPreparation(
+ token: ResumePreparation,
+ context: PairedDeliveryContext | undefined,
+ review: unknown
+): Promise<ResumePreparationResult> {
+ return (
+ resumes.get(token)?.run(context, review) ??
+ Promise.resolve({ status: 'invalid' })
+ );
+}
+export function resumePreparationSnapshot(token: ResumePreparation) {
+ return resumes.get(token)?.snapshot();
+}
+export function resumeRecoveredRumor(token: ResumePreparation) {
+ return resumes.get(token)?.rumor();
+}
+export function stopResumePreparation(token: ResumePreparation): void {
+ resumes.get(token)?.stop(false);
+}
+export function expireResumePreparationWait(token: ResumePreparation): void {
+ resumes.get(token)?.stop(true);
+}
diff --git a/web/src/lib/messaging/rumor-plan.ts b/web/src/lib/messaging/rumor-plan.ts
@@ -6,6 +6,10 @@ import {
type IdentitySession
} from '../runtime/identity-session.ts';
import { buildEnquiryMessage, type EnquiryContext } from './enquiry-context.ts';
+import {
+ recoveredSelfEnvelopeSnapshot,
+ type RecoveredSelfEnvelope
+} from '../nostr/self-recovery-reader.ts';
declare const rumorBrand: unique symbol;
export type RumorPlan = Readonly<{ readonly [rumorBrand]: true }>;
export type RumorPlanSnapshot = Readonly<{
@@ -96,6 +100,37 @@ export function captureReplyRumor(
observedTime
);
}
+// Historical time/hash/wire are admitted only by actual authenticated SDK
+// recovery. This creates no new intent, reservation, event or persistent body.
+export function restoreRecoveredRumor(
+ session: IdentitySession,
+ recovered: RecoveredSelfEnvelope
+): RumorPlan | undefined {
+ const ownership = identityMessagingOwnership(session),
+ snapshot = recoveredSelfEnvelopeSnapshot(recovered);
+ if (
+ !ownership?.current() ||
+ !snapshot ||
+ snapshot.record.owner !== ownership.owner
+ )
+ return undefined;
+ const token = Object.freeze({}) as RumorPlan;
+ const current = () =>
+ ownership.current() && !!recoveredSelfEnvelopeSnapshot(recovered);
+ const unsubscribe = subscribeIdentityInvalidation(session, () =>
+ stopRumorPlan(token)
+ );
+ plans.set(token, {
+ owner: snapshot.record.owner,
+ peer: snapshot.record.peer,
+ id: snapshot.record.rumorHash,
+ createdAt: snapshot.record.createdAt,
+ wire: snapshot.rumorWire,
+ current,
+ unsubscribe
+ });
+ return current() ? token : undefined;
+}
export function rumorPlanSnapshot(
plan: RumorPlan
): RumorPlanSnapshot | undefined {
diff --git a/web/src/lib/messaging/send-identity.ts b/web/src/lib/messaging/send-identity.ts
@@ -6,6 +6,10 @@ import {
} from '../runtime/identity-session.ts';
import { rumorPlanSnapshot, type RumorPlan } from './rumor-plan.ts';
import {
+ recoveredSelfEnvelopeSnapshot,
+ type RecoveredSelfEnvelope
+} from '../nostr/self-recovery-reader.ts';
+import {
privateSendReservationOwner,
reservePrivateSendReservation,
type PrivateSendReservationRepository,
@@ -102,6 +106,56 @@ export function reservedSendSnapshot(
const value = identities.get(identity);
return value?.current() ? { ...value.record } : undefined;
}
+// Restore the original actual command from authenticated stored self evidence;
+// never re-reserve it using the current clock or a detached caller hash.
+export function restoreRecoveredSendIdentity(
+ session: IdentitySession,
+ recovered: RecoveredSelfEnvelope,
+ plan: RumorPlan
+): ReservedSendIdentity | undefined {
+ const snapshot = recoveredSelfEnvelopeSnapshot(recovered),
+ ownership = identityMessagingOwnership(session),
+ rumor = rumorPlanSnapshot(plan);
+ if (
+ !snapshot ||
+ !ownership?.current() ||
+ !rumor ||
+ ownership.owner !== snapshot.record.owner ||
+ rumor.owner !== snapshot.record.owner ||
+ rumor.peer !== snapshot.record.peer ||
+ rumor.id !== snapshot.record.rumorHash ||
+ rumor.createdAt !== snapshot.record.createdAt ||
+ rumor.wire !== snapshot.rumorWire
+ )
+ return undefined;
+ const record: PrivateSendReservation = {
+ schema: 1,
+ family: 'private_send_reservation',
+ owner: snapshot.record.owner,
+ id: snapshot.record.id,
+ revision: 0,
+ peer: snapshot.record.peer,
+ rumorHash: snapshot.record.rumorHash,
+ createdAt: snapshot.record.createdAt
+ };
+ const current = () => {
+ const observed = rumorPlanSnapshot(plan),
+ source = recoveredSelfEnvelopeSnapshot(recovered);
+ return (
+ ownership.current() &&
+ !!source &&
+ observed?.wire === source.rumorWire &&
+ source.record.id === record.id &&
+ source.record.owner === record.owner &&
+ source.record.peer === record.peer &&
+ source.record.rumorHash === record.rumorHash &&
+ source.record.createdAt === record.createdAt
+ );
+ };
+ const identity = Object.freeze({}) as ReservedSendIdentity;
+ identities.set(identity, { record, plan, current });
+ return current() ? identity : undefined;
+}
// Internal memory-only input to future encryption. A detached wire/snapshot is
// neither reserved identity nor effect permission and cannot retarget a send.
export function reservedSendRumorWire(
diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts
@@ -0,0 +1,345 @@
+import { ExtensionSigner } from 'applesauce-signers';
+import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
+import { canonicalLocalId } from '../private-handles.ts';
+import { exactLocalFields } from '../contracts/local-records.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+import {
+ identityMessagingOwnership,
+ subscribeIdentityInvalidation,
+ disconnectIdentity,
+ type IdentitySession
+} from '../runtime/identity-session.ts';
+import {
+ loadPrivateRecord,
+ type PrivateStorageRepository,
+ type PrivateStorageFailure
+} from '../persistence/private-storage.ts';
+import {
+ privateRecordSnapshot,
+ privateRecordWire,
+ type PrivateSendOperation
+} from '../persistence/private-records.ts';
+import {
+ verifyEnvelope,
+ verifiedEnvelopeSnapshot
+} from './verified-envelope.ts';
+import { verifyOutboundLayerData } from './outbound-envelope-layers.ts';
+import { sealCiphertextV2 } from './seal-template.ts';
+import {
+ browserExtensionScheduler,
+ runExtensionAction,
+ callExtension,
+ stopExtensionAction,
+ markExtensionWaitExpired,
+ type ExtensionAction
+} from './extension-scheduler.ts';
+declare const readerBrand: unique symbol;
+declare const recoveredBrand: unique symbol;
+export type SelfRecoveryReader = Readonly<{ [readerBrand]: true }>;
+export type RecoveredSelfEnvelope = Readonly<{ [recoveredBrand]: true }>;
+type Snapshot = Readonly<{
+ record: PrivateSendOperation;
+ storedWire: string;
+ rumorWire: string;
+ sealWire: string;
+}>;
+export type SelfRecoveryReadResult =
+ | Readonly<{ status: 'recovered'; envelope: RecoveredSelfEnvelope }>
+ | Readonly<{
+ status:
+ | PrivateStorageFailure
+ | 'invalid'
+ | 'stopped'
+ | 'busy'
+ | 'refused'
+ | 'mismatch'
+ | 'lost_evidence';
+ }>;
+type Reader = {
+ run(): Promise<SelfRecoveryReadResult>;
+ stop(expired: boolean): void;
+};
+const readers = new WeakMap<SelfRecoveryReader, Reader>(),
+ recovered = new WeakMap<
+ RecoveredSelfEnvelope,
+ { snapshot: Snapshot; current(): boolean }
+ >();
+// Actual owner-scoped storage and guarded SDK decryption are the only issuer.
+// Detached JSON, metadata, SDK cache symbols and snapshots cannot mint this
+// memory-only authenticated recovery proof or authorize a private relay effect.
+export function captureSelfRecoveryReader(
+ repository: PrivateStorageRepository,
+ session: IdentitySession,
+ localId: unknown,
+ review: unknown
+): SelfRecoveryReader | undefined {
+ if (typeof window === 'undefined' || review !== 'reviewed_self_decryption')
+ return undefined;
+ const inputId = canonicalLocalId(localId),
+ inputOwnership = identityMessagingOwnership(session);
+ if (!inputId || !inputOwnership?.current()) return undefined;
+ const id = inputId,
+ ownership = inputOwnership;
+ let stopped = false,
+ started = false,
+ active: ExtensionAction | undefined,
+ proof: RecoveredSelfEnvelope | undefined,
+ unsubscribe = () => {};
+ const current = () => !stopped && ownership.current();
+ function stop(expired: boolean) {
+ stopped = true;
+ if (active) {
+ if (expired) markExtensionWaitExpired(active);
+ else stopExtensionAction(active);
+ }
+ if (proof) recovered.delete(proof);
+ proof = undefined;
+ unsubscribe();
+ unsubscribe = () => {};
+ }
+ function port() {
+ try {
+ if (!current()) return undefined;
+ const cipher = new ExtensionSigner().nip44;
+ if (!current() || !cipher) return undefined;
+ const method = cipher.decrypt;
+ if (!current() || typeof method !== 'function') return undefined;
+ const decrypt = method.bind(cipher);
+ return current() ? { decrypt } : undefined;
+ } catch {
+ return undefined;
+ }
+ }
+ async function fresh(action: ExtensionAction) {
+ if (!current()) return false;
+ const result = await callExtension(action, 'key', () =>
+ new ExtensionSigner().getPublicKey()
+ );
+ if (!current()) return false;
+ if (
+ result.status !== 'settled' ||
+ !result.current ||
+ result.value !== ownership.owner ||
+ !port()
+ ) {
+ disconnectIdentity(session);
+ return false;
+ }
+ return current();
+ }
+ async function run(): Promise<SelfRecoveryReadResult> {
+ if (started || !current()) return { status: 'stopped' };
+ started = true;
+ if (!navigator.locks?.request) return { status: 'unavailable' };
+ try {
+ return await navigator.locks.request(
+ 'harvestcircle:owner:' + ownership.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock): Promise<SelfRecoveryReadResult> => {
+ if (!lock) return { status: 'busy' };
+ if (!current()) return { status: 'stopped' };
+ // Complete the readonly transaction before any extension await.
+ const loaded = await loadPrivateRecord(
+ repository,
+ 'private_sends',
+ id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!loaded.ok)
+ return {
+ status:
+ loaded.reason === 'invalid_record'
+ ? 'lost_evidence'
+ : loaded.reason
+ };
+ const record = privateRecordSnapshot(
+ loaded.value,
+ ownership.owner,
+ id
+ ),
+ storedWire = privateRecordWire(loaded.value, ownership.owner, id);
+ if (!record || !storedWire || record.family === 'received_envelope')
+ return { status: 'invalid_scope' };
+ if (record.family !== 'private_send_operation')
+ return { status: 'lost_evidence' };
+ const verified = verifyEnvelope(record.self.wire),
+ outer = verified.ok && verifiedEnvelopeSnapshot(verified.value);
+ if (
+ !outer ||
+ outer.id !== record.self.eventId ||
+ outer.kind !== 1059 ||
+ JSON.stringify(outer.tags) !==
+ JSON.stringify([['p', record.owner]]) ||
+ !exactLocalFields(outer, [
+ 'id',
+ 'pubkey',
+ 'created_at',
+ 'kind',
+ 'tags',
+ 'content',
+ 'sig'
+ ]) ||
+ !sealCiphertextV2(outer.content)
+ )
+ return { status: 'mismatch' };
+ const scheduler = browserExtensionScheduler();
+ if (!scheduler) return { status: 'unavailable' };
+ const result = await runExtensionAction(
+ scheduler,
+ {
+ owner: ownership.owner,
+ session: ownership.session,
+ operation: Symbol()
+ },
+ current,
+ async (action): Promise<SelfRecoveryReadResult> => {
+ active = action;
+ if (!(await fresh(action))) return { status: 'stopped' };
+ const outerPort = port();
+ if (!outerPort || !current()) return { status: 'stopped' };
+ const opened = await callExtension(action, 'decrypt', () =>
+ outerPort.decrypt(outer.pubkey, outer.content)
+ );
+ if (!current()) return { status: 'stopped' };
+ if (opened.status !== 'settled' || !opened.current)
+ return {
+ status: opened.status === 'denied' ? 'refused' : 'stopped'
+ };
+ if (
+ typeof opened.value !== 'string' ||
+ !boundedUtf8(opened.value, PRIVATE_TRANSPORT_BUDGETS.sealBytes)
+ )
+ return { status: 'mismatch' };
+ const sealWire = opened.value,
+ verifiedSeal = verifyEnvelope(sealWire),
+ seal =
+ verifiedSeal.ok &&
+ verifiedEnvelopeSnapshot(verifiedSeal.value);
+ if (
+ !seal ||
+ seal.pubkey !== record.owner ||
+ seal.kind !== 13 ||
+ seal.tags.length !== 0 ||
+ !exactLocalFields(seal, [
+ 'id',
+ 'pubkey',
+ 'created_at',
+ 'kind',
+ 'tags',
+ 'content',
+ 'sig'
+ ]) ||
+ JSON.stringify(JSON.parse(sealWire)) !== sealWire ||
+ !sealCiphertextV2(seal.content)
+ )
+ return { status: 'mismatch' };
+ if (!(await fresh(action))) return { status: 'stopped' };
+ const innerPort = port();
+ if (!innerPort || !current()) return { status: 'stopped' };
+ const decrypted = await callExtension(action, 'decrypt', () =>
+ innerPort.decrypt(seal.pubkey, seal.content)
+ );
+ if (!current()) return { status: 'stopped' };
+ if (decrypted.status !== 'settled' || !decrypted.current)
+ return {
+ status: decrypted.status === 'denied' ? 'refused' : 'stopped'
+ };
+ if (
+ typeof decrypted.value !== 'string' ||
+ !boundedUtf8(
+ decrypted.value,
+ PRIVATE_TRANSPORT_BUDGETS.rumorBytes
+ )
+ )
+ return { status: 'mismatch' };
+ const rumorWire = decrypted.value;
+ if (
+ !verifyOutboundLayerData(
+ rumorWire,
+ rumorWire,
+ sealWire,
+ record.self.wire,
+ record.owner,
+ record.peer,
+ 'self'
+ )
+ )
+ return { status: 'mismatch' };
+ const rumor = JSON.parse(rumorWire) as {
+ id: string;
+ created_at: number;
+ };
+ if (
+ JSON.stringify(JSON.parse(rumorWire)) !== rumorWire ||
+ rumor.id !== record.rumorHash ||
+ rumor.created_at !== record.createdAt
+ )
+ return { status: 'mismatch' };
+ if (!(await fresh(action))) return { status: 'stopped' };
+ const readback = await loadPrivateRecord(
+ repository,
+ 'private_sends',
+ id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!readback.ok)
+ return {
+ status:
+ readback.reason === 'invalid_record'
+ ? 'lost_evidence'
+ : readback.reason
+ };
+ if (
+ privateRecordWire(readback.value, record.owner, id) !==
+ storedWire
+ )
+ return { status: 'conflict' };
+ if (!(await fresh(action))) return { status: 'stopped' };
+ const token = Object.freeze({}) as RecoveredSelfEnvelope;
+ recovered.set(token, {
+ snapshot: { record, storedWire, rumorWire, sealWire },
+ current
+ });
+ proof = token;
+ return { status: 'recovered', envelope: token };
+ }
+ );
+ if (!current()) return { status: 'stopped' };
+ if (result.status === 'busy') return { status: 'busy' };
+ return result.status === 'completed' &&
+ 'value' in result &&
+ result.value
+ ? result.value
+ : { status: result.status === 'denied' ? 'refused' : 'stopped' };
+ }
+ );
+ } catch {
+ return { status: current() ? 'refused' : 'stopped' };
+ } finally {
+ active = undefined;
+ }
+ }
+ const token = Object.freeze({}) as SelfRecoveryReader;
+ readers.set(token, { run, stop });
+ unsubscribe = subscribeIdentityInvalidation(session, () => stop(false));
+ return current() ? token : undefined;
+}
+export function readSelfRecoveryEnvelope(
+ reader: SelfRecoveryReader
+): Promise<SelfRecoveryReadResult> {
+ return readers.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' });
+}
+export function stopSelfRecoveryReader(reader: SelfRecoveryReader): void {
+ readers.get(reader)?.stop(false);
+}
+export function expireSelfRecoveryReaderWait(reader: SelfRecoveryReader): void {
+ readers.get(reader)?.stop(true);
+}
+export function recoveredSelfEnvelopeSnapshot(
+ token: RecoveredSelfEnvelope
+): Snapshot | undefined {
+ const saved = recovered.get(token);
+ return saved?.current()
+ ? (JSON.parse(JSON.stringify(saved.snapshot)) as Snapshot)
+ : undefined;
+}
diff --git a/web/src/lib/nostr/verify-outbound-envelope.ts b/web/src/lib/nostr/verify-outbound-envelope.ts
@@ -10,6 +10,10 @@ import {
} from './giftwrap-builder.ts';
import { privateSealSnapshot, privateSealReservation } from './seal-builder.ts';
import { verifyOutboundLayerData } from './outbound-envelope-layers.ts';
+import {
+ recoveredSelfEnvelopeSnapshot,
+ type RecoveredSelfEnvelope
+} from './self-recovery-reader.ts';
declare const outboundBrand: unique symbol;
export type VerifiedOutboundEnvelope = Readonly<{ [outboundBrand]: true }>;
type Saved = Readonly<{
@@ -17,6 +21,10 @@ type Saved = Readonly<{
wrap: PrivateGiftwrap;
}>;
const proofs = new WeakMap<VerifiedOutboundEnvelope, Saved>();
+const recoveredProofs = new WeakMap<
+ VerifiedOutboundEnvelope,
+ { reserved: ReservedSendIdentity; source: RecoveredSelfEnvelope }
+>();
function inspect(reserved: ReservedSendIdentity, wrap: PrivateGiftwrap) {
const record = reservedSendSnapshot(reserved),
rumor = reservedSendRumorWire(reserved),
@@ -72,5 +80,67 @@ export function verifyOutboundEnvelope(
}
export function verifiedOutboundSnapshot(token: VerifiedOutboundEnvelope) {
const saved = proofs.get(token);
- return saved ? inspect(saved.reserved, saved.wrap) : undefined;
+ if (saved) return inspect(saved.reserved, saved.wrap);
+ const recovery = recoveredProofs.get(token);
+ return recovery && inspectRecovered(recovery.reserved, recovery.source);
+}
+function inspectRecovered(
+ reserved: ReservedSendIdentity,
+ source: RecoveredSelfEnvelope
+) {
+ const original = recoveredSelfEnvelopeSnapshot(source),
+ record = reservedSendSnapshot(reserved),
+ wire = reservedSendRumorWire(reserved);
+ if (
+ !original ||
+ !record ||
+ wire !== original.rumorWire ||
+ record.owner !== original.record.owner ||
+ record.id !== original.record.id ||
+ record.peer !== original.record.peer ||
+ record.rumorHash !== original.record.rumorHash ||
+ record.createdAt !== original.record.createdAt ||
+ !verifyOutboundLayerData(
+ wire,
+ wire,
+ original.sealWire,
+ original.record.self.wire,
+ record.owner,
+ record.peer,
+ 'self'
+ )
+ )
+ return undefined;
+ return {
+ owner: record.owner,
+ peer: record.peer,
+ destination: record.owner,
+ role: 'self' as const,
+ command: record.id,
+ rumorHash: record.rumorHash,
+ wire: original.record.self.wire
+ };
+}
+export function verifyRecoveredSelfEnvelope(
+ reserved: ReservedSendIdentity,
+ source: RecoveredSelfEnvelope,
+ review: unknown
+): VerifiedOutboundEnvelope | undefined {
+ if (
+ review !== 'reviewed_recovered_self' ||
+ !inspectRecovered(reserved, source)
+ )
+ return undefined;
+ const token = Object.freeze({}) as VerifiedOutboundEnvelope;
+ recoveredProofs.set(token, { reserved, source });
+ return token;
+}
+// Extra full-wire custody fence for actual recovery, absent for new factories.
+export function verifiedOutboundRecoverySource(
+ token: VerifiedOutboundEnvelope
+): string | undefined {
+ const recovery = recoveredProofs.get(token);
+ return recovery && inspectRecovered(recovery.reserved, recovery.source)
+ ? recoveredSelfEnvelopeSnapshot(recovery.source)?.storedWire
+ : undefined;
}
diff --git a/web/src/lib/persistence/private-sends.ts b/web/src/lib/persistence/private-sends.ts
@@ -8,6 +8,7 @@ import {
} from '../messaging/send-identity.ts';
import {
verifiedOutboundSnapshot,
+ verifiedOutboundRecoverySource,
type VerifiedOutboundEnvelope
} from '../nostr/verify-outbound-envelope.ts';
import {
@@ -129,7 +130,8 @@ function input(
record,
current,
ownerCurrent: () => ownership.current(),
- self: { eventId: event.id, wire: observed.wire }
+ self: { eventId: event.id, wire: observed.wire },
+ recoveryWire: verifiedOutboundRecoverySource(proof)
}
: undefined;
}
@@ -159,6 +161,15 @@ export async function commitSelfRecovery(
);
if (!base || base.family === 'received_envelope')
return { status: 'invalid_record' };
+ if (
+ captured.recoveryWire !== undefined &&
+ privateRecordWire(
+ loaded.value,
+ captured.record.owner,
+ captured.record.id
+ ) !== captured.recoveryWire
+ )
+ return { status: 'conflict' };
let expected: PrivateRecordHandle,
status: 'saved' | 'existing' | 'reconciled';
if (base.family === 'private_send_operation') {
diff --git a/web/tests/e2e/harness/resume-preparation.ts b/web/tests/e2e/harness/resume-preparation.ts
@@ -0,0 +1,404 @@
+import {
+ finalizeEvent,
+ getPublicKey,
+ type UnsignedEvent
+} from 'applesauce-core/helpers';
+import { nip44 } from 'applesauce-core/helpers/encryption';
+import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts';
+import {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ disconnectIdentity
+} from '../../../src/lib/runtime/identity-session.ts';
+import {
+ openBrowserDatabase,
+ closeBrowserDatabase,
+ browserDatabaseTransaction
+} from '../../../src/lib/persistence/database.ts';
+import {
+ createPrivateStorageRepository,
+ loadPrivateRecord
+} from '../../../src/lib/persistence/private-storage.ts';
+import {
+ privateRecordSnapshot,
+ privateRecordWire,
+ decodePrivateRecord
+} from '../../../src/lib/persistence/private-records.ts';
+import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts';
+import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts';
+import {
+ captureEnquiryRumor,
+ stopRumorPlan,
+ rumorPlanSnapshot
+} from '../../../src/lib/messaging/rumor-plan.ts';
+import {
+ reserveSendIdentity,
+ reservedSendSnapshot
+} from '../../../src/lib/messaging/send-identity.ts';
+import {
+ captureSelfRecoveryPreparation,
+ prepareSelfRecovery,
+ stopSelfRecoveryPreparation
+} from '../../../src/lib/messaging/prepare-send.ts';
+import {
+ browserExtensionScheduler,
+ extensionSchedulerSnapshot
+} from '../../../src/lib/nostr/extension-scheduler.ts';
+import { validateRelayPolicy } from '../../../src/lib/config/relays.ts';
+import {
+ createPublicScheduler,
+ createPublicRun,
+ openInboxRequest,
+ closePublicScheduler
+} from '../../../src/lib/nostr/request-scope.ts';
+import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
+import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts';
+import {
+ captureResumePreparation,
+ resumeEncryptedPreparation,
+ resumePreparationSnapshot,
+ resumeRecoveredRumor,
+ stopResumePreparation
+} from '../../../src/lib/messaging/resume-preparation.ts';
+export {
+ captureResumePreparation,
+ resumeEncryptedPreparation,
+ resumePreparationSnapshot,
+ resumeRecoveredRumor,
+ stopResumePreparation,
+ rumorPlanSnapshot
+};
+// Public disposable fixture keys, never installed operator credentials. Stable
+// only so an actual page reload can unlock the same actual stored ciphertext.
+const command = '12345678-1234-4234-8234-123456789abc',
+ marker = 'HCP083_PRIVATE_RECOVERY_MEMORY_ONLY_SENTINEL';
+type Mode =
+ | 'normal'
+ | 'changed_key'
+ | 'hold_decrypt'
+ | 'declined_decrypt'
+ | 'wrong_plaintext';
+export async function makeFixture(initialise = true) {
+ const secret = new Uint8Array(32).fill(83),
+ peerSecret = new Uint8Array(32).fill(84),
+ owner = getPublicKey(secret),
+ peer = getPublicKey(peerSecret);
+ let mode: Mode = 'normal',
+ keys = 0,
+ encrypts = 0,
+ decrypts = 0,
+ signs = 0,
+ release: (() => void) | undefined;
+ function encrypt(target: string, text: string) {
+ const conversation = nip44.v2.utils.getConversationKey(secret, target);
+ try {
+ return nip44.v2.encrypt(text, conversation);
+ } finally {
+ conversation.fill(0);
+ }
+ }
+ function decrypt(target: string, wire: string) {
+ const conversation = nip44.v2.utils.getConversationKey(secret, target);
+ try {
+ return nip44.v2.decrypt(wire, conversation);
+ } finally {
+ conversation.fill(0);
+ }
+ }
+ Object.defineProperty(window, 'nostr', {
+ configurable: true,
+ value: {
+ getPublicKey: () => {
+ keys++;
+ return Promise.resolve(mode === 'changed_key' ? peer : owner);
+ },
+ signEvent: (template: UnsignedEvent) => {
+ signs++;
+ return Promise.resolve(finalizeEvent(template, secret));
+ },
+ nip44: {
+ encrypt: (target: string, text: string) => {
+ encrypts++;
+ return Promise.resolve(encrypt(target, text));
+ },
+ decrypt: (target: string, wire: string) => {
+ decrypts++;
+ if (mode === 'declined_decrypt')
+ return Promise.reject(Error('controlled decryption refusal'));
+ const work = () =>
+ mode === 'wrong_plaintext' ? '{}' : decrypt(target, wire);
+ return mode === 'hold_decrypt'
+ ? new Promise<string>((resolve) => {
+ release = () => resolve(work());
+ })
+ : Promise.resolve(work());
+ }
+ }
+ }
+ });
+ const identity = createIdentitySession();
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ const opened = await openBrowserDatabase();
+ if (opened.state !== 'ready') throw Error('fixture storage unavailable');
+ const database = opened.owner,
+ repository = createPrivateStorageRepository(database, owner);
+ if (!repository) throw Error('fixture namespace unavailable');
+ if (initialise) {
+ const listing = finalizeEvent(
+ {
+ kind: 30402,
+ created_at: 1700000060,
+ content: 'Public carrots',
+ tags: [
+ ['d', 'carrots'],
+ ['title', 'Carrots'],
+ ['summary', 'Fresh carrots'],
+ ['published_at', '1700000000'],
+ ['location', 'Victoria'],
+ ['price', '3.5', 'CAD'],
+ ['radroots:price_unit', 'lb'],
+ ['status', 'active']
+ ]
+ },
+ peerSecret
+ );
+ const verified = verifyEnvelope(JSON.stringify(listing)),
+ context = verified.ok && captureEnquiryContext(verified.value),
+ observed = Date.now();
+ const plan =
+ context &&
+ captureEnquiryRumor(
+ identity,
+ context,
+ marker,
+ Math.floor(observed / 1000)
+ );
+ const reservations = createPrivateSendReservationRepository(
+ database,
+ owner
+ );
+ if (!plan || !reservations)
+ throw Error('fixture original intent unavailable');
+ const realNow = Date.now;
+ Date.now = () => observed;
+ let reserved: Awaited<ReturnType<typeof reserveSendIdentity>>;
+ try {
+ reserved = await reserveSendIdentity(
+ reservations,
+ identity,
+ command,
+ plan,
+ 'reviewed_private_intent'
+ );
+ } finally {
+ Date.now = realNow;
+ }
+ if (!('identity' in reserved) || !reservedSendSnapshot(reserved.identity))
+ throw Error('fixture original command unavailable');
+ const preparation = captureSelfRecoveryPreparation(
+ repository,
+ identity,
+ reserved.identity,
+ 'reviewed_self_recovery'
+ );
+ if (
+ !preparation ||
+ !['saved', 'existing'].includes(
+ (await prepareSelfRecovery(preparation, 'reviewed_self_recovery'))
+ .status
+ )
+ )
+ throw Error('fixture actual self save unavailable');
+ stopSelfRecoveryPreparation(preparation);
+ stopRumorPlan(plan);
+ }
+ const discovery = 'wss://discovery.example.org',
+ archive = 'wss://archive.example.org',
+ destination = 'wss://peer.example.org';
+ const policy = validateRelayPolicy(
+ JSON.stringify({
+ schemaVersion: 1,
+ public: [{ origin: discovery, read: true, write: false, nip50: false }],
+ inbox: [archive, destination].map((origin) => ({
+ origin,
+ read: true,
+ write: true
+ })),
+ postingEnabled: false,
+ messagingEnabled: false,
+ operatorDenylist: []
+ })
+ );
+ if (!policy) throw Error('fixture policy unavailable');
+ const schedulers: ReturnType<typeof createPublicScheduler>[] = [],
+ tokens: ReturnType<typeof captureResumePreparation>[] = [];
+ let current = true;
+ function resolve(asPeer: boolean) {
+ const event = finalizeEvent(
+ {
+ kind: 10050,
+ created_at: 100,
+ tags: [['relay', asPeer ? destination : archive]],
+ content: ''
+ },
+ asPeer ? peerSecret : secret
+ );
+ const scheduler = createPublicScheduler({
+ now: () => 0,
+ schedule: () => () => {}
+ });
+ schedulers.push(scheduler);
+ const run = createPublicRun(scheduler, policy!);
+ return createInboxResolver(
+ run,
+ event.pubkey,
+ (next) =>
+ openInboxRequest(
+ run,
+ event.pubkey,
+ (sink) => {
+ sink({ type: 'EVENT', from: discovery, id: 'fixture', event });
+ sink({ type: 'EOSE', from: discovery, id: 'fixture' });
+ return () => {};
+ },
+ next
+ ),
+ () => current
+ );
+ }
+ const own = resolve(false),
+ other = resolve(true),
+ plan = createInboxRoutePlan(policy, owner, peer, own, other);
+ if (!plan) throw Error('fixture genuine routing unavailable');
+ async function row() {
+ const loaded = await loadPrivateRecord(
+ repository!,
+ 'private_sends',
+ command
+ );
+ if (!loaded.ok) return undefined;
+ const record = privateRecordSnapshot(loaded.value, owner, command),
+ wire = privateRecordWire(loaded.value, owner, command);
+ return record?.family === 'private_send_operation' && wire
+ ? { record, wire }
+ : undefined;
+ }
+ async function raw() {
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readonly'
+ ),
+ request = tx.objectStore('private_sends').getAll();
+ return new Promise<string>((resolve, reject) => {
+ tx.addEventListener('complete', () =>
+ resolve(JSON.stringify(request.result))
+ );
+ tx.addEventListener('abort', () => reject(Error('fixture read aborted')));
+ });
+ }
+ async function write(kind: 'erase' | 'revision' | 'corrupt') {
+ const original = kind === 'revision' ? await row() : undefined;
+ const wire =
+ original &&
+ JSON.stringify({
+ ...original.record,
+ revision: original.record.revision + 1
+ });
+ if (
+ kind === 'revision' &&
+ (!wire || !decodePrivateRecord(wire, owner, command).ok)
+ )
+ throw Error('fixture successor unavailable');
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readwrite'
+ ),
+ store = tx.objectStore('private_sends');
+ if (kind === 'erase') store.delete([owner, command]);
+ else
+ store.put({
+ owner,
+ id: command,
+ wire: kind === 'corrupt' ? '{"schema":999}' : wire
+ });
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('fixture write aborted'))
+ );
+ });
+ }
+ return {
+ owner,
+ peer,
+ command,
+ marker,
+ identity,
+ repository,
+ context: { plan, policy, own, other },
+ row,
+ raw,
+ write,
+ capture() {
+ const token = captureResumePreparation(
+ repository,
+ identity,
+ command,
+ 'reviewed_private_resume'
+ );
+ if (!token) throw Error('fixture resume unavailable');
+ tokens.push(token);
+ return token;
+ },
+ counts: () => ({ keys, encrypts, decrypts, signs }),
+ mode: (next: Mode) => {
+ mode = next;
+ },
+ settle: () => release?.(),
+ pending: () => {
+ const scheduler = browserExtensionScheduler(),
+ slot = scheduler && extensionSchedulerSnapshot(scheduler);
+ return slot?.state === 'active' && slot.pending === 'decrypt';
+ },
+ disconnect: () => disconnectIdentity(identity),
+ decryptPeer(wire: string) {
+ const outer = JSON.parse(wire) as { pubkey: string; content: string };
+ const conversation = nip44.v2.utils.getConversationKey(
+ peerSecret,
+ outer.pubkey
+ );
+ let seal: { pubkey: string; content: string };
+ try {
+ seal = JSON.parse(
+ nip44.v2.decrypt(outer.content, conversation)
+ ) as typeof seal;
+ } finally {
+ conversation.fill(0);
+ }
+ const inner = nip44.v2.utils.getConversationKey(peerSecret, seal.pubkey);
+ try {
+ return JSON.parse(nip44.v2.decrypt(seal.content, inner)) as {
+ id: string;
+ created_at: number;
+ content: string;
+ };
+ } finally {
+ inner.fill(0);
+ }
+ },
+ close() {
+ current = false;
+ for (const token of tokens) if (token) stopResumePreparation(token);
+ for (const scheduler of schedulers) closePublicScheduler(scheduler);
+ disconnectIdentity(identity);
+ closeBrowserDatabase(database);
+ secret.fill(0);
+ peerSecret.fill(0);
+ delete window.nostr;
+ }
+ };
+}
diff --git a/web/tests/e2e/resume-preparation.spec.ts b/web/tests/e2e/resume-preparation.spec.ts
@@ -0,0 +1,520 @@
+import { expect, test, type Page } from '@playwright/test';
+import { build } from 'vite';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Resume from './harness/resume-preparation.ts';
+declare global {
+ interface Window {
+ hcp083: typeof Resume;
+ hcp083Fixture: Awaited<ReturnType<typeof Resume.makeFixture>>;
+ hcp083Token: ReturnType<Window['hcp083Fixture']['capture']>;
+ hcp083Pending: Promise<
+ Awaited<ReturnType<typeof Resume.resumeEncryptedPreparation>>
+ >;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ const built = await build({
+ configFile: false,
+ logLevel: 'silent',
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/resume-preparation.ts', import.meta.url)
+ ),
+ name: 'hcp083',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(built) ? built[0] : built;
+ if (!('output' in output)) throw Error('missing resume bundle');
+ const chunks = output.output.filter((entry) => entry.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+ console.log(
+ JSON.stringify({
+ fixture: 'HCP083_ACTUAL_RELOAD_SDK_IDB',
+ bundleSha256: createHash('sha256').update(bundle).digest('hex'),
+ moduleIds: Object.keys(chunks[0].modules),
+ qualification:
+ 'Source-only disposable provider, actual SDK/IDB/WebLocks; no installed extension/relay/client Q'
+ })
+ );
+});
+test.afterAll(async () => server.close());
+async function load(page: Page, initialise = true) {
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async (initialise) => {
+ window.hcp083Fixture = await window.hcp083.makeFixture(initialise);
+ }, initialise);
+}
+test('actual reload loses presentation capabilities and explicitly recovers the same rumor and missing peer without rebuilding self', async ({
+ page
+}) => {
+ let sockets = 0;
+ page.on('websocket', () => sockets++);
+ await load(page);
+ const before = await page.evaluate(async () => {
+ const row = await window.hcp083Fixture.row();
+ if (!row) throw Error('missing self');
+ return row.record;
+ });
+ await page.reload();
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async () => {
+ window.hcp083Fixture = await window.hcp083.makeFixture(false);
+ });
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ const token = f.capture(),
+ initial = f.counts(),
+ raw = await f.raw();
+ const recovered = await s.resumeEncryptedPreparation(
+ token,
+ undefined,
+ 'reviewed_private_resume'
+ ),
+ rumor = s.resumeRecoveredRumor(token),
+ memory = rumor && s.rumorPlanSnapshot(rumor),
+ afterRecovery = f.counts();
+ const pair = await s.resumeEncryptedPreparation(
+ token,
+ f.context,
+ 'reviewed_private_resume'
+ ),
+ row = await f.row(),
+ peer =
+ row?.record.peerArtifact &&
+ f.decryptPeer(row.record.peerArtifact.wire);
+ return {
+ recovered: recovered.status,
+ pair: pair.status,
+ memory,
+ record: row?.record,
+ peer,
+ noSelfCrypto:
+ afterRecovery.encrypts === initial.encrypts &&
+ afterRecovery.signs === initial.signs,
+ privateOnly:
+ !raw.includes(f.marker) && !(await f.raw()).includes(f.marker)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result.recovered).toBe('recovered');
+ expect(result.pair).toBe('prepared');
+ expect(result.noSelfCrypto).toBe(true);
+ expect(result.privateOnly).toBe(true);
+ expect(result.record?.self).toEqual(before.self);
+ expect(result.record?.rumorHash).toBe(before.rumorHash);
+ expect(result.record?.createdAt).toBe(before.createdAt);
+ expect(result.memory?.id).toBe(before.rumorHash);
+ expect(result.memory?.wire).toContain(
+ 'HCP083_PRIVATE_RECOVERY_MEMORY_ONLY_SENTINEL'
+ );
+ expect(result.peer?.id).toBe(before.rumorHash);
+ expect(result.peer?.created_at).toBe(before.createdAt);
+ const originalRumor = JSON.parse(result.memory!.wire) as { content: string };
+ expect(result.peer?.content).toBe(originalRumor.content);
+ expect(result.peer?.content).toContain('Enquiry about "Carrots"');
+ expect(result.peer?.content).toContain(
+ 'HCP083_PRIVATE_RECOVERY_MEMORY_ONLY_SENTINEL'
+ );
+ expect(sockets).toBe(0);
+});
+test('capture and unreviewed Resume spend no prompts or private effects', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ const before = f.counts(),
+ raw = await f.raw(),
+ token = f.capture(),
+ result = await s.resumeEncryptedPreparation(token, f.context, 'wrong');
+ return {
+ status: result.status,
+ inert: JSON.stringify(before) === JSON.stringify(f.counts()),
+ unchanged: raw === (await f.raw()),
+ noRumor: !s.resumeRecoveredRumor(token)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'invalid',
+ inert: true,
+ unchanged: true,
+ noRumor: true
+ });
+});
+test('erased evidence explicitly discloses loss without a new reservation or SDK prompt', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ await f.write('erase');
+ const before = f.counts(),
+ token = f.capture(),
+ r = await s.resumeEncryptedPreparation(
+ token,
+ f.context,
+ 'reviewed_private_resume'
+ );
+ return {
+ status: r.status,
+ copy: s.resumePreparationSnapshot(token)?.copy,
+ inert: JSON.stringify(before) === JSON.stringify(f.counts()),
+ raw: await f.raw(),
+ noRumor: !s.resumeRecoveredRumor(token)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result.status).toBe('lost_evidence');
+ expect(result.copy).toContain('lost');
+ expect(result.inert).toBe(true);
+ expect(result.raw).toBe('[]');
+ expect(result.noRumor).toBe(true);
+});
+test('corrupt stored recovery stays intact and blocks decryption and silent reset', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ await f.write('corrupt');
+ const raw = await f.raw(),
+ before = f.counts(),
+ r = await s.resumeEncryptedPreparation(
+ f.capture(),
+ f.context,
+ 'reviewed_private_resume'
+ );
+ return {
+ status: r.status,
+ unchanged: raw === (await f.raw()),
+ inert: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'corrupt_record',
+ unchanged: true,
+ inert: true
+ });
+});
+test('fresh changed extension key blocks before the first recovery decrypt', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ const raw = await f.raw(),
+ before = f.counts(),
+ token = f.capture();
+ f.mode('changed_key');
+ const r = await s.resumeEncryptedPreparation(
+ token,
+ f.context,
+ 'reviewed_private_resume'
+ );
+ return {
+ status: r.status,
+ unchanged: raw === (await f.raw()),
+ noDecrypt: f.counts().decrypts === before.decrypts,
+ noRumor: !s.resumeRecoveredRumor(token)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'stopped',
+ unchanged: true,
+ noDecrypt: true,
+ noRumor: true
+ });
+});
+test('late decryption after Disconnect cannot restore memory or continue peer work', async ({
+ page
+}) => {
+ await load(page);
+ await page.evaluate(() => {
+ const f = window.hcp083Fixture;
+ f.mode('hold_decrypt');
+ window.hcp083Token = f.capture();
+ window.hcp083Pending = window.hcp083.resumeEncryptedPreparation(
+ window.hcp083Token,
+ f.context,
+ 'reviewed_private_resume'
+ );
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp083Fixture.pending()))
+ .toBe(true);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ const raw = await f.raw(),
+ before = f.counts();
+ f.disconnect();
+ f.mode('normal');
+ f.settle();
+ const r = await window.hcp083Pending;
+ return {
+ status: r.status,
+ unchanged: raw === (await f.raw()),
+ noPeer:
+ f.counts().encrypts === before.encrypts &&
+ f.counts().signs === before.signs,
+ noRumor: !s.resumeRecoveredRumor(window.hcp083Token)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'stopped',
+ unchanged: true,
+ noPeer: true,
+ noRumor: true
+ });
+});
+test('stopped pending decryption occupies the shared owner until actual settlement', async ({
+ page
+}) => {
+ await load(page);
+ await page.evaluate(() => {
+ const f = window.hcp083Fixture;
+ f.mode('hold_decrypt');
+ window.hcp083Token = f.capture();
+ window.hcp083Pending = window.hcp083.resumeEncryptedPreparation(
+ window.hcp083Token,
+ undefined,
+ 'reviewed_private_resume'
+ );
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp083Fixture.pending()))
+ .toBe(true);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ s.stopResumePreparation(window.hcp083Token);
+ const before = f.counts(),
+ other = f.capture(),
+ r = await s.resumeEncryptedPreparation(
+ other,
+ undefined,
+ 'reviewed_private_resume'
+ );
+ const noQueue = JSON.stringify(before) === JSON.stringify(f.counts());
+ f.mode('normal');
+ f.settle();
+ return {
+ second: r.status,
+ first: (await window.hcp083Pending).status,
+ noQueue,
+ noRumor: !s.resumeRecoveredRumor(window.hcp083Token)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ second: 'busy',
+ first: 'stopped',
+ noQueue: true,
+ noRumor: true
+ });
+});
+test('decryption refusal preserves self ciphertext and never falls back to encryption or signing', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ const raw = await f.raw(),
+ before = f.counts(),
+ token = f.capture();
+ f.mode('declined_decrypt');
+ const r = await s.resumeEncryptedPreparation(
+ token,
+ f.context,
+ 'reviewed_private_resume'
+ );
+ return {
+ status: r.status,
+ unchanged: raw === (await f.raw()),
+ noFallback:
+ f.counts().encrypts === before.encrypts &&
+ f.counts().signs === before.signs,
+ noRumor: !s.resumeRecoveredRumor(token)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'refused',
+ unchanged: true,
+ noFallback: true,
+ noRumor: true
+ });
+});
+test('substituted decrypted plaintext fails authenticated rumor recovery', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ const raw = await f.raw(),
+ token = f.capture();
+ f.mode('wrong_plaintext');
+ const r = await s.resumeEncryptedPreparation(
+ token,
+ f.context,
+ 'reviewed_private_resume'
+ );
+ return {
+ status: r.status,
+ unchanged: raw === (await f.raw()),
+ noRumor: !s.resumeRecoveredRumor(token)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'mismatch',
+ unchanged: true,
+ noRumor: true
+ });
+});
+test('completed pair recovery and repeated Resume retain both original artifacts without peer regeneration', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ const first = f.capture();
+ await s.resumeEncryptedPreparation(
+ first,
+ f.context,
+ 'reviewed_private_resume'
+ );
+ const raw = await f.raw(),
+ before = f.counts(),
+ repeat = await s.resumeEncryptedPreparation(
+ first,
+ f.context,
+ 'reviewed_private_resume'
+ ),
+ inert = JSON.stringify(before) === JSON.stringify(f.counts());
+ s.stopResumePreparation(first);
+ const fresh = f.capture(),
+ nextBefore = f.counts(),
+ r = await s.resumeEncryptedPreparation(
+ fresh,
+ f.context,
+ 'reviewed_private_resume'
+ );
+ return {
+ repeat: repeat.status,
+ inert,
+ fresh: r.status,
+ noPeer:
+ f.counts().encrypts === nextBefore.encrypts &&
+ f.counts().signs === nextBefore.signs,
+ unchanged: raw === (await f.raw())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ repeat: 'prepared',
+ inert: true,
+ fresh: 'already_prepared',
+ noPeer: true,
+ unchanged: true
+ });
+});
+test('unacknowledged full-wire mutation while decrypting is refused and retained', async ({
+ page
+}) => {
+ await load(page);
+ await page.evaluate(() => {
+ const f = window.hcp083Fixture;
+ f.mode('hold_decrypt');
+ window.hcp083Token = f.capture();
+ window.hcp083Pending = window.hcp083.resumeEncryptedPreparation(
+ window.hcp083Token,
+ f.context,
+ 'reviewed_private_resume'
+ );
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp083Fixture.pending()))
+ .toBe(true);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp083Fixture,
+ s = window.hcp083;
+ try {
+ await f.write('revision');
+ const raw = await f.raw(),
+ before = f.counts();
+ f.mode('normal');
+ f.settle();
+ const r = await window.hcp083Pending;
+ return {
+ status: r.status,
+ unchanged: raw === (await f.raw()),
+ noPeer:
+ f.counts().encrypts === before.encrypts &&
+ f.counts().signs === before.signs,
+ noRumor: !s.resumeRecoveredRumor(window.hcp083Token)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'conflict',
+ unchanged: true,
+ noPeer: true,
+ noRumor: true
+ });
+});
diff --git a/web/tests/unit/resume-preparation.test.ts b/web/tests/unit/resume-preparation.test.ts
@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import {
+ captureResumePreparation,
+ resumeEncryptedPreparation,
+ resumePreparationSnapshot,
+ resumeRecoveredRumor,
+ type ResumePreparation
+} from '../../src/lib/messaging/resume-preparation.ts';
+import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts';
+import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts';
+describe('explicit encrypted recovery cannot manufacture a new message', () => {
+ it('SSR and forged preparation are inert', async () => {
+ expect(
+ captureResumePreparation(
+ {} as PrivateStorageRepository,
+ {} as IdentitySession,
+ '12345678-1234-4234-8234-123456789abc',
+ 'reviewed_private_resume'
+ )
+ ).toBeUndefined();
+ expect(
+ await resumeEncryptedPreparation(
+ {} as ResumePreparation,
+ undefined,
+ 'reviewed_private_resume'
+ )
+ ).toEqual({ status: 'invalid' });
+ });
+ it('detached tokens expose neither recovered text nor acknowledgement', () => {
+ expect(resumePreparationSnapshot({} as ResumePreparation)).toBeUndefined();
+ expect(resumeRecoveredRumor({} as ResumePreparation)).toBeUndefined();
+ });
+ it('unreviewed input cannot coerce itself into Resume', async () => {
+ let calls = 0;
+ const review = {
+ toString() {
+ calls++;
+ return 'reviewed_private_resume';
+ }
+ };
+ expect(
+ await resumeEncryptedPreparation(
+ {} as ResumePreparation,
+ undefined,
+ review
+ )
+ ).toEqual({ status: 'invalid' });
+ expect(calls).toBe(0);
+ });
+});