create-ailk 0.13.0 → 0.15.0

package/dist/site-chrome.js

@@ -29,6 +29,21 @@
  * close): an unrecognized design NAME now fails in `resolveDesign`, before
  * this function ever sees one.
  */
+/**
+ * The `deckGrounds` knob's vocabulary (#7719 D3) — the shared section surface
+ * enum, duplicated from `@working-theory/validation`'s `SectionSurfaceSchema`
+ * because `create-ailk` cannot import it (one runtime dependency, § 1.5);
+ * `site-chrome.test.ts` proves the two lists equal.
+ */
+export const DECK_GROUND_VALUES = [
+    "none",
+    "gray-100",
+    "wash",
+    "wash-secondary",
+    "gradient-brand",
+    "gradient-dark",
+    "solid-dark",
+];
 /** Defaults (#5612 D1; banner off since #6469). */
 export const DEFAULT_SITE_CHROME = {
     nav: "full",
@@ -48,6 +63,17 @@ export class TemplateLayoutError extends Error {
 const NAV_VALUES = ["full", "mark-only"];
 const FOOTER_VALUES = ["columns", "centered"];
 const HOME_VALUES = ["default", "deck"];
+const INNER_PAGES_VALUES = ["default", "bare"];
+const COLOR_MODE_VALUES = ["user", "light"];
+const CHROME_STYLE_VALUES = ["default", "minimal"];
+/**
+ * A `closingFooterPaths` member (#7797): a route path as the site writes it —
+ * a leading "/" and no query, fragment, whitespace or control character. The
+ * layout normalizes the visitor's pathname (locale prefix, trailing slash)
+ * before comparing, so "/about" and "/about/" name the same page.
+ */
+// eslint-disable-next-line no-control-regex -- the class deliberately refuses control characters
+const CLOSING_FOOTER_PATH = /^\/[^\s?#\u0000-\u001f]*$/;
 /**
  * Validate an UNTRUSTED `layout` value (a bundle's `ailk-template.json`
  * `layout` field — arbitrary JSON, never compile-time checked the way the
@@ -92,6 +118,50 @@ export function validateTemplateLayout(value, subject) {
         }
         result.home = raw.home;
     }
+    if ("deckGrounds" in raw && raw.deckGrounds !== undefined) {
+        const grounds = raw.deckGrounds;
+        const badIndex = Array.isArray(grounds)
+            ? grounds.findIndex((g) => !DECK_GROUND_VALUES.includes(g))
+            : -1;
+        if (!Array.isArray(grounds) || grounds.length === 0 || badIndex !== -1) {
+            throw new TemplateLayoutError(`${subject}: layout.deckGrounds must be a non-empty list of ${DECK_GROUND_VALUES.join(", ")} — got ${JSON.stringify(badIndex !== -1 ? grounds[badIndex] : grounds)}`);
+        }
+        result.deckGrounds = grounds;
+    }
+    if ("innerPages" in raw && raw.innerPages !== undefined) {
+        if (!INNER_PAGES_VALUES.includes(raw.innerPages)) {
+            throw new TemplateLayoutError(`${subject}: layout.innerPages must be one of ${INNER_PAGES_VALUES.join(", ")} — got ${JSON.stringify(raw.innerPages)}`);
+        }
+        result.innerPages = raw.innerPages;
+    }
+    if ("deckPresentation" in raw && raw.deckPresentation !== undefined) {
+        if (typeof raw.deckPresentation !== "boolean") {
+            throw new TemplateLayoutError(`${subject}: layout.deckPresentation must be a boolean — got ${JSON.stringify(raw.deckPresentation)}`);
+        }
+        result.deckPresentation = raw.deckPresentation;
+    }
+    if ("colorMode" in raw && raw.colorMode !== undefined) {
+        if (!COLOR_MODE_VALUES.includes(raw.colorMode)) {
+            throw new TemplateLayoutError(`${subject}: layout.colorMode must be one of ${COLOR_MODE_VALUES.join(", ")} — got ${JSON.stringify(raw.colorMode)}`);
+        }
+        result.colorMode = raw.colorMode;
+    }
+    if ("chromeStyle" in raw && raw.chromeStyle !== undefined) {
+        if (!CHROME_STYLE_VALUES.includes(raw.chromeStyle)) {
+            throw new TemplateLayoutError(`${subject}: layout.chromeStyle must be one of ${CHROME_STYLE_VALUES.join(", ")} — got ${JSON.stringify(raw.chromeStyle)}`);
+        }
+        result.chromeStyle = raw.chromeStyle;
+    }
+    if ("closingFooterPaths" in raw && raw.closingFooterPaths !== undefined) {
+        const paths = raw.closingFooterPaths;
+        const badIndex = Array.isArray(paths)
+            ? paths.findIndex((p) => typeof p !== "string" || !CLOSING_FOOTER_PATH.test(p))
+            : -1;
+        if (!Array.isArray(paths) || paths.length === 0 || badIndex !== -1) {
+            throw new TemplateLayoutError(`${subject}: layout.closingFooterPaths must be a non-empty list of route paths ("/about") with no query or fragment — got ${JSON.stringify(badIndex !== -1 ? paths[badIndex] : paths)}`);
+        }
+        result.closingFooterPaths = paths;
+    }
     return result;
 }
 /**
@@ -113,7 +183,7 @@ export function resolveSiteChrome(layout, designLayout) {
         throw new TypeError(`resolveSiteChrome: designLayout must be a layout object, got ${JSON.stringify(designLayout)}`);
     }
     const fromDesign = designLayout ?? {};
-    return {
+    const resolved = {
         nav: layout?.nav ?? fromDesign.nav ?? DEFAULT_SITE_CHROME.nav,
         footer: layout?.footer ?? fromDesign.footer ?? DEFAULT_SITE_CHROME.footer,
         announcementBanner: layout?.announcementBanner ??
@@ -121,6 +191,35 @@ export function resolveSiteChrome(layout, designLayout) {
             DEFAULT_SITE_CHROME.announcementBanner,
         home: layout?.home ?? fromDesign.home ?? DEFAULT_SITE_CHROME.home,
     };
+    // #7719 D3 — the grounds resolve as a whole list, and only a deck keeps them.
+    const deckGrounds = layout?.deckGrounds ?? fromDesign.deckGrounds;
+    if (deckGrounds !== undefined && resolved.home === "deck") {
+        resolved.deckGrounds = deckGrounds;
+    }
+    // #7721 D1 — only "bare" is ever a key, so a chrome that does not opt in
+    // (unset, or an explicit "default") resolves exactly as before.
+    if ((layout?.innerPages ?? fromDesign.innerPages) === "bare") {
+        resolved.innerPages = "bare";
+    }
+    // #7740 D1 — only `true` on a deck is ever a key: an explicit layout
+    // `false` wins over the design's `true`, and a non-deck home drops it.
+    if ((layout?.deckPresentation ?? fromDesign.deckPresentation) === true && resolved.home === "deck") {
+        resolved.deckPresentation = true;
+    }
+    // #7742 D1 — as with `innerPages`, only the opt-in value is ever a key.
+    if ((layout?.colorMode ?? fromDesign.colorMode) === "light") {
+        resolved.colorMode = "light";
+    }
+    if ((layout?.chromeStyle ?? fromDesign.chromeStyle) === "minimal") {
+        resolved.chromeStyle = "minimal";
+    }
+    // #7797 D1 — the list resolves as a whole (an explicit layout wins over the
+    // design's), and only a non-empty list is ever a key.
+    const closingFooterPaths = layout?.closingFooterPaths ?? fromDesign.closingFooterPaths;
+    if (closingFooterPaths !== undefined && closingFooterPaths.length > 0) {
+        resolved.closingFooterPaths = closingFooterPaths;
+    }
+    return resolved;
 }
 /**
  * Render `apps/web/lib/site-chrome.ts` for a resolved layout — the same
@@ -130,6 +229,30 @@ export function resolveSiteChrome(layout, designLayout) {
  * `snap="mandatory"` + `deckHero` to MarketingShell.
  */
 export function renderSiteChrome(resolved) {
+    // #7719 D3 — each `deckGrounds` line is emitted only when the chrome has one,
+    // so a chrome without it renders today's text exactly.
+    const grounds = resolved.deckGrounds;
+    const groundsComment = grounds === undefined
+        ? ""
+        : "\n//   - deckGrounds → the deck home cycles these surfaces, slide by slide, onto slides that author none";
+    const groundsMember = grounds === undefined
+        ? ""
+        : `\n  deckGrounds?: readonly (${DECK_GROUND_VALUES.map((g) => JSON.stringify(g)).join(" | ")})[];`;
+    const groundsValue = grounds === undefined ? "" : `\n  deckGrounds: [${grounds.map((g) => JSON.stringify(g)).join(", ")}],`;
+    // #7721 D1 — the value line only for a bare chrome; the interface member
+    // and comment bullet always, so the layout reads `siteChrome.innerPages`.
+    const innerPagesValue = resolved.innerPages === "bare" ? '\n  innerPages: "bare",' : "";
+    // #7740 D1 — `innerPages`' form: the member and bullet always, the value
+    // line only when the chrome presents.
+    const presentationValue = resolved.deckPresentation === true ? "\n  deckPresentation: true," : "";
+    // #7742 D1 — the same form again: member and bullet always, value lines
+    // only for the opt-in values.
+    const colorModeValue = resolved.colorMode === "light" ? '\n  colorMode: "light",' : "";
+    const chromeStyleValue = resolved.chromeStyle === "minimal" ? '\n  chromeStyle: "minimal",' : "";
+    // #7797 D1 — the same form: member and bullet always, the value line only for a non-empty list.
+    const closingFooterPathsValue = resolved.closingFooterPaths === undefined
+        ? ""
+        : `\n  closingFooterPaths: [${resolved.closingFooterPaths.map((p) => JSON.stringify(p)).join(", ")}],`;
     return `// site-chrome.ts — resolved template layout knobs.
 //
 // GENERATED by create-ailk from the declared template's \`layout\` block
@@ -145,19 +268,34 @@ export function renderSiteChrome(resolved) {
 //   - home: "deck" → the locale-root route mounts MarketingShell with
 //     snap="mandatory" + deckHero (spec 5426 D7); every other route is
 //     unaffected.
+//   - innerPages: "bare" → every non-home page renders the bare header and
+//     the one-bar footer.
+//   - deckPresentation → the deck home presents slide by slide: fitted slides, slide anchors, the mark follows the ground
+//   - colorMode: "light" → the site is pinned to light and shows no theme
+//     switch; dark appears only as a deck ground.
+//   - chromeStyle: "minimal" → the deck's closing slide is the wordmark,
+//     contact lines and one legal line; the consent bar is a hairline bar on
+//     the page ground; the 404 renders in the site's theme.
+//   - closingFooterPaths → each listed inner page ends on the closing footer
+//     (the wordmark, contact lines and legal line) instead of its usual footer.${groundsComment}
 
 export interface SiteChrome {
   nav: "full" | "mark-only";
   footer: "columns" | "centered";
   announcementBanner: boolean;
   home: "default" | "deck";
+  innerPages?: "bare";
+  deckPresentation?: true;
+  colorMode?: "light";
+  chromeStyle?: "minimal";
+  closingFooterPaths?: readonly string[];${groundsMember}
 }
 
 export const siteChrome: SiteChrome = {
   nav: ${JSON.stringify(resolved.nav)},
   footer: ${JSON.stringify(resolved.footer)},
   announcementBanner: ${JSON.stringify(resolved.announcementBanner)},
-  home: ${JSON.stringify(resolved.home)},
+  home: ${JSON.stringify(resolved.home)},${groundsValue}${innerPagesValue}${presentationValue}${colorModeValue}${chromeStyleValue}${closingFooterPathsValue}
 };
 `;
 }

package/dist/site-fonts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The web faces a design's typography sources (#7720, spec
+ * docs/specs/7720-a-web-font-source-and-spec.md D3.2) — rendered into the
+ * generated `apps/web/lib/site-fonts.ts` every scaffold gets, beside
+ * `site-chrome.ts` and in the same GENERATED-header idiom.
+ *
+ * next/font/google picks a face by the imported function's name and needs
+ * literal options at a module-scope call site, so a face cannot be chosen
+ * from the request-time `theme:` block — it is chosen here, at scaffold and
+ * apply-design time, as source text. The faces download at the site's
+ * `next build` and are served from its own origin, which the CSP's
+ * `font-src 'self'` already allows.
+ *
+ * With no sourced face the render is the empty default, byte-identical to the
+ * monorepo's own committed `apps/web/lib/site-fonts.ts`.
+ */
+import type { CompiledDesignFonts } from "./design-compile.js";
+/** Template-relative path of the generated site-fonts module — beside `SITE_CHROME_PATH`. */
+export declare const SITE_FONTS_PATH = "apps/web/lib/site-fonts.ts";
+/** Render `apps/web/lib/site-fonts.ts` for `fonts` (D3.2). Ends with a trailing newline. */
+export declare function renderSiteFonts(fonts: CompiledDesignFonts | undefined): string;

package/dist/site-fonts.js

@@ -0,0 +1,54 @@
+/** Template-relative path of the generated site-fonts module — beside `SITE_CHROME_PATH`. */
+export const SITE_FONTS_PATH = "apps/web/lib/site-fonts.ts";
+const HEADER = `// site-fonts.ts — the web faces the site's design sources.
+//
+// GENERATED by create-ailk from the design's \`typography.<role>.fontSource\`
+// (#7720). A design that sources no face gets the empty default.
+// \`apps/web/app/[locale]/layout.tsx\` passes this to \`applyDesignFonts\`
+// (@working-theory/theme): \`families\` fills --font-display / --font-body
+// unless the site's own \`brand.fonts\` sets them, and \`className\` (the
+// next/font variable classes) goes on <html>.
+`;
+const INTERFACE = `export interface SiteFonts {
+  className: string;
+  families: { display?: string | undefined; body?: string | undefined };
+}
+`;
+/** Render `apps/web/lib/site-fonts.ts` for `fonts` (D3.2). Ends with a trailing newline. */
+export function renderSiteFonts(fonts) {
+    const faces = ["display", "body"].flatMap((role) => {
+        const face = fonts?.[role];
+        return face !== undefined ? [{ role, face }] : [];
+    });
+    if (faces.length === 0) {
+        return `${HEADER}\n${INTERFACE}\nexport const siteFonts: SiteFonts = { className: "", families: {} };\n`;
+    }
+    // One loader per distinct family, named for the first role using it (display before body).
+    const slotOf = new Map();
+    for (const { role, face } of faces) {
+        if (!slotOf.has(face.family))
+            slotOf.set(face.family, role);
+    }
+    const exportName = (family) => family.replace(/ /g, "_");
+    const imports = [...slotOf.keys()].map(exportName).sort();
+    const loaders = [...slotOf].map(([family, slot]) => `const ${slot}Face = ${exportName(family)}({ subsets: ${JSON.stringify(["latin"])}, variable: ${JSON.stringify(`--font-design-${slot}`)} });`);
+    const className = [...slotOf.values()].map((slot) => `${slot}Face.variable`).join(", ");
+    const families = faces.map(({ role, face }) => {
+        const slot = slotOf.get(face.family) ?? role;
+        const value = `var(--font-design-${slot})${face.fallback === "" ? "" : `, ${face.fallback}`}`;
+        return `    ${role}: ${JSON.stringify(value)},`;
+    });
+    return `${HEADER}
+import { ${imports.join(", ")} } from "next/font/google";
+
+${INTERFACE}
+${loaders.join("\n")}
+
+export const siteFonts: SiteFonts = {
+  className: [${className}].join(" "),
+  families: {
+${families.join("\n")}
+  },
+};
+`;
+}

package/dist/site-manifest.d.ts

@@ -2,6 +2,7 @@ import type { Level } from "./lib/module-tier.js";
 import type { ModuleName } from "./parse-args.js";
 import { type SiteRoster } from "./site-roster.js";
 import type { MarkerMap } from "./substitute.js";
+import type { Topology } from "./topology.js";
 export interface PlanSiteManifestOptions {
     targetDir: string;
     /** The installed manifest, read after every layer landed. */
@@ -10,16 +11,22 @@ export interface PlanSiteManifestOptions {
     modules: readonly ModuleName[];
     /** The level the key path derived, or undefined when it derived none. */
     level: Level | undefined;
+    /** The scaffold's topology (#7426 D10). */
+    topology: Topology;
+    /** The create-ailk version that wrote the scaffold (`CREATE_AILK_VERSION`). */
+    patternVersion: string;
     siteTemplatesDir: string;
     templatesDir: string;
     markers: MarkerMap;
 }
 /**
- * The manifest's next text: `modules` (and `level`, when derived) after
- * `requires`, and a row for every route present on disk.
+ * The manifest's next text: `modules` (and `level`, when derived), then
+ * `topology` and `patternVersion`, after `requires`, and a row for every
+ * route present on disk.
  *
- * @throws AddModuleRefusedError when the file already records `modules` or
- *   `level`, or its layout is not the generator's (`rows` last, `requires`
- *   at the top level) — guessing would silently mis-record the site.
+ * @throws AddModuleRefusedError when the file already records `modules`,
+ *   `level`, `topology` or `patternVersion`, or its layout is not the
+ *   generator's (`rows` last, `requires` at the top level) — guessing would
+ *   silently mis-record the site.
  */
 export declare function planSiteManifest(opts: PlanSiteManifestOptions): string;

package/dist/site-manifest.js

@@ -15,6 +15,10 @@
  *     (`resolveModuleSet` / `deriveLevel`). Never inferred from `modules`:
  *     the level comes only from the key. An alias or `--modules` keep run
  *     derives none and records none;
+ *   - `topology` and `patternVersion` (#7426 D10) — `"hub"` or `"spoke"`,
+ *     and the create-ailk version that wrote the files, on every scaffold.
+ *     A site with no `topology` predates the option and reads as a hub
+ *     (`topology.ts` `readSiteTopology`);
  *   - a row for every route present on disk — each module's contributed rows
  *     through `planRosterAppend` (add-module's own append), the sample pages
  *     a module's bundle installs (`sampleRows`), and a code-route row for any
@@ -51,16 +55,18 @@ const CODE_ROUTE_ROW = {
     sections: [],
 };
 /**
- * The manifest's next text: `modules` (and `level`, when derived) after
- * `requires`, and a row for every route present on disk.
+ * The manifest's next text: `modules` (and `level`, when derived), then
+ * `topology` and `patternVersion`, after `requires`, and a row for every
+ * route present on disk.
  *
- * @throws AddModuleRefusedError when the file already records `modules` or
- *   `level`, or its layout is not the generator's (`rows` last, `requires`
- *   at the top level) — guessing would silently mis-record the site.
+ * @throws AddModuleRefusedError when the file already records `modules`,
+ *   `level`, `topology` or `patternVersion`, or its layout is not the
+ *   generator's (`rows` last, `requires` at the top level) — guessing would
+ *   silently mis-record the site.
  */
 export function planSiteManifest(opts) {
     const { roster } = opts;
-    for (const key of ["modules", "level"]) {
+    for (const key of ["modules", "level", "topology", "patternVersion"]) {
         if (key in roster.doc) {
             throw new AddModuleRefusedError(`${roster.path} already records "${key}"`);
         }
@@ -81,7 +87,7 @@ export function planSiteManifest(opts) {
         ...codeRouteRows(opts.targetDir, declared),
     ];
     const withRows = appendRows(appended, extra, roster);
-    return insertRecord(withRows, opts.modules, opts.level, roster.path);
+    return insertRecord(withRows, opts, roster.path);
 }
 /**
  * The rows for the sample pages a module's bundle installs through its
@@ -233,8 +239,12 @@ function appendRows(text, rows, roster) {
         ? text.slice(0, end) + rendered + roster.trail + text.slice(close)
         : text.slice(0, end) + "," + rendered + text.slice(end);
 }
-/** `text` with `modules` (and `level`, when derived) inserted after the top-level `requires`. */
-function insertRecord(text, modules, level, label) {
+/**
+ * `text` with `modules` (and `level`, when derived), `topology` and
+ * `patternVersion` inserted after the top-level `requires`.
+ */
+function insertRecord(text, opts, label) {
+    const { modules, level, topology, patternVersion } = opts;
     const anchor = '\n  "requires": ';
     const at = text.indexOf(anchor);
     if (at === -1 || text.indexOf(anchor, at + 1) !== -1) {
@@ -243,11 +253,15 @@ function insertRecord(text, modules, level, label) {
     const end = text.indexOf("]", at) + 1;
     const name = '"modules": ';
     const record = `,\n  ${name}${renderJson([...modules], 2, name.length, 1)}` +
-        (level !== undefined ? `,\n  "level": ${JSON.stringify(level)}` : "");
+        (level !== undefined ? `,\n  "level": ${JSON.stringify(level)}` : "") +
+        `,\n  "topology": ${JSON.stringify(topology)}` +
+        `,\n  "patternVersion": ${JSON.stringify(patternVersion)}`;
     const next = text.slice(0, end) + record + text.slice(end);
     const doc = JSON.parse(next);
     if (!isDeepStrictEqual(doc["modules"], [...modules]) ||
-        doc["level"] !== level) {
+        doc["level"] !== level ||
+        doc["topology"] !== topology ||
+        doc["patternVersion"] !== patternVersion) {
         throw new AddModuleRefusedError(`${label}: the module set could not be recorded beside "requires"`);
     }
     return next;

package/dist/site-roster.d.ts

@@ -1,4 +1,5 @@
 import type { CompiledDesignTheme } from "./design-compile.js";
+import { type SectionLookCatalog } from "./design-presets.js";
 import { type PageRosterRow } from "./module-architecture.js";
 import type { ModuleName } from "./parse-args.js";
 import type { ResolvedSiteChrome } from "./site-chrome.js";
@@ -76,6 +77,21 @@ export interface SiteManifestDesignNext {
  *   never reaches this function (`scaffold()` guards on the file's presence).
  */
 export declare function planSiteManifestDesign(text: string, next: SiteManifestDesignNext, label: string): string | undefined;
+/**
+ * `build-template-manifest.mjs`'s `OPTION_KEYS` — the section `data` keys
+ * whose scalar values a manifest row's `sections[].options` records. A
+ * duplicate (the script is not importable here); a test pins the two equal.
+ */
+export declare const MANIFEST_OPTION_KEYS: readonly ["itemStyle", "actionsPosition", "gapBelow", "measure", "cardLayout", "layout", "size", "surface", "imagerySlot", "headingLevel", "align", "tone", "columns", "density", "fill", "accentStyle"];
+/**
+ * Plan the manifest's `/` row `sections` as the home's sections (#7743 D6):
+ * `[{ type, component, options? }]`, `options` being the section's scalar
+ * `MANIFEST_OPTION_KEYS` values, as the generator writes them. `undefined`
+ * when the record already says so, or the manifest has no `/` row with a
+ * `sections` key. The value is spliced in place at its own depth; no other
+ * byte moves.
+ */
+export declare function planHomeRecord(manifestText: string, homeText: string, catalog: SectionLookCatalog): string | undefined;
 /**
  * The generator's row for each of a module's `pageContributions`, in
  * declaration order — read from the committed manifest of the first

package/dist/site-roster.js

@@ -27,6 +27,8 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { AddModuleRefusedError, readArchitectureHeader, } from "./add-module-core.js";
+import { HOME_PAGE_PATH } from "./design-home.js";
+import { locatePageSections } from "./design-presets.js";
 import { diffTwoStrings } from "./lib/extract-module-bundle.js";
 import { MODULE_SLICES, normalizeModules, } from "./module-architecture.js";
 import { substituteMarkers } from "./substitute.js";
@@ -234,6 +236,85 @@ export function planSiteManifestDesign(text, next, label) {
     }
     return result;
 }
+// ── #7743 D6: the `/` row records the home's sections ─────────────────────
+/**
+ * `build-template-manifest.mjs`'s `OPTION_KEYS` — the section `data` keys
+ * whose scalar values a manifest row's `sections[].options` records. A
+ * duplicate (the script is not importable here); a test pins the two equal.
+ */
+export const MANIFEST_OPTION_KEYS = [
+    "itemStyle",
+    "actionsPosition",
+    "gapBelow",
+    "measure",
+    "cardLayout",
+    "layout",
+    "size",
+    "surface",
+    "imagerySlot",
+    "headingLevel",
+    "align",
+    "tone",
+    "columns",
+    "density",
+    "fill",
+    "accentStyle",
+];
+/** A raw YAML scalar's value — a JSON scalar, a single-quoted string or a plain one — or undefined for a collection or null. */
+function scalarValue(raw) {
+    const text = raw.trim();
+    if (text.startsWith("{") || text.startsWith("["))
+        return undefined;
+    if (text.startsWith("'"))
+        return text.slice(1, -1).replace(/''/g, "'");
+    try {
+        const value = JSON.parse(text);
+        return value === null || typeof value === "object" ? undefined : value;
+    }
+    catch {
+        return text;
+    }
+}
+/**
+ * Plan the manifest's `/` row `sections` as the home's sections (#7743 D6):
+ * `[{ type, component, options? }]`, `options` being the section's scalar
+ * `MANIFEST_OPTION_KEYS` values, as the generator writes them. `undefined`
+ * when the record already says so, or the manifest has no `/` row with a
+ * `sections` key. The value is spliced in place at its own depth; no other
+ * byte moves.
+ */
+export function planHomeRecord(manifestText, homeText, catalog) {
+    const file = parseRosterFile(manifestText, SITE_ROSTER_PATH);
+    const row = file.rows.find((r) => r.value["route"] === "/");
+    if (row === undefined || !("sections" in row.value))
+        return undefined;
+    const sections = (locatePageSections(homeText, HOME_PAGE_PATH) ?? []).map((section) => {
+        const options = {};
+        for (const key of MANIFEST_OPTION_KEYS) {
+            const entry = section.entries.find((e) => e.key === key);
+            const value = entry === undefined ? undefined : scalarValue(homeText.slice(entry.valueStart, entry.valueEnd));
+            if (value !== undefined)
+                options[key] = value;
+        }
+        return {
+            type: section.type,
+            component: catalog[section.type]?.component ?? section.type,
+            ...(Object.keys(options).length > 0 ? { options } : {}),
+        };
+    });
+    if (isDeepStrictEqual(row.value["sections"], sections))
+        return undefined;
+    const rowStart = manifestText.indexOf(row.text, file.open);
+    const at = findKey(row.text, 0, "sections");
+    const end = endOfValue(row.text, at.valueStart);
+    const column = at.keyStart - (row.text.lastIndexOf("\n", at.keyStart) + 1);
+    const rendered = JSON.stringify(sections, null, 2)
+        .split("\n")
+        .map((line, i) => (i === 0 ? line : `${" ".repeat(column)}${line}`))
+        .join("\n");
+    const rowText = row.text.slice(0, at.valueStart) + rendered + row.text.slice(end);
+    return manifestText.slice(0, rowStart) + rowText + manifestText.slice(rowStart + row.text.length);
+}
 // ── D2: a module's rows, from the shipped manifests ───────────────────────
 /** A template's shipped manifest, or undefined when its tree ships none. */
 function readShippedManifest(siteTemplatesDir, templateName) {

package/dist/starter-grid.js

@@ -170,6 +170,18 @@ const PORTFOLIO_ROWS = [
     { route: "/portfolio", content: ["content/en/PortfolioList/portfolio.mdx"] },
     { route: "/portfolio/[slug]", contentDir: "content/en/PortfolioItem" },
 ];
+/**
+ * The team pages (#7744, checklist D1) — a TeamList hub at `/team` and one
+ * TeamMember profile per person at `/team/<slug>`, each emitting a
+ * `ProfilePage` whose main entity is that `Person`. They belong to the three
+ * ORGANIZATION shapes; person-service is one person and carries none. The
+ * seeds live in the `_base` layer under `content/en/TeamMember/`; the detail
+ * row's `contentDir` installs them, exactly as `PORTFOLIO_ROWS` does.
+ */
+const TEAM_ROWS = [
+    { route: "/team", content: ["content/en/TeamList/team.mdx"] },
+    { route: "/team/[slug]", contentDir: "content/en/TeamMember" },
+];
 /**
  * The two report/referral sample rows. Neither carries a `GATEABLE_SURFACES`
  * entry: `/referral` is a single-segment `LandingPage` slug served by the
@@ -308,18 +320,21 @@ export const SHAPE_ROSTERS = Object.freeze({
         FREE_BLOG_TEASER_ROW,
         ...FREE_MEET_PLACEHOLDER_ROWS,
         ...PORTFOLIO_ROWS,
+        ...TEAM_ROWS,
     ],
     "organization-service": [
         ...ORGANIZATION_SERVICE_ROWS,
         FREE_BLOG_TEASER_ROW,
         ...FREE_MEET_PLACEHOLDER_ROWS,
         ...PORTFOLIO_ROWS,
+        ...TEAM_ROWS,
     ],
     "local-business-service": [
         ...LOCAL_BUSINESS_SERVICE_ROWS,
         FREE_BLOG_TEASER_ROW,
         ...FREE_MEET_PLACEHOLDER_ROWS,
         ...PORTFOLIO_ROWS,
+        ...TEAM_ROWS,
     ],
     "person-service": [
         ...PERSON_SERVICE_ROWS,

package/dist/surfaces.js

@@ -299,6 +299,13 @@ export const GATEABLE_SURFACES = [
         routes: [`${ROUTE_ROOT}/software`],
         content: ["content/<locale>/SoftwareProduct"],
     },
+    {
+        // #7744 — the team profile pages, module-less: a roster row enables it,
+        // so only the organization shapes ship /team (person-service does not).
+        id: "team",
+        routes: [`${ROUTE_ROOT}/team`],
+        content: ["content/<locale>/TeamList", "content/<locale>/TeamMember"],
+    },
     {
         id: "tech-articles",
         routes: [`${ROUTE_ROOT}/tech-articles`],
@@ -583,6 +590,9 @@ export const ROUTE_SINCE = {
     "services/[slug]": "0.0.0",
     software: "0.0.0",
     "software/[slug]": "0.0.0",
+    // #7744 — the team profile pages, a new route pair at today's line.
+    team: "0.35.0",
+    "team/[slug]": "0.35.0",
     "tech-articles": "0.0.0",
     "tech-articles/[slug]": "0.0.0",
     terms: "0.22.0",
@@ -824,6 +834,8 @@ export const ROUTE_MESSAGE_NAMESPACES = {
     "(authed)/admin/site": ["admin"],
     "(authed)/admin/team": ["admin"],
     "(authed)/waitlist": ["waitlistDashboard.gate"],
+    // #7744 — the /team hub's empty state reads the `team` namespace.
+    team: ["team"],
 };
 /** Template-relative path of the generated site-nav registry. */
 export const NAV_CONFIG_PATH = "apps/web/lib/nav-config.ts";

package/dist/sync-routes.js

@@ -33,6 +33,7 @@ import { parseArgs } from "node:util";
 import { copyTemplate } from "./copy.js";
 import { substituteMarkers } from "./substitute.js";
 import { GATEABLE_SURFACES, NON_ROUTE_DIRS, ROUTE_DEPENDENCIES, ROUTE_MESSAGE_NAMESPACES, ROUTE_SINCE, surfaceForRouteDir, } from "./surfaces.js";
+import { isSpokeExcluded, readSiteTopology } from "./topology.js";
 /** Template-relative prefix every `apps/web` route directory sits under. */
 const ROUTE_ROOT = "apps/web/app/[locale]";
 /**
@@ -163,12 +164,20 @@ export function syncRoutes(opts) {
             skippedSurfaces.push(surface.id);
     }
     skippedSurfaces.sort();
+    // #7426 D13 — on a spoke, a route dir the spoke does not carry (the
+    // `(auth)` and `(authed)` groups) is out of scope: neither reported nor
+    // copied. This is the one filter point for add-module, add-route and the
+    // sync-routes subcommand alike; a hub's scope is unchanged.
+    const spoke = readSiteTopology(targetAbs) === "spoke"
+        ? { mcp: existsSync(join(targetAbs, "apps", "mcp")) }
+        : undefined;
     const inScope = listTemplateRouteDirs(opts.templatesDir)
         .map(reportFor)
         // "authed" (#5014): the `(authed)` route group ships unconditionally in
-        // every scaffold today, the same as "core" — it is checked regardless of
+        // every hub scaffold, the same as "core" — it is checked regardless of
         // `carried`, which only tracks GATEABLE_SURFACES opt-in.
-        .filter((r) => r.surface === "core" || r.surface === "authed" || carried.has(r.surface));
+        .filter((r) => r.surface === "core" || r.surface === "authed" || carried.has(r.surface))
+        .filter((r) => spoke === undefined || !isSpokeExcluded(`${ROUTE_ROOT}/${r.route}`, spoke));
     // Identical to scaffoldSync's defaults, so a synced route matches a fresh
     // scaffold of the same target byte-for-byte.
     const markers = {

package/dist/team-profiles.d.ts

@@ -0,0 +1,29 @@
+/**
+ * One people-slide / team-index member: the `team` section's member shape,
+ * declared here because create-ailk depends on neither
+ * `@working-theory/validation` nor `yaml`.
+ */
+export interface TeamSlideMember {
+    readonly name: string;
+    readonly role: string;
+    readonly links: readonly [
+        {
+            readonly type: "page";
+            readonly url: string;
+            readonly label: string;
+        }
+    ];
+}
+/**
+ * The three seeded people, in seed order: slug, the seed's `title` as `name`,
+ * "{Their title}", and a page link to `/team/<slug>` labelled "{View profile}".
+ */
+export declare const TEAM_SEED_MEMBERS: readonly (TeamSlideMember & {
+    readonly slug: string;
+})[];
+/**
+ * `TEAM_SEED_MEMBERS` whose `<siteRoot>/content/en/TeamMember/<slug>.mdx`
+ * exists (without `slug`), or `undefined` when none does (person-service, or
+ * a site that deleted them). Reads, never writes.
+ */
+export declare function teamSlideMembers(siteRoot: string): TeamSlideMember[] | undefined;