create-ailk 0.20.0 → 0.22.0

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 {
@@ -51,6 +100,8 @@ const VALID_FIELDS = {
   name: "Jane Smith",
   email: "jane@example.com",
   message: "I am interested in your services.",
+  // #8661 D8 — the terms box is checked on the server too.
+  consent: "true",
 };
 
 const INITIAL_STATE = null;
@@ -149,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);
@@ -177,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();
   });
@@ -269,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");
   });
 
@@ -369,3 +402,450 @@ describe("captureLeadAction — visitor forwarding (#7394)", () => {
     expect(mockSubmit.mock.calls[0]).toHaveLength(1);
   });
 });
+
+// ─── #8661 D8 — the terms box and the source stamp ──────────────────────────
+
+describe("captureLeadAction — consent and source (#8661 D8)", () => {
+  const { consent: _consent, ...UNTICKED } = VALID_FIELDS;
+
+  it("no consent → a consent field error, and nothing is sent", async () => {
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(UNTICKED));
+
+    expect(result).toEqual({
+      kind: "error",
+      fieldErrors: { consent: expect.any(String) },
+    });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("no consent and no name → both errors", async () => {
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...UNTICKED, name: "" }),
+    );
+
+    expect(result).toMatchObject({ kind: "error" });
+    const fieldErrors = (result as { fieldErrors: Record<string, string> }).fieldErrors;
+    expect(Object.keys(fieldErrors).sort()).toEqual(["consent", "name"]);
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("a ticked flow:contact post carries the source and the subject", async () => {
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, source: "flow:contact", subject: "Support" }),
+    );
+
+    expect(result).toEqual({ kind: "success" });
+    expect(mockSubmit).toHaveBeenCalledTimes(1);
+    const body = mockSubmit.mock.calls[0][0] as {
+      source: string;
+      payload: Record<string, unknown>;
+    };
+    expect(body.source).toBe("flow:contact");
+    expect(body.payload.subject).toBe("Support");
+  });
+
+  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("contact-form");
+    },
+  );
+
+  // #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({ ...VALID_FIELDS, source: "conversational-intake" }),
+    );
+
+    expect(result).toEqual({ kind: "success" });
+    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

@@ -55,6 +55,7 @@ jest.mock("@working-theory/ui", () => ({
   LeadCaptureForm: (props: {
     fields?: Array<{ name: string }>;
     submitLabel?: string;
+    text?: { submit?: string };
     fallbackEmail?: string;
     termsHref: string;
   }) =>
@@ -69,7 +70,8 @@ jest.mock("@working-theory/ui", () => ({
       React.createElement(
         "button",
         { "data-testid": "contact-submit" },
-        props.submitLabel ?? "Send",
+        // The real block falls back to its copy's submit label.
+        props.submitLabel ?? props.text?.submit ?? "Send",
       ),
     ),
   ContactFallback: (props: { email?: string; text?: { noEmail?: string } }) =>
@@ -171,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);
 });
@@ -181,14 +190,14 @@ describe("ContactPage — snapshot regression", () => {
   it("empty state renders deterministic HTML (renderPage empty-state + the form after it)", async () => {
     const { container } = await renderWith(null);
     expect(container.innerHTML).toMatchInlineSnapshot(
-      `"<main id="main"><h1>Contact</h1><p data-testid="section-empty-state">Contact page content coming soon.</p></main><div data-testid="lead-capture-form" data-fields="" data-fallback-email="" data-terms-href="/en/terms"><button data-testid="contact-submit">Send</button></div>"`,
+      `"<main id="main"><h1>Contact</h1><p data-testid="section-empty-state">Contact page content coming soon.</p></main><div data-testid="lead-capture-form" data-fields="name,email,subject,message" data-fallback-email="" data-terms-href="/en/terms"><button data-testid="contact-submit">Send message</button></div>"`,
     );
   });
 
   it("populated state renders deterministic HTML (renderPage sections + the form after it)", async () => {
     const { container } = await renderWith([]);
     expect(container.innerHTML).toMatchInlineSnapshot(
-      `"<script type="application/ld+json" data-testid="json-ld">{"@context":"https://schema.org","@type":"ContactPage","inLanguage":"en","name":"Contact Us","description":"Get in touch.","mainEntity":{"@type":"ContactPoint","contactType":"customer support"}}</script><main id="main"><div><h1>Contact Us</h1><p data-testid="contact-description" class="mt-block-tight text-lead">Get in touch.</p></div><div data-testid="section-renderer" data-section-count="0"></div></main><div data-testid="lead-capture-form" data-fields="" data-fallback-email="" data-terms-href="/en/terms"><button data-testid="contact-submit">Send</button></div>"`,
+      `"<script type="application/ld+json" data-testid="json-ld">{"@context":"https://schema.org","@type":"ContactPage","inLanguage":"en","name":"Contact Us","description":"Get in touch.","mainEntity":{"@type":"ContactPoint","contactType":"customer support"}}</script><main id="main"><div><h1>Contact Us</h1><p data-testid="contact-description" class="mt-block-tight text-lead">Get in touch.</p></div><div data-testid="section-renderer" data-section-count="0"></div></main><div data-testid="lead-capture-form" data-fields="name,email,subject,message" data-fallback-email="" data-terms-href="/en/terms"><button data-testid="contact-submit">Send message</button></div>"`,
     );
   });
 });