@open-press/core 0.8.0 → 1.0.0

package/engine/react/document-entry.mjs

@@ -1,6 +1,6 @@
 // Layer 1 — Document entry loader.
 //
-// Loads `document/index.tsx`, validates it exports a Press component as
+// 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`).
@@ -12,7 +12,8 @@ import { fileURLToPath } from "node:url";
 import react from "@vitejs/plugin-react";
 import ts from "typescript";
 import { createServer as createViteServer } from "vite";
-import { normalizeConfig } from "../runtime/config.mjs";
+import { loadConfig } from "../runtime/config.mjs";
+import { inspectPressTree } from "./press-tree-inspection.mjs";
 
 const ENGINE_REACT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const FRAMEWORK_ROOT = path.resolve(ENGINE_REACT_DIR, "..", "..");
@@ -24,10 +25,17 @@ 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;
+}
+
 export async function loadReactDocumentEntry(root = ".", { server: externalServer } = {}) {
   const workspaceRoot = path.resolve(root);
-  const entryPath = path.join(workspaceRoot, "document", "index.tsx");
-  if (!(await fileExists(entryPath))) return null;
+  const entryPath = await resolveEntryPath(workspaceRoot);
+  if (!entryPath) return null;
 
   const source = await fs.readFile(entryPath, "utf8");
   assertNoObviousTopLevelSideEffects(source, entryPath);
@@ -44,19 +52,35 @@ export async function loadReactDocumentEntry(root = ".", { server: externalServe
     // export pipeline throws separately if it's missing when actually needed.
     const Press = typeof mod.default === "function" ? mod.default : null;
 
-    const config = normalizeReactDocumentConfig(workspaceRoot, entryPath, mod.config);
-    const sources = mod.sources ?? {};
-    if (sources && (typeof sources !== "object" || Array.isArray(sources))) {
-      throw new Error(
-        `OpenPress document entry ${entryPath} \`sources\` export must be an object literal (or omitted).`,
+    // Inspect the JSX tree returned by the user's default export to
+    // pull <Workspace> / <Press> props declared inline. The 1.0 contract
+    // treats workspaces uniformly as "array of Press children" — the
+    // single-doc case is just length 1.
+    let inspection = { workspaceProps: {}, presses: [], wrappedInWorkspace: false };
+    if (Press) {
+      const coreModule = await ownServer.ssrLoadModule(
+        path.join(FRAMEWORK_ROOT, "src", "openpress", "core", "index.tsx"),
       );
+      inspection = inspectPressTree({
+        UserComponent: Press,
+        PRESS_MARKER: coreModule.PRESS_MARKER,
+        WORKSPACE_MARKER: coreModule.WORKSPACE_MARKER,
+      });
     }
 
+    // Workspace-level config (deploy, pdf, captionNumbering defaults)
+    // comes from package.json "openpress" via loadConfig. Each Press
+    // overlays its own metadata via JSX props at export time.
+    const config = await loadConfig(workspaceRoot);
+
     return {
       entryPath,
       config,
       Press,
-      sources,
+      presses: inspection.presses,
+      workspaceProps: inspection.workspaceProps,
+      pressCount: inspection.presses.length,
+      wrappedInWorkspace: inspection.wrappedInWorkspace,
     };
   } finally {
     if (!externalServer) await ownServer.close();
@@ -80,7 +104,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, "document", "components") },
+        { find: "@/components", replacement: path.join(resolvedWorkspaceRoot, "press", "components") },
       ],
     },
     optimizeDeps: {
@@ -250,23 +274,6 @@ function isFileSystemModule(moduleName) {
   return moduleName === "fs" || moduleName === "node:fs" || moduleName === "fs/promises" || moduleName === "node:fs/promises";
 }
 
-function normalizeReactDocumentConfig(workspaceRoot, entryPath, config) {
-  if (config != null && (typeof config !== "object" || Array.isArray(config))) {
-    throw new Error("OpenPress React document entry `config` export must be an object when provided.");
-  }
-  const rawConfig = config ?? {};
-  const paths = rawConfig.paths ?? {};
-  return normalizeConfig(workspaceRoot, {
-    ...rawConfig,
-    documentDir: rawConfig.documentDir ?? paths.documentDir ?? "document",
-    sourceDir: rawConfig.sourceDir ?? paths.chaptersDir ?? paths.sourceDir ?? "chapters",
-    componentsDir: rawConfig.componentsDir ?? paths.componentsDir ?? "components",
-    mediaDir: rawConfig.mediaDir ?? paths.mediaDir ?? "media",
-    themeDir: rawConfig.themeDir ?? paths.themeDir ?? "theme",
-    designDoc: rawConfig.designDoc ?? paths.designDoc ?? "design.md",
-  }, entryPath);
-}
-
 async function fileExists(filePath) {
   try {
     const stat = await fs.stat(filePath);

package/engine/react/document-export.mjs

@@ -6,8 +6,11 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 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 { pageGeometryToTheme } from "../runtime/page-geometry.mjs";
+import { normalizePageGeometry } from "../runtime/page-geometry.mjs";
 import { createCaptionNumberingState, numberCaptionsInHtml } from "./caption-numbering.mjs";
 import { buildSectionScopedCss } from "./section-css.mjs";
 import { CORE_ENTRY, createReactSsrServer, loadReactDocumentEntry } from "./document-entry.mjs";
@@ -50,7 +53,11 @@ export async function exportReactDocument(root = ".", { syncAssets = true } = {}
     }
 
     // Discover workspace for component scope and chapter-scoped style files.
-    const workspace = await discoverSectionStyles(workspaceRoot, entry.config);
+    // Pass every Press's resolved section-folders root so per-Press chapter
+    // folders (e.g. press/userstory/chapters/) are all picked up — the
+    // workspace can host more than one chapter root.
+    const sectionRoots = collectSectionRoots(entry.presses, entry.config.paths.documentRoot);
+    const workspace = await discoverSectionStyles(workspaceRoot, entry.config, { sectionRoots });
     const coreAuthorComponents = {};
     for (const name of ["MediaFigure", "ImageFigure"]) {
       if (typeof coreModule[name] === "function") coreAuthorComponents[name] = coreModule[name];
@@ -60,199 +67,309 @@ export async function exportReactDocument(root = ".", { syncAssets = true } = {}
       ...(await loadComponentModules(server, workspace.globalComponents ?? [])),
     };
 
-    // Resolve sources.
-    const documentRoot = entry.config.paths.documentRoot;
-    const { resolved: sources, renderData: renderRegistry } = await resolveAllSources({
-      sources: entry.sources,
-      documentRoot,
-      globalComponents,
-    });
+    // Build measurement CSS once at the workspace level — shared by every
+    // Press inside the Workspace.
+    const measurementCss = await buildReactMeasurementCss(workspaceRoot, entry.config, workspace);
 
-    // Build measurement CSS.
-    const css = await buildReactMeasurementCss(workspaceRoot, entry.config, workspace);
-
-    // Iterative allocation loop.
-    let hints = null;
-    let allocation = null;
-    let lastFrames = null;
-    let warnings = [];
-    for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
-      const { html, frames } = expandPressTree({
-        Press: entry.Press,
-        PressContext,
-        sources,
-        hints,
-      });
-      lastFrames = frames;
-      validateAllChainsKnown(frames, sources);
-      const measurement = await measureFrames({
-        pressHtml: html,
-        sources,
-        renderRegistry,
-        css,
-        baseHref: pathToFileURL(`${documentRoot}${path.sep}`).href,
-        mediaDir: path.join(documentRoot, "media"),
-        captionNumbering: entry.config.captionNumbering,
+    // Write chapter-scoped CSS once (workspace shared). Every per-press
+    // readerDocument references the same file via "/openpress/chapter-scoped.css".
+    const chapterCss = await buildSectionScopedCss(workspace);
+    const sharedStyles = [];
+    await fs.mkdir(entry.config.paths.publicDir, { recursive: true });
+    if (chapterCss.trim()) {
+      await fs.writeFile(path.join(entry.config.paths.publicDir, "chapter-scoped.css"), chapterCss, "utf8");
+      sharedStyles.push({
+        kind: "chapter-scoped-css",
+        href: "/openpress/chapter-scoped.css",
+        path: "chapter-scoped.css",
       });
-      const alloc = allocateChains({
-        frames,
-        mdxAreas: measurement.mdxAreas,
-        blockHeights: measurement.blockHeights,
-        sources,
+    }
+
+    // Iterate every Press declared inside <Workspace>. Single-doc
+    // workspaces just have length-1 here; the code path is uniform.
+    const pressResults = [];
+    for (const press of entry.presses) {
+      const result = await exportSinglePress({
+        press,
+        entry,
+        workspaceRoot,
+        server,
+        coreModule,
+        PressContext,
+        workspace,
+        globalComponents,
+        measurementCss,
+        sharedStyles,
       });
-      if (process.env.OPENPRESS_DEBUG_ALLOC) {
-        const sample = measurement.mdxAreas
-          .slice(0, 5)
-          .map((a) => `${a.frameKey}#${a.indexInFrame} cap=${a.capacity.toFixed(0)} raw=${(a.rawHeight ?? 0).toFixed(0)}`);
-        const blocks = measurement.blockHeights
-          .slice(0, 8)
-          .map((b) => `${b.id} h=${b.height.toFixed(0)}`);
-        process.stderr.write(`[allocator iter ${iteration}]\n`);
-        process.stderr.write(`  mdxAreas[0..4]: ${sample.join(" | ")}\n`);
-        process.stderr.write(`  blocks[0..7]:   ${blocks.join(" | ")}\n`);
-        process.stderr.write(`  hints:          ${JSON.stringify(alloc.hints.totalPagesPerChain)}\n`);
-        if (alloc.warnings.length > 0) {
-          process.stderr.write(`  warnings:       ${JSON.stringify(alloc.warnings)}\n`);
-        }
-      }
-      if (hintsEqual(hints, alloc.hints)) {
-        allocation = alloc.allocation;
-        warnings = alloc.warnings;
-        break;
-      }
-      hints = alloc.hints;
+      pressResults.push(result);
     }
-    if (allocation == null) {
-      throw new Error(
-        `Allocation did not converge after ${MAX_ITERATIONS} iterations. ` +
-          `This usually means a chain keeps growing without fitting; check MdxArea capacities and block heights.`,
-      );
+
+    // Build workspace.json — one entry per Press. The reader fetches
+    // this first to decide between gallery (length > 1) and direct
+    // load (length 1).
+    const workspaceManifest = {
+      version: 1,
+      name: typeof entry.workspaceProps?.name === "string" && entry.workspaceProps.name.trim()
+        ? entry.workspaceProps.name.trim()
+        : null,
+      presses: pressResults.map((r) => ({
+        slug: r.slug,
+        title: r.readerDocument.meta.title,
+        page: r.readerDocument.theme ?? null,
+        pageCount: r.pageCount,
+        documentUrl: r.documentUrl,
+      })),
+    };
+    const workspacePath = path.join(entry.config.paths.publicDir, "workspace.json");
+    await fs.writeFile(workspacePath, JSON.stringify(workspaceManifest, null, 2), "utf8");
+
+    if (syncAssets) {
+      await syncPublicAssets(workspaceRoot, entry.config.paths.publicDir, entry.config);
     }
 
-    const toc = buildTocContext({ sources, frames: lastFrames ?? [], allocation });
+    const primary = pressResults[0];
+    return {
+      documentPath: primary?.documentPath,
+      pageCount: primary?.pageCount ?? 0,
+      document: primary?.readerDocument,
+      presses: pressResults,
+    };
+  } finally {
+    await server.close();
+  }
+}
+
+// Render one Press from the Workspace into its own document.json.
+// Called once per <Press> child; single-doc workspaces just call this
+// once with the only Press. Returns the per-press summary the
+// workspace manifest is built from.
+async function exportSinglePress({
+  press,
+  entry,
+  workspaceRoot,
+  server,
+  coreModule,
+  PressContext,
+  workspace,
+  globalComponents,
+  measurementCss,
+  sharedStyles,
+}) {
+  const slug = typeof press.metadata?.slug === "string" && press.metadata.slug.trim()
+    ? press.metadata.slug.trim()
+    : "";
+
+  // Effective config for this press: workspace config with per-press
+  // metadata overlaid. Press JSX page prop wins over the workspace page.
+  const effectiveConfig = applyPressOverridesToConfig(entry.config, press.metadata);
+  const documentRoot = effectiveConfig.paths.documentRoot;
+
+  // Resolve sources for this press. The 1.0 contract reads them from
+  // <Press sources={[...]}>; the v0.x legacy path uses the synthesized
+  // record from `export const sources`.
+  const sourcesRecord = press.sources ?? {};
+  const { resolved: sources, renderData: renderRegistry } = await resolveAllSources({
+    sources: sourcesRecord,
+    documentRoot,
+    globalComponents,
+  });
+
+  // Component the render pipeline drives. For Press elements captured
+  // by inspection (1.0 contract), wrap the captured element in a thin
+  // function component. For legacy projects without inspection data,
+  // fall back to the user's whole default export.
+  const PressComponent = press.element
+    ? () => press.element
+    : entry.Press;
 
-    // Final render.
-    const final = await renderFinalPress({
-      Press: entry.Press,
+  // Iterative allocation loop (identical to v0.x — paginates until the
+  // hints stabilise).
+  let hints = null;
+  let allocation = null;
+  let lastFrames = null;
+  let warnings = [];
+  for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
+    const { html, frames } = expandPressTree({
+      Press: PressComponent,
       PressContext,
       sources,
       hints,
-      toc,
-      allocation,
+    });
+    lastFrames = frames;
+    validateAllChainsKnown(frames, sources);
+    const measurement = await measureFrames({
+      pressHtml: html,
+      sources,
       renderRegistry,
+      css: measurementCss,
+      baseHref: pathToFileURL(`${documentRoot}${path.sep}`).href,
+      mediaDir: path.join(documentRoot, "media"),
+      captionNumbering: effectiveConfig.captionNumbering,
     });
-
-    // Write chapter-scoped CSS (under section-scoped rules but filename
-    // unchanged for now).
-    const chapterCss = await buildSectionScopedCss(workspace);
-    const styles = [];
-    await fs.mkdir(entry.config.paths.publicDir, { recursive: true });
-    if (chapterCss.trim()) {
-      await fs.writeFile(path.join(entry.config.paths.publicDir, "chapter-scoped.css"), chapterCss, "utf8");
-      styles.push({
-        kind: "chapter-scoped-css",
-        href: "/openpress/chapter-scoped.css",
-        path: "chapter-scoped.css",
-      });
+    const alloc = allocateChains({
+      frames,
+      mdxAreas: measurement.mdxAreas,
+      blockHeights: measurement.blockHeights,
+      sources,
+    });
+    if (process.env.OPENPRESS_DEBUG_ALLOC) {
+      const sample = measurement.mdxAreas
+        .slice(0, 5)
+        .map((a) => `${a.frameKey}#${a.indexInFrame} cap=${a.capacity.toFixed(0)} raw=${(a.rawHeight ?? 0).toFixed(0)}`);
+      const blocks = measurement.blockHeights
+        .slice(0, 8)
+        .map((b) => `${b.id} h=${b.height.toFixed(0)}`);
+      process.stderr.write(`[allocator press=${slug || "(root)"} iter ${iteration}]\n`);
+      process.stderr.write(`  mdxAreas[0..4]: ${sample.join(" | ")}\n`);
+      process.stderr.write(`  blocks[0..7]:   ${blocks.join(" | ")}\n`);
+      process.stderr.write(`  hints:          ${JSON.stringify(alloc.hints.totalPagesPerChain)}\n`);
+      if (alloc.warnings.length > 0) {
+        process.stderr.write(`  warnings:       ${JSON.stringify(alloc.warnings)}\n`);
+      }
+    }
+    if (hintsEqual(hints, alloc.hints)) {
+      allocation = alloc.allocation;
+      warnings = alloc.warnings;
+      break;
     }
+    hints = alloc.hints;
+  }
+  if (allocation == null) {
+    throw new Error(
+      `Allocation did not converge after ${MAX_ITERATIONS} iterations (press="${slug || "(root)"}"). ` +
+        `This usually means a chain keeps growing without fitting; check MdxArea capacities and block heights.`,
+    );
+  }
 
-    // Build document.json. The reader filters blocks by kind === "htmlPage",
-    // so wrap each frame through `pageToBlock` to inherit that contract.
-    const blockMap = {};
-    const captionState = createCaptionNumberingState();
-    const blocks = final.frames.map((frame, index) => {
-      const source = {
-        file: "index.tsx",
-        path: "document/index.tsx",
-        kind: frame.role ?? "manuscript.content",
-        slug: frame.frameKey,
-        sectionIndex: index + 1,
-      };
-      const html = numberCaptionsInHtml(frame.html, entry.config.captionNumbering, captionState);
-      for (const id of collectFrameBlockIds(frame.blockIds, html)) {
-        blockMap[id] = { id, pageIndex: index, pageNumber: index + 1, frameKey: frame.frameKey };
-      }
-      const block = pageToBlock(index, html, source, entry.config, {
-        idPrefix: "openpress-page",
-        anchorPrefix: "page",
-        titleFallback: "Page",
-      });
-      return {
-        ...block,
-        frameKey: frame.frameKey,
-        role: frame.role ?? null,
-        chrome: frame.chrome ?? true,
-        blockIds: frame.blockIds,
-      };
+  const toc = buildTocContext({ sources, frames: lastFrames ?? [], allocation });
+
+  const final = await renderFinalPress({
+    Press: PressComponent,
+    PressContext,
+    sources,
+    hints,
+    toc,
+    allocation,
+    renderRegistry,
+  });
+
+  // Build the reader's document.json. Same shape as v0.x; the only
+  // change is metadata.title comes from the per-press Press JSX prop.
+  const blockMap = {};
+  const captionState = createCaptionNumberingState();
+  const blocks = final.frames.map((frame, index) => {
+    const source = {
+      file: "index.tsx",
+      path: slug ? `press/${slug}/index.tsx` : "press/index.tsx",
+      kind: frame.role ?? "manuscript.content",
+      slug: frame.frameKey,
+      sectionIndex: index + 1,
+    };
+    const html = numberCaptionsInHtml(frame.html, effectiveConfig.captionNumbering, captionState);
+    for (const id of collectFrameBlockIds(frame.blockIds, html)) {
+      blockMap[id] = { id, pageIndex: index, pageNumber: index + 1, frameKey: frame.frameKey };
+    }
+    const block = pageToBlock(index, html, source, effectiveConfig, {
+      idPrefix: "openpress-page",
+      anchorPrefix: "page",
+      titleFallback: "Page",
     });
+    return {
+      ...block,
+      frameKey: frame.frameKey,
+      role: frame.role ?? null,
+      chrome: frame.chrome ?? true,
+      blockIds: frame.blockIds,
+    };
+  });
 
-    // Enrich blockMap with source records from resolved chains so comment
-    // tooling can resolve block IDs back to MDX positions.
-    const sourceBlockIndex = buildSourceBlockIndex(sources);
-    for (const id of Object.keys(blockMap)) {
-      const sourceRecord = sourceBlockIndex.get(id);
-      if (sourceRecord) {
-        blockMap[id] = {
-          ...blockMap[id],
-          kind: sourceRecord.kind,
-          name: sourceRecord.name,
-          path: sourceRecord.path,
-          source: sourceRecord.source,
-          chainId: sourceRecord.chainId,
-          sectionSlug: sourceRecord.sectionSlug,
-        };
-      }
+  const sourceBlockIndex = buildSourceBlockIndex(sources);
+  for (const id of Object.keys(blockMap)) {
+    const sourceRecord = sourceBlockIndex.get(id);
+    if (sourceRecord) {
+      blockMap[id] = {
+        ...blockMap[id],
+        kind: sourceRecord.kind,
+        name: sourceRecord.name,
+        path: sourceRecord.path,
+        source: sourceRecord.source,
+        chainId: sourceRecord.chainId,
+        sectionSlug: sourceRecord.sectionSlug,
+      };
     }
+  }
 
-    const objectEntities = buildObjectEntities({
-      frames: final.frames.map((frame, index) => ({ ...frame, pageIndex: index })),
-      blocks,
-      blockMap,
-    });
+  const objectEntities = buildObjectEntities({
+    frames: final.frames.map((frame, index) => ({ ...frame, pageIndex: index })),
+    blocks,
+    blockMap,
+  });
 
-    const readerDocument = {
-      meta: {
-        title: trimmedString(entry.config.title) ?? "Untitled Document",
-        subtitle: trimmedString(entry.config.subtitle) ?? "",
-        organization: trimmedString(entry.config.organization) ?? "",
-        workspaceLabel: trimmedString(entry.config.workspaceLabel) ?? "",
-        version: "openpress-press-tree-v1",
-      },
-      source: {
-        type: "openpress-press-tree-mdx",
-        contentDir: documentRelativePath(entry.config, entry.config.sourceDir),
-        editable: true,
-        editMode: "source-mdx",
-        styles,
-        blockMap,
-        objectEntities,
-        frames: final.frames.map((frame, index) => ({
-          frameKey: frame.frameKey,
-          role: frame.role ?? null,
-          pageIndex: index,
-          mdxAreas: frame.mdxAreas.map((area) => ({
-            chainId: area.chainId,
-            indexInFrame: area.indexInFrame,
-            blockIds: area.blockIds,
-          })),
+  const readerDocument = {
+    meta: {
+      title: trimmedString(effectiveConfig.title) ?? "Untitled Document",
+      subtitle: trimmedString(effectiveConfig.subtitle) ?? "",
+      organization: trimmedString(effectiveConfig.organization) ?? "",
+      workspaceLabel: trimmedString(effectiveConfig.workspaceLabel) ?? "",
+      version: "openpress-press-tree-v1",
+    },
+    theme: pageGeometryToTheme(effectiveConfig.page),
+    source: {
+      type: "openpress-press-tree-mdx",
+      contentDir: documentRelativePath(effectiveConfig, effectiveConfig.sourceDir),
+      editable: true,
+      editMode: "source-mdx",
+      styles: sharedStyles,
+      blockMap,
+      objectEntities,
+      frames: final.frames.map((frame, index) => ({
+        frameKey: frame.frameKey,
+        role: frame.role ?? null,
+        pageIndex: index,
+        mdxAreas: frame.mdxAreas.map((area) => ({
+          chainId: area.chainId,
+          indexInFrame: area.indexInFrame,
+          blockIds: area.blockIds,
         })),
-        chains: Object.keys(sources).flatMap((id) => Object.keys(sources[id].chains)),
-        warnings,
-      },
-      blocks,
-    };
+      })),
+      chains: Object.keys(sources).flatMap((id) => Object.keys(sources[id].chains)),
+      warnings,
+    },
+    blocks,
+  };
 
-    const documentPath = path.join(entry.config.paths.publicDir, "document.json");
-    await fs.writeFile(documentPath, JSON.stringify(readerDocument, null, 2), "utf8");
+  // Output path: empty slug → root /openpress/document.json (legacy
+  // single-Press shape). Non-empty slug → /openpress/<slug>/document.json.
+  const pressOutputDir = slug
+    ? path.join(effectiveConfig.paths.publicDir, slug)
+    : effectiveConfig.paths.publicDir;
+  await fs.mkdir(pressOutputDir, { recursive: true });
+  const documentPath = path.join(pressOutputDir, "document.json");
+  await fs.writeFile(documentPath, JSON.stringify(readerDocument, null, 2), "utf8");
 
-    if (syncAssets) {
-      await syncPublicAssets(workspaceRoot, entry.config.paths.publicDir, entry.config);
-    }
+  return {
+    slug,
+    documentPath,
+    documentUrl: slug ? `/openpress/${slug}/document.json` : "/openpress/document.json",
+    readerDocument,
+    pageCount: blocks.length,
+  };
+}
 
-    return { documentPath, pageCount: blocks.length, document: readerDocument };
-  } finally {
-    await server.close();
+// Apply per-Press JSX prop overrides onto the workspace-level config.
+// Returns a new config object — the original is untouched so other
+// presses in the same workspace get a clean base.
+function applyPressOverridesToConfig(workspaceConfig, pressMetadata) {
+  if (!pressMetadata) return workspaceConfig;
+  const out = { ...workspaceConfig };
+  if (pressMetadata.title) out.title = pressMetadata.title;
+  if (pressMetadata.page !== undefined) {
+    out.page = normalizePageGeometry(pressMetadata.page);
   }
+  if (pressMetadata.captionNumbering !== undefined) {
+    out.captionNumbering = { ...workspaceConfig.captionNumbering, ...pressMetadata.captionNumbering };
+  }
+  return out;
 }
 
 async function loadComponentModules(server, components) {
@@ -371,3 +488,25 @@ function trimmedString(value) {
   const trimmed = value.trim();
   return trimmed ? trimmed : null;
 }
+
+// Walk every Press's mdxSource descriptors and collect the absolute
+// path each section-folders root resolves to. discoverSectionStyles
+// iterates these to find section-scoped CSS across a multi-Press
+// workspace where chapters live under per-Press subfolders.
+function collectSectionRoots(presses, documentRoot) {
+  const roots = new Set();
+  for (const press of presses ?? []) {
+    const sources = press?.sources;
+    if (!sources || typeof sources !== "object") continue;
+    for (const descriptor of Object.values(sources)) {
+      if (descriptor?.type !== "mdx") continue;
+      if (descriptor?.preset !== "section-folders") continue;
+      const rel = typeof descriptor.root === "string" && descriptor.root.trim()
+        ? descriptor.root.trim()
+        : "chapters";
+      roots.add(path.resolve(documentRoot, rel));
+    }
+  }
+  return [...roots];
+}
+