@open-press/core 0.7.0 → 0.8.0

package/engine/react/mdx-compile.mjs

@@ -99,9 +99,20 @@ 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);
+      setDataAttribute(node, "data-openpress-object-id", createBlockObjectEntityId(id));
       const extraAttributes = blockAttributes.get(id);
       if (extraAttributes) {
         for (const [name, value] of Object.entries(extraAttributes)) {
@@ -132,9 +143,19 @@ function applyTableRowBlocks({
   includeBlockIds,
 }) {
   const rows = tableBodyRows(node);
+  const header = tableHeaderRow(node);
+  const caption = tableCaption(node);
+  const captionRecord = caption ? { id: `${id}-caption`, node: caption } : null;
+  const headerRecord = header ? { id: `${id}-h0`, node: header } : null;
+  const selectedCaption = captionRecord && (!includeBlockIds || includeBlockIds.has(captionRecord.id));
+  const selectedHeader = headerRecord && (!includeBlockIds || includeBlockIds.has(headerRecord.id));
+  const firstSelectedRowIndex = selectedFirstTableRowIndex(rows, includeBlockIds, id);
+  const renderCaption = selectedCaption || (captionRecord && includeBlockIds && firstSelectedRowIndex === 0);
+  const renderHeader = Boolean(headerRecord && (!includeBlockIds || firstSelectedRowIndex === 0 || selectedHeader));
   if (rows.length === 0) {
     if (includeBlockIds && !includeBlockIds.has(id)) return false;
     setDataAttribute(node, "data-openpress-block-id", id);
+    setDataAttribute(node, "data-openpress-object-id", createBlockObjectEntityId(id));
     blocks.push({
       id,
       kind: "element",
@@ -155,15 +176,56 @@ function applyTableRowBlocks({
   const selected = includeBlockIds
     ? rowRecords.filter((row) => includeBlockIds.has(row.id))
     : rowRecords;
-  if (selected.length === 0) return false;
+  if (selected.length === 0 && !selectedCaption && !selectedHeader) return false;
 
   setDataAttribute(node, "data-openpress-table-id", id);
+  if (headerRecord && renderHeader) {
+    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");
+  }
+  if (captionRecord) {
+    if (renderCaption) {
+      setDataAttribute(captionRecord.node, "data-openpress-block-id", captionRecord.id);
+      setDataAttribute(captionRecord.node, "data-openpress-object-id", createBlockObjectEntityId(captionRecord.id));
+      if (selectedCaption) {
+        blocks.push({
+          id: captionRecord.id,
+          kind: "element",
+          name: "caption",
+          text: textContent(captionRecord.node).trim() || undefined,
+          filePath,
+          chapterSlug,
+          tableId: id,
+          layout: "attached",
+          source: sourcePosition(captionRecord.node.position ?? node.position),
+        });
+      }
+    } else {
+      removeTableCaption(node);
+    }
+  }
+  if (headerRecord && selectedHeader) {
+    blocks.push({
+      id: headerRecord.id,
+      kind: "table-row",
+      name: "table-header-row",
+      text: textContent(headerRecord.node).trim() || undefined,
+      filePath,
+      chapterSlug,
+      tableId: id,
+      rowIndex: -1,
+      layout: "attached",
+      source: sourcePosition(headerRecord.node.position ?? node.position),
+    });
+  }
   const selectedNodes = new Set(selected.map((row) => row.node));
   pruneUnselectedTableRows(node, new Set(rowRecords.map((row) => row.node)), selectedNodes);
-  if (selected[0]?.index > 0) stripTableHeader(node);
+  if (!renderHeader) stripTableHeader(node);
 
   for (const row of selected) {
     setDataAttribute(row.node, "data-openpress-block-id", row.id);
+    setDataAttribute(row.node, "data-openpress-object-id", createBlockObjectEntityId(row.id));
     blocks.push({
       id: row.id,
       kind: "table-row",
@@ -219,6 +281,7 @@ function normalizeTableCaptions(node) {
         type: "element",
         tagName: "caption",
         properties: {},
+        position: child.position,
         children: [{ type: "text", value: captionText }],
       });
     }
@@ -262,8 +325,10 @@ function wrapMdxComponents(components) {
     if (typeof Component !== "function") continue;
     wrapped[name] = function ComponentBlock(props = {}) {
       const blockId = props["data-openpress-block-id"];
+      const objectId = props["data-openpress-object-id"] || (blockId ? createBlockObjectEntityId(blockId) : undefined);
       const rest = { ...props };
       delete rest["data-openpress-block-id"];
+      delete rest["data-openpress-object-id"];
 
       if (!blockId) return React.createElement(Component, rest);
 
@@ -271,6 +336,7 @@ function wrapMdxComponents(components) {
         "div",
         {
           "data-openpress-block-id": blockId,
+          "data-openpress-object-id": objectId,
           "data-openpress-component-block": name,
         },
         React.createElement(Component, rest),
@@ -314,6 +380,89 @@ 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);
+    setDataAttribute(node, "data-openpress-object-id", createBlockObjectEntityId(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);
+    setDataAttribute(item.node, "data-openpress-object-id", createBlockObjectEntityId(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 = [];
@@ -328,6 +477,28 @@ function tableBodyRows(table) {
   return (table.children ?? []).filter((child) => child?.type === "element" && child.tagName === "tr");
 }
 
+function tableHeaderRow(table) {
+  if (table?.type !== "element" || table.tagName !== "table") return null;
+  for (const child of table.children ?? []) {
+    if (child?.type !== "element" || child.tagName !== "thead") continue;
+    return (child.children ?? []).find((row) => row?.type === "element" && row.tagName === "tr") ?? null;
+  }
+  return null;
+}
+
+function selectedFirstTableRowIndex(rows, includeBlockIds, tableId) {
+  if (!includeBlockIds) return 0;
+  for (let index = 0; index < rows.length; index += 1) {
+    if (includeBlockIds.has(`${tableId}-r${index}`)) return index;
+  }
+  return -1;
+}
+
+function tableCaption(table) {
+  if (table?.type !== "element" || table.tagName !== "table") return null;
+  return (table.children ?? []).find((child) => child?.type === "element" && child.tagName === "caption") ?? null;
+}
+
 function pruneUnselectedTableRows(node, rowNodes, selectedNodes) {
   if (!Array.isArray(node?.children)) return;
   node.children = node.children.filter((child) => {
@@ -341,10 +512,15 @@ function stripTableHeader(table) {
   if (!Array.isArray(table?.children)) return;
   table.children = table.children.filter((child) => {
     if (child?.type !== "element") return true;
-    return child.tagName !== "caption" && child.tagName !== "thead";
+    return child.tagName !== "thead";
   });
 }
 
+function removeTableCaption(table) {
+  if (!Array.isArray(table?.children)) return;
+  table.children = table.children.filter((child) => child?.type !== "element" || child.tagName !== "caption");
+}
+
 function headingText(node) {
   if (!/^h[1-6]$/.test(String(node?.tagName ?? ""))) return undefined;
   return textContent(node).trim() || undefined;
@@ -379,6 +555,14 @@ function setDataAttribute(node, name, value) {
   node.properties[name] = value;
 }
 
+function createObjectEntityId(kind, ...parts) {
+  return [kind, ...parts.map((part) => encodeURIComponent(String(part)))].join(":");
+}
+
+function createBlockObjectEntityId(blockId) {
+  return createObjectEntityId("mdx-block", blockId);
+}
+
 function visit(node, visitor) {
   visitor(node);
   if (!Array.isArray(node?.children)) return;

package/engine/react/measurement-css.mjs

@@ -20,7 +20,7 @@ export async function buildReactMeasurementCss(root, config, workspace) {
     parts.push("\n/* === public/openpress/chapter-scoped.css === */\n");
     parts.push(chapterCss);
   }
-  return rewriteAssetUrls(parts.join("\n"), config);
+  return rewriteAssetUrls(stripViewportMediaQueries(parts.join("\n")), config);
 }
 
 async function appendOptionalFile(parts, filePath, label) {
@@ -42,3 +42,95 @@ function rewriteAssetUrls(css, config) {
     .replace(/url\((["'])?\/openpress\/fonts\//g, `url($1${themeFontsDir}`)
     .replace(/url\((["'])?\/openpress\/katex-fonts\//g, `url($1${katexFontsDir}`);
 }
+
+function stripViewportMediaQueries(css) {
+  let output = "";
+  let cursor = 0;
+
+  while (cursor < css.length) {
+    const mediaIndex = css.indexOf("@media", cursor);
+    if (mediaIndex < 0) {
+      output += css.slice(cursor);
+      break;
+    }
+
+    output += css.slice(cursor, mediaIndex);
+    const blockStart = css.indexOf("{", mediaIndex);
+    if (blockStart < 0) {
+      output += css.slice(mediaIndex);
+      break;
+    }
+
+    const prelude = css.slice(mediaIndex + "@media".length, blockStart);
+    const blockEnd = findCssBlockEnd(css, blockStart);
+    if (blockEnd < 0) {
+      output += css.slice(mediaIndex);
+      break;
+    }
+
+    if (!isViewportMediaPrelude(prelude)) {
+      output += css.slice(mediaIndex, blockEnd + 1);
+    }
+    cursor = blockEnd + 1;
+  }
+
+  return output;
+}
+
+function isViewportMediaPrelude(prelude) {
+  if (/\bprint\b/i.test(prelude)) return false;
+  return /\(\s*(?:min-|max-)?(?:device-)?(?:width|height)\s*:/i.test(prelude)
+    || /\(\s*orientation\s*:/i.test(prelude)
+    || /\(\s*(?:min-|max-)?aspect-ratio\s*:/i.test(prelude);
+}
+
+function findCssBlockEnd(css, blockStart) {
+  let depth = 0;
+  let quote = "";
+  let inComment = false;
+
+  for (let index = blockStart; index < css.length; index += 1) {
+    const current = css[index];
+    const next = css[index + 1];
+
+    if (inComment) {
+      if (current === "*" && next === "/") {
+        inComment = false;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (quote) {
+      if (current === "\\") {
+        index += 1;
+        continue;
+      }
+      if (current === quote) quote = "";
+      continue;
+    }
+
+    if (current === "/" && next === "*") {
+      inComment = true;
+      index += 1;
+      continue;
+    }
+
+    if (current === "\"" || current === "'") {
+      quote = current;
+      continue;
+    }
+
+    if (current === "{") {
+      depth += 1;
+      continue;
+    }
+
+    if (current === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+
+  return -1;
+}

package/engine/react/object-entities.mjs

@@ -0,0 +1,119 @@
+export function createObjectEntityId(kind, ...parts) {
+  return [kind, ...parts.map((part) => encodeURIComponent(String(part)))].join(":");
+}
+
+export function createBlockObjectEntityId(blockId) {
+  return createObjectEntityId("mdx-block", blockId);
+}
+
+export function createPageObjectEntityId(frameKey) {
+  return createObjectEntityId("page", frameKey);
+}
+
+export function createFrameObjectEntityId(frameKey) {
+  return createObjectEntityId("frame", frameKey);
+}
+
+export function createMdxAreaObjectEntityId(frameKey, chainId, indexInFrame) {
+  return createObjectEntityId("mdx-area", frameKey, chainId, indexInFrame);
+}
+
+export function buildObjectEntities({ frames, blocks, blockMap }) {
+  const entities = {};
+  const blockParentIdByBlockId = new Map();
+
+  for (const block of blocks) {
+    const frameKey = block.frameKey ?? block.id;
+    const sourcePath = block.source?.path;
+    const pageId = createPageObjectEntityId(frameKey);
+    const base = {
+      frameKey,
+      pageId,
+      source: sourcePath
+        ? {
+            path: sourcePath,
+            file: block.source?.file,
+            line: 1,
+            column: 1,
+          }
+        : undefined,
+    };
+
+    entities[pageId] = {
+      id: pageId,
+      kind: "page",
+      label: block.title || `Page ${block.pageNumber}`,
+      ...base,
+    };
+
+    const frameId = createFrameObjectEntityId(frameKey);
+    entities[frameId] = {
+      id: frameId,
+      kind: "frame",
+      label: block.role || block.title || frameKey,
+      ...base,
+      parentId: pageId,
+      metadata: { role: block.role ?? null, chrome: block.chrome ?? null },
+    };
+  }
+
+  for (const frame of frames) {
+    const pageId = createPageObjectEntityId(frame.frameKey);
+    const frameId = createFrameObjectEntityId(frame.frameKey);
+    for (const area of frame.mdxAreas ?? []) {
+      const id = createMdxAreaObjectEntityId(frame.frameKey, area.chainId, area.indexInFrame);
+      const firstEditableBlock = (area.blockIds ?? [])
+        .map((blockId) => blockMap[blockId])
+        .find((block) => block?.path);
+      for (const blockId of area.blockIds ?? []) blockParentIdByBlockId.set(blockId, id);
+      entities[id] = {
+        id,
+        kind: "mdx-area",
+        label: `${area.chainId} area ${area.indexInFrame + 1}`,
+        parentId: frameId,
+        pageId,
+        frameKey: frame.frameKey,
+        chainId: area.chainId,
+        source: firstEditableBlock
+          ? {
+              path: firstEditableBlock.path,
+              source: firstEditableBlock.source,
+              line: firstEditableBlock.source?.line,
+              column: firstEditableBlock.source?.column,
+            }
+          : undefined,
+        metadata: { blockCount: area.blockIds?.length ?? 0 },
+      };
+    }
+  }
+
+  for (const block of Object.values(blockMap)) {
+    if (!block?.id) continue;
+    const id = createBlockObjectEntityId(block.id);
+    const pageId = block.frameKey ? createPageObjectEntityId(block.frameKey) : undefined;
+    entities[id] = {
+      id,
+      kind: "mdx-block",
+      label: block.name ? `${block.name} ${block.id}` : block.id,
+      parentId: blockParentIdByBlockId.get(block.id),
+      pageId,
+      blockId: block.id,
+      frameKey: block.frameKey,
+      chainId: block.chainId,
+      source: block.path
+        ? {
+            path: block.path,
+            source: block.source,
+            line: block.source?.line,
+            column: block.source?.column,
+          }
+        : undefined,
+      metadata: {
+        blockKind: block.kind ?? null,
+        componentName: block.kind === "component" ? block.name ?? null : null,
+      },
+    };
+  }
+
+  return entities;
+}

package/engine/react/pipeline/allocate.mjs

@@ -179,7 +179,8 @@ function greedyAllocate(blocks, regions) {
 
 function shouldKeepWithNext(block, nextBlock) {
   if (!nextBlock) return false;
-  return /^h[1-6]$/.test(String(block?.name ?? ""));
+  const name = String(block?.name ?? "");
+  return /^h[1-6]$/.test(name) || name === "caption";
 }
 
 function recordAllocation(allocation, result, regions) {
@@ -223,12 +224,14 @@ function groupBlockHeights(blockHeights) {
 
 function buildBlockStream(chainSource, heightMap) {
   if (!chainSource || !heightMap) return [];
-  return chainSource.map((block) => ({
-    id: block.id,
-    kind: block.kind,
-    name: block.name,
-    height: heightMap.get(block.id) ?? 0,
-  }));
+  return chainSource
+    .filter((block) => block.layout !== "attached")
+    .map((block) => ({
+      id: block.id,
+      kind: block.kind,
+      name: block.name,
+      height: heightMap.get(block.id) ?? 0,
+    }));
 }
 
 function* iterateChains(sources) {

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) => {
@@ -206,6 +221,8 @@ async function runChromiumMeasurement(html, viewport) {
         const parentTop = chain.parentElement?.getBoundingClientRect().top ?? chain.getBoundingClientRect().top;
         let previousBottom = parentTop;
         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;
           const rect = el.getBoundingClientRect();
           out.push({
             id: el.getAttribute("data-openpress-block-id"),
@@ -232,13 +249,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/engine/react/project-asset-endpoint.mjs

@@ -3,8 +3,7 @@ import path from "node:path";
 import { loadConfig } from "../runtime/config.mjs";
 import { collectSourceTextFiles } from "../runtime/source-text-tools.mjs";
 import { insertCommentMarker } from "./comment-marker.mjs";
-
-const MAX_PROJECT_ASSET_BODY_BYTES = 64 * 1024;
+import { readJsonBody, writeJson } from "./http-json.mjs";
 
 export async function handleProjectAssetRequest(req, res, {
   root = ".",
@@ -16,7 +15,7 @@ export async function handleProjectAssetRequest(req, res, {
   }
 
   try {
-    const body = await readJsonBody(req);
+    const body = await readJsonBody(req, { bodyLabel: "Project asset request" });
     const config = await loadConfig(root);
     const action = stringValue(body?.action);
     const kind = stringValue(body?.kind);
@@ -53,6 +52,7 @@ export async function handleProjectAssetRequest(req, res, {
         note: body?.note,
         commentTarget: body?.commentTarget,
         currentSource: body?.currentSource,
+        objectEntity: body?.objectEntity,
         timestamp,
       });
       writeJson(res, 200, { ok: true, ...result });
@@ -133,6 +133,7 @@ async function createProjectAssetComment({
   note,
   commentTarget,
   currentSource,
+  objectEntity,
   timestamp,
 }) {
   const normalizedName = normalizeAssetName(kind, name);
@@ -146,13 +147,14 @@ async function createProjectAssetComment({
     commentTarget: stringValue(commentTarget),
     currentSource,
   });
+  const objectHint = stringValue(objectEntity?.id) ? ` object=${stringValue(objectEntity.id)}` : "";
 
   const result = await insertCommentMarker({
     root: config.root,
     path: target.path,
     source: { line: target.line, column: 1 },
     note: `${assetLabel(kind, normalizedName)}：${noteText}`,
-    hint: `openpress-project-asset kind=${kind} action=comment target=${target.reason} asset=${normalizedName}`,
+    hint: `openpress-project-asset kind=${kind} action=comment target=${target.reason} asset=${normalizedName}${objectHint}`,
     timestamp,
   });
 
@@ -357,23 +359,3 @@ async function fileExists(filePath) {
     return false;
   }
 }
-
-async function readJsonBody(req) {
-  let body = "";
-  for await (const chunk of req) {
-    body += String(chunk);
-    if (Buffer.byteLength(body, "utf8") > MAX_PROJECT_ASSET_BODY_BYTES) {
-      throw new Error("Project asset request body is too large.");
-    }
-  }
-  try {
-    return JSON.parse(body || "{}");
-  } catch {
-    throw new Error("Project asset request body must be valid JSON.");
-  }
-}
-
-function writeJson(res, status, body) {
-  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
-  res.end(`${JSON.stringify(body, null, 2)}\n`);
-}

package/engine/react/source-edit-endpoint.d.mts

@@ -0,0 +1,10 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+export function handleSourceEditRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  options?: {
+    root?: string;
+    refreshDocument?: boolean;
+  },
+): Promise<void>;