create-ailk 0.20.0 → 0.22.0

package/templates/apps/web/lib/__tests__/structured-data.test.tsx

@@ -240,10 +240,12 @@ describe("structured data — every content page builds valid JSON-LD", () => {
     "content/$locale/$typeDir — every page validates as its type",
     async ({ locale, typeDir }) => {
       if (!(SCHEMA_ORG_TYPES as readonly string[]).includes(typeDir)) {
-        // Identity + sub-entity types (Organization, Person, BreadcrumbList,
+        // Identity + sub-entity types (Organization, BreadcrumbList,
         // ContactPoint) hold sub-objects other pages' builders embed — never
         // rendered as pages, and skipped by tools/content-compile the same
-        // way. Anything else is a directory nothing will ever render.
+        // way. Anything else is a directory nothing will ever render. Person
+        // (#8650) is a registered page type (`/about/<slug>`), so it is
+        // covered by the SCHEMA_ORG_TYPES branch above, not this one.
         if (!knownSchemaOrgTypes.has(typeDir)) {
           throw new Error(
             `content/${locale}/${typeDir}: "${typeDir}" is not a registered page type — no route or builder will ever render it (see packages/content-adapters/src/types.ts SCHEMA_ORG_TYPES)`,
@@ -295,11 +297,13 @@ describe("structured data — every content page builds valid JSON-LD", () => {
  * exempt route whose page.tsx does render through `renderPage` fails too,
  * because the reason given for it is false.
  */
-// Literal, not imported: apps/web does not depend on create-ailk (the import
-// boundary). Mirrors packages/create-ailk/src/spoke-checkout.ts's
-// SPOKE_CHECKOUT_PAGE_MARKER; packages/create-ailk/__tests__/
-// spoke-checkout.test.ts pins the two in sync (#8513 AC-5).
-const CHECKOUT_PAGE_MARKER = "GENERATED by create-ailk (#7838)";
+// The marker both standard spoke checkout pages carry in their header comment
+// (apps/web/app/[locale]/checkout/{thank-you,unavailable}/page.tsx, #8748 D5).
+const CHECKOUT_PAGE_MARKER = "Standard spoke checkout page (#8748)";
+// The marker create-ailk rendered before #8748. A spoke scaffolded then keeps
+// its rendered pages through `create-ailk update` (they are not in its
+// record), so its updated copy of this test must still exempt them.
+const LEGACY_CHECKOUT_PAGE_MARKER = "GENERATED by create-ailk (#7838)";
 const CHECKOUT_PAGE_NOINDEX_LINE = "robots: { index: false, follow: false }";
 
 const NO_STRUCTURED_DATA_ROUTES: ReadonlyArray<{
@@ -311,9 +315,10 @@ const NO_STRUCTURED_DATA_ROUTES: ReadonlyArray<{
    * entry naming no strings applies to its route unconditionally, as every
    * entry did before. Keys the exemption on the file, not the topology seam:
    * a spoke can carry a hand-written page at this route, and a site can
-   * edit the generated one — either is checked like any other route.
+   * edit the generated one — either is checked like any other route. A
+   * nested list is any one of its strings.
    */
-  requires?: readonly string[];
+  requires?: ReadonlyArray<string | readonly string[]>;
 }> = [
   // Fumadocs routes: JSON-LD is emitted by @working-theory/fumadocs-schema
   // from the fumadocs `.source` collection, which is not built in this
@@ -386,22 +391,28 @@ const NO_STRUCTURED_DATA_ROUTES: ReadonlyArray<{
     reason: "auth surfaces, not content pages",
     subtree: true,
   },
-  // #8513 — a spoke carrying commerce gets two generated checkout return
-  // pages (create-ailk #7838): noindex, rendered through SectionRenderer
-  // directly, no JSON-LD. Exempt only when the page on disk still carries
-  // both the generated marker and the noindex line (see `requires` above) —
-  // a hand-written or edited page at either route is checked like any other.
+  // #8513 — the two standard spoke checkout return pages (#8748 D5):
+  // noindex, rendered through SectionRenderer directly, no JSON-LD. Exempt
+  // only when the page on disk still carries both the standard's marker and
+  // the noindex line (see `requires` above) — a hand-written or edited page
+  // at either route is checked like any other.
   {
     route: "checkout/thank-you",
     reason:
-      "spoke checkout return page (create-ailk #7838) — noindex, renders sections only, no JSON-LD",
-    requires: [CHECKOUT_PAGE_MARKER, CHECKOUT_PAGE_NOINDEX_LINE],
+      "spoke checkout return page (#8748) — noindex, renders sections only, no JSON-LD",
+    requires: [
+      [CHECKOUT_PAGE_MARKER, LEGACY_CHECKOUT_PAGE_MARKER],
+      CHECKOUT_PAGE_NOINDEX_LINE,
+    ],
   },
   {
     route: "checkout/unavailable",
     reason:
-      "spoke checkout return page (create-ailk #7838) — noindex, renders sections only, no JSON-LD",
-    requires: [CHECKOUT_PAGE_MARKER, CHECKOUT_PAGE_NOINDEX_LINE],
+      "spoke checkout return page (#8748) — noindex, renders sections only, no JSON-LD",
+    requires: [
+      [CHECKOUT_PAGE_MARKER, LEGACY_CHECKOUT_PAGE_MARKER],
+      CHECKOUT_PAGE_NOINDEX_LINE,
+    ],
   },
 ];
 
@@ -437,7 +448,9 @@ function exemption(route: string, src: string): string | undefined {
   if (entry === undefined) return undefined;
   if (
     entry.requires !== undefined &&
-    !entry.requires.every((s) => src.includes(s))
+    !entry.requires.every((s) =>
+      typeof s === "string" ? src.includes(s) : s.some((any) => src.includes(any)),
+    )
   ) {
     return undefined;
   }
@@ -643,6 +656,12 @@ describe("structured data — exemption(route, src) keys the generated checkout
     expect(exemption("checkout/unavailable", NO_NOINDEX_SRC)).toBeUndefined();
   });
 
+  it("still exempts a page create-ailk rendered before #8748, which update leaves in place", () => {
+    const legacy = `// The checkout thank-you page — ${LEGACY_CHECKOUT_PAGE_MARKER}.\nexport async function generateMetadata() {\n  return { ${CHECKOUT_PAGE_NOINDEX_LINE} };\n}\n`;
+    expect(exemption("checkout/thank-you", legacy)).toContain("noindex");
+    expect(exemption("checkout/unavailable", legacy)).toContain("noindex");
+  });
+
   it("does not exempt a neighboring checkout route or an unrelated route", () => {
     expect(exemption("checkout/other", GENERATED_SRC)).toBeUndefined();
     expect(exemption("about", GENERATED_SRC)).toBeUndefined();

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

@@ -0,0 +1,37 @@
+/**
+ * account-invite.ts — the /contact thank-you's account link (#8757 D8): the
+ * path that starts sign-in on this site with the submitter's email prefilled
+ * and lands on their account. It signs no one in; the email is only the
+ * sign-in form's starting value (NFR2).
+ *
+ * Built from the generated sign-in provider (`SIGN_IN_PROVIDER`):
+ *   - `site` — this site's own `/sign-in`, locale-prefixed like every page
+ *     (`localeHref`), with `next` = the locale's `/account` and `email`;
+ *   - `hub`  — a hub-sign-in spoke starts at `/api/hub-session/sign-in`
+ *     (`accountInvitePath("hub", …)`), which hands the hint to the hub;
+ *   - `none` — no sign-in, so no link.
+ * An email the hint schema refuses (`accountEmailHintSchema`) gives no link.
+ * The query is built with `URLSearchParams` (SEC-8757-L).
+ */
+import { localeHref } from "@working-theory/ui";
+import { accountEmailHintSchema, accountInvitePath } from "@working-theory/validation";
+
+import { SIGN_IN_PROVIDER } from "./topology.generated";
+
+export function accountInviteHref(locale: string, email: string): string | null {
+  const hint = accountEmailHintSchema.safeParse(email);
+  if (!hint.success) return null;
+  switch (SIGN_IN_PROVIDER) {
+    case "site": {
+      const query = new URLSearchParams({
+        next: localeHref(locale, "/account"),
+        email: hint.data,
+      });
+      return `${localeHref(locale, "/sign-in")}?${query.toString()}`;
+    }
+    case "hub":
+      return accountInvitePath("hub", hint.data);
+    default:
+      return null;
+  }
+}

package/templates/apps/web/lib/checkout-config.ts

@@ -0,0 +1,27 @@
+// checkout-config.ts — this spoke's checkout, as data (#7838, #8748).
+//
+// The one checkout file this site edits. Written once by create-ailk and yours
+// from then on: `create-ailk update` never rewrites it. The standard checkout
+// (lib/checkout.ts, the buy route and the Stripe webhook route) reads only
+// `site` and `offerings` from it and is kept current by `create-ailk update`.
+// Keep it to data: no import, and no code.
+//
+// site       Stamped on every Checkout Session as metadata.site. This site's
+//            webhook acts only on its own stamp, and the hub ignores any stamp
+//            that is not its own, so the stamp must be unique on the Stripe
+//            account this site shares. Never "default". Change it only before
+//            any price exists: every lookup key starts with it.
+// offerings  slug -> Stripe lookup_key. The buy link is /api/checkout/<slug>,
+//            and any other slug answers 404. Name an offering's slug after the
+//            last segment of the Service or Product page that sells it: that
+//            is the key the hub's plan rule and a magnet's checkoutOffering
+//            use. scaffold-commerce replaces the placeholder below.
+const SITE = "example-site";
+
+export const checkoutConfig = {
+  site: SITE,
+  offerings: {
+    // A placeholder until scaffold-commerce creates this site's prices.
+    example: { kind: "fixed", lookupKey: `${SITE}_example`, cancelPath: "/" },
+  },
+};

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

@@ -0,0 +1,93 @@
+// checkout.ts — the standard spoke checkout (#8748).
+//
+// The standard every selling spoke shares, kept current by `create-ailk
+// update`: do not edit it. This site's checkout is data in
+// lib/checkout-config.ts, the one file to edit. Only the buy route and the
+// Stripe webhook route import this file, and it never imports the checkout
+// package: every guarantee lives there and arrives by a package bump.
+//
+// spokeCheckoutConfig  What the two routes build their handlers from. It reads
+//                      only `site` and `offerings` from the site's file, so no
+//                      other key a site declares reaches the package.
+// fulfil               Runs for each paid session, at least once. It posts one
+//                      lead to the hub with the session id as its
+//                      Idempotency-Key, so a repeat writes nothing new. The hub
+//                      dedupes only an identical body: change the payload's
+//                      shape only when no webhook is failing. `termsAccepted`
+//                      is the stamp of the terms the buyer ticked in Stripe's
+//                      box, else null: the hub records the buyer's checkout
+//                      consent grant from it (#8778).
+import { leads } from "@working-theory/api-client";
+
+import { resolveBaseUrl } from "../src/lib/routes";
+
+import { checkoutConfig } from "./checkout-config";
+import { TOPOLOGY } from "./topology.generated";
+
+/** What the fulfilment reads from a completed checkout. */
+interface CompletedCheckout {
+  idempotencyKey: string;
+  sessionId: string;
+  offering: string;
+  kind: "fixed" | "quoted";
+  mode: "test" | "live";
+  amountTotal: number | null;
+  currency: string | null;
+  email: string | null;
+  customerId: string | null;
+  termsOfService: "accepted" | null;
+  termsStamp: string | null;
+}
+
+async function fulfil(checkout: CompletedCheckout): Promise<void> {
+  if (checkout.email === null) return;
+  // No spoke key: the hub cannot place the lead in this site's workspace.
+  // Fail, so Stripe retries and the dashboard shows a failed webhook.
+  if (!process.env.AILK_SPOKE_KEY)
+    throw new Error("AILK_SPOKE_KEY is not set");
+  const result = await leads.submit(
+    {
+      siteId: checkoutConfig.site,
+      source: "web",
+      email: checkout.email,
+      payload: {
+        site: checkoutConfig.site,
+        page: "checkout",
+        offering: checkout.offering,
+        checkoutKind: checkout.kind,
+        mode: checkout.mode,
+        amountTotal: checkout.amountTotal,
+        currency: checkout.currency,
+        stripeCustomerId: checkout.customerId,
+        checkoutSession: checkout.sessionId,
+        termsAccepted:
+          checkout.termsOfService === "accepted" ? checkout.termsStamp : null,
+      },
+    },
+    { headers: { "Idempotency-Key": checkout.idempotencyKey } },
+  );
+  // A replay under the same key answers 201 with the first lead; any
+  // failure (422 idempotency_key_reused included) makes Stripe retry.
+  if (!result.ok) throw new Error(`hub lead write answered ${result.status}`);
+}
+
+/** The config both routes pass to the checkout package, built key by key. */
+export const spokeCheckoutConfig = {
+  site: checkoutConfig.site,
+  offerings: checkoutConfig.offerings,
+  siteBaseUrl: resolveBaseUrl(),
+  fulfil,
+};
+
+/** Whether this build serves the checkout: a spoke only (#8748 D11). */
+export function checkoutServed(): boolean {
+  return TOPOLOGY === "spoke";
+}
+
+/** What either route answers on a build that does not serve the checkout. */
+export function checkoutNotServed(): Response {
+  return new Response(null, {
+    status: 404,
+    headers: { "Cache-Control": "no-store" },
+  });
+}

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

@@ -0,0 +1,22 @@
+/**
+ * consent-policies.ts — the one policy map an agreement surface links
+ * through (#8765 D9, spec docs/specs/8765-sign-up-refuses-without-the-spec.md).
+ *
+ * A consent statement names its links by key (`[Terms](terms)`); the keys
+ * resolve against the registry's `policies` map. This localizes that map, so
+ * the sign-up page, the account interstitial and the Privacy tab link Terms,
+ * Privacy Policy and Working Agreement to the same three pages `/contact`
+ * builds inline (#8761 decision, C6).
+ */
+import { localeHref } from "@working-theory/ui";
+import { SITE_CONSENT_CONFIG_DEFAULTS } from "@working-theory/validation";
+
+/** The registry's policy map with each path localized for `locale`. */
+export function consentPoliciesFor(locale: string): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(SITE_CONSENT_CONFIG_DEFAULTS.policies).map(([key, path]) => [
+      key,
+      localeHref(locale, path),
+    ]),
+  );
+}

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

@@ -0,0 +1,192 @@
+/**
+ * The deck-page resolver (#8687 D3) — the layout's question ("does the page
+ * at this path opt in?") and `renderPage`'s consult both ask this ONE
+ * resolver, so they always agree. Registers with `@working-theory/page-renderer`
+ * at module load, in `lib/site-identity.ts`'s precedent: `app/[locale]/layout.tsx`
+ * imports this module, and Next.js evaluates a layout module before any page
+ * under it renders.
+ */
+import {
+  getMdxSource as defaultGetMdxSource,
+  optsIntoDeck,
+  setDeckPages,
+  type DeckPageContext,
+  type DeckPageInputs,
+  type SchemaOrgType,
+} from "@working-theory/page-renderer";
+import { ROUTES, type RouteRow } from "@working-theory/templates/routes";
+import { readLocales } from "@working-theory/web-i18n";
+import { headers } from "next/headers";
+import { cache } from "react";
+
+import { normalizeRoutePath } from "./closing-footer-path";
+import { siteChrome, type SiteChrome } from "./site-chrome";
+
+/**
+ * The routes besides `[slug]` whose page can present as a deck: every
+ * routes-map row with seed content whose route renders sections, minus `/`.
+ *
+ * This is a fixed superset across every shape/level a scaffold can ship,
+ * not a per-site exact list: a shape that doesn't carry one of these routes
+ * (e.g. a Free scaffold without `/alternatives`) has no `page.tsx` there, so
+ * `deckCandidates`/`resolveDeckPage` never get a request for that path —
+ * harmless. `apps/web/lib/__tests__/deck-page.test.ts`'s parity case checks
+ * the direction that would be a real bug: that this list names every
+ * sections route THIS build's own tree actually carries.
+ */
+export const DECK_ROUTES = [
+  "/about",
+  "/alternatives",
+  "/contact",
+  "/faq",
+  "/launch-service",
+  "/pricing",
+  "/privacy",
+  "/projects",
+  "/projects/:slug",
+  "/purchase-policy",
+  "/reports",
+  "/terms",
+  "/thanks/:slug",
+  "/working-agreement",
+] as const;
+
+/** The widened type (#7719 D3, #7740 D8): present only when the design sets it. */
+type Chrome = SiteChrome & {
+  deckGrounds?: DeckPageInputs["deckGrounds"];
+  deckPresentation?: true;
+  /** #8773 — present only when the design chooses bare slide anchors. */
+  deckAnchors?: "bare";
+};
+const chrome: Chrome = siteChrome;
+
+function routeSegments(route: string): string[] {
+  return route.split("/").filter((segment) => segment.length > 0);
+}
+
+function matchesRoute(routeDef: string, pathSegments: readonly string[]): boolean {
+  const defSegments = routeSegments(routeDef);
+  if (defSegments.length !== pathSegments.length) return false;
+  return defSegments.every(
+    (segment, i) => segment.startsWith(":") || segment === pathSegments[i],
+  );
+}
+
+/** The type and slug a matched routes-map row resolves to for this request. */
+function resolveTypeAndSlug(
+  row: RouteRow,
+  routeDef: string,
+  pathSegments: readonly string[],
+): { type: SchemaOrgType; slug: string } | null {
+  if (row.contentPath === undefined) return null;
+  const parts = row.contentPath.split("/");
+  const last = parts[parts.length - 1];
+  if (last === undefined) return null;
+  const isFile = last.endsWith(".mdx");
+  const type = isFile ? parts[parts.length - 2] : last;
+  if (type === undefined) return null;
+  const slug = isFile
+    ? last.replace(/\.mdx$/, "")
+    : pathSegments[routeSegments(routeDef).findIndex((segment) => segment.startsWith(":"))];
+  if (slug === undefined) return null;
+  return { type: type as SchemaOrgType, slug };
+}
+
+/** Whether a routes-map row at this exact route is always scaffolded (never absent from a site). */
+function isAlwaysScaffolded(path: string): boolean {
+  const row = ROUTES.find((candidate) => candidate.route === path);
+  return row !== undefined && row.gateable !== true && row.module === "marketing";
+}
+
+/**
+ * The content pages that could serve `pathname`, in the order Next.js tries
+ * them (D3). `/` gives none — the home's deck is its own `layout.home` knob,
+ * never this resolver's.
+ */
+export function deckCandidates(
+  pathname: string,
+  locales: readonly string[],
+): Array<{ type: SchemaOrgType; slug: string }> {
+  const path = normalizeRoutePath(pathname, locales);
+  if (path === "/") return [];
+  const segments = routeSegments(path);
+  const candidates: Array<{ type: SchemaOrgType; slug: string }> = [];
+
+  for (const routeDef of DECK_ROUTES) {
+    if (!matchesRoute(routeDef, segments)) continue;
+    const row = ROUTES.find((candidate) => candidate.route === routeDef);
+    const resolved = row && resolveTypeAndSlug(row, routeDef, segments);
+    if (resolved) candidates.push(resolved);
+    break;
+  }
+
+  // A one-segment path not always scaffolded falls through to `[slug]`,
+  // which serves `LandingPage` then `BlogList` (D3).
+  if (segments.length === 1 && !isAlwaysScaffolded(path)) {
+    const slug = segments[0];
+    if (slug !== undefined) {
+      candidates.push({ type: "LandingPage", slug });
+      candidates.push({ type: "BlogList", slug });
+    }
+  }
+
+  return candidates;
+}
+
+/**
+ * The first candidate with a source, and its frontmatter, or `null`. A read
+ * that throws ends the walk as `null` (NFR 3) — the page's own render
+ * surfaces that error, and the layout keeps its plain shell. Per-request
+ * memoised (React `cache`) — the layout and `renderPage`'s consult ask the
+ * same question for the same request and must share one answer.
+ */
+export const resolveDeckPage = cache(async function resolveDeckPage(
+  pathname: string,
+  locale: string,
+): Promise<{ type: SchemaOrgType; slug: string; frontmatter: Record<string, unknown> } | null> {
+  for (const candidate of deckCandidates(pathname, readLocales())) {
+    let source;
+    try {
+      source = await defaultGetMdxSource(candidate.type, candidate.slug, locale);
+    } catch {
+      return null;
+    }
+    if (source) return { ...candidate, frontmatter: source.frontmatter };
+  }
+  return null;
+});
+
+/** The layout's question: does the page at this path opt in? */
+export async function pageOptsIntoDeck(input: {
+  pathname: string;
+  locale: string;
+}): Promise<boolean> {
+  const resolved = await resolveDeckPage(input.pathname, input.locale);
+  return resolved !== null && optsIntoDeck(resolved.frontmatter);
+}
+
+/** `inputsFor`: only when this render IS the page the request path resolves to and it opts in. */
+async function inputsFor(ctx: DeckPageContext): Promise<DeckPageInputs | null> {
+  const headerStore = await headers();
+  const pathname = headerStore.get("x-pathname") ?? null;
+  if (pathname === null) return null;
+  const resolved = await resolveDeckPage(pathname, ctx.locale);
+  if (
+    resolved === null ||
+    resolved.type !== ctx.type ||
+    resolved.slug !== ctx.slug ||
+    !optsIntoDeck(resolved.frontmatter)
+  ) {
+    return null;
+  }
+  return {
+    ...(chrome.deckGrounds !== undefined ? { deckGrounds: chrome.deckGrounds } : {}),
+    deckPresentation: chrome.deckPresentation === true,
+    // #8773 — a page that presents names its slides as the design chose.
+    ...(chrome.deckPresentation === true && chrome.deckAnchors === "bare"
+      ? { deckAnchorStyle: "bare" as const }
+      : {}),
+  };
+}
+
+setDeckPages({ inputsFor });

package/templates/apps/web/lib/hub-session/__tests__/sign-in-gate.test.tsx

@@ -0,0 +1,111 @@
+/**
+ * HubSignInGate (#7894 D10) as #8790 AC-1/AC-2 shape it: the site's inner-page
+ * header (back arrow + mark), a label-size heading, the one hub sign-in
+ * action, and a prospect line only when the site's messages carry it.
+ */
+import { render, screen } from "@testing-library/react";
+import en from "../../../messages/en.json";
+import { HubSignInGate } from "../sign-in-gate";
+
+type Gate = Record<string, string>;
+let gateMessages: Gate;
+
+jest.mock("next-intl/server", () => ({
+  __esModule: true,
+  getTranslations: jest.fn(async () => {
+    const t = (key: string) => gateMessages[key] ?? `copy:${key}`;
+    t.has = (key: string) => key in gateMessages;
+    return t;
+  }),
+}));
+
+const mockConfig = jest.fn();
+// eslint-disable-next-line no-restricted-syntax -- #507: mock-internal rewrite pending; hubSessionConfig() is a pure env read
+jest.mock("../config", () => ({
+  __esModule: true,
+  hubSessionConfig: () => mockConfig(),
+}));
+
+// eslint-disable-next-line no-restricted-syntax -- #507: mock-internal rewrite pending; siteLogo() reads the site's brand files
+jest.mock("../../site-logo", () => ({
+  __esModule: true,
+  siteLogo: () => (
+    <img src="/logomark.svg" alt="Site" data-testid="site-mark" />
+  ),
+}));
+
+async function renderGate(pathname?: string): Promise<void> {
+  const requestHeaders = new Headers();
+  if (pathname) requestHeaders.set("x-pathname", pathname);
+  render(await HubSignInGate({ locale: "en", requestHeaders }));
+}
+
+beforeEach(() => {
+  gateMessages = { ...(en.account.gate as Gate) };
+  mockConfig.mockReset().mockReturnValue({ clientId: "spoke_1" });
+});
+
+describe("<HubSignInGate/> (#8790 AC-1)", () => {
+  it("wears the site's inner-page header: a back arrow to the home and the mark", async () => {
+    await renderGate("/account");
+    const header = screen.getByTestId("account-sign-in-gate-header");
+    const back = screen.getByTestId("nav-back-link");
+    expect(header).toContainElement(back);
+    expect(back).toHaveAttribute("href", "/");
+    expect(back).toHaveAccessibleName(en.account.gate.homeLink);
+    expect(screen.getByTestId("account-sign-in-gate-mark")).toContainElement(
+      screen.getByTestId("site-mark"),
+    );
+  });
+
+  it("sets the heading at the label size and offers the one sign-in action", async () => {
+    await renderGate("/account/settings");
+    const heading = screen.getByRole("heading", { level: 1 });
+    expect(heading).toHaveTextContent(en.account.gate.hubHeadline);
+    expect(heading).toHaveClass("text-heading-2");
+    expect(screen.getByTestId("account-hub-sign-in")).toHaveAttribute(
+      "href",
+      "/api/hub-session/sign-in?next=%2Faccount%2Fsettings",
+    );
+  });
+
+  it("renders no prospect line by default (the shipped messages carry no prospect keys)", async () => {
+    await renderGate();
+    expect(screen.queryByTestId("account-sign-in-gate-prospect")).toBeNull();
+  });
+});
+
+describe("<HubSignInGate/> prospect line (#8790 AC-2)", () => {
+  it("renders the line and its link when the site fills all three keys", async () => {
+    gateMessages.prospectPrompt = "New here?";
+    gateMessages.prospectLink = "See if we fit";
+    gateMessages.prospectHref = "/fit";
+    await renderGate();
+    const line = screen.getByTestId("account-sign-in-gate-prospect");
+    expect(line).toHaveTextContent("New here? See if we fit.");
+    expect(screen.getByRole("link", { name: "See if we fit" })).toHaveAttribute(
+      "href",
+      "/fit",
+    );
+  });
+
+  it("renders nothing when any of the three keys is absent", async () => {
+    gateMessages.prospectPrompt = "New here?";
+    gateMessages.prospectLink = "See if we fit";
+    await renderGate();
+    expect(screen.queryByTestId("account-sign-in-gate-prospect")).toBeNull();
+  });
+
+  it("keeps the not-configured state when the hub is not configured", async () => {
+    mockConfig.mockReturnValue(null);
+    await renderGate();
+    expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+      en.account.gate.emptyHeadline,
+    );
+    expect(screen.getByTestId("account-sign-in-gate-home")).toHaveAttribute(
+      "href",
+      "/",
+    );
+    expect(screen.queryByTestId("account-hub-sign-in")).toBeNull();
+  });
+});