@open-press/core 1.1.3 → 1.2.0

package/engine/output/static-server.mjs

@@ -208,13 +208,18 @@ async function handleLocalPdfExportRequest(req, res) {
     return;
   }
 
-  const result = await runLocalPdfExport();
-  const exists = await fileExists(config.paths.pdf);
+  const body = await readJsonBody(req);
+  const slug = normalizePressSlug(body?.press);
+  const result = await runLocalPdfExport(slug);
+  const pdfPath = pressPdfPath(slug);
+  const exists = await fileExists(pdfPath);
+  const command = slug ? `open-press pdf . --press ${slug}` : "open-press pdf .";
+  const pdfUrl = `/__openpress/local-pdf-file?${slug ? `press=${encodeURIComponent(slug)}&` : ""}ts=${Date.now()}`;
   writeJson(res, result.code === 0 && exists ? 200 : 500, {
     ok: result.code === 0 && exists,
     code: result.code,
-    pdf: `/__openpress/local-pdf-file?ts=${Date.now()}`,
-    command: "open-press pdf .",
+    pdf: pdfUrl,
+    command,
     stdout: result.stdout,
     stderr: result.stderr,
   });
@@ -226,11 +231,15 @@ async function handleLocalPdfFileRequest(req, res) {
     return;
   }
 
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  const slug = normalizePressSlug(url.searchParams.get("press"));
+  const pdfPath = pressPdfPath(slug);
+  const filename = pressFilename(config.pdf.filename, slug);
   try {
-    const body = await fs.readFile(config.paths.pdf);
+    const body = await fs.readFile(pdfPath);
     res.writeHead(200, {
       "Content-Type": "application/pdf",
-      "Content-Disposition": `inline; filename="${config.pdf.filename}"`,
+      "Content-Disposition": `inline; filename="${filename}"`,
       "Cache-Control": "no-store",
     });
     res.end(body);
@@ -239,6 +248,35 @@ async function handleLocalPdfFileRequest(req, res) {
   }
 }
 
+function normalizePressSlug(value) {
+  if (typeof value !== "string") return "";
+  return value.trim().replace(/^\/+|\/+$/g, "");
+}
+
+function pressFilename(baseFilename, slug) {
+  if (!slug) return baseFilename;
+  const ext = path.extname(baseFilename);
+  const stem = ext ? baseFilename.slice(0, -ext.length) : baseFilename;
+  return `${stem}-${slug}${ext}`;
+}
+
+function pressPdfPath(slug) {
+  return path.join(config.outputDir, pressFilename(config.pdf.filename, slug));
+}
+
+async function readJsonBody(req) {
+  try {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length === 0) return null;
+    const text = Buffer.concat(chunks.map((chunk) => (typeof chunk === "string" ? Buffer.from(chunk) : chunk))).toString("utf8");
+    if (!text.trim()) return null;
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
 async function handleDeployRequest(req, res) {
   if (req.method !== "POST") {
     writeJson(res, 405, { ok: false, message: "Deploy endpoint requires POST." });
@@ -356,9 +394,11 @@ async function handleMediaFileRequest(req, res, url) {
   }
 }
 
-function runLocalPdfExport() {
+function runLocalPdfExport(slug = "") {
+  const cliArgs = [CLI_ENTRY, "pdf", "."];
+  if (slug) cliArgs.push("--press", slug);
   return new Promise((resolve) => {
-    const child = spawn("node", [CLI_ENTRY, "pdf", "."], {
+    const child = spawn("node", cliArgs, {
       cwd: workspace,
       shell: false,
     });

package/engine/react/document-export.mjs

@@ -9,6 +9,7 @@ import { pathToFileURL } from "node:url";
 import React from "react";
 import { documentRelativePath, pageToBlock } from "../output/page-block.mjs";
 import { syncPublicAssets } from "../output/public-assets.mjs";
+import { collectSourceTextFiles } from "../runtime/source-text-tools.mjs";
 import { pageGeometryToTheme } from "../runtime/page-geometry.mjs";
 import { normalizePageGeometry } from "../runtime/page-geometry.mjs";
 import { createCaptionNumberingState, numberCaptionsInHtml } from "./caption-numbering.mjs";
@@ -125,6 +126,27 @@ export async function exportReactDocument(root = ".", { syncAssets = true } = {}
     const workspacePath = path.join(entry.config.paths.publicDir, "workspace.json");
     await fs.writeFile(workspacePath, JSON.stringify(workspaceManifest, null, 2), "utf8");
 
+    // Static search corpus — raw text of every content source file in the
+    // workspace, shipped as JSON so the deployed reader can search without
+    // a backend. Lives next to workspace.json so the public route can
+    // GET /openpress/search-corpus.json once and grep in memory. Workspace-
+    // scoped (not per-press) because most workspaces have a single Press
+    // and corpus size for typical content is small (<1MB raw); per-press
+    // scoping can come later if multi-Press search noise becomes a problem.
+    const corpusFiles = await collectSourceTextFiles(entry.config, { scope: "content" });
+    const corpus = {
+      kind: "search-corpus",
+      version: 1,
+      files: corpusFiles.map((file) => ({
+        scope: file.scope,
+        file: file.name,
+        path: file.relativePath,
+        text: file.text,
+      })),
+    };
+    const corpusPath = path.join(entry.config.paths.publicDir, "search-corpus.json");
+    await fs.writeFile(corpusPath, JSON.stringify(corpus), "utf8");
+
     if (syncAssets) {
       await syncPublicAssets(workspaceRoot, entry.config.paths.publicDir, entry.config);
     }

package/engine/runtime/inspection.mjs

@@ -139,9 +139,51 @@ export async function inspectRenderedOverflow({ root, config, host = "127.0.0.1"
   }
 }
 
-export async function waitForInspectionReady(client) {
-  const deadline = Date.now() + 30000;
-  while (Date.now() < deadline) {
+export const INSPECTION_READY_DEFAULTS = Object.freeze({
+  totalTimeoutMs: 300_000,
+  idleTimeoutMs: 30_000,
+  pollIntervalMs: 100,
+});
+
+export function resolveInspectionReadyTiming(env = process.env) {
+  const total = Number(env.OPENPRESS_INSPECTION_TIMEOUT_MS);
+  const idle = Number(env.OPENPRESS_INSPECTION_IDLE_MS);
+  return {
+    totalTimeoutMs: Number.isFinite(total) && total > 0 ? total : INSPECTION_READY_DEFAULTS.totalTimeoutMs,
+    idleTimeoutMs: Number.isFinite(idle) && idle > 0 ? idle : INSPECTION_READY_DEFAULTS.idleTimeoutMs,
+    pollIntervalMs: INSPECTION_READY_DEFAULTS.pollIntervalMs,
+  };
+}
+
+function formatInspectionTimeoutMessage(reason, snapshot, timing, elapsedMs) {
+  const seconds = Math.round(elapsedMs / 1000);
+  const observed = `(observed ${snapshot.pageCount} page(s))`;
+  if (reason === "idle") {
+    return (
+      `Timed out waiting for OpenPress pagination before inspection. ` +
+      `No progress for ${seconds}s ${observed}. ` +
+      `Raise OPENPRESS_INSPECTION_IDLE_MS (currently ${timing.idleTimeoutMs}ms) to extend the idle window.`
+    );
+  }
+  return (
+    `Timed out waiting for OpenPress pagination before inspection. ` +
+    `Total ${seconds}s exceeded ${observed}. ` +
+    `Raise OPENPRESS_INSPECTION_TIMEOUT_MS (currently ${timing.totalTimeoutMs}ms) to extend the hard cap.`
+  );
+}
+
+export async function waitForInspectionReady(client, timing = resolveInspectionReadyTiming()) {
+  const startedAt = Date.now();
+  let lastSignature = "";
+  let lastProgressAt = startedAt;
+  let lastSnapshot = { pageCount: 0 };
+
+  while (true) {
+    const totalElapsed = Date.now() - startedAt;
+    if (totalElapsed > timing.totalTimeoutMs) {
+      throw new Error(formatInspectionTimeoutMessage("total", lastSnapshot, timing, totalElapsed));
+    }
+
     const result = await client.send("Runtime.evaluate", {
       returnByValue: true,
       awaitPromise: true,
@@ -149,9 +191,23 @@ export async function waitForInspectionReady(client) {
     });
     const value = result.result?.value;
     if (Array.isArray(value)) return value;
-    await delay(100);
+
+    const pageCount = Number.isFinite(Number(value?.pageCount)) ? Number(value.pageCount) : lastSnapshot.pageCount;
+    lastSnapshot = { pageCount };
+
+    const signature = String(pageCount);
+    if (signature !== lastSignature) {
+      lastSignature = signature;
+      lastProgressAt = Date.now();
+    }
+
+    const idleElapsed = Date.now() - lastProgressAt;
+    if (idleElapsed > timing.idleTimeoutMs) {
+      throw new Error(formatInspectionTimeoutMessage("idle", lastSnapshot, timing, idleElapsed));
+    }
+
+    await delay(timing.pollIntervalMs);
   }
-  throw new Error("Timed out waiting for OpenPress pagination before inspection.");
 }
 
 export function overflowIssuesFromMeasurements(measurements) {
@@ -241,7 +297,9 @@ function humanOverflowTarget(code) {
 function inspectionExpression() {
   return `Promise.resolve().then(async () => {
     const root = document.querySelector('[data-openpress-print-document="true"]');
-    if (!root || root.querySelectorAll('.openpress-html-page').length === 0) return null;
+    if (!root) return { pending: true, pageCount: 0 };
+    const candidates = root.querySelectorAll('.openpress-html-page');
+    if (candidates.length === 0) return { pending: true, pageCount: 0 };
 
     await document.fonts?.ready;
     await Promise.all(Array.from(document.images).map(async (img) => {
@@ -290,7 +348,7 @@ function inspectionExpression() {
     };
 
     const wrappers = Array.from(document.querySelectorAll('.openpress-public-page > .openpress-html-page'));
-    if (wrappers.length === 0) return null;
+    if (wrappers.length === 0) return { pending: true, pageCount: candidates.length };
     return wrappers.map((wrapper, index) => {
       const page = wrapper.querySelector('.reader-page') || wrapper;
       const frame = page.querySelector('.page-frame') || page;

package/engine/runtime/page-selector.mjs

@@ -0,0 +1,87 @@
+const TOKEN_PATTERN = /^\s*(-?\d*)\s*(?:-\s*(\d*))?\s*$/;
+
+export function parsePageSelector(input) {
+  if (typeof input !== "string") {
+    throw new TypeError("Page selector must be a string");
+  }
+  const trimmed = input.trim();
+  if (trimmed === "") {
+    throw new Error("Page selector is empty; expected something like '3', '3,5-7', or '12-'.");
+  }
+
+  const segments = trimmed.split(",").map((part) => part.trim()).filter(Boolean);
+  if (segments.length === 0) {
+    throw new Error(`Page selector "${input}" has no usable segments.`);
+  }
+
+  return segments.map((segment) => parseSegment(segment, input));
+}
+
+function parseSegment(segment, original) {
+  if (!segment.includes("-")) {
+    const value = toPositiveInteger(segment, original);
+    return { kind: "single", value };
+  }
+
+  if (segment === "-") {
+    throw new Error(`Page selector "${original}" contains a bare "-"; ranges need at least one bound.`);
+  }
+
+  const dashIndex = segment.indexOf("-");
+  if (segment.indexOf("-", dashIndex + 1) !== -1) {
+    throw new Error(`Page selector segment "${segment}" has too many dashes.`);
+  }
+
+  const leftRaw = segment.slice(0, dashIndex);
+  const rightRaw = segment.slice(dashIndex + 1);
+  const from = leftRaw.trim() === "" ? null : toPositiveInteger(leftRaw, original);
+  const to = rightRaw.trim() === "" ? null : toPositiveInteger(rightRaw, original);
+
+  if (from != null && to != null && from > to) {
+    throw new Error(`Page selector range "${segment}" goes backwards (${from} > ${to}).`);
+  }
+
+  return { kind: "range", from, to };
+}
+
+function toPositiveInteger(raw, original) {
+  const trimmed = raw.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(`Page selector "${original}" contains non-integer token "${raw}".`);
+  }
+  const value = Number(trimmed);
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`Page selector "${original}" contains out-of-range page number "${raw}"; pages start at 1.`);
+  }
+  return value;
+}
+
+export function resolvePageSelector(spec, totalPages) {
+  if (!Array.isArray(spec)) {
+    throw new TypeError("resolvePageSelector expects a parsed selector array");
+  }
+  if (!Number.isInteger(totalPages) || totalPages < 0) {
+    throw new TypeError("resolvePageSelector expects a non-negative integer totalPages");
+  }
+  if (totalPages === 0) return [];
+
+  const selected = new Set();
+  for (const segment of spec) {
+    if (segment.kind === "single") {
+      if (segment.value > totalPages) {
+        throw new Error(`Page ${segment.value} is out of range; document has ${totalPages} page(s).`);
+      }
+      selected.add(segment.value);
+      continue;
+    }
+    const from = segment.from ?? 1;
+    const to = segment.to ?? totalPages;
+    if (from > totalPages) {
+      throw new Error(`Range start ${from} is out of range; document has ${totalPages} page(s).`);
+    }
+    const upper = Math.min(to, totalPages);
+    for (let i = from; i <= upper; i += 1) selected.add(i);
+  }
+
+  return Array.from(selected).sort((a, b) => a - b);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-press/core",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "type": "module",
   "description": "open-press core — runtime primitives, CLI, and render pipeline for AI-first fixed-layout documents.",
   "license": "MIT",

package/src/openpress/app/OpenPressApp.tsx

@@ -250,6 +250,7 @@ export function OpenPressApp() {
       document={state.document}
       runtimeMode={state.runtimeMode}
       deploymentInfo={state.deploymentInfo}
+      activeSlug={state.activeSlug}
       onDocumentRefresh={refreshDocument}
       onOpenPresentation={openPresentation}
       onExitPresentation={exitPresentation}

package/src/openpress/app/OpenPressRuntime.tsx

@@ -1,4 +1,4 @@
-import { useMemo, type CSSProperties } from "react";
+import { useEffect, useMemo, useState, type CSSProperties } from "react";
 import { PrintDocument, PublicViewer, SlidePresentationPage } from "../reader";
 import { isPresentationModeLocation, isPrintModeLocation, isWorkspaceModeLocation } from "../shared";
 import { HtmlWorkbench } from "../workbench";
@@ -15,6 +15,12 @@ interface OpenPressRuntimeProps {
   document: ReaderDocument;
   runtimeMode?: OpenPressRuntimeMode;
   deploymentInfo?: DeploymentInfo;
+  // Active Press slug — supplied by OpenPressApp when the active document
+  // came from a multi-Press workspace. The workbench passes this through to
+  // useDeploymentWorkbench so the local PDF export endpoint can target the
+  // right Press instead of defaulting to the first one and producing a
+  // "0 pages observed" timeout.
+  activeSlug?: string;
   onDocumentRefresh?: () => void | Promise<void>;
   onOpenPresentation?: (pageIndex: number) => void;
   onExitPresentation?: (pageIndex: number) => void;
@@ -28,6 +34,7 @@ export function OpenPressRuntime({
   document,
   runtimeMode,
   deploymentInfo = { online: false },
+  activeSlug,
   onDocumentRefresh,
   onOpenPresentation,
   onExitPresentation,
@@ -35,19 +42,29 @@ export function OpenPressRuntime({
 }: OpenPressRuntimeProps) {
   const style = themeToCssVariables(document.theme);
   const htmlPages = document.blocks.filter((block): block is HtmlPageBlock => block.kind === "htmlPage");
+  // The mode flags below all read window.location synchronously. They
+  // would otherwise stay frozen at their mount-time values when
+  // OpenPressApp re-renders us in response to a client-side URL change
+  // (e.g. /<slug>/present -> /<slug>/preview after exiting the slide
+  // presenter), so the SlidePresentationPage exits to the wrong
+  // route-driven branch (PublicViewer instead of HtmlWorkbench) and the
+  // user sees the legacy public-viewer chrome until a hard reload.
+  // Bump a version on every pathname/search change so the memos
+  // re-evaluate exactly when the URL does.
+  const routeVersion = useLocationVersion();
   const activeRuntimeMode = useMemo<OpenPressRuntimeMode>(() => {
     if (runtimeMode) return runtimeMode;
     if (typeof window === "undefined") return "preview";
     return isPresentationModeLocation(window.location) ? "present" : "preview";
-  }, [runtimeMode]);
+  }, [runtimeMode, routeVersion]);
   const workspaceMode = useMemo(() => {
     if (typeof window === "undefined") return false;
     return isWorkspaceModeLocation(window.location);
-  }, []);
+  }, [routeVersion]);
   const printMode = useMemo(() => {
     if (typeof window === "undefined") return false;
     return isPrintModeLocation(window.location);
-  }, []);
+  }, [routeVersion]);
 
   if (htmlPages.length > 0) {
     if (printMode) {
@@ -74,8 +91,9 @@ export function OpenPressRuntime({
         document={document}
         pages={htmlPages}
         style={style}
-        devMode={workspaceMode}
+        workspaceMode={workspaceMode}
         deploymentInfo={deploymentInfo}
+        pressSlug={activeSlug ?? null}
         onDocumentRefresh={onDocumentRefresh}
         onOpenPresentation={onOpenPresentation}
         onBackToWorkspace={onBackToWorkspace}
@@ -110,6 +128,42 @@ function EmptyState({ style, workspaceMode }: { style: CSSProperties; workspaceM
   );
 }
 
+// Bump a counter whenever client-side navigation changes pathname /
+// search / hash, so location-derived memos in OpenPressRuntime
+// re-evaluate. popstate fires on browser back/forward; we also patch
+// pushState / replaceState because the SPA itself calls those when
+// the user opens a Press, exits a slide presenter, or toggles between
+// /<slug>/preview and /<slug>/present.
+function useLocationVersion() {
+  const [version, setVersion] = useState(0);
+  useEffect(() => {
+    if (typeof window === "undefined") return undefined;
+    const bump = () => setVersion((value) => value + 1);
+    window.addEventListener("popstate", bump);
+    window.addEventListener("hashchange", bump);
+    const history = window.history;
+    const originalPushState = history.pushState.bind(history);
+    const originalReplaceState = history.replaceState.bind(history);
+    history.pushState = function patchedPushState(...args) {
+      const result = originalPushState(...args);
+      bump();
+      return result;
+    } as typeof history.pushState;
+    history.replaceState = function patchedReplaceState(...args) {
+      const result = originalReplaceState(...args);
+      bump();
+      return result;
+    } as typeof history.replaceState;
+    return () => {
+      window.removeEventListener("popstate", bump);
+      window.removeEventListener("hashchange", bump);
+      history.pushState = originalPushState;
+      history.replaceState = originalReplaceState;
+    };
+  }, []);
+  return version;
+}
+
 function themeToCssVariables(theme?: Theme) {
   const style: CSSProperties & Record<`--${string}`, string> = {
     "--openpress-font-family": theme?.fontFamily ?? "'Noto Sans TC', 'PingFang TC', sans-serif",