papilot 0.8.2 → 0.8.3

package/{vendor/latex-review → engine}/src/web/review.tsx

@@ -1,5 +1,7 @@
 import {
   Fragment,
+  lazy,
+  Suspense,
   useEffect,
   useMemo,
   useRef,
@@ -18,7 +20,11 @@ import type {
 } from "../types.ts";
 import { PdfStrip } from "./PdfStrip.tsx";
 import { ChangeMap } from "./ChangeMap.tsx";
+import { placeable, type PlacedChange } from "./paper.ts";
+// pdf.js loads only when the full paper is shown.
+const FullPaper = lazy(() => import("./FullPaper.tsx").then((module) => ({ default: module.FullPaper })));
 import { EFFECTS_EVENT, EFFECTS_STORAGE, readExpandedEffects } from "./effect-preferences.ts";
+import { readView, VIEW_EVENT, VIEW_STORAGE, type ReviewView } from "./view-preferences.ts";
 import { STATUS } from "./overview.tsx";
 import { language, locale, t, tn, withLanguage } from "./i18n.ts";
 import {
@@ -167,6 +173,22 @@ export function ReviewApp({
     scrollUntil = useRef(0),
     snapshot = useRef({ state, detail, busy, composer, current });
   const [shortcuts, setShortcuts] = useState(readShortcuts);
+  // The whole paper with the changes in place, or the changed sections only.
+  // A host may fix the view in the address (Papilot's manuscript chooses its
+  // PDF with its own switch); otherwise it follows the stored choice.
+  const [pinnedView] = useState<ReviewView | null>(() => {
+    const value = new URLSearchParams(location.search).get("view");
+    return value === "paper" || value === "changes" ? value : null;
+  });
+  const [view, setView] = useState<ReviewView>(() => pinnedView ?? readView());
+  useEffect(() => {
+    if (pinnedView) return;
+    const chosen = (event: Event) => setView((event as CustomEvent).detail === "changes" ? "changes" : "paper");
+    const stored = (event: StorageEvent) => { if (event.key === VIEW_STORAGE || event.key === null) setView(readView()); };
+    window.addEventListener(VIEW_EVENT, chosen);
+    window.addEventListener("storage", stored);
+    return () => { window.removeEventListener(VIEW_EVENT, chosen); window.removeEventListener("storage", stored); };
+  }, [pinnedView]);
   const [expandedEffects, setExpandedEffects] = useState(readExpandedEffects);
   // Per-edit disclosure is temporary and scoped to its round. Changing the
   // global preference resets those overrides without reloading the review.
@@ -195,6 +217,16 @@ export function ReviewApp({
       [detail],
     ),
     stops = useMemo(() => (detail ? buildStops(detail) : []), [detail]),
+    // The change blocks in the order and numbering of the changes view.
+    placed = useMemo(() => {
+      const list: PlacedChange[] = [];
+      if (!detail) return list;
+      for (const section of detail.sections)
+        for (const block of section.blocks)
+          if (block.kind === "change") list.push({ block, index: list.length });
+      for (const block of detail.loose) list.push({ block, index: list.length });
+      return list;
+    }, [detail]),
     // An edit's places show under the first change that includes it.
     firstStop = useMemo(() => {
       const found = new Map<string, number>();
@@ -1094,6 +1126,32 @@ export function ReviewApp({
       </article>
     );
   }
+  const fullPaper = !pinnedView && Boolean(detail?.pdf) && placeable(placed),
+    paperView = fullPaper && view === "paper";
+  // A host shows its own switch while the whole paper can be shown.
+  useEffect(() => {
+    const root = document.documentElement;
+    if (fullPaper) root.dataset.fullPaper = "available";
+    else delete root.dataset.fullPaper;
+  }, [fullPaper]);
+  // Keep the selected change in view when the view changes, from here or the host.
+  const shownView = useRef(paperView);
+  useEffect(() => {
+    if (shownView.current === paperView) return;
+    shownView.current = paperView;
+    requestAnimationFrame(() => {
+      const article = paper.current?.querySelector<HTMLElement>(`[data-stop="${snapshot.current.current}"]`);
+      if (article) reveal(article);
+    });
+  }, [paperView]);
+  function chooseView(next: ReviewView) {
+    setView(next);
+    try {
+      localStorage.setItem(VIEW_STORAGE, next);
+    } catch {
+      /* The choice lasts for this page. */
+    }
+  }
   let index = 0;
   return (
     <>
@@ -1233,6 +1291,24 @@ export function ReviewApp({
               {t("Undo revert")}
             </button>
           )}
+          {fullPaper && (
+            <div className="view-switch" role="group" aria-label={t("Review view")}>
+              <button
+                className={`ghost${view === "paper" ? " active" : ""}`}
+                aria-pressed={view === "paper"}
+                onClick={() => chooseView("paper")}
+              >
+                PDF
+              </button>
+              <button
+                className={`ghost${view === "changes" ? " active" : ""}`}
+                aria-pressed={view === "changes"}
+                onClick={() => chooseView("changes")}
+              >
+                {t("Changes")}
+              </button>
+            </div>
+          )}
           {/* History is a toolbar action; its own row appears only while
               browsing earlier decisions. */}
           {detail && !history && !changes && (
@@ -1462,7 +1538,28 @@ export function ReviewApp({
               />
             )}
           <div className="document">
-            {detail ? (
+            {detail && paperView ? (
+              <>
+                <Suspense fallback={<div className="paper-status" role="status"><div className="pulse" /></div>}>
+                <FullPaper
+                  url={detail.pdf!}
+                  changes={placed}
+                  render={(block, at) => change(block, at, true)}
+                  scrollRoot={paper}
+                  onReady={() => {
+                    const article = paper.current?.querySelector<HTMLElement>(
+                      `[data-stop="${snapshot.current.current}"]`,
+                    );
+                    if (article) reveal(article);
+                  }}
+                  onUnavailable={() => chooseView("changes")}
+                />
+                </Suspense>
+                {!stops.length && !changes && (
+                  <p className="empty">{t("No changes to review.")}</p>
+                )}
+              </>
+            ) : detail ? (
               <>
                 {detail.sections.map((section) => (
                   <section className="part" key={section.node}>

package/{vendor/latex-review → engine}/src/web/style.css

@@ -247,6 +247,33 @@ kbd {
   border-color: var(--line);
 }
 
+/* Full paper or changes only, as one segmented control (a host such as
+   Papilot shows its own instead). */
+.view-switch {
+  display: inline-grid;
+  grid-template-columns: repeat(2, 1fr);
+  flex: none;
+  gap: 2px;
+  padding: 2px;
+  border: 1px solid var(--line);
+  border-radius: 9px;
+  background: var(--head);
+}
+.view-switch .ghost {
+  padding: 3px 10px;
+  border-radius: 6px;
+  font-weight: 500;
+}
+.view-switch .ghost:hover {
+  text-decoration: none;
+  border-color: transparent;
+}
+.view-switch .ghost.active {
+  color: var(--ink);
+  background: var(--paper);
+  box-shadow: 0 1px 2px rgb(0 0 0 / 0.06), 0 0 0 1px var(--line);
+}
+
 /* Document */
 #paper {
   overflow: auto;
@@ -898,6 +925,49 @@ kbd {
   text-align: center;
   padding: 90px 16px;
 }
+/* The whole paper: the new PDF's pages, opened where each change is shown
+   as in the changes view. A host's narrow-screen crop of the strips
+   (--pdf-crop-scale, --pdf-crop-shift) applies to the pages too. */
+.paper-page {
+  background: var(--pdf-page, var(--paper));
+  box-shadow: var(--shadow);
+  border-radius: 3px;
+  margin-bottom: 14px;
+}
+.paper-context {
+  line-height: 0;
+}
+.paper-slice {
+  position: relative;
+  width: 100%;
+}
+.paper-slice canvas {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  filter: var(--pdf-filter, none);
+}
+@media (max-width: 680px) {
+  .paper-slice {
+    width: calc(100% * var(--pdf-crop-scale, 1));
+    margin-left: calc(-100% * var(--pdf-crop-scale, 1) * var(--pdf-crop-shift, 0));
+  }
+  .paper-context {
+    overflow-x: clip;
+  }
+}
+.paper-status {
+  text-align: center;
+  padding: 90px 16px;
+  color: var(--muted);
+}
+.paper-status p {
+  margin: 6px 0 14px;
+}
+.paper-clock {
+  font-variant-numeric: tabular-nums;
+}
 .waiting p {
   margin: 6px 0;
 }

package/engine/src/web/view-preferences.ts

@@ -0,0 +1,13 @@
+// Whole paper or changed sections only. A host such as Papilot shows its own
+// switch: it stores the choice and tells this frame; storage events also
+// update other tabs.
+export const VIEW_STORAGE = "latex-review:view";
+export const VIEW_EVENT = "latex-review:view-changed";
+export type ReviewView = "paper" | "changes";
+export function readView(): ReviewView {
+  try {
+    return localStorage.getItem(VIEW_STORAGE) === "changes" ? "changes" : "paper";
+  } catch {
+    return "paper";
+  }
+}

package/{vendor/latex-review → engine}/src/web/zh-CN.ts

@@ -66,6 +66,9 @@ export const zhCN: Record<string, string> = {
   "Review history": "审阅历史",
   "Keyboard shortcuts": "键盘快捷键",
   "Review view": "审阅视图",
+  "Changes": "改动",
+  "Preparing the full PDF…": "正在准备完整 PDF…",
+  "The full PDF could not be loaded.": "无法加载完整 PDF。",
   "Undo {action} · {changes}": "撤销{action} · {changes}",
   "Change {list}": "修改 {list}",
   "Changes {list}": "修改 {list}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papilot",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "A Cursor-like workspace for your papers: annotate and review PDFs directly without ever touching LaTeX.",
   "keywords": [
     "latex",
@@ -48,23 +48,25 @@
     "scripts/demo.ts",
     "scripts/service.ts",
     "examples/papilot-paper",
-    "vendor/latex-review/src",
-    "vendor/latex-review/dist",
+    "engine/src",
+    "engine/dist",
+    "engine/package.json",
+    "engine/package-lock.json",
+    "engine/LICENSE",
     "vendor/latex-review/package.json",
-    "vendor/latex-review/package-lock.json",
-    "vendor/latex-review/LICENSE"
+    "vendor/latex-review/package-lock.json"
   ],
   "engines": {
     "node": ">=22.22.0"
   },
-  "desktopShell": 1,
+  "desktopShell": 2,
   "scripts": {
     "dev": "tsx watch src/server/main.ts",
     "start": "tsx src/server/main.ts",
     "build": "tsc --noEmit && vite build",
     "typecheck": "tsc --noEmit && tsc -p desktop/tsconfig.json --noEmit",
     "test": "tsx --test tests/*.test.ts",
-    "setup:review": "npm --prefix vendor/latex-review ci && npm --prefix vendor/latex-review run build",
+    "setup:review": "npm --prefix engine ci && npm --prefix engine run build",
     "demo": "tsx scripts/demo.ts",
     "doctor": "node bin/papilot.mjs doctor",
     "service:install": "tsx scripts/service.ts install",
@@ -79,7 +81,7 @@
     "test:desktop": "node scripts/check-desktop.mjs",
     "i18n": "tsx scripts/i18n.ts",
     "i18n:check-app": "tsx scripts/i18n/app-locales.ts",
-    "test:locales": "npm run build && npm --prefix vendor/latex-review run build && node --import tsx scripts/check-locales.mjs"
+    "test:locales": "npm run build && npm --prefix engine run build && node --import tsx scripts/check-locales.mjs"
   },
   "dependencies": {
     "@fastify/compress": "^9.2.2",

package/src/conversation.ts

@@ -33,7 +33,7 @@ export function skillPrompt(skill: { name: string; body: string; folder?: string
 }
 
 interface FeedbackItem { kind?: string; round?: number | null; text?: string; changes?: (string | { file?: string; lines?: [number, number] })[] }
-// The review engine's feedback (see vendor/latex-review FeedbackItem) as the chat shows it.
+// The review engine's feedback (see engine FeedbackItem) as the chat shows it.
 export function summarizeFeedback(feedback: { feedback?: FeedbackItem[]; build_error?: unknown }): FeedbackSummary | undefined {
   const items = feedback.feedback || [];
   if (!items.length && !feedback.build_error) return undefined;

package/src/server/app.ts

@@ -473,6 +473,10 @@ export async function buildApp(options: AppOptions) {
     if (typeof b?.id !== 'string' || typeof b?.confirmed !== 'boolean') throw new Error('Choose an entry to confirm.');
     return changes.confirmReference(project.id, project.path, Number(request.params.number), b.id, b.confirmed);
   });
+  app.get<{ Params: { projectId: string; number: string } }>('/review/:projectId/changes/pdf/:number', changesAccess, (request, reply) => {
+    const pdf = changes.pdf(store.project(request.params.projectId).id, Number(request.params.number));
+    return reply.type('application/pdf').sendFile(path.basename(pdf), path.dirname(pdf), { cacheControl: false });
+  });
   app.get<{ Params: { projectId: string; number: string; file: string } }>('/review/:projectId/changes/files/:number/:file', changesAccess, (request, reply) => {
     const file = changes.file(store.project(request.params.projectId).id, Number(request.params.number), request.params.file);
     return reply.header('Cache-Control', 'private, max-age=31536000, immutable').type(file.endsWith('.svg') ? 'image/svg+xml' : 'image/png').send(fs.createReadStream(file));
@@ -491,6 +495,14 @@ export async function buildApp(options: AppOptions) {
     return serialGit(project.id, () => workspace.exclusiveCommit(project.id, () => changes.undo(project.id, project.path, csrfFor(request.viewer!), id)));
   });
 
+  // The complete PDF of a round's new version, for the review's full paper.
+  // A round may compile only the changed chapters; this compiles them all once.
+  app.get<{ Params: { projectId: string; name: string; round: string } }>('/review/:projectId/pdf/:name/:round', { config: { access: { project: 'projectId' } } }, async (request, reply) => {
+    const project = store.project(request.params.projectId), name = request.params.name, round = Number(request.params.round);
+    if (!/^[a-z0-9-]+$/.test(name) || !Number.isSafeInteger(round) || round < 1) return reply.code(404).send({ error: 'Review resource not found.' });
+    const pdf = await fullPaperPdf(project.path, name, round, 'after');
+    return reply.type('application/pdf').sendFile(path.basename(pdf), path.dirname(pdf), { cacheControl: false });
+  });
   app.route<{ Params: { projectId: string; '*': string } }>({
     // The review page posts with the review engine's token rather than Papilot's.
     method: ['GET', 'POST'], url: '/review/:projectId/*', config: { access: { project: 'projectId' }, csrf: false }, handler: async (request, reply) => {
@@ -528,6 +540,10 @@ export async function buildApp(options: AppOptions) {
               await workspace.refresh(task.id);
             }
           }
+          // A round's new version as one complete PDF, which Papilot compiles,
+          // lets the review show the changes in the whole paper.
+          const round = request.method === 'GET' && response.ok ? /^\/api\/tasks\/([a-z0-9-]+)\/rounds\/(\d+)$/.exec(route) : null;
+          if (round) (value as { pdf?: string }).pdf = `${prefix}/pdf/${round[1]}/${round[2]}`;
           return rewriteReviewJson(value, prefix);
         }
         if (reviewTask && writesFiles) throw new Error('The review engine returned an unexpected response. Select Check status before continuing.');

package/src/server/changes.ts

@@ -17,7 +17,7 @@ type Op = ['equal' | 'replace' | 'insert' | 'delete', number, number, number, nu
 export interface Unit { id: string; file: string; status: 'added' | 'deleted' | 'modified'; kind: string; whole_file: boolean; ops: Op[]; old_start: number; old_end: number; new_start: number; new_end: number; old_text: string; new_text: string; truncated: boolean }
 type Decision = 'pending' | 'accepted' | 'rejected' | 'commented';
 export type ChangeAction = 'stage' | 'unstage' | 'revert';
-interface Round { number: number; before: string; after: string; units: Unit[]; folder: string; warnings: string[]; decisions: Record<string, Decision> }
+interface Round { number: number; before: string; after: string; units: Unit[]; folder: string; warnings: string[]; decisions: Record<string, Decision>; pdf?: string }
 interface Job { key: string; phase: 'build' | 'render'; status: 'running' | 'failed'; created: number; error?: string; details?: string[]; log?: string }
 interface Snapshot { before: string | null; after: string }
 interface Entry { mode: string; sha: string }
@@ -139,7 +139,7 @@ export class Changes {
       const { Builder, BuildError, Repo, loadProject, withUnits, render } = await engine();
       const project = loadProject(root), repo = new Repo(root), number = comparison.next++;
       const units = await this.units(projectId, root, snapshot), folder = path.join(this.dir, projectId, String(number));
-      let warnings: string[] = [];
+      let warnings: string[] = [], pdf: string | undefined;
       fs.rmSync(folder, { recursive: true, force: true }); fs.mkdirSync(folder, { recursive: true });
       if (units.length) {
         const builder = new Builder(project, repo);
@@ -154,8 +154,9 @@ export class Changes {
         await render(folder, { main: project.main, source_dir: project.source_dir, figures: project.figures, old, new: next, units },
           (subset: Unit[]) => builder.build(withUnits(repo, snapshot.before!, snapshot.after, subset), ['full']));
         warnings = next.warnings.filter((warning: string) => !old.warnings.includes(warning));
+        pdf = next.pdf;
       } else fs.writeFileSync(path.join(folder, 'round.json'), JSON.stringify({ units: {}, sections: [], loose: [] }));
-      comparison.rounds.push({ number, before: snapshot.before!, after: snapshot.after, units, folder, warnings, decisions: {} });
+      comparison.rounds.push({ number, before: snapshot.before!, after: snapshot.after, units, folder, warnings, decisions: {}, pdf });
       // The viewer may still show the round before; older ones go.
       for (const old of comparison.rounds.splice(0, Math.max(0, comparison.rounds.length - 3))) fs.rmSync(old.folder, { recursive: true, force: true });
       if (comparison.job === job) comparison.job = null;
@@ -203,6 +204,8 @@ export class Changes {
       task: 'changes', round: round.number, before: round.before, after: round.after,
       units: round.units.map(unit => ({ ...unit, ...render.units[unit.id] })), sections: render.sections, loose: render.loose,
       warnings: round.warnings, files: `/review/${projectId}/changes/files/${round.number}/`,
+      // The working tree compiles in full, so its PDF shows the whole paper.
+      ...(round.pdf ? { pdf: `/review/${projectId}/changes/pdf/${round.number}` } : {}),
       ...(render.references ? { references: render.references } : {}),
     };
   }
@@ -238,6 +241,12 @@ export class Changes {
     return { places: await more(round.folder, unit) };
   }
 
+  pdf(projectId: string, number: number) {
+    const file = this.comparison(projectId).rounds.find(item => item.number === number)?.pdf;
+    if (!file || !fs.existsSync(file)) throw Object.assign(new Error('This comparison is out of date. Refresh the page.'), { statusCode: 404 });
+    return file;
+  }
+
   file(projectId: string, number: number, name: string) {
     const round = this.comparison(projectId).rounds.find(item => item.number === number);
     const file = round && /^[\w.-]+\.(svg|png)$/.test(name) ? path.join(round.folder, name) : '';

package/src/server/imports.ts

@@ -149,7 +149,9 @@ export class PaperImports {
   private save(value: PaperImport) {
     fs.mkdirSync(path.join(this.directory, 'imports'), { recursive: true, mode: 0o700 });
     const file = path.join(this.directory, 'imports', value.id + '.json');
-    fs.writeFileSync(file + '.tmp', JSON.stringify(value), { mode: 0o600 }); fs.renameSync(file + '.tmp', file);
+    // Progress is live state; a restarted server fails a running import anyway.
+    const { progress: _progress, ...stored } = value;
+    fs.writeFileSync(file + '.tmp', JSON.stringify(stored), { mode: 0o600 }); fs.renameSync(file + '.tmp', file);
     this.sessions.set(value.id, value); return { ...value };
   }
   get(id: string) {
@@ -207,7 +209,7 @@ export class PaperImports {
     if (input.name !== undefined && (typeof input.name !== 'string' || !input.name.trim() || input.name.length > 120)) throw new Error('Enter a paper name under 120 characters.');
     this.active.add(id);
     const previousError = value.error || '';
-    Object.assign(value, { main, engine, ...(input.name ? { name: input.name } : {}), phase: repair ? 'repairing' : 'building', error: undefined });
+    Object.assign(value, { main, engine, ...(input.name ? { name: input.name } : {}), phase: repair ? 'repairing' : 'building', error: undefined, startedAt: Date.now(), progress: undefined });
     this.save(value);
     void (async () => {
       try {
@@ -227,10 +229,13 @@ export class PaperImports {
         // opened paper finds this PDF in the cache instead of compiling again.
         this.manuscripts.forgetProject('import-' + id);
         let result = await this.manuscripts.state('import-' + id, value.path);
-        while (result.build.status === 'building') { await new Promise(resolve => setTimeout(resolve, 400)); result = await this.manuscripts.state('import-' + id, value.path); }
+        while (result.build.status === 'building') {
+          value.progress = result.build.progress;
+          await new Promise(resolve => setTimeout(resolve, 400)); result = await this.manuscripts.state('import-' + id, value.path);
+        }
         value.phase = result.build.status === 'ready' ? 'ready' : 'failed'; value.error = result.build.error;
       } catch (error) { value.phase = 'failed'; value.error = (error as Error).message; }
-      finally { this.active.delete(id); this.save(value); }
+      finally { this.active.delete(id); value.progress = undefined; this.save(value); }
     })();
     return this.get(id);
   }

package/src/server/main.ts

@@ -3,8 +3,9 @@ import { pathToFileURL } from 'node:url';
 import { ROOT, DATA } from './paths.ts';
 import { activeInstallation, waitForActivation } from '../../bin/installation.mjs';
 
-await waitForActivation(DATA);
-const root = activeInstallation(ROOT, DATA);
+const desktop = process.env.PAPILOT_DESKTOP === '1';
+if (!desktop) await waitForActivation(DATA);
+const root = desktop ? ROOT : activeInstallation(ROOT, DATA);
 // A source checkout's default data directory must not move with the release.
 process.env.PAPILOT_DATA = DATA;
 await import(pathToFileURL(path.join(root, 'src/server/start.ts')).href);

package/src/server/manuscript.ts

@@ -8,7 +8,7 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { pathToFileURL } from 'node:url';
 import { ENGINE } from './paths.ts';
-import type { Annotation, BuildProblem, GitFile, GitStatus, ManuscriptBuild, ManuscriptProblems } from '../shared.ts';
+import type { Annotation, BuildProblem, BuildProgress, GitFile, GitStatus, ManuscriptBuild, ManuscriptProblems } from '../shared.ts';
 import { notesInstructions } from '../notes.ts';
 import { ignorePattern } from '../commit.ts';
 import { AnnotationPages, placeAnnotation } from './annotation-placement.ts';
@@ -360,7 +360,7 @@ export async function pdfWords(pdf: string, page: number) {
 // `problems` come from the last finished build. They are placed on the PDF
 // named `problemsKey`; a failed build has no PDF of its own to place them on.
 interface Build {
-  tree: string; status: ManuscriptBuild['status']; key?: string; pdf?: string; root?: string; sourceDir?: string; pages?: [number, number][]; builtAt?: number; error?: string;
+  tree: string; status: ManuscriptBuild['status']; key?: string; pdf?: string; root?: string; sourceDir?: string; pages?: [number, number][]; builtAt?: number; error?: string; progress?: BuildProgress;
   problems?: StoredProblem[]; problemsKey?: string; log?: string; logFolder?: string;
 }
 
@@ -402,7 +402,7 @@ export class Manuscripts extends EventEmitter {
     let build = this.builds.get(projectId);
     if (!build || (build.status !== 'building' && (build.tree !== tree || rebuild))) build = this.start(projectId, root, tree, build, rebuild);
     const { status: state, key, pages, builtAt, error } = build;
-    return { git: status, build: { status: state, key, pages, builtAt, error, current: build.tree === tree && state === 'ready', problems: build.problems && countProblems(build.problems) } };
+    return { git: status, build: { status: state, key, pages, builtAt, error, current: build.tree === tree && state === 'ready', problems: build.problems && countProblems(build.problems), ...(state === 'building' && build.progress ? { progress: build.progress } : {}) } };
   }
 
   // Keep the previous pages visible while a newer working tree compiles.
@@ -415,7 +415,8 @@ export class Manuscripts extends EventEmitter {
       try {
         const { Builder, Repo, loadProject, mupdf } = await engine();
         project = loadProject(root);
-        const result = await new Builder(project, new Repo(root)).build(tree, ['full'], null, { force });
+        const startedAt = Date.now();
+        const result = await new Builder(project, new Repo(root)).build(tree, ['full'], null, { force, progress: (progress: Omit<BuildProgress, 'startedAt'>) => { if (this.builds.get(projectId) === build) build.progress = { ...progress, startedAt }; } });
         const document = mupdf.Document.openDocument(fs.readFileSync(result.pdf), 'application/pdf');
         const pages: [number, number][] = [];
         for (let i = 0; i < document.countPages(); i++) { const [x0, y0, x1, y1] = document.loadPage(i).getBounds(); pages.push([Math.round(x1 - x0), Math.round(y1 - y0)]); }

package/src/server/paths.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 export const DATA = path.resolve(process.env.PAPILOT_DATA || path.join(ROOT, '.papilot'));
-export const ENGINE = path.resolve(process.env.PAPILOT_REVIEW_ENGINE || path.join(ROOT, 'vendor/latex-review'));
+export const ENGINE = path.resolve(process.env.PAPILOT_REVIEW_ENGINE || path.join(ROOT, 'engine'));
 export const VERSION: string = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8')).version;
 export const PORT = Number(process.env.PAPILOT_PORT || 7274);
 export const PUBLIC_ORIGIN = process.env.PAPILOT_PUBLIC_ORIGIN || '';

package/src/server/start.ts

@@ -10,7 +10,6 @@ import { Manuscripts } from './manuscript.ts';
 import { Changes } from './changes.ts';
 import { buildApp, gitQueue } from './app.ts';
 import { Updates } from './updates.ts';
-import { installRelease } from './update-install.ts';
 import { readJson } from '../../bin/installation.mjs';
 import { desktopDemo } from './desktop-demo.ts';
 
@@ -22,16 +21,10 @@ const accounts = new Accounts(store, ACCOUNT_ORIGIN || null);
 const manuscripts = new Manuscripts(), changes = new Changes();
 const desktop = process.env.PAPILOT_DESKTOP === '1';
 if (desktop) await desktopDemo(ROOT, DATA, store, workspace, manuscripts).catch(error => console.error('Could not prepare the demo paper:', error));
-// A packaged desktop app installs newer releases and restarts them itself.
-const shell = desktop && process.send ? Number(process.env.PAPILOT_DESKTOP_SHELL) || 0 : 0, downloadUrl = 'https://github.com/PapilotAI/papilot/releases/latest';
-const updates = new Updates({ root: ROOT, data: DATA, version: VERSION, port: PORT,
-  ...(shell ? {
-    desktop: { shell, installer: process.env.PAPILOT_DESKTOP_INSTALLER || VERSION, downloadUrl },
-    install: (data: string, version: string) => installRelease(data, version, { shell, codex: process.env.PAPILOT_DESKTOP_CODEX }),
-    restart: async (root: string, version: string) => { process.send!({ type: 'papilot:activate', root, version }); },
-  } : desktop ? { supported: false, downloadUrl } : {}),
+// Desktop releases are complete installers; npm updates belong to the web server.
+const updates = new Updates({ root: ROOT, data: DATA, version: VERSION, port: PORT, desktop,
   busy: () => workspace.busyForUpdate || manuscripts.busyForUpdate || changes.busyForUpdate, shutdown: () => shutdown() });
-const activation = readJson(path.join(DATA, 'updates/active.json'));
+const activation = desktop ? null : readJson(path.join(DATA, 'updates/active.json'));
 const updateInstance = typeof activation?.root === 'string' && fs.existsSync(activation.root) && fs.realpathSync(activation.root) === fs.realpathSync(ROOT) ? activation.id : undefined;
 const shared = {
   store, workspace, accounts, manuscripts, changes, updates, updateInstance, csrf: randomBytes(32).toString('base64url'), serialGit: gitQueue(),

package/src/server/update-install.ts

@@ -4,7 +4,7 @@ import net from 'node:net';
 import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createRequire } from 'node:module';
-import { devRevision, newerVersion, readJson, stableVersion } from '../../bin/installation.mjs';
+import { devRevision, readJson, stableVersion } from '../../bin/installation.mjs';
 
 export const DEV_REPOSITORY = 'https://github.com/PapilotAI/papilot.git';
 const git = async (args: string[], cwd: string) => (await promisify(execFile)('git', args, { cwd, timeout: 120000, maxBuffer: 1024 * 1024, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } })).stdout.trim();
@@ -18,19 +18,6 @@ export function npmCli(env = process.env, executable = process.execPath) {
   }
   throw new Error('npm is unavailable to Papilot.');
 }
-// A desktop installer runs a newer release when it provides the shell level the
-// release declares and its bundled Node meets the release's engine range.
-export const NEEDS_INSTALLER = 'This version needs the latest desktop app. Download it from GitHub Releases.';
-export function desktopSupports(pkg: any, shell: number, node = process.versions.node) {
-  if (!Number.isInteger(pkg?.desktopShell) || pkg.desktopShell < 1 || pkg.desktopShell > shell) return false;
-  // npm's --engine-strict checks other range forms during installation.
-  const minimum = typeof pkg.engines?.node === 'string' ? /^\s*>=\s*v?(\d+\.\d+\.\d+)\s*$/.exec(pkg.engines.node)?.[1] : undefined;
-  return !minimum || !newerVersion(minimum, node);
-}
-// The installer's Codex serves releases that test the same or an older one.
-export function codexVersion(bin: string | undefined) {
-  try { return readJson(path.join(path.dirname(fs.realpathSync(bin!)), '../package.json'))?.version || null; } catch { return null; }
-}
 export const loaderFor = (root: string) => createRequire(path.join(root, 'package.json')).resolve('tsx/esm');
 export function runInstall(args: string[], cwd: string, log: number, timeout = 600000) {
   return new Promise<void>((resolve, reject) => {
@@ -84,7 +71,7 @@ export async function prepareDev(root: string, version: string, log: number, run
   // Test-only tools can exclude a Node version that supports the application.
   // Build first, then enforce engine compatibility for the retained runtime.
   await run(['ci', '--include=dev', '--engine-strict=false', ...flags], root, log);
-  const engine = path.join(root, 'vendor/latex-review');
+  const engine = path.join(root, 'engine');
   await run(['ci', '--include=dev', '--engine-strict=false', ...flags], engine, log);
   // Only this installed snapshot gets a dev version; the repository stays unchanged.
   fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ ...pkg, version }, null, 2) + '\n');
@@ -115,7 +102,8 @@ async function installDev(data: string, version: string) {
   } catch (error) { fs.rmSync(stage, { recursive: true, force: true }); throw error; }
   finally { fs.closeSync(log); }
 }
-export async function installRelease(data: string, version: string, desktop?: { shell: number; codex?: string }) {
+export async function installRelease(data: string, version: string) {
+  if (process.env.PAPILOT_DESKTOP === '1') throw new Error('Download desktop updates from GitHub Releases.');
   if (devRevision(version)) return installDev(data, version);
   if (!stableVersion(version)) throw new Error('Invalid release version.');
   const releases = path.join(data, 'updates/releases'); fs.mkdirSync(releases, { recursive: true, mode: 0o700 });
@@ -126,17 +114,12 @@ export async function installRelease(data: string, version: string, desktop?: {
     await runInstall(['install', '--prefix', stage, '--save-exact', ...flags, `papilot@${version}`], stage, log);
     const pkg = readJson(path.join(root, 'package.json'));
     if (pkg?.name !== 'papilot' || pkg.version !== version) throw new Error('The downloaded package does not match the requested release.');
-    for (const file of ['dist/index.html', 'src/server/start.ts', 'src/server/main.ts', 'bin/papilot.mjs', 'vendor/latex-review/package-lock.json']) {
+    // Releases also ship an empty vendor/latex-review package, where 0.8.2 and
+    // earlier look for the engine when they install an update.
+    for (const file of ['dist/index.html', 'src/server/start.ts', 'src/server/main.ts', 'bin/papilot.mjs', 'engine/package-lock.json']) {
       if (!fs.existsSync(path.join(root, file))) throw new Error('The downloaded release is incomplete.');
     }
-    if (desktop && !desktopSupports(pkg, desktop.shell)) throw new Error(NEEDS_INSTALLER);
-    await runInstall(['ci', '--prefix', path.join(root, 'vendor/latex-review'), ...flags], stage, log);
-    // Like the CLI's first run, Codex installs with its own scripts. The app
-    // finds it beside the release.
-    const tested = pkg.devDependencies?.['@openai/codex'], bundled = desktop && codexVersion(desktop.codex);
-    if (desktop && stableVersion(tested) && (!bundled || newerVersion(tested, bundled))) {
-      await runInstall(['install', '--prefix', path.join(stage, 'codex'), '--registry=https://registry.npmjs.org', '--no-audit', '--no-fund', `@openai/codex@${tested}`], stage, log);
-    }
+    await runInstall(['ci', '--prefix', path.join(root, 'engine'), ...flags], stage, log);
     await probeInstallation(root, version, stage, log);
     return root;
   } catch (error) { fs.rmSync(stage, { recursive: true, force: true }); throw error; }