papilot 0.8.1 → 0.8.3

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/engine/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 → 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";