create-ailk 0.20.0 → 0.22.0

package/templates/apps/web/app/api/webhooks/stripe/route.ts

@@ -0,0 +1,31 @@
+// The Stripe webhook route — the standard spoke checkout (#8748), kept current
+// by `create-ailk update`: do not edit it. Every guarantee lives in the
+// spoke-checkout package and arrives by a package bump. This site's checkout
+// data is lib/checkout-config.ts, the one file to edit. It answers 404 on any
+// build that is not a spoke.
+import { createSpokeCheckout } from "@working-theory/spoke-checkout";
+
+import {
+  checkoutNotServed,
+  checkoutServed,
+  spokeCheckoutConfig,
+} from "../../../../lib/checkout";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type WebhookRoute = ReturnType<typeof createSpokeCheckout>["webhook"];
+
+let webhook: WebhookRoute | undefined;
+
+/** Built on the first served request and kept for every later one. */
+function webhookRoute(): WebhookRoute {
+  webhook ??= createSpokeCheckout(spokeCheckoutConfig).webhook;
+  return webhook;
+}
+
+// platform-decisions-waiver: api-versioning — the endpoint URL registered in Stripe, not a versioned API contract (spec 8748 §7)
+export async function POST(request: Request): Promise<Response> {
+  if (!checkoutServed()) return checkoutNotServed();
+  return webhookRoute().POST(request);
+}

package/templates/apps/web/auth.ts

@@ -43,6 +43,11 @@ import {
   isSignUpOpen,
   resetSendConfigured,
 } from "./lib/auth-env";
+import {
+  signUpAgreementHooks,
+  signUpAgreementsPlugin,
+  withAuthTransactionCapture,
+} from "./lib/sign-up-agreements";
 
 /**
  * Reset-token lifetime (#5962 § D11). One hour — the library's own default,
@@ -438,9 +443,25 @@ export function createAuth(deps: CreateAuthDeps = {}) {
   };
 
   const instance = betterAuth({
-    database: prismaAdapter(prisma, {
+    /**
+     * `transaction: true` (#8765 D4): Better Auth opens one `$transaction` for
+     * exactly its three `runWithTransaction` sites — `/sign-up/email`,
+     * `createOAuthUser` and verification-token consumption — so a user, its
+     * account and its sign-up grants commit together or not at all. Every
+     * other write stays autocommit. The capture wrapper exposes that
+     * transaction's client to the sign-up hooks below; it changes nothing
+     * about the transaction itself (lib/sign-up-agreements.ts).
+     */
+    database: prismaAdapter(withAuthTransactionCapture(prisma), {
       provider: "postgresql",
+      transaction: true,
     }),
+    /**
+     * The sign-up grants (#8765 D4): the user hook decides whether the new
+     * user carries agreements, the account hook writes them on the captured
+     * transaction client. No other database hook is installed.
+     */
+    databaseHooks: signUpAgreementHooks(),
     secret: resolveSecret(),
     baseURL: process.env.BETTER_AUTH_URL,
     socialProviders: buildSocialProviders(),
@@ -653,13 +674,18 @@ export function createAuth(deps: CreateAuthDeps = {}) {
      * Sign-in only — the callback mails existing users and nobody else, and
      * `disableSignUp` refuses to create one even for a live token
      * (lib/auth-email.ts).
+     *
+     * `signUpAgreementsPlugin` always (#8765 D3): while sign-up is open,
+     * `/sign-up/email` without every sign-up agreement is refused before the
+     * handler looks the address up.
      */
     plugins: magicLinkActive
       ? [
           nextCookies(),
+          signUpAgreementsPlugin(),
           magicLink(makeMagicLinkOptions({ send: authEmailTransport })),
         ]
-      : [nextCookies()],
+      : [nextCookies(), signUpAgreementsPlugin()],
   });
   return instance;
 }

package/templates/apps/web/jest.config.cjs

@@ -2,6 +2,7 @@
 // but no Vitest is installed anywhere yet). JSDOM env so RTL can mount components.
 module.exports = {
   preset: "ts-jest",
+  globalSetup: require.resolve("../../tools/jest/pin-timezone.cjs"),
   testEnvironment: "jsdom",
   roots: [
     "<rootDir>/__tests__",

package/templates/apps/web/lib/__tests__/account-invite.test.ts

@@ -0,0 +1,63 @@
+/**
+ * account-invite.test.ts — #8757 D8 / AC-5: the /contact thank-you's account
+ * link, by the generated sign-in provider. A site signs in at its own
+ * locale-prefixed `/sign-in` and lands on its own `/account`; a hub-sign-in
+ * spoke starts at `/api/hub-session/sign-in`; a site with no sign-in gets no
+ * link, and neither does an email the hint schema refuses.
+ */
+
+let mockProvider: "site" | "hub" | "none" = "site";
+// eslint-disable-next-line no-restricted-syntax -- #507: SIGN_IN_PROVIDER is a generated per-build constant (#8757 D8), not a runtime input; no env or HTTP surface selects it.
+jest.mock("../topology.generated", () => ({
+  __esModule: true,
+  get SIGN_IN_PROVIDER() {
+    return mockProvider;
+  },
+}));
+
+import { accountInviteHref } from "../account-invite";
+
+afterEach(() => {
+  mockProvider = "site";
+});
+
+describe("accountInviteHref (#8757 D8)", () => {
+  it("site, the default locale: the bare /sign-in with next=/account and the email", () => {
+    expect(accountInviteHref("en", "a@b.example")).toBe(
+      "/sign-in?next=%2Faccount&email=a%40b.example",
+    );
+  });
+
+  it("site, another locale: both the sign-in path and next carry the prefix", () => {
+    expect(accountInviteHref("fr", "a@b.example")).toBe(
+      "/fr/sign-in?next=%2Ffr%2Faccount&email=a%40b.example",
+    );
+  });
+
+  it("site: a plus sign in the address is encoded, never read as a space", () => {
+    expect(accountInviteHref("en", "a+b@x.example")).toBe(
+      "/sign-in?next=%2Faccount&email=a%2Bb%40x.example",
+    );
+  });
+
+  it("hub: the spoke's hub-session start, unprefixed", () => {
+    mockProvider = "hub";
+    expect(accountInviteHref("fr", "a@b.example")).toBe(
+      "/api/hub-session/sign-in?next=%2Faccount&email=a%40b.example",
+    );
+  });
+
+  it("none: no link", () => {
+    mockProvider = "none";
+    expect(accountInviteHref("en", "a@b.example")).toBeNull();
+  });
+
+  it.each(["x\r\n@y.example", "a&next=/evil@b.example", "not-an-email", ""])(
+    "an email the hint schema refuses (%j) gives no link, on either provider",
+    (email) => {
+      expect(accountInviteHref("en", email)).toBeNull();
+      mockProvider = "hub";
+      expect(accountInviteHref("en", email)).toBeNull();
+    },
+  );
+});

package/templates/apps/web/lib/__tests__/checkout.test.ts

@@ -0,0 +1,243 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * The standard spoke checkout (#8748 D6; spec
+ * docs/specs/8748-a-standard-spoke-checkout-route-spec.md AC-2, AC-3, AC-4).
+ *
+ * `./checkout-config` — the site's own data — is mocked with a fixture in
+ * every case, so this suite passes against any shape of the site's file,
+ * including a pre-#8748 one that also carries `siteBaseUrl` and `fulfil`.
+ * The hub's `leads.submit` is the one external boundary mocked: the
+ * fulfilment must post one lead marked with the site, under the session id as
+ * its Idempotency-Key, with a body that stays byte-identical between attempts
+ * so the hub can replay it.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const mockSubmit = jest.fn();
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  leads: { submit: (...args: unknown[]) => mockSubmit(...args) },
+}));
+
+const OFFERINGS = {
+  starter: { kind: "fixed", lookupKey: "acme_starter", cancelPath: "/" },
+};
+const mockSite: { value: Record<string, unknown> } = {
+  value: { site: "acme", offerings: OFFERINGS },
+};
+// eslint-disable-next-line no-restricted-syntax -- #507: the site's checkout-config.ts is the site's own data, not this suite's subject; a fixture stands in for it so the suite holds against any shape a site's file has (#8748 AC-2).
+jest.mock("../checkout-config", () => ({
+  __esModule: true,
+  get checkoutConfig() {
+    return mockSite.value;
+  },
+}));
+
+const mockTopology: { value: "hub" | "spoke" } = { value: "spoke" };
+// eslint-disable-next-line no-restricted-syntax -- #507: the topology is a generated constant (#7426), not a runtime input; the seam IS the boundary between a hub and a spoke build, and no env or HTTP surface selects it.
+jest.mock("../topology.generated", () => ({
+  __esModule: true,
+  get TOPOLOGY() {
+    return mockTopology.value;
+  },
+}));
+
+type CheckoutModule = typeof import("../checkout");
+
+/** `lib/checkout.ts`, loaded fresh against the current site fixture. */
+function load(site: Record<string, unknown> = { site: "acme", offerings: OFFERINGS }): CheckoutModule {
+  mockSite.value = site;
+  let loaded!: CheckoutModule;
+  jest.isolateModules(() => {
+    loaded = require("../checkout") as CheckoutModule;
+  });
+  return loaded;
+}
+
+/** A test-mode completion as the package hands it to `fulfil`. */
+const COMPLETION = {
+  idempotencyKey: "cs_test_1",
+  sessionId: "cs_test_1",
+  offering: "starter",
+  kind: "fixed" as const,
+  mode: "test" as const,
+  livemode: false,
+  paymentStatus: "paid" as const,
+  amountTotal: 4900,
+  currency: "usd",
+  email: "b@example.com",
+  customerId: "cus_test_1",
+  termsOfService: null,
+  termsStamp: null,
+  metadata: { site: "acme", offering: "starter", kind: "fixed" },
+};
+
+/**
+ * `renderConfig`'s body for COMPLETION, key order included (NFR5), plus the
+ * session's terms consent as its last key (#8778).
+ */
+const EXPECTED_BODY =
+  '{"siteId":"acme","source":"web","email":"b@example.com","payload":{"site":"acme","page":"checkout","offering":"starter","checkoutKind":"fixed","mode":"test","amountTotal":4900,"currency":"usd","stripeCustomerId":"cus_test_1","checkoutSession":"cs_test_1","termsAccepted":null}}';
+
+const SOURCE = readFileSync(join(__dirname, "..", "checkout.ts"), "utf8");
+const ENV = process.env;
+
+beforeEach(() => {
+  mockSubmit.mockReset();
+  mockSubmit.mockResolvedValue({ ok: true, status: 201 });
+  process.env = { ...ENV, AILK_SPOKE_KEY: "spoke-key-fixture" };
+  mockTopology.value = "spoke";
+});
+
+afterAll(() => {
+  process.env = ENV;
+});
+
+describe("spokeCheckoutConfig (#8748 AC-2, AC-4)", () => {
+  it("exports exactly spokeCheckoutConfig, checkoutServed and checkoutNotServed", () => {
+    expect(Object.keys(load()).sort()).toEqual([
+      "checkoutNotServed",
+      "checkoutServed",
+      "spokeCheckoutConfig",
+    ]);
+  });
+
+  it("has exactly site, offerings, siteBaseUrl and fulfil, the offerings being the site's own object", () => {
+    const { spokeCheckoutConfig } = load();
+    expect(Object.keys(spokeCheckoutConfig).sort()).toEqual([
+      "fulfil",
+      "offerings",
+      "site",
+      "siteBaseUrl",
+    ]);
+    expect(spokeCheckoutConfig.site).toBe("acme");
+    expect(spokeCheckoutConfig.offerings).toBe(OFFERINGS);
+  });
+
+  it("takes only site and offerings from a site file that also carries env, siteBaseUrl and fulfil (SEC-8748-B)", async () => {
+    const siteFulfil = jest.fn();
+    const { spokeCheckoutConfig } = load({
+      site: "acme",
+      offerings: OFFERINGS,
+      env: { STRIPE_MODE: "live" },
+      siteBaseUrl: "https://elsewhere.example",
+      fulfil: siteFulfil,
+    });
+    expect(Object.keys(spokeCheckoutConfig).sort()).toEqual([
+      "fulfil",
+      "offerings",
+      "site",
+      "siteBaseUrl",
+    ]);
+    expect("env" in spokeCheckoutConfig).toBe(false);
+    expect(spokeCheckoutConfig.siteBaseUrl).not.toBe("https://elsewhere.example");
+    expect(spokeCheckoutConfig.fulfil).not.toBe(siteFulfil);
+    await spokeCheckoutConfig.fulfil(COMPLETION);
+    expect(siteFulfil).not.toHaveBeenCalled();
+    expect(mockSubmit).toHaveBeenCalledTimes(1);
+  });
+
+  it("reads no Stripe setting and imports no Stripe client (AC-4)", () => {
+    expect(SOURCE).not.toContain("STRIPE_");
+    expect(SOURCE).not.toContain("stripe-client");
+  });
+});
+
+describe("checkoutServed / checkoutNotServed (#8748 D11)", () => {
+  it("serves on a spoke only", () => {
+    const { checkoutServed } = load();
+    mockTopology.value = "spoke";
+    expect(checkoutServed()).toBe(true);
+    mockTopology.value = "hub";
+    expect(checkoutServed()).toBe(false);
+  });
+
+  it("answers 404 with no-store", () => {
+    const res = load().checkoutNotServed();
+    expect(res.status).toBe(404);
+    expect(res.headers.get("cache-control")).toBe("no-store");
+  });
+});
+
+describe("the fulfilment (#8748 AC-3)", () => {
+  it("posts one lead marked with the site, under the session id as its Idempotency-Key", async () => {
+    await load().spokeCheckoutConfig.fulfil(COMPLETION);
+    expect(mockSubmit).toHaveBeenCalledTimes(1);
+    const [body, init] = mockSubmit.mock.calls[0] as [unknown, unknown];
+    expect(body).toEqual({
+      siteId: "acme",
+      source: "web",
+      email: "b@example.com",
+      payload: {
+        site: "acme",
+        page: "checkout",
+        offering: "starter",
+        checkoutKind: "fixed",
+        mode: "test",
+        amountTotal: 4900,
+        currency: "usd",
+        stripeCustomerId: "cus_test_1",
+        checkoutSession: "cs_test_1",
+        termsAccepted: null,
+      },
+    });
+    expect(init).toEqual({ headers: { "Idempotency-Key": "cs_test_1" } });
+    expect(JSON.stringify(body)).toBe(EXPECTED_BODY);
+  });
+
+  it("carries the stamp of the terms the buyer accepted as payload.termsAccepted (#8778)", async () => {
+    await load().spokeCheckoutConfig.fulfil({
+      ...COMPLETION,
+      termsOfService: "accepted",
+      termsStamp: "account_terms@2",
+    });
+    const [body] = mockSubmit.mock.calls[0] as [{ payload: Record<string, unknown> }];
+    expect(body.payload["termsAccepted"]).toBe("account_terms@2");
+  });
+
+  it.each([
+    ["a box not accepted", { termsOfService: null, termsStamp: "account_terms@2" }],
+    ["an accepted box with no stamp", { termsOfService: "accepted" as const, termsStamp: null }],
+  ])("sends termsAccepted: null for %s (#8778)", async (_label, terms) => {
+    await load().spokeCheckoutConfig.fulfil({ ...COMPLETION, ...terms });
+    const [body] = mockSubmit.mock.calls[0] as [{ payload: Record<string, unknown> }];
+    expect(body.payload).toHaveProperty("termsAccepted", null);
+  });
+
+  it("sends the same bytes under the same key on a replay", async () => {
+    const { spokeCheckoutConfig } = load();
+    await spokeCheckoutConfig.fulfil(COMPLETION);
+    await spokeCheckoutConfig.fulfil(COMPLETION);
+    expect(mockSubmit).toHaveBeenCalledTimes(2);
+    const [first, second] = mockSubmit.mock.calls as [
+      [unknown, unknown],
+      [unknown, unknown],
+    ];
+    expect(JSON.stringify(second[0])).toBe(JSON.stringify(first[0]));
+    expect(second[1]).toEqual(first[1]);
+  });
+
+  it("makes no call for a completion without an email", async () => {
+    await load().spokeCheckoutConfig.fulfil({ ...COMPLETION, email: null });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("rejects with no call when AILK_SPOKE_KEY is unset", async () => {
+    delete process.env["AILK_SPOKE_KEY"];
+    await expect(load().spokeCheckoutConfig.fulfil(COMPLETION)).rejects.toThrow(
+      "AILK_SPOKE_KEY is not set",
+    );
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("rejects when the hub answers { ok: false }", async () => {
+    mockSubmit.mockResolvedValue({ ok: false, status: 422 });
+    await expect(load().spokeCheckoutConfig.fulfil(COMPLETION)).rejects.toThrow(
+      "hub lead write answered 422",
+    );
+  });
+});

package/templates/apps/web/lib/__tests__/consent-policies.test.ts

@@ -0,0 +1,23 @@
+/**
+ * The localized policy map (#8765 D9, AC-5): one map, the registry's keys,
+ * each path carrying the locale prefix off the default locale.
+ */
+import { consentPoliciesFor } from "../consent-policies";
+
+describe("consentPoliciesFor", () => {
+  it("is /contact's three destinations for the default locale", () => {
+    expect(consentPoliciesFor("en")).toEqual({
+      terms: "/terms",
+      privacy: "/privacy",
+      working_agreement: "/working-agreement",
+    });
+  });
+
+  it("prefixes every path for another locale", () => {
+    expect(consentPoliciesFor("fr")).toEqual({
+      terms: "/fr/terms",
+      privacy: "/fr/privacy",
+      working_agreement: "/fr/working-agreement",
+    });
+  });
+});

package/templates/apps/web/lib/__tests__/deck-page.test.ts

@@ -0,0 +1,249 @@
+/**
+ * The deck-page resolver (#8687 D3, AC-2).
+ *
+ * `deckCandidates` and the `DECK_ROUTES` parity are pure functions over the
+ * real routes map. `resolveDeckPage` and `inputsFor` (captured off the
+ * `setDeckPages` registration call) are exercised with `getMdxSource` and
+ * `next/headers` mocked, in `renderPage-extension.test.tsx`'s idiom.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+import { ROUTES } from "@working-theory/templates/routes";
+
+const mockGetMdxSource = jest.fn();
+const mockSetDeckPages = jest.fn();
+
+jest.mock("@working-theory/page-renderer", () => {
+  const actual = jest.requireActual("@working-theory/page-renderer");
+  return {
+    ...actual,
+    getMdxSource: (...args: unknown[]) => mockGetMdxSource(...args),
+    setDeckPages: (...args: unknown[]) => mockSetDeckPages(...args),
+  };
+});
+
+const mockHeaders = jest.fn();
+jest.mock("next/headers", () => ({ headers: () => mockHeaders() }));
+
+const savedLocales = process.env["NEXT_PUBLIC_ENABLED_LOCALES"];
+
+beforeAll(() => {
+  process.env["NEXT_PUBLIC_ENABLED_LOCALES"] = "en,es";
+});
+afterAll(() => {
+  if (savedLocales === undefined) delete process.env["NEXT_PUBLIC_ENABLED_LOCALES"];
+  else process.env["NEXT_PUBLIC_ENABLED_LOCALES"] = savedLocales;
+});
+
+import { DECK_ROUTES, deckCandidates, resolveDeckPage } from "../deck-page";
+import { siteChrome } from "../site-chrome";
+
+describe("deckCandidates (#8687 D3, AC-2)", () => {
+  const LOCALES = ["en", "es"];
+
+  it("/pricing resolves the route row, then the [slug] fallback", () => {
+    expect(deckCandidates("/pricing", LOCALES)).toEqual([
+      { type: "Pricing", slug: "pricing" },
+      { type: "LandingPage", slug: "pricing" },
+      { type: "BlogList", slug: "pricing" },
+    ]);
+  });
+
+  it("/about (core, always scaffolded) resolves the route row only", () => {
+    expect(deckCandidates("/about", LOCALES)).toEqual([
+      { type: "AboutPage", slug: "about" },
+    ]);
+  });
+
+  it("/es/offer/ (no route match) falls through to [slug] alone", () => {
+    expect(deckCandidates("/es/offer/", LOCALES)).toEqual([
+      { type: "LandingPage", slug: "offer" },
+      { type: "BlogList", slug: "offer" },
+    ]);
+  });
+
+  it("/projects/apollo resolves the detail row's directory type", () => {
+    expect(deckCandidates("/projects/apollo", LOCALES)).toEqual([
+      { type: "Project", slug: "apollo" },
+    ]);
+  });
+
+  it("/careers (gateable, no DECK_ROUTES entry) falls through to [slug]", () => {
+    expect(deckCandidates("/careers", LOCALES)).toEqual([
+      { type: "LandingPage", slug: "careers" },
+      { type: "BlogList", slug: "careers" },
+    ]);
+  });
+
+  it.each(["/", "/software", "/sign-in", "/blog/post", "/edit/LandingPage/x", "/a/b"])(
+    "%s resolves no candidates",
+    (pathname) => {
+      expect(deckCandidates(pathname, LOCALES)).toEqual([]);
+    },
+  );
+});
+
+describe("DECK_ROUTES parity (#8687 D3)", () => {
+  it("contains every routes-map row with seed content whose page.tsx renders sections, minus /", () => {
+    // DECK_ROUTES is a fixed superset, not a per-scaffold exact set: a shape
+    // that doesn't ship one of these routes (e.g. a Free scaffold without
+    // /alternatives) simply has no page.tsx there, so deckCandidates/
+    // resolveDeckPage never get a request for it (harmless). What would be a
+    // real bug is the OTHER direction — an actually-shipped sections route
+    // this build's own tree carries that DECK_ROUTES fails to name.
+    const appRoot = path.join(__dirname, "..", "..", "app", "[locale]");
+    const sectionsRoutes = new Set<string>();
+    for (const row of ROUTES) {
+      if (row.route === "/" || !row.contentPath?.startsWith("content/en/")) continue;
+      const dir = row.route
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => (segment.startsWith(":") ? "[slug]" : segment))
+        .join("/");
+      let pageSource: string;
+      try {
+        pageSource = readFileSync(path.join(appRoot, dir, "page.tsx"), "utf8");
+      } catch {
+        continue;
+      }
+      if (!pageSource.includes('bodyMode: "mdx-body"')) {
+        sectionsRoutes.add(row.route);
+      }
+    }
+    const deckRoutesSet = new Set<string>(DECK_ROUTES);
+    const missing = [...sectionsRoutes].filter((route) => !deckRoutesSet.has(route));
+    expect(missing).toEqual([]);
+  });
+});
+
+describe("resolveDeckPage (#8687 D3, AC-2)", () => {
+  beforeEach(() => {
+    mockGetMdxSource.mockReset();
+  });
+
+  it("returns the first candidate with a source", async () => {
+    mockGetMdxSource.mockImplementation((type: string) =>
+      Promise.resolve(
+        type === "LandingPage"
+          ? null
+          : type === "BlogList"
+            ? { frontmatter: { type: "BlogList", slug: "offer" }, body: "" }
+            : null,
+      ),
+    );
+
+    const result = await resolveDeckPage("/es/offer/", "en");
+
+    expect(result).toEqual({
+      type: "BlogList",
+      slug: "offer",
+      frontmatter: { type: "BlogList", slug: "offer" },
+    });
+  });
+
+  it("returns null when a read throws", async () => {
+    mockGetMdxSource.mockRejectedValue(new Error("read failed"));
+
+    expect(await resolveDeckPage("/pricing", "en")).toBeNull();
+  });
+
+  it("returns null for a path with no candidates, with zero getMdxSource calls (NFR 2)", async () => {
+    expect(await resolveDeckPage("/software", "en")).toBeNull();
+    expect(mockGetMdxSource).not.toHaveBeenCalled();
+  });
+});
+
+describe("the registered inputsFor (#8687 D3, AC-2)", () => {
+  beforeEach(() => {
+    mockGetMdxSource.mockReset();
+    mockHeaders.mockReset();
+  });
+
+  function registeredInputsFor(): (ctx: {
+    type: string;
+    slug: string;
+    locale: string;
+  }) => Promise<unknown> {
+    const call = mockSetDeckPages.mock.calls[mockSetDeckPages.mock.calls.length - 1];
+    return (
+      call?.[0] as {
+        inputsFor: (ctx: { type: string; slug: string; locale: string }) => Promise<unknown>;
+      }
+    ).inputsFor;
+  }
+
+  it("resolves the design's inputs when the resolved page matches and opts in", async () => {
+    mockHeaders.mockResolvedValue(new Map([["x-pathname", "/pricing"]]));
+    mockGetMdxSource.mockImplementation((type: string) =>
+      Promise.resolve(
+        type === "Pricing"
+          ? null
+          : type === "LandingPage"
+            ? { frontmatter: { type: "LandingPage", slug: "pricing", layout: "deck" }, body: "" }
+            : null,
+      ),
+    );
+
+    const result = await registeredInputsFor()({
+      type: "LandingPage",
+      slug: "pricing",
+      locale: "en",
+    });
+
+    // The scaffold's generated site-chrome carries the DESIGN's values — minimalism
+    // presents the deck (deckPresentation true), standard does not — so the expected
+    // inputs are read from it rather than hard-coded to one design.
+    const chrome = siteChrome as typeof siteChrome & {
+      deckGrounds?: unknown;
+      deckPresentation?: true;
+      deckAnchors?: "bare";
+    };
+    expect(result).toEqual({
+      ...(chrome.deckGrounds !== undefined ? { deckGrounds: chrome.deckGrounds } : {}),
+      deckPresentation: chrome.deckPresentation === true,
+      // #8773 — the design's slide naming rides along only when it presents and chose bare.
+      ...(chrome.deckPresentation === true && chrome.deckAnchors === "bare"
+        ? { deckAnchorStyle: "bare" }
+        : {}),
+    });
+  });
+
+  it("returns null when the resolved page does not match this render", async () => {
+    mockHeaders.mockResolvedValue(new Map([["x-pathname", "/pricing"]]));
+    mockGetMdxSource.mockResolvedValue(
+      { frontmatter: { type: "Pricing", slug: "pricing" }, body: "" },
+    );
+
+    const result = await registeredInputsFor()({
+      type: "Pricing",
+      slug: "pricing",
+      locale: "en",
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it("returns null for a resolved page without the field", async () => {
+    mockHeaders.mockResolvedValue(new Map([["x-pathname", "/pricing"]]));
+    mockGetMdxSource.mockImplementation((type: string) =>
+      Promise.resolve(
+        type === "LandingPage"
+          ? { frontmatter: { type: "LandingPage", slug: "pricing" }, body: "" }
+          : null,
+      ),
+    );
+
+    expect(
+      await registeredInputsFor()({ type: "LandingPage", slug: "pricing", locale: "en" }),
+    ).toBeNull();
+  });
+
+  it("returns null with no x-pathname header", async () => {
+    mockHeaders.mockResolvedValue(new Map());
+
+    expect(
+      await registeredInputsFor()({ type: "LandingPage", slug: "pricing", locale: "en" }),
+    ).toBeNull();
+  });
+});