create-ailk 0.27.0 → 0.28.1

package/dist/lib/chrome-readers.d.ts

@@ -5,17 +5,33 @@ export interface UnreadChromeKnob {
     /** Overlay-relative path of the reader file, with `/` separators. */
     file: string;
 }
+/** One overlay file that reads a knob. */
+export interface ChromeReader {
+    /** Overlay-relative path, with `/` separators. */
+    file: string;
+    /** Present when `file` reads the knob only through its imports: the files it reaches that read it directly. */
+    via?: string[];
+}
 /** The pattern that means "this text reads `knob`". */
 export declare function chromeReadPattern(knob: string): RegExp;
 /**
- * knob → the overlay files that read it, sorted. Scans `<templatesDir>/apps/web`;
- * fails closed (throws, naming the directory) when it is absent or unreadable,
- * so a broken overlay can never read as "nothing reads any knob".
+ * knob → the overlay files that read it, sorted by file; one that reads it
+ * only through relative imports carries `via`. Scans `<templatesDir>/apps/web`; fails closed (throws, naming the directory)
+ * when it is absent or unreadable, so a broken overlay can never read as
+ * "nothing reads any knob".
  */
-export declare function chromeKnobReaders(templatesDir: string): Map<string, string[]>;
+export declare function chromeKnobReaders(templatesDir: string): Map<string, ChromeReader[]>;
 /**
  * The `(knob, file)` pairs where the resolved chrome sets a non-default `knob`,
  * the shipped overlay's `file` reads it, the site has its own `file`, and the
  * site's `file` does not read it. A reader file the site lacks is skipped.
+ *
+ * A pair the overlay credits only through an import is also satisfied when
+ * some site file outside its `via` reads the knob directly: a site from before
+ * the read moved into the helper renders it in its own place (#10156). So the
+ * import credit adds a pair only for a knob the site reads nowhere but its
+ * helpers. It is per file, not per export: a site whose home page drops the
+ * helper import is named for every knob that helper reads — a refusal the
+ * operator passes with `--allow-unread-chrome`, never a silent miss.
  */
-export declare function unreadChromeKnobs(resolved: ResolvedSiteChrome, readers: ReadonlyMap<string, readonly string[]>, siteDir: string): UnreadChromeKnob[];
+export declare function unreadChromeKnobs(resolved: ResolvedSiteChrome, readers: ReadonlyMap<string, readonly ChromeReader[]>, siteDir: string): UnreadChromeKnob[];

package/dist/lib/chrome-readers.js

@@ -11,12 +11,16 @@
  *   each knob — nothing is hard-coded, so a new reader file is picked up.
  * - `unreadChromeKnobs` compares the site's own copy of each reader file.
  *
- * "Reads `knob`" means the file's text matches `(?:siteChrome|chrome)\.<knob>\b`.
- * A file that reads a knob under another name (a destructured alias) is not
- * recognised — accepted (spec § Clarifications, detection).
+ * A file "reads `knob` directly" when its text matches
+ * `(?:siteChrome|chrome)\.<knob>\b`, and "reads" it when it or a file it
+ * imports by a relative path, at any depth, reads it directly — so the layout
+ * stays a reader of `innerPages` after #10106 moved that read into
+ * `lib/page-chrome.ts` (#10156). A file that reads a knob under another name
+ * (a destructured alias) is not recognised — accepted (spec § Clarifications,
+ * detection).
  */
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
+import { join, posix } from "node:path";
 import { DEFAULT_SITE_CHROME, } from "../site-chrome.js";
 /** The overlay tree the generated app files live under. */
 const OVERLAY_WEB_DIR = ["apps", "web"];
@@ -31,41 +35,126 @@ function listSources(root, dir, out) {
     for (const entry of readdirSync(join(root, dir), { withFileTypes: true })) {
         const rel = `${dir}/${entry.name}`;
         if (entry.isDirectory()) {
-            if (entry.name !== "__tests__")
+            if (entry.name !== "__tests__" &&
+                entry.name !== "node_modules" &&
+                !entry.name.startsWith(".")) {
                 listSources(root, rel, out);
+            }
         }
         else if (/\.tsx?$/.test(entry.name)) {
             out.push(rel);
         }
     }
 }
+/** A relative module specifier in an import, export-from or dynamic import. */
+const RELATIVE_IMPORT = /(?:\bfrom|\bimport)\s*\(?\s*["'](\.{1,2}\/[^"']+)["']/g;
+function sourceTree(root) {
+    const texts = new Map();
+    const closures = new Map();
+    const importLists = new Map();
+    const text = (file) => {
+        if (!texts.has(file)) {
+            const abs = join(root, file);
+            texts.set(file, existsSync(abs) ? readFileSync(abs, "utf8") : null);
+        }
+        return texts.get(file);
+    };
+    /** The files `file` imports by a relative path that exist under the root; `./x.js` may name `x.ts`. */
+    const imports = (file) => {
+        const cached = importLists.get(file);
+        if (cached !== undefined)
+            return cached;
+        const out = [];
+        for (const match of (text(file) ?? "").matchAll(RELATIVE_IMPORT)) {
+            const base = posix
+                .normalize(posix.join(posix.dirname(file), match[1]))
+                .replace(/\/$/, "");
+            if (base.startsWith(".."))
+                continue;
+            const stem = base.replace(/\.(?:js|jsx)$/, "");
+            const hit = [
+                base,
+                `${stem}.ts`,
+                `${stem}.tsx`,
+                `${stem}/index.ts`,
+                `${stem}/index.tsx`,
+            ].find((candidate) => /\.tsx?$/.test(candidate) && text(candidate) !== null);
+            if (hit !== undefined)
+                out.push(hit);
+        }
+        importLists.set(file, out);
+        return out;
+    };
+    const reached = (file) => {
+        let closure = closures.get(file);
+        if (closure === undefined) {
+            closure = new Set();
+            const stack = [...imports(file)];
+            while (stack.length > 0) {
+                const next = stack.pop();
+                if (next === file || closure.has(next))
+                    continue;
+                closure.add(next);
+                stack.push(...imports(next));
+            }
+            closures.set(file, closure);
+        }
+        return closure;
+    };
+    const readsDirectly = (file, pattern) => pattern.test(text(file) ?? "");
+    return {
+        text,
+        reached,
+        readsDirectly,
+        reads: (file, pattern) => readsDirectly(file, pattern) ||
+            [...reached(file)].some((dep) => readsDirectly(dep, pattern)),
+    };
+}
 /**
- * knob → the overlay files that read it, sorted. Scans `<templatesDir>/apps/web`;
- * fails closed (throws, naming the directory) when it is absent or unreadable,
- * so a broken overlay can never read as "nothing reads any knob".
+ * knob → the overlay files that read it, sorted by file; one that reads it
+ * only through relative imports carries `via`. Scans `<templatesDir>/apps/web`; fails closed (throws, naming the directory)
+ * when it is absent or unreadable, so a broken overlay can never read as
+ * "nothing reads any knob".
  */
 export function chromeKnobReaders(templatesDir) {
     const webDir = join(templatesDir, ...OVERLAY_WEB_DIR);
-    const readers = new Map();
+    const direct = new Map();
+    const files = [];
+    const tree = sourceTree(templatesDir);
     try {
         if (!existsSync(webDir))
             throw new Error("missing");
-        const files = [];
         listSources(templatesDir, OVERLAY_WEB_DIR.join("/"), files);
-        for (const file of files.sort()) {
-            const text = readFileSync(join(templatesDir, file), "utf8");
-            for (const match of text.matchAll(new RegExp(`${READ_HEAD}([A-Za-z_$][\\w$]*)\\b`, "g"))) {
+        files.sort();
+        for (const file of files) {
+            for (const match of tree
+                .text(file)
+                .matchAll(new RegExp(`${READ_HEAD}([A-Za-z_$][\\w$]*)\\b`, "g"))) {
                 const knob = match[1];
-                const list = readers.get(knob) ?? [];
+                const list = direct.get(knob) ?? [];
                 if (!list.includes(file))
                     list.push(file);
-                readers.set(knob, list);
+                direct.set(knob, list);
             }
         }
     }
     catch {
         throw new Error(`cannot check chrome knobs: the overlay has no readable apps/web at ${webDir}. Reinstall create-ailk.`);
     }
+    const readers = new Map();
+    for (const [knob, directFiles] of direct) {
+        const list = [];
+        for (const file of files) {
+            if (directFiles.includes(file)) {
+                list.push({ file });
+                continue;
+            }
+            const via = directFiles.filter((reader) => tree.reached(file).has(reader));
+            if (via.length > 0)
+                list.push({ file, via });
+        }
+        readers.set(knob, list);
+    }
     return readers;
 }
 /** A knob is set when it differs from its default; an optional knob (no default) when present. */
@@ -81,19 +170,38 @@ function isSet(resolved, knob) {
  * The `(knob, file)` pairs where the resolved chrome sets a non-default `knob`,
  * the shipped overlay's `file` reads it, the site has its own `file`, and the
  * site's `file` does not read it. A reader file the site lacks is skipped.
+ *
+ * A pair the overlay credits only through an import is also satisfied when
+ * some site file outside its `via` reads the knob directly: a site from before
+ * the read moved into the helper renders it in its own place (#10156). So the
+ * import credit adds a pair only for a knob the site reads nowhere but its
+ * helpers. It is per file, not per export: a site whose home page drops the
+ * helper import is named for every knob that helper reads — a refusal the
+ * operator passes with `--allow-unread-chrome`, never a silent miss.
  */
 export function unreadChromeKnobs(resolved, readers, siteDir) {
     const out = [];
+    const site = sourceTree(siteDir);
+    let siteFiles;
     for (const knob of Object.keys(resolved).sort()) {
         if (!isSet(resolved, knob))
             continue;
         const pattern = chromeReadPattern(knob);
-        for (const file of readers.get(knob) ?? []) {
-            const abs = join(siteDir, file);
-            if (!existsSync(abs))
+        for (const { file, via } of readers.get(knob) ?? []) {
+            if (site.text(file) === null || site.reads(file, pattern))
                 continue;
-            if (!pattern.test(readFileSync(abs, "utf8")))
-                out.push({ knob, file });
+            if (via !== undefined) {
+                if (siteFiles === undefined) {
+                    siteFiles = [];
+                    if (existsSync(join(siteDir, ...OVERLAY_WEB_DIR))) {
+                        listSources(siteDir, OVERLAY_WEB_DIR.join("/"), siteFiles);
+                    }
+                }
+                const elsewhere = siteFiles.some((other) => !via.includes(other) && site.readsDirectly(other, pattern));
+                if (elsewhere)
+                    continue;
+            }
+            out.push({ knob, file });
         }
     }
     return out;

package/dist/lib/declared-env.d.ts

@@ -109,6 +109,12 @@ export interface PlanEnvRowsOptions {
      * with no reader and so no `scope`; a platform or refused name is skipped.
      */
     declare?: readonly string[];
+    /**
+     * When set, only reads in these site-relative files get a row (#10173):
+     * `update` declares what the files it wrote read, never a name only the
+     * site's own code reads.
+     */
+    onlyFiles?: ReadonlySet<string>;
 }
 /**
  * `projectYamlText` with a row appended for every name the site at `root`

package/dist/lib/declared-env.js

@@ -904,6 +904,8 @@ export function planEnvRows(root, projectYamlText, opts) {
     const refused = new Set(opts.topology === "spoke" ? SPOKE_REFUSED_ENV : []);
     const files = new Map();
     for (const read of collectSiteReads(root).reads) {
+        if (opts.onlyFiles !== undefined && !opts.onlyFiles.has(read.file))
+            continue;
         if (isPlatformEnvName(read.name) || refused.has(read.name))
             continue;
         if (declared.has(read.name))

package/dist/lib/env-catalog.js

@@ -23,6 +23,14 @@ export const ENV_CATALOG = {
         description: "This site's public origin as the MCP server sees it: the same-origin check for audits and the purchase return URLs.",
         secret: false,
     },
+    AILK_BOOKING_BOT_CHECK: {
+        description: 'Set to "off" to turn off the booking relay\'s Vercel BotID check (#9889) — the booking alone; AILK_BOT_CHECK=off turns every check off. It runs only on Vercel; unset, empty or any other value leaves it on.',
+        secret: false,
+    },
+    AILK_BOT_CHECK: {
+        description: 'Set to "off" to turn off the site\'s Vercel BotID check on its public writes — lead, newsletter, callback, flow, checkout and booking (#9255). On by default; it runs only on Vercel.',
+        secret: false,
+    },
     AILK_CONTENT_ROOT: {
         description: "Overrides the on-disk content root (absolute, or relative to the working directory). Unset, the MCP server tries <cwd>/content, then <cwd>/../../content; the web app defaults to <repo-root>/content.",
         secret: false,
@@ -107,6 +115,10 @@ export const ENV_CATALOG = {
         description: "Better Stack heartbeat URL pinged on cron and startup; unset turns the heartbeat off.",
         secret: true,
     },
+    CONTENT_ADAPTER: {
+        description: 'Where pages are read from: unset reads the MDX files under content/; "database" reads the database. The build checks Service categories (parent:) only for MDX content.',
+        secret: false,
+    },
     CONTENT_REVALIDATE_SECRET: {
         description: "The shared secret /api/revalidate checks the API's publish webhook against; the same value as the API's.",
         secret: true,
@@ -163,6 +175,14 @@ export const ENV_CATALOG = {
         description: "The API origin the browser reads on a hub. A spoke never sets it: its hub origin is server-only (AILK_API_URL).",
         secret: false,
     },
+    NEXT_PUBLIC_AILK_DOCS_PATH: {
+        description: "The docs' public path, baked at build from content/_site.mdx's docsPath; do not set by hand.",
+        secret: false,
+    },
+    NEXT_PUBLIC_AILK_SERVICES_PATH: {
+        description: "The services' public base, baked at build from content/_site.mdx's services.path; do not set by hand.",
+        secret: false,
+    },
     NEXT_PUBLIC_AILK_LISTING_SITE_KEY: {
         description: "The site's public listing key, inlined at build; it switches the listicle directory on. Public by design.",
         secret: false,

package/dist/lib/import-graph.d.ts

@@ -27,3 +27,19 @@ export declare function resolveRelativeImport(fromFile: string, spec: string, ca
  * @param seeds repo-relative, "/"-separated files the closure starts from.
  */
 export declare function importClosure(repoRoot: string, roots: readonly string[], seeds: Iterable<string>): Set<string>;
+/**
+ * The names a module imports from each specifier, textually (#10173): the
+ * members of a `{ … }` list (an `a as b` member names `a`, a `type a` member
+ * `a`) and `default` for a default import. A namespace import (`* as x`) and
+ * a side-effect import name nothing.
+ */
+export declare function namedImportsOf(text: string): Array<{
+    specifier: string;
+    names: string[];
+}>;
+/**
+ * Whether module `text` exports `name`, textually. Fails toward `true` — an
+ * `export *`, or a destructuring export, could export anything — so a caller
+ * that holds a file back on `false` never holds one that does export it.
+ */
+export declare function exportsName(text: string, name: string): boolean;

package/dist/lib/import-graph.js

@@ -138,3 +138,56 @@ export function importClosure(repoRoot, roots, seeds) {
     }
     return closed;
 }
+const IDENT = "[A-Za-z_$][\\w$]*";
+/** `import { a, b as c }` / `export { a } from` / `import X from` — the bound names per specifier. */
+const NAMED_IMPORT = new RegExp(`\\b(?:import|export)\\s+(?:type\\s+)?(?:(${IDENT})\\s*,\\s*)?\\{([^}]*)\\}\\s*from\\s*["']([^"']+)["']` +
+    `|\\bimport\\s+(?:type\\s+)?(${IDENT})\\s+from\\s*["']([^"']+)["']`, "g");
+/**
+ * The names a module imports from each specifier, textually (#10173): the
+ * members of a `{ … }` list (an `a as b` member names `a`, a `type a` member
+ * `a`) and `default` for a default import. A namespace import (`* as x`) and
+ * a side-effect import name nothing.
+ */
+export function namedImportsOf(text) {
+    const out = [];
+    for (const m of text.matchAll(NAMED_IMPORT)) {
+        if (m[3] !== undefined) {
+            const names = (m[2] ?? "")
+                .split(",")
+                .map((member) => member.trim().replace(/^type\s+/, "").split(/\s+as\s+/)[0].trim())
+                .filter((name) => new RegExp(`^${IDENT}$`).test(name));
+            if (m[1] !== undefined)
+                names.push("default");
+            out.push({ specifier: m[3], names });
+        }
+        else if (m[5] !== undefined) {
+            out.push({ specifier: m[5], names: ["default"] });
+        }
+    }
+    return out;
+}
+/**
+ * Whether module `text` exports `name`, textually. Fails toward `true` — an
+ * `export *`, or a destructuring export, could export anything — so a caller
+ * that holds a file back on `false` never holds one that does export it.
+ */
+export function exportsName(text, name) {
+    if (/\bexport\s*\*/.test(text))
+        return true;
+    if (/\bexport\s+(?:const|let|var)\s*[{[]/.test(text))
+        return true;
+    if (name === "default" && /\bexport\s+default\b/.test(text))
+        return true;
+    const declared = new RegExp(`\\bexport\\s+(?:declare\\s+)?(?:async\\s+)?(?:abstract\\s+)?` +
+        `(?:const\\s+enum|const|let|var|function\\s*\\*?|class|type|interface|enum|namespace)\\s*${name.replace(/\$/g, "\\$")}\\b`);
+    if (declared.test(text))
+        return true;
+    for (const m of text.matchAll(/\bexport\s*(?:type\s*)?\{([^}]*)\}/g)) {
+        for (const member of (m[1] ?? "").split(",")) {
+            const parts = member.trim().replace(/^type\s+/, "").split(/\s+as\s+/);
+            if ((parts[1] ?? parts[0])?.trim() === name)
+                return true;
+        }
+    }
+    return false;
+}

package/dist/lib/site-modules.d.ts

@@ -0,0 +1,8 @@
+/** `.ailk-site-manifest.json`'s `modules`, or undefined when the site has no manifest or it records none. */
+export declare function readSiteManifestModules(targetDir: string): string[] | undefined;
+/**
+ * Whether the site has dropped the `marketing` module: its manifest records a
+ * module list without it. A site with no manifest, or whose manifest records
+ * no list, keeps its public tree (today's behaviour).
+ */
+export declare function publicTreeRemoved(targetDir: string): boolean;

package/dist/lib/site-modules.js

@@ -0,0 +1,34 @@
+/**
+ * The site's own module list, as `.ailk-site-manifest.json` records it
+ * (#10040 D10). The one reader `sync-routes`, `update`, the module flags and
+ * the roster check share to answer "has this site dropped the marketing
+ * module?" — never the architecture header alone, because a bare
+ * `--modules <paid>` keep run writes a header without `marketing` while its
+ * public pages are all on disk, and such a site has no manifest.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/** `.ailk-site-manifest.json`'s `modules`, or undefined when the site has no manifest or it records none. */
+export function readSiteManifestModules(targetDir) {
+    const path = join(targetDir, ".ailk-site-manifest.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const doc = JSON.parse(readFileSync(path, "utf8"));
+        return Array.isArray(doc.modules) && doc.modules.every((m) => typeof m === "string")
+            ? doc.modules
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Whether the site has dropped the `marketing` module: its manifest records a
+ * module list without it. A site with no manifest, or whose manifest records
+ * no list, keeps its public tree (today's behaviour).
+ */
+export function publicTreeRemoved(targetDir) {
+    const modules = readSiteManifestModules(targetDir);
+    return modules !== undefined && !modules.includes("marketing");
+}

package/dist/module-architecture.js

@@ -1362,16 +1362,15 @@ export const MODULE_SLICES = {
         // routes, named exactly as `surfaces.ts`'s ROUTE_SINCE keys name them.
         // ROWS AND SEED ONLY: unlike docs-blog and scheduling above, this module's
         // route code is deliberately NOT in `ownedFiles` (see the comment inside
-        // that array). The first two rows' code reaches a scaffold from the
-        // `templates/` snapshot, retained because the `flows` surface is enabled;
-        // the results row's code is `commerce`'s (`commerce.ownedFiles` carries
-        // `results/[payload]/page.tsx` + its two client files below, and
-        // `paidModuleTemplateExclusions` strips every paid module's owned files
-        // from the snapshot unconditionally), so that one row rides a DIFFERENT
-        // module's bundle — recorded in spec 5478 § 8 item 1, whose delivery
-        // consequence is #5481's and #5464's. Declaring the rows here changes none
-        // of it: a contribution is data, and which delivery shape carries the code
-        // is a property of the module, not of the contribution.
+        // that array). All three rows' code reaches a scaffold from the
+        // `templates/` snapshot, retained because the `flows` surface is enabled.
+        // The results row's code was `commerce`'s until #6786, so a Pro scaffold
+        // without commerce 404'd a finished recommending flow; it now ships here,
+        // and commerce's bundle adds only the checkout half
+        // (`commerce.ownedFiles`: `results/[payload]/layout.tsx` and
+        // `checkout.actions.ts`). Declaring the rows here changes none of it: a
+        // contribution is data, and which delivery shape carries the code is a
+        // property of the module, not of the contribution.
         pageContributions: [
             { route: "/flows/[slug]" },
             { route: "/flows/[slug]/start" },
@@ -1500,7 +1499,8 @@ export const MODULE_SLICES = {
         // filter (`isSpokeExcluded`), which drops every destination under
         // apps/api or database and the web files that call the hub's own
         // checkout (`SPOKE_HUB_CHECKOUT_SEEDS`: flows/[slug]/checkout.actions.ts,
-        // the flow results pages, dev/purchase — spoke-intake Rule 3). What lands
+        // the flow results directory — the results layout among it — and
+        // dev/purchase, spoke-intake Rule 3). What lands
         // is the scaffold-commerce skill, the commerce-boundary rule and the
         // @working-theory/ui-commerce dependency (`patches` below). A spoke sells
         // through its hub's Offerings buy route (#9142); its remaining checkout
@@ -1583,10 +1583,13 @@ export const MODULE_SLICES = {
             // + the slice's own re-export entry point) moved to
             // packages-paid/ui-commerce; the package is delivered to a keyed
             // scaffold via `patches` below, not via `ownedFiles`/`installMap` (D5).
+            // #6786 — the flow results page is signal-collectors' (it rides the
+            // `flows` surface's directory, see that slice); commerce owns only its
+            // checkout half: Pay's action and the results layout that provides the
+            // price card + Pay through the base tree's `checkout-seam.ts`. Without
+            // them the page renders, offering Book a Call for every fit.
             "apps/web/app/[locale]/flows/[slug]/checkout.actions.ts",
-            "apps/web/app/[locale]/flows/[slug]/results/[payload]/page.tsx",
-            "apps/web/app/[locale]/flows/[slug]/results/[payload]/ResultsClient.tsx",
-            "apps/web/app/[locale]/flows/[slug]/results/[payload]/ResultsEmailStep.tsx",
+            "apps/web/app/[locale]/flows/[slug]/results/[payload]/layout.tsx",
             "apps/web/app/[locale]/dev/purchase/page.tsx",
             "apps/web/app/[locale]/dev/purchase/error.tsx",
             "apps/web/app/[locale]/dev/purchase/purchase.actions.ts",
@@ -1823,6 +1826,11 @@ export function coOwnedModuleDestinations() {
 //     named by one file. A scaffold is not a git repository. Only those two
 //     cases moved there; `connection.test.ts` and
 //     `checkout-session-record.test.ts` keep the stores' coverage and ship.
+//   - the content hubs' `lib/__tests__/hub-children.test.tsx` (#10121) — it
+//     imports the hub page of thirteen route families across surfaces, and a
+//     scaffold carries only the families its surfaces select, so a gated
+//     scaffold would ship it with dangling imports. Its coverage of the
+//     generated child cards runs in this monorepo only.
 export const EXCLUDE_TEMPLATE_DIRS = [
     "apps/web/__tests__",
     "apps/web/app/__tests__",
@@ -1847,6 +1855,7 @@ export const EXCLUDE_TEMPLATE_DIRS = [
     "apps/mcp/__tests__/parity.test.ts",
     "apps/web/app/[locale]/pricing/__tests__/monorepo-only.test.tsx",
     "apps/web/app/[locale]/pricing/__tests__/__snapshots__/monorepo-only.test.tsx.snap",
+    "apps/web/lib/__tests__/hub-children.test.tsx",
 ];
 export function paidModuleTemplateExclusions(snapshotRoots, repoRoot) {
     const roots = new Set(snapshotRoots);

package/dist/paid-sections.d.ts

@@ -26,7 +26,24 @@ export declare function renderPaidSections(present: ReadonlySet<string>): string
  */
 export declare function renderModuleFlags(flags: {
     schedulingPages: boolean;
+    /** The `marketing` module is in the architecture header (#10040 D6). Absent → `true`. */
+    marketingPages?: boolean;
+    /** The `docs-blog` module is in the architecture header (#10040 D6). Absent → `false`. */
+    docsBlogPages?: boolean;
 }): string;
+/**
+ * The `marketing` / `docs-blog` presence the flags render (#10040 D6).
+ * `marketing` is read from the site's manifest (`lib/site-modules.ts`): a
+ * site with no manifest keeps its public tree, whatever its header says — a
+ * bare `--modules <paid>` keep run writes a header without `marketing` while
+ * every public page is on disk. `docs-blog` is read from the architecture
+ * header, which lists it on every site that carries it; an unreadable header
+ * reads as absent.
+ */
+export declare function readPublicPageFlags(targetDir: string): {
+    marketingPages: boolean;
+    docsBlogPages: boolean;
+};
 /**
  * Write the module-presence flags into a scaffold from its own
  * `apps/web/package.json` (#8843 D10) — never copied from a template, so a

package/dist/paid-sections.js

@@ -25,6 +25,8 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { readArchitectureHeader } from "./add-module-core.js";
+import { readSiteManifestModules } from "./lib/site-modules.js";
 import { MODULE_SLICES } from "./module-architecture.js";
 import { RECOGNIZED_MODULES } from "./parse-args.js";
 /** Scaffold-relative path of the generated registry. */
@@ -119,15 +121,51 @@ const MODULE_FLAGS_HEADER = `// modules.generated.ts — which module pages this
  * tree does not carry.
  */
 export function renderModuleFlags(flags) {
+    const marketingPages = flags.marketingPages ?? true;
+    const docsBlogPages = flags.docsBlogPages ?? false;
     const lines = [];
+    // The line-1 marker stays keyed on the scheduling pages alone (#10040 D6).
     if (flags.schedulingPages)
         lines.push("// oss: false");
     lines.push(MODULE_FLAGS_HEADER.trimEnd());
     lines.push("");
     lines.push("/** The scheduling module's booking pages (/meet, /private) exist. */");
     lines.push(`export const SCHEDULING_PAGES: boolean = ${String(flags.schedulingPages)};`);
+    lines.push("");
+    lines.push("/** The marketing module's public pages exist (#10040): false on a hub. */");
+    lines.push(`export const MARKETING_PAGES: boolean = ${String(marketingPages)};`);
+    lines.push("");
+    lines.push("/** The docs-blog module's /docs and /blog pages exist (#10040). */");
+    lines.push(`export const DOCS_BLOG_PAGES: boolean = ${String(docsBlogPages)};`);
+    lines.push("");
+    lines.push("/** Any public page exists: robots, sitemap, llms.txt and the noindex header read this (#10040 D6/D7). */");
+    lines.push(`export const PUBLIC_PAGES: boolean = ${String(marketingPages || docsBlogPages)};`);
     return `${lines.join("\n")}\n`;
 }
+/**
+ * The `marketing` / `docs-blog` presence the flags render (#10040 D6).
+ * `marketing` is read from the site's manifest (`lib/site-modules.ts`): a
+ * site with no manifest keeps its public tree, whatever its header says — a
+ * bare `--modules <paid>` keep run writes a header without `marketing` while
+ * every public page is on disk. `docs-blog` is read from the architecture
+ * header, which lists it on every site that carries it; an unreadable header
+ * reads as absent.
+ */
+export function readPublicPageFlags(targetDir) {
+    const siteModules = readSiteManifestModules(targetDir);
+    const marketingPages = siteModules === undefined || siteModules.includes("marketing");
+    const archPath = join(targetDir, "architecture.yaml");
+    let docsBlogPages = false;
+    if (existsSync(archPath)) {
+        try {
+            docsBlogPages = readArchitectureHeader(readFileSync(archPath, "utf8")).modules.includes("docs-blog");
+        }
+        catch {
+            docsBlogPages = false;
+        }
+    }
+    return { marketingPages, docsBlogPages };
+}
 /** The web app's `dependencies`, or `undefined` for a scaffold with no web app. */
 function webDependencies(targetDir, writing) {
     const pkgPath = join(targetDir, "apps/web/package.json");
@@ -158,6 +196,7 @@ export function writeModuleFlags(targetDir) {
     const before = existsSync(path) ? readFileSync(path, "utf8") : undefined;
     const next = renderModuleFlags({
         schedulingPages: Object.hasOwn(deps, SCHEDULING_PAGES_PACKAGE),
+        ...readPublicPageFlags(targetDir),
     });
     if (before === next)
         return "unchanged";

package/dist/programmatic.d.ts

@@ -19,6 +19,7 @@ import { type AddModuleResult } from "./add-module.js";
 import { type SyncClaudeMdResult } from "./claude-md.js";
 import { CATALOG_TARGET_PATH } from "./component-catalog.js";
 import { type ModuleName } from "./parse-args.js";
+import { type RemoveModuleResult } from "./remove-module.js";
 import { type TemplateLayout } from "./site-chrome.js";
 import { type SyncRoutesResult } from "./sync-routes.js";
 import { type StarterShape } from "./template-manifest.js";
@@ -367,6 +368,21 @@ export interface AddModuleOptions {
  *   4. the fetched bundle is merged under the plus-config policy.
  */
 export declare function addModule(opts: AddModuleOptions): Promise<AddModuleResult>;
+export interface RemoveModuleCliOptions {
+    /** The already-scaffolded site (absolute or relative). */
+    targetDir: string;
+    /** The module to remove (validated upstream by `parseRemoveModuleArgs`). */
+    moduleName: ModuleName;
+    /** Delete the site's own edits in the removal set too. */
+    force?: boolean;
+}
+/**
+ * Take a module's public pages off an already-scaffolded site in place
+ * (`create-ailk remove-module`, #10040) — the thin package-rooted wrapper
+ * around `remove-module.ts`'s `removeModuleFromScaffold`, the `addModule`
+ * split. Every refusal is the core's and throws before the first write.
+ */
+export declare function removeModule(opts: RemoveModuleCliOptions): RemoveModuleResult;
 /** Re-exported so the CLI can name the file it wrote without duplicating it. */
 export { CATALOG_TARGET_PATH };
 /**