@anja.codes/vitakit 0.1.0 → 0.2.0

package/dist/shared/vitakit.CoWX2Z4R.mjs

@@ -0,0 +1,1554 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve, dirname, relative } from 'node:path';
+import { p as packageRoot } from './vitakit.DQ6PmGoL.mjs';
+import process from 'node:process';
+import { parseArgs } from 'node:util';
+import { createInterface } from 'node:readline/promises';
+
+function detectPackageManager(rootDir = process.cwd(), env = process.env) {
+  const userAgent = env.npm_config_user_agent;
+  if (userAgent) return userAgent.startsWith("npm/") ? "npm" : "pnpm";
+  return existsSync(join(rootDir, "package-lock.json")) && !existsSync(join(rootDir, "pnpm-lock.yaml")) ? "npm" : "pnpm";
+}
+function commands(packageManager = detectPackageManager()) {
+  const npm = packageManager === "npm";
+  const words = (...parts) => parts.filter(Boolean).join(" ");
+  return {
+    // npm would take options meant for the script (--tex-only) as its own.
+    script: (name, args) => npm ? words("npm run", name, args && `-- ${args}`) : words("pnpm", name, args),
+    bin: (name, args) => words(npm ? "npx" : "pnpm", name, args)
+  };
+}
+function aligned(rows, indent = "  ") {
+  const width = Math.max(...rows.map(([command]) => command.length)) + 2;
+  return rows.map(([command, comment]) => `${indent}${comment ? command.padEnd(width) + comment : command}`).join("\n");
+}
+
+class UsageError extends Error {
+  constructor(message, command) {
+    super(message);
+    this.command = command;
+    this.name = "UsageError";
+  }
+}
+class CommandError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CommandError";
+  }
+}
+const COMMON_OPTIONS = {
+  "help": { type: "boolean", short: "h", description: "this help" },
+  "root": { type: "string", value: "<dir>", description: "the project directory; found from the current one otherwise" },
+  "no-color": { type: "boolean", description: "plain output, also when NO_COLOR is set" }
+};
+const JSON_OPTION = { type: "boolean", description: "print one JSON result instead of text" };
+function optionsOf(spec) {
+  return { ...COMMON_OPTIONS, ...spec.json ? { json: JSON_OPTION } : {}, ...spec.options };
+}
+function parseCommandArgs(spec, argv) {
+  const options = optionsOf(spec);
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      strict: true,
+      options: Object.fromEntries(Object.entries(options).map(([name, option]) => [name, {
+        type: option.type,
+        ...option.multiple ? { multiple: true } : {},
+        ...option.short ? { short: option.short } : {}
+      }]))
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message.replace(/\. To specify a positional argument.*$/s, "") : String(error);
+    throw new UsageError(message.replace(/^Unknown option/, "unknown option"), spec.name);
+  }
+  if (parsed.values.help) return { positionals: parsed.positionals, values: parsed.values };
+  const { positionals } = parsed;
+  const variadic = spec.positionals.some((positional) => positional.variadic);
+  if (!variadic && positionals.length > spec.positionals.length) {
+    throw new UsageError(`unexpected argument "${positionals[spec.positionals.length]}"`, spec.name);
+  }
+  const missing = spec.positionals.find((positional, index) => positional.required && positionals[index] === void 0);
+  if (missing) throw new UsageError(`missing <${missing.name}>`, spec.name);
+  return { positionals, values: parsed.values };
+}
+function usageLine(spec, run) {
+  const positionals = spec.positionals.map((positional) => {
+    const name = `<${positional.name}>${positional.variadic ? "..." : ""}`;
+    return positional.required ? name : `[${name}]`;
+  });
+  return run.bin("vitakit", [spec.name, ...positionals, "[options]"].join(" "));
+}
+function commandHelp(spec, run) {
+  const options = optionsOf(spec);
+  const rows = Object.entries(options).map(([name, option]) => {
+    const flag = `${option.short ? `-${option.short}, ` : ""}--${name}${option.value ? ` ${option.value}` : ""}`;
+    return [flag, option.description];
+  });
+  const width = Math.max(...rows.map(([flag]) => flag.length));
+  return [
+    `vitakit ${spec.name} \u2014 ${spec.summary}`,
+    "",
+    "Usage",
+    ...(spec.usage ? spec.usage(run) : [usageLine(spec, run)]).map((line) => `  ${line}`),
+    "",
+    spec.help(run).trim(),
+    "",
+    "Options",
+    ...rows.map(([flag, description]) => `  ${flag.padEnd(width)}  ${description}`),
+    ""
+  ].join("\n");
+}
+
+const PACKAGE = "@anja.codes/vitakit";
+function dependsOnVitakit(dir) {
+  const file = join(dir, "package.json");
+  if (!existsSync(file)) return false;
+  try {
+    const manifest = JSON.parse(readFileSync(file, "utf8"));
+    return Boolean(manifest.dependencies?.[PACKAGE] ?? manifest.devDependencies?.[PACKAGE]);
+  } catch {
+    return false;
+  }
+}
+function findProjectRoot(start) {
+  let dir = resolve(start);
+  for (; ; ) {
+    if (dependsOnVitakit(dir)) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function resolveRoot(cwd, explicit) {
+  if (explicit !== void 0) {
+    const root2 = resolve(cwd, explicit);
+    if (!existsSync(root2)) throw new CommandError(`--root ${explicit}: no such directory`);
+    return root2;
+  }
+  const root = findProjectRoot(cwd);
+  if (!root) {
+    throw new CommandError(
+      `not inside a vitakit project: no package.json from here upwards depends on ${PACKAGE}.
+  Run this in your site's directory, or pass --root <dir>.`
+    );
+  }
+  return root;
+}
+
+const FOX = [
+  "                                      __..--''/\\ /\\",
+  "                                _.--''          V  \\",
+  "                           _.-''                    \\",
+  "                        .-'                         |",
+  "    _.--~~~~--..__    ,'            ,--.__      ^.  /",
+  " .-'              ``-.'             `-.   `-.      /",
+  "(_                    /                \\  ( (   . /",
+  "  ``--..____...--''  /             _.-' \\  \\ \\  `-'",
+  "                    |          _.-'      `-\\_)_)",
+  "                    |      _.-'",
+  "                    |  _.-'",
+  "                   / .'",
+  "                  / /",
+  "                 | |",
+  "                 | |",
+  "                 |_|"
+];
+const TEXT_ROW = 10;
+const TEXT_COLUMN = 37;
+const BANNER_WIDTH = 61;
+function banner(version, paint) {
+  const text = [paint.bold(`vitakit ${version}`), "", "one leap, two landings:", "your website and", "a typeset CV"];
+  return FOX.map((line, index) => {
+    const beside = text[index - TEXT_ROW];
+    return beside ? paint.fox(line.padEnd(TEXT_COLUMN)) + beside : paint.fox(line);
+  }).join("\n");
+}
+
+function processIo() {
+  return {
+    cwd: process.cwd(),
+    env: process.env,
+    out: (text) => process.stdout.write(text),
+    err: (text) => process.stderr.write(text),
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    tty: Boolean(process.stdout.isTTY),
+    ...process.stdout.columns ? { columns: process.stdout.columns } : {},
+    async ask(question) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        return await rl.question(question);
+      } finally {
+        rl.close();
+      }
+    }
+  };
+}
+function style(color) {
+  const wrap = (open, close) => (text) => color ? `\x1B[${open}m${text}\x1B[${close}m` : text;
+  return {
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    red: wrap(31, 39),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    orange: wrap("38;5;208", 39)
+  };
+}
+function table(rows, indent = "  ", gap = "   ") {
+  const visible = (text) => text.replace(/\u001B\[[\d;]+m/g, "").length;
+  const widths = [];
+  for (const row of rows) {
+    row.forEach((cell, index) => {
+      widths[index] = Math.max(widths[index] ?? 0, visible(cell));
+    });
+  }
+  return rows.map((row) => indent + row.map(
+    (cell, index) => index === row.length - 1 ? cell : cell + " ".repeat(widths[index] - visible(cell))
+  ).join(gap).trimEnd()).join("\n");
+}
+function block(label, rows, width = 10) {
+  const lines = table(rows, "", "   ").split("\n");
+  return lines.map((line, index) => `  ${(index === 0 ? label : "").padEnd(width)}${line}`).join("\n");
+}
+
+const asking = (context, values) => context.io.interactive && values.yes !== true;
+async function finish(context, ws, values, { before = [], after = [] }) {
+  const { io, style, root } = context;
+  const { applyPlan, confirmPlan, printPlan } = await import('../chunks/plan.mjs');
+  const plan = ws.plan();
+  const writes = plan.items.some((item) => item.kind === "create" || item.kind === "edit" || item.kind === "replace");
+  io.out("\n");
+  printPlan(io, style, plan);
+  if (before.length) io.out(`
+${before.join("\n")}
+`);
+  if (!writes) {
+    io.out("\nNothing to write.\n");
+    if (after.length) io.out(`
+${after.join("\n")}
+`);
+    return 0;
+  }
+  if (values["dry-run"]) {
+    io.out(`
+${style.dim("Dry run: nothing was written.")}
+`);
+    return 0;
+  }
+  if (!await confirmPlan(io, plan, values.yes === true)) return 1;
+  await applyPlan(root, plan);
+  io.out(`
+${style.green("\u2713")} done.${after.length ? `
+
+${after.join("\n")}` : ""}
+`);
+  return 0;
+}
+
+const SECTION_OPTIONS = ["page", "document", "title", "after", "like"];
+const FIELD_OPTIONS = ["type", "several", "required", "choice"];
+const PAGE_OPTIONS = ["title", "no-menu"];
+const COMMON = ["help", "root", "no-color", "dry-run", "yes"];
+function onlyOptions(kind, values, allowed) {
+  const wrong = Object.keys(values).filter((name) => values[name] !== void 0 && ![...COMMON, ...allowed].includes(name));
+  if (wrong.length) throw new UsageError(`--${wrong[0]} does not apply to add ${kind}`, "add");
+}
+const strings$1 = (value) => (Array.isArray(value) ? value : value === void 0 ? [] : [value]).map(String);
+async function planSchema$1(context, ws, inv, id, section, entries, values) {
+  const { matchingSchemas, schemaOwner, sharedSchemaModule } = await import('../chunks/authoring.mjs');
+  const { draftSchema } = await import('../chunks/draft.mjs');
+  const { describeSection } = await import('../chunks/fields.mjs');
+  const { confirm } = await import('../chunks/prompt.mjs');
+  const notes = [];
+  let like = values.like;
+  if (like) {
+    if (!await schemaOwner(inv, like)) throw new CommandError(`--like ${like}: no section "${like}" with a schema`);
+  } else if (section && entries.length) {
+    const matches = await matchingSchemas(context.root, inv, id, entries);
+    if (matches.length && asking(context, values)) {
+      if (await confirm(context.io, `
+The entries of ${section.where} fit the schema of ${matches[0]}. Use the same schema?`)) like = matches[0];
+    } else if (matches.length) {
+      notes.push(`Its entries fit the schema of ${matches[0]}: --like ${matches[0]} would share it.`);
+    }
+  }
+  const path = `schemas/${id}.ts`;
+  if (like) {
+    const other = await schemaOwner(inv, like);
+    ws.create(path, sharedSchemaModule(id, other), `the same fields as ${like}`, { show: true });
+    return { ...other.fields ? { fields: other.fields } : {}, changes: [], notes };
+  }
+  const file = section?.where ?? `content/${id}.yml`;
+  const draft = draftSchema(id, entries, { file });
+  ws.create(path, draft.source, section ? `drafted from the ${entries.length} ${entries.length === 1 ? "entry" : "entries"} in ${file}; check its comments` : "date, title and note; change it to fit", { show: true });
+  return { fields: describeSection(draft.schema) ?? [], changes: draft.changes, notes };
+}
+async function addSection(context, id, values) {
+  const { io, run, root } = context;
+  const { sectionNameProblem } = await import('../chunks/sections.mjs');
+  const problem = sectionNameProblem(id);
+  if (problem) throw new CommandError(problem);
+  if (id === "publications") throw new CommandError("publications come from content/publications.bib; `vitakit customize publications` changes their groups");
+  const { inventory } = await import('../chunks/inventory.mjs');
+  const { Workspace } = await import('../chunks/plan.mjs');
+  const authoring = await import('../chunks/authoring.mjs');
+  const { schemas } = await import('../chunks/schemas.mjs');
+  const { describeSection } = await import('../chunks/fields.mjs');
+  const { countsText } = await Promise.resolve().then(function () { return describe; });
+  const prompt = await import('../chunks/prompt.mjs');
+  const inv = await inventory(root);
+  const ws = new Workspace(root);
+  const section = inv.sections.find((candidate) => candidate.id === id);
+  const builtIn = Object.hasOwn(schemas, id);
+  const interactive = asking(context, values);
+  let entries = [];
+  let schemaResult = { changes: [], notes: [] };
+  if (section) {
+    try {
+      entries = authoring.rawEntries(await ws.read(section.where) ?? "");
+    } catch (error) {
+      throw new CommandError(`${section.where}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    ws.keep(section.where, countsText(section) || "your entries");
+  }
+  if (section?.schema.origin === "local") {
+    ws.keep(section.schema.file, section.schema.sharedWith ? `the schema of ${section.schema.sharedWith}` : "your schema");
+    schemaResult = { ...section.fields ? { fields: section.fields } : {}, changes: [], notes: [] };
+  } else if (builtIn) {
+    schemaResult = { fields: describeSection(schemas[id]) ?? [], changes: [], notes: [] };
+  } else {
+    if (!section) {
+      const like = values.like;
+      const other = like ? await authoring.schemaOwner(inv, like) : void 0;
+      if (other?.fields) ws.create(`content/${id}.yml`, authoring.dataExample(id, other.fields), "empty for now, with an example entry as a comment");
+      else {
+        ws.create(`content/${id}.yml`, authoring.dataStarter(id), "one example entry, to replace");
+        entries = authoring.STARTER_ENTRIES;
+      }
+    }
+    schemaResult = await planSchema$1(context, ws, inv, id, section, entries, values);
+  }
+  if (!section && builtIn) {
+    ws.create(`content/${id}.yml`, authoring.dataExample(id, schemaResult.fields ?? []), `empty for now; vitakit already knows the ${id} fields`);
+  }
+  if (section && entries.length && (section.schema.origin === "built-in" || section.schema.origin === "local")) {
+    const missing = await authoring.planMissingFields(root, ws, section, entries);
+    if (missing.note) schemaResult.notes.push(missing.note);
+    if (missing.fields.length) {
+      const added = missing.fields.map((name) => ({ path: name, type: "custom", optional: true, several: false }));
+      schemaResult = { ...schemaResult, fields: [...schemaResult.fields ?? [], ...added], changes: missing.changes };
+    }
+  }
+  const { webPlacementsOf, pdfPlacementsOf } = await Promise.resolve().then(function () { return describe; });
+  const shownOn = new Set(webPlacementsOf(inv, id).map((placement) => placement.file));
+  const inDocuments = new Set(pdfPlacementsOf(inv, id).map((placement) => placement.document));
+  const vuePages = inv.pages.filter((page) => page.vue);
+  let title = values.title;
+  const after = values.after;
+  const pages = strings$1(values.page).map((route) => ({ route: route.endsWith("/") ? route : `${route}/`, ...after ? { after } : {} }));
+  const documents = strings$1(values.document).map((name) => ({ name, ...after ? { after } : {} }));
+  if (interactive && !pages.length && !documents.length) {
+    const candidates = vuePages.filter((page) => !shownOn.has(page.vue));
+    const newRoute = `/${id}/`;
+    const choices = [
+      ...candidates.map((page) => ({ label: `${page.route}  (${page.vue})`, value: page.route })),
+      ...inv.pages.some((page) => page.route === newRoute) ? [] : [{ label: `a new page, ${newRoute}`, value: newRoute }],
+      { label: shownOn.size ? `nowhere else (already on ${[...shownOn].join(", ")})` : "not on the website, for now", value: "" }
+    ];
+    const preferred = Math.max(0, choices.findIndex((choice) => choice.value === "/cv/"));
+    const route = await prompt.choose(io, `Show ${id} on which page of your website?`, choices, preferred);
+    if (route) {
+      const existing = inv.web.placements.filter((placement) => placement.route === route && placement.component !== "code");
+      let position;
+      if (existing.length) {
+        position = await prompt.choose(io, "After which section?", [
+          ...existing.map((placement) => ({ label: placement.section, value: placement.section }))
+        ], existing.length - 1);
+      }
+      pages.push({ route, ...position ? { after: position } : {} });
+    }
+    for (const document of inv.documents.filter((candidate) => !inDocuments.has(candidate.name))) {
+      if (!await prompt.confirm(io, `
+Include ${id} in the PDF ${document.tex}?`, true)) continue;
+      const existing = document.placements;
+      const position = existing.length ? await prompt.choose(io, "After which section?", existing.map((placement) => ({ label: placement.section, value: placement.section })), existing.length - 1) : void 0;
+      documents.push({ name: document.name, ...position ? { after: position } : {} });
+    }
+    if ((pages.length || documents.length) && title === void 0) title = await prompt.input(io, "\nHeading", prompt.headingFor(id));
+  }
+  title ??= prompt.headingFor(id);
+  for (const page of pages) {
+    let path = vuePages.find((candidate) => candidate.route === page.route)?.vue;
+    if (!path) {
+      const name = /^\/([a-z0-9]+(?:-[a-z0-9]+)*)\/$/.exec(page.route)?.[1];
+      if (!name) throw new CommandError(`--page ${page.route}: no Vue page has this route; a new page needs a route like /talks/`);
+      path = await authoring.planCreatePage(ws, inv, name, { title: page.route === `/${id}/` ? title : prompt.headingFor(name), menu: true });
+    }
+    await authoring.planPlaceOnPage(ws, inv, path, { id, title, ...page.after ? { after: page.after } : {} });
+  }
+  for (const document of documents) {
+    if (!inv.documents.some((candidate) => candidate.name === document.name)) {
+      throw new CommandError(`--document ${document.name}: no cv-tex/${document.name}.tex; the documents are ${inv.documents.map((candidate) => candidate.name).join(", ") || "(none)"}`);
+    }
+    await authoring.planPlaceInDocument(ws, document.name, { id, title, ...document.after ? { after: document.after } : {} });
+  }
+  const before = [...schemaResult.notes];
+  if (schemaResult.changes.length) {
+    before.push(`The drafted schema does not accept every entry yet. In ${section?.where ?? `content/${id}.yml`}, change:`);
+    before.push(...schemaResult.changes.slice(0, 12).map((change) => `  ${change}`));
+    if (schemaResult.changes.length > 12) before.push(`  \u2026 and ${schemaResult.changes.length - 12} more`);
+  }
+  if (!pages.length && !shownOn.size) before.push(`Not on the website: \`${run.bin("vitakit", `add section ${id} --page /cv/`)}\` adds it to a page later.`);
+  if (!documents.length && !inDocuments.size && inv.documents.length) before.push(`Not in a PDF: \`${run.bin("vitakit", `add section ${id} --document ${inv.documents[0].name}`)}\` adds it later.`);
+  const next = [];
+  if (!section) next.push(`Write your entries in content/${id}.yml.`);
+  if (schemaResult.changes.length) next.push(`Then check them: \`${run.bin("vitakit", `validate ${id}`)}\``);
+  const hidden = authoring.fieldsNotShown(schemaResult.fields);
+  if (hidden.length && (pages.length || documents.length || shownOn.size || inDocuments.size)) {
+    next.push(`Accepted, but not shown by the standard layout: ${hidden.join(", ")}. To show them: \`${run.bin("vitakit", `customize ${id} --web --pdf ${hidden.map((name) => `--field ${name}`).join(" ")}`)}\``);
+  }
+  return finish(context, ws, values, { before, after: next });
+}
+async function addField(context, id, name, values) {
+  const { io, run, root } = context;
+  const { inventory } = await import('../chunks/inventory.mjs');
+  const { Workspace } = await import('../chunks/plan.mjs');
+  const authoring = await import('../chunks/authoring.mjs');
+  const { schemas } = await import('../chunks/schemas.mjs');
+  const { describeSection, FIELD_TYPE_NAMES } = await import('../chunks/fields.mjs');
+  const prompt = await import('../chunks/prompt.mjs');
+  if (!/^[A-Za-z_][\w-]*$/.test(name)) throw new CommandError(`"${name}" cannot be a field name; use letters and digits, like evaluationScore`);
+  if (name === "visibility" || name === "id") throw new CommandError(`"${name}" is a field every entry has already`);
+  const inv = await inventory(root);
+  let section = inv.sections.find((candidate) => candidate.id === id);
+  const builtIn = Object.hasOwn(schemas, id);
+  if (!section && builtIn) {
+    section = { id, where: `content/${id}.yml`, schema: { origin: "built-in" }, fields: describeSection(schemas[id]) ?? [], problems: [] };
+  }
+  if (!section) throw new CommandError(`no section called "${id}"; the sections are ${inv.sections.map((candidate) => candidate.id).join(", ") || "(none)"}`);
+  if (section.schema.origin === "none") throw new CommandError(`${id} has no schema yet; \`${run.bin("vitakit", `add section ${id}`)}\` drafts one from its entries`);
+  if (section.schema.sharedWith) {
+    throw new CommandError(`${id} uses the schema of ${section.schema.sharedWith} (schemas/${id}.ts). Add the field there, for both: \`${run.bin("vitakit", `add field ${section.schema.sharedWith} ${name}`)}\``);
+  }
+  const existing = section.fields?.find((field) => field.path === name);
+  if (existing) {
+    const { fieldSummary } = await import('../chunks/fields.mjs');
+    io.out(`${id} has a field ${name} already: ${fieldSummary(existing)}. Nothing to do.
+`);
+    return 0;
+  }
+  const interactive = asking(context, values);
+  let type = values.type;
+  const known = authoring.FIELD_TYPES.map((entry) => entry.type);
+  if (type !== void 0 && !known.includes(type)) throw new UsageError(`--type ${type}: one of ${known.join(", ")}`, "add");
+  if (type === void 0) {
+    if (!interactive) throw new UsageError(`which type? --type ${known.join("|")}`, "add");
+    type = await prompt.choose(io, `What kind of value is "${name}"?`, authoring.FIELD_TYPES.map((entry) => ({ label: entry.label, value: entry.type })));
+  }
+  let choices = strings$1(values.choice);
+  if (type === "choice" && !choices.length) {
+    if (!interactive) throw new UsageError("a choice needs its values: --choice <value>, once per value", "add");
+    choices = (await prompt.input(io, "The allowed values, separated by commas")).split(",").map((choice) => choice.trim()).filter(Boolean);
+  }
+  const several = values.several === true || values.several === void 0 && interactive && await prompt.confirm(io, "Can an entry have several?", false);
+  const required = values.required === true || values.required === void 0 && interactive && await prompt.confirm(io, "Should every entry have it?", false);
+  const ws = new Workspace(root);
+  const outcome = await authoring.planAddField(ws, section, name, { type, several, required, choices });
+  const before = [];
+  const entries = section.entries ?? 0;
+  if (required && entries) before.push(`Required: the ${entries} entries in ${section.where} need it before they are valid again.`);
+  const example = authoring.exampleValue({ type, several, choices });
+  const after = [
+    `Next: give entries in ${section.where} the new field, e.g.`,
+    `    ${name}: ${example}`,
+    ...outcome === "pasted" ? [] : [`It is accepted now, not shown yet (${FIELD_TYPE_NAMES[type]}). To show it: \`${run.bin("vitakit", `customize ${id} --web --pdf --field ${name}`)}\``]
+  ];
+  return finish(context, ws, values, { before, after });
+}
+async function addPage(context, name, values) {
+  const { io, run, root } = context;
+  const { inventory } = await import('../chunks/inventory.mjs');
+  const { Workspace } = await import('../chunks/plan.mjs');
+  const authoring = await import('../chunks/authoring.mjs');
+  const prompt = await import('../chunks/prompt.mjs');
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) throw new CommandError(`"${name}" must be lowercase kebab-case, e.g. research-interests; it becomes the address /${name}/`);
+  const inv = await inventory(root);
+  const interactive = asking(context, values);
+  const title = values.title ?? (interactive ? await prompt.input(io, "Title", prompt.headingFor(name)) : prompt.headingFor(name));
+  const menu = values["no-menu"] !== true && (!interactive || await prompt.confirm(io, "Add it to the menu?", true));
+  const ws = new Workspace(root);
+  await authoring.planCreatePage(ws, inv, name, { title, menu });
+  return finish(context, ws, values, {
+    after: [
+      `The page is /${name}/. Write its text in content/pages/${name}.md;`,
+      `add sections to it with \`${run.bin("vitakit", `add section <name> --page /${name}/`)}\`.`
+    ]
+  });
+}
+const add = {
+  name: "add",
+  summary: "add a section, a field of a section, or a website page",
+  positionals: [{ name: "what", required: true }, { name: "name" }, { name: "field" }],
+  options: {
+    "page": { type: "string", multiple: true, value: "<route>", description: "section: show it on this page, e.g. /cv/ (repeatable)" },
+    "document": { type: "string", multiple: true, value: "<name>", description: "section: include it in this PDF document, e.g. cv (repeatable)" },
+    "after": { type: "string", value: "<section>", description: "section: place it after this section" },
+    "title": { type: "string", value: "<text>", description: "section: its heading; page: its title" },
+    "like": { type: "string", value: "<section>", description: "section: use the schema of another section" },
+    "type": { type: "string", value: "<type>", description: "field: text, formatted-text, number, yes-no, date, web-address, link or choice" },
+    "several": { type: "boolean", description: "field: an entry may have a list of values" },
+    "required": { type: "boolean", description: "field: every entry must have it" },
+    "choice": { type: "string", multiple: true, value: "<value>", description: "field: an allowed value of a choice (repeatable)" },
+    "no-menu": { type: "boolean", description: "page: do not add it to the menu" },
+    "dry-run": { type: "boolean", description: "show what would be written, write nothing" },
+    "yes": { type: "boolean", description: "ask nothing: use the options given and write" }
+  },
+  project: true,
+  usage: (run) => [
+    run.bin("vitakit", "add section <name> [options]"),
+    run.bin("vitakit", "add field <section> <name> [options]"),
+    run.bin("vitakit", "add page <name> [options]")
+  ],
+  help: (run) => `
+A section is a file content/<name>.yml. \`add section\` creates what is missing:
+the file, a schema drafted from your entries (or one of another section, with
+--like), and its place on a website page and in a PDF document -- one line in
+each, after the section you choose.
+
+  ${run.bin("vitakit", "add section grants")}
+  ${run.bin("vitakit", "add section grants --page /cv/ --document cv --after education --yes")}
+  ${run.bin("vitakit", "add section talks-public --like talks")}
+
+\`add field\` lets a section accept one more field. For a built-in section it
+creates schemas/<section>.ts, which keeps all of vitakit's fields:
+
+  ${run.bin("vitakit", "add field teaching evaluation --type number")}
+  ${run.bin("vitakit", "add field talks audience --type choice --choice school --choice public")}
+
+\`add page\` creates a website page that can show sections, with its text in
+content/pages/<name>.md, and adds it to the menu:
+
+  ${run.bin("vitakit", "add page talks --title Talks")}
+
+Everything is shown before it is written, and asked; nothing existing is
+replaced. A file that cannot be changed safely gets a line to paste instead.`,
+  async run(context, { positionals, values }) {
+    const [what, name, field] = positionals;
+    if (what === "section" || what === "page") {
+      if (!name) throw new UsageError(`missing <name>: \`add ${what} <name>\``, "add");
+      if (field !== void 0) throw new UsageError(`unexpected argument "${field}"`, "add");
+      onlyOptions(what, values, what === "section" ? SECTION_OPTIONS : PAGE_OPTIONS);
+      return what === "section" ? addSection(context, name, values) : addPage(context, name, values);
+    }
+    if (what === "field") {
+      if (!name || !field) throw new UsageError("`add field <section> <name>`, e.g. add field teaching evaluation", "add");
+      onlyOptions(what, values, FIELD_OPTIONS);
+      return addField(context, name, field, values);
+    }
+    throw new UsageError(`add what? \`add section <name>\`, \`add field <section> <name>\` or \`add page <name>\`${what ? `, not "${what}"` : ""}`, "add");
+  }
+};
+
+const strings = (value) => (Array.isArray(value) ? value : value === void 0 ? [] : [value]).map(String);
+const pascal = (id) => id.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+async function planSchema(context, ws, inv, id, values, notes) {
+  const { run } = context;
+  const { extensionModule } = await import('../chunks/authoring.mjs');
+  const { builtinSchemaSource } = await import('../chunks/schema-source.mjs');
+  const { schemas } = await import('../chunks/schemas.mjs');
+  const path = `schemas/${id}.ts`;
+  if (id === "publications") {
+    if (ws.exists(path)) {
+      notes.after.push(`${path} is yours already: its groups, badges and fields decide how content/publications.bib is grouped and linked.`);
+      return;
+    }
+    ws.create(path, await builtinSchemaSource("publications"), "vitakit's publication groups, badges and fields, to change");
+    notes.before.push("The website, `vitakit verify` and the PDF all read it from now on.");
+    notes.after.push(`Edit ${path}: change groups, add badges, pass on BibTeX fields. Check it: \`${run.bin("vitakit", "validate")}\``);
+    return;
+  }
+  const section = inv.sections.find((candidate) => candidate.id === id);
+  if (section?.schema.origin === "local") {
+    notes.after.push(`${path} is yours already${section.schema.sharedWith ? `; it uses the schema of ${section.schema.sharedWith}` : ""}. Edit it, or add a field with \`${run.bin("vitakit", `add field ${id} <name>`)}\`.`);
+    return;
+  }
+  if (!Object.hasOwn(schemas, id)) {
+    throw new CommandError(`${id} has no schema yet; \`${run.bin("vitakit", `add section ${id}`)}\` drafts one from its entries`);
+  }
+  if (values.copy) {
+    ws.create(path, await builtinSchemaSource(id), `vitakit's complete ${id} definition, yours from now on`);
+    notes.before.push(
+      "A complete copy: change or remove any rule. Improvements to vitakit's",
+      `${id} fields will not reach you; without --copy, you would keep them and only add.`
+    );
+  } else {
+    ws.create(path, extensionModule(id, [], []), `keeps vitakit's ${id} fields; yours go below them`, { show: true });
+    notes.before.push(
+      `Your fields are added to vitakit's, which stay as they are and keep improving.`,
+      `To remove or rewrite built-in rules instead: \`${run.bin("vitakit", `customize ${id} --schema --copy`)}\``
+    );
+  }
+  notes.after.push(`Add a field: \`${run.bin("vitakit", `add field ${id} <name>`)}\`. Check: \`${run.bin("vitakit", `validate ${id}`)}\``);
+}
+async function planWeb(context, ws, inv, section, fields, list, values, notes) {
+  const { io, run } = context;
+  const { entryComponent, listComponent } = await import('../chunks/snippets.mjs');
+  const { useComponentForSection } = await import('../chunks/vue.mjs').then(function (n) { return n.v; });
+  const { planPlaceOnPage } = await import('../chunks/authoring.mjs');
+  const prompt = await import('../chunks/prompt.mjs');
+  const id = section.id;
+  const interactive = asking(context, values);
+  const current = [...new Set(inv.web.placements.filter((placement) => placement.section === id && inv.web.components.has(placement.component)).map((placement) => placement.component))];
+  if (current.length === 1 && !values.use && !values.component && !values.force && values.list === void 0) {
+    const { webFieldSnippet } = await import('../chunks/snippets.mjs');
+    const file = inv.web.components.get(current[0]);
+    const existing = await ws.read(file) ?? "";
+    const missing = fields.map((field) => webFieldSnippet(field)).filter((snippet) => !existing.includes(snippet.markup));
+    if (!fields.length) notes.after.push(`${id} is shown by ${file} already, which is yours. --force starts over, keeping it as a backup.`);
+    else if (!missing.length) ws.keep(file, `shows ${fields.map((field) => field.path).join(", ")} already`);
+    else {
+      const imports = [...new Set(missing.flatMap((snippet) => snippet.imports))];
+      ws.paste(
+        file,
+        [...missing.map((snippet) => snippet.markup), ...imports.length ? ["", `import { ${imports.join(", ")} } from '@anja.codes/vitakit/shared'`] : []].join("\n"),
+        "is yours already; add these lines where the entry's lines are, e.g. in its #note slot"
+      );
+    }
+    return;
+  }
+  let component = values.use;
+  if (component) {
+    if (!inv.web.components.has(component)) {
+      throw new CommandError(`--use ${component}: no app/components/${component}.vue; the components are ${[...inv.web.components.keys()].join(", ") || "(none)"}`);
+    }
+  } else {
+    const fallback = `${pascal(id)}${list ? "List" : "Section"}`;
+    component = values.component ?? (interactive ? await prompt.input(io, "Name of the component", fallback) : fallback);
+    if (!/^[A-Z][A-Za-z0-9]*$/.test(component)) throw new CommandError(`"${component}" cannot be a component name; use PascalCase, like TalkList`);
+    if (component.startsWith("Vita")) throw new CommandError(`"${component}" would replace vitakit's own component; choose a name that does not start with Vita`);
+    const path = `app/components/${component}.vue`;
+    const region = values.region ?? "note";
+    if (region !== "note" && region !== "meta") throw new UsageError("--region note or --region meta", "customize");
+    let groupBy = values["group-by"];
+    if (list && groupBy === void 0 && interactive) {
+      groupBy = await prompt.input(io, "Group the entries by a field, e.g. term? (Enter for no groups)") || void 0;
+    }
+    if (groupBy && !section.fields?.some((field) => field.path === groupBy)) {
+      throw new CommandError(`--group-by ${groupBy}: ${id} has no such field; its fields are ${section.fields?.map((field) => field.path).join(", ")}`);
+    }
+    const source = list ? listComponent(id, component, section.fields ?? [], groupBy) : entryComponent(id, component, fields, region);
+    const reason = list ? `${id} as your own list${groupBy ? `, grouped by ${groupBy}` : ""}, with a line for each field` : `${id} through VitaSection, with your own ${region} line${fields.length ? ` showing ${fields.map((field) => field.path).join(", ")}` : ""}`;
+    if (ws.exists(path)) {
+      if (!values.force) throw new CommandError(`${path} exists. \`--use ${component}\` shows ${id} with it; --force replaces it, keeping yours as a backup.`);
+      ws.replace(path, source, `${reason}; yours is kept next to it as a .backup`, { show: true });
+    } else {
+      ws.create(path, source, reason, { show: true });
+    }
+  }
+  const placements = inv.web.placements.filter((placement) => placement.section === id);
+  const files = [...new Set(placements.filter((placement) => placement.component !== "code").map((placement) => placement.file))];
+  const known = [...inv.web.components.keys(), component];
+  for (const file of files) {
+    const source = await ws.read(file);
+    const result = useComponentForSection(source, id, component, known);
+    if (result.ok && result.value.changed.length) await ws.edit(file, result.value.source, `shows ${id} with ${component}`);
+    else if (result.ok) ws.keep(file, `shows ${id} with ${component} already`);
+    else ws.paste(file, `<${component} id="${id}" />`, `cannot be changed safely (${result.reason}); use this where ${id} should appear`);
+  }
+  for (const placement of placements.filter((candidate) => candidate.component === "code")) {
+    notes.before.push(`${placement.file}:${placement.line} uses useSection('${id}') in code; that is left as it is.`);
+  }
+  let routes = strings(values.page);
+  if (!files.length && !routes.length && interactive) {
+    const pages = inv.pages.filter((page) => page.vue);
+    const route = await prompt.choose(io, `${id} is on no page yet. Show it on which page?`, [
+      ...pages.map((page) => ({ label: `${page.route}  (${page.vue})`, value: page.route })),
+      { label: "not now", value: "" }
+    ], Math.max(0, pages.findIndex((page) => page.route === "/cv/")));
+    if (route) routes = [route];
+  }
+  for (const route of routes) {
+    const page = inv.pages.find((candidate) => candidate.route === (route.endsWith("/") ? route : `${route}/`));
+    if (!page?.vue) throw new CommandError(`--page ${route}: no Vue page has this route`);
+    await planPlaceOnPage(ws, inv, page.vue, { id, title: prompt.headingFor(id), component });
+  }
+  if (!files.length && !routes.length) {
+    notes.before.push(`${id} is on no page. Show it with <${component} id="${id}" title="${prompt.headingFor(id)}" />, or --page /cv/.`);
+  }
+  notes.after.push(`Edit app/components/${component}.vue; \`${run.script("dev")}\` shows every change as you save.`);
+}
+async function planPdf(context, ws, inv, id, fields, values, notes) {
+  const { io, run, root } = context;
+  const { resolveTemplate } = await import('../chunks/emit.mjs');
+  const { etaFieldSnippet } = await import('../chunks/snippets.mjs');
+  const { addToEntryLoop } = await import('../chunks/eta.mjs');
+  const prompt = await import('../chunks/prompt.mjs');
+  const templateDir = join(root, "cv-tex", "templates");
+  const path = `cv-tex/templates/${id}.eta`;
+  const lines = fields.map((field) => etaFieldSnippet(field));
+  if (!inv.documents.length) throw new CommandError("there are no PDF documents in cv-tex/");
+  if (id === "publications" && fields.length) throw new CommandError("publications are formatted by biblatex; --field does not apply");
+  let from = values.from;
+  if (!from && !ws.exists(path) && asking(context, values)) {
+    const section = inv.sections.find((candidate) => candidate.id === id);
+    const relatives = inv.sections.filter((candidate) => candidate.id !== id && (candidate.id === section?.schema.sharedWith || candidate.schema.sharedWith === id || section?.schema.sharedWith !== void 0 && candidate.schema.sharedWith === section.schema.sharedWith));
+    const withTemplate = relatives.find((candidate) => ws.exists(`cv-tex/templates/${candidate.id}.eta`));
+    if (withTemplate && await prompt.confirm(io, `
+${id} has the fields of ${withTemplate.id}, which has its own template. Start from a copy of it?`)) from = withTemplate.id;
+  }
+  if (ws.exists(path) && !values.force) {
+    const existing = await ws.read(path) ?? "";
+    const missing = lines.filter((line) => !existing.includes(line));
+    if (lines.length && !missing.length) {
+      ws.keep(path, `shows ${fields.map((field) => field.path).join(", ")} already`);
+      return;
+    }
+    if (!missing.length) {
+      notes.after.push(`${path} is yours already. \`${run.bin("vitakit", `explain ${id} --field <name>`)}\` shows lines to add for a field; --force starts over, keeping yours as a backup.`);
+      return;
+    }
+    ws.paste(path, missing.join("\n"), "is yours already; add these lines inside its loop over the entries, where the notes are");
+    return;
+  }
+  let source;
+  let reason;
+  if (from) {
+    const copied = await ws.read(`cv-tex/templates/${from}.eta`);
+    if (copied === void 0) throw new CommandError(`--from ${from}: there is no cv-tex/templates/${from}.eta to copy`);
+    source = `<%/* A copy of ${from}.eta: the two are separate files from now on. */%>
+${copied}`;
+    reason = `a copy of your ${from}.eta`;
+  } else {
+    const template = await resolveTemplate(id, templateDir, { exclude: join(templateDir, `${id}.eta`) });
+    source = template.source;
+    reason = template.origin === "local" ? "a copy of your _generic.eta" : template.generic ? "a copy of vitakit's generic template" : `a copy of vitakit's ${id}.eta`;
+  }
+  if (lines.length) {
+    const added = addToEntryLoop(source, lines);
+    if (added.ok) {
+      source = added.value;
+      reason += `, with ${fields.map((field) => field.path).join(", ")}`;
+    } else {
+      ws.paste(path, lines.join("\n"), `add these lines inside the loop over the entries (${added.reason})`);
+    }
+  }
+  if (ws.exists(path)) ws.replace(path, source, `${reason}; yours is kept next to it as a .backup`, { show: true });
+  else ws.create(path, source, reason, { show: true });
+  const included = inv.documents.filter((document) => document.placements.some((placement) => placement.section === id));
+  if (!included.length) notes.before.push(`No PDF document includes ${id} yet: \`${run.bin("vitakit", `add section ${id} --document ${inv.documents[0].name}`)}\``);
+  if (id === "publications") {
+    notes.before.push("This template groups the references; how each one is formatted is up to biblatex, in cv-tex/preamble.tex.");
+  }
+  notes.after.push(`Edit ${path}; \`${run.bin("vitakit", `validate ${id}`)}\` checks it without LaTeX, \`${run.bin("vitakit", "pdf")}\` builds.`);
+}
+async function selectFields(context, section, values, ask) {
+  const all = section?.fields ?? [];
+  const requested = strings(values.field);
+  const unknown = requested.filter((name) => !all.some((field) => field.path === name));
+  if (unknown.length) {
+    throw new CommandError(`${section?.id ?? "this section"} has no field ${unknown.join(", ")}; its fields are ${all.map((field) => field.path).join(", ") || "(unknown)"}`);
+  }
+  if (requested.length || !ask || !all.length) return all.filter((field) => requested.includes(field.path));
+  const { fieldsNotShown } = await import('../chunks/authoring.mjs');
+  const { input } = await import('../chunks/prompt.mjs');
+  const hidden = fieldsNotShown(all);
+  context.io.out(`
+Fields of ${section.id}: ${all.map((field) => field.path).join(", ")}${hidden.length ? `
+Not shown by the standard layout: ${hidden.join(", ")}` : ""}
+`);
+  const answer = await input(context.io, "Which fields should it show? (separated by commas, - for none)", hidden.join(", ") || "-");
+  const chosen = answer === "-" ? [] : answer.split(",").map((name) => name.trim()).filter(Boolean);
+  const missing = chosen.filter((name) => !all.some((field) => field.path === name));
+  if (missing.length) throw new CommandError(`${section.id} has no field ${missing.join(", ")}`);
+  return all.filter((field) => chosen.includes(field.path));
+}
+const customize = {
+  name: "customize",
+  summary: "make one section yours: how it looks on the website and in the PDF, what it may contain",
+  positionals: [{ name: "section", required: true }],
+  options: {
+    "web": { type: "boolean", description: "how it looks on the website: a component of your own" },
+    "pdf": { type: "boolean", description: "how it looks in the PDF: cv-tex/templates/<section>.eta" },
+    "schema": { type: "boolean", description: "what its entries may contain: schemas/<section>.ts" },
+    "field": { type: "string", multiple: true, value: "<name>", description: "show this field (repeatable)" },
+    "list": { type: "boolean", description: "web: your own list markup, for grouping or numbering" },
+    "group-by": { type: "string", value: "<field>", description: "web, with --list: one group per value of this field, e.g. term" },
+    "region": { type: "string", value: "note|meta", description: "web: the line of each entry the fields go on (note)" },
+    "component": { type: "string", value: "<Name>", description: "web: the component's name; <Section>Section by default" },
+    "use": { type: "string", value: "<Name>", description: "web: show it with a component you have already" },
+    "page": { type: "string", multiple: true, value: "<route>", description: "web: also show it on this page" },
+    "from": { type: "string", value: "<section>", description: "pdf: start from a copy of that section's template" },
+    "copy": { type: "boolean", description: "schema: a complete copy of a built-in schema, instead of additions" },
+    "force": { type: "boolean", description: "replace your component or template; yours is kept as a backup" },
+    "dry-run": { type: "boolean", description: "show what would be written, write nothing" },
+    "yes": { type: "boolean", description: "ask nothing: use the options given and write" }
+  },
+  project: true,
+  help: (run) => `
+  ${run.bin("vitakit", "customize grants")}                              asks what to change
+  ${run.bin("vitakit", "customize grants --web --pdf --field amount")}   show a field in both
+  ${run.bin("vitakit", "customize talks --web --list --component TalkList")}
+  ${run.bin("vitakit", "customize talks-public --web --use TalkList")}   reuse a component
+  ${run.bin("vitakit", "customize teaching --schema")}                   add fields to a built-in section
+  ${run.bin("vitakit", "customize publications --schema")}               groups, badges and fields
+
+On the website, a section is shown by a component. --web creates one of your
+own in app/components/ -- either around VitaSection, which keeps vitakit's list
+and changes one line of every entry, or (--list) with a list of its own -- and
+uses it everywhere the section appears. One component can show several
+sections with the same fields (--use).
+
+In the PDF, a section is written by a template. --pdf copies the one in use to
+cv-tex/templates/<section>.eta, where yours wins.
+
+With --field, the new files show those fields. Files you have already are
+never replaced without --force; for them, \`${run.bin("vitakit", "explain <section> --field <name>")}\`
+prints lines to add.`,
+  async run(context, { positionals, values }) {
+    const id = positionals[0];
+    const { io, root } = context;
+    const interactive = asking(context, values);
+    let web = values.web === true;
+    let pdf = values.pdf === true;
+    let schema = values.schema === true;
+    const webOnly = ["list", "group-by", "region", "component", "use", "page"].filter((name) => values[name] !== void 0);
+    if (webOnly.length && !web) throw new UsageError(`--${webOnly[0]} goes with --web`, "customize");
+    if (values["group-by"] !== void 0 && !values.list) throw new UsageError("--group-by goes with --list", "customize");
+    if (values.from !== void 0 && !pdf) throw new UsageError("--from goes with --pdf", "customize");
+    if (values.copy && !schema) throw new UsageError("--copy goes with --schema", "customize");
+    if (!web && !pdf && !schema && id === "publications") schema = true;
+    if (!web && !pdf && !schema) {
+      if (!interactive) throw new UsageError(`what about ${id}? --web, --pdf or --schema`, "customize");
+      const { choose } = await import('../chunks/prompt.mjs');
+      const choice = await choose(io, `What do you want to change about ${id}?`, [
+        { label: "how it looks on the website", value: "web" },
+        { label: "how it looks in the PDF", value: "pdf" },
+        { label: "how it looks on the website and in the PDF", value: "both" },
+        { label: "which fields its entries may have", value: "schema" }
+      ]);
+      web = choice === "web" || choice === "both";
+      pdf = choice === "pdf" || choice === "both";
+      schema = choice === "schema";
+    }
+    const { inventory } = await import('../chunks/inventory.mjs');
+    const { Workspace } = await import('../chunks/plan.mjs');
+    const inv = await inventory(root);
+    const ws = new Workspace(root);
+    const notes = { before: [], after: [] };
+    if (id === "publications" && web) {
+      throw new CommandError("publications are shown by VitaPublications and VitaPublication: `vitakit eject VitaPublication` changes how one reference looks, `vitakit eject VitaPublications` the whole list");
+    }
+    const section = inv.sections.find((candidate) => candidate.id === id);
+    if (!section && id !== "publications" && (web || pdf || !(await import('../chunks/schemas.mjs')).schemas[id])) {
+      throw new CommandError(`no section called "${id}"; the sections are ${inv.sections.map((candidate) => candidate.id).join(", ") || "(none)"}`);
+    }
+    if (section?.problems.length && (web || pdf)) {
+      notes.before.push(`${section.where} has problems; \`vitakit validate ${id}\` lists them. The new files work once it is valid.`);
+    }
+    if (schema) await planSchema(context, ws, inv, id, values, notes);
+    let list = values.list === true;
+    if (web && !values.use && values.list === void 0 && interactive) {
+      const { choose } = await import('../chunks/prompt.mjs');
+      list = await choose(io, "What do you want to change on the website?", [
+        { label: "how each entry reads (title, details, links); vitakit keeps the list", value: false },
+        { label: "how the list is organised (grouping, numbering, badges); the list is yours", value: true }
+      ]);
+    }
+    const fields = web || pdf ? await selectFields(context, section, values, interactive && (pdf || web && !list && !values.use)) : [];
+    if (web) await planWeb(context, ws, inv, section, fields, list, values, notes);
+    if (pdf) await planPdf(context, ws, inv, id, fields, values, notes);
+    return finish(context, ws, values, notes);
+  }
+};
+
+const eject = {
+  name: "eject",
+  summary: "take over a shared vitakit file: a component, the citation style, the LaTeX class",
+  positionals: [{ name: "asset" }],
+  options: {
+    "list": { type: "boolean", description: "show what can be ejected, and what each one affects" },
+    "force": { type: "boolean", description: "replace your existing copy; the old one is kept as a backup" },
+    "dry-run": { type: "boolean", description: "show what would be written, write nothing" },
+    "yes": { type: "boolean", description: "do not ask for confirmation" }
+  },
+  project: true,
+  help: (run) => `
+Copies a file vitakit shares between all sections or all documents into your
+project, where it then wins. It is yours from then on: later improvements to it
+in vitakit will not reach you, so eject deliberately.
+
+  ${run.bin("vitakit", "eject --list")}
+  ${run.bin("vitakit", "eject VitaPublication")}     how one reference looks on the website
+  ${run.bin("vitakit", "eject publications.csl")}    the website's citation style
+  ${run.bin("vitakit", "eject vitakit-cv.cls")}      the LaTeX document class of every PDF
+
+To change one section, prefer \`${run.bin("vitakit", "customize <section>")}\`; CSS and
+cv-tex/preamble.tex cover most styling without taking anything over.`,
+  async run({ io, style, run, root }, { positionals, values }) {
+    const { ejectableAssets } = await import('../chunks/eject.mjs');
+    const assets = await ejectableAssets();
+    const name = positionals[0];
+    if (values.list || name === void 0) {
+      if (!values.list) throw new UsageError("which file? See `--list`", "eject");
+      io.out(`${table(assets.map((asset2) => [asset2.name, `\u2192 ${asset2.target}`, asset2.scope]))}
+
+Copy one with \`${run.bin("vitakit", "eject <name>")}\`.
+`);
+      return 0;
+    }
+    const asset = assets.find((candidate) => candidate.name.toLowerCase() === name.toLowerCase());
+    if (!asset) {
+      throw new CommandError(`"${name}" cannot be ejected. Ejectable: ${assets.map((candidate) => candidate.name).join(", ")}.${/^[a-z0-9-]+(\.eta)?$/.test(name) ? `
+  For one section, use \`${run.bin("vitakit", `customize ${name.replace(/\.eta$/, "")}`)}\`.` : ""}`);
+    }
+    const { applyPlan, printPlan, confirmPlan } = await import('../chunks/plan.mjs');
+    const plan = await (await import('../chunks/eject.mjs')).ejectPlan(root, asset, { force: values.force === true });
+    printPlan(io, style, plan);
+    if (values["dry-run"]) return 0;
+    if (!await confirmPlan(io, plan, values.yes === true)) return 1;
+    await applyPlan(root, plan);
+    io.out(`${style.green("\u2713")} done. ${asset.after}
+`);
+    return 0;
+  }
+};
+
+function webPlacementsOf(inventory, section) {
+  return inventory.web.placements.filter((placement) => placement.section === section);
+}
+function pdfPlacementsOf(inventory, section) {
+  return inventory.documents.flatMap((document) => document.placements.filter((placement) => placement.section === section));
+}
+function webCell(inventory, section) {
+  const placements = webPlacementsOf(inventory, section);
+  if (!placements.length) return inventory.web.dynamic.length ? "unknown" : "\u2013";
+  const counts = /* @__PURE__ */ new Map();
+  for (const placement of placements) {
+    const key = placement.route ?? placement.file.replace(/^app\/components\//, "").replace(/\.vue$/, "");
+    const current = counts.get(key) ?? { count: 0, where: false };
+    counts.set(key, { count: current.count + 1, where: current.where || placement.where !== void 0 });
+  }
+  return [...counts].map(([key, { count, where }]) => `${key}${count > 1 ? ` (\xD7${count}${where ? ", where" : ""})` : where ? " (where)" : ""}`).join(" ");
+}
+function pdfCell(inventory, section) {
+  const documents = [...new Set(pdfPlacementsOf(inventory, section).map((placement) => placement.document))];
+  return documents.length ? documents.join(", ") : "\u2013";
+}
+function readableIssue(line) {
+  return line.replace(/^(\s*)- (\d+)(?:\.([\w.-]+))?: /, (_match, indent, index, field) => `${indent}entry ${Number(index) + 1}${field ? `, ${field}` : ""}: `).replace(/^(\s*)- /, "$1");
+}
+function messageLines(message) {
+  const lines = message.split("\n").filter((line) => line.trim() && line.trim() !== "invalid");
+  const indent = Math.min(...lines.map((line) => /^\s*/.exec(line)[0].length));
+  return lines.map((line) => readableIssue(line.slice(indent)));
+}
+function firstLine(text) {
+  const lines = messageLines(text);
+  const first = lines[0] ?? text;
+  return first.endsWith(":") ? first.slice(0, -1) : `${first}${lines.length > 1 ? ` (+${lines.length - 1} more)` : ""}`;
+}
+function countsText(section) {
+  if (section.counts) {
+    const total = section.counts.public + section.counts.cv + section.counts.private;
+    const parts = ["public", "cv", "private"].filter((level) => section.counts[level] > 0).map((level) => `${section.counts[level]} ${level}`);
+    return `${total} ${total === 1 ? "entry" : "entries"}${parts.length > 1 || parts.length === 1 && !section.counts.public ? `: ${parts.join(", ")}` : ""}`;
+  }
+  if (section.entries !== void 0) return `${section.entries} ${section.entries === 1 ? "entry" : "entries"}`;
+  return "";
+}
+function problemLines(problems, indent = "  ") {
+  return problems.flatMap((problem) => [
+    `${indent}${problem.where}`,
+    ...messageLines(problem.message).map((line) => `${indent}  ${line}`)
+  ]);
+}
+
+const describe = {
+  __proto__: null,
+  countsText: countsText,
+  firstLine: firstLine,
+  messageLines: messageLines,
+  pdfCell: pdfCell,
+  pdfPlacementsOf: pdfPlacementsOf,
+  problemLines: problemLines,
+  readableIssue: readableIssue,
+  webCell: webCell,
+  webPlacementsOf: webPlacementsOf
+};
+
+const STARTER = (id) => [
+  `import { section, dateRange, richText, text } from '@anja.codes/vitakit'`,
+  ``,
+  `export default section({`,
+  `  date: dateRange,`,
+  `  title: richText,`,
+  `  note: text.optional(),`,
+  `})`
+].map((line) => `    ${line}`).join("\n").replace(/^/, `  schemas/${id}.ts, for example:
+
+`);
+function schemaText(section) {
+  const { schema } = section;
+  if (schema.origin === "none") return "none yet";
+  if (schema.origin === "built-in") return "built-in";
+  if (schema.sharedWith) return `${schema.file}, the same as ${schema.sharedWith}`;
+  return schema.extendsBuiltIn ? `built-in, extended in ${schema.file}` : `${schema.file} (yours)`;
+}
+async function fieldSnippets(context, inv, section, names) {
+  const { style, run, root } = context;
+  const { webFieldSnippet, etaFieldSnippet } = await import('../chunks/snippets.mjs');
+  const { existsSync } = await import('node:fs');
+  const { join: join2 } = await import('node:path');
+  const id = section.id;
+  const unknown = names.filter((name) => !section.fields?.some((field) => field.path === name));
+  if (unknown.length) {
+    throw new CommandError(`${id} has no field ${unknown.join(", ")}; its fields are ${section.fields?.map((field) => field.path).join(", ") || "(unknown)"}`);
+  }
+  const fields = names.map((name) => section.fields.find((field) => field.path === name));
+  const web = fields.map((field) => webFieldSnippet(field));
+  const imports = [...new Set(web.flatMap((snippet) => snippet.imports))];
+  const lines = ["", style.bold(`Showing ${names.join(", ")}`), ""];
+  const components = [...new Set(webPlacementsOf(inv, id).filter((placement) => placement.component !== "code" && placement.component !== "VitaSection").map((placement) => placement.component))];
+  const indented = (snippets) => snippets.map((snippet) => `    ${snippet}`);
+  if (components.length) {
+    for (const component of components) {
+      lines.push(block("website", [[`${inv.web.components.get(component)}: add where the entry's lines are, e.g. in its #note slot`]]));
+    }
+  } else {
+    lines.push(block("website", [[`${id} is shown by VitaSection. \`${run.bin("vitakit", `customize ${id} --web --field ${names.join(" --field ")}`)}\``]]));
+    lines.push(block("", [["creates a component that shows them; or, on the page, give VitaSection a slot:"]]));
+    lines.push(
+      "",
+      `    <VitaSection id="${id}">`,
+      '      <template #note="{ entry, display }">',
+      '        <p v-if="display.note !== undefined" class="vita-entry__note">{{ display.note }}</p>'
+    );
+    lines.push(...web.map((snippet) => `        ${snippet.markup}`), "      </template>", "    </VitaSection>");
+  }
+  if (components.length) lines.push("", ...indented(web.map((snippet) => snippet.markup)));
+  if (imports.length) lines.push("", `    import { ${imports.join(", ")} } from '@anja.codes/vitakit/shared'`);
+  lines.push("");
+  if (existsSync(join2(root, "cv-tex", "templates", `${id}.eta`))) {
+    lines.push(block("pdf", [[`cv-tex/templates/${id}.eta (yours): add inside its loop over the entries, after the notes`]]));
+  } else if (inv.documents.length) {
+    lines.push(block("pdf", [[`vitakit's template. \`${run.bin("vitakit", `customize ${id} --pdf --field ${names.join(" --field ")}`)}\` copies it with these lines:`]]));
+  }
+  if (inv.documents.length) lines.push("", ...indented(fields.map((field) => etaFieldSnippet(field))));
+  return lines;
+}
+async function explainSection(context, inv, section, fields = []) {
+  const { style, run } = context;
+  const lines = [style.bold(section.id), ""];
+  lines.push(block("data", [[`${section.where}${countsText(section) ? ` \xB7 ${countsText(section)}` : ""}`]]));
+  lines.push(block("schema", [[schemaText(section)]]));
+  if (section.fields) {
+    const { fieldSummary } = await import('../chunks/fields.mjs');
+    lines.push(block("", section.fields.flatMap((field) => [
+      [`  ${field.path}`, fieldSummary(field)],
+      ...(field.fields ?? []).map((child) => [`    ${child.path}`, fieldSummary(child)])
+    ])));
+  } else if (section.schema.origin === "none") {
+    lines.push("", `  There is no built-in schema for "${section.id}". \`${context.run.bin("vitakit", `add section ${section.id}`)}\``, "  drafts one from its entries; or write", STARTER(section.id));
+  }
+  lines.push("");
+  const web = webPlacementsOf(inv, section.id);
+  if (web.length) {
+    lines.push(block("website", web.map((placement) => [
+      placement.route ?? "",
+      `${placement.file}:${placement.line}`,
+      placement.component === "code" ? "useSection, in code" : `<${placement.component}${placement.title !== void 0 ? ` title="${placement.title}"` : ""}${placement.where ? ` :where="${placement.where}"` : ""}${placement.limit ? ` limit ${placement.limit}` : ""}>`
+    ])));
+  } else {
+    lines.push(block("website", [[inv.web.dynamic.length ? "not found on any page; some pages choose sections in code (see status)" : "not on any page"]]));
+  }
+  if (inv.documents.length) {
+    const { explainSelection } = await import('../chunks/documents.mjs');
+    const { resolveTemplate } = await import('../chunks/emit.mjs');
+    const template = section.problems.length ? void 0 : await resolveTemplate(section.id, join(inv.root, "cv-tex", "templates"));
+    const templateText = template ? template.origin === "local" ? `cv-tex/templates/${template.generic ? "_generic" : section.id}.eta (yours)` : template.generic ? `vitakit's generic template (there is no ${section.id}.eta)` : `vitakit's ${section.id}.eta` : void 0;
+    const rows = [];
+    for (const document of inv.documents) {
+      const placements = document.placements.filter((placement) => placement.section === section.id);
+      if (!placements.length) {
+        rows.push([document.name, "not included"]);
+        continue;
+      }
+      for (const placement of placements) {
+        rows.push([document.name, `${placement.file}:${placement.line}  \\vitasection${placement.heading !== void 0 ? `[${placement.heading}]` : ""}{${section.id}}`]);
+      }
+      if (templateText) rows.push(["", `template: ${templateText}`]);
+      const entries = inv.content.sections[section.id];
+      if (entries && !section.problems.length) {
+        const { total, steps } = explainSelection(entries, document.options, section.id);
+        const kept = steps[steps.length - 1]?.kept ?? total;
+        const removed = steps.filter((step) => step.removed > 0).map((step) => `${step.rule} \u2212${step.removed}`);
+        rows.push(["", `${kept} of ${total} entries${removed.length ? ` (${removed.join(", ")})` : ""}`]);
+      }
+    }
+    lines.push("", block("pdf", rows));
+  } else {
+    lines.push("", block("pdf", [["no documents in cv-tex/"]]));
+  }
+  if (fields.length) lines.push(...await fieldSnippets(context, inv, section, fields));
+  const problems = section.problems.filter((problem) => !(section.schema.origin === "none" && problem.message.startsWith("no schema")));
+  if (problems.length) lines.push("", style.bold("Problems"), ...problemLines(problems));
+  lines.push("", `Check it: \`${run.bin("vitakit", `validate ${section.id}`)}\``);
+  return lines;
+}
+async function explainDocument(context, inv, document) {
+  const { style, run } = context;
+  const { explainSelection } = await import('../chunks/documents.mjs');
+  const lines = [style.bold(`${document.name}`), ""];
+  lines.push(block("source", [[document.tex]]));
+  lines.push(block("settings", [[document.yml ? `${document.yml} \xB7 visibility: ${document.options.visibility}` : `none (no cv-tex/${document.name}.yml) \xB7 visibility: ${document.options.visibility}`]]), "");
+  if (document.placements.length) {
+    lines.push(block("includes", document.placements.map((placement) => {
+      const section = inv.sections.find((candidate) => candidate.id === placement.section);
+      let detail = "";
+      if (placement.section === "publications") {
+        detail = inv.publications ? `${inv.publications.entries} entries in ${inv.publications.groups} groups` : "no content/publications.bib";
+      } else if (section?.problems.length) {
+        detail = style.red("has problems");
+      } else if (section) {
+        const { total, steps } = explainSelection(inv.content.sections[section.id] ?? [], document.options, section.id);
+        detail = `${steps[steps.length - 1]?.kept ?? total} of ${total} entries`;
+      } else {
+        detail = style.red("no such section");
+      }
+      return [
+        `line ${placement.line}`,
+        placement.section,
+        placement.heading ?? "",
+        detail
+      ];
+    })));
+  } else {
+    lines.push(block("includes", [["no \\vitasection or \\vitainput lines found"]]));
+  }
+  const pdf = document.pdf ? `${document.pdf.file}${document.pdf.mtimeMs < inv.sourcesMtimeMs ? ", older than its sources" : ""}` : "not built yet";
+  lines.push("", block("pdf", [[pdf]]));
+  if (document.problems.length) lines.push("", style.bold("Problems"), ...problemLines(document.problems));
+  lines.push("", `Build it: \`${run.bin("vitakit", `pdf ${document.name}`)}\`; per section: \`${run.bin("vitakit", "explain <section>")}\``);
+  return lines;
+}
+function explainRoute(context, inv, page, route) {
+  const { style } = context;
+  const lines = [style.bold(route), ""];
+  const rows = [];
+  if (page?.markdown) rows.push(["text", `${page.markdown}${page.title ? ` \xB7 "${page.title}"` : ""}`]);
+  if (page?.vue) rows.push(["page", page.vue]);
+  else if (page?.markdown && inv.catchAll) rows.push(["page", `${inv.catchAll} (shows Markdown pages)`]);
+  if (!page) rows.push(["page", "no Markdown or Vue page has this route"]);
+  else rows.push(["menu", page.inMenu ? "in the menu (content/profile.yml)" : "not in the menu (content/profile.yml, nav)"]);
+  lines.push(...rows.map(([label, text]) => block(label, [[text]])));
+  const placements = inv.web.placements.filter((placement) => placement.route === route);
+  if (placements.length) {
+    lines.push("", block("sections", placements.map((placement) => [
+      placement.section,
+      `line ${placement.line}`,
+      placement.component === "code" ? "useSection, in code" : `<${placement.component}${placement.title !== void 0 ? ` title="${placement.title}"` : ""}>`
+    ])));
+  }
+  const dynamic = inv.web.dynamic.filter((usage) => usage.file === page?.vue);
+  if (dynamic.length) {
+    lines.push("", "Chosen in code, so not listed:", ...dynamic.map((usage) => `  line ${usage.line}  ${usage.usage}`));
+  }
+  return lines;
+}
+const explain = {
+  name: "explain",
+  summary: "where a section, PDF document or page comes from, and where it goes",
+  positionals: [{ name: "name", required: true }],
+  options: {
+    section: { type: "boolean", description: "the name is a section (when a document has the same name)" },
+    document: { type: "boolean", description: "the name is a PDF document (when a section has the same name)" },
+    field: { type: "string", multiple: true, value: "<name>", description: "a section: lines that show this field, on the website and in the PDF" }
+  },
+  project: true,
+  help: (run) => `
+  ${run.bin("vitakit", "explain talks")}       a section: its file, fields, pages and PDFs
+  ${run.bin("vitakit", "explain cv")}          a PDF document: what it includes, from where
+  ${run.bin("vitakit", "explain /cv/")}        a website page: its files and sections
+  ${run.bin("vitakit", "explain teaching --field evaluation")}   lines that show a field
+
+For a section it shows which entries each PDF document selects, and which
+setting removed the others -- the answer to "why is this not in my PDF?".
+Never prints entry contents, only counts.`,
+  async run(context, { positionals, values }) {
+    const { inventory } = await import('../chunks/inventory.mjs');
+    const inv = await inventory(context.root);
+    const name = positionals[0];
+    let lines;
+    if (name.startsWith("/")) {
+      const route = name.endsWith("/") ? name : `${name}/`;
+      lines = explainRoute(context, inv, inv.pages.find((page) => page.route === route), route);
+    } else {
+      const section = inv.sections.find((candidate) => candidate.id === name);
+      const document = inv.documents.find((candidate) => candidate.name === name);
+      if (values.section && values.document) throw new UsageError("use --section or --document, not both", "explain");
+      if (section && document && !values.section && !values.document) {
+        throw new UsageError(`"${name}" is both a section and a PDF document; add --section or --document`, "explain");
+      }
+      const fields = values.field ?? [];
+      if (fields.length && !(section && !values.document)) throw new UsageError("--field goes with a section", "explain");
+      if (section && !values.document) lines = await explainSection(context, inv, section, fields);
+      else if (document && !values.section) lines = await explainDocument(context, inv, document);
+      else {
+        const known = [
+          inv.sections.length ? `sections: ${inv.sections.map((candidate) => candidate.id).join(", ")}` : "",
+          inv.documents.length ? `documents: ${inv.documents.map((candidate) => candidate.name).join(", ")}` : ""
+        ].filter(Boolean).join("; ");
+        throw new CommandError(`nothing called "${name}"${known ? `; ${known}` : ""}. A page is explained by its route, e.g. /cv/.`);
+      }
+    }
+    context.io.out(`${lines.join("\n")}
+`);
+    return 0;
+  }
+};
+
+const pdf = {
+  name: "pdf",
+  summary: "build the PDF documents in cv-tex/",
+  positionals: [{ name: "document", variadic: true }],
+  options: {
+    "tex-only": { type: "boolean", description: "write the .tex files but do not run LaTeX; needs no TeX installation" },
+    "verbose": { type: "boolean", description: "show LaTeX's full output while it runs" }
+  },
+  project: true,
+  help: (run) => `
+Renders content/ into cv-tex/generated/<document>/, one .tex file per section,
+then runs latexmk. The finished PDF is written next to its source, as
+cv-tex/<document>.pdf; everything else stays in the generated directory, which
+is vitakit's -- do not edit anything there.
+
+  ${run.bin("vitakit", "pdf")}                    every document in cv-tex/
+  ${run.bin("vitakit", "pdf cv")}                 just cv.tex
+  ${run.bin("vitakit", "pdf cv application")}     several
+  ${run.bin("vitakit", "pdf --tex-only")}         only the .tex files
+
+A document is a .tex file you own; a copy of cv.tex is a new document. What it
+contains is decided by an optional cv-tex/<document>.yml. Needs latexmk and
+biber, from any current TeX distribution.`,
+  async run({ io, style, run, root }, { positionals, values }) {
+    const { buildCv, MissingToolError } = await import('../chunks/build.mjs');
+    const texOnly = values["tex-only"] === true;
+    const local = (path) => relative(root, path);
+    try {
+      await buildCv({
+        rootDir: root,
+        only: positionals,
+        noPdf: texOnly,
+        latexOutput: values.verbose ? "inherit" : "capture",
+        onProgress(event) {
+          if (event.step === "tex") io.out(`${event.document}: wrote ${local(event.dir)}/ (${event.files} files)${texOnly ? "" : ", running latexmk\u2026"}
+`);
+          else io.out(`${event.document}: ${style.green("\u2713")} ${local(event.file)}
+`);
+        }
+      });
+    } catch (error) {
+      if (error instanceof MissingToolError) {
+        throw new CommandError(`${error.message}.
+  Without one, \`${run.bin("vitakit", "pdf --tex-only")}\` writes the .tex files, e.g. for Overleaf or CI.`);
+      }
+      if (error instanceof Error) error.message = error.message.replaceAll(`${root}/`, "");
+      throw error;
+    }
+    return 0;
+  }
+};
+
+const status = {
+  name: "status",
+  summary: "what is in this project, what is broken, where sections appear",
+  positionals: [],
+  options: {},
+  json: true,
+  project: true,
+  help: (run) => `
+Lists your sections and where each one appears: on which website pages, and in
+which PDF documents. A section that appears nowhere is fine -- that is your
+choice -- and is shown as "\u2013". Problems are things a build would fail on.
+
+Reads your files only: no website build, no LaTeX. Entry contents are never
+printed, only how many there are.
+
+Next: \`${run.bin("vitakit", "explain <section>")}\` for the details of one section,
+\`${run.bin("vitakit", "validate")}\` to check everything before building.`,
+  async run({ io, style, run, root, json }) {
+    const { inventory } = await import('../chunks/inventory.mjs');
+    const inv = await inventory(root);
+    if (json) {
+      io.out(`${JSON.stringify({
+        root,
+        sections: inv.sections.map((section) => ({
+          id: section.id,
+          where: section.where,
+          schema: section.schema,
+          entries: section.entries,
+          counts: section.counts,
+          website: webPlacementsOf(inv, section.id),
+          pdf: pdfPlacementsOf(inv, section.id),
+          problems: section.problems
+        })),
+        unknownWebsiteUsages: inv.web.dynamic,
+        publications: inv.publications ?? null,
+        pages: inv.pages,
+        documents: inv.documents.map((document) => ({
+          name: document.name,
+          tex: document.tex,
+          yml: document.yml ?? null,
+          pdf: document.pdf ? { file: document.pdf.file, upToDate: document.pdf.mtimeMs >= inv.sourcesMtimeMs } : null,
+          problems: document.problems
+        })),
+        problems: inv.problems
+      }, null, 2)}
+`);
+      return 0;
+    }
+    const lines = [];
+    if (inv.sections.length) {
+      const rows = [[style.bold("Sections"), "", style.bold("website"), style.bold("pdf")]];
+      for (const section of inv.sections) {
+        const mark = section.schema.origin === "none" ? style.yellow("?") : section.problems.length ? style.red("\u2716") : " ";
+        const state = section.schema.origin === "none" ? style.yellow("no schema yet") : section.problems.length ? style.red(`${countsText(section) || "unreadable"}, has problems`) : countsText(section);
+        rows.push([`${mark} ${section.id}`, state, webCell(inv, section.id), pdfCell(inv, section.id)]);
+      }
+      lines.push(table(rows, ""), "");
+    } else {
+      lines.push(`${style.bold("Sections")}  none yet: a section is a file content/<name>.yml`, "");
+    }
+    const facts = [];
+    if (inv.publications) {
+      facts.push([style.bold("Publications"), `${inv.publications.file} \xB7 ${inv.publications.entries} entries in ${inv.publications.groups} groups`]);
+    }
+    const pages = inv.pages.filter((page) => page.markdown || page.vue);
+    if (pages.length) {
+      const outside = pages.filter((page) => !page.inMenu).map((page) => page.route);
+      facts.push([style.bold("Pages"), `${pages.map((page) => page.route).join("  ")}${outside.length === 0 ? "   (all in the menu)" : `   (not in the menu: ${outside.join(" ")})`}`]);
+    }
+    for (const [index, document] of inv.documents.entries()) {
+      const pdf = document.pdf ? `${document.name}.pdf${document.pdf.mtimeMs < inv.sourcesMtimeMs ? " (older than its sources)" : ""}` : "not built yet";
+      facts.push([index === 0 ? style.bold("PDF") : "", `${document.tex} \u2192 ${pdf}`]);
+    }
+    if (!inv.documents.length) facts.push([style.bold("PDF"), "no documents in cv-tex/"]);
+    lines.push(table(facts, ""), "");
+    if (inv.web.dynamic.length) {
+      lines.push(`Not resolvable without running the site, so "unknown" above:`);
+      lines.push(...inv.web.dynamic.map((usage) => `  ${usage.file}:${usage.line}  ${usage.usage}`), "");
+    }
+    const missingSchemas = inv.sections.filter((section) => section.schema.origin === "none");
+    const count = inv.problems.length;
+    if (count) {
+      lines.push(style.bold("Problems"));
+      lines.push(...inv.problems.map((problem) => `  ${style.red("\u2716")} ${problem.where}: ${firstLine(problem.message)}`), "");
+    }
+    if (count) {
+      lines.push(`${count} ${count === 1 ? "problem" : "problems"}. Details: \`${run.bin("vitakit", "validate")}\`${missingSchemas.length ? `; to draft a schema from a section's entries: \`${run.bin("vitakit", `add section ${missingSchemas[0].id}`)}\`` : ""}`);
+    } else {
+      lines.push(style.green("No problems."));
+    }
+    io.out(`${lines.join("\n")}
+`);
+    return 0;
+  }
+};
+
+const validate = {
+  name: "validate",
+  summary: "check content, schemas, pages and PDF settings; no build, no LaTeX",
+  positionals: [{ name: "section", variadic: true }],
+  options: {},
+  json: true,
+  project: true,
+  help: (run) => `
+Checks everything a build would check, without building: every file in
+content/, the schemas, page settings, which sections pages and PDF documents
+include, cv-tex/<document>.yml, and every PDF template, rendered in memory.
+Reports all problems at once and exits with 1 if there is any.
+
+  ${run.bin("vitakit", "validate")}              everything
+  ${run.bin("vitakit", "validate talks")}        only what concerns talks
+
+Not a replacement for \`${run.script("check")}\`, which builds the website and checks
+what was built, or for building the PDF, which runs LaTeX.`,
+  async run({ io, style, run, root, json }, { positionals }) {
+    const { validateProject } = await import('../chunks/validate.mjs');
+    const { problems, inventory: inv } = await validateProject(root, { sections: positionals });
+    for (const problem of problems) {
+      if (problem.message.startsWith("no schema for this file") && problem.section) {
+        problem.message = `no schema yet; \`${run.bin("vitakit", `add section ${problem.section}`)}\` drafts one from its entries`;
+      }
+    }
+    const unknown = positionals.filter((id) => !inv.sections.some((section) => section.id === id));
+    if (unknown.length) {
+      throw new CommandError(`no section called ${unknown.join(", ")}; the sections are ${inv.sections.map((section) => section.id).join(", ") || "(none)"}`);
+    }
+    if (json) {
+      io.out(`${JSON.stringify({ ok: problems.length === 0, problems }, null, 2)}
+`);
+      return problems.length ? 1 : 0;
+    }
+    if (!problems.length) {
+      const checked = positionals.length ? positionals : inv.sections.map((section) => section.id);
+      const parts = [
+        `${checked.length} ${checked.length === 1 ? "section" : "sections"}`,
+        ...!positionals.length && inv.publications ? [`${inv.publications.entries} publications`] : [],
+        ...!positionals.length ? [`${inv.pages.filter((page) => page.markdown || page.vue).length} pages`] : [],
+        `${inv.documents.length} PDF ${inv.documents.length === 1 ? "document" : "documents"}`
+      ];
+      io.out(`${style.green("\u2713")} ${parts.join(", ")}: no problems
+`);
+      return 0;
+    }
+    const lines = problemLines(problems).map((line) => line.startsWith("    ") ? line : `${style.red("\u2716")}${line.slice(1)}`);
+    io.out(`${lines.join("\n")}
+
+${problems.length} ${problems.length === 1 ? "problem" : "problems"}
+`);
+    return 1;
+  }
+};
+
+const verify = {
+  name: "verify",
+  summary: "check the generated website, after nuxt generate",
+  positionals: [],
+  options: {
+    "out": { type: "string", value: "<dir>", description: "the generated site; .output/public by default" },
+    "no-leak-check": { type: "boolean", description: "skip the check for cv and private entries (see below)" }
+  },
+  project: true,
+  help: (run) => `
+Checks the built HTML, not your content, because a schema cannot catch a
+renderer that silently did nothing:
+
+  - every page in content/pages/ was generated
+  - mathematics was typeset, and KaTeX reported no errors
+  - the site was built for the deployment base path (NUXT_APP_BASE_URL), and
+    every link and asset (href, src, srcset, poster, \u2026) stays inside it
+  - every link into the site leads to a file or page that was generated
+  - no entry marked \`visibility: cv\` or \`private\` appears anywhere in the site
+  - the bibliography is fully formatted wherever it is shown
+
+\`${run.script("check")}\` builds the site and runs this. The leak check compares the
+titles of cv and private entries with the text of every page, so a title that
+is legitimately public elsewhere looks like a leak; --no-leak-check skips it.`,
+  async run({ io, style, run, root }, { values }) {
+    const { checkStatic } = await import('../check.mjs');
+    const { checked, failures } = await checkStatic({
+      rootDir: root,
+      outDir: values.out,
+      skipLeakCheck: values["no-leak-check"] === true
+    });
+    for (const line of checked) io.out(`  ${style.green("ok")}  ${line}
+`);
+    if (failures.length) {
+      io.err(`
+${failures.length} ${failures.length === 1 ? "problem" : "problems"}:
+`);
+      for (const failure of failures) {
+        io.err(`  ${style.red("\u2716")} ${failure.replace("run `nuxt generate` first", `build it first with \`${run.script("generate")}\``)}
+`);
+      }
+      return 1;
+    }
+    io.out(`
+${style.green("The generated site looks correct.")}
+`);
+    return 0;
+  }
+};
+
+const COMMANDS = [status, explain, validate, add, customize, pdf, verify, eject];
+const GROUPS = [
+  { title: "Look", names: ["status", "explain", "validate"] },
+  { title: "Build and check", names: ["pdf", "verify"] },
+  { title: "Change", names: ["add", "customize", "eject"] }
+];
+
+function version() {
+  return JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf8")).version;
+}
+function overview(run) {
+  const width = Math.max(...COMMANDS.map((command) => command.name.length));
+  const groups = GROUPS.map(({ title, names }) => [
+    title,
+    ...names.map((name) => {
+      const command = COMMANDS.find((candidate) => candidate.name === name);
+      return `  ${command.name.padEnd(width)}   ${command.summary}`;
+    })
+  ].join("\n"));
+  return [
+    "vitakit \u2014 your website and CV from the files in content/",
+    "",
+    "Usage",
+    `  ${run.bin("vitakit", "<command> [options]")}`,
+    "",
+    ...groups.flatMap((group) => [group, ""]),
+    `Start with \`${run.bin("vitakit", "status")}\`. Every command has --help.`,
+    ""
+  ].join("\n");
+}
+const MOVED = {
+  list: "eject --list"
+};
+async function main(argv, io = processIo()) {
+  const [name, ...rest] = argv;
+  const run = commands(detectPackageManager(io.cwd, io.env));
+  const color = io.tty && !io.env.NO_COLOR && !argv.includes("--no-color");
+  if (name === void 0 || name === "help" || name === "--help" || name === "-h") {
+    const topic = name === "help" ? rest[0] : void 0;
+    const command = topic ? COMMANDS.find((candidate) => candidate.name === topic) : void 0;
+    if (command) {
+      io.out(commandHelp(command, run));
+      return 0;
+    }
+    const paint = style(color);
+    const room = io.columns === void 0 || io.columns >= BANNER_WIDTH;
+    io.out(`${room ? `${banner(version(), { fox: paint.orange, bold: paint.bold })}
+
+` : ""}${overview(run)}`);
+    return topic ? 2 : 0;
+  }
+  if (name === "--version" || name === "-v") {
+    io.out(`${version()}
+`);
+    return 0;
+  }
+  const spec = COMMANDS.find((candidate) => candidate.name === name);
+  try {
+    if (!spec) {
+      const moved = MOVED[name];
+      throw new UsageError(moved ? `"${name}" is now \`${run.bin("vitakit", moved)}\`` : `unknown command "${name}"`);
+    }
+    const args = parseCommandArgs(spec, rest);
+    if (args.values.help) {
+      io.out(commandHelp(spec, run));
+      return 0;
+    }
+    const root = spec.project ? resolveRoot(io.cwd, args.values.root) : io.cwd;
+    const projectRun = spec.project ? commands(detectPackageManager(root, io.env)) : run;
+    return await spec.run({ io, style: style(color), run: projectRun, root, json: args.values.json === true }, args);
+  } catch (error) {
+    if (error instanceof UsageError) {
+      const help = error.command ? run.bin("vitakit", `${error.command} --help`) : run.bin("vitakit", "--help");
+      io.err(`vitakit: ${error.message}
+  See \`${help}\`.
+`);
+      return 2;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    io.err(`vitakit: ${message}
+`);
+    if (!(error instanceof CommandError) && io.env.VITAKIT_DEBUG && error instanceof Error) io.err(`${error.stack}
+`);
+    return 1;
+  }
+}
+
+export { CommandError as C, aligned as a, commands as c, detectPackageManager as d, main as m };