@stream-mdx/react 0.4.0 → 1.0.0

package/dist/trusted-mdx/server.mjs

@@ -0,0 +1,724 @@
+// src/trusted-mdx/server.tsx
+import React2 from "react";
+
+// src/trusted-mdx-contract.ts
+function assertTrustedMdxNativeChildContinuations(owners, flowChildren) {
+  if (owners.length !== flowChildren.length)
+    throw new Error("A trusted MDX native child continuation has misaligned owner and source spans.");
+  let continuationOwnerIndex;
+  for (let index = 0; index < owners.length; index++) {
+    let owner = owners[index];
+    if (owner?.kind !== "continuation") {
+      continuationOwnerIndex = void 0;
+      continue;
+    }
+    let ownerIndex = owner.ownerIndex, ownerForRun = owners[ownerIndex], previousChild = flowChildren[index - 1], child = flowChildren[index];
+    if (!Number.isSafeInteger(ownerIndex) || ownerIndex < 0 || ownerIndex >= index || (continuationOwnerIndex === void 0 ? ownerIndex !== index - 1 : ownerIndex !== continuationOwnerIndex) || ownerForRun === null || ownerForRun === void 0 || ownerForRun.kind === "continuation" || previousChild?.kind !== "inline" || child?.kind !== "inline" || previousChild.to <= previousChild.from || child.to <= child.from || previousChild.to !== child.from)
+      throw new Error("A trusted MDX native child continuation does not cover one exact contiguous inline run.");
+    continuationOwnerIndex = ownerIndex;
+  }
+}
+
+// src/trusted-mdx/evaluate.ts
+import React from "react";
+import * as jsxRuntime from "react/jsx-runtime";
+var AsyncFunction = Object.getPrototypeOf(async function() {
+}).constructor;
+async function evaluateCompiledMdx(code, options, canInvoke) {
+  let hostImports = options.imports, resolveSyncHostImport = (specifier) => {
+    if (specifier === "react")
+      return { default: React, ...React };
+    if (specifier === "react/jsx-runtime")
+      return jsxRuntime;
+    if (hostImports && Object.prototype.hasOwnProperty.call(hostImports, specifier))
+      return hostImports[specifier];
+    throw new Error(
+      `Cannot resolve MDX import specifier "${specifier}": no host binding configured. Automatic fetching and network egress are disabled.`
+    );
+  };
+  async function resolveDynamicHostImport(specifier) {
+    return resolveSyncHostImport(specifier);
+  }
+  let runtime = {
+    Fragment: jsxRuntime.Fragment,
+    jsx: jsxRuntime.jsx,
+    jsxs: jsxRuntime.jsxs,
+    _resolveSyncHostImport: resolveSyncHostImport,
+    _resolveDynamicHostImport: resolveDynamicHostImport
+  }, fn = new AsyncFunction(code);
+  return canInvoke() ? fn(runtime) : null;
+}
+
+// src/trusted-mdx/server.tsx
+import { TrustedMdxNativeChildrenSlot } from "@stream-mdx/react/_internal/trusted-mdx-native-children";
+
+// src/trusted-mdx/projection.ts
+function getActiveTrustedMdxNativeTree(meta) {
+  if (Array.isArray(meta?.trustedMdxNativeChildren)) return meta.trustedMdxNativeChildren;
+  if (meta?.htmlOwnership === !0 && Array.isArray(meta.htmlTree)) return meta.htmlTree;
+  if (Array.isArray(meta?.htmlParagraphTree)) return meta.htmlParagraphTree;
+  if (Array.isArray(meta?.htmlTree)) return meta.htmlTree;
+}
+function readSourceRange(value, sourceLength) {
+  if (typeof value != "object" || value === null || Array.isArray(value) || !("from" in value) || !("to" in value))
+    return null;
+  let from = value.from, to = value.to;
+  return typeof from != "number" || typeof to != "number" || !Number.isSafeInteger(from) || !Number.isSafeInteger(to) || from < 0 || to <= from || to > sourceLength ? null : { from, to };
+}
+function readSnapshotFields(value) {
+  if (typeof value != "object" || value === null || Array.isArray(value) || !("id" in value) || !("type" in value))
+    return null;
+  let id = value.id, type = value.type;
+  return typeof id != "string" || typeof type != "string" ? null : {
+    id,
+    type,
+    range: "range" in value ? value.range : void 0,
+    props: "props" in value ? value.props : void 0,
+    children: "children" in value ? value.children : void 0
+  };
+}
+function hasNativeBlockOwner(tree) {
+  if (!Array.isArray(tree)) return !1;
+  let pending = [...tree];
+  for (; pending.length > 0; ) {
+    let current = pending.pop();
+    if (!(typeof current != "object" || current === null || Array.isArray(current))) {
+      if ("kind" in current && current.kind === "block" && "block" in current) return !0;
+      "children" in current && Array.isArray(current.children) && pending.push(...current.children);
+    }
+  }
+  return !1;
+}
+function collectInlineOwners(value, sourceLength, matches) {
+  if (!Array.isArray(value)) return;
+  let visited = /* @__PURE__ */ new WeakSet(), pending = [...value];
+  for (; pending.length > 0; ) {
+    let current = pending.pop();
+    if (!(typeof current != "object" || current === null || visited.has(current))) {
+      if (visited.add(current), Array.isArray(current)) {
+        pending.push(...current);
+        continue;
+      }
+      "kind" in current && current.kind === "trusted-mdx-inline" && "ownerId" in current && typeof current.ownerId == "string" && addMdxOwner(
+        matches,
+        current.ownerId,
+        "inline expression",
+        "sourceRange" in current ? current.sourceRange : void 0,
+        sourceLength
+      ), "children" in current && Array.isArray(current.children) && pending.push(...current.children);
+    }
+  }
+}
+function isNestedMdxType(type) {
+  return type === "paragraph-mdx" || type === "blockquote-mdx" || type === "list-item-mdx";
+}
+function addMdxOwner(matches, id, label, range, sourceLength) {
+  let sourceRange = readSourceRange(range, sourceLength);
+  matches.push({
+    id,
+    label,
+    from: sourceRange?.from ?? null,
+    to: sourceRange?.to ?? null,
+    regions: [],
+    placement: null,
+    rootElementName: void 0,
+    nativeChildren: !1,
+    nativeChildOwners: [],
+    flowChildren: void 0,
+    nativeFlowOwnedBlockIds: [],
+    wholeBlockFlowRoot: !1,
+    ambiguous: !1
+  });
+}
+function readFlowChildRanges(flowChildren, flowRange, sourceLength) {
+  if (flowChildren === void 0) return;
+  let ranges = [], previousTo = flowRange.from;
+  for (let child of flowChildren) {
+    let range = readSourceRange(child, sourceLength);
+    if (!range || range.from < flowRange.from || range.to > flowRange.to || range.from < previousTo)
+      return null;
+    ranges.push(range), previousTo = range.to;
+  }
+  return ranges;
+}
+function classifyFlowRange(range, childRanges) {
+  let directChildIndex;
+  for (let index = 0; index < childRanges.length; index++) {
+    let childRange = childRanges[index];
+    if (!childRange) return null;
+    if (range.from >= childRange.from && range.to <= childRange.to) {
+      if (directChildIndex !== void 0) return null;
+      directChildIndex = index;
+    } else if (range.from < childRange.to && range.to > childRange.from)
+      return null;
+  }
+  return directChildIndex ?? "root-syntax";
+}
+function findInlineChildRunForRange(range, flowChildren, childRanges) {
+  if (!(flowChildren === void 0 || childRanges === void 0 || range.to <= range.from))
+    for (let startIndex = 0; startIndex < flowChildren.length; startIndex++) {
+      let firstChild = flowChildren[startIndex], firstRange = childRanges[startIndex];
+      if (firstChild?.kind !== "inline" || !firstRange || firstRange.from !== range.from || firstRange.to <= firstRange.from) continue;
+      let previousRange = firstRange;
+      for (let endIndex = startIndex + 1; endIndex < flowChildren.length; endIndex++) {
+        let child = flowChildren[endIndex], childRange = childRanges[endIndex];
+        if (child?.kind !== "inline" || !childRange || childRange.from !== previousRange.to || childRange.to <= childRange.from) break;
+        if (previousRange = childRange, previousRange.to === range.to)
+          return {
+            startIndex,
+            endIndex
+          };
+        if (previousRange.to > range.to) break;
+      }
+    }
+}
+function collectFlowOwnerBlocks(blocks) {
+  let flowOwnerBlocks = [], seenBlockIds = /* @__PURE__ */ new Set(), pendingBlocks = [...blocks], pendingNodes = [], visitedNodes = /* @__PURE__ */ new WeakSet();
+  for (let blockIndex = 0; blockIndex < pendingBlocks.length; blockIndex++) {
+    let block = pendingBlocks[blockIndex];
+    if (!block || seenBlockIds.has(block.id)) continue;
+    seenBlockIds.add(block.id), flowOwnerBlocks.push(block);
+    let meta = block.payload.meta, preparedTree = getActiveTrustedMdxNativeTree(meta);
+    for (preparedTree !== void 0 && pendingNodes.push(...preparedTree); pendingNodes.length > 0; ) {
+      let node = pendingNodes.pop();
+      !node || visitedNodes.has(node) || (visitedNodes.add(node), node.kind === "block" ? pendingBlocks.push(node.block) : (node.kind === "element" || node.kind === "component") && pendingNodes.push(...node.children));
+    }
+  }
+  return flowOwnerBlocks;
+}
+function hasWholeFlowRootMatch(block, childRange, matches) {
+  return matches.some(
+    (match) => match.wholeBlockFlowRoot && match.from === childRange.from && match.to === childRange.to && (match.id === block.id || block.payload.inline?.some(
+      (node) => node.kind === "trusted-mdx-inline" && node.ownerId === match.id && node.sourceRange?.from === childRange.from && node.sourceRange?.to === childRange.to
+    ) === !0)
+  );
+}
+function findPreparedTreeBlock(tree, childRange, sourceLength, exact = !1, wholeFlowRoots) {
+  if (!tree) return;
+  let pending = [...tree], owner, ownerWidth = -1;
+  for (; pending.length > 0; ) {
+    let node = pending.pop();
+    if (node)
+      if (node.kind === "block") {
+        let range = readSourceRange(node.block.payload.range, sourceLength);
+        if (!range) continue;
+        let wholeFlowRoot = wholeFlowRoots !== void 0 && hasWholeFlowRootMatch(node.block, childRange, wholeFlowRoots) && range.from === childRange.from && range.to <= childRange.to;
+        (exact ? range.from === childRange.from && range.to === childRange.to || wholeFlowRoot : range.from >= childRange.from && range.to <= childRange.to) && (wholeFlowRoots === void 0 || node.block.type === "mdx" || wholeFlowRoot) && range.to - range.from > ownerWidth && (owner = node.block, ownerWidth = range.to - range.from);
+      } else (node.kind === "element" || node.kind === "component") && pending.push(...node.children);
+  }
+  return owner;
+}
+function assertPreparedTreeOwnersFitFlowChildren(tree, childRanges, flowChildren, flowRange, sourceLength) {
+  if (!tree) return;
+  let pending = [...tree];
+  for (; pending.length > 0; ) {
+    let node = pending.pop();
+    if (node)
+      if (node.kind === "block") {
+        let range = readSourceRange(node.block.payload.range, sourceLength);
+        if (!range)
+          throw new Error("A trusted MDX flow region has a prepared worker block without a source span.");
+        if (range.from < flowRange.from || range.to > flowRange.to || range.from === flowRange.from && range.to === flowRange.to) continue;
+        if (childRanges === void 0)
+          throw new Error("A trusted MDX flow region has prepared tree owners but no direct-child spans.");
+        let inlineRun = node.block.type === "paragraph" && Array.isArray(node.block.payload.inline) && node.block.payload.inline.length > 0 ? findInlineChildRunForRange(range, flowChildren, childRanges) : void 0;
+        if (classifyFlowRange(range, childRanges) === null && inlineRun === void 0)
+          throw new Error("A trusted MDX flow region has prepared tree owners crossing direct-child boundaries.");
+      } else (node.kind === "element" || node.kind === "component") && pending.push(...node.children);
+  }
+}
+function collectFlowNativeBlocks(flowChildren, flowRange, blocks, rootOwnerId, sourceLength, matches, flowOwnerBlocks) {
+  let childRanges = readFlowChildRanges(flowChildren, flowRange, sourceLength);
+  if (childRanges === null)
+    throw new Error("A trusted MDX flow region has invalid or overlapping direct-child spans.");
+  let meta = flowOwnerBlocks.find((block) => block.id === rootOwnerId)?.payload.meta, preparedTree = getActiveTrustedMdxNativeTree(meta), preparedTrees = preparedTree === void 0 ? [] : [preparedTree], ownedBlockIds = [];
+  for (let block of blocks) {
+    if (block.id === rootOwnerId) continue;
+    let blockRange = readSourceRange(block.payload.range, sourceLength);
+    if (!blockRange || blockRange.from < flowRange.from || blockRange.to > flowRange.to || blockRange.from === flowRange.from && blockRange.to === flowRange.to) continue;
+    if (childRanges === void 0)
+      throw new Error("A trusted MDX flow region has worker owners but no direct-child spans.");
+    let ownership = classifyFlowRange(blockRange, childRanges), inlineRun = block.type === "paragraph" && Array.isArray(block.payload.inline) && block.payload.inline.length > 0 ? findInlineChildRunForRange(blockRange, flowChildren, childRanges) : void 0;
+    if (ownership === null && inlineRun === void 0)
+      throw new Error("A trusted MDX flow region has worker owners crossing direct-child boundaries.");
+    ownedBlockIds.push(block.id);
+  }
+  for (let tree of preparedTrees)
+    hasNativeBlockOwner(tree) && assertPreparedTreeOwnersFitFlowChildren(tree, childRanges, flowChildren, flowRange, sourceLength);
+  if (flowChildren === void 0 || flowChildren.length === 0)
+    return { childOwners: [], ownedBlockIds };
+  if (childRanges === void 0)
+    throw new Error("A trusted MDX flow region has native children but no direct-child spans.");
+  let groupedInlineOwners, registerGroupedInlineOwner = (block, kind) => {
+    if (block.id === rootOwnerId || block.type !== "paragraph" || !Array.isArray(block.payload.inline) || block.payload.inline.length === 0)
+      return;
+    let range = readSourceRange(block.payload.range, sourceLength);
+    if (!range) return;
+    let run = findInlineChildRunForRange(range, flowChildren, childRanges);
+    if (!run) return;
+    let groupedOwners = groupedInlineOwners ?? (groupedInlineOwners = new Array(flowChildren.length));
+    for (let index = run.startIndex; index <= run.endIndex; index++) {
+      let existing2 = groupedOwners[index];
+      if (existing2 && (existing2.block.id !== block.id || existing2.startIndex !== run.startIndex || existing2.endIndex !== run.endIndex))
+        throw new Error("A trusted MDX flow region has duplicate native owners for one inline child run.");
+    }
+    if (groupedOwners[run.startIndex]?.owner.kind === "block" && kind === "prepared-tree") return;
+    let candidate = {
+      startIndex: run.startIndex,
+      endIndex: run.endIndex,
+      block,
+      owner: kind === "block" ? { kind: "block", blockId: block.id } : { kind: "prepared-tree", blockId: block.id }
+    };
+    for (let index = run.startIndex; index <= run.endIndex; index++)
+      groupedOwners[index] = candidate;
+  };
+  for (let block of blocks)
+    registerGroupedInlineOwner(block, "block");
+  for (let tree of preparedTrees) {
+    let pending = [...tree], visited = /* @__PURE__ */ new WeakSet();
+    for (; pending.length > 0; ) {
+      let node = pending.pop();
+      !node || visited.has(node) || (visited.add(node), node.kind === "block" ? registerGroupedInlineOwner(node.block, "prepared-tree") : (node.kind === "element" || node.kind === "component") && pending.push(...node.children));
+    }
+  }
+  let groupedChildRanges;
+  for (let startIndex = 0; startIndex < (groupedInlineOwners?.length ?? 0); startIndex++) {
+    let groupedOwner = groupedInlineOwners?.[startIndex];
+    if (!(!groupedOwner || groupedOwner.startIndex !== startIndex))
+      for (let childIndex = groupedOwner.startIndex; childIndex <= groupedOwner.endIndex; childIndex++) {
+        let childRange = childRanges[childIndex];
+        if (!childRange)
+          throw new Error("A trusted MDX flow region has an invalid grouped inline child span.");
+        groupedChildRanges ?? (groupedChildRanges = /* @__PURE__ */ new Map()), groupedChildRanges.set(childRange.from, childRange.to);
+      }
+  }
+  if (groupedChildRanges !== void 0) {
+    for (let block of blocks) {
+      if (block.id === rootOwnerId) continue;
+      let blockRange = readSourceRange(block.payload.range, sourceLength);
+      if (blockRange && groupedChildRanges.get(blockRange.from) === blockRange.to)
+        throw new Error("A trusted MDX flow region has duplicate native owners inside a grouped inline run.");
+    }
+    for (let tree of preparedTrees) {
+      let pending = [...tree], visited = /* @__PURE__ */ new WeakSet();
+      for (; pending.length > 0; ) {
+        let node = pending.pop();
+        if (!(!node || visited.has(node)))
+          if (visited.add(node), node.kind === "block") {
+            let blockRange = readSourceRange(node.block.payload.range, sourceLength);
+            if (blockRange && groupedChildRanges.get(blockRange.from) === blockRange.to)
+              throw new Error("A trusted MDX flow region has duplicate native owners inside a grouped inline run.");
+          } else (node.kind === "element" || node.kind === "component") && pending.push(...node.children);
+      }
+    }
+  }
+  let childOwners = [];
+  for (let childIndex = 0; childIndex < flowChildren.length; childIndex++) {
+    let child = flowChildren[childIndex], childRange = childRanges?.[childIndex];
+    if (!child || !childRange)
+      throw new Error("A trusted MDX flow region has invalid direct-child spans.");
+    let groupedOwner = groupedInlineOwners?.[childIndex];
+    if (groupedOwner) {
+      if (groupedOwner.startIndex !== childIndex || child.kind !== "inline")
+        throw new Error("A trusted MDX flow region has an invalid grouped inline native owner.");
+      childOwners.push(groupedOwner.owner);
+      for (let coveredIndex = childIndex + 1; coveredIndex <= groupedOwner.endIndex; coveredIndex++)
+        childOwners.push({ kind: "continuation", ownerIndex: childIndex });
+      childIndex = groupedOwner.endIndex;
+      continue;
+    }
+    let ownerId, ownerWidth = -1;
+    if (child.kind !== "expression")
+      for (let block of blocks) {
+        if (block.id === rootOwnerId) continue;
+        let blockRange = readSourceRange(block.payload.range, sourceLength);
+        if (!blockRange || blockRange.from === flowRange.from && blockRange.to === flowRange.to || !(child.kind === "markdown" ? blockRange.from >= childRange.from && blockRange.to <= childRange.to : child.kind === "inline" || block.type === "mdx" ? blockRange.from === childRange.from && blockRange.to === childRange.to : blockRange.from === childRange.from && hasWholeFlowRootMatch(block, childRange, matches))) continue;
+        let width = blockRange.to - blockRange.from;
+        width > ownerWidth && (ownerId = block.id, ownerWidth = width);
+      }
+    if (ownerId !== void 0) {
+      childOwners.push({ kind: "block", blockId: ownerId });
+      continue;
+    }
+    if (child.kind !== "expression") {
+      let preparedOwner;
+      for (let tree of preparedTrees)
+        if (preparedOwner = findPreparedTreeBlock(
+          tree,
+          childRange,
+          sourceLength,
+          child.kind === "jsx",
+          child.kind === "jsx" ? matches : void 0
+        ), preparedOwner) break;
+      if (preparedOwner) {
+        if (child.kind === "inline") {
+          let preparedRange = readSourceRange(preparedOwner.payload.range, sourceLength);
+          if (preparedRange?.from !== childRange.from || preparedRange.to !== childRange.to)
+            throw new Error("A compiler-authored inline child has no exact prepared native owner.");
+        }
+        childOwners.push({ kind: "prepared-tree", blockId: preparedOwner.id });
+        continue;
+      }
+    }
+    if (child.kind === "markdown" || child.kind === "inline")
+      throw new Error("A compiler-authored Markdown child has no prepared native block owner.");
+    childOwners.push(null);
+  }
+  return { childOwners, ownedBlockIds };
+}
+function collectCompilerFlowBlockOwners(source, blocks, regions, matches) {
+  let ownerIds = new Set(matches.map((match) => match.id));
+  for (let region of regions) {
+    if (region.kind !== "render" || region.placement !== "flow" || !("rootElementName" in region)) continue;
+    let range = readSourceRange(region, source.length);
+    if (!range) continue;
+    let exactMatches = matches.filter((match) => match.from === range.from && match.to === range.to);
+    if (exactMatches.length > 0) {
+      for (let match of exactMatches) match.wholeBlockFlowRoot = !0;
+      continue;
+    }
+    let block = blocks.find((candidate) => {
+      let blockRange = readSourceRange(candidate.payload.range, source.length);
+      return blockRange !== null && blockRange.from === range.from && blockRange.to <= range.to;
+    });
+    !block || ownerIds.has(block.id) || (addMdxOwner(matches, block.id, `${block.type} compiler flow root`, range, source.length), matches[matches.length - 1].wholeBlockFlowRoot = !0, ownerIds.add(block.id));
+  }
+}
+function collectPreparedNestedOwners(prepared, sourceLength, matches) {
+  if (typeof prepared != "object" || prepared === null || Array.isArray(prepared) || !("children" in prepared) || !Array.isArray(prepared.children))
+    return;
+  let visited = /* @__PURE__ */ new WeakSet(), pending = [];
+  for (let index = 0; index < prepared.children.length; index++) {
+    let child = prepared.children[index];
+    pending.push(child);
+  }
+  for (; pending.length > 0; ) {
+    let value = pending.pop();
+    if (typeof value != "object" || value === null || Array.isArray(value) || visited.has(value))
+      continue;
+    visited.add(value);
+    let node = readSnapshotFields(value), nodeProps = node?.props && typeof node.props == "object" ? node.props : void 0;
+    if (nodeProps && "inline" in nodeProps && collectInlineOwners(nodeProps.inline, sourceLength, matches), node && isNestedMdxType(node.type) && addMdxOwner(matches, node.id, `${node.type} segment`, node.range, sourceLength), !(!node || !Array.isArray(node.children)))
+      for (let index = 0; index < node.children.length; index++) {
+        let child = node.children[index];
+        pending.push(child);
+      }
+  }
+}
+function collectHtmlTreeOwners(tree, sourceLength, matches) {
+  if (!Array.isArray(tree)) return;
+  let pending = [...tree], visited = /* @__PURE__ */ new WeakSet();
+  for (; pending.length > 0; ) {
+    let current = pending.pop();
+    if (!(typeof current != "object" || current === null || visited.has(current))) {
+      if (visited.add(current), Array.isArray(current)) {
+        pending.push(...current);
+        continue;
+      }
+      if ("kind" in current && current.kind === "block" && "block" in current) {
+        let candidate = current.block;
+        if (typeof candidate == "object" && candidate !== null && !Array.isArray(candidate) && "id" in candidate && typeof candidate.id == "string" && "type" in candidate && typeof candidate.type == "string" && "payload" in candidate && typeof candidate.payload == "object" && candidate.payload !== null) {
+          let block = candidate, meta = block.payload.meta;
+          if (block.type === "mdx" && addMdxOwner(
+            matches,
+            block.id,
+            "nested block",
+            block.payload.range,
+            sourceLength
+          ), collectInlineOwners(block.payload.inline, sourceLength, matches), meta) {
+            if (block.type === "paragraph" && Array.isArray(meta.mixedSegments))
+              for (let index = 0; index < meta.mixedSegments.length; index++) {
+                let segment = meta.mixedSegments[index];
+                typeof segment != "object" || segment === null || Array.isArray(segment) || !("kind" in segment) || segment.kind !== "mdx" || addMdxOwner(
+                  matches,
+                  `${block.id}::paragraph:segment:${index}`,
+                  "paragraph segment",
+                  "range" in segment ? segment.range : void 0,
+                  sourceLength
+                );
+              }
+            collectInlineOwners(meta.header, sourceLength, matches), collectInlineOwners(meta.rows, sourceLength, matches), collectPreparedNestedOwners(meta.preparedNested, sourceLength, matches);
+            let preparedTree = getActiveTrustedMdxNativeTree(meta);
+            preparedTree !== void 0 && pending.push(preparedTree);
+          }
+        }
+      }
+      "children" in current && Array.isArray(current.children) && pending.push(...current.children);
+    }
+  }
+}
+function collectMdxOwners(source, blocks) {
+  let matches = [];
+  for (let block of blocks) {
+    if (block.type === "mdx" && addMdxOwner(
+      matches,
+      block.id,
+      "block",
+      block.payload.range,
+      source.length
+    ), block.type === "paragraph") {
+      let segments = block.payload.meta?.mixedSegments;
+      if (Array.isArray(segments))
+        for (let index = 0; index < segments.length; index++) {
+          let segment = segments[index];
+          typeof segment != "object" || segment === null || Array.isArray(segment) || !("kind" in segment) || segment.kind !== "mdx" || addMdxOwner(
+            matches,
+            `${block.id}::paragraph:segment:${index}`,
+            "paragraph segment",
+            "range" in segment ? segment.range : void 0,
+            source.length
+          );
+        }
+    }
+    collectInlineOwners(block.payload.inline, source.length, matches);
+    let tableMeta = block.payload.meta;
+    if (tableMeta) {
+      collectInlineOwners(tableMeta.header, source.length, matches), collectInlineOwners(tableMeta.rows, source.length, matches), collectPreparedNestedOwners(tableMeta.preparedNested, source.length, matches);
+      let preparedTree = getActiveTrustedMdxNativeTree(tableMeta);
+      preparedTree !== void 0 && collectHtmlTreeOwners(preparedTree, source.length, matches);
+    }
+  }
+  let unique = /* @__PURE__ */ new Map();
+  for (let match of matches) {
+    let existing = unique.get(match.id);
+    existing ? (existing.from !== match.from || existing.to !== match.to) && (existing.ambiguous = !0) : unique.set(match.id, match);
+  }
+  return Array.from(unique.values());
+}
+function describeOwner(match) {
+  return match.label === "block" ? `MDX block "${match.id}"` : `MDX ${match.label} "${match.id}"`;
+}
+function isExactNativeMdxAliasRegion(region, owners) {
+  if (owners.length !== 2) return !1;
+  let first = owners[0], second = owners[1];
+  return !first || !second || first.from === null || first.to === null || first.from !== second.from || first.to !== second.to || region.from !== first.from || region.to !== first.to ? !1 : (first.label === "block" || first.label === "nested block") && second.label === "inline expression" && second.id.startsWith(`${first.id}::native-mdx:`) || (second.label === "block" || second.label === "nested block") && first.label === "inline expression" && first.id.startsWith(`${second.id}::native-mdx:`);
+}
+function placementFields(match) {
+  return match.placement === null ? {} : { placement: match.placement };
+}
+function projectMdxBlocks(source, blocks, regions, regionComponents) {
+  let projections = /* @__PURE__ */ new Map(), flowOwnerBlocks = collectFlowOwnerBlocks(blocks), matches = collectMdxOwners(source, blocks);
+  collectCompilerFlowBlockOwners(source, flowOwnerBlocks, regions, matches);
+  let ownersByRegion = /* @__PURE__ */ new Map();
+  for (let region of regions) {
+    let regionRange = readSourceRange(region, source.length);
+    if (!regionRange) continue;
+    let owners = [];
+    for (let match of matches) {
+      if (match.from === null || match.to === null) continue;
+      let ownerFrom = match.from, ownerTo = match.to;
+      if (regionRange.to <= match.from || regionRange.from >= match.to) continue;
+      let compilerFlowRoot = region.kind === "render" && "rootElementName" in region, regionContainsOwner = regionRange.from <= match.from && regionRange.to >= match.to;
+      if (region.kind !== "module" && (regionRange.from < match.from || regionRange.to > match.to)) {
+        if (compilerFlowRoot && regionContainsOwner) continue;
+        match.ambiguous = !0;
+        continue;
+      }
+      if (!(match.wholeBlockFlowRoot && regionRange.from >= ownerFrom && regionRange.to <= ownerTo && (regionRange.from > ownerFrom || regionRange.to < ownerTo)) && (match.regions.push(region), region.kind !== "module")) {
+        if (owners.push(match), region.placement !== "flow" && region.placement !== "inline" || match.placement !== null && match.placement !== region.placement ? match.ambiguous = !0 : match.placement = region.placement, region.kind === "render" && region.placement === "flow" && "rootElementName" in region && regionRange.from === match.from && regionRange.to === match.to && region.kind === "render" && "rootElementName" in region) {
+          match.wholeBlockFlowRoot = !0;
+          let flowNativeBlocks = collectFlowNativeBlocks(
+            region.flowChildren,
+            regionRange,
+            blocks,
+            match.id,
+            source.length,
+            matches,
+            flowOwnerBlocks
+          );
+          match.nativeFlowOwnedBlockIds = flowNativeBlocks.ownedBlockIds, match.nativeChildOwners = flowNativeBlocks.childOwners, match.flowChildren = region.flowChildren;
+        }
+        match.nativeChildren = match.nativeChildOwners.some((owner) => owner !== null) && match.placement === "flow", "rootElementName" in region && (match.rootElementName !== void 0 && match.rootElementName !== region.rootElementName ? match.ambiguous = !0 : match.rootElementName = region.rootElementName);
+      }
+    }
+    owners.length > 1 && ownersByRegion.set(region, owners);
+  }
+  for (let [region, owners] of ownersByRegion)
+    if (!isExactNativeMdxAliasRegion(region, owners))
+      for (let owner of owners) owner.ambiguous = !0;
+  for (let match of matches) {
+    let description = describeOwner(match);
+    if (match.from === null || match.to === null) {
+      projections.set(match.id, {
+        kind: "unmapped",
+        diagnostic: `${description} has no valid authored source range.`
+      });
+      continue;
+    }
+    if (!match.ambiguous && match.regions.length > 0) {
+      let orderedRegions = match.regions.slice().sort((left, right) => left.from - right.from || left.to - right.to), coveredUntil = match.from;
+      for (let region of orderedRegions) {
+        let from = Math.max(match.from, region.from), to = Math.min(match.to, region.to);
+        if (from < coveredUntil || source.slice(coveredUntil, from).trim().length > 0) {
+          match.ambiguous = !0;
+          break;
+        }
+        coveredUntil = to;
+      }
+      !match.ambiguous && source.slice(coveredUntil, match.to).trim().length > 0 && (match.ambiguous = !0);
+    }
+    if (match.ambiguous || match.regions.length === 0) {
+      projections.set(match.id, {
+        kind: "unmapped",
+        diagnostic: match.ambiguous ? `${description} cannot be mapped exactly to unique authored regions.` : `${description} (${match.from}..${match.to}) has no corresponding authored MDX region.`,
+        ...placementFields(match)
+      });
+      continue;
+    }
+    let renderRegions = match.regions.filter((region) => region.kind === "render");
+    if (renderRegions.length > 0) {
+      let placement = match.placement;
+      if (placement === null) {
+        projections.set(match.id, {
+          kind: "unmapped",
+          diagnostic: `${description} has render regions without compiler placement provenance.`
+        });
+        continue;
+      }
+      if (match.nativeChildren && match.rootElementName === void 0) {
+        projections.set(match.id, {
+          kind: "unmapped",
+          diagnostic: `${description} has prepared native children but no compiler-authored flow JSX root.`,
+          placement
+        });
+        continue;
+      }
+      let components = [], missingKey = null;
+      for (let region of renderRegions) {
+        if (!Object.prototype.hasOwnProperty.call(regionComponents, region.key)) {
+          missingKey = region.key;
+          break;
+        }
+        let component = regionComponents[region.key];
+        if (typeof component != "function") {
+          missingKey = region.key;
+          break;
+        }
+        components.push(component);
+      }
+      projections.set(
+        match.id,
+        missingKey === null ? {
+          kind: "render",
+          regions: Object.freeze(components),
+          placement,
+          ...match.nativeChildren ? { nativeChildren: !0 } : {},
+          ...match.nativeChildOwners.length > 0 ? { nativeChildOwners: Object.freeze([...match.nativeChildOwners]) } : {},
+          ...match.flowChildren ? { flowChildren: match.flowChildren } : {},
+          ...match.nativeFlowOwnedBlockIds.length > 0 ? { nativeFlowOwnedBlockIds: Object.freeze([...match.nativeFlowOwnedBlockIds]) } : {},
+          ...match.wholeBlockFlowRoot ? { wholeBlockFlowRoot: !0 } : {},
+          ...match.rootElementName === void 0 ? {} : { rootElementName: match.rootElementName }
+        } : {
+          kind: "unmapped",
+          diagnostic: `No evaluated renderer exists for MDX region "${missingKey}".`,
+          placement
+        }
+      );
+      continue;
+    }
+    if (match.regions.some((region) => region.kind === "module")) {
+      projections.set(match.id, { kind: "module" });
+      continue;
+    }
+    projections.set(match.id, {
+      kind: "unmapped",
+      diagnostic: `${description} has no renderable or module region.`
+    });
+  }
+  let moduleRanges = [];
+  for (let region of regions) {
+    if (region.kind !== "module") continue;
+    let range = readSourceRange(region, source.length);
+    range && moduleRanges.push(range);
+  }
+  for (let block of blocks) {
+    let range = readSourceRange(block.payload.range, source.length);
+    range && moduleRanges.some((module) => module.from <= range.from && module.to >= range.to) && projections.set(block.id, { kind: "module" });
+  }
+  let nativeChildIds = /* @__PURE__ */ new Set();
+  for (let projection of projections.values())
+    if (projection.kind === "render")
+      for (let id of projection.nativeFlowOwnedBlockIds ?? []) nativeChildIds.add(id);
+  for (let id of nativeChildIds) {
+    let projection = projections.get(id);
+    projection ? projections.set(id, { ...projection, nativeFlowParent: !0 }) : projections.set(id, { kind: "native-child", nativeFlowParent: !0 });
+  }
+  return Object.freeze(Object.fromEntries(projections));
+}
+
+// src/trusted-mdx/server.tsx
+async function projectTrustedMdxServerDocument(options) {
+  let components = options.components ? Object.freeze({ ...options.components }) : Object.freeze({}), evaluated = await evaluateCompiledMdx(options.artifact.code, { imports: options.imports }, () => !0);
+  if (!evaluated)
+    throw new Error("Trusted MDX server evaluation was unexpectedly cancelled.");
+  let regionComponents = evaluated.createRegions({ components }), projections = projectMdxBlocks(options.source, options.blocks, options.artifact.regions, regionComponents), regions = [];
+  for (let [ownerId, projection] of Object.entries(projections)) {
+    if (projection.kind === "native-child") {
+      regions.push(Object.freeze({ ownerId, kind: "native-child" }));
+      continue;
+    }
+    if (projection.kind === "module") {
+      regions.push(Object.freeze({ ownerId, kind: "module", ...projection.nativeFlowParent ? { nativeFlowParent: !0 } : {} }));
+      continue;
+    }
+    if (projection.kind === "unmapped")
+      throw new Error(projection.diagnostic);
+    if (projection.kind !== "render")
+      throw new Error(`Trusted MDX owner "${ownerId}" has no server-renderable compiler regions.`);
+    if (projection.nativeChildren && (projection.rootElementName === void 0 || projection.regions.length !== 1))
+      throw new Error(`Trusted MDX owner "${ownerId}" has no unique compiler-authored native-children root.`);
+    let nativeChildrenOverride = projection.nativeChildren ? (fallback) => {
+      let owners = projection.nativeChildOwners, flowChildren = projection.flowChildren;
+      if (!owners || !flowChildren || owners.length !== flowChildren.length)
+        throw new Error(`Trusted MDX owner "${ownerId}" has misaligned native child owners.`);
+      assertTrustedMdxNativeChildContinuations(owners, flowChildren);
+      let children = owners.map((owner, index) => {
+        if (owner?.kind === "continuation") return null;
+        if (owner !== null)
+          return React2.createElement(TrustedMdxNativeChildrenSlot, {
+            index,
+            key: `${owner.kind}:${owner.blockId}:${index}`
+          });
+        let flowChild = flowChildren[index];
+        if (flowChild === void 0)
+          throw new Error(`Trusted MDX owner "${ownerId}" has a missing native flow child at index ${index}.`);
+        return React2.createElement(
+          React2.Fragment,
+          { key: `source:${flowChild.kind}:${flowChild.from}:${flowChild.to}` },
+          fallback(index)
+        );
+      });
+      return React2.createElement(TrustedMdxNativeChildrenSlot, null, children);
+    } : void 0, content = React2.createElement(
+      React2.Fragment,
+      null,
+      ...projection.regions.map((Region, index) => React2.createElement(
+        React2.Fragment,
+        { key: `${ownerId}:${index}` },
+        Region({
+          components,
+          ...nativeChildrenOverride === void 0 ? {} : { children: nativeChildrenOverride }
+        })
+      ))
+    );
+    regions.push(
+      Object.freeze({
+        ownerId,
+        kind: "render",
+        content,
+        placement: projection.placement,
+        ...projection.nativeChildren ? { nativeChildren: !0 } : {},
+        ...projection.nativeChildOwners ? { nativeChildOwners: projection.nativeChildOwners } : {},
+        ...projection.flowChildren ? { flowChildren: projection.flowChildren } : {},
+        ...projection.nativeFlowOwnedBlockIds ? { nativeFlowOwnedBlockIds: projection.nativeFlowOwnedBlockIds } : {},
+        ...projection.wholeBlockFlowRoot ? { wholeBlockFlowRoot: !0 } : {},
+        ...projection.nativeFlowParent ? { nativeFlowParent: !0 } : {},
+        ...projection.rootElementName === void 0 ? {} : { rootElementName: projection.rootElementName }
+      })
+    );
+  }
+  return Object.freeze({ regions: Object.freeze(regions), layout: evaluated.layout ?? null });
+}
+export {
+  projectTrustedMdxServerDocument
+};