@anja.codes/vitakit 0.1.0 → 0.3.0

package/dist/chunks/validate.mjs

@@ -0,0 +1,133 @@
+import { join, sep, isAbsolute, relative } from 'node:path';
+import { parseExpression } from '@babel/parser';
+import { l as loadContent } from '../shared/vitakit.DteA9vLy.mjs';
+import { inventory } from './inventory.mjs';
+import { m as messageOf, w as whereOf } from '../shared/vitakit.DCK90zq4.mjs';
+import { assertTemplatesAreUsed, renderSection, renderPublications } from './emit.mjs';
+import 'node:fs/promises';
+import 'gray-matter';
+import 'yaml';
+import './bibliography.mjs';
+import 'node:fs';
+import '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:url';
+import '@behackl/citation-js-extras';
+import 'unified';
+import 'rehype-parse';
+import 'rehype-sanitize';
+import 'rehype-stringify';
+import 'remark-parse';
+import 'remark-gfm';
+import 'remark-math';
+import 'remark-rehype';
+import 'rehype-katex';
+import 'rehype-raw';
+import 'unist-util-visit';
+import 'zod';
+import './publication-lists.mjs';
+import '../shared/vitakit.D10HyDhF.mjs';
+import './sections.mjs';
+import './schemas.mjs';
+import '../shared/vitakit.DvABWuUc.mjs';
+import '../shared/vitakit.TSMTC5Jl.mjs';
+import './fields.mjs';
+import './documents.mjs';
+import '../shared/vitakit.DvvUYUTS.mjs';
+import '../shared/vitakit.D-DdJaDZ.mjs';
+import 'eta';
+import '../shared/vitakit.DcQOdM4I.mjs';
+import '../shared/vitakit.CfB3hMHl.mjs';
+
+function literalKeys(expression) {
+  try {
+    const node = parseExpression(expression, { plugins: ["typescript"] });
+    if (node.type !== "ObjectExpression") return void 0;
+    const keys = [];
+    for (const property of node.properties) {
+      if (property.type !== "ObjectProperty" || property.computed) return void 0;
+      if (property.key.type === "Identifier") keys.push(property.key.name);
+      else if (property.key.type === "StringLiteral") keys.push(property.key.value);
+      else return void 0;
+    }
+    return keys;
+  } catch {
+    return void 0;
+  }
+}
+async function validateProject(rootDir, { sections: only } = {}) {
+  const inv = await inventory(rootDir);
+  const problems = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (problem) => {
+    const key = `${problem.where}
+${problem.message}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    problems.push(problem);
+  };
+  const local = (where) => isAbsolute(where) ? relative(rootDir, where) : where;
+  for (const problem of inv.problems) {
+    const section = inv.sections.find((candidate) => candidate.problems.includes(problem));
+    add({ ...problem, ...section ? { section: section.id } : {} });
+  }
+  const valid = new Map(inv.sections.filter((section) => !section.problems.length).map((section) => [section.id, section]));
+  const known = new Set(inv.sections.map((section) => section.id));
+  for (const placement of inv.web.placements) {
+    const where = `${placement.file}:${placement.line}`;
+    if (!known.has(placement.section)) {
+      add({ where, section: placement.section, message: `no section called "${placement.section}" (no content/${placement.section}.yml)` });
+      continue;
+    }
+    const fields = valid.get(placement.section)?.fields;
+    if (placement.where === void 0 || !fields) continue;
+    const keys = literalKeys(placement.where);
+    if (!keys) continue;
+    const names = /* @__PURE__ */ new Set(["year", ...fields.map((field) => field.path)]);
+    for (const key of keys.filter((key2) => !names.has(key2))) {
+      add({ where, section: placement.section, message: `where.${key}: ${placement.section} has no field "${key}"; its fields are ${[...names].join(", ")}` });
+    }
+  }
+  if (inv.documents.length) {
+    const templateDir = join(rootDir, "cv-tex", "templates");
+    try {
+      await assertTemplatesAreUsed(templateDir, [...known]);
+    } catch (error) {
+      add({ where: local(whereOf(error, "cv-tex/templates/")), message: messageOf(error) });
+    }
+    const content = await loadContent(rootDir, { strict: false, maxVisibility: "private", target: "pdf" });
+    for (const document of inv.documents) {
+      for (const placement of document.placements) {
+        try {
+          if (valid.has(placement.section)) {
+            await renderSection(placement.section, content.sections[placement.section] ?? [], document.options, templateDir);
+          }
+        } catch (error) {
+          add({
+            where: local(whereOf(error, `cv-tex/templates/${placement.section}.eta`)),
+            section: placement.section,
+            message: `${messageOf(error)} (in ${document.tex})`
+          });
+        }
+      }
+      for (const placement of document.publications) {
+        const list = content.publications[placement.list];
+        if (!list) continue;
+        try {
+          await renderPublications(list, templateDir, content.profile.url);
+        } catch (error) {
+          add({ where: local(whereOf(error, "cv-tex/templates/publications.eta")), message: `${messageOf(error)} (in ${document.tex})` });
+        }
+      }
+    }
+  }
+  const { realpath } = await import('node:fs/promises');
+  const roots = [.../* @__PURE__ */ new Set([rootDir, await realpath(rootDir).catch(() => rootDir)])];
+  for (const problem of problems) {
+    for (const root of roots) problem.message = problem.message.replaceAll(`${root}${sep}`, "");
+    problem.message = problem.message.replace(/^(template [\w-]+\.eta: )cv-tex\/templates\/[\w-]+\.eta: /, "$1");
+  }
+  const relevant = only?.length ? problems.filter((problem) => problem.section !== void 0 && only.includes(problem.section) || problem.where === "content/profile.yml") : problems;
+  return { problems: relevant, inventory: inv };
+}
+
+export { validateProject };

package/dist/chunks/vue.mjs

@@ -0,0 +1,153 @@
+import { parse } from '@vue/compiler-sfc';
+import { l as lineStart, a as lineEnd, i as indentationAt, b as insertLinesAfter, c as insertLinesBefore } from '../shared/vitakit.UfoXdL7U.mjs';
+
+const ELEMENT = 1;
+const ATTRIBUTE = 6;
+const pascal = (name) => name.split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+function literalAttribute(node, name) {
+  for (const prop of node.props ?? []) {
+    if (prop.type === ATTRIBUTE && prop.name === name) return prop.value?.content;
+    if (prop.type !== ATTRIBUTE && prop.name === "bind" && prop.arg?.content === name) {
+      return /^\s*(['"`])([^'"`$]*)\1\s*$/.exec(prop.exp?.content ?? "")?.[2];
+    }
+  }
+  return void 0;
+}
+const hasContent = (node) => (node.children ?? []).some((child) => child.type !== 3 && !(child.type === 2 && !child.content.trim()));
+const directive = (node, ...names) => (node?.props ?? []).some((prop) => prop.type !== ATTRIBUTE && names.includes(prop.name));
+function sectionElements(source, components = []) {
+  const known = /* @__PURE__ */ new Set(["VitaSection", ...components]);
+  let ast;
+  try {
+    const { descriptor, errors } = parse(source);
+    if (errors.length) return { ok: false, reason: `cannot be parsed: ${String(errors[0])}` };
+    ast = descriptor.template?.ast;
+  } catch (error) {
+    return { ok: false, reason: `cannot be parsed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  if (!ast) return { ok: false, reason: "it has no <template>" };
+  const roots = (ast.children ?? []).filter((node) => node.type === ELEMENT);
+  const root = roots.length === 1 ? roots[0] : void 0;
+  const elements = [];
+  const lists = [];
+  const visit = (node, anchor) => {
+    if (node.type === ELEMENT && node.tag) {
+      const tag = node.tag.includes("-") ? pascal(node.tag) : node.tag;
+      const found = (id2) => ({
+        id: id2,
+        tag: node.tag,
+        start: node.loc.start.offset,
+        end: node.loc.end.offset,
+        line: node.loc.start.line,
+        hasContent: hasContent(node),
+        anchor: anchor ?? { start: node.loc.start.offset, end: node.loc.end.offset, line: node.loc.start.line, chained: false }
+      });
+      const id = known.has(tag) ? literalAttribute(node, "id") : void 0;
+      if (id) elements.push(found(id));
+      const list = tag === "VitaPublications" ? literalAttribute(node, "list") : void 0;
+      if (list) lists.push(found(list));
+    }
+    const children = (node.children ?? []).filter((child) => child.type === ELEMENT);
+    for (const [index, child] of children.entries()) {
+      const block = node === root ? { start: child.loc.start.offset, end: child.loc.end.offset, line: child.loc.start.line, chained: directive(children[index + 1], "else", "else-if") } : anchor;
+      visit(child, block);
+    }
+  };
+  visit(ast);
+  return { ok: true, value: { elements, lists, ...root ? { root } : {} } };
+}
+function attribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function sectionElementSource(placement) {
+  return `<${placement.component ?? "VitaSection"} id="${placement.id}"${placement.title ? ` title="${attribute(placement.title)}"` : ""} />`;
+}
+function publicationsElementSource(list, title) {
+  return `<VitaPublications list="${attribute(list)}"${title ? ` title="${attribute(title)}"` : ""} />`;
+}
+function insertElement(source, markup, anchors, root, after) {
+  const sorted = [...anchors].sort((a, b) => a.start - b.start);
+  const found = (after && sorted.find((existing) => existing.id === after)) ?? sorted[sorted.length - 1];
+  if (found) {
+    const { anchor } = found;
+    if (anchor.chained) return { ok: false, reason: `a v-else follows line ${anchor.line}; a line after it would split the v-if from its v-else` };
+    if (source.slice(lineStart(source, anchor.start), anchor.start).trim() || source.slice(anchor.end, lineEnd(source, anchor.end)).trim()) {
+      return { ok: false, reason: `line ${anchor.line} holds other markup too` };
+    }
+    const indent2 = indentationAt(source, anchor.start);
+    return { ok: true, value: { source: insertLinesAfter(source, anchor.end - 1, [`${indent2}${markup}`]), afterSection: found.id } };
+  }
+  if (!root || !root.tag) return { ok: false, reason: "its template has no single root element to add to" };
+  const close = source.lastIndexOf(`</${root.tag}`, root.loc.end.offset);
+  if (close === -1 || close < root.loc.start.offset || source.slice(lineStart(source, close), close).trim() !== "") {
+    return { ok: false, reason: `its <${root.tag}> does not end on a line of its own` };
+  }
+  const indent = `${indentationAt(source, close)}  `;
+  return { ok: true, value: { source: insertLinesBefore(source, close, ["", `${indent}${markup}`]) } };
+}
+function addSectionToPage(source, placement, components = []) {
+  const found = sectionElements(source, components);
+  if (!found.ok) return found;
+  const { elements, lists, root } = found.value;
+  if (elements.some((element) => element.id === placement.id)) return { ok: false, reason: `it already shows ${placement.id}` };
+  const anchors = [...elements, ...lists.filter((list) => list.id === placement.after && !elements.some((element) => element.id === list.id))];
+  return insertElement(source, sectionElementSource(placement), anchors, root, placement.after);
+}
+function addPublicationsToPage(source, placement, components = []) {
+  const found = sectionElements(source, components);
+  if (!found.ok) return found;
+  const { elements, lists, root } = found.value;
+  if (lists.some((list) => list.id === placement.list)) return { ok: false, reason: `it already shows the list ${placement.list}` };
+  return insertElement(source, publicationsElementSource(placement.list, placement.title), [...elements, ...lists], root, placement.after);
+}
+function useComponentForSection(source, id, component, components = []) {
+  const found = sectionElements(source, components);
+  if (!found.ok) return found;
+  const elements = found.value.elements.filter((element) => element.id === id);
+  if (!elements.length) return { ok: false, reason: `it does not show ${id}` };
+  const blocked = elements.find((element) => element.hasContent);
+  if (blocked) return { ok: false, reason: `line ${blocked.line} has content of its own, such as slots; move it into the component` };
+  const changed = [];
+  let result = source;
+  for (const element of [...elements].reverse()) {
+    if (element.tag === component) continue;
+    let text = result.slice(element.start, element.end);
+    text = `<${component}${text.slice(element.tag.length + 1)}`;
+    if (text.endsWith(`</${element.tag}>`)) text = `${text.slice(0, -(element.tag.length + 3))}</${component}>`;
+    result = result.slice(0, element.start) + text + result.slice(element.end);
+    changed.unshift(element.line);
+  }
+  return { ok: true, value: { source: result, changed } };
+}
+function publicationsElements(source) {
+  let ast;
+  try {
+    const { descriptor, errors } = parse(source);
+    if (errors.length) return { ok: false, reason: `cannot be parsed: ${String(errors[0])}` };
+    ast = descriptor.template?.ast;
+  } catch (error) {
+    return { ok: false, reason: `cannot be parsed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const found = [];
+  const visit = (node) => {
+    if (node.type === ELEMENT && node.tag && (node.tag.includes("-") ? pascal(node.tag) : node.tag) === "VitaPublications") {
+      found.push({
+        tag: node.tag,
+        start: node.loc.start.offset,
+        line: node.loc.start.line,
+        hasContent: hasContent(node),
+        props: (node.props ?? []).map((prop) => ({
+          name: prop.type === ATTRIBUTE ? prop.name : prop.name === "bind" && prop.arg ? prop.arg.content : `v-${prop.name}`,
+          start: prop.loc.start.offset,
+          end: prop.loc.end.offset,
+          ...prop.type === ATTRIBUTE ? prop.value ? { value: prop.value.content } : {} : { expression: prop.exp?.content ?? "" }
+        }))
+      });
+    }
+    for (const child of node.children ?? []) visit(child);
+  };
+  if (ast) visit(ast);
+  return { ok: true, value: found };
+}
+
+export { addPublicationsToPage, addSectionToPage, publicationsElementSource, publicationsElements, sectionElementSource, sectionElements, useComponentForSection };

package/dist/chunks/yaml.mjs

@@ -0,0 +1,62 @@
+import { parseDocument, isMap, isScalar, isSeq } from 'yaml';
+import { l as lineStart, a as lineEnd } from '../shared/vitakit.UfoXdL7U.mjs';
+
+function yamlScalar(value) {
+  return /^[A-Za-z0-9/][\w ./()'-]*$/.test(value) && !/(^|\s)#|:\s|\s$/.test(value) ? value : JSON.stringify(value);
+}
+function addNavItem(source, item) {
+  const document = parseDocument(source);
+  if (document.errors.length) return { ok: false, reason: `cannot be parsed: ${document.errors[0].message}` };
+  if (!isMap(document.contents)) return { ok: false, reason: "it is not a map of settings" };
+  const entry = `- { label: ${yamlScalar(item.label)}, to: ${yamlScalar(item.to)} }`;
+  const nav = document.contents.get("nav", true);
+  if (nav === void 0) {
+    const ending = source.endsWith("\n") ? "" : "\n";
+    return { ok: true, value: `${source}${ending}
+nav:
+  ${entry}
+` };
+  }
+  if (!isSeq(nav) || nav.flow) return { ok: false, reason: "its nav is not a list with one entry per line" };
+  if (nav.items.some((existing) => isMap(existing) && existing.get("to") === item.to)) {
+    return { ok: false, reason: `its menu already links ${item.to}` };
+  }
+  const last = nav.items[nav.items.length - 1];
+  if (!last?.range) return { ok: false, reason: "its nav is empty; add the first entry by hand" };
+  const start = lineStart(source, last.range[0]);
+  const prefix = /^[ \t]*-[ \t]*/.exec(source.slice(start))?.[0];
+  if (!prefix) return { ok: false, reason: "its nav entries are not one per line" };
+  const end = lineEnd(source, last.range[1] - 1);
+  const indent = prefix.slice(0, prefix.indexOf("-"));
+  return { ok: true, value: `${source.slice(0, end)}
+${indent}${entry}${source.slice(end)}` };
+}
+function flow(value) {
+  if (Array.isArray(value)) return `[${value.map(flow).join(", ")}]`;
+  if (value && typeof value === "object") return `{ ${Object.entries(value).map(([key, item]) => `${yamlScalar(key)}: ${flow(item)}`).join(", ")} }`;
+  return typeof value === "string" ? yamlScalar(value) : String(value);
+}
+function publicationListYaml(name, settings) {
+  const lines = Object.entries(settings).filter(([, value]) => value !== void 0).map(([key, value]) => `  ${key}: ${flow(value)}`);
+  return lines.length ? `${name}:
+${lines.join("\n")}` : `${name}: {}`;
+}
+function publicationListLine(source, name) {
+  const document = parseDocument(source);
+  const pair = isMap(document.contents) ? document.contents.items.find((item) => isScalar(item.key) && item.key.value === name) : void 0;
+  const offset = pair?.key?.range?.[0];
+  return offset === void 0 ? void 0 : source.slice(0, offset).split("\n").length;
+}
+function addPublicationList(source, name, settings) {
+  const document = parseDocument(source);
+  if (document.errors.length) return { ok: false, reason: `cannot be parsed: ${document.errors[0].message}` };
+  if (document.contents !== null && !isMap(document.contents)) return { ok: false, reason: "it is not one list per name" };
+  if (isMap(document.contents) && document.contents.flow) return { ok: false, reason: "its lists are written on one line" };
+  const line = publicationListLine(source, name);
+  if (line !== void 0) return { ok: false, reason: `it has a list "${name}" already, on line ${line}` };
+  const body = source.replace(/\s*$/, "");
+  return { ok: true, value: `${body}${body ? "\n\n" : ""}${publicationListYaml(name, settings)}
+` };
+}
+
+export { addNavItem, addPublicationList, publicationListLine, publicationListYaml, yamlScalar };

package/dist/cli.d.mts

@@ -1,45 +1,38 @@
-interface AddOptions {
-    /**
-     * Also scaffold `app/components/<Name>Section.vue`. On by default: a section
-     * without a component renders through the generic one, which is a fallback
-     * rather than a design.
-     */
-    component?: boolean;
+interface Io {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    /** Write to stdout; text is written as is, add `\n` yourself. */
+    out: (text: string) => void;
+    err: (text: string) => void;
+    /** Whether a person can answer questions: stdin and stdout are terminals. */
+    interactive: boolean;
+    /** Whether stdout is a terminal, for colour. */
+    tty: boolean;
+    /** Width of the terminal, when stdout is one. */
+    columns?: number;
+    /** Ask a question and return the answer; only called when `interactive`. */
+    ask: (question: string) => Promise<string>;
 }
-interface WrittenFile {
-    path: string;
-    /** Why it was written, for the command's output. */
-    note: string;
-}
-/**
- * Create what is missing for a section: the YAML file, the schema, optionally
- * a component. Existing files are never touched.
- */
-declare function addSection(id: string, rootDir: string, options?: AddOptions): Promise<WrittenFile[]>;
 
-interface EjectableItem {
-    /** Name to pass to `eject`, e.g. `VitaSection`, `talks.eta` or `teaching`. */
-    name: string;
-    kind: 'component' | 'template' | 'class' | 'schema' | 'style';
-    /** Absolute source path inside the package. */
-    source: string;
-    /** Destination relative to the project root. */
-    target: string;
-}
-/** Everything that can be copied into a project. */
-declare function listEjectable(): Promise<EjectableItem[]>;
-interface EjectResult {
-    item: EjectableItem;
-    /** Absolute path written. */
-    path: string;
-}
+declare function main(argv: string[], io?: Io): Promise<number>;
+
+type PackageManager = 'pnpm' | 'npm';
 /**
- * Copy a package default into the project, where it then wins by the normal
- * resolution rule. Never overwrites without `force`.
+ * The package manager that started this process, from the user agent npm and
+ * pnpm set for everything they run (`npm run`, `npx`, `pnpm <script>`,
+ * `pnpm exec`); anything but npm gets pnpm, the default, as in the creator.
+ * A binary run directly has no user agent; the project's lockfile decides.
  */
-declare function eject(name: string, rootDir: string, { force }?: {
-    force?: boolean | undefined;
-}): Promise<EjectResult>;
+declare function detectPackageManager(rootDir?: string, env?: NodeJS.ProcessEnv): PackageManager;
+interface Commands {
+    /** A script from package.json: `pnpm pdf cv`, `npm run pdf -- cv`. */
+    script: (name: string, args?: string) => string;
+    /** A binary of an installed package: `pnpm vitakit status`, `npx vitakit status`. */
+    bin: (name: string, args?: string) => string;
+}
+declare function commands(packageManager?: PackageManager): Commands;
+/** Lines of `command  # comment`, with the comments aligned. */
+declare function aligned(rows: [command: string, comment?: string][], indent?: string): string;
 
-export { addSection, eject, listEjectable };
-export type { AddOptions, EjectResult, EjectableItem, WrittenFile };
+export { aligned, commands, detectPackageManager, main };
+export type { Commands, Io, PackageManager };

package/dist/cli.mjs

@@ -1,225 +1,8 @@
-import { readFile, mkdir, writeFile, copyFile, readdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join, relative, basename } from 'node:path';
-import { s as schemas, o as resolveAsset } from './shared/vitakit.BxcnlFGP.mjs';
-import { b as bundledTexDir } from './shared/vitakit.BRhjqpAt.mjs';
-import { parse } from 'yaml';
+export { a as aligned, c as commands, d as detectPackageManager, m as main } from './shared/vitakit.zwr1ssO5.mjs';
+import 'node:fs';
+import 'node:path';
+import './shared/vitakit.DQ6PmGoL.mjs';
 import 'node:url';
-import 'zod';
-import 'eta';
-import './shared/index.mjs';
-import './shared/vitakit.BlU-p01e.mjs';
-
-const DATE_LIKE = /^\d{4}(-\d{2}){0,2}$/;
-function pascalCase(id) {
-  return id.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function inferField(values, present, total) {
-  const optional = present < total ? ".optional()" : "";
-  const sample = values[0];
-  if (typeof sample === "boolean") return `z.boolean().default(false)`;
-  if (typeof sample === "number" && !DATE_LIKE.test(String(sample))) return `z.number()${optional}`;
-  if (values.every((value) => DATE_LIKE.test(String(value)))) return `dateRange${optional}`;
-  if (typeof sample === "object" && sample !== null && "from" in sample) return `dateRange${optional}`;
-  if (typeof sample === "string" && /^https?:\/\//.test(sample)) return `url${optional}`;
-  const strings = values.filter((value) => typeof value === "string");
-  const unique = [...new Set(strings)];
-  if (strings.length === values.length && unique.length > 1 && unique.length <= Math.max(2, values.length / 2) && unique.every((value) => /^[a-z][\w-]*$/.test(value))) {
-    return `z.enum([${unique.map((value) => `'${value}'`).join(", ")}])${optional}`;
-  }
-  if (typeof sample === "string") return `text${optional}`;
-  return `z.unknown()${optional}`;
-}
-function inferSchema(entries) {
-  const fields = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    for (const [key, value] of Object.entries(entry)) {
-      if (key === "visibility") continue;
-      if (!fields.has(key)) fields.set(key, []);
-      if (value !== void 0 && value !== null) fields.get(key).push(value);
-    }
-  }
-  const used = /* @__PURE__ */ new Set(["section"]);
-  const lines = [];
-  for (const [key, values] of fields) {
-    const present = entries.filter((entry) => entry[key] !== void 0).length;
-    let type = inferField(values, present, entries.length);
-    if (/^(title|headline)$/.test(key) && type.startsWith("text")) type = type.replace("text", "richText");
-    for (const primitive of ["dateRange", "richText", "text", "url", "z"]) {
-      if (new RegExp(`\\b${primitive}\\b`).test(type)) used.add(primitive);
-    }
-    lines.push(`  ${key}: ${type},`);
-  }
-  return { body: lines.join("\n"), imports: [...used].sort() };
-}
-const SAMPLE_YAML = (id) => `# ${id}: one entry per item, newest first is not required --
-# vitakit sorts by date for you. Edit the fields, then edit schemas/${id}.ts
-# to match.
-- date: 2025-03-14
-  title: An example entry
-  note: Replace this with something real.
-`;
-function schemaModule(id, body, imports, inferred) {
-  return [
-    `/**`,
-    ` * Shape of content/${id}.yml.`,
-    ` *`,
-    inferred ? ` * Drafted from the existing file: check the types, especially which fields
- * are optional and whether any should be an enum.` : ` * Edit freely: this file defines what content/${id}.yml may contain.`,
-    ` *`,
-    ` * \`section()\` adds \`visibility\` and validates a list of entries.`,
-    ` */`,
-    `import { ${imports.join(", ")} } from '@anja.codes/vitakit'`,
-    ``,
-    `export default section({`,
-    body || `  date: dateRange,
-  title: richText,`,
-    `})`,
-    ``
-  ].join("\n");
-}
-function componentModule(id) {
-  `${pascalCase(id)}Section`;
-  return `<script setup lang="ts">
-/**
- * How ${id} entries look. Yours to change: props in, markup out.
- *
- * \`useSection('${id}')\` returns validated, sorted entries; \`VitaEntry\`,
- * \`VitaDate\` and \`richHtml\` come from vitakit.
- */
-import { richHtml, type Entry } from '@anja.codes/vitakit/shared'
-
-const props = defineProps<{ entries?: Entry[], limit?: number }>()
-
-const items = computed(() => {
-  const source = props.entries ?? useSection('${id}')
-  return props.limit ? source.slice(0, props.limit) : source
-})
-<\/script>
-
-<template>
-  <ul v-if="items.length" class="vita-section">
-    <VitaEntry v-for="item in items" :key="item.id" :date="item.date as never">
-      <p class="vita-entry__title" v-html="richHtml(item.title)" />
-      <p v-if="typeof item.note === 'string'" class="vita-entry__note">
-        {{ item.note }}
-      </p>
-    </VitaEntry>
-  </ul>
-</template>
-`;
-}
-async function addSection(id, rootDir, options = {}) {
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)) {
-    throw new Error(`"${id}" must be lowercase kebab-case, e.g. research-stays`);
-  }
-  if (id in schemas) {
-    throw new Error(
-      `"${id}" is a built-in section: create content/${id}.yml and it works.
-  To change which fields it may contain, copy its schema into your project:
-      pnpm vitakit eject ${id}
-  and edit schemas/${id}.ts.`
-    );
-  }
-  const written = [];
-  const yamlPath = join(rootDir, "content", `${id}.yml`);
-  const schemaPath = join(rootDir, "schemas", `${id}.ts`);
-  let entries = [];
-  let inferred = false;
-  if (existsSync(yamlPath)) {
-    const parsed = parse(await readFile(yamlPath, "utf8"));
-    if (!Array.isArray(parsed)) throw new Error(`content/${id}.yml must contain a list of entries`);
-    entries = parsed.filter((entry) => typeof entry === "object" && entry !== null);
-    if (!entries.length) throw new Error(`content/${id}.yml has no entries to infer a schema from`);
-    inferred = true;
-  } else {
-    await mkdir(join(yamlPath, ".."), { recursive: true });
-    await writeFile(yamlPath, SAMPLE_YAML(id));
-    written.push({ path: yamlPath, note: "your data \u2014 edit this first" });
-    entries = [{ date: "2025-03-14", title: "An example entry", note: "Replace this." }];
-  }
-  if (existsSync(schemaPath)) {
-    throw new Error(`schemas/${id}.ts already exists; delete it first to regenerate`);
-  }
-  const { body, imports } = inferSchema(entries);
-  await mkdir(join(schemaPath, ".."), { recursive: true });
-  await writeFile(schemaPath, schemaModule(id, body, imports, inferred));
-  written.push({ path: schemaPath, note: inferred ? `drafted from content/${id}.yml` : "the shape of an entry" });
-  if (options.component !== false) {
-    const componentPath = join(rootDir, "app", "components", `${pascalCase(id)}Section.vue`);
-    if (!existsSync(componentPath)) {
-      await mkdir(join(componentPath, ".."), { recursive: true });
-      await writeFile(componentPath, componentModule(id));
-      written.push({ path: componentPath, note: "how the entries look" });
-    }
-  }
-  return written.map((file) => ({ ...file, path: relative(rootDir, file.path) }));
-}
-
-async function listEjectable() {
-  const items = [];
-  const componentsDir = resolveAsset("runtime/components");
-  for (const file of (await readdir(componentsDir)).filter((name) => name.endsWith(".vue")).sort()) {
-    items.push({
-      name: basename(file, ".vue"),
-      kind: "component",
-      source: join(componentsDir, file),
-      target: join("app", "components", file)
-    });
-  }
-  const templatesDir = join(bundledTexDir, "templates");
-  for (const file of (await readdir(templatesDir)).filter((name) => name.endsWith(".eta")).sort()) {
-    items.push({
-      name: file,
-      kind: "template",
-      source: join(templatesDir, file),
-      target: join("cv-tex", "templates", file)
-    });
-  }
-  const schemaDir = resolveAsset("schemas");
-  for (const file of (await readdir(schemaDir)).filter((name) => name.endsWith(".ts")).sort()) {
-    const id = basename(file, ".ts");
-    items.push({
-      name: id,
-      kind: "schema",
-      source: join(schemaDir, file),
-      target: join("schemas", file)
-    });
-  }
-  items.push({
-    name: "publications.csl",
-    kind: "style",
-    // The path of `defaultCslStyle`, without loading citation-js to get it.
-    source: join(resolveAsset("styles"), "vitakit-math.csl"),
-    target: join("content", "publications.csl")
-  });
-  items.push({
-    name: "vitakit-cv.cls",
-    kind: "class",
-    source: join(bundledTexDir, "vitakit-cv.cls"),
-    target: join("cv-tex", "vitakit-cv.cls")
-  });
-  return items;
-}
-async function eject(name, rootDir, { force = false } = {}) {
-  const items = await listEjectable();
-  const item = items.find((candidate) => candidate.name === name) ?? items.find((candidate) => candidate.name.toLowerCase() === name.toLowerCase());
-  if (!item) {
-    const known = items.map((candidate) => candidate.name).join(", ");
-    throw new Error(`unknown item "${name}". Available: ${known}`);
-  }
-  const path = join(rootDir, item.target);
-  if (existsSync(path) && !force) {
-    throw new Error(`${relative(rootDir, path)} already exists; pass --force to overwrite`);
-  }
-  await mkdir(join(path, ".."), { recursive: true });
-  if (item.kind === "schema") {
-    const source = await readFile(item.source, "utf8");
-    await writeFile(path, source.replace(/from '\.\.\/[\w-]+'/g, "from '@anja.codes/vitakit'"));
-  } else {
-    await copyFile(item.source, path);
-  }
-  return { item, path };
-}
-
-export { addSection, eject, listEjectable };
+import 'node:process';
+import 'node:util';
+import 'node:readline/promises';