app

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

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:
Mweb/src/lib/config/budgets.ts | 1+
Aweb/src/lib/messaging/composer-state.ts | 328+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/prepare-send.ts | 88+++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------------
Aweb/src/lib/runtime/dirty-navigation.ts | 115+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/private-preparation.ts | 226+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/private-preparation.spec.ts | 613+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/private-preparation.test.ts | 57+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
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); + }); +});