create-ailk 0.30.0 → 0.31.0

package/templates/apps/web/app/[locale]/flows/[slug]/FlowStepperClient.tsx

@@ -35,6 +35,13 @@
  * a `thankYou` block, so without this widening the callback would never be
  * supplied on a recommending flow at all.
  *
+ * Per-tier completion redirect (#10616 D4): when a `scoring.tiers[]` entry
+ * carries a `thankYou` slug, the client scores the walk's own answers
+ * (`resolveTierThankYouSlug`) and navigates to the scored tier's
+ * `/thanks/<slug>` AHEAD of the results permalink and the `thankYou` block;
+ * a tier with no slug, or a flow with none, continues exactly as before. The
+ * answers are read to score, never written into the href.
+ *
  * Account link (#8771 D5): when the walk completes on an `invite` magnet (the
  * step response's `next`), the client asks `accountInviteLinkAction` for the
  * sign-in link with the email the visitor gave already filled in, then shows
@@ -92,6 +99,7 @@ import type {
   FlowEndingOutcome,
   FlowState,
   FlowStepDeliverable,
+  WaitlistAnswers,
 } from "@working-theory/validation";
 import {
   deriveFlags,
@@ -107,6 +115,7 @@ import {
   pruneHiddenState,
   resolveLocalizedString,
   resolveThankYouSlug,
+  resolveTierThankYouSlug,
   selectFlowEndingOutcome,
   SITE_CONSENT_CONFIG_DEFAULTS,
   visitorNameOf,
@@ -202,12 +211,21 @@ function segmentationQuestionNames(config: FlowConfig): Set<string> {
 /**
  * #8840 D9 — the answers the ending is chosen from, assembled as the
  * permalink path assembles them: the visible steps' answers flattened, then
- * the hidden segmentation steps' `whenHidden` answers.
+ * the hidden segmentation steps' `whenHidden` answers. Narrowed to the
+ * evaluator's string / string[] shape (#10616), which is all any reader keeps.
  */
-function walkAnswers(config: FlowConfig, state: FlowState): Record<string, unknown> {
+function walkAnswers(config: FlowConfig, state: FlowState): WaitlistAnswers {
   const flags = deriveFlags(config, state);
   const flat = flattenState(pruneHiddenState(config, state, flags));
-  return Object.assign(flat, hiddenAnswers(config, state, flags));
+  const answers: WaitlistAnswers = {};
+  for (const [name, value] of Object.entries(
+    Object.assign(flat, hiddenAnswers(config, state, flags)),
+  )) {
+    if (typeof value === "string" || Array.isArray(value)) {
+      answers[name] = value as string | string[];
+    }
+  }
+  return answers;
 }
 
 export function FlowStepperClient({
@@ -225,6 +243,10 @@ export function FlowStepperClient({
   // client never routes to.
   const isRecommending =
     config.mode === "recommending" && config.offers !== undefined;
+  // #10616 D4 — a flow whose scoring maps at least one tier to a thank-you
+  // page: completion may redirect there, so `onCompleted` is passed.
+  const hasTierThankYou =
+    config.scoring?.tiers.some((tier) => tier.thankYou !== undefined) === true;
 
   // #4770 D1 — the client's own accumulated answers, written from the
   // RESOLVED result of onSubmitStep (never the inbound payload) so a
@@ -427,6 +449,18 @@ export function FlowStepperClient({
     segment?: string;
     aeoScore?: AeoScoreResult;
   }): void {
+    // #10616 D4 — a scored tier's thank-you page wins over the permalink and
+    // the `thankYou` block. Scored from the walk's answers as the server's
+    // completion payload assembles them; no flags are passed (the server
+    // scores with none).
+    if (hasTierThankYou) {
+      const tierSlug = resolveTierThankYouSlug(config, walkAnswers(config, answersRef.current));
+      if (tierSlug !== undefined) {
+        goToThanks(tierSlug);
+        return;
+      }
+    }
+
     if (isRecommending) {
       // D1 (hidden-step pruning) — apply the shipped visibility resolver to
       // the accumulated state before encoding, so an abandoned branch's
@@ -481,7 +515,12 @@ export function FlowStepperClient({
     }
 
     if (!thankYou) return;
-    const thankYouSlug = resolveThankYouSlug(thankYou, result.segment);
+    goToThanks(resolveThankYouSlug(thankYou, result.segment));
+  }
+
+  // The thank-you redirect's tail, shared by the `thankYou` block and a
+  // scored tier's slug (#10616 D4): the invite hand-off, then the push.
+  function goToThanks(thankYouSlug: string): void {
     // #8771 D5 — hand the link to /thanks through the per-tab sessionStorage,
     // never the URL; with no link, clear an earlier walk's so it never shows
     // on this page. A storage that throws gives no link.
@@ -587,7 +626,7 @@ export function FlowStepperClient({
       locale={locale}
       messages={messages}
       onSubmitStep={handleSubmitStep}
-      {...(!endingWins && (thankYou !== undefined || isRecommending)
+      {...(!endingWins && (thankYou !== undefined || isRecommending || hasTierThankYou)
         ? { onCompleted: handleCompleted }
         : {})}
       {...(completedAction !== undefined ? { completedAction } : {})}

package/templates/apps/web/app/[locale]/flows/[slug]/__tests__/FlowStepperClient.thanks-by-tier.test.tsx

@@ -0,0 +1,306 @@
+// oss: false
+/**
+ * Tests for FlowStepperClient's per-tier thank-you redirect on a scored
+ * recommending flow (#10616 D4).
+ *
+ * A SEPARATE file from the six existing `FlowStepperClient.*.test.tsx`
+ * suites, which stay UNEDITED as the AC-4 regression floor. It mocks
+ * `FlowStepper` the way `FlowStepperClient.permalink.test.tsx` does — a stub
+ * that captures the `onSubmitStep`/`onCompleted` props — because this file's
+ * scope is the client's own completion wiring, not the stepper.
+ *
+ * AC-3(b) — a finished walk whose scored tier carries a `thankYou` slug
+ *   pushes exactly `/<locale>/thanks/<slug>`, ahead of the results
+ *   permalink; the URL carries no submitted value, no segmentation answer
+ *   and no session id; an unknown locale falls back to the default.
+ * AC-3(a) — the client scores with EMPTY flags (the server's input), so a
+ *   flag-gated tier never wins even when the walk's own `flags` would set it.
+ * AC-3(c) — a flow with tier slugs but no `thankYou` and no `offers` still
+ *   receives `onCompleted`.
+ * AC-4 — a tier with no slug pushes today's permalink; a `thankYou`-only
+ *   flow pushes `thankYou.default`; an `ending` still wins (no `onCompleted`).
+ */
+import { render } from "@testing-library/react";
+import type { FlowConfig } from "@working-theory/validation";
+import { decodePermalink } from "@working-theory/validation";
+import type { ReactElement } from "react";
+
+const mockPush = jest.fn();
+jest.mock("next/navigation", () => ({
+  useRouter: () => ({ push: mockPush }),
+}));
+
+jest.mock("next-intl", () => ({
+  useTranslations: () => (key: string) => key,
+  useMessages: () => ({}),
+}));
+
+// FlowStepperClient binds onSubmitStep directly to this Server Action, and
+// the boundary under test here is the onCompleted -> router.push wiring, not
+// the action itself (covered by flow.actions.test.ts) — mirrors the sibling
+// suites' identical narrow-scope justification.
+// eslint-disable-next-line no-restricted-syntax -- see comment above
+jest.mock("../flow.actions", () => ({
+  submitFlowStepAction: jest.fn(),
+}));
+
+interface MockFlowStepperProps {
+  onSubmitStep: (payload: {
+    stepKey: string;
+    values: Record<string, unknown>;
+    locale?: string;
+  }) => Promise<{
+    ok: boolean;
+    kind?: string;
+    response?: { completed: boolean; segment?: string };
+  }>;
+  onCompleted?: (result: { segment?: string }) => void;
+}
+
+let captured: MockFlowStepperProps | undefined;
+
+jest.mock("@working-theory/ui-signal-collectors", () => ({
+  FlowStepper: (props: MockFlowStepperProps) => {
+    captured = props;
+    return require("react").createElement("div", {
+      "data-testid": "mock-flow-stepper",
+    }) as ReactElement;
+  },
+}));
+
+import { submitFlowStepAction } from "../flow.actions";
+import { FlowStepperClient } from "../FlowStepperClient";
+
+const mockSubmitFlowStepAction = submitFlowStepAction as jest.MockedFunction<
+  typeof submitFlowStepAction
+>;
+
+const SLUG = "founder-diagnostic";
+const SESSION_ID = "sess-1a2b3c";
+
+type Scoring = NonNullable<FlowConfig["scoring"]>;
+
+const PATH_A_ANSWERS = { revenue: "1m-plus", timing: "now" };
+const PATH_B_ANSWERS = { revenue: "under-500k", timing: "exploring" };
+const PII_PAYLOAD = {
+  email: "jane@example.com",
+  name: "Jane Doe",
+  phone: "555-123-4567",
+  message: "Please reach out about the enterprise plan as soon as possible",
+};
+
+/**
+ * path_a: revenue in the top bands AND timing not "exploring" — a rule over
+ * two answers, which `thankYou.bySegment` cannot express; path_b is the
+ * default. Each tier carries its own ThankYouPage slug.
+ */
+function tierScoring(): Scoring {
+  return {
+    version: 1,
+    points: [
+      {
+        name: "revenue_points",
+        question: "revenue",
+        kind: "optionWeights",
+        weights: { "under-500k": 0, "500k-1m": 1, "1m-plus": 2 },
+      },
+    ],
+    scores: { total: { sum: ["revenue_points"] } },
+    tiers: [
+      {
+        key: "path_a",
+        when: {
+          allOf: [
+            { answer: "revenue", in: ["500k-1m", "1m-plus"] },
+            { not: { answer: "timing", eq: "exploring" } },
+          ],
+        },
+        thankYou: "path-a-thanks",
+      },
+      { key: "path_b", when: { answer: "timing", eq: "exploring" }, thankYou: "path-b-thanks" },
+    ],
+    default: "path_b",
+  };
+}
+
+/** A recommending flow — `offers` plus the scoring above — whose field step
+ * submits an email, a name, a phone number and free text. */
+function scoredFlowConfig(overrides: Partial<FlowConfig> = {}): FlowConfig {
+  return {
+    slug: SLUG,
+    defaultLocale: "en",
+    mode: "recommending",
+    steps: [
+      {
+        key: "fit",
+        type: "segmentation",
+        copy: { title: { en: "Fit" } },
+        questions: [
+          {
+            name: "revenue",
+            options: [
+              { value: "under-500k", label: { en: "Under $500K" } },
+              { value: "500k-1m", label: { en: "$500K–$1M" } },
+              { value: "1m-plus", label: { en: "$1M+" } },
+            ],
+          },
+          {
+            name: "timing",
+            options: [
+              { value: "now", label: { en: "Now" } },
+              { value: "exploring", label: { en: "Just exploring" } },
+            ],
+          },
+        ],
+      },
+      {
+        key: "contact",
+        type: "field",
+        copy: { title: { en: "Contact" } },
+        fields: [
+          { name: "email", inputType: "email", required: true, copy: { label: { en: "Email" } } },
+          { name: "name", inputType: "text", required: true, copy: { label: { en: "Name" } } },
+          { name: "phone", inputType: "tel", copy: { label: { en: "Phone" } } },
+          { name: "message", inputType: "textarea", copy: { label: { en: "Message" } } },
+        ],
+      },
+    ],
+    offers: [
+      {
+        key: "call",
+        copy: { name: { en: "A call" } },
+        price: { kind: "label", label: { en: "Free" } },
+        rules: [{ when: { answer: "revenue", eq: "1m-plus" }, reason: { en: "Ready" } }],
+      },
+    ],
+    scoring: tierScoring(),
+    ...overrides,
+  } as FlowConfig;
+}
+
+/** Render the client, submit the segmentation step then the PII-laden field
+ * step (the second completing the walk), and fire `onCompleted`. */
+async function completeWalk(
+  config: FlowConfig,
+  answers: Record<string, string>,
+  locale = "en",
+): Promise<void> {
+  mockSubmitFlowStepAction
+    .mockResolvedValueOnce({
+      ok: true,
+      response: { sessionId: SESSION_ID, landed: "fit", nextStepKey: "contact", completed: false },
+    })
+    .mockResolvedValueOnce({
+      ok: true,
+      response: { sessionId: SESSION_ID, landed: "contact", nextStepKey: null, completed: true },
+    });
+
+  render(<FlowStepperClient config={config} locale={locale} slug={SLUG} />);
+
+  await captured!.onSubmitStep({ stepKey: "fit", values: answers, locale });
+  await captured!.onSubmitStep({ stepKey: "contact", values: PII_PAYLOAD, locale });
+  captured!.onCompleted?.({});
+}
+
+function pushedUrl(): string {
+  expect(mockPush).toHaveBeenCalledTimes(1);
+  return mockPush.mock.calls[0]?.[0] as string;
+}
+
+beforeEach(() => {
+  mockPush.mockClear();
+  mockSubmitFlowStepAction.mockClear();
+  captured = undefined;
+  window.sessionStorage.clear();
+});
+
+describe("FlowStepperClient — a scored tier's thank-you page replaces the permalink (#10616 AC-3(b))", () => {
+  it("path-A answers push exactly /en/thanks/path-a-thanks", async () => {
+    await completeWalk(scoredFlowConfig(), PATH_A_ANSWERS);
+    expect(pushedUrl()).toBe("/en/thanks/path-a-thanks");
+  });
+
+  it("path-B answers push exactly /en/thanks/path-b-thanks", async () => {
+    await completeWalk(scoredFlowConfig(), PATH_B_ANSWERS);
+    expect(pushedUrl()).toBe("/en/thanks/path-b-thanks");
+  });
+
+  it("the pushed URL carries no submitted value, no segmentation answer and no session id", async () => {
+    await completeWalk(scoredFlowConfig(), PATH_A_ANSWERS);
+    // The PII reached onSubmitStep (the wiring forwards real form data) —
+    // the assertion is that none of it reaches the push.
+    expect(mockSubmitFlowStepAction).toHaveBeenCalledWith(
+      SLUG,
+      expect.objectContaining({ values: PII_PAYLOAD }),
+    );
+    const url = pushedUrl();
+    expect(url).toMatch(/^\/[A-Za-z-]+\/thanks\/[a-z0-9-]+$/);
+    for (const value of [
+      ...Object.values(PII_PAYLOAD),
+      ...Object.values(PATH_A_ANSWERS),
+      SESSION_ID,
+    ]) {
+      expect(url).not.toContain(value);
+    }
+  });
+
+  it("an unknown [locale] falls back to the default locale before interpolation", async () => {
+    await completeWalk(scoredFlowConfig(), PATH_A_ANSWERS, "xx");
+    expect(pushedUrl()).toBe("/en/thanks/path-a-thanks");
+  });
+});
+
+describe("FlowStepperClient — the client scores with the server's empty flags (#10616 AC-3(a))", () => {
+  it("a flag-gated first tier never wins, even when the walk's own flags would set it", async () => {
+    const scoring = tierScoring();
+    scoring.tiers = [
+      { key: "flagged", when: { flag: "pre_launch" }, thankYou: "flagged-thanks" },
+      { key: "path_b", when: { answer: "timing", eq: "exploring" }, thankYou: "path-b-thanks" },
+    ];
+    const config = scoredFlowConfig({
+      flags: [{ name: "pre_launch", when: { answer: "timing", eq: "now" } }],
+      scoring,
+    });
+    await completeWalk(config, PATH_A_ANSWERS);
+    expect(pushedUrl()).toBe("/en/thanks/path-b-thanks");
+  });
+});
+
+describe("FlowStepperClient — onCompleted is supplied for a flow with tier slugs alone (#10616 AC-3(c))", () => {
+  it("mode recommending with scoring, no offers and no thankYou still receives onCompleted", () => {
+    const { offers: _offers, ...noOffers } = scoredFlowConfig();
+    render(<FlowStepperClient config={noOffers as FlowConfig} locale="en" slug={SLUG} />);
+    expect(captured?.onCompleted).toBeDefined();
+  });
+});
+
+describe("FlowStepperClient — no mapping is today's behavior (#10616 AC-4)", () => {
+  it("(a) a tier with no slug pushes the results permalink, decodable to the segmentation answers", async () => {
+    const scoring = tierScoring();
+    delete scoring.tiers[1]!.thankYou;
+    await completeWalk(scoredFlowConfig({ scoring }), PATH_B_ANSWERS);
+
+    const match = pushedUrl().match(new RegExp(`^/en/flows/${SLUG}/results/(.+)$`));
+    expect(match).not.toBeNull();
+    const decoded = decodePermalink(match![1]!);
+    expect(decoded.ok).toBe(true);
+    if (!decoded.ok) return;
+    expect(decoded.value.flowSlug).toBe(SLUG);
+    expect(decoded.value.answers).toEqual(PATH_B_ANSWERS);
+  });
+
+  it("(b) a thankYou-only flow with no scoring pushes thankYou.default", async () => {
+    const { mode: _mode, offers: _offers, scoring: _scoring, ...plain } = scoredFlowConfig();
+    const config = { ...plain, thankYou: { default: "flow-thanks" } } as FlowConfig;
+    await completeWalk(config, PATH_A_ANSWERS);
+    expect(pushedUrl()).toBe("/en/thanks/flow-thanks");
+  });
+
+  it("(c) a flow with an ending and tier slugs is passed no onCompleted", () => {
+    const config = scoredFlowConfig({
+      ending: { default: { kind: "screen", headline: { en: "Thanks" } } },
+    } as Partial<FlowConfig>);
+    render(<FlowStepperClient config={config} locale="en" slug={SLUG} />);
+    expect(captured?.onCompleted).toBeUndefined();
+  });
+});

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

@@ -25,10 +25,17 @@
 // every page in the tree (#4090 item 1).
 import "../globals.css";
 
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
 import { Telemetry, VerificationMeta } from "@working-theory/analytics";
+import {
+  SiteConsentSchema,
+  type ConsentAppearance,
+} from "@working-theory/site-config/schema";
 import { MarketingShell } from "@working-theory/templates/shells";
 import { themeToShellCss } from "@working-theory/theme";
-import { Link, isRtl, localeHref } from "@working-theory/ui";
+import { Link, NewsletterSignupProvider, isRtl, localeHref } from "@working-theory/ui";
 import { BRAND_PATHS, LocaleSwitcherNav } from "@working-theory/ui/blocks";
 import {
   Banner,
@@ -54,6 +61,7 @@ import { cookies, headers } from "next/headers";
 import { NextIntlClientProvider } from "next-intl";
 import { getMessages, getTranslations } from "next-intl/server";
 import type { ReactElement, ReactNode } from "react";
+import { parse as parseYaml } from "yaml";
 
 import { GoogleAnalytics } from "../../components/google-analytics";
 import {
@@ -71,6 +79,8 @@ import {
 import {
   inPageView,
   newsletterSignup,
+  type InPageView,
+  type NewsletterFormView,
   readCaptureStatus,
   readServedMagnet,
 } from "../../lib/in-page-magnet";
@@ -84,6 +94,7 @@ import { footerColumns, navItems } from "../../lib/nav-config";
 import { navMessageKeys, usedNavLabelKeys } from "../../lib/nav-label-keys";
 import { getOgImageUrl } from "../../lib/og";
 import {
+  readClosingFooterSettings,
   resolveChromePage,
   resolveHomeChrome,
   resolvePageChrome,
@@ -98,6 +109,7 @@ import {
   COPYRIGHT_HOLDER,
   SITE_DESCRIPTION,
   SITE_NAME,
+  resolveContentRoot,
 } from "../../lib/site-brand";
 import { siteChrome, type SiteChrome } from "../../lib/site-chrome";
 import {
@@ -209,6 +221,38 @@ async function resolveThemeMode(): Promise<ThemeMode> {
 const DECK_FIRST_SLIDE_SELECTOR =
   '.ailk-snap-deck .ailk-section-renderer > :not(.ailk-section-separator):not([data-section="separator"])';
 
+let warnedConsentAppearance = false;
+
+/**
+ * `_site.mdx`'s `consent.appearance` (#10555), else `undefined`. The same
+ * local frontmatter read as `lib/site-header.ts`, validated against the
+ * canonical schema. An absent file, frontmatter or key is silent; an invalid
+ * value warns once per process, naming the field path and never the value.
+ */
+function readConsentAppearance(): ConsentAppearance | undefined {
+  try {
+    const raw = readFileSync(join(resolveContentRoot(), "_site.mdx"), "utf8");
+    const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+    if (!match) return undefined;
+    const fm: unknown = parseYaml(match[1] ?? "");
+    if (!fm || typeof fm !== "object") return undefined;
+    const { consent } = fm as { consent?: unknown };
+    if (consent === undefined) return undefined;
+    const parsed = SiteConsentSchema.safeParse(consent);
+    if (parsed.success) return parsed.data.appearance;
+    if (!warnedConsentAppearance) {
+      warnedConsentAppearance = true;
+      const issue = parsed.error.issues[0];
+      console.warn(
+        `[layout] ignoring _site.mdx ${["consent", ...(issue?.path ?? [])].join(".")}: ${issue?.message ?? "invalid"}`,
+      );
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Whether this visitor has already accepted or declined cookies (#5557).
  *
@@ -300,12 +344,15 @@ interface Props {
 }
 
 /**
- * #8847 D13 — the footer's newsletter signup: the newsletter magnet's compact
- * `NewsletterFormInline`, only when the magnet is served (live), maps as a
- * one-field signup, and the API accepts signups. The seeded built-in config
- * never fills the footer. Both reads are shared for 15 seconds per instance.
+ * #8847 D13 — the newsletter magnet's view for the footer's signup, and
+ * (#10629 D4) for every bound `newsletter` section: only when the magnet is
+ * served (live), maps as a one-field signup, and the API accepts signups. The
+ * seeded built-in config never fills either. Both reads are shared for 15
+ * seconds per instance.
  */
-async function footerNewsletter(locale: string): Promise<ReactElement | undefined> {
+async function servedNewsletterView(
+  locale: string,
+): Promise<(InPageView & { form: NewsletterFormView }) | undefined> {
   const [magnet, status] = await Promise.all([
     readServedMagnet(NEWSLETTER_FLOW_SLUG),
     readCaptureStatus(),
@@ -313,11 +360,7 @@ async function footerNewsletter(locale: string): Promise<ReactElement | undefine
   if (magnet === null || status?.newsletter !== true) return undefined;
   const view = inPageView(magnet, locale, "newsletter");
   if (view === null || !("kind" in view.form)) return undefined;
-  return (
-    <div data-testid="footer-newsletter">
-      {newsletterSignup({ ...view, form: view.form }, { locale, compact: true })}
-    </div>
-  );
+  return { ...view, form: view.form };
 }
 
 export default async function LocaleLayout({
@@ -336,6 +379,11 @@ export default async function LocaleLayout({
   // #7742 D3/D5 — the minimal chrome: the closing slide, the hairline consent
   // bar and the cue offset.
   const isMinimalChrome = chrome.chromeStyle === "minimal";
+  // #10555 — `_site.mdx`'s `consent.appearance` picks the cookie notice's
+  // look; absent, the chrome does (hairline under minimal, else compact).
+  const isHairlineConsent =
+    (readConsentAppearance() ?? (isMinimalChrome ? "hairline" : "compact")) ===
+    "hairline";
   const consentDecided = await hasConsentChoice();
   // Server-side session read (#4984) — the same `auth.api.getSession` idiom
   // the `(authed)` segment guard uses, through the generated topology seam
@@ -343,7 +391,26 @@ export default async function LocaleLayout({
   // Null when signed out or auth is unset.
   const session = await readSession(await headers());
 
-  const footerSignup = await footerNewsletter(locale);
+  const newsletterView = await servedNewsletterView(locale);
+  // #8847 D13 — the footer's compact signup.
+  const footerSignup =
+    newsletterView === undefined ? undefined : (
+      <div data-testid="footer-newsletter">
+        {newsletterSignup(newsletterView, { locale, compact: true })}
+      </div>
+    );
+  // #10629 D4 — the full-size signup every bound `newsletter` section renders
+  // (as on /newsletter), with the on-submit consent gate. Both shell branches
+  // render the page under its provider, so a bound section on any page reads it.
+  const page = (
+    <NewsletterSignupProvider
+      {...(newsletterView !== undefined && {
+        signup: newsletterSignup(newsletterView, { locale, consentGate: "on-submit" }),
+      })}
+    >
+      {children}
+    </NewsletterSignupProvider>
+  );
 
   // Resolve nav labels server-side so Nav + Footer components stay
   // i18n-hook-free and are testable without a NextIntlClientProvider wrapper.
@@ -486,6 +553,22 @@ export default async function LocaleLayout({
   const deckFooterActions = session
     ? [{ labelKey: "account", path: "/account", variant: "outline-strong" as const }]
     : [...authActions];
+  // #10550 D4 — the closing footer's site settings: its locality line, its
+  // actions (the primary, then the secondary — they replace the auth links
+  // on the closing footer in every header state) and its legal bar. The
+  // site's labels ride `itemLabels` under keys no nav key can collide with
+  // (no nav key contains a dot).
+  const closingFooter = readClosingFooterSettings();
+  const closingFooterActions = closingFooter.actions?.map(
+    (action, i) => ({
+      labelKey: `closingFooter.action.${i}`,
+      path: action.href,
+      variant: i === 0 ? ("primary" as const) : ("ghost" as const),
+    }),
+  );
+  const closingFooterLabels = Object.fromEntries(
+    (closingFooter.actions ?? []).map((action, i) => [`closingFooter.action.${i}`, action.label]),
+  );
   // A bare inner page's auth (#7721 D3/D4) rides the one-bar footer's link
   // group: Sign in / Sign up signed out, Account signed in (where Sign out
   // lives). Labels from the existing `nav` namespace. Under a full header
@@ -788,7 +871,7 @@ export default async function LocaleLayout({
              * consent Banner below. The booking paths (#8843 D10) and a magnet
              * walk (#8840 D10) take it and keep the Banner.
              */
-            children
+            page
           ) : (
             <MarketingShell
               contentOwnsMain
@@ -925,13 +1008,23 @@ export default async function LocaleLayout({
                   // #10049 D5 — the style is `pageChrome.footer`, and every
                   // footer with an actions row takes the auth links when the
                   // header is not full.
+                  // #10550 D4 — a site's own `footer.locality`, `footer.actions`
+                  // and `footer.legalBar` set the closing footer's locality line,
+                  // its actions (in place of the auth links, whatever the header)
+                  // and its legal bar.
                   {...(pageChrome.footer === "closing"
                     ? {
                         layout: "closing" as const,
-                        contactLines: readSiteContactLines(),
-                        ...(!headerIsFull && !(isHome && isMinimalChrome)
-                          ? { actions: deckFooterActions }
-                          : {}),
+                        contactLines: readSiteContactLines(closingFooter.locality),
+                        ...(closingFooterActions !== undefined
+                          ? {
+                              actions: closingFooterActions,
+                              itemLabels: { ...navLabels.items, ...closingFooterLabels },
+                            }
+                          : !headerIsFull && !(isHome && isMinimalChrome)
+                            ? { actions: deckFooterActions }
+                            : {}),
+                        ...(closingFooter.legalBar ? { legalBar: true } : {}),
                       }
                     : pageChrome.footer === "line"
                       ? { layout: "line" as const, accountLinks }
@@ -967,7 +1060,7 @@ export default async function LocaleLayout({
                 )
               }
             >
-              {children}
+              {page}
             </MarketingShell>
           )}
           {/*
@@ -996,11 +1089,11 @@ export default async function LocaleLayout({
               consentCookieName={CONSENT_COOKIE_NAME}
               consentDecided={consentDecided}
               title={tConsent("title")}
-              // #9656 D7 — the standard chrome mounts the compact floating
-              // card on every width, its Privacy Policy link on the button
-              // row; the minimal chrome keeps its hairline band (#7742 D5),
-              // the statement with the link inline.
-              {...(isMinimalChrome
+              // #9656 D7 — the compact floating card on every width, its
+              // Privacy Policy link on the button row; the hairline band
+              // (#7742 D5), the statement with the link inline. #10555 —
+              // which one is `isHairlineConsent`'s, not the chrome's.
+              {...(isHairlineConsent
                 ? {
                     message: (
                       <>
@@ -1038,12 +1131,14 @@ export default async function LocaleLayout({
               // (`CONSENT_COOKIE_NAME`) stays the operative switch the
               // island itself still writes (C3).
               locale={locale}
-              // #7742 D5 — the minimal chrome's consent bar: the page ground,
-              // a hairline, no shadow.
-              {...(isMinimalChrome ? { consentAppearance: "hairline" as const } : {})}
+              // #7742 D5 — the hairline consent bar: the page ground, a
+              // hairline, no shadow.
+              {...(isHairlineConsent ? { consentAppearance: "hairline" as const } : {})}
               // #7782 — on the minimal deck home the bar first shows once the
               // first slide has left view; every other page shows it on load.
-              {...(isDeckHome && isMinimalChrome
+              // #10721 — the bar's alone: a minimal site that picks the card
+              // (`consent.appearance: compact`) shows it on load there too.
+              {...(isDeckHome && isMinimalChrome && isHairlineConsent
                 ? { consentRevealAfter: DECK_FIRST_SLIDE_SELECTOR }
                 : {})}
             />