@open-press/core 1.1.4 → 1.2.1

package/engine/cli.mjs

@@ -85,9 +85,9 @@ 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]
-  deploy --confirm [--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 [--press <slug>] [--dry-run]
   doctor [--json] [--no-cache]                          # version + skill staleness check
   upgrade [--dry-run] [--no-deps] [--no-skills] [--json] # apply updates; agent-driven
   migrate [--dry-run] [--no-deps] [--no-skills] [--json] # alias for upgrade; reads migration notes

package/engine/commands/_shared.mjs

@@ -4,7 +4,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { captureUrlPagesToPng, printUrlToPdf, stopChildProcess, waitForPrintReady } from "../output/chrome-pdf.mjs";
-import { loadConfig, publicPdfHref } from "../runtime/config.mjs";
+import { loadConfig } from "../runtime/config.mjs";
 import { exportDocument } from "../document-export.mjs";
 import { optimizePdfMediaForStaticRoot } from "../output/pdf-media.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,56 @@ 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`;
+}
+
+export 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 function publicPdfHrefForFilename(filename) {
+  return `/${filename}`;
+}
+
 export async function buildReactPdf({
   root,
   config,
@@ -111,31 +162,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 +211,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 +239,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);
@@ -223,18 +298,19 @@ export function startStaticServer(root, config, host, port) {
   });
 }
 
-export async function writePdfStageDeployConfig(root, source, config) {
+export async function writePdfStageDeployConfig(root, source, config, { pdfFilename = config.pdf.filename } = {}) {
   const deployRoot = path.resolve(root, source);
   const openpressDir = path.join(deployRoot, "openpress");
+  const pdfHref = publicPdfHrefForFilename(pdfFilename);
   await fs.mkdir(openpressDir, { recursive: true });
   await fs.writeFile(
     path.join(openpressDir, "deploy.json"),
-    `${JSON.stringify({ pdf: publicPdfHref(config), deployed_at: new Date().toISOString() }, null, 2)}\n`,
+    `${JSON.stringify({ pdf: pdfHref, deployed_at: new Date().toISOString() }, null, 2)}\n`,
     "utf8",
   );
   await fs.writeFile(
     path.join(deployRoot, "_headers"),
-    `${publicPdfHref(config)}\n  Content-Type: application/pdf\n  Content-Disposition: inline; filename="${config.pdf.filename}"\n`,
+    `${pdfHref}\n  Content-Type: application/pdf\n  Content-Disposition: inline; filename="${pdfFilename}"\n`,
     "utf8",
   );
 }

package/engine/commands/deploy.mjs

@@ -1,6 +1,12 @@
 import path from "node:path";
 import { deploySync } from "../output/deploy-sync.mjs";
-import { buildReactPdf, formatOpenPressCommand, runCommand, writePdfStageDeployConfig } from "./_shared.mjs";
+import {
+  buildReactPdf,
+  formatOpenPressCommand,
+  pressSuffixedFilename,
+  runCommand,
+  writePdfStageDeployConfig,
+} from "./_shared.mjs";
 
 export async function run({ root, config, options, recurse }) {
   if (config.deploy.requiresConfirmation === true && !options.confirm) {
@@ -10,11 +16,15 @@ export async function run({ root, config, options, recurse }) {
   const source = config.deploy.source;
   const projectName = config.deploy.projectName;
   const commitDirty = config.deploy.commitDirty;
+  const pressSlug = normalizePressSlug(options.press);
+  const pdfFilename = pressSuffixedFilename(config.pdf.filename, pressSlug);
+  const pdfArgs = ["pdf", ".", "--output", `${source}/${pdfFilename}`];
+  if (pressSlug) pdfArgs.push("--press", pressSlug);
   if (options.dryRun) {
     console.log("OpenPress deploy dry run");
     console.log(`Command: ${formatOpenPressCommand(["render", ".", "--renderer", "react"])}`);
     console.log(`Step:    deploy-sync (copy ${config.outputDir} → ${source})`);
-    console.log(`Command: ${formatOpenPressCommand(["pdf", ".", "--output", `${source}/${config.pdf.filename}`])}`);
+    console.log(`Command: ${formatOpenPressCommand(pdfArgs)}`);
     console.log(`Step:    write ${source}/openpress/deploy.json with deployment metadata`);
     console.log(`Command: npx wrangler pages deploy ${source}${projectName ? ` --project-name=${projectName}` : ""}${commitDirty ? " --commit-dirty=true" : ""}`);
     return 0;
@@ -22,10 +32,15 @@ export async function run({ root, config, options, recurse }) {
   const renderCode = await recurse("render", [root, "--renderer", "react"]);
   if (renderCode !== 0) return renderCode;
   await deploySync(root, config.outputDir, source);
-  await buildReactPdf({ root, config, outPath: path.resolve(root, source, config.pdf.filename), noBuild: true, recurse });
-  await writePdfStageDeployConfig(root, source, config);
+  await buildReactPdf({ root, config, outPath: path.resolve(root, source, pdfFilename), noBuild: true, recurse, pressSlug });
+  await writePdfStageDeployConfig(root, source, config, { pdfFilename });
   const wranglerArgs = ["wrangler", "pages", "deploy", source];
   if (projectName) wranglerArgs.push(`--project-name=${projectName}`);
   if (commitDirty) wranglerArgs.push("--commit-dirty=true");
   return runCommand("npx", wranglerArgs, root);
 }
+
+function normalizePressSlug(value) {
+  if (typeof value !== "string") return "";
+  return value.trim().replace(/^\/+|\/+$/g, "");
+}

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,12 +248,46 @@ 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." });
     return;
   }
 
+  const body = await readJsonBody(req);
+  const slug = normalizePressSlug(body?.press);
+  const command = slug ? `open-press deploy . --confirm --press ${slug}` : "open-press deploy . --confirm";
+  const pdfFilename = pressFilename(config.pdf.filename, slug);
+
   if (!isDeployConfigured()) {
     writeJson(res, 400, {
       ok: false,
@@ -254,15 +297,15 @@ async function handleDeployRequest(req, res) {
       deploy_adapter: config.deploy.adapter,
       deploy_source: config.deploy.source,
       deploy_project_name: config.deploy.projectName,
-      command: "open-press deploy . --confirm",
+      command,
     });
     return;
   }
 
-  const result = await runDeploy();
+  const result = await runDeploy(slug);
   const deployedUrl = extractDeployUrl(result.stdout);
   if (result.code === 0 && deployedUrl) {
-    await writeDeploymentPublicUrl(deployedUrl);
+    await writeDeploymentPublicUrl(deployedUrl, pdfFilename);
   }
   const deploymentInfo = await readDeploymentInfo();
   const publicUrl = deployedUrl ?? deploymentInfo.public_url;
@@ -270,10 +313,10 @@ async function handleDeployRequest(req, res) {
     ok: result.code === 0,
     code: result.code,
     deployed_at: deploymentInfo.deployed_at,
-    pdf: deployedUrl ? `${deployedUrl}/${config.pdf.filename}` : deploymentInfo.pdf,
+    pdf: deployedUrl ? `${deployedUrl}/${pdfFilename}` : deploymentInfo.pdf,
     public_url: publicUrl,
     dirty: false,
-    command: "open-press deploy . --confirm",
+    command,
     stdout: result.stdout,
     stderr: result.stderr,
   });
@@ -356,9 +399,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,
     });
@@ -379,9 +424,11 @@ function runLocalPdfExport() {
   });
 }
 
-function runDeploy() {
+function runDeploy(slug = "") {
+  const cliArgs = [CLI_ENTRY, "deploy", ".", "--confirm"];
+  if (slug) cliArgs.push("--press", slug);
   return new Promise((resolve) => {
-    const child = spawn("node", [CLI_ENTRY, "deploy", ".", "--confirm"], {
+    const child = spawn("node", cliArgs, {
       cwd: workspace,
       shell: false,
     });
@@ -445,7 +492,7 @@ async function readDeploymentInfo() {
   }
 }
 
-async function writeDeploymentPublicUrl(publicUrl) {
+async function writeDeploymentPublicUrl(publicUrl, pdfFilename = config.pdf.filename) {
   let deployConfig = {};
   try {
     deployConfig = JSON.parse(await fs.readFile(config.paths.deployMetadata, "utf8"));
@@ -455,7 +502,7 @@ async function writeDeploymentPublicUrl(publicUrl) {
   await fs.mkdir(path.dirname(config.paths.deployMetadata), { recursive: true });
   await fs.writeFile(
     config.paths.deployMetadata,
-    `${JSON.stringify({ ...deployConfig, pdf: `${publicUrl}/${config.pdf.filename}`, public_url: publicUrl }, null, 2)}\n`,
+    `${JSON.stringify({ ...deployConfig, pdf: `${publicUrl}/${pdfFilename}`, public_url: publicUrl }, null, 2)}\n`,
     "utf8",
   );
 }

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

@@ -230,7 +230,10 @@ export function OpenPressApp() {
   const presentationSlug = state.activeSlug || currentRouteFromLocation().slug;
   const openPresentation = state.document.meta.type === "slides" && presentationSlug
     ? (pageIndex: number) => {
-        openPressRoute(presentationSlug, "present", pageIndex, { fullscreen: true });
+        const slug = normalizeSlug(presentationSlug);
+        const pathname = slug ? `/${slug}` : "/";
+        const hash = `#page-${String(pageIndex + 1).padStart(2, "0")}`;
+        window.open(`${pathname}?fullscreen=1${hash}`, "_blank", "noopener,noreferrer");
       }
     : undefined;
 
@@ -250,6 +253,7 @@ export function OpenPressApp() {
       document={state.document}
       runtimeMode={state.runtimeMode}
       deploymentInfo={state.deploymentInfo}
+      activeSlug={state.activeSlug}
       onDocumentRefresh={refreshDocument}
       onOpenPresentation={openPresentation}
       onExitPresentation={exitPresentation}