papilot 0.8.0 → 0.8.2

package/vendor/latex-review/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,42 +270,139 @@ 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(
   ours: Buffer | null,
   base: Buffer | null,
   theirs: Buffer | null,
+  favorCurrent = false,
 ): [Buffer | null, boolean] {
   if (same(ours, base) || same(ours, theirs)) return [theirs, false];
   if (same(theirs, base)) return [ours, false];
@@ -312,7 +418,7 @@ export function merge3(
       path.join(folder, name),
     );
     [ours, base, theirs].forEach((data, i) => fs.writeFileSync(files[i], data));
-    const result = run(gitBinary(), ["merge-file", "-p", ...files], {
+    const result = run(gitBinary(), ["merge-file", "-p", ...(favorCurrent ? ["--ours"] : []), ...files], {
       check: false,
     });
     return [result.stdout, result.status !== 0];

package/vendor/latex-review/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/vendor/latex-review/src/core/publish.ts

@@ -321,6 +321,7 @@ export class Publisher {
     const app = this.app,
       name = job.task,
       project = app.project;
+    if (app.reconciliation.get(name)?.ready === false) throw new Error("Retry applying to finish preparing the merge review.");
     let task = app.tasks.get(name);
     if (!fs.existsSync(task.worktree))
       throw new PublishError(
@@ -335,13 +336,18 @@ export class Publisher {
       latest = app.review.latestRound(name),
       decided = app.review.lastChange(name),
       violations = scopeViolations(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))
+        if (!reconciliation.files.includes(file) && !violations.includes(file)) violations.push(file);
+    }
     if (violations.length)
       throw new PublishError(
         "Some edits are outside the task scope: " +
           violations.slice(0, 10).join(", "),
         [
           "Allowed: " +
-            (task.scope.sections.length
+            (reconciliation ? reconciliation.files : task.scope.sections.length
               ? task.scope.sections.map((s) => `${s.number} ${s.title}`)
               : task.scope.paths
             ).join(", "),

package/vendor/latex-review/src/core/reconcile.ts

@@ -0,0 +1,101 @@
+import { randomUUID } from "node:crypto";
+import type { App } from "../server.ts";
+import { merge3 } from "./git.ts";
+import { readBytes, same, writeOrDelete } from "./files.ts";
+import { safePath } from "./review.ts";
+import { GENERATED, revisionReader } from "./tasks.ts";
+import { buildOutline, resolveSections, selectedRanges } from "./outline.ts";
+
+export interface Reconciliation {
+  id: string;
+  round: number;
+  files: string[];
+  sourceBase: string;
+  sourceAccepted: string;
+  base: string;
+  reviewBase: string;
+  worktreeBefore: string;
+  ready: boolean;
+  intent?: { mode: "workspace" | "commit"; message: string };
+}
+
+// A conflict is another proposal in the same task. The manuscript and its
+// index stay untouched; only the private proposal is rebased for PDF review.
+export class Reconciliations {
+  constructor(public app: App) {}
+  get(name: string) {
+    return this.app.store.one<{ data: Reconciliation }>("SELECT data FROM reconciliations WHERE task=?", name)?.data;
+  }
+  intent(name: string, intent: NonNullable<Reconciliation["intent"]>) {
+    const data = { ...this.get(name)!, intent };
+    this.app.store.execute("UPDATE reconciliations SET data=? WHERE task=?", JSON.stringify(data), name);
+    return data;
+  }
+  clear(name: string) {
+    this.app.store.execute("DELETE FROM reconciliations WHERE task=?", name);
+  }
+  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)
+      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 files: string[] = [], contents: Record<string, Buffer | null> = {};
+    for (const file of changed) {
+      const [merged, conflict] = merge3(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);
+        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 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);
+    // 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);
+    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) {
+    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 writes = files.map(file => ({ file, path: safePath(task.worktree, file) }));
+    for (const write of writes) {
+      const current = readBytes(write.path);
+      if (!same(current, before[write.file]) && !same(current, after[write.file]))
+        throw new Error("The task changed while preparing its merge review. Keep those edits and retry after reviewing them.");
+    }
+    let scope = task.scope;
+    if (scope.sections.length) {
+      const outline = buildOutline(revisionReader(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);
+    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() {
+    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. */ }
+  }
+}

package/vendor/latex-review/src/core/review.ts

@@ -121,8 +121,8 @@ export class Review {
         "SELECT * FROM actions WHERE task=? AND status='applied' ORDER BY seq DESC LIMIT 1",
         name,
       );
-    const delivered = this.app.delivery.get(name);
-    return action && latest && action.round === latest.number && (!delivered || action.seq > delivered.seq) ? action : null;
+    const delivered = this.app.delivery.get(name), reconciliation = this.app.reconciliation.get(name);
+    return action && latest && (!reconciliation || action.round > reconciliation.round) && action.round === latest.number && (!delivered || action.seq > delivered.seq) ? action : null;
   }
   summary(name: string): Summary {
     const task = this.app.tasks.get(name),
@@ -367,6 +367,9 @@ export class Review {
     const task = this.app.tasks.get(name),
       kind = data.action;
     this.app.delivery.assertReady(name);
+    const reconciliation = this.app.reconciliation.get(name);
+    if (reconciliation && (!reconciliation.ready || data.round <= reconciliation.round))
+      throw new Error("Review the new merge suggestion before changing decisions.");
     if (!Object.hasOwn(DECIDED, kind))
       throw new Error("The action must be accept, reject or comment.");
     const identity = data.id || randomUUID();

package/vendor/latex-review/src/core/store.ts

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS tasks(name TEXT PRIMARY KEY,title TEXT NOT NULL,worktree TEXT NOT NULL,base TEXT NOT NULL,accepted TEXT NOT NULL,scope TEXT NOT NULL,created REAL NOT NULL,closed REAL);
+CREATE TABLE IF NOT EXISTS reconciliations(task TEXT PRIMARY KEY,data TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS deliveries(task TEXT PRIMARY KEY,data TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS rounds(task TEXT NOT NULL,number INTEGER NOT NULL,before TEXT NOT NULL,after TEXT NOT NULL,units TEXT NOT NULL,summary TEXT NOT NULL,created REAL NOT NULL,PRIMARY KEY(task,number));
 CREATE TABLE IF NOT EXISTS actions(seq INTEGER PRIMARY KEY AUTOINCREMENT,id TEXT NOT NULL UNIQUE,task TEXT NOT NULL,round INTEGER NOT NULL,kind TEXT NOT NULL,changes TEXT NOT NULL,body TEXT NOT NULL DEFAULT '',status TEXT NOT NULL,detail TEXT NOT NULL DEFAULT '{}',created REAL NOT NULL);

package/vendor/latex-review/src/core/tasks.ts

@@ -155,7 +155,7 @@ export class Tasks {
           name,
         );
         app.store.execute("DELETE FROM tasks WHERE name=?", name);
-        for (const table of ["rounds", "actions", "messages", "jobs", "deliveries"])
+        for (const table of ["rounds", "actions", "messages", "jobs", "deliveries", "reconciliations"])
           app.store.execute(`DELETE FROM ${table} WHERE task=?`, name);
         app.store.execute(
           "INSERT INTO tasks(name,title,worktree,base,accepted,scope,created,deferred) VALUES(?,?,?,?,?,?,?,?)",

package/vendor/latex-review/src/locales.ts

@@ -0,0 +1,47 @@
+// Shared by the workspace and the standalone review viewer.
+export const LANGUAGES = [
+  { id: 'en', name: 'English' },
+  { id: 'zh-Hans', name: '简体中文' },
+  { id: 'zh-Hant', name: '繁體中文' },
+  { id: 'ja', name: '日本語' },
+  { id: 'ko', name: '한국어' },
+  { id: 'de', name: 'Deutsch' },
+  { id: 'fr', name: 'Français' },
+  { id: 'es', name: 'Español' },
+  { id: 'pt', name: 'Português' },
+  { id: 'it', name: 'Italiano' },
+  { id: 'sv', name: 'Svenska' },
+] as const;
+
+export type Language = typeof LANGUAGES[number]['id'];
+
+// Accept older saved choices and regional browser preferences, but expose only
+// the canonical language/script choices in the interface.
+export function supportedLanguage(tag: string | null | undefined): Language | null {
+  if (!tag) return null;
+  try {
+    const locale = new Intl.Locale(tag);
+    if (locale.language === 'zh') return locale.maximize().script === 'Hant' ? 'zh-Hant' : 'zh-Hans';
+    return LANGUAGES.find(item => item.id === locale.language)?.id || null;
+  } catch { return null; }
+}
+
+const rules = new Map<Language, Intl.PluralRules>();
+export function singularCount(language: Language, count: number) {
+  let rule = rules.get(language);
+  if (!rule) { rule = new Intl.PluralRules(language); rules.set(language, rule); }
+  return rule.select(count) === 'one';
+}
+
+const numberFormats = new Map<Language, Intl.NumberFormat>();
+export function interpolateMessage(text: string, language: Language, values?: Record<string, string | number>) {
+  if (!values) return text;
+  return text.replace(/\{(\w+)\}/g, (match, name: string) => {
+    if (!Object.hasOwn(values, name)) return match;
+    const value = values[name];
+    if (typeof value !== 'number') return value;
+    let format = numberFormats.get(language);
+    if (!format) { format = new Intl.NumberFormat(language, { maximumFractionDigits: 20 }); numberFormats.set(language, format); }
+    return format.format(value);
+  });
+}

package/vendor/latex-review/src/server.ts

@@ -10,6 +10,7 @@ import { CONFIG_NAME, loadProject, type Project } from "./core/config.ts";
 import { Store } from "./core/store.ts";
 import { Tasks } from "./core/tasks.ts";
 import { Review } from "./core/review.ts";
+import { Reconciliations } from "./core/reconcile.ts";
 import { Deliveries } from "./core/delivery.ts";
 import { more, PublishError, Publisher } from "./core/publish.ts";
 import { view, type ViewRequest } from "./core/view.ts";
@@ -29,6 +30,7 @@ export class App {
   tasks: Tasks;
   review: Review;
   delivery: Deliveries;
+  reconciliation: Reconciliations;
   publisher: Publisher;
   references: ReferenceChecker;
   confirmations: Confirmations;
@@ -42,6 +44,7 @@ export class App {
     this.tasks = new Tasks(this);
     this.review = new Review(this);
     this.delivery = new Deliveries(this);
+    this.reconciliation = new Reconciliations(this);
     this.publisher = new Publisher(this);
     this.references = new ReferenceChecker(
       path.join(this.state, "references.json"),
@@ -51,6 +54,7 @@ export class App {
     );
     this.review.recover();
     this.delivery.recover();
+    this.reconciliation.recover();
   }
   get project() {
     const config = path.join(this.root, CONFIG_NAME),
@@ -67,11 +71,13 @@ export class App {
   taskInfo(name: string) {
     const task = this.tasks.get(name),
       delivery = this.delivery.get(name),
-      scope = task.scope;
+      reconciliation = this.reconciliation.get(name),
+      scope = reconciliation ? { ...task.scope, paths: reconciliation.files, ranges: null } : task.scope;
     return {
       ...this.review.summary(name),
       deferred: Boolean(task.deferred),
       delivery: delivery ? { ...this.delivery.result(delivery), pending: !delivery.done } : null,
+      reconciliation: reconciliation ?? null,
       worktree: task.worktree,
       url: this.page(name),
       viewing: now() - (this.viewers.get(name) ?? 0) < 15,
@@ -337,6 +343,11 @@ export function createServer(app: App) {
       { schema: { body: { ...objectSchema, additionalProperties: false, properties: { locations: { type: "array", maxItems: 8, items: { type: "string", maxLength: 1000 } }, pages: { type: "array", maxItems: 8, items: { type: "string", maxLength: 40 } }, accepted: { type: "boolean" } } } } },
       (request) => view(app, request.params.name, request.body),
     );
+    server.post<{ Params: { name: string }; Body: { keepCurrent?: boolean; mode?: "workspace" | "commit"; message?: string; confirmation?: string } }>(
+      "/api/tasks/:name/apply",
+      { schema: { body: { ...objectSchema, additionalProperties: false, properties: { confirmation: { type: "string", maxLength: 100 }, keepCurrent: { type: "boolean" }, mode: { enum: ["workspace", "commit"] }, message: { type: "string", maxLength: 5000 } } } } },
+      request => app.delivery.apply(request.params.name, request.body.keepCurrent === true, request.body.mode, request.body.message, request.body.confirmation),
+    );
     server.post<{ Params: { name: string }; Body: { mode: "workspace" | "branch"; message?: string } }>(
       "/api/tasks/:name/deliver",
       { schema: { body: { ...objectSchema, required: ["mode"], properties: { mode: { enum: ["workspace", "branch"] }, message: { type: "string", maxLength: 5000 } } } } },

package/vendor/latex-review/src/types.ts

@@ -50,12 +50,14 @@ export interface Task {
   closed: number | null;
 }
 export interface Delivery {
-  mode: "workspace" | "branch";
+  mode: "workspace" | "commit" | "branch";
   accepted: string;
   seq: number;
   branch?: string;
   commit?: string;
   parent?: string;
+  indexBefore?: string;
+  indexAfter?: string;
   previous?: string;
   done: boolean;
   writes: { file: string; before: string | null; after: string | null }[];
@@ -422,8 +424,9 @@ export interface PageState {
    * and how many manuscript files this task's accepted changes touched.
    */
   workspace?: {
+    merging?: boolean;
     deferred?: boolean;
-    destination?: "workspace" | "branch";
+    destination?: "workspace" | "commit" | "branch";
     status: string;
     unsent: number;
     comments?: number;

package/vendor/latex-review/src/web/i18n.ts

@@ -1,17 +1,9 @@
-import { zhCN } from "./zh-CN.ts";
+import { supportedLanguage, singularCount, interpolateMessage, type Language } from '../locales.ts';
+import { messages } from './locales/index.ts';
+export type { Language };
 
-// The viewer reads in English unless the page asks for another language with
-// ?lang=zh-CN (Papilot passes its interface language). The English text is the
-// message key, so a string without a translation still reads correctly.
-export type Language = "en" | "zh-CN";
-const messages: Record<Language, Record<string, string>> = {
-  en: {},
-  "zh-CN": zhCN,
-};
 export function pageLanguage(search = location.search): Language {
-  return new URLSearchParams(search).get("lang")?.toLowerCase().startsWith("zh")
-    ? "zh-CN"
-    : "en";
+  return supportedLanguage(new URLSearchParams(search).get('lang')) || 'en';
 }
 const current: Language =
   typeof location === "undefined" ? "en" : pageLanguage();
@@ -19,7 +11,7 @@ if (typeof document !== "undefined") document.documentElement.lang = current;
 
 export const language = () => current;
 // Dates and numbers follow the interface language.
-export const locale = () => (current === "zh-CN" ? "zh-CN" : "en-US");
+export const locale = () => current;
 
 // Links inside the viewer keep the page's language.
 export function withLanguage(href: string) {
@@ -30,19 +22,15 @@ export function withLanguage(href: string) {
 
 // t("Change {n}", { n }) fills {placeholders} after translating.
 export function t(text: string, values?: Record<string, string | number>) {
-  const template = messages[current][text] ?? text;
-  return values
-    ? template.replace(/\{(\w+)\}/g, (match, name: string) =>
-        name in values ? String(values[name]) : match,
-      )
-    : template;
+  const template = Object.hasOwn(messages[current], text) ? messages[current][text] : text;
+  return interpolateMessage(template, current, values);
 }
-// English picks between one and other by count; {n} is the count.
+// Select the count form using the active locale; {n} is the count.
 export function tn(
   count: number,
   one: string,
   other: string,
   values?: Record<string, string | number>,
 ) {
-  return t(count === 1 ? one : other, { n: count, ...values });
+  return t(singularCount(current, count) ? one : other, { n: count, ...values });
 }