papilot 0.8.2 → 0.8.4

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 opens on the stored default.
+  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,28 @@ 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]);
+  // The switch changes this review only; the default is a Papilot setting.
+  function chooseView(next: ReviewView) {
+    setView(next);
+  }
   let index = 0;
   return (
     <>
@@ -1233,6 +1287,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 +1534,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,15 @@
+// Whole paper ("paper") or changed sections only ("changes"). Reviews open on
+// the stored default: the changed sections, which show fastest, unless the
+// whole paper was chosen in Papilot's settings. Switching views lasts for the
+// open review only. A host such as Papilot shows its own switch and tells this
+// frame; storage events bring a new default to reviews already open.
+export const VIEW_STORAGE = "latex-review:default-view";
+export const VIEW_EVENT = "latex-review:view-changed";
+export type ReviewView = "paper" | "changes";
+export function readView(): ReviewView {
+  try {
+    return localStorage.getItem(VIEW_STORAGE) === "paper" ? "paper" : "changes";
+  } catch {
+    return "changes";
+  }
+}

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.4",
   "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

@@ -25,7 +25,7 @@ import type { Updates } from './updates.ts';
 import { Diagnostics } from './diagnostics.ts';
 import { attachmentIds } from './attachments.ts';
 import { MAX_ATTACHMENT_BYTES } from '../shared.ts';
-import { PaperImports } from './imports.ts';
+import { PaperImports, openFolder } from './imports.ts';
 import { DATA } from './paths.ts';
 import { registerAiReviewRoutes } from './ai-review-routes.ts';
 import { detectLatex } from './latex-installation.ts';
@@ -174,6 +174,7 @@ export async function buildApp(options: AppOptions) {
   const string = (value: unknown, name: string, max = 20000) => { if (typeof value !== 'string' || !value.trim() || value.length > max) throw new Error(`${name} is required and must be no longer than ${max} characters.`); return value.trim(); };
   // Adding a paper names a folder on this host, so only the owner can.
   app.post('/api/projects', owner, async request => { const b = request.body as any; return workspace.addProject(string(b.path, 'Repository path', 4000), b.name ? string(b.name, 'Paper name', 120) : undefined); });
+  app.post('/api/projects/open', owner, request => openFolder((request.body || {}) as any, root => store.projectByPath(root), (root, name) => workspace.addProject(root, name)));
   app.post('/api/imports', { ...owner, bodyLimit: 90 * 1024 * 1024 }, request => imports!.create((request.body || {}) as any));
   app.get<{ Params: { id: string } }>('/api/imports/:id', owner, request => imports!.get(request.params.id));
   app.post<{ Params: { id: string } }>('/api/imports/:id/build', owner, request => imports!.build(request.params.id, (request.body || {}) as any));
@@ -473,6 +474,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 +496,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 +541,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

@@ -88,18 +88,25 @@ export async function inspectPaper(root: string) {
     const found = new Set(roots);
     candidates = [...roots, ...files.filter(file => !found.has(file))];
   }
-  try {
-    // Engine detection also works before Git initialization by reading the source hints.
-    if (main) {
-      const text = sourceHead(path.join(root, main));
-      engine = typeof settings.engine === 'string' ? settings.engine : '';
-      const rc = [path.join(path.dirname(main), '.latexmkrc'), path.join(path.dirname(main), 'latexmkrc'), '.latexmkrc', 'latexmkrc'].find(file => fs.existsSync(path.join(root, file)));
-      const mode = rc ? fs.readFileSync(path.join(root, rc), 'utf8').match(/^\s*\$pdf_mode\s*=\s*(\d)/m)?.[1] : undefined;
-      if (!engine) engine = text.match(/^%\s*!\s*TEX\s+(?:TS-)?program\s*=\s*(pdflatex|xelatex|lualatex)/im)?.[1].toLowerCase() || ({ '1': 'pdflatex', '4': 'lualatex', '5': 'xelatex' } as Record<string, string>)[mode || ''] || (/\\(?:usepackage(?:\[[^\]]*\])?\{[^}]*\b(?:fontspec|xeCJK|unicode-math|polyglossia)\b|documentclass(?:\[[^\]]*\])?\{ctex)/.test(text) ? 'xelatex' : 'pdflatex');
-    }
-  } catch (failure) { error = (failure as Error).message; }
+  try { if (main) engine = engineFor(root, main, settings); } catch (failure) { error = (failure as Error).message; }
   return { candidates, main, engine: engine || 'pdflatex', error };
 }
+// Engine detection also works before Git initialization by reading the source hints.
+function engineFor(root: string, main: string, settings: Record<string, unknown>) {
+  if (typeof settings.engine === 'string' && settings.engine) return settings.engine;
+  const text = sourceHead(path.join(root, main));
+  const rc = [path.join(path.dirname(main), '.latexmkrc'), path.join(path.dirname(main), 'latexmkrc'), '.latexmkrc', 'latexmkrc'].find(file => fs.existsSync(path.join(root, file)));
+  const mode = rc ? fs.readFileSync(path.join(root, rc), 'utf8').match(/^\s*\$pdf_mode\s*=\s*(\d)/m)?.[1] : undefined;
+  return text.match(/^%\s*!\s*TEX\s+(?:TS-)?program\s*=\s*(pdflatex|xelatex|lualatex)/im)?.[1].toLowerCase() || ({ '1': 'pdflatex', '4': 'lualatex', '5': 'xelatex' } as Record<string, string>)[mode || ''] || (/\\(?:usepackage(?:\[[^\]]*\])?\{[^}]*\b(?:fontspec|xeCJK|unicode-math|polyglossia)\b|documentclass(?:\[[^\]]*\])?\{ctex)/.test(text) ? 'xelatex' : 'pdflatex');
+}
+// Keep the author's settings, including a source folder that still contains
+// the main file; without one, the whole folder compiles.
+function rememberMain(root: string, main: string, engine: string) {
+  const settings = config(root), folder = typeof settings.source_dir === 'string' ? settings.source_dir.replace(/\/+$/, '') : null;
+  const contains = folder === '' || (folder !== null && main.startsWith(folder + '/'));
+  const next = { ...settings, main, engine, ...(contains ? {} : { source_dir: '' }) };
+  if (JSON.stringify(next) !== JSON.stringify(settings)) fs.writeFileSync(path.join(root, CONFIG), JSON.stringify(next, null, 2) + '\n');
+}
 async function repositoryRoot(root: string) {
   let top: string | undefined;
   try { top = await git(root, 'rev-parse', '--show-toplevel'); } catch { /* A plain folder needs Git. */ }
@@ -115,6 +122,28 @@ export async function prepareRepository(root: string) {
   await git(root, 'add', '--all');
   await git(root, '-c', 'user.name=Papilot', '-c', 'user.email=papilot@localhost', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-qm', 'Import paper into Papilot');
 }
+// The desktop app opens a folder the way an editor does. A paper already in
+// Papilot opens again; any other folder with a clear main file is added as it
+// is and compiles in its own view. Only a folder with several possible main
+// files returns them, so the author can pick one.
+export async function openFolder(input: { path?: unknown; main?: unknown }, known: (root: string) => Project | undefined, register: (root: string, name: string) => Promise<Project>): Promise<{ project: Project } | { name: string; candidates: string[] }> {
+  if (typeof input.path !== 'string' || !input.path.trim()) throw new Error('Enter a folder path.');
+  const root = fs.realpathSync(input.path);
+  if (!fs.statSync(root).isDirectory()) throw new Error('Select a folder containing the paper.');
+  const project = known(root);
+  if (project) return { project };
+  await repositoryRoot(root);
+  const detected = await inspectPaper(root);
+  if (detected.error) throw new Error(detected.error);
+  if (input.main === undefined && !detected.main) {
+    if (!detected.candidates.length) throw new Error('Select a folder containing the paper.');
+    return { name: path.basename(root), candidates: detected.candidates };
+  }
+  const main = input.main ?? detected.main;
+  if (!existingTex(root, main)) throw new Error('Choose an existing TeX main file.');
+  rememberMain(root, main, engineFor(root, main, config(root)));
+  return { project: await register(root, path.basename(root)) };
+}
 export async function extractZip(buffer: Buffer, root: string) {
   if (buffer.length > MAX_BYTES) throw new Error('Choose a ZIP smaller than 64 MB.');
   const zip = await new Promise<yauzl.ZipFile>((resolve, reject) => yauzl.fromBuffer(buffer, { lazyEntries: true, strictFileNames: true, validateEntrySizes: true }, (error, value) => error ? reject(error) : resolve(value)));
@@ -149,7 +178,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,19 +238,12 @@ 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 {
         await repositoryRoot(value.path);
-        if (!repair) {
-          // Keep the author's settings, including a source folder that still
-          // contains the main file; without one, the whole folder compiles.
-          const settings = config(value.path), folder = typeof settings.source_dir === 'string' ? settings.source_dir.replace(/\/+$/, '') : null;
-          const contains = folder === '' || (folder !== null && (main as string).startsWith(folder + '/'));
-          const next = { ...settings, main, engine, ...(contains ? {} : { source_dir: '' }) };
-          if (JSON.stringify(next) !== JSON.stringify(settings)) fs.writeFileSync(path.join(value.path, CONFIG), JSON.stringify(next, null, 2) + '\n');
-        }
+        if (!repair) rememberMain(value.path, main as string, engine as string);
         await prepareRepository(value.path); value.versioned = true;
         if (repair) { value.summary = await repair(value.path, previousError); Object.assign(value, await inspectPaper(value.path)); }
         value.phase = 'building'; this.save(value);
@@ -227,10 +251,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(),