@anja.codes/vitakit 0.2.0 → 0.3.0

package/dist/chunks/publication-lists.mjs

@@ -0,0 +1,202 @@
+import { readFile } from 'node:fs/promises';
+import { 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 'node:url';
+
+const LISTS_FILE = "content/publication-lists.yml";
+const LISTS_HEADER = `# Publication lists: which publications of publications.bib a list shows,
+# in what order and in which groups. A page shows one with
+#   <VitaPublications list="recent" title="Recent publications" />
+# and a PDF with
+#   \\vitapublications[Recent publications]{recent}
+#
+# Settings, all optional:
+#   where:    { status: preprint }, { keywords: selected }, { year: 2024 } --
+#             fields of the entries in publications.bib; [a, b] means a or b
+#   keys:     [doe2024, roe2023] -- exactly these, in this order
+#   since, until: years
+#   sort:     date (newest first), year, title, source (as in publications.bib),
+#             or a field; order: asc or desc
+#   limit:    at most this many
+#   groupBy:  status, year or a field; otherLabel: the heading for the entries
+#             without it (Other)
+# \`vitakit explain publications\` shows what each list contains and where.
+`;
+const DERIVED = /* @__PURE__ */ new Set(["key", "status", "year"]);
+const NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const field = z.string().regex(/^[A-Za-z][\w-]*$/, "expected a BibTeX field name").transform((name) => name.toLowerCase());
+const scalar = z.union([z.string(), z.number(), z.boolean()]);
+const listInput = z.strictObject({
+  where: z.record(z.string(), z.union([scalar, z.array(scalar).min(1)])).default({}),
+  keys: z.array(z.string().min(1)).min(1).optional(),
+  since: z.number().int().optional(),
+  until: z.number().int().optional(),
+  sort: field.optional(),
+  order: z.enum(["asc", "desc"]).optional(),
+  limit: z.number().int().positive().optional(),
+  groupBy: field.optional(),
+  otherLabel: z.string().trim().min(1).optional()
+});
+function resolveList(name, value, schema) {
+  const at = (option) => `${name}.${option}`;
+  if (!NAME.test(name)) fail(LISTS_FILE, `${name}: a list name is lowercase kebab-case, e.g. recent-papers`);
+  const parsed = listInput.safeParse(value ?? {});
+  if (!parsed.success) fail(LISTS_FILE, `${name}: invalid
+${formatZodIssues(parsed.error)}`);
+  const input = parsed.data;
+  const where = {};
+  for (const [key, wanted] of Object.entries(input.where)) {
+    const parsedField = field.safeParse(key);
+    if (!parsedField.success) fail(LISTS_FILE, `${at(`where.${key}`)}: expected a BibTeX field name`);
+    where[parsedField.data] = wanted;
+  }
+  const statuses = schema.statuses.map((status) => status.id);
+  for (const status of where.status === void 0 ? [] : [where.status].flat()) {
+    if (!statuses.includes(String(status).toLowerCase())) {
+      fail(LISTS_FILE, `${at("where.status")}: no status "${status}"; the statuses are ${statuses.join(", ")} (schemas/publications.ts)`);
+    }
+  }
+  if (input.keys && input.sort) fail(LISTS_FILE, `${at("sort")}: a list of keys is shown in the order of its keys; remove sort or keys`);
+  if (input.order && (input.keys || input.sort === "source")) fail(LISTS_FILE, `${at("order")}: only applies when sorting by a field`);
+  if (input.groupBy === "keywords") fail(LISTS_FILE, `${at("groupBy")}: an entry can have several keywords; group by another field`);
+  if (input.otherLabel && (!input.groupBy || input.groupBy === "status")) {
+    fail(LISTS_FILE, `${at("otherLabel")}: only applies when grouping by year or by a field`);
+  }
+  const sort = input.sort ?? "date";
+  return {
+    where,
+    ...input.keys ? { keys: input.keys } : {},
+    ...input.since !== void 0 ? { since: input.since } : {},
+    ...input.until !== void 0 ? { until: input.until } : {},
+    sort,
+    order: input.order ?? (sort === "date" || sort === "year" ? "desc" : "asc"),
+    ...input.limit !== void 0 ? { limit: input.limit } : {},
+    ...input.groupBy ? { groupBy: input.groupBy } : {},
+    otherLabel: input.otherLabel ?? "Other"
+  };
+}
+async function publicationListNames(rootDir) {
+  try {
+    const data = parse(await readFile(join(rootDir, LISTS_FILE), "utf8"));
+    return data && typeof data === "object" && !Array.isArray(data) ? Object.keys(data) : [];
+  } catch {
+    return [];
+  }
+}
+async function loadPublicationLists(rootDir, schema) {
+  const raw = await readFile(join(rootDir, LISTS_FILE), "utf8").catch((error) => {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  });
+  if (raw === void 0) return {};
+  let data;
+  try {
+    data = parse(raw);
+  } catch (error) {
+    fail(LISTS_FILE, messageOf(error));
+  }
+  if (data === null || data === void 0) return {};
+  if (typeof data !== "object" || Array.isArray(data)) fail(LISTS_FILE, "expected one list per name, e.g. `recent: { limit: 3 }`");
+  return Object.fromEntries(Object.entries(data).map(([name, value]) => [name, resolveList(name, value, schema)]));
+}
+function publicationStatus(entry, schema) {
+  return (entry.custom.status?.trim() || schema.defaultStatus).toLowerCase();
+}
+const plain = (value) => {
+  const text = typeof value === "string" ? value.replace(/[{}]/g, "").trim() : void 0;
+  return text || void 0;
+};
+function valueOf(entry, name, schema) {
+  if (name === "key") return entry.key;
+  if (name === "status") return publicationStatus(entry, schema);
+  if (name === "year") return entry.year === null ? void 0 : String(entry.year);
+  return plain(entry.raw[name]);
+}
+function matches(entry, name, wanted, schema) {
+  const value = valueOf(entry, name, schema);
+  const actual = name === "keywords" ? value?.split(/[,;]/).map((keyword) => keyword.trim()) ?? [] : value === void 0 ? [] : [value];
+  return [wanted].flat().map(String).some((candidate) => actual.includes(name === "status" ? candidate.toLowerCase() : candidate));
+}
+const collator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+function sortByText(entries, value, order) {
+  const keyed = entries.map((entry) => ({ entry, value: value(entry) }));
+  const sign = order === "asc" ? 1 : -1;
+  return keyed.sort((a, b) => a.value === void 0 ? b.value === void 0 ? 0 : 1 : b.value === void 0 ? -1 : sign * collator.compare(a.value, b.value)).map((item) => item.entry);
+}
+function sortEntries(bib, entries, list, schema) {
+  if (list.keys || list.sort === "source") return entries;
+  if (list.sort === "date" || list.sort === "year") {
+    const dated = entries.filter((entry) => entry.year !== null);
+    return [...bib.sort(dated, { by: list.sort, order: list.order }), ...entries.filter((entry) => entry.year === null)];
+  }
+  return sortByText(entries, (entry) => valueOf(entry, list.sort, schema), list.order);
+}
+function group(entries, list, schema) {
+  const by = list.groupBy;
+  if (!by) return entries.length ? [{ entries }] : [];
+  if (by === "status") {
+    return schema.statuses.map((status) => ({ label: status.label, entries: entries.filter((entry) => publicationStatus(entry, schema) === status.id) })).filter((selected) => selected.entries.length);
+  }
+  const values = [...new Set(entries.map((entry) => valueOf(entry, by, schema)).filter((value) => value !== void 0))];
+  values.sort(by === "year" ? (a, b) => Number(b) - Number(a) : collator.compare);
+  const groups = values.map((value) => ({ label: value, entries: entries.filter((entry) => valueOf(entry, by, schema) === value) }));
+  const other = entries.filter((entry) => valueOf(entry, by, schema) === void 0);
+  return other.length ? [...groups, { label: list.otherLabel, entries: other }] : groups;
+}
+function selectionSteps(bib, name, list, schema) {
+  const fields = [...Object.keys(list.where), list.sort, list.groupBy].filter((candidate) => !!candidate && !DERIVED.has(candidate) && !["date", "source"].includes(candidate));
+  for (const candidate of new Set(fields)) {
+    if (bib.entries.length && !bib.entries.some((entry) => plain(entry.raw[candidate]) !== void 0)) {
+      fail(LISTS_FILE, `${name}: no publication has a field "${candidate}"`);
+    }
+  }
+  const steps = [];
+  if (list.keys) {
+    const byKey = new Map(bib.entries.map((entry) => [entry.key, entry]));
+    const missing = list.keys.filter((key) => !byKey.has(key));
+    if (missing.length) fail(LISTS_FILE, `${name}.keys: no publication ${missing.join(", ")} in content/publications.bib`);
+    steps.push({ rule: `keys: ${list.keys.length}`, apply: () => list.keys.map((key) => byKey.get(key)) });
+  }
+  for (const [field2, wanted] of Object.entries(list.where)) {
+    steps.push({ rule: `where ${field2}: ${[wanted].flat().join(", ")}`, apply: (entries) => entries.filter((entry) => matches(entry, field2, wanted, schema)) });
+  }
+  if (list.since !== void 0) steps.push({ rule: `since: ${list.since}`, apply: (entries) => entries.filter((entry) => entry.year !== null && entry.year >= list.since) });
+  if (list.until !== void 0) steps.push({ rule: `until: ${list.until}`, apply: (entries) => entries.filter((entry) => entry.year !== null && entry.year <= list.until) });
+  steps.push({ rule: "sort", apply: (entries) => sortEntries(bib, entries, list, schema) });
+  if (list.limit !== void 0) steps.push({ rule: `limit: ${list.limit}`, apply: (entries) => entries.slice(0, list.limit) });
+  return steps;
+}
+function selectPublications(bib, name, list, schema) {
+  let entries = bib.entries;
+  for (const step of selectionSteps(bib, name, list, schema)) entries = step.apply(entries);
+  return group(entries, list, schema);
+}
+function explainListSelection(bib, name, list, schema) {
+  let entries = bib.entries;
+  const steps = [];
+  for (const step of selectionSteps(bib, name, list, schema)) {
+    const next = step.apply(entries);
+    steps.push({ rule: step.rule, removed: entries.length - next.length });
+    entries = next;
+  }
+  return { total: bib.entries.length, steps: steps.filter((step) => step.removed > 0), keys: group(entries, list, schema).flatMap((selected) => selected.entries.map((entry) => entry.key)) };
+}
+function describeList(list) {
+  const parts = [];
+  if (list.keys) parts.push(`${list.keys.length} chosen by key`);
+  for (const [name, wanted] of Object.entries(list.where)) parts.push(`${name} ${[wanted].flat().join(" or ")}`);
+  if (list.since !== void 0) parts.push(`since ${list.since}`);
+  if (list.until !== void 0) parts.push(`until ${list.until}`);
+  if (!list.keys) {
+    if (list.sort === "source") parts.push("in .bib order");
+    else if (list.sort === "date" || list.sort === "year") parts.push(list.order === "desc" ? "newest first" : "oldest first");
+    else parts.push(`by ${list.sort}${list.order === "desc" ? ", descending" : ""}`);
+  }
+  if (list.limit !== void 0) parts.push(`at most ${list.limit}`);
+  if (list.groupBy) parts.push(`grouped by ${list.groupBy}`);
+  return parts.join(" \xB7 ");
+}
+
+export { LISTS_FILE, LISTS_HEADER, describeList, explainListSelection, loadPublicationLists, publicationListNames, publicationStatus, resolveList, selectPublications };

package/dist/chunks/schemas.mjs

@@ -1,6 +1,6 @@
-import { s as section, t as text, a as richText, u as url, l as linked, d as dateRange, b as absoluteUrl, r as requiredLink } from '../shared/vitakit.BerUaxtF.mjs';
+import { s as section, t as text, a as richText, u as url, l as linked, d as dateRange, b as absoluteUrl, r as requiredLink } from '../shared/vitakit.DvABWuUc.mjs';
 import { z } from 'zod';
-import '../shared/vitakit.DbSeENVS.mjs';
+import '../shared/vitakit.DCK90zq4.mjs';
 import 'node:url';
 import '../shared/vitakit.D10HyDhF.mjs';
 

package/dist/chunks/sections.mjs

@@ -2,14 +2,14 @@ import { readdir, readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parse } from 'yaml';
 import { schemas } from './schemas.mjs';
-import { f as fail, a as formatZodIssues, i as importProjectModule } from '../shared/vitakit.DbSeENVS.mjs';
-import { c as renderRichFields } from '../shared/vitakit.BerUaxtF.mjs';
+import { f as fail, a as formatZodIssues, i as importProjectModule } from '../shared/vitakit.DCK90zq4.mjs';
+import { c as renderRichFields } from '../shared/vitakit.DvABWuUc.mjs';
 import { r as resolveSitePaths } from '../shared/vitakit.D10HyDhF.mjs';
 import { a as atMost } from '../shared/vitakit.TSMTC5Jl.mjs';
 import 'zod';
 import 'node:url';
 
-const RESERVED_SECTION_NAMES = /* @__PURE__ */ new Set(["site", "profile"]);
+const RESERVED_SECTION_NAMES = /* @__PURE__ */ new Set(["site", "profile", "publication-lists"]);
 const SECTION_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function sectionNameProblem(id) {
   if (RESERVED_SECTION_NAMES.has(id)) return `"${id}" is reserved and cannot be a section`;

package/dist/chunks/validate.mjs

@@ -1,37 +1,39 @@
 import { join, sep, isAbsolute, relative } from 'node:path';
 import { parseExpression } from '@babel/parser';
-import { l as loadContent } from '../shared/vitakit.By5VWQ1n.mjs';
+import { l as loadContent } from '../shared/vitakit.DteA9vLy.mjs';
 import { inventory } from './inventory.mjs';
-import { m as messageOf, w as whereOf } from '../shared/vitakit.DbSeENVS.mjs';
-import { assertTemplatesAreUsed, renderPublications, renderSection } from './emit.mjs';
+import { m as messageOf, w as whereOf } from '../shared/vitakit.DCK90zq4.mjs';
+import { assertTemplatesAreUsed, renderSection, renderPublications } from './emit.mjs';
 import 'node:fs/promises';
 import 'gray-matter';
 import 'yaml';
+import './bibliography.mjs';
+import 'node:fs';
+import '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:url';
+import '@behackl/citation-js-extras';
 import 'unified';
+import 'rehype-parse';
+import 'rehype-sanitize';
+import 'rehype-stringify';
 import 'remark-parse';
 import 'remark-gfm';
 import 'remark-math';
 import 'remark-rehype';
 import 'rehype-katex';
 import 'rehype-raw';
-import 'rehype-stringify';
 import 'unist-util-visit';
-import '../shared/vitakit.D10HyDhF.mjs';
-import 'node:fs';
-import '../shared/vitakit.DQ6PmGoL.mjs';
-import 'node:url';
-import '@behackl/citation-js-extras';
-import 'rehype-parse';
-import 'rehype-sanitize';
 import 'zod';
+import './publication-lists.mjs';
+import '../shared/vitakit.D10HyDhF.mjs';
 import './sections.mjs';
 import './schemas.mjs';
-import '../shared/vitakit.BerUaxtF.mjs';
+import '../shared/vitakit.DvABWuUc.mjs';
 import '../shared/vitakit.TSMTC5Jl.mjs';
 import './fields.mjs';
 import './documents.mjs';
+import '../shared/vitakit.DvvUYUTS.mjs';
 import '../shared/vitakit.D-DdJaDZ.mjs';
-import '../shared/vitakit.Do5HC_MD.mjs';
 import 'eta';
 import '../shared/vitakit.DcQOdM4I.mjs';
 import '../shared/vitakit.CfB3hMHl.mjs';
@@ -96,9 +98,7 @@ ${problem.message}`;
     for (const document of inv.documents) {
       for (const placement of document.placements) {
         try {
-          if (placement.section === "publications") {
-            await renderPublications(content.publications, document.options, templateDir, content.profile.url);
-          } else if (valid.has(placement.section)) {
+          if (valid.has(placement.section)) {
             await renderSection(placement.section, content.sections[placement.section] ?? [], document.options, templateDir);
           }
         } catch (error) {
@@ -109,6 +109,15 @@ ${problem.message}`;
           });
         }
       }
+      for (const placement of document.publications) {
+        const list = content.publications[placement.list];
+        if (!list) continue;
+        try {
+          await renderPublications(list, templateDir, content.profile.url);
+        } catch (error) {
+          add({ where: local(whereOf(error, "cv-tex/templates/publications.eta")), message: `${messageOf(error)} (in ${document.tex})` });
+        }
+      }
     }
   }
   const { realpath } = await import('node:fs/promises');

package/dist/chunks/vue.mjs

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

package/dist/chunks/yaml.mjs

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

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-export { a as aligned, c as commands, d as detectPackageManager, m as main } from './shared/vitakit.CoWX2Z4R.mjs';
+export { a as aligned, c as commands, d as detectPackageManager, m as main } from './shared/vitakit.zwr1ssO5.mjs';
 import 'node:fs';
 import 'node:path';
 import './shared/vitakit.DQ6PmGoL.mjs';

package/dist/index.d.mts

@@ -1,9 +1,9 @@
 import * as zod from 'zod';
 import { z } from 'zod';
 export { z } from 'zod';
-import { D as DateRange, V as Visibility, a as VitakitContent } from './shared/vitakit.BfpxDtz1.mjs';
+import { D as DateRange, V as Visibility, a as VitakitContent } from './shared/vitakit.BfR_mUHm.mjs';
 import { RichTextMarker } from './shared/index.mjs';
-export { C as ContentIssue, b as DatePoint, E as Entry, c as EntryBase, L as Link, d as Linked, P as Page, e as Profile, f as Publication, g as PublicationBadge, h as PublicationGroup, i as RichText } from './shared/vitakit.BfpxDtz1.mjs';
+export { C as ContentIssue, b as DatePoint, E as Entry, c as EntryBase, L as Link, d as Linked, P as Page, e as Profile, f as Publication, g as PublicationBadge, h as PublicationGroup, i as PublicationList, j as RichText } from './shared/vitakit.BfR_mUHm.mjs';
 import { BadgeConfig } from '@behackl/citation-js-extras';
 export { BadgeConfig, badgePresets } from '@behackl/citation-js-extras';
 import * as zod_v4_core from 'zod/v4/core';
@@ -696,18 +696,18 @@ interface LoadContentOptions {
 }
 declare function loadContent(rootDir: string, options?: LoadContentOptions): Promise<VitakitContent>;
 
-interface PublicationGroupConfig {
+interface PublicationStatusConfig {
     /** A value of the `status` field; lowercase, e.g. `preprint` or `talk-slides`. */
     id: string;
-    /** Heading on the website and in the PDF. */
+    /** Heading of its group, on the website and in the PDF. */
     label: string;
 }
 /** What `schemas/publications.ts` may set; everything is optional. */
 interface PublicationsInput {
-    /** The values of `status`, in the order the groups appear. */
-    groups?: PublicationGroupConfig[];
-    /** The group of an entry without `status`. Defaults to the first group. */
-    defaultGroup?: string;
+    /** The values of `status`, in the order their groups appear. */
+    statuses?: PublicationStatusConfig[];
+    /** The status of an entry without one. Defaults to the first status. */
+    defaultStatus?: string;
     /** BibTeX fields that become links after a reference, on the website. */
     badges?: BadgeConfig[];
     /** Further BibTeX fields to hand to the website, as `entry.fields`. */
@@ -725,4 +725,4 @@ interface PublicationsInput {
 declare function publications(input: PublicationsInput): PublicationsInput;
 
 export { DateRange, Visibility, VitakitContent, dateRange, _default$4 as education, _default$3 as employment, entry, extendSection, linked, loadContent, publications, requiredLink, richText, schemas, section, _default as supervision, _default$1 as talks, _default$2 as teaching, text, url, visibility };
-export type { BuiltinSection, LoadContentOptions, PublicationGroupConfig, PublicationsInput };
+export type { BuiltinSection, LoadContentOptions, PublicationStatusConfig, PublicationsInput };

package/dist/index.mjs

@@ -1,27 +1,29 @@
-export { d as dateRange, e as entry, l as linked, r as requiredLink, a as richText, s as section, t as text, u as url, v as visibility } from './shared/vitakit.BerUaxtF.mjs';
+export { d as dateRange, e as entry, l as linked, r as requiredLink, a as richText, s as section, t as text, u as url, v as visibility } from './shared/vitakit.DvABWuUc.mjs';
 export { education, employment, extendSection, schemas, supervision, talks, teaching } from './chunks/schemas.mjs';
-export { l as loadContent, p as publications } from './shared/vitakit.By5VWQ1n.mjs';
+export { l as loadContent } from './shared/vitakit.DteA9vLy.mjs';
+export { p as publications } from './chunks/bibliography.mjs';
 export { badgePresets } from '@behackl/citation-js-extras';
 export { z } from 'zod';
-import './shared/vitakit.DbSeENVS.mjs';
+import './shared/vitakit.DCK90zq4.mjs';
 import 'node:url';
 import './shared/vitakit.D10HyDhF.mjs';
 import 'node:fs/promises';
 import 'node:path';
 import 'gray-matter';
 import 'yaml';
+import './chunks/publication-lists.mjs';
+import './chunks/sections.mjs';
+import './shared/vitakit.TSMTC5Jl.mjs';
+import 'node:fs';
+import './shared/vitakit.DQ6PmGoL.mjs';
 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 'rehype-stringify';
 import 'unist-util-visit';
-import 'node:fs';
-import './shared/vitakit.DQ6PmGoL.mjs';
-import 'rehype-parse';
-import 'rehype-sanitize';
-import './chunks/sections.mjs';
-import './shared/vitakit.TSMTC5Jl.mjs';