create-ailk 0.8.0 → 0.10.0

package/dist/site-chrome.d.ts

@@ -21,11 +21,14 @@
  * block, gets these defaults written, byte-identical to the monorepo's own
  * committed `apps/web/lib/site-chrome.ts`.
  *
- * A template's DESIGN supplies layout knobs too (#6638): `DESIGN_LAYOUTS` in
- * `template-manifest.ts`, read by `resolveSiteChrome`'s optional `design`
- * argument between an explicit `layout` and these defaults.
+ * A design supplies layout knobs too (#6638, widened #6813 D4): its OWN
+ * `layout` (a `DesignPackage`'s, read by `design-scaffold.ts`'s
+ * `resolveDesign`), passed as `resolveSiteChrome`'s optional `designLayout`
+ * argument between an explicit `layout` and these defaults. This module
+ * imports nothing from `template-manifest.ts` (the cycle that import used to
+ * close): an unrecognized design NAME now fails in `resolveDesign`, before
+ * this function ever sees one.
  */
-import { type StarterDesign } from "./template-manifest.js";
 /** The `nav` knob's vocabulary. `mark-only` → the layout passes Nav an empty
  *  `navItems` (brand mark + the existing actions/theme/locale controls only). */
 export type SiteChromeNav = "full" | "mark-only";
@@ -75,12 +78,19 @@ export declare class TemplateLayoutError extends Error {
  */
 export declare function validateTemplateLayout(value: unknown, subject: string): TemplateLayout;
 /**
- * Fill every field a `TemplateLayout` leaves unset — from `design`'s
- * `DESIGN_LAYOUTS` entry when one is named (#6638), then from
- * `DEFAULT_SITE_CHROME`. The explicit `layout` wins field by field, so a
- * template can wear a design and still override one knob of it.
+ * Fill every field a `TemplateLayout` leaves unset — from `designLayout`
+ * (a design package's own resolved `layout`, #6638/#6813 D4) when one is
+ * given, then from `DEFAULT_SITE_CHROME`. The explicit `layout` wins field by
+ * field, so a template can wear a design and still override one knob of it.
+ *
+ * `designLayout` is typed `TemplateLayout`, but a `.mjs` caller
+ * (`build-template-manifest.mjs`) cannot be compile-time checked the way a
+ * `.ts` caller can, so the type alone cannot stop a caller passing a design
+ * NAME (a string) rather than its resolved layout: a runtime guard throws a
+ * `TypeError` naming what was given, rather than silently resolving to the
+ * defaults.
  */
-export declare function resolveSiteChrome(layout?: TemplateLayout, design?: StarterDesign): ResolvedSiteChrome;
+export declare function resolveSiteChrome(layout?: TemplateLayout, designLayout?: TemplateLayout): ResolvedSiteChrome;
 /**
  * Render `apps/web/lib/site-chrome.ts` for a resolved layout — the same
  * GENERATED-header idiom `renderNavConfig` uses. `layout.tsx` imports

package/dist/site-chrome.js

@@ -21,11 +21,14 @@
  * block, gets these defaults written, byte-identical to the monorepo's own
  * committed `apps/web/lib/site-chrome.ts`.
  *
- * A template's DESIGN supplies layout knobs too (#6638): `DESIGN_LAYOUTS` in
- * `template-manifest.ts`, read by `resolveSiteChrome`'s optional `design`
- * argument between an explicit `layout` and these defaults.
+ * A design supplies layout knobs too (#6638, widened #6813 D4): its OWN
+ * `layout` (a `DesignPackage`'s, read by `design-scaffold.ts`'s
+ * `resolveDesign`), passed as `resolveSiteChrome`'s optional `designLayout`
+ * argument between an explicit `layout` and these defaults. This module
+ * imports nothing from `template-manifest.ts` (the cycle that import used to
+ * close): an unrecognized design NAME now fails in `resolveDesign`, before
+ * this function ever sees one.
  */
-import { DESIGN_LAYOUTS, TemplateError, } from "./template-manifest.js";
 /** Defaults (#5612 D1; banner off since #6469). */
 export const DEFAULT_SITE_CHROME = {
     nav: "full",
@@ -92,17 +95,24 @@ export function validateTemplateLayout(value, subject) {
     return result;
 }
 /**
- * Fill every field a `TemplateLayout` leaves unset — from `design`'s
- * `DESIGN_LAYOUTS` entry when one is named (#6638), then from
- * `DEFAULT_SITE_CHROME`. The explicit `layout` wins field by field, so a
- * template can wear a design and still override one knob of it.
+ * Fill every field a `TemplateLayout` leaves unset — from `designLayout`
+ * (a design package's own resolved `layout`, #6638/#6813 D4) when one is
+ * given, then from `DEFAULT_SITE_CHROME`. The explicit `layout` wins field by
+ * field, so a template can wear a design and still override one knob of it.
+ *
+ * `designLayout` is typed `TemplateLayout`, but a `.mjs` caller
+ * (`build-template-manifest.mjs`) cannot be compile-time checked the way a
+ * `.ts` caller can, so the type alone cannot stop a caller passing a design
+ * NAME (a string) rather than its resolved layout: a runtime guard throws a
+ * `TypeError` naming what was given, rather than silently resolving to the
+ * defaults.
  */
-export function resolveSiteChrome(layout, design) {
-    const fromDesign = design !== undefined ? DESIGN_LAYOUTS[design] : {};
-    // A JS caller (or a cast) can reach here with an undeclared design.
-    if (fromDesign === undefined) {
-        throw new TemplateError(`unknown design "${design}". Declared: ${Object.keys(DESIGN_LAYOUTS).join(", ")}`);
+export function resolveSiteChrome(layout, designLayout) {
+    if (designLayout !== undefined &&
+        (typeof designLayout !== "object" || designLayout === null || Array.isArray(designLayout))) {
+        throw new TypeError(`resolveSiteChrome: designLayout must be a layout object, got ${JSON.stringify(designLayout)}`);
     }
+    const fromDesign = designLayout ?? {};
     return {
         nav: layout?.nav ?? fromDesign.nav ?? DEFAULT_SITE_CHROME.nav,
         footer: layout?.footer ?? fromDesign.footer ?? DEFAULT_SITE_CHROME.footer,

package/dist/site-manifest.d.ts

@@ -0,0 +1,25 @@
+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";
+export interface PlanSiteManifestOptions {
+    targetDir: string;
+    /** The installed manifest, read after every layer landed. */
+    roster: SiteRoster;
+    /** The effective module set the scaffold installed. */
+    modules: readonly ModuleName[];
+    /** The level the key path derived, or undefined when it derived none. */
+    level: Level | undefined;
+    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.
+ *
+ * @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.
+ */
+export declare function planSiteManifest(opts: PlanSiteManifestOptions): string;

package/dist/site-manifest.js

@@ -0,0 +1,254 @@
+/**
+ * The site manifest's record of what the scaffold IS (#6944) — written into
+ * `<site>/.ailk-site-manifest.json` by `scaffold()` once every layer has
+ * landed.
+ *
+ * A template scaffold's manifest arrives as its template's generated
+ * `TEMPLATE-MANIFEST.json` (#6658 D7): the template's own `requires` and
+ * rows, and nothing about the run that installed it. A Pro `--shape` run of a
+ * Free template recorded `requires: ["marketing"]` and the Free rows, missing
+ * every page its module bundles landed. `planSiteManifest` adds:
+ *
+ *   - `modules` — the effective module set, the one `architecture.yaml`
+ *     declares. Skills read it for what the site can render;
+ *   - `level` — ONLY when the licence-key path derived one
+ *     (`resolveModuleSet` / `deriveLevel`). Never inferred from `modules`:
+ *     the level comes only from the key. An alias or `--modules` keep run
+ *     derives none and records none;
+ *   - 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
+ *     other page route under `apps/web/app/[locale]/` (`codeRouteRows`).
+ *
+ * Every byte already in the file is kept; the new rows and keys are rendered
+ * the way prettier prints the generator's JSON, so the file stays formatted.
+ *
+ * Pure module: no `import.meta.url`. Package-rooted directories are supplied
+ * by the caller, the same split as `site-roster.ts` / `programmatic.ts`.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { AddModuleRefusedError } from "./add-module-core.js";
+import { MODULE_SLICES, normalizeModules } from "./module-architecture.js";
+import { moduleRosterRows, planRosterAppend, } from "./site-roster.js";
+import { TEMPLATE_MANIFESTS, rosterDeclares, templateTreeDir, } from "./template-manifest.js";
+/** Prettier's default print width — the generator formats the manifest with it. */
+const PRINT_WIDTH = 80;
+/** Where the site's App Router pages live. */
+const ROUTE_ROOT = join("apps", "web", "app", "[locale]");
+const PAGE_FILE = /^page\.(tsx|ts|jsx|js|mdx)$/;
+/**
+ * The generator's row for a content-less route (`build-template-manifest.mjs`:
+ * every row renders under the locale layout's MarketingShell, chrome on).
+ */
+const CODE_ROUTE_ROW = {
+    kind: "route",
+    pageType: null,
+    schema: null,
+    shell: "MarketingShell",
+    chrome: "on",
+    sections: [],
+};
+/**
+ * The manifest's next text: `modules` (and `level`, when derived) 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.
+ */
+export function planSiteManifest(opts) {
+    const { roster } = opts;
+    for (const key of ["modules", "level"]) {
+        if (key in roster.doc) {
+            throw new AddModuleRefusedError(`${roster.path} already records "${key}"`);
+        }
+    }
+    const plan = planRosterAppend({
+        targetDir: opts.targetDir,
+        roster,
+        modules: opts.modules,
+        references: opts.modules.flatMap((m) => moduleRosterRows(m, opts.siteTemplatesDir)),
+        siteTemplatesDir: opts.siteTemplatesDir,
+        templatesDir: opts.templatesDir,
+        markers: opts.markers,
+    });
+    const appended = plan.next ?? roster.text;
+    const declared = new Set(JSON.parse(appended).rows.map((row) => row["route"]));
+    const extra = [
+        ...sampleRows(opts, declared),
+        ...codeRouteRows(opts.targetDir, declared),
+    ];
+    const withRows = appendRows(appended, extra, roster);
+    return insertRecord(withRows, opts.modules, opts.level, roster.path);
+}
+/**
+ * The rows for the sample pages a module's bundle installs through its
+ * `installMap` (`signal-collectors`' /projects family) that no row names yet:
+ * each is the row a template requiring the module declares for that content,
+ * as the generator wrote it into the template's shipped manifest. A
+ * `contentDir` row lists the site's own seeds. `declared` gains each route.
+ */
+function sampleRows(opts, declared) {
+    const out = [];
+    for (const moduleName of normalizeModules([...opts.modules])) {
+        const installed = Object.values(MODULE_SLICES[moduleName].installMap ?? {})
+            .filter((to) => to.startsWith("content/en/") && to.endsWith(".mdx"))
+            .filter((to) => existsSync(join(opts.targetDir, to)));
+        if (installed.length === 0)
+            continue;
+        for (const template of Object.values(TEMPLATE_MANIFESTS)) {
+            if (!template.requires.includes(moduleName))
+                continue;
+            const shippedPath = join(opts.siteTemplatesDir, templateTreeDir(template.name), "TEMPLATE-MANIFEST.json");
+            if (!existsSync(shippedPath))
+                continue;
+            const shipped = JSON.parse(readFileSync(shippedPath, "utf8")).rows;
+            for (const row of template.roster) {
+                if (declared.has(row.route))
+                    continue;
+                if (!installed.some((path) => rosterDeclares([row], path)))
+                    continue;
+                const value = shipped.find((r) => r["route"] === row.route);
+                if (value === undefined)
+                    continue;
+                declared.add(row.route);
+                out.push(row.contentDir !== undefined && "seeds" in value
+                    ? {
+                        ...value,
+                        seeds: listMdx(join(opts.targetDir, row.contentDir), opts.targetDir),
+                    }
+                    : value);
+            }
+        }
+    }
+    return out;
+}
+/** A code-route row for every page route on disk that `declared` does not name. */
+function codeRouteRows(targetDir, declared) {
+    return routesOnDisk(targetDir)
+        .filter((route) => !declared.has(route))
+        .map((route) => ({ route, ...CODE_ROUTE_ROW }));
+}
+/**
+ * Every route the site's App Router serves from a page file, sorted: route
+ * groups `(x)` dropped, a trailing optional catch-all `[[...x]]` folded into
+ * its parent (docs-blog's `/blog/[[...slug]]` serves `/blog`). The root
+ * content renderers (`/[slug]`, `/[slug]/[detail]`) are not routes of their
+ * own — they are how the content rows render — so they are left out.
+ */
+function routesOnDisk(targetDir) {
+    const root = join(targetDir, ROUTE_ROOT);
+    const routes = new Set();
+    const stack = existsSync(root) ? [root] : [];
+    for (let cur = stack.pop(); cur !== undefined; cur = stack.pop()) {
+        const entries = readdirSync(cur, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory())
+                stack.push(join(cur, entry.name));
+        }
+        if (!entries.some((entry) => entry.isFile() && PAGE_FILE.test(entry.name))) {
+            continue;
+        }
+        const segments = relative(root, cur)
+            .split(sep)
+            .filter((segment) => segment !== "" && !/^\(.+\)$/.test(segment));
+        const last = segments[segments.length - 1];
+        if (last !== undefined && /^\[\[\.\.\..+\]\]$/.test(last))
+            segments.pop();
+        if (segments[0]?.startsWith("["))
+            continue;
+        routes.add(`/${segments.join("/")}`);
+    }
+    return [...routes].sort();
+}
+/** Every `.mdx` under `dir`, as sorted `/`-separated paths relative to `base`. */
+function listMdx(dir, base) {
+    const out = [];
+    const stack = existsSync(dir) ? [dir] : [];
+    for (let cur = stack.pop(); cur !== undefined; cur = stack.pop()) {
+        for (const entry of readdirSync(cur, { withFileTypes: true })) {
+            const abs = join(cur, entry.name);
+            if (entry.isDirectory())
+                stack.push(abs);
+            else if (entry.isFile() && entry.name.endsWith(".mdx")) {
+                out.push(relative(base, abs).split(sep).join("/"));
+            }
+        }
+    }
+    return out.sort();
+}
+/**
+ * `value` as prettier prints the generator's JSON with its value starting at
+ * `column` after a `prefix`-wide key: objects expanded one key per line, an
+ * array of scalars inline when the line fits, one element per line otherwise.
+ */
+function renderJson(value, column, prefix = 0, trailing = 0) {
+    const pad = " ".repeat(column + 2);
+    const close = " ".repeat(column);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "[]";
+        if (value.every((item) => item === null || typeof item !== "object")) {
+            const inline = `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+            if (column + prefix + inline.length + trailing <= PRINT_WIDTH)
+                return inline;
+        }
+        const items = value.map((item, i) => pad + renderJson(item, column + 2, 0, i < value.length - 1 ? 1 : 0));
+        return `[\n${items.join(",\n")}\n${close}]`;
+    }
+    if (value !== null && typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return "{}";
+        const lines = entries.map(([key, item], i) => {
+            const name = `${JSON.stringify(key)}: `;
+            return (pad +
+                name +
+                renderJson(item, column + 2, name.length, i < entries.length - 1 ? 1 : 0));
+        });
+        return `{\n${lines.join(",\n")}\n${close}}`;
+    }
+    return JSON.stringify(value);
+}
+/** `text` with `rows` appended to its `rows` array — which the generator writes last. */
+function appendRows(text, rows, roster) {
+    if (rows.length === 0)
+        return text;
+    const keys = Object.keys(JSON.parse(text));
+    if (keys[keys.length - 1] !== "rows") {
+        throw new AddModuleRefusedError(`${roster.path} does not end with its "rows" array, so rows cannot be appended`);
+    }
+    const close = text.lastIndexOf("]");
+    let end = close;
+    while (end > 0 && /\s/.test(text[end - 1]))
+        end--;
+    const empty = text[end - 1] === "[";
+    const column = roster.lead.length - roster.lead.lastIndexOf("\n") - 1;
+    const rendered = rows
+        .map((row) => roster.lead + renderJson(row, column))
+        .join(",");
+    return empty
+        ? 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) {
+    const anchor = '\n  "requires": ';
+    const at = text.indexOf(anchor);
+    if (at === -1 || text.indexOf(anchor, at + 1) !== -1) {
+        throw new AddModuleRefusedError(`${label} has no single top-level "requires" key to record the module set beside`);
+    }
+    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)}` : "");
+    const next = text.slice(0, end) + record + text.slice(end);
+    const doc = JSON.parse(next);
+    if (!isDeepStrictEqual(doc["modules"], [...modules]) ||
+        doc["level"] !== level) {
+        throw new AddModuleRefusedError(`${label}: the module set could not be recorded beside "requires"`);
+    }
+    return next;
+}

package/dist/site-roster.d.ts

@@ -1,5 +1,7 @@
+import type { CompiledDesignTheme } from "./design-compile.js";
 import { type PageRosterRow } from "./module-architecture.js";
 import type { ModuleName } from "./parse-args.js";
+import type { ResolvedSiteChrome } from "./site-chrome.js";
 import { type MarkerMap } from "./substitute.js";
 import { type TemplateManifest } from "./template-manifest.js";
 /** The site-root file that is the roster of record (#6658 D7). */
@@ -55,6 +57,25 @@ export interface ModuleRosterRow {
  * not declare is refused: guessing would silently mis-roster the site.
  */
 export declare function readSiteRoster(targetDir: string): SiteRoster | undefined;
+/** What `planSiteManifestDesign` writes when it rewrites the manifest. */
+export interface SiteManifestDesignNext {
+    design: string;
+    layout: ResolvedSiteChrome;
+    theme: CompiledDesignTheme;
+}
+/**
+ * Plan the site manifest's `design`/`layout`/`theme` keys as a design's
+ * applied values (#6813 D6) — `undefined` when the file already carries
+ * `next` (no rewrite, so the file keeps its bytes byte-for-byte), else the
+ * text with each CHANGED key's value spliced in place, located with the same
+ * `findKey`/`endOfValue` scanner `planRosterAppend` uses. `rows`,
+ * `generatedHash` and every other byte stay untouched.
+ *
+ * @throws AddModuleRefusedError when `text` is not a JSON object, or is
+ *   missing `design`, `layout` or `theme` — a manifest predating #6658 D7
+ *   never reaches this function (`scaffold()` guards on the file's presence).
+ */
+export declare function planSiteManifestDesign(text: string, next: SiteManifestDesignNext, label: string): string | undefined;
 /**
  * The generator's row for each of a module's `pageContributions`, in
  * declaration order — read from the committed manifest of the first
@@ -63,6 +84,26 @@ export declare function readSiteRoster(targetDir: string): SiteRoster | undefine
  * of its forms. A route no shipped manifest carries is refused.
  */
 export declare function moduleRosterRows(moduleName: ModuleName, siteTemplatesDir: string): ModuleRosterRow[];
+/**
+ * The Free `/meet` placeholder seeds on `route` (#6942): the keyless Free
+ * template's own `content` on a route the `scheduling` module contributes
+ * (`FREE_MEET_PLACEHOLDER_ROWS`, `starter-grid.ts`, read through the one
+ * registry that composes it). Empty for any other route. Throws when the Free
+ * template carries none at all, so a renamed template or a moved row fails
+ * loudly instead of re-opening the prune #6942 closed.
+ */
+export declare function meetPlaceholderSeeds(route: string): readonly string[];
+/**
+ * `roster` with the Free `/meet` placeholder seeds folded onto the
+ * `scheduling` module's code-route rows (#6942) — a row on a placeholder
+ * route that names no `content` of its own. Unconfigured, the module's
+ * `/meet` and `/meet/[slug]` pages hand off to the placeholder routes, so a
+ * seed there is still served and still declared: the scaffold's seed prune
+ * (`programmatic.ts`) and the site roster check read the roster through
+ * this. A row with its own `content` (the Free placeholder row itself) and a
+ * row on any other route are returned as is.
+ */
+export declare function withMeetPlaceholderSeeds(roster: readonly PageRosterRow[]): PageRosterRow[];
 /** What becomes of a superseded template row's seed file. */
 export type SupersededSeed = {
     path: string;

package/dist/site-roster.js

@@ -30,7 +30,7 @@ import { AddModuleRefusedError, readArchitectureHeader, } from "./add-module-cor
 import { diffTwoStrings } from "./lib/extract-module-bundle.js";
 import { MODULE_SLICES, normalizeModules, } from "./module-architecture.js";
 import { substituteMarkers } from "./substitute.js";
-import { BASE_LAYER_DIR, SHAPE_STARTERS, TEMPLATE_MANIFESTS, resolveTemplate, rosterDeclares, templateTreeDir, } from "./template-manifest.js";
+import { BASE_LAYER_DIR, SHAPE_STARTERS, TEMPLATE_MANIFESTS, resolveTemplate, rosterDeclares, shippedManifestPath, templateTreeDir, } from "./template-manifest.js";
 /** The site-root file that is the roster of record (#6658 D7). */
 export const SITE_ROSTER_PATH = ".ailk-site-manifest.json";
 /**
@@ -39,8 +39,6 @@ export const SITE_ROSTER_PATH = ".ailk-site-manifest.json";
  * `SITE_ROSTER_PATH` is absent, and written back in place.
  */
 export const LEGACY_SITE_ROSTER_PATH = "TEMPLATE-MANIFEST.json";
-/** A template tree's own generated manifest — the file the site copy is made from. */
-const SHIPPED_MANIFEST_PATH = "TEMPLATE-MANIFEST.json";
 /** Prettier's default print width — the generator formats the manifest with it. */
 const PRINT_WIDTH = 80;
 // ── A string-aware JSON scanner, for the text splice ──────────────────────
@@ -183,13 +181,67 @@ export function readSiteRoster(targetDir) {
     }
     return { ...file, template, path };
 }
+/** `value`, rendered the way prettier prints an object-only JSON value nested one level under the manifest's root object. */
+function renderManifestValue(value) {
+    return JSON.stringify(value, null, 2)
+        .split("\n")
+        .map((line, i) => (i === 0 ? line : `  ${line}`))
+        .join("\n");
+}
+/**
+ * Plan the site manifest's `design`/`layout`/`theme` keys as a design's
+ * applied values (#6813 D6) — `undefined` when the file already carries
+ * `next` (no rewrite, so the file keeps its bytes byte-for-byte), else the
+ * text with each CHANGED key's value spliced in place, located with the same
+ * `findKey`/`endOfValue` scanner `planRosterAppend` uses. `rows`,
+ * `generatedHash` and every other byte stay untouched.
+ *
+ * @throws AddModuleRefusedError when `text` is not a JSON object, or is
+ *   missing `design`, `layout` or `theme` — a manifest predating #6658 D7
+ *   never reaches this function (`scaffold()` guards on the file's presence).
+ */
+export function planSiteManifestDesign(text, next, label) {
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch (err) {
+        throw new AddModuleRefusedError(`${label} is not JSON (${err.message})`);
+    }
+    if (typeof doc !== "object" || doc === null || Array.isArray(doc)) {
+        throw new AddModuleRefusedError(`${label} is not a JSON object`);
+    }
+    const parsed = doc;
+    const keys = ["design", "layout", "theme"];
+    for (const key of keys) {
+        if (!(key in parsed)) {
+            throw new AddModuleRefusedError(`${label} has no "${key}" key`);
+        }
+    }
+    if (keys.every((key) => isDeepStrictEqual(parsed[key], next[key]))) {
+        return undefined;
+    }
+    let result = text;
+    for (const key of keys) {
+        if (isDeepStrictEqual(parsed[key], next[key]))
+            continue;
+        const at = findKey(result, result.indexOf("{"), key);
+        if (at === undefined) {
+            throw new AddModuleRefusedError(`${label} has a "${key}" key the scanner cannot locate`);
+        }
+        const end = endOfValue(result, at.valueStart);
+        result = result.slice(0, at.valueStart) + renderManifestValue(next[key]) + result.slice(end);
+    }
+    return result;
+}
 // ── 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) {
-    const path = join(siteTemplatesDir, templateName, SHIPPED_MANIFEST_PATH);
+    const relPath = shippedManifestPath(templateName);
+    const path = join(siteTemplatesDir, relPath);
     if (!existsSync(path))
         return undefined;
-    return parseRosterFile(readFileSync(path, "utf8"), `site-templates/${templateName}/${SHIPPED_MANIFEST_PATH}`);
+    return parseRosterFile(readFileSync(path, "utf8"), `site-templates/${relPath}`);
 }
 /**
  * The generator's row for each of a module's `pageContributions`, in
@@ -216,14 +268,53 @@ export function moduleRosterRows(moduleName, siteTemplatesDir) {
     };
     return contributions.map((contribution) => {
         const isDir = contribution.contentDir !== undefined;
-        const row = find(contribution.route, isDir ? "route" : undefined);
         const seeded = isDir ? find(contribution.route, "page") : undefined;
+        let row = find(contribution.route, isDir ? "route" : undefined);
+        if (row === undefined && isDir && seeded !== undefined) {
+            const contentDir = contribution.contentDir;
+            const installMap = MODULE_SLICES[moduleName].installMap ?? {};
+            const selfSeeds = Object.values(installMap).some((dest) => dest.startsWith(`${contentDir}/`));
+            if (selfSeeds)
+                row = deriveRouteRow(contribution.route, seeded);
+        }
         if (row === undefined || (isDir && seeded === undefined)) {
             throw new AddModuleRefusedError(`module "${moduleName}" contributes ${contribution.route}, but no shipped template manifest carries ${isDir ? "both forms of " : ""}its row, so it cannot be added to ${SITE_ROSTER_PATH}`);
         }
         return { module: moduleName, contribution, row, ...(seeded && { seeded }) };
     });
 }
+/**
+ * Derive a `contentDir` contribution's code-route form from its seeded page
+ * form (spec 6892 D9) — for a SELF-SEEDING contribution, one whose
+ * contributing module's own `installMap` lands at least one file under the
+ * directory, so no template supplies a route form for it (every template
+ * taking the module gets the module's seeds, never zero of them). Returns
+ * field-for-field the route form `build-template-manifest.mjs` emits for a
+ * template that supplies no seeds of its own: `kind: "route"`, no
+ * `pageType`/`schema`/`contentDir`/`seeds`, the seeded form's own `shell` and
+ * `chrome`, no sections. Rendered the way a generated manifest's row-array
+ * element is indented (four spaces beyond `JSON.stringify`'s own two), so a
+ * derived row's `text` is byte-identical to the route-form slice a template
+ * manifest carries for the same contribution.
+ */
+function deriveRouteRow(route, seeded) {
+    const value = {
+        route,
+        kind: "route",
+        pageType: null,
+        schema: null,
+        shell: seeded.value["shell"],
+        chrome: seeded.value["chrome"],
+        sections: [],
+    };
+    return {
+        value,
+        text: JSON.stringify(value, null, 2)
+            .split("\n")
+            .map((line, i) => (i === 0 ? line : `    ${line}`))
+            .join("\n"),
+    };
+}
 /**
  * Every `.mdx` under `dir`, as `/`-separated paths relative to `base`. Walked
  * by hand: `Dirent.parentPath` and a reliable recursive `readdirSync` post-date
@@ -281,6 +372,40 @@ function expectedRow(ref, targetDir) {
     const seeds = listMdx(join(targetDir, dir), targetDir);
     return seeds.length > 0 ? withSeeds(ref.seeded, seeds) : ref.row;
 }
+/**
+ * The Free `/meet` placeholder seeds on `route` (#6942): the keyless Free
+ * template's own `content` on a route the `scheduling` module contributes
+ * (`FREE_MEET_PLACEHOLDER_ROWS`, `starter-grid.ts`, read through the one
+ * registry that composes it). Empty for any other route. Throws when the Free
+ * template carries none at all, so a renamed template or a moved row fails
+ * loudly instead of re-opening the prune #6942 closed.
+ */
+export function meetPlaceholderSeeds(route) {
+    const scheduling = new Set((MODULE_SLICES.scheduling.pageContributions ?? []).map((row) => row.route));
+    const placeholders = (TEMPLATE_MANIFESTS["marketing-site-free"]?.roster ?? []).filter((row) => scheduling.has(row.route) && row.content !== undefined);
+    if (placeholders.length === 0) {
+        throw new Error('meetPlaceholderSeeds: "marketing-site-free" carries no /meet placeholder row on a scheduling route');
+    }
+    return placeholders.find((row) => row.route === route)?.content ?? [];
+}
+/**
+ * `roster` with the Free `/meet` placeholder seeds folded onto the
+ * `scheduling` module's code-route rows (#6942) — a row on a placeholder
+ * route that names no `content` of its own. Unconfigured, the module's
+ * `/meet` and `/meet/[slug]` pages hand off to the placeholder routes, so a
+ * seed there is still served and still declared: the scaffold's seed prune
+ * (`programmatic.ts`) and the site roster check read the roster through
+ * this. A row with its own `content` (the Free placeholder row itself) and a
+ * row on any other route are returned as is.
+ */
+export function withMeetPlaceholderSeeds(roster) {
+    return roster.map((row) => {
+        if (row.content !== undefined || row.contentDir !== undefined)
+            return row;
+        const seeds = meetPlaceholderSeeds(row.route);
+        return seeds.length === 0 ? row : { ...row, content: seeds };
+    });
+}
 /** The bytes a scaffold installed at `path` from the template, base or overlay layer. */
 function installedSeed(opts, path) {
     const layers = [
@@ -313,7 +438,7 @@ export function planRosterAppend(opts) {
     const inSet = new Set(opts.modules);
     const refs = opts.references.filter((ref) => inSet.has(ref.module));
     const contributed = new Set(refs.map((ref) => ref.contribution.route));
-    const shipped = readShippedManifest(opts.siteTemplatesDir, templateTreeDir(roster.template.name));
+    const shipped = readShippedManifest(opts.siteTemplatesDir, roster.template.name);
     const templateRows = [];
     const moduleRows = new Map();
     const superseded = [];
@@ -350,7 +475,13 @@ export function planRosterAppend(opts) {
     }
     const seeds = [];
     for (const row of superseded) {
+        // The module's row on this route still declares a Free `/meet`
+        // placeholder seed (#6942): its unconfigured pages serve it, so the seed
+        // is kept, never removed or reported.
+        const kept = meetPlaceholderSeeds(row.route);
         for (const path of row.content ?? []) {
+            if (kept.includes(path))
+                continue;
             const abs = join(targetDir, path);
             if (!existsSync(abs))
                 continue;
@@ -487,11 +618,13 @@ export function siteRosterProblems(opts) {
                 }),
         };
     });
+    // #6942 — the Free /meet placeholder seeds the scheduling module's rows keep.
+    const declared = withMeetPlaceholderSeeds(effective);
     const installed = [...layerInstalledSeeds(roster.template, modules, opts)]
         .filter((path) => existsSync(join(opts.targetDir, path)))
         .sort();
     for (const path of installed) {
-        if (!rosterDeclares(effective, path)) {
+        if (!rosterDeclares(declared, path)) {
             problems.push(`${path}: installed but not declared by any roster row`);
         }
     }