chiltepin 0.47.0

package/dist/bin.js

@@ -0,0 +1,3582 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import pc5 from 'picocolors';
+import { useState } from 'react';
+import { render, Box, Text, useApp, useInput } from 'ink';
+import { existsSync, readFileSync, statSync, watch, readdirSync } from 'fs';
+import { resolve, dirname, join, parse, relative, sep, basename, posix, extname } from 'path';
+import { parse as parse$1 } from 'yaml';
+import { createJiti } from 'jiti';
+import { fileURLToPath } from 'url';
+import { PROSE_CHECK_CODES, DOC_TEMPLATE_INFO, BLOCK_FAMILIES, familyBlocks, isBlockFamily, parseDocument, validateDocument, lintProse, lintDensity, resolveRefs, helpUrl, isDocTemplate, BLOCK_TYPES, BLOCK_ALIASES, DOC_TEMPLATES, BLOCK_DESCRIPTIONS, parseOpenApi, openapiToMarkdown, suggestCsvImport, csvToStatustable, csvToChart, csvToTable, blockContract, formatBlockContract, BLOCK_TEMPLATES, convertSqlDdl, convertDbml, convertPrisma, erdFence, BLOCK_FAMILY } from 'chiltepin-core';
+import { readFile, mkdir, writeFile, cp, realpath, stat, unlink, rmdir, readdir, rename } from 'fs/promises';
+import fg from 'fast-glob';
+import { createHash, randomBytes } from 'crypto';
+import { tmpdir } from 'os';
+import open from 'open';
+import { renderDocument, toSlides, houseCss, buildThemeVars, DEFAULT_THEME, escapeHtml, renderDocumentParts, schemeMarkup, FAVICON_LINK, htmlRenderers } from 'chiltepin-render';
+import { spawnSync, spawn } from 'child_process';
+import { createRequire } from 'module';
+import SelectInput2 from 'ink-select-input';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { createServer } from 'http';
+import cfonts from 'cfonts';
+
+var DEFAULTS = {
+  docsDir: "docs",
+  outDir: "dist",
+  richIndex: true,
+  colorScheme: "dark"
+};
+var CONFIG_EXTENSIONS = ["ts", "js", "mjs", "json", "yml", "yaml"];
+var CONFIG_FILES = [
+  ...CONFIG_EXTENSIONS.map((ext) => `chiltepin.config.${ext}`),
+  ...CONFIG_EXTENSIONS.map((ext) => `avodado.config.${ext}`)
+];
+var isLegacyConfigName = (name) => name.startsWith("avodado.config.");
+var warnedLegacy = false;
+function findConfig(cwd) {
+  return CONFIG_FILES.find((name) => existsSync(resolve(cwd, name)));
+}
+async function loadConfig(cwd) {
+  for (const name of CONFIG_FILES) {
+    const path = resolve(cwd, name);
+    if (!existsSync(path)) continue;
+    if (isLegacyConfigName(name) && !warnedLegacy) {
+      warnedLegacy = true;
+      process.stderr.write(
+        `${name} is the old name \u2014 rename it to ${name.replace("avodado", "chiltepin")}. It still loads for now.
+`
+      );
+    }
+    const raw = await readConfig(path);
+    return mergeWithDefaults(raw);
+  }
+  return DEFAULTS;
+}
+async function readConfig(path) {
+  if (path.endsWith(".json")) {
+    return JSON.parse(readFileSync(path, "utf8"));
+  }
+  if (path.endsWith(".yml") || path.endsWith(".yaml")) {
+    return parse$1(readFileSync(path, "utf8"));
+  }
+  const jiti = createJiti(import.meta.url);
+  const mod = await jiti.import(path);
+  return mod.default ?? mod;
+}
+function mergeWithDefaults(raw) {
+  if (raw === null || typeof raw !== "object") return DEFAULTS;
+  const r = raw;
+  const scheme = r.colorScheme === "light" || r.colorScheme === "system" || r.colorScheme === "dark" ? r.colorScheme : DEFAULTS.colorScheme;
+  return {
+    docsDir: typeof r.docsDir === "string" ? r.docsDir : DEFAULTS.docsDir,
+    outDir: typeof r.outDir === "string" ? r.outDir : DEFAULTS.outDir,
+    richIndex: typeof r.richIndex === "boolean" ? r.richIndex : DEFAULTS.richIndex,
+    colorScheme: scheme
+  };
+}
+function cliVersion() {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+      const p = join(dir, "package.json");
+      if (existsSync(p)) {
+        const j = JSON.parse(readFileSync(p, "utf8"));
+        if ((j.name === "chiltepin" || j.name === "avodado" || j.name === "@avodado/cli") && typeof j.version === "string") {
+          return j.version;
+        }
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+async function loadDocs(patterns, cwd, docsRoot) {
+  const matches = await fg(patterns, {
+    cwd,
+    absolute: true,
+    onlyFiles: true,
+    dot: false,
+    followSymbolicLinks: false
+  });
+  const docsRootAbs = resolve(cwd, docsRoot);
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const absolute of matches) {
+    let real;
+    try {
+      real = await realpath(absolute);
+    } catch {
+      real = absolute;
+    }
+    if (seen.has(real)) continue;
+    seen.add(real);
+    unique.push(absolute);
+  }
+  const files = await Promise.all(
+    unique.map(async (absolute) => {
+      const file = relative(cwd, absolute);
+      const slug = deriveSlug(absolute, docsRootAbs);
+      const decoded = decodeUtf8(await readFile(absolute));
+      return { absolute, file, slug, ...decoded };
+    })
+  );
+  files.sort((a, b) => a.file.localeCompare(b.file));
+  return files;
+}
+function encodingDiagnostics(docs) {
+  const out = [];
+  for (const d of docs) {
+    if (d.encodingError === void 0) continue;
+    out.push({
+      file: d.file,
+      ...d.encodingLine !== void 0 ? { line: d.encodingLine } : {},
+      level: "error",
+      code: "E_ENCODING",
+      message: d.encodingError,
+      hint: "Re-save the file as UTF-8 (no byte order mark)."
+    });
+  }
+  return out;
+}
+var BOMS = [
+  { bytes: [255, 254, 0, 0], label: "UTF-32 LE" },
+  { bytes: [0, 0, 254, 255], label: "UTF-32 BE" },
+  { bytes: [255, 254], label: "UTF-16 LE" },
+  { bytes: [254, 255], label: "UTF-16 BE" }
+];
+var startsWith = (buf, bytes) => buf.length >= bytes.length && bytes.every((b, i) => buf[i] === b);
+function decodeUtf8(buf) {
+  for (const bom of BOMS) {
+    if (startsWith(buf, bom.bytes)) {
+      return {
+        source: "",
+        encodingError: `The file is not UTF-8: it starts with a ${bom.label} byte order mark.`,
+        encodingLine: 1
+      };
+    }
+  }
+  const body = startsWith(buf, [239, 187, 191]) ? buf.subarray(3) : buf;
+  const bad = firstInvalidUtf8(body);
+  if (bad !== void 0) {
+    let line = 1;
+    for (let i = 0; i < bad; i += 1) if (body[i] === 10) line += 1;
+    return {
+      source: "",
+      encodingError: `The file is not UTF-8: byte ${bad} is not part of a valid UTF-8 sequence.`,
+      encodingLine: line
+    };
+  }
+  return { source: body.toString("utf8") };
+}
+function firstInvalidUtf8(buf) {
+  const len = buf.length;
+  let i = 0;
+  while (i < len) {
+    const b = buf[i];
+    if (b < 128) {
+      i += 1;
+      continue;
+    }
+    let need;
+    let cp2;
+    if (b >= 194 && b <= 223) {
+      need = 1;
+      cp2 = b & 31;
+    } else if (b >= 224 && b <= 239) {
+      need = 2;
+      cp2 = b & 15;
+    } else if (b >= 240 && b <= 244) {
+      need = 3;
+      cp2 = b & 7;
+    } else {
+      return i;
+    }
+    if (i + need > len - 1) return i;
+    for (let k = 1; k <= need; k += 1) {
+      const c = buf[i + k];
+      if ((c & 192) !== 128) return i;
+      cp2 = cp2 << 6 | c & 63;
+    }
+    if (need === 2 && (cp2 < 2048 || cp2 >= 55296 && cp2 <= 57343)) return i;
+    if (need === 3 && (cp2 < 65536 || cp2 > 1114111)) return i;
+    i += need + 1;
+  }
+  return void 0;
+}
+function deriveSlug(absolute, docsRootAbs) {
+  const rel2 = relative(docsRootAbs, absolute);
+  const inside2 = !rel2.startsWith("..") && !rel2.startsWith(sep) && rel2.length > 0;
+  const path = inside2 ? rel2 : basename(absolute);
+  return path.replace(/\\/g, "/").replace(/\.md$/i, "");
+}
+var KEBAB_FILE = /^[a-z0-9]+(-[a-z0-9]+)*\.md$/;
+var MAX_DEPTH = 2;
+function kebabSuggestion(filename) {
+  const stem = filename.replace(/\.md$/i, "");
+  const slug = stem.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${slug.length > 0 ? slug : "doc"}.md`;
+}
+function lintConventions(file, absolute, cwd, docsRoot) {
+  const rel2 = relative(resolve(cwd, docsRoot), absolute);
+  const inside2 = rel2.length > 0 && !rel2.startsWith("..") && !rel2.startsWith(sep);
+  if (!inside2) return [];
+  const diagnostics = [];
+  const name = basename(absolute);
+  if (!KEBAB_FILE.test(name)) {
+    diagnostics.push({
+      file,
+      level: "warn",
+      code: "W_DOC_CONVENTION",
+      message: `The file name "${name}" is not kebab-case. Doc names use lowercase a-z, 0-9, and hyphens. The name is the reference prefix, so refs to this doc inherit it.`,
+      value: name,
+      hint: `Rename the file to kebab-case: ${kebabSuggestion(name)}.`
+    });
+  }
+  const depth = rel2.split(sep).length;
+  if (depth > MAX_DEPTH) {
+    diagnostics.push({
+      file,
+      level: "warn",
+      code: "W_DOC_CONVENTION",
+      message: `The file is ${depth} levels below ${docsRoot}/. The convention permits one group level: ${docsRoot}/<area>/<doc>.md.`,
+      value: rel2.split(sep).join("/"),
+      hint: `Move the file to ${docsRoot}/<area>/${name}, then update refs to its old slug.`
+    });
+  }
+  return diagnostics;
+}
+
+// src/commands/check.tsx
+var PROSE_CODES = new Set(PROSE_CHECK_CODES);
+async function runCheck(opts) {
+  const docs = await loadDocs(opts.patterns, opts.cwd, opts.docsRoot);
+  const parsed = docs.filter((d) => d.encodingError === void 0).map((d) => ({
+    doc: parseDocument(d.source, d.slug),
+    file: d.file
+  }));
+  const diagnostics = [...encodingDiagnostics(docs)];
+  for (const { doc, file } of parsed) {
+    diagnostics.push(...validateDocument(doc, file));
+    diagnostics.push(...lintProse(doc, file));
+    diagnostics.push(...lintDensity(doc, file));
+  }
+  for (const d of docs) {
+    diagnostics.push(...lintConventions(d.file, d.absolute, opts.cwd, opts.docsRoot));
+  }
+  const resolved = resolveRefs(parsed);
+  diagnostics.push(...resolved.diagnostics);
+  const escalated = opts.strictProse === true ? diagnostics.map(
+    (d) => d.level === "warn" && PROSE_CODES.has(d.code) ? { ...d, level: "error" } : d
+  ) : diagnostics;
+  escalated.sort((a, b) => {
+    const f = a.file.localeCompare(b.file);
+    if (f !== 0) return f;
+    return (a.line ?? 0) - (b.line ?? 0);
+  });
+  const exitCode = escalated.some((d) => d.level === "error") ? 1 : 0;
+  const sources = /* @__PURE__ */ new Map();
+  for (const d of docs) {
+    if (d.encodingError !== void 0) continue;
+    sources.set(d.file, d.source.split(/\r\n|\r|\n/));
+  }
+  return {
+    diagnostics: escalated,
+    files: docs.map((d) => d.file),
+    sources,
+    exitCode
+  };
+}
+var require2 = createRequire(import.meta.url);
+function isMissingBrowserError(message) {
+  return /Executable doesn't exist|playwright install|just installed or updated/i.test(message);
+}
+function playwrightCliPath() {
+  try {
+    return join(dirname(require2.resolve("playwright/package.json")), "cli.js");
+  } catch {
+    return void 0;
+  }
+}
+async function installChromium(log = () => {
+}) {
+  const cli = playwrightCliPath();
+  if (cli === void 0) {
+    throw new Error("Could not locate the Playwright CLI. Run `npx playwright install chromium`.");
+  }
+  log("Downloading Chromium for PDF export (one-time, ~100 MB)\u2026");
+  await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(process.execPath, [cli, "install", "chromium"], {
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    child.on("error", rejectPromise);
+    child.on(
+      "exit",
+      (code2) => code2 === 0 ? resolvePromise() : rejectPromise(new Error(`playwright install exited with code ${String(code2)}`))
+    );
+  });
+}
+async function toPdf(input, opts = {}) {
+  const html = typeof input === "string" ? input : renderDocument(input);
+  const pw = await loadPlaywright();
+  const browser = await launchChromium(pw, opts);
+  try {
+    const page = await browser.newPage();
+    await page.setContent(html, { waitUntil: "networkidle" });
+    const buffer = await page.pdf({
+      // A custom pixel width wins over the named format (Playwright ignores
+      // `format` when width/height are given): portrait A-series proportions
+      // keep the page shape familiar at every preset.
+      ...opts.pageWidthPx !== void 0 ? {
+        width: `${String(opts.pageWidthPx)}px`,
+        height: `${String(Math.round(opts.pageWidthPx * Math.SQRT2))}px`
+      } : { format: opts.format ?? "A4" },
+      printBackground: true,
+      ...opts.margin !== void 0 ? { margin: opts.margin } : {}
+    });
+    return new Uint8Array(buffer);
+  } finally {
+    await browser.close();
+  }
+}
+async function launchChromium(pw, opts) {
+  try {
+    return await pw.chromium.launch({ headless: true });
+  } catch (err) {
+    const message = err.message;
+    if (!isMissingBrowserError(message)) throw err;
+    if (opts.autoInstallBrowser === true) {
+      await installChromium(opts.log);
+      return await pw.chromium.launch({ headless: true });
+    }
+    const cli = playwrightCliPath();
+    const cmd = cli !== void 0 ? `node "${cli}" install chromium` : "npx playwright install chromium";
+    throw new Error(
+      `Chromium isn't installed for PDF export. Install it once with:
+  ${cmd}
+Original error: ${message}`
+    );
+  }
+}
+async function loadPlaywright() {
+  try {
+    return await import('playwright');
+  } catch (err) {
+    throw new Error(
+      `Playwright is required for PDF export. Run: pnpm add playwright && npx playwright install chromium
+Original error: ${err.message}`
+    );
+  }
+}
+function overwriteRefusal(abs, guard = {}) {
+  if (guard.force === true) return void 0;
+  if (!existsSync(abs)) return void 0;
+  const lower = abs.toLowerCase();
+  const regenerates = guard.regenerates ?? [];
+  if (regenerates.some((ext) => lower.endsWith(ext.toLowerCase()))) return void 0;
+  const flag = guard.flag ?? "--force";
+  return `${abs} already exists \u2014 refusing to overwrite it. Pass ${flag} to replace it, or write to another path.`;
+}
+var OverwriteRefusedError = class extends Error {
+  name = "OverwriteRefusedError";
+};
+function assertWritable(abs, guard = {}) {
+  const refusal = overwriteRefusal(abs, guard);
+  if (refusal !== void 0) throw new OverwriteRefusedError(refusal);
+}
+async function writeFileSafe(abs, data, guard = {}) {
+  assertWritable(abs, guard);
+  await mkdir(dirname(abs), { recursive: true });
+  await writeFile(abs, data);
+}
+function errorMessage(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+var renderers = htmlRenderers;
+function failingBlock(doc) {
+  for (const seg of doc.segments) {
+    if (seg.kind === "markdown") continue;
+    if (seg.data === void 0) continue;
+    const render = renderers[seg.kind];
+    if (render === void 0) continue;
+    try {
+      render(seg.data);
+    } catch {
+      return seg;
+    }
+  }
+  return void 0;
+}
+function renderFailure(doc, file, what, err) {
+  const reason = errorMessage(err);
+  const block = failingBlock(doc);
+  if (block === void 0) {
+    return {
+      file,
+      level: "error",
+      code: "E_RENDER",
+      message: `The ${what} could not be rendered: ${reason}`,
+      hint: "No single block reproduces the failure \u2014 the whole document does."
+    };
+  }
+  const label = block.sourceType ?? block.kind;
+  return {
+    file,
+    line: block.line,
+    level: "error",
+    code: "E_RENDER",
+    message: `The ${what} could not be rendered: the \`${label}\` block failed \u2014 ${reason}`,
+    ...block.id !== void 0 ? { value: block.id } : {},
+    hint: "Fix the values in this block, or remove it and re-run `chiltepin build`."
+  };
+}
+function guardRender(doc, file, what, render) {
+  try {
+    return { ok: true, value: render() };
+  } catch (err) {
+    return { ok: false, diagnostic: renderFailure(doc, file, what, err) };
+  }
+}
+
+// src/commands/single.ts
+var SIZE_WIDTHS = {
+  sm: 720,
+  md: 960,
+  lg: 1280,
+  xl: 1600
+};
+function parseExportSize(value) {
+  return value === "sm" || value === "md" || value === "lg" || value === "xl" ? value : void 0;
+}
+var EXT = {
+  html: "html",
+  slides: "slides.html",
+  pdf: "pdf"
+};
+var REGENERATES = {
+  html: [".html", ".htm"],
+  slides: [".html", ".htm"],
+  pdf: [".pdf"]
+};
+async function runSingle(opts) {
+  const inputAbs = resolve(opts.cwd, opts.input);
+  const source = await readFile(inputAbs, "utf8");
+  const slug = parse(inputAbs).name;
+  const doc = parseDocument(source, slug);
+  const sizePx = opts.size !== void 0 && (opts.format === "html" || opts.format === "pdf") ? SIZE_WIDTHS[opts.size] : void 0;
+  const config = await loadConfig(opts.cwd);
+  const themeOpts = {
+    colorScheme: config.colorScheme,
+    ...sizePx !== void 0 ? { themeVars: { "--page-max": `${String(sizePx)}px` } } : {}
+  };
+  let outputAbs;
+  if (opts.preview === true) {
+    const hash = createHash("sha1").update(`${source}\0${opts.format}\0${JSON.stringify(themeOpts)}`).digest("hex").slice(0, 10);
+    const dir = join(tmpdir(), "chiltepin-preview");
+    await mkdir(dir, { recursive: true });
+    outputAbs = join(dir, `${slug}-${hash}.${EXT[opts.format]}`);
+  } else {
+    outputAbs = opts.output !== void 0 ? resolve(opts.cwd, opts.output) : inputAbs.replace(/\.md$/i, `.${EXT[opts.format]}`);
+    if (opts.output !== void 0) {
+      assertWritable(outputAbs, {
+        ...opts.force === true ? { force: true } : {},
+        regenerates: REGENERATES[opts.format]
+      });
+    }
+    await mkdir(dirname(outputAbs), { recursive: true });
+  }
+  const named = async (what, produce) => {
+    try {
+      return await produce();
+    } catch (err) {
+      const d = renderFailure(doc, relative(opts.cwd, inputAbs) || opts.input, what, err);
+      const where = d.line !== void 0 ? `${d.file}:${d.line}` : d.file;
+      throw new Error(`${where}  ${d.message}`, { cause: err });
+    }
+  };
+  let bytes;
+  if (opts.format === "pdf") {
+    const page = await named("PDF", () => renderDocument(doc, themeOpts));
+    const pdf = await toPdf(page, {
+      autoInstallBrowser: true,
+      log: (m) => console.error(m),
+      // With a size preset the PDF page itself takes the preset width (portrait
+      // A-series proportions); without one the page stays A4.
+      ...sizePx !== void 0 ? { pageWidthPx: sizePx } : {}
+    });
+    await writeFile(outputAbs, pdf);
+    bytes = pdf.byteLength;
+  } else {
+    const html = await named(
+      opts.format === "slides" ? "slide deck" : "page",
+      () => opts.format === "slides" ? toSlides(doc, themeOpts) : renderDocument(doc, themeOpts)
+    );
+    await writeFile(outputAbs, html, "utf8");
+    bytes = html.length;
+  }
+  const doOpen = opts.preview === true && opts.open !== false;
+  if (doOpen) await open(outputAbs);
+  return { output: outputAbs, bytes, opened: doOpen };
+}
+var SKILL_REFERENCE_FILES = [
+  "reference/blocks/INDEX.md",
+  "reference/blocks/narrative.md",
+  "reference/blocks/tables-data.md",
+  "reference/blocks/api.md",
+  "reference/blocks/architecture.md",
+  "reference/blocks/flows.md",
+  "reference/blocks/data-model.md",
+  "reference/blocks/charts-overviews.md",
+  "reference/blocks/planning.md",
+  "reference/blocks/business.md",
+  "reference/blocks/design-system.md",
+  "reference/blocks/algorithms.md",
+  "reference/blocks/agentic.md",
+  "reference/blocks/quality.md",
+  "reference/recipes.md",
+  "reference/patterns.md",
+  "reference/patterns-design.md",
+  "reference/mermaid.md",
+  "reference/writing.md",
+  "reference/check.md",
+  "reference/system-design.md",
+  "reference/decks.md",
+  "reference/intake.md",
+  "reference/organizing.md",
+  "reference/style-ste.md"
+];
+var SKILL_FILES = ["SKILL.md", ...SKILL_REFERENCE_FILES];
+var BASE_FILES = [
+  "chiltepin.config.json",
+  "docs/getting-started.md",
+  "docs/tutorial.md"
+];
+function templatesDir() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, "templates");
+    if (existsSync(candidate) && statSync(candidate).isDirectory()) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(`Could not locate chiltepin/cli templates directory near ${import.meta.url}`);
+}
+function skillDir() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    const candidate = join(dir, "skills", "chiltepin");
+    if (existsSync(join(candidate, "SKILL.md")) && existsSync(join(dir, "pnpm-workspace.yaml"))) {
+      return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const packaged = join(templatesDir(), "skill");
+  if (existsSync(join(packaged, "SKILL.md"))) return packaged;
+  throw new Error("Could not locate the Chiltepin skill (templates/skill or skills/chiltepin)");
+}
+async function stitchSkill(srcRoot = skillDir()) {
+  const parts = await Promise.all(SKILL_FILES.map((f) => readFile(resolve(srcRoot, f), "utf8")));
+  return (parts.map((p) => p.trimEnd()).join("\n\n---\n\n") + "\n").replaceAll(
+    "live beside this file \u2014 read them on demand",
+    "are included in full below \u2014 read them on demand"
+  );
+}
+async function runInit(opts) {
+  const srcRoot = templatesDir();
+  const created = [];
+  const skipped = [];
+  for (const rel2 of BASE_FILES) {
+    const dst = join(opts.cwd, rel2);
+    if (existsSync(dst) && opts.force !== true) {
+      skipped.push(rel2);
+      continue;
+    }
+    await mkdir(dirname(dst), { recursive: true });
+    await cp(resolve(srcRoot, rel2), dst);
+    created.push(rel2);
+  }
+  return { created, skipped };
+}
+function filterDemoSource(source, family) {
+  const doc = parseDocument(source, "demo");
+  const label = BLOCK_FAMILIES.find((f) => f.id === family)?.label ?? family;
+  const out = [];
+  let pendingMarkdown;
+  for (const seg of doc.segments) {
+    if (seg.kind === "markdown") {
+      pendingMarkdown = seg.text;
+      continue;
+    }
+    const keep = seg.kind === "meta" || BLOCK_FAMILY[seg.kind] === family;
+    if (keep) {
+      if (seg.kind === "meta") {
+        out.push("```meta\n" + retagMeta(seg.raw, label) + "\n```");
+      } else {
+        if (pendingMarkdown !== void 0) out.push(pendingMarkdown.trim());
+        out.push("```" + seg.kind + "\n" + seg.raw + "\n```");
+      }
+    }
+    pendingMarkdown = void 0;
+  }
+  return out.join("\n\n") + "\n";
+}
+function retagMeta(raw, label) {
+  const tagged = `tag: DEMO \xB7 ${label.toUpperCase()}`;
+  if (/^tag:.*$/m.test(raw)) return raw.replace(/^tag:.*$/m, tagged);
+  return `${raw}
+${tagged}`;
+}
+async function runDemo(opts) {
+  const format = opts.format ?? "html";
+  let source = await readFile(join(templatesDir(), "demo.md"), "utf8");
+  if (opts.family !== void 0) source = filterDemoSource(source, opts.family);
+  const dir = join(tmpdir(), "chiltepin-demo");
+  await mkdir(dir, { recursive: true });
+  const input = join(dir, opts.family === void 0 ? "demo.md" : `demo-${opts.family}.md`);
+  await writeFile(input, source, "utf8");
+  return runSingle({
+    cwd: dir,
+    input,
+    format,
+    ...opts.output !== void 0 ? { output: opts.output } : { preview: opts.preview ?? true },
+    ...opts.force === true ? { force: true } : {}
+  });
+}
+var EVERYTHING = "__all__";
+function DemoApp({ onPick }) {
+  const { exit } = useApp();
+  useInput((input, key) => {
+    if (input === "q" || key.escape) exit();
+  });
+  const items = [
+    { label: `Everything \u2014 the full showcase, all ${BLOCK_TYPES.length} blocks`, value: EVERYTHING },
+    ...BLOCK_FAMILIES.map((f) => ({
+      label: `${f.label} \u2014 ${familyBlocks(f.id).length} blocks`,
+      value: f.id
+    }))
+  ];
+  function pick(value) {
+    onPick(value === EVERYTHING ? {} : { family: value });
+    exit();
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+      "What do you want to see? ",
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "(\u2191\u2193 move \xB7 enter to render \xB7 q to quit)" })
+    ] }),
+    /* @__PURE__ */ jsx(SelectInput2, { items, onSelect: (item) => pick(item.value) })
+  ] });
+}
+var MANIFEST_FILE = ".chiltepin-build.json";
+var LEGACY_MANIFEST_FILE = ".avodado-build.json";
+async function readManifest(outDir) {
+  let raw;
+  try {
+    raw = await readFile(join(outDir, MANIFEST_FILE), "utf8");
+  } catch {
+    try {
+      raw = await readFile(join(outDir, LEGACY_MANIFEST_FILE), "utf8");
+    } catch {
+      return void 0;
+    }
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || !Array.isArray(parsed.files)) return void 0;
+    const files = parsed.files.filter((f) => typeof f === "string");
+    return { version: 1, generator: String(parsed.generator ?? ""), files };
+  } catch {
+    return void 0;
+  }
+}
+async function writeManifest(outDir, files, generator) {
+  const manifest = { version: 1, generator, files: [...files].sort() };
+  await writeFile(join(outDir, MANIFEST_FILE), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+  try {
+    await unlink(join(outDir, LEGACY_MANIFEST_FILE));
+  } catch {
+  }
+}
+function inside(root, abs) {
+  const rel2 = relative(root, abs);
+  return rel2 !== "" && !rel2.startsWith("..") && !rel2.startsWith(sep);
+}
+async function pruneStale(outDir, previous, current) {
+  const root = resolve(outDir);
+  const removed = [];
+  const parents = /* @__PURE__ */ new Set();
+  for (const rel2 of previous) {
+    if (current.has(rel2)) continue;
+    const abs = resolve(root, rel2);
+    if (!inside(root, abs)) continue;
+    try {
+      await unlink(abs);
+    } catch {
+      continue;
+    }
+    removed.push(rel2);
+    parents.add(dirname(abs));
+  }
+  for (const dir of [...parents].sort((a, b) => b.length - a.length)) {
+    let cur = dir;
+    while (inside(root, cur)) {
+      try {
+        await rmdir(cur);
+      } catch {
+        break;
+      }
+      cur = dirname(cur);
+    }
+  }
+  removed.sort();
+  return removed;
+}
+var LIVE_RELOAD_SCRIPT = `<script>new EventSource('/__events').onmessage=()=>location.reload()</script>`;
+var SITE_CSS = `
+body{margin:0;}
+.site{display:flex;align-items:flex-start;max-width:1440px;margin:0 auto;}
+.site-nav{position:sticky;top:0;flex:none;width:248px;max-height:100vh;overflow-y:auto;padding:28px 18px 48px;border-right:1px solid var(--rule);font-family:var(--font-body);font-size:13px;color:var(--ink);}
+.site-nav .nav-brand{display:block;font-family:var(--font-display);font-weight:600;font-size:14px;letter-spacing:.01em;color:var(--ink);text-decoration:none;padding:4px 8px;margin-bottom:6px;}
+.site-eyebrow{font-family:var(--font-mono);font-size:10px;font-weight:500;letter-spacing:.14em;text-transform:uppercase;color:var(--soft);}
+.site-nav .nav-head{padding:10px 8px 6px;border-top:1px solid var(--rule);}
+.site-nav a{display:block;color:var(--ink);text-decoration:none;padding:4px 8px;border-radius:4px;line-height:1.45;}
+.site-nav a:hover{background:var(--paper-2);}
+.site-nav a.current{color:var(--ink);font-weight:600;background:var(--paper-2);box-shadow:inset 2px 0 0 var(--ink);}
+.site-nav .nav-sections{margin:2px 0 8px 12px;padding-left:10px;border-left:1px solid var(--rule);}
+.site-nav .nav-sections a{font-size:12px;color:var(--muted);}
+.site-nav .nav-sections a:hover{color:var(--ink);}
+.site-main{flex:1;min-width:0;}
+.site-main .docskin{padding-top:40px;}
+@media (max-width:900px){
+.site{display:block;}
+.site-nav{position:static;width:auto;max-height:none;border-right:0;border-bottom:1px solid var(--rule);padding:20px 24px;}
+}
+.idx-head{padding:16px 0 28px;margin-bottom:36px;border-bottom:1px solid var(--rule);}
+.idx-eyebrow{margin-bottom:10px;}
+.idx-title{font-family:var(--font-display);font-weight:700;font-size:clamp(32px,4.4vw,48px);line-height:1.1;letter-spacing:-.015em;color:var(--ink);margin:0;}
+.idx-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:16px;}
+.idx-card{display:block;border:1px solid var(--rule-solid);border-radius:6px;background:var(--paper);padding:20px 22px 16px;text-decoration:none;color:var(--ink);box-shadow:none;}
+.idx-card:hover{border-color:var(--ink);}
+.idx-card .idx-tag{display:inline-block;font-family:var(--font-mono);font-size:10px;font-weight:500;letter-spacing:.14em;text-transform:uppercase;line-height:1.3;padding:2px 7px;border:1px solid var(--rule-solid);border-radius:2px;background:var(--paper);color:var(--muted);margin-bottom:12px;}
+.idx-card h2{font-family:var(--font-body);font-weight:600;font-size:16px;line-height:1.3;color:var(--ink);margin:0 0 6px;}
+.idx-card p{font-size:13px;line-height:1.55;color:var(--muted);margin:0 0 12px;}
+.idx-card .idx-slug{font-family:var(--font-mono);font-size:11px;color:var(--soft);}
+.site-main{position:relative;}
+.view-toggle{position:absolute;top:30px;right:32px;z-index:30;display:inline-flex;border:1px solid var(--rule-solid);border-radius:6px;background:var(--paper);overflow:hidden;font-family:var(--font-body);font-size:12px;font-weight:600;letter-spacing:.01em;box-shadow:none;}
+.view-toggle a{display:flex;align-items:center;padding:5px 14px;color:var(--muted);text-decoration:none;line-height:1.4;}
+.view-toggle a + a{border-left:1px solid var(--rule-solid);}
+.view-toggle a:hover{color:var(--ink);background:var(--paper-2);}
+.view-toggle a[aria-current]{background:var(--ink);color:var(--paper);}
+.view-toggle a[aria-current]:hover{background:var(--ink);color:var(--paper);}
+@media (max-width:900px){.view-toggle{top:14px;right:16px;}}
+`;
+var DECK_BACK_CSS = `
+.deck-doc-link{position:fixed;top:14px;right:18px;z-index:20;display:inline-flex;align-items:center;gap:7px;
+  padding:6px 14px;border:1px solid var(--rule-solid);border-radius:6px;
+  background:var(--paper);
+  font-family:var(--font-body);font-size:12px;font-weight:600;letter-spacing:.01em;color:var(--ink);
+  text-decoration:none;box-shadow:none;}
+.deck-doc-link:hover{background:var(--paper-2);border-color:var(--ink);}
+@media print{.deck-doc-link{display:none;}}
+`;
+function rootPrefix(slug) {
+  const depth = slug.split("/").length - 1;
+  return "../".repeat(depth);
+}
+var REF_CHIP_RE = / data-ref="([^"]+)" href="#[^"]*"/g;
+var REF_RE = /^([\w/.-]+)?#([\w.-]+)$/;
+function rewriteRefs(html, slug, nodes) {
+  const prefix = rootPrefix(slug);
+  return html.replace(REF_CHIP_RE, (whole, ref) => {
+    const m = REF_RE.exec(ref);
+    if (m === null) return whole;
+    const targetDoc = m[1] ?? slug;
+    const id = m[2] ?? "";
+    const node = nodes.get(id);
+    if (node === void 0 || node.doc !== targetDoc) return ` data-ref="${ref}"`;
+    if (node.doc === slug) return ` data-ref="${ref}" href="#${id}"`;
+    return ` data-ref="${ref}" href="${prefix}${node.doc}.html#${id}"`;
+  });
+}
+function sidebar(navDocs, current, sections) {
+  const prefix = current !== void 0 ? rootPrefix(current) : "";
+  const items = navDocs.map((d) => {
+    const isCurrent = d.slug === current;
+    const cls = isCurrent ? ' class="current"' : "";
+    const link = `<a${cls} href="${prefix}${escapeHtml(d.slug)}.html">${escapeHtml(d.title)}</a>`;
+    if (!isCurrent || sections.length === 0) return link;
+    const secs = sections.map((s) => `<a href="#${s.id}">${escapeHtml(s.title ?? s.label)}</a>`).join("");
+    return link + `<div class="nav-sections">${secs}</div>`;
+  }).join("");
+  return `<aside class="site-nav"><a class="nav-brand" href="${prefix}index.html">Documentation</a><div class="nav-head site-eyebrow">Documents</div><nav>${items}</nav></aside>`;
+}
+function slugBase(slug) {
+  return slug.split("/").pop() ?? slug;
+}
+function viewToggle(slug) {
+  const base = escapeHtml(slugBase(slug));
+  return `<nav class="view-toggle" aria-label="View as"><a aria-current="page" href="${base}.html">Doc</a><a href="${base}.slides.html">Slides</a></nav>`;
+}
+function deckWithChrome(deckHtml, slug, liveReload) {
+  const base = escapeHtml(slugBase(slug));
+  const pill = `<a class="deck-doc-link" href="${base}.html">Document <span aria-hidden="true">\u25B8</span></a>`;
+  const chrome = `<style>${DECK_BACK_CSS}</style>${pill}${liveReload ? LIVE_RELOAD_SCRIPT : ""}`;
+  return deckHtml.replace("</head>", `${FAVICON_LINK}
+</head>`).replace("</body>", `${chrome}</body>`);
+}
+function pageShell(args) {
+  const themeBlock = args.themeVars.length > 0 ? `<style>:root{${args.themeVars}}</style>` : "";
+  const reload = args.liveReload ? LIVE_RELOAD_SCRIPT : "";
+  const scheme = schemeMarkup(args.colorScheme);
+  return `<!doctype html>
+<html lang="en"${scheme.stamp}>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(args.title)}</title>
+${FAVICON_LINK}
+<style>${args.css}</style>` + themeBlock + scheme.style + `<style>${SITE_CSS}</style>
+</head>
+<body>
+<div class="site">
+` + args.nav + `
+<main class="site-main">${args.toggle ?? ""}<div class="docskin">${args.main}</div></main>
+</div>
+` + reload + `</body>
+</html>
+`;
+}
+function indexCard(d, tagDisplay) {
+  const meta = d.doc.meta;
+  const shownTag = tagDisplay ?? meta?.tag;
+  const tag = shownTag !== void 0 ? `<span class="idx-tag">${escapeHtml(shownTag)}</span>` : "";
+  const title = escapeHtml(meta?.title ?? d.slug);
+  const sub = meta?.subtitle !== void 0 ? `<p>${escapeHtml(meta.subtitle)}</p>` : "";
+  return `<a class="idx-card" href="${escapeHtml(d.slug)}.html">` + tag + `<h2>${title}</h2>` + sub + `<span class="idx-slug">${escapeHtml(d.slug)}</span></a>`;
+}
+function indexCards(docs) {
+  const cards = docs.map((d) => indexCard(d)).join("");
+  return `<div class="idx-head"><div class="idx-eyebrow site-eyebrow">${docs.length} document${docs.length === 1 ? "" : "s"}</div><h1 class="idx-title">Documentation</h1></div><div class="idx-grid">${cards}</div>`;
+}
+var RICH_INDEX_CSS = `
+.idx-tldr{display:grid;gap:5px;margin-top:16px;font-size:13px;line-height:1.55;color:var(--muted);}
+.idx-tldr a{color:var(--muted);text-decoration:none;}
+.idx-tldr a:hover{color:var(--ink);}
+.idx-tldr strong{font-family:var(--font-mono);font-size:10px;font-weight:500;letter-spacing:.14em;text-transform:uppercase;color:var(--ink);}
+.idx-group{margin-bottom:40px;}
+.idx-group-head{display:flex;align-items:baseline;gap:10px;font-family:var(--font-body);font-weight:600;font-size:18px;color:var(--ink);margin:0 0 14px;padding-bottom:8px;border-bottom:1px solid var(--rule);}
+.idx-group-count{font-family:var(--font-mono);font-size:10px;font-weight:500;letter-spacing:.14em;color:var(--soft);}
+.idx-graph{margin-top:8px;}
+.idx-graph-legend{list-style:none;margin:14px 0 0;padding:0;display:grid;gap:6px;font-size:13px;}
+.idx-graph-legend a{color:var(--link);text-decoration:none;font-weight:600;}
+.idx-graph-legend a:hover{text-decoration:underline;}
+.idx-graph-legend .idx-slug{font-family:var(--font-mono);font-size:11px;color:var(--soft);margin-left:8px;}
+`;
+function tagToken(tag) {
+  return (tag.split("\xB7")[0] ?? tag).trim();
+}
+function groupOf(d) {
+  const tag = d.doc.meta?.tag?.trim();
+  if (tag !== void 0 && tag.length > 0) {
+    const token = tagToken(tag);
+    if (token.length > 0) return { key: `tag:${token.toLowerCase()}`, label: token };
+  }
+  const slash = d.slug.indexOf("/");
+  if (slash > 0) {
+    const folder = d.slug.slice(0, slash);
+    return { key: `dir:${folder.toLowerCase()}`, label: folder };
+  }
+  return { key: "default", label: "Documents" };
+}
+function groupDocs(docs) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const d of docs) {
+    const { key, label } = groupOf(d);
+    const g = byKey.get(key);
+    if (g !== void 0) g.docs.push(d);
+    else byKey.set(key, { label, docs: [d] });
+  }
+  const groups = [...byKey.values()].sort(
+    (a, b) => b.docs.length - a.docs.length || (a.label < b.label ? -1 : 1)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return groups.map((g) => {
+    const base = `group-${g.label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "docs"}`;
+    let anchor = base;
+    for (let n = 2; seen.has(anchor); n += 1) anchor = `${base}-${n}`;
+    seen.add(anchor);
+    return { label: g.label, anchor, docs: g.docs };
+  });
+}
+function tldrDigest(groups) {
+  const lines = groups.map((g) => {
+    const sub = g.docs.length === 1 ? g.docs[0]?.doc.meta?.subtitle : void 0;
+    const tail = sub !== void 0 ? ` \u2014 ${escapeHtml(sub)}` : "";
+    const count = `${g.docs.length} document${g.docs.length === 1 ? "" : "s"}`;
+    return `<a href="#${g.anchor}"><strong>${escapeHtml(g.label)}</strong> \xB7 ${count}${tail}</a>`;
+  }).join("");
+  return `<nav class="idx-tldr">${lines}</nav>`;
+}
+function crossRefGraphSection(docs, refEdges) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of refEdges) {
+    const from = e.from.split(/[#@]/, 1)[0] ?? "";
+    const to = e.to.split("#", 1)[0] ?? "";
+    if (from.length === 0 || to.length === 0 || from === to) continue;
+    const key = `${from}\0${to}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  if (counts.size === 0) return "";
+  const involved = /* @__PURE__ */ new Set();
+  for (const key of counts.keys()) {
+    const [from, to] = key.split("\0");
+    if (from !== void 0) involved.add(from);
+    if (to !== void 0) involved.add(to);
+  }
+  const graphDocs = docs.filter((d) => involved.has(d.slug));
+  const data = {
+    title: "Cross-references",
+    nodes: graphDocs.map((d) => ({ id: d.slug, label: d.doc.meta?.title ?? d.slug })),
+    edges: [...counts.entries()].map(([key, count]) => {
+      const sep6 = key.indexOf("\0");
+      return {
+        from: key.slice(0, sep6),
+        to: key.slice(sep6 + 1),
+        ...count > 1 ? { weight: count } : {}
+      };
+    })
+  };
+  const legend = graphDocs.map(
+    (d) => `<li><a href="${escapeHtml(d.slug)}.html">${escapeHtml(d.doc.meta?.title ?? d.slug)}</a><span class="idx-slug">${escapeHtml(d.slug)}</span></li>`
+  ).join("");
+  return `<section class="idx-graph">` + htmlRenderers.graph(data) + `<ul class="idx-graph-legend">${legend}</ul></section>`;
+}
+function groupCards(g) {
+  const firstSeen = /* @__PURE__ */ new Map();
+  return g.docs.map((d) => {
+    const tag = d.doc.meta?.tag;
+    if (tag === void 0) return indexCard(d);
+    const key = tag.trim().toLowerCase();
+    const display = firstSeen.get(key) ?? tag;
+    if (!firstSeen.has(key)) firstSeen.set(key, tag);
+    return indexCard(d, display);
+  }).join("");
+}
+var SINGLETON_LIMIT = 0.6;
+function richIndexMain(docs, refEdges) {
+  const groups = groupDocs(docs);
+  const singletons = groups.filter((g) => g.docs.length === 1).length;
+  const degenerate = groups.length > 0 && singletons / groups.length > SINGLETON_LIMIT;
+  const head = `<div class="idx-head"><div class="idx-eyebrow site-eyebrow">${docs.length} document${docs.length === 1 ? "" : "s"}</div><h1 class="idx-title">Documentation</h1>` + (groups.length > 0 && !degenerate ? tldrDigest(groups) : "") + `</div>`;
+  const body = degenerate ? `<div class="idx-grid">${docs.map((d) => indexCard(d)).join("")}</div>` : groups.map(
+    (g) => `<section class="idx-group" id="${g.anchor}"><h2 class="idx-group-head">${escapeHtml(g.label)}<span class="idx-group-count">${g.docs.length}</span></h2><div class="idx-grid">${groupCards(g)}</div></section>`
+  ).join("");
+  return `<style>${RICH_INDEX_CSS}</style>` + head + body + crossRefGraphSection(docs, refEdges);
+}
+function failedBody(d, message) {
+  return `<div class="idx-head"><div class="idx-eyebrow site-eyebrow">Render failed</div><h1 class="idx-title">${escapeHtml(d.doc.meta?.title ?? d.slug)}</h1></div><p>${escapeHtml(d.file)} could not be rendered.</p><pre><code>${escapeHtml(message)}</code></pre>`;
+}
+function failedParts(d, message) {
+  return {
+    css: houseCss,
+    themeVars: "",
+    body: failedBody(d, message),
+    title: d.doc.meta?.title ?? d.slug,
+    sections: []
+  };
+}
+function buildSite(docs, opts = {}) {
+  const diagnostics = [];
+  for (const d of docs) diagnostics.push(...validateDocument(d.doc, d.file));
+  const resolved = resolveRefs(docs.map((d) => ({ doc: d.doc, file: d.file })));
+  diagnostics.push(...resolved.diagnostics);
+  const themeOpts = {
+    ...opts.themeVars !== void 0 ? { themeVars: opts.themeVars } : {},
+    ...opts.colorScheme !== void 0 ? { colorScheme: opts.colorScheme } : {}
+  };
+  const liveReload = opts.liveReload === true;
+  const rendered = docs.map((d) => {
+    const guarded = guardRender(
+      d.doc,
+      d.file,
+      "page",
+      () => renderDocumentParts(d.doc, themeOpts)
+    );
+    if (guarded.ok) return { doc: d, parts: guarded.value, failed: false };
+    diagnostics.push(guarded.diagnostic);
+    return { doc: d, parts: failedParts(d, guarded.diagnostic.message), failed: true };
+  });
+  const navDocs = rendered.map((r) => ({
+    slug: r.doc.slug,
+    title: r.doc.doc.meta?.title ?? r.doc.slug
+  }));
+  const first = rendered[0];
+  const css = first?.parts.css ?? houseCss;
+  const themeVars = first?.parts.themeVars ?? buildThemeVars(DEFAULT_THEME, opts.themeVars);
+  const pages = [];
+  pages.push({
+    path: "index.html",
+    title: "Documentation",
+    html: pageShell({
+      title: "Documentation",
+      css,
+      themeVars,
+      nav: sidebar(navDocs, void 0, []),
+      main: opts.richIndex !== false ? richIndexMain(docs, resolved.graph.edges) : indexCards(docs),
+      liveReload,
+      ...opts.colorScheme !== void 0 ? { colorScheme: opts.colorScheme } : {}
+    })
+  });
+  for (const { doc, parts, failed } of rendered) {
+    const shell = pageShell({
+      title: parts.title,
+      css: parts.css,
+      themeVars: parts.themeVars,
+      nav: sidebar(navDocs, doc.slug, parts.sections),
+      main: parts.body,
+      liveReload,
+      ...opts.colorScheme !== void 0 ? { colorScheme: opts.colorScheme } : {},
+      toggle: viewToggle(doc.slug)
+    });
+    pages.push({
+      path: `${doc.slug}.html`,
+      title: parts.title,
+      html: rewriteRefs(shell, doc.slug, resolved.graph.nodes)
+    });
+    let deckHtml;
+    let deckError = "The page could not be rendered.";
+    if (!failed) {
+      const deck = guardRender(
+        doc.doc,
+        doc.file,
+        "slide deck",
+        () => deckWithChrome(toSlides(doc.doc, themeOpts), doc.slug, liveReload)
+      );
+      if (deck.ok) deckHtml = deck.value;
+      else {
+        diagnostics.push(deck.diagnostic);
+        deckError = deck.diagnostic.message;
+      }
+    }
+    pages.push({
+      path: `${doc.slug}.slides.html`,
+      title: `${parts.title} \u2014 Slides`,
+      html: deckHtml ?? pageShell({
+        title: `${parts.title} \u2014 Slides`,
+        css: parts.css,
+        themeVars: parts.themeVars,
+        nav: sidebar(navDocs, doc.slug, []),
+        main: failedBody(doc, deckError),
+        liveReload,
+        ...opts.colorScheme !== void 0 ? { colorScheme: opts.colorScheme } : {}
+      })
+    });
+  }
+  return { pages, diagnostics };
+}
+
+// src/commands/build.ts
+async function runBuild(opts) {
+  const config = await loadConfig(opts.cwd);
+  const outDir = resolve(opts.cwd, opts.out ?? config.outDir);
+  const files = await loadDocs([`${config.docsDir}/**/*.md`], opts.cwd, config.docsDir);
+  const docs = files.filter((f) => f.encodingError === void 0).map((f) => ({
+    slug: f.slug,
+    file: f.file,
+    doc: parseDocument(f.source, f.slug)
+  }));
+  const site = buildSite(docs, { richIndex: opts.richIndex ?? config.richIndex, colorScheme: config.colorScheme });
+  const diagnostics = [...encodingDiagnostics(files), ...site.diagnostics];
+  const previous = await readManifest(outDir);
+  const pages = [];
+  for (const page of site.pages) {
+    const abs = join(outDir, page.path);
+    await mkdir(dirname(abs), { recursive: true });
+    await writeFile(abs, page.html, "utf8");
+    pages.push({ path: page.path, bytes: page.html.length });
+  }
+  const generated = site.pages.map((p) => p.path);
+  const removed = previous === void 0 ? [] : await pruneStale(outDir, previous.files, new Set(generated));
+  await writeManifest(outDir, generated, `chiltepin ${cliVersion()}`);
+  return {
+    outDir,
+    outDirRel: relative(opts.cwd, outDir) || ".",
+    pages,
+    removed,
+    pruneDeferred: previous === void 0 && await hadContent(outDir, generated),
+    diagnostics,
+    exitCode: diagnostics.some((d) => d.code === "E_RENDER") ? 1 : 0
+  };
+}
+async function hadContent(outDir, generated) {
+  const own = /* @__PURE__ */ new Set([
+    ...generated.map((p) => p.split("/")[0]),
+    MANIFEST_FILE
+  ]);
+  try {
+    const entries = await readdir(outDir);
+    return entries.some((e) => !own.has(e));
+  } catch {
+    return false;
+  }
+}
+function walkDirs(root) {
+  const out = [root];
+  const walk2 = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const p = join(dir, e.name);
+      out.push(p);
+      walk2(p);
+    }
+  };
+  walk2(root);
+  return out;
+}
+function createDocsWatcher(dirAbs, onEvent) {
+  const dirWatchers = /* @__PURE__ */ new Map();
+  let rootWatcher;
+  let usingFallback = false;
+  const syncDirWatchers = () => {
+    const dirs = new Set(walkDirs(dirAbs));
+    for (const [dir, w] of dirWatchers) {
+      if (!dirs.has(dir)) {
+        w.close();
+        dirWatchers.delete(dir);
+      }
+    }
+    for (const dir of dirs) {
+      if (dirWatchers.has(dir)) continue;
+      try {
+        const w = watch(dir, (_event, filename) => {
+          onEvent(filename === null ? void 0 : join(dir, filename));
+        });
+        w.on("error", () => dirWatchers.delete(dir));
+        dirWatchers.set(dir, w);
+      } catch {
+      }
+    }
+  };
+  if (existsSync(dirAbs)) {
+    try {
+      rootWatcher = watch(dirAbs, { recursive: true }, (_event, filename) => {
+        onEvent(filename === null ? void 0 : join(dirAbs, filename));
+      });
+      rootWatcher.on("error", () => {
+        rootWatcher = void 0;
+        usingFallback = true;
+        syncDirWatchers();
+      });
+    } catch {
+      usingFallback = true;
+      syncDirWatchers();
+    }
+  }
+  return {
+    resync() {
+      if (usingFallback) syncDirWatchers();
+    },
+    close() {
+      rootWatcher?.close();
+      for (const w of dirWatchers.values()) w.close();
+      dirWatchers.clear();
+    }
+  };
+}
+function createConfigWatcher(cwd, onEvent) {
+  let watcher;
+  if (existsSync(cwd)) {
+    try {
+      watcher = watch(cwd, (_event, filename) => {
+        if (filename !== null && /^(chiltepin|avodado)\.config\./.test(filename)) onEvent();
+      });
+      watcher.on("error", () => {
+        watcher?.close();
+        watcher = void 0;
+      });
+    } catch {
+    }
+  }
+  return {
+    close() {
+      watcher?.close();
+      watcher = void 0;
+    }
+  };
+}
+
+// src/commands/serve.ts
+var DEBOUNCE_MS = 150;
+var HEARTBEAT_MS = 25e3;
+var MAX_BANNER_ITEMS = 4;
+function fmtDiag(d) {
+  const loc = d.line !== void 0 ? `${d.file}:${d.line}` : d.file;
+  return `${loc}  ${d.code}  ${d.message}`;
+}
+function bannerHtml(diagnostics, fatal) {
+  const items = fatal !== void 0 ? [fatal] : diagnostics.map(fmtDiag);
+  if (items.length === 0) return "";
+  const isError = fatal !== void 0 || diagnostics.some((d) => d.level === "error");
+  const bg = isError ? "#7f1d1d" : "#78350f";
+  const shown = items.slice(0, MAX_BANNER_ITEMS);
+  const more = items.length - shown.length;
+  const rows = shown.map((t) => `<div>${escapeHtml(t)}</div>`).join("");
+  const moreRow = more > 0 ? `<div style="opacity:.75">\u2026and ${more} more</div>` : "";
+  return `<div id="chiltepin-diagnostics" style="position:fixed;left:0;right:0;bottom:0;z-index:2147483647;background:${bg};color:#fff;font:12px/1.6 ui-monospace,Menlo,Consolas,monospace;padding:10px 18px;box-shadow:0 -2px 10px rgba(0,0,0,.3);white-space:pre-wrap;"><div style="font-weight:700;letter-spacing:.06em;text-transform:uppercase;font-size:10px;opacity:.85;margin-bottom:4px;">chiltepin \u2014 ${isError ? "errors" : "warnings"}</div>` + rows + moreRow + `</div>`;
+}
+async function runServe(opts) {
+  const config = await loadConfig(opts.cwd);
+  const docsDirAbs = resolve(opts.cwd, config.docsDir);
+  const state = { pages: /* @__PURE__ */ new Map(), diagnostics: [], fatal: void 0 };
+  const rebuild = async () => {
+    try {
+      const files = await loadDocs([`${config.docsDir}/**/*.md`], opts.cwd, config.docsDir);
+      const docs = files.map((f) => ({
+        slug: f.slug,
+        file: f.file,
+        doc: parseDocument(f.source, f.slug)
+      }));
+      const site = buildSite(docs, {
+        colorScheme: config.colorScheme,
+        liveReload: true,
+        richIndex: opts.richIndex ?? config.richIndex
+      });
+      const next = /* @__PURE__ */ new Map();
+      for (const p of site.pages) next.set(p.path, p);
+      state.pages = next;
+      state.diagnostics = site.diagnostics;
+      state.fatal = void 0;
+    } catch (err) {
+      state.fatal = err instanceof Error ? err.message : String(err);
+    }
+  };
+  await rebuild();
+  const sseClients = /* @__PURE__ */ new Set();
+  const server = createServer((req, res) => {
+    const url2 = (req.url ?? "/").split("?")[0] ?? "/";
+    if (url2 === "/__events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-store",
+        Connection: "keep-alive"
+      });
+      res.write(":connected\n\n");
+      sseClients.add(res);
+      req.on("close", () => sseClients.delete(res));
+      return;
+    }
+    let path;
+    try {
+      path = url2 === "/" ? "index.html" : decodeURIComponent(url2.replace(/^\//, ""));
+    } catch {
+      path = "index.html";
+    }
+    const page = state.pages.get(path);
+    if (page === void 0) {
+      res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end(`404 \u2014 no page at ${url2}
+`);
+      return;
+    }
+    const banner2 = bannerHtml(state.diagnostics, state.fatal);
+    const html = banner2 === "" ? page.html : page.html.replace("<body>", `<body>
+${banner2}`);
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
+    res.end(html);
+  });
+  const heartbeat = setInterval(() => {
+    for (const c of sseClients) c.write(":heartbeat\n\n");
+  }, HEARTBEAT_MS);
+  heartbeat.unref();
+  const broadcastReload = () => {
+    for (const c of sseClients) c.write("data: reload\n\n");
+  };
+  let debounce;
+  const onFsEvent = () => {
+    if (debounce !== void 0) clearTimeout(debounce);
+    debounce = setTimeout(() => {
+      void (async () => {
+        await rebuild();
+        docsWatcher.resync();
+        broadcastReload();
+      })();
+    }, DEBOUNCE_MS);
+  };
+  const docsWatcher = createDocsWatcher(docsDirAbs, onFsEvent);
+  const configWatcher = createConfigWatcher(opts.cwd, onFsEvent);
+  await new Promise((ready, fail) => {
+    server.once("error", fail);
+    server.listen(opts.port, () => {
+      server.removeListener("error", fail);
+      ready();
+    });
+  });
+  const address = server.address();
+  const port = address !== null && typeof address === "object" ? address.port : opts.port;
+  const url = `http://localhost:${port}`;
+  console.log(`Serving ${config.docsDir}/ at ${url}  (Ctrl-C to stop)`);
+  if (opts.open) await open(url);
+  await new Promise((done) => {
+    let closed = false;
+    const shutdown = () => {
+      if (closed) return;
+      closed = true;
+      if (debounce !== void 0) clearTimeout(debounce);
+      clearInterval(heartbeat);
+      docsWatcher.close();
+      configWatcher.close();
+      for (const c of sseClients) c.end();
+      server.close(() => done());
+      server.closeAllConnections();
+      setTimeout(done, 1e3).unref();
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+var DEBOUNCE_MS2 = 150;
+var HEARTBEAT_MS2 = 25e3;
+var MAX_BODY_BYTES = 10 * 1024 * 1024;
+var normalizeLf = (s) => s.replace(/\r\n?/g, "\n");
+var hashOf = (s) => createHash("sha256").update(s, "utf8").digest("hex");
+function sendJson(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+  res.end(JSON.stringify(body));
+}
+function readBody(req, limit) {
+  return new Promise((done) => {
+    const chunks = [];
+    let total = 0;
+    let overflowed = false;
+    req.on("data", (chunk) => {
+      if (overflowed) return;
+      total += chunk.length;
+      if (total > limit) {
+        overflowed = true;
+        chunks.length = 0;
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => done(overflowed ? null : Buffer.concat(chunks)));
+    req.on("error", () => done(null));
+  });
+}
+function resolveDocPath(docsDirAbs, remainder) {
+  let slug;
+  try {
+    slug = decodeURIComponent(remainder);
+  } catch {
+    return { kind: "bad" };
+  }
+  if (slug === "") return { kind: "bad" };
+  const abs = resolve(join(docsDirAbs, slug + ".md"));
+  if (!abs.startsWith(docsDirAbs + sep)) return { kind: "forbidden" };
+  return { kind: "ok", slug, abs };
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".woff2": "font/woff2",
+  ".json": "application/json",
+  ".map": "application/json"
+};
+var FALLBACK_HTML = '<!doctype html><html><head><meta charset="utf-8"><title>Chiltepin Studio</title></head><body style="font:16px/1.6 system-ui,sans-serif;max-width:38rem;margin:4rem auto;padding:0 1rem;"><h1>Chiltepin Studio</h1><p>The studio web app (<code>chiltepin-studio</code>) is not installed, so there is nothing to show here. Reinstall <code>chiltepin</code> to get the bundled assets.</p><p>The file-bridge API is still running: <code>/api/meta</code>, <code>/api/docs</code>, <code>/api/doc/&lt;slug&gt;</code> and the <code>/__events</code> stream all work.</p></body></html>';
+async function runStudio(opts) {
+  const config = await loadConfig(opts.cwd);
+  const docsDirAbs = resolve(opts.cwd, config.docsDir);
+  const recentWrites = /* @__PURE__ */ new Map();
+  let assetsRootPromise;
+  const assetsRoot = () => {
+    assetsRootPromise ??= import('chiltepin-studio').then((mod) => resolve(mod.assetsPath())).catch(() => null);
+    return assetsRootPromise;
+  };
+  let sitePages = null;
+  let siteFresh = false;
+  let siteBuild = null;
+  const rebuildSite = async () => {
+    const files = await loadDocs([`${config.docsDir}/**/*.md`], opts.cwd, config.docsDir);
+    const docs = files.map((f) => ({
+      slug: f.slug,
+      file: f.file,
+      doc: parseDocument(f.source, f.slug)
+    }));
+    const site = buildSite(docs, {
+      colorScheme: config.colorScheme,
+      liveReload: true,
+      // the script hits /__events — same origin here
+      richIndex: config.richIndex
+      // on by default; config `false` opts out
+    });
+    const next = /* @__PURE__ */ new Map();
+    for (const p of site.pages) next.set(p.path, p);
+    return next;
+  };
+  const getSitePages = () => {
+    if (siteFresh && sitePages !== null) return Promise.resolve(sitePages);
+    siteBuild ??= rebuildSite().then((pages) => {
+      sitePages = pages;
+      siteFresh = true;
+      return pages;
+    }).catch((err) => {
+      if (sitePages !== null) return sitePages;
+      throw err;
+    }).finally(() => {
+      siteBuild = null;
+    });
+    return siteBuild;
+  };
+  const invalidateSite = () => {
+    siteFresh = false;
+  };
+  const sseClients = /* @__PURE__ */ new Set();
+  const broadcast = (payload) => {
+    const line = `data: ${JSON.stringify(payload)}
+
+`;
+    for (const c of sseClients) c.write(line);
+  };
+  let docsDebounce;
+  let metaDebounce;
+  const pendingPaths = /* @__PURE__ */ new Set();
+  let pendingUnattributed = false;
+  const flushDocsEvents = async () => {
+    docsWatcher.resync();
+    invalidateSite();
+    const paths = [...pendingPaths];
+    const unattributed = pendingUnattributed;
+    pendingPaths.clear();
+    pendingUnattributed = false;
+    for (const abs of paths) {
+      const slug = relative(docsDirAbs, abs).split(sep).join("/").replace(/\.md$/i, "");
+      let hash;
+      try {
+        hash = hashOf(normalizeLf(await readFile(abs, "utf8")));
+      } catch {
+      }
+      if (hash !== void 0 && recentWrites.get(slug) === hash) {
+        recentWrites.delete(slug);
+        continue;
+      }
+      broadcast({ type: "fs", slug, ...hash !== void 0 ? { hash } : {} });
+    }
+    if (unattributed) broadcast({ type: "fs" });
+  };
+  const onDocsEvent = (absPath) => {
+    if (absPath === void 0) pendingUnattributed = true;
+    else if (/\.md$/i.test(absPath)) pendingPaths.add(absPath);
+    if (docsDebounce !== void 0) clearTimeout(docsDebounce);
+    docsDebounce = setTimeout(() => void flushDocsEvents(), DEBOUNCE_MS2);
+  };
+  const onMetaEvent = () => {
+    if (metaDebounce !== void 0) clearTimeout(metaDebounce);
+    metaDebounce = setTimeout(() => {
+      invalidateSite();
+      broadcast({ type: "meta" });
+    }, DEBOUNCE_MS2);
+  };
+  const docsWatcher = createDocsWatcher(docsDirAbs, onDocsEvent);
+  const configWatcher = createConfigWatcher(opts.cwd, onMetaEvent);
+  const handleMeta = (res) => {
+    sendJson(res, 200, { version: cliVersion(), docsDir: config.docsDir, colorScheme: config.colorScheme });
+  };
+  const docListCache = /* @__PURE__ */ new Map();
+  const handleDocs = async (res) => {
+    const files = await loadDocs([`${config.docsDir}/**/*.md`], opts.cwd, config.docsDir);
+    const seen = /* @__PURE__ */ new Set();
+    const docs = await Promise.all(
+      files.map(async (f) => {
+        const st = await stat(f.absolute);
+        seen.add(f.slug);
+        let entry = docListCache.get(f.slug);
+        if (entry === void 0 || entry.mtimeMs !== st.mtimeMs) {
+          let title = f.slug;
+          let errorCount = 0;
+          try {
+            const doc = parseDocument(f.source, f.slug);
+            title = doc.meta?.title ?? f.slug;
+            errorCount = validateDocument(doc, f.file).filter((d) => d.level === "error").length;
+          } catch {
+            errorCount = 1;
+          }
+          entry = { mtimeMs: st.mtimeMs, title, errorCount };
+          docListCache.set(f.slug, entry);
+        }
+        return {
+          slug: f.slug,
+          file: f.file,
+          title: entry.title,
+          mtimeMs: st.mtimeMs,
+          errorCount: entry.errorCount
+        };
+      })
+    );
+    for (const slug of [...docListCache.keys()]) {
+      if (!seen.has(slug)) docListCache.delete(slug);
+    }
+    sendJson(res, 200, docs);
+  };
+  const handleDocGet = async (res, abs) => {
+    if (!existsSync(abs)) {
+      sendJson(res, 404, { error: "document not found" });
+      return;
+    }
+    const [raw, st] = await Promise.all([readFile(abs, "utf8"), stat(abs)]);
+    const source = normalizeLf(raw);
+    sendJson(res, 200, { source, hash: hashOf(source), mtimeMs: st.mtimeMs });
+  };
+  const handleDocPut = async (req, res, slug, abs, force) => {
+    const body = await readBody(req, MAX_BODY_BYTES);
+    if (body === null) {
+      sendJson(res, 413, { error: `body exceeds ${MAX_BODY_BYTES} bytes` });
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body.toString("utf8"));
+    } catch {
+      sendJson(res, 400, { error: "invalid JSON body" });
+      return;
+    }
+    if (parsed === null || typeof parsed !== "object") {
+      sendJson(res, 400, { error: "body must be a JSON object" });
+      return;
+    }
+    const { source: rawSource, baseHash } = parsed;
+    if (typeof rawSource !== "string") {
+      sendJson(res, 400, { error: 'missing "source" (string)' });
+      return;
+    }
+    if (baseHash !== void 0 && typeof baseHash !== "string") {
+      sendJson(res, 400, { error: '"baseHash" must be a string when present' });
+      return;
+    }
+    const source = normalizeLf(rawSource);
+    if (existsSync(abs)) {
+      const currentSource = normalizeLf(await readFile(abs, "utf8"));
+      const currentHash = hashOf(currentSource);
+      if (baseHash !== void 0 && baseHash !== currentHash && !force) {
+        sendJson(res, 409, { currentHash, currentSource });
+        return;
+      }
+    } else if (baseHash !== void 0 && !force) {
+      sendJson(res, 409, { error: "file no longer exists on disk (use ?force=1 to recreate)" });
+      return;
+    }
+    await mkdir(dirname(abs), { recursive: true });
+    const tmp = join(dirname(abs), `.${basename(abs)}.${randomBytes(6).toString("hex")}.tmp`);
+    await writeFile(tmp, source, "utf8");
+    await rename(tmp, abs);
+    const hash = hashOf(source);
+    recentWrites.set(slug, hash);
+    const st = await stat(abs);
+    sendJson(res, 200, { hash, mtimeMs: st.mtimeMs });
+  };
+  const chromiumExport = (convert, contentType) => async (req, res) => {
+    const body = await readBody(req, MAX_BODY_BYTES);
+    if (body === null) {
+      sendJson(res, 413, { error: `body exceeds ${MAX_BODY_BYTES} bytes` });
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body.toString("utf8"));
+    } catch {
+      sendJson(res, 400, { error: "invalid JSON body" });
+      return;
+    }
+    const html = parsed?.html;
+    if (typeof html !== "string") {
+      sendJson(res, 400, { error: 'missing "html" (string)' });
+      return;
+    }
+    try {
+      const bytes = await convert(html);
+      res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "no-store" });
+      res.end(Buffer.from(bytes));
+    } catch (err) {
+      sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+    }
+  };
+  const handleExportPdf = chromiumExport(
+    (html) => toPdf(html, { autoInstallBrowser: true, log: (m) => console.log(m) }),
+    "application/pdf"
+  );
+  const handleSite = async (res, pathname) => {
+    let rel2;
+    try {
+      rel2 = decodeURIComponent(pathname.slice("/site/".length));
+    } catch {
+      rel2 = "";
+    }
+    const path = rel2 === "" ? "index.html" : rel2;
+    const pages = await getSitePages();
+    const page = pages.get(path);
+    if (page === void 0) {
+      res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end(`404 \u2014 no page at ${pathname}
+`);
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
+    res.end(page.html);
+  };
+  const handleStatic = async (res, pathname) => {
+    const root = await assetsRoot();
+    let rel2;
+    try {
+      rel2 = decodeURIComponent(pathname).replace(/^\/+/, "");
+    } catch {
+      rel2 = "";
+    }
+    const isAsset = extname(rel2) !== "";
+    if (root === null) {
+      if (isAsset) {
+        sendJson(res, 404, { error: "studio assets not installed" });
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
+      res.end(FALLBACK_HTML);
+      return;
+    }
+    const target = isAsset ? resolve(join(root, rel2)) : join(root, "index.html");
+    if (isAsset && !target.startsWith(root + sep)) {
+      sendJson(res, 403, { error: "forbidden" });
+      return;
+    }
+    try {
+      const content = await readFile(target);
+      const type = MIME[extname(target).toLowerCase()] ?? "application/octet-stream";
+      res.writeHead(200, { "Content-Type": type, "Cache-Control": "no-store" });
+      res.end(content);
+    } catch {
+      sendJson(res, 404, { error: "not found" });
+    }
+  };
+  const handle = async (req, res) => {
+    const method = req.method ?? "GET";
+    const rawUrl = req.url ?? "/";
+    const q = rawUrl.indexOf("?");
+    const pathname = q === -1 ? rawUrl : rawUrl.slice(0, q);
+    const query = new URLSearchParams(q === -1 ? "" : rawUrl.slice(q + 1));
+    if (method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (pathname === "/__events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-store",
+        Connection: "keep-alive"
+      });
+      res.write(":connected\n\n");
+      sseClients.add(res);
+      req.on("close", () => sseClients.delete(res));
+      return;
+    }
+    if (pathname === "/api/meta") {
+      if (method !== "GET") return sendJson(res, 405, { error: "method not allowed" });
+      return handleMeta(res);
+    }
+    if (pathname === "/api/docs") {
+      if (method !== "GET") return sendJson(res, 405, { error: "method not allowed" });
+      return handleDocs(res);
+    }
+    if (pathname === "/api/export/pdf") {
+      if (method !== "POST") return sendJson(res, 405, { error: "method not allowed" });
+      return handleExportPdf(req, res);
+    }
+    if (pathname.startsWith("/api/doc/")) {
+      const hit = resolveDocPath(docsDirAbs, pathname.slice("/api/doc/".length));
+      if (hit.kind === "bad") return sendJson(res, 400, { error: "invalid slug" });
+      if (hit.kind === "forbidden") return sendJson(res, 403, { error: "forbidden" });
+      if (method === "GET") return handleDocGet(res, hit.abs);
+      if (method === "PUT") {
+        return handleDocPut(req, res, hit.slug, hit.abs, query.get("force") === "1");
+      }
+      return sendJson(res, 405, { error: "method not allowed" });
+    }
+    if (pathname.startsWith("/api/")) return sendJson(res, 404, { error: "unknown API route" });
+    if (method !== "GET" && method !== "HEAD") {
+      return sendJson(res, 405, { error: "method not allowed" });
+    }
+    if (pathname === "/site" || pathname.startsWith("/site/")) {
+      return handleSite(res, pathname);
+    }
+    return handleStatic(res, pathname);
+  };
+  const server = createServer((req, res) => {
+    void handle(req, res).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!res.headersSent) sendJson(res, 500, { error: message });
+      else res.end();
+    });
+  });
+  const heartbeat = setInterval(() => {
+    for (const c of sseClients) c.write(":heartbeat\n\n");
+  }, HEARTBEAT_MS2);
+  heartbeat.unref();
+  await new Promise((ready, fail) => {
+    server.once("error", fail);
+    server.listen(opts.port, "127.0.0.1", () => {
+      server.removeListener("error", fail);
+      ready();
+    });
+  });
+  const address = server.address();
+  const port = address !== null && typeof address === "object" ? address.port : opts.port;
+  const url = `http://localhost:${port}`;
+  console.log(`Studio at ${url}  (Ctrl-C to stop)`);
+  console.log(`Editing ${config.docsDir}/ \u2014 the files stay the source of truth`);
+  if (opts.open) await open(url);
+  await new Promise((done) => {
+    let closed = false;
+    const shutdown = () => {
+      if (closed) return;
+      closed = true;
+      if (docsDebounce !== void 0) clearTimeout(docsDebounce);
+      if (metaDebounce !== void 0) clearTimeout(metaDebounce);
+      clearInterval(heartbeat);
+      docsWatcher.close();
+      configWatcher.close();
+      for (const c of sseClients) c.end();
+      server.close(() => done());
+      server.closeAllConnections();
+      setTimeout(done, 1e3).unref();
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+function resolveBlockName(name) {
+  if (BLOCK_TYPES.includes(name)) return { type: name };
+  const alias = BLOCK_ALIASES[name];
+  if (alias !== void 0) return { type: alias.type, alias: name };
+  return void 0;
+}
+function blockIndex() {
+  const out = [
+    `${BLOCK_TYPES.length} block types \u2014 chiltepin block <type> for fields + example`,
+    ""
+  ];
+  for (const fam of BLOCK_FAMILIES) {
+    const types = familyBlocks(fam.id);
+    out.push(`${fam.label} (${types.length})`);
+    for (const t of types) out.push(`  ${t.padEnd(14)}${BLOCK_DESCRIPTIONS[t]}`);
+    out.push("");
+  }
+  const aliases = Object.entries(BLOCK_ALIASES).map(([a, d]) => `${a}\u2192${d.type}`);
+  out.push(`Old names still accepted: ${aliases.join("  ")}`);
+  return out.join("\n") + "\n";
+}
+function blockReference(type, json) {
+  return json ? JSON.stringify(blockContract(type), null, 2) + "\n" : formatBlockContract(type);
+}
+function copyToClipboard(text) {
+  const candidates = process.platform === "darwin" ? [["pbcopy", []]] : process.platform === "win32" ? [["clip", []]] : [
+    ["wl-copy", []],
+    ["xclip", ["-selection", "clipboard"]],
+    ["xsel", ["--clipboard", "--input"]]
+  ];
+  for (const [cmd, args] of candidates) {
+    try {
+      const r = spawnSync(cmd, [...args], { input: text });
+      if (r.status === 0) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+
+// src/commands/skill.ts
+var SYSTEM_HEADER = `# Chiltepin authoring \u2014 system prompt
+
+You are an expert author of **Chiltepin** documents: Markdown files that mix prose
+with typed, fenced YAML blocks, where the \`.md\` file on disk is the single source
+of truth. Whenever you create or edit documentation in a Chiltepin project, follow
+the grammar and rules below exactly:
+
+- Keep narrative in plain Markdown; put every structured thing (diagram, table,
+  roadmap, story) in a documented typed block. Never paste raw HTML or SVG.
+- Use only the documented block types and their documented fields \u2014 the schemas
+  are strict, so an unknown block or field is an error.
+- Give a block an \`id:\` when something references it; reference it as \`doc#id\`.
+- Quote any YAML value containing \`,\` \`:\` \`#\` \`[\` \`]\` \`{\` \`}\` or a leading special character.
+- Edit blocks surgically \u2014 don't regenerate whole files.
+- A change is done only when \`chiltepin check\` passes (if the tooling is available).
+
+The complete block grammar, field contract, and authoring recipe follow.
+
+---
+`;
+async function readSkill() {
+  return stitchSkill();
+}
+function stripFrontmatter(md) {
+  const m = /^---\n[\s\S]*?\n---\n/.exec(md);
+  return m !== null ? md.slice(m[0].length).replace(/^\s+/, "") : md;
+}
+async function systemPrompt(opts = {}) {
+  const skill = await readSkill();
+  if (opts.raw === true) return skill;
+  return SYSTEM_HEADER + stripFrontmatter(skill);
+}
+function slugFromPath(path) {
+  const base = basename(path, extname(path));
+  return base.length > 0 ? base : "api";
+}
+async function runSyncOpenApi(opts) {
+  if (opts.out === void 0 && opts.check === void 0) {
+    return { exitCode: 2, message: "chiltepin sync openapi: must specify --out <path> or --check <path>" };
+  }
+  if (opts.out !== void 0 && opts.check !== void 0) {
+    return { exitCode: 2, message: "chiltepin sync openapi: --out and --check are mutually exclusive" };
+  }
+  const specAbs = resolve(opts.cwd, opts.spec);
+  if (!existsSync(specAbs)) {
+    return { exitCode: 2, message: `Spec not found: ${specAbs}` };
+  }
+  const source = await readFile(specAbs, "utf8");
+  let spec;
+  try {
+    spec = parseOpenApi(source);
+  } catch (err) {
+    return { exitCode: 1, message: `Failed to parse spec: ${err.message}` };
+  }
+  const targetPath = opts.out ?? opts.check;
+  if (targetPath === void 0) {
+    return { exitCode: 2, message: "no target path" };
+  }
+  const slug = opts.slug ?? slugFromPath(targetPath);
+  const generated = openapiToMarkdown(spec, { slug });
+  if (opts.out !== void 0) {
+    const outAbs = resolve(opts.cwd, opts.out);
+    const refusal = overwriteRefusal(outAbs, { force: opts.force });
+    if (refusal !== void 0) return { exitCode: 1, message: refusal };
+    await mkdir(dirname(outAbs), { recursive: true });
+    await writeFile(outAbs, generated, "utf8");
+    return {
+      exitCode: 0,
+      message: `Wrote ${outAbs} (${generated.length} bytes)`
+    };
+  }
+  const checkAbs = resolve(opts.cwd, opts.check ?? "");
+  if (!existsSync(checkAbs)) {
+    return {
+      exitCode: 1,
+      message: `Drift: ${checkAbs} does not exist. Run with --out ${opts.check} to generate it.`
+    };
+  }
+  const existing = await readFile(checkAbs, "utf8");
+  if (existing === generated) {
+    return {
+      exitCode: 0,
+      message: `OK: ${checkAbs} matches ${specAbs} (${generated.length} bytes)`
+    };
+  }
+  return {
+    exitCode: 1,
+    message: `Drift: ${checkAbs} differs from what ${specAbs} would generate.`,
+    diff: simpleDiff(existing, generated)
+  };
+}
+function simpleDiff(a, b) {
+  const aLines = a.split("\n");
+  const bLines = b.split("\n");
+  const out = [];
+  const max = Math.max(aLines.length, bLines.length);
+  for (let i = 0; i < max; i++) {
+    const av = aLines[i];
+    const bv = bLines[i];
+    if (av === bv) continue;
+    if (av !== void 0) out.push(`- ${av}`);
+    if (bv !== void 0) out.push(`+ ${bv}`);
+    if (out.length >= 40) {
+      out.push(`\u2026 (truncated; ${max - i - 1} more lines)`);
+      break;
+    }
+  }
+  return out.join("\n");
+}
+function idFromFile(file) {
+  const slug = basename(file, extname(file)).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug === "" ? "schema" : slug;
+}
+async function runSyncSchema(opts) {
+  const fileAbs = resolve(opts.cwd, opts.file);
+  if (!existsSync(fileAbs)) {
+    return { exitCode: 2, entities: 0, relations: 0, message: `Schema not found: ${fileAbs}` };
+  }
+  const source = await readFile(fileAbs, "utf8");
+  const result = opts.dialect === "sql" ? convertSqlDdl(source) : opts.dialect === "dbml" ? convertDbml(source) : convertPrisma(source);
+  if (!result.ok) {
+    const where = result.line !== void 0 ? `${opts.file}:${result.line}` : opts.file;
+    return { exitCode: 1, entities: 0, relations: 0, message: `Could not read ${where}: ${result.message}` };
+  }
+  const data = result.data;
+  const entities = Array.isArray(data["entities"]) ? data["entities"].length : 0;
+  const relations = Array.isArray(data["relations"]) ? data["relations"].length : 0;
+  const fence = erdFence(data, opts.id ?? idFromFile(opts.file));
+  if (opts.out === void 0) {
+    return { exitCode: 0, fence, entities, relations };
+  }
+  const title = opts.title ?? titleFromFile(opts.file);
+  const doc = "```meta\ntitle: " + JSON.stringify(title) + "\n```\n\n" + fence;
+  const outAbs = resolve(opts.cwd, opts.out);
+  const refusal = overwriteRefusal(outAbs, { force: opts.force });
+  if (refusal !== void 0) {
+    return { exitCode: 1, entities, relations, message: refusal };
+  }
+  await mkdir(dirname(outAbs), { recursive: true });
+  await writeFile(outAbs, doc, "utf8");
+  const check = await runCheck({
+    patterns: [relative(opts.cwd, outAbs) || opts.out],
+    cwd: opts.cwd,
+    docsRoot: dirname(relative(opts.cwd, outAbs)) || "."
+  });
+  return { exitCode: check.exitCode, outPath: outAbs, entities, relations, check };
+}
+function parseDelimiter(raw) {
+  if (raw === void 0) return void 0;
+  if (raw === "," || raw === ";" || raw === "	") return raw;
+  if (raw === "tab" || raw === "\\t") return "	";
+  return null;
+}
+function titleFromFile(file) {
+  const stem = basename(file, extname(file));
+  const spaced = stem.replace(/[-_]+/g, " ").trim();
+  return spaced === "" ? "Imported schema" : spaced.replace(/^\w/, (c) => c.toUpperCase());
+}
+var warnMessages = (diags) => diags.filter((d) => d.level === "warn").map((d) => d.message);
+var errorMessages = (diags) => diags.filter((d) => d.level === "error").map((d) => d.message);
+async function runSyncCsv(opts) {
+  const fallback = opts.block ?? "table";
+  const delimiter = parseDelimiter(opts.delimiter);
+  if (delimiter === null) {
+    return {
+      exitCode: 2,
+      block: fallback,
+      warnings: [],
+      message: `chiltepin sync csv: unknown delimiter ${JSON.stringify(opts.delimiter)} \u2014 use "," ";" or "tab"`
+    };
+  }
+  const fileAbs = resolve(opts.cwd, opts.file);
+  if (!existsSync(fileAbs)) {
+    return { exitCode: 2, block: fallback, warnings: [], message: `CSV not found: ${fileAbs}` };
+  }
+  const csv = await readFile(fileAbs, "utf8");
+  let block;
+  let reason;
+  if (opts.block !== void 0) {
+    block = opts.block;
+  } else {
+    const suggestion = suggestCsvImport(csv);
+    block = suggestion.kind;
+    reason = suggestion.reason;
+  }
+  const convertOpts = delimiter !== void 0 ? { delimiter } : {};
+  const result = block === "statustable" ? csvToStatustable(csv, convertOpts) : block === "chart" ? csvToChart(csv, convertOpts) : csvToTable(csv, convertOpts);
+  const warnings = warnMessages(result.diagnostics);
+  if (result.data === null) {
+    const errors = errorMessages(result.diagnostics);
+    return {
+      exitCode: 1,
+      block,
+      ...reason !== void 0 ? { reason } : {},
+      warnings,
+      message: `Could not import ${opts.file} as ${block}: ${errors.join("; ")}`
+    };
+  }
+  const parseErrors = errorMessages(result.diagnostics);
+  if (parseErrors.length > 0) {
+    return {
+      exitCode: 1,
+      block,
+      ...reason !== void 0 ? { reason } : {},
+      warnings,
+      message: `CSV parse failed for ${opts.file}: ${parseErrors.join("; ")}`
+    };
+  }
+  if (opts.out === void 0) {
+    return {
+      exitCode: 0,
+      block,
+      ...reason !== void 0 ? { reason } : {},
+      fence: result.fence,
+      warnings
+    };
+  }
+  const title = opts.title ?? titleFromFile(opts.file);
+  const doc = "```meta\ntitle: " + JSON.stringify(title) + "\n```\n\n" + result.fence;
+  const outAbs = resolve(opts.cwd, opts.out);
+  const refusal = overwriteRefusal(outAbs, { force: opts.force });
+  if (refusal !== void 0) {
+    return {
+      exitCode: 1,
+      block,
+      ...reason !== void 0 ? { reason } : {},
+      warnings,
+      message: refusal
+    };
+  }
+  await mkdir(dirname(outAbs), { recursive: true });
+  await writeFile(outAbs, doc, "utf8");
+  const check = await runCheck({
+    patterns: [relative(opts.cwd, outAbs) || opts.out],
+    cwd: opts.cwd,
+    docsRoot: dirname(relative(opts.cwd, outAbs)) || "."
+  });
+  return {
+    exitCode: check.exitCode,
+    block,
+    ...reason !== void 0 ? { reason } : {},
+    outPath: outAbs,
+    warnings,
+    check
+  };
+}
+function templateFor(type) {
+  return `\`\`\`meta
+title: New document
+tag: DRAFT
+\`\`\`
+
+${BLOCK_TEMPLATES[type]}`;
+}
+async function writeNewDoc(opts) {
+  const outAbs = resolve(opts.cwd, opts.out);
+  assertWritable(outAbs, opts.force === true ? { force: true } : {});
+  await mkdir(dirname(outAbs), { recursive: true });
+  const content = isDocTemplate(opts.type) ? DOC_TEMPLATES[opts.type] : templateFor(opts.type);
+  await writeFile(outAbs, content, "utf8");
+  return outAbs;
+}
+var DOCS_SECTION = "__docs__";
+function NewPickerApp({ onPick }) {
+  const { exit } = useApp();
+  const [section, setSection] = useState("top");
+  useInput((input, key) => {
+    if (input === "q" || key.escape) exit();
+  });
+  if (section === "top") {
+    const items2 = [
+      {
+        label: `Doc templates \u2014 a complete starting doc (${Object.keys(DOC_TEMPLATES).length})`,
+        value: DOCS_SECTION
+      },
+      ...BLOCK_FAMILIES.map((f) => ({
+        label: `Blocks \xB7 ${f.label} \u2014 ${familyBlocks(f.id).length} scaffolds`,
+        value: f.id
+      }))
+    ];
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+        "What do you want to create? ",
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "(\u2191\u2193 move \xB7 enter \xB7 q to quit)" })
+      ] }),
+      /* @__PURE__ */ jsx(
+        SelectInput2,
+        {
+          items: items2,
+          onSelect: (item) => setSection(item.value)
+        }
+      )
+    ] });
+  }
+  const pick = (name) => {
+    onPick(name);
+    exit();
+  };
+  if (section === DOCS_SECTION) {
+    const items2 = Object.keys(DOC_TEMPLATES).map((name) => {
+      const info = DOC_TEMPLATE_INFO[name];
+      return { label: `${(info?.title ?? name).padEnd(14)} ${info?.description ?? ""}`, value: name };
+    });
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+        "Doc templates ",
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "(\u2191\u2193 move \xB7 enter \xB7 q to quit)" })
+      ] }),
+      /* @__PURE__ */ jsx(SelectInput2, { items: items2, onSelect: (item) => pick(item.value) })
+    ] });
+  }
+  const items = familyBlocks(section).map((t) => ({
+    label: `${t.padEnd(13)} ${BLOCK_DESCRIPTIONS[t]}`,
+    value: t
+  }));
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+      "Blocks \xB7 ",
+      BLOCK_FAMILIES.find((f) => f.id === section)?.label ?? section,
+      " ",
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "(\u2191\u2193 move \xB7 enter \xB7 q to quit)" })
+    ] }),
+    /* @__PURE__ */ jsx(SelectInput2, { items, onSelect: (item) => pick(item.value) })
+  ] });
+}
+async function projectStatus(cwd) {
+  const config = await loadConfig(cwd);
+  const result = await runCheck({
+    patterns: [`${config.docsDir}/**/*.md`],
+    cwd,
+    docsRoot: config.docsDir
+  });
+  const errors = result.diagnostics.filter((d) => d.level === "error").length;
+  return {
+    docCount: result.files.length,
+    errors,
+    warnings: result.diagnostics.length - errors,
+    docsDir: config.docsDir
+  };
+}
+var NEXT_ACTIONS = [
+  ["chiltepin check", "validate every doc"],
+  ["chiltepin <file.md>", "render + open one doc in the browser"],
+  ["chiltepin studio", "edit visually \xB7 Site mode previews the docs site live"],
+  ["chiltepin build", "build the static docs site"],
+  ["chiltepin block", "every block type, or one block's fields + example"]
+];
+function formatStatus(status, plain = false) {
+  const dim = (s) => plain ? s : pc5.dim(s);
+  const cyan = (s) => plain ? s : pc5.cyan(s);
+  const bold = (s) => plain ? s : pc5.bold(s);
+  const checkLine = status.errors > 0 ? (plain ? "" : pc5.red("\u2717 ")) + `${status.errors} error(s)` + (status.warnings > 0 ? ` \xB7 ${status.warnings} warning(s)` : "") + dim(" \u2014 run chiltepin check") : (plain ? "" : pc5.green("\u2713 ")) + "clean" + (status.warnings > 0 ? dim(` (${status.warnings} warning(s))`) : "");
+  const width = Math.max(...NEXT_ACTIONS.map(([cmd]) => cmd.length));
+  return [
+    `  ${dim("docs".padEnd(8))}${status.docCount} document(s) ${dim(`in ${status.docsDir}/`)}`,
+    `  ${dim("check".padEnd(8))}${checkLine}`,
+    "",
+    `  ${bold("Next:")}`,
+    ...NEXT_ACTIONS.map(([cmd, note]) => `    ${cyan(cmd.padEnd(width))}  ${dim(note)}`),
+    ""
+  ].join("\n");
+}
+var FILE_CAP = 2e3;
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".scratch",
+  "graphify-out",
+  "coverage",
+  ".next",
+  ".turbo",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "vendor",
+  "target",
+  "out"
+]);
+var CODE_EXTS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts", "py", "go", "rb"]);
+function langOf(ext) {
+  switch (ext) {
+    case "tsx":
+    case "mts":
+    case "cts":
+      return "ts";
+    case "jsx":
+    case "mjs":
+    case "cjs":
+      return "js";
+    case "yml":
+      return "yaml";
+    default:
+      return ext;
+  }
+}
+function extOf(name) {
+  const i = name.lastIndexOf(".");
+  if (i <= 0) return "";
+  return name.slice(i + 1).toLowerCase();
+}
+function rel(root, abs) {
+  return relative(root, abs).split(sep).join("/");
+}
+async function walk(root) {
+  const files = [];
+  const queue = [root];
+  let truncated = false;
+  while (queue.length > 0 && !truncated) {
+    const dir = queue.shift();
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !SKIP_DIRS.has(entry.name)) queue.push(abs);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (files.length >= FILE_CAP) {
+        truncated = true;
+        break;
+      }
+      files.push({ abs, rel: rel(root, abs), ext: extOf(entry.name) });
+    }
+  }
+  return { files, truncated };
+}
+var KNOWN_EXTERNALS = [
+  "axios",
+  "node-fetch",
+  "got",
+  "undici",
+  "ky",
+  "stripe",
+  "openai",
+  "@anthropic-ai/",
+  "@aws-sdk/",
+  "aws-sdk",
+  "@octokit/",
+  "twilio",
+  "@sendgrid/",
+  "@supabase/",
+  "firebase",
+  "pg",
+  "mysql2",
+  "mongodb",
+  "mongoose",
+  "redis",
+  "ioredis",
+  "@prisma/client",
+  // Python
+  "requests",
+  "httpx",
+  "boto3",
+  "anthropic"
+];
+var TEST_SEGMENT_RE = /(^|\/)(__tests__|__fixtures__|__mocks__)(\/|$)/;
+var TEST_FILE_RE = /\.(test|spec)\./i;
+function isTestPath(rel2) {
+  return TEST_SEGMENT_RE.test(rel2) || TEST_FILE_RE.test(posix.basename(rel2));
+}
+function importSpecifiers(text) {
+  const out = [];
+  const re = /(?:\bfrom\s+|\bimport\s+|\brequire\(\s*)['"]([^'"\n]+)['"]/g;
+  for (const m of text.matchAll(re)) out.push(m[1]);
+  return out;
+}
+var JS_ROUTE_RE = /\b(?:app|router|server|fastify|api)\s*\.\s*(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`\n]+)['"`]/g;
+var FASTAPI_ROUTE_RE = /@\w+\.(get|post|put|patch|delete)\(\s*['"]([^'"\n]+)['"]/g;
+var FLASK_ROUTE_RE = /@\w+\.route\(\s*['"]([^'"\n]+)['"]([^)\n]*)/g;
+async function collectBuiltin(root) {
+  const { files, truncated } = await walk(root);
+  const languages = {};
+  for (const f of files) {
+    if (f.ext === "") continue;
+    if (f.ext.length > 6) continue;
+    const lang = langOf(f.ext);
+    languages[lang] = (languages[lang] ?? 0) + 1;
+  }
+  const entrypoints = [];
+  const routes = [];
+  const schemas = [];
+  const packages = [];
+  const externals = /* @__PURE__ */ new Map();
+  const composeServices = [];
+  const importers = /* @__PURE__ */ new Map();
+  const seenEntry = /* @__PURE__ */ new Set();
+  let readmeLines;
+  let readmeFile;
+  const addEntry = (file, why) => {
+    if (seenEntry.has(file)) return;
+    seenEntry.add(file);
+    entrypoints.push({ file, why });
+  };
+  const fileSet = new Set(files.map((f) => f.rel));
+  for (const f of files) {
+    if (isTestPath(f.rel)) continue;
+    const base = posix.basename(f.rel);
+    if (f.ext === "prisma") schemas.push({ file: f.rel, kind: "prisma" });
+    else if (f.ext === "proto") schemas.push({ file: f.rel, kind: "proto" });
+    else if (f.ext === "sql" && /(^|\/)migrations?\//.test(f.rel))
+      schemas.push({ file: f.rel, kind: "sql" });
+    else if (/^(openapi|swagger)\./i.test(base) && ["yaml", "yml", "json"].includes(f.ext))
+      schemas.push({ file: f.rel, kind: "openapi" });
+    else if (/^drizzle\.config\./.test(base)) schemas.push({ file: f.rel, kind: "other" });
+    if (/^src\/index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f.rel)) addEntry(f.rel, "src/index convention");
+    if (/^(main|app|manage)\.py$/.test(f.rel)) addEntry(f.rel, "python entry convention");
+    if (/^cmd\/[^/]+\/main\.go$/.test(f.rel)) addEntry(f.rel, "Go cmd/ convention");
+    if (f.rel.toLowerCase() === "readme.md") {
+      try {
+        const text2 = await readFile(f.abs, "utf8");
+        const lines = text2.split("\n");
+        if (lines[lines.length - 1] === "") lines.pop();
+        readmeLines = lines.length;
+        readmeFile = f.rel;
+      } catch {
+      }
+    }
+    if (base === "package.json") {
+      try {
+        const pkg = JSON.parse(await readFile(f.abs, "utf8"));
+        const dir = posix.dirname(f.rel);
+        if (typeof pkg["name"] === "string") {
+          packages.push({ name: pkg["name"], dir: dir === "." ? "." : dir });
+        }
+        const inPkg = (p) => posix.normalize(posix.join(dir === "." ? "" : dir, p));
+        if (typeof pkg["main"] === "string") addEntry(inPkg(pkg["main"]), "package.json main");
+        const bin = pkg["bin"];
+        if (typeof bin === "string") addEntry(inPkg(bin), "package.json bin");
+        else if (bin !== null && typeof bin === "object") {
+          for (const v of Object.values(bin)) {
+            if (typeof v === "string") addEntry(inPkg(v), "package.json bin");
+          }
+        }
+        const scripts = pkg["scripts"];
+        if (scripts !== null && typeof scripts === "object") {
+          const start = scripts["start"];
+          if (typeof start === "string") {
+            const m = start.match(/(\S+\.(?:[mc]?[jt]sx?|py))\b/);
+            if (m !== null) addEntry(inPkg(m[1]), "package.json start script");
+          }
+        }
+      } catch {
+      }
+    }
+    if (/^(docker-)?compose(\.[\w-]+)?\.ya?ml$/.test(base) && posix.dirname(f.rel) === ".") {
+      try {
+        const lines = (await readFile(f.abs, "utf8")).split("\n");
+        const start = lines.findIndex((l) => /^services:\s*$/.test(l));
+        if (start >= 0) {
+          for (let i = start + 1; i < lines.length; i += 1) {
+            const line = lines[i];
+            if (/^\S/.test(line)) break;
+            const m = line.match(/^ {2}([\w-]+):\s*$/);
+            if (m !== null) composeServices.push({ name: m[1], file: f.rel });
+          }
+        }
+      } catch {
+      }
+    }
+    if (!CODE_EXTS.has(f.ext)) continue;
+    let text;
+    try {
+      text = await readFile(f.abs, "utf8");
+    } catch {
+      continue;
+    }
+    for (const m of text.matchAll(JS_ROUTE_RE)) {
+      routes.push({ method: m[1].toUpperCase(), path: m[2], file: f.rel });
+    }
+    if (f.ext === "py") {
+      for (const m of text.matchAll(FASTAPI_ROUTE_RE)) {
+        routes.push({ method: m[1].toUpperCase(), path: m[2], file: f.rel });
+      }
+      for (const m of text.matchAll(FLASK_ROUTE_RE)) {
+        const methods = m[2].match(/methods\s*=\s*\[([^\]]*)\]/);
+        const list = methods === null ? ["GET"] : methods[1].split(",").map((s) => s.replace(/['"\s]/g, "")).filter((s) => s !== "");
+        for (const method of list) {
+          routes.push({ method: method.toUpperCase(), path: m[1], file: f.rel });
+        }
+      }
+      for (const m of text.matchAll(/^(?:import|from)\s+([\w.]+)/gm)) {
+        const mod = m[1].split(".")[0];
+        if (KNOWN_EXTERNALS.includes(mod) && !externals.has(mod)) {
+          externals.set(mod, { name: mod, file: f.rel });
+        }
+      }
+      continue;
+    }
+    if (/\bfetch\s*\(/.test(text) && !externals.has("fetch")) {
+      externals.set("fetch", { name: "fetch", file: f.rel });
+    }
+    for (const spec of importSpecifiers(text)) {
+      if (spec.startsWith(".")) {
+        const target = posix.normalize(posix.join(posix.dirname(f.rel), spec)).replace(/\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/, "").replace(/\/index$/, "");
+        let set = importers.get(target);
+        if (set === void 0) {
+          set = /* @__PURE__ */ new Set();
+          importers.set(target, set);
+        }
+        set.add(f.rel);
+        continue;
+      }
+      const hit = KNOWN_EXTERNALS.find(
+        (k) => k.endsWith("/") ? spec.startsWith(k) : spec === k || spec.startsWith(`${k}/`)
+      );
+      if (hit !== void 0) {
+        const name = hit.endsWith("/") ? spec : hit;
+        if (!externals.has(name)) externals.set(name, { name, file: f.rel });
+      }
+    }
+  }
+  for (const f of files) {
+    if (isTestPath(f.rel)) continue;
+    const api = f.rel.match(/(?:^|\/)pages\/api\/(.+)\.(?:[jt]sx?)$/);
+    if (api !== null) {
+      const p = `/${api[1].replace(/\/index$/, "")}`;
+      routes.push({ method: "ANY", path: `/api${p === "/index" ? "" : p}`, file: f.rel });
+      continue;
+    }
+    const appRoute = f.rel.match(/(?:^|\/)app\/(.*?)route\.(?:[jt]s)$/);
+    if (appRoute !== null) {
+      const p = `/${appRoute[1].replace(/\/$/, "")}`;
+      routes.push({ method: "ANY", path: p === "/" ? "/" : p, file: f.rel });
+    }
+  }
+  const godNodes = [...importers.entries()].map(([target, set]) => ({ target, degree: set.size })).filter((g) => g.degree >= 3).sort((a, b) => b.degree - a.degree || a.target.localeCompare(b.target)).slice(0, 10).map((g) => {
+    const candidates = [
+      g.target,
+      ...["ts", "tsx", "js", "jsx", "mjs", "cjs"].flatMap((e) => [
+        `${g.target}.${e}`,
+        `${g.target}/index.${e}`
+      ])
+    ];
+    const file = candidates.find((c) => fileSet.has(c)) ?? g.target;
+    return { name: g.target, degree: g.degree, file };
+  });
+  const stats = { files: files.length, languages };
+  return {
+    stats,
+    evidence: { entrypoints, routes, schemas, packages, externals: [...externals.values()], godNodes },
+    composeServices,
+    readmeLines,
+    readmeFile,
+    truncated
+  };
+}
+async function isUsableRoot(p) {
+  try {
+    return (await stat(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var GRAPH_PATH = "graphify-out/graph.json";
+async function loadGraphify(root) {
+  const path = join(root, GRAPH_PATH);
+  if (!existsSync(path)) return { ok: false, missing: true };
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path, "utf8"));
+  } catch (err) {
+    return {
+      ok: false,
+      missing: false,
+      reason: `${GRAPH_PATH} did not parse as JSON (${err.message}).`
+    };
+  }
+  const obj = parsed;
+  if (!Array.isArray(obj.nodes) || !Array.isArray(obj.links)) {
+    return {
+      ok: false,
+      missing: false,
+      reason: `${GRAPH_PATH} has no nodes/links arrays.`
+    };
+  }
+  const n0 = obj.nodes[0];
+  if (n0 !== void 0 && (typeof n0["id"] !== "string" || typeof n0["label"] !== "string")) {
+    return {
+      ok: false,
+      missing: false,
+      reason: `${GRAPH_PATH} nodes lack the id/label fields.`
+    };
+  }
+  const l0 = obj.links[0];
+  if (l0 !== void 0 && (l0["source"] === void 0 || l0["target"] === void 0)) {
+    return {
+      ok: false,
+      missing: false,
+      reason: `${GRAPH_PATH} links lack the source/target fields.`
+    };
+  }
+  return { ok: true, graph: { nodes: obj.nodes, links: obj.links } };
+}
+function extOf2(path) {
+  const base = path.slice(path.lastIndexOf("/") + 1);
+  const i = base.lastIndexOf(".");
+  return i <= 0 ? "" : base.slice(i + 1).toLowerCase();
+}
+function graphifyStats(graph) {
+  const files = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes) {
+    if (typeof node.source_file === "string" && node.source_file !== "") files.add(node.source_file);
+  }
+  const languages = {};
+  for (const file of files) {
+    const ext = extOf2(file);
+    if (ext === "" || ext.length > 6) continue;
+    languages[ext] = (languages[ext] ?? 0) + 1;
+  }
+  return { files: files.size, languages };
+}
+function graphifyGodNodes(graph, top = 10) {
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const link of graph.links) {
+    if (link.relation !== "calls" && link.relation !== "imports") continue;
+    const target = String(link.target);
+    inDegree.set(target, (inDegree.get(target) ?? 0) + 1);
+  }
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  return [...inDegree.entries()].filter(([, degree]) => degree >= 3).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, top).map(([id, degree]) => {
+    const node = byId.get(id);
+    return {
+      name: node?.label ?? id,
+      degree,
+      file: node?.source_file ?? ""
+    };
+  });
+}
+
+// src/commands/audit/rules.ts
+var CITE_CAP = 8;
+function cite(files) {
+  return [...new Set(files)].slice(0, CITE_CAP);
+}
+function deriveRecommendations(collected, source) {
+  const { evidence, composeServices, readmeLines, readmeFile } = collected;
+  const out = [];
+  const pkgCount = evidence.packages.length;
+  const svcCount = composeServices.length;
+  const entryCount = evidence.entrypoints.length;
+  const archCites = cite([
+    ...evidence.packages.map((p) => p.dir === "." ? "package.json" : `${p.dir}/package.json`),
+    ...composeServices.map((s) => s.file),
+    ...evidence.entrypoints.map((e) => e.file)
+  ]);
+  if (pkgCount >= 2 || svcCount >= 2 || entryCount >= 3) {
+    const parts = [];
+    if (pkgCount >= 2) parts.push(`${pkgCount} packages`);
+    if (svcCount >= 2) parts.push(`${svcCount} compose services`);
+    if (entryCount >= 3) parts.push(`${entryCount} entrypoints`);
+    out.push({
+      kind: "architecture-overview",
+      title: "Architecture overview",
+      rationale: `The repo has ${parts.join(" and ")}. An overview shows how they connect.`,
+      confidence: "high",
+      citations: archCites,
+      template: "system-design"
+    });
+  } else if (entryCount >= 1 && evidence.externals.length >= 5) {
+    out.push({
+      kind: "architecture-overview",
+      title: "Architecture overview",
+      rationale: `The code talks to ${evidence.externals.length} external services from ${entryCount} entrypoint(s). An overview maps the boundary.`,
+      confidence: "medium",
+      citations: cite([...archCites, ...evidence.externals.map((e) => e.file)]),
+      template: "system-design"
+    });
+  }
+  if (evidence.schemas.length >= 1) {
+    out.push({
+      kind: "data-model",
+      title: "Data model",
+      rationale: `The repo defines ${evidence.schemas.length} schema file(s). A data-model doc explains the entities.`,
+      confidence: "high",
+      citations: cite(evidence.schemas.map((s) => s.file)),
+      template: "data-model"
+    });
+  }
+  const routeCount = evidence.routes.length;
+  if (routeCount >= 1) {
+    out.push({
+      kind: "request-flows",
+      title: "Request flows",
+      rationale: `The audit found ${routeCount} route(s). A flow doc traces each request path.`,
+      confidence: routeCount >= 3 ? "high" : "low",
+      citations: cite(evidence.routes.map((r) => r.file)),
+      template: "service-overview"
+    });
+  }
+  const openapi = evidence.schemas.filter((s) => s.kind === "openapi");
+  if (openapi.length >= 1) {
+    out.push({
+      kind: "api-reference",
+      title: "API reference",
+      rationale: `An OpenAPI spec exists (${openapi[0]?.file}). An API reference doc can stay in sync with it.`,
+      confidence: "high",
+      citations: cite(openapi.map((s) => s.file)),
+      template: "api-spec"
+    });
+  } else if (routeCount >= 5) {
+    out.push({
+      kind: "api-reference",
+      title: "API reference",
+      rationale: `The audit found ${routeCount} routes and no OpenAPI spec. An API reference documents them.`,
+      confidence: "medium",
+      citations: cite(evidence.routes.map((r) => r.file)),
+      template: "api-spec"
+    });
+  }
+  const godThreshold = source === "graphify" ? 15 : 10;
+  const god = evidence.godNodes.find((g) => g.degree >= godThreshold);
+  if (god !== void 0) {
+    out.push({
+      kind: "dependency-map",
+      title: "Dependency map",
+      rationale: `${god.name} has ${god.degree} inbound dependencies. A dependency map shows what breaks when it changes.`,
+      confidence: "medium",
+      citations: cite([god.file].filter((f) => f !== "")),
+      template: "system-design"
+    });
+  }
+  if (readmeLines === void 0 || readmeLines < 30) {
+    const rationale = readmeLines === void 0 ? "The repo has no README. An onboarding guide gives new contributors a start." : `The README has only ${readmeLines} line(s). An onboarding guide gives new contributors a start.`;
+    out.push({
+      kind: "onboarding-guide",
+      title: "Onboarding guide",
+      rationale,
+      confidence: "medium",
+      citations: cite(
+        [readmeFile, ...evidence.entrypoints.map((e) => e.file)].filter(
+          (f) => f !== void 0
+        )
+      ),
+      template: "onboarding"
+    });
+  }
+  return out;
+}
+
+// src/commands/audit/run.ts
+async function runAudit(options) {
+  const root = resolve(options.cwd, options.path ?? ".");
+  if (!await isUsableRoot(root)) {
+    return { ok: false, error: `Cannot audit ${options.path ?? root}: not a directory.` };
+  }
+  const collected = await collectBuiltin(root);
+  const graph = await loadGraphify(root);
+  let source = "builtin";
+  const notices = [];
+  let stats = collected.stats;
+  let evidence = collected.evidence;
+  if (graph.ok) {
+    source = "graphify";
+    stats = graphifyStats(graph.graph);
+    evidence = { ...evidence, godNodes: graphifyGodNodes(graph.graph) };
+  } else if (graph.missing) {
+    notices.push("Install graphify to get a richer audit (call graph, communities).");
+  } else {
+    notices.push(`${graph.reason} The audit used the builtin extractor.`);
+  }
+  if (collected.truncated) {
+    notices.push(`The scan stopped at ${FILE_CAP} files. Counts are lower bounds.`);
+  }
+  const merged = { ...collected, evidence };
+  const recommendations = deriveRecommendations(merged, source);
+  const report = {
+    version: 1,
+    source,
+    ...notices.length > 0 ? { notice: notices.join(" ") } : {},
+    stats,
+    evidence,
+    recommendations
+  };
+  return { ok: true, report };
+}
+function languagesLine(languages, cap = 6) {
+  const top = Object.entries(languages).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, cap);
+  return top.map(([lang, n]) => `${lang} ${n}`).join(" \xB7 ");
+}
+function formatAudit(report, plain = false) {
+  const dim = (s) => plain ? s : pc5.dim(s);
+  const bold = (s) => plain ? s : pc5.bold(s);
+  const cyan = (s) => plain ? s : pc5.cyan(s);
+  const paint = (confidence) => {
+    if (plain) return confidence;
+    if (confidence === "high") return pc5.green(confidence);
+    if (confidence === "medium") return pc5.yellow(confidence);
+    return pc5.dim(confidence);
+  };
+  const lines = [];
+  const langs = languagesLine(report.stats.languages);
+  lines.push(`  ${dim("source".padEnd(8))}${report.source}`);
+  lines.push(
+    `  ${dim("files".padEnd(8))}${report.stats.files}${langs === "" ? "" : dim(` \xB7 ${langs}`)}`
+  );
+  const e = report.evidence;
+  const counts = [
+    `${e.entrypoints.length} entrypoint(s)`,
+    `${e.routes.length} route(s)`,
+    `${e.schemas.length} schema(s)`,
+    `${e.packages.length} package(s)`,
+    `${e.externals.length} external(s)`,
+    `${e.godNodes.length} god node(s)`
+  ].join(" \xB7 ");
+  lines.push(`  ${dim("found".padEnd(8))}${counts}`);
+  lines.push("");
+  if (report.recommendations.length === 0) {
+    lines.push(`  ${bold("No recommendations.")} ${dim("The audit found too little evidence.")}`);
+  } else {
+    lines.push(`  ${bold("Recommended docs:")}`);
+    const kindWidth = Math.max(...report.recommendations.map((r) => r.kind.length));
+    for (const r of report.recommendations) {
+      lines.push(
+        `    ${paint(r.confidence.padEnd(7))} ${cyan(r.kind.padEnd(kindWidth))}  ${r.rationale} ${dim(`(${r.citations.length} citation(s))`)}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(`  ${dim("Next:")} run ${cyan("/chiltepin audit")} in Claude Code to generate the docs you pick.`);
+  if (report.notice !== void 0) lines.push(`  ${dim(`note: ${report.notice}`)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderCodeFrame(input) {
+  const { lines, line } = input;
+  if (line < 1 || line > lines.length) return "";
+  const contextBefore = input.contextBefore ?? 1;
+  const start = Math.max(1, line - contextBefore);
+  const gutterWidth = String(line).length + 1;
+  const tint = input.level === "warn" ? pc5.yellow : pc5.red;
+  const out = [];
+  for (let n = start; n <= line; n++) {
+    const text = lines[n - 1] ?? "";
+    const gutter = pc5.dim(`${String(n).padStart(gutterWidth)} | `);
+    out.push(gutter + text);
+  }
+  if (input.column !== void 0 && input.column >= 1) {
+    const col = input.column;
+    const span = input.endColumn !== void 0 ? Math.max(1, input.endColumn - col) : 1;
+    const pad = " ".repeat(gutterWidth) + pc5.dim(" | ") + " ".repeat(col - 1);
+    out.push(pad + tint("^".repeat(span)));
+  }
+  return out.join("\n");
+}
+var COLOR = {
+  error: "red",
+  warn: "yellow"
+};
+function frameFor(d, sources) {
+  if (d.line === void 0) return "";
+  const lines = sources.get(d.file);
+  if (lines === void 0) return "";
+  return renderCodeFrame({
+    lines,
+    line: d.line,
+    ...d.column !== void 0 ? { column: d.column } : {},
+    ...d.endColumn !== void 0 ? { endColumn: d.endColumn } : {},
+    level: d.level
+  });
+}
+function DiagnosticsTable({ diagnostics, fileCount, sources }) {
+  const errorCount = diagnostics.filter((d) => d.level === "error").length;
+  const warnCount = diagnostics.filter((d) => d.level === "warn").length;
+  if (diagnostics.length === 0) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+      "\u2713 ",
+      fileCount,
+      " ",
+      fileCount === 1 ? "file" : "files",
+      " checked \u2014 no diagnostics"
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    diagnostics.map((d, i) => {
+      const frame = frameFor(d, sources);
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(Text, { color: COLOR[d.level], bold: true, children: [
+            d.level === "error" ? "\u2716" : "\u26A0",
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            d.file,
+            d.line !== void 0 ? `:${d.line}` : "",
+            d.column !== void 0 ? `:${d.column}` : "",
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: COLOR[d.level], children: [
+            d.code,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(Text, { children: d.message })
+        ] }),
+        frame.length > 0 ? /* @__PURE__ */ jsx(Text, { children: frame }) : null,
+        d.hint !== void 0 ? /* @__PURE__ */ jsxs(Text, { children: [
+          "  ",
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: "hint:" }),
+          " ",
+          d.hint
+        ] }) : null,
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          helpUrl(d.code)
+        ] })
+      ] }, `${d.file}:${d.line ?? "-"}:${i}`);
+    }),
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { bold: true, color: errorCount > 0 ? "red" : warnCount > 0 ? "yellow" : "green", children: [
+      errorCount,
+      " ",
+      errorCount === 1 ? "error" : "errors",
+      ", ",
+      warnCount,
+      " ",
+      warnCount === 1 ? "warning" : "warnings",
+      " across ",
+      fileCount,
+      " ",
+      fileCount === 1 ? "file" : "files"
+    ] }) })
+  ] });
+}
+function formatDiagnosticsPlain(diagnostics, fileCount, sources) {
+  if (diagnostics.length === 0) {
+    return `OK: ${fileCount} ${fileCount === 1 ? "file" : "files"} checked, no diagnostics
+`;
+  }
+  const blocks = diagnostics.map((d) => {
+    const loc = d.line !== void 0 ? `${d.file}:${d.line}${d.column !== void 0 ? `:${d.column}` : ""}` : d.file;
+    const parts = [`${loc}  ${d.level}  ${d.code}  ${d.message}`];
+    const frame = frameFor(d, sources);
+    if (frame.length > 0) parts.push(frame);
+    if (d.hint !== void 0) parts.push(`  hint: ${d.hint}`);
+    return parts.join("\n");
+  });
+  const errors = diagnostics.filter((d) => d.level === "error").length;
+  const warns = diagnostics.filter((d) => d.level === "warn").length;
+  blocks.push(`${errors} error(s), ${warns} warning(s) across ${fileCount} file(s)`);
+  return blocks.join("\n\n") + "\n";
+}
+var TAGLINE = "Documentation-as-code \u2014 Markdown with typed, fenced YAML blocks.";
+var BRAND_GRADIENT = ["#e4744c", "#b04a25"];
+var plainOutput = () => process.stdout.isTTY !== true || process.env["CHILTEPIN_PLAIN"] === "1";
+var plainLine = (version) => `chiltepin v${version} \u2014 ${TAGLINE}`;
+function actionBanner(word) {
+  try {
+    const out = cfonts.render(word, {
+      font: "tiny",
+      gradient: BRAND_GRADIENT,
+      transitionGradient: true,
+      space: false,
+      env: "node"
+    });
+    if (out !== false && typeof out === "object" && out.string !== void 0) {
+      return `
+${out.string}
+`;
+    }
+  } catch {
+  }
+  return `
+  ${pc5.red(pc5.bold(word))}
+`;
+}
+var FUN_LINES = {
+  html: "Roasting your doc into HTML\u2026",
+  slides: "Slicing the pepper into slides\u2026",
+  pdf: "Drying one PDF in the sun\u2026",
+  preview: "Tasting the preview\u2026",
+  check: "Checking the crop for bad pods\u2026",
+  new: "Planting a fresh doc\u2026",
+  demo: "Serving up the chiltepin demo\u2026",
+  build: "Grinding the whole harvest into a site\u2026",
+  serve: "Serving fresh docs \u2014 reloads on save\u2026",
+  studio: "Opening the studio \u2014 the harvest goes visual\u2026"
+};
+function funLine(action) {
+  return pc5.dim(`  ${FUN_LINES[action] ?? `${action}\u2026`}`);
+}
+function banner(version = "0.0.2") {
+  if (plainOutput()) return `
+${plainLine(version)}
+`;
+  const glyph = pc5.red("\u25CF");
+  const name = pc5.bold(pc5.red("chiltepin"));
+  return `
+  ${glyph} ${name} ${pc5.dim(`v${version} \u2014 ${TAGLINE}`)}
+`;
+}
+var HELP_GROUPS = [
+  { header: "WORK", commands: ["init", "new", "check", "studio"] },
+  { header: "OUTPUT", commands: ["html", "slides", "pdf", "build"] },
+  { header: "REFERENCE", commands: ["block", "demo"] },
+  { header: "SETUP", commands: ["sync"] }
+];
+function examples() {
+  const p = plainOutput();
+  const dim = (s) => p ? s : pc5.dim(s);
+  const cyan = (s) => p ? s : pc5.cyan(s);
+  const rows = HELP_GROUPS.map(
+    (g) => `  ${dim(g.header.padEnd(10))}${g.commands.map((c) => cyan(c)).join(dim(" \xB7 "))}`
+  );
+  return [
+    "",
+    ...rows,
+    "",
+    `  ${cyan("chiltepin <file.md>")} ${dim("renders + opens a doc \u2014 the fastest preview")}`,
+    `  ${cyan("npx skills add jdiejim/chiltepin")} ${dim("installs the authoring skill into your AI agent")}`,
+    `  ${dim("Docs:")} https://github.com/jdiejim/chiltepin`,
+    ""
+  ].join("\n");
+}
+var COMMAND_EXAMPLES = {
+  init: [
+    ["chiltepin init", "scaffold docs/ and chiltepin.config.json"],
+    ["chiltepin init --force", "overwrite the starter files"]
+  ],
+  new: [
+    ["chiltepin new", "pick a doc template or block scaffold interactively"],
+    ["chiltepin new adr -o docs/decisions/001-queue.md", "scaffold an ADR into a file"],
+    ["chiltepin new sequence", "print a sequence-block scaffold to paste"]
+  ],
+  check: [
+    ["chiltepin check", "validate every doc under docs/"],
+    ["chiltepin check docs/api.md", "validate one file"],
+    ["chiltepin check --json", "machine-readable diagnostics (CI)"]
+  ],
+  studio: [
+    ["chiltepin studio", "open the studio \u2014 Edit \xB7 Site \xB7 Present, files stay the source of truth"],
+    ["chiltepin studio --port 5000 --no-open", "pick the port, skip the browser"]
+  ],
+  html: [
+    ["chiltepin html docs/design.md", "write docs/design.html next to the source"],
+    ["chiltepin html docs/design.md -p", "render to a temp file and open it"]
+  ],
+  slides: [
+    ["chiltepin slides docs/roadmap.md -p", "open the doc as a slide deck"],
+    ["chiltepin slides docs/roadmap.md -o deck.html", "write the deck to a file"]
+  ],
+  pdf: [
+    ["chiltepin pdf docs/design.md", "write docs/design.pdf (downloads Chromium once)"],
+    ["chiltepin pdf docs/design.md -o out/design.pdf", "choose the output path"]
+  ],
+  build: [
+    ["chiltepin build", "build the whole site into dist/"],
+    ["chiltepin build --out site", "build into a different directory"]
+  ],
+  block: [
+    ["chiltepin block", "every block type, one line each, by family"],
+    ["chiltepin block sequence", "fields, enums, terse forms, and a validating example"],
+    ["chiltepin block erd --json", "the same contract as JSON"]
+  ],
+  demo: [
+    ["chiltepin demo", "render the built-in showcase of every block and open it"],
+    ["chiltepin demo charts -s", "one family, as a slide deck"]
+  ],
+  sync: [
+    ["chiltepin sync openapi api.yaml -o docs/api.md", "generate a doc from an OpenAPI spec"],
+    ["chiltepin sync openapi api.yaml --check docs/api.md", "fail on drift (CI)"],
+    [
+      "chiltepin sync csv sales.csv",
+      "print a ready-to-paste block (auto-picks table/statustable/chart)"
+    ],
+    [
+      "chiltepin sync csv sales.csv -o docs/sales.md",
+      "wrap the block in a doc, write it, and validate"
+    ],
+    ["chiltepin sync csv sales.csv --block chart", "force the target block type"]
+  ]
+};
+function commandExamples(name) {
+  const rows = COMMAND_EXAMPLES[name];
+  if (rows === void 0) return "";
+  const p = plainOutput();
+  const dim = (s) => p ? s : pc5.dim(s);
+  const cyan = (s) => p ? s : pc5.cyan(s);
+  const width = Math.max(...rows.map(([cmd]) => cmd.length));
+  return [
+    "",
+    "Examples:",
+    ...rows.map(([cmd, note]) => `  ${cyan("$ " + cmd.padEnd(width))}  ${dim(note)}`),
+    ""
+  ].join("\n");
+}
+
+// src/tty.ts
+var isInteractive = process.stdout.isTTY === true && process.env["CI"] !== "true" && process.env["CHILTEPIN_PLAIN"] !== "1";
+function flourish(word, lineKey = word) {
+  if (!isInteractive) return;
+  console.log(actionBanner(word));
+  console.log(funLine(lineKey) + "\n");
+}
+function printInitSummary(result) {
+  for (const f of result.created) console.log(pc5.green("+ ") + f);
+  for (const f of result.skipped) console.log(pc5.dim("  skip ") + f + pc5.dim(" (exists)"));
+  console.log(
+    pc5.bold(`
+Created ${result.created.length} file(s), skipped ${result.skipped.length}.`)
+  );
+  console.log(
+    pc5.dim(
+      "Layout: docs/<area>/<doc>.md, kebab-case names \xB7 output goes to dist/ \u2014 do not commit it."
+    )
+  );
+  console.log(
+    `Next: ${pc5.cyan("chiltepin check")} ${pc5.dim("\xB7")} ${pc5.cyan("chiltepin docs/getting-started.md")} ${pc5.dim("(render + open)")}`
+  );
+  console.log(
+    `AI:   ${pc5.cyan("npx skills add jdiejim/chiltepin")} ${pc5.dim("installs the authoring skill into Claude Code, Cursor, Codex, and 70+ agents")}`
+  );
+}
+async function main(argv) {
+  argv = argv.map((a) => a === "-V" ? "--version" : a);
+  const version = cliVersion();
+  const program = new Command();
+  program.name("chiltepin").description("Author, validate, render, and export Chiltepin documentation.").version(version, "-v, --version", "print the version").addHelpText("beforeAll", (ctx) => ctx.command.name() === "chiltepin" ? banner(version) : "").addHelpText("after", (ctx) => ctx.command.name() === "chiltepin" ? examples() : "").exitOverride();
+  let exitCode = 0;
+  program.argument("[file]", "a .md file to render + open in the browser (same as `chiltepin html <file> -p`)").action(async (file) => {
+    const cwd = process.cwd();
+    if (file !== void 0) {
+      if (!/\.md$/i.test(file)) {
+        console.error(`error: unknown command '${file}'`);
+        exitCode = 1;
+        return;
+      }
+      flourish("preview");
+      const result = await runSingle({
+        cwd,
+        input: file,
+        format: "html",
+        preview: true,
+        open: isInteractive
+        // script-safe: piped output renders but doesn't open
+      });
+      const verb = result.opened ? "Opened" : "Wrote";
+      console.log(`${pc5.green(verb)} ${result.output} ${pc5.dim(`(${result.bytes} bytes)`)}`);
+      return;
+    }
+    if (!isInteractive) {
+      program.outputHelp();
+      return;
+    }
+    console.log(banner(version));
+    if (findConfig(cwd) === void 0) {
+      console.log(`  Not a Chiltepin project yet \u2014 run ${pc5.cyan("chiltepin init")} to scaffold one.`);
+      console.log(
+        `  ${pc5.dim("Curious first?")} ${pc5.cyan("chiltepin demo")} ${pc5.dim("renders every block \xB7 ")}${pc5.cyan("chiltepin block")} ${pc5.dim("lists them.")}`
+      );
+      console.log("");
+      return;
+    }
+    const status = await projectStatus(cwd);
+    console.log(formatStatus(status));
+  });
+  program.command("init").description("Scaffold a new Chiltepin project in the current directory").option("--force", "overwrite existing files").option("-y, --yes", "accepted for compatibility (init has no prompts)", void 0).action(async (opts) => {
+    const result = await runInit({
+      cwd: process.cwd(),
+      ...opts.force === true ? { force: true } : {}
+    });
+    printInitSummary(result);
+  });
+  program.command("check [globs...]").description("Validate documents (default: docs/**/*.md)").option("--json", "emit machine-readable JSON").option("--strict-prose", "treat prose-lint warnings (W_PROSE_*) as errors").action(async (globs, opts) => {
+    const cwd = process.cwd();
+    const config = await loadConfig(cwd);
+    const patterns = globs.length > 0 ? globs : [`${config.docsDir}/**/*.md`];
+    const result = await runCheck({
+      patterns,
+      cwd,
+      docsRoot: config.docsDir,
+      ...opts.strictProse === true ? { strictProse: true } : {}
+    });
+    if (opts.json === true) {
+      process.stdout.write(
+        JSON.stringify({ diagnostics: result.diagnostics, files: result.files }, null, 2) + "\n"
+      );
+    } else if (isInteractive) {
+      flourish("check");
+      const { waitUntilExit } = render(
+        /* @__PURE__ */ jsx(
+          DiagnosticsTable,
+          {
+            diagnostics: result.diagnostics,
+            fileCount: result.files.length,
+            sources: result.sources
+          }
+        )
+      );
+      await waitUntilExit();
+    } else {
+      process.stdout.write(
+        formatDiagnosticsPlain(result.diagnostics, result.files.length, result.sources)
+      );
+    }
+    exitCode = result.exitCode;
+  });
+  program.command("audit [path]").description("Audit a codebase and recommend which Chiltepin docs to write (evidence-cited)").option("--json", "emit machine-readable JSON (schema version 1)").action(async (pathArg, opts) => {
+    const result = await runAudit({
+      cwd: process.cwd(),
+      ...pathArg !== void 0 ? { path: pathArg } : {}
+    });
+    if (!result.ok) {
+      console.error(pc5.red(result.error));
+      exitCode = 2;
+      return;
+    }
+    if (opts.json === true) {
+      process.stdout.write(JSON.stringify(result.report, null, 2) + "\n");
+      return;
+    }
+    if (isInteractive) {
+      flourish("audit");
+      console.log(formatAudit(result.report, false));
+    } else {
+      process.stdout.write(formatAudit(result.report, true) + "\n");
+    }
+  });
+  program.command("preview <input>", { hidden: true }).description("Render a document to a temp HTML file and open it (same as `chiltepin <file.md>`)").action(async (input) => {
+    flourish("preview");
+    const result = await runSingle({
+      cwd: process.cwd(),
+      input,
+      format: "html",
+      preview: true,
+      open: isInteractive
+    });
+    const verb = result.opened ? "Opened" : "Wrote";
+    console.log(`${pc5.green(verb)} ${result.output} ${pc5.dim(`(${result.bytes} bytes)`)}`);
+  });
+  program.command("new [name]").description(
+    "Create from a template \u2014 a full doc (adr, runbook, \u2026) or a single block (sequence, erd, \u2026)"
+  ).option("-o, --output <path>", "write to a file instead of printing to stdout").option("--force", "with -o, replace the file if it already exists").action(async (nameArg, opts) => {
+    const cwd = process.cwd();
+    const resolveName = (n) => {
+      if (isDocTemplate(n) || BLOCK_TYPES.includes(n)) return { type: n };
+      const alias = BLOCK_ALIASES[n];
+      if (alias !== void 0) {
+        const patch = Object.entries(alias.patch ?? {}).map(([k, v]) => `${k}: ${String(v)}`).join(", ");
+        return {
+          type: alias.type,
+          note: `\`${n}\` now lives in \`${alias.type}\`${patch === "" ? "" : ` (${patch})`} \u2014 both spellings work; no change needed.`
+        };
+      }
+      return void 0;
+    };
+    const emit = async (type) => {
+      if (opts.output !== void 0) {
+        const p = await writeNewDoc({
+          cwd,
+          type,
+          out: opts.output,
+          ...opts.force === true ? { force: true } : {}
+        });
+        console.log(`${pc5.green("\u2713")} Wrote ${p}`);
+        return;
+      }
+      const content = isDocTemplate(type) ? DOC_TEMPLATES[type] : templateFor(type);
+      if (isInteractive)
+        console.log(pc5.dim(`# ${type} \u2014 paste into a docs/*.md (or re-run with -o <path>)
+`));
+      process.stdout.write(content);
+      if (isInteractive && copyToClipboard(content))
+        console.log(pc5.green("\n\u2713 copied to clipboard"));
+    };
+    if (nameArg !== void 0) {
+      const hit = resolveName(nameArg);
+      if (hit === void 0) {
+        console.error(
+          pc5.red(`Unknown template or block: ${nameArg}. Run \`chiltepin new\` to list them.`)
+        );
+        exitCode = 2;
+        return;
+      }
+      if (hit.note !== void 0) console.error(pc5.yellow(hit.note));
+      await emit(hit.type);
+      return;
+    }
+    if (!isInteractive) {
+      console.log("Doc templates:");
+      for (const [name, info] of Object.entries(DOC_TEMPLATE_INFO)) {
+        console.log(`  ${name.padEnd(14)}${info.description}`);
+      }
+      console.log("\nBlocks:");
+      for (const fam of BLOCK_FAMILIES) {
+        console.log(`  ${fam.label}: ${familyBlocks(fam.id).join("  ")}`);
+      }
+      console.log("\nUsage: chiltepin new <name> [-o <path>]");
+      return;
+    }
+    flourish("new");
+    let picked;
+    const { waitUntilExit } = render(
+      /* @__PURE__ */ jsx(
+        NewPickerApp,
+        {
+          onPick: (n) => {
+            picked = n;
+          }
+        }
+      )
+    );
+    await waitUntilExit();
+    if (picked === void 0) return;
+    await emit(picked);
+  });
+  program.command("build").description("Build a static HTML site from all docs \u2014 index, sidebar nav, cross-doc links").option("--out <dir>", 'output directory (default: config outDir, "dist")').option(
+    "--rich-index",
+    "build the rich index page \u2014 project TLDR, doc map by tag, cross-reference graph (default)"
+  ).option("--no-rich-index", "build the plain card-grid index instead").action(async (opts) => {
+    flourish("build");
+    const result = await runBuild({
+      cwd: process.cwd(),
+      ...opts.out !== void 0 ? { out: opts.out } : {},
+      ...opts.richIndex !== void 0 ? { richIndex: opts.richIndex } : {}
+    });
+    if (result.diagnostics.length > 0) {
+      for (const d of result.diagnostics) {
+        const loc = d.line !== void 0 ? `${d.file}:${d.line}` : d.file;
+        const fatal = d.code === "E_RENDER" || d.code === "E_ENCODING";
+        const line = `${fatal ? "error" : "warn "}  ${loc}  ${d.code}  ${d.message}`;
+        console.error(fatal ? pc5.red(line) : pc5.yellow(line));
+      }
+      const errors = result.diagnostics.filter(
+        (d) => d.code === "E_RENDER" || d.code === "E_ENCODING"
+      ).length;
+      const warnings = result.diagnostics.length - errors;
+      const parts = [];
+      if (errors > 0) parts.push(`${errors} error(s)`);
+      if (warnings > 0) parts.push(`${warnings} warning(s)`);
+      console.error(
+        (errors > 0 ? pc5.red : pc5.yellow)(`${parts.join(", ")} \u2014 run \`chiltepin check\` for details`)
+      );
+    }
+    const bytes = result.pages.reduce((sum, p) => sum + p.bytes, 0);
+    const decks = result.pages.filter((p) => p.path.endsWith(".slides.html")).length;
+    const deckPart = decks > 0 ? ` + ${decks} deck(s)` : "";
+    console.log(
+      `${pc5.green("\u2713")} ${result.pages.length - decks} page(s)${deckPart} \u2192 ${result.outDirRel}/ ${pc5.dim(`(${bytes} bytes)`)}`
+    );
+    if (result.removed.length > 0) {
+      for (const p of result.removed) console.log(pc5.dim(`  removed ${p}`));
+      console.log(
+        `${pc5.green("\u2713")} ${result.removed.length} stale file(s) removed ${pc5.dim("(no longer generated)")}`
+      );
+    }
+    if (result.pruneDeferred) {
+      console.log(
+        pc5.dim(
+          `Note: ${result.outDirRel}/ had no build manifest, so nothing was pruned. The next build prunes what this one generated.`
+        )
+      );
+    }
+    exitCode = result.exitCode;
+  });
+  program.command("serve", { hidden: true }).description(
+    "Serve the docs site locally with live reload (compat \u2014 `chiltepin studio` includes this as Site mode)"
+  ).option("--port <n>", "port to listen on (0 = pick a free port)", "4173").option("--no-open", "don't open the browser").option(
+    "--rich-index",
+    "serve the rich index page \u2014 project TLDR, doc map by tag, cross-reference graph (default)"
+  ).option("--no-rich-index", "serve the plain card-grid index instead").action(async (opts) => {
+    flourish("serve");
+    const parsed = Number.parseInt(opts.port, 10);
+    await runServe({
+      cwd: process.cwd(),
+      port: Number.isNaN(parsed) ? 4173 : parsed,
+      open: opts.open,
+      ...opts.richIndex !== void 0 ? { richIndex: opts.richIndex } : {}
+    });
+  });
+  program.command("studio").description(
+    "open the local studio \u2014 a Home page of your docs, edit in place, present as slides; the built site is one click away; files stay the source of truth"
+  ).option("--port <n>", "port to listen on (0 = pick a free port)", "4174").option("--no-open", "don't open the browser").action(async (opts) => {
+    flourish("studio");
+    const parsed = Number.parseInt(opts.port, 10);
+    await runStudio({
+      cwd: process.cwd(),
+      port: Number.isNaN(parsed) ? 4174 : parsed,
+      open: opts.open
+    });
+  });
+  const syncCmd = program.command("sync").description(
+    "Generate Chiltepin docs from external sources (OpenAPI, CSV, SQL / DBML / Prisma schemas)"
+  );
+  syncCmd.command("openapi <spec>").description("Generate (or drift-check) a doc from an OpenAPI 3.x spec").option("-o, --out <path>", "write generated markdown to this path").option("--check <path>", "compare against an existing doc and fail on drift").option("--slug <slug>", "block-id namespace (defaults to the output basename)").option("--force", "with --out, replace the file if it already exists").action(
+    async (spec, opts) => {
+      const result = await runSyncOpenApi({
+        cwd: process.cwd(),
+        spec,
+        ...opts.out !== void 0 ? { out: opts.out } : {},
+        ...opts.check !== void 0 ? { check: opts.check } : {},
+        ...opts.slug !== void 0 ? { slug: opts.slug } : {},
+        ...opts.force === true ? { force: true } : {}
+      });
+      if (result.exitCode === 0) {
+        console.log(pc5.green("\u2713 ") + result.message);
+      } else {
+        console.error(pc5.red(result.message));
+        if (result.diff !== void 0) console.error(result.diff);
+      }
+      exitCode = result.exitCode;
+    }
+  );
+  syncCmd.command("csv <file>").description("Turn a CSV into a table/statustable/chart block (stdout), or a whole doc (--out)").option("-o, --out <path>", "write a minimal doc (meta + block) to this path and validate it").option("--block <type>", "target block: table | statustable | chart (default: auto-suggest)").option("--title <title>", "doc title with --out (default: prettified file name)").option("--delimiter <d>", 'field delimiter: "," ";" or "tab" (default: auto-detect)').option("--force", "with --out, replace the file if it already exists").action(
+    async (file, opts) => {
+      if (opts.block !== void 0 && opts.block !== "table" && opts.block !== "statustable" && opts.block !== "chart") {
+        console.error(pc5.red(`Unknown block: ${opts.block}. Use table | statustable | chart.`));
+        exitCode = 2;
+        return;
+      }
+      const result = await runSyncCsv({
+        cwd: process.cwd(),
+        file,
+        ...opts.out !== void 0 ? { out: opts.out } : {},
+        ...opts.block !== void 0 ? { block: opts.block } : {},
+        ...opts.title !== void 0 ? { title: opts.title } : {},
+        ...opts.delimiter !== void 0 ? { delimiter: opts.delimiter } : {},
+        ...opts.force === true ? { force: true } : {}
+      });
+      if (result.reason !== void 0) {
+        console.error(pc5.dim(`\u2192 ${result.block}: ${result.reason}`));
+      }
+      for (const w of result.warnings) console.error(pc5.yellow(`warn  ${w}`));
+      if (result.message !== void 0) {
+        console.error(pc5.red(result.message));
+        exitCode = result.exitCode;
+        return;
+      }
+      if (result.fence !== void 0) {
+        process.stdout.write(result.fence);
+        if (isInteractive && copyToClipboard(result.fence)) {
+          console.log(pc5.green("\n\u2713 copied to clipboard"));
+        }
+      }
+      if (result.outPath !== void 0) {
+        console.log(`${pc5.green("\u2713")} Wrote ${result.outPath} ${pc5.dim(`(${result.block})`)}`);
+        const diags = result.check?.diagnostics ?? [];
+        if (diags.length === 0) {
+          console.log(`${pc5.green("\u2713")} chiltepin check: clean`);
+        } else {
+          for (const d of diags) {
+            const loc = d.line !== void 0 ? `${d.file}:${d.line}` : d.file;
+            const paint = d.level === "error" ? pc5.red : pc5.yellow;
+            console.error(paint(`${d.level}  ${loc}  ${d.code}  ${d.message}`));
+          }
+          console.error(pc5.dim(`chiltepin check: ${diags.length} diagnostic(s)`));
+        }
+      }
+      exitCode = result.exitCode;
+    }
+  );
+  const schemaSync = (dialect, what) => {
+    syncCmd.command(`${dialect} <file>`).description(`Turn ${what} into an erd block (stdout), or a whole doc (--out)`).option("-o, --out <path>", "write a minimal doc (meta + erd) to this path and validate it").option("--title <title>", "doc title with --out (default: prettified file name)").option("--id <id>", "block id (default: the file stem as a slug)").option("--force", "with --out, replace the file if it already exists").action(
+      async (file, opts) => {
+        const result = await runSyncSchema({
+          cwd: process.cwd(),
+          file,
+          dialect,
+          ...opts.out !== void 0 ? { out: opts.out } : {},
+          ...opts.title !== void 0 ? { title: opts.title } : {},
+          ...opts.id !== void 0 ? { id: opts.id } : {},
+          ...opts.force === true ? { force: true } : {}
+        });
+        if (result.message !== void 0) {
+          console.error(pc5.red(result.message));
+          exitCode = result.exitCode;
+          return;
+        }
+        if (result.fence !== void 0) {
+          process.stdout.write(result.fence);
+          if (isInteractive && copyToClipboard(result.fence)) {
+            console.log(pc5.green("\n\u2713 copied to clipboard"));
+          }
+        }
+        if (result.outPath !== void 0) {
+          console.log(
+            `${pc5.green("\u2713")} Wrote ${result.outPath} ${pc5.dim(`(erd \xB7 ${result.entities} entities \xB7 ${result.relations} relations)`)}`
+          );
+          const diags = result.check?.diagnostics ?? [];
+          if (diags.length === 0) {
+            console.log(`${pc5.green("\u2713")} chiltepin check: clean`);
+          } else {
+            for (const d of diags) {
+              const loc = d.line !== void 0 ? `${d.file}:${d.line}` : d.file;
+              const paint = d.level === "error" ? pc5.red : pc5.yellow;
+              console.error(paint(`${d.level}  ${loc}  ${d.code}  ${d.message}`));
+            }
+            console.error(pc5.dim(`chiltepin check: ${diags.length} diagnostic(s)`));
+          }
+        }
+        exitCode = result.exitCode;
+      }
+    );
+  };
+  schemaSync("sql", "SQL DDL (CREATE TABLE \u2026)");
+  schemaSync("dbml", "a DBML schema");
+  schemaSync("prisma", "a Prisma schema");
+  const single = (name, desc) => {
+    const cmd = program.command(`${name} <input>`).description(desc).option("-o, --output <path>", "output file path").option("-p, --preview", "render to a temp file and open it in the browser").option(
+      "--force",
+      `with -o, replace a file that is not already a .${name === "slides" ? "html" : name} file`
+    );
+    if (name === "html" || name === "pdf") {
+      cmd.option(
+        "--size <preset>",
+        "set the page width: sm (720 px) | md (960 px) | lg (1280 px) | xl (1600 px). Without this option, the page keeps the default width."
+      );
+    }
+    cmd.action(
+      async (input, opts) => {
+        let size;
+        if (opts.size !== void 0) {
+          size = parseExportSize(opts.size);
+          if (size === void 0) {
+            console.error(pc5.red(`Unknown size: ${opts.size}. Use one of: sm | md | lg | xl`));
+            exitCode = 2;
+            return;
+          }
+        }
+        const word = opts.preview === true ? "preview" : name;
+        if (isInteractive) {
+          console.log(actionBanner(word));
+          console.log(funLine(word) + "\n");
+        }
+        const result = await runSingle({
+          cwd: process.cwd(),
+          input,
+          format: name,
+          ...opts.output !== void 0 ? { output: opts.output } : {},
+          ...opts.preview === true ? { preview: true } : {},
+          ...size !== void 0 ? { size } : {},
+          ...opts.force === true ? { force: true } : {}
+        });
+        const verb = result.opened ? "Opened" : "Wrote";
+        console.log(`${pc5.green(verb)} ${result.output} ${pc5.dim(`(${result.bytes} bytes)`)}`);
+      }
+    );
+  };
+  single("html", "Render one document to a standalone HTML file");
+  single("slides", "Render one document to a self-contained slide deck");
+  single("pdf", "Render one document to a PDF (needs Chromium once)");
+  program.command("demo [family]").description(
+    `Render the built-in showcase and open it \u2014 all blocks or one family (${BLOCK_FAMILIES.map((f) => f.id).join(" | ")}); -s for a slide deck`
+  ).option("-s, --slides", "render as a slide deck").option("-o, --output <path>", "write the rendered file to a path (implies --no-open)").option("--no-open", "write the file but don't open it").option("--force", "with -o, replace a file that is not already an .html file").action(
+    async (familyArg, opts) => {
+      let family;
+      if (familyArg !== void 0) {
+        if (!isBlockFamily(familyArg)) {
+          const choices = BLOCK_FAMILIES.map((f) => f.id).join(" | ");
+          console.error(pc5.red(`Unknown family: ${familyArg}. Try one of: ${choices}`));
+          exitCode = 2;
+          return;
+        }
+        family = familyArg;
+      } else if (isInteractive) {
+        let picked;
+        const { waitUntilExit } = render(
+          /* @__PURE__ */ jsx(
+            DemoApp,
+            {
+              onPick: (p) => {
+                picked = p;
+              }
+            }
+          )
+        );
+        await waitUntilExit();
+        if (picked === void 0) return;
+        family = picked.family;
+      }
+      flourish("demo");
+      const result = await runDemo({
+        format: opts.slides === true ? "slides" : "html",
+        ...family !== void 0 ? { family } : {},
+        ...opts.output !== void 0 ? { output: resolve(process.cwd(), opts.output) } : { preview: opts.open !== false },
+        ...opts.force === true ? { force: true } : {}
+      });
+      const verb = result.opened ? "Opened" : "Wrote";
+      console.log(`${pc5.green(verb)} ${result.output} ${pc5.dim(`(${result.bytes} bytes)`)}`);
+    }
+  );
+  program.command("block [type]").description(
+    "Block reference \u2014 every type on one line, or one type's fields, enums, terse forms, and example"
+  ).option("--json", "emit the contract as JSON").action((typeArg, opts) => {
+    if (typeArg === void 0) {
+      process.stdout.write(blockIndex());
+      return;
+    }
+    const hit = resolveBlockName(typeArg);
+    if (hit === void 0) {
+      console.error(pc5.red(`Unknown block: ${typeArg}. Run \`chiltepin block\` to list them.`));
+      exitCode = 2;
+      return;
+    }
+    if (hit.alias !== void 0) {
+      console.error(
+        pc5.yellow(
+          `\`${hit.alias}\` is an old spelling of \`${hit.type}\` \u2014 both work; showing \`${hit.type}\`.`
+        )
+      );
+    }
+    process.stdout.write(blockReference(hit.type, opts.json === true));
+  });
+  program.command("skill", { hidden: true }).description(
+    "Print the Chiltepin authoring grammar as a copy-paste system prompt (for Copilot / custom GPTs / any AI)"
+  ).option("-o, --output <path>", "write the system prompt to a file instead of printing it").option(
+    "--raw",
+    "emit the raw skill file verbatim (with frontmatter) instead of the wrapped prompt"
+  ).option("--force", "with -o, replace the file if it already exists").action(async (opts) => {
+    const text = await systemPrompt({ ...opts.raw === true ? { raw: true } : {} });
+    if (opts.output !== void 0) {
+      await writeFileSafe(
+        resolve(process.cwd(), opts.output),
+        text,
+        opts.force === true ? { force: true } : {}
+      );
+      console.log(`${pc5.green("\u2713")} Wrote ${opts.output} ${pc5.dim(`(${text.length} chars)`)}`);
+      return;
+    }
+    if (isInteractive) {
+      console.log(
+        pc5.dim(
+          "# Chiltepin system prompt \u2014 paste into your tool's system / custom-instructions box\n"
+        )
+      );
+    }
+    console.log(text);
+    if (isInteractive && copyToClipboard(text)) {
+      console.log(pc5.green("\n\u2713 copied to clipboard") + pc5.dim(` (${text.length} chars)`));
+    }
+  });
+  for (const cmd of program.commands) {
+    const name = cmd.name();
+    if (commandExamples(name) !== "") {
+      cmd.addHelpText("after", () => commandExamples(name));
+    }
+  }
+  try {
+    await program.parseAsync(argv, { from: "node" });
+  } catch (err) {
+    const e = err;
+    if (e.code === "commander.helpDisplayed" || e.code === "commander.version") {
+      return 0;
+    }
+    if (e.code === "commander.help") return 0;
+    if (typeof e.exitCode === "number" && e.code?.startsWith("commander.")) {
+      return e.exitCode;
+    }
+    console.error(pc5.red(e.message ?? String(err)));
+    return 1;
+  }
+  return exitCode;
+}
+
+// src/bin.ts
+function flush(stream) {
+  if (stream.writableLength === 0) return Promise.resolve();
+  return new Promise((resolve13) => {
+    stream.write("", () => resolve13());
+    stream.once("error", () => resolve13());
+    stream.once("close", () => resolve13());
+  });
+}
+var code = await main(process.argv);
+await Promise.all([flush(process.stdout), flush(process.stderr)]);
+process.exit(code);
+//# sourceMappingURL=bin.js.map
+//# sourceMappingURL=bin.js.map