create-ailk 0.8.0 → 0.9.0

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`);
         }
     }

package/dist/starter-grid.d.ts

@@ -56,6 +56,15 @@ export interface TemplateAlias {
     readonly categories: readonly CategorySlug[];
     readonly layout?: TemplateLayout;
     readonly differences?: AliasDifferences;
+    /**
+     * Whether this alias ships its own `site-templates/<name>/` tree (spec 6892
+     * D1). Absent means `true` — every alias but `minimalism-site` keeps its
+     * own directory. `false` declares that the alias resolves purely from the
+     * grid: its seed layer is its shape's tree (`templateTreeDir`), and its
+     * generated roster record lives under `site-templates/aliases/` rather
+     * than a directory of its own (`shippedManifestPath`).
+     */
+    readonly ownTree?: boolean;
 }
 /**
  * Each buildable shape's standard roster (#6753 D3) — the rows an alias starts
@@ -64,7 +73,9 @@ export interface TemplateAlias {
  * `organization-product` is today's base roster, the `/blog` teaser and the
  * portfolio pair. `organization-service`, `local-business-service` (#6757)
  * and `person-service` (#6758, roadmap § 6 Phase 2) are each their own rows,
- * the `/blog` teaser and the portfolio pair.
+ * the `/blog` teaser and the portfolio pair. Every shape's own rows carry
+ * `/sign-in` and `/sign-up` (#6797): the locale layout's header links both on
+ * every shape, so the roster of record lists them as code routes.
  */
 export declare const SHAPE_ROSTERS: Readonly<Record<BuildableShape, readonly TemplateRosterRow[]>>;
 /**
@@ -116,7 +127,7 @@ export declare const ALIASES: Readonly<{
         readonly modules: readonly ["marketing", "docs-blog", "scheduling", "signal-collectors"];
         readonly categories: readonly ["accounting", "legal", "consulting", "hvac", "roofing", "plumbing", "electrical", "landscaping", "auto-repair", "real-estate", "technology", "medical-specialty"];
         readonly differences: {
-            readonly drop: readonly ["/blog"];
+            readonly drop: readonly ["/blog", "/meet", "/meet/[slug]"];
             readonly add: readonly import("./module-architecture.js").PageRosterRow[];
             readonly before: "/portfolio";
         };
@@ -136,7 +147,7 @@ export declare const ALIASES: Readonly<{
         readonly modules: readonly ["marketing", "docs-blog", "scheduling", "signal-collectors", "multi-tenant"];
         readonly categories: readonly ["technology", "medical-specialty"];
         readonly differences: {
-            readonly drop: readonly ["/blog"];
+            readonly drop: readonly ["/blog", "/meet", "/meet/[slug]"];
             readonly add: readonly import("./module-architecture.js").PageRosterRow[];
             readonly before: "/portfolio";
         };
@@ -157,17 +168,19 @@ export declare const ALIASES: Readonly<{
      * (`rosterSurfaces`) nor its `_base`/overlay seed (#6646 D1).
      *
      * It declares NO `layout` block (#6638): the deck home, mark-only nav and
-     * centered footer are the `minimalism` design's, supplied by
-     * `DESIGN_LAYOUTS` from `design:` — the look any shape can wear. The
-     * roster rows the `organization-service` shape does not derive
-     * (`/reports`, `/referral`) are recorded with their reasons in this
-     * template's TEMPLATE-MANIFEST.md § 3a.
+     * centered footer are the `minimalism` design's own `layout` (its
+     * `DESIGN.md`, resolved by `resolveDesign` off `design:` — #6813 D4) — the
+     * look any shape can wear. This alias ships no tree of its own (`ownTree:
+     * false`, spec 6892 D1); its GENERATED roster record (no narrative `.md`,
+     * D5) lives at `site-templates/aliases/minimalism-site.TEMPLATE-MANIFEST.json`.
      *
-     * `/reports` and `/referral` carry no `GATEABLE_SURFACES` entry and need
-     * none: both are single-segment `LandingPage` slugs served by the generic
-     * `[slug]` route (#5469 D2), the same mechanism Free's `/how-it-works`
-     * uses. `/reports/[slug]` (the reader) is the signal-collectors module's
-     * own contributed row.
+     * `/reports` (a `ReportsList` hub over `ReportPage`) and `/referral` (a
+     * flow landing page) are signal-collectors module samples (spec 6892 D3);
+     * neither carries a `GATEABLE_SURFACES` entry: `/referral` is a
+     * single-segment `LandingPage` slug served by the generic `[slug]` route
+     * (#5469 D2), the same mechanism Free's `/how-it-works` uses, and `/reports`
+     * is its own routes-map row. `/reports/[slug]` (the reader) is the
+     * signal-collectors module's own contributed row.
      *
      * `/services/[slug]` declares its seed DIRECTORY as `contentDir`
      * (`content/en/Service`, as `routes-map.ts` records it). The three
@@ -176,8 +189,10 @@ export declare const ALIASES: Readonly<{
      * Since #6757, `organization-service` carries a real standard roster
      * (D1), so this alias's `differences` is additions and drops only: it
      * drops the `/blog` teaser (a Pro alias does not upsell its own level,
-     * D8) and the portfolio pair (the reports are the proof, not a
-     * portfolio), adds the signal-collectors samples, and INSERTS its two own
+     * D8), the portfolio pair (the reports are the proof, not a
+     * portfolio) and the two auth code routes the shape rosters (#6797 —
+     * this site has no `/sign-in`, above), adds the signal-collectors
+     * samples, and INSERTS its two own
      * rows — `/reports` before `/about`, `/referral` before `/faq` (D7) — to
      * reproduce its pre-#6757 row order (§ 1.2) exactly.
      */
@@ -186,8 +201,9 @@ export declare const ALIASES: Readonly<{
         readonly design: "minimalism";
         readonly modules: readonly ["marketing", "scheduling", "signal-collectors"];
         readonly categories: readonly ["real-estate", "technology", "legal"];
+        readonly ownTree: false;
         readonly differences: {
-            readonly drop: readonly ["/blog", "/portfolio", "/portfolio/[slug]"];
+            readonly drop: readonly ["/sign-in", "/sign-up", "/blog", "/meet", "/meet/[slug]", "/portfolio", "/portfolio/[slug]"];
             readonly add: readonly import("./module-architecture.js").PageRosterRow[];
             readonly insert: readonly [{
                 readonly before: "/about";