papilot 0.8.5 → 0.8.6

package/dist/index.html

@@ -8,6 +8,6 @@
   document.documentElement.dataset.theme = dark ? 'dark' : 'light';
   document.querySelector('meta[name="theme-color"]').content = dark ? '#26272b' : '#ffffff';
 })();
-</script><style>html{--lightningcss-light:initial;--lightningcss-dark: ;color-scheme:light;background:#fff}html[data-theme=dark]{--lightningcss-light: ;--lightningcss-dark:initial;color-scheme:dark;background:#26272b}</style>  <script type="module" crossorigin src="/assets/index-DSWizoaI.js"></script>
+</script><style>html{--lightningcss-light:initial;--lightningcss-dark: ;color-scheme:light;background:#fff}html[data-theme=dark]{--lightningcss-light: ;--lightningcss-dark:initial;color-scheme:dark;background:#26272b}</style>  <script type="module" crossorigin src="/assets/index-Dm7AYM9e.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-PFQDdu53.css">
 </head><body><div id="root"></div></body></html>

package/engine/src/core/build.ts

@@ -263,12 +263,13 @@ export class Builder {
         fs.utimesSync(folder, new Date(), new Date());
         return cached;
       }
-      // A full build continues from the latest completed one, or from the
-      // author's own latexmk output, as latexmk does when a folder is
-      // compiled again: unchanged files are cloned and LaTeX keeps its state,
-      // so it reruns only as often as the edit requires. Manual recompilation
-      // starts clean, and so does a retry when leftover state broke a build.
-      const start = partial || options.force ? null : this.latest(context) ?? "author";
+      // A build continues from the latest completed one with the same
+      // targets, or a full build from the author's own latexmk output, as
+      // latexmk does when a folder is compiled again: unchanged files are
+      // cloned and LaTeX keeps its state, so it reruns only as often as the
+      // edit requires. Manual recompilation starts clean, and so does a retry
+      // when leftover state broke a build.
+      const start = options.force ? null : this.latest(context, targets) ?? (partial ? null : "author");
       let result: BuildInfo;
       try {
         result = await this.compile(rev, tree, key, targets, seed, date, start, options.progress);
@@ -276,15 +277,21 @@ export class Builder {
         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, options.progress);
       }
-      if (!partial) writeJson(path.join(this.cache, "latest.json"), { key, context, date: date.SOURCE_DATE_EPOCH });
+      writeJson(this.latestFile(targets), { key, context, date: date.SOURCE_DATE_EPOCH });
       return result;
     });
   }
-  private latest(context: string): { info: BuildInfo; date: unknown } | null {
-    const latest = readJson<{ key?: unknown; context?: unknown; date?: unknown } | null>(path.join(this.cache, "latest.json"), null);
+  // Review rounds build the same chapters again and again (\includeonly), so
+  // each set of targets continues from its own latest build.
+  private latestFile(targets: string[]) {
+    const name = JSON.stringify(targets) === '["full"]' ? "latest.json" : `latest-${hash(JSON.stringify(targets)).slice(0, 16)}.json`;
+    return path.join(this.cache, name);
+  }
+  private latest(context: string, targets: string[]): { info: BuildInfo; date: unknown } | null {
+    const latest = readJson<{ key?: unknown; context?: unknown; date?: unknown } | null>(this.latestFile(targets), null);
     if (typeof latest?.key !== "string" || !/^[0-9a-f]{32}$/.test(latest.key) || latest.context !== context) return null;
     const info = readJson<BuildInfo | null>(path.join(this.cache, latest.key, "result.json"), null);
-    return info && JSON.stringify(info.targets) === '["full"]' && fs.existsSync(info.pdf) && fs.existsSync(info.root) ? { info, date: latest.date } : null;
+    return info && JSON.stringify(info.targets) === JSON.stringify(targets) && fs.existsSync(info.pdf) && fs.existsSync(info.root) ? { info, date: latest.date } : null;
   }
   private async compile(
     rev: string,
@@ -353,12 +360,16 @@ export class Builder {
       "-file-line-error",
     ];
     if (partial) {
-      const seedOut = path.dirname(seed!.pdf);
+      // Chapters outside \includeonly keep the seed's auxiliary files, also
+      // when this build continues from an earlier one built on another seed.
+      // latexmk compares contents, so an unchanged chapter causes no rerun.
+      const seedOut = path.dirname(seed!.pdf),
+        others = new Set(included.filter((target) => !targets.includes(target)).map((target) => path.join(...target.split("/")) + ".aux"));
       for (const file of listFiles(seedOut))
         if (AUXILIARY.has(path.extname(file))) {
-          const target = path.join(out, path.relative(seedOut, file));
+          const relative = path.relative(seedOut, file), target = path.join(out, relative);
           fs.mkdirSync(path.dirname(target), { recursive: true });
-          if (!fs.existsSync(target)) fs.copyFileSync(file, target);
+          if (!fs.existsSync(target) || others.has(relative)) fs.copyFileSync(file, target);
         }
       const preload = Object.entries(p.preload)
         .filter(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papilot",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "description": "A Cursor-like workspace for your papers: annotate and review PDFs directly without ever touching LaTeX.",
   "keywords": [
     "latex",

package/src/server/update-install.ts

@@ -106,7 +106,10 @@ async function installDev(data: string, version: string) {
 const INSTALL_FAILED = 'The new version could not be installed. Check the connection and available disk space, then retry.';
 // Release assets redirect from github.com to GitHub's download hosts. Each hop
 // stays on HTTPS and on those hosts (or on the smoke test's local source).
-export async function download(url: string, fetcher: typeof fetch, limit: number) {
+// With missing, a file that does not exist resolves to null.
+export async function download(url: string, fetcher: typeof fetch, limit: number, missing: true): Promise<Buffer | null>;
+export async function download(url: string, fetcher: typeof fetch, limit: number): Promise<Buffer>;
+export async function download(url: string, fetcher: typeof fetch, limit: number, missing = false): Promise<Buffer | null> {
   const source = process.env.PAPILOT_DESKTOP_UPDATE_SOURCE ? new URL(process.env.PAPILOT_DESKTOP_UPDATE_SOURCE).origin : null;
   const trusted = (address: URL) => address.origin === source
     || address.protocol === 'https:' && (address.hostname === 'github.com' || address.hostname.endsWith('.githubusercontent.com'));
@@ -116,6 +119,7 @@ export async function download(url: string, fetcher: typeof fetch, limit: number
     const response = await fetcher(address.href, { signal: AbortSignal.timeout(300000), redirect: 'manual', headers: { Accept: 'application/octet-stream', 'User-Agent': 'Papilot' } });
     const location = response.headers.get('location');
     if (response.status >= 300 && response.status < 400 && location) { address = new URL(location, address); continue; }
+    if (missing && response.status === 404) return null;
     if (!response.ok || Number(response.headers.get('content-length') || 0) > limit) throw new Error(INSTALL_FAILED);
     const bytes = Buffer.from(await response.arrayBuffer());
     if (bytes.length > limit) throw new Error(INSTALL_FAILED);

package/src/server/updates.ts

@@ -8,9 +8,8 @@ import type { UpdateChannel, UpdateStatus } from '../shared.ts';
 
 const activePhases = new Set(['installing', 'waiting', 'restarting']);
 export const alive = (pid: number) => { try { process.kill(pid, 0); return true; } catch { return false; } };
-async function releaseInfo(url: string, fetcher: typeof fetch, limit = 256000, missing?: null) {
+async function releaseInfo(url: string, fetcher: typeof fetch, limit = 256000) {
   const response = await fetcher(url, { signal: AbortSignal.timeout(10000), redirect: 'error', headers: { Accept: 'application/json', 'User-Agent': 'Papilot' } });
-  if (response.status === 404 && missing === null) return null;
   if (!response.ok) throw new Error('Could not check for updates.');
   const text = await response.text();
   if (text.length > limit) throw new Error('Invalid release information.');
@@ -34,53 +33,29 @@ export const latestRelease = async (channel: UpdateChannel = 'stable', fetcher =
 export const DESKTOP_RELEASES = 'https://github.com/PapilotAI/papilot/releases';
 // Nightly builds of main replace the assets of this one prerelease.
 export const DESKTOP_DEV_TAG = 'desktop-dev';
-const DESKTOP_API = 'https://api.github.com/repos/PapilotAI/papilot';
-// The smoke test serves releases locally.
-const desktopApi = () => process.env.PAPILOT_DESKTOP_UPDATE_SOURCE ? process.env.PAPILOT_DESKTOP_UPDATE_SOURCE.replace(/\/+$/, '') + '/repos/PapilotAI/papilot' : DESKTOP_API;
+// Release downloads, not the rate-limited REST API. The smoke test serves
+// them locally.
+const desktopDownloads = () => (process.env.PAPILOT_DESKTOP_UPDATE_SOURCE ? process.env.PAPILOT_DESKTOP_UPDATE_SOURCE.replace(/\/+$/, '') + '/PapilotAI/papilot/releases' : DESKTOP_RELEASES);
 export interface DesktopRelease { version: string; downloadUrl: string; layer?: DesktopLayer }
-const asset = (release: any, name: unknown) => release.assets.find((asset: any) => asset.name === name && asset.state === 'uploaded' && asset.size > 0 && typeof asset.browser_download_url === 'string');
-// desktop.json (written by scripts/desktop-layer.mjs) names the release's
-// version, its update layer and the installer shell that layer runs on.
-async function desktopManifest(release: any, fetcher: typeof fetch) {
-  const listed = asset(release, 'desktop.json');
-  if (!listed) return null;
-  try { return JSON.parse((await download(listed.browser_download_url, fetcher, 64 * 1024)).toString('utf8')); }
-  catch { throw new Error('Could not check for updates.'); }
-}
-function desktopLayer(release: any, manifest: any, version: string, fingerprint: string): DesktopLayer | undefined {
-  const layer = manifest?.layer, file = layer && asset(release, layer.name);
-  if (!fingerprint || manifest?.format !== 1 || manifest.version !== version || manifest.fingerprint !== fingerprint || !file || file.size !== layer.size || !/^[a-f0-9]{64}$/.test(layer.sha256)) return undefined;
-  return { url: file.browser_download_url, size: layer.size, sha256: layer.sha256 };
-}
-// Stable: npm can be published before desktop builds finish. Only advertise
-// releases with an uploaded installer for this OS and CPU, and link to that
-// exact release. Dev: the latest nightly build of main. Either includes the update layer
-// when it was built for this installer's shell (fingerprint).
-export async function latestDesktopRelease(platform = process.platform, arch = process.arch, fetcher = fetch, channel: UpdateChannel = 'stable', fingerprint = ''): Promise<DesktopRelease | null> {
-  if (channel === 'dev') {
-    const release = await releaseInfo(`${desktopApi()}/releases/tags/${DESKTOP_DEV_TAG}`, fetcher, 4 * 1024 * 1024, null);
-    if (!release) return null;
-    if (!Array.isArray(release.assets) || release.draft !== false) throw new Error('Invalid release information.');
-    const manifest = await desktopManifest(release, fetcher);
-    if (!manifest) return null;
-    if (!devRevision(manifest.version)) throw new Error('Invalid release information.');
-    const layer = desktopLayer(release, manifest, manifest.version, fingerprint);
-    return { version: manifest.version, downloadUrl: `${DESKTOP_RELEASES}/tag/${DESKTOP_DEV_TAG}`, ...(layer ? { layer } : {}) };
-  }
-  const releases = await releaseInfo(`${desktopApi()}/releases?per_page=100`, fetcher, 4 * 1024 * 1024);
-  if (!Array.isArray(releases)) throw new Error('Invalid release information.');
-  let latest: { version: string; downloadUrl: string; release: any } | null = null;
-  for (const release of releases) {
-    const version = typeof release.tag_name === 'string' ? release.tag_name.replace(/^v/, '') : '';
-    if (release.draft !== false || release.prerelease !== false || !stableVersion(version) || !Array.isArray(release.assets)) continue;
-    const names = platform === 'darwin' && ['arm64', 'x64'].includes(arch) ? [`Papilot-${version}-mac-${arch}.dmg`, `Papilot-${version}-mac-${arch}.zip`]
-      : platform === 'linux' && ['arm64', 'x64'].includes(arch) ? [`Papilot-${version}-linux-${arch === 'x64' ? 'x86_64' : arch}.AppImage`, `Papilot-${version}-linux-${arch === 'x64' ? 'amd64' : arch}.deb`] : [];
-    if (!release.assets.some((asset: any) => asset.state === 'uploaded' && asset.size > 0 && names.includes(asset.name))) continue;
-    if (!latest || newerVersion(version, latest.version)) latest = { version, downloadUrl: `${DESKTOP_RELEASES}/tag/${release.tag_name}`, release };
-  }
-  if (!latest) return null;
-  const layer = fingerprint ? desktopLayer(latest.release, await desktopManifest(latest.release, fetcher), latest.version, fingerprint) : undefined;
-  return { version: latest.version, downloadUrl: latest.downloadUrl, ...(layer ? { layer } : {}) };
+// desktop.json (written by scripts/desktop-layer.mjs, uploaded after every
+// other asset of its release) names the version, its update layer and the
+// installer shell that layer runs on. Stable: the latest release. Dev: the
+// latest nightly build of main. The layer is offered only to that shell.
+export async function latestDesktopRelease(fetcher = fetch, channel: UpdateChannel = 'stable', fingerprint = ''): Promise<DesktopRelease | null> {
+  const folder = channel === 'dev' ? `download/${DESKTOP_DEV_TAG}` : 'latest/download';
+  let manifest: any;
+  try {
+    const bytes = await download(`${desktopDownloads()}/${folder}/desktop.json`, fetcher, 64 * 1024, true);
+    if (!bytes) return null;
+    manifest = JSON.parse(bytes.toString('utf8'));
+  } catch { throw new Error('Could not check for updates.'); }
+  const version = manifest?.version;
+  if (manifest?.format !== 1 || (channel === 'dev' ? !devRevision(version) : !stableVersion(version))) throw new Error('Invalid release information.');
+  const tag = channel === 'dev' ? DESKTOP_DEV_TAG : `v${version}`, layer = manifest.layer;
+  const usable = fingerprint && manifest.fingerprint === fingerprint && typeof layer?.name === 'string' && /^papilot-app-[\w.-]+\.tgz$/.test(layer.name)
+    && Number.isSafeInteger(layer.size) && layer.size > 0 && /^[a-f0-9]{64}$/.test(layer.sha256);
+  return { version, downloadUrl: `${DESKTOP_RELEASES}/tag/${tag}`,
+    ...(usable ? { layer: { url: `${desktopDownloads()}/download/${tag}/${layer.name}`, size: layer.size, sha256: layer.sha256 } } : {}) };
 }
 const validTarget = (version: unknown, channel: UpdateChannel): version is string => channel === 'dev' ? Boolean(devRevision(version)) : stableVersion(version);
 const available = (next: string, current: string, channel: UpdateChannel) => validTarget(next, channel)
@@ -197,7 +172,7 @@ export class Updates {
     return this.checking;
   }
   private desktopRelease(channel: UpdateChannel) {
-    return (this.options.latestDesktop || (channel => latestDesktopRelease(process.platform, process.arch, fetch, channel, this.options.bundle?.fingerprint)))(channel);
+    return (this.options.latestDesktop || (channel => latestDesktopRelease(fetch, channel, this.options.bundle?.fingerprint)))(channel);
   }
   // A retry after a restart finds the release again; the check that offered it
   // happened in the previous process.