@anja.codes/vitakit 0.3.0 → 0.5.0

package/dist/check.mjs

@@ -77,18 +77,48 @@ function urlReferences(html) {
   }
   return found;
 }
-async function existsInSite(outDir, path) {
+function listing(listings, dir) {
+  let names = listings.get(dir);
+  if (!names) {
+    names = readdir(dir, { withFileTypes: true }).then(
+      (entries) => new Map(entries.map((entry) => [entry.name, entry.isDirectory()])),
+      () => void 0
+    );
+    listings.set(dir, names);
+  }
+  return names;
+}
+async function existsInSite(outDir, path, listings) {
   let decoded;
   try {
     decoded = decodeURIComponent(path.replace(/[?#].*$/, ""));
   } catch {
-    return false;
+    return { found: false };
+  }
+  if (relative(outDir, join(outDir, decoded)).startsWith("..")) return { found: false };
+  const segments = decoded.split("/").filter((segment) => segment !== "" && segment !== ".");
+  let dir = outDir;
+  const actual = [];
+  let caseOnly = false;
+  for (const [index, segment] of segments.entries()) {
+    const names = await listing(listings, dir);
+    if (!names) return { found: false };
+    let name = names.has(segment) ? segment : void 0;
+    if (name === void 0) {
+      const lower = segment.toLowerCase();
+      name = [...names.keys()].find((candidate) => candidate.toLowerCase() === lower);
+      if (name === void 0) return { found: false };
+      caseOnly = true;
+    }
+    actual.push(name);
+    const isDirectory = names.get(name);
+    if (index < segments.length - 1 && !isDirectory) return { found: false };
+    dir = join(dir, name);
   }
-  const target = join(outDir, decoded);
-  if (relative(outDir, target).startsWith("..")) return false;
-  const found = await stat(target).catch(() => void 0);
-  if (found?.isFile()) return true;
-  return found?.isDirectory() === true && (await stat(join(target, "index.html")).catch(() => void 0))?.isFile() === true;
+  const last = segments.length ? (await listing(listings, join(dir, "..")))?.get(actual.at(-1)) : true;
+  const leads = last === false || (await listing(listings, dir))?.get("index.html") === false;
+  if (!leads) return { found: false };
+  return caseOnly ? { found: false, differsInCase: `/${actual.join("/")}${decoded.endsWith("/") ? "/" : ""}` } : { found: true };
 }
 const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
 function decodeEntity(reference, name) {
@@ -181,14 +211,16 @@ async function checkStatic(options) {
   checked.push(`assets and links use ${base}`);
   if (builtForBase) {
     const missing = /* @__PURE__ */ new Map();
+    const listings = /* @__PURE__ */ new Map();
     for (const [file, html] of pages) {
       for (const path of urlReferences(html)) {
         if (!underBase(path, base) || missing.has(path)) continue;
-        if (!await existsInSite(outDir, path.slice(base.length))) missing.set(path, relative(outDir, file));
+        const found = await existsInSite(outDir, path.slice(base.length), listings);
+        if (!found.found) missing.set(path, { file: relative(outDir, file), differsInCase: found.differsInCase });
       }
     }
-    for (const [path, file] of missing) {
-      fail(`${file}: ${path} leads nowhere: no such file or page in the generated site. A file belongs in public/, a page in content/pages/ or app/pages/`);
+    for (const [path, { file, differsInCase }] of missing) {
+      fail(differsInCase !== void 0 ? `${file}: ${path} leads nowhere: the site has ${base}${differsInCase.slice(1)}, which differs only in case. Web servers usually tell them apart, even where your computer does not; write the name as it is` : `${file}: ${path} leads nowhere: no such file or page in the generated site. A file belongs in public/, a page in content/pages/ or app/pages/`);
     }
     checked.push("links into the site lead somewhere");
   }

package/dist/chunks/authoring.mjs

@@ -1,11 +1,11 @@
 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 { findPdfPublicationPlacements, findPdfPlacements } from './placements.mjs';
 import { a as escapeTex } from '../shared/vitakit.DcQOdM4I.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 { C as CommandError } from '../shared/vitakit.CvYy_Quj.mjs';
 import '@babel/parser';
 import 'node:fs/promises';
 import 'node:path';

package/dist/chunks/build.mjs

@@ -1,12 +1,12 @@
 import { spawn } from 'node:child_process';
 import { mkdir, readFile, writeFile, rm, copyFile, rename } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import process from 'node:process';
-import { join, delimiter, resolve } from 'node:path';
+import { join, delimiter, resolve, extname } from 'node:path';
 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 { publicationPlacementProblems } from './placements.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';
@@ -74,7 +74,7 @@ Full log: ${log}` : ""}`));
     });
   });
 }
-function profilePreamble(content, document, lists) {
+function profilePreamble(content, document, lists, cvDir) {
   const { profile } = content;
   const href = (url) => {
     if (isSitePath(url)) fail("content/profile.yml", `links: ${url} ${SITE_PATH_HELP}`);
@@ -91,6 +91,7 @@ function profilePreamble(content, document, lists) {
     `\\vitaname{${escapeTex(profile.name)}}`,
     `\\vitatagline{${tagline}}`,
     `\\vitacontact{${contact}}`,
+    ...portraitLine(content, document, cvDir),
     ...profile.url ? siteUrlSourcemap(profile.url) : [],
     ...Object.entries(content.sections).flatMap(([id, entries]) => {
       const title = document.options.sections[id]?.title;
@@ -103,6 +104,30 @@ function profilePreamble(content, document, lists) {
     ""
   ].join("\n");
 }
+const PORTRAIT_FORMATS = [".jpg", ".jpeg", ".png", ".pdf"];
+function portraitLine(content, document, cvDir) {
+  const option = document.options.portrait;
+  if (option === false) return [];
+  const where = `cv-tex/${document.name}.yml`;
+  const path = option === true ? content.profile.avatar : option;
+  if (!path) {
+    fail(where, "portrait: true shows avatar from content/profile.yml, which has none; add one there, or give the image here, e.g. portrait: /img/portrait.jpg");
+  }
+  const what = option === true ? `portrait: true shows avatar ${path} (content/profile.yml)` : `portrait: ${path}`;
+  const format = extname(path).toLowerCase();
+  if (!PORTRAIT_FORMATS.includes(format)) {
+    fail(where, `${what}, but LaTeX cannot include ${format ? `a ${format} file` : "a file without an extension"}; use a JPG, PNG or PDF${option === true ? ", e.g. portrait: /img/portrait.jpg" : ""}`);
+  }
+  if (!/^[\w./-]+$/.test(path) || path.split("/").includes("..")) {
+    fail(where, `${what}: the path may only contain letters, digits and - . _ /`);
+  }
+  if (!existsSync(join(cvDir, "..", "public", path))) fail(where, `${what}: public${path} does not exist`);
+  const ejected = join(cvDir, CLASS_FILE);
+  if (existsSync(ejected) && !readFileSync(ejected, "utf8").includes("\\vitaportrait")) {
+    fail(where, `portrait needs \\vitaportrait, which cv-tex/${CLASS_FILE} does not define: it was ejected from an earlier vitakit. Run vitakit eject vitakit-cv.cls --force for the current class (your copy is kept as a backup), or remove portrait`);
+  }
+  return [`\\vitaportrait{../public${path}}`];
+}
 function siteUrlSourcemap(siteUrl) {
   const base = siteUrl.replace(/\/?$/, "/");
   if (!/^https?:\/\/[\w.:/-]+$/.test(base)) {
@@ -125,7 +150,7 @@ async function buildDocument(document, content, options, cvDir) {
     templateDir: join(cvDir, "templates"),
     outDir
   });
-  await writeFile(join(outDir, "profile.tex"), profilePreamble(content, document, lists));
+  await writeFile(join(outDir, "profile.tex"), profilePreamble(content, document, lists, cvDir));
   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);

package/dist/chunks/documents.mjs

@@ -3,7 +3,7 @@ import { basename, join } from 'node:path';
 import { parse } from 'yaml';
 import { z } from 'zod';
 import { f as fail, m as messageOf, a as formatZodIssues } from '../shared/vitakit.DCK90zq4.mjs';
-import { c as findPdfPublicationPlacements, f as findPdfPlacements } from '../shared/vitakit.DvvUYUTS.mjs';
+import { findPdfPublicationPlacements, findPdfPlacements } from './placements.mjs';
 import { a as atMost } from '../shared/vitakit.TSMTC5Jl.mjs';
 import { f as fieldValue, a as filterWhere } from '../shared/vitakit.D-DdJaDZ.mjs';
 import 'node:url';
@@ -38,6 +38,13 @@ const documentSchema = z.strictObject({
    * build (see `vitakit verify`), and the website renders CV data directly.
    */
   visibility: z.enum(["public", "cv", "private"]).default("cv"),
+  /**
+   * A portrait beside the header: `true` for `avatar` from
+   * `content/profile.yml`, or a path below `public/` for another image, e.g.
+   * a print version. Off by default: whether a CV shows a photo depends on
+   * where it is sent, so each document decides.
+   */
+  portrait: z.union([z.boolean(), z.string().startsWith("/")]).default(false),
   sections: z.record(z.string(), sectionOptions).default({})
 });
 const DEFAULTS = documentSchema.parse({});

package/dist/chunks/eject.mjs

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { r as resolveAsset } from '../shared/vitakit.DQ6PmGoL.mjs';
-import { C as CommandError } from '../shared/vitakit.zwr1ssO5.mjs';
+import { C as CommandError } from '../shared/vitakit.CvYy_Quj.mjs';
 import 'node:url';
 import 'node:process';
 import 'node:util';

package/dist/chunks/emit.mjs

@@ -11,7 +11,7 @@ import { selectEntries } from './documents.mjs';
 import 'node:url';
 import 'yaml';
 import 'zod';
-import '../shared/vitakit.DvvUYUTS.mjs';
+import './placements.mjs';
 import '../shared/vitakit.TSMTC5Jl.mjs';
 import '../shared/vitakit.D-DdJaDZ.mjs';
 

package/dist/chunks/inventory.mjs

@@ -8,7 +8,7 @@ import { describeSection } from './fields.mjs';
 import { findSectionFiles, resolveSectionSchema } from './sections.mjs';
 import { schemas } from './schemas.mjs';
 import { findDocuments, documentSectionProblems } from './documents.mjs';
-import { a as pageRoute, d as documentDirective, p as publicationPlacementProblems, b as findWebPlacements } from '../shared/vitakit.DvvUYUTS.mjs';
+import { pageRoute, documentDirective, publicationPlacementProblems, findWebPlacements } from './placements.mjs';
 import { m as messageOf, w as whereOf } from '../shared/vitakit.DCK90zq4.mjs';
 import './bibliography.mjs';
 import '../shared/vitakit.DQ6PmGoL.mjs';

package/dist/chunks/migrations.mjs

@@ -7,7 +7,7 @@ import { i as importProjectModule } from '../shared/vitakit.DCK90zq4.mjs';
 import { addPublicationList, publicationListYaml } from './yaml.mjs';
 import { r as renamePublicationsSettings } from '../shared/vitakit.CCTDg7pz.mjs';
 import { publicationsElements } from './vue.mjs';
-import { f as findPdfPlacements } from '../shared/vitakit.DvvUYUTS.mjs';
+import { findPdfPlacements } from './placements.mjs';
 import { LISTS_FILE, LISTS_HEADER } from './publication-lists.mjs';
 import 'node:fs';
 import '../shared/vitakit.DQ6PmGoL.mjs';
@@ -85,15 +85,30 @@ async function statusOrder(root) {
     return Array.isArray(old) ? ids(old) : ids(defaultPublications.statuses);
   }
 }
-async function vueFiles(root, dir = join(root, "app")) {
+async function appFiles(root, extension, dir = join(root, "app")) {
   const files = [];
   for (const entry of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
     const path = join(dir, entry.name);
-    if (entry.isDirectory()) files.push(...await vueFiles(root, path));
-    else if (entry.name.endsWith(".vue")) files.push(relative(root, path).split(sep).join("/"));
+    if (entry.isDirectory()) files.push(...await appFiles(root, extension, path));
+    else if (entry.name.endsWith(extension)) files.push(relative(root, path).split(sep).join("/"));
   }
   return files.sort();
 }
+const PUBLICATIONS_TITLE_CSS = `.vita-publications__title {
+  @apply text-xl font-semibold;
+}
+.vita-publications__title ~ .vita-publications__group .vita-publications__heading {
+  @apply mt-4 text-base;
+}`;
+async function checkStyles(ws, root, notes) {
+  const sheets = [];
+  for (const path of await appFiles(root, ".css")) sheets.push({ path, source: await ws.read(path) });
+  if (sheets.some((sheet) => sheet.source.includes(".vita-publications__title"))) return;
+  const styled = sheets.find((sheet) => sheet.source.includes(".vita-publications__heading"));
+  if (!styled) return;
+  notes.after.push(`By hand: ${styled.path} styles the groups of a publication list but not its title, <VitaPublications title>. New projects have, after .vita-publications__heading:
+${PUBLICATIONS_TITLE_CSS}`);
+}
 async function migrateSchema(ws, notes) {
   const path = "schemas/publications.ts";
   const source = await ws.read(path);
@@ -104,7 +119,7 @@ async function migrateSchema(ws, notes) {
 }
 async function migratePages(root, ws, lists, notes) {
   const statuses = await statusOrder(root);
-  for (const path of await vueFiles(root)) {
+  for (const path of await appFiles(root, ".vue")) {
     const source = await ws.read(path);
     if (/(^|\/)VitaPublications\.vue$/.test(path)) {
       notes.after.push(`By hand: ${path} is your copy of VitaPublications. Its props are now list and title, and it reads usePublicationList(list); \`vitakit eject VitaPublications\` shows vitakit's.`);
@@ -187,6 +202,7 @@ async function migrateDocuments(root, ws, lists, notes) {
 }
 async function migratePublicationLists(root, ws, notes) {
   await migrateSchema(ws, notes);
+  await checkStyles(ws, root, notes);
   const source = await ws.read(LISTS_FILE);
   let existing;
   try {
@@ -214,5 +230,28 @@ ${[...lists.added].map(([other, value]) => publicationListYaml(other, value)).jo
   if (source === void 0) ws.create(LISTS_FILE, lines, reason, { show: true });
   else await ws.edit(LISTS_FILE, lines, reason);
 }
+const CAST = /\bentry\.[\w$]+\s+as\s+[A-Z][\w$]*(?:\s*\|\s*undefined)?|\(\s*entry\s+as\s+[A-Z][\w$<>'" |]*\)/;
+async function migrateSectionComponents(root, ws, notes) {
+  const { findWebPlacements } = await import('./placements.mjs');
+  const { sectionProps, typeSectionProps } = await import('./props.mjs');
+  const { placements, components } = await findWebPlacements(root);
+  for (const [name, file] of components) {
+    const source = await ws.read(file);
+    if (source === void 0) continue;
+    const found = sectionProps(source);
+    if (!found.ok || !found.value.untyped) continue;
+    const ids = [...new Set(placements.filter((placement) => placement.component === name).map((placement) => placement.section))].sort();
+    if (!ids.length) {
+      notes.after.push(`By hand: ${file} is shown on no page with a literal id. To type its entries, give its id the sections it shows, e.g. id: 'talks' | 'talks-public'.`);
+      continue;
+    }
+    const typed = typeSectionProps(source, ids);
+    if (!typed.ok) continue;
+    await ws.edit(file, typed.value.source, `its entries are typed by the schema of ${ids.join(", ")}`);
+    if (CAST.test(source)) {
+      notes.after.push(`${file} casts entries to types of its own (as \u2026). They still work, but its entries are typed by their schema now; the casts can go, and fields read as written, e.g. entry.<group>.<field>.`);
+    }
+  }
+}
 
-export { migratePublicationLists };
+export { PUBLICATIONS_TITLE_CSS, migratePublicationLists, migrateSectionComponents };

package/dist/{shared/vitakit.DvvUYUTS.mjs → chunks/placements.mjs}

@@ -197,4 +197,4 @@ function documentDirective(source) {
   return void 0;
 }
 
-export { pageRoute as a, findWebPlacements as b, findPdfPublicationPlacements as c, documentDirective as d, findPdfPlacements as f, publicationPlacementProblems as p };
+export { componentName, documentDirective, findPdfPlacements, findPdfPublicationPlacements, findWebPlacements, pageRoute, publicationPlacementProblems };

package/dist/chunks/plan.mjs

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { readFile, mkdir, writeFile, rename } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
-import { C as CommandError } from '../shared/vitakit.zwr1ssO5.mjs';
+import { C as CommandError } from '../shared/vitakit.CvYy_Quj.mjs';
 import '../shared/vitakit.DQ6PmGoL.mjs';
 import 'node:url';
 import 'node:process';

package/dist/chunks/props.mjs

@@ -0,0 +1,50 @@
+import { entryComponentProps, listComponentProps } from './snippets.mjs';
+import '../shared/vitakit.DcQOdM4I.mjs';
+
+const UNTYPED_ENTRY = "const props = defineProps<{ id?: string, entries?: Entry[], title?: string, where?: Where, limit?: number }>()";
+const UNTYPED_LIST = "const props = defineProps<{ id: string, title?: string, where?: Where, limit?: number }>()";
+const IDS = String.raw`'[a-z0-9-]+'(?:\s*\|\s*'[a-z0-9-]+')*`;
+const TYPED_ENTRY = new RegExp(String.raw`^const props = defineProps<\{ id: (${IDS}), entries\?: SectionEntries<(${IDS})>, title\?: string, where\?: Where, limit\?: number \}>\(\)$`, "m");
+const TYPED_LIST = new RegExp(String.raw`^const props = defineProps<\{ id: (${IDS}), title\?: string, where\?: Where, limit\?: number \}>\(\)$`, "m");
+const parseIds = (type) => [...type.matchAll(/'([a-z0-9-]+)'/g)].map((match) => match[1]);
+function sectionProps(source) {
+  const lines = source.split("\n");
+  if (lines.includes(UNTYPED_ENTRY)) return { ok: true, value: { kind: "entry", ids: [], untyped: true } };
+  if (lines.includes(UNTYPED_LIST)) return { ok: true, value: { kind: "list", ids: [], untyped: true } };
+  const entry = TYPED_ENTRY.exec(source);
+  if (entry && entry[1] === entry[2]) return { ok: true, value: { kind: "entry", ids: parseIds(entry[1]), untyped: false } };
+  const list = TYPED_LIST.exec(source);
+  if (list) return { ok: true, value: { kind: "list", ids: parseIds(list[1]), untyped: false } };
+  return { ok: false, reason: "its defineProps is not the one vitakit writes" };
+}
+function typeSectionProps(source, ids) {
+  const found = sectionProps(source);
+  if (!found.ok) return found;
+  const { kind, ids: current, untyped } = found.value;
+  const wanted = [.../* @__PURE__ */ new Set([...current, ...ids])];
+  if (!untyped && wanted.length === current.length) return { ok: true, value: { source, changed: false, from: found.value } };
+  const line = kind === "entry" ? entryComponentProps(wanted) : listComponentProps(wanted);
+  let result = untyped ? source.replace(kind === "entry" ? UNTYPED_ENTRY : UNTYPED_LIST, line) : source.replace(kind === "entry" ? TYPED_ENTRY : TYPED_LIST, line);
+  if (untyped) result = retypeImports(result, kind);
+  return { ok: true, value: { source: result, changed: result !== source, from: found.value } };
+}
+function retypeImports(source, kind) {
+  let result = source;
+  if (kind === "list") result = result.replace("const entries = computed<Entry[]>(() => {", "const entries = computed(() => {");
+  const stillUsed = /\bEntry\b/.test(result.replace(/import[^\n]*from '@anja\.codes\/vitakit\/shared'/g, ""));
+  return result.replace(/^(import (?:type )?\{)([^}\n]*)(\} from '@anja\.codes\/vitakit\/shared')$/m, (whole, start, names, end) => {
+    const typeOnly = start.startsWith("import type");
+    const list = names.split(",").map((name) => name.trim()).filter(Boolean);
+    const entry = list.findIndex((name) => name.replace(/^type /, "") === "Entry");
+    const wanted = kind === "entry" ? typeOnly ? "SectionEntries" : "type SectionEntries" : void 0;
+    if (entry !== -1 && !stillUsed) list.splice(entry, 1);
+    if (wanted && !list.some((name) => name.replace(/^type /, "") === "SectionEntries")) {
+      const at = list.findIndex((name) => name.replace(/^type /, "").localeCompare("SectionEntries") > 0);
+      list.splice(at === -1 ? list.length : at, 0, wanted);
+    }
+    if (!list.length) return "";
+    return `${start} ${list.join(", ")} ${end}`;
+  });
+}
+
+export { sectionProps, typeSectionProps };

package/dist/chunks/snippets.mjs

@@ -6,10 +6,10 @@ function fieldLabel(name) {
   return words.charAt(0).toUpperCase() + words.slice(1);
 }
 const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
-const access = (object, name) => IDENTIFIER.test(name) ? `${object}.${name}` : `${object}['${name}']`;
+const access = (object, path) => path.split(".").reduce((result, name) => IDENTIFIER.test(name) ? `${result}.${name}` : `${result}['${name}']`, object);
 function webFieldSnippet(field, className = "vita-entry__note", entry = "entry") {
   const value = access(entry, field.path);
-  const label = fieldLabel(field.path);
+  const label = fieldLabel(field.path.split(".").pop());
   const line = (condition, content) => `<p v-if="${condition}" class="${className}">${content}</p>`;
   if (field.type === "link") {
     return {
@@ -37,8 +37,15 @@ function webFieldSnippet(field, className = "vita-entry__note", entry = "entry")
         return { markup: line(`typeof ${value} === 'string'`, `<a :href="${value}">${label}</a>`), imports: [] };
     }
   }
+  if (field.type === "group" && !field.several && field.fields?.length) {
+    const parts = field.fields.map((part) => webFieldSnippet(part, className, entry));
+    return {
+      markup: [`<template v-if="${value}">`, ...parts.map((part) => `  ${part.markup}`), "</template>"].join("\n"),
+      imports: parts.flatMap((part) => part.imports)
+    };
+  }
   return {
-    markup: `<!-- ${field.path}: ${field.type === "group" ? "a group of fields" : "a value of its own kind"}; show its parts, e.g. ${field.fields?.[0] ? `{{ ${value}.${field.fields[0].path.split(".").pop()} }}` : `{{ ${value} }}`} -->`,
+    markup: `<!-- ${field.path}: ${field.type === "group" ? "a list of groups of fields" : "a value of its own kind"}; its type is in schemas/, e.g. {{ ${value} }} -->`,
     imports: []
   };
 }
@@ -74,9 +81,19 @@ function sharedImport(imports) {
   return names.every((name) => name.startsWith("type ")) ? [`import type { ${names.map((name) => name.slice(5)).join(", ")} } from '@anja.codes/vitakit/shared'`] : [`import { ${names.join(", ")} } from '@anja.codes/vitakit/shared'`];
 }
 const indent = (lines, by) => lines.map((line) => line ? by + line : line);
+function sectionIdType(ids) {
+  return [...new Set(ids)].map((id) => `'${id}'`).join(" | ");
+}
+function entryComponentProps(ids) {
+  const type = sectionIdType(ids);
+  return `const props = defineProps<{ id: ${type}, entries?: SectionEntries<${type}>, title?: string, where?: Where, limit?: number }>()`;
+}
+function listComponentProps(ids) {
+  return `const props = defineProps<{ id: ${sectionIdType(ids)}, title?: string, where?: Where, limit?: number }>()`;
+}
 function entryComponent(id, name, fields, region) {
   const snippets = fields.map((field) => webFieldSnippet(field, region === "note" ? "vita-entry__note" : "vita-entry__meta"));
-  const imports = sharedImport(["type Entry", "type Where", ...snippets.flatMap((snippet) => snippet.imports)]);
+  const imports = sharedImport(["type SectionEntries", "type Where", ...snippets.flatMap((snippet) => snippet.imports)]);
   const keep = region === "note" ? ['<p v-if="display.note !== undefined" class="vita-entry__note">{{ display.note }}</p>'] : [
     '<p v-if="display.meta.length" class="vita-entry__meta">',
     '  <template v-for="(part, index) in display.meta" :key="index">',
@@ -89,7 +106,7 @@ function entryComponent(id, name, fields, region) {
     "  </template>",
     "</p>"
   ];
-  const body = fields.length ? [...keep, ...snippets.map((snippet) => snippet.markup)] : [...keep, `<!-- Add your own lines here, e.g. -->`, `<!-- <p v-if="typeof entry.audience === 'string'" class="vita-entry__${region}">Audience: {{ entry.audience }}</p> -->`];
+  const body = fields.length ? [...keep, ...snippets.flatMap((snippet) => snippet.markup.split("\n"))] : [...keep, `<!-- Add your own lines here, e.g. -->`, `<!-- <p v-if="typeof entry.audience === 'string'" class="vita-entry__${region}">Audience: {{ entry.audience }}</p> -->`];
   return [
     '<script setup lang="ts">',
     "/**",
@@ -100,11 +117,12 @@ function entryComponent(id, name, fields, region) {
     ` * The #${region} slot below replaces that region of each entry. Delete it to get`,
     " * vitakit's version back; the other slots are #title, #meta, #note and the",
     " * default slot (the whole entry). `entry` has every field of the entry,",
-    " * `display` what vitakit would show.",
+    ` * typed by its schema; \`display\` what vitakit would show. \`entries\` takes`,
+    ` * ${id} entries a page selected itself, e.g. filtered in its script.`,
     " */",
     ...imports,
     "",
-    "const props = defineProps<{ id?: string, entries?: Entry[], title?: string, where?: Where, limit?: number }>()",
+    entryComponentProps([id]),
     "<\/script>",
     "",
     "<template>",
@@ -124,8 +142,8 @@ function listComponent(id, name, fields, groupBy) {
   const titleLine = titleField ? titleField.type === "formatted-text" ? `<p class="vita-entry__title" v-html="richHtml(${access("entry", titleField.path)})" />` : `<p class="vita-entry__title">{{ ${access("entry", titleField.path)} }}</p>` : '<!-- <p class="vita-entry__title">{{ entry.title }}</p> -->';
   const imports = sharedImport([
     "filterWhere",
-    "type Entry",
     "type Where",
+    ...groupBy ? ["type SectionEntries"] : [],
     ...fields.some((field) => field.path === "date") ? ["type DateRange"] : [],
     ...titleField?.type === "formatted-text" ? ["richHtml"] : [],
     ...snippets.flatMap((snippet) => snippet.imports)
@@ -133,7 +151,7 @@ function listComponent(id, name, fields, groupBy) {
   const hasDate = fields.some((field) => field.path === "date");
   const row = [
     `<VitaEntry v-for="entry in ${groupBy ? "group.entries" : "entries"}" :key="entry.id"${hasDate ? ' :date="entry.date as DateRange"' : ""}>`,
-    ...indent([titleLine, ...snippets.map((snippet) => snippet.markup)], "  "),
+    ...indent([titleLine, ...snippets.flatMap((snippet) => snippet.markup.split("\n"))], "  "),
     "</VitaEntry>"
   ];
   const grouping = groupBy ? [
@@ -141,7 +159,7 @@ function listComponent(id, name, fields, groupBy) {
     `// Entries in a row with the same ${groupBy} form a group, in the order`,
     "// vitakit sorted them (newest first).",
     "const groups = computed(() => {",
-    "  const result: { label: string, entries: Entry[] }[] = []",
+    "  const result: { label: string, entries: SectionEntries<typeof props.id> }[] = []",
     "  for (const entry of entries.value) {",
     `    const label = String(${access("entry", groupBy)} ?? '')`,
     "    const last = result[result.length - 1]",
@@ -175,9 +193,9 @@ function listComponent(id, name, fields, groupBy) {
     `import { computed } from 'vue'`,
     ...imports,
     "",
-    "const props = defineProps<{ id: string, title?: string, where?: Where, limit?: number }>()",
+    listComponentProps([id]),
     "",
-    "const entries = computed<Entry[]>(() => {",
+    "const entries = computed(() => {",
     "  const selected = filterWhere(useSection(props.id), props.where)",
     "  return props.limit ? selected.slice(0, props.limit) : selected",
     "})",
@@ -196,4 +214,4 @@ function listComponent(id, name, fields, groupBy) {
   ].join("\n");
 }
 
-export { entryComponent, etaFieldSnippet, fieldLabel, listComponent, webFieldSnippet };
+export { entryComponent, entryComponentProps, etaFieldSnippet, fieldLabel, listComponent, listComponentProps, sectionIdType, webFieldSnippet };

package/dist/chunks/validate.mjs

@@ -32,7 +32,7 @@ import '../shared/vitakit.DvABWuUc.mjs';
 import '../shared/vitakit.TSMTC5Jl.mjs';
 import './fields.mjs';
 import './documents.mjs';
-import '../shared/vitakit.DvvUYUTS.mjs';
+import './placements.mjs';
 import '../shared/vitakit.D-DdJaDZ.mjs';
 import 'eta';
 import '../shared/vitakit.DcQOdM4I.mjs';

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-export { a as aligned, c as commands, d as detectPackageManager, m as main } from './shared/vitakit.zwr1ssO5.mjs';
+export { a as aligned, c as commands, d as detectPackageManager, m as main } from './shared/vitakit.CvYy_Quj.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.BfR_mUHm.mjs';
+import { D as DateRange, V as Visibility, a as VitakitContent } from './shared/vitakit.CB8b91Lh.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 PublicationList, j as RichText } from './shared/vitakit.BfR_mUHm.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.CB8b91Lh.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';
@@ -675,11 +675,7 @@ type BuiltinSection = keyof typeof schemas;
  * export default extendSection(schemas.teaching, { evaluationScore: z.number().optional() })
  * ```
  */
-declare function extendSection<Shape extends z.ZodRawShape>(base: z.ZodArray<z.ZodObject<z.ZodRawShape>>, shape: Shape): z.ZodArray<z.ZodObject<((string | number) & keyof Shape extends never ? Readonly<{
-    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-}> & { -readonly [P in keyof Shape]: Shape[P]; } : (Readonly<{
-    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-}> extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof Shape ? never : K]: T_1[K]; } : never) & { [K_1 in keyof { -readonly [P in keyof Shape]: Shape[P]; }]: { -readonly [P in keyof Shape]: Shape[P]; }[K_1]; }) extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>>;
+declare function extendSection<Base extends z.ZodObject, Shape extends z.ZodRawShape>(base: z.ZodArray<Base>, shape: Shape): z.ZodArray<z.ZodObject<z.util.Extend<Base['shape'], Shape>, Base['_zod']['config']>>;
 
 interface LoadContentOptions {
     /** Throw on the first problem (builds) or collect them (dev). */

package/dist/nuxt.mjs

@@ -1,14 +1,16 @@
 import { defineNuxtModule, createResolver, addTemplate, addTypeTemplate, addImportsDir, addComponentsDir, addPrerenderRoutes, updateTemplates } from '@nuxt/kit';
 import { createRequire } from 'node:module';
 import { l as loadContent } from './shared/vitakit.DteA9vLy.mjs';
+import { existsSync } from 'node:fs';
+import { join, relative, sep, isAbsolute, resolve } from 'node:path';
+import { schemas } from './chunks/schemas.mjs';
+import { findSectionFiles } from './chunks/sections.mjs';
 import { f as fail } from './shared/vitakit.DCK90zq4.mjs';
-import { b as findWebPlacements, p as publicationPlacementProblems } from './shared/vitakit.DvvUYUTS.mjs';
+import { findWebPlacements, publicationPlacementProblems } from './chunks/placements.mjs';
 import { readdir } from 'node:fs/promises';
-import { isAbsolute, resolve, relative } from 'node:path';
 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';
@@ -26,11 +28,35 @@ import 'unist-util-visit';
 import 'zod';
 import './chunks/publication-lists.mjs';
 import './shared/vitakit.D10HyDhF.mjs';
-import './chunks/sections.mjs';
-import './chunks/schemas.mjs';
 import './shared/vitakit.DvABWuUc.mjs';
 import './shared/vitakit.TSMTC5Jl.mjs';
 
+async function sectionTypeSources(rootDir) {
+  const { files } = await findSectionFiles(rootDir).catch(() => ({ files: [] }));
+  return files.map(({ id }) => {
+    const file = join(rootDir, "schemas", `${id}.ts`);
+    return { id, ...existsSync(file) ? { file } : {}, builtIn: Object.hasOwn(schemas, id) };
+  }).filter((source) => source.file !== void 0 || source.builtIn);
+}
+function sectionTypesDeclaration(sources, buildDir) {
+  const dir = join(buildDir, "vitakit");
+  const lines = sources.map(({ id, file }) => {
+    const schema = file !== void 0 ? `typeof import('${relative(dir, file).split(sep).join("/").replace(/\.ts$/, "")}').default` : `typeof import('@anja.codes/vitakit').schemas[${JSON.stringify(id)}]`;
+    return `    ${JSON.stringify(id)}: SectionEntry<${schema}>`;
+  });
+  return [
+    "// Generated by vitakit from content/*.yml and schemas/; do not edit.",
+    `import type { SectionEntry } from '@anja.codes/vitakit/shared'`,
+    `declare module '@anja.codes/vitakit/shared' {`,
+    `  interface VitakitSections {`,
+    ...lines,
+    `  }`,
+    `}`,
+    `export {}`,
+    ""
+  ].join("\n");
+}
+
 function isWithin(directory, path) {
   const child = relative(directory, path);
   return child === "" || !isAbsolute(child) && child.split(/[/\\]/)[0] !== "..";
@@ -60,6 +86,7 @@ function katexStylesheet() {
 }
 const TEMPLATE = "vitakit/content.mjs";
 const TYPES = "vitakit/content.d.ts";
+const SECTION_TYPES = "vitakit/sections.d.ts";
 function report(content) {
   if (!content.issues.length) return;
   const lines = content.issues.map((issue) => `  ${issue.where}: ${issue.message.replace(/\n/g, "\n  ")}`);
@@ -109,6 +136,11 @@ const module$1 = defineNuxtModule({
         ""
       ].join("\n")
     });
+    let sections = await sectionTypeSources(rootDir);
+    addTypeTemplate({
+      filename: SECTION_TYPES,
+      getContents: () => sectionTypesDeclaration(sections, nuxt.options.buildDir)
+    });
     if (options.katexCss !== false) nuxt.options.css.push(katexStylesheet());
     nuxt.options.build.transpile.push(resolver.resolve("./runtime"));
     addImportsDir(resolver.resolve("./runtime/composables"));
@@ -117,8 +149,15 @@ const module$1 = defineNuxtModule({
     if (!nuxt.options.dev) return;
     await watchComponentOverrides(nuxt, resolver.resolve("./runtime/components"));
     nuxt.options.watch.push("../content", "../schemas");
-    nuxt.hook("builder:watch", async (_event, path) => {
+    nuxt.hook("builder:watch", async (event, path) => {
       if (!/[/\\](content|schemas)[/\\]/.test(path)) return;
+      if (event === "add" || event === "unlink") {
+        const found = await sectionTypeSources(rootDir);
+        if (JSON.stringify(found) !== JSON.stringify(sections)) {
+          sections = found;
+          await updateTemplates({ filter: (item) => item.filename === SECTION_TYPES });
+        }
+      }
       try {
         content = await load(false);
       } catch (error) {

package/dist/runtime/components/VitaSection.vue

@@ -1,4 +1,4 @@
-<script setup lang="ts">
+<script setup lang="ts" generic="Id extends string = string">
 /**
  * A generic section with conventional field selection and optional overrides.
  *
@@ -18,14 +18,15 @@ import {
   richHtml,
   type DateRange,
   type Entry,
+  type SectionEntries,
   type VitaSectionSlotProps,
   type Where,
 } from '@anja.codes/vitakit/shared'
 
 const props = defineProps<{
   /** Section id; ignored when `entries` is given. */
-  id?: string
-  entries?: Entry[]
+  id?: Id
+  entries?: SectionEntries<Id>
   /** Fields to try, in order, for the main line. */
   titleFields?: string[]
   /** Only entries whose fields have these values, as `where` in a PDF document. */
@@ -35,23 +36,24 @@ const props = defineProps<{
   title?: string
 }>()
 
+type Row = VitaSectionSlotProps<SectionEntries<Id>[number]>
 const slots = defineSlots<{
-  title?(props: VitaSectionSlotProps): VNodeChild
-  meta?(props: VitaSectionSlotProps): VNodeChild
-  note?(props: VitaSectionSlotProps): VNodeChild
-  default?(props: VitaSectionSlotProps): VNodeChild
+  title?(props: Row): VNodeChild
+  meta?(props: Row): VNodeChild
+  note?(props: Row): VNodeChild
+  default?(props: Row): VNodeChild
 }>()
 
 const rows = computed(() => {
-  const source = filterWhere(props.entries ?? (props.id ? useSection(props.id) : []), props.where)
+  const source = filterWhere((props.entries ?? (props.id ? useSection(props.id) : [])) as Entry[], props.where)
   const items = props.limit ? source.slice(0, props.limit) : source
-  return items.map((entry, index): VitaSectionSlotProps => {
+  return items.map((entry, index): Row => {
     // Field selection remains shared with the emitter; only the web-specific
     // presentation (such as a term replacing the date) is decided here.
     const titleField = entryTitleField(entry, props.titleFields)
     const term = typeof entry.term === 'string' && entry.term.length > 0 ? entry.term : undefined
     return {
-      entry,
+      entry: entry as Row['entry'],
       index,
       display: {
         titleHtml: (titleField && richHtml(entry[titleField])) || '',
@@ -74,7 +76,7 @@ const rows = computed(() => {
     <h2 class="vita-section-group__title">
       {{ title }}
     </h2>
-    <VitaSection :entries="rows.map(row => row.entry)" :title-fields="titleFields">
+    <VitaSection :entries="rows.map(row => row.entry as Entry)" :title-fields="titleFields">
       <template v-for="(_, name) in slots" #[name]="scope">
         <slot :name="name" v-bind="scope" />
       </template>

package/dist/runtime/composables/useVitakit.ts

@@ -6,7 +6,7 @@
  * chunk.
  */
 import content from '#vitakit/content'
-import type { Entry, Page, Profile, PublicationList, VitakitContent } from '@anja.codes/vitakit/shared'
+import type { Page, Profile, PublicationList, SectionEntries, VitakitContent } from '@anja.codes/vitakit/shared'
 
 export function useVitakit(): VitakitContent {
   return content
@@ -23,8 +23,8 @@ export function useProfile(): Profile {
  * Unknown ids return an empty list rather than throwing, so deleting a content
  * file cannot break a page that still mentions it.
  */
-export function useSection(id: string): Entry[] {
-  return content.sections[id] ?? []
+export function useSection<Id extends string>(id: Id): SectionEntries<Id> {
+  return (content.sections[id] ?? []) as SectionEntries<Id>
 }
 
 /** All section ids that have content. */

package/dist/shared/index.d.mts

@@ -1,5 +1,5 @@
-import { D as DateRange, d as Linked, L as Link, E as Entry } from './vitakit.BfR_mUHm.mjs';
-export { C as ContentIssue, b as DatePoint, c as EntryBase, P as Page, e as Profile, f as Publication, g as PublicationBadge, h as PublicationGroup, i as PublicationList, j as RichText, R as RichTextMarker, V as Visibility, a as VitakitContent } from './vitakit.BfR_mUHm.mjs';
+import { D as DateRange, d as Linked, L as Link, E as Entry } from './vitakit.CB8b91Lh.mjs';
+export { C as ContentIssue, b as DatePoint, c as EntryBase, P as Page, e as Profile, f as Publication, g as PublicationBadge, h as PublicationGroup, i as PublicationList, k as Rendered, j as RichText, R as RichTextMarker, S as SectionEntries, l as SectionEntry, V as Visibility, a as VitakitContent, m as VitakitSections } from './vitakit.CB8b91Lh.mjs';
 
 /**
  * Presentation helpers shared by the website and the LaTeX side.
@@ -69,8 +69,8 @@ interface VitaSectionDisplay {
     ongoing: boolean;
 }
 /** Shared context for VitaSection's title, meta, note and default (body) slots. */
-interface VitaSectionSlotProps {
-    entry: Entry;
+interface VitaSectionSlotProps<E = Entry> {
+    entry: E;
     /** Zero-based position in the displayed list, after limiting. */
     index: number;
     display: VitaSectionDisplay;

package/dist/shared/{vitakit.BfR_mUHm.d.mts → vitakit.CB8b91Lh.d.mts}

@@ -151,6 +151,15 @@ interface ContentIssue {
     where: string;
     message: string;
 }
+/**
+ * Section id -> its entries' type. Empty here; a project's
+ * `.nuxt/vitakit/sections.d.ts` adds one key per `content/<id>.yml`, from its
+ * schema, so that `useSection('talks')` is typed by `schemas/talks.ts`.
+ */
+interface VitakitSections {
+}
+/** The entries of a section: typed by its schema when the section is known. */
+type SectionEntries<Id extends string> = Id extends keyof VitakitSections ? VitakitSections[Id][] : Entry[];
 /** Everything compiled from `content/`, as the app sees it. */
 interface VitakitContent {
     profile: Profile;
@@ -162,5 +171,32 @@ interface VitakitContent {
     /** Always empty in a production build, which fails instead. */
     issues: ContentIssue[];
 }
+/**
+ * A path on the site before it is resolved: `{ __vitakitPath }`. Internal, like
+ * `RichTextMarker`; components receive a string.
+ */
+interface SitePathMarkerShape {
+    __vitakitPath: string;
+}
+/**
+ * A value as a component receives it: rendered text instead of its marker,
+ * resolved paths instead of theirs, at any depth.
+ */
+type Rendered<T> = T extends RichTextMarker ? RichText : T extends SitePathMarkerShape ? string : T extends DateRange ? DateRange : T extends readonly (infer Item)[] ? Rendered<Item>[] : T extends object ? {
+    [Key in keyof T]: Rendered<T[Key]>;
+} : T;
+/**
+ * One entry of a section, as `useSection` and the slots of `VitaSection` see
+ * it, from the section's schema: `SectionEntry<typeof schema>`.
+ */
+type SectionEntry<Schema extends {
+    _zod: {
+        output: readonly unknown[];
+    };
+}> = Flat<Rendered<Schema['_zod']['output'][number]> & EntryBase>;
+/** One object type instead of an intersection: readable on hover, and assignable to `Entry`. */
+type Flat<T> = {
+    [Key in keyof T]: T[Key];
+};
 
-export type { ContentIssue as C, DateRange as D, Entry as E, Link as L, Page as P, RichTextMarker as R, Visibility as V, VitakitContent as a, DatePoint as b, EntryBase as c, Linked as d, Profile as e, Publication as f, PublicationBadge as g, PublicationGroup as h, PublicationList as i, RichText as j };
+export type { ContentIssue as C, DateRange as D, Entry as E, Link as L, Page as P, RichTextMarker as R, SectionEntries as S, Visibility as V, VitakitContent as a, DatePoint as b, EntryBase as c, Linked as d, Profile as e, Publication as f, PublicationBadge as g, PublicationGroup as h, PublicationList as i, RichText as j, Rendered as k, SectionEntry as l, VitakitSections as m };

package/dist/shared/{vitakit.zwr1ssO5.mjs → vitakit.CvYy_Quj.mjs}

@@ -781,6 +781,11 @@ async function planWeb(context, ws, inv, section, fields, list, values, notes) {
     if (!inv.web.components.has(component)) {
       throw new CommandError(`--use ${component}: no app/components/${component}.vue; the components are ${[...inv.web.components.keys()].join(", ") || "(none)"}`);
     }
+    const { typeSectionProps } = await import('../chunks/props.mjs');
+    const file = inv.web.components.get(component);
+    const typed = typeSectionProps(await ws.read(file), [id]);
+    if (!typed.ok) notes.after.push(`By hand: ${file} ${typed.reason}; for ${id}'s entries to be typed in it, its id should accept '${id}' too, e.g. id: 'talks' | '${id}'.`);
+    else if (typed.value.changed) await ws.edit(file, typed.value.source, `shows ${id} too: its id accepts '${id}'`);
   } else {
     const fallback = `${pascal(id)}${list ? "List" : "Section"}`;
     component = values.component ?? (interactive ? await prompt.input(io, "Name of the component", fallback) : fallback);
@@ -1192,9 +1197,9 @@ async function fieldSnippets(context, inv, section, names) {
       '      <template #note="{ entry, display }">',
       '        <p v-if="display.note !== undefined" class="vita-entry__note">{{ display.note }}</p>'
     );
-    lines.push(...web.map((snippet) => `        ${snippet.markup}`), "      </template>", "    </VitaSection>");
+    lines.push(...web.flatMap((snippet) => snippet.markup.split("\n")).map((line) => `        ${line}`), "      </template>", "    </VitaSection>");
   }
-  if (components.length) lines.push("", ...indented(web.map((snippet) => snippet.markup)));
+  if (components.length) lines.push("", ...indented(web.flatMap((snippet) => snippet.markup.split("\n"))));
   if (imports.length) lines.push("", `    import { ${imports.join(", ")} } from '@anja.codes/vitakit/shared'`);
   lines.push("");
   if (existsSync2(join2(root, "cv-tex", "templates", `${id}.eta`))) {
@@ -1492,10 +1497,11 @@ nothing that is up to date.
 Then check the project: \`${run.bin("vitakit", "validate")}\``,
   async run(context, { values }) {
     const { Workspace } = await import('../chunks/plan.mjs');
-    const { migratePublicationLists } = await import('../chunks/migrations.mjs');
+    const { migratePublicationLists, migrateSectionComponents } = await import('../chunks/migrations.mjs');
     const ws = new Workspace(context.root);
     const notes = { before: [], after: [] };
     await migratePublicationLists(context.root, ws, notes);
+    await migrateSectionComponents(context.root, ws, notes);
     notes.after.push(`Check the project: \`${context.run.bin("vitakit", "validate")}\``);
     return finish(context, ws, values, notes);
   }

package/dist/tex/vitakit-cv.cls

@@ -27,6 +27,7 @@
 \RequirePackage{xcolor}
 \RequirePackage{titlesec}
 \RequirePackage{amsmath,amssymb}
+\RequirePackage{graphicx}
 \RequirePackage{hyperref}
 
 %% --- bibliography ---------------------------------------------------------
@@ -76,13 +77,38 @@
 \newcommand{\vitaname}[1]{\def\vita@name{#1}}
 \newcommand{\vitatagline}[1]{\def\vita@tagline{#1}}
 \newcommand{\vitacontact}[1]{\def\vita@contact{#1}}
-\vitaname{} \vitatagline{} \vitacontact{}
+%% `portrait` in the document's .yml: the image, relative to cv-tex/.
+\newcommand{\vitaportrait}[1]{\def\vita@portrait{#1}}
+\vitaname{} \vitatagline{} \vitacontact{} \vitaportrait{}
 
-\newcommand{\vitaheader}{%
-  \begingroup
+%% The portrait's height in \vitaheader. It is never wider than a quarter of
+%% the line. \setlength{\vitaportraitheight}{4cm} in preamble.tex changes it.
+\newlength{\vitaportraitheight}
+\setlength{\vitaportraitheight}{3cm}
+\newsavebox{\vita@portraitbox}
+
+\newcommand{\vita@headertext}{%
   \noindent{\LARGE\bfseries\vita@name}\par
   \ifx\vita@tagline\empty\else\vspace{0.2em}\noindent{\color{vitamuted}\vita@tagline}\par\fi
-  \ifx\vita@contact\empty\else\vspace{0.2em}\noindent{\small\vita@contact}\par\fi
+  \ifx\vita@contact\empty\else\vspace{0.2em}\noindent{\small\vita@contact}\par\fi}
+
+%% Name, tagline and contact line; with a portrait, those on the left and the
+%% portrait on the right, both aligned at the top.
+\newcommand{\vitaheader}{%
+  \begingroup
+  \ifx\vita@portrait\empty
+    \vita@headertext
+  \else
+    \sbox{\vita@portraitbox}{\includegraphics[height=\vitaportraitheight,
+      width=0.25\linewidth, keepaspectratio]{\vita@portrait}}%
+    \noindent
+    \begin{minipage}[t]{\dimexpr\linewidth-\wd\vita@portraitbox-1.5em\relax}
+      \vspace{0pt}\vita@headertext
+    \end{minipage}\hfill
+    \begin{minipage}[t]{\wd\vita@portraitbox}
+      \vspace{0pt}\usebox{\vita@portraitbox}
+    \end{minipage}\par
+  \fi
   \vspace{1em}\hrule\vspace{1.5em}
   \endgroup}
 

package/dist/tex.d.mts

@@ -59,6 +59,7 @@ declare const documentSchema: z.ZodObject<{
         cv: "cv";
         private: "private";
     }>>;
+    portrait: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
     sections: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         where: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>>;
         limit: z.ZodOptional<z.ZodNumber>;

package/dist/tex.mjs

@@ -33,7 +33,7 @@ import './chunks/sections.mjs';
 import './chunks/schemas.mjs';
 import './shared/vitakit.DvABWuUc.mjs';
 import './shared/vitakit.TSMTC5Jl.mjs';
-import './shared/vitakit.DvvUYUTS.mjs';
+import './chunks/placements.mjs';
 import 'eta';
 import './shared/vitakit.CfB3hMHl.mjs';
 import './shared/vitakit.D-DdJaDZ.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anja.codes/vitakit",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Structured CV data in, academic website and LaTeX CV out.",
   "license": "MIT",
   "keywords": [