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:
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(),