create-ailk 0.7.0 → 0.9.0

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,
@@ -50,10 +50,12 @@ import { auth } from "../../auth";
 import { GoogleAnalytics } from "../../components/google-analytics";
 import { SignOutTrigger } from "../../components/sign-out-trigger";
 import { isAuthPath } from "../../lib/auth-routes";
+import { assertEnabledLocale } from "../../lib/locale-guard";
 import { footerColumns, navItems } from "../../lib/nav-config";
 import { getOgImageUrl } from "../../lib/og";
-import { SITE_NAME, siteLogo } from "../../lib/site-brand";
+import { SITE_NAME } from "../../lib/site-brand";
 import { siteChrome } from "../../lib/site-chrome";
+import { siteLogo } from "../../lib/site-logo";
 // Registers the `_site.mdx` identity with page-renderer at module load, so
 // every page rendered under this layout carries the sitewide JSON-LD (#6597).
 import "../../lib/site-identity";
@@ -211,6 +213,9 @@ export default async function LocaleLayout({
   params,
 }: Props): Promise<ReactElement> {
   const { locale } = await params;
+  // #6107 — a segment that is not an enabled locale is a 404, before any
+  // message load or session read.
+  assertEnabledLocale(locale);
   const messages = await getMessages();
   const themeMode = await resolveThemeMode();
   const consentDecided = await hasConsentChoice();
@@ -227,6 +232,7 @@ export default async function LocaleLayout({
       // The Free marketing-site chrome (#5469 D5): the Product flyout's three
       // entries + descriptions, the top-level items, and the Get started CTA.
       product: tNav("product"),
+      services: tNav("services"),
       useCases: tNav("useCases"),
       useCasesDesc: tNav("useCasesDesc"),
       footerSitePagesHeading: tNav("footerSitePagesHeading"),
@@ -238,6 +244,20 @@ export default async function LocaleLayout({
       feature4: tNav("feature4"),
       feature5: tNav("feature5"),
       allFeatures: tNav("allFeatures"),
+      // #6878 D6 — one flyout rule for every shape: the offering column
+      // (Features or Services) beside the Customers column (the /for
+      // persona pages), plus the Customers footer column.
+      flyoutFeaturesHeading: tNav("flyoutFeaturesHeading"),
+      flyoutServicesHeading: tNav("flyoutServicesHeading"),
+      flyoutCustomersHeading: tNav("flyoutCustomersHeading"),
+      footerCustomersHeading: tNav("footerCustomersHeading"),
+      allCustomers: tNav("allCustomers"),
+      customer1: tNav("customer1"),
+      customer2: tNav("customer2"),
+      customer3: tNav("customer3"),
+      service1: tNav("service1"),
+      service2: tNav("service2"),
+      service3: tNav("service3"),
       howItWorks: tNav("howItWorks"),
       howItWorksDesc: tNav("howItWorksDesc"),
       features: tNav("features"),
@@ -245,6 +265,7 @@ export default async function LocaleLayout({
       faq: tNav("faq"),
       faqDesc: tNav("faqDesc"),
       pricing: tNav("pricing"),
+      portfolio: tNav("portfolio"),
       about: tNav("about"),
       // The footer's column groups (#6468): their two headings + Contact.
       contact: tNav("contact"),
@@ -284,10 +305,13 @@ export default async function LocaleLayout({
   // enforcement, the callbacks are the hook for @working-theory/consent.
   const tConsent = await getTranslations({ locale, namespace: "consent" });
 
-  // Right-side action cluster (#4984). Signed out → the Free template's pair
-  // (#5469 D5): a primary "Get started" → /contact beside the outline-strong
-  // "Sign in" link (the operator's auth-pair idiom, #4370, MINUS Sign up —
-  // this site offers no sign-up flow). Signed in → the user's name (a
+  // Right-side action cluster (#4984). Signed out → the auth pair: an
+  // outline-strong "Sign in" → /sign-in beside a primary "Sign up" → /sign-up
+  // (the operator's auth-pair idiom, #4370). Every shape ships the (auth)
+  // route group, so both routes exist in every scaffold; whether the header
+  // shows them is the design's nav setting (#6797 — an earlier revision of
+  // this comment said the Free site had no sign-up flow; it renders both and
+  // the service shapes now roster both). Signed in → the user's name (a
   // non-navigating label) + an outline-strong "Sign out"; both authored as
   // `kind: "flow"` so Nav hands their triggers back through
   // `renderFlowTrigger` (see NAV_CLIENT_ACTION_FLOW above).
@@ -319,7 +343,7 @@ export default async function LocaleLayout({
   const hasFlowAction = navActions.some((action) => action.kind === "flow");
 
   // Shared brand mark injected into both Nav and Footer chrome slots. The
-  // mark comes from site-brand.tsx (the mark the /sign-in card also renders);
+  // mark comes from site-logo.tsx (the mark the /sign-in card also renders);
   // both add the shipped wordmark beside it — the Nav composes mark + wordmark
   // on desktop and mark-only below `md` (#5469 D5), the columns Footer shows
   // the full lockup at every width (#6507).
@@ -364,11 +388,10 @@ export default async function LocaleLayout({
   // `(marketing)` group — a ~35-directory move for a five-page delta (spec D1).
   const isAuthRoute = isAuthPath(pathname, enabledLocales);
 
-  // Placeholder social handles + copyright (#5469 D5): `{{COMPANY_HANDLE}}` /
-  // `{{COMPANY_NAME}}` are create-ailk markers substituted at scaffold time
+  // Placeholder social handles (#5469 D5): `{{COMPANY_HANDLE}}` is a
+  // create-ailk marker substituted at scaffold time
   // (packages/create-ailk/src/programmatic.ts), so a customer's site never
-  // carries the kit vendor's own identity here. The year is computed, never
-  // typed, so the placeholder does not go stale.
+  // carries the kit vendor's own identity here.
   const socialLinks = [
     { platform: "facebook", href: "https://facebook.com/{{COMPANY_HANDLE}}" },
     { platform: "instagram", href: "https://instagram.com/{{COMPANY_HANDLE}}" },
@@ -378,6 +401,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.
@@ -389,8 +415,9 @@ export default async function LocaleLayout({
     items: col.items.map((item) => ({ ...item, label: labelFor(item.labelKey) })),
   }));
 
-  // NO_HAND_IMPLEMENT_OK: operator-directed live Free-template pass (2026-09-23).
-  const copyrightText = `© ${new Date().getFullYear()} SalesSmyth LLC. All rights reserved.`;
+  // The site's own name (#6942) — `SITE_NAME` resolves from `_site.mdx`'s
+  // `siteName:`, so a customer's footer never carries the kit vendor's name.
+  const copyrightText = `© ${new Date().getFullYear()} ${SITE_NAME}. All rights reserved.`;
 
   // Footer legal links (#5612 D3). The centered variant folds in FAQ — the
   // roster's third always-scaffolded core route (`/faq`, alongside `/privacy`
@@ -400,6 +427,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 +546,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 +641,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();
+    },
+  );
+});

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

@@ -0,0 +1,66 @@
+"use server";
+
+/**
+ * subscribeNewsletterAction — Server Action paired with the
+ * `ailkSubscribeNewsletter` MCP tool (#6730 D9).
+ *
+ * `/newsletter` renders the shared `LeadCaptureForm` bound to this action
+ * when the API accepts a subscription (a database is set up) and the page's
+ * content declares no signup section of its own. Validates the address with
+ * the tool's own input schema, calls `POST /v1/leads/subscribe` through
+ * `@working-theory/api-client`, and maps the outcome the same way
+ * `captureLeadAction` does: the API's 503 `lead_capture_not_configured` →
+ * `unavailable`; any other non-2xx or thrown error → the generic `error`;
+ * only a 2xx is `success`.
+ */
+
+import { leads } from "@working-theory/api-client";
+import { LEAD_CAPTURE_HONEYPOT, type LeadCaptureFormState } from "@working-theory/ui";
+import { subscribeNewsletterInputSchema } from "@working-theory/validation";
+
+const GENERIC_ERROR = "Something went wrong, please try again.";
+
+export async function subscribeNewsletterAction(
+  _prevState: LeadCaptureFormState,
+  formData: FormData,
+): Promise<LeadCaptureFormState> {
+  // Honeypot: a bot that fills the hidden field gets a person's answer, and
+  // nothing is sent.
+  const honeypot = formData.get(LEAD_CAPTURE_HONEYPOT);
+  if (typeof honeypot === "string" && honeypot !== "") return { kind: "success" };
+
+  const parsed = subscribeNewsletterInputSchema.safeParse({
+    email: formData.get("email"),
+  });
+  if (!parsed.success) {
+    return {
+      kind: "error",
+      fieldErrors: { email: parsed.error.issues[0]?.message ?? "Invalid email" },
+    };
+  }
+
+  const siteId = process.env.AILK_SITE_ID ?? "default";
+  try {
+    const res = await leads.subscribe({
+      siteId,
+      source: "newsletter",
+      email: parsed.data.email,
+    });
+    if (!res.ok) {
+      const error =
+        typeof res.body === "object" && res.body !== null
+          ? (res.body as { error?: unknown }).error
+          : undefined;
+      if (res.status === 503 && error === "lead_capture_not_configured") {
+        return { kind: "unavailable" };
+      }
+      return { kind: "error", message: GENERIC_ERROR };
+    }
+    return { kind: "success" };
+  } catch (err) {
+    // The api-client never attaches the request payload to a thrown error,
+    // so logging `err` carries no subscriber address.
+    console.error("[subscribeNewsletterAction]", err);
+    return { kind: "error", message: GENERIC_ERROR };
+  }
+}

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

@@ -1,21 +1,78 @@
-// Newsletter page (#6658 D5) — a NewsletterSignup at /newsletter. Its
-// `newsletter` section posts to lead capture (`/v1/leads/subscribe`), which
-// persists a Subscriber and sends no verification email. A module-less
-// surface a template enables by naming it in its roster; with no content the
-// route 404s. Mirrors use-cases/page.tsx: a sections-composed page renders its
-// sections, a prose-only page its MDX body.
-import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+// Newsletter page (#6658 D5) — a NewsletterSignup at /newsletter. A
+// module-less surface a template enables by naming it in its roster; with no
+// content the route 404s. Mirrors for/page.tsx: a sections-composed
+// page renders its sections, a prose-only page its MDX body.
+//
+// A signup only when there is somewhere to keep it (#6730 D9). The API says
+// whether it accepts a subscription (`GET /v1/leads/capture` — a database is
+// set up):
+//
+//   - accepting: a content `newsletter` section renders as authored (its own
+//     form posts to `/v1/leads/subscribe`); a page with no such section gets
+//     the shared `LeadCaptureForm` (one email field) appended, bound to
+//     `subscribeNewsletterAction`.
+//   - otherwise — including an unreachable API — every `newsletter` section
+//     is dropped before render, and a leading hero's CTA that pointed at a
+//     dropped section's anchor goes with it, so no signup form of any kind
+//     renders and no button points at a section that is gone. The API
+//     refuses a subscribe in that state anyway, so a cached page can never
+//     record a false success.
+import { leads } from "@working-theory/api-client";
+import type {
+  getMdxSource as defaultGetMdxSource,
+  getPageSections as defaultGetPageSections,
+} from "@working-theory/page-renderer";
 import {
   getMdxSource as loadMdxSource,
+  getPageSections as loadPageSections,
   renderPage,
   renderPageMetadata,
 } from "@working-theory/page-renderer";
+import { LeadCaptureForm, localeHref } from "@working-theory/ui";
 import type { Metadata } from "next";
+import { getTranslations } from "next-intl/server";
 import type { ReactElement } from "react";
 
+import { subscribeNewsletterAction } from "./newsletter.actions";
+
+export const revalidate = 60;
+
 interface Props {
   params: Promise<{ locale: string }>;
   getMdxSource?: typeof defaultGetMdxSource;
+  getPageSections?: typeof defaultGetPageSections;
+}
+
+type Section = Awaited<ReturnType<typeof defaultGetPageSections>>[number];
+
+/** Whether the API accepts a subscription; `false` for any failed read. */
+async function acceptsSubscription(): Promise<boolean> {
+  try {
+    const res = await leads.captureStatus();
+    return res.ok && res.body.ok === true && res.body.data.newsletter;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Drop every `newsletter` section, and any leading-hero CTA whose `href` is
+ * the `#<id>` anchor of a section that was dropped.
+ */
+function withoutSignup(sections: Section[]): Section[] {
+  const dropped = new Set(
+    sections.filter((s) => s.type === "newsletter").map((s) => `#${s.id}`),
+  );
+  if (dropped.size === 0) return sections;
+  return sections
+    .filter((s) => s.type !== "newsletter")
+    .map((s, i) => {
+      if (i !== 0 || s.type !== "hero") return s;
+      const data = { ...s.data };
+      if (data.primaryCta && dropped.has(data.primaryCta.href)) delete data.primaryCta;
+      if (data.secondaryCta && dropped.has(data.secondaryCta.href)) delete data.secondaryCta;
+      return { ...s, data };
+    });
 }
 
 export async function generateMetadata({
@@ -32,19 +89,54 @@ export async function generateMetadata({
 export default async function Page({
   params,
   getMdxSource,
+  getPageSections,
 }: Props): Promise<ReactElement> {
   const { locale } = await params;
-  const source = await (getMdxSource ?? loadMdxSource)("NewsletterSignup", "newsletter", locale);
-  const composed =
-    source !== null &&
-    Array.isArray((source.frontmatter as { sections?: unknown[] }).sections) &&
-    ((source.frontmatter as { sections?: unknown[] }).sections?.length ?? 0) >
-      0;
-  return renderPage({
+  const load = getMdxSource ?? loadMdxSource;
+  const loadSections = getPageSections ?? loadPageSections;
+  const [source, accepting] = await Promise.all([
+    load("NewsletterSignup", "newsletter", locale),
+    acceptsSubscription(),
+  ]);
+  const declared = source ? await loadSections(source.frontmatter) : [];
+  const composed = declared.length > 0;
+  const hasSignupSection = declared.some((s) => s.type === "newsletter");
+
+  const rendered = await renderPage({
     type: "NewsletterSignup",
     slug: "newsletter",
     locale,
     ...(composed ? {} : { bodyMode: "mdx-body" as const }),
     ...(getMdxSource !== undefined && { getMdxSource }),
+    getPageSections: accepting
+      ? loadSections
+      : async (frontmatter: unknown) => withoutSignup(await loadSections(frontmatter)),
   });
+
+  if (!accepting || hasSignupSection || source === null) return rendered;
+
+  const [t, tc] = await Promise.all([
+    getTranslations({ locale, namespace: "newsletter" }),
+    getTranslations({ locale, namespace: "contact" }),
+  ]);
+  return (
+    <>
+      {rendered}
+      <LeadCaptureForm
+        action={subscribeNewsletterAction}
+        fields={[{ name: "email", label: t("emailLabel"), type: "email", required: true }]}
+        termsHref={localeHref(locale, "/terms")}
+        text={{
+          submit: t("submit"),
+          sending: t("sending"),
+          success: t("success"),
+          consentStatement: t("consentStatement"),
+          genericError: tc("genericError"),
+          unavailableHeading: tc("unavailableHeading"),
+          unavailableBody: tc("unavailableBody", { email: "{email}" }),
+          unavailableNoEmail: tc("unavailableNoEmail"),
+        }}
+      />
+    </>
+  );
 }