@anja.codes/vitakit 0.2.0 → 0.3.0

package/README.md

@@ -27,11 +27,12 @@ published site, [concepts](https://vitakit.anja.codes/guide/concepts),
 content/
   profile.yml           name, affiliation, links, menu, footer
   <section>.yml         education, employment, teaching, talks, …
-  publications.bib      grouped, linked publication list
+  publications.bib      your publications, formatted and linked
+  publication-lists.yml which of them each list shows: recent, preprints, by year, …
   pages/*.md            prose pages, mathematics and images included
 schemas/<section>.ts    optional: what a section of your own may contain
-app/pages/*.vue         which sections each website page shows
-cv-tex/<document>.tex   which sections each PDF shows; cv-tex/<document>.yml selects entries
+app/pages/*.vue         which sections and lists each website page shows
+cv-tex/<document>.tex   which sections and lists each PDF shows; cv-tex/<document>.yml selects entries
 ```
 
 - **Validated content.** Every file is checked against its schema. A broken

package/dist/check.mjs

@@ -1,29 +1,31 @@
 import { readFile, stat, readdir } from 'node:fs/promises';
 import { join, relative } from 'node:path';
-import { l as loadContent } from './shared/vitakit.By5VWQ1n.mjs';
-import { M as MARKER_KEY } from './shared/vitakit.BerUaxtF.mjs';
+import { l as loadContent } from './shared/vitakit.DteA9vLy.mjs';
+import { M as MARKER_KEY } from './shared/vitakit.DvABWuUc.mjs';
 import { a as richSource, r as richHtml } from './shared/vitakit.CtChKO0I.mjs';
 import { a as atMost } from './shared/vitakit.TSMTC5Jl.mjs';
 import 'gray-matter';
 import 'yaml';
+import './chunks/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 './shared/vitakit.DbSeENVS.mjs';
+import './shared/vitakit.DCK90zq4.mjs';
 import 'zod';
+import './chunks/publication-lists.mjs';
+import './shared/vitakit.D10HyDhF.mjs';
 import './chunks/sections.mjs';
 import './chunks/schemas.mjs';
 
@@ -190,7 +192,7 @@ async function checkStatic(options) {
     }
     checked.push("links into the site lead somewhere");
   }
-  if (content.publications.length) {
+  if (Object.values(content.publications).some((list) => list.count)) {
     const bibPages = [...pages].filter(([, html]) => html.includes("vita-bib"));
     for (const [file, html] of bibPages) {
       if (/bibmathplaceholderx*\d+end/i.test(html)) fail(`${relative(outDir, file)}: a formula in the bibliography was not rendered`);

package/dist/chunks/authoring.mjs

@@ -1,9 +1,11 @@
-import { parseDocument, isMap, isSeq, parse } from 'yaml';
-import { p as propertyKey, a as addSchemaField, e as ensurePackageImports } from '../shared/vitakit.BZZIsWlY.mjs';
-import { f as findPdfPlacements } from '../shared/vitakit.Do5HC_MD.mjs';
+import { parse } from 'yaml';
+import { p as propertyKey, a as addSchemaField, e as ensurePackageImports } from '../shared/vitakit.CCTDg7pz.mjs';
+import { c as findPdfPublicationPlacements, f as findPdfPlacements } from '../shared/vitakit.DvvUYUTS.mjs';
 import { a as escapeTex } from '../shared/vitakit.DcQOdM4I.mjs';
-import { i as insertLinesAfter, a as indentationAt, b as insertLinesBefore, l as lineStart, c as lineEnd, d as addSectionToPage, s as sectionElementSource } from './vue.mjs';
-import { C as CommandError } from '../shared/vitakit.CoWX2Z4R.mjs';
+import { b as insertLinesAfter, i as indentationAt, c as insertLinesBefore } from '../shared/vitakit.UfoXdL7U.mjs';
+import { addPublicationsToPage, publicationsElementSource, addSectionToPage, sectionElementSource } from './vue.mjs';
+import { addNavItem, yamlScalar } from './yaml.mjs';
+import { C as CommandError } from '../shared/vitakit.zwr1ssO5.mjs';
 import '@babel/parser';
 import 'node:fs/promises';
 import 'node:path';
@@ -18,56 +20,42 @@ import 'node:readline/promises';
 function vitasectionLine(id, heading) {
   return `\\vitasection${heading ? `[${escapeTex(heading)}]` : ""}{${id}}`;
 }
-function addSectionToDocument(source, placement) {
-  const placements = findPdfPlacements("", "", source);
-  if (placements.some((existing) => existing.section === placement.id && existing.macro === "vitasection")) {
-    return { ok: false, reason: `it already includes ${placement.id}` };
-  }
-  const line = vitasectionLine(placement.id, placement.heading);
+function vitapublicationsLine(list, heading) {
+  return `\\vitapublications${heading ? `[${escapeTex(heading)}]` : ""}{${list}}`;
+}
+function anchors(source) {
+  return [
+    ...findPdfPlacements("", "", source).map((placement) => ({ id: placement.section, line: placement.line })),
+    ...findPdfPublicationPlacements("", "", source).map((placement) => ({ id: placement.list, line: placement.line }))
+  ].sort((a, b) => a.line - b.line);
+}
+function insertLine(source, text, after) {
+  const found = anchors(source);
   const lines = source.split("\n");
-  const offsetOf = (lineNumber) => lines.slice(0, lineNumber - 1).reduce((sum, text) => sum + text.length + 1, 0);
-  const anchor = (placement.after && placements.find((existing) => existing.section === placement.after)) ?? placements[placements.length - 1];
+  const offsetOf = (lineNumber) => lines.slice(0, lineNumber - 1).reduce((sum, line) => sum + line.length + 1, 0);
+  const anchor = (after && found.find((existing) => existing.id === after)) ?? found[found.length - 1];
   if (anchor) {
     const offset = offsetOf(anchor.line);
     return {
       ok: true,
-      value: { source: insertLinesAfter(source, offset, [`${indentationAt(source, offset)}${line}`]), line: anchor.line + 1, afterSection: anchor.section }
+      value: { source: insertLinesAfter(source, offset, [`${indentationAt(source, offset)}${text}`]), line: anchor.line + 1, afterSection: anchor.id }
     };
   }
-  const end = lines.findIndex((text) => /^\s*\\end\{document\}/.test(text));
+  const end = lines.findIndex((line) => /^\s*\\end\{document\}/.test(line));
   if (end === -1) return { ok: false, reason: "it has no \\end{document} line" };
-  return { ok: true, value: { source: insertLinesBefore(source, offsetOf(end + 1), [line, ""]), line: end + 1 } };
-}
-
-function yamlScalar(value) {
-  return /^[A-Za-z0-9/][\w ./()'-]*$/.test(value) && !/(^|\s)#|:\s|\s$/.test(value) ? value : JSON.stringify(value);
+  return { ok: true, value: { source: insertLinesBefore(source, offsetOf(end + 1), [text, ""]), line: end + 1 } };
 }
-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}
-` };
+function addSectionToDocument(source, placement) {
+  if (findPdfPlacements("", "", source).some((existing) => existing.section === placement.id && existing.macro === "vitasection")) {
+    return { ok: false, reason: `it already includes ${placement.id}` };
   }
-  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}` };
+  return insertLine(source, vitasectionLine(placement.id, placement.heading), placement.after);
+}
+function addPublicationsToDocument(source, placement) {
+  if (findPdfPublicationPlacements("", "", source).some((existing) => existing.list === placement.id)) {
+    return { ok: false, reason: `it already includes the list ${placement.id}` };
   }
-  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)}` };
+  return insertLine(source, vitapublicationsLine(placement.id, placement.heading), placement.after);
 }
 
 function dataStarter(id) {
@@ -255,6 +243,23 @@ async function planPlaceInDocument(ws, document, placement) {
     ws.paste(path, vitasectionLine(placement.id, placement.title), `cannot be changed safely (${result.reason}); add this line where the section should appear`);
   }
 }
+async function planListOnPage(ws, inv, path, placement) {
+  const source = await ws.read(path);
+  if (source === void 0) throw new CommandError(`${path} does not exist`);
+  const result = addPublicationsToPage(source, placement, inv.web.components.keys());
+  if (result.ok) await ws.edit(path, result.value.source, `shows the list ${placement.list}${result.value.afterSection ? ` after ${result.value.afterSection}` : ""}`);
+  else if (result.reason.startsWith("it already shows")) ws.keep(path, `already shows the list ${placement.list}`);
+  else ws.paste(path, publicationsElementSource(placement.list, placement.title), `cannot be changed safely (${result.reason}); add this line where the list should appear`);
+}
+async function planListInDocument(ws, document, placement) {
+  const path = `cv-tex/${document}.tex`;
+  const source = await ws.read(path);
+  if (source === void 0) throw new CommandError(`${path} does not exist`);
+  const result = addPublicationsToDocument(source, { id: placement.id, ...placement.title ? { heading: placement.title } : {}, ...placement.after ? { after: placement.after } : {} });
+  if (result.ok) await ws.edit(path, result.value.source, `includes the list ${placement.id}${result.value.afterSection ? ` after ${result.value.afterSection}` : ""}`);
+  else if (result.reason.startsWith("it already includes")) ws.keep(path, `already includes the list ${placement.id}`);
+  else ws.paste(path, vitapublicationsLine(placement.id, placement.title), `cannot be changed safely (${result.reason}); add this line where the list should appear`);
+}
 function pageModule(route, name, title) {
   return `<script setup lang="ts">
 /**
@@ -364,4 +369,4 @@ async function planMissingFields(rootDir, ws, section, entries) {
   return { fields: names, changes: extension.changes };
 }
 
-export { FIELD_TYPES, STARTER_ENTRIES, dataExample, dataStarter, exampleValue, extensionModule, fieldCode, fieldsNotShown, matchingSchemas, planAddField, planCreatePage, planMissingFields, planPlaceInDocument, planPlaceOnPage, rawEntries, schemaOwner, sharedSchemaModule };
+export { FIELD_TYPES, STARTER_ENTRIES, dataExample, dataStarter, exampleValue, extensionModule, fieldCode, fieldsNotShown, matchingSchemas, planAddField, planCreatePage, planListInDocument, planListOnPage, planMissingFields, planPlaceInDocument, planPlaceOnPage, rawEntries, schemaOwner, sharedSchemaModule };

package/dist/{shared/vitakit.By5VWQ1n.mjs → chunks/bibliography.mjs}

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

package/dist/chunks/build.mjs

@@ -3,32 +3,35 @@ import { mkdir, readFile, writeFile, rm, copyFile, rename } from 'node:fs/promis
 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 { l as loadContent } from '../shared/vitakit.DteA9vLy.mjs';
+import { f as fail } from '../shared/vitakit.DCK90zq4.mjs';
 import { discoverDocuments, validateDocumentSections, selectEntries } from './documents.mjs';
+import { p as publicationPlacementProblems } from '../shared/vitakit.DvvUYUTS.mjs';
 import { discoverSections } from './sections.mjs';
 import { emitDocument, bundledTexDir, SITE_PATH_HELP } from './emit.mjs';
 import { a as escapeTex, b as escapeUrl } from '../shared/vitakit.DcQOdM4I.mjs';
 import { i as isSitePath } from '../shared/vitakit.D10HyDhF.mjs';
 import 'gray-matter';
 import 'yaml';
+import './bibliography.mjs';
+import '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:url';
+import '@behackl/citation-js-extras';
 import 'unified';
+import 'rehype-parse';
+import 'rehype-sanitize';
+import 'rehype-stringify';
 import 'remark-parse';
 import 'remark-gfm';
 import 'remark-math';
 import 'remark-rehype';
 import 'rehype-katex';
 import 'rehype-raw';
-import '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 './publication-lists.mjs';
 import './schemas.mjs';
-import '../shared/vitakit.BerUaxtF.mjs';
+import '../shared/vitakit.DvABWuUc.mjs';
 import '../shared/vitakit.TSMTC5Jl.mjs';
 import '../shared/vitakit.D-DdJaDZ.mjs';
 import 'eta';
@@ -71,7 +74,7 @@ Full log: ${log}` : ""}`));
     });
   });
 }
-function profilePreamble(content, document) {
+function profilePreamble(content, document, lists) {
   const { profile } = content;
   const href = (url) => {
     if (isSitePath(url)) fail("content/profile.yml", `links: ${url} ${SITE_PATH_HELP}`);
@@ -96,6 +99,7 @@ function profilePreamble(content, document) {
         ...title ? [`\\vitasectiontitle{${id}}{${escapeTex(title)}}`] : []
       ];
     }),
+    ...lists.filter((name) => !content.publications[name]?.count).map((name) => `\\vitaemptypublications{${name}}`),
     ""
   ].join("\n");
 }
@@ -112,15 +116,16 @@ function siteUrlSourcemap(siteUrl) {
 }
 async function buildDocument(document, content, options, cvDir) {
   const outDir = join(cvDir, "generated", document.name);
+  const lists = [...new Set(document.publications.map((placement) => placement.list))];
   const written = await emitDocument({
     sections: content.sections,
-    publications: content.publications,
+    publications: Object.fromEntries(lists.map((name) => [name, content.publications[name]])),
     siteUrl: content.profile.url,
     options: document.options,
     templateDir: join(cvDir, "templates"),
     outDir
   });
-  await writeFile(join(outDir, "profile.tex"), profilePreamble(content, document));
+  await writeFile(join(outDir, "profile.tex"), profilePreamble(content, document, lists));
   const generatedClass = join(outDir, CLASS_FILE);
   if (existsSync(join(cvDir, CLASS_FILE))) await rm(generatedClass, { force: true });
   else await copyFile(join(bundledTexDir, CLASS_FILE), generatedClass);
@@ -149,13 +154,10 @@ async function buildCv(options) {
   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 [problem] = publicationPlacementProblems([], [...document.placements, ...document.publications], Object.keys(content.publications));
+    if (problem) fail(problem.where, problem.message);
   }
   const unknown = options.only?.filter((name) => !documents.some((document) => document.name === name)) ?? [];
   if (unknown.length) {