@anja.codes/vitakit 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,159 @@
+# @anja.codes/vitakit
+
+Structured CV data in, academic website and LaTeX CV out.
+
+```bash
+pnpm create @anja.codes/vitakit my-site
+cd my-site && pnpm install
+pnpm dev            # the website
+pnpm build:cv       # cv-tex/cv.pdf, from the same data
+```
+
+To add it to an existing Nuxt project instead:
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@anja.codes/vitakit/nuxt'],
+})
+```
+
+## Documentation
+
+[Getting started](./docs/getting-started.md) ·
+[Content reference](./docs/content-reference.md) ·
+[Commands](./docs/cli.md) ·
+[Customising](./docs/customising.md) ·
+[CV documents](./docs/cv-documents.md) ·
+[Privacy](./docs/privacy.md) ·
+[Troubleshooting](./docs/troubleshooting.md)
+
+## What it does
+
+`content/` is compiled at build time into a typed module. Markdown and TeX are
+rendered with remark and KaTeX, BibTeX with citation-js, and every file is
+validated with Zod. Nothing content-related reaches the browser: no Markdown
+parser, no content database, no KaTeX runtime.
+
+```
+content/
+  profile.yml           name, affiliation, links, navigation, footer
+  <section>.yml         education, employment, teaching, talks, …
+  publications.bib      grouped, linked reference list
+  publications.csl      optional: its citation style on the website
+  pages/*.md            prose pages, math and images included
+schemas/<section>.ts    optional: change a built-in schema, or add your own
+schemas/publications.ts optional: publication groups, badges, fields
+```
+
+## Composables
+
+| | |
+|---|---|
+| `useSection(id)` | validated, sorted, visibility-filtered entries |
+| `usePublications()` | reference groups; each entry has its formatted `html` and its `badges` as data |
+| `usePage(route)`, `usePages()` | compiled Markdown pages |
+| `useProfile()` | everything in `profile.yml`, including `nav` |
+| `useVitakit()` | everything, including `issues` |
+
+## Components
+
+`VitaSection`, `VitaEntry`, `VitaDate`, `VitaLinks`, `VitaPublications`,
+`VitaPublication`, `VitaMarkdown`, `VitaIssues`. All are thin: they take props and emit markup, so
+ejecting one into your own repo leaves nothing behind that can silently break.
+
+## Sections
+
+A file `content/<name>.yml` is a section. Its schema is found by convention:
+`schemas/<name>.ts` in your repo wins, otherwise the built-in schema for
+`<name>` is used, otherwise the build fails with a starter snippet.
+
+```ts
+// schemas/outreach.ts
+import { section, dateRange, richText, institution } from '@anja.codes/vitakit'
+
+export default section({
+  date: dateRange,
+  title: richText,          // Markdown and $math$ allowed
+  venue: institution.optional(),
+})
+```
+
+Every entry gets `visibility: public | cv | private`. The website loader is
+hard-wired to `public`, so a phone number, an address or a referee marked `cv`
+cannot reach the site; the other levels exist for the LaTeX side. Assume the
+repository itself is private, and let `vitakit-check` verify the build output.
+
+PDFs are never part of the website build: `build:cv` writes to `cv-tex/`, and
+the website renders CV information directly from the same data.
+
+## Strict builds, forgiving development
+
+A broken file fails `nuxt generate`, naming the file, the entry and the field.
+The same problem during `nuxt dev` is reported instead of thrown: the page shows
+its error, `VitaIssues` lists all of them, and saving a fix recovers in place —
+a typo never takes down the dev server.
+
+## Status
+
+Early but complete in both halves: website and PDF are produced from the same
+content, with strict builds, forgiving development, output assertions and a
+scaffolder whose output is regenerated and tested in CI.
+
+Not yet implemented: cover-letter helpers (`\vitacount`, `\vitafirst`), a
+`schema` command to draft a schema from existing YAML, a second theme, and a
+Typst target.
+
+MIT
+
+## LaTeX CV
+
+```bash
+pnpm build:cv          # every document in cv-tex/
+pnpm build:cv cv       # one document
+pnpm build:cv --no-pdf # only generate .tex
+```
+
+A **document** is a `.tex` file you own. vitakit renders `content/` into
+`cv-tex/generated/<document>/`, one file per section, and `latexmk` typesets it.
+No `-shell-escape`, no Python.
+
+```tex
+\documentclass{vitakit-cv}
+\vitadocument{cv}
+\addbibresource{../content/publications.bib}
+\input{preamble.tex}
+\input{generated/cv/profile.tex}
+
+\begin{document}
+\vitaheader
+\vitasection{employment}     % order lives here: move a line, move a section
+\vitasection{education}
+\section{Publications}\vitainput{publications}
+\end{document}
+```
+
+An optional `cv-tex/<name>.yml` decides *what* goes in:
+
+```yaml
+visibility: cv        # include public and cv entries, not private
+sections:
+  talks:
+    where: { kind: invited }
+    limit: 10
+```
+
+Copy `cv.tex` to make a variant; a document is just a file. Generated files use
+only the macros in `vitakit-cv.cls` (`\vitaentry`, `\vitanote`, `\vitasection`),
+so redefining those in `preamble.tex` restyles everything. Any template can be
+overridden by putting a file of the same name in `cv-tex/templates/`.
+
+## Starting a project
+
+```bash
+pnpm create @anja.codes/vitakit my-site
+```
+
+See [`@anja.codes/create-vitakit`](./create). The scaffolded output is kept in
+[`examples/scaffolded`](./examples/scaffolded), regenerated by
+`pnpm example` and verified in CI, so it cannot drift from the package.

package/dist/check.d.mts

@@ -0,0 +1,22 @@
+interface CheckOptions {
+    rootDir: string;
+    /** Generated site; defaults to `.output/public`. */
+    outDir?: string;
+    baseURL?: string;
+    /**
+     * Skip the leak check. It compares text of non-public entries against the
+     * generated pages, which is a heuristic: a title or institution that is
+     * legitimately public elsewhere looks like a leak. Turn it off rather than
+     * rewording content to satisfy it.
+     */
+    skipLeakCheck?: boolean;
+}
+interface CheckResult {
+    /** Human-readable summary lines for what was verified. */
+    checked: string[];
+    failures: string[];
+}
+declare function checkStatic(options: CheckOptions): Promise<CheckResult>;
+
+export { checkStatic };
+export type { CheckOptions, CheckResult };

package/dist/check.mjs

@@ -0,0 +1,196 @@
+import { readFile, stat, readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { l as loadContent } from './shared/vitakit.CypCF-4Q.mjs';
+import { M as MARKER_KEY, k as atMost } from './shared/vitakit.BxcnlFGP.mjs';
+import { r as richSource, a as richHtml } from './shared/vitakit.BlU-p01e.mjs';
+import 'gray-matter';
+import 'yaml';
+import 'unified';
+import 'remark-parse';
+import 'remark-gfm';
+import 'remark-math';
+import 'remark-rehype';
+import 'rehype-katex';
+import 'rehype-raw';
+import 'rehype-stringify';
+import 'unist-util-visit';
+import 'node:fs';
+import '@behackl/citation-js-extras';
+import 'rehype-parse';
+import 'rehype-sanitize';
+import 'zod';
+import 'node:url';
+
+async function exists(path) {
+  return stat(path).then(() => true, () => false);
+}
+async function htmlFiles(dir) {
+  const found = [];
+  for (const item of await readdir(dir, { withFileTypes: true })) {
+    const path = join(dir, item.name);
+    if (item.isDirectory()) found.push(...await htmlFiles(path));
+    else if (item.name.endsWith(".html")) found.push(path);
+  }
+  return found;
+}
+const IDENTIFYING = ["title", "position", "degree", "student", "event", "thesis", "project"];
+function identifyingText(entry) {
+  const parts = [];
+  const add = (value) => {
+    const source = richSource(value);
+    if (source) {
+      parts.push(source);
+      const html = richHtml(value);
+      if (html && html !== source) parts.push(html);
+      const prose = source.split(/\$\$[\s\S]*?\$\$|\$(?:\\.|[^$\\])*\$/);
+      if (prose.length > 1) parts.push(...prose.filter((part) => part.trim().length >= 20));
+    } else if (typeof value === "object" && value !== null && "title" in value) {
+      add(value.title);
+    }
+  };
+  for (const field of IDENTIFYING) add(entry[field]);
+  return [...new Set(parts.map((part) => normaliseText(part)))].filter((part) => part.length >= 12);
+}
+const isRootRelative = (value) => value.startsWith("/") && !value.startsWith("//");
+const underBase = (path, base) => path.startsWith(base) || `${path}/` === base;
+function assetReferences(html) {
+  const found = [];
+  for (const [tag] of html.matchAll(/<(?:script|link)\b[^>]*>/gi)) {
+    const value = /\s(?:src|href)\s*=\s*(["'])(.*?)\1/i.exec(tag)?.[2];
+    if (value && isRootRelative(value)) found.push(value);
+  }
+  return found;
+}
+function urlReferences(html) {
+  const found = [];
+  for (const match of html.matchAll(/\s(src|href|poster|data|action|formaction|srcset)\s*=\s*(["'])(.*?)\2/gi)) {
+    const values = match[1].toLowerCase() === "srcset" ? match[3].split(/\s*,\s+|\s*,(?=\/)/).map((candidate) => candidate.trim().split(/\s+/)[0]) : [match[3]];
+    found.push(...values.filter(isRootRelative));
+  }
+  return found;
+}
+async function existsInSite(outDir, path) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(path.replace(/[?#].*$/, ""));
+  } catch {
+    return false;
+  }
+  const target = join(outDir, decoded);
+  if (relative(outDir, target).startsWith("..")) return false;
+  const found = await stat(target).catch(() => void 0);
+  if (found?.isFile()) return true;
+  return found?.isDirectory() === true && (await stat(join(target, "index.html")).catch(() => void 0))?.isFile() === true;
+}
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
+function decodeEntity(reference, name) {
+  if (name[0] === "#") {
+    const code = name[1] === "x" || name[1] === "X" ? Number.parseInt(name.slice(2), 16) : Number(name.slice(1));
+    return Number.isInteger(code) && code >= 0 && code <= 1114111 ? String.fromCodePoint(code) : reference;
+  }
+  return ENTITIES[name] ?? reference;
+}
+function normaliseText(html) {
+  return html.replace(/<(script|style)[\s\S]*?<\/\1>/gi, " ").replace(/<[^>]*>/g, " ").replace(/&(#\d+|#x[0-9a-f]+|[a-z]+);/gi, decodeEntity).replace(/\s+/g, " ").trim();
+}
+async function checkStatic(options) {
+  const outDir = join(options.rootDir, options.outDir ?? ".output/public");
+  const base = options.baseURL ?? process.env.NUXT_APP_BASE_URL ?? "/";
+  const checked = [];
+  const failures = [];
+  const fail = (message) => failures.push(message);
+  if (!await exists(outDir)) {
+    return { checked, failures: [`no generated site at ${outDir}; run \`nuxt generate\` first`] };
+  }
+  let content;
+  try {
+    content = await loadContent(options.rootDir, { strict: true, baseURL: base, maxVisibility: "private" });
+  } catch (error) {
+    return { checked, failures: [`content did not load: ${error instanceof Error ? error.message : String(error)}`] };
+  }
+  const files = await htmlFiles(outDir);
+  const pages = /* @__PURE__ */ new Map();
+  for (const file of files) pages.set(file, await readFile(file, "utf8"));
+  for (const page of content.pages) {
+    const file = join(outDir, page.route === "/" ? "index.html" : `${page.route.slice(1)}index.html`);
+    if (!await exists(file)) fail(`page ${page.route} was not generated (${file})`);
+  }
+  checked.push(`${content.pages.length} page(s) generated`);
+  let mathPages = 0;
+  for (const [file, html] of pages) {
+    if (html.includes("katex-error")) fail(`${file}: KaTeX reported an error`);
+    if (html.includes('class="katex')) mathPages += 1;
+    if (html.includes(MARKER_KEY)) fail(`${file}: an unrendered rich-text marker reached the output`);
+  }
+  checked.push(`mathematics rendered on ${mathPages} page(s)`);
+  const assets = [...pages.values()].flatMap(assetReferences);
+  const strayAssets = assets.filter((path) => !underBase(path, base));
+  const recorded = [...pages.values()].map((html) => /\bapp:\{baseURL:"([^"]*)"/.exec(html)?.[1]).find((value) => value !== void 0 && value !== base);
+  const builtForBase = !strayAssets.length && recorded === void 0;
+  if (!builtForBase) {
+    const evidence = recorded === void 0 ? `e.g. ${strayAssets[0]}` : `it was built for ${recorded}`;
+    fail(
+      `assets do not use the base path ${base} (${evidence}); the site was built for a different base. Set NUXT_APP_BASE_URL to the same value for \`nuxt generate\` and for this check.`
+    );
+  }
+  checked.push(`base path ${base}`);
+  if (!options.skipLeakCheck) {
+    const text = new Map([...pages].map(([file, html]) => [file, normaliseText(html)]));
+    let hidden = 0;
+    let leaked = 0;
+    for (const [id, entries] of Object.entries(content.sections)) {
+      for (const [index, entry] of entries.entries()) {
+        if (atMost(entry.visibility, "public")) continue;
+        hidden += 1;
+        const fragments = identifyingText(entry);
+        let found = false;
+        for (const [file, body] of text) {
+          const fragment = fragments.find((candidate) => body.includes(candidate));
+          if (fragment === void 0) continue;
+          found = true;
+          fail(
+            `content/${id}.yml entry ${index + 1} is marked "${entry.visibility}" but its text appears in ${relative(outDir, file)}: "${fragment.slice(0, 60)}${fragment.length > 60 ? "\u2026" : ""}".
+  Either raise the entry's visibility or stop rendering it on that page (pass --no-leak-check if the match is a coincidence).`
+          );
+        }
+        if (found) leaked += 1;
+      }
+    }
+    checked.push(`${hidden - leaked} of ${hidden} non-public entr(ies) absent from the site`);
+  }
+  if (base !== "/" && builtForBase) {
+    const escaped = /* @__PURE__ */ new Set();
+    for (const [file, html] of pages) {
+      for (const path of urlReferences(html)) {
+        if (!underBase(path, base)) escaped.add(`${relative(outDir, file)}: ${path}`);
+      }
+    }
+    for (const problem of escaped) {
+      fail(`${problem} does not use the base path ${base}; in a component, use <NuxtLink> or prefix it with useRuntimeConfig().app.baseURL`);
+    }
+  }
+  checked.push(`assets and links use ${base}`);
+  if (builtForBase) {
+    const missing = /* @__PURE__ */ new Map();
+    for (const [file, html] of pages) {
+      for (const path of urlReferences(html)) {
+        if (!underBase(path, base) || missing.has(path)) continue;
+        if (!await existsInSite(outDir, path.slice(base.length))) missing.set(path, relative(outDir, file));
+      }
+    }
+    for (const [path, file] of missing) {
+      fail(`${file}: ${path} leads nowhere: no such file or page in the generated site. A file belongs in public/, a page in content/pages/ or app/pages/`);
+    }
+    checked.push("links into the site lead somewhere");
+  }
+  if (content.publications.length) {
+    const bibPages = [...pages].filter(([, html]) => html.includes("vita-bib"));
+    for (const [file, html] of bibPages) {
+      if (/bibmathplaceholderx*\d+end/i.test(html)) fail(`${relative(outDir, file)}: a formula in the bibliography was not rendered`);
+    }
+    checked.push(bibPages.length ? `bibliography on ${bibPages.length} page(s)` : "bibliography not shown on any page (fine if publications.bib is only for the PDF)");
+  }
+  return { checked, failures };
+}
+
+export { checkStatic };

package/dist/cli.d.mts

@@ -0,0 +1,45 @@
+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 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;
+}
+/**
+ * Copy a package default into the project, where it then wins by the normal
+ * resolution rule. Never overwrites without `force`.
+ */
+declare function eject(name: string, rootDir: string, { force }?: {
+    force?: boolean | undefined;
+}): Promise<EjectResult>;
+
+export { addSection, eject, listEjectable };
+export type { AddOptions, EjectResult, EjectableItem, WrittenFile };

package/dist/cli.mjs

@@ -0,0 +1,225 @@
+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';
+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 };