create-ailk 0.21.0 → 0.22.0

package/templates/apps/web/app/[locale]/contact/__tests__/contact-magnet-page.test.tsx

@@ -124,8 +124,15 @@ async function tickAndSubmit(values: Record<string, string>) {
   });
 }
 
+// #8731 — the page shares its two hub reads for a few seconds, per module
+// instance. Each test starts an hour later so none sees another's read.
+let clock = 1_800_000_000_000;
+const nowSpy = jest.spyOn(Date, "now");
+
 beforeEach(() => {
   jest.clearAllMocks();
+  clock += 60 * 60 * 1000;
+  nowSpy.mockImplementation(() => clock);
   mockCaptureStatus.mockResolvedValue({
     ok: true,
     status: 200,
@@ -167,17 +174,49 @@ describe("contact/page — rendering (AC-3)", () => {
     expect(screen.queryByTestId("field-company")).toBeNull();
   });
 
-  it("two requests with two configs render two labels (no caching)", async () => {
+  it("a burst of views makes one hub read of each kind, not one per view (#8731)", async () => {
+    mockFlowsGet.mockResolvedValue(served(configWithSubjectLabel("Topic")));
+    for (let i = 0; i < 25; i += 1) {
+      const view = await renderPage();
+      expect(screen.getByTestId("lead-capture-form")).toHaveTextContent("Topic");
+      view.unmount();
+    }
+    expect(mockFlowsGet).toHaveBeenCalledTimes(1);
+    expect(mockCaptureStatus).toHaveBeenCalledTimes(1);
+  });
+
+  it("concurrent views share one in-flight read of each (#8731)", async () => {
+    mockFlowsGet.mockResolvedValue(served(contactFormFlowConfig));
+    await Promise.all([renderPage(), renderPage(), renderPage()]);
+    expect(mockFlowsGet).toHaveBeenCalledTimes(1);
+    expect(mockCaptureStatus).toHaveBeenCalledTimes(1);
+  });
+
+  it("an Admin edit shows once the shared read expires (#8731)", async () => {
     mockFlowsGet.mockResolvedValueOnce(served(configWithSubjectLabel("Topic")));
     const first = await renderPage();
     expect(screen.getByTestId("lead-capture-form")).toHaveTextContent("Topic");
     first.unmount();
 
     mockFlowsGet.mockResolvedValueOnce(served(configWithSubjectLabel("Reason")));
+    clock += 60_000;
     await renderPage();
     const form = screen.getByTestId("lead-capture-form");
     expect(form).toHaveTextContent("Reason");
     expect(form).not.toHaveTextContent("Topic");
+    expect(mockFlowsGet).toHaveBeenCalledTimes(2);
+  });
+
+  it("a failed read is shared too, so an unreachable hub is not retried per view (#8731)", async () => {
+    mockFlowsGet.mockRejectedValue(new Error("hub down"));
+    mockCaptureStatus.mockRejectedValue(new Error("hub down"));
+    for (let i = 0; i < 5; i += 1) {
+      const view = await renderPage();
+      expect(screen.getByTestId("lead-capture-form")).toBeInTheDocument();
+      view.unmount();
+    }
+    expect(mockFlowsGet).toHaveBeenCalledTimes(1);
+    expect(mockCaptureStatus).toHaveBeenCalledTimes(1);
   });
 
   it("links Terms, Privacy Policy and Working Agreement in the statement", async () => {
@@ -251,7 +290,7 @@ describe("contact/page — fallback (AC-5)", () => {
     await tickAndSubmit({ name: "Ada", email: "ada@example.com" });
 
     await waitFor(() => expect(mockSubmit).toHaveBeenCalledTimes(1));
-    expect(mockSubmit.mock.calls[0][0]).toMatchObject({ source: "web" });
+    expect(mockSubmit.mock.calls[0][0]).toMatchObject({ source: "contact-form" });
   });
 
   it("with no magnet, a section's declared fields still apply", async () => {

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

@@ -8,8 +8,12 @@
  *   without calling api-client
  * - captureLeadAction returns generic error on API failure
  * - Parity: captureLeadAction is paired with ailkCaptureLead per ADR 0013
+ * - #8747: the lead is marked payload.site / payload.page and sends no
+ *   siteId; a per-visitor limit runs before the write; an unreachable API is
+ *   `unavailable`; the built-in form's source is `contact-form`
  */
 
+import { __resetRateLimit } from "../../../../src/lib/rate-limit";
 import { captureLeadAction } from "../contact.actions.js";
 
 // Mock @working-theory/api-client. `visitorForwardHeaders` stays real (#7394)
@@ -29,6 +33,50 @@ jest.mock("next/headers", () => ({
   headers: jest.fn().mockResolvedValue({ get: () => null }),
 }));
 
+// #8757 D8 — the thank-you's account link reads the request's locale and the
+// `contact` messages through next-intl, and the generated sign-in provider.
+// Both are mocked here, per case.
+jest.mock("next-intl/server", () => {
+  const messages = require("../../../../messages/en.json") as {
+    contact: Record<string, unknown>;
+  };
+  return {
+    __esModule: true,
+    getLocale: jest.fn().mockResolvedValue("en"),
+    getTranslations: jest.fn(async (namespace: string) => {
+      if (namespace !== "contact") throw new Error(`unexpected namespace ${namespace}`);
+      return (key: string) => {
+        const value = messages.contact[key];
+        return typeof value === "string" ? value : `contact.${key}`;
+      };
+    }),
+  };
+});
+
+// #8757 D11 — a `checkout` magnet redirects after the write. Next's
+// `redirect()` throws NEXT_REDIRECT; the mock throws the same way so a case
+// can read the target and prove nothing ran after it.
+const mockRedirect = jest.fn((url: string): never => {
+  throw new Error(`NEXT_REDIRECT:${url}`);
+});
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  redirect: (url: string) => mockRedirect(url),
+}));
+
+let mockSignInProvider: "site" | "hub" | "none" = "site";
+let mockTopology: "hub" | "spoke" = "spoke";
+// eslint-disable-next-line no-restricted-syntax -- #507: SIGN_IN_PROVIDER and TOPOLOGY are generated per-build constants (#8757 D8, D11), not runtime inputs; no env or HTTP surface selects them.
+jest.mock("../../../../lib/topology.generated", () => ({
+  __esModule: true,
+  get SIGN_IN_PROVIDER() {
+    return mockSignInProvider;
+  },
+  get TOPOLOGY() {
+    return mockTopology;
+  },
+}));
+
 import { leads, visitorForwardHeaders } from "@working-theory/api-client";
 import { headers } from "next/headers";
 const mockSubmit = leads.submit as jest.Mock;
@@ -37,6 +85,7 @@ const mockHeaders = headers as jest.Mock;
 afterEach(() => {
   jest.clearAllMocks();
   mockHeaders.mockResolvedValue({ get: () => null });
+  __resetRateLimit();
 });
 
 function makeFormData(fields: Record<string, string>): FormData {
@@ -151,25 +200,10 @@ describe("captureLeadAction — API error", () => {
     });
   });
 
-  it("returns generic error when api-client throws", async () => {
+  // #4042 — a thrown submit leaves a server-side trace; #8747 — it is the
+  // API being unreachable, so the visitor is shown the contact email.
+  it("a thrown submit is logged with no submitted field, and is unavailable", async () => {
     mockSubmit.mockRejectedValueOnce(new Error("Network error"));
-
-    const result = await captureLeadAction(
-      INITIAL_STATE,
-      makeFormData(VALID_FIELDS),
-    );
-
-    expect(result).toMatchObject({
-      kind: "error",
-      message: expect.any(String),
-    });
-  });
-
-  // #4042 — the catch-all previously discarded a thrown error silently,
-  // leaving zero server-side trace of a production integration failure.
-  it("logs the thrown error server-side with a [captureLeadAction] prefix, with no PII from the submitted fields", async () => {
-    const thrown = new Error("Network error");
-    mockSubmit.mockRejectedValueOnce(thrown);
     const consoleErrorSpy = jest
       .spyOn(console, "error")
       .mockImplementation(() => undefined);
@@ -179,17 +213,14 @@ describe("captureLeadAction — API error", () => {
       makeFormData(VALID_FIELDS),
     );
 
-    expect(consoleErrorSpy).toHaveBeenCalledWith("[captureLeadAction]", thrown);
+    expect(consoleErrorSpy).toHaveBeenCalled();
     const loggedArgs = consoleErrorSpy.mock.calls.flat();
     for (const value of Object.values(VALID_FIELDS)) {
       for (const arg of loggedArgs) {
         expect(String(arg)).not.toContain(value);
       }
     }
-    expect(result).toMatchObject({
-      kind: "error",
-      message: expect.any(String),
-    });
+    expect(result).toEqual({ kind: "unavailable" });
 
     consoleErrorSpy.mockRestore();
   });
@@ -271,7 +302,7 @@ describe("captureLeadAction — declared extra fields (#6730 D8a)", () => {
       source: string;
       payload: Record<string, unknown>;
     };
-    expect(Object.keys(body.payload).sort()).toEqual(["message", "name"]);
+    expect(Object.keys(body.payload).sort()).toEqual(["message", "name", "page"]);
     expect(body.source).toBe("conversational-intake");
   });
 
@@ -417,28 +448,404 @@ describe("captureLeadAction — consent and source (#8661 D8)", () => {
     expect(body.payload.subject).toBe("Support");
   });
 
-  it.each(["flow:other", "flow:onboarding", "admin", "WEB"])(
-    "an unknown source (%s) is sent as web",
+  it.each(["flow:other", "flow:onboarding", "admin", "WEB", "web"])(
+    "an unknown source (%s) is sent as contact-form",
     async (source) => {
       mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
 
       await captureLeadAction(INITIAL_STATE, makeFormData({ ...VALID_FIELDS, source }));
 
-      expect((mockSubmit.mock.calls[0][0] as { source: string }).source).toBe("web");
+      expect((mockSubmit.mock.calls[0][0] as { source: string }).source).toBe("contact-form");
     },
   );
 
-  it("the conversational intake submits with no consent field", async () => {
+  // #8730 D2/D4 — the hidden source picks the stamp, never the gate: the
+  // intake captures consent itself and posts consent=true like the form.
+  it("source=conversational-intake without consent is refused, and nothing is sent", async () => {
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...UNTICKED, source: "conversational-intake" }),
+    );
+
+    expect(result).toEqual({
+      kind: "error",
+      fieldErrors: { consent: expect.any(String) },
+    });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it.each(["contact-form", "conversational-intake", "flow:contact", "anything-else"])(
+    "no source value (%s) switches the check off",
+    async (source) => {
+      const result = await captureLeadAction(
+        INITIAL_STATE,
+        makeFormData({ ...UNTICKED, source }),
+      );
+
+      expect(result).toMatchObject({ kind: "error", fieldErrors: { consent: expect.any(String) } });
+      expect(mockSubmit).not.toHaveBeenCalled();
+    },
+  );
+
+  it("consent other than the string true is not acceptance", async () => {
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, consent: "on" }),
+    );
+
+    expect(result).toMatchObject({ kind: "error", fieldErrors: { consent: expect.any(String) } });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("an intake post with consent=true is sent as conversational-intake, carrying consent: true", async () => {
     mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
 
     const result = await captureLeadAction(
       INITIAL_STATE,
-      makeFormData({ ...UNTICKED, source: "conversational-intake" }),
+      makeFormData({ ...VALID_FIELDS, source: "conversational-intake" }),
     );
 
     expect(result).toEqual({ kind: "success" });
-    expect((mockSubmit.mock.calls[0][0] as { source: string }).source).toBe(
-      "conversational-intake",
+    const body = mockSubmit.mock.calls[0][0] as { source: string; consent: unknown };
+    expect(body.source).toBe("conversational-intake");
+    expect(body.consent).toBe(true);
+  });
+
+  it("every accepted post tells the API the terms were accepted, top level, never in payload", async () => {
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    const body = mockSubmit.mock.calls[0][0] as {
+      consent: unknown;
+      payload: Record<string, unknown>;
+    };
+    expect(body.consent).toBe(true);
+    expect(body.payload).not.toHaveProperty("consent");
+  });
+
+  it("an API 400 consent_required is shown as the consent field error", async () => {
+    mockSubmit.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      body: { error: "consent_required", message: "Accept the terms to send a contact message." },
+    });
+
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    expect(result).toEqual({
+      kind: "error",
+      fieldErrors: { consent: expect.any(String) },
+    });
+  });
+});
+
+// ─── #8747 — the spoke lead writer, the per-visitor limit, an unreachable API ─
+
+describe("captureLeadAction — the site marker (#8747)", () => {
+  const priorSite = process.env.AILK_LEAD_SITE;
+
+  afterEach(() => {
+    if (priorSite === undefined) delete process.env.AILK_LEAD_SITE;
+    else process.env.AILK_LEAD_SITE = priorSite;
+  });
+
+  it("marks payload.site from AILK_LEAD_SITE and payload.page as contact, and sends no siteId", async () => {
+    process.env.AILK_LEAD_SITE = "wendihenry";
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    const body = mockSubmit.mock.calls[0][0] as Record<string, unknown> & {
+      payload: Record<string, unknown>;
+    };
+    expect(body).not.toHaveProperty("siteId");
+    expect(body.payload).toMatchObject({ site: "wendihenry", page: "contact" });
+  });
+
+  it("a form field named site or page never overrides the marker", async () => {
+    process.env.AILK_LEAD_SITE = "wendihenry";
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, site: "attacker", page: "checkout" }),
+    );
+
+    const body = mockSubmit.mock.calls[0][0] as { payload: Record<string, unknown> };
+    expect(body.payload.site).toBe("wendihenry");
+    expect(body.payload.page).toBe("contact");
+  });
+
+  it("with AILK_LEAD_SITE unset, the lead carries no site at all", async () => {
+    delete process.env.AILK_LEAD_SITE;
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    await captureLeadAction(INITIAL_STATE, makeFormData({ ...VALID_FIELDS, site: "attacker" }));
+
+    const body = mockSubmit.mock.calls[0][0] as { payload: Record<string, unknown> };
+    expect(body.payload).not.toHaveProperty("site");
+    expect(body.payload.page).toBe("contact");
+  });
+});
+
+describe("captureLeadAction — the built-in form's source (#8747)", () => {
+  it("a post with no source is stamped contact-form", async () => {
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    expect((mockSubmit.mock.calls[0][0] as { source: string }).source).toBe("contact-form");
+  });
+});
+
+describe("captureLeadAction — the per-visitor limit (#8747)", () => {
+  const visitor = (ip: string) => ({
+    get: (name: string) => (name === "x-forwarded-for" ? ip : null),
+  });
+
+  it("admits 30 posts from one visitor in ten minutes, and refuses the 31st without calling the API", async () => {
+    mockHeaders.mockResolvedValue(visitor("203.0.113.5"));
+    mockSubmit.mockResolvedValue({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    for (let i = 0; i < 30; i += 1) {
+      expect(await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).toEqual({
+        kind: "success",
+      });
+    }
+    expect(mockSubmit).toHaveBeenCalledTimes(30);
+
+    const refused = await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+
+    expect(refused).toMatchObject({ kind: "error", message: expect.any(String) });
+    expect(mockSubmit).toHaveBeenCalledTimes(30);
+  });
+
+  it("with no readable address, the limit is skipped rather than shared", async () => {
+    mockHeaders.mockResolvedValue({ get: () => null });
+    mockSubmit.mockResolvedValue({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    for (let i = 0; i < 31; i += 1) {
+      expect(await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).toEqual({
+        kind: "success",
+      });
+    }
+    expect(mockSubmit).toHaveBeenCalledTimes(31);
+  });
+
+  it("another visitor keeps its own budget", async () => {
+    mockSubmit.mockResolvedValue({ ok: true, body: { id: "lead_1", persisted: "db" } });
+    mockHeaders.mockResolvedValue(visitor("203.0.113.5"));
+    for (let i = 0; i < 30; i += 1) {
+      await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+    }
+
+    mockHeaders.mockResolvedValue(visitor("198.51.100.7"));
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).toEqual({
+      kind: "success",
+    });
+  });
+});
+
+describe("captureLeadAction — an unreachable API (#8747)", () => {
+  it.each([502, 504])("a %s is unavailable", async (status) => {
+    mockSubmit.mockResolvedValueOnce({ ok: false, status, body: null });
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).toEqual({
+      kind: "unavailable",
+    });
+  });
+
+  it("a thrown submit is unavailable", async () => {
+    mockSubmit.mockRejectedValueOnce(new TypeError("fetch failed"));
+    const spy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).toEqual({
+      kind: "unavailable",
+    });
+    spy.mockRestore();
+  });
+
+  it.each([400, 429, 500, 501, 503])("a %s that is not lead_capture_not_configured stays the generic error", async (status) => {
+    mockSubmit.mockResolvedValueOnce({ ok: false, status, body: { error: "x" } });
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).toEqual({
+      kind: "error",
+      message: expect.any(String),
+    });
+  });
+});
+
+// ── #8757 AC-5 — the thank-you carries the account link on `invite` only ───
+
+describe("captureLeadAction — the account link (#8757 D8)", () => {
+  const { getLocale } = jest.requireMock("next-intl/server") as { getLocale: jest.Mock };
+  const INVITE_FIELDS = { ...VALID_FIELDS, email: "a@b.example" };
+  const LABEL = "Track this in your account";
+
+  function answers(next?: unknown): void {
+    mockSubmit.mockResolvedValueOnce({
+      ok: true,
+      body: {
+        id: "lead_abc123",
+        persisted: "db",
+        email: { attempted: true, sent: true },
+        ...(next !== undefined && { next }),
+      },
+    });
+  }
+
+  afterEach(() => {
+    mockSignInProvider = "site";
+    getLocale.mockResolvedValue("en");
+  });
+
+  it("provider site, locale en (served bare): invite → the sign-in link with next and the email", async () => {
+    answers({ completion: "invite" });
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(INVITE_FIELDS))).toEqual({
+      kind: "success",
+      next: { href: "/sign-in?next=%2Faccount&email=a%40b.example", label: LABEL },
+    });
+  });
+
+  it("provider site, locale fr: both paths carry the prefix", async () => {
+    getLocale.mockResolvedValue("fr");
+    answers({ completion: "invite" });
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(INVITE_FIELDS))).toEqual({
+      kind: "success",
+      next: { href: "/fr/sign-in?next=%2Ffr%2Faccount&email=a%40b.example", label: LABEL },
+    });
+  });
+
+  it("no next → exactly { kind: success }", async () => {
+    answers();
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(INVITE_FIELDS))).toStrictEqual({
+      kind: "success",
+    });
+  });
+
+  it("provider hub → the hub-session sign-in start", async () => {
+    mockSignInProvider = "hub";
+    answers({ completion: "invite" });
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(INVITE_FIELDS))).toEqual({
+      kind: "success",
+      next: { href: "/api/hub-session/sign-in?next=%2Faccount&email=a%40b.example", label: LABEL },
+    });
+  });
+
+  it("provider none → exactly { kind: success }", async () => {
+    mockSignInProvider = "none";
+    answers({ completion: "invite" });
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(INVITE_FIELDS))).toStrictEqual({
+      kind: "success",
+    });
+  });
+
+  it("an unreadable locale still answers success, with the default locale's link", async () => {
+    getLocale.mockRejectedValueOnce(new Error("no request scope"));
+    answers({ completion: "invite" });
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(INVITE_FIELDS))).toEqual({
+      kind: "success",
+      next: { href: "/sign-in?next=%2Faccount&email=a%40b.example", label: LABEL },
+    });
+  });
+
+  it("a malformed next is ignored → exactly { kind: success }", async () => {
+    answers({ completion: "invite", extra: true });
+
+    expect(await captureLeadAction(INITIAL_STATE, makeFormData(INVITE_FIELDS))).toStrictEqual({
+      kind: "success",
+    });
+  });
+});
+
+describe("captureLeadAction — a checkout magnet redirects after the write (#8757 D11, AC-8)", () => {
+  function answers(next: unknown): void {
+    mockSubmit.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "lead_abc123", persisted: "db", email: { skipped: true }, next },
+    });
+  }
+
+  it("next: checkout, retainer → Next's redirect to /api/checkout/retainer, after exactly one write", async () => {
+    answers({ completion: "checkout", checkoutOffering: "retainer" });
+
+    await expect(captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).rejects.toThrow(
+      "NEXT_REDIRECT:/api/checkout/retainer",
+    );
+    expect(mockSubmit).toHaveBeenCalledTimes(1);
+    expect(mockRedirect).toHaveBeenCalledTimes(1);
+    expect(mockRedirect).toHaveBeenCalledWith("/api/checkout/retainer");
+    expect(mockSubmit.mock.invocationCallOrder[0]!).toBeLessThan(
+      mockRedirect.mock.invocationCallOrder[0]!,
+    );
+  });
+
+  it.each([
+    ["a 500", { ok: false, status: 500, body: { error: "boom" } }, "error"],
+    ["an unreachable API", { ok: false, status: 0, body: null }, "unavailable"],
+    [
+      "lead capture not configured",
+      { ok: false, status: 503, body: { error: "lead_capture_not_configured" } },
+      "unavailable",
+    ],
+  ] as const)("a failed write (%s) → { kind: %s } and no redirect", async (_label, response, kind) => {
+    mockSubmit.mockResolvedValueOnce(response);
+
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+    expect(result).toMatchObject({ kind });
+    expect(mockRedirect).not.toHaveBeenCalled();
+  });
+
+  it("a thrown write → { kind: unavailable } and no redirect", async () => {
+    mockSubmit.mockRejectedValueOnce(new Error("network"));
+
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS));
+    expect(result).toMatchObject({ kind: "unavailable" });
+    expect(mockRedirect).not.toHaveBeenCalled();
+  });
+
+  it.each(["../x", "/evil", "Retainer", "has_underscore", "a".repeat(41), ""])(
+    "checkoutOffering %j → exactly { kind: success } and no redirect",
+    async (checkoutOffering) => {
+      answers({ completion: "checkout", checkoutOffering });
+
+      expect(await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).toStrictEqual({
+        kind: "success",
+      });
+      expect(mockRedirect).not.toHaveBeenCalled();
+    },
+  );
+
+  it("a build that is not a spoke (no standard checkout) → exactly { kind: success } and no redirect", async () => {
+    mockTopology = "hub";
+    try {
+      answers({ completion: "checkout", checkoutOffering: "retainer" });
+
+      expect(await captureLeadAction(INITIAL_STATE, makeFormData(VALID_FIELDS))).toStrictEqual({
+        kind: "success",
+      });
+      expect(mockSubmit).toHaveBeenCalledTimes(1);
+      expect(mockRedirect).not.toHaveBeenCalled();
+    } finally {
+      mockTopology = "spoke";
+    }
+  });
+
+  it("an invite still answers the account link and never redirects", async () => {
+    answers({ completion: "invite" });
+
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, email: "a@b.example" }),
     );
+    expect(result).toMatchObject({ kind: "success", next: { label: "Track this in your account" } });
+    expect(mockRedirect).not.toHaveBeenCalled();
   });
 });

package/templates/apps/web/app/[locale]/contact/__tests__/page-renderer-migration.test.tsx

@@ -173,8 +173,15 @@ async function renderWith(sections: unknown[] | null) {
   return render(element);
 }
 
+// #8731 — the page shares its two hub reads for a few seconds, per module
+// instance. Each test starts an hour later so none sees another's read.
+let clock = 1_800_000_000_000;
+const nowSpy = jest.spyOn(Date, "now");
+
 beforeEach(() => {
   jest.clearAllMocks();
+  clock += 60 * 60 * 1000;
+  nowSpy.mockImplementation(() => clock);
   mockCaptureStatus.mockResolvedValue(ACCEPTING);
   mockContactEmail.mockReturnValue(undefined);
 });