@anja.codes/vitakit 0.1.0 → 0.2.0

package/dist/chunks/build.mjs

@@ -0,0 +1,176 @@
+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, a as loadPublicationsSchema } from '../shared/vitakit.By5VWQ1n.mjs';
+import { f as fail } from '../shared/vitakit.DbSeENVS.mjs';
+import { discoverDocuments, validateDocumentSections, selectEntries } from './documents.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 '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 '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:url';
+import '@behackl/citation-js-extras';
+import 'rehype-parse';
+import 'rehype-sanitize';
+import 'zod';
+import './schemas.mjs';
+import '../shared/vitakit.BerUaxtF.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) {
+  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)}}`] : []
+      ];
+    }),
+    ""
+  ].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 written = await emitDocument({
+    sections: content.sections,
+    publications: content.publications,
+    siteUrl: content.profile.url,
+    options: document.options,
+    templateDir: join(cvDir, "templates"),
+    outDir
+  });
+  await writeFile(join(outDir, "profile.tex"), profilePreamble(content, document));
+  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);
+  const groups = (await loadPublicationsSchema(options.rootDir)).groups.map((group) => group.id);
+  for (const document of documents) {
+    validateDocumentSections(document, sources);
+    const unknown2 = (document.options.publications.groups ?? []).filter((id) => !groups.includes(id));
+    if (unknown2.length) {
+      fail(`cv-tex/${document.name}.yml`, `publications.groups: unknown group ${unknown2.join(", ")}; the groups are ${groups.join(", ")} (schemas/publications.ts)`);
+    }
+  }
+  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 };

package/dist/chunks/documents.mjs

@@ -0,0 +1,143 @@
+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.DbSeENVS.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({}),
+  publications: z.strictObject({
+    groups: z.array(z.string()).optional()
+  }).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;
+      }
+      const parsed = documentSchema.safeParse(data ?? {});
+      if (!parsed.success) {
+        problems.push({ where, message: `invalid
+${formatZodIssues(parsed.error)}` });
+        continue;
+      }
+      options = parsed.data;
+    }
+    documents.push({ name, texFile: join(cvDir, file), options });
+  }
+  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.BerUaxtF.mjs';
+import { p as propertyKey } from '../shared/vitakit.BZZIsWlY.mjs';
+import { i as isSitePath } from '../shared/vitakit.D10HyDhF.mjs';
+import '../shared/vitakit.DbSeENVS.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.CoWX2Z4R.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: "the publication list and its 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 };