@anja.codes/vitakit 0.1.0 → 0.3.0

package/dist/{shared/vitakit.CypCF-4Q.mjs → chunks/bibliography.mjs}

@@ -1,22 +1,22 @@
-import { readFile, stat, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { stat, readFile } from 'node:fs/promises';
 import { join, isAbsolute, resolve } from 'node:path';
-import matter from 'gray-matter';
-import { parse } from 'yaml';
+import { r as resolveAsset } from '../shared/vitakit.DQ6PmGoL.mjs';
+import { badgePresets, Bibliography } from '@behackl/citation-js-extras';
 import { unified } from 'unified';
+import rehypeParse from 'rehype-parse';
+import rehypeSanitize, { defaultSchema } from 'rehype-sanitize';
+import rehypeStringify from 'rehype-stringify';
 import remarkParse from 'remark-parse';
 import remarkGfm from 'remark-gfm';
 import remarkMath from 'remark-math';
 import remarkRehype from 'remark-rehype';
 import rehypeKatex from 'rehype-katex';
 import rehypeRaw from 'rehype-raw';
-import rehypeStringify from 'rehype-stringify';
 import { visit } from 'unist-util-visit';
-import { m as fail, p as formatZodIssues, o as resolveAsset, q as importProjectModule, s as schemas, k as atMost, w as renderRichFields, x as resolveSitePaths, I as Issues, y as profile, z as absoluteSitePath, A as whereOf, B as messageOf, C as page } from './vitakit.BxcnlFGP.mjs';
-import { existsSync } from 'node:fs';
-import { badgePresets, Bibliography } from '@behackl/citation-js-extras';
-import rehypeParse from 'rehype-parse';
-import rehypeSanitize, { defaultSchema } from 'rehype-sanitize';
+import { f as fail, a as formatZodIssues, I as Issues, i as importProjectModule } from '../shared/vitakit.DCK90zq4.mjs';
 import { z } from 'zod';
+import { LISTS_FILE, selectPublications, publicationStatus } from './publication-lists.mjs';
 
 const URL_PROPERTIES = ["href", "src", "poster", "data", "action", "formAction"];
 const isRootRelative = (value) => value.startsWith("/") && !value.startsWith("//");
@@ -81,7 +81,7 @@ ${details}`);
   }
   function inline(source) {
     const html = markdown(source);
-    const unwrapped = /^<p>([\s\S]*)<\/p>$/.exec(html);
+    const unwrapped = /^<p>((?:(?!<\/p>)[\s\S])*)<\/p>$/.exec(html);
     if (!unwrapped) throw new Error(`expected a single paragraph, got: ${html}`);
     return unwrapped[1];
   }
@@ -102,30 +102,34 @@ const badge = z.strictObject({
   className: z.string().optional()
 });
 const input = z.strictObject({
-  groups: z.array(z.strictObject({
+  statuses: z.array(z.strictObject({
     id: z.string().regex(ID, "expected a lowercase id such as `preprint` or `talk-slides`"),
     label: z.string().trim().min(1)
-  })).min(1, "expected at least one group").optional(),
-  defaultGroup: z.string().optional(),
+  })).min(1, "expected at least one status").optional(),
+  defaultStatus: z.string().optional(),
   badges: z.array(badge).optional(),
   fields: z.array(z.string().regex(/^[a-z][a-z0-9_-]*$/i, "expected a BibTeX field name")).optional(),
   cslStyle: z.string().trim().min(1).optional()
 });
-function resolvePublications(value, defaults = { groups: [], defaultGroup: "", badges: [], fields: [] }, where = "schemas/publications.ts") {
+function resolvePublications(value, defaults = { statuses: [], defaultStatus: "", badges: [], fields: [] }, where = "schemas/publications.ts") {
+  const renamed = ["groups", "defaultGroup"].filter((key) => typeof value === "object" && value !== null && Object.hasOwn(value, key));
+  if (renamed.length) {
+    fail(where, `${renamed.join(" and ")} ${renamed.length > 1 ? "are" : "is"} now called ${renamed.map((key) => key === "groups" ? "statuses" : "defaultStatus").join(" and ")}; \`vitakit migrate\` renames ${renamed.length > 1 ? "them" : "it"}`);
+  }
   const parsed = input.safeParse(value);
   if (!parsed.success) fail(where, `invalid
 ${formatZodIssues(parsed.error)}`);
-  const groups = parsed.data.groups ?? defaults.groups;
-  const ids = groups.map((group) => group.id);
+  const statuses = parsed.data.statuses ?? defaults.statuses;
+  const ids = statuses.map((status) => status.id);
   const duplicate = ids.find((id, index) => ids.indexOf(id) !== index);
-  if (duplicate) fail(where, `group "${duplicate}" is defined twice`);
-  const defaultGroup = parsed.data.defaultGroup ?? (parsed.data.groups ? ids[0] : defaults.defaultGroup);
-  if (!ids.includes(defaultGroup)) {
-    fail(where, `defaultGroup "${defaultGroup}" is not one of the groups (${ids.join(", ")})`);
+  if (duplicate) fail(where, `status "${duplicate}" is defined twice`);
+  const defaultStatus = parsed.data.defaultStatus ?? (parsed.data.statuses ? ids[0] : defaults.defaultStatus);
+  if (!ids.includes(defaultStatus)) {
+    fail(where, `defaultStatus "${defaultStatus}" is not one of the statuses (${ids.join(", ")})`);
   }
   return {
-    groups,
-    defaultGroup,
+    statuses,
+    defaultStatus,
     badges: parsed.data.badges ?? defaults.badges,
     fields: parsed.data.fields ?? defaults.fields,
     ...parsed.data.cslStyle ? { cslStyle: parsed.data.cslStyle } : {}
@@ -134,18 +138,19 @@ ${formatZodIssues(parsed.error)}`);
 
 const packageDefaults = publications({
   /**
-   * The values of the `status` field, in the order the groups appear. A
-   * status that is not listed here is an error, in any capitalisation.
+   * The values of the `status` field, with the heading of their group, in
+   * the order the groups appear in a list grouped by status. A status that
+   * is not listed here is an error, in any capitalisation.
    */
-  groups: [
+  statuses: [
     { id: "published", label: "Published" },
     { id: "accepted", label: "Accepted" },
     { id: "preprint", label: "Preprints" },
     { id: "software", label: "Software" },
     { id: "other", label: "Other" }
   ],
-  /** The group of an entry without `status`; the first group if left out. */
-  defaultGroup: "published",
+  /** The status of an entry without one; the first status if left out. */
+  defaultStatus: "published",
   /**
    * BibTeX fields that become links after a reference on the website. The
    * presets accept the spellings real exports use (`doi:10...`, doi.org URLs,
@@ -168,8 +173,6 @@ const packageDefaults = publications({
 });
 
 const defaultPublications = resolvePublications(packageDefaults, void 0, "src/schemas/publications.ts");
-defaultPublications.badges;
-defaultPublications.groups;
 async function loadPublicationsSchema(rootDir) {
   const where = "schemas/publications.ts";
   const path = join(rootDir, where);
@@ -236,17 +239,28 @@ const GENRES = {
   techreport: "Technical report"
 };
 const readableGenre = (html, { variable }) => variable === "genre" ? GENRES[html.toLowerCase()] ?? html : html;
-async function loadPublications(bibPath, renderer, schema = defaultPublications, baseURL = "/") {
-  const { groups, fields } = schema;
+const readBib = (path) => readFile(path, "utf8").catch((error) => {
+  if (error.code === "ENOENT") return "";
+  throw error;
+});
+async function readBibliography(bibPath, schema) {
+  try {
+    return new Bibliography({ data: await readBib(bibPath), customFields: ["status", ...schema.fields], preserveMath: true });
+  } catch (error) {
+    throw new Error(`${bibPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+async function loadPublications(bibPath, renderer, schema, lists, baseURL = "/", issues = new Issues(true)) {
+  const { statuses, fields } = schema;
   const prefix = baseURL.replace(/\/$/, "");
   const withFile = (error) => new Error(`${bibPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   let bib;
   try {
     bib = new Bibliography({
-      data: await readFile(bibPath, "utf8"),
+      data: await readBib(bibPath),
       cslStyle: schema.cslStyle ?? projectCslStyle(bibPath) ?? defaultCslStyle,
       // Only fields listed here survive the citation-js pipeline; they then
-      // appear as `entry.custom.<field>`. Badges read the raw fields.
+      // appear as `entry.custom.<field>`. Badges and lists read the raw fields.
       customFields: ["status", ...fields],
       preserveMath: true,
       // Defaults for every formatHtml call below.
@@ -258,18 +272,15 @@ async function loadPublications(bibPath, renderer, schema = defaultPublications,
   } catch (error) {
     throw withFile(error);
   }
-  const statusOf = (entry) => (entry.custom.status?.trim() || schema.defaultGroup).toLowerCase();
-  const known = new Set(groups.map((group) => group.id));
+  const statusOf = (entry) => publicationStatus(entry, schema);
+  const known = new Set(statuses.map((status) => status.id));
   const unknown = bib.entries.filter((entry) => !known.has(statusOf(entry)));
   if (unknown.length) {
     throw new Error(
-      `${bibPath}: unknown status ${[...new Set(unknown.map(statusOf))].join(", ")} on ${unknown.map((entry) => entry.key).join(", ")}; expected one of ${[...known].join(", ")} (groups are defined in schemas/publications.ts)`
+      `${bibPath}: unknown status ${[...new Set(unknown.map(statusOf))].join(", ")} on ${unknown.map((entry) => entry.key).join(", ")}; expected one of ${[...known].join(", ")} (statuses are defined in schemas/publications.ts)`
     );
   }
-  const result = [];
-  for (const group of groups) {
-    const entries = bib.sort(bib.entries.filter((entry) => statusOf(entry) === group.id), { by: "date" });
-    if (!entries.length) continue;
+  const format = (entries) => {
     let items;
     try {
       items = splitList(bib.formatHtml(entries, {
@@ -282,7 +293,7 @@ async function loadPublications(bibPath, renderer, schema = defaultPublications,
     } catch (error) {
       throw withFile(error);
     }
-    const publications = entries.map((entry) => {
+    return entries.map((entry) => {
       const html = items.get(entry.key);
       if (html === void 0) throw new Error(`${bibPath}: ${entry.key} is missing from the formatted list`);
       const { title, badges } = bib.links(entry);
@@ -300,204 +311,30 @@ async function loadPublications(bibPath, renderer, schema = defaultPublications,
         }))
       };
     });
-    result.push({ id: group.id, label: group.label, count: entries.length, entries: publications });
+  };
+  const result = {};
+  for (const [name, list] of Object.entries(lists)) {
+    result[name] = await issues.attempt(LISTS_FILE, () => {
+      const groups = selectPublications(bib, name, list, schema).map((group, index) => ({
+        id: `${name}-${index + 1}`,
+        ...group.label !== void 0 ? { label: group.label } : {},
+        count: group.entries.length,
+        entries: format(group.entries)
+      }));
+      return { count: groups.reduce((sum, group) => sum + group.count, 0), groups };
+    }, { count: 0, groups: [] });
   }
   return result;
 }
 
-const RESERVED = /* @__PURE__ */ new Set(["site", "profile"]);
-async function exists(path) {
-  return stat(path).then(() => true, () => false);
-}
-async function loadRepoSchema(path, id) {
-  const { mtimeMs } = await stat(path);
-  const module = await importProjectModule(path, mtimeMs, `schemas/${id}.ts`);
-  const schema = module.default ?? module.schema;
-  if (!schema || typeof schema.safeParse !== "function") {
-    fail(`schemas/${id}.ts`, "must export a Zod schema as its default export");
-  }
-  return schema;
-}
-const STARTER = (id) => `create schemas/${id}.ts, for example:
-
-  import { z, section, dateRange } from '@anja.codes/vitakit'
-
-  export default section({
-    date: dateRange,
-    title: z.string(),
-  })`;
-async function discoverSections(rootDir) {
-  const contentDir = join(rootDir, "content");
-  const schemaDir = join(rootDir, "schemas");
-  const files = (await readdir(contentDir).catch(() => fail("content/", "directory is missing"))).filter((name) => name.endsWith(".yml") || name.endsWith(".yaml")).sort();
-  const sources = [];
-  for (const file of files) {
-    const id = file.replace(/\.ya?ml$/, "");
-    if (RESERVED.has(id)) continue;
-    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)) {
-      fail(`content/${file}`, "file name must be lowercase kebab-case, e.g. `research-stays.yml`");
-    }
-    const override = join(schemaDir, `${id}.ts`);
-    if (await exists(override)) {
-      sources.push({ id, file: join(contentDir, file), schemaOrigin: "repo", schema: await loadRepoSchema(override, id) });
-      continue;
-    }
-    const builtin = schemas[id];
-    if (!builtin) fail(`content/${file}`, `no schema for this file; ${STARTER(id)}`);
-    sources.push({ id, file: join(contentDir, file), schemaOrigin: "built-in", schema: builtin });
-  }
-  return sources;
-}
-function byDateDesc(a, b) {
-  const left = a.date?.from?.sortKey;
-  const right = b.date?.from?.sortKey;
-  if (left === right) return 0;
-  if (!left) return 1;
-  if (!right) return -1;
-  return right.localeCompare(left);
-}
-async function loadSection(source, options) {
-  const where = `content/${source.id}.yml`;
-  const raw = await readFile(source.file, "utf8");
-  let data;
-  try {
-    data = parse(raw);
-  } catch (error) {
-    fail(where, error instanceof Error ? error.message : String(error));
-  }
-  if (data === null) return [];
-  if (!Array.isArray(data)) fail(where, "expected a list of entries");
-  const parsed = source.schema.safeParse(data);
-  if (!parsed.success) {
-    const origin = source.schemaOrigin === "repo" ? ` (schema: schemas/${source.id}.ts)` : "";
-    fail(where, `invalid${origin}
-${formatZodIssues(parsed.error)}`);
-  }
-  return parsed.data.map((item, index) => ({ ...item, id: `${source.id}-${index}` })).filter((item) => atMost(item.visibility, options.maxVisibility)).map((item, index) => renderRichFields(item, options.renderer, String(index), where)).map((item) => resolveSitePaths(item, options.resolvePath ?? ((path) => path))).sort(byDateDesc);
-}
-
-const FALLBACK_PROFILE = { name: "Your Name", links: [], nav: [], footerHtml: "" };
-async function loadYaml(file, where) {
-  const raw = await readFile(file, "utf8").catch(() => fail(where, "missing"));
-  try {
-    return parse(raw);
-  } catch (error) {
-    fail(where, messageOf(error));
-  }
-}
-async function loadProfile(contentDir, baseURL, renderer, target) {
-  const data = await loadYaml(join(contentDir, "profile.yml"), "content/profile.yml");
-  const parsed = profile.safeParse(data);
-  if (!parsed.success) fail("content/profile.yml", `invalid
-${formatZodIssues(parsed.error)}`);
-  const prefix = baseURL.replace(/\/$/, "");
-  const { avatar, nav, footer, ...rest } = parsed.data;
-  return resolveSitePaths({
-    ...rest,
-    ...avatar ? { avatar: prefixRootRelative(avatar, prefix) } : {},
-    nav: nav.map((item) => ({ label: item.label, url: item.to })),
-    footerHtml: footer ? renderer.inline(footer) : ""
-  }, sitePathResolver(target, baseURL, parsed.data.url));
-}
-function sitePathResolver(target, baseURL, siteUrl) {
-  const prefix = baseURL.replace(/\/$/, "");
-  return target === "pdf" ? (path) => absoluteSitePath(path, siteUrl) : (path) => prefixRootRelative(path, prefix);
-}
-function errorPage(route, where, message) {
-  const escaped = message.replace(/[&<>]/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[character]);
-  return {
-    route,
-    title: `Error in ${where}`,
-    titleHtml: `Error in <code>${where}</code>`,
-    order: -1,
-    bodyHtml: `<pre>${escaped}</pre>`,
-    error: message
-  };
-}
-async function loadPage(dir, file, renderer) {
-  const where = `content/pages/${file}`;
-  const slug = file.slice(0, -".md".length);
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
-    fail(where, "file name must be lowercase kebab-case, e.g. `research-interests.md`");
-  }
-  const { data, content } = matter(await readFile(join(dir, file), "utf8"));
-  const parsed = page.safeParse(data);
-  if (!parsed.success) fail(where, `invalid front matter
-${formatZodIssues(parsed.error)}`);
-  const route = parsed.data.route ?? (slug === "index" ? "/" : `/${slug}/`);
-  try {
-    return {
-      route,
-      title: parsed.data.title,
-      titleHtml: renderer.inline(parsed.data.title),
-      description: parsed.data.description,
-      order: parsed.data.order,
-      bodyHtml: content.trim() ? renderer.markdown(content) : ""
-    };
-  } catch (error) {
-    fail(where, messageOf(error));
-  }
-}
-async function loadPages(contentDir, renderer, issues) {
-  const dir = join(contentDir, "pages");
-  const files = (await readdir(dir).catch(() => [])).filter((name) => name.endsWith(".md")).sort();
-  const pages = await Promise.all(files.map(async (file) => {
-    try {
-      return await loadPage(dir, file, renderer);
-    } catch (error) {
-      if (issues.strict) throw error;
-      const where = whereOf(error, `content/pages/${file}`);
-      const message = messageOf(error);
-      issues.record(where, message);
-      const slug = file.slice(0, -".md".length);
-      return errorPage(slug === "index" ? "/" : `/${slug}/`, where, message);
-    }
-  }));
-  const seen = /* @__PURE__ */ new Map();
-  for (const [index, page] of pages.entries()) {
-    const previous = seen.get(page.route);
-    if (previous) issues.record(`content/pages/${files[index]}`, `route ${page.route} is already used by ${previous}`);
-    else seen.set(page.route, `content/pages/${files[index]}`);
-  }
-  return pages.sort((a, b) => a.order - b.order || a.route.localeCompare(b.route));
-}
-async function loadSections(rootDir, maxVisibility, renderer, resolvePath, issues) {
-  const sources = await issues.attempt("content/", () => discoverSections(rootDir), []);
-  const sections = {};
-  for (const source of sources) {
-    sections[source.id] = await issues.attempt(
-      `content/${source.id}.yml`,
-      () => loadSection(source, { maxVisibility, renderer, resolvePath }),
-      []
-    );
-  }
-  return sections;
-}
-async function loadContent(rootDir, options = {}) {
-  const strict = options.strict ?? true;
-  const baseURL = options.baseURL ?? "/";
-  const maxVisibility = options.maxVisibility ?? "public";
-  const issues = new Issues(strict);
-  const renderer = createRenderer({ baseURL });
-  const contentDir = join(rootDir, "content");
-  const target = options.target ?? "website";
-  const profile = await issues.attempt("content/profile.yml", () => loadProfile(contentDir, baseURL, renderer, target), FALLBACK_PROFILE);
-  const resolvePath = sitePathResolver(target, baseURL, profile.url);
-  const [pages, sections, publications] = await Promise.all([
-    loadPages(contentDir, renderer, issues),
-    loadSections(rootDir, maxVisibility, renderer, resolvePath, issues),
-    issues.attempt(
-      "content/publications.bib",
-      async () => {
-        const bib = join(contentDir, "publications.bib");
-        const present = await readFile(bib, "utf8").then(() => true, () => false);
-        if (!present) return [];
-        return loadPublications(bib, renderer, await loadPublicationsSchema(rootDir), baseURL);
-      },
-      []
-    )
-  ]);
-  return { profile, pages, sections, publications, issues: issues.list };
-}
+const bibliography = {
+  __proto__: null,
+  defaultCslStyle: defaultCslStyle,
+  defaultPublications: defaultPublications,
+  loadPublications: loadPublications,
+  loadPublicationsSchema: loadPublicationsSchema,
+  projectCslStyle: projectCslStyle,
+  readBibliography: readBibliography
+};
 
-export { loadPublicationsSchema as a, loadContent as l, publications as p };
+export { prefixRootRelative as a, loadPublications as b, createRenderer as c, defaultPublications as d, bibliography as e, loadPublicationsSchema as l, publications as p };

package/dist/chunks/build.mjs

@@ -0,0 +1,178 @@
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, writeFile, rm, copyFile, rename } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import process from 'node:process';
+import { join, delimiter, resolve } from 'node:path';
+import { l as loadContent } from '../shared/vitakit.DteA9vLy.mjs';
+import { f as fail } from '../shared/vitakit.DCK90zq4.mjs';
+import { discoverDocuments, validateDocumentSections, selectEntries } from './documents.mjs';
+import { p as publicationPlacementProblems } from '../shared/vitakit.DvvUYUTS.mjs';
+import { discoverSections } from './sections.mjs';
+import { emitDocument, bundledTexDir, SITE_PATH_HELP } from './emit.mjs';
+import { a as escapeTex, b as escapeUrl } from '../shared/vitakit.DcQOdM4I.mjs';
+import { i as isSitePath } from '../shared/vitakit.D10HyDhF.mjs';
+import 'gray-matter';
+import 'yaml';
+import './bibliography.mjs';
+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 './schemas.mjs';
+import '../shared/vitakit.DvABWuUc.mjs';
+import '../shared/vitakit.TSMTC5Jl.mjs';
+import '../shared/vitakit.D-DdJaDZ.mjs';
+import 'eta';
+import '../shared/vitakit.CfB3hMHl.mjs';
+
+const CLASS_FILE = "vitakit-cv.cls";
+class MissingToolError extends Error {
+  constructor(tool) {
+    super(`${tool} not found; install a TeX distribution that includes latexmk and biber`);
+    this.tool = tool;
+    this.name = "MissingToolError";
+  }
+}
+function run(command, args, cwd, env = {}, output = "inherit", log) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, { cwd, stdio: output === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"], env: { ...process.env, ...env } });
+    let captured = "";
+    child.stdout?.on("data", (chunk) => {
+      captured += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      captured += chunk.toString();
+    });
+    child.on("error", (error) => reject(
+      error.code === "ENOENT" ? new MissingToolError(command) : error
+    ));
+    child.on("exit", (code) => {
+      if (code === 0) return resolve2();
+      if (output === "inherit") return reject(new Error(`${command} exited with code ${code}`));
+      void readFile(log ?? "", "utf8").catch(() => "").then((text) => {
+        const lines = text.split("\n");
+        const start = lines.findIndex((line) => line.startsWith("! "));
+        const excerpt = start === -1 ? captured.trim().split("\n").slice(-25).join("\n") : lines.slice(start, start + 8).join("\n").trim();
+        reject(new Error(`${command} exited with code ${code}${excerpt ? `
+
+${excerpt}` : ""}${log ? `
+
+Full log: ${log}` : ""}`));
+      });
+    });
+  });
+}
+function profilePreamble(content, document, lists) {
+  const { profile } = content;
+  const href = (url) => {
+    if (isSitePath(url)) fail("content/profile.yml", `links: ${url} ${SITE_PATH_HELP}`);
+    return escapeUrl(url);
+  };
+  const affiliation = profile.affiliation?.label ? escapeTex(profile.affiliation.label) : "";
+  const tagline = [profile.title && escapeTex(profile.title), affiliation].filter(Boolean).join(", ");
+  const contact = [
+    profile.email && `\\href{mailto:${escapeUrl(profile.email)}}{${escapeTex(profile.email)}}`,
+    ...profile.links.map((link) => `\\href{${href(link.url)}}{${escapeTex(link.label)}}`)
+  ].filter(Boolean).join(" \\quad ");
+  return [
+    `% Generated by vitakit. Do not edit; edit content/profile.yml or cv-tex/${document.name}.yml instead.`,
+    `\\vitaname{${escapeTex(profile.name)}}`,
+    `\\vitatagline{${tagline}}`,
+    `\\vitacontact{${contact}}`,
+    ...profile.url ? siteUrlSourcemap(profile.url) : [],
+    ...Object.entries(content.sections).flatMap(([id, entries]) => {
+      const title = document.options.sections[id]?.title;
+      return [
+        ...selectEntries(entries, document.options, id).length ? [] : [`\\vitaemptysection{${id}}`],
+        ...title ? [`\\vitasectiontitle{${id}}{${escapeTex(title)}}`] : []
+      ];
+    }),
+    ...lists.filter((name) => !content.publications[name]?.count).map((name) => `\\vitaemptypublications{${name}}`),
+    ""
+  ].join("\n");
+}
+function siteUrlSourcemap(siteUrl) {
+  const base = siteUrl.replace(/\/?$/, "/");
+  if (!/^https?:\/\/[\w.:/-]+$/.test(base)) {
+    fail("content/profile.yml", `url: ${siteUrl} may only contain letters, digits and - . _ : /`);
+  }
+  return [
+    "\\ifdefined\\DeclareSourcemap",
+    `  \\DeclareSourcemap{\\maps[datatype=bibtex]{\\map{\\step[fieldsource=url, match=\\regexp{\\A/}, replace={${base}}]}}}`,
+    "\\fi"
+  ];
+}
+async function buildDocument(document, content, options, cvDir) {
+  const outDir = join(cvDir, "generated", document.name);
+  const lists = [...new Set(document.publications.map((placement) => placement.list))];
+  const written = await emitDocument({
+    sections: content.sections,
+    publications: Object.fromEntries(lists.map((name) => [name, content.publications[name]])),
+    siteUrl: content.profile.url,
+    options: document.options,
+    templateDir: join(cvDir, "templates"),
+    outDir
+  });
+  await writeFile(join(outDir, "profile.tex"), profilePreamble(content, document, lists));
+  const generatedClass = join(outDir, CLASS_FILE);
+  if (existsSync(join(cvDir, CLASS_FILE))) await rm(generatedClass, { force: true });
+  else await copyFile(join(bundledTexDir, CLASS_FILE), generatedClass);
+  options.onProgress?.({ document: document.name, step: "tex", dir: outDir, files: written.length + 1 });
+  if (options.noPdf) return;
+  const relativeOut = join("generated", document.name);
+  await run("latexmk", [
+    "-pdf",
+    "-halt-on-error",
+    "-interaction=nonstopmode",
+    `-outdir=${relativeOut}`,
+    // Otherwise -outdir can shadow teaching.tex with its generated section.
+    resolve(document.texFile)
+  ], cvDir, {
+    // A trailing delimiter keeps the standard search paths.
+    TEXINPUTS: `.${delimiter}${relativeOut}${delimiter}${process.env.TEXINPUTS ?? ""}`
+  }, options.latexOutput, join(outDir, `${document.name}.log`));
+  await rename(join(outDir, `${document.name}.pdf`), join(cvDir, `${document.name}.pdf`));
+  options.onProgress?.({ document: document.name, step: "pdf", file: join(cvDir, `${document.name}.pdf`) });
+}
+async function buildCv(options) {
+  const cvDir = join(options.rootDir, "cv-tex");
+  if (!existsSync(cvDir)) {
+    throw new Error(`no cv-tex/ directory in ${options.rootDir}`);
+  }
+  const content = await loadContent(options.rootDir, { strict: true, maxVisibility: "private", target: "pdf" });
+  const documents = await discoverDocuments(cvDir);
+  const sources = await discoverSections(options.rootDir);
+  for (const document of documents) {
+    validateDocumentSections(document, sources);
+    const [problem] = publicationPlacementProblems([], [...document.placements, ...document.publications], Object.keys(content.publications));
+    if (problem) fail(problem.where, problem.message);
+  }
+  const unknown = options.only?.filter((name) => !documents.some((document) => document.name === name)) ?? [];
+  if (unknown.length) {
+    const known = documents.map((document) => document.name).join(", ");
+    throw new Error(`no document matched ${unknown.join(", ")}; available: ${known}`);
+  }
+  const selected = options.only?.length ? documents.filter((document) => options.only.includes(document.name)) : documents;
+  await mkdir(join(cvDir, "generated"), { recursive: true });
+  for (const document of selected) {
+    await buildDocument(document, content, options, cvDir);
+  }
+  return selected.map((document) => join(cvDir, `${document.name}.pdf`));
+}
+async function readGenerated(rootDir, document, section) {
+  return readFile(join(rootDir, "cv-tex", "generated", document, `${section}.tex`), "utf8");
+}
+
+export { MissingToolError, buildCv, readGenerated };