commit 9275c6754b3c581b1e5a2561aa2df3ec22d27c29
parent a7f9a61c7ea54fe8ee60f0e8100dbfbaa4f32f20
Author: triesap <tyson@radroots.org>
Date: Wed, 7 Oct 2026 13:30:11 +0000
web: wire the reusable inbox setup panel (HCP-070)
- Show exact current and proposed inbox preference destinations.
- Connect explicit setup controls to owned preference and access workflows.
- Fence cancellation and reconnects while preserving caller drafts.
- Verify shared SSR, browser behavior and exact compiler output admission.
Diffstat:
14 files changed, 1713 insertions(+), 67 deletions(-)
diff --git a/web/src/lib/components/AccountGate.svelte b/web/src/lib/components/AccountGate.svelte
@@ -1,7 +1,7 @@
<script lang="ts">
import { getContext, onMount } from 'svelte';
import CapabilityGate from './CapabilityGate.svelte';
- import Button from './primitives/Button.svelte';
+ import InboxSetup from './InboxSetup.svelte';
import {
IDENTITY_VIEW_CONTEXT,
identityViewSnapshot,
@@ -48,5 +48,5 @@
<p class="notice">
Private views and editing are unavailable during development.
</p>
- <Button label="Unlock" disabled />
+ <InboxSetup />
</div>
diff --git a/web/src/lib/components/InboxSetup.svelte b/web/src/lib/components/InboxSetup.svelte
@@ -0,0 +1,317 @@
+<script lang="ts">
+ import { getContext, onMount } from 'svelte';
+ import Button from './primitives/Button.svelte';
+ import {
+ IDENTITY_VIEW_CONTEXT,
+ subscribeIdentityView,
+ type IdentityViewContext
+ } from '../runtime/view-context.ts';
+ import {
+ PUBLIC_RUNTIME_CONTEXT,
+ publicRuntimeReady,
+ type PublicRuntimeContext,
+ type PublicRuntime
+ } from '../runtime/public-runtime.ts';
+ import {
+ createRuntimeInboxSetupView,
+ inboxSetupViewSnapshot,
+ subscribeInboxSetupView,
+ checkInboxSetupView,
+ reviewInboxSetupView,
+ enableInboxSetupView,
+ unlockInboxSetupView,
+ readbackInboxSetupView,
+ stopInboxSetupView,
+ closeInboxSetupView,
+ type InboxSetupView
+ } from '../messaging/inbox-setup-view.ts';
+ let { controller }: { controller?: InboxSetupView } = $props();
+ const identityContext = getContext<IdentityViewContext>(
+ IDENTITY_VIEW_CONTEXT
+ );
+ const publicContext = getContext<PublicRuntimeContext>(
+ PUBLIC_RUNTIME_CONTEXT
+ );
+ let owned = $state.raw<InboxSetupView | undefined>(),
+ panel = $state(inboxSetupViewSnapshot(undefined)),
+ selected = $state<string[]>([]),
+ removeTags = $state<number[]>([]),
+ removeFields = $state<string[]>([]);
+ let runtime: PublicRuntime | undefined;
+ let off = () => {};
+ onMount(() => {
+ let disposed = false;
+ function acquire() {
+ if (disposed) return;
+ if (owned) {
+ // An injected genuine owner belongs to its caller. The production
+ // context must retire its own old generation before reconnecting.
+ if (controller || inboxSetupViewSnapshot(owned).owner) return;
+ off();
+ closeInboxSetupView(owned);
+ owned = undefined;
+ panel = inboxSetupViewSnapshot(undefined);
+ selected = [];
+ removeTags = [];
+ removeFields = [];
+ }
+ owned =
+ controller ??
+ (runtime && createRuntimeInboxSetupView(identityContext, runtime));
+ if (owned)
+ off = subscribeInboxSetupView(owned, (next) => {
+ panel = next;
+ });
+ }
+ const identityOff = identityContext
+ ? subscribeIdentityView(identityContext, acquire)
+ : () => {};
+ acquire();
+ if (!controller && publicContext)
+ void publicRuntimeReady(publicContext)
+ .then((value) => {
+ if (disposed) return;
+ runtime = value;
+ acquire();
+ })
+ .catch(() => {
+ /* Keep unavailable panel without acquiring any effects. */
+ });
+ return () => {
+ disposed = true;
+ identityOff();
+ off();
+ closeInboxSetupView(owned);
+ };
+ });
+ function originalFields(wire: string | null): {
+ tags: unknown[];
+ extras: string[];
+ } {
+ if (!wire) return { tags: [], extras: [] };
+ try {
+ const value: unknown = JSON.parse(wire);
+ if (!value || typeof value !== 'object' || Array.isArray(value))
+ return { tags: [], extras: [] };
+ const row = value as Record<string, unknown>;
+ const extras: string[] = [];
+ function appendExtra(key: string) {
+ extras.push(key);
+ }
+ for (const key in row) {
+ if (
+ ![
+ 'id',
+ 'pubkey',
+ 'sig',
+ 'kind',
+ 'created_at',
+ 'tags',
+ 'content'
+ ].includes(key)
+ )
+ appendExtra(key);
+ }
+ return {
+ tags: Array.isArray(row.tags) ? row.tags : [],
+ extras
+ };
+ } catch {
+ return { tags: [], extras: [] };
+ }
+ }
+ const original = $derived(originalFields(panel.currentWire));
+ function advertisedRelays(wire: string): string[] {
+ const relays: string[] = [];
+ function append(origin: string) {
+ relays.push(origin);
+ }
+ for (const tag of originalFields(wire).tags) {
+ if (
+ Array.isArray(tag) &&
+ tag.length === 2 &&
+ tag[0] === 'relay' &&
+ typeof tag[1] === 'string'
+ )
+ append(tag[1]);
+ }
+ return relays;
+ }
+ const proposedRelays = $derived(
+ panel.preview ? advertisedRelays(panel.preview.wire) : []
+ );
+ const messages: Record<string, string> = {
+ not_checked:
+ 'Check your observed public inbox preference before making changes.',
+ checking: 'Checking your public inbox preference.',
+ lookup_incomplete:
+ 'The lookup is incomplete. Your current inbox preference is unknown.',
+ not_observed:
+ 'No preference was observed in this completed bounded lookup. This does not prove global absence.',
+ needs_review: 'Review your observed configuration before changing it.',
+ compatible:
+ 'Your observed preference is compatible with the configured destinations. Unlock to check inbox access.',
+ review: 'Review the exact public replacement before enabling your inbox.',
+ approval_wait:
+ 'Preparing your inbox setup. Extension approvals or named relay acceptance may be pending. Another approval may be needed.',
+ awaiting_readback:
+ 'Relay acceptance and exact readback are separate facts.',
+ checking_readback:
+ 'Checking the exact signed preference on the discovery path.',
+ access_unavailable: 'Inbox access has not been qualified and exercised.',
+ compatible_existing:
+ 'Your existing inbox configuration and exercised access are confirmed for this session.',
+ verified:
+ 'Preference acceptance, exact readback and exercised inbox access are confirmed for this session.',
+ paused: 'Inbox setup is paused. Your unsent text stays in this page.',
+ unavailable:
+ 'Inbox setup is unavailable. Connect a messaging-capable extension and use qualified inbox sources.',
+ storage_unavailable:
+ 'Browser storage is unavailable. The preference change has not been confirmed.',
+ conflict:
+ 'A conflicting inbox preference was observed. Check the current preference and review again.',
+ stopped:
+ 'Setup stopped. Review the original operation before any further action.',
+ needs_action:
+ 'The preference operation needs attention. Setup is not complete.'
+ };
+</script>
+
+<section class="stack" aria-label="Inbox setup">
+ <h2>Reply inbox</h2>
+ <p role="status" aria-live="polite">
+ {messages[panel.status] ??
+ 'Setup could not continue. Check your current preference before trying again.'}
+ </p>
+ <p>
+ A relay stores encrypted messages for retrieval. Enabling an inbox changes
+ your public preference; it does not send your enquiry or publish a listing.
+ </p>
+ {#if panel.owner}<p>Public key: <code>{panel.owner}</code></p>{/if}
+ <Button
+ label="Check current preference"
+ disabled={!owned || panel.busy}
+ onclick={() => {
+ void checkInboxSetupView(owned);
+ }}
+ />
+ {#if panel.currentWire}
+ <h3>Current observed destinations</h3>
+ <ul aria-label="Current observed inbox destinations">
+ {#each panel.existingInboxes as origin, index (index)}<li>
+ {origin}
+ </li>{/each}
+ </ul>
+ <details>
+ <summary>Exact current public preference</summary>
+ <pre>{panel.currentWire}</pre>
+ </details>
+ {/if}
+ {#if panel.status === 'compatible' || panel.status === 'access_unavailable' || panel.status === 'awaiting_readback'}
+ <Button
+ label="Unlock inbox"
+ disabled={!owned || panel.busy}
+ onclick={() => {
+ void unlockInboxSetupView(owned);
+ }}
+ />
+ {/if}
+ {#if panel.status !== 'compatible' && panel.availableInboxes.length > 0 && panel.currentWire !== undefined && !panel.busy && panel.status !== 'review' && panel.status !== 'awaiting_readback'}
+ <fieldset>
+ <legend>Select 1–3 configured inboxes</legend>
+ {#each panel.availableInboxes as origin (origin)}
+ <label
+ ><input
+ type="checkbox"
+ bind:group={selected}
+ value={origin}
+ />{origin}</label
+ >
+ {/each}
+ </fieldset>
+ {#if original.tags.length > 0 || original.extras.length > 0}
+ <details>
+ <summary>Explicit removals from the replacement</summary>
+ <p>
+ Existing entries remain unless you select their removal. Unsupported
+ extra fields require an explicit decision before replacement.
+ </p>
+ {#each original.tags as tag, index (index)}<label
+ ><input
+ type="checkbox"
+ bind:group={removeTags}
+ value={index}
+ />Remove entry {index + 1}:
+ <code>{JSON.stringify(tag)}</code></label
+ >{/each}
+ {#each original.extras as field (field)}<label
+ ><input
+ type="checkbox"
+ bind:group={removeFields}
+ value={field}
+ />Remove extra field {field}</label
+ >{/each}
+ </details>
+ {/if}
+ <Button
+ label="Review inbox change"
+ disabled={!owned ||
+ panel.busy ||
+ selected.length < 1 ||
+ selected.length > 3}
+ onclick={() => {
+ void reviewInboxSetupView(owned, selected, removeTags, removeFields);
+ }}
+ />
+ {/if}
+ {#if panel.preview}
+ <h3>Selected configured reply inboxes</h3>
+ <ul>
+ {#each panel.preview.selectedInboxes as origin (origin)}<li>
+ {origin}
+ </li>{/each}
+ </ul>
+ <h3>Proposed public inbox destinations</h3>
+ <ul aria-label="Proposed public inbox destinations">
+ {#each proposedRelays as origin, index (index)}<li>{origin}</li>{/each}
+ </ul>
+ <p>{panel.preview.globalEffect}</p>
+ <h3>Public preference publication destinations</h3>
+ <ul>
+ {#each panel.preview.destinations as origin (origin)}<li>
+ {origin}
+ </li>{/each}
+ </ul>
+ <details open>
+ <summary>Exact proposed public preference</summary>
+ <pre>{panel.preview.wire}</pre>
+ </details>
+ <Button
+ label="Enable inbox"
+ variant="primary"
+ disabled={panel.busy}
+ onclick={() => {
+ void enableInboxSetupView(owned);
+ }}
+ />
+ {/if}
+ {#each panel.accepted as origin, index (index)}<p>
+ Accepted by {origin}
+ </p>{/each}
+ {#each panel.readback as origin (origin)}<p>
+ Exact signed preference read back from {origin}
+ </p>{/each}
+ {#if panel.accepted.length > 0}<Button
+ label="Check acceptance and readback"
+ disabled={panel.busy}
+ onclick={() => {
+ void readbackInboxSetupView(owned);
+ }}
+ />{/if}
+ <Button
+ label="Not now"
+ onclick={() => {
+ stopInboxSetupView(owned);
+ }}
+ />
+</section>
diff --git a/web/src/lib/messaging/inbox-setup-view.ts b/web/src/lib/messaging/inbox-setup-view.ts
@@ -0,0 +1,533 @@
+import {
+ readRelayPolicy,
+ inboxRelayTargets,
+ type RelayPolicy
+} from '../config/relays.ts';
+import { deploymentRelayPolicy } from '../config/deployment-relays.ts';
+import {
+ identityMessagingOwnership,
+ subscribeIdentityInvalidation,
+ type IdentitySession
+} from '../runtime/identity-session.ts';
+import {
+ createPrivateSession,
+ closePrivateSession,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import {
+ identityViewSession,
+ type IdentityViewContext
+} from '../runtime/view-context.ts';
+import {
+ createPublicView,
+ beginPublicViewRun,
+ disposePublicView,
+ type PublicRuntime
+} from '../runtime/public-runtime.ts';
+import {
+ resolveInboxPreference,
+ inboxResolutionSnapshot,
+ closeInboxResolver,
+ type InboxResolver
+} from './resolve-inbox.ts';
+import {
+ inboxPreferenceSnapshot,
+ inboxPreferenceWire
+} from '../nostr/inbox-preferences.ts';
+import {
+ reviewInboxSetup,
+ inboxSetupPreview,
+ type InboxSetupReview
+} from './inbox-setup.ts';
+import {
+ beginInboxPreferenceOperation,
+ runInboxPreferenceOperation,
+ stopInboxPreferenceOperation,
+ type InboxPreferenceAction
+} from './inbox-setup-operation.ts';
+import {
+ openBrowserDatabase,
+ closeBrowserDatabase,
+ type BrowserDatabase
+} from '../persistence/database.ts';
+import {
+ createPublicQuotaRepository,
+ loadPreferenceOperation,
+ type PublicQuotaRepository
+} from '../persistence/quota.ts';
+import {
+ publicRecordSnapshot,
+ type PublicRecordHandle
+} from '../persistence/records.ts';
+import {
+ resolveInboxReadback,
+ inboxReadbackSnapshot,
+ closeInboxReadback,
+ type InboxReadback
+} from '../nostr/inbox-readback.ts';
+import {
+ existingInboxSetupSnapshot,
+ verifyInboxSetupOperation
+} from './inbox-setup-verification.ts';
+import type { ObserveInboxAccess } from './readiness.ts';
+declare const viewBrand: unique symbol;
+export type InboxSetupView = Readonly<{ [viewBrand]: true }>;
+export type InboxSetupViewSnapshot = Readonly<{
+ status: string;
+ busy: boolean;
+ owner?: string;
+ currentWire: string | null;
+ existingInboxes: string[];
+ availableInboxes: string[];
+ preview?: NonNullable<ReturnType<typeof inboxSetupPreview>>;
+ accepted: string[];
+ readback: string[];
+ setupComplete: boolean;
+}>;
+// Internal trusted orchestration ports require real opaque discovery/readback
+// owners. Neither displayed facts nor caller booleans admit a preference effect.
+type Inputs = Readonly<{
+ identity: IdentitySession;
+ policy: RelayPolicy;
+ lookup(): Promise<InboxResolver>;
+ readback?(
+ record: PublicRecordHandle,
+ owner: string,
+ id: string
+ ): InboxReadback | undefined;
+ observeAccess?: ObserveInboxAccess;
+ now?(): number;
+ close?(): void;
+}>;
+type Controller = {
+ snapshot(): InboxSetupViewSnapshot;
+ subscribe(listener: (state: InboxSetupViewSnapshot) => void): () => void;
+ check(): Promise<void>;
+ review(
+ selected: string[],
+ removeTags: number[],
+ removeFields: string[]
+ ): Promise<void>;
+ enable(): Promise<void>;
+ unlock(): Promise<void>;
+ readback(): Promise<void>;
+ stop(): void;
+ close(): void;
+};
+const views = new WeakMap<InboxSetupView, Controller>();
+const unavailable = (): InboxSetupViewSnapshot => ({
+ status: 'unavailable',
+ busy: false,
+ currentWire: null,
+ existingInboxes: [],
+ availableInboxes: [],
+ accepted: [],
+ readback: [],
+ setupComplete: false
+});
+export function createInboxSetupView(
+ input: Inputs
+): InboxSetupView | undefined {
+ if (typeof window === 'undefined') return undefined;
+ const initial = identityMessagingOwnership(input.identity);
+ if (!initial || !initial.current()) return undefined;
+ const capture = initial;
+ const manifest = readRelayPolicy(input.policy);
+ const available = manifest.inbox
+ .filter(
+ ({ read, write, origin }) =>
+ read && write && !manifest.operatorDenylist.includes(origin)
+ )
+ .map((row) => row.origin);
+ const token = Object.freeze({}) as InboxSetupView;
+ let state = {
+ ...unavailable(),
+ status: 'not_checked',
+ owner: capture.owner,
+ availableInboxes: available
+ },
+ epoch = 0,
+ closed = false;
+ let resolver: InboxResolver | undefined,
+ review: InboxSetupReview | undefined,
+ action: InboxPreferenceAction | undefined,
+ database: BrowserDatabase | undefined,
+ repository: PublicQuotaRepository | undefined,
+ session: PrivateSession | undefined,
+ reader: InboxReadback | undefined,
+ command: string | undefined;
+ const listeners = new Map<symbol, (state: InboxSetupViewSnapshot) => void>();
+ const current = (generation = epoch) =>
+ !closed && generation === epoch && capture.current();
+ const snapshot = () => {
+ if (closed) return { ...unavailable(), status: 'closed' };
+ if (!capture.current()) return unavailable();
+ return JSON.parse(JSON.stringify(state)) as InboxSetupViewSnapshot;
+ };
+ function notify() {
+ for (const listener of listeners.values()) {
+ try {
+ listener(snapshot());
+ } catch {
+ /* Isolate presentation observers. */
+ }
+ }
+ }
+ function update(status: string, busy = state.busy) {
+ state = { ...state, status, busy };
+ notify();
+ }
+ function inspect() {
+ if (!resolver || !current()) return;
+ const observed = inboxResolutionSnapshot(resolver);
+ if (!current() || observed.author !== capture.owner) return;
+ const head = observed.head && inboxPreferenceSnapshot(observed.head);
+ state = {
+ ...state,
+ currentWire: observed.head
+ ? (inboxPreferenceWire(observed.head) ?? null)
+ : null,
+ existingInboxes: head?.relays.slice() ?? [],
+ setupComplete: false
+ };
+ if (
+ observed.coverage !== 'bounded-eose' ||
+ observed.status === 'inconclusive'
+ ) {
+ update('lookup_incomplete');
+ return;
+ }
+ const compatible =
+ head?.status === 'supported' &&
+ inboxRelayTargets(input.policy, head.relays, 'read').length > 0 &&
+ inboxRelayTargets(input.policy, head.relays, 'write').length > 0;
+ update(
+ compatible
+ ? 'compatible'
+ : observed.status === 'missing'
+ ? 'not_observed'
+ : 'needs_review'
+ );
+ }
+ async function work(
+ status: string,
+ perform: (generation: number) => Promise<void>
+ ) {
+ if (!current() || state.busy) return;
+ const generation = epoch;
+ update(status, true);
+ if (!current(generation)) return;
+ try {
+ await perform(generation);
+ } catch {
+ if (current(generation)) update('unavailable');
+ } finally {
+ if (current(generation)) {
+ state = { ...state, busy: false };
+ notify();
+ }
+ }
+ }
+ function stop() {
+ epoch++;
+ if (action) stopInboxPreferenceOperation(action);
+ review = undefined;
+ state = { ...state, preview: undefined, setupComplete: false };
+ if (reader) closeInboxReadback(reader);
+ reader = undefined;
+ if (resolver) closeInboxResolver(resolver);
+ resolver = undefined;
+ update('paused', false);
+ }
+ const invalidate = subscribeIdentityInvalidation(input.identity, () => {
+ if (!capture.current()) stop();
+ });
+ views.set(token, {
+ snapshot,
+ subscribe(listener) {
+ const id = Symbol();
+ listeners.set(id, listener);
+ try {
+ listener(snapshot());
+ } catch {
+ /* Isolate presentation observers. */
+ }
+ return () => {
+ listeners.delete(id);
+ };
+ },
+ check: () =>
+ work('checking', async (generation) => {
+ if (resolver) closeInboxResolver(resolver);
+ const found = await input.lookup();
+ if (!current(generation)) {
+ closeInboxResolver(found);
+ return;
+ }
+ resolver = found;
+ review = undefined;
+ state = { ...state, preview: undefined };
+ inspect();
+ }),
+ review: (selected, removeTags, removeFields) =>
+ work('reviewing', async (generation) => {
+ if (!resolver) {
+ update('lookup_incomplete');
+ return;
+ }
+ inspect();
+ if (!current(generation) || state.status === 'compatible') return;
+ const result = await reviewInboxSetup(
+ input.identity,
+ resolver,
+ input.policy,
+ JSON.stringify({
+ selectedInboxes: selected,
+ removeTagIndices: removeTags,
+ removeExtraFields: removeFields,
+ createdAt: (input.now ?? (() => Math.floor(Date.now() / 1000)))()
+ }),
+ input.now
+ );
+ if (!current(generation)) return;
+ if (result.status !== 'review') {
+ update(result.reason);
+ return;
+ }
+ review = result.review;
+ state = { ...state, preview: inboxSetupPreview(review) };
+ update('review');
+ }),
+ enable: () =>
+ work('approval_wait', async (generation) => {
+ if (
+ !review ||
+ state.preview === undefined ||
+ !manifest.postingEnabled ||
+ !manifest.messagingEnabled
+ ) {
+ update('unavailable');
+ return;
+ }
+ const opened = await openBrowserDatabase();
+ if (!current(generation)) {
+ if (opened.state === 'ready') closeBrowserDatabase(opened.owner);
+ return;
+ }
+ if (opened.state !== 'ready') {
+ update('storage_unavailable');
+ return;
+ }
+ if (database) closeBrowserDatabase(database);
+ database = opened.owner;
+ repository = createPublicQuotaRepository(database, capture.owner);
+ if (!repository) {
+ update('storage_unavailable');
+ return;
+ }
+ command = crypto.randomUUID();
+ const prepared = await beginInboxPreferenceOperation(
+ repository,
+ input.identity,
+ input.policy,
+ review,
+ command,
+ input.lookup,
+ 'reviewed_global_inbox_replacement'
+ );
+ if (!current(generation)) {
+ if (prepared.status === 'prepared')
+ stopInboxPreferenceOperation(prepared.action);
+ return;
+ }
+ if (prepared.status !== 'prepared') {
+ update(prepared.status);
+ return;
+ }
+ action = prepared.action;
+ const result = await runInboxPreferenceOperation(action);
+ if (!current(generation)) return;
+ const stored = await loadPreferenceOperation(repository, command);
+ if (!current(generation)) return;
+ const row =
+ stored.ok &&
+ publicRecordSnapshot(stored.value, capture.owner, command);
+ state = {
+ ...state,
+ accepted:
+ row && row.family === 'preference_operation'
+ ? row.receipts
+ .filter(
+ (fact) =>
+ fact.status === 'accepted' &&
+ fact.eventId === row.artifact?.eventId
+ )
+ .map((fact) => fact.origin)
+ : [],
+ setupComplete: false
+ };
+ review = undefined;
+ state = { ...state, preview: undefined };
+ update(
+ result.status === 'completed' ? 'awaiting_readback' : result.status
+ );
+ }),
+ unlock: () =>
+ work('approval_wait', async (generation) => {
+ const acquired = await createPrivateSession(
+ input.identity,
+ 'reviewed_private_session'
+ );
+ if (!current(generation)) {
+ if (acquired) closePrivateSession(acquired);
+ return;
+ }
+ session = acquired;
+ if (!session || !resolver) {
+ update('unavailable');
+ return;
+ }
+ const result = existingInboxSetupSnapshot(
+ input.identity,
+ session,
+ input.policy,
+ resolver,
+ input.observeAccess
+ );
+ if (!current(generation)) return;
+ state = { ...state, setupComplete: result.setupComplete };
+ update(result.status);
+ }),
+ readback: () =>
+ work('checking_readback', async (generation) => {
+ if (!repository || !command || !input.readback) {
+ update('awaiting_readback');
+ return;
+ }
+ if (!reader) {
+ const stored = await loadPreferenceOperation(repository, command);
+ if (!current(generation)) return;
+ if (!stored.ok) {
+ update('storage_unavailable');
+ return;
+ }
+ reader = input.readback(stored.value, capture.owner, command);
+ }
+ const observation = reader && inboxReadbackSnapshot(reader);
+ if (!observation || observation.status === 'pending') {
+ update('awaiting_readback');
+ return;
+ }
+ state = { ...state, readback: observation.sources.slice() };
+ const result = await verifyInboxSetupOperation(
+ repository,
+ input.identity,
+ session,
+ input.policy,
+ reader!,
+ input.observeAccess
+ );
+ if (!current(generation)) return;
+ state = { ...state, setupComplete: result.setupComplete };
+ closeInboxReadback(reader!);
+ reader = undefined;
+ update(result.status);
+ }),
+ stop,
+ close() {
+ if (closed) return;
+ closed = true;
+ stop();
+ invalidate();
+ if (resolver) closeInboxResolver(resolver);
+ if (session) closePrivateSession(session);
+ if (database) closeBrowserDatabase(database);
+ input.close?.();
+ listeners.clear();
+ }
+ });
+ return token;
+}
+// Production egress always comes from the root's governed runtime and fixed
+// deployment manifest. No fixture, arbitrary relay, signing template or sender.
+export function createRuntimeInboxSetupView(
+ context: IdentityViewContext,
+ runtime: PublicRuntime
+): InboxSetupView | undefined {
+ const identity = identityViewSession(context);
+ if (!identity) return undefined;
+ const view = createPublicView(runtime);
+ try {
+ const controller = createInboxSetupView({
+ identity,
+ policy: deploymentRelayPolicy,
+ lookup: () => {
+ const owner = identityMessagingOwnership(identity);
+ if (!owner) throw new Error('inbox_owner_unavailable');
+ return Promise.resolve(
+ resolveInboxPreference(view, beginPublicViewRun(view), owner.owner)
+ );
+ },
+ readback: (record, owner, id) =>
+ resolveInboxReadback(
+ view,
+ beginPublicViewRun(view),
+ record,
+ owner,
+ id,
+ deploymentRelayPolicy
+ ),
+ close: () => disposePublicView(view)
+ });
+ if (!controller) disposePublicView(view);
+ return controller;
+ } catch {
+ disposePublicView(view);
+ return undefined;
+ }
+}
+export function inboxSetupViewSnapshot(
+ view: InboxSetupView | undefined
+): InboxSetupViewSnapshot {
+ return (view && views.get(view)?.snapshot()) || unavailable();
+}
+export function subscribeInboxSetupView(
+ view: InboxSetupView | undefined,
+ listener: (state: InboxSetupViewSnapshot) => void
+): () => void {
+ return (view && views.get(view)?.subscribe(listener)) || (() => {});
+}
+export async function checkInboxSetupView(
+ view: InboxSetupView | undefined
+): Promise<void> {
+ await (view && views.get(view)?.check());
+}
+export async function reviewInboxSetupView(
+ view: InboxSetupView | undefined,
+ selected: string[],
+ removeTags: number[],
+ removeFields: string[]
+): Promise<void> {
+ await (view && views.get(view)?.review(selected, removeTags, removeFields));
+}
+export async function enableInboxSetupView(
+ view: InboxSetupView | undefined
+): Promise<void> {
+ await (view && views.get(view)?.enable());
+}
+export async function unlockInboxSetupView(
+ view: InboxSetupView | undefined
+): Promise<void> {
+ await (view && views.get(view)?.unlock());
+}
+export async function readbackInboxSetupView(
+ view: InboxSetupView | undefined
+): Promise<void> {
+ await (view && views.get(view)?.readback());
+}
+export function stopInboxSetupView(view: InboxSetupView | undefined): void {
+ if (view) views.get(view)?.stop();
+}
+export function closeInboxSetupView(view: InboxSetupView | undefined): void {
+ if (view) views.get(view)?.close();
+}
diff --git a/web/src/lib/runtime/view-context.ts b/web/src/lib/runtime/view-context.ts
@@ -177,6 +177,14 @@ export function invalidateIdentityView(context: IdentityViewContext): void {
const owned = contexts.get(context);
owned?.invalidate();
}
+// Trusted client orchestration receives only the original opaque session. This
+// is not effect permission; each workflow still rechecks its genuine owner.
+export function identityViewSession(
+ context: IdentityViewContext
+): IdentitySession | undefined {
+ const owner = contexts.get(context);
+ return owner?.snapshot().mounted ? owner.session : undefined;
+}
// Mechanical observed-owner comparison only, never private authorization.
export function identityViewMatchesOwner(
context: IdentityViewContext,
diff --git a/web/tests/e2e/capability-gate.spec.ts b/web/tests/e2e/capability-gate.spec.ts
@@ -306,6 +306,8 @@ test.describe('actual shared inline capability component', () => {
'src/lib/runtime/view-context.ts',
'src/lib/components/AppShell.svelte',
'src/lib/components/AccountGate.svelte',
+ 'src/lib/components/InboxSetup.svelte',
+ 'src/lib/messaging/inbox-setup-view.ts',
'src/routes/+layout.svelte',
'tests/e2e/harness/capability-gate.svelte'
])
diff --git a/web/tests/e2e/harness/inbox-setup-panel.svelte b/web/tests/e2e/harness/inbox-setup-panel.svelte
@@ -0,0 +1,21 @@
+<script lang="ts">
+ import InboxSetup from '../../../src/lib/components/InboxSetup.svelte';
+ import type { InboxSetupView } from '../../../src/lib/messaging/inbox-setup-view.ts';
+ let { controller }: { controller: InboxSetupView } = $props();
+ let draft = $state('Memory-only enquiry text');
+ let sends = $state(0);
+</script>
+
+<section class="page stack">
+ <h1>HC_TEST_ONLY_INBOX_SETUP</h1>
+ <label for="fixture-draft">Memory-only enquiry</label>
+ <textarea id="fixture-draft" bind:value={draft}></textarea>
+ <p role="status">Explicit enquiry sends: {sends}</p>
+ <button
+ class="button"
+ onclick={() => {
+ sends++;
+ }}>Explicit fixture Send</button
+ >
+ <InboxSetup {controller} />
+</section>
diff --git a/web/tests/e2e/harness/inbox-setup-view.ts b/web/tests/e2e/harness/inbox-setup-view.ts
@@ -0,0 +1,57 @@
+import { mount, unmount } from 'svelte';
+import Panel from './inbox-setup-panel.svelte';
+import { makeSetupFixture, fixturePolicy, inbox } from './inbox-setup.ts';
+import {
+ makePublisherFixture,
+ closePublicPool,
+ getPublicPool
+} from './inbox-preference-publisher.ts';
+import {
+ createInboxSetupView,
+ closeInboxSetupView,
+ inboxSetupViewSnapshot
+} from '../../../src/lib/messaging/inbox-setup-view.ts';
+export { inboxSetupViewSnapshot };
+export { makeSetupFixture };
+export async function renderFixture(
+ mode: 'incomplete' | 'compatible' | 'review' | 'publish' = 'review'
+) {
+ const f =
+ mode === 'publish'
+ ? await makePublisherFixture()
+ : await makeSetupFixture(
+ mode === 'compatible' ? [['relay', inbox]] : undefined
+ );
+ const controller = createInboxSetupView({
+ identity: f.identity,
+ policy: 'policy' in f ? f.policy : fixturePolicy(),
+ lookup: () => {
+ if ('own' in f)
+ return Promise.resolve(
+ f.resolve(undefined, mode !== 'incomplete').resolver
+ );
+ return Promise.resolve(f.resolve());
+ },
+ now: () => 101
+ });
+ if (!controller) throw new Error('genuine setup controller unavailable');
+ const target = document.createElement('div');
+ document.body.append(target);
+ const mounted = mount(Panel, { target, props: { controller } });
+ return {
+ controller,
+ beforeSign(callback: () => Promise<void>) {
+ if ('beforeSign' in f) f.beforeSign(callback);
+ },
+ async close() {
+ closeInboxSetupView(controller);
+ await unmount(mounted);
+ f.close();
+ if ('policy' in f) {
+ const pool = getPublicPool(f.policy);
+ if (pool) closePublicPool(pool);
+ }
+ target.remove();
+ }
+ };
+}
diff --git a/web/tests/e2e/inbox-setup-view.spec.ts b/web/tests/e2e/inbox-setup-view.spec.ts
@@ -0,0 +1,257 @@
+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/inbox-setup-view.ts';
+declare global {
+ interface Window {
+ hcp070: typeof Fixture;
+ hcp070Fixture: Awaited<ReturnType<typeof Fixture.renderFixture>>;
+ hcp070Release?: () => void;
+ hcp070Provider?: Awaited<ReturnType<typeof Fixture.makeSetupFixture>>;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>;
+let socketServer: WebSocketServer, bundle: string, endpoint: string;
+let frames: string[] = [];
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ socketServer = new WebSocketServer({
+ host: '127.0.0.1',
+ port: 0,
+ maxPayload: 65536
+ });
+ await once(socketServer, 'listening');
+ const address = socketServer.address();
+ if (!address || typeof address === 'string')
+ throw new Error('missing loopback');
+ endpoint = 'ws://127.0.0.1:' + address.port;
+ socketServer.on('connection', (socket) =>
+ socket.on('message', (bytes) => {
+ const frame = JSON.parse(
+ Buffer.from(bytes as ArrayBuffer).toString()
+ ) as [string, { id: string }];
+ if (frame[0] === 'EVENT') {
+ frames.push(JSON.stringify(frame));
+ socket.send(JSON.stringify(['OK', frame[1].id, true, '']));
+ }
+ })
+ );
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ plugins: [svelte({ configFile: false })],
+ resolve: { conditions: ['browser'] },
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/inbox-setup-view.ts', import.meta.url)
+ ),
+ name: 'hcp070',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw new Error('missing fixture output');
+ const chunks = output.output.filter((row) => row.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => {
+ for (const socket of socketServer.clients) socket.terminate();
+ await new Promise<void>((resolve) => socketServer.close(() => resolve()));
+ await server.close();
+});
+test.beforeEach(async ({ page }) => {
+ frames = [];
+ await page.addInitScript(
+ ({ endpoint }) => {
+ const Native = window.WebSocket;
+ window.WebSocket = class extends Native {
+ constructor(url: string | URL, protocols?: string | string[]) {
+ if (String(url) !== 'wss://discovery.example.org/')
+ throw new Error('unexpected destination');
+ super(endpoint, protocols);
+ }
+ };
+ },
+ { endpoint }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(async () => {
+ window.hcp070Release?.();
+ await window.hcp070Fixture?.close();
+ window.hcp070Provider?.close();
+ });
+});
+test('production shared gate reacquires its genuine controller after disconnect and reconnect', async ({
+ page
+}) => {
+ await page.goto(server.url + '/messages');
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async () => {
+ window.hcp070Provider = await window.hcp070.makeSetupFixture();
+ });
+ const main = page.locator('#main-content');
+ const panel = main.getByRole('region', { name: 'Inbox setup' });
+ await main.getByRole('button', { name: 'Connect extension' }).click();
+ await main.getByRole('button', { name: 'Check messaging support' }).click();
+ await expect(panel.getByText(/^Public key:/)).toBeVisible();
+ await page.locator('header summary').click();
+ await page
+ .locator('header')
+ .getByRole('button', { name: 'Disconnect', exact: true })
+ .click();
+ await expect(panel.getByText(/^Public key:/)).toHaveCount(0);
+ await main.getByRole('button', { name: 'Connect extension' }).click();
+ await main.getByRole('button', { name: 'Check messaging support' }).click();
+ await expect(panel.getByText(/^Public key:/)).toBeVisible();
+ expect(frames).toEqual([]);
+});
+test('incomplete actual lookup shows uncertainty without an empty-success claim', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ window.hcp070Fixture = await window.hcp070.renderFixture('incomplete');
+ });
+ await page.getByRole('button', { name: 'Check current preference' }).click();
+ await expect(
+ page.getByText(
+ 'The lookup is incomplete. Your current inbox preference is unknown.'
+ )
+ ).toBeVisible();
+ await expect(page.getByRole('button', { name: 'Enable inbox' })).toHaveCount(
+ 0
+ );
+ expect(frames).toEqual([]);
+});
+test('inline review and Not now retain parent memory text and never send', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ window.hcp070Fixture = await window.hcp070.renderFixture();
+ });
+ await page.getByLabel('Memory-only enquiry').fill('Keep this unsent request');
+ await page.getByRole('button', { name: 'Check current preference' }).click();
+ await page.getByLabel('wss://inbox.example.org', { exact: true }).check();
+ await page.getByRole('button', { name: 'Review inbox change' }).click();
+ await expect(
+ page.getByText(
+ /This replaces your public inbox preference for other clients/
+ )
+ ).toBeVisible();
+ await expect(
+ page
+ .getByRole('list', { name: 'Current observed inbox destinations' })
+ .getByText('wss://old.example.org', { exact: true })
+ ).toBeVisible();
+ await expect(
+ page
+ .getByRole('list', { name: 'Proposed public inbox destinations' })
+ .getByText('wss://old.example.org', { exact: true })
+ ).toBeVisible();
+ await expect(
+ page
+ .getByRole('list', { name: 'Proposed public inbox destinations' })
+ .getByText('wss://inbox.example.org', { exact: true })
+ ).toBeVisible();
+ await page.getByRole('button', { name: 'Not now' }).click();
+ await expect(page.getByLabel('Memory-only enquiry')).toHaveValue(
+ 'Keep this unsent request'
+ );
+ await expect(page.getByText('Explicit enquiry sends: 0')).toBeVisible();
+ expect(frames).toEqual([]);
+});
+test('compatible observed preference offers Unlock and never a redundant replacement', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ window.hcp070Fixture = await window.hcp070.renderFixture('compatible');
+ });
+ await page.getByRole('button', { name: 'Check current preference' }).click();
+ await expect(
+ page.getByRole('button', { name: 'Unlock inbox' })
+ ).toBeVisible();
+ await expect(page.getByRole('button', { name: 'Enable inbox' })).toHaveCount(
+ 0
+ );
+ await page.getByRole('button', { name: 'Unlock inbox' }).click();
+ await expect(
+ page.getByText('Inbox access has not been qualified and exercised.')
+ ).toBeVisible();
+ expect(frames).toEqual([]);
+});
+test('Enable displays real approval wait, records named preference acceptance and never sends an enquiry', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = await window.hcp070.renderFixture('publish');
+ window.hcp070Fixture = f;
+ const wait = new Promise<void>((resolve) => {
+ window.hcp070Release = resolve;
+ });
+ f.beforeSign(() => wait);
+ });
+ await page.getByRole('button', { name: 'Check current preference' }).click();
+ await page.getByLabel('wss://inbox.example.org', { exact: true }).check();
+ await page.getByRole('button', { name: 'Review inbox change' }).click();
+ await page.getByRole('button', { name: 'Enable inbox' }).click();
+ await expect(
+ page.getByText(
+ 'Preparing your inbox setup. Extension approvals or named relay acceptance may be pending. Another approval may be needed.'
+ )
+ ).toBeVisible();
+ expect(frames).toEqual([]);
+ await page.evaluate(() => window.hcp070Release?.());
+ await expect(
+ page.getByText('Relay acceptance and exact readback are separate facts.')
+ ).toBeVisible();
+ await expect(
+ page.getByText('Accepted by wss://discovery.example.org')
+ ).toBeVisible();
+ await expect(page.getByText('Explicit enquiry sends: 0')).toBeVisible();
+ expect(frames).toHaveLength(1);
+ expect((JSON.parse(frames[0]) as [string, { kind: number }])[1].kind).toBe(
+ 10050
+ );
+});
+test('Not now during real approval wait prevents a late signature from publishing', async ({
+ page
+}) => {
+ await page.evaluate(async () => {
+ const f = await window.hcp070.renderFixture('publish');
+ window.hcp070Fixture = f;
+ const wait = new Promise<void>((resolve) => {
+ window.hcp070Release = resolve;
+ });
+ f.beforeSign(() => wait);
+ });
+ await page.getByRole('button', { name: 'Check current preference' }).click();
+ await page.getByLabel('wss://inbox.example.org', { exact: true }).check();
+ await page.getByRole('button', { name: 'Review inbox change' }).click();
+ await page.getByRole('button', { name: 'Enable inbox' }).click();
+ await expect(
+ page.getByText(
+ 'Preparing your inbox setup. Extension approvals or named relay acceptance may be pending. Another approval may be needed.'
+ )
+ ).toBeVisible();
+ await page.getByRole('button', { name: 'Not now' }).click();
+ await page.evaluate(() => window.hcp070Release?.());
+ await expect(
+ page.getByText(
+ 'Inbox setup is paused. Your unsent text stays in this page.'
+ )
+ ).toBeVisible();
+ await expect(page.getByText('Explicit enquiry sends: 0')).toBeVisible();
+ expect(frames).toEqual([]);
+});
diff --git a/web/tests/e2e/route-inventory.spec.ts b/web/tests/e2e/route-inventory.spec.ts
@@ -153,9 +153,21 @@ for (const routeCase of cases) {
'noindex'
);
await expect(
- page.getByRole('button', { name: 'Unlock', exact: true })
+ page.getByRole('button', {
+ name: 'Check current preference',
+ exact: true
+ })
).toBeDisabled();
- await expect(page.locator('main button')).toHaveCount(2);
+ await expect(page.locator('main button')).toHaveCount(3);
+ await expect(
+ page.getByRole('button', { name: 'Not now', exact: true })
+ ).toBeEnabled();
+ await expect(
+ page.getByRole('button', { name: 'Unlock inbox', exact: true })
+ ).toHaveCount(0);
+ await expect(
+ page.getByRole('button', { name: 'Enable inbox', exact: true })
+ ).toHaveCount(0);
await expect(
page
.locator('main')
diff --git a/web/tests/integration/inbox-setup-view.test.ts b/web/tests/integration/inbox-setup-view.test.ts
@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+ createInboxSetupView,
+ inboxSetupViewSnapshot
+} from '../../src/lib/messaging/inbox-setup-view.ts';
+import { createIdentitySession } from '../../src/lib/runtime/identity-session.ts';
+import { deploymentRelayPolicy } from '../../src/lib/config/deployment-relays.ts';
+await test('SSR setup construction acquires no browser identity, storage or network', () => {
+ assert.equal(typeof window, 'undefined');
+ let lookups = 0;
+ const view = createInboxSetupView({
+ identity: createIdentitySession(),
+ policy: deploymentRelayPolicy,
+ lookup: () => {
+ lookups++;
+ return Promise.reject(new Error('SSR lookup forbidden'));
+ }
+ });
+ assert.equal(view, undefined);
+ assert.equal(lookups, 0);
+ assert.equal(inboxSetupViewSnapshot(view).setupComplete, false);
+});
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -137,7 +137,7 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
const f = await fixture(t);
const files = await f.audit();
// Exact eleven-route module/page/static admission; CSS stays once-imported.
- assert.equal(files.length, 47);
+ assert.equal(files.length, 48);
// The actual SDK payload crosses the reader scratch boundary; a reused
// scratch buffer must still preserve every compiler/static byte exactly.
const sizes = await Promise.all(
@@ -218,6 +218,48 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
])
await writeFile(path.join(f.web, name), bytes);
}
+ for (const name of [
+ 'components/InboxSetup.svelte',
+ 'messaging/inbox-setup-view.ts',
+ 'runtime/view-context.ts'
+ ])
+ await check(
+ 'linked inbox setup requires exact owned source ' + name,
+ async (t) => {
+ const f = await fixture(t);
+ const file = path.join(f.web, 'src/lib', name);
+ await writeFile(
+ file,
+ (await readFile(file, 'utf8')) + '\n// changed source\n'
+ );
+ await refresh(f);
+ await assert.rejects(f.audit, /inbox compiler source/);
+ }
+ );
+ for (const name of [
+ 'private-handles',
+ 'public-runtime',
+ 'AccountGate',
+ 'Disclosure'
+ ])
+ await check(
+ 'linked inbox setup rejects changed exact compiler edge ' + name,
+ async (t) => {
+ const f = await fixture(t);
+ const file = path.join(
+ f.web,
+ '.svelte-kit/output/client/.vite/manifest.json'
+ );
+ const manifest = JSON.parse(await readFile(file, 'utf8'));
+ const entry = Object.entries(manifest).find(
+ ([, row]) => row.name === name
+ );
+ assert.ok(entry, 'Missing actual linked inbox compiler role');
+ entry[1].imports = ['forged-compiler-edge'];
+ await writeFile(file, JSON.stringify(manifest));
+ await assert.rejects(f.audit, /compiler/);
+ }
+ );
await check(
'owned root preserves its lifecycle across a 64 KiB read boundary',
async (t) => {
@@ -233,7 +275,7 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
assert.ok(Buffer.byteLength(expanded) > 64 * 1024);
await writeFile(file, expanded);
await refresh(f);
- assert.equal((await f.audit()).length, 47);
+ assert.equal((await f.audit()).length, 48);
}
);
const sdkKey =
@@ -340,7 +382,13 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
);
const m = JSON.parse(await readFile(file, 'utf8'));
const root = Object.values(m).find((v) => v.name === 'nodes/0');
- const dist = Object.entries(m).find(([, v]) => v.name === 'Disclosure');
+ const dist = Object.entries(m).find(
+ ([, v]) =>
+ v.name ===
+ (Object.values(m).some((row) => row.name === 'public-runtime')
+ ? 'public-runtime'
+ : 'Disclosure')
+ );
assert.ok(m[sdkKey] && root && dist, 'Actual successor SDK identities');
if (mutation === 'unknown-name') m[sdkKey].name = 'unapproved-sdk';
if (
@@ -350,7 +398,7 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
const entry = Object.entries(m).find(
([, v]) =>
v.name ===
- (mutation === 'missing-dist' ? 'Disclosure' : mutation.slice(8))
+ (mutation === 'missing-dist' ? dist[1].name : mutation.slice(8))
);
assert.ok(entry);
delete m[entry[0]];
@@ -568,7 +616,11 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
(record) => record.name === 'identity-session'
)
? 'identity-session'
- : 'heads';
+ : Object.values(manifest).some(
+ (record) => record.name === 'public-runtime'
+ )
+ ? 'public-runtime'
+ : 'heads';
const [identityKey, identity] = find('view-context'),
[headsKey, heads] = find(identityCompilerRole);
if (mutation === 'missing-view') delete manifest[identityKey];
@@ -720,7 +772,13 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
);
assert.ok(client);
assert.deepEqual(budget.imports, [client[0]]);
- for (const name of ['Disclosure', 'nodes/9', 'routes'])
+ for (const name of [
+ Object.values(manifest).some((row) => row.name === 'public-runtime')
+ ? 'public-runtime'
+ : 'Disclosure',
+ 'nodes/9',
+ 'routes'
+ ])
assert.ok(
Object.values(manifest)
.find((record) => record.name === name)
@@ -800,7 +858,15 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
publisher.imports = publisher.imports.filter(
(/** @type {string} */ key) =>
key !==
- find(mutation === 'publisher-budget' ? 'Button' : 'Disclosure')[0]
+ find(
+ mutation === 'publisher-budget'
+ ? 'Button'
+ : Object.values(manifest).some(
+ (row) => row.name === 'public-runtime'
+ )
+ ? 'public-runtime'
+ : 'Disclosure'
+ )[0]
);
else {
const target = mutation === 'search-publisher' ? 'nodes/9' : 'nodes/7';
@@ -869,7 +935,11 @@ await test('actual output qualification', { timeout: 180000 }, async (t) => {
assert.ok(entry, 'Missing actual compiler record ' + name);
return entry;
};
- const [sharedKey, shared] = find('Disclosure');
+ const [sharedKey, shared] = find(
+ Object.values(manifest).some((row) => row.name === 'public-runtime')
+ ? 'public-runtime'
+ : 'Disclosure'
+ );
const [budgetKey] = find('Button');
if (mutation === 'missing-shared') delete manifest[sharedKey];
else if (mutation === 'missing-navigation')
diff --git a/web/tests/unit/inbox-setup-view.test.ts b/web/tests/unit/inbox-setup-view.test.ts
@@ -0,0 +1,233 @@
+import { inboxResolverCurrentAfterSample } from '../../src/lib/messaging/resolve-inbox.ts';
+import { it, expect } from 'vitest';
+import {
+ createInboxSetupView,
+ checkInboxSetupView,
+ reviewInboxSetupView,
+ inboxSetupViewSnapshot,
+ stopInboxSetupView,
+ closeInboxSetupView,
+ subscribeInboxSetupView,
+ unlockInboxSetupView
+} from '../../src/lib/messaging/inbox-setup-view.ts';
+import {
+ makeSetupFixture,
+ fixturePolicy,
+ inbox
+} from '../e2e/harness/inbox-setup.ts';
+it('incomplete actual bounded lookup remains unknown, never global absence', async () => {
+ const f = await makeSetupFixture();
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: () => Promise.resolve(f.resolve(null, false).resolver),
+ now: () => 101
+ });
+ try {
+ await checkInboxSetupView(view);
+ const state = inboxSetupViewSnapshot(view);
+ expect(state.status).toBe('lookup_incomplete');
+ expect(state.currentWire).toBeNull();
+ expect(state.setupComplete).toBe(false);
+ expect(f.counts().signs).toBe(0);
+ } finally {
+ closeInboxSetupView(view);
+ f.close();
+ }
+});
+it('exact review preserves unknown entries and displays global effect without signing', async () => {
+ const f = await makeSetupFixture();
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: () => Promise.resolve(f.resolve().resolver),
+ now: () => 101
+ });
+ try {
+ await checkInboxSetupView(view);
+ await reviewInboxSetupView(view, [inbox], [], []);
+ const state = inboxSetupViewSnapshot(view);
+ expect(state.status).toBe('review');
+ expect(state.preview?.globalEffect).toContain('other clients');
+ expect(state.preview?.selectedInboxes).toEqual([inbox]);
+ expect(
+ (JSON.parse(state.preview!.wire) as { tags: string[][] }).tags
+ ).toEqual([...f.event.tags, ['relay', inbox]]);
+ expect(f.counts().signs).toBe(0);
+ stopInboxSetupView(view);
+ expect(inboxSetupViewSnapshot(view).preview).toBeUndefined();
+ expect(inboxSetupViewSnapshot(view).status).toBe('paused');
+ } finally {
+ closeInboxSetupView(view);
+ f.close();
+ }
+});
+it('compatible observed configuration offers Unlock without replacing a global preference', async () => {
+ const f = await makeSetupFixture([['relay', inbox]]);
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: () => Promise.resolve(f.resolve().resolver),
+ now: () => 101
+ });
+ try {
+ await checkInboxSetupView(view);
+ expect(inboxSetupViewSnapshot(view).status).toBe('compatible');
+ await reviewInboxSetupView(view, [inbox], [], []);
+ expect(inboxSetupViewSnapshot(view).preview).toBeUndefined();
+ expect(f.counts().signs).toBe(0);
+ expect(inboxSetupViewSnapshot(view).setupComplete).toBe(false);
+ } finally {
+ closeInboxSetupView(view);
+ f.close();
+ }
+});
+it('late original lookup cannot restore a stopped panel', async () => {
+ const f = await makeSetupFixture();
+ let release: (() => void) | undefined;
+ const gate = new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: async () => {
+ await gate;
+ return f.resolve().resolver;
+ }
+ });
+ try {
+ const pending = checkInboxSetupView(view);
+ stopInboxSetupView(view);
+ release?.();
+ await pending;
+ expect(inboxSetupViewSnapshot(view).status).toBe('paused');
+ expect(inboxSetupViewSnapshot(view).setupComplete).toBe(false);
+ expect(f.counts().signs).toBe(0);
+ } finally {
+ closeInboxSetupView(view);
+ f.close();
+ }
+});
+
+it('synchronous checking cancellation prevents lookup from starting', async () => {
+ const f = await makeSetupFixture();
+ let lookups = 0;
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: () => {
+ lookups++;
+ return Promise.resolve(f.resolve().resolver);
+ }
+ });
+ const unsubscribe = subscribeInboxSetupView(view, (state) => {
+ if (state.status === 'checking' && state.busy) stopInboxSetupView(view);
+ });
+ try {
+ await checkInboxSetupView(view);
+ expect(lookups).toBe(0);
+ expect(inboxSetupViewSnapshot(view).status).toBe('paused');
+ } finally {
+ unsubscribe();
+ closeInboxSetupView(view);
+ f.close();
+ }
+});
+it('synchronous approval cancellation prevents a fresh provider observation', async () => {
+ const f = await makeSetupFixture();
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: () => Promise.resolve(f.resolve().resolver)
+ });
+ const unsubscribe = subscribeInboxSetupView(view, (state) => {
+ if (state.status === 'approval_wait' && state.busy)
+ stopInboxSetupView(view);
+ });
+ try {
+ const keys = f.counts().keys;
+ await unlockInboxSetupView(view);
+ expect(f.counts().keys).toBe(keys);
+ expect(inboxSetupViewSnapshot(view).status).toBe('paused');
+ } finally {
+ unsubscribe();
+ closeInboxSetupView(view);
+ f.close();
+ }
+});
+it('Not now closes a retained incomplete discovery resolver', async () => {
+ const f = await makeSetupFixture();
+ const retained = f.resolve(null, false).resolver;
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: () => Promise.resolve(retained)
+ });
+ try {
+ await checkInboxSetupView(view);
+ expect(inboxResolverCurrentAfterSample(retained)).toBe(true);
+ stopInboxSetupView(view);
+ expect(inboxResolverCurrentAfterSample(retained)).toBe(false);
+ expect(inboxSetupViewSnapshot(view).status).toBe('paused');
+ } finally {
+ closeInboxSetupView(view);
+ f.close();
+ }
+});
+
+it('closing is terminal before notifying observers', async () => {
+ const f = await makeSetupFixture();
+ let lookups = 0;
+ let notifications = 0;
+ let restarted: Promise<void> | undefined;
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: () => {
+ lookups++;
+ return Promise.resolve(f.resolve().resolver);
+ }
+ });
+ const unsubscribe = subscribeInboxSetupView(view, (state) => {
+ notifications++;
+ if (state.status === 'paused' && !state.busy)
+ restarted = checkInboxSetupView(view);
+ });
+ try {
+ closeInboxSetupView(view);
+ await restarted;
+ expect(lookups).toBe(0);
+ expect(inboxSetupViewSnapshot(view).status).toBe('closed');
+ const settledNotifications = notifications;
+ closeInboxSetupView(view);
+ expect(notifications).toBe(settledNotifications);
+ } finally {
+ unsubscribe();
+ f.close();
+ }
+});
+
+it('closing prevents provider observation from a teardown observer', async () => {
+ const f = await makeSetupFixture();
+ let restarted: Promise<void> | undefined;
+ const view = createInboxSetupView({
+ identity: f.identity,
+ policy: fixturePolicy(),
+ lookup: () => Promise.resolve(f.resolve().resolver)
+ });
+ const unsubscribe = subscribeInboxSetupView(view, (state) => {
+ if (state.status === 'paused' && !state.busy)
+ restarted = unlockInboxSetupView(view);
+ });
+ try {
+ const keys = f.counts().keys;
+ closeInboxSetupView(view);
+ await restarted;
+ expect(f.counts().keys).toBe(keys);
+ expect(inboxSetupViewSnapshot(view).status).toBe('closed');
+ } finally {
+ unsubscribe();
+ f.close();
+ }
+});
diff --git a/web/tests/unit/route-inventory.test.ts b/web/tests/unit/route-inventory.test.ts
@@ -75,7 +75,10 @@ describe('thin protected route SSR', () => {
expect(output.body).toMatch(
/<button[^>]*disabled[^>]*>Connect extension/
);
- expect(output.body).toMatch(/<button[^>]*disabled[^>]*>Unlock/);
+ expect(output.body).toContain('Inbox setup');
+ expect(output.body).toMatch(
+ /<button[^>]*disabled[^>]*>Check current preference/
+ );
expect(output.body).not.toMatch(
/<form|<textarea|<input|PRIVATE_TEST_ONLY|naddr1/
);
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -480,6 +480,26 @@ async function preferencePublicationAdmission(web) {
}
return true;
}
+/** @param {string} web */
+async function inboxSetupAdmission(web) {
+ const gate = await readOwned(web, 'src/lib/components/AccountGate.svelte');
+ if (!gate.toString().includes("'./InboxSetup.svelte'")) return false;
+ const producers = {
+ 'src/lib/components/InboxSetup.svelte':
+ 'b6ee2ecccd3ad3e192a56b6d03178bdf222c60dcc0bcb8e2ce7b09dda3bb3bf0',
+ 'src/lib/messaging/inbox-setup-view.ts':
+ '26bf9a653c9b09ff9e7466b4b219d5292e6313b93b84db188a8b2f4f5cd979e4',
+ 'src/lib/runtime/view-context.ts':
+ 'e2329113e29db35e983270217c47d38a44d4e0491fd710395e008786b5ae7033'
+ };
+ for (const [name, pin] of Object.entries(producers)) {
+ const bytes = await readOwned(web, name);
+ publicText(bytes);
+ if (createHash('sha256').update(bytes).digest('hex') !== pin)
+ throw new Error('Invalid owned inbox compiler source');
+ }
+ return true;
+}
/** @param {string} webDirectory */
export async function auditOutput(webDirectory) {
const web = path.resolve(webDirectory);
@@ -583,9 +603,15 @@ export async function auditOutput(webDirectory) {
(await productPresentationAdmission(web));
const hasPreferencePublication =
hasPublicRuntime && (await preferencePublicationAdmission(web));
- const identityCompilerModule = hasPreferencePublication
- ? 'identity-session'
- : 'heads';
+ const hasInboxSetup =
+ hasFullRoutes &&
+ hasPublicRuntime === 'public_identity' &&
+ (await inboxSetupAdmission(web));
+ const identityCompilerModule = hasInboxSetup
+ ? 'public-runtime'
+ : hasPreferencePublication
+ ? 'identity-session'
+ : 'heads';
// Admit compiler-owned module identities, not arbitrary extensions/copy roots.
const names = new Set([
'entry/app',
@@ -628,6 +654,7 @@ export async function auditOutput(webDirectory) {
])
names.add(name);
if (hasProductPresentation) names.add('publishers');
+ if (hasInboxSetup) names.add('private-handles');
const admitted = new Map([['build-info.json', expectedMetadata]]);
const seen = new Set();
for (const [key, record] of Object.entries(manifest)) {
@@ -719,7 +746,13 @@ export async function auditOutput(webDirectory) {
if (!entry) throw new Error('Incomplete owned SDK compiler module');
return entry;
}
- const dist = requiredRecord(hasSearchPresentation ? 'Disclosure' : 'dist');
+ const dist = requiredRecord(
+ hasInboxSetup
+ ? 'public-runtime'
+ : hasSearchPresentation
+ ? 'Disclosure'
+ : 'dist'
+ );
const root = requiredRecord('nodes/0')[1];
const [budgetKey, budget] = requiredRecord(
hasPublicRuntime === 'public_identity' ? 'Button' : 'budgets'
@@ -744,7 +777,7 @@ export async function auditOutput(webDirectory) {
);
for (const consumer of hasSearchPresentation
? [
- 'Disclosure',
+ hasInboxSetup ? 'public-runtime' : 'Disclosure',
'nodes/9',
'routes',
...(hasProductPresentation ? ['nodes/7', 'publishers'] : [])
@@ -766,9 +799,11 @@ export async function auditOutput(webDirectory) {
throw new Error('Invalid owned SDK compiler identity');
equal(
sdk.imports,
- hasPublicRuntime === 'public_identity'
- ? [requiredRecord(identityCompilerModule)[0], dist[0]]
- : [dist[0]],
+ hasInboxSetup
+ ? [dist[0]]
+ : hasPublicRuntime === 'public_identity'
+ ? [requiredRecord(identityCompilerModule)[0], dist[0]]
+ : [dist[0]],
'Invalid owned SDK compiler dependency'
);
equal(
@@ -797,21 +832,23 @@ export async function auditOutput(webDirectory) {
throw new Error('Invalid owned navigation compiler dynamic imports');
equal(
dist[1].imports,
- (hasPublicRuntime === 'public_identity'
- ? [
- 'public-key',
- 'preload-helper',
- identityCompilerModule,
- 'client',
- 'Button'
- ]
- : [
- 'rolldown-runtime',
- 'preload-helper',
- 'public-key',
- 'client',
- 'budgets'
- ]
+ (hasInboxSetup
+ ? ['public-key', 'preload-helper', 'private-handles', 'Button']
+ : hasPublicRuntime === 'public_identity'
+ ? [
+ 'public-key',
+ 'preload-helper',
+ identityCompilerModule,
+ 'client',
+ 'Button'
+ ]
+ : [
+ 'rolldown-runtime',
+ 'preload-helper',
+ 'public-key',
+ 'client',
+ 'budgets'
+ ]
).map((name) => requiredRecord(name)[0]),
'Invalid owned shared compiler dependencies'
);
@@ -838,23 +875,69 @@ export async function auditOutput(webDirectory) {
'Button'
]
],
- [identityCompilerModule, ['public-key', 'Button']]
+ [
+ identityCompilerModule,
+ hasInboxSetup
+ ? ['public-key', 'preload-helper', 'private-handles', 'Button']
+ : ['public-key', 'Button']
+ ],
+ ...(hasInboxSetup
+ ? [/** @type {[string, string[]]} */ (['private-handles', []])]
+ : [])
];
for (const [name, dependencies] of identityDependencies) {
const [key, record] = requiredRecord(name);
if (
!/^_[A-Za-z0-9_-]+\.js$/.test(key) ||
Object.keys(record).some(
- (field) => !['file', 'name', 'imports'].includes(field)
+ (field) =>
+ ![
+ 'file',
+ 'name',
+ 'imports',
+ ...(hasInboxSetup && name === 'public-runtime'
+ ? ['dynamicImports']
+ : [])
+ ].includes(field)
)
)
throw new Error('Invalid owned identity compiler chunk');
equal(
- record.imports,
+ record.imports ?? [],
dependencies.map((dependency) => requiredRecord(dependency)[0]),
'Invalid owned identity compiler dependencies'
);
}
+ if (hasInboxSetup) {
+ const [disclosureKey, disclosure] = requiredRecord('Disclosure');
+ if (
+ !/^_[A-Za-z0-9_-]+\.js$/.test(disclosureKey) ||
+ Object.keys(disclosure).some(
+ (field) => !['file', 'name', 'imports'].includes(field)
+ )
+ )
+ throw new Error('Invalid owned inbox disclosure compiler identity');
+ equal(
+ disclosure.imports,
+ [requiredRecord('client')[0]],
+ 'Invalid owned inbox disclosure compiler dependencies'
+ );
+ const [, gate] = requiredRecord('AccountGate');
+ equal(
+ gate.imports,
+ [
+ 'public-key',
+ 'private-handles',
+ 'public-runtime',
+ 'client',
+ 'Button',
+ 'view-context'
+ ].map((name) => requiredRecord(name)[0]),
+ 'Invalid owned inbox compiler dependencies'
+ );
+ if (gate.dynamicImports !== undefined)
+ throw new Error('Invalid owned inbox compiler dynamic imports');
+ }
const [identityKey] = requiredRecord('view-context');
if (
!root.imports?.includes(identityKey) ||
@@ -893,67 +976,94 @@ export async function auditOutput(webDirectory) {
throw new Error('Invalid owned product compiler identity');
equal(
publisher.imports,
- (hasPublicRuntime === 'public_identity'
- ? ['public-key', identityCompilerModule, 'Disclosure', 'Button']
- : ['public-key', 'Disclosure', 'budgets']
+ (hasInboxSetup
+ ? ['public-key', identityCompilerModule, 'Button']
+ : hasPublicRuntime === 'public_identity'
+ ? ['public-key', identityCompilerModule, 'Disclosure', 'Button']
+ : ['public-key', 'Disclosure', 'budgets']
).map((name) => entry(name)[0]),
'Invalid owned product publisher compiler dependencies'
);
equal(
entry('nodes/7')[1].imports,
- (hasPublicRuntime === 'public_identity'
+ (hasInboxSetup
? [
'public-key',
'references',
identityCompilerModule,
- 'Disclosure',
'client',
'Button',
'client.svelte',
'state',
- 'publishers'
- ]
- : [
- 'rolldown-runtime',
- 'references',
'Disclosure',
- 'client',
- 'budgets',
- 'client.svelte',
- 'state',
- 'Button',
'publishers'
]
+ : hasPublicRuntime === 'public_identity'
+ ? [
+ 'public-key',
+ 'references',
+ identityCompilerModule,
+ 'Disclosure',
+ 'client',
+ 'Button',
+ 'client.svelte',
+ 'state',
+ 'publishers'
+ ]
+ : [
+ 'rolldown-runtime',
+ 'references',
+ 'Disclosure',
+ 'client',
+ 'budgets',
+ 'client.svelte',
+ 'state',
+ 'Button',
+ 'publishers'
+ ]
).map((name) => entry(name)[0]),
'Invalid owned product compiler dependencies'
);
equal(
entry('nodes/9')[1].imports,
- (hasPublicRuntime === 'public_identity'
+ (hasInboxSetup
? [
'references',
identityCompilerModule,
- 'Disclosure',
'client',
'Button',
'client.svelte',
'navigation',
'state',
- 'routes',
- 'publishers'
- ]
- : [
- 'references',
'Disclosure',
- 'client',
- 'budgets',
- 'client.svelte',
- 'navigation',
- 'state',
- 'Button',
'routes',
'publishers'
]
+ : hasPublicRuntime === 'public_identity'
+ ? [
+ 'references',
+ identityCompilerModule,
+ 'Disclosure',
+ 'client',
+ 'Button',
+ 'client.svelte',
+ 'navigation',
+ 'state',
+ 'routes',
+ 'publishers'
+ ]
+ : [
+ 'references',
+ 'Disclosure',
+ 'client',
+ 'budgets',
+ 'client.svelte',
+ 'navigation',
+ 'state',
+ 'Button',
+ 'routes',
+ 'publishers'
+ ]
).map((name) => entry(name)[0]),
'Invalid owned search product compiler dependencies'
);