app

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

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:
Mweb/src/lib/components/AccountGate.svelte | 4++--
Aweb/src/lib/components/InboxSetup.svelte | 317+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/messaging/inbox-setup-view.ts | 533+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/runtime/view-context.ts | 8++++++++
Mweb/tests/e2e/capability-gate.spec.ts | 2++
Aweb/tests/e2e/harness/inbox-setup-panel.svelte | 21+++++++++++++++++++++
Aweb/tests/e2e/harness/inbox-setup-view.ts | 57+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/inbox-setup-view.spec.ts | 257+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/route-inventory.spec.ts | 16++++++++++++++--
Aweb/tests/integration/inbox-setup-view.test.ts | 23+++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 86+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------
Aweb/tests/unit/inbox-setup-view.test.ts | 233+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/unit/route-inventory.test.ts | 5++++-
Mweb/tools/check-output.mjs | 218+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------
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' );