papilot 0.8.1 → 0.8.3

package/engine/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "latex-review-skill",
+  "version": "0.2.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=22.22.0"
+  },
+  "bin": {
+    "latex-review": "scripts/review.mjs"
+  },
+  "scripts": {
+    "review": "tsx src/cli.ts",
+    "dev": "vite --host 127.0.0.1",
+    "build": "tsc --noEmit && vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "check": "npm run typecheck && npm test && npm run build",
+    "demo": "tsx examples/demo.ts",
+    "test:browser": "playwright test",
+    "test:corpus": "tsx scripts/validate-corpus.ts",
+    "fixture:prepare": "tsx scripts/prepare-fixture.ts",
+    "format": "prettier --write src tests scripts examples/demo.ts *.ts *.json"
+  },
+  "dependencies": {
+    "@fastify/compress": "^9.2.2",
+    "@fastify/static": "^10.1.7",
+    "commander": "^15.0.0",
+    "diff": "^9.0.0",
+    "fastify": "^5.12.7",
+    "mupdf": "^1.28.1",
+    "proper-lockfile": "^4.1.2",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "tsx": "^4.23.15"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.64.1",
+    "@types/node": "^22.20.5",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.2",
+    "pdfjs-dist": "^6.4.299",
+    "prettier": "^3.9.10",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.5",
+    "vitest": "^5.0.5"
+  }
+}

package/{vendor/latex-review → engine}/src/core/build.ts

@@ -2,12 +2,14 @@ import fs from "node:fs";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
+import { gunzipSync, gzipSync } from "node:zlib";
 import { Repo } from "./git.ts";
 import { listFiles, readJson, writeJson, withLock, now } from "./files.ts";
 import { stripComments } from "./outline.ts";
 import { signature, type Project } from "./config.ts";
 import { run, runAsync } from "./process.ts";
-import type { BuildInfo } from "../types.ts";
+import { progressReader, writtenPages } from "./progress.ts";
+import type { BuildInfo, BuildProgress } from "../types.ts";
 export class BuildError extends Error {
   constructor(
     message: string,
@@ -28,6 +30,27 @@ const AUXILIARY = new Set([
   ".out",
   ".thm",
 ]);
+// Output that TeX writes for this folder: SyncTeX data and the log name its
+// absolute path.
+const OUTPUT = /\.(?:pdf|xdv|dvi|log|synctex(?:\.gz)?)$/i;
+function clone(file: string, target: string) {
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.copyFileSync(file, target, fs.constants.COPYFILE_FICLONE);
+}
+// Output that latexmk kept from an earlier build folder still names that
+// folder. Build folders differ only in their equal-length key, so the paths
+// are replaced in place without moving anything else in the file.
+export function relocate(file: string, from: string, to: string) {
+  if (!fs.existsSync(file)) return;
+  const old = Buffer.from(from + path.sep), next = Buffer.from(to + path.sep);
+  if (old.length !== next.length) return;
+  const zipped = file.endsWith(".gz"),
+    data = zipped ? gunzipSync(fs.readFileSync(file)) : fs.readFileSync(file);
+  let at = data.indexOf(old);
+  if (at < 0) return;
+  for (; at >= 0; at = data.indexOf(old, at + next.length)) next.copy(data, at);
+  fs.writeFileSync(file, zipped ? gzipSync(data) : data);
+}
 const hash = (value: string | Buffer) =>
   createHash("sha256").update(value).digest("hex");
 export const includes = (text: string) =>
@@ -197,7 +220,7 @@ export class Builder {
     rev: string,
     targets = ["full"],
     seed: BuildInfo | null = null,
-    options: { force?: boolean } = {},
+    options: { force?: boolean; progress?: (progress: BuildProgress) => void } = {},
   ): Promise<BuildInfo> {
     const p = this.project,
       partial = JSON.stringify(targets) !== '["full"]';
@@ -215,6 +238,7 @@ export class Builder {
     }
     const tree = this.repo.treeId(rev, p.source_dir),
       date = buildDate(),
+      context = hash(JSON.stringify([signature(p), version])),
       key = hash(
         JSON.stringify([
           tree,
@@ -239,109 +263,184 @@ export class Builder {
         fs.utimesSync(folder, new Date(), new Date());
         return cached;
       }
-      fs.rmSync(folder, { recursive: true, force: true });
-      const source = path.join(folder, "src");
-      this.repo.export(rev, p.source_dir, source);
-      const cwd = path.join(
-          source,
-          path.posix.relative(p.source_dir || ".", p.doc_dir || "."),
-        ),
-        main = path.posix.basename(p.main),
-        job = path.posix.basename(main, ".tex"),
-        out = path.join(cwd, "build");
-      fs.mkdirSync(out, { recursive: true });
-      for (const target of includes(
-        fs.readFileSync(path.join(cwd, main), "utf8"),
-      ))
-        fs.mkdirSync(path.join(out, path.dirname(target)), { recursive: true });
-      const args = [
-        "-norc",
-        ...(p.latexmkrc
-          ? ["-r", path.posix.relative(p.doc_dir || ".", p.latexmkrc)]
-          : []),
-        { pdflatex: "-pdf", xelatex: "-xelatex", lualatex: "-lualatex" }[
-          p.engine
-        ],
-        "-outdir=build",
-        `-jobname=${job}`,
-        "-synctex=1",
-        "-interaction=nonstopmode",
-        "-halt-on-error",
-        "-file-line-error",
-      ];
-      if (partial) {
-        const seedOut = path.dirname(seed!.pdf);
-        for (const file of listFiles(seedOut))
-          if (AUXILIARY.has(path.extname(file))) {
-            const target = path.join(out, path.relative(seedOut, file));
-            fs.mkdirSync(path.dirname(target), { recursive: true });
-            if (!fs.existsSync(target)) fs.copyFileSync(file, target);
-          }
-        const preload = Object.entries(p.preload)
-          .filter(
-            ([name, file]) =>
-              !targets.includes(name) && fs.existsSync(path.join(cwd, file)),
-          )
-          .map(([, file]) => `\\input{${file}}`)
-          .join("");
-        args.push(
-          `-usepretex=\\includeonly{${targets.join(",")}}` +
-            (preload ? `\\AtBeginDocument{${preload}}` : ""),
-        );
-      }
-      args.push(main);
-      const transcript = path.join(folder, "latexmk.log"),
-        fd = fs.openSync(transcript, "w"),
-        started = now();
-      let failure: Error | null = null;
+      // A full build continues from the latest completed one, or from the
+      // author's own latexmk output, as latexmk does when a folder is
+      // compiled again: unchanged files are cloned and LaTeX keeps its state,
+      // so it reruns only as often as the edit requires. Manual recompilation
+      // starts clean, and so does a retry when leftover state broke a build.
+      const start = partial || options.force ? null : this.latest(context) ?? "author";
+      let result: BuildInfo;
       try {
-        await runAsync("latexmk", args, {
-          cwd,
-          env: { ...process.env, ...date },
-          timeout: 1800000,
-          output: (chunk) => fs.writeSync(fd, chunk),
-        });
+        result = await this.compile(rev, tree, key, targets, seed, date, start, options.progress);
       } catch (error) {
-        failure = error as Error;
-      } finally {
-        fs.closeSync(fd);
-      }
-      const pdf = path.join(out, job + ".pdf"),
-        log = path.join(out, job + ".log"),
-        logText = fs.existsSync(log) ? fs.readFileSync(log, "utf8") : "";
-      if (failure || !fs.existsSync(pdf)) {
-        const transcriptText = fs.readFileSync(transcript, "utf8"),
-          details = compilerDiagnostics(logText, transcriptText),
-          kept = path.join(p.state, "logs", key + ".log");
-        fs.mkdirSync(path.dirname(kept), { recursive: true });
-        fs.writeFileSync(
-          kept,
-          transcriptText + (logText ? "\n\n--- TeX log ---\n" + logText : ""),
-        );
-        const tail = transcriptText.split("\n").slice(-25);
-        fs.rmSync(folder, { recursive: true, force: true });
-        throw new BuildError(
-          failure?.message.includes("ENOENT")
-            ? "latexmk was not found. Install TeX Live or MacTeX."
-            : "LaTeX failed to compile.",
-          details.length ? details : tail,
-          kept,
-        );
+        if (!start || (error instanceof BuildError && !error.details.some(line => /(?:^|\s|\()(?:\.\/)?build\//.test(line)))) throw error;
+        result = await this.compile(rev, tree, key, targets, seed, date, null, options.progress);
       }
-      const result: BuildInfo = {
-        key,
-        tree,
-        targets,
-        root: source,
-        cwd,
-        pdf,
-        seconds: Math.round((now() - started) * 10) / 10,
-        warnings: warnings(logText),
-      };
-      writeJson(path.join(folder, "result.json"), result);
+      if (!partial) writeJson(path.join(this.cache, "latest.json"), { key, context, date: date.SOURCE_DATE_EPOCH });
       return result;
     });
   }
+  private latest(context: string): { info: BuildInfo; date: unknown } | null {
+    const latest = readJson<{ key?: unknown; context?: unknown; date?: unknown } | null>(path.join(this.cache, "latest.json"), null);
+    if (typeof latest?.key !== "string" || !/^[0-9a-f]{32}$/.test(latest.key) || latest.context !== context) return null;
+    const info = readJson<BuildInfo | null>(path.join(this.cache, latest.key, "result.json"), null);
+    return info && JSON.stringify(info.targets) === '["full"]' && fs.existsSync(info.pdf) && fs.existsSync(info.root) ? { info, date: latest.date } : null;
+  }
+  private async compile(
+    rev: string,
+    tree: string,
+    key: string,
+    targets: string[],
+    seed: BuildInfo | null,
+    date: ReturnType<typeof buildDate>,
+    start: { info: BuildInfo; date: unknown } | "author" | null,
+    progress?: (progress: BuildProgress) => void,
+  ): Promise<BuildInfo> {
+    const p = this.project,
+      partial = JSON.stringify(targets) !== '["full"]',
+      folder = path.join(this.cache, key);
+    fs.rmSync(folder, { recursive: true, force: true });
+    const source = path.join(folder, "src");
+    const base = start && start !== "author" ? start.info : null;
+    await this.repo.export(rev, p.source_dir, source, base ? { root: base.root, tree: base.tree } : undefined);
+    const cwd = path.join(
+        source,
+        path.posix.relative(p.source_dir || ".", p.doc_dir || "."),
+      ),
+      main = path.posix.basename(p.main),
+      job = path.posix.basename(main, ".tex"),
+      out = path.join(cwd, "build");
+    fs.mkdirSync(out, { recursive: true });
+    const included = includes(fs.readFileSync(path.join(cwd, main), "utf8"));
+    for (const target of included)
+      fs.mkdirSync(path.join(out, path.dirname(target)), { recursive: true });
+    // The PDF, SyncTeX data and log carry over only within a day, so that
+    // \today stays current; latexmk then skips TeX when no input changed.
+    const reused = base !== null && start !== "author" && start?.date === date.SOURCE_DATE_EPOCH;
+    if (base) {
+      const previous = path.dirname(base.pdf);
+      for (const file of listFiles(previous))
+        if (!/\.fls$/i.test(file) && (reused || !OUTPUT.test(file)))
+          clone(file, path.join(out, path.relative(previous, file)));
+    } else if (start === "author") {
+      // Only this job's state: the author's folder may hold other editions.
+      const own = path.join(p.root, p.doc_dir, "build");
+      if (fs.existsSync(path.join(own, job + ".fdb_latexmk")))
+        for (const name of [
+          ...fs.readdirSync(own).filter((name) => (name.startsWith(job + ".") && !OUTPUT.test(name) && !name.endsWith(".fls")) || name.startsWith("_minted")),
+          ...included.map((target) => target + ".aux"),
+        ])
+          try {
+            if (fs.statSync(path.join(own, name)).isDirectory()) fs.cpSync(path.join(own, name), path.join(out, name), { recursive: true });
+            else clone(path.join(own, name), path.join(out, name));
+          } catch {
+            /* A missing file is regenerated. */
+          }
+    }
+    const args = [
+      "-norc",
+      ...(p.latexmkrc
+        ? ["-r", path.posix.relative(p.doc_dir || ".", p.latexmkrc)]
+        : []),
+      { pdflatex: "-pdf", xelatex: "-xelatex", lualatex: "-lualatex" }[
+        p.engine
+      ],
+      "-outdir=build",
+      `-jobname=${job}`,
+      "-synctex=1",
+      "-interaction=nonstopmode",
+      "-halt-on-error",
+      "-file-line-error",
+    ];
+    if (partial) {
+      const seedOut = path.dirname(seed!.pdf);
+      for (const file of listFiles(seedOut))
+        if (AUXILIARY.has(path.extname(file))) {
+          const target = path.join(out, path.relative(seedOut, file));
+          fs.mkdirSync(path.dirname(target), { recursive: true });
+          if (!fs.existsSync(target)) fs.copyFileSync(file, target);
+        }
+      const preload = Object.entries(p.preload)
+        .filter(
+          ([name, file]) =>
+            !targets.includes(name) && fs.existsSync(path.join(cwd, file)),
+        )
+        .map(([, file]) => `\\input{${file}}`)
+        .join("");
+      args.push(
+        `-usepretex=\\includeonly{${targets.join(",")}}` +
+          (preload ? `\\AtBeginDocument{${preload}}` : ""),
+      );
+    }
+    args.push(main);
+    const transcript = path.join(folder, "latexmk.log"),
+      fd = fs.openSync(transcript, "w"),
+      started = now(),
+      // Pages are counted against the build this one continues from.
+      read = progress
+        ? progressReader(
+            progress,
+            writtenPages(
+              base
+                ? path.join(path.dirname(base.pdf), job + ".log")
+                : path.join(p.root, p.doc_dir, "build", job + ".log"),
+            ),
+          )
+        : null;
+    let failure: Error | null = null;
+    try {
+      await runAsync("latexmk", args, {
+        cwd,
+        env: { ...process.env, ...date },
+        timeout: 1800000,
+        output: (chunk) => {
+          fs.writeSync(fd, chunk);
+          read?.(chunk);
+        },
+      });
+    } catch (error) {
+      failure = error as Error;
+    } finally {
+      fs.closeSync(fd);
+    }
+    const pdf = path.join(out, job + ".pdf"),
+      log = path.join(out, job + ".log");
+    if (reused && !failure)
+      for (const file of [path.join(out, job + ".synctex.gz"), log])
+        relocate(file, path.dirname(base!.root), folder);
+    const logText = fs.existsSync(log) ? fs.readFileSync(log, "utf8") : "";
+    if (failure || !fs.existsSync(pdf)) {
+      const transcriptText = fs.readFileSync(transcript, "utf8"),
+        details = compilerDiagnostics(logText, transcriptText),
+        kept = path.join(p.state, "logs", key + ".log");
+      fs.mkdirSync(path.dirname(kept), { recursive: true });
+      fs.writeFileSync(
+        kept,
+        transcriptText + (logText ? "\n\n--- TeX log ---\n" + logText : ""),
+      );
+      const tail = transcriptText.split("\n").slice(-25);
+      fs.rmSync(folder, { recursive: true, force: true });
+      throw new BuildError(
+        failure?.message.includes("ENOENT")
+          ? "latexmk was not found. Install TeX Live or MacTeX."
+          : "LaTeX failed to compile.",
+        details.length ? details : tail,
+        kept,
+      );
+    }
+    const result: BuildInfo = {
+      key,
+      tree,
+      targets,
+      root: source,
+      cwd,
+      pdf,
+      seconds: Math.round((now() - started) * 10) / 10,
+      warnings: warnings(logText),
+    };
+    writeJson(path.join(folder, "result.json"), result);
+    return result;
+  }
   async prune(keep: Set<string>, maxAge = 3 * 86400) {
     if (!fs.existsSync(this.cache)) return;
     for (const entry of fs.readdirSync(this.cache, { withFileTypes: true })) {

package/{vendor/latex-review → engine}/src/core/git.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { spawn } from "node:child_process";
 import { run, which } from "./process.ts";
 import { same } from "./files.ts";
 const IDENTITY = {
@@ -128,6 +129,14 @@ export class Repo {
       .split("\0")
       .filter(Boolean);
   }
+  entries(rev: string, folder = "") {
+    return this.run([
+      "ls-tree", "-r", "-l", "-z", rev, ...(folder ? ["--", folder] : []),
+    ]).toString().split("\0").filter(Boolean).flatMap(entry => {
+      const tab = entry.indexOf("\t"), [mode, type, oid, size] = entry.slice(0, tab).split(/ +/);
+      return type === "blob" ? [{ mode, oid, size: Number(size), file: entry.slice(tab + 1) }] : [];
+    });
+  }
   changedFiles(before: string, after: string) {
     return this.run([
       "diff",
@@ -261,36 +270,132 @@ export class Repo {
       return this.text(["write-tree"], { env });
     });
   }
-  export(rev: string, folder: string, destination: string) {
-    fs.mkdirSync(destination, { recursive: true });
-    const files = this.files(rev, folder),
-      blobs = this.blobs(rev, files);
-    const links: [string, string][] = [];
-    for (const file of files) {
-      const relative = path.posix.relative(folder || ".", file);
+  // Write a revision's files under destination. Given an earlier export of
+  // another tree, files with the same Git object are cloned from it
+  // (copy-on-write where the file system supports it), so only changed files
+  // are read from Git.
+  async export(rev: string, folder: string, destination: string, base?: { root: string; tree: string }) {
+    const previous = new Map<string, string>();
+    if (base) for (const entry of this.entries(base.tree)) previous.set(entry.file, entry.mode + " " + entry.oid);
+    const wanted = this.entries(rev, folder).map(entry => {
+      const relative = path.posix.relative(folder || ".", entry.file);
       cleanPath(relative);
-      const target = path.join(destination, relative),
-        data = blobs[file];
-      if (data === null) continue;
-      fs.mkdirSync(path.dirname(target), { recursive: true });
-      const mode = this.mode(rev, file);
-      if (mode === "120000") {
-        const link = data.toString(),
-          resolved = path.resolve(path.dirname(target), link);
-        if (
-          path.isAbsolute(link) ||
-          !resolved.startsWith(path.resolve(destination) + path.sep)
-        )
-          throw new GitError(
-            `A link in the snapshot points outside the document: ${file}`,
-          );
-        links.push([target, link]);
-      } else
-        fs.writeFileSync(target, data, {
-          mode: mode === "100755" ? 0o755 : 0o644,
-        });
+      return { ...entry, relative, target: path.join(destination, relative) };
+    });
+    // On APFS, cp clones a whole folder far faster than creating each file
+    // separately; files that are not in this tree are then removed again.
+    let cloned = false;
+    if (base && process.platform === "darwin" && !fs.existsSync(destination))
+      try {
+        fs.mkdirSync(path.dirname(destination), { recursive: true });
+        cloned = run("/bin/cp", ["-c", "-R", base.root, destination], { check: false }).status === 0;
+      }
+      catch { /* Copy file by file below. */ }
+    if (cloned) {
+      const keep = new Set(wanted.map(entry => entry.relative));
+      (function prune(directory: string, prefix: string) {
+        for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+          const relative = prefix + item.name, file = path.join(directory, item.name);
+          if (item.isDirectory()) prune(file, relative + "/");
+          else if (!keep.has(relative)) fs.rmSync(file, { force: true });
+        }
+      })(destination, "");
+    } else {
+      fs.rmSync(destination, { recursive: true, force: true });
+      fs.mkdirSync(destination, { recursive: true });
+    }
+    const folders = new Set<string>(), entries: typeof wanted = [];
+    for (const entry of wanted) {
+      const { relative, target } = entry;
+      if (!folders.has(path.dirname(target))) { fs.mkdirSync(path.dirname(target), { recursive: true }); folders.add(path.dirname(target)); }
+      if (entry.mode !== "120000" && previous.get(relative) === entry.mode + " " + entry.oid) {
+        const source = cloned ? target : path.join(base!.root, relative);
+        try {
+          // A compiler may have rewritten a file in the earlier export.
+          const stat = fs.lstatSync(source);
+          if (stat.isFile() && stat.size === entry.size) {
+            if (!cloned) fs.copyFileSync(source, target, fs.constants.COPYFILE_FICLONE);
+            if ((stat.mode & 0o777) !== (entry.mode === "100755" ? 0o755 : 0o644)) fs.chmodSync(target, entry.mode === "100755" ? 0o755 : 0o644);
+            continue;
+          }
+        } catch { /* Read this file from Git. */ }
+      }
+      // A cloned link or rewritten file is replaced, never written through.
+      if (cloned) fs.rmSync(target, { force: true });
+      entries.push(entry);
+    }
+    if (!entries.length) return;
+    // Keep one Git process and stream each blob to disk. Collecting the entire
+    // snapshot with blobs() both duplicates memory and hits spawnSync's buffer
+    // limit for ordinary repositories containing PDFs and figures.
+    const child = spawn(gitBinary(), ["cat-file", "--batch"], {
+      cwd: this.root, stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stderr = "", timedOut = false;
+    child.stderr.on("data", (data: Buffer) => { stderr = (stderr + data.toString()).slice(-65536); });
+    child.stdin.on("error", () => { /* Report process failures through finished. */ });
+    const finished = new Promise<Error | null>(resolve => {
+      child.once("error", resolve);
+      child.once("close", code => resolve(code === 0 && !timedOut ? null : new GitError(
+        timedOut ? "Git snapshot export timed out." : stderr.trim() || `Git snapshot export failed (${code}).`,
+      )));
+    });
+    const timer = setTimeout(() => { timedOut = true; child.kill("SIGKILL"); }, 300000);
+    const output = child.stdout[Symbol.asyncIterator]();
+    let chunk: Buffer = Buffer.alloc(0), offset = 0;
+    const available = async () => {
+      if (offset < chunk.length) return;
+      const next = await output.next();
+      if (next.done) throw await finished || new GitError("Git snapshot export ended before a file was complete.");
+      chunk = next.value; offset = 0;
+    };
+    const header = async () => {
+      const parts: Buffer[] = [];
+      while (true) {
+        await available();
+        const end = chunk.indexOf(10, offset);
+        parts.push(chunk.subarray(offset, end < 0 ? chunk.length : end));
+        offset = end < 0 ? chunk.length : end + 1;
+        if (end >= 0) return Buffer.concat(parts).toString();
+      }
+    };
+    const links: [string, string][] = [];
+    try {
+      for (const { file, mode, oid, target } of entries) {
+        child.stdin.write(oid + "\n");
+        const [object, type, size] = (await header()).split(" ");
+        let remaining = Number(size);
+        if (object !== oid || type !== "blob" || !Number.isSafeInteger(remaining) || remaining < 0)
+          throw new GitError(`Git snapshot export could not read: ${file}`);
+        const linkParts: Buffer[] = [], fd = mode === "120000" ? null : fs.openSync(target, "w", mode === "100755" ? 0o755 : 0o644);
+        try {
+          while (remaining) {
+            await available();
+            const length = Math.min(remaining, chunk.length - offset), data = chunk.subarray(offset, offset + length);
+            if (fd === null) linkParts.push(Buffer.from(data));
+            else fs.writeFileSync(fd, data);
+            remaining -= length; offset += length;
+          }
+        } finally { if (fd !== null) fs.closeSync(fd); }
+        await available();
+        if (chunk[offset++] !== 10) throw new GitError(`Git snapshot export returned an invalid file boundary: ${file}`);
+        if (mode === "120000") {
+          const link = Buffer.concat(linkParts).toString(), resolved = path.resolve(path.dirname(target), link);
+          if (path.isAbsolute(link) || !resolved.startsWith(path.resolve(destination) + path.sep))
+            throw new GitError(`A link in the snapshot points outside the document: ${file}`);
+          links.push([target, link]);
+        }
+      }
+      child.stdin.end();
+      if (!(await output.next()).done) throw new GitError("Git snapshot export returned unexpected output.");
+      const failure = await finished;
+      if (failure) throw failure;
+      for (const [target, link] of links) fs.symlinkSync(link, target);
+    } finally {
+      clearTimeout(timer);
+      if (child.exitCode === null) child.kill("SIGKILL");
+      await finished;
     }
-    for (const [target, link] of links) fs.symlinkSync(link, target);
   }
 }
 export function merge3(

package/{vendor/latex-review → engine}/src/core/outline.ts

@@ -247,15 +247,6 @@ export function buildOutline(
       .slice(0, 20),
   };
 }
-export function overlaps(a: Ranges, b: Ranges) {
-  return Object.keys(a).some(
-    (file) =>
-      b[file] &&
-      a[file].some(([x, y]) =>
-        b[file].some(([u, v]) => Math.max(x, u) <= Math.min(y, v)),
-      ),
-  );
-}
 export function selectedRanges(
   nodes: Heading[],
   ids: string[],

package/engine/src/core/progress.ts

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import type { BuildProgress } from "../types.ts";
+
+// What latexmk is doing, read from its output as it streams: the rule it
+// runs, the TeX pass, and the pages TeX has shipped out in that pass. TeX
+// prints "[n" for every page and flushes the terminal right after, so the
+// count moves while a long document typesets.
+const RUN = /^Run number (\d+) of rule '([^']+)'/;
+const WRITTEN = /^Output written on .*?\((\d+) pages?\b/;
+// A page marker is "[" with \count0 (and any nonzero \count1–9), closed by
+// "]", a space, or the font map and image notes TeX prints inside it.
+const PAGE = /\[-?\d+(?:\.-?\d+)*(?=[\]\s{<(])/g;
+
+export function progressReader(
+  report: (progress: BuildProgress) => void,
+  total: number | null,
+) {
+  const state: BuildProgress = { step: "tex", pass: 0, pages: 0, total };
+  let line = "",
+    scanned = 0;
+  const pages = (text: string, from: number) => {
+    if (state.step !== "tex" || state.pass === 0) return text.length;
+    PAGE.lastIndex = from;
+    let end = from;
+    while (PAGE.exec(text)) {
+      state.pages++;
+      end = PAGE.lastIndex;
+    }
+    // An unfinished marker at the end counts once it is complete.
+    const open = text.lastIndexOf("[");
+    return open >= end && /^\[-?[\d.]*$/.test(text.slice(open)) ? open : text.length;
+  };
+  report({ ...state });
+  return (chunk: Buffer) => {
+    const before = JSON.stringify(state),
+      parts = (line + chunk.toString("latin1")).split("\n");
+    line = parts.pop()!;
+    for (const complete of parts) {
+      const run = RUN.exec(complete),
+        written = WRITTEN.exec(complete);
+      if (run) {
+        const rule = run[2].split(" ")[0];
+        if (/^(?:pdf|xe|lua)?latex$/.test(rule))
+          Object.assign(state, { step: "tex", pass: Number(run[1]), pages: 0 });
+        else
+          state.step = /^(?:xdvipdfmx|dvipdfmx?|dvips|ps2pdf)$/.test(rule)
+            ? "pdf"
+            : "bibliography";
+      } else if (written) state.total = state.pages = Number(written[1]);
+      else pages(complete, scanned);
+      scanned = 0;
+    }
+    scanned = pages(line, scanned);
+    if (JSON.stringify(state) !== before) report({ ...state });
+  };
+}
+
+// The pages of the build a compilation continues from, as TeX reported them.
+export function writtenPages(log: string): number | null {
+  try {
+    const text = fs.readFileSync(log, "latin1"),
+      found = [...text.matchAll(/Output written on .*?\((\d+) pages?\b/g)].at(-1);
+    return found ? Number(found[1]) : null;
+  } catch {
+    return null;
+  }
+}