create-ailk 0.7.0 → 0.9.0

package/templates/apps/web/app/[locale]/[slug]/[detail]/page.tsx

@@ -0,0 +1,60 @@
+// The Free /meet/<slug> placeholder detail route (#6897 D2). BookCall
+// content served at /meet/<detail> by Next.js static-segment precedence:
+// wherever apps/web/app/[locale]/meet/ exists (the scheduling module), that
+// directory resolves every /meet/* URL first and this route never runs. On a
+// keyless scaffold, this route serves the four Free placeholder detail pages.
+//
+// `slug` must equal MEET_PLACEHOLDER_HUB ("meet") — any other value 404s.
+// This route deliberately serves ONLY the one meet hub, not a generic
+// two-segment content route: BookCall's slug pattern forbids "/", so a
+// generic join would also be reachable at a one-segment URL through the
+// `[slug]` route — a duplicate-content defect. A second hub can generalize
+// this route when one exists.
+//
+// Unknown detail slug → notFound() (renderPage's own detail-route branch: no
+// translationsNamespace is passed, so a null source 404s rather than
+// rendering an empty-state placeholder — the same contract `[slug]/page.tsx`
+// documents).
+//
+// Deliberately NO generateStaticParams, for the same reason as `[slug]/page.tsx`:
+// the locale layout reads cookies()/headers(), so this segment always renders
+// on request.
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import { renderPage, renderPageMetadata } from "@working-theory/page-renderer";
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import type { ReactElement } from "react";
+
+import { MEET_PLACEHOLDER_HUB } from "../../../../lib/meet-placeholder";
+
+interface Props {
+  params: Promise<{ locale: string; slug: string; detail: string }>;
+  /** Test-only DI override for getMdxSource. Production callers leave undefined. */
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export async function generateMetadata({
+  params,
+}: Pick<Props, "params">): Promise<Metadata> {
+  const { locale, slug, detail } = await params;
+  // Mirrors renderPageMetadata's own missing-frontmatter → {} contract: a
+  // hub mismatch is the same "nothing to title" case, not a thrown 404 —
+  // generateMetadata cannot itself change the response status.
+  if (slug !== MEET_PLACEHOLDER_HUB) return {};
+  return renderPageMetadata({ type: "BookCall", slug: detail, locale });
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale, slug, detail } = await params;
+  if (slug !== MEET_PLACEHOLDER_HUB) notFound();
+  return renderPage({
+    type: "BookCall",
+    slug: detail,
+    locale,
+    populatedDescriptionTestId: `${detail}-description`,
+    ...(getMdxSource !== undefined && { getMdxSource }),
+  });
+}

package/templates/apps/web/app/[locale]/[slug]/page.tsx

@@ -21,7 +21,7 @@
 // `ItemList` — the correct page type, not a LandingPage wearing a `schema:`
 // override the structured-data gate rejects) served here, and still yields
 // to the module's directory by the same precedence. Every other list type
-// has its own route directory (`/features` → ProductsList, `/use-cases` →
+// has its own route directory (`/features` → ProductsList, `/for` →
 // UseCasesList) and never reaches this route.
 //
 // Unknown slug → `notFound()` (renderPage's own detail-route branch: no

package/templates/apps/web/app/[locale]/alternatives/__tests__/page.test.tsx

@@ -0,0 +1,161 @@
+/**
+ * Tests for /alternatives (#6878 D9) — the ComparisonsList hub.
+ *
+ * `renderPage`/`renderPageMetadata`/`getMdxSlugs` are mocked at the
+ * `@working-theory/page-renderer` boundary so this suite can assert on the
+ * exact input `renderPage` receives — in particular the injected
+ * `getPageSections` override that appends the generated spoke list (AC-7:
+ * "the hub links each /vs spoke").  `getMdxSource` and `getPageSections`
+ * (the hub's own declared sections) are supplied per-call through the
+ * route's DI props, as every other page in this app does.
+ */
+// The mock return value is never rendered — every assertion below inspects
+// `mockRenderPage.mock.calls` directly — so it carries no `ReactElement`
+// cast; `renderPage`'s real return type is `Promise<ReactElement>` in
+// production, unaffected by this mock's loose type here.
+const mockRenderPage = jest.fn(async (..._args: unknown[]) => "<rendered/>");
+const mockRenderPageMetadata = jest.fn((..._args: unknown[]) => undefined);
+const mockGetMdxSlugs = jest.fn((..._args: unknown[]) => Promise.resolve<string[]>([]));
+const mockNotFound = jest.fn(() => {
+  throw new Error("NEXT_NOT_FOUND");
+});
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: () => mockNotFound(),
+}));
+
+jest.mock("@working-theory/page-renderer", () => ({
+  __esModule: true,
+  getMdxSlugs: (...args: unknown[]) => mockGetMdxSlugs(...args),
+  renderPage: (...args: unknown[]) => mockRenderPage(...args),
+  renderPageMetadata: (...args: unknown[]) => mockRenderPageMetadata(...args),
+  // Never reached — every call in this suite passes both via DI props.
+  getMdxSource: jest.fn(),
+  getPageSections: jest.fn(),
+}));
+
+import AlternativesPage, { generateMetadata } from "../page";
+
+const HUB_SOURCE = {
+  frontmatter: {
+    type: "ComparisonsList",
+    slug: "alternatives",
+    title: "Alternatives",
+    description: "How we compare.",
+  },
+  body: "",
+};
+
+beforeEach(() => jest.clearAllMocks());
+
+describe("AlternativesPage — hub seed absent", () => {
+  it("calls notFound() and never reaches renderPage", async () => {
+    const getMdxSource = jest.fn().mockResolvedValue(null);
+
+    await expect(
+      AlternativesPage({
+        params: Promise.resolve({ locale: "en" }),
+        getMdxSource,
+        getPageSections: jest.fn(),
+      }),
+    ).rejects.toThrow("NEXT_NOT_FOUND");
+
+    expect(mockNotFound).toHaveBeenCalledTimes(1);
+    expect(mockRenderPage).not.toHaveBeenCalled();
+  });
+});
+
+describe("AlternativesPage — metadata", () => {
+  it("resolves ComparisonsList slug alternatives", async () => {
+    await generateMetadata({ params: Promise.resolve({ locale: "en" }) });
+    expect(mockRenderPageMetadata).toHaveBeenCalledWith({
+      type: "ComparisonsList",
+      slug: "alternatives",
+      locale: "en",
+    });
+  });
+});
+
+describe("AlternativesPage — generated spoke list (D9)", () => {
+  it("appends one items section entry per ComparisonPage spoke, each linking /vs/<slug>", async () => {
+    mockGetMdxSlugs.mockResolvedValue(["acme", "globex"]);
+    const spokeSources: Record<string, unknown> = {
+      acme: {
+        frontmatter: { title: "vs. Acme", description: "How we compare to Acme." },
+        body: "",
+      },
+      globex: {
+        frontmatter: { title: "vs. Globex", description: "How we compare to Globex." },
+        body: "",
+      },
+    };
+    const getMdxSource = jest
+      .fn()
+      .mockImplementation((type: string, slug: string) => {
+        if (type === "ComparisonsList") return Promise.resolve(HUB_SOURCE);
+        return Promise.resolve(spokeSources[slug] ?? null);
+      });
+    const getPageSections = jest
+      .fn()
+      .mockResolvedValue([{ id: "hero", type: "hero", data: {} }]);
+
+    await AlternativesPage({
+      params: Promise.resolve({ locale: "en" }),
+      getMdxSource,
+      getPageSections,
+    });
+
+    expect(mockRenderPage).toHaveBeenCalledTimes(1);
+    const passedInput = mockRenderPage.mock.calls[0]?.[0] as {
+      type: string;
+      slug: string;
+      getPageSections: (frontmatter: unknown) => Promise<unknown[]>;
+    };
+    expect(passedInput.type).toBe("ComparisonsList");
+    expect(passedInput.slug).toBe("alternatives");
+
+    const sections = await passedInput.getPageSections({});
+    expect(sections).toEqual([
+      { id: "hero", type: "hero", data: {} },
+      {
+        type: "items",
+        id: "comparison-spokes",
+        data: {
+          items: [
+            {
+              title: "vs. Acme",
+              description: "How we compare to Acme.",
+              link: { label: "Read the comparison", href: "/vs/acme" },
+            },
+            {
+              title: "vs. Globex",
+              description: "How we compare to Globex.",
+              link: { label: "Read the comparison", href: "/vs/globex" },
+            },
+          ],
+        },
+      },
+    ]);
+  });
+
+  it("omits the generated section entirely with zero spokes (the hub's own sections render alone)", async () => {
+    mockGetMdxSlugs.mockResolvedValue([]);
+    const getMdxSource = jest.fn().mockResolvedValue(HUB_SOURCE);
+    const getPageSections = jest
+      .fn()
+      .mockResolvedValue([{ id: "hero", type: "hero", data: {} }]);
+
+    await AlternativesPage({
+      params: Promise.resolve({ locale: "en" }),
+      getMdxSource,
+      getPageSections,
+    });
+
+    const passedInput = mockRenderPage.mock.calls[0]?.[0] as {
+      getPageSections: (frontmatter: unknown) => Promise<unknown[]>;
+    };
+    const sections = await passedInput.getPageSections({});
+    expect(sections).toEqual([{ id: "hero", type: "hero", data: {} }]);
+  });
+});

package/templates/apps/web/app/[locale]/alternatives/page.tsx

@@ -0,0 +1,104 @@
+// ComparisonsList hub (#6878 D9) — the /alternatives page. Reads
+// ComparisonsList MDX via the content adapter, injects a generated `items`
+// section listing every ComparisonPage spoke (so the visible card grid and
+// the CollectionPage's ItemList JSON-LD — built from the same sections —
+// always agree, D9), and emits via the dispatcher.
+//
+// notFound() when the hub seed is absent, so no empty hub is ever served
+// (unlike the /for hub's empty-state branch): an add-page run always writes
+// the seed alongside the first spoke (D11), so a fresh scaffold — which
+// excludes this gated surface entirely — never reaches this branch in
+// production, only a mis-authored site would.
+//
+// Gated off by default (surfaces.ts `alternatives` surface): no roster names
+// this route, so a fresh scaffold excludes it.
+import type {
+  getMdxSource as defaultGetMdxSource,
+  getPageSections as defaultGetPageSections,
+} from "@working-theory/page-renderer";
+import {
+  getMdxSlugs,
+  getMdxSource as loadMdxSource,
+  getPageSections as loadPageSections,
+  renderPage,
+  renderPageMetadata,
+} from "@working-theory/page-renderer";
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+  getPageSections?: typeof defaultGetPageSections;
+}
+
+type Section = Awaited<ReturnType<typeof defaultGetPageSections>>[number];
+
+export async function generateMetadata({
+  params,
+}: Pick<Props, "params">): Promise<Metadata> {
+  const { locale } = await params;
+  return renderPageMetadata({
+    type: "ComparisonsList",
+    slug: "alternatives",
+    locale,
+  });
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+  getPageSections,
+}: Props): Promise<ReactElement> {
+  const { locale } = await params;
+  const load = getMdxSource ?? loadMdxSource;
+  const loadSections = getPageSections ?? loadPageSections;
+
+  const source = await load("ComparisonsList", "alternatives", locale);
+  if (source === null) {
+    notFound();
+  }
+
+  /**
+   * Append one generated `items` section listing every ComparisonPage spoke
+   * — D9's "the visible list and the CollectionPage's ItemList always
+   * agree" property, since `renderPage` builds JSON-LD from these same
+   * sections. Absent when there are zero spokes: the hub still renders its
+   * own authored sections and answers 200 on its seed alone.
+   */
+  async function withSpokes(frontmatter: unknown): Promise<Section[]> {
+    const declared = await loadSections(frontmatter);
+    const slugs = await getMdxSlugs("ComparisonPage", locale);
+    if (slugs.length === 0) return declared;
+
+    const items = await Promise.all(
+      slugs.map(async (slug) => {
+        const spoke = await load("ComparisonPage", slug, locale);
+        const fm = (spoke?.frontmatter ?? {}) as {
+          title?: string;
+          description?: string;
+        };
+        return {
+          title: fm.title ?? slug,
+          description: fm.description ?? "",
+          link: { label: "Read the comparison", href: `/vs/${slug}` },
+        };
+      }),
+    );
+
+    return [
+      ...declared,
+      { type: "items" as const, id: "comparison-spokes", data: { items } },
+    ];
+  }
+
+  return renderPage({
+    type: "ComparisonsList",
+    slug: "alternatives",
+    locale,
+    translationsNamespace: "alternatives",
+    getPageSections: withSpokes,
+    ...(getMdxSource !== undefined && { getMdxSource }),
+  });
+}

package/templates/apps/web/app/[locale]/contact/ConversationalIntakeWrapper.tsx

@@ -8,8 +8,8 @@
  * conversation logic, only:
  *
  *   1. Submission — `onComplete` hands the finished answers to the SAME
- *      `captureLeadAction` (`./contact.actions.ts`) the plain `<ContactForm/>`
- *      already uses, built as a `FormData` (imperatively, not a real
+ *      `captureLeadAction` (`./contact.actions.ts`) the shared
+ *      `LeadCaptureForm` on `/contact` already uses, built as a `FormData` (imperatively, not a real
  *      `<form>` submit — React 19 Server Actions are plain async functions).
  *      That action posts through the EXISTING `POST /v1/leads/submit` route
  *      (`apps/api/src/routes/leads`, consumed via `@working-theory/api-client`,
@@ -21,7 +21,8 @@
  *      second web surface, not a new one. `contact.actions.ts`'s own
  *      doc-comment covers the additive `source` FormData field this file
  *      sets to distinguish intake-originated leads.
- *   2. Skip fallback — `onSkip` swaps to the EXISTING `<ContactForm/>`,
+ *   2. Skip fallback — `onSkip` swaps to the shared `LeadCaptureForm` block
+ *      (#6730 — the one contact form), bound to the same action,
  *      carrying over whatever answers were already captured as its
  *      `initialValues` prefill. A failed auto-submit on `onComplete` falls
  *      back the same way, so a lead is never silently lost.
@@ -43,14 +44,16 @@ import {
   ConversationalIntake,
   type ConversationalIntakeProps,
   InlineMessage,
+  LeadCaptureForm,
+  localeHref,
   THINKING_DELAY_MAX_MS,
   THINKING_DELAY_MIN_MS,
 } from "@working-theory/ui";
 import { useLocale, useTranslations } from "next-intl";
 import { useCallback, useMemo, useRef, useState } from "react";
 
+import { contactFormText } from "./contact-form-text";
 import { captureLeadAction } from "./contact.actions";
-import { ContactForm, type ContactFormInitialValues } from "./ContactForm";
 import { recordIntakeTurn } from "./intake-analytics";
 import { buildContactIntakeScript } from "./intake-script";
 
@@ -120,7 +123,7 @@ export function ConversationalIntakeWrapper({
   );
 
   const [surface, setSurface] = useState<Surface>("intake");
-  const [initialValues, setInitialValues] = useState<ContactFormInitialValues>(
+  const [initialValues, setInitialValues] = useState<Record<string, string>>(
     {},
   );
   const [submitError, setSubmitError] = useState<string | undefined>(
@@ -193,7 +196,12 @@ export function ConversationalIntakeWrapper({
             {submitError}
           </InlineMessage>
         ) : null}
-        <ContactForm initialValues={initialValues} />
+        <LeadCaptureForm
+          action={captureLeadAction}
+          text={contactFormText(t)}
+          termsHref={localeHref(locale, "/terms")}
+          initialValues={initialValues}
+        />
       </Container>
     );
   }

package/templates/apps/web/app/[locale]/contact/__tests__/ConversationalIntakeWrapper.test.tsx

@@ -6,8 +6,8 @@
  *   the EXISTING lead-capture endpoint. Only the outermost network
  *   boundary is mocked (`@working-theory/api-client`'s `leads.submit`) —
  *   the REAL `ConversationalIntake` block (#4543) and its engine (#4532),
- *   the REAL `captureLeadAction` (the SAME action `<ContactForm/>` already
- *   uses), and the REAL `submitLeadInputSchema` validation all run, proving
+ *   the REAL `captureLeadAction` (the SAME action the shared
+ *   `LeadCaptureForm` on `/contact` uses), and the REAL `submitLeadInputSchema` validation all run, proving
  *   the whole chain end to end. No file under apps/api is imported, mocked,
  *   or touched by this test or by the wiring it exercises.
  * AC2 — Skip renders the existing form, carrying over answers already
@@ -36,13 +36,14 @@ jest.mock("@working-theory/analytics/server", () => ({
 }));
 
 // ConversationalIntakeWrapper's own responsibility under test here is the
-// submission/skip/analytics wiring around the block — not ContactForm's own
-// rendering, which apps/web's existing tests already document as crashing
-// in jsdom (useFormState/useFormStatus; see page-renderer-migration.test.tsx).
-// Narrow internal-module mock, same precedent as that file's ContactForm stub.
-// eslint-disable-next-line no-restricted-syntax -- test-seam mock required; ContactForm uses useFormState/useFormStatus which crash in jsdom (see page-renderer-migration.test.tsx); narrowest possible scope
-jest.mock("../ContactForm", () => ({
-  ContactForm: (props: { initialValues?: Record<string, string> }) =>
+// submission/skip/analytics wiring around the block — not the shared
+// LeadCaptureForm's own rendering, which its block suite covers
+// (packages/ui/src/blocks/__tests__/LeadCaptureForm.test.tsx). The real
+// `@working-theory/ui` runs (the ConversationalIntake block included); only
+// the form block is stubbed, so the carried-over `initialValues` can be read.
+jest.mock("@working-theory/ui", () => ({
+  ...jest.requireActual("@working-theory/ui"),
+  LeadCaptureForm: (props: { initialValues?: Record<string, string> }) =>
     require("react").createElement("div", {
       "data-testid": "contact-form-stub",
       "data-initial-values": JSON.stringify(props.initialValues ?? {}),

package/templates/apps/web/app/[locale]/contact/__tests__/contact-form-text.test.ts

@@ -0,0 +1,32 @@
+/**
+ * contactFormText (#6730 D8) — the `contact` namespace mapped onto the shared
+ * form block's copy, with `unavailableBody`'s `{email}` placeholder kept for
+ * the block to fill.
+ */
+import messages from "../../../../messages/en.json";
+import { contactFormText } from "../contact-form-text";
+
+/** A translator over the English catalog that interpolates `{name}` values, as ICU does. */
+function translator(key: string, values?: Record<string, string>): string {
+  const template = (messages.contact as Record<string, unknown>)[key];
+  if (typeof template !== "string") throw new Error(`missing contact.${key}`);
+  return template.replace(/\{(\w+)\}/g, (m, name: string) => values?.[name] ?? m);
+}
+
+describe("contactFormText", () => {
+  it("maps every block string from the English catalog, keeping {email} for the block", () => {
+    expect(contactFormText(translator)).toEqual({
+      nameLabel: "Name",
+      emailLabel: "Email",
+      messageLabel: "Message",
+      submit: "Send message",
+      sending: "Sending…",
+      success: messages.contact.successMessage,
+      genericError: messages.contact.genericError,
+      consentStatement: messages.contact.consentStatement,
+      unavailableHeading: messages.contact.unavailableHeading,
+      unavailableBody: "Email us at {email} and we'll reply.",
+      unavailableNoEmail: messages.contact.unavailableNoEmail,
+    });
+  });
+});

package/templates/apps/web/app/[locale]/contact/__tests__/contact.actions.test.ts

@@ -179,3 +179,132 @@ describe("captureLeadAction — API error", () => {
     consoleErrorSpy.mockRestore();
   });
 });
+
+// ─── #6730 D8 — honest outcomes and declared extra fields ────────────────────
+
+describe("captureLeadAction — outcome mapping (#6730)", () => {
+  it("503 lead_capture_not_configured → unavailable", async () => {
+    mockSubmit.mockResolvedValueOnce({
+      ok: false,
+      status: 503,
+      body: { error: "lead_capture_not_configured", message: "Lead capture is not configured." },
+    });
+
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    expect(result).toEqual({ kind: "unavailable" });
+  });
+
+  it("503 delivery_failed → the generic error, never success", async () => {
+    mockSubmit.mockResolvedValueOnce({
+      ok: false,
+      status: 503,
+      body: { error: "delivery_failed", message: "The message could not be delivered." },
+    });
+
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    expect(result).toMatchObject({ kind: "error" });
+    expect(result).not.toMatchObject({ kind: "success" });
+  });
+
+  it.each([400, 429, 500, 503])("a non-2xx (%s) is never success", async (status) => {
+    mockSubmit.mockResolvedValueOnce({ ok: false, status, body: { error: "x" } });
+
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    expect(result?.kind).toBe("error");
+  });
+
+  it("201 → success", async () => {
+    mockSubmit.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "email-1-abcdef12", persisted: "email" },
+    });
+
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    expect(result).toEqual({ kind: "success" });
+  });
+});
+
+describe("captureLeadAction — declared extra fields (#6730 D8a)", () => {
+  it("carries an extra string field (e.g. a select) into payload", async () => {
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    await captureLeadAction(INITIAL_STATE, makeFormData({ ...VALID_FIELDS, plan: "pro" }));
+
+    const body = mockSubmit.mock.calls[0][0] as { payload: Record<string, unknown> };
+    expect(body.payload.plan).toBe("pro");
+  });
+
+  it("never copies reserved or Next-internal fields into payload", async () => {
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({
+        ...VALID_FIELDS,
+        consent: "true",
+        ailk_hp: "",
+        source: "conversational-intake",
+        $ACTION_ID_abc: "",
+      }),
+    );
+
+    const body = mockSubmit.mock.calls[0][0] as {
+      source: string;
+      payload: Record<string, unknown>;
+    };
+    expect(Object.keys(body.payload).sort()).toEqual(["message", "name"]);
+    expect(body.source).toBe("conversational-intake");
+  });
+
+  it("more than 20 extra keys → a form error, no API call", async () => {
+    const extras = Object.fromEntries(
+      Array.from({ length: 21 }, (_, i) => [`extra${i}`, "x"]),
+    );
+
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, ...extras }),
+    );
+
+    expect(result).toMatchObject({ kind: "error" });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("an extra value over 2000 characters → a form error, no API call", async () => {
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, notes: "x".repeat(2001) }),
+    );
+
+    expect(result).toMatchObject({ kind: "error" });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+});
+
+describe("captureLeadAction — honeypot (#6730)", () => {
+  it("a filled honeypot → success, and nothing is sent", async () => {
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, ailk_hp: "https://spam.example" }),
+    );
+
+    expect(result).toEqual({ kind: "success" });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("a declared `website` field is an ordinary field, carried into payload", async () => {
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, website: "https://acme.example" }),
+    );
+
+    const body = mockSubmit.mock.calls[0][0] as { payload: Record<string, unknown> };
+    expect(body.payload.website).toBe("https://acme.example");
+  });
+});