papilot 0.8.5 → 0.8.7

package/engine/src/core/process.ts

@@ -1,6 +1,9 @@
+import fs from "node:fs";
+import path from "node:path";
 import {
   spawn,
   spawnSync,
+  type ChildProcess,
   type SpawnSyncOptionsWithBufferEncoding,
 } from "node:child_process";
 export class ProcessError extends Error {
@@ -39,16 +42,92 @@ export function run(
     status: result.status ?? 1,
   };
 }
-const running = new Set<ReturnType<typeof spawn>>();
+const running = new Set<ChildProcess>();
+let stopped = false;
+/** Tracks a child that `start` spawns in its own process group (detached),
+ *  so stopAll() ends it with everything it started. Once the server is
+ *  stopping nothing new starts: a build must not retry or move on to its next
+ *  step after its compiler was stopped. */
+export function startTracked<T extends ChildProcess>(start: () => T): T {
+  if (stopped) throw new ProcessError("The review server is stopping.");
+  const child = start();
+  running.add(child);
+  child.once("close", () => running.delete(child));
+  child.once("error", () => running.delete(child));
+  return child;
+}
 export function stopAll() {
+  stopped = true;
   for (const child of running) {
     try {
-      if (child.pid) process.kill(-child.pid, "SIGTERM");
+      if (child.pid) {
+        process.kill(-child.pid, "SIGTERM");
+        // A paused background build receives the signal once it continues.
+        process.kill(-child.pid, "SIGCONT");
+      }
     } catch {
       child.kill();
     }
   }
 }
+/** `run` without blocking the event loop: the same result and errors,
+ *  delivered when the command exits. Servers call this so that a Git command
+ *  never holds up the requests they answer meanwhile. */
+export function capture(
+  command: string,
+  args: string[],
+  options: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    input?: string | Buffer;
+    check?: boolean;
+    timeout?: number;
+    maxBuffer?: number;
+  } = {},
+) {
+  const { check = true, timeout = 300000, maxBuffer = 128 * 1024 * 1024 } = options;
+  return new Promise<{ stdout: Buffer; stderr: Buffer; status: number }>((resolve, reject) => {
+    let child: ChildProcess;
+    try {
+      child = startTracked(() =>
+        spawn(command, args, { cwd: options.cwd, env: options.env, stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"] }),
+      );
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const out: Buffer[] = [], err: Buffer[] = [];
+    let size = 0, failure: Error | null = null;
+    const stop = (error: Error) => {
+      failure ??= error;
+      child.kill("SIGKILL");
+    };
+    const timer = setTimeout(() => stop(new ProcessError(`${command} timed out`)), timeout);
+    const collect = (into: Buffer[]) => (data: Buffer) => {
+      size += data.length;
+      if (size > maxBuffer) stop(new ProcessError(`${command} produced more output than expected`));
+      else into.push(data);
+    };
+    child.stdout!.on("data", collect(out));
+    child.stderr!.on("data", collect(err));
+    if (options.input !== undefined) {
+      child.stdin!.on("error", () => { /* The exit status reports the failure. */ });
+      child.stdin!.end(options.input);
+    }
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(failure ?? error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const stdout = Buffer.concat(out), stderr = Buffer.concat(err), status = code ?? 1;
+      if (failure) reject(failure);
+      else if (check && status !== 0)
+        reject(new ProcessError(stderr.toString().trim() || `${command} failed (${status})`, stdout, stderr, status));
+      else resolve({ stdout, stderr, status });
+    });
+  });
+}
 export function runAsync(
   command: string,
   args: string[],
@@ -57,16 +136,20 @@ export function runAsync(
     env?: NodeJS.ProcessEnv;
     timeout?: number;
     output?: (chunk: Buffer) => void;
+    /** Receives the process group's leader, e.g. to pause and resume it. */
+    started?: (child: ChildProcess) => void;
   } = {},
 ) {
   return new Promise<Buffer>((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      env: options.env,
-      detached: true,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    running.add(child);
+    const child = startTracked(() =>
+      spawn(command, args, {
+        cwd: options.cwd,
+        env: options.env,
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+      }),
+    );
+    options.started?.(child);
     const chunks: Buffer[] = [];
     let timedOut = false;
     const timer = setTimeout(() => {
@@ -85,12 +168,10 @@ export function runAsync(
     child.stderr.on("data", receive);
     child.on("error", (error) => {
       clearTimeout(timer);
-      running.delete(child);
       reject(error);
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      running.delete(child);
       const data = Buffer.concat(chunks);
       if (code === 0 && !timedOut) resolve(data);
       else
@@ -109,3 +190,35 @@ export function which(command: string): string | null {
   const found = run("which", [command], { check: false });
   return found.status === 0 ? found.stdout.toString().trim() : null;
 }
+// A command's first output line (such as `xelatex --version`), read once per
+// executable file: TeX is not replaced while a server runs, and when it is,
+// the file's identity changes.
+const versions = new Map<string, Promise<string>>();
+export async function commandVersion(command: string, env: NodeJS.ProcessEnv = process.env) {
+  const found = await resolveCommand(command, env);
+  let identity = command;
+  if (found) try {
+    const stat = await fs.promises.stat(found);
+    identity = `${found}:${stat.ino}:${stat.mtimeMs}:${stat.size}`;
+  } catch { /* The command reports its own failure below. */ }
+  let version = versions.get(identity);
+  if (!version) {
+    version = capture(found ?? command, ["--version"], { env, timeout: 60000 }).then((r) => r.stdout.toString().split("\n")[0]);
+    versions.set(identity, version);
+    version.catch(() => versions.delete(identity));
+  }
+  return version;
+}
+// The executable file PATH resolves a command to, as a shell would find it.
+async function resolveCommand(command: string, env: NodeJS.ProcessEnv) {
+  if (command.includes("/")) return path.resolve(command);
+  for (const folder of (env.PATH ?? "").split(path.delimiter)) {
+    if (!folder) continue;
+    const file = path.join(folder, command);
+    try {
+      await fs.promises.access(file, fs.constants.X_OK);
+      if ((await fs.promises.stat(file)).isFile()) return fs.promises.realpath(file);
+    } catch { /* Try the next folder. */ }
+  }
+  return null;
+}

package/engine/src/core/publish.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 import { randomBytes } from "node:crypto";
 import { ROOT, codeVersion } from "../runtime.ts";
 import { Builder, BuildError } from "./build.ts";
-import { diffUnits, scopeViolations, withUnits } from "./changes.ts";
+import { diffUnitsAsync, scopeViolationsAsync, withUnits } from "./changes.ts";
 import { isFigure } from "./config.ts";
 import { now, readJson, writeJson } from "./files.ts";
 import { runAsync } from "./process.ts";
@@ -189,6 +189,10 @@ export class Publisher {
   running = new Map<string, Promise<void>>();
   queue: string[] = [];
   stopping = false;
+  // The new version of each running job whose round compiles only some of
+  // its chapters: a host may compile the whole paper meanwhile, without
+  // waiting for or competing with a build of the same files here.
+  private revisions = new Map<string, string>();
   constructor(public app: App) {
     app.store.execute(
       "UPDATE jobs SET status='failed', finished=?, result=? WHERE status IN ('queued','running')",
@@ -241,6 +245,9 @@ export class Publisher {
     if (!job) throw new Error("Unknown job " + id);
     return job;
   }
+  revision(id: string) {
+    return this.revisions.get(id) ?? null;
+  }
   current(name: string) {
     return this.app.store.one<Job>(
       "SELECT * FROM jobs WHERE task=? ORDER BY created DESC,rowid DESC LIMIT 1",
@@ -276,6 +283,10 @@ export class Publisher {
   stop() {
     this.stopping = true;
   }
+  private phase(job: Pick<Job, "id">, phase: string) {
+    if (this.stopping) throw new Error("Server stopped during publication.");
+    this.update(job.id, { phase });
+  }
   async join() {
     await Promise.resolve();
     while (this.running.size || this.pruning)
@@ -313,6 +324,9 @@ export class Publisher {
       }
       this.update(job.id, { status: "done", result, finished: now() });
     } catch (error) {
+      // A build the server stopped stays unfinished: the next server marks it
+      // as interrupted by a restart, and the app builds it again.
+      if (this.stopping) return;
       const result: JobResult =
         error instanceof PublishError
           ? {
@@ -324,6 +338,7 @@ export class Publisher {
           : { error: (error as Error).message, next: "Publish again." };
       this.update(job.id, { status: "failed", result, finished: now() });
     } finally {
+      this.revisions.delete(job.id);
       this.running.delete(job.task);
       if (this.pending.get(job.task) === job.id) this.pending.delete(job.task);
       else if (!this.stopping) this.queue.push(this.pending.get(job.task)!);
@@ -343,16 +358,17 @@ export class Publisher {
         [],
         "Run `finish --force`, then start a new task.",
       );
-    this.update(job.id, { phase: "snapshot" });
-    const after = app.tasks.snapshot(task);
-    task = app.tasks.get(name);
-    const before = task.accepted,
-      latest = app.review.latestRound(name),
-      decided = app.review.lastChange(name),
-      violations = scopeViolations(app.repo, task.base, after, task.scope);
+    this.phase(job, "snapshot");
+    // The worktree and the decisions are read together, between writes.
+    const { after, before, latest, decided } = await app.exclusive(async () => {
+      const after = await app.tasks.snapshotAsync(task);
+      task = app.tasks.get(name);
+      return { after, before: task.accepted, latest: app.review.latestRound(name), decided: app.review.lastChange(name) };
+    });
+    const violations = await scopeViolationsAsync(app.repo, task.base, after, task.scope);
     const reconciliation = app.reconciliation.get(name);
     if (reconciliation) {
-      for (const file of app.repo.changedFiles(task.base, after))
+      for (const file of await app.repo.changedFilesAsync(task.base, after))
         if (!reconciliation.files.includes(file) && !violations.includes(file)) violations.push(file);
     }
     if (violations.length)
@@ -371,7 +387,7 @@ export class Publisher {
     if (
       latest &&
       latest.before === before &&
-      app.repo.treeId(latest.after) === app.repo.treeId(after) &&
+      (await app.repo.treeIdAsync(latest.after)) === (await app.repo.treeIdAsync(after)) &&
       latest.summary.renderer === codeVersion()
     )
       return {
@@ -379,45 +395,35 @@ export class Publisher {
         round: latest.number,
         changes: latest.units.length,
       };
-    const files = app.repo.changedFiles(before, after);
+    const files = await app.repo.changedFilesAsync(before, after);
     if (!files.length) return { outcome: "empty", round: null, changes: 0 };
-    const units = diffUnits(app.repo, before, after, (f) =>
+    const units = await diffUnitsAsync(app.repo, before, after, (f) =>
       isFigure(project, f),
     );
-    this.update(job.id, { phase: "build" });
+    this.phase(job, "build");
     const builder = new Builder(project, app.repo),
-      targets = builder.plan(before, after, files);
-    let seed = null,
-      old,
-      next;
-    try {
-      seed = targets[0] !== "full" ? await builder.build(task.base) : null;
-      old = await builder.build(before, targets, seed);
-    } catch (error) {
-      if (error instanceof BuildError)
-        throw new PublishError(
-          "The comparison baseline could not be compiled.",
-          error.details,
-          "Check the compiler diagnostics, fix the document or build environment, then publish again.",
-          error.log,
-        );
-      throw error;
-    }
-    try {
-      next = await builder.build(after, targets, seed);
-    } catch (error) {
+      targets = await builder.planAsync(before, after, files);
+    if (targets[0] !== "full") this.revisions.set(job.id, after);
+    const failed = (what: string) => (error: unknown) => {
       if (error instanceof BuildError)
         throw new PublishError(
-          "The revised document could not be compiled.",
+          what,
           error.details,
           "Check the compiler diagnostics, fix the document or build environment, then publish again.",
           error.log,
         );
       throw error;
-    }
+    };
+    const seed = targets[0] !== "full" ? await builder.build(task.base).catch(failed("The comparison baseline could not be compiled.")) : null;
+    // Both versions compile at once: each needs only the seed.
+    const baseline = builder.build(before, targets, seed).catch(failed("The comparison baseline could not be compiled.")),
+      revised = builder.build(after, targets, seed).catch(failed("The revised document could not be compiled."));
+    // A failure of either is reported once both have settled, the baseline's first.
+    await Promise.allSettled([baseline, revised]);
+    const old = await baseline, next = await revised;
     if (app.review.lastChange(name) !== decided) throw new Stale();
     const warnings = next.warnings.filter((w) => !old.warnings.includes(w));
-    this.update(job.id, { phase: "render" });
+    this.phase(job, "render");
     const number = (latest?.number ?? 0) + 1,
       rounds = path.join(app.state, "rounds", name),
       final = path.join(rounds, String(number).padStart(3, "0")),
@@ -447,20 +453,23 @@ export class Publisher {
             seed,
           ),
       );
-      if (app.review.lastChange(name) !== decided) throw new Stale();
-      fs.rmSync(final, { recursive: true, force: true });
-      fs.renameSync(output, final);
-      app.store.execute(
-        "INSERT INTO rounds(task,number,before,after,units,summary,created) VALUES(?,?,?,?,?,?,?)",
-        name,
-        number,
-        before,
-        after,
-        JSON.stringify(units),
-        JSON.stringify(summary),
-        now(),
-      );
-      app.repo.updateRef(`refs/latex-review/${name}/round-${number}`, after);
+      // No decision may come between this check and the new round.
+      await app.exclusive(async () => {
+        if (app.review.lastChange(name) !== decided) throw new Stale();
+        await fs.promises.rm(final, { recursive: true, force: true });
+        await fs.promises.rename(output, final);
+        app.store.execute(
+          "INSERT INTO rounds(task,number,before,after,units,summary,created) VALUES(?,?,?,?,?,?,?)",
+          name,
+          number,
+          before,
+          after,
+          JSON.stringify(units),
+          JSON.stringify(summary),
+          now(),
+        );
+        await app.repo.updateRefAsync(`refs/latex-review/${name}/round-${number}`, after);
+      });
     } finally {
       fs.rmSync(output, { recursive: true, force: true });
     }

package/engine/src/core/reconcile.ts

@@ -1,9 +1,9 @@
 import { randomUUID } from "node:crypto";
 import type { App } from "../server.ts";
-import { merge3 } from "./git.ts";
+import { merge3Async } from "./git.ts";
 import { readBytes, same, writeOrDelete } from "./files.ts";
 import { safePath } from "./review.ts";
-import { GENERATED, revisionReader } from "./tasks.ts";
+import { GENERATED, revisionReaderAsync } from "./tasks.ts";
 import { buildOutline, resolveSections, selectedRanges } from "./outline.ts";
 
 export interface Reconciliation {
@@ -34,45 +34,46 @@ export class Reconciliations {
   clear(name: string) {
     this.app.store.execute("DELETE FROM reconciliations WHERE task=?", name);
   }
-  start(name: string, force = false, intent?: Reconciliation["intent"]) {
+  // Callers hold the engine's write turn.
+  async start(name: string, force = false, intent?: Reconciliation["intent"]) {
     const app = this.app, task = app.tasks.get(name), previous = this.get(name);
     if (previous && (!previous.ready || (!force && (app.review.latestRound(name)?.number ?? 0) <= previous.round)))
       return this.prepare(name, previous);
-    const worktreeBefore = app.tasks.snapshot(task);
-    if (app.repo.changedFiles(task.accepted, worktreeBefore).length)
+    const worktreeBefore = await app.tasks.snapshotAsync(task);
+    if ((await app.repo.changedFilesAsync(task.accepted, worktreeBefore)).length)
       throw new Error("Review the latest task edits before applying the manuscript changes.");
     const delivered = app.delivery.get(name);
     const sourceBase = previous?.base ?? (delivered && delivered.mode !== "branch" ? delivered.accepted : task.base);
-    const base = app.repo.snapshot([app.project.source_dir, ...task.scope.paths], GENERATED);
-    const changed = app.repo.changedFiles(sourceBase, task.accepted);
-    const old = app.repo.blobs(sourceBase, changed), accepted = app.repo.blobs(task.accepted, changed), current = app.repo.blobs(base, changed);
+    const base = await app.repo.snapshotAsync([app.project.source_dir, ...task.scope.paths], GENERATED);
+    const changed = await app.repo.changedFilesAsync(sourceBase, task.accepted);
+    const [old, accepted, current] = await Promise.all([sourceBase, task.accepted, base].map((rev) => app.repo.blobsAsync(rev, changed)));
     const files: string[] = [], contents: Record<string, Buffer | null> = {};
     for (const file of changed) {
-      const [merged, conflict] = merge3(current[file], old[file], accepted[file]);
+      const [merged, conflict] = await merge3Async(current[file], old[file], accepted[file]);
       if (!conflict) contents[file] = merged;
       else {
         files.push(file);
         // Keep clean hunks even in a file with conflicts. At overlapping
         // hunks keep the latest manuscript as the baseline for human review.
-        const [kept, failed] = merge3(current[file], old[file], accepted[file], true);
+        const [kept, failed] = await merge3Async(current[file], old[file], accepted[file], true);
         contents[file] = failed ? current[file] : kept;
       }
     }
     if (!files.length) return null; // The author may have resolved it meanwhile.
-    const reviewBase = app.repo.commitWith(base, contents, "latex-review: prepare merge review");
+    const reviewBase = await app.repo.commitWithAsync(base, contents, "latex-review: prepare merge review");
     const data: Reconciliation = { id: randomUUID(), round: app.review.latestRound(name)?.number ?? 0, files, sourceBase, sourceAccepted: task.accepted, base, reviewBase, worktreeBefore, ready: false, ...(intent ? { intent } : {}) };
-    for (const file of app.repo.changedFiles(worktreeBefore, reviewBase)) safePath(task.worktree, file);
+    for (const file of await app.repo.changedFilesAsync(worktreeBefore, reviewBase)) safePath(task.worktree, file);
     // Keep the three versions available to the agent and across Git GC.
     for (const [kind, rev] of Object.entries({ original: sourceBase, proposed: task.accepted, current: base, before: worktreeBefore, review: reviewBase }))
-      app.repo.updateRef(`refs/latex-review/${name}/merge/${data.id}/${kind}`, rev);
+      await app.repo.updateRefAsync(`refs/latex-review/${name}/merge/${data.id}/${kind}`, rev);
     app.store.execute("INSERT OR REPLACE INTO reconciliations(task,data) VALUES(?,?)", name, JSON.stringify(data));
     return this.prepare(name, data);
   }
-  prepare(name: string, data: Reconciliation) {
+  async prepare(name: string, data: Reconciliation) {
     if (data.ready) return data;
     const app = this.app, task = app.tasks.get(name);
-    const files = app.repo.changedFiles(data.worktreeBefore, data.reviewBase);
-    const before = app.repo.blobs(data.worktreeBefore, files), after = app.repo.blobs(data.reviewBase, files);
+    const files = await app.repo.changedFilesAsync(data.worktreeBefore, data.reviewBase);
+    const [before, after] = await Promise.all([app.repo.blobsAsync(data.worktreeBefore, files), app.repo.blobsAsync(data.reviewBase, files)]);
     const writes = files.map(file => ({ file, path: safePath(task.worktree, file) }));
     for (const write of writes) {
       const current = readBytes(write.path);
@@ -81,21 +82,22 @@ export class Reconciliations {
     }
     let scope = task.scope;
     if (scope.sections.length) {
-      const outline = buildOutline(revisionReader(app.repo, data.reviewBase, app.project.doc_dir), app.project.main);
+      const outline = buildOutline(await revisionReaderAsync(app.repo, data.reviewBase, app.project.doc_dir), app.project.main);
       const [ranges, sections] = selectedRanges(outline.nodes, resolveSections(outline.nodes, scope.sections.map(section => section.id.replace(/^label:/, ""))));
       scope = { ranges, sections, paths: Object.keys(ranges).sort() };
     }
     for (const write of writes) writeOrDelete(write.path, after[write.file]);
-    app.repo.updateRef(`refs/latex-review/${name}/base`, data.reviewBase);
-    app.repo.updateRef(`refs/latex-review/${name}/accepted`, data.reviewBase);
+    await app.repo.updateRefAsync(`refs/latex-review/${name}/base`, data.reviewBase);
+    await app.repo.updateRefAsync(`refs/latex-review/${name}/accepted`, data.reviewBase);
     app.store.transaction(() => {
       app.store.execute("UPDATE tasks SET base=?,accepted=?,scope=? WHERE name=?", data.reviewBase, data.reviewBase, JSON.stringify(scope), name);
       app.store.execute("UPDATE reconciliations SET data=? WHERE task=?", JSON.stringify({ ...data, ready: true }), name);
     });
     return { ...data, ready: true };
   }
-  recover() {
+  // At start, before any other write.
+  async recover() {
     for (const row of this.app.store.all<{ task: string; data: Reconciliation }>("SELECT * FROM reconciliations"))
-      if (!row.data.ready) try { this.prepare(row.task, row.data); } catch { /* Retry without overwriting intervening edits. */ }
+      if (!row.data.ready) try { await this.prepare(row.task, row.data); } catch { /* Retry without overwriting intervening edits. */ }
   }
 }

package/engine/src/core/review.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { applyUnits, revertUnits } from "./changes.ts";
 import { now, readBytes, readJson, same, writeOrDelete } from "./files.ts";
-import { cleanPath, merge3 } from "./git.ts";
+import { cleanPath, merge3Async } from "./git.ts";
 import type { App } from "../server.ts";
 import type {
   Action,
@@ -293,6 +293,9 @@ export class Review {
       loose: render.loose,
       warnings: round.summary.warnings ?? [],
       files: `/files/${name}/${number}/`,
+      ...(round.summary.builds?.length
+        ? { build: { key: round.summary.builds.at(-1)!, targets: round.summary.targets ?? ["full"] } }
+        : {}),
       ...(render.references ? { references: render.references } : {}),
     };
   }
@@ -386,6 +389,8 @@ export class Review {
       warnings: this.latestRound(name)?.summary.warnings ?? [],
     };
   }
+  /** Accepts, rejects or comments on changes of the latest round. Runs after
+   *  every other write of the review engine, never beside one. */
   decide(
     name: string,
     data: {
@@ -395,6 +400,18 @@ export class Review {
       round: number;
       body?: string;
     },
+  ) {
+    return this.app.exclusive(() => this.decideNow(name, data));
+  }
+  private async decideNow(
+    name: string,
+    data: {
+      action: ActionKind;
+      id?: string;
+      changes: string[];
+      round: number;
+      body?: string;
+    },
   ) {
     const task = this.app.tasks.get(name),
       kind = data.action;
@@ -443,8 +460,8 @@ export class Review {
     if (body.length > 20000)
       throw new Error("Comments are limited to 20,000 characters.");
     const selected = chosen.map((c) => latest.units.find((u) => u.id === c)!);
-    if (kind === "accept") this.accept(task, latest, identity, selected);
-    else if (kind === "reject") this.reject(task, latest, identity, selected);
+    if (kind === "accept") await this.accept(task, latest, identity, selected);
+    else if (kind === "reject") await this.reject(task, latest, identity, selected);
     else
       this.app.store.transaction(() => {
         this.record(
@@ -470,22 +487,20 @@ export class Review {
     for (const unit of units) (groups[unit.file] ??= []).push(unit);
     return groups;
   }
-  accept(task: Task, round: Round, identity: string, units: Unit[]) {
+  private async accept(task: Task, round: Round, identity: string, units: Unit[]) {
     const app = this.app,
       writes: [string, Buffer | null, Buffer | null][] = [],
       accepted: Record<string, Buffer | null> = {},
       conflicts: string[] = [],
       groups = this.byFile(units),
       files = Object.keys(groups),
-      before = app.repo.blobs(round.before, files),
-      after = app.repo.blobs(round.after, files),
-      records = app.repo.blobs(task.accepted, files);
+      [before, after, records] = await Promise.all([round.before, round.after, task.accepted].map((rev) => app.repo.blobsAsync(rev, files)));
     for (const [file, group] of Object.entries(groups)) {
       const proposed = applyUnits(before[file], after[file], group),
         target = task.deferred ? "" : safePath(app.root, file),
         current = task.deferred ? records[file] : readBytes(target),
-        [merged, conflict] = merge3(current, before[file], proposed),
-        [recorded, recordedConflict] = merge3(
+        [merged, conflict] = await merge3Async(current, before[file], proposed),
+        [recorded, recordedConflict] = await merge3Async(
           records[file],
           before[file],
           proposed,
@@ -498,7 +513,7 @@ export class Review {
       throw new Conflict(
         `${units.map((u) => u.id).join(", ")} can't be applied: ${conflicts.join(", ")} changed in your manuscript since this round was published. Nothing was written. Comment on the change to have the agent redo it.`,
       );
-    const afterCommit = app.repo.commitWith(
+    const afterCommit = await app.repo.commitWithAsync(
       task.accepted,
       accepted,
       "latex-review: accept " + units.map((u) => u.id).join(", "),
@@ -513,20 +528,19 @@ export class Review {
       { accepted_before: task.accepted, accepted_after: afterCommit },
       writes,
     );
-    this.carryOut(identity, "apply");
+    await this.carryOut(identity, "apply");
   }
-  reject(task: Task, round: Round, identity: string, units: Unit[]) {
+  private async reject(task: Task, round: Round, identity: string, units: Unit[]) {
     const writes: [string, Buffer | null, Buffer | null][] = [],
       kept: string[] = [],
       groups = this.byFile(units),
       files = Object.keys(groups),
-      before = this.app.repo.blobs(round.before, files),
-      after = this.app.repo.blobs(round.after, files);
+      [before, after] = await Promise.all([this.app.repo.blobsAsync(round.before, files), this.app.repo.blobsAsync(round.after, files)]);
     for (const [file, group] of Object.entries(groups)) {
       const reverted = revertUnits(before[file], after[file], group),
         target = safePath(task.worktree, file),
         current = readBytes(target),
-        [merged, conflict] = merge3(current, after[file], reverted);
+        [merged, conflict] = await merge3Async(current, after[file], reverted);
       if (conflict) kept.push(file);
       else if (!same(merged, current)) writes.push([target, current, merged]);
     }
@@ -540,7 +554,7 @@ export class Review {
       { not_reverted: kept },
       writes,
     );
-    this.carryOut(identity, "apply");
+    await this.carryOut(identity, "apply");
   }
   record(
     identity: string,
@@ -601,7 +615,7 @@ export class Review {
       if (!same(current.get(row.path)!, row.target))
         writeOrDelete(row.path, row.target);
   }
-  carryOut(identity: string, phase: Write["phase"]) {
+  private async carryOut(identity: string, phase: Write["phase"]) {
     try {
       this.perform(identity, phase);
     } catch (error) {
@@ -629,9 +643,9 @@ export class Review {
       });
       throw error;
     }
-    this.complete(identity);
+    await this.complete(identity);
   }
-  complete(identity: string) {
+  private async complete(identity: string) {
     const app = this.app,
       action = app.store.one<Action>(
         "SELECT * FROM actions WHERE id=?",
@@ -674,7 +688,7 @@ export class Review {
       }
     });
     if (action.kind === "accept")
-      app.repo.updateRef(
+      await app.repo.updateRefAsync(
         `refs/latex-review/${action.task}/accepted`,
         accepted!,
       );
@@ -713,7 +727,11 @@ export class Review {
     );
     return this.pageState(name);
   }
+  /** Undoes the latest decision, after every other write of the engine. */
   undo(name: string, identity: string) {
+    return this.app.exclusive(() => this.undoNow(name, identity));
+  }
+  private async undoNow(name: string, identity: string) {
     this.app.delivery.assertReady(name);
     const app = this.app,
       task = app.tasks.get(name),
@@ -734,7 +752,7 @@ export class Review {
       identity,
     )) {
       const current = readBytes(write.path),
-        [restored, conflict] = merge3(current, write.target, write.expected);
+        [restored, conflict] = await merge3Async(current, write.target, write.expected);
       if (conflict) conflicts.push(write.path);
       else if (!same(restored, current))
         restores.push([write.path, current, restored]);
@@ -757,15 +775,16 @@ export class Review {
           target,
         );
     });
-    this.carryOut(identity, "undo");
+    await this.carryOut(identity, "undo");
     return { ...this.pageState(name), restored: action.changes };
   }
-  recover() {
+  // At start, before any other write.
+  async recover() {
     for (const action of this.app.store.all<Action>(
       "SELECT * FROM actions WHERE status IN ('applying','undoing') ORDER BY seq",
     )) {
       try {
-        this.carryOut(
+        await this.carryOut(
           action.id,
           action.status === "applying" ? "apply" : "undo",
         );