@open-press/core 0.7.0 → 0.7.1

package/engine/commands/upgrade.mjs

@@ -1,9 +1,15 @@
 import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { diagnose } from "./doctor.mjs";
 import { runCommand } from "./_shared.mjs";
 
+// Migration notes live in the framework repo, not in scaffolded workspaces.
+// `npx open-press upgrade` fetches the notes for each pending version and
+// caches them under `.openpress/migrations/` so agents can read locally.
+const MIGRATION_REMOTE_BASE = "https://raw.githubusercontent.com/quan0715/open-press/main/docs/migrations";
+const MIGRATION_CACHE_DIR = path.join(".openpress", "migrations");
+
 export async function run({ root, options }) {
   const dryRun = Boolean(options?.dryRun);
   const skipSkills = Boolean(options?.noSkills);
@@ -85,7 +91,11 @@ export async function run({ root, options }) {
     process.stdout.write("  (no migration docs in this version range)\n\n");
   } else {
     for (const m of migrationContents) {
-      process.stdout.write(`  ─ ${m.path}\n`);
+      if (m.path) {
+        process.stdout.write(`  ─ ${m.path}${m.fetched ? "  (fetched from github)" : ""}\n`);
+      } else {
+        process.stdout.write(`  ─ ${m.version}.md  (not found locally or on github — check the repo manually)\n`);
+      }
     }
     process.stdout.write(
       "\nAgent: open each file, identify document-level changes, grep document/ for affected patterns, propose edits before applying.\n",
@@ -107,11 +117,43 @@ async function hasCoreDep(root) {
 
 async function loadMigrations(root, versions) {
   const results = [];
+  const cacheDir = path.join(root, MIGRATION_CACHE_DIR);
+  await mkdir(cacheDir, { recursive: true });
+
   for (const v of versions) {
-    const p = path.join(root, "docs", "migrations", `${v}.md`);
-    if (existsSync(p)) {
-      results.push({ version: v, path: path.relative(root, p) });
+    // Framework repo has docs/migrations/ at root — prefer local if present
+    // (covers the open-press framework repo itself acting as a workspace).
+    const localDocsPath = path.join(root, "docs", "migrations", `${v}.md`);
+    if (existsSync(localDocsPath)) {
+      results.push({ version: v, path: path.relative(root, localDocsPath), fetched: false });
+      continue;
+    }
+
+    // Otherwise fetch from GitHub raw and cache to .openpress/migrations/.
+    const cachedPath = path.join(cacheDir, `${v}.md`);
+    if (existsSync(cachedPath)) {
+      results.push({ version: v, path: path.relative(root, cachedPath), fetched: false });
+      continue;
+    }
+
+    const body = await fetchMigration(v);
+    if (body) {
+      await writeFile(cachedPath, body, "utf8");
+      results.push({ version: v, path: path.relative(root, cachedPath), fetched: true });
+    } else {
+      results.push({ version: v, path: null, fetched: false });
     }
   }
   return results;
 }
+
+async function fetchMigration(version) {
+  const url = `${MIGRATION_REMOTE_BASE}/${version}.md`;
+  try {
+    const res = await fetch(url, { headers: { Accept: "text/plain" } });
+    if (!res.ok) return null;
+    return await res.text();
+  } catch {
+    return null;
+  }
+}

package/engine/react/document-export.mjs

@@ -92,6 +92,21 @@ export async function exportReactDocument(root = ".", { syncAssets = true } = {}
         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 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;

package/engine/react/mdx-compile.mjs

@@ -99,6 +99,16 @@ export function rehypeBlockIds(options = {}) {
           includeBlockIds,
         });
       }
+      if (block.name === "ul" || block.name === "ol") {
+        return applyListItemBlocks({
+          node,
+          id,
+          blocks,
+          filePath,
+          chapterSlug,
+          includeBlockIds,
+        });
+      }
       if (includeBlockIds && !includeBlockIds.has(id)) return false;
 
       setDataAttribute(node, "data-openpress-block-id", id);
@@ -314,6 +324,87 @@ function blockInfo(node) {
   return null;
 }
 
+function applyListItemBlocks({
+  node,
+  id,
+  blocks,
+  filePath,
+  chapterSlug,
+  includeBlockIds,
+}) {
+  const items = listItems(node);
+  if (items.length === 0) {
+    if (includeBlockIds && !includeBlockIds.has(id)) return false;
+    setDataAttribute(node, "data-openpress-block-id", id);
+    blocks.push({
+      id,
+      kind: "element",
+      name: node.tagName,
+      text: textContent(node).trim() || undefined,
+      filePath,
+      chapterSlug,
+      source: sourcePosition(node.position),
+    });
+    return "skip";
+  }
+
+  const itemRecords = items.map((item, index) => ({
+    id: `${id}-i${index}`,
+    node: item,
+    index,
+  }));
+  const selected = includeBlockIds
+    ? itemRecords.filter((item) => includeBlockIds.has(item.id))
+    : itemRecords;
+  if (selected.length === 0) return false;
+
+  setDataAttribute(node, "data-openpress-list-id", id);
+
+  // For ordered lists, continuation pages must keep numbering picking up
+  // from the first surviving item. `start` is the 1-based number of the
+  // first `<li>` rendered, so if the original list had `start="5"` and we
+  // dropped the first three items, continuation starts at 5 + 3 = 8.
+  if (node.tagName === "ol" && selected[0]?.index > 0) {
+    const baseStart = Number(node.properties?.start ?? 1);
+    const continuationStart = baseStart + selected[0].index;
+    node.properties = { ...node.properties, start: continuationStart };
+  }
+
+  const selectedNodes = new Set(selected.map((item) => item.node));
+  pruneUnselectedListItems(node, new Set(itemRecords.map((item) => item.node)), selectedNodes);
+
+  for (const item of selected) {
+    setDataAttribute(item.node, "data-openpress-block-id", item.id);
+    blocks.push({
+      id: item.id,
+      kind: "list-item",
+      name: "list-item",
+      text: textContent(item.node).trim() || undefined,
+      filePath,
+      chapterSlug,
+      listId: id,
+      listTag: node.tagName,
+      itemIndex: item.index,
+      source: sourcePosition(item.node.position ?? node.position),
+    });
+  }
+  return "skip";
+}
+
+function listItems(list) {
+  if (list?.type !== "element") return [];
+  if (list.tagName !== "ul" && list.tagName !== "ol") return [];
+  return (list.children ?? []).filter((child) => child?.type === "element" && child.tagName === "li");
+}
+
+function pruneUnselectedListItems(node, itemNodes, selectedNodes) {
+  if (!Array.isArray(node?.children)) return;
+  node.children = node.children.filter((child) => {
+    if (!itemNodes.has(child)) return true;
+    return selectedNodes.has(child);
+  });
+}
+
 function tableBodyRows(table) {
   if (table?.type !== "element" || table.tagName !== "table") return [];
   const rows = [];

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

@@ -135,15 +135,30 @@ async function runChromiumMeasurement(html, viewport) {
   try {
     const page = await browser.newPage({ viewport });
     await page.setContent(html, { waitUntil: "load" });
+    // Match the print-ready settle: fonts first (font metrics affect image
+    // alt-text fallback boxes), then await every image's `complete` AND
+    // `decode()` so intrinsic sizes are committed before layout, then two
+    // animation frames so the chromium layout pass observes the final box
+    // model. Without this, `getBoundingClientRect()` on figures that hold
+    // images can race the decode and return collapsed heights, causing the
+    // allocator to pack too many blocks per page.
     await page.evaluate(async () => {
-      await Promise.all(Array.from(document.images).map((img) => {
-        if (img.complete) return Promise.resolve();
-        return new Promise((resolve) => {
-          img.addEventListener("load", resolve, { once: true });
-          img.addEventListener("error", resolve, { once: true });
-        });
-      }));
       if (document.fonts?.ready) await document.fonts.ready;
+      await Promise.all(Array.from(document.images).map(async (img) => {
+        if (!img.complete) {
+          await new Promise((resolve) => {
+            const settle = () => {
+              img.removeEventListener("load", settle);
+              img.removeEventListener("error", settle);
+              resolve(undefined);
+            };
+            img.addEventListener("load", settle, { once: true });
+            img.addEventListener("error", settle, { once: true });
+          });
+        }
+        await img.decode?.().catch(() => undefined);
+      }));
+      await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
     });
 
     const mdxAreas = await page.evaluate((safety) => {
@@ -232,13 +247,27 @@ async function inlineMeasurementMediaUrls(html, mediaDir) {
   if (!mediaDir || !html) return html;
   let out = String(html);
   const matches = new Set();
-  for (const match of out.matchAll(/\/openpress\/media\/([^"')\s>]+)/g)) {
-    matches.add(match[1]);
+  for (const match of out.matchAll(/\bsrc=(['"])([^\1]*?)\1/g)) {
+    const src = match[2];
+    if (!src) continue;
+    if (src.startsWith('/openpress/media/')) {
+      matches.add(src.slice('/openpress/media/'.length));
+      continue;
+    }
+    if (src.startsWith('media/')) {
+      matches.add(src.slice('media/'.length));
+      continue;
+    }
+    if (src.startsWith('./media/')) {
+      matches.add(src.slice('./media/'.length));
+    }
   }
   for (const rawName of matches) {
     const dataUrl = await mediaDataUrl(mediaDir, rawName);
     if (!dataUrl) continue;
     out = out.replaceAll(`/openpress/media/${rawName}`, dataUrl);
+    out = out.replaceAll(`media/${rawName}`, dataUrl);
+    out = out.replaceAll(`./media/${rawName}`, dataUrl);
   }
   return out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-press/core",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "type": "module",
   "description": "open-press core — runtime primitives, CLI, and render pipeline for AI-first fixed-layout documents.",
   "license": "MIT",