app

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

commit 6a7ba8c64d890df233f9cc7644cea4abab0bd41c
parent 547813797c84dcee167ecc0f7db2c8670688acf0
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 23:08:57 +0000

web: keep inline connect and inbox setup separate from Send (HCP-107)

Diffstat:
Mweb/src/lib/components/CapabilityGate.svelte | 10+++++++++-
Mweb/src/lib/components/InboxSetup.svelte | 32++++++++++++++++++++++----------
Mweb/src/lib/components/MessageComposer.svelte | 125++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------
Mweb/src/lib/components/ProductEnquiry.svelte | 163+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------
Mweb/src/lib/messaging/inbox-setup-view.ts | 14++++++++------
Mweb/src/lib/messaging/product-enquiry.ts | 16+++++++++++++++-
Aweb/src/lib/messaging/product-request-controller.ts | 578++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/resolve-inbox.ts | 29+++++++++++++++++++++++++++++
Mweb/src/lib/messaging/rumor-plan.ts | 5+++--
Mweb/tests/e2e/capability-gate.spec.ts | 1+
Aweb/tests/e2e/harness/product-request-panel.svelte | 91+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/product-request.ts | 432+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/product-request.spec.ts | 845+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 74++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------
Mweb/tests/unit/components/product-details.test.ts | 4++++
Aweb/tests/unit/product-request.test.ts | 76++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 485+++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------
17 files changed, 2737 insertions(+), 243 deletions(-)

diff --git a/web/src/lib/components/CapabilityGate.svelte b/web/src/lib/components/CapabilityGate.svelte @@ -8,6 +8,7 @@ identity, required = 'connection', compact = false, + primary = false, focusScope = '', focusTarget = 'inline', ondisconnect, @@ -17,6 +18,7 @@ identity: IdentitySnapshot; required?: 'connection' | 'messaging'; compact?: boolean; + primary?: boolean; focusScope?: string; focusTarget?: 'navbar' | 'protected' | 'inline'; ondisconnect?: () => void; @@ -112,6 +114,7 @@ {#if !compact}<p>Your private key stays in the extension.</p>{/if} <Button label="Connect extension" + variant={primary ? 'primary' : 'secondary'} disabled={identity.state === 'pending' || !onconnect} onclick={connect} /> @@ -129,5 +132,10 @@ This check asks your extension to encrypt and decrypt a disposable self-copy. It does not unlock messages or change public inbox preferences. </p> - <Button label="Check messaging support" disabled={!onprobe} onclick={probe} /> + <Button + label="Check messaging support" + variant={primary ? 'primary' : 'secondary'} + disabled={!onprobe} + onclick={probe} + /> {/if} diff --git a/web/src/lib/components/InboxSetup.svelte b/web/src/lib/components/InboxSetup.svelte @@ -1,4 +1,5 @@ <script lang="ts"> + /* global setInterval, clearInterval */ import { getContext, onMount } from 'svelte'; import Button from './primitives/Button.svelte'; import { @@ -23,9 +24,13 @@ readbackInboxSetupView, stopInboxSetupView, closeInboxSetupView, + observeInboxSetupView, type InboxSetupView } from '../messaging/inbox-setup-view.ts'; - let { controller }: { controller?: InboxSetupView } = $props(); + let { + controller, + inline = false + }: { controller?: InboxSetupView; inline?: boolean } = $props(); const identityContext = getContext<IdentityViewContext>( IDENTITY_VIEW_CONTEXT ); @@ -67,6 +72,9 @@ ? subscribeIdentityView(identityContext, acquire) : () => {}; acquire(); + const timer = inline + ? setInterval(() => observeInboxSetupView(owned), 250) + : undefined; if (!controller && publicContext) void publicRuntimeReady(publicContext) .then((value) => { @@ -79,6 +87,7 @@ }); return () => { disposed = true; + if (timer !== undefined) clearInterval(timer); identityOff(); off(); closeInboxSetupView(owned); @@ -188,13 +197,14 @@ 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 !inline || ['not_checked', 'lookup_incomplete', 'unavailable', 'conflict', 'stopped', 'needs_action'].includes(panel.status)}<Button + label="Check current preference" + variant={inline ? 'primary' : 'secondary'} + disabled={!owned || panel.busy} + onclick={() => { + void checkInboxSetupView(owned); + }} + />{/if} {#if panel.currentWire} <h3>Current observed destinations</h3> <ul aria-label="Current observed inbox destinations"> @@ -210,13 +220,14 @@ {#if panel.status === 'compatible' || panel.status === 'access_unavailable' || panel.status === 'awaiting_readback'} <Button label="Unlock inbox" + variant={inline ? 'primary' : 'secondary'} 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'} + {#if (!inline || ['needs_review', 'not_observed'].includes(panel.status)) && 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)} @@ -255,6 +266,7 @@ {/if} <Button label="Review inbox change" + variant={inline ? 'primary' : 'secondary'} disabled={!owned || panel.busy || selected.length < 1 || @@ -301,7 +313,7 @@ {#each panel.readback as origin (origin)}<p> Exact signed preference read back from {origin} </p>{/each} - {#if panel.accepted.length > 0}<Button + {#if panel.accepted.length > 0 && (!inline || ['awaiting_readback', 'needs_action'].includes(panel.status))}<Button label="Check acceptance and readback" disabled={panel.busy} onclick={() => { diff --git a/web/src/lib/components/MessageComposer.svelte b/web/src/lib/components/MessageComposer.svelte @@ -4,6 +4,18 @@ import { beforeNavigate, goto } from '$app/navigation'; import { internalHref } from '../navigation-url.ts'; import { + productRequestSnapshot, + productRequestText, + updateProductRequestText, + sendProductRequest, + requestProductRequestNavigation, + keepProductRequestEditing, + discardProductRequestNavigation, + productRequestBeforeUnload, + closeProductRequestController, + type ProductRequestController + } from '../messaging/product-request-controller.ts'; + import { replySnapshot, replyText, updateReplyText, @@ -17,10 +29,21 @@ } from '../messaging/reply-controller.ts'; let { controller, + request, + oncancel, + ondiscard, focusScope = 'enquiry' - }: { controller: ReplyController; focusScope?: 'conversation' | 'enquiry' } = - $props(); - let model = $state<ReturnType<typeof replySnapshot>>(), + }: { + controller?: ReplyController; + request?: ProductRequestController; + oncancel?: () => void; + ondiscard?: () => void; + focusScope?: 'conversation' | 'enquiry'; + } = $props(); + let model = $state< + | ReturnType<typeof replySnapshot> + | ReturnType<typeof productRequestSnapshot> + >(), text = $state(''); let destination: string | undefined, disposed = false; @@ -41,15 +64,23 @@ } function refresh() { if (disposed) return; - model = replySnapshot(controller); - text = replyText(controller) ?? ''; + model = request + ? productRequestSnapshot(request) + : controller && replySnapshot(controller); + text = + (request + ? productRequestText(request) + : controller && replyText(controller)) ?? ''; + } + function askNavigation() { + return request + ? requestProductRequestNavigation(request) + : controller + ? requestReplyNavigation(controller) + : 'invalid'; } beforeNavigate((event) => { - if ( - disposed || - requestReplyNavigation(controller) !== 'confirmation_required' - ) - return; + if (disposed || askNavigation() !== 'confirmation_required') return; event.cancel(); const url = event.to?.url; destination = @@ -65,20 +96,24 @@ return () => { disposed = true; clearInterval(timer); - closeReplyController(controller); + if (request) closeProductRequestController(request); + else if (controller) closeReplyController(controller); text = ''; model = undefined; destination = undefined; }; }); async function send() { - const work = sendReply(controller, 'reviewed_reply_send'); + const work = request + ? sendProductRequest(request, 'reviewed_product_request_send') + : controller && sendReply(controller, 'reviewed_reply_send'); refresh(); await work; refresh(); } function warnUnload(event: BeforeUnloadEvent) { - replyBeforeUnload(controller, event); + if (request) productRequestBeforeUnload(request, event); + else if (controller) replyBeforeUnload(controller, event); } </script> @@ -86,38 +121,59 @@ {#if model} <div class="stack"> - <label for={fieldId}>Reply</label> + <label for={fieldId}>{request ? 'Your message' : 'Reply'}</label> <textarea id={fieldId} value={text} disabled={model.busy || model.state === 'completed'} aria-describedby={fieldId + '-save'} oninput={(event) => { - updateReplyText( - controller, - event.currentTarget.value, - 'reviewed_private_text' - ); + if (request) + updateProductRequestText( + request, + event.currentTarget.value, + 'reviewed_private_text' + ); + else if (controller) + updateReplyText( + controller, + event.currentTarget.value, + 'reviewed_private_text' + ); refresh(); }}></textarea> <p id={fieldId + '-save'}> {model.saveCopy} Unsent text is lost when this page closes. </p> <p>{model.pairCopy}</p> - <p> - Replying moves this conversation to your inbox in this view. It does not - accept an order. - </p> + {#if !request}<p> + Replying moves this conversation to your inbox in this view. It does not + accept an order. + </p>{/if} <p>Messages do not reserve products or record payment.</p> <button type="button" class="button button--primary" - disabled={model.busy || model.state === 'completed' || !text.trim()} + disabled={model.busy || + model.state === 'completed' || + !text.trim() || + (!!request && !productRequestSnapshot(request)?.readyToSend)} onclick={() => { void send(); - }}>Send reply</button + }}>{request ? 'Send request' : 'Send reply'}</button > <p role="status" aria-live="polite">{model.copy}</p> + {#if request}<button + type="button" + class="button button--secondary" + onclick={() => { + oncancel?.(); + destination = undefined; + if (askNavigation() === 'allowed') ondiscard?.(); + refresh(); + void tick().then(focusKeep); + }}>Cancel</button + >{/if} {#if model.navigation === 'confirmation_required'} <div class="notice stack" role="group" aria-label="Unsaved private reply"> <p> @@ -132,7 +188,8 @@ ? 'conversation-keep-reply' : 'enquiry-keep-reply'} onclick={() => { - keepReplyEditing(controller); + if (request) keepProductRequestEditing(request); + else if (controller) keepReplyEditing(controller); destination = undefined; refresh(); void tick().then(focusEditor); @@ -143,13 +200,21 @@ class="button button--secondary" onclick={() => { const target = internalHref(destination); - const result = discardReplyNavigation( - controller, - 'reviewed_discard_private_text' - ); + const result = request + ? discardProductRequestNavigation( + request, + 'reviewed_discard_private_text' + ) + : controller + ? discardReplyNavigation( + controller, + 'reviewed_discard_private_text' + ) + : 'invalid'; destination = undefined; refresh(); if (result === 'allowed') { + ondiscard?.(); if (target) void goto(target); } else void tick().then(focusEditor); }}>Discard draft</button diff --git a/web/src/lib/components/ProductEnquiry.svelte b/web/src/lib/components/ProductEnquiry.svelte @@ -7,7 +7,40 @@ </script> <script lang="ts"> - import { onMount, untrack } from 'svelte'; + import { getContext, onMount, untrack } from 'svelte'; + import CapabilityGate from './CapabilityGate.svelte'; + import InboxSetup from './InboxSetup.svelte'; + import MessageComposer from './MessageComposer.svelte'; + import { + IDENTITY_VIEW_CONTEXT, + identityViewSnapshot, + identityViewSession, + subscribeIdentityView, + connectIdentityView, + probeIdentityViewMessaging, + invalidateIdentityView, + type IdentityViewContext + } from '../runtime/view-context.ts'; + import { + PUBLIC_RUNTIME_CONTEXT, + publicRuntimeReady, + type PublicRuntimeContext, + type PublicRuntime + } from '../runtime/public-runtime.ts'; + import { + createRuntimeInboxSetupView, + closeInboxSetupView, + stopInboxSetupView, + type InboxSetupView + } from '../messaging/inbox-setup-view.ts'; + import { + createProductRequestController, + configureProductRequest, + closeProductRequestController, + stopProductRequestWork, + productRequestSnapshot, + type ProductRequestController + } from '../messaging/product-request-controller.ts'; import type { ProductView, ProductViewSnapshot @@ -15,7 +48,6 @@ import { captureProductEnquiry, productEnquirySnapshot, - updateProductEnquiry, closeProductEnquiry, type ProductEnquiry } from '../messaging/product-enquiry.ts'; @@ -23,19 +55,79 @@ let { view, observation, - oncapture + oncapture, + setup, + onrequest }: { view: ProductView; observation?: ProductViewSnapshot; oncapture?: (draft: ProductEnquiry) => void; + setup?: InboxSetupView; + onrequest?: (controller: ProductRequestController) => void; } = $props(); let draft = $state.raw<ProductEnquiry | undefined>(), - captured = $state<ReturnType<typeof productEnquirySnapshot>>(); + captured = $state<ReturnType<typeof productEnquirySnapshot>>(), + workflow = $state<ReturnType<typeof productRequestSnapshot>>(), + request = $state.raw<ProductRequestController | undefined>(), + ownedSetup = $state.raw<InboxSetupView | undefined>(); + const identityContext = getContext<IdentityViewContext>( + IDENTITY_VIEW_CONTEXT + ); + const publicContext = getContext<PublicRuntimeContext>( + PUBLIC_RUNTIME_CONTEXT + ); + let identity = $state( + identityContext + ? identityViewSnapshot(identityContext).identity + : { state: 'guest' as const, reason: 'unavailable' as const } + ); + let runtime: PublicRuntime | undefined; + function acquire() { + if (!identityContext) return; + identity = identityViewSnapshot(identityContext).identity; + if (!setup && runtime && identity.state === 'messaging_capable') { + if (ownedSetup) closeInboxSetupView(ownedSetup); + ownedSetup = createRuntimeInboxSetupView(identityContext, runtime); + } + configure(); + } + function configure() { + const actor = identityContext && identityViewSession(identityContext); + const selected = setup ?? ownedSetup; + if (request && actor && selected) + configureProductRequest( + request, + actor, + selected, + 'reviewed_product_request_setup' + ); + } onMount(() => { + let alive = true; + const off = identityContext + ? subscribeIdentityView(identityContext, acquire) + : () => {}; + if (publicContext) + void publicRuntimeReady(publicContext).then((value) => { + if (alive) { + runtime = value; + acquire(); + } + }); const timer = setInterval(() => { if (draft) captured = productEnquirySnapshot(draft); + workflow = request && productRequestSnapshot(request); }, 250); - return () => clearInterval(timer); + return () => { + alive = false; + clearInterval(timer); + off(); + if (ownedSetup) closeInboxSetupView(ownedSetup); + }; + }); + $effect(() => { + void setup; + configure(); }); $effect(() => { const original = view; @@ -43,6 +135,8 @@ untrack(() => { void original; if (draft) closeProductEnquiry(draft); + if (request) closeProductRequestController(request); + request = undefined; draft = undefined; captured = undefined; }); @@ -56,11 +150,23 @@ draft = captureProductEnquiry(view, 'reviewed_product_enquiry'); captured = draft ? productEnquirySnapshot(draft) : undefined; if (draft) oncapture?.(draft); + request = draft && createProductRequestController(draft, runtime); + configure(); + if (request) onrequest?.(request); } - function edit(value: string) { - if (!draft) return; - if (updateProductEnquiry(draft, value, 'reviewed_product_enquiry_edit')) - captured = productEnquirySnapshot(draft); + function cancelSetup() { + if (request) + stopProductRequestWork(request, 'reviewed_product_request_cancel'); + if (identityContext) invalidateIdentityView(identityContext); + stopInboxSetupView(setup ?? ownedSetup); + } + function discard() { + cancelSetup(); + if (request) closeProductRequestController(request); + if (draft) closeProductEnquiry(draft); + request = undefined; + draft = undefined; + captured = undefined; } </script> @@ -69,28 +175,45 @@ <h2>Message about {captured.title}</h2> <p>Publisher: <code>{captured.peer}</code></p> <p>Advertised price (seller assertion): {captured.advertisedPrice}</p> - <label - >Your message<textarea - value={captured.text} - oninput={(event) => edit(event.currentTarget.value)}></textarea></label - > + {#if request}<MessageComposer + {request} + oncancel={cancelSetup} + ondiscard={discard} + />{/if} <details> <summary>Included product references</summary> <p>Product: <code>nostr:{captured.naddr}</code></p> <p>Viewed listing: <code>nostr:{captured.nevent}</code></p> </details> - <p>Not yet saved. Unsent text is lost when this page closes.</p> {#if !captured.listingCurrent}<p role="status"> Listing status needs review. Your unsent text is kept in memory. </p>{/if} <p> This is a message, not a confirmed order. It does not reserve the food. </p> - <Button label="Send request" disabled={true} /> - <p> - Connect and prepare your inbox to send a request. No message has been - sent. - </p> + <CapabilityGate + {identity} + required="messaging" + compact={true} + primary={true} + onconnect={identityContext + ? () => connectIdentityView(identityContext) + : undefined} + onprobe={identityContext + ? () => + probeIdentityViewMessaging(identityContext, 'reviewed_self_copy') + : undefined} + /> + {#if identity.state === 'messaging_capable'} + {#key setup ?? ownedSetup}<InboxSetup + controller={setup ?? ownedSetup} + inline={true} + />{/key} + {/if} + {#if !workflow || workflow.state === 'idle'}<p> + Connect and prepare your inbox to send a request. No message has been + sent. + </p>{/if} </section> {:else} <Button diff --git a/web/src/lib/messaging/inbox-setup-view.ts b/web/src/lib/messaging/inbox-setup-view.ts @@ -26,6 +26,7 @@ import { } from '../runtime/public-runtime.ts'; import { resolveInboxPreference, + settleInboxResolver, inboxResolutionSnapshot, closeInboxResolver, type InboxResolver @@ -89,7 +90,7 @@ export type InboxSetupViewSnapshot = Readonly<{ type Inputs = Readonly<{ identity: IdentitySession; policy: RelayPolicy; - lookup(): Promise<InboxResolver>; + lookup(current?: () => boolean): Promise<InboxResolver>; readback?( record: PublicRecordHandle, owner: string, @@ -286,7 +287,7 @@ export function createInboxSetupView( check: () => work('checking', async (generation) => { if (resolver) closeInboxResolver(resolver); - const found = await input.lookup(); + const found = await input.lookup(() => current(generation)); if (!current(generation)) { closeInboxResolver(found); return; @@ -359,7 +360,7 @@ export function createInboxSetupView( input.policy, review, command, - input.lookup, + () => input.lookup(() => current(generation)), 'reviewed_global_inbox_replacement' ); if (!current(generation)) { @@ -517,11 +518,12 @@ export function createRuntimeInboxSetupView( const controller = createInboxSetupView({ identity, policy: deploymentRelayPolicy, - lookup: () => { + lookup: (current = () => true) => { const owner = identityMessagingOwnership(identity); if (!owner) throw new Error('inbox_owner_unavailable'); - return Promise.resolve( - resolveInboxPreference(view, beginPublicViewRun(view), owner.owner) + return settleInboxResolver( + resolveInboxPreference(view, beginPublicViewRun(view), owner.owner), + () => owner.current() && current() ); }, readback: (record, owner, id) => diff --git a/web/src/lib/messaging/product-enquiry.ts b/web/src/lib/messaging/product-enquiry.ts @@ -6,7 +6,8 @@ import { captureEnquiryContext, enquiryContextSnapshot, buildEnquiryMessage, - type EnquiryContextSnapshot + type EnquiryContextSnapshot, + type EnquiryContext } from './enquiry-context.ts'; import { openInboxConversation, type InboxView } from './inbox-view.ts'; import type { MessageWireParts } from '../contracts/message-v1/index.ts'; @@ -16,11 +17,14 @@ export type ProductEnquiry = Readonly<{ readonly [enquiryBrand]: true }>; type Snapshot = EnquiryContextSnapshot & Readonly<{ text: string; + revision: number; memoryOnly: true; saved: false; listingCurrent: boolean; }>; type Owner = { + ownership(): + Readonly<{ context: EnquiryContext; current(): boolean }> | undefined; snapshot(): Snapshot | undefined; message(): MessageWireParts | undefined; update(text: unknown, review: unknown): boolean; @@ -43,6 +47,7 @@ export function captureProductEnquiry( const observed = context && enquiryContextSnapshot(context); if (!context || !observed || observed.status !== 'active') return; let active = true, + revision = 0, text = `Hello, I am interested in ${JSON.stringify(observed.title)}. Is it available?`; if (!buildEnquiryMessage(context, text)) return; function close() { @@ -58,11 +63,16 @@ export function captureProductEnquiry( } const token = Object.freeze({}) as ProductEnquiry; owners.set(token, { + ownership: () => + current() + ? { context, current: () => current() && listing.current() } + : undefined, snapshot() { return current() ? { ...observed, text, + revision, memoryOnly: true, saved: false, listingCurrent: listing.current() @@ -83,6 +93,7 @@ export function captureProductEnquiry( ) return false; text = value; + revision++; return true; }, async reuse(inbox, permission) { @@ -130,3 +141,6 @@ export function reuseProductEnquiryConversation( export function closeProductEnquiry(token: ProductEnquiry): void { owners.get(token)?.close(); } +export function productEnquirySendOwnership(token: ProductEnquiry) { + return owners.get(token)?.ownership(); +} diff --git a/web/src/lib/messaging/product-request-controller.ts b/web/src/lib/messaging/product-request-controller.ts @@ -0,0 +1,578 @@ +import { + productEnquirySnapshot, + productEnquirySendOwnership, + updateProductEnquiry, + closeProductEnquiry, + type ProductEnquiry +} from './product-enquiry.ts'; +import { + identityMessagingOwnership, + subscribeIdentityInvalidation, + type IdentitySession +} from '../runtime/identity-session.ts'; +import { + inboxSetupViewOwnership, + type InboxSetupView +} from './inbox-setup-view.ts'; +import { messagingReadinessSnapshot } from './readiness.ts'; +import { + createInboxRoutePlan, + inboxRoutePlanSnapshot +} from './inbox-routing.ts'; +import { + resolveInboxPreference, + settleInboxResolver, + closeInboxResolver, + type InboxResolver +} from './resolve-inbox.ts'; +import { + createPublicView, + beginPublicViewRun, + disposePublicView, + type PublicRuntime +} from '../runtime/public-runtime.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + type BrowserDatabase +} from '../persistence/database.ts'; +import { createPrivateStorageRepository } from '../persistence/private-storage.ts'; +import { createPrivateSendReservationRepository } from '../persistence/private-send-reservations.ts'; +import { + createPrivateComposer, + updatePrivateComposerText, + privateComposerSnapshot, + bindPrivateComposerPreparation, + closePrivateComposer, + type PrivateComposer +} from './composer-state.ts'; +import { + captureEnquiryRumor, + stopRumorPlan, + type RumorPlan +} from './rumor-plan.ts'; +import { reserveSendIdentity } from './send-identity.ts'; +import { + captureSelfRecoveryPreparation, + prepareSelfRecovery, + preparedSelfRecovery, + preparePairedDelivery, + preparedPairedDelivery, + selfRecoveryPreparationSnapshot, + type SelfRecoveryPreparation +} from './prepare-send.ts'; +import { getPrivatePool } from '../nostr/private-pool.ts'; +import { + capturePrivateRetry, + runPrivateRetry, + stopPrivateRetry, + type PrivateRetry +} from './retry-send.ts'; +import { newLocalId } from '../private-handles.ts'; +import { privateSessionOwnership } from '../runtime/private-session.ts'; + +declare const requestBrand: unique symbol; +export type ProductRequestController = Readonly<{ [requestBrand]: true }>; +type Result = Readonly<{ + status: 'invalid' | 'busy' | 'stopped' | 'needs_action' | 'completed'; +}>; +type NavigationResult = + 'invalid' | 'allowed' | 'confirmation_required' | 'review_required'; +type State = + | 'idle' + | 'checking' + | 'preparing' + | 'publishing' + | 'needs_action' + | 'completed'; +type Snapshot = Readonly<{ + state: State; + busy: boolean; + dirty: boolean; + revision: number; + readyToSend: boolean; + copy: string; + saveCopy: string; + pairCopy: string; + navigation: 'idle' | 'confirmation_required'; +}>; +type Controller = { + snapshot(): Snapshot | undefined; + text(): string | undefined; + update(text: unknown, review: unknown): boolean; + configure( + identity: IdentitySession, + setup: InboxSetupView, + review: unknown + ): boolean; + send(review: unknown): Promise<Result>; + request(): NavigationResult; + keep(): boolean; + discard(review: unknown): NavigationResult; + unload(event: BeforeUnloadEvent): boolean; + close(): void; + stop(review: unknown): boolean; +}; +const controllers = new WeakMap<ProductRequestController, Controller>(); + +// Guest allocation and configuration preserve the original enquiry memory. +// Only the reviewed Send command acquires storage, crypto or publication. +export function createProductRequestController( + enquiry: ProductEnquiry, + runtime?: PublicRuntime +): ProductRequestController | undefined { + if (typeof window === 'undefined' || !productEnquirySnapshot(enquiry)) return; + let active = true, + busy = false, + attempted = false; + let state: State = 'idle', + copy = '', + requestedRevision: number | undefined, + sentRevision: number | undefined; + let identity: IdentitySession | undefined, setup: InboxSetupView | undefined; + let composer: PrivateComposer | undefined, + database: BrowserDatabase | undefined; + let plan: RumorPlan | undefined, + preparation: SelfRecoveryPreparation | undefined, + retry: PrivateRetry | undefined; + let identityOff = () => {}, + generation = 0; + const source = runtime && createPublicView(runtime); + let resolver: InboxResolver | undefined; + function stopWork(preserveComposer = false) { + generation++; + if (preserveComposer && composer) privateComposerSnapshot(composer); + if (retry) stopPrivateRetry(retry); + if (plan) stopRumorPlan(plan); + if (!preserveComposer) { + if (composer) closePrivateComposer(composer); + composer = undefined; + } + } + function close() { + if (!active) return; + active = false; + stopWork(); + identityOff(); + closeProductEnquiry(enquiry); + if (resolver) closeInboxResolver(resolver); + if (source) disposePublicView(source); + if (database) closeBrowserDatabase(database); + } + function current() { + if (!active || !productEnquirySnapshot(enquiry)) { + close(); + return false; + } + return true; + } + function ownership() { + const actor = identity && identityMessagingOwnership(identity); + const own = inboxSetupViewOwnership(setup); + const product = productEnquirySendOwnership(enquiry); + const data = productEnquirySnapshot(enquiry); + return current() && + actor?.current() && + own?.current() && + own.identity === identity && + own.session && + product?.current() && + data && + data.peer !== actor.owner + ? { actor, own, product, data } + : undefined; + } + function ready() { + const scope = ownership(); + return ( + !!scope && + !!source && + messagingReadinessSnapshot( + identity!, + scope.own.session, + scope.own.policy, + scope.own.resolver, + undefined, + scope.own.observeAccess + ).newListingReady + ); + } + function snapshot(): Snapshot | undefined { + if (!current()) return; + const actual = productEnquirySnapshot(enquiry); + const draft = + actual?.revision === sentRevision && + composer && + privateComposerSnapshot(composer); + const workflow = + preparation && selfRecoveryPreparationSnapshot(preparation); + return { + state, + busy, + dirty: draft + ? draft.dirty + : !!productEnquirySnapshot(enquiry)?.text.trim(), + revision: actual?.revision ?? 0, + readyToSend: !attempted && ready(), + copy: + copy || + (state === 'preparing' + ? 'Preparing encryption. The extension may ask for several approvals.' + : state === 'publishing' + ? 'Publishing encrypted copies to the reviewed inbox relays.' + : ''), + saveCopy: draft + ? draft.copy + : attempted + ? 'Encrypted work needs review in this browser.' + : 'Not yet saved.', + pairCopy: workflow?.pairCopy ?? '', + navigation: + requestedRevision === undefined ? 'idle' : 'confirmation_required' + }; + } + async function send(review: unknown): Promise<Result> { + if (review !== 'reviewed_product_request_send') + return { status: 'invalid' }; + if (!current()) return { status: 'stopped' }; + if (busy) return { status: 'busy' }; + if (attempted) return { status: 'needs_action' }; + const captured = ownership(); + if ( + !captured || + !ready() || + !identity || + !source || + !captured.data.text.trim() + ) + return { status: 'invalid' }; + const actor = identity, + originalSetup = setup, + originalGeneration = generation; + const privateOwner = privateSessionOwnership(captured.own.session!); + if ( + !privateOwner?.current() || + privateOwner.owner !== captured.actor.owner || + privateOwner.session !== captured.actor.session + ) + return { status: 'invalid' }; + const admitted = () => + current() && + generation === originalGeneration && + identity === actor && + setup === originalSetup && + captured.actor.current() && + captured.own.current() && + captured.product.current() && + privateOwner.current() && + productEnquirySnapshot(enquiry)?.revision === captured.data.revision && + inboxSetupViewOwnership(originalSetup)?.session === captured.own.session; + function needsAction(): Result { + state = 'needs_action'; + copy = + 'Send needs review. Your unsent text stays in memory. Existing encrypted work requires its own recovery review.'; + return { status: 'needs_action' }; + } + busy = true; + state = 'checking'; + copy = + 'Checking the intended publisher inbox. Your text remains in memory.'; + try { + if (resolver) closeInboxResolver(resolver); + resolver = resolveInboxPreference( + source, + beginPublicViewRun(source), + captured.data.peer + ); + const other = resolver; + // Resolver observations are asynchronous; sample their original bounded + // result through the existing readiness projection, without guessing. + await settleInboxResolver(other, admitted); + if (!admitted()) return { status: 'stopped' }; + if ( + !messagingReadinessSnapshot( + actor, + captured.own.session, + captured.own.policy, + captured.own.resolver, + { author: captured.data.peer, resolver: other }, + captured.own.observeAccess + ).sendReady + ) + return needsAction(); + const routes = createInboxRoutePlan( + captured.own.policy, + captured.actor.owner, + captured.data.peer, + captured.own.resolver!, + other + ); + const routeData = routes && inboxRoutePlanSnapshot(routes); + if (!routes || !routeData || !admitted()) return needsAction(); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') return needsAction(); + database = opened.owner; + if (!admitted()) return { status: 'stopped' }; + const repository = createPrivateStorageRepository( + database, + captured.actor.owner + ); + const reservations = createPrivateSendReservationRepository( + database, + captured.actor.owner + ); + composer = createPrivateComposer(actor, 'reviewed_private_composer'); + sentRevision = captured.data.revision; + if ( + !repository || + !reservations || + !composer || + !updatePrivateComposerText( + composer, + captured.data.text, + 'reviewed_private_text' + ) + ) + return needsAction(); + plan = captureEnquiryRumor( + actor, + captured.product.context, + captured.data.text, + Math.floor(Date.now() / 1000), + admitted + ); + const command = newLocalId(); + if (!plan || !command || !admitted()) return needsAction(); + attempted = true; + const reserved = await reserveSendIdentity( + reservations, + actor, + command, + plan, + 'reviewed_private_intent' + ); + if (!admitted()) return { status: 'stopped' }; + if (!('identity' in reserved)) return needsAction(); + preparation = captureSelfRecoveryPreparation( + repository, + actor, + reserved.identity, + 'reviewed_self_recovery' + ); + if ( + !preparation || + !bindPrivateComposerPreparation( + composer, + reserved.identity, + preparation, + captured.product.context, + 'reviewed_composer_preparation' + ) + ) + return needsAction(); + state = 'preparing'; + copy = ''; + const self = await prepareSelfRecovery( + preparation, + 'reviewed_self_recovery' + ); + if (!admitted()) return { status: 'stopped' }; + if ( + !['saved', 'existing', 'reconciled'].includes(self.status) || + !preparedSelfRecovery(preparation) + ) + return needsAction(); + const context = { + plan: routes, + policy: captured.own.policy, + own: captured.own.resolver!, + other + }; + const paired = await preparePairedDelivery( + preparation, + context, + 'reviewed_pair_preparation' + ); + if (!admitted()) return { status: 'stopped' }; + const receipt = preparedPairedDelivery(preparation); + if ( + !['prepared', 'existing', 'reconciled'].includes(paired.status) || + !receipt + ) + return needsAction(); + const pool = getPrivatePool( + captured.own.session!, + captured.own.policy, + Array.from( + new Set([...routeData.peer.targets, ...routeData.archive.targets]) + ) + ); + if (!pool || !admitted()) return needsAction(); + retry = capturePrivateRetry( + repository, + captured.own.session!, + receipt, + context, + pool, + 'reviewed_private_retry' + ); + if (!retry || !admitted()) return needsAction(); + state = 'publishing'; + const delivered = await runPrivateRetry(retry, 'reviewed_private_retry'); + if (!admitted()) return { status: 'stopped' }; + if (delivered.status !== 'completed') return needsAction(); + state = 'completed'; + copy = + 'Accepted by recipient inbox relay. This does not confirm that the person read the message.'; + return { status: 'completed' }; + } catch { + return admitted() ? needsAction() : { status: 'stopped' }; + } finally { + busy = false; + } + } + const token = Object.freeze({}) as ProductRequestController; + controllers.set(token, { + snapshot, + text: () => (current() ? productEnquirySnapshot(enquiry)?.text : undefined), + update(text, review) { + if ( + review !== 'reviewed_private_text' || + !current() || + busy || + attempted || + !updateProductEnquiry(enquiry, text, 'reviewed_product_enquiry_edit') + ) + return false; + return true; + }, + configure(nextIdentity, nextSetup, review) { + if ( + review !== 'reviewed_product_request_setup' || + !current() || + attempted || + busy + ) + return false; + const actor = identityMessagingOwnership(nextIdentity), + own = inboxSetupViewOwnership(nextSetup); + if (!actor?.current() || !own?.current() || own.identity !== nextIdentity) + return false; + if (identity === nextIdentity && setup === nextSetup) return true; + stopWork(); + identityOff(); + identity = nextIdentity; + setup = nextSetup; + identityOff = subscribeIdentityInvalidation(nextIdentity, () => { + if (!actor.current()) { + stopWork(); + copy = 'Connection changed. Your unsent text stays in memory.'; + } + }); + return true; + }, + send, + stop(review) { + if (review !== 'reviewed_product_request_cancel' || !current()) + return false; + stopWork(true); + if (state !== 'completed') { + state = attempted ? 'needs_action' : 'idle'; + copy = + 'Sending is paused. Your unsent text stays in this page; existing encrypted work requires its own recovery review.'; + } + return true; + }, + request() { + if (!current()) return 'invalid'; + if (!snapshot()?.dirty) return 'allowed'; + requestedRevision = productEnquirySnapshot(enquiry)?.revision; + return 'confirmation_required'; + }, + keep() { + if (!current()) return false; + requestedRevision = undefined; + return true; + }, + discard(review) { + if ( + !current() || + review !== 'reviewed_discard_private_text' || + requestedRevision === undefined + ) + return 'invalid'; + const expected = requestedRevision; + requestedRevision = undefined; + if (expected !== productEnquirySnapshot(enquiry)?.revision) + return 'review_required'; + close(); + return 'allowed'; + }, + unload(event) { + if (!current() || !snapshot()?.dirty) return false; + event.preventDefault(); + return true; + }, + close + }); + return token; +} +export function productRequestSnapshot(token: ProductRequestController) { + return controllers.get(token)?.snapshot(); +} +export function productRequestText(token: ProductRequestController) { + return controllers.get(token)?.text(); +} +export function updateProductRequestText( + token: ProductRequestController, + text: unknown, + review: unknown +) { + return controllers.get(token)?.update(text, review) ?? false; +} +export function configureProductRequest( + token: ProductRequestController, + identity: IdentitySession, + setup: InboxSetupView, + review: unknown +) { + return controllers.get(token)?.configure(identity, setup, review) ?? false; +} +export function sendProductRequest( + token: ProductRequestController, + review: unknown +): Promise<Result> { + return ( + controllers.get(token)?.send(review) ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function requestProductRequestNavigation( + token: ProductRequestController +): NavigationResult { + return controllers.get(token)?.request() ?? 'invalid'; +} +export function keepProductRequestEditing(token: ProductRequestController) { + return controllers.get(token)?.keep() ?? false; +} +export function discardProductRequestNavigation( + token: ProductRequestController, + review: unknown +): NavigationResult { + return controllers.get(token)?.discard(review) ?? 'invalid'; +} +export function productRequestBeforeUnload( + token: ProductRequestController, + event: BeforeUnloadEvent +) { + return controllers.get(token)?.unload(event) ?? false; +} +export function closeProductRequestController(token: ProductRequestController) { + controllers.get(token)?.close(); +} +export function stopProductRequestWork( + token: ProductRequestController, + review: unknown +) { + return controllers.get(token)?.stop(review) ?? false; +} diff --git a/web/src/lib/messaging/resolve-inbox.ts b/web/src/lib/messaging/resolve-inbox.ts @@ -201,3 +201,32 @@ export function closeInboxResolver(token: InboxResolver): void { export function inboxResolverCurrentAfterSample(token: InboxResolver): boolean { return ownerOf(token).currentAfterSample(); } +declare function setTimeout(callback: () => void, milliseconds: number): number; +// Await the same original bounded request, preserving its observed outcome. +// The original clock and owner decide retirement; this never renews a run, +// manufactures EOSE/readiness or grants a signing/publication capability. +export async function settleInboxResolver( + token: InboxResolver, + current: () => boolean = () => true +): Promise<InboxResolver> { + const owner = ownerOf(token); + try { + for (;;) { + const observed = owner.snapshot(); + if (!current() || !owner.currentAfterSample()) { + owner.close(); + return token; + } + const scope = publicRequestScopeSnapshot(observed.request); + if ( + scope.state !== 'active' && + (scope.state !== 'eose' || scope.inboxSettled === true) + ) + return token; + await new Promise<void>((resolve) => setTimeout(resolve, 50)); + } + } catch { + owner.close(); + return token; + } +} diff --git a/web/src/lib/messaging/rumor-plan.ts b/web/src/lib/messaging/rumor-plan.ts @@ -135,12 +135,13 @@ export function captureEnquiryRumor( session: IdentitySession, context: EnquiryContext, text: unknown, - observedTime: unknown + observedTime: unknown, + additionalCurrent: () => boolean = () => true ): RumorPlan | undefined { const parts = buildEnquiryMessage(context, text); const message = parts && messageFromWireParts(JSON.stringify(parts)); return message - ? capture(session, JSON.stringify(message), observedTime) + ? capture(session, JSON.stringify(message), observedTime, additionalCurrent) : undefined; } export function captureReplyRumor( diff --git a/web/tests/e2e/capability-gate.spec.ts b/web/tests/e2e/capability-gate.spec.ts @@ -308,6 +308,7 @@ test.describe('actual shared inline capability component', () => { 'src/lib/components/AccountGate.svelte', 'src/lib/components/InboxSetup.svelte', 'src/lib/messaging/inbox-setup-view.ts', + 'src/lib/messaging/resolve-inbox.ts', 'src/routes/+layout.svelte', 'tests/e2e/harness/capability-gate.svelte' ]) diff --git a/web/tests/e2e/harness/product-request-panel.svelte b/web/tests/e2e/harness/product-request-panel.svelte @@ -0,0 +1,91 @@ +<script lang="ts"> + import { onMount, setContext, untrack } from 'svelte'; + import ProductEnquiry from '../../../src/lib/components/ProductEnquiry.svelte'; + import { + IDENTITY_VIEW_CONTEXT, + identityViewSession, + identityViewSnapshot, + subscribeIdentityView, + type IdentityViewContext + } from '../../../src/lib/runtime/view-context.ts'; + import { identityMessagingOwnership } from '../../../src/lib/runtime/identity-session.ts'; + import { + PUBLIC_RUNTIME_CONTEXT, + type PublicRuntimeContext + } from '../../../src/lib/runtime/public-runtime.ts'; + import type { + ProductView, + ProductViewSnapshot + } from '../../../src/lib/catalog/product-view.ts'; + import type { ProductEnquiry as Draft } from '../../../src/lib/messaging/product-enquiry.ts'; + import type { ProductRequestController } from '../../../src/lib/messaging/product-request-controller.ts'; + import { + closeInboxSetupView, + type InboxSetupView + } from '../../../src/lib/messaging/inbox-setup-view.ts'; + import type { IdentitySession } from '../../../src/lib/runtime/identity-session.ts'; + let { + view, + context, + publicContext, + observe, + makeSetup, + capture, + request + }: { + view: ProductView; + context: IdentityViewContext; + publicContext: PublicRuntimeContext; + observe: (callback: (value: ProductViewSnapshot) => void) => () => void; + makeSetup: (identity: IdentitySession) => InboxSetupView; + capture: (draft: Draft) => void; + request: (controller: ProductRequestController) => void; + } = $props(); + setContext( + IDENTITY_VIEW_CONTEXT, + untrack(() => context) + ); + setContext( + PUBLIC_RUNTIME_CONTEXT, + untrack(() => publicContext) + ); + let observation = $state.raw<ProductViewSnapshot | undefined>(), + setup = $state.raw<InboxSetupView | undefined>(); + onMount(() => { + let original: IdentitySession | undefined; + const acquire = () => { + const identity = identityViewSession(context); + if (identity === original && setup) return; + if ( + identityViewSnapshot(context).identity.state !== 'messaging_capable' || + !identity || + !identityMessagingOwnership(identity)?.current() + ) + return; + if (setup) closeInboxSetupView(setup); + original = identity; + setup = makeSetup(identity); + }; + const off = subscribeIdentityView(context, acquire); + acquire(); + return () => { + off(); + if (setup) closeInboxSetupView(setup); + }; + }); + $effect(() => + observe((value) => { + observation = value; + }) + ); +</script> + +<section data-request-fixture> + <ProductEnquiry + {view} + {observation} + {setup} + oncapture={capture} + onrequest={request} + /> +</section> diff --git a/web/tests/e2e/harness/product-request.ts b/web/tests/e2e/harness/product-request.ts @@ -0,0 +1,432 @@ +import { mount, unmount, tick } from 'svelte'; +import type { beforeNavigate as KitBeforeNavigate } from '$app/navigation'; +import { + getPublicKey, + finalizeEvent, + type UnsignedEvent +} from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import Panel from './product-request-panel.svelte'; +import { validateRelayPolicy } from '../../../src/lib/config/relays.ts'; +import { + createPublicRuntimeContext, + mountPublicRuntime, + createPublicView, + beginPublicViewRun, + disposePublicView, + closePublicRuntime +} from '../../../src/lib/runtime/public-runtime.ts'; +import { + createIdentityViewContext, + mountIdentityView, + identityViewSnapshot, + identityViewSession, + disconnectIdentityView, + closeIdentityView +} from '../../../src/lib/runtime/view-context.ts'; +import { + identityMessagingOwnership, + type IdentitySession +} from '../../../src/lib/runtime/identity-session.ts'; +import { + createProductView, + productViewSnapshot, + closeProductView, + type ProductViewSnapshot +} from '../../../src/lib/catalog/product-view.ts'; +import { encodeProductReference } from '../../../src/lib/nostr/references.ts'; +import { + productEnquirySnapshot, + productEnquiryMessage, + captureProductEnquiry, + updateProductEnquiry, + type ProductEnquiry +} from '../../../src/lib/messaging/product-enquiry.ts'; +import { + createProductRequestController, + productRequestSnapshot, + productRequestText, + updateProductRequestText, + configureProductRequest, + sendProductRequest, + requestProductRequestNavigation, + keepProductRequestEditing, + discardProductRequestNavigation, + closeProductRequestController, + type ProductRequestController +} from '../../../src/lib/messaging/product-request-controller.ts'; +import { + createInboxSetupView, + inboxSetupViewSnapshot, + type InboxSetupView +} from '../../../src/lib/messaging/inbox-setup-view.ts'; +import { + resolveInboxPreference, + settleInboxResolver +} from '../../../src/lib/messaging/resolve-inbox.ts'; +import { resolveInboxReadback } from '../../../src/lib/nostr/inbox-readback.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; +import { + browserExtensionScheduler, + extensionSchedulerSnapshot +} from '../../../src/lib/nostr/extension-scheduler.ts'; + +type BeforeNavigate = Parameters<Parameters<typeof KitBeforeNavigate>[0]>[0]; +const navigation: ((event: BeforeNavigate) => void)[] = []; +let destinations: string[] = []; +export function beforeNavigate(callback: (event: BeforeNavigate) => void) { + navigation.push(callback); +} +export function goto(destination: string | URL) { + destinations = destinations.concat(String(destination)); + return Promise.resolve(); +} +type Mode = + | 'normal' + | 'refused_key' + | 'hold_key' + | 'changed_key' + | 'hold_encrypt' + | 'declined_encrypt' + | 'hold_seal'; + +// Controlled disposable provider, actual SDK crypto/storage/DOM. No production +// credential, extension, relay access or qualification is supplied by this test. +export async function renderFixture(qualified = true) { + navigation.length = 0; + destinations = []; + const secret = new Uint8Array(32).fill(83), + peerSecret = new Uint8Array(32).fill(84), + owner = getPublicKey(secret), + peer = getPublicKey(peerSecret); + let mode: Mode = 'normal', + release: (() => void) | undefined, + keys = 0, + encrypts = 0, + decrypts = 0, + signs = 0, + active = true, + offset = 0, + pending = false; + const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); + const held = async <T>(work: () => T): Promise<T> => { + pending = true; + return new Promise<T>((resolve) => { + release = () => { + pending = false; + release = undefined; + resolve(work()); + }; + }); + }; + const provider = { + getPublicKey: () => { + keys++; + if (mode === 'refused_key') + return Promise.reject(Error('controlled refusal')); + const value = () => (mode === 'changed_key' ? peer : owner); + return mode === 'hold_key' ? held(value) : Promise.resolve(value()); + }, + signEvent: (template: UnsignedEvent) => { + signs++; + const value = () => finalizeEvent(template, secret); + return mode === 'hold_seal' && template.kind === 13 + ? held(value) + : Promise.resolve(value()); + }, + nip44: { + encrypt: (target: string, text: string) => { + encrypts++; + if (mode === 'declined_encrypt') + return Promise.reject(Error('controlled encryption refusal')); + const value = () => { + const key = nip44.v2.utils.getConversationKey(secret, target); + try { + return nip44.v2.encrypt(text, key); + } finally { + key.fill(0); + } + }; + return mode === 'hold_encrypt' ? held(value) : Promise.resolve(value()); + }, + decrypt: (target: string, wire: string) => { + decrypts++; + const key = nip44.v2.utils.getConversationKey(secret, target); + try { + return Promise.resolve(nip44.v2.decrypt(wire, key)); + } finally { + key.fill(0); + } + } + } + }; + Object.defineProperty(window, 'nostr', { + configurable: true, + value: provider + }); + const policy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: [ + { + origin: 'wss://discovery.example.org', + read: true, + write: true, + nip50: false + } + ], + inbox: ['wss://archive.example.org', 'wss://peer.example.org'].map( + (origin) => ({ origin, read: true, write: true }) + ), + postingEnabled: true, + messagingEnabled: true, + operatorDenylist: [] + }) + ); + if (!policy) throw Error('invalid fixed test policy'); + const publicContext = createPublicRuntimeContext(), + runtime = mountPublicRuntime(publicContext, policy, { + now: () => offset, + schedule: () => () => {} + }); + if (!runtime) throw Error('original runtime unavailable'); + const context = createIdentityViewContext(); + mountIdentityView(context); + const reference = encodeProductReference({ + kind: 30402, + pubkey: peer, + identifier: 'carrots' + }); + if (!reference) throw Error('invalid coordinate'); + const observers = new Set<(value: ProductViewSnapshot) => void>(); + const view = createProductView( + createPublicView(runtime), + reference, + { nowSeconds: () => 1700000200 }, + (value) => { + for (const callback of observers) callback(value); + } + ); + const target = document.createElement('div'); + document.body.append(target); + let draft: ProductEnquiry | undefined, + controller: ProductRequestController | undefined, + headless: ProductRequestController | undefined, + setup: InboxSetupView | undefined; + const mounted = mount(Panel, { + target, + props: { + view, + context, + publicContext, + observe(callback: (value: ProductViewSnapshot) => void) { + observers.add(callback); + callback(productViewSnapshot(view)); + return () => { + observers.delete(callback); + }; + }, + makeSetup(identity: IdentitySession) { + const source = createPublicView(runtime); + const made = createInboxSetupView({ + identity, + policy, + lookup: (current = () => true) => + settleInboxResolver( + resolveInboxPreference(source, beginPublicViewRun(source), owner), + () => + active && + !!identityMessagingOwnership(identity)?.current() && + current() + ), + readback: (record, author, id) => + resolveInboxReadback( + source, + beginPublicViewRun(source), + record, + author, + id, + policy + ), + observeAccess: qualified + ? (data) => ({ + ...data, + receive: 'qualified_exercised', + archive: 'qualified_exercised', + current: () => + active && !!identityMessagingOwnership(identity)?.current() + }) + : undefined, + close: () => disposePublicView(source) + }); + if (!made) throw Error('genuine setup unavailable'); + setup = made; + return made; + }, + capture(value: ProductEnquiry) { + draft = value; + }, + request(value: ProductRequestController) { + controller = value; + } + } + }); + async function native() { + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') + throw Error('native browser inspection unavailable'); + try { + const transaction = browserDatabaseTransaction( + opened.owner, + ['private_sends'], + 'readonly' + ); + const sends = await new Promise<unknown[]>((resolve, reject) => { + const store = transaction.objectStore('private_sends'); + const request = store.getAll(); + request.onsuccess = () => resolve(request.result); + request.onerror = () => + reject( + request.error ?? Error('controlled browser inspection failed') + ); + }); + return { sends }; + } finally { + closeBrowserDatabase(opened.owner); + } + } + await tick(); + return { + owner, + peer, + viewSnapshot: () => productViewSnapshot(view), + identity: () => identityViewSnapshot(context), + setup: () => inboxSetupViewSnapshot(setup), + snapshot: () => controller && productRequestSnapshot(controller), + text: () => controller && productRequestText(controller), + product: () => draft && productEnquirySnapshot(draft), + message: () => draft && productEnquiryMessage(draft), + native, + counts: () => ({ keys, encrypts, decrypts, signs }), + pending: () => pending, + scheduler: () => { + const scheduler = browserExtensionScheduler(); + return scheduler && extensionSchedulerSnapshot(scheduler); + }, + mode(value: Mode) { + mode = value; + }, + settle() { + mode = 'normal'; + release?.(); + }, + logout() { + disconnectIdentityView(context); + }, + update(value: string) { + return ( + !!controller && + updateProductRequestText(controller, value, 'reviewed_private_text') + ); + }, + directUpdate(value: string) { + return ( + !!draft && + updateProductEnquiry(draft, value, 'reviewed_product_enquiry_edit') + ); + }, + beginHeadless() { + const original = captureProductEnquiry(view, 'reviewed_product_enquiry'); + const actor = identityViewSession(context); + headless = original && createProductRequestController(original, runtime); + if ( + !headless || + !actor || + !setup || + !configureProductRequest( + headless, + actor, + setup, + 'reviewed_product_request_setup' + ) + ) + throw Error('genuine headless test owner unavailable'); + return sendProductRequest(headless, 'reviewed_product_request_send'); + }, + headlessSnapshot: () => headless && productRequestSnapshot(headless), + headlessText: () => headless && productRequestText(headless), + revokeView() { + closeProductView(view); + }, + unreviewed: () => controller && sendProductRequest(controller, undefined), + copied: async () => ({ + create: !!createProductRequestController({} as ProductEnquiry), + snapshot: productRequestSnapshot({} as ProductRequestController), + configure: configureProductRequest( + {} as ProductRequestController, + {} as IdentitySession, + {} as InboxSetupView, + 'reviewed_product_request_setup' + ), + send: await sendProductRequest( + {} as ProductRequestController, + 'reviewed_product_request_send' + ) + }), + request: () => controller && requestProductRequestNavigation(controller), + keep: () => controller && keepProductRequestEditing(controller), + discard: () => + controller && + discardProductRequestNavigation( + controller, + 'reviewed_discard_private_text' + ), + async navigate() { + let cancelled = false; + const event = { + cancel() { + cancelled = true; + }, + to: { url: new URL('/about', location.href) }, + willUnload: false + } as BeforeNavigate; + for (const callback of navigation) callback(event); + await tick(); + return { cancelled, destinations: destinations.slice() }; + }, + destinations: () => destinations.slice(), + persistentText: async () => + JSON.stringify({ + url: location.href, + local: { ...localStorage }, + session: { ...sessionStorage }, + native: await native() + }), + advance() { + offset += 15001; + }, + async closeView() { + closeProductView(view); + if (headless) closeProductRequestController(headless); + await tick(); + }, + async close() { + active = false; + mode = 'normal'; + release?.(); + closeProductView(view); + await unmount(mounted); + closeIdentityView(context); + closePublicRuntime(publicContext); + target.remove(); + if (prior) Object.defineProperty(window, 'nostr', prior); + else Reflect.deleteProperty(window, 'nostr'); + secret.fill(0); + peerSecret.fill(0); + } + }; +} diff --git a/web/tests/e2e/product-request.spec.ts b/web/tests/e2e/product-request.spec.ts @@ -0,0 +1,845 @@ +import { test, expect, type Page } 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 { finalizeEvent, getPublicKey } from 'applesauce-core/helpers'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/product-request.ts'; + +declare global { + interface Window { + hcp107: typeof Fixture; + hcp107Fixture: Awaited<ReturnType<typeof Fixture.renderFixture>>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>; +let sockets: WebSocketServer, endpoint: string, bundle: string; +let missingOwn = false; +let holdOwnEose = false, + holdPeerEose = false; +let waitingEose: (() => void)[] = []; +let events: { + origin: string; + event: { + kind: number; + id: string; + pubkey: string; + content: string; + tags: string[][]; + }; +}[] = []; +const sellerSecret = new Uint8Array(32).fill(84); +const ownerSecret = new Uint8Array(32).fill(83); +const peer = getPublicKey(sellerSecret), + owner = getPublicKey(ownerSecret); +let ownPreference: ReturnType<typeof finalizeEvent> | undefined; +function preference(secret: Uint8Array, origin: string) { + return finalizeEvent( + { + kind: 10050, + created_at: 1700000060, + tags: [['relay', origin]], + content: '' + }, + secret + ); +} +test.beforeAll(async () => { + server = await createStaticHarness(); + sockets = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 65536 + }); + await once(sockets, 'listening'); + const address = sockets.address(); + if (!address || typeof address === 'string') throw Error('no loopback'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket, request) => { + const origin = + new URL(request.url ?? '/', endpoint).searchParams.get('source') ?? ''; + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes + : Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.from(bytes); + const frame = JSON.parse(raw.toString()) as unknown[]; + if (frame[0] === 'EVENT') { + const event = frame[1] as (typeof events)[number]['event']; + events.push({ origin, event }); + if (event.kind === 10050) + ownPreference = event as ReturnType<typeof finalizeEvent>; + socket.send( + JSON.stringify(['OK', event.id, true, 'controlled acceptance']) + ); + return; + } + if (frame[0] !== 'REQ') return; + const filters = frame.slice(2) as { + kinds?: number[]; + authors?: string[]; + }[]; + for (const filter of filters) { + if (filter.kinds?.includes(30402)) { + const event = finalizeEvent( + { + kind: 30402, + created_at: 1700000060, + content: 'Independently signed carrots', + tags: [ + ['d', 'carrots'], + ['title', 'Verified carrots'], + ['summary', 'Actual signed listing'], + ['published_at', '1700000000'], + ['location', 'Victoria'], + ['price', '3.5', 'CAD'], + ['radroots:price_unit', 'lb'], + ['status', 'active'] + ] + }, + sellerSecret + ); + socket.send(JSON.stringify(['EVENT', frame[1], event])); + } + if (filter.kinds?.includes(10050)) { + if (filter.authors?.includes(peer)) + socket.send( + JSON.stringify([ + 'EVENT', + frame[1], + preference(sellerSecret, 'wss://peer.example.org') + ]) + ); + if (filter.authors?.includes(owner) && (!missingOwn || ownPreference)) + socket.send( + JSON.stringify([ + 'EVENT', + frame[1], + ownPreference ?? + preference(ownerSecret, 'wss://archive.example.org') + ]) + ); + } + } + if ( + filters.some( + (filter) => + filter.kinds?.includes(10050) && + ((holdOwnEose && filter.authors?.includes(owner)) || + (holdPeerEose && filter.authors?.includes(peer))) + ) + ) + waitingEose.push(() => { + if (socket.readyState === 1) + socket.send(JSON.stringify(['EOSE', frame[1]])); + }); + else socket.send(JSON.stringify(['EOSE', frame[1]])); + }); + }); + const result = await build({ + configFile: false, + logLevel: 'silent', + plugins: [svelte({ configFile: false })], + resolve: { + conditions: ['browser'], + alias: { + '$app/navigation': fileURLToPath( + new URL('./harness/product-request.ts', import.meta.url) + ) + } + }, + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/product-request.ts', import.meta.url) + ), + name: 'hcp107', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('no bundle'); + const chunks = output.output.filter((row) => row.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const socket of sockets.clients) socket.terminate(); + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server.close(); +}); +test.beforeEach(async ({ page }) => { + events = []; + missingOwn = false; + ownPreference = undefined; + holdOwnEose = false; + holdPeerEose = false; + waitingEose = []; + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + const origin = new URL(String(url)).origin; + if ( + ![ + 'wss://discovery.example.org', + 'wss://archive.example.org', + 'wss://peer.example.org' + ].includes(origin) + ) + throw Error('unapproved destination'); + super(endpoint + '/?source=' + encodeURIComponent(origin), protocols); + } + }; + }, + { endpoint } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => window.hcp107Fixture?.close()); +}); +const panel = (page: Page) => page.locator('[data-request-fixture]'); +const editor = (page: Page) => + panel(page).getByRole('textbox', { name: 'Your message', exact: true }); +async function ready(page: Page, qualified = true) { + await page.evaluate(async (qualified) => { + window.hcp107Fixture = await window.hcp107.renderFixture(qualified); + }, qualified); + await expect + .poll(() => + page.evaluate(() => window.hcp107Fixture.viewSnapshot().outcome) + ) + .toBe('active'); + await panel(page) + .getByRole('button', { name: 'Message seller', exact: true }) + .click(); + await expect(editor(page)).toBeVisible(); +} +async function connect(page: Page) { + await panel(page) + .getByRole('button', { name: 'Connect extension', exact: true }) + .click(); + await expect( + panel(page).getByRole('button', { + name: 'Check messaging support', + exact: true + }) + ).toBeVisible(); + await panel(page) + .getByRole('button', { name: 'Check messaging support', exact: true }) + .click(); + await expect(panel(page)).toContainText('Messaging support checked.'); +} +async function unlock(page: Page) { + await connect(page); + await panel(page) + .getByRole('button', { name: 'Check current preference', exact: true }) + .click(); + await panel(page) + .getByRole('button', { name: 'Unlock inbox', exact: true }) + .click(); + await expect( + panel(page).getByRole('button', { name: 'Send request', exact: true }) + ).toBeEnabled(); +} +async function noPrivate(page: Page, marker?: string) { + expect(events.filter((row) => row.event.kind === 1059)).toEqual([]); + expect( + await page.evaluate(async () => (await window.hcp107Fixture.native()).sends) + ).toEqual([]); + if (marker) + expect( + await page.evaluate(() => window.hcp107Fixture.persistentText()) + ).not.toContain(marker); +} +test('guest text is memory only, with no automatic identity or private intent', async ({ + page +}) => { + await ready(page); + await editor(page).fill('guest-private-marker'); + expect(await page.evaluate(() => window.hcp107Fixture.counts())).toEqual({ + keys: 0, + encrypts: 0, + decrypts: 0, + signs: 0 + }); + await noPrivate(page, 'guest-private-marker'); +}); +test('same-page Connect preserves edited text and never sends', async ({ + page +}) => { + await ready(page); + await editor(page).fill('connect-private-marker'); + await panel(page) + .getByRole('button', { name: 'Connect extension', exact: true }) + .click(); + await expect(editor(page)).toHaveValue('connect-private-marker'); + await noPrivate(page, 'connect-private-marker'); +}); +test('explicit support probe preserves text and creates no private send', async ({ + page +}) => { + await ready(page); + await editor(page).fill('probe-private-marker'); + await connect(page); + await expect(editor(page)).toHaveValue('probe-private-marker'); + await noPrivate(page, 'probe-private-marker'); +}); +test('existing preference and unlock are separate from final Send', async ({ + page +}) => { + await ready(page); + await unlock(page); + expect(events).toEqual([]); + await noPrivate(page); +}); +test('public preference enablement is explicit and never autosends the request', async ({ + page +}) => { + missingOwn = true; + await ready(page); + await editor(page).fill('setup-private-marker'); + await connect(page); + await panel(page) + .getByRole('button', { name: 'Check current preference', exact: true }) + .click(); + await panel(page) + .getByRole('checkbox', { name: 'wss://archive.example.org', exact: true }) + .check(); + await panel(page) + .getByRole('button', { name: 'Review inbox change', exact: true }) + .click(); + expect(events).toEqual([]); + await panel(page) + .getByRole('button', { name: 'Enable inbox', exact: true }) + .click(); + await expect + .poll(() => events.filter((row) => row.event.kind === 10050).length) + .toBeGreaterThan(0); + await expect(editor(page)).toHaveValue('setup-private-marker'); + await noPrivate(page, 'setup-private-marker'); +}); +test('unqualified access cannot enable final Send', async ({ page }) => { + await ready(page, false); + await connect(page); + await panel(page) + .getByRole('button', { name: 'Check current preference', exact: true }) + .click(); + await panel(page) + .getByRole('button', { name: 'Unlock inbox', exact: true }) + .click(); + await expect(panel(page)).toContainText( + 'Inbox access has not been qualified' + ); + await expect( + panel(page).getByRole('button', { name: 'Send request', exact: true }) + ).toBeDisabled(); + await noPrivate(page); +}); +test('only the current task has one enabled primary action', async ({ + page +}) => { + await ready(page); + await expect( + panel(page).locator('button.button--primary:enabled') + ).toHaveCount(1); + await connect(page); + await expect( + panel(page).locator('button.button--primary:enabled') + ).toHaveCount(1); + await panel(page) + .getByRole('button', { name: 'Check current preference', exact: true }) + .click(); + await expect( + panel(page).locator('button.button--primary:enabled') + ).toHaveCount(1); +}); +test('refused Connect keeps unsaved text and performs no send', async ({ + page +}) => { + await ready(page); + await editor(page).fill('refused-private-marker'); + await page.evaluate(() => window.hcp107Fixture.mode('refused_key')); + await panel(page) + .getByRole('button', { name: 'Connect extension', exact: true }) + .click(); + await expect(panel(page)).toContainText('Connection was not approved'); + await expect(editor(page)).toHaveValue('refused-private-marker'); + await noPrivate(page); +}); +test('held Connect can be cancelled without losing text or autosending later', async ({ + page +}) => { + await ready(page); + await editor(page).fill('held-connect-marker'); + await page.evaluate(() => window.hcp107Fixture.mode('hold_key')); + await panel(page) + .getByRole('button', { name: 'Connect extension', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.pending())) + .toBe(true); + await panel(page) + .getByRole('button', { name: 'Cancel', exact: true }) + .click(); + await panel(page) + .getByRole('button', { name: 'Keep editing', exact: true }) + .click(); + await page.evaluate(() => window.hcp107Fixture.settle()); + await expect(editor(page)).toHaveValue('held-connect-marker'); + await noPrivate(page); +}); +test('copied owners and unreviewed Send are rejected', async ({ page }) => { + await ready(page); + expect(await page.evaluate(() => window.hcp107Fixture.copied())).toEqual({ + create: false, + snapshot: undefined, + configure: false, + send: { status: 'invalid' } + }); + expect(await page.evaluate(() => window.hcp107Fixture.unreviewed())).toEqual({ + status: 'invalid' + }); + await noPrivate(page); +}); +test('final explicit Send publishes only ciphertext to the intended named destinations', async ({ + page +}) => { + await ready(page); + await unlock(page); + const expected = await page.evaluate(() => window.hcp107Fixture.message()); + expect(expected).toBeDefined(); + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect + .poll(() => events.filter((row) => row.event.kind === 1059).length) + .toBeGreaterThanOrEqual(2); + expect(events.every((row) => row.event.kind === 1059)).toBe(true); + expect(new Set(events.map((row) => row.origin))).toEqual( + new Set(['wss://archive.example.org', 'wss://peer.example.org']) + ); + expect( + events.every((row) => !row.event.content.includes('Verified carrots')) + ).toBe(true); + await expect(panel(page)).not.toContainText('Delivered'); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.snapshot()?.state)) + .toBe('completed'); + await expect(panel(page)).not.toContainText('No message has been sent.'); + expect(events).toHaveLength(2); + const { nip44 } = await import('applesauce-core/helpers/encryption'); + const { getEventHash } = await import('applesauce-core/helpers'); + const rumors = events.map(({ event: outer }) => { + const recipient = outer.tags.find((tag) => tag[0] === 'p')?.[1]; + expect([owner, peer]).toContain(recipient); + const key = new Uint8Array(32).fill(recipient === owner ? 83 : 84); + try { + const seal = JSON.parse( + nip44.v2.decrypt( + outer.content, + nip44.v2.utils.getConversationKey(key, outer.pubkey) + ) + ) as { pubkey: string; content: string; kind: number; tags: string[][] }; + expect(seal.kind).toBe(13); + expect(seal.pubkey).toBe(owner); + expect(seal.tags).toEqual([]); + const rumor = JSON.parse( + nip44.v2.decrypt( + seal.content, + nip44.v2.utils.getConversationKey(key, seal.pubkey) + ) + ) as { + id: string; + kind: number; + pubkey: string; + content: string; + tags: string[][]; + created_at: number; + }; + expect(rumor.kind).toBe(14); + expect(rumor.pubkey).toBe(owner); + expect(rumor.tags).toEqual([['p', peer]]); + expect(rumor.content).toBe(expected?.content); + expect(rumor.content).toContain('Viewed listing: nostr:nevent1'); + expect(rumor.content).toContain('Product: nostr:naddr1'); + expect(getEventHash(rumor)).toBe(rumor.id); + return rumor; + } finally { + key.fill(0); + } + }); + expect(rumors[0]).toEqual(rumors[1]); +}); +test('held self seal reports multiple approvals and does not publish ahead of persistence', async ({ + page +}) => { + await ready(page); + await unlock(page); + await page.evaluate(() => window.hcp107Fixture.mode('hold_seal')); + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.pending())) + .toBe(true); + await expect(panel(page)).toContainText('approval'); + expect(events).toEqual([]); + await page.evaluate(() => window.hcp107Fixture.settle()); +}); +test('Cancel retires a held private Send while Keep preserves unsaved text', async ({ + page +}) => { + await ready(page); + await unlock(page); + await editor(page).fill('cancel-held-seal-marker'); + await page.evaluate(() => window.hcp107Fixture.mode('hold_seal')); + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.pending())) + .toBe(true); + const before = await page.evaluate(() => window.hcp107Fixture.native()); + const calls = await page.evaluate(() => window.hcp107Fixture.counts()); + await panel(page) + .getByRole('button', { name: 'Cancel', exact: true }) + .click(); + await panel(page) + .getByRole('button', { name: 'Keep editing', exact: true }) + .click(); + await expect(editor(page)).toHaveValue('cancel-held-seal-marker'); + expect(await page.evaluate(() => window.hcp107Fixture.pending())).toBe(true); + await page.evaluate(() => window.hcp107Fixture.settle()); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.snapshot()?.busy)) + .toBe(false); + expect(await page.evaluate(() => window.hcp107Fixture.native())).toEqual( + before + ); + expect(await page.evaluate(() => window.hcp107Fixture.counts())).toEqual( + calls + ); + expect(events).toEqual([]); +}); +test('declined encryption retains unsaved text without publication', async ({ + page +}) => { + await ready(page); + await unlock(page); + await editor(page).fill('declined-encryption-marker'); + await page.evaluate(() => window.hcp107Fixture.mode('declined_encrypt')); + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect(editor(page)).toHaveValue('declined-encryption-marker'); + expect(events).toEqual([]); +}); +test('disconnect during held crypto prevents late publication', async ({ + page +}) => { + await ready(page); + await unlock(page); + await page.evaluate(() => window.hcp107Fixture.mode('hold_encrypt')); + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.pending())) + .toBe(true); + await page.evaluate(() => { + window.hcp107Fixture.logout(); + window.hcp107Fixture.settle(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.pending())) + .toBe(false); + expect(events).toEqual([]); +}); +test('dirty Cancel defaults to Keep editing with focus restored', async ({ + page +}) => { + await ready(page); + await editor(page).fill('dirty-cancel-marker'); + await panel(page) + .getByRole('button', { name: 'Cancel', exact: true }) + .click(); + await expect( + panel(page).getByRole('button', { name: 'Keep editing', exact: true }) + ).toBeFocused(); + await panel(page) + .getByRole('button', { name: 'Keep editing', exact: true }) + .click(); + await expect(editor(page)).toHaveValue('dirty-cancel-marker'); + await expect(editor(page)).toBeFocused(); + await noPrivate(page); +}); +test('dirty navigation is cancelled and Keep leaves the URL unchanged', async ({ + page +}) => { + await ready(page); + await editor(page).fill('navigation-private-marker'); + const url = page.url(); + expect( + (await page.evaluate(() => window.hcp107Fixture.navigate())).cancelled + ).toBe(true); + await panel(page) + .getByRole('button', { name: 'Keep editing', exact: true }) + .click(); + expect(page.url()).toBe(url); + await expect(editor(page)).toHaveValue('navigation-private-marker'); + await noPrivate(page, 'navigation-private-marker'); +}); +test('editing after confirmation invalidates stale discard permission', async ({ + page +}) => { + await ready(page); + await editor(page).fill('revision-one'); + await page.evaluate(() => window.hcp107Fixture.request()); + await page.evaluate(() => window.hcp107Fixture.update('revision-two')); + expect(await page.evaluate(() => window.hcp107Fixture.discard())).not.toBe( + 'allowed' + ); + await expect(editor(page)).toHaveValue('revision-two'); + await noPrivate(page); +}); +test('explicit discard clears unsaved text without saving or sending it', async ({ + page +}) => { + await ready(page); + await editor(page).fill('discard-private-marker'); + await panel(page) + .getByRole('button', { name: 'Cancel', exact: true }) + .click(); + await panel(page) + .getByRole('button', { name: 'Discard draft', exact: true }) + .click(); + await expect(editor(page)).toHaveCount(0); + await noPrivate(page, 'discard-private-marker'); +}); +test('a genuine second draft writer invalidates stale discard permission', async ({ + page +}) => { + await ready(page); + await editor(page).fill('original-writer-one'); + await page.evaluate(() => window.hcp107Fixture.request()); + expect( + await page.evaluate(() => + window.hcp107Fixture.directUpdate('original-writer-two') + ) + ).toBe(true); + expect(await page.evaluate(() => window.hcp107Fixture.discard())).not.toBe( + 'allowed' + ); + await expect(editor(page)).toHaveValue('original-writer-two'); + await noPrivate(page); +}); +for (const revoke of ['close', 'expiry'] as const) { + test( + 'headless original ' + + revoke + + ' prevents later internal crypto and native self commit', + async ({ page }) => { + await ready(page); + await unlock(page); + await page.evaluate(() => window.hcp107Fixture.mode('hold_seal')); + await page.evaluate(() => { + void window.hcp107Fixture.beginHeadless(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.pending())) + .toBe(true); + const before = await page.evaluate(() => window.hcp107Fixture.native()); + const calls = await page.evaluate(() => window.hcp107Fixture.counts()); + await page.evaluate((revoke) => { + if (revoke === 'close') window.hcp107Fixture.revokeView(); + else window.hcp107Fixture.advance(); + window.hcp107Fixture.settle(); + }, revoke); + await expect + .poll(() => + page.evaluate( + () => window.hcp107Fixture.headlessSnapshot()?.busy ?? false + ) + ) + .toBe(false); + expect(await page.evaluate(() => window.hcp107Fixture.native())).toEqual( + before + ); + expect(await page.evaluate(() => window.hcp107Fixture.counts())).toEqual( + calls + ); + expect(events).toEqual([]); + if (revoke === 'expiry') + expect( + await page.evaluate(() => window.hcp107Fixture.headlessText()) + ).toContain('Verified carrots'); + } + ); +} +test('original view closure revokes the mounted draft and later Send', async ({ + page +}) => { + await ready(page); + await editor(page).fill('close-private-marker'); + await page.evaluate(() => window.hcp107Fixture.closeView()); + await expect(editor(page)).toHaveCount(0); + await noPrivate(page, 'close-private-marker'); +}); +test('protocol freshness expiry preserves text but blocks final Send', async ({ + page +}) => { + await ready(page); + await unlock(page); + await editor(page).fill('stale-private-marker'); + await page.evaluate(() => window.hcp107Fixture.advance()); + await expect(editor(page)).toHaveValue('stale-private-marker'); + await expect( + panel(page).getByRole('button', { name: 'Send request', exact: true }) + ).toBeDisabled(); + await noPrivate(page); +}); +test('inbox Check waits for actual bounded EOSE without sending', async ({ + page +}) => { + await ready(page); + await connect(page); + holdOwnEose = true; + await panel(page) + .getByRole('button', { name: 'Check current preference', exact: true }) + .click(); + await expect.poll(() => waitingEose.length).toBeGreaterThan(0); + expect(await page.evaluate(() => window.hcp107Fixture.setup().status)).toBe( + 'checking' + ); + await noPrivate(page); + holdOwnEose = false; + for (const release of waitingEose) release(); + waitingEose = []; + await expect( + panel(page).getByRole('button', { name: 'Unlock inbox', exact: true }) + ).toBeVisible(); + await noPrivate(page); +}); +test('Cancel during actual inbox lookup preserves text and rejects late EOSE', async ({ + page +}) => { + await ready(page); + await editor(page).fill('cancel-inbox-lookup-marker'); + await connect(page); + holdOwnEose = true; + const calls = await page.evaluate(() => window.hcp107Fixture.counts()); + await panel(page) + .getByRole('button', { name: 'Check current preference', exact: true }) + .click(); + await expect.poll(() => waitingEose.length).toBeGreaterThan(0); + await panel(page) + .getByRole('button', { name: 'Cancel', exact: true }) + .click(); + await panel(page) + .getByRole('button', { name: 'Keep editing', exact: true }) + .click(); + holdOwnEose = false; + for (const release of waitingEose) release(); + waitingEose = []; + await expect(editor(page)).toHaveValue('cancel-inbox-lookup-marker'); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.setup().busy)) + .toBe(false); + expect(await page.evaluate(() => window.hcp107Fixture.counts())).toEqual( + calls + ); + await noPrivate(page, 'cancel-inbox-lookup-marker'); +}); +test('original deadline ends a held incomplete inbox lookup without inventing readiness', async ({ + page +}) => { + await ready(page); + await editor(page).fill('expired-inbox-lookup-marker'); + await connect(page); + holdOwnEose = true; + await panel(page) + .getByRole('button', { name: 'Check current preference', exact: true }) + .click(); + await expect.poll(() => waitingEose.length).toBeGreaterThan(0); + await page.evaluate(() => window.hcp107Fixture.advance()); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.setup().busy)) + .toBe(false); + await expect(panel(page)).toContainText('lookup is incomplete'); + await expect(editor(page)).toHaveValue('expired-inbox-lookup-marker'); + await expect( + panel(page).getByRole('button', { name: 'Send request', exact: true }) + ).toBeDisabled(); + await noPrivate(page); +}); +test('new genuine text during held peer lookup stops the original frozen Send', async ({ + page +}) => { + await ready(page); + await unlock(page); + await editor(page).fill('peer-lookup-original'); + holdPeerEose = true; + const calls = await page.evaluate(() => window.hcp107Fixture.counts()); + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect.poll(() => waitingEose.length).toBeGreaterThan(0); + expect( + await page.evaluate(() => + window.hcp107Fixture.directUpdate('peer-lookup-newer') + ) + ).toBe(true); + holdPeerEose = false; + for (const release of waitingEose) release(); + waitingEose = []; + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.snapshot()?.busy)) + .toBe(false); + await expect(editor(page)).toHaveValue('peer-lookup-newer'); + expect(await page.evaluate(() => window.hcp107Fixture.counts())).toEqual( + calls + ); + await noPrivate(page); +}); +test('closing the original view during held peer lookup refuses late Send', async ({ + page +}) => { + await ready(page); + await unlock(page); + holdPeerEose = true; + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect.poll(() => waitingEose.length).toBeGreaterThan(0); + await page.evaluate(() => window.hcp107Fixture.closeView()); + holdPeerEose = false; + for (const release of waitingEose) release(); + waitingEose = []; + await expect(editor(page)).toHaveCount(0); + await noPrivate(page); +}); +test('native unload warns for unsaved private text without saving', async ({ + page +}) => { + await ready(page); + await editor(page).fill('unload-private-marker'); + expect( + await page.evaluate(() => { + const event = new Event('beforeunload', { cancelable: true }); + window.dispatchEvent(event); + return event.defaultPrevented; + }) + ).toBe(true); + await noPrivate(page, 'unload-private-marker'); +}); diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -326,7 +326,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; 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, 55); + assert.equal(files.length, 53); // 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( @@ -475,17 +475,18 @@ import { auditOutput } from '../../tools/check-output.mjs'; (mutation.startsWith('enquiry-view-') ? 'inbox-view' : mutation.startsWith('enquiry-setup-') - ? 'inbox-setup-view' + ? 'InboxSetup' : mutation.startsWith('enquiry-gate-') - ? 'CapabilityGate' + ? 'InboxSetup' : mutation.startsWith('enquiry-root-') ? 'nodes/0' : mutation.startsWith('context-') - ? 'resolve-head' - : mutation.startsWith('thread-') || - mutation.startsWith('reply-') - ? 'nodes/5' - : 'InboxStatus') + ? 'publishers' + : mutation.startsWith('reply-') + ? 'MessageComposer' + : mutation.startsWith('thread-') + ? 'nodes/5' + : 'InboxStatus') ); assert.ok(entry); const [, row] = entry; @@ -505,7 +506,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; if (mutation === 'enquiry-root-missing-gate') row.imports = row.imports.filter( (/** @type {string} */ value) => - manifest[value].name !== 'CapabilityGate' + manifest[value].name !== 'view-context' ); if (mutation === 'context-resolver-dynamic') row.dynamicImports = []; @@ -599,7 +600,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; assert.ok(Buffer.byteLength(expanded) > 64 * 1024); await writeFile(file, expanded); await refresh(f); - assert.equal((await f.audit()).length, 55); + assert.equal((await f.audit()).length, 53); } ); @@ -1096,6 +1097,9 @@ import { auditOutput } from '../../tools/check-output.mjs'; 'src/lib/catalog/product-view.ts', 'src/lib/components/ProductEnquiry.svelte', 'src/lib/messaging/product-enquiry.ts', + 'src/lib/messaging/product-request-controller.ts', + 'src/lib/messaging/resolve-inbox.ts', + 'src/lib/components/CapabilityGate.svelte', 'src/lib/messaging/enquiry-context.ts', 'src/lib/components/ListingFacts.svelte', 'src/lib/components/PublisherIdentity.svelte', @@ -1153,12 +1157,54 @@ import { auditOutput } from '../../tools/check-output.mjs'; } await writeFile(file, JSON.stringify(manifest)); if (mutation === 'permuted-edges') - assert.equal((await f.audit()).length, 55); + assert.equal((await f.audit()).length, 53); else await assert.rejects(f.audit, /compiler|references/); } ); } for (const mutation of [ + 'missing', + 'extra-edge', + 'missing-edge', + 'duplicate-edge', + 'dynamic', + 'entry', + 'css' + ]) { + await check( + 'inline request shared composer compiler rejects ' + mutation, + async (t) => { + const f = await fixture(t), + 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 === 'MessageComposer' + ); + assert.ok(entry); + const [key, row] = entry; + if (mutation === 'missing') delete manifest[key]; + if (mutation === 'extra-edge') + row.imports = row.imports.concat( + Object.keys(manifest).find( + (name) => manifest[name].name === 'AccountGate' + ) + ); + if (mutation === 'missing-edge') + row.imports = row.imports.slice(1); + if (mutation === 'duplicate-edge') + row.imports = row.imports.concat(row.imports[0]); + if (mutation === 'dynamic') row.dynamicImports = []; + if (mutation === 'entry') row.isEntry = true; + if (mutation === 'css') row.css = []; + await writeFile(file, JSON.stringify(manifest)); + await assert.rejects(f.audit, /compiler|references/); + } + ); + } + for (const mutation of [ 'missing-publishers', 'publisher-budget', 'publisher-shared', @@ -1210,7 +1256,11 @@ import { auditOutput } from '../../tools/check-output.mjs'; ); else { const target = - mutation === 'search-publisher' ? 'nodes/9' : 'nodes/7'; + mutation === 'search-publisher' + ? 'nodes/9' + : mutation === 'product-publisher' + ? 'MessageComposer' + : 'nodes/7'; const dependency = mutation === 'product-shared' ? 'Disclosure' diff --git a/web/tests/unit/components/product-details.test.ts b/web/tests/unit/components/product-details.test.ts @@ -15,6 +15,10 @@ const host = vi.hoisted(() => ({ url: new URL('https://harvest.example/products/invalid') })); vi.mock('$app/state', () => ({ page: host })); +vi.mock('$app/navigation', () => ({ + beforeNavigate: vi.fn(), + goto: vi.fn() +})); const corpus = JSON.parse( readFileSync( new URL( diff --git a/web/tests/unit/product-request.test.ts b/web/tests/unit/product-request.test.ts @@ -0,0 +1,76 @@ +import { describe, expect, it } from 'vitest'; +import { + createProductRequestController, + productRequestSnapshot, + productRequestText, + updateProductRequestText, + configureProductRequest, + sendProductRequest, + requestProductRequestNavigation, + keepProductRequestEditing, + discardProductRequestNavigation, + closeProductRequestController, + type ProductRequestController +} from '../../src/lib/messaging/product-request-controller.ts'; +import type { ProductEnquiry } from '../../src/lib/messaging/product-enquiry.ts'; +import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts'; +import type { InboxSetupView } from '../../src/lib/messaging/inbox-setup-view.ts'; + +describe('inline product request requires original opaque owners', () => { + it('SSR and a copied product enquiry cannot allocate a request', () => { + expect( + createProductRequestController({} as ProductEnquiry) + ).toBeUndefined(); + }); + it('a copied request cannot reveal text or readiness', () => { + expect( + productRequestSnapshot({} as ProductRequestController) + ).toBeUndefined(); + expect(productRequestText({} as ProductRequestController)).toBeUndefined(); + }); + it('unreviewed or copied edit has no private storage authority', () => { + expect( + updateProductRequestText( + {} as ProductRequestController, + 'private', + undefined + ) + ).toBe(false); + }); + it('displayed identity and setup copies cannot configure a request', () => { + expect( + configureProductRequest( + {} as ProductRequestController, + {} as IdentitySession, + {} as InboxSetupView, + 'reviewed_product_request_setup' + ) + ).toBe(false); + }); + it('copied and unreviewed Send cannot reserve or publish', async () => { + expect( + await sendProductRequest({} as ProductRequestController, undefined) + ).toEqual({ status: 'invalid' }); + }); + it('a copied request cannot grant navigation or discard authority', () => { + expect( + requestProductRequestNavigation({} as ProductRequestController) + ).toBe('invalid'); + expect( + discardProductRequestNavigation( + {} as ProductRequestController, + 'reviewed_discard_private_text' + ) + ).toBe('invalid'); + }); + it('keeping a copied request cannot revive its private editor', () => { + expect(keepProductRequestEditing({} as ProductRequestController)).toBe( + false + ); + }); + it('closing an unknown request is safe and never starts Send', () => { + const copied = {} as ProductRequestController; + closeProductRequestController(copied); + expect(productRequestSnapshot(copied)).toBeUndefined(); + }); +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -404,7 +404,12 @@ async function productPresentationAdmission(web) { const hasEnquiry = route.includes( '../../../lib/components/ProductEnquiry.svelte' ); - const producers = hasEnquiry + const hasRequest = + hasEnquiry && + (await readOwned(web, 'src/lib/components/ProductEnquiry.svelte')) + .toString() + .includes('../messaging/product-request-controller.ts'); + const producers = hasRequest ? { 'src/routes/products/[naddr=naddr]/+page.svelte': '970f716e5f31bb0a7e463db84876d4f4b0801979e0893ef69fbeed1b17d69b0f', @@ -425,39 +430,72 @@ async function productPresentationAdmission(web) { 'src/lib/catalog/resolve-head.ts': '4f1c9f144164580da038d127ab463f9f8ba6b20e882fc31151cb29850782d633', 'src/lib/components/ProductEnquiry.svelte': - '4935f091aa4db3b79b681e4bfdda4547b6654a87adee897b1da25abd17c03290', + 'a13db6509100a0db73536211301b22cb42e86b3c2ad06d861f61a679ae6ac635', 'src/lib/messaging/product-enquiry.ts': - 'fdabb058bd42b253d24e0cb2b0a27fb24ef1c65bdc1783e298d1098185e345f4', + '093fe1d5331b81fcf63efeae2b17e5f2c39cbab990e542a13e529a39e28eb8f1', 'src/lib/messaging/enquiry-context.ts': - 'fc00bb77f601427fb73defc0c758332c3465c2d583bfa1f7b996f808f508b735' + 'fc00bb77f601427fb73defc0c758332c3465c2d583bfa1f7b996f808f508b735', + 'src/lib/messaging/product-request-controller.ts': + 'd26242d348c6575cfae197833f3cf5a12751cf987c0f36322a647cc55e2bcb22', + 'src/lib/components/CapabilityGate.svelte': + '38584846f67135d03ad531199cfd4e5f9dbcede58ca7baa2ee2d14fd9f46d414', + 'src/lib/messaging/resolve-inbox.ts': + '6c6438c518f13916a4a5664d8dd0e313338219bd52d5a91db8abab9bbc4a794c' } - : { - 'src/routes/products/[naddr=naddr]/+page.svelte': - '1869d4dc32ea794d5ee5c1d6cc6b4aac94483482d18cff0562c0cb10087b5278', - 'src/lib/catalog/product-view.ts': - 'e3739170e3c700246a80c1358c7b96541a5cbf1e4c26905e6ca60537adfce9cf', - 'src/lib/components/ListingFacts.svelte': - '65d009b4940e7ced61347919689877da9473a2a66a44f61cc5e7bd0b2d217215', - 'src/lib/components/PublisherIdentity.svelte': - '90b156e2401d40079ee559d65ce66ec09ecc4246bc80cfdfc5def0e21e8ce9ff', - 'src/lib/contracts/food-availability-v1/contact-read.ts': - '18f812812c15858768223d929bcea9d7eae5154612747016ccd17864c229420a', - 'src/lib/navigation-copy.ts': - '1a17eac4b355d8a3fb2b55b3fe1bc856cc3b3bce07434836d708b68407686f20', - 'src/lib/runtime/public-runtime.ts': - 'fa2e27d72b82b6bef73693cf93f19614e61ea51ebd11eb40d8ca4ec723f0c14e', - 'src/lib/catalog/publishers.ts': - 'a6795a35ebbf97246e22235df1ca868432e2cccfb26a38f0ebdf4524911192e6', - 'src/lib/catalog/resolve-head.ts': - '4f1c9f144164580da038d127ab463f9f8ba6b20e882fc31151cb29850782d633' - }; + : hasEnquiry + ? { + 'src/routes/products/[naddr=naddr]/+page.svelte': + '970f716e5f31bb0a7e463db84876d4f4b0801979e0893ef69fbeed1b17d69b0f', + 'src/lib/catalog/product-view.ts': + 'e608bcc5b7918366e2daabd5f5270cabf0ded22e1bbfd413d26450387ebac171', + 'src/lib/components/ListingFacts.svelte': + '65d009b4940e7ced61347919689877da9473a2a66a44f61cc5e7bd0b2d217215', + 'src/lib/components/PublisherIdentity.svelte': + '90b156e2401d40079ee559d65ce66ec09ecc4246bc80cfdfc5def0e21e8ce9ff', + 'src/lib/contracts/food-availability-v1/contact-read.ts': + '18f812812c15858768223d929bcea9d7eae5154612747016ccd17864c229420a', + 'src/lib/navigation-copy.ts': + '1a17eac4b355d8a3fb2b55b3fe1bc856cc3b3bce07434836d708b68407686f20', + 'src/lib/runtime/public-runtime.ts': + 'fa2e27d72b82b6bef73693cf93f19614e61ea51ebd11eb40d8ca4ec723f0c14e', + 'src/lib/catalog/publishers.ts': + 'a6795a35ebbf97246e22235df1ca868432e2cccfb26a38f0ebdf4524911192e6', + 'src/lib/catalog/resolve-head.ts': + '4f1c9f144164580da038d127ab463f9f8ba6b20e882fc31151cb29850782d633', + 'src/lib/components/ProductEnquiry.svelte': + '4935f091aa4db3b79b681e4bfdda4547b6654a87adee897b1da25abd17c03290', + 'src/lib/messaging/product-enquiry.ts': + 'fdabb058bd42b253d24e0cb2b0a27fb24ef1c65bdc1783e298d1098185e345f4', + 'src/lib/messaging/enquiry-context.ts': + 'fc00bb77f601427fb73defc0c758332c3465c2d583bfa1f7b996f808f508b735' + } + : { + 'src/routes/products/[naddr=naddr]/+page.svelte': + '1869d4dc32ea794d5ee5c1d6cc6b4aac94483482d18cff0562c0cb10087b5278', + 'src/lib/catalog/product-view.ts': + 'e3739170e3c700246a80c1358c7b96541a5cbf1e4c26905e6ca60537adfce9cf', + 'src/lib/components/ListingFacts.svelte': + '65d009b4940e7ced61347919689877da9473a2a66a44f61cc5e7bd0b2d217215', + 'src/lib/components/PublisherIdentity.svelte': + '90b156e2401d40079ee559d65ce66ec09ecc4246bc80cfdfc5def0e21e8ce9ff', + 'src/lib/contracts/food-availability-v1/contact-read.ts': + '18f812812c15858768223d929bcea9d7eae5154612747016ccd17864c229420a', + 'src/lib/navigation-copy.ts': + '1a17eac4b355d8a3fb2b55b3fe1bc856cc3b3bce07434836d708b68407686f20', + 'src/lib/runtime/public-runtime.ts': + 'fa2e27d72b82b6bef73693cf93f19614e61ea51ebd11eb40d8ca4ec723f0c14e', + 'src/lib/catalog/publishers.ts': + 'a6795a35ebbf97246e22235df1ca868432e2cccfb26a38f0ebdf4524911192e6', + 'src/lib/catalog/resolve-head.ts': + '4f1c9f144164580da038d127ab463f9f8ba6b20e882fc31151cb29850782d633' + }; 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 product presentation source'); } - return hasEnquiry ? 'enquiry' : true; + return hasRequest ? 'request' : hasEnquiry ? 'enquiry' : true; } // This exact reviewed producer set owns the shared presentation/runtime split. // A successor changes these identities only with new compiler qualification. @@ -516,9 +554,9 @@ async function inboxSetupAdmission(web) { if (!gate.toString().includes("'./InboxSetup.svelte'")) return false; const producers = { 'src/lib/components/InboxSetup.svelte': - 'b6ee2ecccd3ad3e192a56b6d03178bdf222c60dcc0bcb8e2ce7b09dda3bb3bf0', + 'd718e9ee2005af0be358fb3c3a051beb6d71568a81e2d43758bdec80edc959f6', 'src/lib/messaging/inbox-setup-view.ts': - '7559ec04394624a8275280027c031b90d0a62b78f94aec3933df6f3b50077450', + '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/runtime/view-context.ts': 'e2329113e29db35e983270217c47d38a44d4e0491fd710395e008786b5ae7033' }; @@ -545,7 +583,7 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/inbox-sync.ts': '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', 'src/lib/messaging/inbox-setup-view.ts': - '7559ec04394624a8275280027c031b90d0a62b78f94aec3933df6f3b50077450', + '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/decryption-queue.ts': '07661a883ee360e9fd7bd411893d637fd6b4b70aecb20101b826fe41b7ca4810', 'src/lib/components/ConversationRow.svelte': @@ -563,11 +601,11 @@ async function inboxPresentationAdmission(web) { 'src/routes/messages/[conversationId=local_id]/+page.svelte': 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7', 'src/lib/components/MessageComposer.svelte': - '9fd8221ab7c9c2d2d0e6626dc8d37b7c95de82b65804dc8766a7f756363c68ae', + 'bc8ac0e2123b60957f1c289acbb2b8740e171097029f640f657cd79f5aa8423b', 'src/lib/messaging/reply-controller.ts': 'c13f1395b5317febcd23396babbcc116065ff96e8cbeb29c8eadfdfc14e45c2d', 'src/lib/messaging/rumor-plan.ts': - '11a672d05a1eaf680b8039bd4c0986754b64f7103034c698843dc24d0560e0f5', + '8ecfa4b8238027f9011a657015da10cc2cc3691d03afa32b9a5064a6ccc56cd9', 'src/lib/components/ConversationOptions.svelte': 'a33d9ffb13e28ce985799fa69342c8fa63816da70e1f9383d4e8e82f5a393c6d', 'src/lib/messaging/cited-product.ts': @@ -684,7 +722,9 @@ export async function auditOutput(webDirectory) { hasFullRoutes && hasPublicRuntime && (await productPresentationAdmission(web)); - const hasProductEnquiry = hasProductPresentation === 'enquiry'; + const hasProductRequest = hasProductPresentation === 'request'; + const hasProductEnquiry = + hasProductRequest || hasProductPresentation === 'enquiry'; const hasPreferencePublication = hasPublicRuntime && (await preferencePublicationAdmission(web)); const hasInboxSetup = @@ -742,10 +782,14 @@ export async function auditOutput(webDirectory) { if (hasProductPresentation) names.add('publishers'); if (hasInboxSetup) names.add('private-handles'); if (hasProductEnquiry) - for (const name of ['inbox-view', 'inbox-setup-view', 'CapabilityGate']) + for (const name of hasProductRequest + ? ['inbox-view', 'MessageComposer'] + : ['inbox-view', 'inbox-setup-view', 'CapabilityGate']) names.add(name); if (hasInboxPresentation) - for (const name of ['InboxStatus', 'InboxSetup', 'read', 'resolve-head']) + for (const name of hasProductRequest + ? ['InboxStatus', 'InboxSetup', 'read'] + : ['InboxStatus', 'InboxSetup', 'read', 'resolve-head']) names.add(name); const admitted = new Map([['build-info.json', expectedMetadata]]); const seen = new Set(); @@ -960,14 +1004,16 @@ export async function auditOutput(webDirectory) { const identityDependencies = [ [ 'view-context', - hasProductEnquiry - ? [identityCompilerModule] - : [ - ...(hasPreferencePublication ? [] : ['public-key']), - identityCompilerModule, - 'client', - 'Button' - ] + hasProductRequest + ? ['public-runtime', 'client', 'Button'] + : hasProductEnquiry + ? [identityCompilerModule] + : [ + ...(hasPreferencePublication ? [] : ['public-key']), + identityCompilerModule, + 'client', + 'Button' + ] ], [ identityCompilerModule, @@ -1019,18 +1065,20 @@ export async function auditOutput(webDirectory) { const [, gate] = requiredRecord('AccountGate'); equal( gate.imports, - (hasProductEnquiry - ? ['client', 'CapabilityGate', 'view-context', 'InboxSetup'] - : hasInboxPresentation - ? ['client', 'view-context', 'InboxSetup'] - : [ - 'public-key', - 'private-handles', - 'public-runtime', - 'client', - 'Button', - 'view-context' - ] + (hasProductRequest + ? ['client', 'view-context', 'InboxSetup'] + : hasProductEnquiry + ? ['client', 'CapabilityGate', 'view-context', 'InboxSetup'] + : hasInboxPresentation + ? ['client', 'view-context', 'InboxSetup'] + : [ + 'public-key', + 'private-handles', + 'public-runtime', + 'client', + 'Button', + 'view-context' + ] ).map((name) => requiredRecord(name)[0]), 'Invalid owned inbox compiler dependencies' ); @@ -1066,7 +1114,7 @@ export async function auditOutput(webDirectory) { return row; }; /** @type {[string,string[]][]} */ - const dependencies = hasProductEnquiry + const dependencies = hasProductRequest ? [ [ 'InboxStatus', @@ -1075,9 +1123,7 @@ export async function auditOutput(webDirectory) { 'client', 'Button', 'navigation', - 'CapabilityGate', 'view-context', - 'inbox-setup-view', 'InboxSetup', 'inbox-view' ] @@ -1085,11 +1131,12 @@ export async function auditOutput(webDirectory) { [ 'InboxSetup', [ + 'public-key', + 'private-handles', 'public-runtime', 'client', 'Button', - 'view-context', - 'inbox-setup-view' + 'view-context' ] ], ['read', ['public-runtime']], @@ -1098,23 +1145,21 @@ export async function auditOutput(webDirectory) { 'nodes/5', [ 'public-key', - 'private-handles', 'public-runtime', 'references', 'client', 'Button', 'client.svelte', - 'navigation', 'state', 'view-context', 'legacy', - 'inbox-setup-view', + 'InboxSetup', 'inbox-view', 'InboxStatus', - 'resolve-head' + 'publishers', + 'MessageComposer' ] ], - ['resolve-head', ['public-runtime', 'Button', 'read']], [ 'inbox-view', [ @@ -1123,21 +1168,24 @@ export async function auditOutput(webDirectory) { 'public-runtime', 'references', 'Button', - 'inbox-setup-view', + 'InboxSetup', 'read' ] ], [ - 'inbox-setup-view', + 'MessageComposer', [ - 'public-key', 'private-handles', 'public-runtime', + 'references', + 'client', 'Button', - 'view-context' + 'navigation', + 'InboxSetup', + 'inbox-view', + 'publishers' ] ], - ['CapabilityGate', ['client', 'Button']], [ 'nodes/0', [ @@ -1147,62 +1195,148 @@ export async function auditOutput(webDirectory) { 'Button', 'client.svelte', 'state', - 'CapabilityGate', - 'Disclosure', - 'view-context' + 'view-context', + 'Disclosure' ] ] ] - : [ - [ - 'InboxStatus', + : hasProductEnquiry + ? [ + [ + 'InboxStatus', + [ + 'public-runtime', + 'client', + 'Button', + 'navigation', + 'CapabilityGate', + 'view-context', + 'inbox-setup-view', + 'InboxSetup', + 'inbox-view' + ] + ], [ - 'public-key', - 'private-handles', - 'public-runtime', - 'references', - 'client', - 'Button', - 'navigation', - 'view-context', 'InboxSetup', - 'read' - ] - ], - [ - 'InboxSetup', + [ + 'public-runtime', + 'client', + 'Button', + 'view-context', + 'inbox-setup-view' + ] + ], + ['read', ['public-runtime']], + ['nodes/4', ['client', 'AccountGate', 'InboxStatus']], [ - 'public-key', - 'private-handles', - 'public-runtime', - 'client', - 'Button', - 'view-context' + 'nodes/5', + [ + 'public-key', + 'private-handles', + 'public-runtime', + 'references', + 'client', + 'Button', + 'client.svelte', + 'navigation', + 'state', + 'view-context', + 'legacy', + 'inbox-setup-view', + 'inbox-view', + 'InboxStatus', + 'resolve-head' + ] + ], + ['resolve-head', ['public-runtime', 'Button', 'read']], + [ + 'inbox-view', + [ + 'public-key', + 'private-handles', + 'public-runtime', + 'references', + 'Button', + 'inbox-setup-view', + 'read' + ] + ], + [ + 'inbox-setup-view', + [ + 'public-key', + 'private-handles', + 'public-runtime', + 'Button', + 'view-context' + ] + ], + ['CapabilityGate', ['client', 'Button']], + [ + 'nodes/0', + [ + 'public-key', + 'public-runtime', + 'client', + 'Button', + 'client.svelte', + 'state', + 'CapabilityGate', + 'Disclosure', + 'view-context' + ] ] - ], - ['read', ['public-runtime']], - ['nodes/4', ['client', 'AccountGate', 'InboxStatus']], - [ - 'nodes/5', + ] + : [ [ - 'public-key', - 'private-handles', - 'public-runtime', - 'references', - 'client', - 'Button', - 'client.svelte', - 'navigation', - 'state', - 'view-context', - 'legacy', - 'InboxSetup', 'InboxStatus', - 'resolve-head' - ] - ], - ['resolve-head', ['public-runtime', 'Button', 'read']] - ]; + [ + 'public-key', + 'private-handles', + 'public-runtime', + 'references', + 'client', + 'Button', + 'navigation', + 'view-context', + 'InboxSetup', + 'read' + ] + ], + [ + 'InboxSetup', + [ + 'public-key', + 'private-handles', + 'public-runtime', + 'client', + 'Button', + 'view-context' + ] + ], + ['read', ['public-runtime']], + ['nodes/4', ['client', 'AccountGate', 'InboxStatus']], + [ + 'nodes/5', + [ + 'public-key', + 'private-handles', + 'public-runtime', + 'references', + 'client', + 'Button', + 'client.svelte', + 'navigation', + 'state', + 'view-context', + 'legacy', + 'InboxSetup', + 'InboxStatus', + 'resolve-head' + ] + ], + ['resolve-head', ['public-runtime', 'Button', 'read']] + ]; for (const [name, imports] of dependencies) { const [key, row] = entry(name); equal( @@ -1264,58 +1398,74 @@ export async function auditOutput(webDirectory) { throw new Error('Invalid owned product compiler identity'); equal( publisher.imports, - (hasInboxSetup - ? [ - 'public-key', - identityCompilerModule, - 'Button', - ...(hasInboxPresentation ? ['resolve-head'] : []) - ] - : hasPublicRuntime === 'public_identity' - ? ['public-key', identityCompilerModule, 'Disclosure', 'Button'] - : ['public-key', 'Disclosure', 'budgets'] + (hasProductRequest + ? ['public-key', 'public-runtime', 'Button', 'read'] + : hasInboxSetup + ? [ + 'public-key', + identityCompilerModule, + 'Button', + ...(hasInboxPresentation ? ['resolve-head'] : []) + ] + : 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?.toSorted(), - (hasInboxSetup + (hasProductRequest ? [ 'public-key', + 'public-runtime', 'references', - identityCompilerModule, 'client', 'Button', 'client.svelte', 'state', + 'view-context', 'Disclosure', - 'publishers', - ...(hasInboxPresentation ? ['resolve-head'] : []), - ...(hasProductEnquiry ? ['inbox-view'] : []) + 'InboxSetup', + 'MessageComposer' ] - : 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' + 'publishers', + ...(hasInboxPresentation ? ['resolve-head'] : []), + ...(hasProductEnquiry ? ['inbox-view'] : []) ] + : 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]) .sort(), @@ -1323,10 +1473,10 @@ export async function auditOutput(webDirectory) { ); equal( entry('nodes/9')[1].imports?.toSorted(), - (hasInboxSetup + (hasProductRequest ? [ + 'public-runtime', 'references', - identityCompilerModule, 'client', 'Button', 'client.svelte', @@ -1334,34 +1484,47 @@ export async function auditOutput(webDirectory) { 'state', 'Disclosure', 'routes', - 'publishers', - ...(hasInboxPresentation ? ['resolve-head'] : []) + 'publishers' ] - : 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' + 'publishers', + ...(hasInboxPresentation ? ['resolve-head'] : []) ] + : 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]) .sort(),