@anja.codes/vitakit 0.1.0 → 0.3.0

package/dist/chunks/documents.mjs

@@ -0,0 +1,152 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { parse } from 'yaml';
+import { z } from 'zod';
+import { f as fail, m as messageOf, a as formatZodIssues } from '../shared/vitakit.DCK90zq4.mjs';
+import { c as findPdfPublicationPlacements, f as findPdfPlacements } from '../shared/vitakit.DvvUYUTS.mjs';
+import { a as atMost } from '../shared/vitakit.TSMTC5Jl.mjs';
+import { f as fieldValue, a as filterWhere } from '../shared/vitakit.D-DdJaDZ.mjs';
+import 'node:url';
+
+const whereScalar = z.union([z.string(), z.number(), z.boolean()]);
+const sectionOptions = z.strictObject({
+  /**
+   * Keep entries whose field equals the value, or one of several values:
+   *
+   * ```yaml
+   * where: { kind: invited }
+   * where: { kind: [invited, seminar] }
+   * ```
+   */
+  where: z.record(z.string(), z.union([whereScalar, z.array(whereScalar).min(1)])).default({}),
+  /** Keep only the newest N entries. */
+  limit: z.number().int().positive().optional(),
+  /** Drop entries starting before this year. */
+  since: z.number().int().optional(),
+  /** Drop entries starting after this year. */
+  until: z.number().int().optional(),
+  /** Heading used by `\vitasection`; overrides the shared preamble's label. */
+  title: z.string().min(1).optional()
+});
+const documentSchema = z.strictObject({
+  /**
+   * Highest visibility level this document may include. Defaults to `cv`,
+   * because a CV is the reason the `cv` level exists; use `private` for an
+   * application containing a cover letter, address or referees.
+   *
+   * There is no "publish this PDF" option: PDFs are never part of the website
+   * build (see `vitakit verify`), and the website renders CV data directly.
+   */
+  visibility: z.enum(["public", "cv", "private"]).default("cv"),
+  sections: z.record(z.string(), sectionOptions).default({})
+});
+const DEFAULTS = documentSchema.parse({});
+async function findDocuments(cvDir) {
+  const files = (await readdir(cvDir).catch(() => [])).filter((name) => name.endsWith(".tex")).sort();
+  const documents = [];
+  const problems = [];
+  for (const file of files) {
+    const name = basename(file, ".tex");
+    const source = await readFile(join(cvDir, file), "utf8");
+    if (!/\\begin\{document\}/.test(source)) continue;
+    const where = `cv-tex/${name}.yml`;
+    const raw = await readFile(join(cvDir, `${name}.yml`), "utf8").catch(() => void 0);
+    let options = DEFAULTS;
+    if (raw !== void 0) {
+      let data;
+      try {
+        data = parse(raw);
+      } catch (error) {
+        problems.push({ where, message: messageOf(error) });
+        continue;
+      }
+      if (typeof data === "object" && data !== null && Object.hasOwn(data, "publications")) {
+        problems.push({ where, message: "publications: which publications a PDF shows is now a list in content/publication-lists.yml, placed with \\vitapublications[Heading]{list}; `vitakit migrate` converts it" });
+        continue;
+      }
+      const parsed = documentSchema.safeParse(data ?? {});
+      if (!parsed.success) {
+        problems.push({ where, message: `invalid
+${formatZodIssues(parsed.error)}` });
+        continue;
+      }
+      options = parsed.data;
+    }
+    const tex = `cv-tex/${file}`;
+    documents.push({
+      name,
+      texFile: join(cvDir, file),
+      options,
+      placements: findPdfPlacements(name, tex, source),
+      publications: findPdfPublicationPlacements(name, tex, source)
+    });
+  }
+  return { documents, problems };
+}
+async function discoverDocuments(cvDir) {
+  await readdir(cvDir).catch(() => fail("cv-tex/", "directory is missing"));
+  const { documents, problems } = await findDocuments(cvDir);
+  if (problems.length) fail(problems[0].where, problems[0].message);
+  if (!documents.length) fail("cv-tex/", "no .tex file contains \\begin{document}");
+  return documents;
+}
+function documentSectionProblems(document, sources) {
+  const where = `cv-tex/${document.name}.yml`;
+  const problems = [];
+  const sections = new Map(sources.map((source) => [source.id, source.schema]));
+  for (const [id, options] of Object.entries(document.options.sections)) {
+    const schema = sections.get(id);
+    if (!schema) {
+      problems.push({ where, message: `sections.${id}: unknown section; the sections are ${[...sections.keys()].join(", ") || "(none)"}` });
+      continue;
+    }
+    if (schema instanceof z.ZodArray && schema.element instanceof z.ZodObject) {
+      const fields = /* @__PURE__ */ new Set(["year", ...Object.keys(schema.element.shape)]);
+      for (const field of Object.keys(options.where)) {
+        if (!fields.has(field)) {
+          problems.push({ where, message: `sections.${id}.where.${field}: unknown field; the fields are ${[...fields].join(", ")}` });
+        }
+      }
+    }
+  }
+  return problems;
+}
+function validateDocumentSections(document, sources) {
+  const [problem] = documentSectionProblems(document, sources);
+  if (problem) fail(problem.where, problem.message);
+}
+function selectEntries(entries, options, sectionId) {
+  const section = options.sections[sectionId] ?? { where: {} };
+  let result = entries.filter((entry) => atMost(entry.visibility, options.visibility));
+  if (section.since !== void 0) {
+    result = result.filter((entry) => Number(fieldValue(entry, "year") ?? 0) >= section.since);
+  }
+  if (section.until !== void 0) {
+    result = result.filter((entry) => Number(fieldValue(entry, "year") ?? Infinity) <= section.until);
+  }
+  result = filterWhere(result, section.where);
+  return section.limit ? result.slice(0, section.limit) : result;
+}
+function explainSelection(entries, options, sectionId) {
+  const section = options.sections[sectionId] ?? { where: {} };
+  const steps = [];
+  let current = entries;
+  const step = (rule, next) => {
+    steps.push({ rule, kept: next.length, removed: current.length - next.length });
+    current = next;
+  };
+  step(`visibility: ${options.visibility}`, current.filter((entry) => atMost(entry.visibility, options.visibility)));
+  if (section.since !== void 0) {
+    step(`since: ${section.since}`, current.filter((entry) => Number(fieldValue(entry, "year") ?? 0) >= section.since));
+  }
+  if (section.until !== void 0) {
+    step(`until: ${section.until}`, current.filter((entry) => Number(fieldValue(entry, "year") ?? Infinity) <= section.until));
+  }
+  for (const [field, value] of Object.entries(section.where ?? {})) {
+    step(`where ${field}: ${Array.isArray(value) ? `[${value.join(", ")}]` : String(value)}`, filterWhere(current, { [field]: value }));
+  }
+  if (section.limit) step(`limit: ${section.limit}`, current.slice(0, section.limit));
+  return { total: entries.length, steps };
+}
+
+export { discoverDocuments, documentSchema, documentSectionProblems, explainSelection, findDocuments, selectEntries, validateDocumentSections };

package/dist/chunks/draft.mjs

@@ -0,0 +1,222 @@
+import { z } from 'zod';
+import { s as section, t as text, d as dateRange, l as linked, u as url, a as richText } from '../shared/vitakit.DvABWuUc.mjs';
+import { p as propertyKey } from '../shared/vitakit.CCTDg7pz.mjs';
+import { i as isSitePath } from '../shared/vitakit.D10HyDhF.mjs';
+import '../shared/vitakit.DCK90zq4.mjs';
+import 'node:url';
+import '@babel/parser';
+
+const DATE_POINT = /^\d{4}(?:-\d{2}(?:-\d{2})?)?$/;
+const isDatePoint = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1e3 && value <= 9999 || typeof value === "string" && DATE_POINT.test(value);
+const isDateRange = (value) => isDatePoint(value) || isRecord(value) && Object.keys(value).every((key) => key === "from" || key === "to") && isDatePoint(value.from) && (value.to === void 0 || value.to === "present" || isDatePoint(value.to));
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const isUrl = (value) => typeof value === "string" && (isSitePath(value) && !/\s/.test(value) || /^(?:https?:\/\/|mailto:)\S+$/.test(value));
+const isLinked = (value) => isRecord(value) && (typeof value.name === "string" || typeof value.label === "string") && Object.keys(value).every((key) => ["name", "label", "url"].includes(key)) && !("name" in value && "label" in value);
+function dateSuggestion(value) {
+  if (typeof value === "string") {
+    const monthYear = /^(\d{1,2})\/(\d{4})$/.exec(value);
+    if (monthYear) return `${monthYear[2]}-${monthYear[1].padStart(2, "0")}`;
+    const dotted = /^(\d{1,2})\.(\d{1,2})\.(\d{4})$/.exec(value);
+    if (dotted) return `${dotted[3]}-${dotted[2].padStart(2, "0")}-${dotted[1].padStart(2, "0")}`;
+    const since = /^since\s+(.+)$/i.exec(value);
+    if (since) return `{ from: ${dateSuggestion(since[1]) ?? since[1]}, to: present }`;
+  }
+  if (Array.isArray(value) && value.length >= 1 && value.length <= 2 && value.every((item) => isDatePoint(item) || dateSuggestion(item))) {
+    const [from, to] = value.map((item) => isDatePoint(item) ? String(item) : dateSuggestion(item));
+    return to ? `{ from: ${from}, to: ${to} }` : String(from);
+  }
+  if (isRecord(value) && "start" in value) {
+    return value.end !== void 0 ? `{ from: ${String(value.start)}, to: ${String(value.end)} }` : String(value.start);
+  }
+  return void 0;
+}
+const TITLE = /^(title|headline|name)$/;
+function inferValues(name, values, depth) {
+  const present = values.filter((value) => value !== void 0 && value !== null && value !== "");
+  if (!present.length) {
+    return { code: "text", schema: text, imports: ["text"], notes: ["never filled in so far; text is a guess"] };
+  }
+  if (name === "date") {
+    if (present.every(isDateRange)) return { code: "dateRange", schema: dateRange, imports: ["dateRange"], notes: [] };
+    const example = present.map(dateSuggestion).find(Boolean);
+    return {
+      code: "dateRange",
+      schema: dateRange,
+      imports: ["dateRange"],
+      notes: [`dates must be written like 2024, 2024-03, 2024-03-15 or { from: 2019, to: present }${example ? `, e.g. ${example}` : ""}`]
+    };
+  }
+  if (present.every((value) => typeof value === "boolean")) return { code: "z.boolean()", schema: z.boolean(), imports: ["z"], notes: [] };
+  const numeric = (value) => typeof value === "number" || typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value);
+  if (present.every(numeric) && present.some((value) => typeof value === "number")) {
+    const notes = present.some((value) => typeof value === "string") ? ["some entries write the number in quotes; remove them"] : [];
+    if (/^(year|time)$/.test(name) && present.every(isDatePoint)) notes.push("to sort entries by it, call this field date");
+    return { code: "z.number()", schema: z.number(), imports: ["z"], notes };
+  }
+  if (present.every(isLinked)) return { code: "linked", schema: linked, imports: ["linked"], notes: [] };
+  if (depth === 0 && ["institution", "issuer", "organisation"].includes(name) && present.every((value) => typeof value === "string" || isLinked(value))) {
+    return { code: "linked", schema: linked, imports: ["linked"], notes: present.some(isLinked) ? ["a name, or { name, url }"] : ["a name; { name, url } links it"] };
+  }
+  if (present.every((value) => typeof value === "string" || isLinked(value)) && present.some(isLinked)) {
+    return { code: "linked", schema: linked, imports: ["linked"], notes: ["a name, or { name, url }"] };
+  }
+  if (present.every(isRecord)) {
+    const keys = [...new Set(present.flatMap((value) => Object.keys(value)))];
+    if (keys.every((key) => key === "from" || key === "to" || key === "start" || key === "end")) {
+      const example = present.map(dateSuggestion).find(Boolean);
+      return {
+        code: "dateRange",
+        schema: dateRange,
+        imports: ["dateRange"],
+        notes: [`a date or a range; write { from, to }${example ? `, e.g. ${example}` : ""}${name === "date" ? "" : ", and call the field date to sort by it"}`]
+      };
+    }
+    const nested = inferObject(present, depth + 1);
+    return { code: nested.code, schema: nested.schema, imports: ["z", ...nested.imports], notes: [] };
+  }
+  if (present.some(Array.isArray)) {
+    const items = present.flatMap((value) => Array.isArray(value) ? value : [value]);
+    const element = inferValues(name, items, depth);
+    const dates = present.find((value) => Array.isArray(value) && dateSuggestion(value));
+    const notes = dates ? element.notes.filter((note) => !note.startsWith("looks like a date")) : [...element.notes];
+    if (!present.every(Array.isArray)) notes.push("a list; where an entry has a single value, write it as a list: [value]");
+    if (dates) notes.push(`if this is a period, write it as a date instead: ${dateSuggestion(dates)}${name === "date" ? "" : ", and call the field date to sort by it"}`);
+    return { code: `z.array(${element.code})`, schema: z.array(element.schema), imports: ["z", ...element.imports], notes };
+  }
+  if (present.every((value) => typeof value === "string")) {
+    const strings = present;
+    if (strings.every(isUrl)) return { code: "url", schema: url, imports: ["url"], notes: [] };
+    const notes = [];
+    const odd = strings.map(dateSuggestion).find(Boolean);
+    if (odd) notes.push(`looks like a date; to use it as one, write ${odd}${name === "date" ? "" : " and call the field date"}`);
+    else if (strings.every((value) => DATE_POINT.test(value)) && name !== "date") notes.push("looks like a date; to sort by it, call this field date and use dateRange");
+    const unique = [...new Set(strings)];
+    if (unique.length > 1 && unique.length <= 5 && strings.length >= 2 * unique.length && unique.every((value) => value.length <= 30)) {
+      notes.push(`values so far: ${unique.join(", ")}; to allow only these: z.enum([${unique.map((value) => `'${value.replace(/'/g, "\\'")}'`).join(", ")}])`);
+    }
+    if (depth === 0 && TITLE.test(name) || strings.some((value) => /\$[^$]+\$/.test(value))) {
+      return { code: "richText", schema: richText, imports: ["richText"], notes: ["Markdown and $math$ allowed", ...notes] };
+    }
+    return { code: "text", schema: text, imports: ["text"], notes };
+  }
+  const numbers = present.filter((value) => typeof value === "number").length;
+  if (numbers * 2 >= present.length && present.every((value) => typeof value === "number" || typeof value === "string")) {
+    const odd = [...new Set(present.filter((value) => typeof value === "string"))];
+    return {
+      code: "z.number()",
+      schema: z.number(),
+      imports: ["z"],
+      notes: [`mostly numbers; ${odd.slice(0, 3).map((value) => JSON.stringify(value)).join(", ")}${odd.length > 3 ? ", \u2026" : ""} ${odd.length === 1 ? "is" : "are"} not: write a number, or use text`]
+    };
+  }
+  const kinds = [...new Set(present.map((value) => Array.isArray(value) ? "list" : typeof value))];
+  return {
+    code: "text",
+    schema: text,
+    imports: ["text"],
+    notes: [`the entries mix ${kinds.join(" and ")}; text is a guess, make them consistent or write a custom schema`]
+  };
+}
+function inferObject(entries, depth, skip = []) {
+  const names = [...new Set(entries.flatMap((entry) => Object.keys(entry)))].filter((name) => !skip.includes(name));
+  const fields = [];
+  const shape = {};
+  const imports = [];
+  for (const name of names) {
+    const values = entries.map((entry) => entry[name]);
+    const inferred = inferValues(name, values, depth);
+    const filled = values.filter((value) => value !== void 0 && value !== null && value !== "").length;
+    const empty = values.filter((value) => value === "" || value === null).length;
+    const optional = filled < entries.length;
+    const notes = [...inferred.notes];
+    if (empty) notes.push(`empty in ${empty} ${empty === 1 ? "entry" : "entries"}; leave the field out instead`);
+    if (propertyKey(name) !== name) notes.push(`a name like ${name.replace(/[^A-Za-z0-9]+(.)/g, (_match, next) => next.toUpperCase())} needs no quotes`);
+    fields.push({ name, code: `${inferred.code}${optional ? ".optional()" : ""}`, notes });
+    shape[name] = optional ? inferred.schema.optional() : inferred.schema;
+    imports.push(...inferred.imports);
+  }
+  const indent = "  ".repeat(depth + 1);
+  const lines = fields.flatMap((field) => [
+    ...field.notes.map((note) => `${indent}// ${note}`),
+    `${indent}${propertyKey(field.name)}: ${field.code},`
+  ]);
+  return {
+    code: depth === 0 ? lines.join("\n") : `z.strictObject({
+${lines.join("\n")}
+${"  ".repeat(depth)}})`,
+    schema: z.strictObject(shape),
+    imports,
+    fields
+  };
+}
+function ranges(numbers) {
+  const parts = [];
+  for (let index = 0; index < numbers.length; index++) {
+    let end = index;
+    while (end + 1 < numbers.length && numbers[end + 1] === numbers[end] + 1) end++;
+    parts.push(end > index + 1 ? `${numbers[index]}\u2013${numbers[end]}` : end === index + 1 ? `${numbers[index]}, ${numbers[end]}` : `${numbers[index]}`);
+    index = end;
+  }
+  return parts.join(", ");
+}
+function changesFrom(error, entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of error.issues) {
+    const [index, ...path] = issue.path;
+    let message = issue.message === "Invalid input" ? "not written in a form this field accepts" : issue.message.replace(/^Invalid input: /, "");
+    if (typeof index === "number") {
+      let value = entries[index];
+      for (const key2 of path) value = value?.[key2];
+      if (value === "" || value === null) message = "empty; leave the field out";
+      else if (value === void 0 && path.length) message = "missing; every entry needs it";
+    }
+    const key = `${path.join(".") || "(entry)"}\0${message}`;
+    grouped.set(key, [...grouped.get(key) ?? [], typeof index === "number" ? index + 1 : 0]);
+  }
+  return [...grouped].map(([key, numbers]) => {
+    const [field, message] = key.split("\0");
+    const unique = [...new Set(numbers)].sort((a, b) => a - b);
+    return `${field}, ${unique.length === 1 ? "entry" : "entries"} ${ranges(unique)}: ${message}`;
+  });
+}
+function draftSchema(id, entries, { file = `content/${id}.yml` } = {}) {
+  const records = entries.filter(isRecord);
+  const object = inferObject(records, 0, ["visibility"]);
+  const imports = [.../* @__PURE__ */ new Set(["section", ...object.imports])].sort();
+  const source = [
+    "/**",
+    ` * What ${file} may contain.`,
+    " *",
+    " * Drafted from its entries by `vitakit add section`: check the comments,",
+    " * change what is not right, then delete them. Every entry also has",
+    " * `visibility: public | cv | private`.",
+    ...object.fields.some((field) => field.name === "date") ? [] : [" *", " * Without a field called `date`, entries keep the order of the file."],
+    " */",
+    `import { ${imports.join(", ")} } from '@anja.codes/vitakit'`,
+    "",
+    "export default section({",
+    object.code,
+    "})",
+    ""
+  ].join("\n");
+  const schema = section(object.schema.shape);
+  const parsed = schema.safeParse(entries);
+  return { source, fields: object.fields, schema, changes: parsed.success ? [] : changesFrom(parsed.error, entries) };
+}
+function draftExtension(base, entries) {
+  if (!(base instanceof z.ZodArray) || !(base.element instanceof z.ZodObject)) return void 0;
+  const element = base.element;
+  const known = Object.keys(element.shape);
+  const object = inferObject(entries.filter(isRecord), 0, known);
+  const schema = z.array(element.extend(object.schema.shape));
+  const parsed = schema.safeParse(entries);
+  return {
+    fields: object.fields,
+    imports: [...new Set(object.imports)].sort(),
+    changes: parsed.success ? [] : changesFrom(parsed.error, entries)
+  };
+}
+
+export { draftExtension, draftSchema };

package/dist/chunks/eject.mjs

@@ -0,0 +1,59 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { r as resolveAsset } from '../shared/vitakit.DQ6PmGoL.mjs';
+import { C as CommandError } from '../shared/vitakit.zwr1ssO5.mjs';
+import 'node:url';
+import 'node:process';
+import 'node:util';
+import 'node:readline/promises';
+
+const SCOPES = {
+  VitaSection: "every section on every page; prefer customize for one section",
+  VitaEntry: "every entry row of every section",
+  VitaDate: "every date on the website",
+  VitaLinks: "the profile links",
+  VitaMarkdown: "every Markdown page body",
+  VitaIssues: "the development error banner",
+  VitaPublications: "how a publication list is laid out: its headings and groups",
+  VitaPublication: "how each reference looks on the website"
+};
+async function ejectableAssets() {
+  const componentsDir = resolveAsset("runtime/components");
+  const components = (await readdir(componentsDir)).filter((file) => file.endsWith(".vue")).sort();
+  return [
+    ...components.map((file) => ({
+      name: basename(file, ".vue"),
+      source: join(componentsDir, file),
+      target: `app/components/${file}`,
+      scope: SCOPES[basename(file, ".vue")] ?? "the website",
+      after: "Your copy is used instead of vitakit's from now on."
+    })),
+    {
+      name: "publications.csl",
+      source: join(resolveAsset("styles"), "vitakit-math.csl"),
+      target: "content/publications.csl",
+      scope: "how publications.bib is formatted on the website (not the PDF)",
+      after: "Edit it, or replace it with any CSL style, e.g. from zotero.org/styles."
+    },
+    {
+      name: "vitakit-cv.cls",
+      source: resolveAsset("tex/vitakit-cv.cls"),
+      target: "cv-tex/vitakit-cv.cls",
+      scope: "the LaTeX class of every PDF document; preamble.tex is usually enough",
+      after: "Every PDF document uses your copy from now on."
+    }
+  ];
+}
+async function ejectPlan(root, asset, { force }) {
+  const exists = existsSync(join(root, asset.target));
+  if (exists && !force) {
+    throw new CommandError(`${asset.target} is already yours. --force replaces it with vitakit's current version, keeping yours as a backup.`);
+  }
+  const content = await readFile(asset.source, "utf8");
+  return {
+    items: [exists ? { kind: "replace", path: asset.target, content, reason: "vitakit's current version; yours is kept next to it as a .backup" } : { kind: "create", path: asset.target, content, reason: asset.scope }]
+  };
+}
+
+export { ejectPlan, ejectableAssets };

package/dist/chunks/emit.mjs

@@ -0,0 +1,216 @@
+import { mkdir, writeFile, readdir, rm, readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { Eta } from 'eta';
+import { r as resolveAsset } from '../shared/vitakit.DQ6PmGoL.mjs';
+import { b as escapeUrl, a as escapeTex, e as escapeRichTex } from '../shared/vitakit.DcQOdM4I.mjs';
+import { f as formatDateRange, e as entrySecondaryParts, b as entryTitleField } from '../shared/vitakit.CfB3hMHl.mjs';
+import { f as fail } from '../shared/vitakit.DCK90zq4.mjs';
+import { i as isSitePath } from '../shared/vitakit.D10HyDhF.mjs';
+import { selectEntries } from './documents.mjs';
+import 'node:url';
+import 'yaml';
+import 'zod';
+import '../shared/vitakit.DvvUYUTS.mjs';
+import '../shared/vitakit.TSMTC5Jl.mjs';
+import '../shared/vitakit.D-DdJaDZ.mjs';
+
+const SITE_PATH_HELP = "is a path on the website, and the PDF can only link it with the address the site is published at: add it to content/profile.yml, e.g. `url: https://jane.example.org/`";
+class Fragment {
+  constructor(value) {
+    this.value = value;
+  }
+  toString() {
+    return this.value;
+  }
+}
+const fragment = (value) => value ? new Fragment(value) : "";
+function isRichText(value) {
+  return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string" && "html" in value && typeof value.html === "string";
+}
+function isTemplate(value) {
+  return Array.isArray(value) && "raw" in value && Array.isArray(value.raw);
+}
+function createTemplateHelpers(where, source) {
+  const text = (value) => {
+    if (value === void 0 || value === null || value === "") return "";
+    if (value instanceof Fragment) return value;
+    if (typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+      return fragment(escapeTex(String(value)));
+    }
+    if (isRichText(value)) {
+      try {
+        return fragment(escapeRichTex(value.text));
+      } catch (error) {
+        return fail(where, error instanceof Error ? error.message : String(error));
+      }
+    }
+    return fail(where, "text expects text or a number; use date(...) or linked(...) for structured values");
+  };
+  const url = (value) => {
+    if (value === void 0 || value === null || value === "") return "";
+    if (typeof value !== "string") return fail(where, "url expects a URL string");
+    if (isSitePath(value)) fail(source, `${value} ${SITE_PATH_HELP}`);
+    return fragment(escapeUrl(value));
+  };
+  const linked = (value, target) => {
+    let label = value;
+    if (typeof value === "object" && value !== null && !(value instanceof Fragment) && !isRichText(value)) {
+      if ("label" in value && typeof value.label === "string") label = value.label;
+      else return fail(where, "linked expects text or { label, url? }; use `linked` in the section schema");
+      if (target === void 0 && "url" in value) target = value.url;
+    }
+    const body = text(label);
+    if (!body) return "";
+    const href = url(target);
+    return href ? fragment(`\\href{${href}}{${body}}`) : body;
+  };
+  const date = (value) => {
+    if (value === void 0 || value === null) return "";
+    if (typeof value !== "object" || !("from" in value) || typeof value.from !== "object" || value.from === null || !("year" in value.from) || typeof value.from.year !== "number" || !("point" in value) || typeof value.point !== "boolean" || !("ongoing" in value) || typeof value.ongoing !== "boolean") {
+      return fail(where, "date expects a normalized date; use dateRange in the collection schema");
+    }
+    return fragment(escapeTex(formatDateRange(value)));
+  };
+  const join = (values, separator = ", ") => {
+    if (!Array.isArray(values)) return fail(where, "join expects an array of values");
+    const parts = values.map((value) => String(text(value))).filter((value) => value !== "");
+    return fragment(parts.join(String(text(separator))));
+  };
+  const optional = (strings, ...values) => {
+    if (!isTemplate(strings) || strings.raw.length !== values.length + 1) {
+      return fail(where, "optional must be used as a tagged template: optional`...${value}...`");
+    }
+    if (values.some((value) => value === void 0 || value === null || value === "")) return "";
+    const parts = values.map(text);
+    if (parts.some((value) => !value)) return "";
+    return fragment(strings.raw.map((literal, index) => literal + (parts[index] ?? "")).join(""));
+  };
+  function note(value, ...values) {
+    const body = isTemplate(value) ? optional(value, ...values) : text(value);
+    return body ? fragment(`\\vitanote{${body}}`) : "";
+  }
+  const entry = (layout) => {
+    if (typeof layout !== "object" || layout === null || !Object.hasOwn(layout, "title") || Object.keys(layout).some((key) => !["date", "title", "context"].includes(key))) {
+      return fail(where, "vita.entry expects { title, date?, context? }");
+    }
+    return fragment(`\\vitaentry{${text(layout.date)}}{${text(layout.title)}}{${text(layout.context)}}`);
+  };
+  return { text, date, linked, url, join, optional, vita: { entry, note } };
+}
+
+const bundledTexDir = resolveAsset("tex");
+const eta = new Eta({ autoEscape: false, autoTrim: [false, false] });
+function tidy(body) {
+  return body.replace(/[ \t]+$/gm, "").replace(/\n{2,}/g, "\n").trim();
+}
+function genericHelpers(h) {
+  return {
+    title(entry) {
+      const field = entryTitleField(entry);
+      return h.text(field ? entry[field] : void 0);
+    },
+    context(entry) {
+      return h.join(entrySecondaryParts(entry, entryTitleField(entry)).map((part) => part.kind === "linked" ? h.linked(part.linked) : part.text));
+    }
+  };
+}
+function texSafe(values, where) {
+  const bad = values.find((value) => !value || /[\s%#\\{},~]/.test(value));
+  if (bad !== void 0) {
+    fail(where, `"${bad}" cannot be used as a citation key or group id in LaTeX; use letters, digits and - _ : . / +`);
+  }
+}
+function bibHelpers(list, where) {
+  return {
+    cite() {
+      const keys = list.groups.flatMap((group) => group.entries.map((entry) => entry.key));
+      texSafe(keys, where);
+      return fragment(`\\nocite{${keys.join(",")}}`);
+    },
+    group(group) {
+      texSafe([group.id, ...group.entries.map((entry) => entry.key)], where);
+      return fragment(`\\vitabibgroup{${group.id}}{${group.entries.map((entry) => entry.key).join(",")}}`);
+    }
+  };
+}
+async function resolveTemplate(id, userDir, { exclude } = {}) {
+  const candidates = [
+    { path: join(userDir, `${id}.eta`), origin: "local", generic: false },
+    { path: join(bundledTexDir, "templates", `${id}.eta`), origin: "bundled", generic: false },
+    { path: join(userDir, "_generic.eta"), origin: "local", generic: true },
+    { path: join(bundledTexDir, "templates", "_generic.eta"), origin: "bundled", generic: true }
+  ];
+  for (const candidate of candidates) {
+    if (candidate.path === exclude) continue;
+    if (existsSync(candidate.path)) return { ...candidate, source: await readFile(candidate.path, "utf8") };
+  }
+  throw new Error(`vitakit: no template for section ${id}`);
+}
+async function assertTemplatesAreUsed(templateDir, ids) {
+  const files = await readdir(templateDir).catch(() => []);
+  const known = /* @__PURE__ */ new Set([...ids, "publications", "_generic"]);
+  for (const file of files.filter((name) => name.endsWith(".eta")).sort()) {
+    const id = file.slice(0, -".eta".length);
+    if (known.has(id)) continue;
+    const suggestion = ids.find((candidate) => candidate.startsWith(id) || id.startsWith(candidate));
+    fail(
+      `cv-tex/templates/${file}`,
+      `no section is called "${id}", so this template is never used${suggestion ? `; did you mean ${suggestion}.eta?` : ""}
+  sections: ${ids.join(", ") || "(none)"}`
+    );
+  }
+}
+async function renderSection(id, entries, options, templateDir) {
+  const selected = selectEntries(entries, options, id);
+  const { path: templatePath, source } = await resolveTemplate(id, templateDir);
+  const h = createTemplateHelpers(templatePath, `content/${id}.yml`);
+  try {
+    return tidy(eta.renderString(source, { entries: selected, ...h, generic: genericHelpers(h) }));
+  } catch (error) {
+    throw new Error(`template ${id}.eta: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+async function renderPublications(list, templateDir, siteUrl) {
+  if (!siteUrl) {
+    const local = list.groups.flatMap((group) => group.entries).find((entry) => entry.titleUrl && isSitePath(entry.titleUrl));
+    if (local) fail("content/publications.bib", `${local.key}: url ${local.titleUrl} ${SITE_PATH_HELP}`);
+  }
+  const { path: templatePath, source } = await resolveTemplate("publications", templateDir);
+  return tidy(eta.renderString(source, {
+    groups: list.groups,
+    ...createTemplateHelpers(templatePath, "content/publications.bib"),
+    bib: bibHelpers(list, templatePath)
+  }));
+}
+async function emitDocument(emit) {
+  await mkdir(emit.outDir, { recursive: true });
+  await assertTemplatesAreUsed(emit.templateDir, Object.keys(emit.sections));
+  const written = [];
+  for (const [id, entries] of Object.entries(emit.sections)) {
+    const body = await renderSection(id, entries, emit.options, emit.templateDir);
+    const file = join(emit.outDir, `${id}.tex`);
+    await writeFile(file, `% Generated by vitakit. Do not edit; edit content/${id}.yml instead.
+${body.trim()}
+`);
+    written.push(file);
+  }
+  const current = /* @__PURE__ */ new Set(["profile.tex", ...written.map((file) => basename(file))]);
+  for (const file of await readdir(emit.outDir)) {
+    if (file.endsWith(".tex") && !current.has(file)) await rm(join(emit.outDir, file));
+  }
+  const listDir = join(emit.outDir, "publications");
+  await rm(listDir, { recursive: true, force: true });
+  await mkdir(listDir);
+  for (const [name, list] of Object.entries(emit.publications)) {
+    const body = await renderPublications(list, emit.templateDir, emit.siteUrl);
+    const file = join(listDir, `${name}.tex`);
+    await writeFile(file, `% Generated by vitakit. Do not edit; edit content/publications.bib or content/publication-lists.yml instead.
+${body.trim()}
+`);
+    written.push(file);
+  }
+  return written;
+}
+
+export { SITE_PATH_HELP, assertTemplatesAreUsed, bundledTexDir, emitDocument, renderPublications, renderSection, resolveTemplate };

package/dist/chunks/eta.mjs

@@ -0,0 +1,16 @@
+function addToEntryLoop(source, lines) {
+  const all = source.split("\n");
+  let close = -1;
+  for (let index = all.length - 1; index >= 0; index--) {
+    if (/^\s*<%\s*}\s*%>\s*$/.test(all[index])) {
+      close = index;
+      break;
+    }
+  }
+  if (close === -1) return { ok: false, reason: "it has no `<% } %>` line ending its loop over the entries" };
+  const fresh = lines.filter((line) => !source.includes(line));
+  if (!fresh.length) return { ok: true, value: source };
+  return { ok: true, value: [...all.slice(0, close), ...fresh, ...all.slice(close)].join("\n") };
+}
+
+export { addToEntryLoop };