papilot 0.8.5 → 0.8.7

package/engine/src/core/changes.ts

@@ -20,10 +20,27 @@ export function diffUnits(
   after: string,
   isFigure: (p: string) => boolean = () => false,
 ): Unit[] {
-  const files = repo.changedFiles(before, after),
-    oldBlobs = repo.blobs(before, files),
-    newBlobs = repo.blobs(after, files),
-    units: Unit[] = [];
+  const files = repo.changedFiles(before, after);
+  return unitsOf(files, repo.blobs(before, files), repo.blobs(after, files), isFigure);
+}
+/** `diffUnits` for servers, which keep answering requests meanwhile. */
+export async function diffUnitsAsync(
+  repo: Repo,
+  before: string,
+  after: string,
+  isFigure: (p: string) => boolean = () => false,
+): Promise<Unit[]> {
+  const files = await repo.changedFilesAsync(before, after),
+    [old, next] = await Promise.all([repo.blobsAsync(before, files), repo.blobsAsync(after, files)]);
+  return unitsOf(files, old, next, isFigure);
+}
+function unitsOf(
+  files: string[],
+  oldBlobs: Record<string, Buffer | null>,
+  newBlobs: Record<string, Buffer | null>,
+  isFigure: (p: string) => boolean,
+): Unit[] {
+  const units: Unit[] = [];
   for (const file of files) {
     const old = oldBlobs[file],
       next = newBlobs[file],
@@ -159,15 +176,27 @@ export function scopeViolations(
   scope: Scope,
 ) {
   const files = repo.changedFiles(base, revision);
-  if (scope.ranges === null)
-    return files.filter((f) => !within(f, scope.paths));
-  const old = repo.blobs(base, files),
-    next = repo.blobs(revision, files),
-    violations: string[] = [];
+  if (scope.ranges === null) return files.filter((f) => !within(f, scope.paths));
+  return violationsOf(files, repo.blobs(base, files), repo.blobs(revision, files), scope);
+}
+/** `scopeViolations` for servers, which keep answering requests meanwhile. */
+export async function scopeViolationsAsync(repo: Repo, base: string, revision: string, scope: Scope) {
+  const files = await repo.changedFilesAsync(base, revision);
+  if (scope.ranges === null) return files.filter((f) => !within(f, scope.paths));
+  const [old, next] = await Promise.all([repo.blobsAsync(base, files), repo.blobsAsync(revision, files)]);
+  return violationsOf(files, old, next, scope);
+}
+function violationsOf(
+  files: string[],
+  old: Record<string, Buffer | null>,
+  next: Record<string, Buffer | null>,
+  scope: Scope,
+) {
+  const violations: string[] = [];
   for (const file of files) {
     const a = textOf(old[file]),
       b = textOf(next[file]),
-      allowed = scope.ranges[file];
+      allowed = scope.ranges?.[file];
     if (!allowed || old[file] === null || a === null || b === null) {
       violations.push(file);
       continue;

package/engine/src/core/config.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { Repo, cleanPath, within } from "./git.ts";
+import { Repo, cleanPath, gitDirOf, within } from "./git.ts";
 export const CONFIG_NAME = ".latex-review.json";
 export const ENGINES = ["pdflatex", "xelatex", "lualatex"] as const;
 type Engine = (typeof ENGINES)[number];
@@ -244,7 +244,7 @@ export function loadProject(root: string): Project {
     throw new Error('"build_workers" must be an integer between 1 and 8.');
   return {
     root,
-    state: path.join(new Repo(root).gitDir(), "latex-review"),
+    state: path.join(gitDirOf(root), "latex-review"),
     main,
     doc_dir,
     engine: engine as Engine,

package/engine/src/core/current-commit.ts

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import type { Repo } from "./git.ts";
-import { merge3 } from "./git.ts";
+import { merge3Async } from "./git.ts";
 import type { Delivery } from "../types.ts";
 
 export interface CombinedCommitReview { token: string; files: string[]; diff: string }
@@ -13,35 +13,35 @@ export class CommitNeedsReview extends Error {
 
 // Project only the task delta onto HEAD. The worktree and staging area are
 // separate destinations: neither is used as the content of the commit.
-export function planCurrentCommit(repo: Repo, data: Delivery, before: string, files: string[], message: string, confirmation?: string) {
-  const ref = repo.text(["symbolic-ref", "-q", "HEAD"], { check: false });
+export async function planCurrentCommit(repo: Repo, data: Delivery, before: string, files: string[], message: string, confirmation?: string) {
+  const ref = await repo.textAsync(["symbolic-ref", "-q", "HEAD"], { check: false });
   if (!ref.startsWith("refs/heads/")) throw new Error("Open a branch to commit this task, or apply it without committing.");
-  const parent = repo.rev("HEAD"), index = repo.text(["write-tree"]);
-  const base = repo.blobs(before, files), accepted = repo.blobs(data.accepted, files), head = repo.blobs(parent, files), staged = repo.blobs(index, files);
+  const [parent, index] = await Promise.all([repo.revAsync("HEAD"), repo.textAsync(["write-tree"])]);
+  const [base, accepted, head, staged] = await Promise.all([before, data.accepted, parent, index].map((rev) => repo.blobsAsync(rev, files)));
   const committed: Record<string, Buffer | null> = {}, nextIndex: Record<string, Buffer | null> = {};
   const dependencies: string[] = [];
   for (const file of files) {
-    let [content, conflict] = merge3(head[file], base[file], accepted[file]);
+    let [content, conflict] = await merge3Async(head[file], base[file], accepted[file]);
     if (conflict) {
       // Include only the overlapping earlier passages, never the whole dirty
       // file. This is a proposal until the author confirms its exact diff.
-      [content, conflict] = merge3(accepted[file], base[file], head[file], true);
+      [content, conflict] = await merge3Async(accepted[file], base[file], head[file], true);
       if (conflict) throw new Error(`The earlier changes in ${file} cannot be included automatically. Apply to workspace to save your reviewed result without a commit.`);
       dependencies.push(file);
     }
-    let [combined, indexConflict] = merge3(staged[file], head[file], content);
-    if (indexConflict && dependencies.includes(file) && !merge3(staged[file], base[file], accepted[file])[1])
-      [combined, indexConflict] = merge3(content, head[file], staged[file], true);
+    let [combined, indexConflict] = await merge3Async(staged[file], head[file], content);
+    if (indexConflict && dependencies.includes(file) && !(await merge3Async(staged[file], base[file], accepted[file]))[1])
+      [combined, indexConflict] = await merge3Async(content, head[file], staged[file], true);
     if (indexConflict) throw new Error(`A different version of ${file} is already selected for another commit. Apply to workspace to save this result without changing that selection.`);
     committed[file] = content;
     nextIndex[file] = combined;
   }
-  const tree = repo.treeWith(parent, committed);
-  if (tree === repo.treeId(parent)) throw new Error("These changes are already in the current commit. Apply without committing to finish this task.");
+  const tree = await repo.treeWithAsync(parent, committed);
+  if (tree === await repo.treeIdAsync(parent)) throw new Error("These changes are already in the current commit. Apply without committing to finish this task.");
   if (dependencies.length || confirmation) {
     const token = createHash("sha256").update(JSON.stringify([ref, parent, index, before, data.accepted, tree, data.writes])).digest("hex");
     if (confirmation !== token) {
-      const diff = repo.text(["diff", "--no-ext-diff", "--no-textconv", parent, tree, "--"]);
+      const diff = await repo.textAsync(["diff", "--no-ext-diff", "--no-textconv", parent, tree, "--"]);
       if (diff.length > 500000) throw new Error("The combined changes are too large to preview here. Apply to workspace and review them in Git before committing.");
       throw new CommitNeedsReview({ token, files: dependencies, diff });
     }
@@ -49,56 +49,56 @@ export function planCurrentCommit(repo: Repo, data: Delivery, before: string, fi
   data.branch = ref.slice("refs/heads/".length);
   data.parent = parent;
   data.indexBefore = index;
-  data.indexAfter = repo.treeWith(index, nextIndex);
-  data.commit = repo.text(["commit-tree", tree, "-p", parent, "-m", message.trim()]);
+  data.indexAfter = await repo.treeWithAsync(index, nextIndex);
+  data.commit = await repo.textAsync(["commit-tree", tree, "-p", parent, "-m", message.trim()]);
 }
 
 // Hold Git's index lock while checking and installing the recorded result.
 // CAS on the branch prevents updating the wrong or concurrently moved HEAD.
 // A retry recognizes our commit and completes its files/index without a
 // duplicate commit. Unrelated staged entries (including their flags) survive.
-export function finishCurrentCommit(repo: Repo, data: Delivery, validateFiles: () => void, writeFiles: () => void) {
-  const index = path.resolve(repo.root, repo.text(["rev-parse", "--git-path", "index"]));
+export async function finishCurrentCommit(repo: Repo, data: Delivery, validateFiles: () => void, writeFiles: () => void) {
+  const index = path.resolve(repo.root, await repo.textAsync(["rev-parse", "--git-path", "index"]));
   const lock = index + ".lock";
-  let fd: number;
-  try { fd = fs.openSync(lock, "wx", fs.existsSync(index) ? fs.statSync(index).mode & 0o777 : 0o644); }
+  let handle: fs.promises.FileHandle;
+  try { handle = await fs.promises.open(lock, "wx", fs.existsSync(index) ? fs.statSync(index).mode & 0o777 : 0o644); }
   catch (error) {
     if ((error as NodeJS.ErrnoException).code === "EEXIST") throw new Error("Another Git operation is using the staging area. Wait for it to finish, then retry.");
     throw error;
   }
   let temp: string | undefined;
   try {
-    temp = fs.mkdtempSync(path.join(os.tmpdir(), "papilot-task-index-"));
+    temp = await fs.promises.mkdtemp(path.join(os.tmpdir(), "papilot-task-index-"));
     const ref = `refs/heads/${data.branch}`;
-    if (repo.text(["symbolic-ref", "-q", "HEAD"], { check: false }) !== ref)
+    if (await repo.textAsync(["symbolic-ref", "-q", "HEAD"], { check: false }) !== ref)
       throw new Error("The current branch changed. Return to the original branch before retrying this task commit.");
-    const head = repo.rev("HEAD");
+    const head = await repo.revAsync("HEAD");
     if (head !== data.parent && head !== data.commit)
       throw new Error("The current branch moved during this task commit. Nothing else was changed; inspect the Git history before retrying.");
     const target = path.join(temp, "index");
-    fs.copyFileSync(index, target);
+    await fs.promises.copyFile(index, target);
     const env = { ...process.env, GIT_INDEX_FILE: target };
-    const currentIndex = repo.text(["write-tree"], { env });
+    const currentIndex = await repo.textAsync(["write-tree"], { env });
     if (currentIndex !== data.indexBefore && currentIndex !== data.indexAfter)
       throw new Error("The staged changes changed during this task commit. Nothing else was changed; restore the previous staging selection before retrying.");
     validateFiles();
     if (currentIndex !== data.indexAfter) {
-      const changed = repo.changedFiles(data.indexBefore!, data.indexAfter!);
+      const changed = await repo.changedFilesAsync(data.indexBefore!, data.indexAfter!);
       for (const file of changed) {
-        const blob = repo.blob(data.indexAfter!, file);
-        if (blob === null) repo.run(["update-index", "--force-remove", "--", file], { env });
-        else repo.run(["update-index", "--add", "--cacheinfo", `${repo.mode(data.indexAfter!, file)},${repo.hashObject(blob)},${file}`], { env });
+        const blob = await repo.blobAsync(data.indexAfter!, file);
+        if (blob === null) await repo.runAsync(["update-index", "--force-remove", "--", file], { env });
+        else await repo.runAsync(["update-index", "--add", "--cacheinfo", `${await repo.modeAsync(data.indexAfter!, file)},${await repo.hashObjectAsync(blob)},${file}`], { env });
       }
     }
-    if (repo.text(["write-tree"], { env }) !== data.indexAfter) throw new Error("Could not prepare the task's staging result.");
-    fs.writeFileSync(fd, fs.readFileSync(target));
-    fs.fsyncSync(fd);
-    if (head !== data.commit) repo.run(["update-ref", "-m", "Papilot: commit reviewed task", ref, data.commit!, data.parent!]);
+    if (await repo.textAsync(["write-tree"], { env }) !== data.indexAfter) throw new Error("Could not prepare the task's staging result.");
+    await handle.writeFile(await fs.promises.readFile(target));
+    await handle.sync();
+    if (head !== data.commit) await repo.runAsync(["update-ref", "-m", "Papilot: commit reviewed task", ref, data.commit!, data.parent!]);
     writeFiles();
     fs.renameSync(lock, index);
   } finally {
-    fs.closeSync(fd);
+    await handle.close();
     fs.rmSync(lock, { force: true });
-    if (temp) fs.rmSync(temp, { recursive: true, force: true });
+    if (temp) await fs.promises.rm(temp, { recursive: true, force: true });
   }
 }

package/engine/src/core/delivery.ts

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import type { App } from "../server.ts";
 import type { Delivery } from "../types.ts";
-import { merge3 } from "./git.ts";
+import { merge3Async } from "./git.ts";
+import { applyUnits } from "./changes.ts";
 import { readBytes, same, writeOrDelete } from "./files.ts";
 import { planCurrentCommit, finishCurrentCommit, CommitNeedsReview } from "./current-commit.ts";
 import { safePath } from "./review.ts";
@@ -23,11 +24,57 @@ export class Deliveries {
   save(name: string, data: Delivery) {
     this.app.store.execute("INSERT OR REPLACE INTO deliveries(task,data) VALUES(?,?)", name, JSON.stringify(data));
   }
+  /** What applying this task to the manuscript would write, if every change
+   *  still pending in its latest round were accepted first: the new contents
+   *  of each file it changes, merged with the files on disk exactly as an
+   *  application merges them. Null while the result cannot be foreseen: a
+   *  delivery or merge review is in progress, or a file would conflict. */
+  async preview(name: string): Promise<Record<string, Buffer | null> | null> {
+    const app = this.app, task = app.tasks.get(name), last = this.get(name), reconciliation = app.reconciliation.get(name);
+    if (!task.deferred || (last && !last.done) || (reconciliation && !reconciliation.ready) || app.publisher.busy(name)) return null;
+    const before = reconciliation?.base ?? (last && last.mode !== "branch" ? last.accepted : task.base);
+    // The latest round's pending changes, accepted onto the accepted text.
+    let accepted = task.accepted;
+    const round = app.review.latestRound(name);
+    if (round) {
+      const decisions = app.review.decisions(name, round), groups: Record<string, typeof round.units> = {};
+      for (const unit of round.units) if (decisions[unit.id] === "pending") (groups[unit.file] ??= []).push(unit);
+      const files = Object.keys(groups);
+      if (files.length) {
+        const [old, next, records] = await Promise.all([round.before, round.after, task.accepted].map((rev) => app.repo.blobsAsync(rev, files)));
+        const contents: Record<string, Buffer | null> = {};
+        for (const file of files) {
+          const [merged, conflict] = await merge3Async(records[file], old[file], applyUnits(old[file], next[file], groups[file]));
+          if (conflict) return null;
+          contents[file] = merged;
+        }
+        accepted = await app.repo.treeWithAsync(task.accepted, contents);
+      }
+    }
+    const files = await app.repo.changedFilesAsync(before, accepted);
+    const [base, result] = await Promise.all([app.repo.blobsAsync(before, files), app.repo.blobsAsync(accepted, files)]);
+    const writes: Record<string, Buffer | null> = {};
+    for (const file of files) {
+      const current = await fs.promises.readFile(safePath(app.root, file)).catch((error) => {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+        throw error;
+      });
+      const [merged, conflict] = await merge3Async(current, base[file], result[file]);
+      if (conflict) return null;
+      writes[file] = merged;
+    }
+    return writes;
+  }
   assertReady(name: string) {
     const last = this.get(name);
     if (last && !last.done) throw new Error("Finish the pending delivery before changing this review. Retry the same destination.");
   }
+  /** Applies the task to the manuscript, with or without a commit. Runs
+   *  after every other write of the review engine, never beside one. */
   apply(name: string, keepCurrent = false, mode?: "workspace" | "commit", message?: string, confirmation?: string) {
+    return this.app.exclusive(() => this.applyNow(name, keepCurrent, mode, message, confirmation));
+  }
+  private async applyNow(name: string, keepCurrent = false, mode?: "workspace" | "commit", message?: string, confirmation?: string) {
     const active = this.app.reconciliation.get(name);
     mode ??= active?.intent?.mode ?? "workspace";
     message ??= active?.intent?.message ?? "";
@@ -35,27 +82,31 @@ export class Deliveries {
     if (mode === "commit" && (!message.trim() || message.length > 5000)) throw new Error("Write a commit message (at most 5,000 characters).");
     const last = this.get(name);
     if (last && !last.done) {
-      const delivery = this.finish(name, last);
+      const delivery = await this.finish(name, last);
       if (last.mode !== "branch") return { delivery };
     }
     if (keepCurrent) {
       const task = this.app.tasks.get(name);
-      if (!active?.ready || task.accepted !== active.reviewBase || this.app.repo.changedFiles(task.accepted, this.app.tasks.snapshot(task)).length)
+      if (!active?.ready || task.accepted !== active.reviewBase || (await this.app.repo.changedFilesAsync(task.accepted, await this.app.tasks.snapshotAsync(task))).length)
         throw new Error("Review the merge suggestion before applying it, or ask the agent to keep the latest wording.");
     }
     if (active) this.app.reconciliation.intent(name, { mode, message });
     if (!keepCurrent && active && (!active.ready || (this.app.review.latestRound(name)?.number ?? 0) <= active.round))
-      return { reconciliation: this.app.reconciliation.prepare(name, this.app.reconciliation.get(name)!) };
-    try { return { delivery: this.deliver(name, mode, message, keepCurrent, confirmation) }; }
+      return { reconciliation: await this.app.reconciliation.prepare(name, this.app.reconciliation.get(name)!) };
+    try { return { delivery: await this.deliverNow(name, mode, message, keepCurrent, confirmation) }; }
     catch (error) {
       if (error instanceof CommitNeedsReview) return { commitReview: error.review };
       if (!(error instanceof DeliveryConflict)) throw error;
-      const reconciliation = this.app.reconciliation.start(name, keepCurrent, { mode, message });
+      const reconciliation = await this.app.reconciliation.start(name, keepCurrent, { mode, message });
       if (reconciliation) return { reconciliation };
-      return { delivery: this.deliver(name, mode, message, keepCurrent, confirmation) };
+      return { delivery: await this.deliverNow(name, mode, message, keepCurrent, confirmation) };
     }
   }
+  /** Delivers the accepted changes to the working directory or a task branch. */
   deliver(name: string, mode: Delivery["mode"], message = "", keepCurrent = false, confirmation?: string) {
+    return this.app.exclusive(() => this.deliverNow(name, mode, message, keepCurrent, confirmation));
+  }
+  private async deliverNow(name: string, mode: Delivery["mode"], message = "", keepCurrent = false, confirmation?: string) {
     const app = this.app, task = app.tasks.get(name), last = this.get(name);
     if (!task.deferred) throw new Error("This task already applies accepted changes to the manuscript.");
     if (mode !== "workspace" && mode !== "commit" && mode !== "branch") throw new Error("Choose a working directory or task branch.");
@@ -69,9 +120,9 @@ export class Deliveries {
     if (last && last.mode === mode && (!last.done || (!reconciliation && last.accepted === task.accepted))) return this.finish(name, last);
     if (app.publisher.busy(name) || app.review.counts(name).pending) throw new Error("Finish reviewing every change before choosing a destination.");
     const before = reconciliation?.base ?? (last && last.mode !== "branch" ? last.accepted : task.base);
-    const files = app.repo.changedFiles(before, task.accepted);
+    const files = await app.repo.changedFilesAsync(before, task.accepted);
     if (!files.length && !reconciliation) throw new Error("This task has no accepted changes left to deliver.");
-    const base = app.repo.blobs(before, files), accepted = app.repo.blobs(task.accepted, files);
+    const [base, accepted] = await Promise.all([app.repo.blobsAsync(before, files), app.repo.blobsAsync(task.accepted, files)]);
     const data: Delivery = { mode, accepted: task.accepted, seq: app.store.one<{ seq: number }>("SELECT MAX(seq) AS seq FROM actions WHERE task=?", name)!.seq, done: false, writes: [] };
     const contents: Record<string, Buffer | null> = {};
     let current: Record<string, Buffer | null>;
@@ -81,50 +132,51 @@ export class Deliveries {
       data.previous = last?.commit;
       // The base snapshot may include the author's uncommitted edits. Apply
       // only the accepted delta onto its original HEAD, never commit those edits.
-      data.parent = last?.commit ?? app.repo.rev(`${task.base}^`);
-      current = app.repo.blobs(data.parent, files);
-      const ref = app.repo.text(["show-ref", "--verify", "--hash", `refs/heads/${data.branch}`], { check: false });
+      data.parent = last?.commit ?? await app.repo.revAsync(`${task.base}^`);
+      current = await app.repo.blobsAsync(data.parent, files);
+      const ref = await app.repo.textAsync(["show-ref", "--verify", "--hash", `refs/heads/${data.branch}`], { check: false });
       if (ref !== (data.previous ?? "")) throw new Error("The task branch was changed outside Papilot. Nothing was committed.");
-      this.assertBranchAvailable(data.branch);
+      await this.assertBranchAvailable(data.branch);
     } else {
-      this.assertNoMerge();
+      await this.assertNoMerge();
       current = Object.fromEntries(files.map(file => [file, readBytes(safePath(app.root, file))]));
     }
     for (const file of files) {
-      const [merged, conflict] = merge3(current[file], base[file], accepted[file]);
+      const [merged, conflict] = await merge3Async(current[file], base[file], accepted[file]);
       if (conflict) throw new DeliveryConflict(`Cannot deliver ${file}: it conflicts with the destination. Nothing was written. Revise the task and try again.`);
       contents[file] = merged;
       if (mode !== "branch" && !same(current[file], merged)) data.writes.push({ file, before: encode(current[file]), after: encode(merged) });
     }
     if (mode === "branch") {
-      const tree = app.repo.treeWith(data.parent!, contents);
-      data.commit = app.repo.text(["commit-tree", tree, "-p", data.parent!, "-m", message.trim()]);
+      const tree = await app.repo.treeWithAsync(data.parent!, contents);
+      data.commit = await app.repo.textAsync(["commit-tree", tree, "-p", data.parent!, "-m", message.trim()]);
     }
     if (mode === "commit" && (!message.trim() || message.length > 5000)) throw new Error("Write a commit message (at most 5,000 characters).");
-    if (mode === "commit") planCurrentCommit(app.repo, data, before, files, message, confirmation);
+    if (mode === "commit") await planCurrentCommit(app.repo, data, before, files, message, confirmation);
     this.save(name, data);
     return this.finish(name, data);
   }
-  private assertBranchAvailable(branch: string) {
-    if (this.app.repo.text(["worktree", "list", "--porcelain"]).split("\n").includes(`branch refs/heads/${branch}`))
+  private async assertBranchAvailable(branch: string) {
+    if ((await this.app.repo.textAsync(["worktree", "list", "--porcelain"])).split("\n").includes(`branch refs/heads/${branch}`))
       throw new Error("The task branch is checked out. Switch that worktree to another branch before committing here.");
   }
-  private assertNoMerge() {
-    if (fs.existsSync(path.resolve(this.app.root, this.app.repo.text(["rev-parse", "--git-path", "MERGE_HEAD"]))))
+  private async assertNoMerge() {
+    if (fs.existsSync(path.resolve(this.app.root, await this.app.repo.textAsync(["rev-parse", "--git-path", "MERGE_HEAD"]))))
       throw new Error("Finish or abort the merge before applying changes.");
   }
-  finish(name: string, data: Delivery) {
+  // Completes a saved delivery. Callers hold the engine's write turn.
+  private async finish(name: string, data: Delivery) {
     if (data.done) { if (data.mode !== "branch") this.app.reconciliation.clear(name); return this.result(data); }
     const app = this.app;
     if (data.mode === "branch") {
       const ref = `refs/heads/${data.branch}`;
-      const current = app.repo.text(["show-ref", "--verify", "--hash", ref], { check: false });
+      const current = await app.repo.textAsync(["show-ref", "--verify", "--hash", ref], { check: false });
       if (current !== data.commit) {
-        this.assertBranchAvailable(data.branch!);
-        app.repo.run(["update-ref", ref, data.commit!, data.previous ?? "0".repeat(data.commit!.length)]);
+        await this.assertBranchAvailable(data.branch!);
+        await app.repo.runAsync(["update-ref", ref, data.commit!, data.previous ?? "0".repeat(data.commit!.length)]);
       }
     } else {
-      this.assertNoMerge();
+      await this.assertNoMerge();
       const writes = data.writes.map(write => ({ ...write, target: safePath(app.root, write.file) }));
       const validate = () => {
         for (const write of writes) {
@@ -134,7 +186,7 @@ export class Deliveries {
         }
       };
       const applyFiles = () => { for (const write of writes) writeOrDelete(write.target, decode(write.after)); };
-      if (data.mode === "commit") finishCurrentCommit(app.repo, data, validate, applyFiles);
+      if (data.mode === "commit") await finishCurrentCommit(app.repo, data, validate, applyFiles);
       else { validate(); applyFiles(); }
     }
     this.save(name, { ...data, done: true, writes: [] });
@@ -145,11 +197,12 @@ export class Deliveries {
     const { mode, accepted, branch, commit } = data;
     return { mode, accepted, ...(branch ? { branch, commit } : {}) };
   }
-  recover() {
+  // At start, before any other write.
+  async recover() {
     for (const row of this.app.store.all<{ task: string; data: Delivery }>("SELECT * FROM deliveries")) {
       if (row.data.done && row.data.mode !== "branch" && this.app.reconciliation.get(row.task) && this.app.tasks.get(row.task).accepted === row.data.accepted)
         this.app.reconciliation.clear(row.task);
-      else if (!row.data.done) try { this.finish(row.task, row.data); } catch { /* Retain the journal for an explicit retry. */ }
+      else if (!row.data.done) try { await this.finish(row.task, row.data); } catch { /* Retain the journal for an explicit retry. */ }
     }
   }
 }

package/engine/src/core/files.ts

@@ -29,6 +29,25 @@ export function atomicWrite(
     fs.rmSync(temporary, { force: true });
   }
 }
+/** `atomicWrite` without blocking the event loop on the disk. */
+export async function atomicWriteAsync(file: string, data: string | Uint8Array) {
+  await fs.promises.mkdir(path.dirname(file), { recursive: true });
+  const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${randomUUID()}.tmp`);
+  try {
+    const handle = await fs.promises.open(temporary, "w");
+    try {
+      await handle.writeFile(data);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await fs.promises.rename(temporary, file);
+  } finally {
+    await fs.promises.rm(temporary, { force: true });
+  }
+}
+export const writeJsonAsync = (file: string, value: unknown) =>
+  atomicWriteAsync(file, JSON.stringify(value, null, 2) + "\n");
 export function readBytes(file: string): Buffer | null {
   try {
     return fs.readFileSync(file);