papilot 0.8.2 → 0.8.4

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

@@ -8,7 +8,8 @@ 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,
@@ -219,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"]';
@@ -270,10 +271,10 @@ export class Builder {
       const start = partial || options.force ? null : this.latest(context) ?? "author";
       let result: BuildInfo;
       try {
-        result = await this.compile(rev, tree, key, targets, seed, date, start);
+        result = await this.compile(rev, tree, key, targets, seed, date, start, options.progress);
       } catch (error) {
         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);
+        result = await this.compile(rev, tree, key, targets, seed, date, null, options.progress);
       }
       if (!partial) writeJson(path.join(this.cache, "latest.json"), { key, context, date: date.SOURCE_DATE_EPOCH });
       return result;
@@ -293,6 +294,7 @@ export class Builder {
     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"]',
@@ -373,14 +375,28 @@ export class Builder {
     args.push(main);
     const transcript = path.join(folder, "latexmk.log"),
       fd = fs.openSync(transcript, "w"),
-      started = now();
+      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),
+        output: (chunk) => {
+          fs.writeSync(fd, chunk);
+          read?.(chunk);
+        },
       });
     } catch (error) {
       failure = error as Error;

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;
+  }
+}

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

@@ -8,6 +8,7 @@ import type { App } from "../server.ts";
 import type {
   Action,
   ActionDetail,
+  BuildInfo,
   ActionKind,
   Decision,
   Feedback,
@@ -54,6 +55,8 @@ export function safePath(root: string, file: string) {
   return target;
 }
 export class Review {
+  // Strip positions recovered for earlier rounds, by round and strip image.
+  private tops = new Map<string, Map<string, number>>();
   constructor(public app: App) {}
   latestRound(name: string) {
     return this.app.store.one<Round>(
@@ -223,6 +226,35 @@ export class Review {
         : null,
     };
   }
+  // The full paper places each change by where its strips start on the page.
+  // Rounds rendered before strips recorded that recover it from the round's
+  // new PDF the first time they are shown.
+  async positioned(detail: RoundDetail): Promise<RoundDetail> {
+    const strips = [...detail.sections.flatMap((s) => s.blocks), ...detail.loose]
+      .flatMap((block) => (block.kind === "change" ? block.after : []))
+      .filter((strip) => strip.top === undefined);
+    if (!strips.length) return detail;
+    const key = `${detail.task}:${detail.round}`;
+    let tops = this.tops.get(key);
+    if (!tops) {
+      tops = new Map();
+      const build = this.round(detail.task, detail.round).summary.builds?.at(-1),
+        info = build
+          ? readJson<BuildInfo | null>(path.join(this.app.state, "cache/builds", build, "result.json"), null)
+          : null;
+      if (info && fs.existsSync(info.pdf)) {
+        const { stripTops } = await import("../render/positions.ts");
+        stripTops(info.pdf, strips);
+        for (const strip of strips) if (strip.top !== undefined) tops.set(strip.src, strip.top);
+      }
+      this.tops.set(key, tops);
+    }
+    for (const strip of strips) {
+      const top = tops.get(strip.src);
+      if (top !== undefined) strip.top = top;
+    }
+    return detail;
+  }
   roundDetail(name: string, number: number): RoundDetail {
     const round = this.round(name, number),
       render = readJson<RenderedRound>(

package/{vendor/latex-review → engine}/src/render/inline.ts

@@ -626,6 +626,7 @@ export class Strips {
       clean,
       width: Math.round(page.width * 100) / 100,
       height: Math.round((bottom - top) * 100) / 100,
+      top: Math.round(top * 100) / 100,
       page: number + 1,
       label: page.label,
       text,

package/{vendor/latex-review → engine}/src/render/locate.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { run } from "../core/process.ts";
 import { argument, buildOutline } from "../core/outline.ts";
+import { SynctexIndex } from "./synctex.ts";
 import { listFiles } from "../core/files.ts";
 import { PdfDocument, type PdfPage, type OutlineEntry } from "./pdf.ts";
 import type {
@@ -47,6 +47,7 @@ export class Build {
   }
   close() {
     this.document.close();
+    this.locator.close();
   }
 }
 export function sourceRange(
@@ -135,29 +136,34 @@ export class Margins {
       : [(this.header ?? 36) + 4, (this.footer ?? page.height - 36) - 4];
   }
 }
+// The CLI prints six decimals with printf, which rounds an exact half to
+// even where toFixed rounds it up; matching it keeps every crop the same as
+// with `synctex view`.
+export function printed(value: number) {
+  const exact = Math.abs(value).toFixed(30),
+    cut = exact.indexOf(".") + 7,
+    kept = exact.slice(0, cut);
+  const magnitude =
+    /^50*$/.test(exact.slice(cut)) && Number(kept.at(-1)) % 2 === 0
+      ? Number(kept)
+      : Number(Math.abs(value).toFixed(6));
+  return value < 0 ? -magnitude : magnitude;
+}
 export class Locator {
   cache = new Map<string, Box[]>();
+  private index: SynctexIndex | null = null;
   constructor(public build: Build) {}
   lookup(file: string, line: number): Box[] {
     const key = `${file}:${line}`;
     if (this.cache.has(key)) return this.cache.get(key)!;
-    const result = run(
-        "synctex",
-        ["view", "-i", `${line}:0:${file}`, "-o", this.build.info.pdf],
-        { check: false },
-      ).stdout.toString(),
-      records: Box[] = [],
+    this.index ??= new SynctexIndex(this.build.info.pdf);
+    const records: Box[] = [],
       shipped = new Set<number>(),
       margins = this.build.margins;
-    for (const block of result.split(/^Page:/m).slice(1)) {
-      const fields = Object.fromEntries(
-          [...block.matchAll(/^(x|y|h|v|W|H):([\d.+-]+)/gm)].map((m) => [
-            m[1],
-            Number(m[2]),
-          ]),
-        ),
-        page = Number(block.split("\n")[0]) - 1,
-        { y, v, H: height } = fields;
+    for (const result of this.index.view(file, line)) {
+      const [number, , y, h, v, W, height] = result.map(printed),
+        page = number - 1,
+        fields = { h, W };
       if (
         ![page, y, v, height].every(Number.isFinite) ||
         y < v - height - 4 ||
@@ -182,6 +188,10 @@ export class Locator {
     this.cache.set(key, filtered);
     return filtered;
   }
+  close() {
+    this.index?.close();
+    this.index = null;
+  }
   boxes(name: string, start: number, end: number) {
     const file = this.build.path(name);
     if (!fs.existsSync(file) || path.extname(file) !== ".tex") return [];

package/engine/src/render/positions.ts

@@ -0,0 +1,34 @@
+import { PdfDocument } from "./pdf.ts";
+import type { Strip } from "../types.ts";
+
+// Where strips start on their page, for rounds rendered before strips
+// recorded it. A strip keeps its characters relative to its top, read from
+// the same PDF page by the same code: the difference between a character's
+// place on the page and in the strip is where the strip starts. A strip
+// without text (a figure alone) stays unplaced.
+export function stripTops(pdf: string, strips: Strip[]) {
+  const document = new PdfDocument(pdf);
+  try {
+    for (const strip of strips) {
+      if (strip.top !== undefined || strip.page < 1 || strip.page > document.length) continue;
+      const page = document.page(strip.page - 1);
+      found: for (const line of strip.text ?? []) {
+        if (line.chars.length < 3) continue;
+        for (const candidate of page.lines)
+          if (
+            candidate.chars.length === line.chars.length &&
+            candidate.chars.every(
+              (char, i) =>
+                char.text === line.chars[i].text &&
+                Math.abs(char.rect[0] - line.chars[i].rect[0]) < 0.01,
+            )
+          ) {
+            strip.top = Math.round((candidate.chars[0].rect[1] - line.chars[0].rect[1]) * 100) / 100;
+            break found;
+          }
+      }
+    }
+  } finally {
+    document.close();
+  }
+}

package/engine/src/render/synctex.ts

@@ -0,0 +1,188 @@
+import fs from "node:fs";
+
+// SyncTeX's own parser (synctex_parser.c with zlib), compiled to WebAssembly
+// by native/synctex/build.sh. `synctex view` parses the whole .synctex.gz
+// again for every query; an index parses it once and answers each forward
+// query from the parser's table of nodes by input file and line, with the
+// values the CLI prints.
+let compiled: WebAssembly.Module | undefined;
+const wasm = () =>
+  (compiled ??= new WebAssembly.Module(
+    fs.readFileSync(new URL("./synctex.wasm", import.meta.url)),
+  ));
+
+interface Exports {
+  memory: WebAssembly.Memory;
+  _initialize?: () => void;
+  st_alloc(size: number): number;
+  st_free(pointer: number): void;
+  st_open(output: number): number;
+  st_close(): void;
+  st_view(input: number, line: number): number;
+  st_results(): number;
+}
+
+// Page (1-based), x, y, h, v, W, H: the fields of a `synctex view` result.
+export type ViewResult = [number, number, number, number, number, number, number];
+
+// The few WASI calls the parser makes, served from JavaScript: it reads the
+// .synctex(.gz) file next to the PDF and prints warnings, nothing else.
+// (Node's own WASI can collect garbage inside fd_read while a WebAssembly
+// frame is on the stack, which crashes V8.)
+const ERRNO = { SUCCESS: 0, ACCES: 2, BADF: 8, INVAL: 28, NOENT: 44, NOTSUP: 58 };
+const ROOT = 3;
+function system(memory: () => WebAssembly.Memory) {
+  const files = new Map<number, { data: Uint8Array; position: number }>();
+  let next = ROOT + 1;
+  const view = () => new DataView(memory().buffer),
+    bytes = () => new Uint8Array(memory().buffer);
+  const vectors = (iovs: number, count: number) =>
+    Array.from({ length: count }, (_, i) => [
+      view().getUint32(iovs + 8 * i, true),
+      view().getUint32(iovs + 8 * i + 4, true),
+    ]);
+  return {
+    environ_sizes_get(count: number, size: number) {
+      view().setUint32(count, 0, true);
+      view().setUint32(size, 0, true);
+      return ERRNO.SUCCESS;
+    },
+    environ_get: () => ERRNO.SUCCESS,
+    // The only preopened directory is the file system root.
+    fd_prestat_get(fd: number, out: number) {
+      if (fd !== ROOT) return ERRNO.BADF;
+      view().setUint8(out, 0);
+      view().setUint32(out + 4, 1, true);
+      return ERRNO.SUCCESS;
+    },
+    fd_prestat_dir_name(fd: number, path: number, length: number) {
+      if (fd !== ROOT || length < 1) return ERRNO.BADF;
+      bytes()[path] = 0x2f;
+      return ERRNO.SUCCESS;
+    },
+    path_open(
+      dir: number,
+      _lookup: number,
+      path: number,
+      length: number,
+      openFlags: number,
+      _rights: bigint,
+      _inherited: bigint,
+      _fdFlags: number,
+      out: number,
+    ) {
+      if (dir !== ROOT) return ERRNO.BADF;
+      if (openFlags !== 0) return ERRNO.ACCES; // read only: no create or truncate
+      const name = "/" + new TextDecoder().decode(bytes().subarray(path, path + length));
+      let data: Uint8Array;
+      try {
+        if (!fs.statSync(name).isFile()) return ERRNO.NOENT;
+        data = fs.readFileSync(name);
+      } catch {
+        return ERRNO.NOENT;
+      }
+      files.set(next, { data, position: 0 });
+      view().setUint32(out, next++, true);
+      return ERRNO.SUCCESS;
+    },
+    fd_fdstat_get(fd: number, out: number) {
+      const type = fd <= 2 ? 2 : fd === ROOT ? 3 : files.has(fd) ? 4 : -1;
+      if (type < 0) return ERRNO.BADF;
+      view().setUint8(out, type);
+      view().setUint16(out + 2, 0, true);
+      view().setBigUint64(out + 8, 0xffffffffffffffffn, true);
+      view().setBigUint64(out + 16, 0xffffffffffffffffn, true);
+      return ERRNO.SUCCESS;
+    },
+    fd_read(fd: number, iovs: number, count: number, out: number) {
+      const file = files.get(fd);
+      if (!file) return fd === 0 ? (view().setUint32(out, 0, true), ERRNO.SUCCESS) : ERRNO.BADF;
+      let read = 0;
+      for (const [at, size] of vectors(iovs, count)) {
+        const chunk = file.data.subarray(file.position, file.position + size);
+        bytes().set(chunk, at);
+        file.position += chunk.length;
+        read += chunk.length;
+        if (chunk.length < size) break;
+      }
+      view().setUint32(out, read, true);
+      return ERRNO.SUCCESS;
+    },
+    fd_seek(fd: number, offset: bigint, whence: number, out: number) {
+      const file = files.get(fd);
+      if (!file) return ERRNO.BADF;
+      const base = whence === 0 ? 0 : whence === 1 ? file.position : whence === 2 ? file.data.length : NaN,
+        position = base + Number(offset);
+      if (!(position >= 0)) return ERRNO.INVAL;
+      file.position = position;
+      view().setBigUint64(out, BigInt(position), true);
+      return ERRNO.SUCCESS;
+    },
+    fd_tell(fd: number, out: number) {
+      const file = files.get(fd);
+      if (!file) return ERRNO.BADF;
+      view().setBigUint64(out, BigInt(file.position), true);
+      return ERRNO.SUCCESS;
+    },
+    // Warnings go nowhere; they carry nothing a result does not.
+    fd_write(fd: number, iovs: number, count: number, out: number) {
+      if (fd > 2) return ERRNO.BADF;
+      view().setUint32(out, vectors(iovs, count).reduce((sum, [, size]) => sum + size, 0), true);
+      return ERRNO.SUCCESS;
+    },
+    fd_close(fd: number) {
+      return files.delete(fd) ? ERRNO.SUCCESS : ERRNO.BADF;
+    },
+    path_rename: () => ERRNO.NOTSUP,
+    proc_exit(code: number) {
+      throw new Error(`SyncTeX index exited with status ${code}`);
+    },
+  };
+}
+
+export class SynctexIndex {
+  private exports: Exports | null;
+  private open: boolean;
+  constructor(pdf: string) {
+    let memory: WebAssembly.Memory | undefined;
+    const instance = new WebAssembly.Instance(wasm(), {
+      wasi_snapshot_preview1: system(() => memory!),
+    });
+    this.exports = instance.exports as unknown as Exports;
+    memory = this.exports.memory;
+    this.exports._initialize?.();
+    const name = this.string(pdf);
+    // Without SyncTeX data the CLI answers every query with no results.
+    this.open = this.exports.st_open(name) !== 0;
+    this.exports.st_free(name);
+  }
+  private string(text: string) {
+    const encoded = new TextEncoder().encode(text + "\0"),
+      at = this.exports!.st_alloc(encoded.length);
+    new Uint8Array(this.exports!.memory.buffer, at, encoded.length).set(encoded);
+    return at;
+  }
+  // What `synctex view -i line:0:input -o pdf` reports, in its order.
+  view(input: string, line: number): ViewResult[] {
+    if (!this.exports || !this.open) return [];
+    const name = this.string(input),
+      count = this.exports.st_view(name, line);
+    this.exports.st_free(name);
+    const rows: ViewResult[] = [];
+    if (count > 0) {
+      const data = new Float64Array(
+        this.exports.memory.buffer,
+        this.exports.st_results(),
+        count * 7,
+      );
+      for (let i = 0; i < count; i++)
+        rows.push(Array.from(data.subarray(i * 7, i * 7 + 7)) as ViewResult);
+    }
+    return rows;
+  }
+  close() {
+    if (!this.exports) return;
+    this.exports.st_close();
+    this.exports = null;
+  }
+}

package/engine/src/render/synctex.wasm.LICENSE

@@ -0,0 +1,50 @@
+synctex.wasm contains SyncTeX's parser (https://github.com/jlaurens/synctex,
+commit a256d4835b7df2a0472cfa3d557af73a1b83f076) and zlib 1.3.1, built by
+native/synctex/build.sh. Their licenses follow.
+
+--- SyncTeX
+
+MIT License
+
+Copyright (c) 2008-2017 jerome DOT laurens AT u-bourgogne DOT fr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--- zlib
+
+ (C) 1995-2024 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu

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

@@ -188,9 +188,11 @@ export function createServer(app: App) {
     server.get<{ Params: { name: string; number: string } }>(
       "/api/tasks/:name/rounds/:number",
       (request) =>
-        app.review.roundDetail(
-          request.params.name,
-          Number(request.params.number),
+        app.review.positioned(
+          app.review.roundDetail(
+            request.params.name,
+            Number(request.params.number),
+          ),
         ),
     );
     // The places an edit changes away from its lines, past those its round

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

@@ -163,6 +163,14 @@ export interface BuildInfo {
   seconds: number;
   warnings: string[];
 }
+// A running compilation: latexmk's current step, the TeX pass, and the
+// pages typeset in it against the last known page count.
+export interface BuildProgress {
+  step: "tex" | "bibliography" | "pdf";
+  pass: number;
+  pages: number;
+  total: number | null;
+}
 export interface Position {
   page: number;
   clip: Rect;
@@ -200,6 +208,8 @@ export interface Strip {
   clean: string;
   width: number;
   height: number;
+  /** Where the strip starts on its page, in points; absent in older rounds. */
+  top?: number;
   page: number;
   label: string;
   text?: TextLine[];
@@ -400,6 +410,9 @@ export interface RoundDetail extends Omit<RenderedRound, "units"> {
   warnings: string[];
   files: string;
   references?: References;
+  /** The new version's complete PDF, when the host serves one, so the review
+   * can show the changes in the whole paper. */
+  pdf?: string;
 }
 export type TaskState =
   "editing" | "building" | "build_failed" | "reviewing" | "revise" | "done";