create-ailk 0.22.0 → 0.24.0

package/templates/apps/web/app/[locale]/flows/[slug]/magnet-page.tsx

@@ -0,0 +1,369 @@
+// oss: false
+/**
+ * magnet-page.tsx — the standard magnet page pair (#8840 D8).
+ *
+ * Every multi-step magnet is two pages, the canon's #5053 split moved to the
+ * magnet's own path: an indexable LANDING (`/<magnet>`, inside the site's
+ * chrome — a centred hero of the flow record's `landing` copy, a CTA to
+ * `/<magnet>/start`, and the `Assessment` page type's single-layer
+ * `WebApplication` JSON-LD) and a `noindex, follow` WALK (`/<magnet>/start`,
+ * or the `startPath` a landing names, as `/trial` names `/trial/request` —
+ * #9287 DD10; chrome-free by `lib/magnet-routes.ts`, the back arrow alone
+ * above step 1).
+ * This module is the only code that renders either half: `/flows/<slug>`,
+ * the careers apply pages and every pair `create-ailk add-route magnet`
+ * writes are callers of the factories below.
+ *
+ * The read: one `flows.get(slug)` shared per server instance for 15 seconds
+ * per slug (the /contact idiom, #8731), so a page's metadata, its body and a
+ * burst of views make one hub read. A slug the schema refuses is `absent`
+ * with no read and no cache entry, each insert first drops the stale
+ * entries, and the map holds at most 256 slugs, so random URLs cannot grow
+ * it (SEC-8840-G). A refused
+ * connection or a 5xx is `unavailable`: both pages then show the site's
+ * contact email instead of a 500, are `noindex`, and retry nothing. A site
+ * with no hub to ask — the read answers 503 `flows_not_configured`, or a
+ * failed read with no API origin configured — is `not-configured` (#9219);
+ * a pair renders it as `unavailable`, and `/reports/<slug>` uses it to 404
+ * an unknown slug where a hub outage shows the contact email; a landing that
+ * passes `notFoundWhenNotConfigured` (`/trial`, #9423) 404s on it too. A walk
+ * that exists apart from its flow (`/careers/apply`) passes a `title`: its
+ * fallback then carries that page heading, and an absent flow renders the
+ * same fallback rather than a 404 (#9219).
+ *
+ * A flow whose served config carries a `deliverable` (#8848 D7) has one
+ * route, `/reports/<slug>`: both halves redirect there (307) before
+ * rendering anything, so `/flows/<slug>` and every `add-route magnet` pair
+ * hand it over and an ungated deliverable never gets a form here. The
+ * deliverable's own walk calls `renderMagnetStart` with `asDeliverable`.
+ */
+import { flows } from "@working-theory/api-client";
+import { JsonLd } from "@working-theory/jsonld";
+import { flowRouteMetadata } from "@working-theory/metadata";
+import { buildJsonLd } from "@working-theory/schema";
+import { ContactFallback, Container, Heading, localeHref } from "@working-theory/ui";
+import { NavBackLink } from "@working-theory/ui/chrome";
+import { SectionRenderer } from "@working-theory/ui/sections";
+import type { FlowConfig, PageSection } from "@working-theory/validation";
+import { flowSlugSchema, resolveLocalizedString } from "@working-theory/validation";
+import type { Metadata } from "next";
+import { notFound, redirect } from "next/navigation";
+import { getTranslations } from "next-intl/server";
+import type { ReactElement } from "react";
+
+import { readSiteContactEmail } from "../../contact/site-contact-email";
+
+import { FlowStepperClient } from "./FlowStepperClient";
+
+/** The marker every standard magnet page carries in its header comment (D13). */
+export const MAGNET_PAGE_MARKER = "Standard magnet page (#8840)";
+
+/** How long one slug's read is shared across requests (/contact's #8731 value). */
+const MAGNET_READ_TTL_MS = 15_000;
+
+/** At most this many slugs are held at once; past it a read is not shared. */
+const MAGNET_READ_MAX_ENTRIES = 256;
+
+export type MagnetRead =
+  | { kind: "ok"; config: FlowConfig }
+  | { kind: "absent" }
+  | { kind: "unavailable" }
+  | { kind: "not-configured" };
+
+const magnetReads = new Map<string, { at: number; read: Promise<MagnetRead> }>();
+
+/**
+ * Whether an API origin is configured: the three names `getApiBase()` in
+ * packages/api-client/src/http.ts reads, in step with it (as `/pricing`
+ * checks them). Without one that function answers `localhost:3001`.
+ */
+function apiOriginConfigured(): boolean {
+  return Boolean(
+    process.env.AILK_API_URL ||
+    process.env.NEXT_PUBLIC_AILK_API_URL ||
+    process.env.NEXT_PUBLIC_API_URL,
+  );
+}
+
+/** The flows route's own answer when its hub has no database (apps/api `flows_not_configured`). */
+function isFlowsNotConfigured(body: unknown): boolean {
+  const error = (body as { error?: { code?: unknown } } | null)?.error;
+  return error?.code === "flows_not_configured";
+}
+
+/** A read that failed: `not-configured` when there is no hub to ask, else `unavailable`. */
+function failedRead(): MagnetRead {
+  return apiOriginConfigured() ? { kind: "unavailable" } : { kind: "not-configured" };
+}
+
+async function fetchMagnet(slug: string): Promise<MagnetRead> {
+  try {
+    const res = await flows.get(slug);
+    if (res.ok) return { kind: "ok", config: res.body };
+    if (res.status === 503 && isFlowsNotConfigured(res.body)) return { kind: "not-configured" };
+    return res.status >= 500 ? failedRead() : { kind: "absent" };
+  } catch {
+    return failedRead();
+  }
+}
+
+/** The served flow config for `slug`, shared per instance for 15 seconds. */
+export function readMagnet(slug: string): Promise<MagnetRead> {
+  if (!flowSlugSchema.safeParse(slug).success) {
+    return Promise.resolve({ kind: "absent" });
+  }
+  const now = Date.now();
+  const hit = magnetReads.get(slug);
+  if (hit && now - hit.at < MAGNET_READ_TTL_MS) return hit.read;
+  for (const [key, entry] of magnetReads) {
+    if (now - entry.at >= MAGNET_READ_TTL_MS) magnetReads.delete(key);
+  }
+  const read = fetchMagnet(slug);
+  if (magnetReads.size < MAGNET_READ_MAX_ENTRIES) magnetReads.set(slug, { at: now, read });
+  return read;
+}
+
+/** The landing's title and line: the record's `landing` copy, else today's. */
+async function landingCopy(
+  config: FlowConfig,
+  locale: string,
+): Promise<{ title: string; description: string; meta?: string; cta: string }> {
+  const t = await getTranslations({ locale, namespace: "flow" });
+  const pick = (value: Record<string, string> | undefined): string | undefined =>
+    value === undefined ? undefined : resolveLocalizedString(value, locale, config.defaultLocale);
+  const { landing } = config;
+  const meta = pick(landing?.meta);
+  return {
+    title: pick(landing?.title) ?? pick(config.steps[0]!.copy.title)!,
+    description: pick(landing?.description) ?? t("landingIntro"),
+    ...(meta !== undefined ? { meta } : {}),
+    cta: pick(landing?.cta) ?? t("getStarted"),
+  };
+}
+
+/**
+ * The site's contact email in place of a magnet the hub cannot serve (D8).
+ * With a `title`, the page's own `<h1>` sits above it (#9219).
+ */
+export async function magnetUnavailable(locale: string, title?: string): Promise<ReactElement> {
+  const t = await getTranslations({ locale, namespace: "flow" });
+  return (
+    <Container className="py-section">
+      <div className="mx-auto max-w-container-sm">
+        {title !== undefined ? (
+          <Heading level={1} className="mb-block-tight">
+            {title}
+          </Heading>
+        ) : null}
+        <ContactFallback
+          email={readSiteContactEmail()}
+          text={{
+            heading: t("unavailableHeading"),
+            body: t("unavailableBody"),
+            noEmail: t("unavailableNoEmail"),
+          }}
+        />
+      </div>
+    </Container>
+  );
+}
+
+export interface MagnetLandingInput {
+  slug: string;
+  /** The landing's own path, e.g. `/diagnostic`; the CTA goes to `<path>/start`. */
+  path: string;
+  locale: string;
+  /** #9287 DD10 — the walk's path when it is not `<path>/start` (`/trial/request`). */
+  startPath?: string;
+  /**
+   * #9423 — a landing that exists only to sell its hub's flow (`/trial`) is a
+   * 404 on a site with no hub to ask (`not-configured`), as `/reports/<slug>`
+   * is (#9219). A configured hub that cannot answer still shows the contact
+   * email.
+   */
+  notFoundWhenNotConfigured?: boolean;
+}
+
+/** The indexable landing of a magnet pair (D8). */
+export async function renderMagnetLanding({
+  slug,
+  path,
+  locale,
+  startPath = `${path}/start`,
+  notFoundWhenNotConfigured = false,
+}: MagnetLandingInput): Promise<ReactElement> {
+  const read = await readMagnet(slug);
+  if (read.kind === "absent") notFound();
+  if (read.kind === "not-configured" && notFoundWhenNotConfigured) notFound();
+  if (read.kind !== "ok") return magnetUnavailable(locale);
+  // #8848 D7 — a deliverable's one route.
+  if (read.config.deliverable !== undefined) redirect(localeHref(locale, `/reports/${slug}`));
+
+  const copy = await landingCopy(read.config, locale);
+  const sections: PageSection[] = [
+    {
+      id: "flow-landing-hero",
+      type: "hero",
+      data: {
+        variant: "centered",
+        headline: copy.title,
+        subheadline: copy.description,
+        ...(copy.meta !== undefined ? { body: copy.meta } : {}),
+        primaryCta: { label: copy.cta, href: localeHref(locale, startPath) },
+      },
+    },
+  ];
+
+  return (
+    <>
+      <JsonLd
+        schema={buildJsonLd({
+          type: "Assessment",
+          slug: read.config.slug,
+          title: copy.title,
+          description: copy.description,
+          locale,
+        })}
+      />
+      <main>
+        <SectionRenderer sections={sections} locale={locale} />
+      </main>
+    </>
+  );
+}
+
+/** The landing's metadata: indexable under the site's own rule; a fallback never is. */
+export async function renderMagnetLandingMetadata({
+  slug,
+  locale,
+  notFoundWhenNotConfigured = false,
+}: Pick<MagnetLandingInput, "slug" | "locale" | "notFoundWhenNotConfigured">): Promise<Metadata> {
+  const read = await readMagnet(slug);
+  if (read.kind === "absent") return {};
+  if (read.kind === "not-configured" && notFoundWhenNotConfigured) return {};
+  if (read.kind !== "ok") return flowRouteMetadata();
+  const copy = await landingCopy(read.config, locale);
+  return { title: copy.title, description: copy.description };
+}
+
+export interface MagnetStartInput {
+  slug: string;
+  locale: string;
+  /** Where the back arrow goes, unlocalized (the landing, or the posting). */
+  backHref: string;
+  /** Page-supplied `hidden` field values (a posting's slug as `job`). */
+  hiddenValues?: Readonly<Record<string, string>>;
+  /** Replaces step 1's title at every locale it holds (a posting's title). */
+  firstStepTitle?: string;
+  /** #8848 D7 — the deliverable's own walk (`/reports/<slug>/start`): no redirect. */
+  asDeliverable?: boolean;
+  /**
+   * #9219 — a walk that exists apart from its flow (`/careers/apply`): the
+   * `<h1>` of its fallback, which an absent flow renders too, never a 404.
+   */
+  title?: string;
+}
+
+function withFirstStepTitle(config: FlowConfig, title: string): FlowConfig {
+  const [first, ...rest] = config.steps;
+  if (!first) return config;
+  const titled = Object.fromEntries(Object.keys(first.copy.title).map((key) => [key, title]));
+  return { ...config, steps: [{ ...first, copy: { ...first.copy, title: titled } }, ...rest] };
+}
+
+/** The chrome-free, noindex walk of a magnet pair (D8). */
+export async function renderMagnetStart({
+  slug,
+  locale,
+  backHref,
+  hiddenValues,
+  firstStepTitle,
+  asDeliverable = false,
+  title,
+}: MagnetStartInput): Promise<ReactElement> {
+  const read = await readMagnet(slug);
+  if (read.kind === "absent" && title === undefined) notFound();
+  if (read.kind === "ok" && read.config.deliverable !== undefined && !asDeliverable) {
+    redirect(localeHref(locale, `/reports/${slug}/start`));
+  }
+  const t = await getTranslations({ locale, namespace: "flow" });
+  const back = <NavBackLink href={localeHref(locale, backHref)} label={t("back")} />;
+  if (read.kind !== "ok") {
+    return (
+      <>
+        <div className="px-control-x pt-control-y">{back}</div>
+        {await magnetUnavailable(locale, title)}
+      </>
+    );
+  }
+
+  const config =
+    firstStepTitle !== undefined ? withFirstStepTitle(read.config, firstStepTitle) : read.config;
+  return (
+    <FlowStepperClient
+      config={config}
+      locale={locale}
+      slug={read.config.slug}
+      header={back}
+      {...(hiddenValues !== undefined ? { hiddenValues } : {})}
+    />
+  );
+}
+
+/** The walk's metadata: always `noindex, follow` (`flowRouteMetadata`). */
+export async function renderMagnetStartMetadata({
+  slug,
+  locale,
+  firstStepTitle,
+  title,
+}: Pick<MagnetStartInput, "slug" | "locale" | "firstStepTitle" | "title">): Promise<Metadata> {
+  const read = await readMagnet(slug);
+  if (read.kind !== "ok") return flowRouteMetadata(title !== undefined ? { title } : {});
+  const firstStep = read.config.steps[0];
+  if (!firstStep) return flowRouteMetadata();
+  return flowRouteMetadata({
+    title:
+      firstStepTitle ??
+      resolveLocalizedString(firstStep.copy.title, locale, read.config.defaultLocale),
+  });
+}
+
+// ─── Factories for a pair at a path (D8, D12) ──────────────────────────────
+
+/** A magnet pair: the flow it walks, and the landing's own path. */
+export interface MagnetRef {
+  slug: string;
+  path: string;
+}
+
+interface MagnetPageProps {
+  params: Promise<{ locale: string }>;
+}
+
+export function magnetLanding(ref: MagnetRef) {
+  return async function MagnetLandingPage({ params }: MagnetPageProps): Promise<ReactElement> {
+    const { locale } = await params;
+    return renderMagnetLanding({ slug: ref.slug, path: ref.path, locale });
+  };
+}
+
+export function magnetLandingMetadata(ref: MagnetRef) {
+  return async function generateMetadata({ params }: MagnetPageProps): Promise<Metadata> {
+    const { locale } = await params;
+    return renderMagnetLandingMetadata({ slug: ref.slug, locale });
+  };
+}
+
+export function magnetStart(ref: MagnetRef) {
+  return async function MagnetStartPage({ params }: MagnetPageProps): Promise<ReactElement> {
+    const { locale } = await params;
+    return renderMagnetStart({ slug: ref.slug, locale, backHref: ref.path });
+  };
+}
+
+export function magnetStartMetadata(ref: MagnetRef) {
+  return async function generateMetadata({ params }: MagnetPageProps): Promise<Metadata> {
+    const { locale } = await params;
+    return renderMagnetStartMetadata({ slug: ref.slug, locale });
+  };
+}

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

@@ -1,6 +1,8 @@
 // oss: false
 /**
- * /[locale]/flows/[slug] — the tool's LANDING route (#5053 D3/D5).
+ * /[locale]/flows/[slug] — the tool's LANDING route (#5053 D3/D5). Standard
+ * magnet page (#8840): rendered by `magnet-page.tsx`'s `renderMagnetLanding`
+ * with the pair's path `/flows/<slug>`.
  *
  * An interactive tool is TWO routes. This is the indexed half: the document
  * that describes the tool, carries its structured data, and links to the
@@ -18,92 +20,29 @@
  * resting on #5019, which names `assessment` and `calculator` among the
  * builders that keep that shape byte for byte).
  *
- * Copy: a served `FlowConfig` carries no tool-level name or description, so
- * the landing derives its name from the flow's own first-step title — the
- * same string this route already used as its page title before the split —
- * and takes its supporting line and CTA label from the site's `flow`
- * message namespace. No consuming site's wording ships here.
- *
- * Same `flows.get` fetch and same 404-on-`!res.ok` as the flow route: a flow
- * that is absent or unconfigured has no landing either. Dynamic rendering
- * for the same reason — the config is DB-backed live data.
+ * Copy (#8840 D8): the flow record's `landing` block — its title, line, meta
+ * line and button — else the flow's own first-step title and the site's
+ * `flow` messages. No consuming site's wording ships here. A flow that is
+ * absent has no landing either; a hub that cannot be reached shows the site's
+ * contact email. Dynamic rendering — the config is DB-backed live data.
  */
-import { flows } from "@working-theory/api-client";
-import { JsonLd } from "@working-theory/jsonld";
-import { buildJsonLd } from "@working-theory/schema";
-import { SectionRenderer } from "@working-theory/ui/sections";
-import type { FlowConfig, PageSection } from "@working-theory/validation";
-import { resolveLocalizedString } from "@working-theory/validation";
 import type { Metadata } from "next";
-import { notFound } from "next/navigation";
-import { getTranslations } from "next-intl/server";
 import type { ReactElement } from "react";
 
+import { renderMagnetLanding, renderMagnetLandingMetadata } from "./magnet-page";
+
 export const dynamic = "force-dynamic";
 
 interface Props {
   params: Promise<{ locale: string; slug: string }>;
 }
 
-/** The tool's name — the flow's own first-step title in the active locale. */
-function toolName(config: FlowConfig, locale: string): string {
-  return resolveLocalizedString(
-    config.steps[0]!.copy.title,
-    locale,
-    config.defaultLocale,
-  );
-}
-
 export async function generateMetadata({ params }: Props): Promise<Metadata> {
   const { locale, slug } = await params;
-  const res = await flows.get(slug);
-  if (!res.ok) return {};
-
-  const t = await getTranslations({ locale, namespace: "flow" });
-  return {
-    title: toolName(res.body, locale),
-    description: t("landingIntro"),
-  };
+  return renderMagnetLandingMetadata({ slug, locale });
 }
 
 export default async function Page({ params }: Props): Promise<ReactElement> {
   const { locale, slug } = await params;
-  const res = await flows.get(slug);
-  if (!res.ok) {
-    notFound();
-  }
-
-  const t = await getTranslations({ locale, namespace: "flow" });
-  const name = toolName(res.body, locale);
-  const intro = t("landingIntro");
-  const startHref = `/flows/${res.body.slug}/start`;
-
-  const sections: PageSection[] = [
-    {
-      id: "flow-landing-hero",
-      type: "hero",
-      data: {
-        headline: name,
-        subheadline: intro,
-        primaryCta: { label: t("getStarted"), href: startHref },
-      },
-    },
-  ];
-
-  return (
-    <>
-      <JsonLd
-        schema={buildJsonLd({
-          type: "Assessment",
-          slug: res.body.slug,
-          title: name,
-          description: intro,
-          locale,
-        })}
-      />
-      <main>
-        <SectionRenderer sections={sections} locale={locale} />
-      </main>
-    </>
-  );
+  return renderMagnetLanding({ slug, path: `/flows/${slug}`, locale });
 }

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

@@ -1,23 +1,19 @@
 // oss: false
 /**
  * /[locale]/flows/[slug]/start — the flow half of the two-route tool
- * (#5053 D3/D5). Moved here from `../page.tsx`, which is now the indexed
- * landing; the fetch, the 404-on-`!res.ok` and the dynamic rendering are
- * unchanged from #3957 D8.
+ * (#5053 D3/D5). Standard magnet page (#8840): rendered by
+ * `magnet-page.tsx`'s `renderMagnetStart`, chrome-free with the back arrow to
+ * `/flows/<slug>` (`lib/magnet-routes.ts`).
  *
- * `flowRouteMetadata` (`@working-theory/metadata`) supplies `noindex,
- * follow` — the whole point of D4 is that this route does NOT write the
- * robots value, it gets it from what it mounts. `follow`, not `nofollow`:
- * the links out of a flow still carry.
+ * `flowRouteMetadata` (`@working-theory/metadata`, mounted by the renderer)
+ * supplies `noindex, follow` — the whole point of D4 is that this route does
+ * NOT write the robots value, it gets it from what it mounts. `follow`, not
+ * `nofollow`: the links out of a flow still carry.
  */
-import { flows } from "@working-theory/api-client";
-import { flowRouteMetadata } from "@working-theory/metadata";
-import { resolveLocalizedString } from "@working-theory/validation";
 import type { Metadata } from "next";
-import { notFound } from "next/navigation";
 import type { ReactElement } from "react";
 
-import { FlowStepperClient } from "../FlowStepperClient";
+import { renderMagnetStart, renderMagnetStartMetadata } from "../magnet-page";
 
 export const dynamic = "force-dynamic";
 
@@ -27,27 +23,10 @@ interface Props {
 
 export async function generateMetadata({ params }: Props): Promise<Metadata> {
   const { locale, slug } = await params;
-  const res = await flows.get(slug);
-  if (!res.ok) return flowRouteMetadata();
-
-  const firstStep = res.body.steps[0];
-  if (!firstStep) return flowRouteMetadata();
-
-  return flowRouteMetadata({
-    title: resolveLocalizedString(
-      firstStep.copy.title,
-      locale,
-      res.body.defaultLocale,
-    ),
-  });
+  return renderMagnetStartMetadata({ slug, locale });
 }
 
 export default async function Page({ params }: Props): Promise<ReactElement> {
   const { locale, slug } = await params;
-  const res = await flows.get(slug);
-  if (!res.ok) {
-    notFound();
-  }
-
-  return <FlowStepperClient config={res.body} locale={locale} slug={slug} />;
+  return renderMagnetStart({ slug, locale, backHref: `/flows/${slug}` });
 }

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

@@ -39,6 +39,7 @@ import {
 } from "@working-theory/ui/chrome";
 import {
   cookiePurpose,
+  NEWSLETTER_FLOW_SLUG,
   resolveConsentStatement,
   SITE_CONSENT_CONFIG_DEFAULTS,
 } from "@working-theory/validation";
@@ -58,13 +59,21 @@ import {
   SignedInNav,
   type SignedInNavProps,
 } from "../../components/signed-in-nav";
-import { isAccountPath, isAuthPath } from "../../lib/auth-routes";
+import { isAccountPath, isAuthPath, isBookingPath } from "../../lib/auth-routes";
 import { isClosingFooterPath } from "../../lib/closing-footer-path";
+import { pageOptsIntoDeck } from "../../lib/deck-page";
+import {
+  inPageView,
+  newsletterSignup,
+  readCaptureStatus,
+  readServedMagnet,
+} from "../../lib/in-page-magnet";
 // #8687 D5 — the per-page deck opt-in. Importing this module registers the
 // deck-page seam with page-renderer at module load (D3), the same
 // precedent as `../../lib/site-identity` and `../../lib/listings` below.
-import { pageOptsIntoDeck } from "../../lib/deck-page";
 import { assertEnabledLocale } from "../../lib/locale-guard";
+import { isMagnetWalkPath } from "../../lib/magnet-routes";
+import { SCHEDULING_PAGES } from "../../lib/modules.generated";
 import { footerColumns, navItems } from "../../lib/nav-config";
 import { getOgImageUrl } from "../../lib/og";
 import { backLinkHref } from "../../lib/profile-back-link";
@@ -268,6 +277,27 @@ interface Props {
   params: Promise<{ locale: string }>;
 }
 
+/**
+ * #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.
+ */
+async function footerNewsletter(locale: string): Promise<ReactElement | undefined> {
+  const [magnet, status] = await Promise.all([
+    readServedMagnet(NEWSLETTER_FLOW_SLUG),
+    readCaptureStatus(),
+  ]);
+  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>
+  );
+}
+
 export default async function LocaleLayout({
   children,
   params,
@@ -291,6 +321,8 @@ export default async function LocaleLayout({
   // Null when signed out or auth is unset.
   const session = await readSession(await headers());
 
+  const footerSignup = await footerNewsletter(locale);
+
   // Resolve nav labels server-side so Nav + Footer components stay
   // i18n-hook-free and are testable without a NextIntlClientProvider wrapper.
   const tNav = await getTranslations({ locale, namespace: "nav" });
@@ -531,6 +563,22 @@ export default async function LocaleLayout({
   // fail-safe direction: an absent `x-pathname` keeps the full frame.
   const isAccountRoute = isAccountPath(pathname, enabledLocales);
 
+  // The booking branch (#8843 D10) — the scheduling module's /meet,
+  // /meet/<slug> and /private render chrome-free: the page draws its own
+  // back link (the index) or none (a meeting page). Only where the module is
+  // installed (`SCHEDULING_PAGES`), so a Free site's /meet placeholder keeps
+  // the marketing frame; /meet/confirmed keeps it too. The consent Banner
+  // stays, as on the auth branch. The same fail-safe direction: an absent
+  // `x-pathname` keeps the full frame.
+  const isBookingRoute = SCHEDULING_PAGES && isBookingPath(pathname, enabledLocales);
+
+  // #8840 D10 — a magnet's walk (`/<magnet>/start`, `/careers/apply`,
+  // `/careers/<posting>/apply`) renders full-screen: the auth branch's frame,
+  // no Nav and no Footer, and it KEEPS the cookie consent banner — a visitor
+  // can land straight on a walk, and analytics must not run on a page that
+  // never asked (SEC-8840-A). The same fail-safe direction.
+  const isMagnetWalkRoute = isMagnetWalkPath(pathname, enabledLocales);
+
   // #8687 D5 — a page whose frontmatter says `layout: deck` presents as the
   // deck home does, without the home's landing (no deckHero, no bare bar).
   // Never the home itself, and never on the auth or account branches, which
@@ -539,6 +587,7 @@ export default async function LocaleLayout({
     !isDeckHome &&
     !isAuthRoute &&
     !isAccountRoute &&
+    !isMagnetWalkRoute &&
     (await pageOptsIntoDeck({ pathname, locale }));
 
   // Every Nav prop that is safe to serialize — shared verbatim by the
@@ -717,7 +766,7 @@ export default async function LocaleLayout({
            * emitted unconditionally in OSS forks; paying customers install
            * @working-theory/branding and gate it in their own layout.
            */}
-          {isAuthRoute || isAccountRoute ? (
+          {isAuthRoute || isAccountRoute || isBookingRoute || isMagnetWalkRoute ? (
             /*
              * The (auth) branch (#5963): the five auth paths render their own
              * `(auth)/layout.tsx` — AuthShell — with no Nav and no marketing
@@ -726,7 +775,8 @@ export default async function LocaleLayout({
              * favicons, NextIntlClientProvider, the consent Banner and
              * Telemetry) is shared by both branches and written once. The
              * account paths (#7430) take this branch too, and also skip the
-             * consent Banner below.
+             * consent Banner below. The booking paths (#8843 D10) and a magnet
+             * walk (#8840 D10) take it and keep the Banner.
              */
             children
           ) : (
@@ -869,6 +919,7 @@ export default async function LocaleLayout({
                   {...(isMinimalChrome ? { chromeStyle: "minimal" as const } : {})}
                   // #7742 D2 — no theme switch under `colorMode: light`.
                   showThemeToggle={!pinLight}
+                  {...(footerSignup !== undefined && { subscribe: footerSignup })}
                   bottomBarAlign="content"
                   copyrightText={copyrightText}
                   legalLinks={legalLinks}