commit f67de70481779c3396f987637a334f146dc3de76
parent 3393cea8fea012be30906959fe44a1d6f6061a10
Author: triesap <tyson@radroots.org>
Date: Thu, 8 Oct 2026 22:55:55 +0000
messages: atomically retain the paired delivery plan (HCP-082)
- Persist both ciphertext artifacts with frozen role routes and preference versions.
- Require genuine current self evidence and verified peer preparation.
- Reconcile exact retries and reject competing paired command writes.
- Verify real storage interruption and preserve source-only qualification boundaries.
Diffstat:
6 files changed, 1367 insertions(+), 6 deletions(-)
diff --git a/web/src/lib/messaging/prepare-send.ts b/web/src/lib/messaging/prepare-send.ts
@@ -17,6 +17,13 @@ import {
} from './envelope-preparation.ts';
import { privateRecordSnapshot } from '../persistence/private-records.ts';
import {
+ inboxRoutePlanSnapshot,
+ recheckInboxRoutePlan,
+ type InboxRoutePlan
+} from './inbox-routing.ts';
+import type { InboxResolver } from './resolve-inbox.ts';
+import type { RelayPolicy } from '../config/relays.ts';
+import {
type PrivateStorageRepository,
type PrivateStorageFailure
} from '../persistence/private-storage.ts';
@@ -25,7 +32,11 @@ import {
commitSelfRecovery,
selfRecoveryAcknowledgementSnapshot,
verifySelfRecoveryAcknowledgement,
- type SelfRecoveryAcknowledgement
+ commitPairedDelivery,
+ pairedDeliveryAcknowledgementSnapshot,
+ verifyPairedDeliveryAcknowledgement,
+ type SelfRecoveryAcknowledgement,
+ type PairedDeliveryAcknowledgement
} from '../persistence/private-sends.ts';
declare const preparationBrand: unique symbol;
@@ -44,6 +55,19 @@ export type SelfRecoveryPreparationResult = Readonly<{
| 'mismatch'
| 'out_of_order';
}>;
+export type PairedDeliveryContext = Readonly<{
+ plan: InboxRoutePlan;
+ policy: RelayPolicy;
+ own: InboxResolver;
+ other: InboxResolver;
+}>;
+export type PairedDeliveryPreparationResult = Readonly<{
+ status:
+ | SelfRecoveryPreparationResult['status']
+ | 'self_required'
+ | 'review_required'
+ | 'prepared';
+}>;
type Phase =
'unsaved' | 'preparing' | 'saved' | 'unknown_completion' | 'needs_action';
type Snapshot = Readonly<{
@@ -55,6 +79,11 @@ type Snapshot = Readonly<{
}>;
type Controller = {
run(review: unknown): Promise<SelfRecoveryPreparationResult>;
+ runPair(
+ context: PairedDeliveryContext,
+ review: unknown
+ ): Promise<PairedDeliveryPreparationResult>;
+ pairReceipt(): PairedDeliveryAcknowledgement | undefined;
snapshot(): Snapshot | undefined;
receipt(): SelfRecoveryAcknowledgement | undefined;
peer(
@@ -96,12 +125,14 @@ export function captureSelfRecoveryPreparation(
busy = false,
phase: Phase = 'unsaved',
acknowledgement: SelfRecoveryAcknowledgement | undefined,
+ pairedAcknowledgement: PairedDeliveryAcknowledgement | undefined,
unsubscribe = () => {};
function stop() {
if (!active) return;
active = false;
generation++;
acknowledgement = undefined;
+ pairedAcknowledgement = undefined;
closeEnvelopePreparation(pair);
unsubscribe();
unsubscribe = () => {};
@@ -186,6 +217,41 @@ export function captureSelfRecoveryPreparation(
return { status: base.reason };
}
if (acknowledgement) {
+ // A genuine committed pair is the exact legitimate successor to our
+ // self-only record. Reconcile through that receipt's full wire, never
+ // treat arbitrary edits to a self record as acknowledged advancement.
+ if (pairedAcknowledgement) {
+ const paired = pairedDeliveryAcknowledgementSnapshot(
+ pairedAcknowledgement
+ ),
+ originalSelf =
+ selfRecoveryAcknowledgementSnapshot(acknowledgement);
+ const matches =
+ paired &&
+ originalSelf &&
+ paired.owner === record.owner &&
+ paired.id === record.id &&
+ paired.peer === record.peer &&
+ paired.rumorHash === record.rumorHash &&
+ paired.createdAt === record.createdAt &&
+ paired.self.eventId === originalSelf.self.eventId &&
+ paired.self.wire === originalSelf.self.wire;
+ const valid =
+ matches &&
+ (await verifyPairedDeliveryAcknowledgement(
+ repository,
+ pairedAcknowledgement
+ ));
+ if (!admitted()) return { status: 'stopped' };
+ if (valid) {
+ phase = 'saved';
+ return { status: 'saved' };
+ }
+ pairedAcknowledgement = undefined;
+ acknowledgement = undefined;
+ phase = 'needs_action';
+ return { status: 'conflict' };
+ }
const valid = await verifySelfRecoveryAcknowledgement(
repository,
acknowledgement
@@ -263,8 +329,118 @@ export function captureSelfRecoveryPreparation(
busy = false;
}
}
+ function pairReceipt() {
+ return current() &&
+ pairedAcknowledgement &&
+ pairedDeliveryAcknowledgementSnapshot(pairedAcknowledgement)
+ ? pairedAcknowledgement
+ : undefined;
+ }
+ async function runPair(
+ context: PairedDeliveryContext,
+ reviewed: unknown
+ ): Promise<PairedDeliveryPreparationResult> {
+ if (reviewed !== 'reviewed_pair_preparation') return { status: 'invalid' };
+ if (!current()) return { status: 'stopped' };
+ if (busy) return { status: 'busy' };
+ const self = receipt();
+ if (!self) return { status: 'self_required' };
+ busy = true;
+ const attempt = generation;
+ try {
+ const { plan, policy, own, other } = context,
+ routes = inboxRoutePlanSnapshot(plan);
+ if (
+ !routes ||
+ routes.peer.author !== record.peer ||
+ routes.archive.author !== record.owner
+ )
+ return { status: 'invalid' };
+ const routeWire = JSON.stringify(routes);
+ const routesCurrent = () =>
+ recheckInboxRoutePlan(plan, policy, own, other) === 'unchanged' &&
+ JSON.stringify(inboxRoutePlanSnapshot(plan)) === routeWire;
+ const admitted = () => current() && attempt === generation;
+ if (!routesCurrent()) return { status: 'review_required' };
+ if (!admitted()) return { status: 'stopped' };
+ if (pairedAcknowledgement) {
+ const valid = await verifyPairedDeliveryAcknowledgement(
+ repository,
+ pairedAcknowledgement
+ );
+ if (!admitted()) return { status: 'stopped' };
+ if (!routesCurrent()) return { status: 'review_required' };
+ const saved = pairedDeliveryAcknowledgementSnapshot(
+ pairedAcknowledgement
+ );
+ return valid &&
+ saved &&
+ JSON.stringify(saved.deliveryPlan.routes) === routeWire
+ ? { status: 'prepared' }
+ : { status: 'conflict' };
+ }
+ const durableSelf = await verifySelfRecoveryAcknowledgement(
+ repository,
+ self
+ );
+ if (!admitted()) return { status: 'stopped' };
+ if (!routesCurrent()) return { status: 'review_required' };
+ if (!admitted()) return { status: 'stopped' };
+ if (!durableSelf) return { status: 'conflict' };
+ phase = 'preparing';
+ // The existing lower crypto factory owns the owner lock during SDK work.
+ const prepared = await prepareEnvelopeRole(
+ pair,
+ 'peer',
+ 'reviewed_pair_role'
+ );
+ if (!admitted()) return { status: 'stopped' };
+ if (!routesCurrent()) return { status: 'review_required' };
+ if (!admitted()) return { status: 'stopped' };
+ if (prepared.status !== 'complete') return { status: prepared.status };
+ const proof = preparedEnvelopeProof(pair, 'peer');
+ if (!proof) return { status: 'mismatch' };
+ const saved = await navigator.locks.request(
+ 'harvestcircle:owner:' + record.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock) => {
+ if (!lock) return { status: 'busy' as const };
+ if (!routesCurrent()) return { status: 'review_required' as const };
+ if (!admitted()) return { status: 'stopped' as const };
+ return await commitPairedDelivery(
+ repository,
+ session,
+ reserved,
+ self,
+ proof,
+ plan,
+ 'reviewed_pair_commit'
+ );
+ }
+ );
+ if (!admitted()) return { status: 'stopped' };
+ if (!routesCurrent()) return { status: 'review_required' };
+ if (!admitted()) return { status: 'stopped' };
+ if ('receipt' in saved) pairedAcknowledgement = saved.receipt;
+ phase = 'saved';
+ return { status: saved.status };
+ } catch {
+ return { status: current() ? 'unavailable' : 'stopped' };
+ } finally {
+ busy = false;
+ if (current()) phase = 'saved';
+ }
+ }
const token = Object.freeze({}) as SelfRecoveryPreparation;
- preparations.set(token, { run, snapshot, receipt, peer, stop });
+ preparations.set(token, {
+ run,
+ runPair,
+ pairReceipt,
+ snapshot,
+ receipt,
+ peer,
+ stop
+ });
unsubscribe = subscribeIdentityInvalidation(session, stop);
return current() ? token : undefined;
}
@@ -296,3 +472,16 @@ export function stopSelfRecoveryPreparation(
): void {
preparations.get(token)?.stop();
}
+export function preparePairedDelivery(
+ token: SelfRecoveryPreparation,
+ context: PairedDeliveryContext,
+ review: unknown
+): Promise<PairedDeliveryPreparationResult> {
+ return (
+ preparations.get(token)?.runPair(context, review) ??
+ Promise.resolve({ status: 'invalid' })
+ );
+}
+export function preparedPairedDelivery(token: SelfRecoveryPreparation) {
+ return preparations.get(token)?.pairReceipt();
+}
diff --git a/web/src/lib/persistence/private-records.ts b/web/src/lib/persistence/private-records.ts
@@ -8,6 +8,7 @@ import {
verifiedEnvelopeSnapshot
} from '../nostr/verified-envelope.ts';
import { canonicalRelayOrigin } from '../config/relays.ts';
+import type { InboxRouteSnapshot } from '../messaging/inbox-routing.ts';
import {
LOCAL_PERSISTENCE_BUDGETS,
PRIVATE_TRANSPORT_BUDGETS,
@@ -38,6 +39,13 @@ export type PrivateSendOperation = Readonly<{
createdAt: number;
self: PrivateCiphertextArtifact;
peerArtifact: PrivateCiphertextArtifact | null;
+ // Absent in original self-only records; never an implicit migration or an
+ // effect capability. Both ciphertext roles are required for a paired plan.
+ deliveryPlan?: PrivateDeliveryPlan;
+}>;
+export type PrivateDeliveryPlan = Readonly<{
+ state: 'prepared';
+ routes: InboxRouteSnapshot;
}>;
export type ReceivedEnvelopeRecord = Readonly<{
schema: 1;
@@ -86,6 +94,85 @@ const reservationFields = [
'rumorHash',
'createdAt'
];
+function routeHead(value: unknown): boolean {
+ return (
+ exactLocalFields(value, ['id', 'createdAt']) &&
+ hash(value.id) &&
+ unsigned(value.createdAt)
+ );
+}
+function persistedRoute(
+ value: unknown,
+ author: string,
+ role: 'peer' | 'self_archive'
+): boolean {
+ if (
+ !exactLocalFields(value, [
+ 'role',
+ 'author',
+ 'targets',
+ 'knownBase',
+ 'sources'
+ ]) ||
+ value.role !== role ||
+ value.author !== author ||
+ !Array.isArray(value.targets) ||
+ value.targets.length < 1 ||
+ value.targets.length > RELAY_BUDGETS.inbox ||
+ new Set(value.targets).size !== value.targets.length ||
+ !value.targets.every(
+ (origin) =>
+ typeof origin === 'string' && canonicalRelayOrigin(origin) === origin
+ ) ||
+ !exactLocalFields(value.knownBase, ['author', 'id', 'createdAt']) ||
+ value.knownBase.author !== author ||
+ !hash(value.knownBase.id) ||
+ !unsigned(value.knownBase.createdAt) ||
+ !Array.isArray(value.sources) ||
+ value.sources.length < 1 ||
+ value.sources.length > RELAY_BUDGETS.public
+ )
+ return false;
+ const origins = new Set<string>();
+ function acceptOrigin(origin: string): boolean {
+ if (origins.has(origin)) return false;
+ origins.add(origin);
+ return true;
+ }
+ for (const source of value.sources) {
+ if (typeof source !== 'object' || source === null || Array.isArray(source))
+ return false;
+ const row = source as Record<string, unknown>;
+ if (
+ !exactLocalFields(
+ row,
+ row.head === undefined
+ ? ['source', 'state']
+ : ['source', 'state', 'head']
+ ) ||
+ row.state !== 'eose' ||
+ typeof row.source !== 'string' ||
+ canonicalRelayOrigin(row.source) !== row.source ||
+ !acceptOrigin(row.source) ||
+ (row.head !== undefined && !routeHead(row.head))
+ )
+ return false;
+ }
+ return true;
+}
+function deliveryPlan(
+ value: unknown,
+ owner: string,
+ peer: string
+): value is PrivateDeliveryPlan {
+ return (
+ exactLocalFields(value, ['state', 'routes']) &&
+ value.state === 'prepared' &&
+ exactLocalFields(value.routes, ['peer', 'archive']) &&
+ persistedRoute(value.routes.peer, peer, 'peer') &&
+ persistedRoute(value.routes.archive, owner, 'self_archive')
+ );
+}
// JSON.parse keeps only the last duplicate key. Retaining the original outer
// bytes therefore requires a separate syntax-only duplicate check, including
// escaped key aliases and nested local metadata. JSON validity/semantics remain
@@ -294,14 +381,18 @@ export function decodePrivateRecord(
!exactLocalFields(fields, [
...reservationFields,
'self',
- 'peerArtifact'
+ 'peerArtifact',
+ ...(fields.deliveryPlan === undefined ? [] : ['deliveryPlan'])
]) ||
!sendMetadata(fields, owner, id) ||
!unsigned(fields.revision) ||
fields.revision < 1 ||
!artifact(fields.self, owner) ||
(fields.peerArtifact !== null &&
- !artifact(fields.peerArtifact, fields.peer as string))
+ !artifact(fields.peerArtifact, fields.peer as string)) ||
+ (fields.deliveryPlan !== undefined &&
+ (fields.peerArtifact === null ||
+ !deliveryPlan(fields.deliveryPlan, owner, fields.peer as string)))
)
return failed('malformed');
record = {
@@ -320,7 +411,10 @@ export function decodePrivateRecord(
: {
eventId: fields.peerArtifact.eventId,
wire: fields.peerArtifact.wire
- }
+ },
+ ...(fields.deliveryPlan === undefined
+ ? {}
+ : { deliveryPlan: fields.deliveryPlan })
};
} else if (fields.family === 'received_envelope') {
if (
diff --git a/web/src/lib/persistence/private-sends.ts b/web/src/lib/persistence/private-sends.ts
@@ -19,9 +19,14 @@ import {
privateRecordSnapshot,
privateRecordWire,
type PrivateRecordHandle,
- type PrivateSendReservation
+ type PrivateSendReservation,
+ type PrivateSendOperation
} from './private-records.ts';
import {
+ inboxRoutePlanSnapshot,
+ type InboxRoutePlan
+} from '../messaging/inbox-routing.ts';
+import {
loadPrivateRecord,
commitPrivateRecord,
type PrivateStorageRepository,
@@ -281,3 +286,226 @@ export async function verifySelfRecoveryAcknowledgement(
saved.wire
);
}
+
+declare const pairedAcknowledgementBrand: unique symbol;
+export type PairedDeliveryAcknowledgement = Readonly<{
+ [pairedAcknowledgementBrand]: true;
+}>;
+type Paired = Readonly<{
+ record: PrivateSendOperation;
+ wire: string;
+ current(): boolean;
+}>;
+const pairedAcknowledgements = new WeakMap<
+ PairedDeliveryAcknowledgement,
+ Paired
+>();
+export type PairedDeliveryCommitResult =
+ | Readonly<{
+ status: 'prepared' | 'existing' | 'reconciled';
+ receipt: PairedDeliveryAcknowledgement;
+ }>
+ | Readonly<{ status: PrivateStorageFailure | 'invalid' | 'stopped' }>;
+
+// Requires genuine current self acknowledgement, peer factory proof and route
+// capture. Structural local record admission alone cannot mint this receipt.
+// Caller owns WebLock and current route recheck; this function owns short CAS.
+export async function commitPairedDelivery(
+ repository: PrivateStorageRepository,
+ session: IdentitySession,
+ reserved: ReservedSendIdentity,
+ self: SelfRecoveryAcknowledgement,
+ peer: VerifiedOutboundEnvelope,
+ plan: InboxRoutePlan,
+ review: unknown
+): Promise<PairedDeliveryCommitResult> {
+ if (typeof window === 'undefined' || review !== 'reviewed_pair_commit')
+ return { status: 'invalid' };
+ const savedSelf = acknowledgements.get(self),
+ original = reservedSendSnapshot(reserved),
+ ownership = identityMessagingOwnership(session),
+ proof = verifiedOutboundSnapshot(peer),
+ routes = inboxRoutePlanSnapshot(plan);
+ if (
+ !savedSelf?.current() ||
+ !original ||
+ !ownership?.current() ||
+ !proof ||
+ !routes ||
+ original.owner !== ownership.owner ||
+ savedSelf.record.owner !== original.owner ||
+ savedSelf.record.id !== original.id ||
+ savedSelf.record.peer !== original.peer ||
+ savedSelf.record.rumorHash !== original.rumorHash ||
+ savedSelf.record.createdAt !== original.createdAt ||
+ proof.role !== 'peer' ||
+ proof.destination !== original.peer ||
+ proof.owner !== original.owner ||
+ proof.command !== original.id ||
+ proof.peer !== original.peer ||
+ proof.rumorHash !== original.rumorHash ||
+ routes.peer.author !== original.peer ||
+ routes.archive.author !== original.owner
+ )
+ return { status: 'invalid' };
+ const verified = verifyEnvelope(proof.wire),
+ event = verified.ok && verifiedEnvelopeSnapshot(verified.value);
+ if (!event || event.kind !== 1059) return { status: 'invalid' };
+ const current = () => {
+ const fresh = reservedSendSnapshot(reserved),
+ peerNow = verifiedOutboundSnapshot(peer);
+ return (
+ ownership.current() &&
+ savedSelf.current() &&
+ fresh?.owner === original.owner &&
+ fresh.id === original.id &&
+ fresh.peer === original.peer &&
+ fresh.rumorHash === original.rumorHash &&
+ fresh.createdAt === original.createdAt &&
+ peerNow?.role === 'peer' &&
+ peerNow.wire === proof.wire
+ );
+ };
+ try {
+ const loaded = await readSelfRecoveryBase(repository, reserved);
+ if (!current()) return { status: 'stopped' };
+ if (!loaded.ok) return { status: loaded.reason };
+ const base = privateRecordSnapshot(
+ loaded.value,
+ original.owner,
+ original.id
+ ),
+ baseWire = privateRecordWire(loaded.value, original.owner, original.id);
+ if (
+ !base ||
+ base.family !== 'private_send_operation' ||
+ base.self.eventId !== savedSelf.self.eventId ||
+ base.self.wire !== savedSelf.self.wire
+ )
+ return { status: 'conflict' };
+ const peerArtifact = { eventId: event.id, wire: proof.wire },
+ deliveryPlan = { state: 'prepared' as const, routes };
+ let expected: PrivateRecordHandle,
+ status: 'prepared' | 'existing' | 'reconciled';
+ if (base.peerArtifact || base.deliveryPlan) {
+ if (
+ base.peerArtifact?.eventId !== peerArtifact.eventId ||
+ base.peerArtifact.wire !== peerArtifact.wire ||
+ JSON.stringify(base.deliveryPlan) !== JSON.stringify(deliveryPlan)
+ )
+ return { status: 'conflict' };
+ expected = loaded.value;
+ status = 'existing';
+ } else {
+ if (baseWire !== savedSelf.wire) return { status: 'conflict' };
+ const decoded = decodePrivateRecord(
+ JSON.stringify({
+ schema: 1,
+ family: 'private_send_operation',
+ owner: base.owner,
+ id: base.id,
+ revision: base.revision + 1,
+ peer: base.peer,
+ rumorHash: base.rumorHash,
+ createdAt: base.createdAt,
+ self: { eventId: base.self.eventId, wire: base.self.wire },
+ peerArtifact,
+ deliveryPlan
+ }),
+ base.owner,
+ base.id
+ );
+ if (!decoded.ok) return { status: 'invalid_record' };
+ expected = decoded.value;
+ if (!current()) return { status: 'stopped' };
+ const committed = await commitPrivateRecord(
+ repository,
+ expected,
+ loaded.value
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!committed.ok && committed.reason !== 'unknown_completion')
+ return { status: committed.reason };
+ status = !committed.ok
+ ? 'reconciled'
+ : committed.value.state === 'existing'
+ ? 'existing'
+ : 'prepared';
+ }
+ const wire = privateRecordWire(expected, original.owner, original.id),
+ readback = await loadPrivateRecord(
+ repository,
+ 'private_sends',
+ original.id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!readback.ok) return { status: 'unknown_completion' };
+ const observed = privateRecordSnapshot(
+ readback.value,
+ original.owner,
+ original.id
+ );
+ if (
+ !wire ||
+ privateRecordWire(readback.value, original.owner, original.id) !== wire ||
+ !observed ||
+ observed.family !== 'private_send_operation' ||
+ !observed.peerArtifact ||
+ !observed.deliveryPlan
+ )
+ return { status: 'conflict' };
+ const receipt = Object.freeze({}) as PairedDeliveryAcknowledgement;
+ pairedAcknowledgements.set(receipt, {
+ record: observed,
+ wire,
+ current: () => ownership.current()
+ });
+ return { status, receipt };
+ } catch {
+ return { status: current() ? 'unavailable' : 'stopped' };
+ }
+}
+export function pairedDeliveryAcknowledgementSnapshot(
+ receipt: PairedDeliveryAcknowledgement
+) {
+ const saved = pairedAcknowledgements.get(receipt);
+ if (
+ !saved?.current() ||
+ !saved.record.peerArtifact ||
+ !saved.record.deliveryPlan
+ )
+ return undefined;
+ const row = saved.record;
+ return {
+ owner: row.owner,
+ id: row.id,
+ revision: row.revision,
+ peer: row.peer,
+ rumorHash: row.rumorHash,
+ createdAt: row.createdAt,
+ self: { ...row.self },
+ peerArtifact: { ...saved.record.peerArtifact },
+ deliveryPlan: JSON.parse(
+ JSON.stringify(saved.record.deliveryPlan)
+ ) as NonNullable<PrivateSendOperation['deliveryPlan']>,
+ fact: 'acknowledged_local_pair_only' as const
+ };
+}
+export async function verifyPairedDeliveryAcknowledgement(
+ repository: PrivateStorageRepository,
+ receipt: PairedDeliveryAcknowledgement
+): Promise<boolean> {
+ const saved = pairedAcknowledgements.get(receipt);
+ if (!saved?.current()) return false;
+ const loaded = await loadPrivateRecord(
+ repository,
+ 'private_sends',
+ saved.record.id
+ );
+ return (
+ saved.current() &&
+ loaded.ok &&
+ privateRecordWire(loaded.value, saved.record.owner, saved.record.id) ===
+ saved.wire
+ );
+}
diff --git a/web/tests/e2e/harness/paired-delivery.ts b/web/tests/e2e/harness/paired-delivery.ts
@@ -0,0 +1,220 @@
+import { makeFixture as makeSelfFixture } from './self-recovery.ts';
+import type { finalizeEvent, EventTemplate } from 'applesauce-core/helpers';
+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,
+ inboxRoutePlanSnapshot
+} from '../../../src/lib/messaging/inbox-routing.ts';
+import { verifiedOutboundSnapshot } from '../../../src/lib/nostr/verify-outbound-envelope.ts';
+export { verifiedOutboundSnapshot, inboxRoutePlanSnapshot };
+import {
+ prepareSelfRecovery,
+ preparedSelfRecovery,
+ selfRecoveryPeerPreparation,
+ preparePairedDelivery,
+ preparedPairedDelivery
+} from '../../../src/lib/messaging/prepare-send.ts';
+import {
+ commitPairedDelivery,
+ pairedDeliveryAcknowledgementSnapshot,
+ selfRecoveryAcknowledgementSnapshot
+} from '../../../src/lib/persistence/private-sends.ts';
+import {
+ decodePrivateRecord,
+ privateRecordSnapshot
+} from '../../../src/lib/persistence/private-records.ts';
+import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts';
+import { browserDatabaseTransaction } from '../../../src/lib/persistence/database.ts';
+import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts';
+import {
+ reserveSendIdentity,
+ reservedSendSnapshot
+} from '../../../src/lib/messaging/send-identity.ts';
+export {
+ prepareSelfRecovery,
+ preparedSelfRecovery,
+ selfRecoveryPeerPreparation,
+ preparePairedDelivery,
+ preparedPairedDelivery,
+ commitPairedDelivery,
+ pairedDeliveryAcknowledgementSnapshot,
+ selfRecoveryAcknowledgementSnapshot,
+ decodePrivateRecord
+};
+const discovery = 'wss://discovery.example.org',
+ peerOrigin = 'wss://peer.example.org',
+ archiveOrigin = 'wss://archive.example.org';
+// Disposable existing source fixture provider signs actual public10050 facts;
+// local discovery observations qualify route semantics only, never relay Q.
+export async function makeFixture() {
+ const f = await makeSelfFixture(),
+ policy = validateRelayPolicy(
+ JSON.stringify({
+ schemaVersion: 1,
+ public: [{ origin: discovery, read: true, write: false, nip50: false }],
+ inbox: [peerOrigin, archiveOrigin].map((origin) => ({
+ origin,
+ read: true,
+ write: true
+ })),
+ postingEnabled: false,
+ messagingEnabled: false,
+ operatorDenylist: []
+ })
+ );
+ if (!policy || !window.nostr) throw Error('missing fixture policy/provider');
+ const provider = window.nostr as Readonly<{
+ signEvent(
+ template: EventTemplate
+ ): Promise<ReturnType<typeof finalizeEvent>>;
+ }>;
+ const schedulers: ReturnType<typeof createPublicScheduler>[] = [];
+ let current = true;
+ async function preference(peer: boolean) {
+ f.mode(peer ? 'wrong_author' : 'normal');
+ const signed = await provider.signEvent({
+ kind: 10050,
+ created_at: 100,
+ tags: [['relay', peer ? peerOrigin : archiveOrigin]],
+ content: ''
+ });
+ f.mode('normal');
+ return {
+ id: signed.id,
+ pubkey: signed.pubkey,
+ sig: signed.sig,
+ kind: signed.kind,
+ created_at: signed.created_at,
+ tags: signed.tags,
+ content: signed.content
+ };
+ }
+ const ownEvent = await preference(false),
+ peerEvent = await preference(true);
+ function resolve(event: typeof ownEvent) {
+ 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(ownEvent),
+ other = resolve(peerEvent),
+ plan = createInboxRoutePlan(policy, f.owner, f.peer, own, other);
+ if (!plan) {
+ f.close();
+ throw Error('missing genuine route plan');
+ }
+ async function distinctIntent() {
+ const repository = createPrivateSendReservationRepository(
+ f.database,
+ f.owner
+ );
+ const observed = Date.now(),
+ realNow = Date.now;
+ Date.now = () => observed;
+ try {
+ const rumor = f.textPlan(f.marker);
+ if (!repository || !rumor) throw Error('missing distinct intent fixture');
+ const result = await reserveSendIdentity(
+ repository,
+ f.identity,
+ '22345678-1234-4234-8234-123456789abc',
+ rumor,
+ 'reviewed_private_intent'
+ );
+ return {
+ status: result.status,
+ identity: 'identity' in result ? result.identity : undefined,
+ id:
+ 'identity' in result
+ ? reservedSendSnapshot(result.identity)?.id
+ : undefined
+ };
+ } finally {
+ Date.now = realNow;
+ }
+ }
+ async function changePairRevision() {
+ const identity = reservedSendSnapshot(f.reserved);
+ if (!identity) throw Error('missing original fixture command');
+ const loaded = await loadPrivateRecord(
+ f.repository,
+ 'private_sends',
+ identity.id
+ );
+ const row =
+ loaded.ok && privateRecordSnapshot(loaded.value, f.owner, identity.id);
+ if (!row || row.family !== 'private_send_operation' || !row.deliveryPlan)
+ throw Error('missing original pair');
+ const wire = JSON.stringify({ ...row, revision: row.revision + 1 });
+ if (!decodePrivateRecord(wire, f.owner, identity.id).ok)
+ throw Error('invalid competing fixture row');
+ const tx = browserDatabaseTransaction(
+ f.database,
+ ['private_sends'],
+ 'readwrite'
+ );
+ tx.objectStore('private_sends').put({
+ owner: f.owner,
+ id: identity.id,
+ wire
+ });
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('competing fixture write aborted'))
+ );
+ });
+ }
+ async function storedPair() {
+ const identity = reservedSendSnapshot(f.reserved);
+ if (!identity) return undefined;
+ const loaded = await loadPrivateRecord(
+ f.repository,
+ 'private_sends',
+ identity.id
+ );
+ const row =
+ loaded.ok && privateRecordSnapshot(loaded.value, f.owner, identity.id);
+ return row && row.family === 'private_send_operation' ? row : undefined;
+ }
+ return {
+ ...f,
+ context: { policy, own, other, plan },
+ distinctIntent,
+ changePairRevision,
+ storedPair,
+ staleRoutes() {
+ current = false;
+ },
+ close() {
+ for (const scheduler of schedulers) closePublicScheduler(scheduler);
+ f.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/paired-delivery.spec.ts b/web/tests/e2e/paired-delivery.spec.ts
@@ -0,0 +1,583 @@
+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 Pair from './harness/paired-delivery.ts';
+declare global {
+ interface Window {
+ hcp082: typeof Pair;
+ hcp082Fixture: Awaited<ReturnType<typeof Pair.makeFixture>>;
+ }
+}
+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/paired-delivery.ts', import.meta.url)
+ ),
+ name: 'hcp082',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(built) ? built[0] : built;
+ if (!('output' in output)) throw Error('missing pair bundle');
+ const chunks = output.output.filter((entry) => entry.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+ console.log(
+ JSON.stringify({
+ fixture: 'HCP082_REAL_PAIRED_IDB_PLAN',
+ bundleSha256: createHash('sha256').update(bundle).digest('hex'),
+ moduleIds: Object.keys(chunks[0].modules),
+ qualification:
+ 'Source-only actual SDK/IDB/WebLocks; controlled public preference observations, no operator Q'
+ })
+ );
+});
+test.afterAll(async () => server.close());
+async function load(page: Page) {
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async () => {
+ window.hcp082Fixture = await window.hcp082.makeFixture();
+ });
+}
+
+test('no paired permission before self acknowledgement; complete artifacts and frozen routes commit before local readiness', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ const before = f.counts(),
+ refused = await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ ),
+ inert = JSON.stringify(before) === JSON.stringify(f.counts());
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const self = await f.stored(),
+ prepared = await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ ),
+ token = s.preparedPairedDelivery(f.preparation),
+ row = token && s.pairedDeliveryAcknowledgementSnapshot(token),
+ raw = await f.stored();
+ return {
+ refused: refused.status,
+ inert,
+ prepared: prepared.status,
+ ack: !!row,
+ state: row?.deliveryPlan.state,
+ roles: row && [
+ row.deliveryPlan.routes.peer.role,
+ row.deliveryPlan.routes.archive.role
+ ],
+ sameRumor:
+ row?.rumorHash ===
+ s.selfRecoveryAcknowledgementSnapshot(
+ s.preparedSelfRecovery(f.preparation)!
+ )?.rumorHash,
+ twoArtifacts: !!row?.self.wire && !!row.peerArtifact.wire,
+ changed: raw !== self,
+ plaintext:
+ raw.includes(f.marker) ||
+ (await f.publicDraftRows()).includes(f.marker)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ refused: 'self_required',
+ inert: true,
+ prepared: 'prepared',
+ ack: true,
+ state: 'prepared',
+ roles: ['peer', 'self_archive'],
+ sameRumor: true,
+ twoArtifacts: true,
+ changed: true,
+ plaintext: false
+ });
+});
+test('same paired command retry keeps both exact wires and routes without more SDK work', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ const token = s.preparedPairedDelivery(f.preparation),
+ before = f.counts(),
+ bytes = await f.stored(),
+ again = await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ return {
+ status: again.status,
+ same: token === s.preparedPairedDelivery(f.preparation),
+ bytes: bytes === (await f.stored()),
+ counts: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'prepared',
+ same: true,
+ bytes: true,
+ counts: true
+ });
+});
+test('genuine paired acknowledgement cannot reconcile arbitrary structurally valid stored advancement', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ await f.changePairRevision();
+ const changed = await f.stored(),
+ before = f.counts(),
+ self = await s.prepareSelfRecovery(
+ f.preparation,
+ 'reviewed_self_recovery'
+ ),
+ pair = await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ return {
+ self: self.status,
+ pair: pair.status,
+ selfAck: !!s.preparedSelfRecovery(f.preparation),
+ pairAck: !!s.preparedPairedDelivery(f.preparation),
+ preserved: changed === (await f.stored()),
+ counts: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ self: 'conflict',
+ pair: 'self_required',
+ selfAck: false,
+ pairAck: false,
+ preserved: true,
+ counts: true
+ });
+});
+for (const fault of ['abort', 'unknown'] as const)
+ test(
+ 'actual ' + fault + ' pair write preserves truthful atomic acknowledgement',
+ async ({ page }) => {
+ await load(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const old = await f.stored(),
+ hits = f.fault(mode),
+ result = await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ ),
+ receipt = s.preparedPairedDelivery(f.preparation),
+ stored = await f.stored();
+ return {
+ status: result.status,
+ hits: hits(),
+ ack: !!receipt,
+ unchanged: old === stored,
+ plaintext: stored.includes(f.marker)
+ };
+ } finally {
+ f.close();
+ }
+ }, fault);
+ expect(result).toEqual(
+ fault === 'abort'
+ ? {
+ status: 'aborted',
+ hits: 1,
+ ack: false,
+ unchanged: true,
+ plaintext: false
+ }
+ : {
+ status: 'reconciled',
+ hits: 1,
+ ack: true,
+ unchanged: false,
+ plaintext: false
+ }
+ );
+ }
+ );
+test('peer interruption after actual encryption entry leaves only acknowledged self recovery ciphertext', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const bytes = await f.stored();
+ f.mode('hold_encrypt');
+ const pending = s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ let entered = false;
+ for (let i = 0; i < 1800; i++) {
+ if (f.pendingEncryption()) {
+ entered = true;
+ break;
+ }
+ await new Promise((resolve) => setTimeout(resolve, 50));
+ }
+ if (!entered) throw Error('peer encryption did not enter');
+ f.disconnect();
+ f.settle();
+ const result = await pending;
+ return {
+ status: result.status,
+ ack: !!s.preparedPairedDelivery(f.preparation),
+ unchanged: bytes === (await f.stored())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({ status: 'stopped', ack: false, unchanged: true });
+});
+test('changed route ownership after actual peer crypto blocks pair commit and preserves self', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const bytes = await f.stored();
+ f.mode('hold_encrypt');
+ const pending = s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ let entered = false;
+ for (let i = 0; i < 1800; i++) {
+ if (f.pendingEncryption()) {
+ entered = true;
+ break;
+ }
+ await new Promise((resolve) => setTimeout(resolve, 50));
+ }
+ if (!entered) throw Error('peer encryption did not enter');
+ f.staleRoutes();
+ f.settle();
+ const result = await pending;
+ return {
+ status: result.status,
+ ack: !!s.preparedPairedDelivery(f.preparation),
+ unchanged: bytes === (await f.stored())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ status: 'review_required',
+ ack: false,
+ unchanged: true
+ });
+});
+test('different genuine peer ciphertext for the same committed command conflicts without overwriting either artifact', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const self = s.preparedSelfRecovery(f.preparation)!;
+ await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ const old = await f.stored(),
+ peer = await f.peerProof();
+ if (!peer) throw Error('missing competing genuine peer proof');
+ const changed = await s.commitPairedDelivery(
+ f.repository,
+ f.identity,
+ f.reserved,
+ self,
+ peer,
+ f.context.plan,
+ 'reviewed_pair_commit'
+ );
+ return { status: changed.status, unchanged: old === (await f.stored()) };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({ status: 'conflict', unchanged: true });
+});
+test('stored route metadata rejects unknown plaintext and missing paired artifacts instead of fabricating readiness', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ const token = s.preparedPairedDelivery(f.preparation)!,
+ row = s.pairedDeliveryAcknowledgementSnapshot(token)!;
+ const raw = {
+ schema: 1,
+ family: 'private_send_operation',
+ owner: row.owner,
+ id: row.id,
+ revision: row.revision,
+ peer: row.peer,
+ rumorHash: row.rumorHash,
+ createdAt: row.createdAt,
+ self: row.self,
+ peerArtifact: row.peerArtifact,
+ deliveryPlan: row.deliveryPlan
+ };
+ return {
+ valid: s.decodePrivateRecord(JSON.stringify(raw), row.owner, row.id).ok,
+ unknown: s.decodePrivateRecord(
+ JSON.stringify({
+ ...raw,
+ deliveryPlan: { ...raw.deliveryPlan, body: f.marker }
+ }),
+ row.owner,
+ row.id
+ ).ok,
+ missing: s.decodePrivateRecord(
+ JSON.stringify({ ...raw, peerArtifact: null }),
+ row.owner,
+ row.id
+ ).ok
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({ valid: true, unknown: false, missing: false });
+});
+test('distinct intentional identical text is not collapsed into the prior paired command', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const self = s.preparedSelfRecovery(f.preparation)!;
+ await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ const peer = await f.peerProof(),
+ intent = await f.distinctIntent();
+ if (!peer) throw Error('missing genuine prior peer');
+ const before = await f.stored();
+ const refused = intent.identity
+ ? await s.commitPairedDelivery(
+ f.repository,
+ f.identity,
+ intent.identity,
+ self,
+ peer,
+ f.context.plan,
+ 'reviewed_pair_commit'
+ )
+ : undefined;
+ return {
+ safe:
+ intent.status === 'clock_conflict' ||
+ (intent.status === 'reserved' &&
+ intent.id !== s.selfRecoveryAcknowledgementSnapshot(self)?.id),
+ refused: !intent.identity || refused?.status === 'invalid',
+ unchanged: before === (await f.stored())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({ safe: true, refused: true, unchanged: true });
+});
+test('concurrent genuine paired commits from the same self-only base produce one exact durable winner and one conflict', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const self = s.preparedSelfRecovery(f.preparation)!,
+ left = await f.peerProof(),
+ right = await f.peerProof();
+ if (!left || !right) throw Error('missing genuine competing peer proofs');
+ const a = s.verifiedOutboundSnapshot(left),
+ b = s.verifiedOutboundSnapshot(right);
+ if (!a || !b || a.wire === b.wire)
+ throw Error('competing wrappers were not distinct');
+ const outcomes = await Promise.all([
+ s.commitPairedDelivery(
+ f.repository,
+ f.identity,
+ f.reserved,
+ self,
+ left,
+ f.context.plan,
+ 'reviewed_pair_commit'
+ ),
+ s.commitPairedDelivery(
+ f.repository,
+ f.identity,
+ f.reserved,
+ self,
+ right,
+ f.context.plan,
+ 'reviewed_pair_commit'
+ )
+ ]);
+ const winner = outcomes.find((value) => 'receipt' in value);
+ if (!winner || !('receipt' in winner))
+ throw Error('missing actual acknowledged winner');
+ const expected = winner === outcomes[0] ? a : b,
+ ack = s.pairedDeliveryAcknowledgementSnapshot(winner.receipt),
+ stored = await f.storedPair(),
+ original = s.selfRecoveryAcknowledgementSnapshot(self),
+ wire = await f.stored();
+ return {
+ statuses: outcomes.map((value) => value.status).sort(),
+ oneReceipt: outcomes.filter((value) => 'receipt' in value).length === 1,
+ peer:
+ stored?.peerArtifact?.wire === expected.wire &&
+ ack?.peerArtifact.wire === expected.wire,
+ self: stored?.self.wire === original?.self.wire,
+ routes:
+ JSON.stringify(stored?.deliveryPlan?.routes) ===
+ JSON.stringify(s.inboxRoutePlanSnapshot(f.context.plan)),
+ revision: stored?.revision === ack?.revision,
+ plaintext: wire.includes(f.marker)
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ statuses: ['conflict', 'prepared'],
+ oneReceipt: true,
+ peer: true,
+ self: true,
+ routes: true,
+ revision: true,
+ plaintext: false
+ });
+});
+test('explicit self then pair retry after pair commit retains genuine successor evidence and exact ciphertext', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp082Fixture,
+ s = window.hcp082;
+ try {
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const self = s.preparedSelfRecovery(f.preparation);
+ await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ const token = s.preparedPairedDelivery(f.preparation),
+ bytes = await f.stored(),
+ before = f.counts(),
+ selfAgain = await s.prepareSelfRecovery(
+ f.preparation,
+ 'reviewed_self_recovery'
+ ),
+ pairAgain = await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ return {
+ self: selfAgain.status,
+ pair: pairAgain.status,
+ sameSelf: self === s.preparedSelfRecovery(f.preparation),
+ samePair: token === s.preparedPairedDelivery(f.preparation),
+ bytes: bytes === (await f.stored()),
+ counts: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(result).toEqual({
+ self: 'saved',
+ pair: 'prepared',
+ sameSelf: true,
+ samePair: true,
+ bytes: true,
+ counts: true
+ });
+});
diff --git a/web/tests/unit/paired-delivery.test.ts b/web/tests/unit/paired-delivery.test.ts
@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import type { SelfRecoveryPreparation } from '../../src/lib/messaging/prepare-send.ts';
+import {
+ preparePairedDelivery,
+ preparedPairedDelivery
+} from '../../src/lib/messaging/prepare-send.ts';
+import {
+ pairedDeliveryAcknowledgementSnapshot,
+ type PairedDeliveryAcknowledgement
+} from '../../src/lib/persistence/private-sends.ts';
+import type { PairedDeliveryContext } from '../../src/lib/messaging/prepare-send.ts';
+
+describe('paired delivery is acknowledged local evidence only', () => {
+ it('SSR forged preparation cannot perform crypto, persistence or acquire a ready receipt', async () => {
+ const token = {} as SelfRecoveryPreparation;
+ expect(
+ await preparePairedDelivery(
+ token,
+ {} as PairedDeliveryContext,
+ 'reviewed_pair_preparation'
+ )
+ ).toEqual({ status: 'invalid' });
+ expect(preparedPairedDelivery(token)).toBeUndefined();
+ });
+ it('a detached paired receipt grants no local acknowledgement', () => {
+ expect(
+ pairedDeliveryAcknowledgementSnapshot({} as PairedDeliveryAcknowledgement)
+ ).toBeUndefined();
+ });
+ it('unreviewed input is inert without coercion', async () => {
+ let calls = 0;
+ const review = {
+ toString() {
+ calls++;
+ return 'reviewed_pair_preparation';
+ }
+ };
+ expect(
+ await preparePairedDelivery(
+ {} as SelfRecoveryPreparation,
+ {} as PairedDeliveryContext,
+ review
+ )
+ ).toEqual({ status: 'invalid' });
+ expect(calls).toBe(0);
+ });
+});