commit 8eae342fb993bce86c9188f012214aadbd054c57
parent c434293440106d19b73e8b8705f5a945602713b2
Author: triesap <tyson@radroots.org>
Date: Fri, 9 Oct 2026 00:15:58 +0000
test: add pre-effect interruption and unsaved-text fixtures (HCP-084)
- Keep private composer input in bounded owner-session memory
- Bind encrypted acknowledgement to the exact captured text revision
- Warn on dirty navigation and preserve uncertain preparation
- Verify real browser interruption and committed ciphertext boundaries
Diffstat:
7 files changed, 1404 insertions(+), 24 deletions(-)
diff --git a/web/src/lib/config/budgets.ts b/web/src/lib/config/budgets.ts
@@ -10,6 +10,7 @@ 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({
+ bodyBytes: 4096,
rumorBytes: 8192,
sealBytes: 16384,
requestedPerRelay: 200,
diff --git a/web/src/lib/messaging/composer-state.ts b/web/src/lib/messaging/composer-state.ts
@@ -0,0 +1,328 @@
+import {
+ identityMessagingOwnership,
+ subscribeIdentityInvalidation,
+ type IdentitySession
+} from '../runtime/identity-session.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
+import { buildEnquiryMessage, type EnquiryContext } from './enquiry-context.ts';
+import {
+ reservedSendSnapshot,
+ reservedSendRumorWire,
+ type ReservedSendIdentity
+} from './send-identity.ts';
+import {
+ selfRecoveryPreparationSnapshot,
+ preparedSelfRecovery,
+ stopSelfRecoveryPreparation,
+ type SelfRecoveryPreparation
+} from './prepare-send.ts';
+import {
+ selfRecoveryAcknowledgementSnapshot,
+ type SelfRecoveryAcknowledgement
+} from '../persistence/private-sends.ts';
+
+declare const composerBrand: unique symbol;
+export type PrivateComposer = Readonly<{ [composerBrand]: true }>;
+type TextState =
+ | 'empty'
+ | 'unsaved'
+ | 'preparing'
+ | 'saved_encrypted'
+ | 'unknown_completion'
+ | 'needs_action';
+type Snapshot = Readonly<{
+ revision: number;
+ dirty: boolean;
+ busy: boolean;
+ state: TextState;
+ pairState:
+ | 'unprepared'
+ | 'preparing'
+ | 'prepared'
+ | 'unknown_completion'
+ | 'needs_action';
+ copy: string;
+ pairCopy: string;
+}>;
+type Controller = {
+ text(): string | undefined;
+ update(text: unknown, review: unknown): boolean;
+ snapshot(): Snapshot | undefined;
+ bind(
+ reserved: ReservedSendIdentity,
+ preparation: SelfRecoveryPreparation,
+ enquiry: EnquiryContext | undefined,
+ review: unknown
+ ): boolean;
+ discard(revision: unknown, review: unknown): boolean;
+ close(): void;
+};
+const composers = new WeakMap<PrivateComposer, Controller>();
+
+// Private input is memory only. The controller has no storage, URL, logging,
+// public-draft, signer or transport sink. Canonical message admission and all
+// effects remain owned by the existing genuine intent/preparation workflow.
+export function createPrivateComposer(
+ session: IdentitySession,
+ review: unknown
+): PrivateComposer | undefined {
+ if (typeof window === 'undefined' || review !== 'reviewed_private_composer')
+ return undefined;
+ const ownership = identityMessagingOwnership(session);
+ if (!ownership?.current()) return undefined;
+ let active = true,
+ body = '',
+ revision = 0,
+ unsubscribe = () => {};
+ type Binding = {
+ revision: number;
+ preparation: SelfRecoveryPreparation;
+ owner: string;
+ command: string;
+ peer: string;
+ rumorHash: string;
+ createdAt: number;
+ };
+ let binding: Binding | undefined;
+ let lastState: ReturnType<typeof selfRecoveryPreparationSnapshot>;
+ let acknowledgement: SelfRecoveryAcknowledgement | undefined;
+ function close() {
+ if (!active) return;
+ active = false;
+ body = '';
+ if (binding) stopSelfRecoveryPreparation(binding.preparation);
+ binding = undefined;
+ lastState = undefined;
+ acknowledgement = undefined;
+ unsubscribe();
+ unsubscribe = () => {};
+ }
+ function current() {
+ if (!active || !ownership?.current()) {
+ close();
+ return false;
+ }
+ return true;
+ }
+ function observe() {
+ if (!binding) return undefined;
+ const workflow = selfRecoveryPreparationSnapshot(binding.preparation);
+ if (
+ workflow?.owner !== binding.owner ||
+ workflow.command !== binding.command
+ )
+ return undefined;
+ lastState = workflow;
+ return workflow;
+ }
+ function acknowledged() {
+ if (!binding) return false;
+ const workflow = selfRecoveryPreparationSnapshot(binding.preparation);
+ const actual = preparedSelfRecovery(binding.preparation);
+ // A genuine historical local fact may survive crypto retirement. A live
+ // controller explicitly losing its acknowledgement must not hide that loss.
+ if (workflow && !actual) acknowledgement = undefined;
+ const receipt = actual ?? acknowledgement,
+ saved = receipt && selfRecoveryAcknowledgementSnapshot(receipt);
+ const matches =
+ !!saved &&
+ saved.owner === binding.owner &&
+ saved.id === binding.command &&
+ saved.peer === binding.peer &&
+ saved.rumorHash === binding.rumorHash &&
+ saved.createdAt === binding.createdAt;
+ if (matches) acknowledgement = receipt;
+ return matches;
+ }
+ function snapshot(): Snapshot | undefined {
+ if (!current()) return undefined;
+ const currentWorkflow = observe(),
+ workflow =
+ currentWorkflow ??
+ (lastState
+ ? {
+ ...lastState,
+ state:
+ lastState.state === 'unknown_completion'
+ ? 'unknown_completion'
+ : 'needs_action',
+ busy: false
+ }
+ : undefined),
+ exact = binding?.revision === revision,
+ saved = exact && acknowledged(),
+ dirty = body.length > 0 && !saved;
+ const state: TextState =
+ body.length === 0
+ ? 'empty'
+ : saved
+ ? 'saved_encrypted'
+ : !exact
+ ? 'unsaved'
+ : workflow?.state === 'unknown_completion'
+ ? 'unknown_completion'
+ : workflow?.state === 'preparing'
+ ? 'preparing'
+ : workflow?.state === 'needs_action' || !workflow
+ ? 'needs_action'
+ : 'unsaved';
+ return {
+ revision,
+ dirty,
+ busy: currentWorkflow?.busy ?? false,
+ state,
+ pairState: workflow?.pairState ?? 'unprepared',
+ copy:
+ state === 'saved_encrypted'
+ ? 'Saved encrypted in this browser'
+ : state === 'unknown_completion'
+ ? 'Encrypted save could not be confirmed. Keep this text and review the existing preparation.'
+ : state === 'preparing'
+ ? 'Private text is unsaved memory while encryption is preparing.'
+ : state === 'needs_action'
+ ? 'Private text has no acknowledged encrypted save in this browser. Keep editing or review preparation.'
+ : state === 'empty'
+ ? 'Private text stays in memory until encrypted capture.'
+ : 'Private text is unsaved memory.',
+ pairCopy:
+ workflow?.pairCopy ?? 'No paired delivery preparation is acknowledged.'
+ };
+ }
+ function update(text: unknown, reviewed: unknown) {
+ if (
+ reviewed !== 'reviewed_private_text' ||
+ !current() ||
+ typeof text !== 'string' ||
+ !boundedUtf8(text, PRIVATE_TRANSPORT_BUDGETS.bodyBytes)
+ )
+ return false;
+ if (body !== text) {
+ body = text;
+ revision++;
+ }
+ return true;
+ }
+ function bind(
+ reserved: ReservedSendIdentity,
+ preparation: SelfRecoveryPreparation,
+ enquiry: EnquiryContext | undefined,
+ reviewed: unknown
+ ) {
+ if (reviewed !== 'reviewed_composer_preparation' || !current())
+ return false;
+ const previous = observe();
+ if (
+ (binding && !previous) ||
+ previous?.busy ||
+ previous?.state === 'unknown_completion' ||
+ previous?.pairState === 'unknown_completion'
+ )
+ return false;
+ const identity = reservedSendSnapshot(reserved),
+ wire = reservedSendRumorWire(reserved),
+ workflow = selfRecoveryPreparationSnapshot(preparation);
+ if (
+ !identity ||
+ !wire ||
+ !workflow ||
+ identity.owner !== ownership?.owner ||
+ workflow.owner !== identity.owner ||
+ workflow.command !== identity.id
+ )
+ return false;
+ // This wire is available only from the genuine current reserved identity;
+ // no caller-provided body/hash can substitute for its canonical rumor.
+ let content: unknown;
+ try {
+ content = (JSON.parse(wire) as { content: unknown }).content;
+ } catch {
+ return false;
+ }
+ const expected =
+ enquiry === undefined
+ ? body
+ : buildEnquiryMessage(enquiry, body)?.content;
+ if (typeof expected !== 'string' || content !== expected) return false;
+ if (
+ binding &&
+ (binding.command !== identity.id || binding.preparation !== preparation)
+ )
+ stopSelfRecoveryPreparation(binding.preparation);
+ binding = {
+ revision,
+ preparation,
+ owner: identity.owner,
+ command: identity.id,
+ peer: identity.peer,
+ rumorHash: identity.rumorHash,
+ createdAt: identity.createdAt
+ };
+ lastState = undefined;
+ acknowledgement = undefined;
+ return true;
+ }
+ function discard(expectedRevision: unknown, reviewed: unknown) {
+ if (
+ reviewed !== 'reviewed_discard_private_text' ||
+ !current() ||
+ expectedRevision !== revision
+ )
+ return false;
+ // Retirement revokes continuations, but the shared SDK scheduler retains
+ // an unsettled extension job until the actual promise completes.
+ if (binding) stopSelfRecoveryPreparation(binding.preparation);
+ binding = undefined;
+ lastState = undefined;
+ acknowledgement = undefined;
+ body = '';
+ revision++;
+ return true;
+ }
+ const token = Object.freeze({}) as PrivateComposer;
+ composers.set(token, {
+ text: () => (current() ? body : undefined),
+ update,
+ snapshot,
+ bind,
+ discard,
+ close
+ });
+ unsubscribe = subscribeIdentityInvalidation(session, close);
+ return current() ? token : undefined;
+}
+export function updatePrivateComposerText(
+ token: PrivateComposer,
+ text: unknown,
+ review: unknown
+) {
+ return composers.get(token)?.update(text, review) ?? false;
+}
+export function privateComposerText(token: PrivateComposer) {
+ return composers.get(token)?.text();
+}
+export function privateComposerSnapshot(token: PrivateComposer) {
+ return composers.get(token)?.snapshot();
+}
+export function bindPrivateComposerPreparation(
+ token: PrivateComposer,
+ reserved: ReservedSendIdentity,
+ preparation: SelfRecoveryPreparation,
+ enquiry: EnquiryContext | undefined,
+ review: unknown
+) {
+ return (
+ composers.get(token)?.bind(reserved, preparation, enquiry, review) ?? false
+ );
+}
+export function discardPrivateComposer(
+ token: PrivateComposer,
+ revision: unknown,
+ review: unknown
+) {
+ return composers.get(token)?.discard(revision, review) ?? false;
+}
+export function closePrivateComposer(token: PrivateComposer) {
+ composers.get(token)?.close();
+ composers.delete(token);
+}
diff --git a/web/src/lib/messaging/prepare-send.ts b/web/src/lib/messaging/prepare-send.ts
@@ -71,12 +71,20 @@ export type PairedDeliveryPreparationResult = Readonly<{
}>;
type Phase =
'unsaved' | 'preparing' | 'saved' | 'unknown_completion' | 'needs_action';
+type PairPhase =
+ | 'unprepared'
+ | 'preparing'
+ | 'prepared'
+ | 'unknown_completion'
+ | 'needs_action';
type Snapshot = Readonly<{
state: Phase;
busy: boolean;
owner: string;
command: string;
copy: string;
+ pairState: PairPhase;
+ pairCopy: string;
}>;
type Controller = {
run(review: unknown): Promise<SelfRecoveryPreparationResult>;
@@ -127,6 +135,7 @@ export function captureSelfRecoveryPreparation(
generation = 0,
busy = false,
phase: Phase = 'unsaved',
+ pairPhase: PairPhase = 'unprepared',
acknowledgement: SelfRecoveryAcknowledgement | undefined,
pairedAcknowledgement: PairedDeliveryAcknowledgement | undefined,
unsubscribe = () => {};
@@ -172,6 +181,17 @@ export function captureSelfRecoveryPreparation(
busy,
owner: record.owner,
command: record.id,
+ pairState: pairPhase,
+ pairCopy:
+ pairPhase === 'prepared'
+ ? 'Both encrypted artifacts and their delivery plan are saved locally. No recipient delivery is claimed.'
+ : pairPhase === 'unknown_completion'
+ ? 'Paired encrypted preparation could not be confirmed. Review the existing preparation before continuing.'
+ : pairPhase === 'preparing'
+ ? 'Preparing the missing peer envelope. No recipient delivery is claimed.'
+ : pairPhase === 'needs_action'
+ ? 'Paired delivery preparation needs review. The acknowledged self copy is a local recovery fact only.'
+ : 'No paired delivery preparation is acknowledged.',
copy:
phase === 'saved' && receipt()
? 'Saved encrypted in this browser'
@@ -350,6 +370,22 @@ export function captureSelfRecoveryPreparation(
if (!self) return { status: 'self_required' };
busy = true;
const attempt = generation;
+ function finishPair(
+ result: PairedDeliveryPreparationResult
+ ): PairedDeliveryPreparationResult {
+ if (current() && attempt === generation)
+ pairPhase =
+ result.status === 'unknown_completion'
+ ? 'unknown_completion'
+ : (result.status === 'prepared' ||
+ result.status === 'existing' ||
+ result.status === 'reconciled') &&
+ pairedAcknowledgement &&
+ pairedDeliveryAcknowledgementSnapshot(pairedAcknowledgement)
+ ? 'prepared'
+ : 'needs_action';
+ return result;
+ }
try {
const { plan, policy, own, other } = context,
routes = inboxRoutePlanSnapshot(plan);
@@ -358,51 +394,55 @@ export function captureSelfRecoveryPreparation(
routes.peer.author !== record.peer ||
routes.archive.author !== record.owner
)
- return { status: 'invalid' };
+ return finishPair({ 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 (!routesCurrent()) return finishPair({ status: 'review_required' });
+ if (!admitted()) return finishPair({ status: 'stopped' });
if (pairedAcknowledgement) {
const valid = await verifyPairedDeliveryAcknowledgement(
repository,
pairedAcknowledgement
);
- if (!admitted()) return { status: 'stopped' };
- if (!routesCurrent()) return { status: 'review_required' };
+ if (!admitted()) return finishPair({ status: 'stopped' });
+ if (!routesCurrent()) return finishPair({ status: 'review_required' });
const saved = pairedDeliveryAcknowledgementSnapshot(
pairedAcknowledgement
);
- return valid &&
- saved &&
- JSON.stringify(saved.deliveryPlan.routes) === routeWire
- ? { status: 'prepared' }
- : { status: 'conflict' };
+ return finishPair(
+ 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' };
+ if (!admitted()) return finishPair({ status: 'stopped' });
+ if (!routesCurrent()) return finishPair({ status: 'review_required' });
+ if (!admitted()) return finishPair({ status: 'stopped' });
+ if (!durableSelf) return finishPair({ status: 'conflict' });
phase = 'preparing';
+ pairPhase = '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 };
+ if (!admitted()) return finishPair({ status: 'stopped' });
+ if (!routesCurrent()) return finishPair({ status: 'review_required' });
+ if (!admitted()) return finishPair({ status: 'stopped' });
+ if (prepared.status !== 'complete')
+ return finishPair({ status: prepared.status });
const proof = preparedEnvelopeProof(pair, 'peer');
- if (!proof) return { status: 'mismatch' };
+ if (!proof) return finishPair({ status: 'mismatch' });
const saved = await navigator.locks.request(
'harvestcircle:owner:' + record.owner,
{ mode: 'exclusive', ifAvailable: true },
@@ -421,14 +461,14 @@ export function captureSelfRecoveryPreparation(
);
}
);
- if (!admitted()) return { status: 'stopped' };
- if (!routesCurrent()) return { status: 'review_required' };
- if (!admitted()) return { status: 'stopped' };
+ if (!admitted()) return finishPair({ status: 'stopped' });
+ if (!routesCurrent()) return finishPair({ status: 'review_required' });
+ if (!admitted()) return finishPair({ status: 'stopped' });
if ('receipt' in saved) pairedAcknowledgement = saved.receipt;
phase = 'saved';
- return { status: saved.status };
+ return finishPair({ status: saved.status });
} catch {
- return { status: current() ? 'unavailable' : 'stopped' };
+ return finishPair({ status: current() ? 'unavailable' : 'stopped' });
} finally {
busy = false;
if (current()) phase = 'saved';
diff --git a/web/src/lib/runtime/dirty-navigation.ts b/web/src/lib/runtime/dirty-navigation.ts
@@ -0,0 +1,115 @@
+import {
+ privateComposerSnapshot,
+ discardPrivateComposer,
+ type PrivateComposer
+} from '../messaging/composer-state.ts';
+declare const navigationBrand: unique symbol;
+export type DirtyNavigation = Readonly<{ [navigationBrand]: true }>;
+type Result =
+ 'allowed' | 'confirmation_required' | 'review_required' | 'invalid';
+type Controller = {
+ request(): Result;
+ discard(review: unknown): Result;
+ keep(): boolean;
+ snapshot():
+ | Readonly<{
+ state: 'idle' | 'confirmation_required';
+ copy: string;
+ defaultAction: 'Keep editing';
+ discardAction: 'Discard draft';
+ }>
+ | undefined;
+ dirty(): boolean;
+};
+const navigations = new WeakMap<DirtyNavigation, Controller>();
+// Shared route interception contract, with no URL/body/persistence/effect sink.
+// Same-page validation and gates do not call this close contract. Mounted
+// consumers own focus return and inline controls; native unload uses its own
+// browser-provided confirmation, never an asynchronous save attempt.
+export function captureDirtyNavigation(
+ composer: PrivateComposer
+): DirtyNavigation | undefined {
+ if (typeof window === 'undefined' || !privateComposerSnapshot(composer))
+ return undefined;
+ let requestedRevision: number | undefined;
+ function request(): Result {
+ const value = privateComposerSnapshot(composer);
+ if (!value) return 'invalid';
+ if (!value.dirty) {
+ requestedRevision = undefined;
+ return 'allowed';
+ }
+ requestedRevision = value.revision;
+ return 'confirmation_required';
+ }
+ function discard(review: unknown): Result {
+ if (
+ review !== 'reviewed_discard_private_text' ||
+ requestedRevision === undefined
+ )
+ return 'invalid';
+ const value = privateComposerSnapshot(composer),
+ revision = requestedRevision;
+ requestedRevision = undefined;
+ if (!value) return 'invalid';
+ if (value.revision !== revision) return 'review_required';
+ return discardPrivateComposer(composer, revision, review)
+ ? 'allowed'
+ : 'invalid';
+ }
+ function keep() {
+ if (!privateComposerSnapshot(composer)) return false;
+ requestedRevision = undefined;
+ return true;
+ }
+ function snapshot() {
+ if (!privateComposerSnapshot(composer)) return undefined;
+ return {
+ state:
+ requestedRevision === undefined
+ ? ('idle' as const)
+ : ('confirmation_required' as const),
+ copy:
+ requestedRevision === undefined
+ ? ''
+ : 'Discard unsaved private text? Keep editing to preserve it. An outstanding extension call remains pending until it settles.',
+ defaultAction: 'Keep editing' as const,
+ discardAction: 'Discard draft' as const
+ };
+ }
+ const token = Object.freeze({}) as DirtyNavigation;
+ navigations.set(token, {
+ request,
+ discard,
+ keep,
+ snapshot,
+ dirty: () => privateComposerSnapshot(composer)?.dirty ?? false
+ });
+ return token;
+}
+export function requestPrivateNavigation(token: DirtyNavigation) {
+ return navigations.get(token)?.request() ?? 'invalid';
+}
+export function confirmDiscardNavigation(
+ token: DirtyNavigation,
+ review: unknown
+) {
+ return navigations.get(token)?.discard(review) ?? 'invalid';
+}
+export function keepPrivateEditing(token: DirtyNavigation) {
+ return navigations.get(token)?.keep() ?? false;
+}
+export function dirtyNavigationSnapshot(token: DirtyNavigation) {
+ return navigations.get(token)?.snapshot();
+}
+export function privateNavigationBeforeUnload(
+ token: DirtyNavigation,
+ event: BeforeUnloadEvent
+): boolean {
+ const controller = navigations.get(token);
+ if (typeof window === 'undefined' || !controller?.dirty()) return false;
+ event.preventDefault();
+ // The mounted consumer owns event registration and legacy returnValue.
+ // This contract never receives or emits the private body or a destination.
+ return true;
+}
diff --git a/web/tests/e2e/harness/private-preparation.ts b/web/tests/e2e/harness/private-preparation.ts
@@ -0,0 +1,226 @@
+import { makeFixture as makePairedFixture } from './paired-delivery.ts';
+import { reservedSendRumorWire } from '../../../src/lib/messaging/send-identity.ts';
+import { disconnectIdentity } from '../../../src/lib/runtime/identity-session.ts';
+import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts';
+import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts';
+import type { EventTemplate, finalizeEvent } from 'applesauce-core/helpers';
+import {
+ createPrivateComposer,
+ updatePrivateComposerText,
+ privateComposerText,
+ privateComposerSnapshot,
+ bindPrivateComposerPreparation,
+ closePrivateComposer
+} from '../../../src/lib/messaging/composer-state.ts';
+import {
+ captureDirtyNavigation,
+ requestPrivateNavigation,
+ confirmDiscardNavigation,
+ keepPrivateEditing,
+ dirtyNavigationSnapshot,
+ privateNavigationBeforeUnload,
+ type DirtyNavigation
+} from '../../../src/lib/runtime/dirty-navigation.ts';
+import {
+ prepareSelfRecovery,
+ preparePairedDelivery,
+ selfRecoveryPreparationSnapshot,
+ preparedSelfRecovery,
+ captureSelfRecoveryPreparation,
+ stopSelfRecoveryPreparation
+} from '../../../src/lib/messaging/prepare-send.ts';
+export {
+ updatePrivateComposerText,
+ privateComposerText,
+ privateComposerSnapshot,
+ bindPrivateComposerPreparation,
+ closePrivateComposer,
+ requestPrivateNavigation,
+ confirmDiscardNavigation,
+ keepPrivateEditing,
+ dirtyNavigationSnapshot,
+ prepareSelfRecovery,
+ preparePairedDelivery,
+ selfRecoveryPreparationSnapshot,
+ preparedSelfRecovery,
+ captureSelfRecoveryPreparation,
+ stopSelfRecoveryPreparation,
+ disconnectIdentity
+};
+export function attachPrivateBeforeUnload(token: DirtyNavigation) {
+ const handler = (event: BeforeUnloadEvent) => {
+ if (privateNavigationBeforeUnload(token, event)) event.returnValue = '';
+ };
+ window.addEventListener('beforeunload', handler);
+ return () => window.removeEventListener('beforeunload', handler);
+}
+export async function makeFixture() {
+ const f = await makePairedFixture(),
+ wire = reservedSendRumorWire(f.reserved),
+ composerInput = createPrivateComposer(
+ f.identity,
+ 'reviewed_private_composer'
+ );
+ if (!wire || !composerInput) throw Error('missing private fixture');
+ const composer = composerInput;
+ const original = (JSON.parse(wire) as { content: string }).content;
+ if (!updatePrivateComposerText(composer, original, 'reviewed_private_text'))
+ throw Error('private text refused');
+ if (
+ !bindPrivateComposerPreparation(
+ composer,
+ f.reserved,
+ f.preparation,
+ undefined,
+ 'reviewed_composer_preparation'
+ )
+ )
+ throw Error('private intent binding refused');
+ const navigationInput = captureDirtyNavigation(composer);
+ if (!navigationInput) throw Error('dirty contract unavailable');
+ const navigation = navigationInput;
+ async function enquiryContext(title = 'Carrots') {
+ const provider = window.nostr as Readonly<{
+ signEvent(
+ template: EventTemplate
+ ): Promise<ReturnType<typeof finalizeEvent>>;
+ }>;
+ f.mode('wrong_author');
+ try {
+ const signed = await provider.signEvent({
+ kind: 30402,
+ created_at: 1700000060,
+ content: 'Public carrots',
+ tags: [
+ ['d', 'carrots'],
+ ['title', title],
+ ['summary', 'Fresh carrots'],
+ ['published_at', '1700000000'],
+ ['location', 'Victoria'],
+ ['price', '3.5', 'CAD'],
+ ['radroots:price_unit', 'lb'],
+ ['status', 'active']
+ ]
+ });
+ const proof = verifyEnvelope(
+ JSON.stringify({
+ id: signed.id,
+ pubkey: signed.pubkey,
+ sig: signed.sig,
+ kind: signed.kind,
+ created_at: signed.created_at,
+ tags: signed.tags,
+ content: signed.content
+ })
+ ),
+ context = proof.ok && captureEnquiryContext(proof.value);
+ if (!context) throw Error('missing genuine enquiry context');
+ return context;
+ } finally {
+ f.mode('normal');
+ }
+ }
+ // The fixture exercises the shared contract with real browser controls. It
+ // does not add a production page or qualify a manual accessibility review.
+ const panel = document.createElement('section'),
+ textarea = document.createElement('textarea'),
+ warning = document.createElement('p'),
+ keep = document.createElement('button'),
+ discard = document.createElement('button');
+ panel.setAttribute('aria-label', 'Private source fixture');
+ textarea.setAttribute('aria-label', 'Private text');
+ textarea.value = original;
+ warning.setAttribute('role', 'status');
+ keep.textContent = 'Keep editing';
+ discard.textContent = 'Discard draft';
+ function render() {
+ warning.textContent = dirtyNavigationSnapshot(navigation)?.copy ?? '';
+ textarea.value = privateComposerText(composer) ?? '';
+ }
+ keep.addEventListener('click', () => {
+ keepPrivateEditing(navigation);
+ render();
+ textarea.focus();
+ });
+ discard.addEventListener('click', () => {
+ confirmDiscardNavigation(navigation, 'reviewed_discard_private_text');
+ render();
+ });
+ panel.addEventListener('keydown', (event) => {
+ if (event.key === 'Escape') {
+ keepPrivateEditing(navigation);
+ render();
+ textarea.focus();
+ }
+ });
+ textarea.addEventListener('input', () => {
+ updatePrivateComposerText(
+ composer,
+ textarea.value,
+ 'reviewed_private_text'
+ );
+ render();
+ });
+ panel.append(textarea, warning, keep, discard);
+ document.body.append(panel);
+ let restoreReadback = () => {};
+ let readbackFailures = 0;
+ function loseReadback() {
+ restoreReadback();
+ const put = Reflect.get<IDBObjectStore, 'put'>(
+ IDBObjectStore.prototype,
+ 'put'
+ ),
+ openCursor = Reflect.get<IDBIndex, 'openCursor'>(
+ IDBIndex.prototype,
+ 'openCursor'
+ );
+ let committed = false;
+ readbackFailures = 0;
+ IDBObjectStore.prototype.put = function (
+ value: unknown,
+ key?: IDBValidKey
+ ) {
+ const request =
+ key === undefined ? put.call(this, value) : put.call(this, value, key);
+ if (this.name === 'private_sends') committed = true;
+ return request;
+ };
+ IDBIndex.prototype.openCursor = function (
+ query?: IDBValidKey | IDBKeyRange | null,
+ direction?: IDBCursorDirection
+ ) {
+ if (this.objectStore.name === 'private_sends' && committed) {
+ readbackFailures++;
+ throw Error('controlled readback unavailable');
+ }
+ return openCursor.call(this, query, direction);
+ };
+ restoreReadback = () => {
+ IDBObjectStore.prototype.put = put;
+ IDBIndex.prototype.openCursor = openCursor;
+ };
+ return restoreReadback;
+ }
+ return {
+ ...f,
+ composer,
+ navigation,
+ original,
+ enquiryContext,
+ loseReadback,
+ readbackFailures: () => readbackFailures,
+ requestClose() {
+ const result = requestPrivateNavigation(navigation);
+ render();
+ keep.focus();
+ return result;
+ },
+ close() {
+ restoreReadback();
+ panel.remove();
+ closePrivateComposer(composer);
+ f.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/private-preparation.spec.ts b/web/tests/e2e/private-preparation.spec.ts
@@ -0,0 +1,613 @@
+import { expect, test, type Page } from '@playwright/test';
+import { build } from 'vite';
+import { fileURLToPath } from 'node:url';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Preparation from './harness/private-preparation.ts';
+declare global {
+ interface Window {
+ hcp084: typeof Preparation;
+ hcp084Fixture: Awaited<ReturnType<typeof Preparation.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/private-preparation.ts', import.meta.url)
+ ),
+ name: 'hcp084',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(built) ? built[0] : built;
+ if (!('output' in output)) throw Error('private fixture bundle missing');
+ const chunks = output.output.filter((entry) => entry.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => server.close());
+test.afterEach(async ({ page }) => {
+ await page.evaluate(() => window.hcp084Fixture?.close());
+});
+test('genuine enquiry binding admits only exact canonical captured body and preserves prior acknowledgement on mismatch', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084,
+ context = await f.enquiryContext(),
+ different = await f.enquiryContext('Different carrots');
+ s.updatePrivateComposerText(f.composer, f.marker, 'reviewed_private_text');
+ const bound = s.bindPrivateComposerPreparation(
+ f.composer,
+ f.reserved,
+ f.preparation,
+ context,
+ 'reviewed_composer_preparation'
+ );
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const saved = s.privateComposerSnapshot(f.composer),
+ bytes = await f.stored(),
+ wrongContext = s.bindPrivateComposerPreparation(
+ f.composer,
+ f.reserved,
+ f.preparation,
+ different,
+ 'reviewed_composer_preparation'
+ ),
+ afterContext = s.privateComposerSnapshot(f.composer);
+ s.updatePrivateComposerText(
+ f.composer,
+ 'different private body',
+ 'reviewed_private_text'
+ );
+ const wrongBody = s.bindPrivateComposerPreparation(
+ f.composer,
+ f.reserved,
+ f.preparation,
+ context,
+ 'reviewed_composer_preparation'
+ );
+ return {
+ bound,
+ saved: saved?.state,
+ wrongContext,
+ unchangedAck: afterContext?.state === saved?.state,
+ wrongBody,
+ dirty: s.privateComposerSnapshot(f.composer)?.dirty,
+ text: s.privateComposerText(f.composer),
+ bytes: bytes === (await f.stored())
+ };
+ });
+ expect(result).toEqual({
+ bound: true,
+ saved: 'saved_encrypted',
+ wrongContext: false,
+ unchangedAck: true,
+ wrongBody: false,
+ dirty: true,
+ text: 'different private body',
+ bytes: true
+ });
+});
+async function load(page: Page) {
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async () => {
+ window.hcp084Fixture = await window.hcp084.makeFixture();
+ });
+}
+test('same-page confirmation defaults Keep editing and Escape preserves exact text and privacy', async ({
+ page
+}) => {
+ const logs: string[] = [];
+ page.on('console', (entry) => logs.push(entry.text()));
+ await load(page);
+ const original = await page.evaluate(() => {
+ const f = window.hcp084Fixture;
+ return {
+ text: f.original,
+ result: f.requestClose(),
+ snapshot: window.hcp084.privateComposerSnapshot(f.composer)
+ };
+ });
+ expect(original.result).toBe('confirmation_required');
+ expect(original.snapshot?.dirty).toBe(true);
+ await expect(
+ page.getByRole('button', { name: 'Keep editing', exact: true })
+ ).toBeFocused();
+ await page.getByRole('button', { name: 'Keep editing', exact: true }).click();
+ await expect(
+ page.getByRole('textbox', { name: 'Private text', exact: true })
+ ).toHaveValue(original.text);
+ await page.evaluate(() => window.hcp084Fixture.requestClose());
+ await page.keyboard.press('Escape');
+ await expect(
+ page.getByRole('textbox', { name: 'Private text', exact: true })
+ ).toHaveValue(original.text);
+ const privacy = await page.evaluate(async () => {
+ const f = window.hcp084Fixture;
+ return {
+ public: (await f.publicDraftRows()).includes(f.marker),
+ private: (await f.stored()).includes(f.marker),
+ storage: JSON.stringify(localStorage).includes(f.marker),
+ url: location.href.includes(f.marker),
+ snapshot: JSON.stringify(
+ window.hcp084.privateComposerSnapshot(f.composer)
+ ).includes(f.marker)
+ };
+ });
+ expect(privacy).toEqual({
+ public: false,
+ private: false,
+ storage: false,
+ url: false,
+ snapshot: false
+ });
+ expect(
+ logs.some((line) =>
+ line.includes('HCP081_PRIVATE_TEXT_MEMORY_ONLY_SENTINEL')
+ )
+ ).toBe(false);
+});
+test('stale discard cannot clear new edits; reviewed same-revision discard is one-shot', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(() => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084;
+ f.requestClose();
+ s.updatePrivateComposerText(
+ f.composer,
+ 'newer private value',
+ 'reviewed_private_text'
+ );
+ const stale = s.confirmDiscardNavigation(
+ f.navigation,
+ 'reviewed_discard_private_text'
+ ),
+ kept = s.privateComposerText(f.composer);
+ f.requestClose();
+ const denied = s.confirmDiscardNavigation(f.navigation, 'unreviewed'),
+ accepted = s.confirmDiscardNavigation(
+ f.navigation,
+ 'reviewed_discard_private_text'
+ );
+ return {
+ stale,
+ kept,
+ denied,
+ accepted,
+ text: s.privateComposerText(f.composer),
+ repeated: s.confirmDiscardNavigation(
+ f.navigation,
+ 'reviewed_discard_private_text'
+ )
+ };
+ });
+ expect(result).toEqual({
+ stale: 'review_required',
+ kept: 'newer private value',
+ denied: 'invalid',
+ accepted: 'allowed',
+ text: '',
+ repeated: 'invalid'
+ });
+});
+test('beforeunload warns only while exact private text lacks encrypted acknowledgement', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084,
+ detach = s.attachPrivateBeforeUnload(f.navigation);
+ const first = new Event('beforeunload', { cancelable: true });
+ window.dispatchEvent(first);
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const saved = s.privateComposerSnapshot(f.composer),
+ second = new Event('beforeunload', { cancelable: true });
+ window.dispatchEvent(second);
+ detach?.();
+ return {
+ dirtyPrevented: first.defaultPrevented,
+ savedPrevented: second.defaultPrevented,
+ saved: saved?.state,
+ dirty: saved?.dirty
+ };
+ });
+ expect(result).toEqual({
+ dirtyPrevented: true,
+ savedPrevented: false,
+ saved: 'saved_encrypted',
+ dirty: false
+ });
+});
+test('acknowledged ciphertext labels only captured text revision; newer value stays unsaved', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084;
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const saved = s.privateComposerSnapshot(f.composer),
+ bytes = await f.stored();
+ s.updatePrivateComposerText(
+ f.composer,
+ 'edited after capture',
+ 'reviewed_private_text'
+ );
+ const changed = s.privateComposerSnapshot(f.composer);
+ return {
+ saved: saved?.state,
+ changed: changed?.state,
+ dirty: changed?.dirty,
+ value: s.privateComposerText(f.composer),
+ unchanged: bytes === (await f.stored()),
+ plaintext: (await f.stored()).includes('edited after capture')
+ };
+ });
+ expect(result).toEqual({
+ saved: 'saved_encrypted',
+ changed: 'unsaved',
+ dirty: true,
+ value: 'edited after capture',
+ unchanged: true,
+ plaintext: false
+ });
+});
+for (const mode of ['declined', 'missing', 'changed_key'] as const)
+ test(
+ mode + ' self preparation never labels dirty text saved',
+ async ({ page }) => {
+ await load(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084;
+ f.mode(mode);
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const state = s.privateComposerSnapshot(f.composer);
+ return {
+ saved: state?.state === 'saved_encrypted',
+ dirty: state?.dirty ?? true,
+ receipt: !!s.preparedSelfRecovery(f.preparation),
+ plaintext: (await f.stored()).includes(f.marker)
+ };
+ }, mode);
+ expect(result).toEqual({
+ saved: false,
+ dirty: true,
+ receipt: false,
+ plaintext: false
+ });
+ }
+ );
+for (const mode of ['abort', 'unknown'] as const)
+ test(
+ mode + ' actual self transaction cannot turn draft into a fresh send',
+ async ({ page }) => {
+ await load(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084,
+ hits = f.fault(mode);
+ const outcome = await s.prepareSelfRecovery(
+ f.preparation,
+ 'reviewed_self_recovery'
+ ),
+ state = s.privateComposerSnapshot(f.composer);
+ return {
+ outcome: outcome.status,
+ hits: hits(),
+ state: state?.state,
+ dirty: state?.dirty,
+ plaintext: (await f.stored()).includes(f.marker),
+ value: s.privateComposerText(f.composer) === f.original
+ };
+ }, mode);
+ expect(result).toEqual(
+ mode === 'abort'
+ ? {
+ outcome: 'aborted',
+ hits: 1,
+ state: 'needs_action',
+ dirty: true,
+ plaintext: false,
+ value: true
+ }
+ : {
+ outcome: 'reconciled',
+ hits: 1,
+ state: 'saved_encrypted',
+ dirty: false,
+ plaintext: false,
+ value: true
+ }
+ );
+ }
+ );
+for (const action of ['discard', 'disconnect'] as const)
+ test(
+ action +
+ ' during real SDK wait preserves pending owner occupancy and cannot advance effects',
+ async ({ page }) => {
+ await load(page);
+ await page.evaluate(() => {
+ const f = window.hcp084Fixture;
+ f.mode('hold_encrypt');
+ Reflect.set(
+ window,
+ 'hcp084Pending',
+ window.hcp084.prepareSelfRecovery(
+ f.preparation,
+ 'reviewed_self_recovery'
+ )
+ );
+ });
+ await expect
+ .poll(() =>
+ page.evaluate(() => window.hcp084Fixture.pendingEncryption())
+ )
+ .toBe(true);
+ const waiting = await page.evaluate((action) => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084;
+ if (action === 'discard') {
+ f.requestClose();
+ s.confirmDiscardNavigation(
+ f.navigation,
+ 'reviewed_discard_private_text'
+ );
+ } else s.disconnectIdentity(f.identity);
+ return {
+ pending: f.pendingEncryption(),
+ receipt: !!s.preparedSelfRecovery(f.preparation),
+ text: s.privateComposerText(f.composer) ?? '',
+ bytes: f.counts().encrypts
+ };
+ }, action);
+ expect(waiting.pending).toBe(true);
+ expect(waiting.receipt).toBe(false);
+ expect(waiting.text).toBe('');
+ const settled = await page.evaluate(async () => {
+ const f = window.hcp084Fixture;
+ f.settle();
+ const result = (await Reflect.get(window, 'hcp084Pending')) as {
+ status: string;
+ };
+ return {
+ status: result.status,
+ pending: f.pendingEncryption(),
+ receipt: !!window.hcp084.preparedSelfRecovery(f.preparation),
+ plaintext: (await f.stored()).includes(f.marker)
+ };
+ });
+ expect(settled).toEqual({
+ status: 'stopped',
+ pending: false,
+ receipt: false,
+ plaintext: false
+ });
+ }
+ );
+for (const mode of ['abort', 'unknown'] as const)
+ test(
+ mode +
+ ' pair transaction retains only genuine local self fact and no remote effect',
+ async ({ page }) => {
+ let sockets = 0;
+ page.on('websocket', () => sockets++);
+ await load(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084;
+ 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'
+ ),
+ snapshot = s.privateComposerSnapshot(f.composer);
+ return {
+ status: result.status,
+ hits: hits(),
+ state: snapshot?.state,
+ pair: snapshot?.pairState,
+ dirty: snapshot?.dirty,
+ unchanged: old === (await f.stored()),
+ plaintext: (await f.stored()).includes(f.marker)
+ };
+ }, mode);
+ expect(result).toEqual(
+ mode === 'abort'
+ ? {
+ status: 'aborted',
+ hits: 1,
+ state: 'saved_encrypted',
+ pair: 'needs_action',
+ dirty: false,
+ unchanged: true,
+ plaintext: false
+ }
+ : {
+ status: 'reconciled',
+ hits: 1,
+ state: 'saved_encrypted',
+ pair: 'prepared',
+ dirty: false,
+ unchanged: false,
+ plaintext: false
+ }
+ );
+ expect(sockets).toBe(0);
+ }
+ );
+test('body budget and unreviewed edits preserve prior exact memory value', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(() => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084;
+ return {
+ oversized: s.updatePrivateComposerText(
+ f.composer,
+ 'x'.repeat(4097),
+ 'reviewed_private_text'
+ ),
+ unreviewed: s.updatePrivateComposerText(
+ f.composer,
+ 'replacement',
+ 'unreviewed'
+ ),
+ equal: s.privateComposerText(f.composer) === f.original
+ };
+ });
+ expect(result).toEqual({ oversized: false, unreviewed: false, equal: true });
+});
+
+for (const role of ['self', 'pair'] as const)
+ test(
+ role +
+ ' actual committed write with unavailable readback remains uncertain instead of fresh',
+ async ({ page }) => {
+ await load(page);
+ const result = await page.evaluate(async (role) => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084;
+ if (role === 'pair')
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ const restore = f.loseReadback();
+ const outcome =
+ role === 'self'
+ ? await s.prepareSelfRecovery(
+ f.preparation,
+ 'reviewed_self_recovery'
+ )
+ : await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ const state = s.privateComposerSnapshot(f.composer),
+ rebinding = s.bindPrivateComposerPreparation(
+ f.composer,
+ f.reserved,
+ f.preparation,
+ undefined,
+ 'reviewed_composer_preparation'
+ );
+ restore();
+ s.stopSelfRecoveryPreparation(f.preparation);
+ const fresh = s.captureSelfRecoveryPreparation(
+ f.repository,
+ f.identity,
+ f.reserved,
+ 'reviewed_self_recovery'
+ );
+ if (!fresh) throw Error('fresh genuine controller missing');
+ const freshBinding = s.bindPrivateComposerPreparation(
+ f.composer,
+ f.reserved,
+ fresh,
+ undefined,
+ 'reviewed_composer_preparation'
+ ),
+ retired = s.privateComposerSnapshot(f.composer);
+ s.stopSelfRecoveryPreparation(fresh);
+ return {
+ outcome: outcome.status,
+ readbackFailures: f.readbackFailures(),
+ state: state?.state,
+ pair: state?.pairState,
+ dirty: state?.dirty,
+ rebinding,
+ freshBinding,
+ uncertaintyRetained:
+ retired?.state === state?.state &&
+ retired?.pairState === state?.pairState,
+ original: s.privateComposerText(f.composer) === f.original,
+ ciphertext: !!(await f.storedPair()),
+ plaintext: (await f.stored()).includes(f.marker)
+ };
+ }, role);
+ expect(result).toEqual(
+ role === 'self'
+ ? {
+ outcome: 'unknown_completion',
+ readbackFailures: 1,
+ state: 'unknown_completion',
+ pair: 'unprepared',
+ dirty: true,
+ rebinding: false,
+ freshBinding: false,
+ uncertaintyRetained: true,
+ original: true,
+ ciphertext: true,
+ plaintext: false
+ }
+ : {
+ outcome: 'unknown_completion',
+ readbackFailures: 1,
+ state: 'saved_encrypted',
+ pair: 'unknown_completion',
+ dirty: false,
+ rebinding: false,
+ freshBinding: false,
+ uncertaintyRetained: true,
+ original: true,
+ ciphertext: true,
+ plaintext: false
+ }
+ );
+ }
+ );
+
+test('pair readback conflict cannot keep a prepared presentation from its prior genuine acknowledgement', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp084Fixture,
+ s = window.hcp084;
+ await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
+ await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ const before = s.privateComposerSnapshot(f.composer)?.pairState;
+ await f.changePairRevision();
+ const bytes = await f.stored();
+ const retry = await s.preparePairedDelivery(
+ f.preparation,
+ f.context,
+ 'reviewed_pair_preparation'
+ );
+ return {
+ before,
+ retry: retry.status,
+ after: s.privateComposerSnapshot(f.composer)?.pairState,
+ unchanged: bytes === (await f.stored())
+ };
+ });
+ expect(result).toEqual({
+ before: 'prepared',
+ retry: 'conflict',
+ after: 'needs_action',
+ unchanged: true
+ });
+});
diff --git a/web/tests/unit/private-preparation.test.ts b/web/tests/unit/private-preparation.test.ts
@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import {
+ createPrivateComposer,
+ updatePrivateComposerText,
+ privateComposerText,
+ privateComposerSnapshot,
+ discardPrivateComposer,
+ type PrivateComposer
+} from '../../src/lib/messaging/composer-state.ts';
+import {
+ captureDirtyNavigation,
+ requestPrivateNavigation,
+ confirmDiscardNavigation,
+ keepPrivateEditing,
+ dirtyNavigationSnapshot,
+ type DirtyNavigation
+} from '../../src/lib/runtime/dirty-navigation.ts';
+import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts';
+describe('private composer capabilities do not persist plaintext or infer acknowledgement', () => {
+ it('SSR and forged composers are inert', () => {
+ expect(
+ createPrivateComposer({} as IdentitySession, 'reviewed_private_composer')
+ ).toBeUndefined();
+ const forged = {} as PrivateComposer;
+ expect(
+ updatePrivateComposerText(forged, 'private', 'reviewed_private_text')
+ ).toBe(false);
+ expect(privateComposerText(forged)).toBeUndefined();
+ expect(privateComposerSnapshot(forged)).toBeUndefined();
+ expect(
+ discardPrivateComposer(forged, 0, 'reviewed_discard_private_text')
+ ).toBe(false);
+ expect(captureDirtyNavigation(forged)).toBeUndefined();
+ });
+ it('forged navigation cannot discard or grant leave permission', () => {
+ const forged = {} as DirtyNavigation;
+ expect(requestPrivateNavigation(forged)).toBe('invalid');
+ expect(
+ confirmDiscardNavigation(forged, 'reviewed_discard_private_text')
+ ).toBe('invalid');
+ expect(keepPrivateEditing(forged)).toBe(false);
+ expect(dirtyNavigationSnapshot(forged)).toBeUndefined();
+ });
+ it('review objects are never coerced', () => {
+ let calls = 0;
+ const review = {
+ toString() {
+ calls++;
+ return 'reviewed_private_text';
+ }
+ };
+ expect(
+ updatePrivateComposerText({} as PrivateComposer, 'private', review)
+ ).toBe(false);
+ expect(calls).toBe(0);
+ });
+});