@remit/web-client 0.0.237 → 0.0.239

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.237",
+  "version": "0.0.239",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/components/mail/IntelligencePane.test.ts

@@ -36,6 +36,7 @@ describe("resolveSimilarState — fail-fast on similar-messages search", () => {
 				similarError: new Error("500"),
 				similarErrorIsFatal: true,
 				isSimilarLoading: false,
+				semanticEnabled: true,
 			}),
 			"ready",
 		);
@@ -47,6 +48,7 @@ describe("resolveSimilarState — fail-fast on similar-messages search", () => {
 				similarError: new Error("404"),
 				similarErrorIsFatal: false,
 				isSimilarLoading: false,
+				semanticEnabled: true,
 			}),
 			"error",
 		);
@@ -58,6 +60,7 @@ describe("resolveSimilarState — fail-fast on similar-messages search", () => {
 				similarError: null,
 				similarErrorIsFatal: false,
 				isSimilarLoading: false,
+				semanticEnabled: true,
 			}),
 			"ready",
 		);
@@ -69,8 +72,39 @@ describe("resolveSimilarState — fail-fast on similar-messages search", () => {
 				similarError: null,
 				similarErrorIsFatal: false,
 				isSimilarLoading: true,
+				semanticEnabled: true,
 			}),
 			"loading",
 		);
 	});
 });
+
+// Off is a property of the deployment, and it leads: nothing was embedded, so
+// there was no query, and the section states the setting instead of an empty
+// list (#1068). `undefined` is the config read still in flight, which is not
+// an answer.
+describe("resolveSimilarState — semantic search off on this instance", () => {
+	test("off wins over every runtime state", () => {
+		assert.equal(
+			resolveSimilarState({
+				similarError: new Error("404"),
+				similarErrorIsFatal: false,
+				isSimilarLoading: true,
+				semanticEnabled: false,
+			}),
+			"off",
+		);
+	});
+
+	test("a config read still in flight is not an off state", () => {
+		assert.equal(
+			resolveSimilarState({
+				similarError: null,
+				similarErrorIsFatal: false,
+				isSimilarLoading: false,
+				semanticEnabled: undefined,
+			}),
+			"ready",
+		);
+	});
+});

package/src/components/mail/IntelligencePane.tsx

@@ -82,6 +82,11 @@ export const resolveSpamAction = (thread: {
 /**
  * Decide the "Similar messages" section state from the semantic-search query.
  *
+ * An instance with semantic search off leads, before any error or in-flight
+ * state: nothing is embedded, no query was sent, and the section states the
+ * setting (#1068). Only `false` counts — the config read has not answered yet
+ * while it is `undefined`, and an off state shown then would be a guess.
+ *
  * The fail-fast rule: a fatal first-party 5xx must NEVER degrade to the benign
  * grey "Similarity search unavailable" label — it escalates to the global red
  * overlay instead, so this returns `"ready"` for it (the section then renders
@@ -93,8 +98,15 @@ export const resolveSimilarState = (input: {
 	similarError: unknown;
 	similarErrorIsFatal: boolean;
 	isSimilarLoading: boolean;
+	semanticEnabled: boolean | undefined;
 }): SimilarState => {
-	const { similarError, similarErrorIsFatal, isSimilarLoading } = input;
+	const {
+		similarError,
+		similarErrorIsFatal,
+		isSimilarLoading,
+		semanticEnabled,
+	} = input;
+	if (semanticEnabled === false) return "off";
 	if (similarError && !similarErrorIsFatal) return "error";
 	if (isSimilarLoading) return "loading";
 	return "ready";
@@ -228,6 +240,7 @@ function WiredPanel({
 		isSimilarLoading,
 		similarError,
 		similarErrorIsFatal,
+		semanticEnabled,
 	} = useIntelligenceData(thread, mailboxId);
 	const [reclassifyOpen, setReclassifyOpen] = useState(false);
 	const senderEmail = thread.fromEmail ?? undefined;
@@ -336,6 +349,7 @@ function WiredPanel({
 		similarError,
 		similarErrorIsFatal,
 		isSimilarLoading,
+		semanticEnabled,
 	});
 
 	return (

package/src/components/mail/SelectionWizardHost.tsx

@@ -49,6 +49,7 @@ import { useOrganizeJob } from "@/hooks/useOrganizeJob";
 import { useOrganizeWiden } from "@/hooks/useOrganizeWiden";
 import { useRulePreview } from "@/hooks/useRulePreview";
 import { useSelectedSubjects } from "@/hooks/useSelectedSubjects";
+import { useSemanticSearchEnabled } from "@/hooks/useSemanticSearchEnabled";
 import type {
 	BulkActionProgress,
 	BulkActionTarget,
@@ -563,7 +564,12 @@ function SelectionWizardSession({
 	// unavailable while the user is already holding it. The fallback is taken then
 	// rather than left as a door that counts nothing: the property step says, in
 	// so many words, that these are the senders it substituted (#477 3.6).
-	const semanticUnavailable = widen.semanticUnavailable || widen.isError;
+	// Off is a deployment setting, not a probe result, and it reaches the door the
+	// same way the runtime failure does: dimmed, pressable, and falling back to
+	// the senders. Only the copy differs (#1068).
+	const semanticOff = useSemanticSearchEnabled() === false;
+	const semanticUnavailable =
+		semanticOff || widen.semanticUnavailable || widen.isError;
 	// Only while the door is the screen: the probe re-fires when the anchor
 	// changes under a background refetch, and a late answer that moved the step
 	// from Review would push an entry the wizard does not own and leave the count
@@ -1001,6 +1007,7 @@ function SelectionWizardSession({
 				accountId: wizardScope.accountId,
 				onModeChange: changeMode,
 				semanticUnavailable,
+				semanticOff,
 				semanticErrorDetail:
 					widen.error instanceof Error ? widen.error.message : undefined,
 				semanticFallbackTaken,

package/src/components/mail/intelligence-semantic-off.render.test.ts

@@ -0,0 +1,128 @@
+/**
+ * "Similar messages" on an instance with semantic search off (#1068).
+ *
+ * Off is a deployment setting, and the client learns it from the config read
+ * every surface already makes. Before this the section rendered nothing at all,
+ * which reads as a sender nothing resembles — the one thing an operator who
+ * has not turned semantic search on cannot tell from the truth.
+ *
+ * Drives the real chain: `useIntelligenceData` reads `GET /config`, the state
+ * resolver turns `semanticSearchEnabled: false` into the off state, and the
+ * real `IntelligencePanel` renders it. Both halves are asserted — the copy the
+ * operator acts on, and that no semantic query is sent at all.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import { IntelligencePanel } from "@remit/ui";
+import { createElement } from "react";
+import { useIntelligenceData } from "@/hooks/useIntelligenceData";
+import { createDomHarness, type DomHarness } from "@/test-support/dom";
+import {
+	makeAccount,
+	makeConfig,
+	makeThreadMessage,
+} from "@/test-support/fixtures";
+import { type HttpMock, mockFetch } from "@/test-support/http";
+import { resolveSimilarState } from "./IntelligencePane";
+
+const thread = makeThreadMessage({ messageId: "msg-1" });
+
+const SimilarHarness = () => {
+	const {
+		data,
+		isSimilarLoading,
+		similarError,
+		similarErrorIsFatal,
+		semanticEnabled,
+	} = useIntelligenceData(thread, "mbx-inbox");
+	if (!data) return null;
+	return createElement(IntelligencePanel, {
+		data,
+		similarState: resolveSimilarState({
+			similarError,
+			similarErrorIsFatal,
+			isSimilarLoading,
+			semanticEnabled,
+		}),
+	});
+};
+
+const respond =
+	(semanticSearchEnabled: boolean) => (call: { path: string }) => {
+		if (call.path.endsWith("/config")) {
+			return makeConfig([makeAccount({ accountId: "acc-1" })], {
+				semanticSearchEnabled,
+			});
+		}
+		if (call.path.endsWith("/addresses/search")) return { items: [] };
+		return { items: [] };
+	};
+
+let harness: DomHarness | undefined;
+let http: HttpMock;
+
+const waitFor = async (
+	predicate: () => boolean,
+	timeoutMs = 2000,
+): Promise<void> => {
+	if (!harness) throw new Error("nothing mounted");
+	const deadline = Date.now() + timeoutMs;
+	while (!predicate()) {
+		if (Date.now() > deadline) {
+			throw new Error(
+				`waitFor: condition never became true within ${timeoutMs}ms`,
+			);
+		}
+		await harness.flush();
+		await harness.wait(5);
+	}
+};
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http.restore();
+});
+
+describe("the Similar messages section on an instance with semantic search off", () => {
+	it("states the setting, what turning it on buys, and the command", async () => {
+		http = mockFetch(respond(false));
+		harness = createDomHarness();
+		harness.renderApp(createElement(SimilarHarness));
+
+		await waitFor(
+			() => harness?.text().includes("Semantic search is off") === true,
+		);
+
+		const text = harness.text();
+		assert.match(text, /Semantic search is off on this instance/);
+		assert.match(text, /Organize/);
+		assert.match(text, /filters/);
+		assert.match(text, /remit semantic on/);
+	});
+
+	it("sends no semantic query, because an empty answer is the same as no match", async () => {
+		http = mockFetch(respond(false));
+		harness = createDomHarness();
+		harness.renderApp(createElement(SimilarHarness));
+
+		await waitFor(
+			() => harness?.text().includes("Semantic search is off") === true,
+		);
+		await harness.wait(30);
+		await harness.flush();
+
+		assert.deepEqual(http.to("/search/semantic"), []);
+	});
+
+	it("says none of it while the instance has semantic search on", async () => {
+		http = mockFetch(respond(true));
+		harness = createDomHarness();
+		harness.renderApp(createElement(SimilarHarness));
+
+		await waitFor(() => http.to("/search/semantic").length > 0);
+
+		assert.doesNotMatch(harness.text(), /Semantic search is off/);
+	});
+});

package/src/components/settings/CalendarFeedCard.render.test.ts

@@ -0,0 +1,154 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import React, { createElement } from "react";
+import { renderToString } from "react-dom/server";
+import type { CalendarFeedState } from "@/hooks/calendar/useCalendarFeed";
+import { CalendarFeedCard } from "./CalendarFeedCard";
+
+// The node test loader transpiles remit-ui's `.tsx` with the classic JSX
+// runtime, which references a global `React`. Vite uses the automatic runtime,
+// so this shim only exists for the SSR test harness.
+(globalThis as { React?: typeof React }).React = React;
+
+const CREATED = Date.parse("2026-05-04T09:12:00Z");
+const ROTATED = Date.parse("2026-08-19T16:40:00Z");
+const ADDRESS = "webcal://mail.example.com/feeds/calendar/token-here.ics";
+
+const render = (
+	state: CalendarFeedState,
+	overrides: {
+		mintedUrl?: string;
+		isBusy?: boolean;
+		actionError?: unknown;
+	} = {},
+) =>
+	renderToString(
+		createElement(CalendarFeedCard, {
+			calendarName: "Work",
+			state,
+			mintedUrl: overrides.mintedUrl ?? "",
+			isBusy: overrides.isBusy ?? false,
+			actionError: overrides.actionError,
+			onMint: () => undefined,
+			onRevoke: () => undefined,
+			onDismissMinted: () => undefined,
+			onRetry: () => undefined,
+		}) as never,
+	);
+
+describe("CalendarFeedCard", () => {
+	it("names the calendar in every state", () => {
+		assert.match(render({ status: "loading" }), /Work/);
+	});
+
+	it("offers to create an address when the calendar is not shared", () => {
+		const html = render({ status: "absent" });
+		assert.match(html, /Create subscription address/);
+		assert.doesNotMatch(html, /Stop sharing/);
+	});
+
+	it("says the address is the credential before one exists", () => {
+		assert.match(
+			render({ status: "absent" }),
+			/the address is the credential/i,
+		);
+	});
+
+	it("shows when a shared address was created, and offers both takebacks", () => {
+		const html = render({
+			status: "active",
+			createdAt: CREATED,
+			rotatedAt: 0,
+		});
+		assert.match(html, /shared/);
+		assert.match(html, /Address created/);
+		assert.doesNotMatch(html, /last replaced/);
+		assert.match(html, /Replace address/);
+		assert.match(html, /Stop sharing/);
+	});
+
+	it("names the last replacement once the address has been rotated", () => {
+		const html = render({
+			status: "active",
+			createdAt: CREATED,
+			rotatedAt: ROTATED,
+		});
+		assert.match(html, /last replaced/);
+	});
+
+	/**
+	 * The whole point of the state: a shared calendar shows no address, because
+	 * only a hash of it is stored. A card that could re-display it would mean the
+	 * server had kept the secret.
+	 */
+	it("never shows an address for a feed it merely knows exists", () => {
+		const html = render({
+			status: "active",
+			createdAt: CREATED,
+			rotatedAt: 0,
+		});
+		assert.doesNotMatch(html, /webcal:\/\//);
+	});
+
+	it("shows a minted address once, with a copy control and both warnings", () => {
+		const html = render(
+			{ status: "active", createdAt: CREATED, rotatedAt: 0 },
+			{ mintedUrl: ADDRESS },
+		);
+		assert.match(html, /webcal:\/\/mail\.example\.com/);
+		assert.match(html, /Copy address/);
+		assert.match(html, /shown once and cannot be read back/);
+		assert.match(html, /Anyone holding this address can read every event/);
+	});
+
+	it("states a refused write where the control is, rather than going quiet", () => {
+		const html = render(
+			{ status: "absent" },
+			{ actionError: new Error("Calendar not found") },
+		);
+		assert.match(html, /was not changed/);
+		assert.match(html, /Calendar not found/);
+	});
+
+	/**
+	 * A read the server refused is not "not shared". Drawing the create button
+	 * for it would tell the reader their calendar is private while it may be
+	 * subscribed to right now.
+	 */
+	it("keeps a failed read distinct from a calendar that is not shared", () => {
+		const html = render({
+			status: "unreadable",
+			error: new Error("Service unavailable"),
+		});
+		assert.match(html, /Couldn.{0,6}t read whether Work is shared/);
+		assert.match(html, /Service unavailable/);
+		assert.doesNotMatch(html, /Create subscription address/);
+	});
+
+	it("disables the create control while a write is in flight", () => {
+		const html = render({ status: "absent" }, { isBusy: true });
+		assert.match(html, /disabled/);
+		assert.match(html, /Creating…/);
+	});
+
+	/**
+	 * The mint's invalidate() re-reads the feed, and that read passes back
+	 * through "loading" before it settles as "active". A skeleton drawn over
+	 * the address already on screen carries a name that is a substring of the
+	 * address input's own label, so the two collide under one accessible name.
+	 */
+	it("does not draw the loading skeleton over an address just minted", () => {
+		const html = render({ status: "loading" }, { mintedUrl: ADDRESS });
+		assert.match(html, /webcal:\/\/mail\.example\.com/);
+		assert.doesNotMatch(html, /Loading the subscription address/);
+	});
+
+	it("does not draw a read failure over an address just minted", () => {
+		const html = render(
+			{ status: "unreadable", error: new Error("Service unavailable") },
+			{ mintedUrl: ADDRESS },
+		);
+		assert.match(html, /webcal:\/\/mail\.example\.com/);
+		assert.doesNotMatch(html, /Couldn.{0,6}t read whether/);
+	});
+});

package/src/components/settings/CalendarFeedCard.stories.tsx

@@ -0,0 +1,134 @@
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { CalendarFeedCard } from "./CalendarFeedCard";
+
+/**
+ * Settings › Calendars: the per-calendar subscription address (#1067). Every
+ * state the server can put the control in, including the one moment the address
+ * is legible and the two confirmations that take it away.
+ */
+const meta: Meta<typeof CalendarFeedCard> = {
+	title: "Flows/Settings Calendars/Subscription address",
+	component: CalendarFeedCard,
+	parameters: { layout: "padded" },
+	args: {
+		calendarName: "Work",
+		mintedUrl: "",
+		isBusy: false,
+		actionError: undefined,
+		onMint: () => undefined,
+		onRevoke: () => undefined,
+		onDismissMinted: () => undefined,
+		onRetry: () => undefined,
+	},
+};
+export default meta;
+
+type Story = StoryObj<typeof CalendarFeedCard>;
+
+const CREATED = Date.parse("2026-05-04T09:12:00Z");
+const ROTATED = Date.parse("2026-08-19T16:40:00Z");
+
+const ADDRESS =
+	"webcal://mail.example.com/feeds/calendar/9Xq2mB7tK1vHs4dLpZ0rY6wJfN3aC8eQuIoT5gRbVkE.ics";
+
+/** The read is still out — no control has an answer to draw yet. */
+export const Loading: Story = {
+	args: { state: { status: "loading" } },
+};
+
+/** Not shared. The one control creates the address, and says what it is. */
+export const NotShared: Story = {
+	args: { state: { status: "absent" } },
+};
+
+/** The create is in flight. */
+export const Creating: Story = {
+	args: { state: { status: "absent" }, isBusy: true },
+};
+
+/** Shared, on an address that has never been replaced. */
+export const Shared: Story = {
+	args: {
+		state: { status: "active", createdAt: CREATED, rotatedAt: 0 },
+	},
+};
+
+/** Shared, on the dark theme. */
+export const SharedDark: Story = {
+	name: "Shared (dark)",
+	parameters: { theme: "dark" },
+	args: {
+		state: { status: "active", createdAt: CREATED, rotatedAt: 0 },
+	},
+};
+
+/** Shared on an address that has been replaced since it was first created. */
+export const SharedAfterRotation: Story = {
+	args: {
+		state: { status: "active", createdAt: CREATED, rotatedAt: ROTATED },
+	},
+};
+
+/**
+ * The one moment the address is readable: straight after the write that minted
+ * it. It is not stored in the clear, so nothing can show it again.
+ */
+export const AddressShownOnce: Story = {
+	args: {
+		state: { status: "active", createdAt: CREATED, rotatedAt: 0 },
+		mintedUrl: ADDRESS,
+	},
+};
+
+/** The same, on the dark theme. */
+export const AddressShownOnceDark: Story = {
+	name: "Address shown once (dark)",
+	parameters: { theme: "dark" },
+	args: {
+		state: { status: "active", createdAt: CREATED, rotatedAt: 0 },
+		mintedUrl: ADDRESS,
+	},
+};
+
+/** Replacing the address warns that the current one stops working. */
+export const RotateConfirm: Story = {
+	args: {
+		state: { status: "active", createdAt: CREATED, rotatedAt: 0 },
+	},
+	play: async ({ canvasElement }) => {
+		const buttons = [...canvasElement.querySelectorAll("button")];
+		buttons.find((button) => button.textContent === "Replace address")?.click();
+	},
+};
+
+/** Revoking says the address stops working immediately. */
+export const RevokeConfirm: Story = {
+	args: {
+		state: { status: "active", createdAt: CREATED, rotatedAt: 0 },
+	},
+	play: async ({ canvasElement }) => {
+		const buttons = [...canvasElement.querySelectorAll("button")];
+		buttons.find((button) => button.textContent === "Stop sharing")?.click();
+	},
+};
+
+/** The write was refused. The card says so where the button is. */
+export const WriteRefused: Story = {
+	args: {
+		state: { status: "absent" },
+		actionError: new Error("Calendar not found"),
+	},
+};
+
+/**
+ * The read itself failed. Not drawn as "not shared": a calendar the server
+ * would not answer for may well be shared with somebody right now.
+ */
+export const Unreadable: Story = {
+	args: {
+		state: {
+			status: "unreadable",
+			error: new Error("Service unavailable"),
+		},
+	},
+};