commit 0de570c68567f16e175ca85ec416ed70216e0c67
parent e150d061ae96fd78cfaa119929d3b6ce444c689a
Author: triesap <tyson@radroots.org>
Date: Fri, 9 Oct 2026 18:05:08 +0000
web: implement the memory-only reply composer (HCP-104)
- Capture replies from the original current private pair and direct parent
- Keep unsent text in memory with reviewed navigation and unload warnings
- Use original self-first durable preparation and honest paired publication
- Verify production expiry retry and retain exact source acceptance evidence
Diffstat:
13 files changed, 1938 insertions(+), 18 deletions(-)
diff --git a/web/src/lib/components/ConversationThread.svelte b/web/src/lib/components/ConversationThread.svelte
@@ -3,6 +3,15 @@
import InboxStatus from './InboxStatus.svelte';
import Button from './primitives/Button.svelte';
import MessageItem from './MessageItem.svelte';
+ import MessageComposer from './MessageComposer.svelte';
+ import {
+ createReplyController,
+ createRuntimeReplyController,
+ selectReplyParent,
+ replySnapshot,
+ closeReplyController,
+ type ReplyController
+ } from '../messaging/reply-controller.ts';
import {
IDENTITY_VIEW_CONTEXT,
identityViewSession,
@@ -37,6 +46,7 @@
const identity = getContext<IdentityViewContext>(IDENTITY_VIEW_CONTEXT),
publicContext = getContext<PublicRuntimeContext>(PUBLIC_RUNTIME_CONTEXT);
let owned = $state.raw<InboxView | undefined>(),
+ reply = $state.raw<ReplyController | undefined>(),
model = $state(inboxThreadSnapshot(undefined, '')),
announcement = $state(''),
readProblem = $state(false),
@@ -48,6 +58,20 @@
previous = Array.from<string>([]),
attempted = Array.from<string>([]),
disposed = false;
+ function captureReply(parent: string) {
+ if (!owned) return;
+ return runtime
+ ? createRuntimeReplyController(owned, conversationId, parent, runtime)
+ : createReplyController(owned, conversationId, parent);
+ }
+ function replyTo(parent: string) {
+ if (reply && replySnapshot(reply)?.dirty) {
+ selectReplyParent(reply, parent, 'reviewed_reply_parent');
+ return;
+ }
+ if (reply) closeReplyController(reply);
+ reply = captureReply(parent);
+ }
onMount(() => {
let observedRevision = -2,
observedMode = '';
@@ -74,6 +98,8 @@
observedMode = mode;
const next = inboxThreadSnapshot(owned, conversationId);
if (next.status !== 'ready') {
+ if (reply) closeReplyController(reply);
+ reply = undefined;
model = next;
announcement = '';
readProblem = false;
@@ -90,6 +116,7 @@
if (ids.length > 0) initialized = true;
previous = ids;
model = next;
+ if (!reply && ids.length) reply = captureReply(ids[ids.length - 1]);
});
}
const identityOff = identity
@@ -109,6 +136,7 @@
disposed = true;
identityOff();
off();
+ if (reply) closeReplyController(reply);
if (owned && !controller) {
const setup = inboxViewSetup(owned);
closeInboxView(owned);
@@ -167,7 +195,12 @@
controller={owned}
{conversationId}
{message}
+ onreply={replyTo}
/>{/each}
+ {#if reply}{#key reply}<MessageComposer
+ controller={reply}
+ focusScope="conversation"
+ />{/key}{/if}
{:else}<p>
This conversation is unavailable until it is unlocked in the matching
browser and account.
diff --git a/web/src/lib/components/MessageComposer.svelte b/web/src/lib/components/MessageComposer.svelte
@@ -0,0 +1,161 @@
+<script lang="ts">
+ /* global document, setInterval, clearInterval */
+ import { onMount, tick } from 'svelte';
+ import { beforeNavigate, goto } from '$app/navigation';
+ import { internalHref } from '../navigation-url.ts';
+ import {
+ replySnapshot,
+ replyText,
+ updateReplyText,
+ sendReply,
+ requestReplyNavigation,
+ keepReplyEditing,
+ discardReplyNavigation,
+ replyBeforeUnload,
+ closeReplyController,
+ type ReplyController
+ } from '../messaging/reply-controller.ts';
+ let {
+ controller,
+ focusScope = 'enquiry'
+ }: { controller: ReplyController; focusScope?: 'conversation' | 'enquiry' } =
+ $props();
+ let model = $state<ReturnType<typeof replySnapshot>>(),
+ text = $state('');
+ let destination: string | undefined,
+ disposed = false;
+ const fieldId = $derived(
+ focusScope === 'conversation' ? 'conversation-reply' : 'enquiry-reply'
+ );
+ function focusEditor() {
+ if (disposed) return;
+ if (focusScope === 'conversation')
+ document.getElementById('conversation-reply')?.focus();
+ else document.getElementById('enquiry-reply')?.focus();
+ }
+ function focusKeep() {
+ if (disposed) return;
+ if (focusScope === 'conversation')
+ document.getElementById('conversation-keep-reply')?.focus();
+ else document.getElementById('enquiry-keep-reply')?.focus();
+ }
+ function refresh() {
+ if (disposed) return;
+ model = replySnapshot(controller);
+ text = replyText(controller) ?? '';
+ }
+ beforeNavigate((event) => {
+ if (
+ disposed ||
+ requestReplyNavigation(controller) !== 'confirmation_required'
+ )
+ return;
+ event.cancel();
+ const url = event.to?.url;
+ destination =
+ url && !event.willUnload
+ ? internalHref(url.pathname + url.search + url.hash)
+ : undefined;
+ refresh();
+ void tick().then(focusKeep);
+ });
+ onMount(() => {
+ refresh();
+ const timer = setInterval(refresh, 200);
+ return () => {
+ disposed = true;
+ clearInterval(timer);
+ closeReplyController(controller);
+ text = '';
+ model = undefined;
+ destination = undefined;
+ };
+ });
+ async function send() {
+ const work = sendReply(controller, 'reviewed_reply_send');
+ refresh();
+ await work;
+ refresh();
+ }
+ function warnUnload(event: BeforeUnloadEvent) {
+ replyBeforeUnload(controller, event);
+ }
+</script>
+
+<svelte:window onbeforeunload={warnUnload} />
+
+{#if model}
+ <div class="stack">
+ <label for={fieldId}>Reply</label>
+ <textarea
+ id={fieldId}
+ value={text}
+ disabled={model.busy || model.state === 'completed'}
+ aria-describedby={fieldId + '-save'}
+ oninput={(event) => {
+ updateReplyText(
+ controller,
+ event.currentTarget.value,
+ 'reviewed_private_text'
+ );
+ refresh();
+ }}></textarea>
+ <p id={fieldId + '-save'}>
+ {model.saveCopy} Unsent text is lost when this page closes.
+ </p>
+ <p>{model.pairCopy}</p>
+ <p>
+ Replying moves this conversation to your inbox in this view. It does not
+ accept an order.
+ </p>
+ <p>Messages do not reserve products or record payment.</p>
+ <button
+ type="button"
+ class="button button--primary"
+ disabled={model.busy || model.state === 'completed' || !text.trim()}
+ onclick={() => {
+ void send();
+ }}>Send reply</button
+ >
+ <p role="status" aria-live="polite">{model.copy}</p>
+ {#if model.navigation === 'confirmation_required'}
+ <div class="notice stack" role="group" aria-label="Unsaved private reply">
+ <p>
+ Discard unsaved private text? Keep editing to preserve it. An
+ outstanding extension call remains pending until it settles.
+ </p>
+ <div class="cluster">
+ <button
+ type="button"
+ class="button button--secondary"
+ id={focusScope === 'conversation'
+ ? 'conversation-keep-reply'
+ : 'enquiry-keep-reply'}
+ onclick={() => {
+ keepReplyEditing(controller);
+ destination = undefined;
+ refresh();
+ void tick().then(focusEditor);
+ }}>Keep editing</button
+ >
+ <button
+ type="button"
+ class="button button--secondary"
+ onclick={() => {
+ const target = internalHref(destination);
+ const result = discardReplyNavigation(
+ controller,
+ 'reviewed_discard_private_text'
+ );
+ destination = undefined;
+ refresh();
+ if (result === 'allowed') {
+ if (target) void goto(target);
+ } else void tick().then(focusEditor);
+ }}>Discard draft</button
+ >
+ </div>
+ </div>
+ {/if}
+ </div>
+{/if}
diff --git a/web/src/lib/components/MessageItem.svelte b/web/src/lib/components/MessageItem.svelte
@@ -8,9 +8,14 @@
let {
controller,
conversationId,
- message
- }: { controller: InboxView; conversationId: string; message: ThreadMessage } =
- $props();
+ message,
+ onreply
+ }: {
+ controller: InboxView;
+ conversationId: string;
+ message: ThreadMessage;
+ onreply?: (parent: string) => void;
+ } = $props();
// Copied rows select only a hash. Render fresh current original room bytes.
const current = $derived(
inboxMessageSnapshot(controller, conversationId, message.data.rumorId)
@@ -53,5 +58,12 @@
{#each current.delivery ?? [] as label (label)}<p class="text-small">
{label}
</p>{/each}
+ {#if onreply}<button
+ type="button"
+ class="button button--secondary"
+ onclick={() => {
+ if (current) onreply?.(current.data.rumorId);
+ }}>Reply to this message</button
+ >{/if}
</article>
{/if}
diff --git a/web/src/lib/messaging/inbox-view.ts b/web/src/lib/messaging/inbox-view.ts
@@ -93,6 +93,11 @@ import {
type InboxSync
} from './inbox-sync.ts';
import { messagingReadinessSnapshot } from './readiness.ts';
+import {
+ selfRecoveryAcknowledgementSnapshot,
+ verifySelfRecoveryAcknowledgement,
+ type SelfRecoveryAcknowledgement
+} from '../persistence/private-sends.ts';
declare const inboxViewBrand: unique symbol;
export type InboxView = Readonly<{ [inboxViewBrand]: true }>;
export type InboxViewSnapshot = Readonly<{
@@ -112,7 +117,25 @@ type Inputs = Readonly<{
setup: InboxSetupView;
conversationId?: string;
}>;
+export type InboxReplyOwnership = Readonly<{
+ owner: string;
+ identity: IdentitySession;
+ session: PrivateSession;
+ database: BrowserDatabase;
+ repository: PrivateStorageRepository;
+ unlocked: UnlockedSession;
+ room: AdmittedConversation;
+ setup: InboxSetupView;
+ peer: string;
+ parent: string;
+ current(): boolean;
+ acceptLocalReply(
+ receipt: SelfRecoveryAcknowledgement,
+ review: unknown
+ ): Promise<boolean>;
+}>;
type Controller = {
+ reply(id: unknown, rumor: unknown): InboxReplyOwnership | undefined;
snapshot(): InboxViewSnapshot;
thread(id: unknown): ThreadSnapshot;
threadRevision(): number;
@@ -192,6 +215,7 @@ export function createInboxView(input: Inputs): InboxView | undefined {
let sendRecords: readonly PrivateRecordHandle[] =
Array.from<PrivateRecordHandle>([]);
let listReason: string | null = null;
+ let repliedPeers = Array.from<string>([]);
let listRevision = 0;
const rowProofs = new Map<
string,
@@ -306,6 +330,79 @@ export function createInboxView(input: Inputs): InboxView | undefined {
messages: messages.filter((row) => row !== undefined)
};
}
+ function replyOwnership(
+ id: unknown,
+ rumor: unknown
+ ): InboxReplyOwnership | undefined {
+ if (
+ typeof rumor !== 'string' ||
+ !messageSnapshot(id, rumor) ||
+ !session ||
+ !database ||
+ !repository ||
+ !unlocked
+ )
+ return;
+ const proof = threadProofs.get(rumor);
+ if (!proof) return;
+ const data = conversationSnapshot(proof.room);
+ if (!data) return;
+ const generation = epoch,
+ selection = threadEpoch,
+ originalSession = session,
+ originalRepository = repository,
+ originalCache = unlocked,
+ originalDatabase = database;
+ const admitted = () =>
+ current(generation) &&
+ privateCurrent() &&
+ selection === threadEpoch &&
+ id === threadId &&
+ threadPeer === data.peer &&
+ session === originalSession &&
+ repository === originalRepository &&
+ unlocked === originalCache &&
+ !!messageSnapshot(id, rumor) &&
+ unlockedConversationCurrent(originalCache, proof.room);
+ if (!admitted()) return;
+ return {
+ owner: capture.owner,
+ identity: input.identity,
+ session: originalSession,
+ database: originalDatabase,
+ repository: originalRepository,
+ unlocked: originalCache,
+ room: proof.room,
+ setup: input.setup,
+ peer: data.peer,
+ parent: data.rumorId,
+ current: admitted,
+ async acceptLocalReply(receipt, review) {
+ const saved = selfRecoveryAcknowledgementSnapshot(receipt);
+ if (
+ review !== 'reviewed_local_reply' ||
+ !admitted() ||
+ saved?.owner !== capture.owner ||
+ saved.peer !== data.peer ||
+ !(await verifySelfRecoveryAcknowledgement(
+ originalRepository,
+ receipt
+ )) ||
+ !admitted()
+ )
+ return false;
+ // Presentation in this unlocked view only, backed by the actual native
+ // self receipt. No order/notification or persistent acceptance field.
+ if (!repliedPeers.includes(data.peer))
+ repliedPeers = repliedPeers.concat(data.peer);
+ listRevision++;
+ await refreshList(generation);
+ if (!admitted()) return false;
+ notify();
+ return true;
+ }
+ };
+ }
async function resolve(id: unknown, review: unknown) {
if (review !== 'reviewed_conversation_navigation') return false;
const selection = ++threadEpoch,
@@ -404,8 +501,22 @@ export function createInboxView(input: Inputs): InboxView | undefined {
return { status: 'unavailable', requests: [], conversations: [] };
return {
status: 'ready',
- requests: requests.filter((row) => row !== undefined),
- conversations: conversations.filter((row) => row !== undefined)
+ requests: requests
+ .filter((row) => row !== undefined)
+ .filter((row) => !repliedPeers.includes(row.peer)),
+ conversations: conversations
+ .filter((row) => row !== undefined)
+ .concat(
+ requests
+ .filter((row) => row !== undefined)
+ .filter((row) => repliedPeers.includes(row.peer))
+ )
+ .sort(
+ (a, b) =>
+ b.latest.createdAt - a.latest.createdAt ||
+ b.latest.rumorId.localeCompare(a.latest.rumorId) ||
+ a.peer.localeCompare(b.peer)
+ )
};
}
async function refreshList(generation = epoch) {
@@ -687,6 +798,7 @@ export function createInboxView(input: Inputs): InboxView | undefined {
threadId = undefined;
threadPeer = undefined;
sendRecords = [];
+ repliedPeers = [];
metadata = undefined;
directory = undefined;
older = undefined;
@@ -962,6 +1074,7 @@ export function createInboxView(input: Inputs): InboxView | undefined {
return current(generation) && privateCurrent();
}
views.set(token, {
+ reply: replyOwnership,
snapshot,
thread: threadSnapshot,
threadRevision: () => (privateCurrent() ? listRevision + threadEpoch : -1),
@@ -1143,3 +1256,11 @@ export function markInboxConversationDisplayed(
export function inboxThreadRevision(token: InboxView | undefined): number {
return token ? (views.get(token)?.threadRevision() ?? -1) : -1;
}
+
+export function inboxReplyOwnership(
+ token: InboxView,
+ id: unknown,
+ rumor: unknown
+): InboxReplyOwnership | undefined {
+ return views.get(token)?.reply(id, rumor);
+}
diff --git a/web/src/lib/messaging/reply-controller.ts b/web/src/lib/messaging/reply-controller.ts
@@ -0,0 +1,440 @@
+import { inboxReplyOwnership, type InboxView } from './inbox-view.ts';
+import { inboxSetupViewOwnership } from './inbox-setup-view.ts';
+import { messagingReadinessSnapshot } from './readiness.ts';
+import {
+ createInboxRoutePlan,
+ inboxRoutePlanSnapshot
+} from './inbox-routing.ts';
+import {
+ resolveInboxPreference,
+ closeInboxResolver,
+ type InboxResolver
+} from './resolve-inbox.ts';
+import {
+ createPublicView,
+ beginPublicViewRun,
+ publicViewRunCurrent,
+ disposePublicView,
+ type PublicRuntime
+} from '../runtime/public-runtime.ts';
+import {
+ createPrivateComposer,
+ privateComposerText,
+ privateComposerSnapshot,
+ updatePrivateComposerText,
+ bindPrivateComposerPreparation,
+ closePrivateComposer
+} from './composer-state.ts';
+import {
+ captureDirtyNavigation,
+ requestPrivateNavigation,
+ confirmDiscardNavigation,
+ keepPrivateEditing,
+ dirtyNavigationSnapshot,
+ privateNavigationBeforeUnload
+} from '../runtime/dirty-navigation.ts';
+import {
+ captureAuthenticatedReplyRumor,
+ stopRumorPlan,
+ type RumorPlan
+} from './rumor-plan.ts';
+import { createPrivateSendReservationRepository } from '../persistence/private-send-reservations.ts';
+import { reserveSendIdentity } from './send-identity.ts';
+import {
+ captureSelfRecoveryPreparation,
+ prepareSelfRecovery,
+ preparedSelfRecovery,
+ preparePairedDelivery,
+ preparedPairedDelivery,
+ selfRecoveryPreparationSnapshot,
+ type SelfRecoveryPreparation
+} from './prepare-send.ts';
+import { getPrivatePool } from '../nostr/private-pool.ts';
+import {
+ capturePrivateRetry,
+ runPrivateRetry,
+ stopPrivateRetry,
+ type PrivateRetry
+} from './retry-send.ts';
+import { newLocalId } from '../private-handles.ts';
+import { subscribeIdentityInvalidation } from '../runtime/identity-session.ts';
+import { subscribePrivateSessionClose } from '../runtime/private-session.ts';
+
+declare const replyBrand: unique symbol;
+export type ReplyController = Readonly<{ [replyBrand]: true }>;
+type Result = Readonly<{
+ status: 'invalid' | 'busy' | 'stopped' | 'needs_action' | 'completed';
+}>;
+type Options = Readonly<{
+ lookupPeer?(peer: string): Promise<InboxResolver>;
+ close?(): void;
+}>;
+type State =
+ | 'idle'
+ | 'checking'
+ | 'preparing'
+ | 'publishing'
+ | 'needs_action'
+ | 'completed';
+type Snapshot = Readonly<{
+ state: State;
+ busy: boolean;
+ dirty: boolean;
+ copy: string;
+ saveCopy: string;
+ pairCopy: string;
+ navigation: 'idle' | 'confirmation_required';
+}>;
+type Controller = {
+ snapshot(): Snapshot | undefined;
+ text(): string | undefined;
+ update(text: unknown, review: unknown): boolean;
+ select(parent: unknown, review: unknown): boolean;
+ send(review: unknown): Promise<Result>;
+ request(): ReturnType<typeof requestPrivateNavigation>;
+ keep(): boolean;
+ discard(review: unknown): ReturnType<typeof confirmDiscardNavigation>;
+ unload(event: BeforeUnloadEvent): boolean;
+ close(): void;
+};
+const controllers = new WeakMap<ReplyController, Controller>();
+
+// Allocating or typing a draft performs no SDK, native write or discovery.
+// Caller hints are resolved through the original selected view's Room/cache.
+export function createReplyController(
+ view: InboxView,
+ conversationId: unknown,
+ parent: unknown,
+ options: Options = {}
+): ReplyController | undefined {
+ if (typeof window === 'undefined') return;
+ let scope = inboxReplyOwnership(view, conversationId, parent);
+ if (!scope?.current()) return;
+ const original = scope,
+ composer = createPrivateComposer(
+ original.identity,
+ 'reviewed_private_composer'
+ );
+ const navigation = composer && captureDirtyNavigation(composer);
+ if (!composer || !navigation) {
+ if (composer) closePrivateComposer(composer);
+ return;
+ }
+ let active = true,
+ busy = false,
+ state: State = 'idle',
+ copy = '',
+ attempted = false;
+ let plan: RumorPlan | undefined,
+ preparation: SelfRecoveryPreparation | undefined,
+ retry: PrivateRetry | undefined;
+ let identityOff = () => {},
+ privateOff = () => {};
+ function close() {
+ if (!active) return;
+ active = false;
+ if (retry) stopPrivateRetry(retry);
+ closePrivateComposer(composer!);
+ if (plan) stopRumorPlan(plan);
+ identityOff();
+ privateOff();
+ options.close?.();
+ }
+ function current() {
+ if (!active || !scope?.current() || !privateComposerSnapshot(composer!)) {
+ close();
+ return false;
+ }
+ return true;
+ }
+ function snapshot(): Snapshot | undefined {
+ if (!current()) return;
+ const draft = privateComposerSnapshot(composer!),
+ workflow = preparation && selfRecoveryPreparationSnapshot(preparation);
+ if (!draft) return;
+ return {
+ state,
+ busy,
+ dirty: draft.dirty,
+ copy:
+ copy ||
+ (state === 'preparing'
+ ? 'Preparing encryption. The extension may ask for several approvals.'
+ : state === 'publishing'
+ ? 'Publishing encrypted copies to the reviewed inbox relays.'
+ : ''),
+ saveCopy: draft.copy,
+ pairCopy: workflow?.pairCopy ?? draft.pairCopy,
+ navigation: dirtyNavigationSnapshot(navigation!)?.state ?? 'idle'
+ };
+ }
+ async function send(review: unknown): Promise<Result> {
+ if (review !== 'reviewed_reply_send') return { status: 'invalid' };
+ if (!current()) return { status: 'stopped' };
+ if (busy) return { status: 'busy' };
+ const text = privateComposerText(composer!);
+ if (!text?.trim()) return { status: 'invalid' };
+ if (attempted) return { status: 'needs_action' };
+ busy = true;
+ state = 'checking';
+ copy =
+ 'Checking the authenticated peer inbox. Your text remains in memory.';
+ const captured = scope!;
+ const admitted = () => current() && scope === captured;
+ function needsAction(): Result {
+ state = 'needs_action';
+ copy =
+ 'Send needs review. Keep this draft; check inbox setup or connection, then explicitly send again. Existing encrypted work needs its own recovery review.';
+ return { status: 'needs_action' };
+ }
+ try {
+ const setup = inboxSetupViewOwnership(captured.setup);
+ if (!setup?.current() || !setup.resolver || !options.lookupPeer)
+ return needsAction();
+ const other = await options.lookupPeer(captured.peer);
+ if (!admitted()) return { status: 'stopped' };
+ if (
+ !messagingReadinessSnapshot(
+ captured.identity,
+ captured.session,
+ setup.policy,
+ setup.resolver,
+ { author: captured.peer, resolver: other },
+ setup.observeAccess
+ ).sendReady ||
+ !admitted()
+ )
+ return needsAction();
+ const routes = createInboxRoutePlan(
+ setup.policy,
+ captured.owner,
+ captured.peer,
+ setup.resolver,
+ other
+ );
+ const routeData = routes && inboxRoutePlanSnapshot(routes);
+ const reservations = createPrivateSendReservationRepository(
+ captured.database,
+ captured.owner
+ );
+ if (!routes || !routeData || !reservations || !admitted())
+ return needsAction();
+ plan = captureAuthenticatedReplyRumor(
+ captured.identity,
+ captured.session,
+ captured.unlocked,
+ captured.room,
+ text,
+ Math.floor(Date.now() / 1000)
+ );
+ const command = newLocalId();
+ if (!plan || !command || !admitted()) return needsAction();
+ // After a native intent may exist, repeated Send never creates another
+ // rumor or silently replays this command. Recovery has its own owner.
+ attempted = true;
+ const reserved = await reserveSendIdentity(
+ reservations,
+ captured.identity,
+ command,
+ plan,
+ 'reviewed_private_intent'
+ );
+ if (!admitted()) return { status: 'stopped' };
+ if (!('identity' in reserved)) return needsAction();
+ preparation = captureSelfRecoveryPreparation(
+ captured.repository,
+ captured.identity,
+ reserved.identity,
+ 'reviewed_self_recovery'
+ );
+ if (
+ !preparation ||
+ !bindPrivateComposerPreparation(
+ composer!,
+ reserved.identity,
+ preparation,
+ undefined,
+ 'reviewed_composer_preparation'
+ )
+ )
+ return needsAction();
+ state = 'preparing';
+ copy = '';
+ const self = await prepareSelfRecovery(
+ preparation,
+ 'reviewed_self_recovery'
+ );
+ if (!admitted()) return { status: 'stopped' };
+ const saved = preparedSelfRecovery(preparation);
+ if (
+ !['saved', 'existing', 'reconciled'].includes(self.status) ||
+ !saved ||
+ !(await captured.acceptLocalReply(saved, 'reviewed_local_reply')) ||
+ !admitted()
+ )
+ return needsAction();
+ const context = {
+ plan: routes,
+ policy: setup.policy,
+ own: setup.resolver,
+ other
+ };
+ const paired = await preparePairedDelivery(
+ preparation,
+ context,
+ 'reviewed_pair_preparation'
+ );
+ if (!admitted()) return { status: 'stopped' };
+ const receipt = preparedPairedDelivery(preparation);
+ if (
+ !['prepared', 'existing', 'reconciled'].includes(paired.status) ||
+ !receipt
+ )
+ return needsAction();
+ const origins = Array.from(
+ new Set([...routeData.peer.targets, ...routeData.archive.targets])
+ );
+ const pool = getPrivatePool(captured.session, setup.policy, origins);
+ if (!pool || !admitted()) return needsAction();
+ retry = capturePrivateRetry(
+ captured.repository,
+ captured.session,
+ receipt,
+ context,
+ pool,
+ 'reviewed_private_retry'
+ );
+ if (!retry || !admitted()) return needsAction();
+ state = 'publishing';
+ const delivered = await runPrivateRetry(retry, 'reviewed_private_retry');
+ if (!admitted()) return { status: 'stopped' };
+ if (delivered.status !== 'completed') return needsAction();
+ state = 'completed';
+ copy =
+ 'Accepted by recipient inbox relay. This does not confirm that the person read the message.';
+ return { status: 'completed' };
+ } catch {
+ return current() ? needsAction() : { status: 'stopped' };
+ } finally {
+ busy = false;
+ }
+ }
+ const token = Object.freeze({}) as ReplyController;
+ controllers.set(token, {
+ snapshot,
+ text: () => (current() ? privateComposerText(composer) : undefined),
+ update: (text, review) =>
+ current() &&
+ !busy &&
+ !attempted &&
+ updatePrivateComposerText(composer, text, review),
+ select(parent, review) {
+ if (review !== 'reviewed_reply_parent' || !current() || busy || attempted)
+ return false;
+ const selected = inboxReplyOwnership(view, conversationId, parent);
+ if (
+ !selected?.current() ||
+ selected.identity !== original.identity ||
+ selected.session !== original.session ||
+ selected.peer !== original.peer
+ )
+ return false;
+ scope = selected;
+ return true;
+ },
+ send,
+ request: () =>
+ current() ? requestPrivateNavigation(navigation) : 'invalid',
+ keep: () => current() && keepPrivateEditing(navigation),
+ discard: (review) =>
+ current() ? confirmDiscardNavigation(navigation, review) : 'invalid',
+ unload: (event) =>
+ current() && privateNavigationBeforeUnload(navigation, event),
+ close
+ });
+ identityOff = subscribeIdentityInvalidation(original.identity, () => {
+ if (!original.current()) close();
+ });
+ privateOff = subscribePrivateSessionClose(original.session, close);
+ return current() ? token : undefined;
+}
+
+export function createRuntimeReplyController(
+ view: InboxView,
+ id: unknown,
+ parent: unknown,
+ runtime: PublicRuntime
+): ReplyController | undefined {
+ const publicView = createPublicView(runtime);
+ let resolver: InboxResolver | undefined,
+ run: ReturnType<typeof beginPublicViewRun> | undefined;
+ const token = createReplyController(view, id, parent, {
+ lookupPeer: (peer) => {
+ // Only this explicit Send lookup may renew an expired run. An active
+ // lookup retains its original bounded work, including pending results.
+ if (!resolver || !run || !publicViewRunCurrent(publicView, run)) {
+ if (resolver) closeInboxResolver(resolver);
+ resolver = undefined;
+ run = beginPublicViewRun(publicView);
+ resolver = resolveInboxPreference(publicView, run, peer);
+ }
+ return Promise.resolve(resolver);
+ },
+ close: () => {
+ if (resolver) closeInboxResolver(resolver);
+ disposePublicView(publicView);
+ }
+ });
+ if (!token) disposePublicView(publicView);
+ return token;
+}
+export function replySnapshot(token: ReplyController) {
+ return controllers.get(token)?.snapshot();
+}
+export function replyText(token: ReplyController) {
+ return controllers.get(token)?.text();
+}
+export function updateReplyText(
+ token: ReplyController,
+ text: unknown,
+ review: unknown
+) {
+ return controllers.get(token)?.update(text, review) ?? false;
+}
+export function selectReplyParent(
+ token: ReplyController,
+ parent: unknown,
+ review: unknown
+) {
+ return controllers.get(token)?.select(parent, review) ?? false;
+}
+export function sendReply(
+ token: ReplyController,
+ review: unknown
+): Promise<Result> {
+ return (
+ controllers.get(token)?.send(review) ??
+ Promise.resolve({ status: 'invalid' })
+ );
+}
+export function requestReplyNavigation(token: ReplyController) {
+ return controllers.get(token)?.request() ?? 'invalid';
+}
+export function keepReplyEditing(token: ReplyController) {
+ return controllers.get(token)?.keep() ?? false;
+}
+export function discardReplyNavigation(
+ token: ReplyController,
+ review: unknown
+) {
+ return controllers.get(token)?.discard(review) ?? 'invalid';
+}
+export function replyBeforeUnload(
+ token: ReplyController,
+ event: BeforeUnloadEvent
+) {
+ return controllers.get(token)?.unload(event) ?? false;
+}
+export function closeReplyController(token: ReplyController) {
+ controllers.get(token)?.close();
+}
diff --git a/web/src/lib/messaging/rumor-plan.ts b/web/src/lib/messaging/rumor-plan.ts
@@ -10,6 +10,20 @@ import {
recoveredSelfEnvelopeSnapshot,
type RecoveredSelfEnvelope
} from '../nostr/self-recovery-reader.ts';
+import {
+ privateSessionOwnership,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import {
+ unlockedSessionOwnership,
+ unlockedConversationCurrent,
+ type UnlockedSession
+} from './unlocked-session.ts';
+import {
+ conversationSnapshot,
+ conversationOwnership,
+ type AdmittedConversation
+} from './admit-conversation.ts';
declare const rumorBrand: unique symbol;
export type RumorPlan = Readonly<{ readonly [rumorBrand]: true }>;
export type RumorPlanSnapshot = Readonly<{
@@ -30,21 +44,23 @@ const plans = new WeakMap<RumorPlan, Controller>();
function capture(
session: IdentitySession,
rawMessage: string,
- observedTime: unknown
+ observedTime: unknown,
+ additionalCurrent: () => boolean = () => true
): RumorPlan | undefined {
const ownership = identityMessagingOwnership(session);
- if (!ownership || !ownership.current()) return undefined;
+ if (!ownership || !ownership.current() || !additionalCurrent())
+ return undefined;
const rumor = buildCanonicalPairRumor(
rawMessage,
ownership.owner,
observedTime
);
- if (!rumor || !ownership.current()) return undefined;
+ if (!rumor || !ownership.current() || !additionalCurrent()) return undefined;
const peer = rumor.tags.find((row) => row[0] === 'p')?.[1];
if (!peer) return undefined;
const token = Object.freeze({}) as RumorPlan;
const unsubscribe = subscribeIdentityInvalidation(session, () => {
- if (!ownership.current()) stopRumorPlan(token);
+ if (!ownership.current() || !additionalCurrent()) stopRumorPlan(token);
});
plans.set(token, {
owner: ownership.owner,
@@ -52,11 +68,69 @@ function capture(
id: rumor.id,
createdAt: rumor.created_at,
wire: JSON.stringify(rumor),
- current: ownership.current,
+ current: () => ownership.current() && additionalCurrent(),
unsubscribe
});
return token;
}
+// Reply authority comes from the original authenticated room and its exact
+// private/cache generation. A detached snapshot, parent hash or outer author
+// cannot select the peer or borrow a same-owner session.
+export function captureAuthenticatedReplyRumor(
+ identity: IdentitySession,
+ session: PrivateSession,
+ unlocked: UnlockedSession,
+ room: AdmittedConversation,
+ text: unknown,
+ observedTime: unknown
+): RumorPlan | undefined {
+ const owner = identityMessagingOwnership(identity),
+ privateOwner = privateSessionOwnership(session),
+ cache = unlockedSessionOwnership(unlocked),
+ admitted = conversationOwnership(room),
+ data = conversationSnapshot(room);
+ if (
+ !owner ||
+ !privateOwner ||
+ !cache ||
+ !admitted ||
+ !data ||
+ typeof text !== 'string'
+ )
+ return;
+ const current = () => {
+ const actual = conversationSnapshot(room);
+ return (
+ owner.current() &&
+ privateOwner.current() &&
+ cache.current() &&
+ admitted.current() &&
+ owner.owner === data.owner &&
+ privateOwner.owner === owner.owner &&
+ privateOwner.session === owner.session &&
+ cache.owner === owner.owner &&
+ cache.session === owner.session &&
+ admitted.owner === owner.owner &&
+ admitted.session === owner.session &&
+ actual?.owner === data.owner &&
+ actual.peer === data.peer &&
+ actual.rumorId === data.rumorId &&
+ unlockedConversationCurrent(unlocked, room)
+ );
+ };
+ if (!current()) return;
+ return capture(
+ identity,
+ JSON.stringify({
+ recipients: [{ public_key: data.peer, relay_url: null }],
+ content: text,
+ reply_to: { id: data.rumorId, relays: null },
+ subject: null
+ }),
+ observedTime,
+ current
+ );
+}
export function captureEnquiryRumor(
session: IdentitySession,
context: EnquiryContext,
diff --git a/web/tests/e2e/harness/conversation-thread.ts b/web/tests/e2e/harness/conversation-thread.ts
@@ -58,6 +58,13 @@ import {
stopInboxView,
closeInboxView
} from '../../../src/lib/messaging/inbox-view.ts';
+import { identityMessagingOwnership } from '../../../src/lib/runtime/identity-session.ts';
+import type { RelayPolicy } from '../../../src/lib/config/relays.ts';
+import type { InboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
+
+// HCP103 does not navigate; HCP104's separate harness exercises actual mounted
+// beforeNavigate callbacks and unload/disposal. This alias owns fixture scope.
+export function beforeNavigate(): void {}
export function goto(): never {
throw Error('Thread fixture must not navigate');
@@ -72,7 +79,12 @@ export type Scenario =
| 'hostile';
export async function renderFixture(
kind: Scenario = 'inbound',
- selectedId?: string
+ selectedId?: string,
+ qualifiedReplyFixture = false,
+ freshOwnLookup?: (
+ owner: string,
+ policy: RelayPolicy
+ ) => Promise<InboxResolver>
) {
// Receipt scenario performs actual original SDK retry and receives loopback
// OKs before mounting the readonly thread. The UI itself never publishes.
@@ -276,7 +288,19 @@ export async function renderFixture(
const setup = createInboxSetupView({
identity: f.identity,
policy,
- lookup: () => Promise.resolve(f.context.own)
+ lookup: () =>
+ freshOwnLookup
+ ? freshOwnLookup(f.owner, policy)
+ : Promise.resolve(f.context.own),
+ // Controlled qualification projection only, never production relay evidence.
+ observeAccess: qualifiedReplyFixture
+ ? (context) => ({
+ ...context,
+ receive: 'qualified_exercised',
+ archive: 'qualified_exercised',
+ current: () => !!identityMessagingOwnership(f.identity)?.current()
+ })
+ : undefined
});
if (!setup) throw Error('no original setup');
const controller = createInboxView({
@@ -342,6 +366,10 @@ export async function renderFixture(
holdReadLock,
releaseRead,
controller,
+ replyLookup(peer: string) {
+ if (peer !== f.peer) throw Error('wrong authenticated fixture peer');
+ return f.context.other;
+ },
owner: f.owner,
peer: f.peer,
conversationId,
diff --git a/web/tests/e2e/harness/reply-composer-panel.svelte b/web/tests/e2e/harness/reply-composer-panel.svelte
@@ -0,0 +1,9 @@
+<script lang="ts">
+ import MessageComposer from '../../../src/lib/components/MessageComposer.svelte';
+ import type { ReplyController } from '../../../src/lib/messaging/reply-controller.ts';
+ let { controller }: { controller: ReplyController } = $props();
+</script>
+
+<section data-reply-fixture>
+ <MessageComposer {controller} />
+</section>
diff --git a/web/tests/e2e/harness/reply-composer.ts b/web/tests/e2e/harness/reply-composer.ts
@@ -0,0 +1,304 @@
+import { mount, unmount } from 'svelte';
+import type { beforeNavigate as KitBeforeNavigate } from '$app/navigation';
+type BeforeNavigate = Parameters<Parameters<typeof KitBeforeNavigate>[0]>[0];
+import {
+ finalizeEvent,
+ type UnsignedEvent,
+ type NostrEvent
+} from 'applesauce-core/helpers';
+import { renderFixture as renderThread } from './conversation-thread.ts';
+import Panel from './reply-composer-panel.svelte';
+import {
+ createReplyController,
+ createRuntimeReplyController,
+ replySnapshot,
+ replyText,
+ updateReplyText,
+ sendReply,
+ closeReplyController,
+ requestReplyNavigation,
+ keepReplyEditing,
+ discardReplyNavigation,
+ selectReplyParent
+} from '../../../src/lib/messaging/reply-controller.ts';
+import {
+ inboxListSnapshot,
+ inboxReplyOwnership
+} from '../../../src/lib/messaging/inbox-view.ts';
+import {
+ captureAuthenticatedReplyRumor,
+ rumorPlanSnapshot,
+ stopRumorPlan
+} from '../../../src/lib/messaging/rumor-plan.ts';
+import {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ disconnectIdentity
+} from '../../../src/lib/runtime/identity-session.ts';
+import { inboxSetupViewOwnership } from '../../../src/lib/messaging/inbox-setup-view.ts';
+import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
+import {
+ createPublicScheduler,
+ createPublicRun,
+ openInboxRequest,
+ closePublicScheduler,
+ type RequestClock
+} from '../../../src/lib/nostr/request-scope.ts';
+import {
+ createPublicRuntimeContext,
+ mountPublicRuntime,
+ closePublicRuntime
+} from '../../../src/lib/runtime/public-runtime.ts';
+
+const navigation: ((event: BeforeNavigate) => void)[] = [];
+let destinations = Array.from<string>([]);
+export function beforeNavigate(callback: (event: BeforeNavigate) => void) {
+ navigation.push(callback);
+}
+export function goto(destination: string | URL) {
+ destinations = destinations.concat(String(destination));
+ return Promise.resolve();
+}
+export async function renderReplyFixture(qualified = true, production = false) {
+ navigation.length = 0;
+ destinations = [];
+ let clockOffset = 0,
+ alive = true;
+ const ownSchedulers: ReturnType<typeof createPublicScheduler>[] = [];
+ const clock: RequestClock = {
+ now: () => performance.now() + clockOffset,
+ schedule(callback, delay) {
+ const timer = setTimeout(callback, delay);
+ return () => clearTimeout(timer);
+ }
+ };
+ const freshOwn: NonNullable<Parameters<typeof renderThread>[3]> = (
+ owner,
+ policy
+ ) => {
+ const event = finalizeEvent(
+ {
+ kind: 10050,
+ created_at: 100,
+ tags: [['relay', 'wss://archive.example.org']],
+ content: ''
+ },
+ new Uint8Array(32).fill(83)
+ );
+ if (event.pubkey !== owner) throw Error('wrong genuine owner');
+ const scheduler = createPublicScheduler({
+ now: () => 0,
+ schedule: () => () => {}
+ });
+ ownSchedulers.push(scheduler);
+ const run = createPublicRun(scheduler, policy);
+ return Promise.resolve(
+ createInboxResolver(
+ run,
+ owner,
+ (next) =>
+ openInboxRequest(
+ run,
+ owner,
+ (sink) => {
+ sink({
+ type: 'EVENT',
+ from: 'wss://discovery.example.org',
+ id: 'fixture',
+ event
+ });
+ sink({
+ type: 'EOSE',
+ from: 'wss://discovery.example.org',
+ id: 'fixture'
+ });
+ return () => {};
+ },
+ next
+ ),
+ () => alive
+ )
+ );
+ };
+ const thread = await renderThread(
+ 'inbound',
+ undefined,
+ qualified,
+ production ? freshOwn : undefined
+ );
+ await thread.checkSetup();
+ if (!(await thread.unlock())) throw Error('no genuine unlocked thread');
+ let gate = false,
+ lookups = 0;
+ const scope = inboxReplyOwnership(
+ thread.controller,
+ thread.conversationId,
+ thread.firstRumor
+ );
+ const setup = scope && inboxSetupViewOwnership(scope.setup);
+ const publicContext = production ? createPublicRuntimeContext() : undefined;
+ const runtime =
+ publicContext &&
+ setup &&
+ mountPublicRuntime(publicContext, setup.policy, clock);
+ if (production && !runtime) throw Error('no genuine public runtime');
+ const candidate = runtime
+ ? createRuntimeReplyController(
+ thread.controller,
+ thread.conversationId,
+ thread.firstRumor,
+ runtime
+ )
+ : createReplyController(
+ thread.controller,
+ thread.conversationId,
+ thread.firstRumor,
+ {
+ lookupPeer: (peer) => {
+ lookups++;
+ if (gate) throw Error('controlled same-page setup cancellation');
+ return Promise.resolve(thread.replyLookup(peer));
+ }
+ }
+ );
+ if (!candidate) throw Error('no original reply controller');
+ const controller = candidate;
+ const target = document.createElement('div');
+ document.body.append(target);
+ const mounted = mount(Panel, { target, props: { controller } });
+ let unmounted = false,
+ held = false,
+ release: (() => void) | undefined;
+ const provider = window.nostr as
+ { signEvent(event: UnsignedEvent): Promise<NostrEvent> } | undefined;
+ if (!provider) throw Error('no actual fixture provider');
+ const nativeSign = provider.signEvent.bind(provider);
+ provider.signEvent = (event: UnsignedEvent) =>
+ held
+ ? new Promise<NostrEvent>((resolve, reject) => {
+ release = () => {
+ held = false;
+ nativeSign(event).then(resolve, reject);
+ };
+ })
+ : nativeSign(event);
+ async function closeComposer() {
+ if (unmounted) return;
+ unmounted = true;
+ await unmount(mounted);
+ closeReplyController(controller);
+ target.remove();
+ }
+ return {
+ owner: thread.owner,
+ peer: thread.peer,
+ parent: thread.firstRumor,
+ conversationId: thread.conversationId,
+ snapshot: () => replySnapshot(controller),
+ text: () => replyText(controller),
+ native: thread.native,
+ delta: thread.delta,
+ list: () => inboxListSnapshot(thread.controller),
+ lookups: () => lookups,
+ advance: () => {
+ clockOffset += 15_001;
+ },
+ refreshSetup: thread.checkSetup,
+ gate: (value: boolean) => {
+ gate = value;
+ },
+ send: (review: unknown = 'reviewed_reply_send') =>
+ sendReply(controller, review),
+ update: (text: string, review: unknown = 'reviewed_private_text') =>
+ updateReplyText(controller, text, review),
+ selectParent: (parent: string) =>
+ selectReplyParent(controller, parent, 'reviewed_reply_parent'),
+ copied: async () => ({
+ snapshot: replySnapshot({ ...controller }),
+ text: replyText({ ...controller }),
+ update: updateReplyText(
+ { ...controller },
+ 'copied sentinel',
+ 'reviewed_private_text'
+ ),
+ send: await sendReply({ ...controller }, 'reviewed_reply_send'),
+ navigation: requestReplyNavigation({ ...controller }),
+ keep: keepReplyEditing({ ...controller }),
+ discard: discardReplyNavigation(
+ { ...controller },
+ 'reviewed_discard_private_text'
+ )
+ }),
+ async admission() {
+ const scope = inboxReplyOwnership(
+ thread.controller,
+ thread.conversationId,
+ thread.firstRumor
+ );
+ if (!scope) throw Error('missing actual original room');
+ const capture = (
+ identity = scope.identity,
+ session = scope.session,
+ unlocked = scope.unlocked,
+ room = scope.room
+ ) =>
+ captureAuthenticatedReplyRumor(
+ identity,
+ session,
+ unlocked,
+ room,
+ 'Local admission fixture only',
+ Math.floor(Date.now() / 1000)
+ );
+ const genuine = capture();
+ if (!genuine) throw Error('missing genuine plan');
+ const wire = rumorPlanSnapshot(genuine)?.wire;
+ stopRumorPlan(genuine);
+ const copied = [
+ capture({ ...scope.identity }),
+ capture(scope.identity, { ...scope.session }),
+ capture(scope.identity, scope.session, { ...scope.unlocked }),
+ capture(scope.identity, scope.session, scope.unlocked, {
+ ...scope.room
+ })
+ ].map((plan) => !!plan);
+ const other = createIdentitySession();
+ await connectIdentity(other);
+ await probeIdentityMessaging(other, 'reviewed_self_copy');
+ const foreign = capture(other);
+ if (foreign) stopRumorPlan(foreign);
+ disconnectIdentity(other);
+ return { wire, copied, foreign: !!foreign };
+ },
+ navigate() {
+ let cancelled = false;
+ const event = {
+ cancel: () => {
+ cancelled = true;
+ },
+ to: { url: new URL('/messages', window.location.origin) },
+ willUnload: false
+ } as unknown as BeforeNavigate;
+ for (const callback of navigation) callback(event);
+ return cancelled;
+ },
+ destinations: () => destinations.slice(),
+ holdSigner: () => {
+ held = true;
+ },
+ pending: () => !!release,
+ settle: () => release?.(),
+ closeComposer,
+ logout: thread.logout,
+ async close() {
+ release?.();
+ provider.signEvent = nativeSign;
+ await closeComposer();
+ if (publicContext) closePublicRuntime(publicContext);
+ await thread.close();
+ alive = false;
+ for (const scheduler of ownSchedulers) closePublicScheduler(scheduler);
+ }
+ };
+}
diff --git a/web/tests/e2e/reply-composer.spec.ts b/web/tests/e2e/reply-composer.spec.ts
@@ -0,0 +1,635 @@
+import { test, expect } from '@playwright/test';
+import { build } from 'vite';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+import { fileURLToPath } from 'node:url';
+import { once } from 'node:events';
+import { WebSocketServer } from 'ws';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Fixture from './harness/reply-composer.ts';
+import { finalizeEvent } from 'applesauce-core/helpers';
+declare global {
+ interface Window {
+ hcp104: typeof Fixture;
+ hcp104Fixture: Awaited<ReturnType<typeof Fixture.renderReplyFixture>>;
+ hcp104Pending?: Promise<unknown>;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string;
+let events: unknown[][] = [],
+ requests: unknown[][] = [];
+let servePeerPreference = false;
+const peerPreference = finalizeEvent(
+ {
+ kind: 10050,
+ created_at: 100,
+ tags: [['relay', 'wss://peer.example.org']],
+ content: ''
+ },
+ new Uint8Array(32).fill(84)
+);
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ sockets = new WebSocketServer({
+ host: '127.0.0.1',
+ port: 0,
+ maxPayload: 65536
+ });
+ await once(sockets, 'listening');
+ const address = sockets.address();
+ if (!address || typeof address === 'string') throw Error('no loopback');
+ endpoint = 'ws://127.0.0.1:' + address.port;
+ sockets.on('connection', (socket) =>
+ socket.on('message', (bytes) => {
+ const raw = Buffer.isBuffer(bytes)
+ ? bytes
+ : Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.from(bytes),
+ frame = JSON.parse(raw.toString()) as unknown[];
+ if (frame[0] === 'EVENT') {
+ events.push(frame);
+ const event = frame[1] as { id: string };
+ socket.send(JSON.stringify(['OK', event.id, true, '']));
+ }
+ if (frame[0] === 'REQ') {
+ requests.push(frame);
+ const filter = frame[2] as { kinds?: number[]; authors?: string[] };
+ if (
+ servePeerPreference &&
+ filter.kinds?.includes(10050) &&
+ filter.authors?.includes(peerPreference.pubkey)
+ )
+ socket.send(JSON.stringify(['EVENT', frame[1], peerPreference]));
+ socket.send(JSON.stringify(['EOSE', frame[1]]));
+ }
+ })
+ );
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ plugins: [svelte({ configFile: false })],
+ resolve: {
+ conditions: ['browser'],
+ alias: {
+ '$app/navigation': fileURLToPath(
+ new URL('./harness/reply-composer.ts', import.meta.url)
+ )
+ }
+ },
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/reply-composer.ts', import.meta.url)
+ ),
+ name: 'hcp104',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('no bundle');
+ const chunks = output.output.filter((row) => row.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => {
+ for (const socket of sockets.clients) socket.terminate();
+ await new Promise<void>((resolve) => sockets.close(() => resolve()));
+ await server.close();
+});
+async function load(page: import('@playwright/test').Page) {
+ await page.addInitScript(
+ ({ endpoint }) => {
+ const Native = window.WebSocket;
+ window.WebSocket = class extends Native {
+ constructor(url: string | URL, protocols?: string | string[]) {
+ if (
+ ![
+ 'wss://peer.example.org',
+ 'wss://archive.example.org',
+ 'wss://discovery.example.org'
+ ].includes(new URL(String(url)).origin)
+ )
+ throw Error('unapproved destination');
+ super(endpoint, protocols);
+ }
+ };
+ },
+ { endpoint }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+}
+test.beforeEach(async ({ page }) => {
+ events = [];
+ requests = [];
+ servePeerPreference = false;
+ await load(page);
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(async () => {
+ window.hcp104Fixture?.settle();
+ await window.hcp104Pending;
+ await window.hcp104Fixture?.close();
+ });
+});
+async function ready(
+ page: import('@playwright/test').Page,
+ qualified = true,
+ production = false
+) {
+ await page.evaluate(
+ async ({ qualified, production }) => {
+ window.hcp104Fixture = await window.hcp104.renderReplyFixture(
+ qualified,
+ production
+ );
+ },
+ { qualified, production }
+ );
+ await expect(
+ page.locator('[data-reply-fixture]').getByLabel('Reply', { exact: true })
+ ).toBeVisible();
+ await expect
+ .poll(() =>
+ page.evaluate(async () => {
+ const native = await window.hcp104Fixture.native();
+ return native.received.every((row) => {
+ const record = JSON.parse((row as { wire: string }).wire) as {
+ read: unknown;
+ };
+ return record.read !== null;
+ });
+ })
+ )
+ .toBe(true);
+}
+const composer = (page: import('@playwright/test').Page) =>
+ page.locator('[data-reply-fixture]');
+const sentinel = 'HCP104_UNSENT_MEMORY_ONLY & <private>\nThursday pickup?';
+
+test('production explicit Send renews an expired peer lookup without losing the draft or automatically sending', async ({
+ page
+}) => {
+ await ready(page, true, true);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ const before = await page.evaluate(async () => ({
+ native: await window.hcp104Fixture.native(),
+ delta: window.hcp104Fixture.delta()
+ }));
+ expect(requests).toEqual([]);
+ expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({
+ status: 'needs_action'
+ });
+ await expect.poll(() => requests.length).toBe(1);
+ expect(requests[0][2]).toMatchObject({
+ kinds: [10050],
+ authors: [peerPreference.pubkey],
+ limit: 200
+ });
+ // An active missing-peer run is reused. Neither its EOSE nor another Send
+ // silently resets the bounded lookup or invents private readiness.
+ expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({
+ status: 'needs_action'
+ });
+ expect(requests).toHaveLength(1);
+ expect(events).toEqual([]);
+ await page.evaluate(async () => {
+ window.hcp104Fixture.advance();
+ await window.hcp104Fixture.refreshSetup();
+ });
+ expect(requests).toHaveLength(1);
+ expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel);
+ expect(
+ await page.evaluate(async () => ({
+ native: await window.hcp104Fixture.native(),
+ delta: window.hcp104Fixture.delta()
+ }))
+ ).toEqual(before);
+ servePeerPreference = true;
+ expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({
+ status: 'needs_action'
+ });
+ // The unchanged producer never issues this second original runtime query.
+ await expect.poll(() => requests.length).toBe(2);
+ expect(requests[1][2]).toEqual(requests[0][2]);
+ expect(events).toEqual([]);
+ expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel);
+ await composer(page)
+ .getByRole('button', { name: 'Send reply', exact: true })
+ .click();
+ await expect
+ .poll(() => page.evaluate(() => window.hcp104Fixture.snapshot()?.state))
+ .toBe('completed');
+ expect(requests).toHaveLength(2);
+ expect(events).toHaveLength(2);
+ expect(await page.evaluate(() => window.hcp104Fixture.delta())).toMatchObject(
+ { encrypts: before.delta.encrypts + 2, signs: before.delta.signs + 2 }
+ );
+});
+
+test('typing is memory only with no autosave SDK discovery publication or order transition', async ({
+ page
+}) => {
+ await ready(page);
+ const before = await page.evaluate(async () => ({
+ native: await window.hcp104Fixture.native(),
+ delta: window.hcp104Fixture.delta()
+ }));
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ await expect(composer(page)).toContainText('unsaved memory');
+ await expect(composer(page)).toContainText('does not accept an order');
+ expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel);
+ expect(await page.evaluate(() => window.hcp104Fixture.lookups())).toBe(0);
+ expect(
+ await page.evaluate(async () => ({
+ native: await window.hcp104Fixture.native(),
+ delta: window.hcp104Fixture.delta()
+ }))
+ ).toEqual(before);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+ expect(
+ await composer(page)
+ .getByRole('button', { name: /Accept order/i })
+ .count()
+ ).toBe(0);
+ expect(
+ await page.evaluate(
+ (text) =>
+ JSON.stringify({
+ local: { ...localStorage },
+ session: { ...sessionStorage }
+ }).includes(text),
+ sentinel
+ )
+ ).toBe(false);
+});
+
+test('explicit Send creates an actual self-first paired reply with the authenticated peer and direct inner parent', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ const before = await page.evaluate(() => window.hcp104Fixture.delta());
+ await composer(page)
+ .getByRole('button', { name: 'Send reply', exact: true })
+ .click();
+ await expect
+ .poll(() => page.evaluate(() => window.hcp104Fixture.snapshot()?.state))
+ .toBe('completed');
+ expect(events).toHaveLength(2);
+ expect(
+ events.every((frame) => (frame[1] as { kind: number }).kind === 1059)
+ ).toBe(true);
+ expect(await page.evaluate(() => window.hcp104Fixture.delta())).toMatchObject(
+ { encrypts: before.encrypts + 2, signs: before.signs + 2 }
+ );
+ await expect(composer(page)).toContainText('Saved encrypted in this browser');
+ await expect(composer(page)).toContainText(
+ 'Accepted by recipient inbox relay'
+ );
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.list().requests)
+ ).toEqual([]);
+ expect(
+ await page.evaluate(() =>
+ window.hcp104Fixture.list().conversations.map((row) => row.peer)
+ )
+ ).toEqual([await page.evaluate(() => window.hcp104Fixture.peer)]);
+ const { nip44 } = await import('applesauce-core/helpers/encryption');
+ const { getEventHash } = await import('applesauce-core/helpers');
+ const owner = await page.evaluate(() => window.hcp104Fixture.owner),
+ peer = await page.evaluate(() => window.hcp104Fixture.peer),
+ parent = await page.evaluate(() => window.hcp104Fixture.parent);
+ const rumors = events.map((frame) => {
+ const outer = frame[1] as {
+ pubkey: string;
+ content: string;
+ tags: string[][];
+ };
+ const key = new Uint8Array(32).fill(outer.tags[0][1] === owner ? 83 : 84);
+ const seal = JSON.parse(
+ nip44.v2.decrypt(
+ outer.content,
+ nip44.v2.utils.getConversationKey(key, outer.pubkey)
+ )
+ ) as { pubkey: string; content: string; kind: number; tags: string[][] };
+ expect(seal.kind).toBe(13);
+ expect(seal.tags).toEqual([]);
+ expect(seal.pubkey).toBe(owner);
+ const rumor = JSON.parse(
+ nip44.v2.decrypt(
+ seal.content,
+ nip44.v2.utils.getConversationKey(key, seal.pubkey)
+ )
+ ) as {
+ id: string;
+ kind: number;
+ pubkey: string;
+ tags: string[][];
+ content: string;
+ created_at: number;
+ };
+ expect(rumor.kind).toBe(14);
+ expect(rumor.pubkey).toBe(owner);
+ expect(rumor.content).toBe(sentinel);
+ expect(rumor.tags).toEqual([
+ ['p', peer],
+ ['e', parent]
+ ]);
+ expect(getEventHash(rumor)).toBe(rumor.id);
+ key.fill(0);
+ return rumor;
+ });
+ expect(rumors[0]).toEqual(rumors[1]);
+ expect(requests).toEqual([]);
+});
+
+test('cancelled same-page setup retains the exact draft and clearing the gate never auto-sends', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ const before = await page.evaluate(async () => ({
+ native: await window.hcp104Fixture.native(),
+ delta: window.hcp104Fixture.delta()
+ }));
+ await page.evaluate(() => window.hcp104Fixture.gate(true));
+ expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({
+ status: 'needs_action'
+ });
+ await expect(composer(page).getByLabel('Reply', { exact: true })).toHaveValue(
+ sentinel
+ );
+ await page.evaluate(() => window.hcp104Fixture.gate(false));
+ expect(
+ await page.evaluate(async () => ({
+ native: await window.hcp104Fixture.native(),
+ delta: window.hcp104Fixture.delta()
+ }))
+ ).toEqual(before);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+
+test('unexercised original inbox access leaves the memory draft honest and cannot send', async ({
+ page
+}) => {
+ await ready(page, false);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ const before = await page.evaluate(async () => ({
+ native: await window.hcp104Fixture.native(),
+ delta: window.hcp104Fixture.delta()
+ }));
+ expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({
+ status: 'needs_action'
+ });
+ expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel);
+ expect(
+ await page.evaluate(async () => ({
+ native: await window.hcp104Fixture.native(),
+ delta: window.hcp104Fixture.delta()
+ }))
+ ).toEqual(before);
+ expect(events).toEqual([]);
+});
+
+test('unreviewed Send and oversized edits retain the previous memory revision without effects', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.update('x'.repeat(4097)))
+ ).toBe(false);
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.send('unreviewed'))
+ ).toEqual({ status: 'invalid' });
+ expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel);
+ expect(await page.evaluate(() => window.hcp104Fixture.lookups())).toBe(0);
+ expect(events).toEqual([]);
+});
+
+test('dirty route navigation defaults to Keep editing and preserves the draft and focus', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ expect(await page.evaluate(() => window.hcp104Fixture.navigate())).toBe(true);
+ await expect(
+ composer(page).getByRole('button', { name: 'Keep editing', exact: true })
+ ).toBeFocused();
+ await composer(page)
+ .getByRole('button', { name: 'Keep editing', exact: true })
+ .click();
+ await expect(composer(page).getByLabel('Reply', { exact: true })).toHaveValue(
+ sentinel
+ );
+ await expect(
+ composer(page).getByLabel('Reply', { exact: true })
+ ).toBeFocused();
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.destinations())
+ ).toEqual([]);
+ expect(events).toEqual([]);
+});
+
+test('reviewed navigation discard clears only the same draft and returns to the safe inbox', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ const before = await page.evaluate(() => window.hcp104Fixture.native());
+ expect(await page.evaluate(() => window.hcp104Fixture.navigate())).toBe(true);
+ await composer(page)
+ .getByRole('button', { name: 'Discard draft', exact: true })
+ .click();
+ expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe('');
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.destinations())
+ ).toEqual(['/messages']);
+ expect(await page.evaluate(() => window.hcp104Fixture.native())).toEqual(
+ before
+ );
+ expect(events).toEqual([]);
+});
+
+test('actual native unload event warns for unsaved text without attempting a save', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ const before = await page.evaluate(() => window.hcp104Fixture.delta());
+ expect(
+ await page.evaluate(() => {
+ const event = new Event('beforeunload', { cancelable: true });
+ return window.dispatchEvent(event);
+ })
+ ).toBe(false);
+ expect(await page.evaluate(() => window.hcp104Fixture.delta())).toEqual(
+ before
+ );
+ expect(events).toEqual([]);
+});
+
+test('unmount during the actual held seal signature retires continuations and never auto-publishes a late result', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ await page.evaluate(() => {
+ window.hcp104Fixture.holdSigner();
+ window.hcp104Pending = window.hcp104Fixture.send();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp104Fixture.pending()))
+ .toBe(true);
+ await expect(composer(page)).toContainText('Preparing');
+ expect(events).toEqual([]);
+ await page.evaluate(() => window.hcp104Fixture.closeComposer());
+ await page.evaluate(async () => {
+ window.hcp104Fixture.settle();
+ await window.hcp104Pending;
+ });
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.text())
+ ).toBeUndefined();
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+ expect(await page.evaluate(() => window.hcp104Fixture.delta())).toMatchObject(
+ { encrypts: 1, signs: 1 }
+ );
+});
+
+test('logout during actual held signer work hides the draft and refuses late peer crypto or publication', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ await page.evaluate(() => {
+ window.hcp104Fixture.holdSigner();
+ window.hcp104Pending = window.hcp104Fixture.send();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp104Fixture.pending()))
+ .toBe(true);
+ await page.evaluate(() => window.hcp104Fixture.logout());
+ await page.evaluate(async () => {
+ window.hcp104Fixture.settle();
+ await window.hcp104Pending;
+ });
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.text())
+ ).toBeUndefined();
+ expect(events).toEqual([]);
+ await expect(composer(page).getByLabel('Reply', { exact: true })).toHaveCount(
+ 0
+ );
+});
+
+test('copied controllers and arbitrary private or product hashes cannot borrow reply custody', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ expect(await page.evaluate(() => window.hcp104Fixture.copied())).toEqual({
+ update: false,
+ send: { status: 'invalid' },
+ navigation: 'invalid',
+ keep: false,
+ discard: 'invalid'
+ });
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.selectParent('f'.repeat(64)))
+ ).toBe(false);
+ expect(
+ await page.evaluate(() =>
+ window.hcp104Fixture.selectParent('nostr:naddr1invalid')
+ )
+ ).toBe(false);
+ expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+
+test('explicitly leaving and reloading loses the unsaved memory draft while ciphertext remains intact', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ const before = await page.evaluate(() => window.hcp104Fixture.native());
+ await page.evaluate(() => window.hcp104Fixture.close());
+ await page.reload();
+ expect(
+ await page.evaluate(() =>
+ document.body.textContent?.includes('HCP104_UNSENT_MEMORY_ONLY')
+ )
+ ).toBe(false);
+ expect(
+ await page.evaluate(
+ (rows) => JSON.stringify(rows).includes('HCP104_UNSENT_MEMORY_ONLY'),
+ before
+ )
+ ).toBe(false);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+
+test('later actual admitted Room replies reject every copied custody token and a genuine different same-owner identity generation', async ({
+ page
+}) => {
+ await ready(page);
+ const before = await page.evaluate(() => window.hcp104Fixture.native());
+ const admission = await page.evaluate(() => window.hcp104Fixture.admission());
+ expect(admission.copied).toEqual([false, false, false, false]);
+ expect(admission.foreign).toBe(false);
+ const rumor = JSON.parse(admission.wire!) as {
+ pubkey: string;
+ tags: string[][];
+ content: string;
+ kind: number;
+ };
+ expect(rumor.pubkey).toBe(
+ await page.evaluate(() => window.hcp104Fixture.owner)
+ );
+ expect(rumor.tags).toEqual([
+ ['p', await page.evaluate(() => window.hcp104Fixture.peer)],
+ ['e', await page.evaluate(() => window.hcp104Fixture.parent)]
+ ]);
+ expect(rumor.kind).toBe(14);
+ expect(rumor.content).toBe('Local admission fixture only');
+ expect(await page.evaluate(() => window.hcp104Fixture.native())).toEqual(
+ before
+ );
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+
+test('later edit after opening dirty warning invalidates the reviewed discard revision without erasing the new draft or navigating', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ expect(await page.evaluate(() => window.hcp104Fixture.navigate())).toBe(true);
+ await composer(page)
+ .getByLabel('Reply', { exact: true })
+ .fill(sentinel + '\nKeep this newer text');
+ await composer(page)
+ .getByRole('button', { name: 'Discard draft', exact: true })
+ .click();
+ expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(
+ sentinel + '\nKeep this newer text'
+ );
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.destinations())
+ ).toEqual([]);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -350,6 +350,9 @@ import { auditOutput } from '../../tools/check-output.mjs';
'src/lib/messaging/inbox-list.ts',
'src/lib/components/ConversationThread.svelte',
'src/lib/components/MessageItem.svelte',
+ 'src/lib/components/MessageComposer.svelte',
+ 'src/lib/messaging/reply-controller.ts',
+ 'src/lib/messaging/rumor-plan.ts',
'src/lib/messaging/conversation-thread.ts',
'src/lib/persistence/private-storage.ts',
'src/routes/messages/[conversationId=local_id]/+page.svelte'
@@ -418,7 +421,9 @@ import { auditOutput } from '../../tools/check-output.mjs';
'directory-duplicate-role',
'thread-missing-edge',
'thread-dynamic',
- 'thread-entry-role'
+ 'thread-entry-role',
+ 'reply-missing-navigation',
+ 'reply-missing-handles'
])
await check(
'actual inbox list compiler rejects ' + mutation,
@@ -432,7 +437,10 @@ import { auditOutput } from '../../tools/check-output.mjs';
const entry = Object.entries(manifest).find(
([, row]) =>
row.name ===
- (mutation.startsWith('thread-') ? 'nodes/5' : 'InboxStatus')
+ (mutation.startsWith('thread-') ||
+ mutation.startsWith('reply-')
+ ? 'nodes/5'
+ : 'InboxStatus')
);
assert.ok(entry);
const [, row] = entry;
@@ -453,6 +461,16 @@ import { auditOutput } from '../../tools/check-output.mjs';
)
];
if (mutation === 'thread-entry-role') row.isEntry = false;
+ if (mutation === 'reply-missing-navigation')
+ row.imports = row.imports.filter(
+ (/** @type {string} */ value) =>
+ manifest[value].name !== 'navigation'
+ );
+ if (mutation === 'reply-missing-handles')
+ row.imports = row.imports.filter(
+ (/** @type {string} */ value) =>
+ manifest[value].name !== 'private-handles'
+ );
await writeFile(file, JSON.stringify(manifest));
await assert.rejects(f.audit, /compiler|duplicate|inventory/);
}
diff --git a/web/tests/unit/reply-controller.test.ts b/web/tests/unit/reply-controller.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import {
+ createReplyController,
+ replySnapshot,
+ replyText,
+ updateReplyText,
+ sendReply,
+ requestReplyNavigation,
+ keepReplyEditing,
+ discardReplyNavigation,
+ closeReplyController,
+ type ReplyController
+} from '../../src/lib/messaging/reply-controller.ts';
+import { captureAuthenticatedReplyRumor } from '../../src/lib/messaging/rumor-plan.ts';
+import type { InboxView } from '../../src/lib/messaging/inbox-view.ts';
+import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts';
+import type { PrivateSession } from '../../src/lib/runtime/private-session.ts';
+import type { UnlockedSession } from '../../src/lib/messaging/unlocked-session.ts';
+import type { AdmittedConversation } from '../../src/lib/messaging/admit-conversation.ts';
+
+const id = '12345678-1234-4234-8234-123456789abc';
+describe('reply entry points reject detached custody and SSR effects', () => {
+ it('SSR cannot allocate an effect-capable reply controller or run discovery', () => {
+ let lookups = 0;
+ expect(
+ createReplyController({} as InboxView, id, 'a'.repeat(64), {
+ lookupPeer: () => {
+ lookups++;
+ throw Error('must not query');
+ }
+ })
+ ).toBeUndefined();
+ expect(lookups).toBe(0);
+ });
+ it('plain copied reply tokens expose no private body or lifecycle state', () => {
+ const fake = Object.freeze({}) as ReplyController;
+ expect(replySnapshot(fake)).toBeUndefined();
+ expect(replyText(fake)).toBeUndefined();
+ expect(
+ updateReplyText(fake, 'Private sentinel', 'reviewed_private_text')
+ ).toBe(false);
+ closeReplyController(fake);
+ expect(replyText(fake)).toBeUndefined();
+ });
+ it('fake Send cannot manufacture native reservation or remote success', async () => {
+ expect(
+ await sendReply({} as ReplyController, 'reviewed_reply_send')
+ ).toEqual({ status: 'invalid' });
+ expect(await sendReply({} as ReplyController, undefined)).toEqual({
+ status: 'invalid'
+ });
+ });
+ it('fake dirty-navigation tokens cannot discard a genuine draft', () => {
+ const fake = {} as ReplyController;
+ expect(requestReplyNavigation(fake)).toBe('invalid');
+ expect(keepReplyEditing(fake)).toBe(false);
+ expect(discardReplyNavigation(fake, 'reviewed_discard_private_text')).toBe(
+ 'invalid'
+ );
+ });
+ it('same-owner strings and copied rooms cannot issue an authenticated reply rumor', () => {
+ expect(
+ captureAuthenticatedReplyRumor(
+ {} as IdentitySession,
+ {} as PrivateSession,
+ {} as UnlockedSession,
+ {
+ owner: 'a'.repeat(64),
+ peer: 'b'.repeat(64),
+ rumorId: 'c'.repeat(64)
+ } as unknown as AdmittedConversation,
+ 'Reply must not redirect to a body contact',
+ 1700000000
+ )
+ ).toBeUndefined();
+ });
+});
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -511,7 +511,7 @@ async function inboxPresentationAdmission(web) {
'src/lib/components/InboxStatus.svelte':
'29f17df1ccece671ea2ba57578dc028fa541ce924e1cdc4b3e7753da500da53f',
'src/lib/messaging/inbox-view.ts':
- '7a66afb2a1dad62f6c8c8a4753f8129d4a1fcd2b00116edbab6ac422f489d83f',
+ 'ba082b95304ef931dde530b846a986cbf492f82d16a4fb04ffc9448f5b21ee81',
'src/lib/messaging/inbox-sync.ts':
'84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae',
'src/lib/messaging/inbox-setup-view.ts':
@@ -523,15 +523,21 @@ async function inboxPresentationAdmission(web) {
'src/lib/messaging/inbox-list.ts':
'9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5',
'src/lib/components/ConversationThread.svelte':
- 'accd91eb5b5ada0f07158dbe7ddfccdd3af65f92536427d0a717a7c18aad7aca',
+ 'beb2fa152de393ffd6edf2fa42f4eb14376983e05e7624292f3f8c60eea57dc0',
'src/lib/components/MessageItem.svelte':
- '7a33a603f806686c29f5b9faec2758f8b78339593d7a7aefa1a3ec1c7ce6f01e',
+ '50c7f7b2f41c46c45ac59013daeed915d116375b45b9f846e06051695aa3c6a8',
'src/lib/messaging/conversation-thread.ts':
'7367f0e6d96a9f249514f66c2459274e856eb83462523e37264d4cd97d2e36d1',
'src/lib/persistence/private-storage.ts':
'e45a95c9b12e8534a6ab0a4ec8ee1c86e730bba2f252dc1947954439720f2bfc',
'src/routes/messages/[conversationId=local_id]/+page.svelte':
- 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7'
+ 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7',
+ 'src/lib/components/MessageComposer.svelte':
+ '9fd8221ab7c9c2d2d0e6626dc8d37b7c95de82b65804dc8766a7f756363c68ae',
+ 'src/lib/messaging/reply-controller.ts':
+ 'c13f1395b5317febcd23396babbcc116065ff96e8cbeb29c8eadfdfc14e45c2d',
+ 'src/lib/messaging/rumor-plan.ts':
+ '11a672d05a1eaf680b8039bd4c0986754b64f7103034c698843dc24d0560e0f5'
};
for (const [name, pin] of Object.entries(producers)) {
const bytes = await readOwned(web, name);
@@ -1048,10 +1054,12 @@ export async function auditOutput(webDirectory) {
'nodes/5',
[
'public-key',
+ 'private-handles',
'public-runtime',
'client',
'Button',
'client.svelte',
+ 'navigation',
'state',
'view-context',
'legacy',