create-ailk 0.26.0 → 0.28.0

package/templates/apps/web/lib/docs-index.ts

@@ -0,0 +1,100 @@
+// docs-index.ts — the docs list `/sitemap.xml` and `/llms.txt` read (#10041 D8).
+//
+// A base file: it reads the docs directory itself rather than `docsSource`,
+// which only a docs-blog site carries, so the sitemap and llms routes stay in
+// the Free template and list the docs on any site that has them. It imports
+// no docs-blog owned file (a relative import of one would drop it, and every
+// file importing it, from the Free template).
+//
+// Default locale only: the docs exist in one locale (`source.config.ts` reads
+// `content/en/docs`).
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parse as parseYaml } from "yaml";
+
+import { DOCS_PATH } from "./docs-path";
+
+export interface DocsIndexPage {
+  url: string;
+  title: string;
+  description?: string;
+}
+
+/** The two content-adapter types the docs route reads under the database adapter. */
+const DOCS_TYPES = new Set(["DocsList", "DocsDetail"]);
+
+export function isDocsType(type: string): boolean {
+  return DOCS_TYPES.has(type);
+}
+
+/** An adapter docs row's URL: the index at `DOCS_PATH`, a doc under it. */
+export function adapterDocsUrl(type: string, slug: string): string {
+  return type === "DocsList" || slug === "index"
+    ? DOCS_PATH
+    : `${DOCS_PATH}/${slug}`;
+}
+
+function frontmatterOf(raw: string): Record<string, unknown> | null {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(raw);
+  if (!match) return null;
+  const parsed: unknown = parseYaml(match[1]!);
+  return parsed && typeof parsed === "object"
+    ? (parsed as Record<string, unknown>)
+    : null;
+}
+
+/**
+ * Fumadocs' slug rule: the path segments without the extension, a trailing
+ * `index` dropped, a `(group)` segment dropped.
+ */
+function urlFor(segments: string[]): string {
+  const slugs = segments.filter((s) => !/^\(.+\)$/.test(s));
+  if (slugs.at(-1) === "index") slugs.pop();
+  return slugs.length === 0 ? DOCS_PATH : `${DOCS_PATH}/${slugs.join("/")}`;
+}
+
+function walk(dir: string, segments: string[], out: DocsIndexPage[]): void {
+  const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) =>
+    a.name.localeCompare(b.name),
+  );
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      walk(join(dir, entry.name), [...segments, entry.name], out);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".mdx")) continue;
+    const data = frontmatterOf(readFileSync(join(dir, entry.name), "utf8"));
+    if (!data || typeof data.title !== "string" || data.title === "") continue;
+    out.push({
+      url: urlFor([...segments, entry.name.slice(0, -".mdx".length)]),
+      title: data.title,
+      ...(typeof data.description === "string" && data.description !== ""
+        ? { description: data.description }
+        : {}),
+    });
+  }
+}
+
+/**
+ * Every titled `*.mdx` page under `dir` (default: this app's
+ * `content/<default locale>/docs`), at the docs' public path. An absent
+ * directory — every Free site — is `[]`; a page with no `title` is skipped.
+ */
+export function listDocsPages(
+  dir: string = join(
+    process.cwd(),
+    "content",
+    process.env.NEXT_PUBLIC_DEFAULT_LOCALE ?? "en",
+    "docs",
+  ),
+): DocsIndexPage[] {
+  const pages: DocsIndexPage[] = [];
+  try {
+    walk(dir, [], pages);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+    throw error;
+  }
+  return pages;
+}

package/templates/apps/web/lib/docs-path.ts

@@ -0,0 +1,94 @@
+// docs-path.ts — where the docs live (#10041 D2).
+//
+// A site sets `docsPath` in `content/_site.mdx` (e.g. `/working-theory/docs`);
+// `next.config.mjs` parses it at build and bakes it into
+// `NEXT_PUBLIC_AILK_DOCS_PATH`. The docs route itself never moves — it stays
+// at `app/[locale]/docs/` (`DOCS_ROUTE`) — and the middleware maps the public
+// path onto it. Every surface that names a docs URL reads `DOCS_PATH` here.
+//
+// Edge-safe and client-safe: this file imports nothing at runtime (the
+// `NavItem` import is type-only), so the middleware and the client signed-in
+// nav can both read it. It is a base file: it must never import a docs-blog
+// owned file, or it would leave the Free template.
+import type { NavItem } from "@working-theory/ui";
+
+/** The internal docs route — the directory under `app/[locale]/`. Always `/docs`. */
+export const DOCS_ROUTE = "/docs";
+
+/** The docs' public base: the site's `docsPath`, or `/docs` when it sets none. */
+export const DOCS_PATH: string =
+  process.env.NEXT_PUBLIC_AILK_DOCS_PATH || DOCS_ROUTE;
+
+/**
+ * `href` at the internal docs route — `/docs`, or starting `/docs/`, `/docs?`
+ * or `/docs#` — with that prefix replaced by `DOCS_PATH`. Anything else
+ * (absolute URLs, `/docsets`, a locale-prefixed path) is returned unchanged.
+ * The identity on a site with no `docsPath`.
+ */
+export function toPublicDocsHref(href: string): string {
+  if (DOCS_PATH === DOCS_ROUTE) return href;
+  const rest = href.slice(DOCS_ROUTE.length);
+  if (href.startsWith(DOCS_ROUTE) && (rest === "" || /^[/?#]/.test(rest))) {
+    return DOCS_PATH + rest;
+  }
+  return href;
+}
+
+/**
+ * A locale-less pathname at or under `DOCS_PATH`, mapped onto the internal
+ * route (`/docs` + the rest); `null` for anything else, and always `null` on a
+ * site with no `docsPath`.
+ */
+export function toInternalDocsPath(bare: string): string | null {
+  if (DOCS_PATH === DOCS_ROUTE) return null;
+  if (bare === DOCS_PATH) return DOCS_ROUTE;
+  if (bare.startsWith(`${DOCS_PATH}/`)) {
+    return DOCS_ROUTE + bare.slice(DOCS_PATH.length);
+  }
+  return null;
+}
+
+type NavFlyout = NonNullable<NavItem["flyout"]>;
+
+function mapPath<T extends { path: string }>(entry: T): T {
+  return { ...entry, path: toPublicDocsHref(entry.path) };
+}
+
+function mapFlyout(flyout: NavFlyout): NavFlyout {
+  return {
+    ...flyout,
+    features: flyout.features.map(mapPath),
+    ...(flyout.groups
+      ? {
+          groups: flyout.groups.map((group) => ({
+            ...group,
+            items: group.items.map(mapPath),
+          })),
+        }
+      : {}),
+    actions: flyout.actions.map(mapPath),
+  };
+}
+
+/**
+ * Copies of the nav items with every docs path mapped onto `DOCS_PATH` — the
+ * item's own `path` and each flyout feature, group item and action. Every
+ * other field (icons are functions) is carried by reference.
+ */
+export function withPublicDocsPaths(items: NavItem[]): NavItem[] {
+  return items.map((item) => ({
+    ...item,
+    ...(item.path !== undefined ? { path: toPublicDocsHref(item.path) } : {}),
+    ...(item.flyout ? { flyout: mapFlyout(item.flyout) } : {}),
+  }));
+}
+
+/** Copies of the footer columns with every item's docs path mapped onto `DOCS_PATH`. */
+export function withPublicDocsColumns<C extends { items: { path: string }[] }>(
+  columns: C[],
+): C[] {
+  return columns.map((column) => ({
+    ...column,
+    items: column.items.map(mapPath),
+  }));
+}

package/templates/apps/web/lib/hub-children.tsx

@@ -0,0 +1,318 @@
+/**
+ * Hub child cards (#10121) — the /alternatives (#6878 D9) and /templates
+ * (#10051 D7) shape, shared by the content hubs that list one child page
+ * type each (/for, /case-studies, /team, …).
+ *
+ * The hub adds a generated card per child page of its type that the hub's
+ * own sections do not already link: into the authored card grid that already
+ * lists its children when there is one, else as one new `items` section
+ * before any trailing closing CTA (#7745 D4). `renderPage` builds the CollectionPage
+ * ItemList JSON-LD from the same sections, so the visible cards and the
+ * ItemList always list the same pages. A child the hub already links keeps
+ * its hand-written card and gets no second one, so a hub whose MDX already
+ * links every child renders exactly as before.
+ *
+ * A prose hub (`bodyMode: "mdx-body"`) never reaches renderPage's
+ * SectionRenderer, so its generated section renders after the MDX body
+ * through renderPage's `trailing` slot.
+ *
+ * Base tree: no paid import, no `oss: false`.
+ */
+import type {
+  getMdxSlugs as defaultGetMdxSlugs,
+  getMdxSource as defaultGetMdxSource,
+  getPageSections as defaultGetPageSections,
+  renderPage,
+  SchemaOrgType,
+} from "@working-theory/page-renderer";
+import {
+  getMdxSlugs as loadMdxSlugs,
+  getMdxSource as loadMdxSource,
+  getPageSections as loadPageSections,
+} from "@working-theory/page-renderer";
+import { SectionRenderer } from "@working-theory/ui/sections";
+
+import {
+  type DetailPage,
+  insertBeforeClosingCtas,
+  listDetailPages,
+} from "./route-family";
+
+type Section = Awaited<ReturnType<typeof defaultGetPageSections>>[number];
+
+/** One hub: its list page, its child type, and how its body renders. */
+export interface HubConfig {
+  /** The list page type, e.g. `UseCasesList`. */
+  listType: SchemaOrgType;
+  /** The hub's slug, translations namespace and route segment, e.g. `for`. */
+  slug: string;
+  /** The child page type, e.g. `UseCase`. */
+  childType: SchemaOrgType;
+  /** The card link label. */
+  linkLabel: string;
+  /** The generated section's id. */
+  sectionId: string;
+  /**
+   * The hub's existing body rule: `sections` always, `mdx-body` always, or
+   * `composed` — sections when the frontmatter carries `sections[]`, the MDX
+   * body otherwise.
+   */
+  body: "sections" | "mdx-body" | "composed";
+  /** Which child pages the hub lists (default: all). */
+  includeChild?: (page: DetailPage) => boolean;
+  /**
+   * One listed page's card (default: title, description and a link to
+   * `/<slug>/<child>` labelled `linkLabel`).
+   */
+  card?: (page: DetailPage) => HubCard;
+  /** A last pass over the hub's final sections (default: none). */
+  mapSections?: (sections: Section[]) => Section[];
+}
+
+/** One generated card. */
+export interface HubCard {
+  title: string;
+  description?: string | undefined;
+  link?: { label: string; href: string } | undefined;
+}
+
+/** A hub route's injectable loaders (tests pass their own). */
+export interface HubLoaders {
+  getMdxSource?: typeof defaultGetMdxSource;
+  getPageSections?: typeof defaultGetPageSections;
+  getMdxSlugs?: typeof defaultGetMdxSlugs;
+}
+
+/**
+ * A link's path for matching: an absolute http(s) URL's pathname, the query
+ * and hash dropped, a leading `/` ensured and trailing `/`s trimmed.
+ */
+function linkPath(href: string): string | null {
+  let path = href.trim();
+  if (/^https?:\/\//i.test(path)) {
+    try {
+      path = new URL(path).pathname;
+    } catch {
+      return null;
+    }
+  }
+  path = path.split(/[?#]/)[0] ?? "";
+  if (!path.startsWith("/")) path = `/${path}`;
+  let end = path.length;
+  while (end > 0 && path[end - 1] === "/") end -= 1;
+  return path.slice(0, end);
+}
+
+/** A BCP-47-shaped first path segment: `en`, `pt-BR`, `zh-Hant`. */
+const LOCALE_SEGMENT = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})?$/;
+
+/** The path without one leading locale segment (`/en/for/a` → `/for/a`). */
+function withoutLocale(path: string): string {
+  const end = path.indexOf("/", 1);
+  if (end === -1) return path;
+  return LOCALE_SEGMENT.test(path.slice(1, end)) ? path.slice(end) : path;
+}
+
+/** Whether a link path names `target`, with or without a locale prefix. */
+function linksTo(path: string, target: string): boolean {
+  return path === target || withoutLocale(path) === target;
+}
+
+/**
+ * Every link path an MDX body carries: markdown link targets and `href`
+ * attributes, the forms a prose hub links its pages with.
+ */
+export function bodyLinkPaths(body: string): string[] {
+  const hrefs = [
+    ...body.matchAll(/\]\(\s*<?([^)\s>]+)/g),
+    ...body.matchAll(/\bhref\s*=\s*\{?\s*["']([^"']+)["']/g),
+  ].map((match) => match[1] ?? "");
+  return hrefs
+    .map(linkPath)
+    .filter((path): path is string => path !== null);
+}
+
+/**
+ * Every link path the sections carry: any `href` or `url` string at any
+ * depth, so an `items` card link, a `team` member's `url` and a CTA all count.
+ */
+export function linkedPaths(sections: readonly unknown[]): string[] {
+  const paths: string[] = [];
+  const walk = (value: unknown): void => {
+    if (Array.isArray(value)) {
+      value.forEach(walk);
+      return;
+    }
+    if (value === null || typeof value !== "object") return;
+    for (const [key, child] of Object.entries(value)) {
+      if ((key === "href" || key === "url") && typeof child === "string") {
+        const path = linkPath(child);
+        if (path !== null) paths.push(path);
+      } else {
+        walk(child);
+      }
+    }
+  };
+  walk(sections);
+  return paths;
+}
+
+/**
+ * The generated section: one card per child page the hub's rendered content
+ * does not already link (`linked`, from `linkedPaths` or `bodyLinkPaths`; a
+ * locale prefix or an absolute URL still counts as a link), or `null` when
+ * there is none.
+ */
+export function childCardsSection(
+  linked: readonly string[],
+  pages: readonly DetailPage[],
+  config: Pick<HubConfig, "slug" | "linkLabel" | "sectionId" | "card">,
+): Section | null {
+  // A child counts as linked at its route path or at its card's own href (a
+  // hub whose public base differs from its route, #10043).
+  const items = pages.flatMap((page) => {
+    const card = config.card?.(page) ?? defaultCard(page, config);
+    const targets = [`/${config.slug}/${page.slug}`];
+    if (card.link !== undefined) targets.push(card.link.href);
+    const linkedAlready = linked.some((path) =>
+      targets.some((t) => linksTo(path, t)),
+    );
+    return linkedAlready ? [] : [card];
+  });
+  if (items.length === 0) return null;
+  return { type: "items", id: config.sectionId, data: { items } } as Section;
+}
+
+function defaultCard(
+  { slug, frontmatter }: DetailPage,
+  config: Pick<HubConfig, "slug" | "linkLabel">,
+): HubCard {
+  const fm = frontmatter as { title?: string; description?: string };
+  return {
+    title: fm.title ?? slug,
+    description: fm.description ?? "",
+    link: { label: config.linkLabel, href: `/${config.slug}/${slug}` },
+  };
+}
+
+type CardItem = { link?: { href?: string; variant?: string } };
+
+/**
+ * Place the generated cards. When an authored `items` section already lists
+ * children of this hub (a card linking `/<hub>/…`), the cards continue that
+ * grid, taking its card link variant, so the hub shows one list. Otherwise
+ * the generated section goes before the closing CTAs (#7745 D4).
+ */
+export function placeChildCards(
+  declared: Section[],
+  generated: Section,
+  hubSlug: string,
+): Section[] {
+  const prefix = `/${hubSlug}/`;
+  const listsChildren = (section: Section): boolean =>
+    section.type === "items" &&
+    ((section.data as { items?: CardItem[] }).items ?? []).some((item) => {
+      const href = item.link?.href;
+      const path = href === undefined ? null : linkPath(href);
+      // Raw first: a short hub slug (`for`) itself looks like a locale.
+      return (
+        path !== null &&
+        (path.startsWith(prefix) || withoutLocale(path).startsWith(prefix))
+      );
+    });
+  let at = declared.length - 1;
+  while (at >= 0 && !listsChildren(declared[at] as Section)) at -= 1;
+  if (at === -1) return insertBeforeClosingCtas(declared, generated);
+
+  const host = declared[at] as Section & { data: { items: CardItem[] } };
+  const variant = host.data.items.find((item) => item.link?.variant)?.link
+    ?.variant;
+  const added = (generated.data as { items: CardItem[] }).items.map((item) =>
+    variant === undefined ? item : { ...item, link: { ...item.link, variant } },
+  );
+  const merged = {
+    ...host,
+    data: { ...host.data, items: [...host.data.items, ...added] },
+  } as Section;
+  return [...declared.slice(0, at), merged, ...declared.slice(at + 1)];
+}
+
+function hasSections(frontmatter: unknown): boolean {
+  const sections = (frontmatter as { sections?: unknown }).sections;
+  return Array.isArray(sections) && sections.length > 0;
+}
+
+type RenderPageInput = Parameters<typeof renderPage>[0];
+
+/**
+ * Everything a hub's `renderPage` call needs beyond its literal `type` and
+ * `slug`, which stay written out in each page.tsx where the content-render
+ * lint reads them.
+ */
+export async function hubPageInput(
+  config: HubConfig,
+  locale: string,
+  loaders: HubLoaders,
+): Promise<Omit<RenderPageInput, "type" | "slug">> {
+  const load = loaders.getMdxSource ?? loadMdxSource;
+  const base = {
+    locale,
+    translationsNamespace: config.slug,
+    ...(loaders.getMdxSource !== undefined && {
+      getMdxSource: loaders.getMdxSource,
+    }),
+  };
+
+  const source = await load(config.listType, config.slug, locale);
+  const mdxBody =
+    config.body === "mdx-body" ||
+    (config.body === "composed" &&
+      (source === null || !hasSections(source.frontmatter)));
+  if (source === null) {
+    // The hub's existing empty-state rule, unchanged.
+    return {
+      ...base,
+      ...(mdxBody && { bodyMode: "mdx-body" as const }),
+      ...(loaders.getPageSections !== undefined && {
+        getPageSections: loaders.getPageSections,
+      }),
+    };
+  }
+
+  const declared = await (loaders.getPageSections ?? loadPageSections)(
+    source.frontmatter,
+  );
+  const pages = await listDetailPages(
+    config.childType,
+    locale,
+    load,
+    loaders.getMdxSlugs ?? loadMdxSlugs,
+  );
+  // A prose hub renders its MDX body, never its declared sections, so its
+  // existing links are read from the body and its cards stand alone after it.
+  const linked = mdxBody
+    ? bodyLinkPaths(source.body)
+    : linkedPaths(declared);
+  const generated = childCardsSection(
+    linked,
+    config.includeChild ? pages.filter(config.includeChild) : pages,
+    config,
+  );
+  const placed =
+    generated === null
+      ? declared
+      : mdxBody
+        ? insertBeforeClosingCtas(declared, generated)
+        : placeChildCards(declared, generated, config.slug);
+  const sections = config.mapSections ? config.mapSections(placed) : placed;
+
+  return {
+    ...base,
+    getPageSections: async () => sections,
+    ...(mdxBody && { bodyMode: "mdx-body" as const }),
+    ...(mdxBody &&
+      generated !== null && {
+        trailing: <SectionRenderer sections={[generated]} locale={locale} />,
+      }),
+  };
+}

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

@@ -4,6 +4,10 @@
  * the one card's frame — the mark in the tile, "Sign in to <site>", the toggle
  * line to the hub's /sign-up (or the site's own prospect line when its
  * messages carry one), and the Terms + Privacy acknowledgement.
+ *
+ * #9912 D1: that toggle reaches the hub's /sign-up through the same round trip
+ * as Sign in — this site's own sign-in route with `prompt=create` and the
+ * same `next` — so completing sign-up returns the buyer here.
  */
 import { render, screen, within } from "@testing-library/react";
 import en from "../../../messages/en.json";
@@ -94,7 +98,11 @@ describe("<HubSignInGate/> (#8790 AC-1; #9662)", () => {
     );
     expect(screen.getByTestId("auth-card-prospect-link")).toHaveAttribute(
       "href",
-      "https://hub.example/sign-up",
+      "/api/hub-session/sign-in?next=%2Faccount&prompt=create",
+    );
+    expect(screen.getByTestId("account-hub-sign-in")).toHaveAttribute(
+      "href",
+      "/api/hub-session/sign-in?next=%2Faccount",
     );
     const footnote = screen.getByTestId("auth-card-footnote");
     expect(footnote).toHaveTextContent(
@@ -107,6 +115,18 @@ describe("<HubSignInGate/> (#8790 AC-1; #9662)", () => {
       within(footnote).getByRole("link", { name: "Privacy Policy" }),
     ).toHaveAttribute("href", "/privacy");
   });
+
+  it("starts Sign up with the requested path as next, the Sign in button's own URL plus prompt=create (#9912 D1, AC-1)", async () => {
+    await renderGate("/account/billing");
+    expect(screen.getByTestId("auth-card-prospect-link")).toHaveAttribute(
+      "href",
+      "/api/hub-session/sign-in?next=%2Faccount%2Fbilling&prompt=create",
+    );
+    expect(screen.getByTestId("account-hub-sign-in")).toHaveAttribute(
+      "href",
+      "/api/hub-session/sign-in?next=%2Faccount%2Fbilling",
+    );
+  });
 });
 
 describe("<HubSignInGate/> prospect line (#8790 AC-2)", () => {
@@ -131,7 +151,7 @@ describe("<HubSignInGate/> prospect line (#8790 AC-2)", () => {
     await renderGate();
     expect(screen.getByTestId("auth-card-prospect-link")).toHaveAttribute(
       "href",
-      "https://hub.example/sign-up",
+      "/api/hub-session/sign-in?next=%2Faccount&prompt=create",
     );
   });
 

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

@@ -17,12 +17,14 @@
  * The one card (#9662, operator 2026-10-24): the single hub action sits in
  * `AuthCard`'s frame — the site's mark in the 48px tile, "Sign in to <site>"
  * (`SITE_NAME`, the deployment's own name, never the request's), the
- * "Don't have an account? Sign up" line to the hub's `/sign-up`, and the
- * Terms + Privacy acknowledgement on this site's own policy routes. A site
- * that fills `account.gate.prospectPrompt` + `prospectLink` + `prospectHref`
- * replaces the toggle line with its own. The acknowledgement is built here
- * rather than from the `(auth)` group's builder: a spoke carries no `(auth)`
- * group (create-ailk's `SPOKE_REMOVAL_SEEDS`).
+ * "Don't have an account? Sign up" line to this site's own sign-in route with
+ * `prompt=create`, which lands on the hub's sign-up screen and returns here
+ * (#9912 D1), and the Terms + Privacy acknowledgement on this site's own
+ * policy routes. A site that fills `account.gate.prospectPrompt` +
+ * `prospectLink` + `prospectHref` replaces the toggle line with its own. The
+ * acknowledgement is built here rather than from the `(auth)` group's
+ * builder: a spoke carries no `(auth)` group (create-ailk's
+ * `SPOKE_REMOVAL_SEEDS`).
  *
  * Not configured (`hubSessionConfig()` is `null`: a client id, secret or
  * session secret missing), the card says "sign-in isn't available yet" and
@@ -60,6 +62,7 @@ export async function HubSignInGate({
   const next =
     requestHeaders.get("x-pathname") ??
     localeHref(locale, HUB_SESSION_FALLBACK_PATH);
+  const signInHref = `${HUB_SIGN_IN_ROUTE}?next=${encodeURIComponent(next)}`;
   const home = localeHref(locale, "/");
   // The three prospect keys are optional extensions of the typed catalog (the
   // shipped en.json carries none — every leaf must be a non-empty string), so
@@ -78,7 +81,7 @@ export async function HubSignInGate({
       : {
           prompt: signIn("prospectPrompt"),
           linkLabel: signIn("prospectLink"),
-          href: `${config.hubOrigin}/sign-up`,
+          href: `${signInHref}&prompt=create`,
         };
 
   return (
@@ -114,7 +117,7 @@ export async function HubSignInGate({
                 // The primary action: full width at `big` (44px).
                 <Button asChild size="big" className="w-full">
                   <Link
-                    href={`${HUB_SIGN_IN_ROUTE}?next=${encodeURIComponent(next)}`}
+                    href={signInHref}
                     variant="bare"
                     data-testid="account-hub-sign-in"
                   >

package/templates/apps/web/lib/modules.generated.ts

@@ -7,3 +7,12 @@
 
 /** The scheduling module's booking pages (/meet, /private) exist. */
 export const SCHEDULING_PAGES: boolean = false;
+
+/** The marketing module's public pages exist (#10040): false on a hub. */
+export const MARKETING_PAGES: boolean = true;
+
+/** The docs-blog module's /docs and /blog pages exist (#10040). */
+export const DOCS_BLOG_PAGES: boolean = false;
+
+/** Any public page exists: robots, sitemap, llms.txt and the noindex header read this (#10040 D6/D7). */
+export const PUBLIC_PAGES: boolean = true;

package/templates/apps/web/lib/nav-label-check.ts

@@ -0,0 +1,61 @@
+// nav-label-check.ts — find nav keys a locale's messages file does not carry
+// (#10045 D2). Run before `next build` by `scripts/check-nav-labels.ts`.
+//
+// A locale's catalog is `messages/<locale>.json` plus the site overlay
+// `messages/site/<locale>.json` (falling back to `messages/site/en.json`),
+// matching how `i18n/request.ts` loads them, so a key the site adds in its
+// overlay counts as present.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+import { navMessageKeys } from "./nav-label-keys";
+
+export interface MissingNavLabel {
+  key: string;
+  /** The `messages/<locale>.json` file the key is missing from. */
+  file: string;
+}
+
+function readJson(file: string): unknown {
+  return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : undefined;
+}
+
+/** Every (key, messages file) pair where a used nav key has no text. */
+export function findMissingNavLabels(
+  messagesDir: string,
+  keys: Iterable<string>,
+): MissingNavLabel[] {
+  const wanted = [...new Set(keys)].sort();
+  const englishOverlay = join(messagesDir, "site", "en.json");
+  const missing: MissingNavLabel[] = [];
+  const catalogs = readdirSync(messagesDir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+    .map((entry) => entry.name)
+    .sort();
+  for (const name of catalogs) {
+    const file = join(messagesDir, name);
+    const ownOverlay = join(messagesDir, "site", name);
+    const overlay = existsSync(ownOverlay) ? ownOverlay : englishOverlay;
+    const present = new Set([
+      ...navMessageKeys(readJson(file)),
+      ...navMessageKeys(readJson(overlay)),
+    ]);
+    for (const key of wanted) {
+      if (!present.has(key)) missing.push({ key, file });
+    }
+  }
+  return missing;
+}
+
+/** One line per missing key, naming the key and the file. */
+export function formatMissingNavLabels(
+  missing: readonly MissingNavLabel[],
+): string {
+  return missing
+    .map(
+      ({ key, file }) =>
+        `nav key "${key}" is used by the site nav but missing from ${file} (namespace "nav")`,
+    )
+    .join("\n");
+}