@open-press/core 0.8.0 → 1.0.0

package/engine/react/mdx-compile.mjs

@@ -183,6 +183,7 @@ function applyTableRowBlocks({
     setDataAttribute(headerRecord.node, "data-openpress-block-id", headerRecord.id);
     setDataAttribute(headerRecord.node, "data-openpress-object-id", createBlockObjectEntityId(headerRecord.id));
     setDataAttribute(headerRecord.node, "data-openpress-block-layout", "attached");
+    annotateTableCells(headerRecord.node, headerRecord.id);
   }
   if (captionRecord) {
     if (renderCaption) {
@@ -226,6 +227,13 @@ function applyTableRowBlocks({
   for (const row of selected) {
     setDataAttribute(row.node, "data-openpress-block-id", row.id);
     setDataAttribute(row.node, "data-openpress-object-id", createBlockObjectEntityId(row.id));
+    // Bake cell-level object ids into every <td>/<th>. The inspector resolves
+    // a clicked target via `closest("[data-openpress-object-id]")` — without
+    // this, a click inside a cell would walk up to the row and a comment
+    // would target the entire row. With the cell-precision id present in the
+    // static HTML the inspector targets the individual cell, matching the
+    // engine's per-cell source-edit pipeline (`cellIndex`).
+    annotateTableCells(row.node, row.id);
     blocks.push({
       id: row.id,
       kind: "table-row",
@@ -241,6 +249,28 @@ function applyTableRowBlocks({
   return "skip";
 }
 
+function annotateTableCells(rowNode, rowBlockId) {
+  const children = Array.isArray(rowNode?.children) ? rowNode.children : [];
+  let cellIndex = 0;
+  for (const child of children) {
+    if (child?.type !== "element") continue;
+    if (child.tagName !== "td" && child.tagName !== "th") continue;
+    // Inherit the row's block id so `findObjectSelection` can resolve the
+    // cell's underlying SourceBlock (which lives on the row). The
+    // cell-precision `data-openpress-object-id` + cellIndex still let the
+    // inspector / source-edit pipeline target a single cell within that row.
+    // `data-openpress-inherited-block-id="true"` keeps the same convention
+    // the inline editor uses for caption / cell descendants, so block
+    // measurement (which queries `[data-openpress-block-id]`) can skip
+    // these and not double-count the row's height across N cells.
+    setDataAttribute(child, "data-openpress-block-id", rowBlockId);
+    setDataAttribute(child, "data-openpress-inherited-block-id", "true");
+    setDataAttribute(child, "data-openpress-object-id", `${createBlockObjectEntityId(rowBlockId)}:cell:${cellIndex}`);
+    setDataAttribute(child, "data-openpress-table-cell-index", String(cellIndex));
+    cellIndex += 1;
+  }
+}
+
 export function remarkBlockOnlyMdx(options = {}) {
   const filePath = String(options.filePath ?? "document.mdx");
 

package/engine/react/measurement-css.mjs

@@ -3,6 +3,7 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { buildComponentsCss, buildContentCss } from "../runtime/file-utils.mjs";
+import { pageGeometryToTheme } from "../runtime/page-geometry.mjs";
 import { buildSectionScopedCss } from "./section-css.mjs";
 
 const require = createRequire(import.meta.url);
@@ -11,6 +12,7 @@ export async function buildReactMeasurementCss(root, config, workspace) {
   const parts = [];
   await appendOptionalFile(parts, path.join(config.paths.themeDir, "fonts.css"), "theme/fonts.css");
   await appendOptionalFile(parts, path.join(config.paths.themeDir, "tokens.css"), "theme/tokens.css");
+  appendPageGeometryCss(parts, config.page);
   parts.push("/* === public/openpress/content.css === */\n");
   parts.push(await buildContentCss(root, config));
   parts.push("\n/* === public/openpress/components.css === */\n");
@@ -23,6 +25,25 @@ export async function buildReactMeasurementCss(root, config, workspace) {
   return rewriteAssetUrls(stripViewportMediaQueries(parts.join("\n")), config);
 }
 
+function appendPageGeometryCss(parts, page) {
+  const theme = pageGeometryToTheme(page);
+  if (!theme) return;
+
+  const declarations = [
+    ["--openpress-page-width", theme.pageWidth],
+    ["--openpress-page-height", theme.pageHeight],
+    ["--openpress-page-aspect-ratio", theme.pageAspectRatio],
+    ["--openpress-page-height-ratio", theme.pageHeightRatio],
+  ].filter(([, value]) => value);
+
+  parts.push("/* === openpress page geometry === */\n");
+  parts.push(":root {\n");
+  for (const [name, value] of declarations) {
+    parts.push(`  ${name}: ${value};\n`);
+  }
+  parts.push("}\n\n");
+}
+
 async function appendOptionalFile(parts, filePath, label) {
   try {
     const css = await fs.readFile(filePath, "utf8");

package/engine/react/object-entities.mjs

@@ -14,6 +14,10 @@ export function createFrameObjectEntityId(frameKey) {
   return createObjectEntityId("frame", frameKey);
 }
 
+export function createScopedObjectEntityId(kind, parentId, objectId) {
+  return parentId ? createObjectEntityId(kind, parentId, objectId) : createObjectEntityId(kind, objectId);
+}
+
 export function createMdxAreaObjectEntityId(frameKey, chainId, indexInFrame) {
   return createObjectEntityId("mdx-area", frameKey, chainId, indexInFrame);
 }
@@ -115,5 +119,86 @@ export function buildObjectEntities({ frames, blocks, blockMap }) {
     };
   }
 
+  for (const entity of collectRenderedObjectEntities(frames)) {
+    if (!entity.id || entities[entity.id]) continue;
+    const pageId = entity.pageId || createPageObjectEntityId(entity.frameKey);
+    const frameId = createFrameObjectEntityId(entity.frameKey);
+    entities[entity.id] = {
+      id: entity.id,
+      kind: entity.kind,
+      label: entity.label || entity.id,
+      parentId: entity.parentId || (entity.id === frameId ? pageId : frameId),
+      pageId,
+      blockId: entity.blockId,
+      frameKey: entity.frameKey,
+      chainId: entity.chainId,
+      source: entity.source,
+      metadata: entity.metadata,
+    };
+  }
+
   return entities;
 }
+
+const OBJECT_OPEN_RE = /<([a-z][a-z0-9-]*)\b([^>]*)\bdata-openpress-object-id="([^"]+)"([^>]*)>/gi;
+const ATTR_RE = (name) => new RegExp(`\\b${name}="([^"]*)"`);
+
+function collectRenderedObjectEntities(frames) {
+  const entities = [];
+  for (const frame of frames) {
+    const pageId = createPageObjectEntityId(frame.frameKey);
+    const frameId = createFrameObjectEntityId(frame.frameKey);
+    const html = String(frame.html ?? "");
+    let match;
+    OBJECT_OPEN_RE.lastIndex = 0;
+    while ((match = OBJECT_OPEN_RE.exec(html)) !== null) {
+      const attrs = `${match[2] ?? ""} data-openpress-object-id="${match[3] ?? ""}" ${match[4] ?? ""}`;
+      const id = htmlDecode(match[3] ?? "");
+      const kind = htmlDecode(pickAttr(attrs, "data-openpress-object-kind")) || objectKindFromId(id);
+      if (!id || !kind) continue;
+      entities.push({
+        id,
+        kind,
+        label: htmlDecode(pickAttr(attrs, "data-openpress-object-label")) || id,
+        parentId: htmlDecode(pickAttr(attrs, "data-openpress-object-parent-id")) || (id === frameId ? pageId : frameId),
+        pageId: htmlDecode(pickAttr(attrs, "data-openpress-object-page-id")) || pageId,
+        blockId: htmlDecode(pickAttr(attrs, "data-openpress-block-id")) || undefined,
+        frameKey: htmlDecode(pickAttr(attrs, "data-openpress-object-frame-key")) || frame.frameKey,
+        chainId: htmlDecode(pickAttr(attrs, "data-openpress-object-chain-id")) || undefined,
+        source: parseJsonAttribute(pickAttr(attrs, "data-openpress-object-source")),
+        metadata: parseJsonAttribute(pickAttr(attrs, "data-openpress-object-metadata")),
+      });
+    }
+  }
+  return entities;
+}
+
+function pickAttr(attrs, name) {
+  const match = ATTR_RE(name).exec(attrs);
+  return match ? match[1] : "";
+}
+
+function objectKindFromId(id) {
+  const separator = id.indexOf(":");
+  return separator === -1 ? "" : id.slice(0, separator);
+}
+
+function parseJsonAttribute(value) {
+  const decoded = htmlDecode(value);
+  if (!decoded) return undefined;
+  try {
+    return JSON.parse(decoded);
+  } catch {
+    return undefined;
+  }
+}
+
+function htmlDecode(value) {
+  return String(value ?? "")
+    .replaceAll("&quot;", '"')
+    .replaceAll("&#x27;", "'")
+    .replaceAll("&#39;", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&amp;", "&");
+}

package/engine/react/pagination/allocator.mjs

@@ -7,7 +7,8 @@ import { singleColumnRegionStream } from "./regions.mjs";
 // region until adding the next block would exceed capacity, then advance to
 // the next region. Pages are a derived view (grouping by pageIndex), so the
 // same code paginates single-column, multi-column, and heterogeneous layouts.
-export function allocateBlocksToRegions(measuredBlocks, regionStream) {
+export function allocateBlocksToRegions(measuredBlocks, regionStream, options = {}) {
+  const keepWithNext = typeof options.keepWithNext === "function" ? options.keepWithNext : null;
   const filled = [];
   const warnings = [];
   let current = regionStream.next();
@@ -16,6 +17,7 @@ export function allocateBlocksToRegions(measuredBlocks, regionStream) {
   }
   let currentBlockIds = [];
   let currentHeight = 0;
+  let consumedCount = 0;
 
   const flush = () => {
     if (currentBlockIds.length === 0) return;
@@ -29,7 +31,9 @@ export function allocateBlocksToRegions(measuredBlocks, regionStream) {
     currentHeight = 0;
   };
 
-  for (const block of measuredBlocks ?? []) {
+  const blocks = measuredBlocks ?? [];
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+    const block = blocks[blockIndex];
     const id = String(block?.id ?? "");
     if (!id) continue;
     const height = Math.max(0, Number(block.height) || 0);
@@ -45,6 +49,24 @@ export function allocateBlocksToRegions(measuredBlocks, regionStream) {
       });
     }
 
+    const nextBlock = blocks[blockIndex + 1];
+    const nextHeight = Math.max(0, Number(nextBlock?.height) || 0);
+    const keepWithNextHeight = keepWithNext?.(block, nextBlock) ? height + nextHeight : 0;
+
+    if (
+      currentBlockIds.length > 0 &&
+      keepWithNextHeight > 0 &&
+      currentHeight + keepWithNextHeight > current.capacity
+    ) {
+      flush();
+      const next = regionStream.next();
+      if (!next) {
+        warnings.push({ code: "out-of-regions", blockId: id });
+        break;
+      }
+      current = next;
+    }
+
     if (currentBlockIds.length > 0 && currentHeight + height > current.capacity) {
       flush();
       const next = regionStream.next();
@@ -57,10 +79,17 @@ export function allocateBlocksToRegions(measuredBlocks, regionStream) {
 
     currentBlockIds.push(id);
     currentHeight += height;
+    consumedCount += 1;
   }
 
   flush();
-  return { regions: filled, warnings };
+  return { regions: filled, warnings, consumedCount };
+}
+
+export function estimateRegionsNeeded(measuredBlocks, regionCapacity, options = {}) {
+  const capacity = positiveNumber(regionCapacity, DEFAULT_PAGE_SAFE_HEIGHT_PX);
+  const result = allocateBlocksToRegions(measuredBlocks, infiniteFixedCapacityRegionStream(capacity), options);
+  return result.regions.length;
 }
 
 // Derive a flat pages[] view from filled regions. Blocks within a page are
@@ -101,6 +130,22 @@ export function paginateMeasuredBlocks(measuredBlocks, options = {}) {
   };
 }
 
+function infiniteFixedCapacityRegionStream(capacity) {
+  let index = 0;
+  return {
+    next() {
+      const region = {
+        id: `estimate-region-${index}`,
+        capacity,
+        pageIndex: index,
+        columnIndex: 0,
+      };
+      index += 1;
+      return region;
+    },
+  };
+}
+
 // Translate the new region-shaped warnings back to the legacy
 // `block-overflows-page` schema that document-export.mjs and downstream
 // consumers expect. Once consumers migrate, this can drop.

package/engine/react/pagination.mjs

@@ -5,5 +5,5 @@
 // these helpers. The region kernel is also usable on its own for custom
 // pipelines or unit tests.
 
-export { paginateMeasuredBlocks, allocateBlocksToRegions, pagesFromRegions } from "./pagination/allocator.mjs";
+export { paginateMeasuredBlocks, allocateBlocksToRegions, estimateRegionsNeeded, pagesFromRegions } from "./pagination/allocator.mjs";
 export { singleColumnRegionStream, multiColumnRegionStream, fixedRegionStream } from "./pagination/regions.mjs";

package/engine/react/pipeline/allocate.mjs

@@ -6,6 +6,8 @@
 //   - `hints`: { totalPagesPerChain: { [chainId]: number } } — fed back to <Sections>
 //   - `warnings`: chain-overflowed, etc.
 
+import { allocateBlocksToRegions, estimateRegionsNeeded } from "../pagination/allocator.mjs";
+
 const SANITY_LIMIT = 200;
 
 /**
@@ -58,7 +60,7 @@ export function allocateChains({ frames, mdxAreas, blockHeights, sources }) {
       continue;
     }
 
-    const { result, neededAreas } = greedyAllocate(blocks, regions);
+    const { result, neededAreas } = allocateBlocksToFiniteRegions(blocks, regions);
     const lastOverflow = regions[regions.length - 1].__overflow;
     const sourceFramesForChain = uniqueFramesForChain(frames, chainId);
 
@@ -110,71 +112,26 @@ export function allocateChains({ frames, mdxAreas, blockHeights, sources }) {
   };
 }
 
-function greedyAllocate(blocks, regions) {
-  const filled = [];
-  let regionIndex = 0;
-  let currentBlockIds = [];
-  let currentHeight = 0;
-  let consumed = 0;
-  const flush = () => {
-    if (currentBlockIds.length === 0) return;
-    filled.push({
-      region: regions[regionIndex],
-      blockIds: currentBlockIds,
-    });
-    currentBlockIds = [];
-    currentHeight = 0;
+function allocateBlocksToFiniteRegions(blocks, regions) {
+  const byRegionId = new Map(regions.map((region) => [region.id, region]));
+  const result = allocateBlocksToRegions(blocks, finiteRegionStream(regions), {
+    keepWithNext: shouldKeepWithNext,
+  });
+  const filled = result.regions.map((region) => ({
+    region: byRegionId.get(region.regionId),
+    blockIds: region.blockIds,
+  })).filter((fill) => fill.region);
+  const consumed = result.consumedCount;
+  const remaining = blocks.slice(consumed);
+  const extraNeeded = remaining.length > 0
+    ? estimateRegionsNeeded(remaining, regions[regions.length - 1].capacity, {
+      keepWithNext: shouldKeepWithNext,
+    })
+    : 0;
+  return {
+    result: { filled, consumed },
+    neededAreas: filled.length + extraNeeded,
   };
-  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
-    const block = blocks[blockIndex];
-    while (regionIndex < regions.length) {
-      const region = regions[regionIndex];
-      const nextBlock = blocks[blockIndex + 1];
-      const keepWithNextHeight = shouldKeepWithNext(block, nextBlock) ? block.height + nextBlock.height : 0;
-      if (
-        currentBlockIds.length > 0 &&
-        keepWithNextHeight > 0 &&
-        currentHeight + keepWithNextHeight > region.capacity
-      ) {
-        flush();
-        regionIndex += 1;
-        continue;
-      }
-      if (currentBlockIds.length === 0 || currentHeight + block.height <= region.capacity) {
-        currentBlockIds.push(block.id);
-        currentHeight += block.height;
-        consumed += 1;
-        break;
-      }
-      // Doesn't fit — flush current region and advance
-      flush();
-      regionIndex += 1;
-    }
-    if (regionIndex >= regions.length) break;
-  }
-  flush();
-  // neededAreas = total regions consumed if we had unlimited supply
-  // For overflow detection we estimate: if consumed < blocks.length, we need more areas.
-  let neededAreas = filled.length;
-  if (consumed < blocks.length) {
-    // Estimate how many more areas needed
-    const lastCap = regions[regions.length - 1].capacity;
-    const remainingBlocks = blocks.slice(consumed);
-    let h = 0;
-    let extra = 0;
-    let inExtra = false;
-    for (const b of remainingBlocks) {
-      if (!inExtra || h + b.height > lastCap) {
-        extra += 1;
-        h = b.height;
-        inExtra = true;
-      } else {
-        h += b.height;
-      }
-    }
-    neededAreas += extra;
-  }
-  return { result: { filled, consumed }, neededAreas };
 }
 
 function shouldKeepWithNext(block, nextBlock) {
@@ -183,6 +140,15 @@ function shouldKeepWithNext(block, nextBlock) {
   return /^h[1-6]$/.test(name) || name === "caption";
 }
 
+function finiteRegionStream(regions) {
+  let index = 0;
+  return {
+    next() {
+      return index < regions.length ? regions[index++] : null;
+    },
+  };
+}
+
 function recordAllocation(allocation, result, regions) {
   for (const fill of result.filled) {
     const frameKey = fill.region.__frameKey;

package/engine/react/pipeline/frame-measurement.mjs

@@ -223,6 +223,10 @@ async function runChromiumMeasurement(html, viewport) {
         for (const el of Array.from(chain.querySelectorAll("[data-openpress-block-id]"))) {
           if (el.tagName.toLowerCase() === "caption") continue;
           if (el.getAttribute("data-openpress-block-layout") === "attached") continue;
+          // Cells inherit their row's block-id so the inspector can resolve a
+          // SourceBlock when clicking inside a <td>. Skip them here so the
+          // row's measured height isn't overwritten by each cell.
+          if (el.getAttribute("data-openpress-inherited-block-id") === "true") continue;
           const rect = el.getBoundingClientRect();
           out.push({
             id: el.getAttribute("data-openpress-block-id"),

package/engine/react/press-tree-inspection.mjs

@@ -0,0 +1,172 @@
+// Walks the user's default-exported component tree to extract
+// <Workspace> and <Press> metadata declared as JSX props.
+//
+// The 1.0 contract says <Press> carries every per-document setting on
+// its props (title, page, sources, slug, theme, componentsDir) and is
+// always nested inside <Workspace>. This helper invokes the user's
+// component once at load time to inspect those props before the engine
+// runs its render pipeline.
+//
+// Safe to call because Workspace, Press, and (typically) the user's
+// default export are inert function components that just return JSX —
+// they don't use hooks at the entry boundary.
+
+import React from "react";
+
+/**
+ * Inspect the user's default export and extract every <Press> child
+ * of the (optional) <Workspace> wrapper. The export pipeline iterates
+ * the returned `presses` array — single-Press workspaces simply have
+ * length 1, multi-Press have length N. There is no separate code path
+ * for the single-Press case.
+ *
+ * @param {object} opts
+ * @param {Function} opts.UserComponent  The default export of press/index.tsx.
+ * @param {symbol} opts.PRESS_MARKER     Marker identifying Press components.
+ * @param {symbol} opts.WORKSPACE_MARKER Marker identifying Workspace components.
+ * @returns {{
+ *   workspaceProps: Record<string, unknown>,
+ *   presses: Array<{
+ *     element: object,                          // ReactElement
+ *     props: Record<string, unknown>,           // Press JSX props (no children)
+ *     metadata: {
+ *       title?: string,
+ *       page?: unknown,
+ *       slug?: string,
+ *       theme?: string,
+ *       componentsDir?: string,
+ *       captionNumbering?: unknown,
+ *     },
+ *     sources: Record<string, unknown> | null,  // mdxSource() descriptors keyed by id
+ *     children: unknown,                        // raw children for re-rendering
+ *     index: number,                            // position in the Workspace
+ *   }>,
+ *   wrappedInWorkspace: boolean,
+ * }}
+ */
+export function inspectPressTree({ UserComponent, PRESS_MARKER, WORKSPACE_MARKER }) {
+  if (typeof UserComponent !== "function") {
+    return emptyResult();
+  }
+
+  let root;
+  try {
+    root = UserComponent({});
+  } catch (err) {
+    // The user's default export threw before returning JSX. This is rare
+    // (function components at the entry boundary don't normally use hooks
+    // that could fail), but we treat it as "no Press metadata declared"
+    // and let the render pipeline surface the real error later with
+    // full React error context.
+    return emptyResult();
+  }
+
+  if (!isReactElement(root)) return emptyResult();
+
+  const workspaceProps = isMarked(root, WORKSPACE_MARKER) ? extractProps(root) : {};
+  const wrappedInWorkspace = isMarked(root, WORKSPACE_MARKER);
+
+  // Find every <Press> element in the tree (Workspace child, or root itself).
+  const pressElements = collectPressElements(root, PRESS_MARKER);
+
+  const presses = pressElements.map((element, index) => {
+    const props = extractProps(element);
+    return {
+      element,
+      props,
+      metadata: pickPressMetadata(props),
+      sources: extractSources(props),
+      children: element.props?.children ?? null,
+      index,
+    };
+  });
+
+  return {
+    workspaceProps,
+    presses,
+    wrappedInWorkspace,
+  };
+}
+
+function emptyResult() {
+  return {
+    workspaceProps: {},
+    presses: [],
+    wrappedInWorkspace: false,
+  };
+}
+
+function isReactElement(value) {
+  return value && typeof value === "object" && "type" in value && "props" in value;
+}
+
+function isMarked(element, marker) {
+  if (!isReactElement(element)) return false;
+  const type = element.type;
+  if (!type) return false;
+  // Components are tagged via `Component.openpressMarker = MARKER`.
+  return type.openpressMarker === marker;
+}
+
+function extractProps(element) {
+  if (!isReactElement(element) || !element.props) return {};
+  // Drop children — props are non-tree metadata only.
+  const { children, ...rest } = element.props;
+  return rest;
+}
+
+function collectPressElements(root, PRESS_MARKER) {
+  const found = [];
+  walk(root);
+  return found;
+
+  function walk(node) {
+    if (!isReactElement(node)) {
+      // Could be array / fragment / string / number — flatten and recurse.
+      if (Array.isArray(node)) {
+        for (const child of node) walk(child);
+      }
+      return;
+    }
+    if (isMarked(node, PRESS_MARKER)) {
+      found.push(node);
+      // Don't descend into Press — its children are the document tree,
+      // not more workspace structure.
+      return;
+    }
+    // Recurse into children + Fragment-like wrappers.
+    const children = node.props?.children;
+    if (children == null) return;
+    React.Children.forEach(children, walk);
+  }
+}
+
+function pickPressMetadata(pressProps) {
+  const out = {};
+  if (typeof pressProps.title === "string") out.title = pressProps.title;
+  if (pressProps.page !== undefined) out.page = pressProps.page;
+  if (typeof pressProps.slug === "string") out.slug = pressProps.slug;
+  if (typeof pressProps.theme === "string") out.theme = pressProps.theme;
+  if (typeof pressProps.componentsDir === "string") out.componentsDir = pressProps.componentsDir;
+  if (pressProps.captionNumbering !== undefined) out.captionNumbering = pressProps.captionNumbering;
+  return out;
+}
+
+// Convert the v1.0 <Press sources={[ mdxSource({ id, ... }), ... ]}> array
+// into the engine's expected sources record { [id]: descriptor }. Returns
+// null if no sources prop was declared (engine falls back to the named
+// `export const sources` from the entry module — the v0.x shape).
+function extractSources(pressProps) {
+  if (!Array.isArray(pressProps.sources)) return null;
+  const out = {};
+  for (const entry of pressProps.sources) {
+    if (!entry || typeof entry !== "object") continue;
+    const id = typeof entry.id === "string" ? entry.id : null;
+    if (!id) continue;
+    // Strip the id field — the engine's descriptor shape doesn't carry it
+    // (id was the record key in v0.x).
+    const { id: _omit, ...descriptor } = entry;
+    out[id] = descriptor;
+  }
+  return out;
+}

package/engine/react/sources/mdx-resolver.mjs

@@ -17,7 +17,7 @@ import { createHeadingState, fallbackOutlineItems, headingAttributesForBlock } f
 const MDX_EXT = ".mdx";
 
 /**
- * Resolve all sources registered in `document/index.tsx`.
+ * Resolve all sources registered in `press/index.tsx`.
  *
  * @param {object} opts
  * @param {Record<string, object>} opts.sources         The raw `sources` export.

package/engine/react/style-discovery.mjs

@@ -9,13 +9,31 @@ import { documentRelativePath } from "../runtime/path-utils.mjs";
 
 const COMPONENT_EXT = ".tsx";
 
-export async function discoverSectionStyles(root = ".", config = {}) {
+export async function discoverSectionStyles(root = ".", config = {}, { sectionRoots } = {}) {
   const workspaceRoot = path.resolve(root);
-  const documentRoot = config.paths?.documentRoot ?? path.join(workspaceRoot, "document");
+  const documentRoot = config.paths?.documentRoot ?? path.join(workspaceRoot, "press");
   const componentsRoot = config.paths?.componentsDir ?? path.join(documentRoot, "components");
-  const sectionsRoot = config.paths?.chaptersDir ?? config.paths?.sourceDir ?? path.join(documentRoot, "chapters");
   const globalComponents = await discoverComponents(componentsRoot, documentRoot, "global");
-  const sections = await discoverSections(documentRoot, sectionsRoot);
+
+  // Multi-Press workspaces can place their chapters under per-Press
+  // subfolders (e.g. press/userstory/chapters/, press/slidepack/chapters/).
+  // The caller passes each Press's resolved section-folders root; we
+  // discover sections in every root and merge. Duplicate paths are
+  // de-duplicated by absolutePath. Falls back to the workspace-default
+  // root (press/chapters/) when no roots are passed in.
+  const effectiveRoots = sectionRoots && sectionRoots.length > 0
+    ? sectionRoots
+    : [config.paths?.chaptersDir ?? config.paths?.sourceDir ?? path.join(documentRoot, "chapters")];
+  const seen = new Set();
+  const sections = [];
+  for (const sectionsRoot of effectiveRoots) {
+    const found = await discoverSections(documentRoot, sectionsRoot);
+    for (const section of found) {
+      if (seen.has(section.absolutePath)) continue;
+      seen.add(section.absolutePath);
+      sections.push(section);
+    }
+  }
 
   return {
     root: workspaceRoot,

package/engine/runtime/config.d.mts

@@ -10,6 +10,14 @@ export interface ResolvedConfig {
   componentsDir: string;
   publicDir: string;
   outputDir: string;
+  page: null | {
+    id: string;
+    label: string;
+    width: string;
+    height: string;
+    aspectRatio?: string;
+    heightRatio?: string;
+  };
   pdf: {
     filename: string;
   };