create-ailk 0.7.0 → 0.8.0

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

@@ -1,8 +1,20 @@
-// Contact page. Renders sections via renderPage (sections mode) with the
-// plain ContactForm slotted into the split hero's right column (or appended
-// below when no split hero leads). The chat-style intake
-// (ConversationalIntakeWrapper, #4534) remains available to a site that
-// prefers it. JSON-LD and translations handled by renderPage.
+// Contact page (#6730 D8). Renders sections via renderPage (sections mode)
+// and places ONE contact surface, first match wins: into the page's first
+// `contact-form` section; else into a leading split hero's right column;
+// else after the page.
+//
+// That surface is the shared `LeadCaptureForm` block, bound to
+// `captureLeadAction` — unless the API says this deployment accepts no
+// contact message (production with neither a database nor an email key), in
+// which case it is `ContactFallback`: the site's contact email, never a form
+// that would report a message as sent when it reached nobody. An unreachable
+// API, an older API without the status route, or any other failed read is
+// treated as accepting: the form renders, and its submit reports honestly.
+//
+// The chat-style intake (ConversationalIntakeWrapper, #4534) remains
+// available to a site that prefers it. JSON-LD and translations handled by
+// renderPage.
+import { leads } from "@working-theory/api-client";
 import type {
   getMdxSource as defaultGetMdxSource,
   getPageSections as defaultGetPageSections,
@@ -13,10 +25,21 @@ import {
   renderPage,
   renderPageMetadata,
 } from "@working-theory/page-renderer";
+import {
+  ContactFallback,
+  type ContactFormField,
+  LeadCaptureForm,
+  localeHref,
+} from "@working-theory/ui";
 import type { Metadata } from "next";
+import { getTranslations } from "next-intl/server";
 import type { ReactElement } from "react";
 
-import { ContactForm } from "./ContactForm";
+import { contactFormText } from "./contact-form-text";
+import { captureLeadAction } from "./contact.actions";
+import { readSiteContactEmail } from "./site-contact-email";
+
+export const revalidate = 60;
 
 interface Props {
   params: Promise<{ locale: string }>;
@@ -24,6 +47,41 @@ interface Props {
   getPageSections?: typeof defaultGetPageSections;
 }
 
+type CaptureStatus = Extract<
+  Awaited<ReturnType<typeof leads.captureStatus>>,
+  { ok: true }
+>["body"]["data"];
+
+type Section = Awaited<ReturnType<typeof defaultGetPageSections>>[number];
+type ContactFormSection = Extract<Section, { type: "contact-form" }>;
+
+const FIELD_TYPES = ["text", "email", "tel", "textarea", "select"] as const;
+
+/** A `contact-form` section's declared fields, as the form block renders them. */
+function sectionFields(section: ContactFormSection): ContactFormField[] {
+  return section.data.fields.map((f) => ({
+    name: f.name,
+    label: f.label,
+    type: (FIELD_TYPES as readonly string[]).includes(f.type)
+      ? (f.type as (typeof FIELD_TYPES)[number])
+      : "text",
+    ...(f.required !== undefined ? { required: f.required } : {}),
+    ...(f.placeholder !== undefined ? { placeholder: f.placeholder } : {}),
+    ...(f.options !== undefined ? { options: f.options } : {}),
+    ...(f.colSpan !== undefined ? { colSpan: f.colSpan as 1 | 2 } : {}),
+  }));
+}
+
+/** The API's capture status, or `null` for any failed read (see header). */
+async function readCaptureStatus(): Promise<CaptureStatus | null> {
+  try {
+    const res = await leads.captureStatus();
+    return res.ok && res.body.ok === true ? res.body.data : null;
+  } catch {
+    return null;
+  }
+}
+
 export async function generateMetadata({
   params,
 }: Pick<Props, "params">): Promise<Metadata> {
@@ -37,17 +95,49 @@ export default async function Page({
   getPageSections,
 }: Props): Promise<ReactElement> {
   const { locale } = await params;
-  // The contact form sits in the hero's right column when the page leads with
-  // a split hero (the two-column contact layout — operator ruling 2026-09-23:
-  // the Free template shows the plain form; the guided intake stays a Pro
-  // option); otherwise — no content, or a different lead section — it renders
-  // below the page, so the contact surface is never lost.
+  const [status, t] = await Promise.all([
+    readCaptureStatus(),
+    getTranslations({ locale, namespace: "contact" }),
+  ]);
+  const accepting = status?.contact ?? true;
+  const contactEmail = readSiteContactEmail();
+  const text = contactFormText(t);
+
   const source = await (getMdxSource ?? loadMdxSource)("ContactPage", "contact", locale);
   const sections = source ? await (getPageSections ?? loadPageSections)(source.frontmatter) : [];
+  const formSection = sections.find(
+    (s): s is ContactFormSection => s.type === "contact-form",
+  );
+  // The section's own published address stands in when _site.mdx has none.
+  const fallbackEmail = contactEmail ?? formSection?.data.contactInfo?.email;
   const lead = sections[0];
   const slotted =
-    lead?.type === "hero" && lead.data.variant === "split" ? lead.id : undefined;
-  const intake = <ContactForm />;
+    formSection?.id ??
+    (lead?.type === "hero" && lead.data.variant === "split" ? lead.id : undefined);
+
+  const surface = accepting ? (
+    <LeadCaptureForm
+      action={captureLeadAction}
+      text={text}
+      termsHref={localeHref(locale, "/terms")}
+      fallbackEmail={fallbackEmail}
+      {...(formSection && {
+        fields: sectionFields(formSection),
+        submitLabel: formSection.data.submitLabel,
+        successMessage: formSection.data.successMessage,
+      })}
+    />
+  ) : (
+    <ContactFallback
+      email={fallbackEmail}
+      text={{
+        heading: text.unavailableHeading,
+        body: text.unavailableBody,
+        noEmail: text.unavailableNoEmail,
+      }}
+    />
+  );
+
   const rendered = await renderPage({
     type: "ContactPage",
     slug: "contact",
@@ -55,12 +145,12 @@ export default async function Page({
     translationsNamespace: "contact",
     ...(getMdxSource !== undefined && { getMdxSource }),
     ...(getPageSections !== undefined && { getPageSections }),
-    ...(slotted !== undefined && { sectionSlots: { [slotted]: intake } }),
+    ...(slotted !== undefined && { sectionSlots: { [slotted]: surface } }),
   });
   return (
     <>
       {rendered}
-      {slotted === undefined ? intake : null}
+      {slotted === undefined ? surface : null}
     </>
   );
 }

package/templates/apps/web/app/[locale]/contact/site-contact-email.ts

@@ -0,0 +1,54 @@
+/**
+ * The site's published contact email (#6730 D10) — `_site.mdx`'s top-level
+ * `contactEmail`, else a `LocalBusiness` identity's `email`, else `undefined`.
+ *
+ * `/contact` shows it in place of the form when the site has nowhere to
+ * deliver a message, and hands it to the form's `unavailable` state.
+ *
+ * A local frontmatter read rather than `@working-theory/site-config/server`'s
+ * `loadSiteConfig`: `architecture.yaml` forbids `apps/web` from importing that
+ * subpath (it pulls `node:fs` into a tree that also carries edge routes,
+ * #1567) — the same reason `lib/site-theme.ts` and `lib/site-brand.tsx` read
+ * locally. The value is still validated against the canonical schema from
+ * the client-safe `/schema` entry. Any failure (no file, no frontmatter, an
+ * invalid address) is `undefined`: the fallback then says the site has
+ * published no contact details, which is true.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { SiteConfigSchema } from "@working-theory/site-config/schema";
+import { parse as parseYaml } from "yaml";
+
+import { resolveContentRoot } from "../../../lib/site-brand";
+
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+
+const EmailSchema = SiteConfigSchema.shape.contactEmail.unwrap();
+
+function validEmail(value: unknown): string | undefined {
+  const parsed = EmailSchema.safeParse(value);
+  return parsed.success ? parsed.data : undefined;
+}
+
+export function readSiteContactEmail(): string | undefined {
+  try {
+    const raw = readFileSync(join(resolveContentRoot(), "_site.mdx"), "utf8");
+    const match = FRONTMATTER_RE.exec(raw);
+    if (!match) return undefined;
+    const fm: unknown = parseYaml(match[1] ?? "");
+    if (!fm || typeof fm !== "object") return undefined;
+
+    const { contactEmail, siteIdentity } = fm as {
+      contactEmail?: unknown;
+      siteIdentity?: { kind?: unknown; email?: unknown };
+    };
+    return (
+      validEmail(contactEmail) ??
+      (siteIdentity?.kind === "LocalBusiness" ? validEmail(siteIdentity.email) : undefined)
+    );
+  } catch {
+    return undefined;
+  }
+}

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

@@ -0,0 +1,64 @@
+// Feature detail page (#6721) — one feature at /features/<slug>, listed by
+// the /features page. Reads the Feature MDX for the given slug, renders via
+// @working-theory/page-renderer, and emits a JSON-LD WebPage whose mainEntity
+// is the product's SoftwareApplication, named for the feature. Unknown slugs
+// 404. Composed `sections[]` render as sections; a prose page renders its
+// MDX body.
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import {
+  getMdxSource as loadMdxSource,
+  getMdxSlugs,
+  renderPage,
+  renderPageMetadata,
+} from "@working-theory/page-renderer";
+import type { Metadata } from "next";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string; slug: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export async function generateMetadata({
+  params,
+}: Pick<Props, "params">): Promise<Metadata> {
+  const { locale, slug } = await params;
+  return renderPageMetadata({ type: "Feature", slug, locale });
+}
+
+export async function generateStaticParams({
+  params,
+}: {
+  params: { locale: string };
+}): Promise<{ slug: string }[]> {
+  const slugs = await getMdxSlugs("Feature", params.locale);
+  return slugs.map((slug) => ({ slug }));
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale, slug } = await params;
+  // A page that composes `sections[]` (the starter seeds, #6721) renders
+  // them; a prose page renders its MDX body — the same rule the /features hub
+  // applies. JSON-LD is built from the frontmatter either way.
+  const source = await (getMdxSource ?? loadMdxSource)("Feature", slug, locale);
+  const composed =
+    source !== null &&
+    Array.isArray((source.frontmatter as { sections?: unknown[] }).sections) &&
+    ((source.frontmatter as { sections?: unknown[] }).sections?.length ?? 0) >
+      0;
+  return renderPage({
+    type: "Feature",
+    slug,
+    locale,
+    ...(composed
+      ? {}
+      : {
+          bodyMode: "mdx-body" as const,
+          populatedDescriptionTestId: "feature-description",
+        }),
+    ...(getMdxSource !== undefined && { getMdxSource }),
+  });
+}

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

@@ -0,0 +1,52 @@
+// Features list page. Reads FeaturesList MDX via the content adapter and emits
+// a JSON-LD CollectionPage via the dispatcher. List-only — no detail route.
+import type {
+  getMdxSource as defaultGetMdxSource,
+} from "@working-theory/page-renderer";
+import {
+  getMdxSource as loadMdxSource,
+  renderPage,
+  renderPageMetadata,
+} from "@working-theory/page-renderer";
+import type { Metadata } from "next";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export async function generateMetadata({
+  params,
+}: Pick<Props, "params">): Promise<Metadata> {
+  const { locale } = await params;
+  return renderPageMetadata({
+    type: "FeaturesList",
+    slug: "features",
+    locale,
+  });
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale } = await params;
+  // A FeaturesList page that composes `sections[]` (the Free template's
+  // /features, operator ruling 2026-09-23) renders them; a prose-only page
+  // keeps the MDX-body render. The CollectionPage JSON-LD is built from the
+  // sections either way (buildFeaturesList).
+  const source = await (getMdxSource ?? loadMdxSource)("FeaturesList", "features", locale);
+  const composed =
+    source !== null &&
+    Array.isArray((source.frontmatter as { sections?: unknown[] }).sections) &&
+    ((source.frontmatter as { sections?: unknown[] }).sections?.length ?? 0) > 0;
+  return renderPage({
+    type: "FeaturesList",
+    slug: "features",
+    locale,
+    translationsNamespace: "features",
+    ...(composed ? {} : { bodyMode: "mdx-body" as const }),
+    ...(getMdxSource !== undefined && { getMdxSource }),
+  });
+}

package/templates/apps/web/app/[locale]/layout.tsx

@@ -27,7 +27,7 @@ import { Telemetry, VerificationMeta } from "@working-theory/analytics";
 import { MarketingShell } from "@working-theory/templates/shells";
 import { themeToCssVarsBothModes } from "@working-theory/theme";
 import { Link, isRtl, localeHref } from "@working-theory/ui";
-import { LocaleSwitcherNav } from "@working-theory/ui/blocks";
+import { BRAND_PATHS, LocaleSwitcherNav } from "@working-theory/ui/blocks";
 import {
   Banner,
   Footer,
@@ -238,6 +238,14 @@ export default async function LocaleLayout({
       feature4: tNav("feature4"),
       feature5: tNav("feature5"),
       allFeatures: tNav("allFeatures"),
+      // #6721 — the two-column Product flyout + the Use Cases footer column.
+      flyoutFeaturesHeading: tNav("flyoutFeaturesHeading"),
+      flyoutUseCasesHeading: tNav("flyoutUseCasesHeading"),
+      footerUseCasesHeading: tNav("footerUseCasesHeading"),
+      useCase1: tNav("useCase1"),
+      useCase2: tNav("useCase2"),
+      useCase3: tNav("useCase3"),
+      allUseCases: tNav("allUseCases"),
       howItWorks: tNav("howItWorks"),
       howItWorksDesc: tNav("howItWorksDesc"),
       features: tNav("features"),
@@ -378,6 +386,9 @@ export default async function LocaleLayout({
       href: "https://linkedin.com/company/{{COMPANY_HANDLE}}",
     },
     { platform: "youtube", href: "https://youtube.com/@{{COMPANY_HANDLE}}" },
+    // #6739 — the kit's own repo, operator-directed: the Free template links
+    // back to where it came from.
+    { platform: "github", href: "https://github.com/working-theory-labs/ai-launch-kit" },
   ] as const;
   // Footer column groups (#6468), generated beside `navItems` as label keys;
   // `Footer` takes translated strings, so resolve them through the same map.
@@ -400,6 +411,10 @@ export default async function LocaleLayout({
   const legalLinks = [
     { label: "Privacy Policy", href: "/privacy" },
     { label: "Terms of Service", href: "/terms" },
+    // #6739 — a link, not the reopen button: the privacy page's
+    // #cookie-settings anchor explains the choice, and arriving there
+    // reopens the consent banner (BannerConsentIsland).
+    { label: tConsent("settingsLabel"), href: "/privacy#cookie-settings" },
     ...(siteChrome.footer === "centered"
       ? [{ label: navLabels.items.faq, href: "/faq" }]
       : []),
@@ -515,11 +530,29 @@ export default async function LocaleLayout({
                         variant="contrast"
                         placement="above-nav"
                         // NO_HAND_IMPLEMENT_OK: operator-directed live Free-template pass.
-                        message="Get started with this template."
+                        message={
+                          <>
+                            <a
+                              href="https://github.com/working-theory-labs/ai-launch-kit"
+                              className="inline-flex items-center gap-1 font-bold text-current underline underline-offset-2"
+                            >
+                              Get started for free
+                              <svg
+                                viewBox="0 0 24 24"
+                                aria-hidden="true"
+                                className="size-4 fill-current"
+                              >
+                                <path d={BRAND_PATHS.github} />
+                              </svg>
+                            </a>
+                            {"\u00A0 "}
+                            or
+                          </>
+                        }
                         messageWeight="regular"
                         action={{
-                          label: "Download for free",
-                          href: "https://ailaunchkit.ai/docs/get-started",
+                          label: "upgrade to Pro",
+                          href: "https://ailaunchkit.ai/pricing",
                           kind: "link",
                         }}
                         routes={{ include: [homePath] }}
@@ -592,7 +625,6 @@ export default async function LocaleLayout({
                   bottomBarAlign="content"
                   copyrightText={copyrightText}
                   legalLinks={legalLinks}
-                  consentSettingsLabel={tConsent("settingsLabel")}
                   languageSwitcher={
                     <LocaleSwitcherNav
                       current={locale}

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

@@ -0,0 +1,75 @@
+/**
+ * subscribeNewsletterAction (#6730 D9) — the Server Action twin of the
+ * `ailkSubscribeNewsletter` MCP tool.
+ */
+
+import { subscribeNewsletterAction } from "../newsletter.actions.js";
+
+jest.mock("@working-theory/api-client", () => ({
+  leads: { subscribe: jest.fn() },
+}));
+
+import { leads } from "@working-theory/api-client";
+const mockSubscribe = leads.subscribe as jest.Mock;
+
+function formWith(email: string): FormData {
+  const fd = new FormData();
+  fd.append("email", email);
+  fd.append("consent", "true");
+  return fd;
+}
+
+afterEach(() => jest.clearAllMocks());
+
+describe("subscribeNewsletterAction", () => {
+  it("calls leads.subscribe with source newsletter and the address", async () => {
+    mockSubscribe.mockResolvedValueOnce({ ok: true, body: { id: "subscr_1", persisted: "db" } });
+
+    const result = await subscribeNewsletterAction(null, formWith("ada@example.com"));
+
+    expect(result).toEqual({ kind: "success" });
+    expect(mockSubscribe).toHaveBeenCalledWith(
+      expect.objectContaining({ source: "newsletter", email: "ada@example.com" }),
+    );
+  });
+
+  it("an invalid address → a field error, no API call", async () => {
+    const result = await subscribeNewsletterAction(null, formWith("not-an-email"));
+
+    expect(result).toMatchObject({ kind: "error", fieldErrors: { email: expect.any(String) } });
+    expect(mockSubscribe).not.toHaveBeenCalled();
+  });
+
+  it("503 lead_capture_not_configured → unavailable", async () => {
+    mockSubscribe.mockResolvedValueOnce({
+      ok: false,
+      status: 503,
+      body: { error: "lead_capture_not_configured" },
+    });
+
+    const result = await subscribeNewsletterAction(null, formWith("ada@example.com"));
+
+    expect(result).toEqual({ kind: "unavailable" });
+  });
+
+  it("any other failure → the generic error, never success", async () => {
+    mockSubscribe.mockResolvedValueOnce({ ok: false, status: 503, body: { error: "persist_failed" } });
+    expect(await subscribeNewsletterAction(null, formWith("a@b.co"))).toMatchObject({
+      kind: "error",
+    });
+
+    mockSubscribe.mockRejectedValueOnce(new Error("ECONNREFUSED"));
+    jest.spyOn(console, "error").mockImplementationOnce(() => undefined);
+    expect(await subscribeNewsletterAction(null, formWith("a@b.co"))).toMatchObject({
+      kind: "error",
+    });
+  });
+
+  it("a filled honeypot → success, and nothing is sent", async () => {
+    const fd = formWith("ada@example.com");
+    fd.append("ailk_hp", "spam");
+
+    expect(await subscribeNewsletterAction(null, fd)).toEqual({ kind: "success" });
+    expect(mockSubscribe).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,163 @@
+/**
+ * newsletter/page.tsx — a signup only when there is somewhere to keep it
+ * (#6730 D9).
+ *
+ * Boundaries mocked: `@working-theory/ui` (the section tree is a stub that
+ * renders one element per section, with a `newsletter` section rendering the
+ * form its content declares), `@working-theory/api-client`
+ * (`leads.captureStatus`), `next-intl/server`, and the Server Action module.
+ */
+import React from "react";
+import { render, screen } from "@testing-library/react";
+
+jest.mock("@working-theory/ui", () => ({
+  Heading: ({ children, level }: { children: React.ReactNode; level: number }) =>
+    React.createElement(`h${level}`, null, children),
+  SectionRenderer: ({
+    sections,
+  }: {
+    sections: Array<{
+      id: string;
+      type: string;
+      data: { action?: string; primaryCta?: { href: string } };
+    }>;
+  }) =>
+    React.createElement(
+      "div",
+      { "data-testid": "section-renderer" },
+      sections.map((s) =>
+        s.type === "newsletter"
+          ? React.createElement(
+              "form",
+              { key: s.id, "data-section-id": s.id, action: s.data.action },
+              "signup",
+            )
+          : React.createElement(
+              "div",
+              { key: s.id, "data-section-id": s.id },
+              s.data.primaryCta
+                ? React.createElement("a", { href: s.data.primaryCta.href }, "cta")
+                : null,
+            ),
+      ),
+    ),
+  localeHref: (locale: string, path: string) => `/${locale}${path}`,
+  LeadCaptureForm: (props: { fields?: Array<{ name: string; type: string }> }) =>
+    React.createElement("div", {
+      "data-testid": "lead-capture-form",
+      "data-fields": (props.fields ?? []).map((f) => `${f.name}:${f.type}`).join(","),
+    }),
+}));
+
+jest.mock("@working-theory/api-client", () => ({
+  leads: { captureStatus: jest.fn() },
+}));
+
+jest.mock("next-intl/server", () => ({
+  getTranslations: async () => (key: string) => key,
+}));
+
+// eslint-disable-next-line no-restricted-syntax -- test-seam mock: the Server Action module is a "use server" boundary; the page only passes it through
+jest.mock("../newsletter.actions", () => ({
+  subscribeNewsletterAction: jest.fn(),
+}));
+
+import { leads } from "@working-theory/api-client";
+
+import NewsletterPage from "../page";
+
+const mockCaptureStatus = leads.captureStatus as jest.Mock;
+const status = (newsletter: boolean) => ({
+  ok: true,
+  status: 200,
+  body: { ok: true, data: { contact: true, newsletter } },
+});
+
+const source = {
+  frontmatter: {
+    type: "NewsletterSignup" as const,
+    slug: "newsletter",
+    title: "Newsletter",
+    description: "What subscribers get.",
+  },
+  body: "",
+};
+
+/** `_base`'s content: a hero whose CTA points at `#signup`, the signup section, an FAQ. */
+const BASE_SECTIONS = [
+  { id: "hero", type: "hero", data: { headline: "News", primaryCta: { label: "Subscribe", href: "#signup" } } },
+  { id: "signup", type: "newsletter", data: { action: "/v1/leads/subscribe", source: "newsletter" } },
+  { id: "faq", type: "faq", data: { items: [] } },
+];
+
+/** #6738's Free content: no signup section. */
+const FREE_SECTIONS = [
+  { id: "hero", type: "hero", data: { headline: "News" } },
+  { id: "faq", type: "faq", data: { items: [] } },
+];
+
+async function renderWith(sections: unknown[]) {
+  const element = await NewsletterPage({
+    params: Promise.resolve({ locale: "en" }),
+    getMdxSource: jest.fn().mockResolvedValue(source),
+    getPageSections: jest.fn().mockResolvedValue(sections),
+  });
+  return render(element);
+}
+
+beforeEach(() => jest.clearAllMocks());
+
+describe("NewsletterPage — #6730 D9", () => {
+  it("newsletter:true + no newsletter section → one appended form with a single email field", async () => {
+    mockCaptureStatus.mockResolvedValue(status(true));
+
+    await renderWith(FREE_SECTIONS);
+
+    expect(screen.getAllByTestId("lead-capture-form")).toHaveLength(1);
+    expect(screen.getByTestId("lead-capture-form")).toHaveAttribute(
+      "data-fields",
+      "email:email",
+    );
+  });
+
+  it("newsletter:false + no newsletter section → no form at all", async () => {
+    mockCaptureStatus.mockResolvedValue(status(false));
+
+    const { container } = await renderWith(FREE_SECTIONS);
+
+    expect(screen.queryByTestId("lead-capture-form")).toBeNull();
+    expect(container.querySelector("form")).toBeNull();
+  });
+
+  it("newsletter:true + _base's newsletter section → that section renders, no second form", async () => {
+    mockCaptureStatus.mockResolvedValue(status(true));
+
+    const { container } = await renderWith(BASE_SECTIONS);
+
+    expect(container.querySelector("form[action='/v1/leads/subscribe']")).not.toBeNull();
+    expect(screen.queryByTestId("lead-capture-form")).toBeNull();
+    expect(container.querySelector("a[href='#signup']")).not.toBeNull();
+  });
+
+  it.each([
+    ["newsletter:false", () => mockCaptureStatus.mockResolvedValue(status(false))],
+    ["the status read rejecting", () => mockCaptureStatus.mockRejectedValue(new Error("ECONNREFUSED"))],
+    ["a 404 (older API)", () => mockCaptureStatus.mockResolvedValue({ ok: false, status: 404, body: {} })],
+  ])(
+    "%s + _base's newsletter section → the section is absent, and so is the hero CTA to it",
+    async (_label, arrange) => {
+      arrange();
+
+      const { container } = await renderWith(BASE_SECTIONS);
+
+      expect(container.querySelector("[data-section-id='signup']")).toBeNull();
+      expect(container.querySelector("form")).toBeNull();
+      expect(container.innerHTML).not.toContain("/v1/leads/subscribe");
+      expect(container.querySelector("a[href='#signup']")).toBeNull();
+      expect(screen.queryByTestId("lead-capture-form")).toBeNull();
+      // The rest of the page still renders.
+      expect(container.querySelector("[data-section-id='hero']")).not.toBeNull();
+      expect(container.querySelector("[data-section-id='faq']")).not.toBeNull();
+    },
+  );
+});