create-zudo-doc 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Takeshi Takatsudo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# create-zudo-doc
+
+Scaffold a new [zudo-doc](https://zudo-doc.takazudomodular.com) documentation site in seconds. Generates a ready-to-run project powered by [zfb](https://github.com/zudolab/zudo-doc), MDX, Tailwind CSS v4, and Preact — with optional features (search, i18n, sidebar, doc history, design token panel, and more).
+
+## Quick Start
+
+```bash
+# pnpm
+pnpm create zudo-doc
+
+# npm
+npm create zudo-doc@latest
+
+# yarn
+yarn create zudo-doc
+
+# bun
+bunx create-zudo-doc
+```
+
+Running without arguments starts the **interactive mode**: the CLI prompts for project name, language, color scheme, and which optional features to enable, then scaffolds the project and optionally installs dependencies.
+
+## Non-Interactive Usage
+
+Pass `--yes` to accept all defaults and skip prompts, or provide flags to pre-answer specific questions:
+
+```bash
+# All defaults, no prompts
+pnpm create zudo-doc my-docs --yes
+
+# Fully specified, non-interactive
+pnpm create zudo-doc my-docs \
+  --lang ja \
+  --scheme Dracula \
+  --no-i18n \
+  --search \
+  --pm pnpm \
+  --install
+```
+
+## Options
+
+### Project basics
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `[project-name]` | Project name (positional arg or `--name`) | prompted |
+| `--lang <code>` | Default language: `en`, `ja`, `zh-cn`, `zh-tw`, `ko`, `es`, `fr`, `de`, `pt` | `en` |
+| `--pm <manager>` | Package manager: `pnpm`, `npm`, `yarn`, `bun` | detected |
+| `--[no-]install` | Install dependencies after scaffolding | prompted |
+| `-y, --yes` | Use defaults for all unspecified options, skip prompts | — |
+| `-h, --help` | Show help | — |
+
+### Color scheme
+
+| Flag | Description |
+|------|-------------|
+| `--color-scheme-mode <mode>` | `single` (one fixed scheme) or `light-dark` (OS-aware) |
+| `--scheme <name>` | Color scheme name when using `single` mode |
+| `--light-scheme <name>` | Light scheme when using `light-dark` mode |
+| `--dark-scheme <name>` | Dark scheme when using `light-dark` mode |
+| `--default-mode <mode>` | `light` or `dark` — initial mode in `light-dark` |
+| `--[no-]respect-system-preference` | Follow OS color scheme preference |
+
+### Features
+
+Each feature has a `--[no-]<flag>` form. Passing `--feature` enables it; `--no-feature` disables it; omitting the flag triggers the interactive prompt (or uses the default when `--yes` is set).
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--[no-]i18n` | Multi-language support (adds a secondary locale) | off |
+| `--[no-]search` | Pagefind full-text search | on |
+| `--[no-]sidebar-filter` | Real-time sidebar filter | on |
+| `--[no-]image-enlarge` | Click-to-enlarge for oversized images | on |
+| `--[no-]tag-governance` | Vocabulary-aware tag audit + suggest scripts | on |
+| `--[no-]claude-resources` | Auto-generate Claude Code docs (`CLAUDE.md`, `llms.txt`) | off |
+| `--[no-]claude-skills` | Ship zudo-doc Claude Code skills (design-system, translate, version-bump) | off |
+| `--[no-]design-token-panel` | Interactive panel for tweaking spacing, font, color tokens | off |
+| `--[no-]sidebar-resizer` | Draggable sidebar width handle | off |
+| `--[no-]sidebar-toggle` | Show/hide desktop sidebar button | off |
+| `--[no-]versioning` | Multi-version documentation support | off |
+| `--[no-]doc-history` | Show per-page document edit history | off |
+| `--[no-]body-foot-util` | Right-aligned strip below each doc (history trigger + GitHub source link) | off |
+| `--[no-]llms-txt` | Generate `llms.txt` for LLM consumption | off |
+| `--[no-]skill-symlinker` | Symlink documentation skills into `.claude/` | off |
+| `--[no-]tauri` | Tauri desktop app — Mode 1 offline reader | off |
+| `--[no-]tauri-dev` | Tauri dev wrapper — Mode 2 configurable dev wrapper | off |
+| `--[no-]footer-nav-group` | Navigation links in the footer | off |
+| `--[no-]footer-copyright` | Copyright notice in the footer | off |
+| `--[no-]footer-taglist` | Grouped tag index in the footer (requires tag-governance) | off |
+| `--[no-]changelog` | Changelog page | off |
+
+### Advanced
+
+| Flag | Description |
+|------|-------------|
+| `--github-url <url>` | GitHub repository URL — drives header link and "View source" links |
+| `--preset <path>` | Load all settings from a JSON file (use `-` for stdin) |
+
+## Examples
+
+```bash
+# Japanese docs site with search and sidebar, using pnpm
+pnpm create zudo-doc my-docs \
+  --lang ja \
+  --search \
+  --sidebar-filter \
+  --pm pnpm \
+  --install \
+  --yes
+
+# Light/dark color scheme with Catppuccin pairings
+pnpm create zudo-doc my-docs \
+  --color-scheme-mode light-dark \
+  --light-scheme "Catppuccin Latte" \
+  --dark-scheme "Catppuccin Mocha" \
+  --default-mode dark \
+  --yes
+
+# Fully featured site from a preset file
+pnpm create zudo-doc my-docs --preset ./my-preset.json --install
+```
+
+## Programmatic API
+
+```ts
+import { createZudoDoc } from "create-zudo-doc";
+
+await createZudoDoc({
+  projectName: "my-docs",
+  defaultLang: "en",
+  colorSchemeMode: "single",
+  singleScheme: "Dracula",
+  features: ["search", "sidebarFilter", "tagGovernance"],
+  packageManager: "pnpm",
+  install: true,
+});
+```
+
+## Documentation
+
+Full documentation at [zudo-doc.takazudomodular.com](https://zudo-doc.takazudomodular.com).
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/bin/create-zudo-doc.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/api.d.ts

@@ -0,0 +1,20 @@
+export type { UserChoices } from "./prompts.js";
+export interface CreateOptions {
+    projectName: string;
+    /** Default language code (default: "en") */
+    defaultLang?: string;
+    colorSchemeMode: "single" | "light-dark";
+    singleScheme?: string;
+    lightScheme?: string;
+    darkScheme?: string;
+    respectPrefersColorScheme?: boolean;
+    defaultMode?: "light" | "dark";
+    features: string[];
+    /** GitHub repository URL — drives the header GitHub link and body-foot
+     *  "View source on GitHub" link. Empty = disabled. */
+    githubUrl?: string;
+    packageManager: "pnpm" | "npm" | "yarn" | "bun";
+    /** Install dependencies after scaffolding (default: false) */
+    install?: boolean;
+}
+export declare function createZudoDoc(options: CreateOptions): Promise<string>;

package/dist/api.js

@@ -0,0 +1,13 @@
+import path from "path";
+import { scaffold } from "./scaffold.js";
+import { installDependencies } from "./utils.js";
+export async function createZudoDoc(options) {
+    const { install = false, ...rest } = options;
+    const choices = { ...rest, defaultLang: rest.defaultLang ?? "en" };
+    await scaffold(choices);
+    const targetDir = path.resolve(process.cwd(), choices.projectName);
+    if (install) {
+        installDependencies(targetDir, choices.packageManager);
+    }
+    return targetDir;
+}

package/dist/claude-md-gen.d.ts

@@ -0,0 +1,2 @@
+import type { UserChoices } from "./prompts.js";
+export declare function generateCLAUDEFile(choices: UserChoices): string;

package/dist/claude-md-gen.js

@@ -0,0 +1,113 @@
+import { capitalize } from "./utils.js";
+function runCmd(pm, script) {
+    if (pm === "npm")
+        return `npm run ${script}`;
+    return `${pm} ${script}`;
+}
+export function generateCLAUDEFile(choices) {
+    const siteName = capitalize(choices.projectName.replace(/-/g, " "));
+    const lines = [];
+    lines.push(`# ${siteName}`);
+    lines.push(``);
+    lines.push(`Documentation site built with [zudo-doc](https://github.com/zudolab/zudo-doc) — a zfb-based documentation framework with MDX, Tailwind CSS v4, and Preact islands.`);
+    lines.push(``);
+    // Tech stack
+    lines.push(`## Tech Stack`);
+    lines.push(``);
+    lines.push(`- **zfb** — documentation build framework`);
+    lines.push(`- **MDX** — content format`);
+    lines.push(`- **Tailwind CSS v4** — via \`@tailwindcss/vite\``);
+    lines.push(`- **Preact** — for interactive islands only (with compat mode for React API)`);
+    lines.push(`- **syntect** — built-in code highlighting, run by zfb's Rust pipeline at build time (single fixed theme: \`base16-ocean-dark\`)`);
+    lines.push(``);
+    // Commands
+    lines.push(`## Commands`);
+    lines.push(``);
+    const pm = choices.packageManager;
+    lines.push(`- \`${runCmd(pm, "dev")}\` — zfb dev server (port 4321)`);
+    lines.push(`- \`${runCmd(pm, "build")}\` — static HTML export to \`dist/\``);
+    lines.push(`- \`${runCmd(pm, "check")}\` — TypeScript type checking`);
+    lines.push(``);
+    // Key directories
+    lines.push(`## Key Directories`);
+    lines.push(``);
+    lines.push("```");
+    lines.push(`src/`);
+    lines.push(`├── components/          # JSX + Preact components`);
+    lines.push(`│   └── admonitions/     # Note, Tip, Info, Warning, Danger`);
+    lines.push(`├── config/              # Settings, color schemes`);
+    lines.push(`├── content/`);
+    lines.push(`│   └── docs/            # MDX content`);
+    if (choices.features.includes("i18n")) {
+        const secondaryLang = choices.defaultLang === "ja" ? "en" : "ja";
+        lines.push(`│   └── docs-${secondaryLang}/         # ${secondaryLang === "ja" ? "Japanese" : "English"} MDX content (mirrors docs/)`);
+    }
+    lines.push(`├── layouts/             # JSX layouts`);
+    lines.push(`├── pages/               # File-based routing`);
+    lines.push(`└── styles/`);
+    lines.push(`    └── global.css       # Design tokens & Tailwind config`);
+    lines.push("```");
+    lines.push(``);
+    // Content conventions
+    lines.push(`## Content Conventions`);
+    lines.push(``);
+    lines.push(`### Frontmatter`);
+    lines.push(``);
+    lines.push(`- Required: \`title\` (string)`);
+    lines.push(`- Optional: \`description\`, \`sidebar_position\` (number), \`category\``);
+    lines.push(`- Sidebar order is driven by \`sidebar_position\``);
+    lines.push(``);
+    lines.push(`### Admonitions`);
+    lines.push(``);
+    lines.push(`Available in all MDX files without imports: \`<Note>\`, \`<Tip>\`, \`<Info>\`, \`<Warning>\`, \`<Danger>\``);
+    lines.push(`Each accepts an optional \`title\` prop.`);
+    lines.push(``);
+    lines.push(`### Headings`);
+    lines.push(``);
+    lines.push(`Do NOT use h1 (\`#\`) in doc content — the page title from frontmatter is rendered as h1. Start content headings from h2 (\`##\`).`);
+    lines.push(``);
+    // Components
+    lines.push(`## Components`);
+    lines.push(``);
+    lines.push(`- Default to **server-rendered JSX components** (\`.tsx\`) — zero JS, server-rendered`);
+    lines.push(`- Use **Preact islands** (\`client:load\`) only when client-side interactivity is needed`);
+    lines.push(``);
+    // i18n section
+    if (choices.features.includes("i18n")) {
+        const secondaryLang = choices.defaultLang === "ja" ? "en" : "ja";
+        const defaultLabel = choices.defaultLang === "ja" ? "Japanese" : "English";
+        const secondaryLabel = secondaryLang === "ja" ? "Japanese" : "English";
+        lines.push(`## i18n`);
+        lines.push(``);
+        lines.push(`- ${defaultLabel} (default): \`/docs/...\` — content in \`src/content/docs/\``);
+        lines.push(`- ${secondaryLabel}: \`/${secondaryLang}/docs/...\` — content in \`src/content/docs-${secondaryLang}/\``);
+        lines.push(`- ${secondaryLabel} docs should mirror the ${defaultLabel} directory structure`);
+        lines.push(``);
+    }
+    // Enabled features
+    const featureDescriptions = {
+        search: "Full-text search via Pagefind",
+        sidebarFilter: "Real-time sidebar filtering",
+        designTokenPanel: "Interactive tabbed panel for tweaking spacing, font, size, and color tokens",
+        sidebarResizer: "Draggable sidebar width",
+        sidebarToggle: "Show/hide desktop sidebar",
+        versioning: "Multi-version documentation support",
+        docHistory: "Document edit history",
+        llmsTxt: "Generates llms.txt for LLM consumption",
+        claudeResources: "Auto-generated docs for Claude Code resources",
+        changelog: "Changelog page at `/docs/changelog`",
+    };
+    const enabledFeatures = choices.features.filter((f) => featureDescriptions[f] !== undefined &&
+        f !== "footerNavGroup" &&
+        f !== "footerCopyright" &&
+        f !== "skillSymlinker");
+    if (enabledFeatures.length > 0) {
+        lines.push(`## Enabled Features`);
+        lines.push(``);
+        for (const f of enabledFeatures) {
+            lines.push(`- **${f}** — ${featureDescriptions[f]}`);
+        }
+        lines.push(``);
+    }
+    return lines.join("\n");
+}

package/dist/cli.d.ts

@@ -0,0 +1,39 @@
+export interface CliArgs {
+    name?: string;
+    lang?: string;
+    colorSchemeMode?: "single" | "light-dark";
+    scheme?: string;
+    lightScheme?: string;
+    darkScheme?: string;
+    defaultMode?: "light" | "dark";
+    respectSystemPreference?: boolean;
+    i18n?: boolean;
+    search?: boolean;
+    sidebarFilter?: boolean;
+    designTokenPanel?: boolean;
+    sidebarResizer?: boolean;
+    sidebarToggle?: boolean;
+    versioning?: boolean;
+    claudeResources?: boolean;
+    claudeSkills?: boolean;
+    docHistory?: boolean;
+    llmsTxt?: boolean;
+    skillSymlinker?: boolean;
+    tauri?: boolean;
+    tauriDev?: boolean;
+    footerNavGroup?: boolean;
+    footerCopyright?: boolean;
+    changelog?: boolean;
+    tagGovernance?: boolean;
+    footerTaglist?: boolean;
+    bodyFootUtil?: boolean;
+    githubUrl?: string;
+    preset?: string;
+    pm?: "pnpm" | "npm" | "yarn" | "bun";
+    install?: boolean;
+    yes?: boolean;
+    help?: boolean;
+}
+export declare function parseArgs(argv?: string[]): CliArgs;
+export declare function printHelp(): void;
+export declare function validateArgs(args: CliArgs): string | null;

package/dist/cli.js

@@ -0,0 +1,157 @@
+import minimist from "minimist";
+import pc from "picocolors";
+import { FEATURES, SINGLE_SCHEMES, SUPPORTED_LANGS } from "./constants.js";
+export function parseArgs(argv = process.argv.slice(2)) {
+    const raw = minimist(argv, {
+        string: [
+            "name",
+            "lang",
+            "color-scheme-mode",
+            "scheme",
+            "light-scheme",
+            "dark-scheme",
+            "default-mode",
+            "github-url",
+            "preset",
+            "pm",
+        ],
+        // Do NOT declare booleans here — minimist would default them to false,
+        // making it impossible to distinguish "not passed" from "--no-flag".
+        // Instead we detect explicit usage by checking whether the original argv
+        // contains the flag (or its --no- variant).
+        alias: {
+            h: "help",
+            y: "yes",
+        },
+    });
+    /** Check if a boolean flag was explicitly passed in argv. */
+    function wasPassed(flag) {
+        return argv.some((a) => a === `--${flag}` || a === `--no-${flag}`);
+    }
+    const args = {};
+    // Project name: first positional arg or --name
+    if (raw.name) {
+        args.name = raw.name;
+    }
+    else if (raw._.length > 0 && typeof raw._[0] === "string") {
+        args.name = raw._[0];
+    }
+    if (raw.lang)
+        args.lang = raw.lang;
+    if (raw["color-scheme-mode"])
+        args.colorSchemeMode = raw["color-scheme-mode"];
+    if (raw.scheme)
+        args.scheme = raw.scheme;
+    if (raw["light-scheme"])
+        args.lightScheme = raw["light-scheme"];
+    if (raw["dark-scheme"])
+        args.darkScheme = raw["dark-scheme"];
+    if (raw["default-mode"])
+        args.defaultMode = raw["default-mode"];
+    if (raw.preset)
+        args.preset = raw.preset;
+    if (raw.pm)
+        args.pm = raw.pm;
+    if (typeof raw["github-url"] === "string")
+        args.githubUrl = raw["github-url"];
+    // Boolean flags — only set if explicitly passed in argv
+    if (wasPassed("respect-system-preference")) {
+        args.respectSystemPreference = raw["respect-system-preference"] !== false;
+    }
+    // Feature flags — driven by FEATURES constant
+    for (const f of FEATURES) {
+        if (wasPassed(f.cliFlag)) {
+            args[f.value] = raw[f.cliFlag] !== false;
+        }
+    }
+    if (wasPassed("install"))
+        args.install = raw["install"] !== false;
+    if (raw.yes || raw.y)
+        args.yes = true;
+    if (raw.help || raw.h)
+        args.help = true;
+    return args;
+}
+export function printHelp() {
+    const langList = SUPPORTED_LANGS.map((l) => l.value).join(", ");
+    const featureHelp = FEATURES.map((f) => `  --[no-]${f.cliFlag.padEnd(22)} ${f.hint}`).join("\n");
+    console.log(`
+${pc.bold("Usage:")} create-zudo-doc [project-name] [options]
+
+${pc.bold("Options:")}
+  --name <name>                Project name (or first positional arg)
+  --lang <code>                Default language (${langList})
+                               Default: en
+  --color-scheme-mode <mode>   single | light-dark
+  --scheme <name>              Color scheme (single mode)
+  --light-scheme <name>        Light scheme (light-dark mode)
+  --dark-scheme <name>         Dark scheme (light-dark mode)
+  --default-mode <mode>        light | dark (light-dark mode)
+  --[no-]respect-system-preference
+                               Respect OS color scheme preference
+${featureHelp}
+  --github-url <url>           GitHub repository URL (drives header link + source link)
+  --preset <path>              Load settings from a JSON preset file (use "-" for stdin)
+  --pm <manager>               pnpm | npm | yarn | bun
+  --[no-]install               Install dependencies after scaffolding
+  -y, --yes                    Use defaults for unspecified options, skip prompts
+  -h, --help                   Show this help message
+
+${pc.bold("Examples:")}
+  ${pc.dim("# Interactive mode (default)")}
+  create-zudo-doc
+
+  ${pc.dim("# Non-interactive with defaults")}
+  create-zudo-doc my-docs --yes
+
+  ${pc.dim("# Fully specified")}
+  create-zudo-doc my-docs --lang ja --scheme Dracula --no-i18n --pm pnpm --install
+
+  ${pc.dim("# Light/dark mode with custom schemes")}
+  create-zudo-doc my-docs --color-scheme-mode light-dark \\
+    --light-scheme "GitHub Light" --dark-scheme "GitHub Dark" \\
+    --default-mode dark --yes
+`);
+}
+export function validateArgs(args) {
+    if (args.lang) {
+        const validLangs = SUPPORTED_LANGS.map((l) => l.value);
+        if (!validLangs.includes(args.lang)) {
+            return `Invalid language "${args.lang}". Supported: ${validLangs.join(", ")}`;
+        }
+    }
+    if (args.colorSchemeMode && !["single", "light-dark"].includes(args.colorSchemeMode)) {
+        return `Invalid color-scheme-mode "${args.colorSchemeMode}". Must be "single" or "light-dark"`;
+    }
+    if (args.scheme && !SINGLE_SCHEMES.includes(args.scheme)) {
+        return `Unknown color scheme "${args.scheme}"`;
+    }
+    if (args.lightScheme && !SINGLE_SCHEMES.includes(args.lightScheme)) {
+        return `Unknown light scheme "${args.lightScheme}"`;
+    }
+    if (args.darkScheme && !SINGLE_SCHEMES.includes(args.darkScheme)) {
+        return `Unknown dark scheme "${args.darkScheme}"`;
+    }
+    if (args.defaultMode && !["light", "dark"].includes(args.defaultMode)) {
+        return `Invalid default-mode "${args.defaultMode}". Must be "light" or "dark"`;
+    }
+    if (args.pm && !["pnpm", "npm", "yarn", "bun"].includes(args.pm)) {
+        return `Invalid package manager "${args.pm}". Must be pnpm, npm, yarn, or bun`;
+    }
+    // Validate scheme combinations
+    if (args.colorSchemeMode === "single" && (args.lightScheme || args.darkScheme)) {
+        return `--light-scheme and --dark-scheme are only valid with --color-scheme-mode light-dark`;
+    }
+    if (args.colorSchemeMode === "light-dark" && args.scheme) {
+        return `--scheme is only valid with --color-scheme-mode single`;
+    }
+    if (args.name) {
+        if (/^[./]|\.\./.test(args.name)) {
+            return "Project name must not contain path traversal characters";
+        }
+        if (/[<>:"|?*\\]/.test(args.name)) {
+            return "Project name contains invalid characters";
+        }
+    }
+    return null;
+}

package/dist/compose.d.ts

@@ -0,0 +1,95 @@
+import type { UserChoices } from "./prompts.js";
+/** A single injection into a shared file at an anchor point. */
+export interface Injection {
+    /** Target file path relative to project root */
+    file: string;
+    /** Anchor comment string to locate in the target file */
+    anchor: string;
+    /** Content to insert */
+    content: string;
+    /**
+     * Where to insert relative to the anchor line.
+     * - "before": insert content on the line before the anchor (default)
+     * - "after": insert content on the line after the anchor
+     * - "replace": replace the range between `anchor` (start) and the
+     *   corresponding `:end` anchor. The anchor must end with `:start`
+     *   and a sibling anchor ending with `:end` must exist.
+     */
+    position?: "before" | "after" | "replace";
+}
+/** Definition of a single feature's contribution to the generated project. */
+export interface FeatureDefinition {
+    /** Feature key (matches constants.ts value or internal name) */
+    name: string;
+    /** Injection instructions for shared/base files */
+    injections: Injection[];
+    /** Other feature names this feature depends on (optional) */
+    dependencies?: string[];
+    /**
+     * Post-processing hook for complex transformations that cannot be expressed
+     * as simple file copies or anchor injections (e.g. i18n page patching).
+     */
+    postProcess?: (targetDir: string, choices: UserChoices) => Promise<void>;
+}
+/**
+ * A function that returns a FeatureDefinition based on user choices.
+ * This allows injections to be conditional on other choices.
+ */
+export type FeatureModule = (choices: UserChoices) => FeatureDefinition;
+/**
+ * Apply a list of injections to files in the target directory.
+ *
+ * Injections are grouped by target file and applied in array order.
+ * For "before"/"after" modes the content is inserted relative to the anchor
+ * line. For "replace" mode, the content replaces everything between the
+ * `:start` and `:end` anchors (exclusive — the anchor lines themselves are
+ * also removed).
+ */
+export declare function applyInjections(targetDir: string, injections: Injection[]): Promise<void>;
+/**
+ * Remove all remaining `@slot:` anchor lines from files in the target
+ * directory. Call this after all injections have been applied so that
+ * unused anchors don't appear in the generated project.
+ */
+export declare function cleanAnchors(targetDir: string, files: string[]): Promise<void>;
+/**
+ * Copy a feature's files into the target directory.
+ * `featureFilesDir` is the absolute path to the feature's `files/` directory.
+ * Each file inside mirrors the project directory structure.
+ */
+export declare function copyFeatureFiles(featureFilesDir: string, targetDir: string): Promise<void>;
+/**
+ * Resolve which features are selected based on UserChoices.
+ * Handles special cases like the footer pseudo-feature.
+ */
+export declare function resolveSelectedFeatures(choices: UserChoices, featureModules: Record<string, FeatureModule>): FeatureDefinition[];
+/**
+ * Validate that all feature dependencies are satisfied.
+ * Throws if a selected feature depends on one that isn't selected.
+ */
+export declare function validateDependencies(features: FeatureDefinition[], allSelectedNames: Set<string>): void;
+/** Files that may contain injection anchors and need cleaning.
+ *
+ * W7A (#1736): the two `.astro` entries were dropped — those files no
+ * longer exist in generated projects after the post-cutover .tsx
+ * migration. The only surviving anchor target is `global.css`, where
+ * `design-token-panel.ts` injects `@import "@takazudo/zdtp/styles.css";`
+ * at `@slot:global-css:feature-styles`. The sibling
+ * `@slot:global-css:theme-tokens` anchor in the same file is consumed
+ * by the color-scheme palette generator and must remain. The .tsx
+ * anchor form is still supported in `ANCHOR_LINE_RE` for forward
+ * compatibility, but no current feature uses it.
+ */
+export declare const ANCHOR_FILES: string[];
+/**
+ * Main composition entry point. Orchestrates the full feature composition
+ * pipeline for a generated project.
+ *
+ * 1. Resolve selected features
+ * 2. Validate dependencies
+ * 3. Copy feature files
+ * 4. Apply all injections
+ * 5. Run post-processing hooks
+ * 6. Clean up unused anchors
+ */
+export declare function composeFeatures(targetDir: string, choices: UserChoices, featureModules: Record<string, FeatureModule>, featuresDir: string): Promise<void>;