explico 0.12.0 → 0.13.0

package/dist/compiler/exports/latex/capture.js

@@ -0,0 +1,435 @@
+import { Buffer } from "node:buffer";
+import { createServer } from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { extname, join, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+async function courseChromium(projectRoot) {
+  const require2 = createRequire(join(projectRoot, "package.json"));
+  for (const name of ["playwright-core", "playwright", "@playwright/test"]) {
+    let path;
+    try {
+      path = require2.resolve(name);
+    } catch {
+      continue;
+    }
+    try {
+      const module = require2(path);
+      const chromium = module.chromium ?? module.default?.chromium;
+      if (chromium) return chromium;
+    } catch {
+      const module = await import(
+        /* @vite-ignore */
+        pathToFileURL(path).href
+      );
+      const chromium = module.chromium ?? module.default?.chromium;
+      if (chromium) return chromium;
+    }
+  }
+  return void 0;
+}
+const MIME_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".txt": "text/plain; charset=utf-8",
+  ".xml": "application/xml",
+  ".wasm": "application/wasm"
+};
+const CAPTURE_PATH = "__explico_capture__";
+async function existingFile(path) {
+  try {
+    const info = await stat(path);
+    if (info.isFile()) return path;
+    if (info.isDirectory()) return existingFile(join(path, "index.html"));
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+async function serve(root, base) {
+  const rootPath = resolve(root);
+  const server = createServer((request, response) => {
+    void (async () => {
+      let pathname = "/";
+      try {
+        pathname = decodeURIComponent(new URL(request.url ?? "/", "http://localhost").pathname);
+      } catch {
+        response.writeHead(400).end();
+        return;
+      }
+      if (pathname.startsWith(base)) pathname = `/${pathname.slice(base.length)}`;
+      if (pathname === `/${CAPTURE_PATH}`) {
+        response.writeHead(200, { "Content-Type": MIME_TYPES[".html"] });
+        response.end("<!doctype html><html><head></head><body></body></html>");
+        return;
+      }
+      const candidate = resolve(rootPath, `.${pathname}`);
+      if (candidate !== rootPath && !candidate.startsWith(`${rootPath}${sep}`)) {
+        response.writeHead(403).end();
+        return;
+      }
+      const file = await existingFile(candidate) ?? await existingFile(`${candidate}.html`);
+      if (!file) {
+        response.writeHead(404).end();
+        return;
+      }
+      response.writeHead(200, {
+        "Content-Type": MIME_TYPES[extname(file).toLowerCase()] ?? "application/octet-stream"
+      });
+      response.end(await readFile(file));
+    })().catch(() => {
+      if (!response.headersSent) response.writeHead(500);
+      response.end();
+    });
+  });
+  await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen(0, "127.0.0.1", () => resolveListen());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("Capture server has no port.");
+  return { origin: `http://127.0.0.1:${address.port}`, server };
+}
+async function settleFigure(page, anchor, timeoutMs) {
+  const settled = await page.evaluate(
+    async ({ anchor: id, timeout }) => {
+      const figure = document.getElementById(id);
+      if (!figure) return `no element #${id}`;
+      const body = figure.querySelector(".keyed-figure__body, .diagram__body") ?? figure;
+      body.scrollIntoView({ block: "center" });
+      const frame = () => new Promise((done) => requestAnimationFrame(() => done()));
+      const started = performance.now();
+      let previous = "";
+      let stableSince = performance.now();
+      while (performance.now() - started < timeout) {
+        await frame();
+        const pending = body.querySelector("astro-island[ssr]");
+        const current = body.innerHTML;
+        if (current !== previous) {
+          previous = current;
+          stableSince = performance.now();
+        }
+        if (!pending && performance.now() - stableSince > 400) {
+          await document.fonts.ready;
+          return "";
+        }
+        await new Promise((done) => setTimeout(done, 50));
+      }
+      return body.querySelector("astro-island[ssr]") ? `#${id} never hydrated` : `#${id} kept changing`;
+    },
+    { anchor, timeout: timeoutMs }
+  );
+  if (settled) throw new Error(`Figure capture: ${settled} within ${timeoutMs} ms.`);
+}
+async function snapshotFigure(page, anchor) {
+  return page.evaluate((id) => {
+    const figure = document.getElementById(id);
+    const body = figure.querySelector(".keyed-figure__body, .diagram__body") ?? figure;
+    const box = body.getBoundingClientRect();
+    const scrolled = [...body.querySelectorAll("*")].map((element) => element.scrollWidth);
+    const clone = figure.cloneNode(true);
+    clone.querySelectorAll("script").forEach((node) => node.remove());
+    const live = figure.querySelector(".float-caption__state");
+    return {
+      html: clone.outerHTML,
+      width: Math.ceil(Math.max(box.width, body.scrollWidth, ...scrolled)),
+      height: Math.ceil(Math.max(box.height, body.scrollHeight)),
+      links: [...document.styleSheets].flatMap((sheet) => sheet.href ? [sheet.href] : []),
+      styles: [...document.querySelectorAll("style")].map((node) => node.textContent ?? "").join("\n"),
+      live: live?.innerHTML ?? ""
+    };
+  }, anchor);
+}
+const LABEL_FONT = "KaTeX_Main, KaTeX_Math, serif";
+const LABEL_PT = 9;
+const PT_PER_PX = 0.75;
+const CAPTURE_STYLE = `
+@page { margin: 0 }
+html, body { margin: 0 !important; padding: 0 !important; background: #fff !important; }
+main, .sl-markdown-content { margin: 0 !important; padding: 0 !important; max-width: none !important; }
+figure { margin: 0 !important; padding: 0 !important; border: 0 !important; box-shadow: none !important; }
+figure > :not(.keyed-figure__body, .diagram__body) { display: none !important; }
+:is(.keyed-figure__body, .diagram__body) { font-family: ${LABEL_FONT}; }
+:is(.keyed-figure__body, .diagram__body) :is(svg text, svg tspan) { font-family: ${LABEL_FONT} !important; }
+:is(.keyed-figure__body, .diagram__body), :is(.keyed-figure__body, .diagram__body) :is(svg, .diagram-scroll) { overflow: visible !important; }
+`;
+function printedPtPerPx(box, measure) {
+  const fit = Math.min(1, measure.width / (box.width * PT_PER_PX), measure.maxHeight / (box.height * PT_PER_PX));
+  return PT_PER_PX * fit;
+}
+async function sizeLabels(page, box, measure) {
+  return page.evaluate(
+    async ({ labelPt, ptPerPx, width, height }) => {
+      const body = document.querySelector(".keyed-figure__body, .diagram__body");
+      if (!body) return { width, height };
+      const scaleOf = (element) => {
+        const matrix = element.getScreenCTM();
+        return matrix ? Math.hypot(matrix.a, matrix.b) : 1;
+      };
+      const elements = [...body.querySelectorAll("svg text, svg tspan")];
+      const own = new Map(elements.map((element) => [element, Number.parseFloat(getComputedStyle(element).fontSize)]));
+      const weights = /* @__PURE__ */ new Map();
+      for (const element of elements) {
+        const characters = [...element.childNodes].filter((node) => node.nodeType === Node.TEXT_NODE).reduce((count, node) => count + (node.textContent ?? "").trim().length, 0);
+        const printed = Math.round((own.get(element) ?? 0) * scaleOf(element) * ptPerPx * 10) / 10;
+        if (characters > 0 && printed > 0) weights.set(printed, (weights.get(printed) ?? 0) + characters);
+      }
+      const common = [...weights].sort((a, b) => b[1] - a[1] || b[0] - a[0])[0]?.[0];
+      if (!common) return { width, height };
+      const texts = [...body.querySelectorAll("svg text")];
+      const ink = (text) => {
+        const rect = text.getBoundingClientRect();
+        const size = Number.parseFloat(getComputedStyle(text).fontSize) * scaleOf(text);
+        const matrix = text.getScreenCTM();
+        if (!matrix || text.getNumberOfChars() === 0 || rect.height > 1.6 * size) {
+          return { left: rect.left, right: rect.right, top: rect.top, bottom: rect.bottom };
+        }
+        const start = text.getStartPositionOfChar(0);
+        const baseline = matrix.b * start.x + matrix.d * start.y + matrix.f;
+        return { left: rect.left, right: rect.right, top: baseline - 0.72 * size, bottom: baseline + 0.22 * size };
+      };
+      const touching = (a, b) => a.left < b.right - 0.5 && b.left < a.right - 0.5 && a.top < b.bottom - 0.5 && b.top < a.bottom - 0.5;
+      const contacts = () => {
+        const boxes = texts.map(ink);
+        const found = /* @__PURE__ */ new Set();
+        boxes.forEach((a, i) => boxes.slice(i + 1).forEach((b, j) => touching(a, b) && found.add(`${i}:${i + 1 + j}`)));
+        return found;
+      };
+      const before = contacts();
+      const transforms = new Map(texts.map((text) => [text, text.getAttribute("transform")]));
+      const titles = ["x", "y", "fx", "fy"].flatMap((axis) => {
+        const ticks = [...body.querySelectorAll(`g[aria-label="${axis}-axis tick label"] text`)];
+        return [...body.querySelectorAll(`g[aria-label="${axis}-axis label"] text`)].flatMap((title) => {
+          const box2 = ink(title);
+          const near = ticks.filter((tick) => {
+            const other = ink(tick);
+            return other.left < box2.right && box2.left < other.right;
+          });
+          if (near.length === 0) return [];
+          const boxes = near.map(ink);
+          const below = (box2.top + box2.bottom) / 2 > Math.max(...boxes.map((other) => (other.top + other.bottom) / 2));
+          const gap = below ? box2.top - Math.max(...boxes.map((other) => other.bottom)) : Math.min(...boxes.map((other) => other.top)) - box2.bottom;
+          return [{ title, near, below, gap: Math.max(1, gap) }];
+        });
+      });
+      const apply = (ratio2) => {
+        for (const element of elements) {
+          element.style.setProperty("font-size", `${(own.get(element) ?? 0) * ratio2}px`, "important");
+        }
+        for (const [text, transform] of transforms) {
+          if (transform === null) text.removeAttribute("transform");
+          else text.setAttribute("transform", transform);
+        }
+        for (const { title, near, below, gap } of titles) {
+          const box2 = ink(title);
+          const boxes = near.map(ink);
+          const shift = below ? Math.max(0, Math.max(...boxes.map((other) => other.bottom)) + gap - box2.top) : Math.min(0, Math.min(...boxes.map((other) => other.top)) - gap - box2.bottom);
+          if (shift === 0) continue;
+          const transform = transforms.get(title);
+          title.setAttribute("transform", `${transform ?? ""} translate(0 ${shift / scaleOf(title)})`.trim());
+        }
+      };
+      const collides = () => [...contacts()].some((pair) => !before.has(pair));
+      const goal = Math.min(2.5, Math.max(0.4, labelPt / common));
+      let ratio = goal;
+      apply(ratio);
+      if (goal > 1 && collides()) {
+        let [fits, fails] = [1, goal];
+        for (let step = 0; step < 8; step++) {
+          const middle = (fits + fails) / 2;
+          apply(middle);
+          if (collides()) fails = middle;
+          else fits = middle;
+        }
+        ratio = fits;
+        apply(ratio);
+      }
+      await document.fonts.ready;
+      for (const svg of body.querySelectorAll("svg")) {
+        for (let node = svg.parentElement; node && node !== body; node = node.parentElement) {
+          node.style.setProperty("overflow", "visible", "important");
+        }
+      }
+      const frame = body.getBoundingClientRect();
+      let [left, top, right, bottom] = [frame.left, frame.top, frame.left + width, frame.top + height];
+      for (const element of elements) {
+        const rect = element.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) continue;
+        [left, top] = [Math.min(left, rect.left), Math.min(top, rect.top)];
+        [right, bottom] = [Math.max(right, rect.right), Math.max(bottom, rect.bottom)];
+      }
+      const [shiftX, shiftY] = [Math.ceil(frame.left - left), Math.ceil(frame.top - top)];
+      if (shiftX > 0 || shiftY > 0) {
+        document.body.style.setProperty("padding", `${shiftY}px 0 0 ${shiftX}px`, "important");
+      }
+      return {
+        width: Math.ceil(right - left),
+        height: Math.ceil(bottom - top),
+        labelPt: Math.round(common * ratio * 10) / 10
+      };
+    },
+    { labelPt: LABEL_PT, ptPerPx: printedPtPerPx(box, measure), width: box.width, height: box.height }
+  );
+}
+async function machineFonts(context, page) {
+  if (!context.newCDPSession) return [];
+  await page.evaluate(() => {
+    for (const element of document.querySelectorAll(
+      ":is(.keyed-figure__body, .diagram__body), :is(.keyed-figure__body, .diagram__body) *"
+    )) {
+      if (element.closest(".katex-mathml")) continue;
+      const text = [...element.childNodes].some(
+        (node) => node.nodeType === Node.TEXT_NODE && (node.textContent ?? "").trim() !== ""
+      );
+      if (text) element.setAttribute("data-explico-capture-text", "");
+    }
+  });
+  const session = await context.newCDPSession(page);
+  try {
+    await session.send("DOM.enable");
+    await session.send("CSS.enable");
+    const { root } = await session.send("DOM.getDocument", { depth: 0 });
+    const { nodeIds } = await session.send("DOM.querySelectorAll", {
+      nodeId: root.nodeId,
+      selector: "[data-explico-capture-text]"
+    });
+    const found = /* @__PURE__ */ new Map();
+    for (const nodeId of nodeIds) {
+      const { fonts } = await session.send("CSS.getPlatformFontsForNode", { nodeId });
+      for (const font of fonts) {
+        if (font.isCustomFont || found.has(font.familyName)) continue;
+        const { outerHTML } = await session.send("DOM.getOuterHTML", { nodeId });
+        const sample = outerHTML.replace(/<[^>]*>/gu, " ").replace(/\s+/gu, " ").trim().slice(0, 40);
+        found.set(font.familyName, sample);
+      }
+    }
+    return [...found].sort(([a], [b]) => a.localeCompare(b)).map(([family, sample]) => `${family} ("${sample}")`);
+  } finally {
+    await session.detach();
+  }
+}
+async function printFigure(context, origin, snapshot, measure, withPng) {
+  const page = await context.newPage();
+  try {
+    await page.goto(`${origin}/${CAPTURE_PATH}`);
+    const links = snapshot.links.map((href) => `<link rel="stylesheet" href="${href.replace(/"/gu, "&quot;")}">`).join("");
+    await page.setContent(
+      `<!doctype html><html data-theme="light"><head><meta charset="utf-8">${links}<style>${snapshot.styles.replace(/<\/style/giu, "<\\/style")}</style><style>${CAPTURE_STYLE}</style></head><body><main><div class="sl-markdown-content" style="width:${snapshot.width}px">${snapshot.html}</div></main></body></html>`,
+      { waitUntil: "load" }
+    );
+    await page.evaluate(async () => {
+      await document.fonts.ready;
+    });
+    await page.emulateMedia({ media: "screen" });
+    const box = await sizeLabels(page, { width: snapshot.width, height: snapshot.height }, measure);
+    const fonts = await machineFonts(context, page);
+    const png = withPng ? await page.screenshot({
+      type: "png",
+      clip: { x: 0, y: 0, width: box.width, height: box.height },
+      animations: "disabled",
+      caret: "hide"
+    }) : void 0;
+    const pdf = await page.pdf({
+      width: `${box.width}px`,
+      height: `${box.height}px`,
+      printBackground: true,
+      pageRanges: "1"
+    });
+    return {
+      pdf,
+      ...png ? { png } : {},
+      machineFonts: fonts,
+      ...box.labelPt ? { labelPt: box.labelPt } : {}
+    };
+  } finally {
+    await page.close();
+  }
+}
+function figureMeasure(paper) {
+  const inch = 72;
+  const millimetre = 72 / 25.4;
+  return paper === "a4" ? { width: (210 - 50.8) * millimetre, maxHeight: 0.6 * (297 - 50.8) * millimetre } : { width: 6.5 * inch, maxHeight: 0.6 * 9 * inch };
+}
+function stampPdfDates(pdf, epoch) {
+  const date = new Date(epoch * 1e3).toISOString().replace(/\D/gu, "").slice(0, 14);
+  const text = Buffer.from(pdf).toString("latin1");
+  return Buffer.from(
+    text.replace(/(\/(?:CreationDate|ModDate)\s*\(D:)\d{14}/gu, (_match, key) => `${key}${date}`),
+    "latin1"
+  );
+}
+async function captureFigures(requests, options) {
+  const results = /* @__PURE__ */ new Map();
+  if (requests.length === 0) return results;
+  const { origin, server } = await serve(options.outputRoot, options.base);
+  const browser = await options.chromium.launch();
+  try {
+    for (const request of requests) {
+      const context = await browser.newContext({
+        viewport: { width: 1200, height: 900 },
+        // Two device pixels per CSS pixel: the PNG a Markdown export shows.
+        deviceScaleFactor: 2,
+        colorScheme: "light",
+        reducedMotion: "reduce",
+        locale: "en-US"
+      });
+      try {
+        const page = await context.newPage();
+        const path = `${options.base}${request.route ? `${request.route}/` : ""}`;
+        await page.goto(`${origin}${path}`, { waitUntil: "load" });
+        await page.evaluate(() => {
+          window.dispatchEvent(
+            new CustomEvent("explico:prepare-static-export", { detail: { mode: "markdown" } })
+          );
+        });
+        const figures = /* @__PURE__ */ new Map();
+        for (const anchor of request.anchors) {
+          await settleFigure(page, anchor, options.timeoutMs ?? 3e4);
+          const snapshot = await snapshotFigure(page, anchor);
+          const printed = await printFigure(
+            context,
+            origin,
+            snapshot,
+            options.measure ?? figureMeasure("letter"),
+            options.png ?? false
+          );
+          const pdf = options.epoch === void 0 ? printed.pdf : stampPdfDates(printed.pdf, options.epoch);
+          figures.set(anchor, { ...printed, pdf, liveHtml: snapshot.live });
+        }
+        results.set(request.route, figures);
+      } catch (error) {
+        throw new Error(
+          `Could not capture the figures of ${request.route || "the landing page"}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      } finally {
+        await context.close();
+      }
+    }
+  } finally {
+    await browser.close();
+    await new Promise((done) => server.close(() => done()));
+  }
+  return results;
+}
+export {
+  LABEL_PT,
+  captureFigures,
+  courseChromium,
+  figureMeasure,
+  stampPdfDates
+};

package/dist/compiler/exports/latex/compile.d.ts

@@ -0,0 +1,73 @@
+import { SourceFile } from './document.js';
+import '../../manifest.js';
+import '../../../curriculum/validation.js';
+import '../../../reference/consistency.js';
+import '../../../course-config-rRtME5UV.js';
+import '../../../rules/catalog.js';
+import '../../../rules/course-rules.js';
+import '../../collections.js';
+import '../../../reference/types.js';
+import '../../../reference/gate-retired-keys.js';
+import '../../../reference/lint-ignore.js';
+import '../../../reference/equations-validate.js';
+import '../../../reference/tables-validate.js';
+import '../../../reference/keyed-float-validate.js';
+import '../../../reference/figures-validate.js';
+import '../../../reference/diagrams-validate.js';
+import '../../../reference/examples-validate.js';
+import '../../../reference/folds-validate.js';
+import '../../../reference/knowledge-checks-validate.js';
+import '../../../reference/raw-floats-validate.js';
+import '../../../reference/lab-katex-validate.js';
+import '../../../reference/gate-math.js';
+import '../../../reference/mixed-content.js';
+import '../../../reference/gloss.js';
+import '../../../rules/waivers.js';
+import '../../knowledge-version.js';
+import '../../lesson-derivation.js';
+import '../static-tree.js';
+import '../html-tree.js';
+import 'parse5';
+import './serialize.js';
+
+/**
+ * Compile a LaTeX folder to PDF with `latexmk`. LuaLaTeX is the engine: it
+ * is the one the LaTeX Project recommends for new documents and the only one
+ * that writes MathML into a tagged PDF. `EXPLICO_LATEX_ENGINE=pdflatex`
+ * switches to pdfLaTeX, for a machine whose TeX Live lacks LuaLaTeX's font
+ * loader.
+ */
+interface LatexEngine {
+    readonly name: 'lualatex' | 'pdflatex';
+    readonly latexmkOption: '-lualatex' | '-pdf';
+}
+interface CompiledLatex {
+    readonly pdf: Buffer;
+    readonly aux: string;
+    readonly log: string;
+}
+/**
+ * The engine to compile with, or the reason there is none. LuaLaTeX also
+ * needs `luaotfload` (Debian ships it separately, in `texlive-luatex`).
+ */
+declare function findLatexEngine(): Promise<LatexEngine | {
+    readonly missing: string;
+}>;
+/**
+ * The characters a compile could not draw, in first-seen order: LuaLaTeX
+ * leaves a blank where the font has no glyph and only logs `Missing
+ * character: There is no 中 (U+4E2D) in font …` — Greek, CJK or emoji in
+ * prose against Latin Modern. Each comes back once, as `中 (U+4E2D)`.
+ */
+declare function missingCharacters(log: string): string[];
+/**
+ * Compile `files` (a folder with `main.tex`) and return the PDF with the
+ * `.aux` LaTeX wrote, for the numbering check. `epoch` fixes the PDF's dates
+ * so the same source gives the same file.
+ */
+declare function compileLatex(files: readonly SourceFile[], engine: LatexEngine, options?: {
+    readonly epoch?: number;
+    readonly name?: string;
+}): Promise<CompiledLatex>;
+
+export { type CompiledLatex, type LatexEngine, compileLatex, findLatexEngine, missingCharacters };

package/dist/compiler/exports/latex/compile.js

@@ -0,0 +1,115 @@
+import { spawn } from "node:child_process";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+function run(command, args, options = {}) {
+  return new Promise((resolveRun) => {
+    let output = "";
+    let child;
+    try {
+      child = spawn(command, args, { cwd: options.cwd, env: options.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+    } catch {
+      resolveRun({ code: null, output: "" });
+      return;
+    }
+    const capture = (chunk) => {
+      if (output.length < 2e5) output += chunk.toString("utf8");
+    };
+    child.stdout.on("data", capture);
+    child.stderr.on("data", capture);
+    child.once("error", () => resolveRun({ code: null, output }));
+    child.once("close", (code) => resolveRun({ code, output }));
+  });
+}
+async function findLatexEngine() {
+  const requested = process.env.EXPLICO_LATEX_ENGINE ?? "lualatex";
+  if (requested !== "lualatex" && requested !== "pdflatex") {
+    return { missing: `EXPLICO_LATEX_ENGINE must be "lualatex" or "pdflatex", not ${JSON.stringify(requested)}.` };
+  }
+  if ((await run("latexmk", ["-v"])).code !== 0) {
+    return { missing: "latexmk is not installed (TeX Live 2025 or later provides it)." };
+  }
+  if ((await run(requested, ["--version"])).code !== 0) {
+    return { missing: `${requested} is not installed.` };
+  }
+  if (requested === "lualatex") {
+    const loader = await run("kpsewhich", ["luaotfload.sty"]);
+    if (loader.code !== 0 || !loader.output.trim()) {
+      return {
+        missing: "LuaLaTeX cannot load fonts: luaotfload is missing (on Debian or Ubuntu, install texlive-luatex). Set EXPLICO_LATEX_ENGINE=pdflatex to compile with pdfLaTeX instead."
+      };
+    }
+  }
+  return requested === "lualatex" ? { name: "lualatex", latexmkOption: "-lualatex" } : { name: "pdflatex", latexmkOption: "-pdf" };
+}
+function latexErrors(log) {
+  const lines = log.split("\n");
+  const found = [];
+  lines.forEach((line, index) => {
+    if (/^(?:\.\/[^:]+:\d+: |! |\[\\directlua\]:\d+: |\S+\.lua:\d+: )/u.test(line)) {
+      found.push([line, lines[index + 1] ?? ""].join(" ").trim());
+    }
+  });
+  return found.slice(0, 6).join("\n  ");
+}
+function missingCharacters(log) {
+  const found = /* @__PURE__ */ new Set();
+  for (const match of log.matchAll(/Missing character: There is no (\S+) \((U\+[0-9A-F]+)\)/gu)) {
+    found.add(`${match[1]} (${match[2]})`);
+  }
+  return [...found];
+}
+async function compileLatex(files, engine, options = {}) {
+  const root = await mkdtemp(join(tmpdir(), "explico-latex-"));
+  try {
+    for (const file of files) {
+      const path = join(root, file.path);
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, file.content);
+    }
+    const result = await run(
+      "latexmk",
+      [
+        engine.latexmkOption,
+        "-interaction=nonstopmode",
+        "-halt-on-error",
+        "-file-line-error",
+        "-norc",
+        // luaotfload's caches are inputs latexmk tracks; the build's other
+        // compiles rewrite them meanwhile, and a compile that sees its inputs
+        // change on every run never settles ("needed too many passes").
+        "-e",
+        "$hash_calc_ignore_pattern{'luc'} = '^';",
+        "main.tex"
+      ],
+      {
+        cwd: root,
+        env: {
+          ...process.env,
+          SOURCE_DATE_EPOCH: String(options.epoch ?? 0),
+          FORCE_SOURCE_DATE: "1"
+        }
+      }
+    );
+    const log = await readFile(join(root, "main.log"), "utf8").catch(() => result.output);
+    if (result.code !== 0) {
+      const errors = latexErrors(log);
+      const said = errors === "" ? `
+  latexmk: ${result.output.trim().split("\n").slice(-12).join("\n  ")}` : "";
+      throw new Error(`LaTeX could not compile ${options.name ?? "the document"}:
+  ${errors || log.slice(-1500)}${said}`);
+    }
+    return {
+      pdf: await readFile(join(root, "main.pdf")),
+      aux: await readFile(join(root, "main.aux"), "utf8"),
+      log
+    };
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+export {
+  compileLatex,
+  findLatexEngine,
+  missingCharacters
+};