@open-press/core 1.1.4 → 1.2.0

package/engine/cli.mjs

@@ -85,8 +85,8 @@ Commands:
   preview --renderer react [--host 127.0.0.1] [--port 5173] [--no-build] [--dry-run]
   dev --renderer react [--host 127.0.0.1] [--port 5173] [--no-build] [--dry-run]
   typecheck
-  image [--output <outputDir>] [--pages <selector>] [--no-build] [--dry-run]
-  pdf [--output <outputDir>/<pdf.filename>] [--no-build] [--dry-run]
+  image [--output <outputDir>] [--press <slug>] [--pages <selector>] [--no-build] [--dry-run]
+  pdf [--output <outputDir>/<pdf.filename>] [--press <slug>] [--no-build] [--dry-run]
   deploy --confirm [--dry-run]
   doctor [--json] [--no-cache]                          # version + skill staleness check
   upgrade [--dry-run] [--no-deps] [--no-skills] [--json] # apply updates; agent-driven

package/engine/commands/_shared.mjs

@@ -41,6 +41,7 @@ export function parseOptions(argv) {
     else if (value === "--source") options.source = argv[++i];
     else if (value === "--output") options.output = argv[++i];
     else if (value === "--pages") options.pages = argv[++i];
+    else if (value === "--press") options.press = argv[++i];
     else if (value.startsWith("--")) throw new Error(`Unknown option: ${value}`);
     else positional.push(value);
   }
@@ -103,6 +104,52 @@ export async function buildReactStatic({ root, noBuild = false, recurse, silent
   return result.status ?? 1;
 }
 
+export async function resolvePressSelection({ outputDir, slug }) {
+  const manifestPath = path.join(outputDir, "openpress", "workspace.json");
+  let manifest;
+  try {
+    const body = await fs.readFile(manifestPath, "utf8");
+    manifest = JSON.parse(body);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      throw new Error(
+        `Cannot resolve --press: workspace manifest not found at ${manifestPath}. ` +
+          `Run a render first (or drop --no-build) so the manifest is regenerated.`,
+      );
+    }
+    throw error;
+  }
+  const presses = Array.isArray(manifest?.presses) ? manifest.presses : [];
+  if (presses.length === 0) {
+    throw new Error(`Workspace manifest at ${manifestPath} declares no Press entries.`);
+  }
+  const knownSlugs = presses.map((press) => press.slug || "").filter(Boolean);
+  const normalized = typeof slug === "string" ? slug.trim().replace(/^\/+|\/+$/g, "") : "";
+  if (!normalized) {
+    return { slug: presses[0].slug ?? "", title: presses[0].title ?? "", knownSlugs };
+  }
+  const match = presses.find((press) => (press.slug ?? "").replace(/^\/+|\/+$/g, "") === normalized);
+  if (!match) {
+    const listed = knownSlugs.length > 0 ? knownSlugs.join(", ") : "(none — workspace has no slugged presses)";
+    throw new Error(`Unknown --press "${slug}". Known slugs: ${listed}.`);
+  }
+  return { slug: match.slug ?? "", title: match.title ?? "", knownSlugs };
+}
+
+function pressPrintUrl(host, port, slug) {
+  const normalized = (slug ?? "").replace(/^\/+|\/+$/g, "");
+  if (!normalized) return `http://${host}:${port}/?print=1`;
+  return `http://${host}:${port}/${normalized}?print=1`;
+}
+
+function pressSuffixedFilename(baseFilename, slug) {
+  const normalized = (slug ?? "").replace(/^\/+|\/+$/g, "");
+  if (!normalized) return baseFilename;
+  const ext = path.extname(baseFilename);
+  const stem = ext ? baseFilename.slice(0, -ext.length) : baseFilename;
+  return `${stem}-${normalized}${ext}`;
+}
+
 export async function buildReactPdf({
   root,
   config,
@@ -111,31 +158,44 @@ export async function buildReactPdf({
   port = "5185",
   noBuild = false,
   recurse,
+  pressSlug = null,
 }) {
   config ??= await loadConfig(root);
-  outPath ??= config.paths.pdf;
   const renderCode = await buildReactStatic({ root, noBuild, recurse });
   if (renderCode !== 0) throw new Error(`React render failed with exit code ${renderCode}`);
   await optimizePdfMediaForStaticRoot(config.paths.outputDir);
+
+  const selection = pressSlug
+    ? await resolvePressSelection({ outputDir: config.paths.outputDir, slug: pressSlug })
+    : { slug: "", title: "", knownSlugs: [] };
+
+  if (!outPath) {
+    const filename = selection.slug
+      ? pressSuffixedFilename(config.pdf.filename, selection.slug)
+      : config.pdf.filename;
+    outPath = path.join(config.paths.outputDir, filename);
+  }
   await fs.mkdir(path.dirname(outPath), { recursive: true });
 
   const server = await startStaticServer(root, config, host, port);
   try {
-    const pageCount = await printUrlToPdf({
+    const result = await printUrlToPdf({
       root,
-      url: `http://${host}:${port}/?print=1`,
+      url: pressPrintUrl(host, port, selection.slug),
       outPath,
       waitForReady: waitForPrintReady,
       debuggingPortBase: 9300,
       debuggingPortRange: 600,
       profilePrefix: "chrome-pdf",
     });
-    console.log(`${pageCount} OpenPress pages printed to PDF`);
+    const pageCount = result?.pageCount ?? result;
+    const pressLabel = selection.slug ? ` (press: ${selection.title || selection.slug})` : "";
+    console.log(`${pageCount} OpenPress pages printed to PDF${pressLabel}`);
   } finally {
     await stopChildProcess(server);
   }
 
-  return { pdfPath: outPath };
+  return { pdfPath: outPath, pressSlug: selection.slug };
 }
 
 export async function buildReactImages({
@@ -147,18 +207,27 @@ export async function buildReactImages({
   noBuild = false,
   recurse,
   pageSelector = null,
+  pressSlug = null,
 }) {
   config ??= await loadConfig(root);
-  outDir ??= path.join(config.paths.outputDir, "images");
   const renderCode = await buildReactStatic({ root, noBuild, recurse });
   if (renderCode !== 0) throw new Error(`React render failed with exit code ${renderCode}`);
+
+  const selection = pressSlug
+    ? await resolvePressSelection({ outputDir: config.paths.outputDir, slug: pressSlug })
+    : { slug: "", title: "", knownSlugs: [] };
+
+  if (!outDir) {
+    const folder = selection.slug ? `images-${selection.slug}` : "images";
+    outDir = path.join(config.paths.outputDir, folder);
+  }
   await fs.mkdir(outDir, { recursive: true });
 
   const server = await startStaticServer(root, config, host, port);
   try {
     const result = await captureUrlPagesToPng({
       root,
-      url: `http://${host}:${port}/?print=1`,
+      url: pressPrintUrl(host, port, selection.slug),
       outDir,
       waitForReady: waitForPrintReady,
       debuggingPortBase: 9700,
@@ -166,15 +235,17 @@ export async function buildReactImages({
       profilePrefix: "chrome-image",
       pageSelector,
     });
-    const label = pageSelector
+    const pressLabel = selection.slug ? ` (press: ${selection.title || selection.slug})` : "";
+    const countLabel = pageSelector
       ? `${result.files.length}/${result.pageCount} OpenPress pages exported to PNG`
       : `${result.files.length} OpenPress pages exported to PNG`;
-    console.log(label);
+    console.log(`${countLabel}${pressLabel}`);
     return {
       outDir,
       files: result.files,
       pageCount: result.pageCount,
       selectedPageNumbers: result.selectedPageNumbers,
+      pressSlug: selection.slug,
     };
   } finally {
     await stopChildProcess(server);

package/engine/commands/image.mjs

@@ -3,20 +3,25 @@ import { STATIC_SERVER, buildReactImages, formatNodeScriptCommand, formatOpenPre
 import { parsePageSelector } from "../runtime/page-selector.mjs";
 
 export async function run({ root, config, options, recurse }) {
-  const outputDir = options.output ? path.resolve(root, options.output) : path.join(config.paths.outputDir, "images");
+  const outputDir = options.output ? path.resolve(root, options.output) : undefined;
   const host = options.host ?? "127.0.0.1";
   const port = options.port ?? "5186";
 
   const pageSelector = options.pages ? parsePageSelector(options.pages) : null;
+  const pressSlug = options.press ?? null;
 
   if (options.dryRun) {
+    const pressPath = pressSlug ? `/${String(pressSlug).replace(/^\/+|\/+$/g, "")}` : "";
+    const previewDir = outputDir
+      ?? path.join(config.paths.outputDir, pressSlug ? `images-${String(pressSlug).replace(/^\/+|\/+$/g, "")}` : "images");
     console.log(`Command: ${formatOpenPressCommand(["render", ".", "--renderer", "react"])}`);
     console.log(`Command: ${formatNodeScriptCommand(root, STATIC_SERVER)} ${config.outputDir} --host ${host} --port ${port} --workspace .`);
-    console.log(`Chrome image export URL: http://${host}:${port}/?print=1`);
+    console.log(`Chrome image export URL: http://${host}:${port}${pressPath}/?print=1`);
+    if (pressSlug) console.log(`Press: ${pressSlug} (validated against workspace manifest at run time)`);
     if (pageSelector) {
       console.log(`Page selector: ${options.pages} (resolved at capture time against the rendered page count)`);
     }
-    console.log(`Output: ${path.relative(root, path.join(outputDir, "page-001.png"))}`);
+    console.log(`Output: ${path.relative(root, path.join(previewDir, "page-001.png"))}`);
     return 0;
   }
 
@@ -29,6 +34,7 @@ export async function run({ root, config, options, recurse }) {
     noBuild: options.noBuild,
     recurse,
     pageSelector,
+    pressSlug,
   });
 
   const suffix = pageSelector

package/engine/commands/pdf.mjs

@@ -7,9 +7,11 @@ export async function run({ root, config, options, recurse }) {
     const relOutput = path.relative(root, outputPath ?? config.paths.pdf);
     const host = options.host ?? "127.0.0.1";
     const port = options.port ?? "5185";
+    const pressPath = options.press ? `/${String(options.press).replace(/^\/+|\/+$/g, "")}` : "";
     console.log(`Command: ${formatOpenPressCommand(["render", ".", "--renderer", "react"])}`);
     console.log(`Command: ${formatNodeScriptCommand(root, STATIC_SERVER)} ${config.outputDir} --host ${host} --port ${port} --workspace .`);
-    console.log(`Command: Chrome --print-to-pdf=${relOutput} http://${host}:${port}/?print=1`);
+    console.log(`Command: Chrome --print-to-pdf=${relOutput} http://${host}:${port}${pressPath}/?print=1`);
+    if (options.press) console.log(`Press: ${options.press} (validated against workspace manifest at run time)`);
     return 0;
   }
   const result = await buildReactPdf({
@@ -20,6 +22,7 @@ export async function run({ root, config, options, recurse }) {
     port: options.port,
     noBuild: options.noBuild,
     recurse,
+    pressSlug: options.press ?? null,
   });
   console.log(`OpenPress PDF: ${path.relative(root, result.pdfPath)}`);
   return 0;

package/engine/output/chrome-pdf.mjs

@@ -101,6 +101,100 @@ export const DEFAULT_PRINT_VIEWPORT = Object.freeze({
   mobile: false,
 });
 
+export function pageGeometryProbeExpression() {
+  return `(() => {
+    if (!document.body) return null;
+    // OpenPressRuntime sets --openpress-page-width / -height on the
+    // PrintDocument <main> via inline style. The workspace's global
+    // theme also defines a *default* --openpress-page-width on :root
+    // (e.g. 210mm for the A4 preset). If we let getComputedStyle fall
+    // back to :root we will silently return that default before the
+    // print document has even rendered — and the per-document override
+    // never gets a chance to apply. Require the actual print surface
+    // so the probe waits until React paints it instead of locking in
+    // the wrong size from the workspace stylesheet.
+    const target = document.querySelector('[data-openpress-print-document="true"]')
+      || document.querySelector('.openpress-html-page');
+    if (!target) return null;
+    const cs = getComputedStyle(target);
+    const widthStr = cs.getPropertyValue('--openpress-page-width').trim();
+    const heightStr = cs.getPropertyValue('--openpress-page-height').trim();
+    if (!widthStr || !heightStr) return null;
+    const helper = document.createElement('div');
+    helper.style.position = 'absolute';
+    helper.style.left = '-99999px';
+    helper.style.top = '-99999px';
+    helper.style.visibility = 'hidden';
+    helper.style.pointerEvents = 'none';
+    helper.style.width = widthStr;
+    helper.style.height = heightStr;
+    document.body.appendChild(helper);
+    const rect = helper.getBoundingClientRect();
+    helper.remove();
+    if (!Number.isFinite(rect.width) || !Number.isFinite(rect.height) || rect.width <= 0 || rect.height <= 0) return null;
+    return { width: rect.width, height: rect.height };
+  })()`;
+}
+
+export async function measurePageGeometryPx(client, { timeoutMs = 5000, pollIntervalMs = 50 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await client.send("Runtime.evaluate", {
+      returnByValue: true,
+      expression: pageGeometryProbeExpression(),
+    });
+    const dims = result.result?.value;
+    if (dims && Number.isFinite(dims.width) && dims.width > 0) {
+      return { width: dims.width, height: dims.height };
+    }
+    await delay(pollIntervalMs);
+  }
+  return null;
+}
+
+export async function syncViewportToPageGeometry(client, viewport, options = {}) {
+  const dims = await measurePageGeometryPx(client, options);
+  if (!dims) return { viewport, pageDimensionsPx: null };
+  const targetWidth = Math.max(viewport.width, Math.ceil(dims.width));
+  const targetHeight = Math.max(viewport.height, Math.ceil(dims.height));
+  if (targetWidth === viewport.width && targetHeight === viewport.height) {
+    return { viewport, pageDimensionsPx: dims };
+  }
+  const next = { ...viewport, width: targetWidth, height: targetHeight };
+  await client.send("Emulation.setDeviceMetricsOverride", next);
+  return { viewport: next, pageDimensionsPx: dims };
+}
+
+// Chrome's Page.printToPDF takes paperWidth / paperHeight in inches and
+// honors them when preferCSSPageSize falls through. Because our @page
+// rule reads CSS custom properties scoped to <main> instead of :root,
+// preferCSSPageSize cannot resolve the size in headless Chrome — we have
+// to pass the inches explicitly. Convert from CSS px at the 1in = 96px
+// rate the rest of the runtime already assumes.
+//
+// Wider-than-tall geometries (slide 16:9, landscape pages) also need
+// `landscape: true`: with `landscape: false` Chrome silently rotates the
+// MediaBox to portrait so the short side becomes the width, leaving the
+// content laid out for the wide canvas but cropped against the short page.
+export function pageDimensionsPxToPaperInches(dims) {
+  if (!dims || !Number.isFinite(dims.width) || dims.width <= 0) return null;
+  if (!Number.isFinite(dims.height) || dims.height <= 0) return null;
+  // Chrome's printToPDF semantics: paperWidth/paperHeight are taken as
+  // *portrait* page dimensions, and `landscape: true` then rotates the
+  // canvas 90°. So for a 1920×1080 slide we have to pass the short side
+  // as paperWidth (11.25"), the long side as paperHeight (20"), and
+  // landscape: true — Chrome will produce a 20"×11.25" landscape page
+  // whose content frame matches the original 1920×1080 layout.
+  const widthIn = dims.width / 96;
+  const heightIn = dims.height / 96;
+  const landscape = widthIn > heightIn;
+  return {
+    paperWidth: landscape ? heightIn : widthIn,
+    paperHeight: landscape ? widthIn : heightIn,
+    landscape,
+  };
+}
+
 export async function printUrlToPdf({
   root,
   url,
@@ -139,6 +233,13 @@ export async function printUrlToPdf({
     try {
       await preparePdfPage(client, { viewport });
       await client.send("Page.navigate", { url });
+      // Widen the headless viewport when the document's page geometry is
+      // wider than the default A4 viewport, so layout uses the full page
+      // width before pagination. Paper size itself is driven by the
+      // @page rule in print-route.css, which now resolves
+      // --openpress-page-width / -height from :root (PrintDocument
+      // mirrors the per-document theme vars onto the document element).
+      await syncViewportToPageGeometry(client, viewport);
       const readyResult = await waitForReady(client);
       warnAboutOverflowingPages("PDF", readyResult);
       const result = await client.send("Page.printToPDF", {
@@ -205,6 +306,7 @@ export async function captureUrlPagesToPng({
     try {
       await preparePdfPage(client, { viewport });
       await client.send("Page.navigate", { url });
+      await syncViewportToPageGeometry(client, viewport);
       const readyResult = await waitForReady(client);
       warnAboutOverflowingPages("image", readyResult);
       const pageCount = readyResult?.pageCount ?? 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-press/core",
-  "version": "1.1.4",
+  "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",