@anja.codes/vitakit 0.1.0

package/dist/shared/vitakit.CypCF-4Q.mjs

@@ -0,0 +1,503 @@
+import { readFile, stat, readdir } from 'node:fs/promises';
+import { join, isAbsolute, resolve } from 'node:path';
+import matter from 'gray-matter';
+import { parse } from 'yaml';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import remarkMath from 'remark-math';
+import remarkRehype from 'remark-rehype';
+import rehypeKatex from 'rehype-katex';
+import rehypeRaw from 'rehype-raw';
+import rehypeStringify from 'rehype-stringify';
+import { visit } from 'unist-util-visit';
+import { m as fail, p as formatZodIssues, o as resolveAsset, q as importProjectModule, s as schemas, k as atMost, w as renderRichFields, x as resolveSitePaths, I as Issues, y as profile, z as absoluteSitePath, A as whereOf, B as messageOf, C as page } from './vitakit.BxcnlFGP.mjs';
+import { existsSync } from 'node:fs';
+import { badgePresets, Bibliography } from '@behackl/citation-js-extras';
+import rehypeParse from 'rehype-parse';
+import rehypeSanitize, { defaultSchema } from 'rehype-sanitize';
+import { z } from 'zod';
+
+const URL_PROPERTIES = ["href", "src", "poster", "data", "action", "formAction"];
+const isRootRelative = (value) => value.startsWith("/") && !value.startsWith("//");
+function prefixRootRelative(value, prefix) {
+  return prefix && isRootRelative(value) ? `${prefix}${value}` : value;
+}
+function baseUrlPlugin(baseURL) {
+  const prefix = baseURL.replace(/\/$/, "");
+  return () => (tree) => {
+    if (!prefix) return;
+    visit(tree, "element", (node) => {
+      const properties = node.properties;
+      if (!properties) return;
+      for (const name of URL_PROPERTIES) {
+        const value = properties[name];
+        if (typeof value === "string") properties[name] = prefixRootRelative(value, prefix);
+      }
+      const srcSet = properties.srcSet;
+      if (typeof srcSet === "string" || Array.isArray(srcSet)) {
+        const candidates = typeof srcSet === "string" ? srcSet.split(/\s*,\s+|\s*,(?=\/)/) : srcSet;
+        properties.srcSet = candidates.map((candidate) => String(candidate).trim()).filter(Boolean).map((candidate) => prefixRootRelative(candidate, prefix)).join(", ");
+      }
+    });
+  };
+}
+const ERROR_COLOR = "#c0ffee";
+const ONE_LINE_DISPLAY = /^([ \t]*)\$\$[ \t]*(\S[^\n]*?)[ \t]*\$\$[ \t]*$/;
+const FENCE = /^[ \t]*(`{3,}|~{3,})/;
+function normaliseDisplayMath(source) {
+  let fence;
+  return source.split("\n").map((line) => {
+    const marker = FENCE.exec(line)?.[1];
+    if (fence === void 0) {
+      if (marker) fence = marker;
+    } else if (marker && marker.startsWith(fence[0]) && marker.length >= fence.length) {
+      fence = void 0;
+      return line;
+    }
+    if (fence !== void 0) return line;
+    return line.replace(ONE_LINE_DISPLAY, "$1$$$$\n$2\n$1$$$$");
+  }).join("\n");
+}
+function createRenderer({ baseURL = "/" } = {}) {
+  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMath).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeRaw).use(rehypeKatex, { strict: "error", trust: false, errorColor: ERROR_COLOR }).use(baseUrlPlugin(baseURL)).use(rehypeStringify, { allowDangerousHtml: true });
+  function markdown(source) {
+    const file = processor.processSync(normaliseDisplayMath(source));
+    if (file.messages.length) {
+      const details = file.messages.map((message) => `  - line ${message.line ?? "?"}: ${message.cause?.message ?? message.reason}`).join("\n");
+      throw new Error(`invalid TeX
+${details}`);
+    }
+    const html = String(file).trim();
+    if (html.includes(ERROR_COLOR)) {
+      const refused = /<annotation[^>]*>([^<]*)<\/annotation>/.exec(html)?.[1] ?? source;
+      throw new Error(
+        `KaTeX refused to render: ${refused.trim()}
+  commands such as \\href, \\url and \\includegraphics are disabled, because
+  rendered mathematics is inserted into the page without further sanitization.`
+      );
+    }
+    return html;
+  }
+  function inline(source) {
+    const html = markdown(source);
+    const unwrapped = /^<p>([\s\S]*)<\/p>$/.exec(html);
+    if (!unwrapped) throw new Error(`expected a single paragraph, got: ${html}`);
+    return unwrapped[1];
+  }
+  return { markdown, inline };
+}
+
+function publications(input2) {
+  return input2;
+}
+const ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const callable = z.custom((value) => typeof value === "function", "expected a function");
+const badge = z.strictObject({
+  field: z.string().min(1),
+  label: z.union([z.string(), callable]),
+  url: z.union([z.string(), callable]),
+  match: z.instanceof(RegExp).optional(),
+  split: z.union([z.string(), z.instanceof(RegExp)]).optional(),
+  className: z.string().optional()
+});
+const input = z.strictObject({
+  groups: 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(),
+  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") {
+  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 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(", ")})`);
+  }
+  return {
+    groups,
+    defaultGroup,
+    badges: parsed.data.badges ?? defaults.badges,
+    fields: parsed.data.fields ?? defaults.fields,
+    ...parsed.data.cslStyle ? { cslStyle: parsed.data.cslStyle } : {}
+  };
+}
+
+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.
+   */
+  groups: [
+    { 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",
+  /**
+   * BibTeX fields that become links after a reference on the website. The
+   * presets accept the spellings real exports use (`doi:10...`, doi.org URLs,
+   * `arXiv:...`, `MR1234567`, `Zbl 1234.56789`) and biblatex's `eprint`. A
+   * badge of your own, e.g. for slides in `public/slides/`:
+   *
+   *   { field: 'slides', label: 'Slides', url: '/slides/$1.pdf', className: 'vita-badge' }
+   */
+  badges: [
+    { ...badgePresets.doi, className: "vita-badge" },
+    { ...badgePresets.arxiv, className: "vita-badge" },
+    { ...badgePresets.mrnumber, className: "vita-badge" },
+    { ...badgePresets.zbl, className: "vita-badge" }
+  ],
+  /**
+   * Further BibTeX fields a component can show, as `entry.fields.<name>`,
+   * e.g. `['project']` for a copy of VitaPublication that names the project.
+   */
+  fields: []
+});
+
+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);
+  const stats = await stat(path).catch(() => void 0);
+  if (!stats) return defaultPublications;
+  const module = await importProjectModule(path, stats.mtimeMs, where);
+  if (module.default === void 0) {
+    fail(where, "must export the settings as its default export: `export default publications({ ... })`");
+  }
+  const schema = resolvePublications(module.default, defaultPublications, where);
+  return schema.cslStyle && /\.csl$/i.test(schema.cslStyle) && !isAbsolute(schema.cslStyle) ? { ...schema, cslStyle: resolve(rootDir, schema.cslStyle) } : schema;
+}
+function allowClasses(tag, ...classNames) {
+  const rules = [...defaultSchema.attributes?.[tag] ?? []];
+  const index = rules.findIndex((rule) => Array.isArray(rule) && rule[0] === "className");
+  const existing = index === -1 ? [] : rules[index].slice(1);
+  const merged = ["className", ...existing, ...classNames];
+  if (index === -1) rules.push(merged);
+  else rules[index] = merged;
+  return rules;
+}
+const sanitizer = unified().use(rehypeParse, { fragment: true }).use(rehypeSanitize, {
+  ...defaultSchema,
+  attributes: {
+    ...defaultSchema.attributes,
+    li: [...defaultSchema.attributes?.li ?? [], "dataCslEntryId"],
+    div: allowClasses("div", "csl-block", "csl-left-margin", "csl-right-inline", "csl-indent"),
+    // citeproc uses these fixed styles for formatting without semantic tags,
+    // e.g. upright emphasis within an italic title. Never allow arbitrary CSS.
+    span: [...defaultSchema.attributes?.span ?? [], [
+      "style",
+      "font-style:normal;",
+      "font-variant:small-caps;",
+      "font-variant:normal;",
+      "font-weight:normal;",
+      "text-decoration:none;",
+      "text-decoration:underline;"
+    ]]
+  }
+}).use(rehypeStringify);
+const parser = unified().use(rehypeParse, { fragment: true });
+const serializer = unified().use(rehypeStringify);
+function splitList(html) {
+  const items = /* @__PURE__ */ new Map();
+  for (const list of parser.parse(html).children) {
+    if (list.type !== "element") continue;
+    for (const item of list.children) {
+      if (item.type !== "element" || item.tagName !== "li") continue;
+      const inner = { type: "root", children: item.children };
+      items.set(String(item.properties.dataCslEntryId), serializer.stringify(inner).trim());
+    }
+  }
+  return items;
+}
+const defaultCslStyle = join(resolveAsset("styles"), "vitakit-math.csl");
+function projectCslStyle(bibPath) {
+  const path = bibPath.replace(/\.bib$/i, ".csl");
+  return path !== bibPath && existsSync(path) ? path : void 0;
+}
+const GENRES = {
+  phdthesis: "PhD thesis",
+  mastersthesis: "Master's thesis",
+  mathesis: "Master's thesis",
+  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 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"),
+      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.
+      customFields: ["status", ...fields],
+      preserveMath: true,
+      // Defaults for every formatHtml call below.
+      badges: schema.badges,
+      sanitize: (html) => String(sanitizer.processSync(html)),
+      wrapVariable: readableGenre,
+      linkAttributes: (link) => ({ href: prefixRootRelative(link.url, prefix) })
+    });
+  } 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 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)`
+    );
+  }
+  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;
+    let items;
+    try {
+      items = splitList(bib.formatHtml(entries, {
+        // Badges are data (`Publication.badges`), laid out by the component.
+        appendBadges: false,
+        // Inserted after sanitizing. citation-js-extras names the citation key
+        // when a formula cannot be rendered; the file is added by withFile.
+        renderMath: (tex, { display }) => display ? renderer.markdown(`$$${tex}$$`) : renderer.inline(`$${tex}$`)
+      }));
+    } catch (error) {
+      throw withFile(error);
+    }
+    const publications = 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);
+      return {
+        key: entry.key,
+        html,
+        ...title ? { titleUrl: prefixRootRelative(title.url, prefix) } : {},
+        fields: Object.fromEntries(fields.filter((field) => entry.custom[field] !== void 0).map((field) => [field, entry.custom[field]])),
+        badges: badges.map((badge) => ({
+          field: badge.field,
+          value: badge.value,
+          label: badge.label,
+          url: prefixRootRelative(badge.url, prefix),
+          ...badge.className ? { className: badge.className } : {}
+        }))
+      };
+    });
+    result.push({ id: group.id, label: group.label, count: entries.length, entries: publications });
+  }
+  return result;
+}
+
+const RESERVED = /* @__PURE__ */ new Set(["site", "profile"]);
+async function exists(path) {
+  return stat(path).then(() => true, () => false);
+}
+async function loadRepoSchema(path, id) {
+  const { mtimeMs } = await stat(path);
+  const module = await importProjectModule(path, mtimeMs, `schemas/${id}.ts`);
+  const schema = module.default ?? module.schema;
+  if (!schema || typeof schema.safeParse !== "function") {
+    fail(`schemas/${id}.ts`, "must export a Zod schema as its default export");
+  }
+  return schema;
+}
+const STARTER = (id) => `create schemas/${id}.ts, for example:
+
+  import { z, section, dateRange } from '@anja.codes/vitakit'
+
+  export default section({
+    date: dateRange,
+    title: z.string(),
+  })`;
+async function discoverSections(rootDir) {
+  const contentDir = join(rootDir, "content");
+  const schemaDir = join(rootDir, "schemas");
+  const files = (await readdir(contentDir).catch(() => fail("content/", "directory is missing"))).filter((name) => name.endsWith(".yml") || name.endsWith(".yaml")).sort();
+  const sources = [];
+  for (const file of files) {
+    const id = file.replace(/\.ya?ml$/, "");
+    if (RESERVED.has(id)) continue;
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)) {
+      fail(`content/${file}`, "file name must be lowercase kebab-case, e.g. `research-stays.yml`");
+    }
+    const override = join(schemaDir, `${id}.ts`);
+    if (await exists(override)) {
+      sources.push({ id, file: join(contentDir, file), schemaOrigin: "repo", schema: await loadRepoSchema(override, id) });
+      continue;
+    }
+    const builtin = schemas[id];
+    if (!builtin) fail(`content/${file}`, `no schema for this file; ${STARTER(id)}`);
+    sources.push({ id, file: join(contentDir, file), schemaOrigin: "built-in", schema: builtin });
+  }
+  return sources;
+}
+function byDateDesc(a, b) {
+  const left = a.date?.from?.sortKey;
+  const right = b.date?.from?.sortKey;
+  if (left === right) return 0;
+  if (!left) return 1;
+  if (!right) return -1;
+  return right.localeCompare(left);
+}
+async function loadSection(source, options) {
+  const where = `content/${source.id}.yml`;
+  const raw = await readFile(source.file, "utf8");
+  let data;
+  try {
+    data = parse(raw);
+  } catch (error) {
+    fail(where, error instanceof Error ? error.message : String(error));
+  }
+  if (data === null) return [];
+  if (!Array.isArray(data)) fail(where, "expected a list of entries");
+  const parsed = source.schema.safeParse(data);
+  if (!parsed.success) {
+    const origin = source.schemaOrigin === "repo" ? ` (schema: schemas/${source.id}.ts)` : "";
+    fail(where, `invalid${origin}
+${formatZodIssues(parsed.error)}`);
+  }
+  return parsed.data.map((item, index) => ({ ...item, id: `${source.id}-${index}` })).filter((item) => atMost(item.visibility, options.maxVisibility)).map((item, index) => renderRichFields(item, options.renderer, String(index), where)).map((item) => resolveSitePaths(item, options.resolvePath ?? ((path) => path))).sort(byDateDesc);
+}
+
+const FALLBACK_PROFILE = { name: "Your Name", links: [], nav: [], footerHtml: "" };
+async function loadYaml(file, where) {
+  const raw = await readFile(file, "utf8").catch(() => fail(where, "missing"));
+  try {
+    return parse(raw);
+  } catch (error) {
+    fail(where, messageOf(error));
+  }
+}
+async function loadProfile(contentDir, baseURL, renderer, target) {
+  const data = await loadYaml(join(contentDir, "profile.yml"), "content/profile.yml");
+  const parsed = profile.safeParse(data);
+  if (!parsed.success) fail("content/profile.yml", `invalid
+${formatZodIssues(parsed.error)}`);
+  const prefix = baseURL.replace(/\/$/, "");
+  const { avatar, nav, footer, ...rest } = parsed.data;
+  return resolveSitePaths({
+    ...rest,
+    ...avatar ? { avatar: prefixRootRelative(avatar, prefix) } : {},
+    nav: nav.map((item) => ({ label: item.label, url: item.to })),
+    footerHtml: footer ? renderer.inline(footer) : ""
+  }, sitePathResolver(target, baseURL, parsed.data.url));
+}
+function sitePathResolver(target, baseURL, siteUrl) {
+  const prefix = baseURL.replace(/\/$/, "");
+  return target === "pdf" ? (path) => absoluteSitePath(path, siteUrl) : (path) => prefixRootRelative(path, prefix);
+}
+function errorPage(route, where, message) {
+  const escaped = message.replace(/[&<>]/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[character]);
+  return {
+    route,
+    title: `Error in ${where}`,
+    titleHtml: `Error in <code>${where}</code>`,
+    order: -1,
+    bodyHtml: `<pre>${escaped}</pre>`,
+    error: message
+  };
+}
+async function loadPage(dir, file, renderer) {
+  const where = `content/pages/${file}`;
+  const slug = file.slice(0, -".md".length);
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
+    fail(where, "file name must be lowercase kebab-case, e.g. `research-interests.md`");
+  }
+  const { data, content } = matter(await readFile(join(dir, file), "utf8"));
+  const parsed = page.safeParse(data);
+  if (!parsed.success) fail(where, `invalid front matter
+${formatZodIssues(parsed.error)}`);
+  const route = parsed.data.route ?? (slug === "index" ? "/" : `/${slug}/`);
+  try {
+    return {
+      route,
+      title: parsed.data.title,
+      titleHtml: renderer.inline(parsed.data.title),
+      description: parsed.data.description,
+      order: parsed.data.order,
+      bodyHtml: content.trim() ? renderer.markdown(content) : ""
+    };
+  } catch (error) {
+    fail(where, messageOf(error));
+  }
+}
+async function loadPages(contentDir, renderer, issues) {
+  const dir = join(contentDir, "pages");
+  const files = (await readdir(dir).catch(() => [])).filter((name) => name.endsWith(".md")).sort();
+  const pages = await Promise.all(files.map(async (file) => {
+    try {
+      return await loadPage(dir, file, renderer);
+    } catch (error) {
+      if (issues.strict) throw error;
+      const where = whereOf(error, `content/pages/${file}`);
+      const message = messageOf(error);
+      issues.record(where, message);
+      const slug = file.slice(0, -".md".length);
+      return errorPage(slug === "index" ? "/" : `/${slug}/`, where, message);
+    }
+  }));
+  const seen = /* @__PURE__ */ new Map();
+  for (const [index, page] of pages.entries()) {
+    const previous = seen.get(page.route);
+    if (previous) issues.record(`content/pages/${files[index]}`, `route ${page.route} is already used by ${previous}`);
+    else seen.set(page.route, `content/pages/${files[index]}`);
+  }
+  return pages.sort((a, b) => a.order - b.order || a.route.localeCompare(b.route));
+}
+async function loadSections(rootDir, maxVisibility, renderer, resolvePath, issues) {
+  const sources = await issues.attempt("content/", () => discoverSections(rootDir), []);
+  const sections = {};
+  for (const source of sources) {
+    sections[source.id] = await issues.attempt(
+      `content/${source.id}.yml`,
+      () => loadSection(source, { maxVisibility, renderer, resolvePath }),
+      []
+    );
+  }
+  return sections;
+}
+async function loadContent(rootDir, options = {}) {
+  const strict = options.strict ?? true;
+  const baseURL = options.baseURL ?? "/";
+  const maxVisibility = options.maxVisibility ?? "public";
+  const issues = new Issues(strict);
+  const renderer = createRenderer({ baseURL });
+  const contentDir = join(rootDir, "content");
+  const target = options.target ?? "website";
+  const profile = await issues.attempt("content/profile.yml", () => loadProfile(contentDir, baseURL, renderer, target), FALLBACK_PROFILE);
+  const resolvePath = sitePathResolver(target, baseURL, profile.url);
+  const [pages, sections, publications] = await Promise.all([
+    loadPages(contentDir, renderer, issues),
+    loadSections(rootDir, maxVisibility, renderer, resolvePath, issues),
+    issues.attempt(
+      "content/publications.bib",
+      async () => {
+        const bib = join(contentDir, "publications.bib");
+        const present = await readFile(bib, "utf8").then(() => true, () => false);
+        if (!present) return [];
+        return loadPublications(bib, renderer, await loadPublicationsSchema(rootDir), baseURL);
+      },
+      []
+    )
+  ]);
+  return { profile, pages, sections, publications, issues: issues.list };
+}
+
+export { loadPublicationsSchema as a, loadContent as l, publications as p };

package/dist/shared/vitakit.D8WRg_Xx.d.mts

@@ -0,0 +1,153 @@
+/**
+ * The contract between the build (Node) and the app (Vue).
+ *
+ * Everything with an `Html` suffix is trusted markup produced at build time;
+ * render it with `v-html`. Nothing here is a Zod schema: schemas describe what
+ * a user may *write*, these types describe what a component *receives*.
+ */
+/** How widely an entry may be shown. */
+type Visibility = 'public' | 'cv' | 'private';
+/** A calendar point with the precision the user actually wrote. */
+interface DatePoint {
+    /** ISO-ish source: `2024`, `2024-03`, or `2024-03-15`. */
+    raw: string;
+    year: number;
+    month?: number;
+    day?: number;
+    /** Sort key: always comparable across precisions. */
+    sortKey: string;
+}
+/** A point in time or a span, normalised from what the user wrote. */
+interface DateRange {
+    from: DatePoint;
+    /** Absent for a single date or an ongoing range; see `ongoing`. */
+    to?: DatePoint;
+    /** True when the user wrote `to: present`. */
+    ongoing: boolean;
+    /** Whether the source was a single date rather than a range. */
+    point: boolean;
+}
+/**
+ * Intermediate form of a `richText` field, before rendering.
+ *
+ * Internal: it exists only between validation and `renderRichFields`, never in
+ * a `VitakitContent`. `vitakit-check` fails the build if one reaches the output.
+ * Read rich fields with `richSource` / `richHtml` instead of inspecting shapes.
+ */
+interface RichTextMarker {
+    __vitakitRich: string;
+}
+/** A field that went through the Markdown/KaTeX renderer. */
+interface RichText {
+    /** The Markdown source, for plain-text contexts such as `title` attributes. */
+    text: string;
+    /** Rendered inline HTML; use with `v-html`. */
+    html: string;
+}
+interface Link {
+    label: string;
+    url: string;
+}
+interface Institution {
+    name: string;
+    url?: string;
+}
+/** Fields every section entry has, whatever else its schema adds. */
+interface EntryBase {
+    /** Stable identity for `v-for` keys: the source file plus the index. */
+    id: string;
+    visibility: Visibility;
+}
+/** A validated entry of an arbitrary section. */
+type Entry = EntryBase & Record<string, unknown>;
+/** A link after a reference: DOI, arXiv, MR, zbMATH, or a badge of your own. */
+interface PublicationBadge {
+    /** The BibTeX field it comes from, e.g. `doi`. */
+    field: string;
+    /** The identifier as matched, e.g. `10.1000/xyz` or `2301.00001`. */
+    value: string;
+    label: string;
+    /** Ready to use: root-relative URLs already carry the base path. */
+    url: string;
+    /** The badge's `className`; `vita-badge` for the built-in ones. */
+    className?: string;
+}
+/** One formatted reference. */
+interface Publication {
+    /** Citation key in the .bib file. */
+    key: string;
+    /**
+     * The reference as the citation style formats it, title linked, formulas
+     * typeset; without the badges. Sanitized HTML.
+     */
+    html: string;
+    /** Where the title links to, if anywhere (already in `html`). */
+    titleUrl?: string;
+    badges: PublicationBadge[];
+    /**
+     * The BibTeX fields listed under `fields` in `schemas/publications.ts`, as
+     * written in the .bib file, where the entry has them.
+     */
+    fields: Record<string, string>;
+}
+/** One group of formatted references, e.g. all preprints. */
+interface PublicationGroup {
+    id: string;
+    label: string;
+    count: number;
+    /**
+     * Newest first. Formatted together, so numbering and year suffixes
+     * (2024a, 2024b) are right within the group.
+     */
+    entries: Publication[];
+}
+interface Page {
+    /** Route path, with leading and trailing slash: `/`, `/research/`. */
+    route: string;
+    title: string;
+    /** Rendered inline Markdown; math allowed. */
+    titleHtml: string;
+    description?: string;
+    order: number;
+    /** Rendered Markdown body. */
+    bodyHtml: string;
+    /** Set only in development, when the page could not be built. */
+    error?: string;
+}
+interface Profile {
+    name: string;
+    title?: string;
+    affiliation?: Institution;
+    email?: string;
+    links: Link[];
+    /** Short plain-text description used for page metadata, not rendered. */
+    summary?: string;
+    /**
+     * Where the website is published, e.g. `https://jane.example.org/`. Links
+     * to paths on the site (`/slides/talk.pdf`) need it to work in the PDF.
+     */
+    url?: string;
+    avatar?: string;
+    /** Navigation entries, as written. */
+    nav: Link[];
+    /** Rendered inline Markdown, or an empty string. */
+    footerHtml: string;
+}
+/** A content problem, reported in the browser during development. */
+interface ContentIssue {
+    /** The file it belongs to, e.g. `content/talks.yml`. */
+    where: string;
+    message: string;
+}
+/** Everything compiled from `content/`, as the app sees it. */
+interface VitakitContent {
+    profile: Profile;
+    pages: Page[];
+    /** Section id -> validated, sorted, visibility-filtered entries. */
+    sections: Record<string, Entry[]>;
+    publications: PublicationGroup[];
+    /** Always empty in a production build, which fails instead. */
+    issues: ContentIssue[];
+}
+
+export type { ContentIssue as C, DateRange as D, Entry as E, Institution as I, Link as L, Page as P, RichTextMarker as R, Visibility as V, VitakitContent as a, DatePoint as b, EntryBase as c, Profile as d, Publication as e, PublicationBadge as f, PublicationGroup as g, RichText as h };