@open-press/core 1.2.0 → 1.3.1

package/README.md

@@ -5,7 +5,7 @@ Package-owned runtime, render engine, and Press Tree primitives for [open-press]
 Most users do **not** install this package directly. Instead, scaffold a workspace with the CLI:
 
 ```bash
-npx @open-press/cli init my-doc
+npx @open-press/cli init my-doc --type pages
 ```
 
 The scaffolded workspace depends on this package; it does not vendor a copy of the runtime. Starter files are supplied by skills or by project-specific `press/` source files.
@@ -31,7 +31,7 @@ import { mdxSource } from "@open-press/core/mdx";
 import { Sections, Toc } from "@open-press/core/manuscript";
 ```
 
-`press/index.tsx` or transitional `document/index.tsx` default-exports a `<Workspace>/<Press>` tree. `Frame` marks fixed-layout pages, `MdxArea` receives measured MDX blocks, and `mdxSource()` declares which MDX files participate in the render pipeline.
+Each `press/<slug>/press.tsx` default-exports a component that renders one `<Press>`. `Frame` marks fixed-layout pages, `MdxArea` receives measured MDX blocks, and `mdxSource()` declares which MDX files participate in the render pipeline.
 
 For the maintenance contract around Press Tree, page geometry presets, and the
 allocation pipeline, see [`docs/press-tree.md`](https://github.com/quan0715/open-press/blob/main/docs/press-tree.md).

package/engine/cli.mjs

@@ -87,7 +87,7 @@ Commands:
   typecheck
   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]
+  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";
 
@@ -142,7 +142,7 @@ function pressPrintUrl(host, port, slug) {
   return `http://${host}:${port}/${normalized}?print=1`;
 }
 
-function pressSuffixedFilename(baseFilename, slug) {
+export function pressSuffixedFilename(baseFilename, slug) {
   const normalized = (slug ?? "").replace(/^\/+|\/+$/g, "");
   if (!normalized) return baseFilename;
   const ext = path.extname(baseFilename);
@@ -150,6 +150,10 @@ function pressSuffixedFilename(baseFilename, slug) {
   return `${stem}-${normalized}${ext}`;
 }
 
+export function publicPdfHrefForFilename(filename) {
+  return `/${filename}`;
+}
+
 export async function buildReactPdf({
   root,
   config,
@@ -294,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/typecheck.mjs

@@ -8,7 +8,7 @@ import { loadConfig } from "../runtime/config.mjs";
 // Run typecheck via the locally installed typescript. The previous
 // implementation used `npx tsc`; npm 11 + Node 24 (our CI / release
 // pin) changed npx's bin lookup so it no longer walks pnpm's nested
-// `.bin/` symlink farm and falls back to fetching the legacy
+// `.bin/` symlink farm and may fetch the wrong
 // `tsc@2.0.4` shim, which crashes.
 //
 // Resolution order:

package/engine/document-export.mjs

@@ -10,6 +10,6 @@ export async function exportDocument(root = ROOT) {
   if (reactResult) return reactResult;
 
   throw new Error(
-    "React/MDX document entry not found. Expected press/index.tsx with a Press default export before exporting.",
+    "React/MDX document entry not found. Expected one or more press/*/press.tsx files before exporting.",
   );
 }

package/engine/output/page-block.mjs

@@ -11,12 +11,21 @@ function rewriteAssetPaths(pageHtml, config) {
   const mediaDir = config.mediaDir.replace(/^\/+|\/+$/g, "");
   return pageHtml
     .replaceAll(`src="${mediaDir}/`, 'src="/openpress/media/')
-    .replaceAll(`src='${mediaDir}/`, "src='/openpress/media/");
+    .replaceAll(`src='${mediaDir}/`, "src='/openpress/media/")
+    .replaceAll('src="media/', 'src="/openpress/media/')
+    .replaceAll("src='media/", "src='/openpress/media/")
+    .replaceAll(`src="./${mediaDir}/`, 'src="/openpress/media/')
+    .replaceAll(`src='./${mediaDir}/`, "src='/openpress/media/")
+    .replaceAll('src="./media/', 'src="/openpress/media/')
+    .replaceAll("src='./media/", "src='/openpress/media/");
 }
 
 export function pageToBlock(index, pageHtml, source, config, { idPrefix = "openpress-page", anchorPrefix = "page", titleFallback = "Page" } = {}) {
   const paddedIndex = String(index + 1).padStart(2, "0");
-  const title = pageHtml.match(/data-page-title="([^"]*)"/)?.[1] ?? `${titleFallback} ${index + 1}`;
+  const title =
+    pageHtml.match(/data-page-title="([^"]*)"/)?.[1] ??
+    pageHtml.match(/data-openpress-frame-key="([^"]*)"/)?.[1] ??
+    `${titleFallback} ${index + 1}`;
   const anchor = pageHtml.match(/\bid="([^"]+)"/)?.[1] ?? `${anchorPrefix}-${paddedIndex}`;
   return {
     id: `${idPrefix}-${paddedIndex}`,

package/engine/output/public-assets.mjs

@@ -1,19 +1,54 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { loadConfig } from "../runtime/config.mjs";
-import { copyDirectory, writeComponentsCss, writeContentCss } from "../runtime/file-utils.mjs";
+import { writeComponentsCss, writeContentCss } from "../runtime/file-utils.mjs";
 import { copyThemeFonts } from "./fonts.mjs";
 import { copyKatexFonts } from "./katex-assets.mjs";
 
-export async function syncPublicAssets(root, publicOutputDir, config) {
+export async function syncPublicAssets(root, publicOutputDir, config, options = {}) {
   config ??= await loadConfig(root);
   await fs.rm(path.join(publicOutputDir, "report.css"), { force: true });
   for (const name of ["tokens.css"]) {
-    await fs.copyFile(path.join(config.paths.themeDir, name), path.join(publicOutputDir, name));
+    await copyOptionalFile(path.join(config.paths.themeDir, name), path.join(publicOutputDir, name));
   }
-  await writeContentCss(root, publicOutputDir, config);
+  await writeContentCss(root, publicOutputDir, config, { themeRoots: options.themeRoots });
   await copyThemeFonts(root, publicOutputDir, config);
   await copyKatexFonts(publicOutputDir);
-  await writeComponentsCss(root, publicOutputDir, config);
-  await copyDirectory(config.paths.mediaDir, path.join(publicOutputDir, "media"));
+  await writeComponentsCss(root, publicOutputDir, config, { componentRoots: options.componentRoots });
+  await copyMediaRoots(options.mediaRoots ?? [config.paths.mediaDir], path.join(publicOutputDir, "media"));
+}
+
+async function copyOptionalFile(src, dst) {
+  try {
+    await fs.copyFile(src, dst);
+  } catch (error) {
+    if (error?.code === "ENOENT") return;
+    throw error;
+  }
+}
+
+async function copyMediaRoots(mediaRoots, dst) {
+  await fs.rm(dst, { recursive: true, force: true });
+  await fs.mkdir(dst, { recursive: true });
+  for (const mediaRoot of uniquePaths(mediaRoots)) {
+    try {
+      await fs.cp(mediaRoot, dst, { recursive: true, force: true });
+    } catch (error) {
+      if (error?.code === "ENOENT") continue;
+      throw error;
+    }
+  }
+}
+
+function uniquePaths(paths) {
+  const out = [];
+  const seen = new Set();
+  for (const candidate of paths ?? []) {
+    if (!candidate) continue;
+    const normalized = path.resolve(candidate);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    out.push(normalized);
+  }
+  return out;
 }

package/engine/output/static-server.mjs

@@ -84,7 +84,7 @@ const server = http.createServer(async (req, res) => {
       res.writeHead(200, { "Content-Type": mimeTypes[path.extname(filePath)] ?? "application/octet-stream" });
       res.end(body);
     } catch (err) {
-      // SPA fallback: when a path doesn't map to a real file AND it
+      // SPA HTML response: when a path doesn't map to a real file AND it
       // looks like a client-side route (no extension, not under a
       // reserved namespace), serve index.html so the reader's URL-based
       // routing can take over. This lets /cheatsheet / /proposal etc.
@@ -181,9 +181,9 @@ function valueAfter(args, flag) {
 
 async function inferWorkspaceRoot(staticRoot) {
   for (const candidate of [staticRoot, path.dirname(staticRoot), path.dirname(path.dirname(staticRoot))]) {
-    // 1.0 workspace markers: press/index.tsx (the document entry) or
-    // package.json with an "openpress" field. Either is sufficient.
-    if (await fileExists(path.join(candidate, "press", "index.tsx"))) return candidate;
+    // Workspace markers: folder-convention Press entries or package.json
+    // with an "openpress" field. Either is sufficient.
+    if (await hasFolderPressEntries(candidate)) return candidate;
     if (await hasOpenpressPackageField(candidate)) return candidate;
   }
   if (path.basename(path.dirname(staticRoot)) === ".deploy") {
@@ -202,6 +202,20 @@ async function hasOpenpressPackageField(dir) {
   }
 }
 
+async function hasFolderPressEntries(dir) {
+  let entries;
+  try {
+    entries = await fs.readdir(path.join(dir, "press"), { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "shared") continue;
+    if (await fileExists(path.join(dir, "press", entry.name, "press.tsx"))) return true;
+  }
+  return false;
+}
+
 async function handleLocalPdfExportRequest(req, res) {
   if (req.method !== "POST") {
     writeJson(res, 405, { ok: false, message: "Local PDF export endpoint requires POST." });
@@ -283,6 +297,11 @@ async function handleDeployRequest(req, res) {
     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,
@@ -292,15 +311,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;
@@ -308,10 +327,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,
   });
@@ -372,14 +391,12 @@ async function handleMediaFileRequest(req, res, url) {
       writeJson(res, 404, { ok: false, message: "Media file not found." });
       return;
     }
-    const targetPath = path.join(config.paths.mediaDir, fileName);
-    const resolvedTarget = path.resolve(targetPath);
-    const mediaRoot = path.resolve(config.paths.mediaDir);
-    if (!resolvedTarget.startsWith(`${mediaRoot}${path.sep}`) && resolvedTarget !== mediaRoot) {
-      writeJson(res, 403, { ok: false, message: "Forbidden." });
+    const mediaPath = await findMediaFile(fileName);
+    if (!mediaPath) {
+      writeJson(res, 404, { ok: false, message: "Media file not found." });
       return;
     }
-    const body = await fs.readFile(resolvedTarget);
+    const body = await fs.readFile(mediaPath);
     res.writeHead(200, {
       "Content-Type": mediaMimeType(fileName),
       "Cache-Control": "no-store",
@@ -419,9 +436,11 @@ function runLocalPdfExport(slug = "") {
   });
 }
 
-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,
     });
@@ -485,7 +504,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"));
@@ -495,7 +514,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",
   );
 }
@@ -510,11 +529,7 @@ async function isDeploymentDirty(deployedAt) {
 
 function getDeploymentSourcePaths() {
   return [
-    config.paths.sourceDir,
-    config.paths.mediaDir,
-    config.paths.themeDir,
-    config.paths.designDoc,
-    config.paths.componentsDir,
+    config.paths.documentRoot,
     path.join(FRAMEWORK_ROOT, "src"),
     path.join(FRAMEWORK_ROOT, "index.html"),
     path.join(FRAMEWORK_ROOT, "vite.config.ts"),
@@ -590,6 +605,51 @@ async function uniqueMediaFileName(mediaDir, fileName) {
   return candidate;
 }
 
+async function findMediaFile(fileName) {
+  for (const mediaRoot of await collectMediaRoots()) {
+    const resolvedRoot = path.resolve(mediaRoot);
+    const candidate = path.resolve(mediaRoot, fileName);
+    if (!isInsideRoot(candidate, resolvedRoot)) continue;
+    if (await fileExists(candidate)) return candidate;
+  }
+  return null;
+}
+
+async function collectMediaRoots() {
+  const roots = [
+    config.paths.mediaDir,
+    path.join(config.paths.publicDir, "media"),
+    path.join(root, "openpress", "media"),
+  ];
+  try {
+    const entries = await fs.readdir(config.paths.documentRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "shared") continue;
+      roots.push(path.join(config.paths.documentRoot, entry.name, "media"));
+    }
+  } catch {
+    // Missing press/ is handled by render/validate.
+  }
+  return uniquePaths(roots);
+}
+
+function uniquePaths(paths) {
+  const out = [];
+  const seen = new Set();
+  for (const candidate of paths) {
+    const normalized = path.resolve(candidate);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    out.push(normalized);
+  }
+  return out;
+}
+
+function isInsideRoot(candidate, rootDir) {
+  const relative = path.relative(rootDir, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
 function readRequestBuffer(req, maxBytes) {
   return new Promise((resolve, reject) => {
     const chunks = [];

package/engine/react/caption-numbering.mjs

@@ -64,8 +64,8 @@ function attrValue(attrs, name) {
   return attrs.match(pattern)?.[2] ?? "";
 }
 
-function stringOption(value, fallback) {
-  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+function stringOption(value, defaultValue) {
+  return typeof value === "string" && value.trim() ? value.trim() : defaultValue;
 }
 
 function escapeHtml(value) {

package/engine/react/comment-marker.mjs

@@ -6,8 +6,7 @@ import { collectSourceTextFiles } from "../runtime/source-text-tools.mjs";
 
 // Any `.mdx` or `.tsx` file under `press/` is a legal comment target.
 // The Press Tree allows arbitrary source layouts — `section-folders`,
-// `section-files`, `file-list`, custom `root` paths, etc. — so we no
-// longer hardcode `press/chapters/<slug>/content/*.mdx`. The boundary
+// `section-files`, `file-list`, custom `root` paths, etc. The boundary
 // is "inside the workspace's authored `press/` directory" and "looks
 // like an editable React/MDX source" by extension.
 const EDITABLE_COMMENT_SOURCE_PATTERNS = [

package/engine/react/document-entry.mjs

@@ -1,9 +1,8 @@
 // Layer 1 — Document entry loader.
 //
-// Loads `press/index.tsx`, validates it exports a Press component as
-// default, reads optional `config` and `sources` named exports, and sets
-// up the vite SSR server with `@open-press/core` aliases (including the
-// subpaths `/mdx` and `/manuscript`).
+// Discovers `press/*/press.tsx`, generates an internal Workspace entry,
+// and sets up the vite SSR server with `@open-press/core` aliases
+// (including the subpaths `/mdx` and `/manuscript`).
 
 import fs from "node:fs/promises";
 import { createRequire } from "node:module";
@@ -26,11 +25,61 @@ const REACT_PACKAGE_ROOT = path.join(FRAMEWORK_ROOT, "node_modules", "react");
 const require = createRequire(import.meta.url);
 const REACT_EXPORT_NAMES = Object.keys(require("react")).filter((name) => /^[A-Za-z_$][\w$]*$/.test(name));
 
-// 1.0 contract: the document entry lives at press/index.tsx.
 async function resolveEntryPath(workspaceRoot) {
-  const candidate = path.join(workspaceRoot, "press", "index.tsx");
-  if (await fileExists(candidate)) return candidate;
-  return null;
+  return createDiscoveredPressEntry(workspaceRoot);
+}
+
+async function createDiscoveredPressEntry(workspaceRoot) {
+  const pressRoot = path.join(workspaceRoot, "press");
+  let entries = [];
+  try {
+    const children = await fs.readdir(pressRoot, { withFileTypes: true });
+    for (const child of children) {
+      if (!child.isDirectory()) continue;
+      if (child.name === "shared" || child.name.startsWith(".")) continue;
+      const entryPath = path.join(pressRoot, child.name, "press.tsx");
+      if (await fileExists(entryPath)) entries.push({ folder: child.name, entryPath });
+    }
+  } catch {
+    return null;
+  }
+
+  entries = entries.sort((a, b) => a.folder.localeCompare(b.folder));
+  if (entries.length === 0) return null;
+
+  for (const entry of entries) {
+    const source = await fs.readFile(entry.entryPath, "utf8");
+    assertNoObviousTopLevelSideEffects(source, entry.entryPath);
+  }
+
+  const generatedDir = path.join(workspaceRoot, ".openpress", "react");
+  await fs.mkdir(generatedDir, { recursive: true });
+  const generatedEntry = path.join(generatedDir, "discovered-press-entry.tsx");
+  const imports = entries
+    .map((entry, index) => `import Press${index} from "${relativeImportPath(generatedDir, entry.entryPath)}";`)
+    .join("\n");
+  const children = entries.map((_, index) => `      <Press${index} />`).join("\n");
+  const source = `import { Workspace } from "@open-press/core";
+${imports}
+
+export const __openpressPressFolders = ${JSON.stringify(entries.map((entry) => entry.folder))};
+
+export default function DiscoveredOpenPressWorkspace() {
+  return (
+    <Workspace>
+${children}
+    </Workspace>
+  );
+}
+`;
+  await fs.writeFile(generatedEntry, source, "utf8");
+  return generatedEntry;
+}
+
+function relativeImportPath(fromDir, toFile) {
+  let relative = path.relative(fromDir, toFile).replaceAll(path.sep, "/");
+  if (!relative.startsWith(".")) relative = `./${relative}`;
+  return relative;
 }
 
 export async function loadReactDocumentEntry(root = ".", { server: externalServer } = {}) {
@@ -82,6 +131,9 @@ export async function loadReactDocumentEntry(root = ".", { server: externalServe
       workspaceProps: inspection.workspaceProps,
       pressCount: inspection.presses.length,
       wrappedInWorkspace: inspection.wrappedInWorkspace,
+      pressFolders: Array.isArray(mod.__openpressPressFolders)
+        ? mod.__openpressPressFolders.filter((item) => typeof item === "string")
+        : [],
     };
   } finally {
     if (!externalServer) await ownServer.close();
@@ -112,7 +164,7 @@ export async function createReactSsrServer(workspaceRoot = ".") {
         { find: "@open-press/core/manuscript", replacement: MANUSCRIPT_ENTRY },
         { find: "@open-press/core/numbering", replacement: NUMBERING_ENTRY },
         { find: "@open-press/core", replacement: CORE_ENTRY },
-        { find: "@/components", replacement: path.join(resolvedWorkspaceRoot, "press", "components") },
+        { find: "@/components", replacement: path.join(resolvedWorkspaceRoot, "press", "shared", "components") },
       ],
     },
     optimizeDeps: {
@@ -159,10 +211,11 @@ function assertNoObviousTopLevelSideEffects(source, entryPath) {
 }
 
 function assertPureImport(statement, entryPath) {
+  const moduleName = stringLiteralText(statement.moduleSpecifier);
   if (!statement.importClause) {
+    if (typeof moduleName === "string" && moduleName.endsWith(".css")) return;
     throw new Error(`OpenPress document entry has an unsupported side-effect import in ${entryPath}`);
   }
-  const moduleName = stringLiteralText(statement.moduleSpecifier);
   if (!statement.importClause.isTypeOnly && isFileSystemModule(moduleName)) {
     throw new Error(`OpenPress document entry imports filesystem APIs at top level in ${entryPath}`);
   }
@@ -179,7 +232,7 @@ function assertTopLevelVariableStatement(statement, entryPath) {
       throw new Error(`OpenPress document entry only allows identifier const declarations at top level in ${entryPath}`);
     }
     const name = declaration.name.text;
-    if (exported && name !== "config" && name !== "sources") {
+    if (exported && name !== "config" && name !== "sources" && name !== "__openpressPressFolders") {
       throw new Error(`OpenPress document entry only allows exported const config and sources in ${entryPath}`);
     }
     if (!declaration.initializer) {

package/engine/react/document-export.d.mts

@@ -0,0 +1,6 @@
+export function exportReactDocument(
+  root?: string,
+  options?: {
+    syncAssets?: boolean;
+  },
+): Promise<unknown>;