@beyondwork/docx-react-component 1.0.132 → 1.0.133

package/dist/{chunk-XYTWOJII.js → chunk-224TSMEB.js}

@@ -7,32 +7,33 @@ import {
   resolveSectionForStoryTarget,
   searchSecondaryStories,
   searchSurfaceBlocks
-} from "./chunk-LPLJZJT2.js";
+} from "./chunk-CVSD3UNK.js";
 import {
   createEditorSurfaceSnapshot,
   createFormattingContext,
   resolveTableStyleResolution
-} from "./chunk-U3UMKA7B.js";
+} from "./chunk-XBQFDBXE.js";
 import {
   createSelectionSnapshot
 } from "./chunk-OYGMRRR7.js";
 import {
   normalizeParsedTextDocument
-} from "./chunk-4HGFJ6Z2.js";
+} from "./chunk-PZIEOEJZ.js";
 import {
   buildFieldRegistry,
   parseMainDocumentXml,
   parseTocLevelRange
-} from "./chunk-RBWJHRNP.js";
+} from "./chunk-T66OS7MN.js";
 import {
   collectEditableTargetRefs,
   collectLayoutInputIdentities,
   validateEditableTargetRef
-} from "./chunk-RYMMKOFI.js";
+} from "./chunk-5KTJKTNE.js";
 import {
   serializeMainDocument
 } from "./chunk-FM4K4XFJ.js";
 import {
+  describeStructuredWrapperBlock,
   findOpaqueFragmentsIntersectingRange
 } from "./chunk-UFVDIR2C.js";
 import {
@@ -43,15 +44,15 @@ import {
   storyTargetsEqual
 } from "./chunk-M2HUK3KF.js";
 
-// src/runtime/workflow/scope-resolver.ts
-function inlineLength(node) {
+// src/core/commands/scope-coordinate-walk.ts
+function inlineLengthForScopeCoordinates(node) {
   switch (node.type) {
     case "text":
       return Array.from(node.text).length;
     case "hyperlink":
     case "field":
       return node.children.reduce(
-        (total, child) => total + inlineLength(child),
+        (total, child) => total + inlineLengthForScopeCoordinates(child),
         0
       );
     case "bookmark_start":
@@ -63,29 +64,241 @@ function inlineLength(node) {
       return 1;
   }
 }
-function walkParagraphs(document) {
-  const envelope = document;
-  const root = "content" in envelope ? envelope.content : document;
-  const out = [];
+function paragraphLengthForScopeCoordinates(paragraph) {
+  return paragraph.children.reduce(
+    (total, child) => total + inlineLengthForScopeCoordinates(child),
+    0
+  );
+}
+function computeScopeStoryLayout(document) {
+  const root = document.content;
+  const paragraphSlots = [];
+  const blockSlots = [];
+  if (!root || root.type !== "doc") {
+    return { paragraphSlots, blockSlots, storyLength: 0 };
+  }
   let cursor = 0;
   for (let index = 0; index < root.children.length; index += 1) {
     const block = root.children[index];
-    if (block && block.type === "paragraph") {
-      out.push({ paragraph: block, from: cursor });
-      cursor += block.children.reduce(
-        (total, child) => total + inlineLength(child),
-        0
-      );
-    } else if (block && block.type === "table") {
-      cursor += 1;
-    } else {
+    if (!block) continue;
+    cursor = walkBlockForScopeCoordinates(
+      block,
+      cursor,
+      [{ kind: "block", index }],
+      index,
+      paragraphSlots,
+      blockSlots
+    );
+    if (index < root.children.length - 1 && root.children[index + 1]?.type === "paragraph") {
       cursor += 1;
     }
-    if (index < root.children.length - 1) {
-      cursor += 1;
+  }
+  return { paragraphSlots, blockSlots, storyLength: cursor };
+}
+function findParagraphSlotAtPosition(layout, position, edge) {
+  const matches = layout.paragraphSlots.filter(
+    (slot) => position >= slot.from && position <= slot.to
+  );
+  if (matches.length === 0) return null;
+  if (edge === "start") {
+    return matches.find((slot) => slot.from === position) ?? matches.find((slot) => position > slot.from && position <= slot.to) ?? matches[0];
+  }
+  return matches.find((slot) => slot.to === position) ?? matches.find((slot) => position >= slot.from && position < slot.to) ?? matches[matches.length - 1];
+}
+function findOwningBlockSlotAtPosition(layout, position) {
+  const matches = layout.blockSlots.filter(
+    (slot) => position >= slot.from && position <= slot.to
+  );
+  if (matches.length === 0) return null;
+  return matches.reduce(
+    (best, slot) => slot.path.length >= best.path.length ? slot : best
+  );
+}
+function sameScopeParagraphPath(a, b) {
+  return scopeParagraphPathKey(a) === scopeParagraphPathKey(b);
+}
+function replaceParagraphChildrenAtPath(root, path, children) {
+  return {
+    ...root,
+    children: replaceInBlockList(root.children, path, children)
+  };
+}
+function removeScopeMarkersFromBlockList(blocks, scopeId) {
+  let mutated = false;
+  const nextBlocks = blocks.map((block) => {
+    const result = removeScopeMarkersFromBlock(block, scopeId);
+    if (result.mutated) mutated = true;
+    return result.block;
+  });
+  return { blocks: nextBlocks, mutated };
+}
+function walkBlockForScopeCoordinates(block, cursor, path, rootBlockIndex, paragraphSlots, blockSlots) {
+  const from = cursor;
+  if (block.type === "paragraph") {
+    const to2 = cursor + paragraphLengthForScopeCoordinates(block);
+    const slot = { path, rootBlockIndex, kind: block.type, from, to: to2 };
+    blockSlots.push(slot);
+    paragraphSlots.push({ ...slot, paragraph: block });
+    return to2;
+  }
+  if (block.type === "table") {
+    let innerCursor = cursor;
+    for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+      const row = block.rows[rowIndex];
+      for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+        const cell = row.cells[cellIndex];
+        for (let childIndex = 0; childIndex < cell.children.length; childIndex += 1) {
+          const child = cell.children[childIndex];
+          innerCursor = walkBlockForScopeCoordinates(
+            child,
+            innerCursor,
+            [
+              ...path,
+              { kind: "tableCell", rowIndex, cellIndex },
+              { kind: "block", index: childIndex }
+            ],
+            rootBlockIndex,
+            paragraphSlots,
+            blockSlots
+          );
+        }
+      }
     }
+    blockSlots.push({
+      path,
+      rootBlockIndex,
+      kind: block.type,
+      from,
+      to: innerCursor
+    });
+    return innerCursor;
   }
-  return out;
+  if (block.type === "sdt") {
+    const descriptor = describeStructuredWrapperBlock(block, {
+      projectVisibleTocContentControls: true
+    });
+    if (descriptor) {
+      const to2 = cursor + 1;
+      blockSlots.push({ path, rootBlockIndex, kind: block.type, from, to: to2 });
+      return to2;
+    }
+    let innerCursor = cursor;
+    for (let childIndex = 0; childIndex < block.children.length; childIndex += 1) {
+      const child = block.children[childIndex];
+      innerCursor = walkBlockForScopeCoordinates(
+        child,
+        innerCursor,
+        [...path, { kind: "sdtChildren" }, { kind: "block", index: childIndex }],
+        rootBlockIndex,
+        paragraphSlots,
+        blockSlots
+      );
+    }
+    blockSlots.push({
+      path,
+      rootBlockIndex,
+      kind: block.type,
+      from,
+      to: innerCursor
+    });
+    return innerCursor;
+  }
+  const to = cursor + 1;
+  blockSlots.push({ path, rootBlockIndex, kind: block.type, from, to });
+  return to;
+}
+function replaceInBlockList(blocks, path, children) {
+  const [head, ...rest] = path;
+  if (!head || head.kind !== "block") return [...blocks];
+  return blocks.map((block, index) => {
+    if (index !== head.index) return block;
+    if (rest.length === 0) {
+      return block.type === "paragraph" ? { ...block, children } : block;
+    }
+    return replaceInsideBlock(block, rest, children);
+  });
+}
+function replaceInsideBlock(block, path, children) {
+  const [head, ...rest] = path;
+  if (!head) return block;
+  if (block.type === "table" && head.kind === "tableCell") {
+    const rows = block.rows.map((row, rowIndex) => {
+      if (rowIndex !== head.rowIndex) return row;
+      const cells = row.cells.map((cell, cellIndex) => {
+        if (cellIndex !== head.cellIndex) return cell;
+        return {
+          ...cell,
+          children: replaceInBlockList(cell.children, rest, children)
+        };
+      });
+      return { ...row, cells };
+    });
+    return { ...block, rows };
+  }
+  if (block.type === "sdt" && head.kind === "sdtChildren") {
+    return {
+      ...block,
+      children: replaceInBlockList(block.children, rest, children)
+    };
+  }
+  return block;
+}
+function removeScopeMarkersFromBlock(block, scopeId) {
+  if (block.type === "paragraph") {
+    const kept = block.children.filter((child) => {
+      return !((child.type === "scope_marker_start" || child.type === "scope_marker_end") && child.scopeId === scopeId);
+    });
+    if (kept.length === block.children.length) {
+      return { block, mutated: false };
+    }
+    return { block: { ...block, children: kept }, mutated: true };
+  }
+  if (block.type === "table") {
+    let mutated = false;
+    const rows = block.rows.map((row) => {
+      let rowMutated = false;
+      const cells = row.cells.map((cell) => {
+        const result = removeScopeMarkersFromBlockList(cell.children, scopeId);
+        if (result.mutated) {
+          mutated = true;
+          rowMutated = true;
+        }
+        return result.mutated ? { ...cell, children: result.blocks } : cell;
+      });
+      return rowMutated ? { ...row, cells } : row;
+    });
+    return mutated ? { block: { ...block, rows }, mutated: true } : { block, mutated: false };
+  }
+  if (block.type === "sdt") {
+    const result = removeScopeMarkersFromBlockList(block.children, scopeId);
+    return result.mutated ? { block: { ...block, children: result.blocks }, mutated: true } : { block, mutated: false };
+  }
+  if (block.type === "custom_xml") {
+    const result = removeScopeMarkersFromBlockList(block.children, scopeId);
+    return result.mutated ? { block: { ...block, children: result.blocks }, mutated: true } : { block, mutated: false };
+  }
+  return { block, mutated: false };
+}
+function scopeParagraphPathKey(path) {
+  return path.map((step) => {
+    if (step.kind === "block") return `b:${step.index}`;
+    if (step.kind === "tableCell") {
+      return `tc:${step.rowIndex}:${step.cellIndex}`;
+    }
+    return "sdt";
+  }).join("/");
+}
+
+// src/runtime/workflow/scope-resolver.ts
+function walkParagraphs(document) {
+  const envelope = document;
+  return computeScopeStoryLayout(envelope).paragraphSlots.map((slot) => ({
+    paragraph: slot.paragraph,
+    from: slot.from
+  }));
+}
+function inlineLength(node) {
+  return inlineLengthForScopeCoordinates(node);
 }
 function collectScopeLocations(document) {
   const locations = /* @__PURE__ */ new Map();
@@ -611,9 +824,9 @@ function messageForPostureBlocker(blocker) {
       return void 0;
   }
 }
-function auditFact(target, category, reason, operation) {
+function auditFact(target, category, reason, operation2) {
   return {
-    operation: operation ?? auditOperationForTarget(target),
+    operation: operation2 ?? auditOperationForTarget(target),
     category,
     dispatch: "blocked-before-mutation",
     reason
@@ -704,25 +917,43 @@ function computeBlockPositions(document) {
   let cursor = 0;
   for (let index = 0; index < root.children.length; index += 1) {
     const block = root.children[index];
+    if (!block) continue;
     const from = cursor;
-    let length = 0;
-    if (block && block.type === "paragraph") {
-      length = block.children.reduce(
-        (total, child) => total + inlineLength2(child),
-        0
-      );
-    } else {
-      length = 1;
-    }
-    cursor += length;
-    const to = cursor;
-    out.push({ blockIndex: index, from, to });
-    if (index < root.children.length - 1) {
+    cursor += blockLength(block);
+    out.push({ blockIndex: index, from, to: cursor });
+    if (index < root.children.length - 1 && root.children[index + 1]?.type === "paragraph") {
       cursor += 1;
     }
   }
   return out;
 }
+function blockLength(block) {
+  if (block.type === "paragraph") {
+    return block.children.reduce(
+      (total, child) => total + inlineLength2(child),
+      0
+    );
+  }
+  if (block.type === "table") {
+    let total = 0;
+    for (const row of block.rows) {
+      for (const cell of row.cells) {
+        for (const child of cell.children) {
+          total += blockLength(child);
+        }
+      }
+    }
+    return total;
+  }
+  if (block.type === "sdt") {
+    const descriptor = describeStructuredWrapperBlock(block, {
+      projectVisibleTocContentControls: true
+    });
+    if (descriptor) return 1;
+    return block.children.reduce((total, child) => total + blockLength(child), 0);
+  }
+  return 1;
+}
 function computeInlinePositions(document, blocks) {
   const envelope = document;
   const root = "content" in envelope ? envelope.content : document;
@@ -970,8 +1201,8 @@ function deriveReplaceability(kind, provenance) {
   if (kind === "scope") {
     if (provenance === "marker-backed") {
       return {
-        level: "preserve-only",
-        reason: "multi-paragraph-replace-not-implemented"
+        level: "text-only",
+        reason: "marker-backed-multi-paragraph-preserves-anchor"
       };
     }
     return {
@@ -2133,6 +2364,54 @@ function compileScopeKind(entry, options) {
     partial: true
   };
 }
+function compileScopeReplacement(entry, proposed, options) {
+  if (entry.handle.provenance !== "marker-backed" || proposed.operation !== "replace" || options.posture !== "direct-edit") {
+    return null;
+  }
+  const markerRange = buildScopePositionMap(options.document).markerScopes.get(
+    entry.handle.scopeId
+  );
+  if (!markerRange) return null;
+  if (proposed.proposedContent.kind === "text") {
+    const text = proposed.proposedContent.text ?? "";
+    return {
+      scopeId: entry.handle.scopeId,
+      targetKind: "scope",
+      operation: proposed.operation,
+      steps: Object.freeze([
+        {
+          kind: "text-replace",
+          summary: `replace multi-paragraph scope ${entry.handle.scopeId} text [${markerRange.from}..${markerRange.to}] (len ${text.length})`,
+          range: { from: markerRange.from, to: markerRange.to },
+          text,
+          ...proposed.formatting ? { formatting: proposed.formatting } : {}
+        }
+      ]),
+      ...proposed.preserve ? { preserve: proposed.preserve } : {},
+      posture: options.posture
+    };
+  }
+  if (proposed.proposedContent.kind === "structured") {
+    const fragment = proposed.proposedContent.structured;
+    if (!isStructuredReplacementContent(fragment)) return null;
+    return {
+      scopeId: entry.handle.scopeId,
+      targetKind: "scope",
+      operation: proposed.operation,
+      steps: Object.freeze([
+        {
+          kind: "fragment-replace",
+          summary: `replace multi-paragraph scope ${entry.handle.scopeId} with structured fragment [${markerRange.from}..${markerRange.to}] (${fragment.blocks.length} block(s))`,
+          range: { from: markerRange.from, to: markerRange.to },
+          fragment
+        }
+      ]),
+      ...proposed.preserve ? { preserve: proposed.preserve } : {},
+      posture: options.posture
+    };
+  }
+  return null;
+}
 
 // src/runtime/scopes/scope-kinds/table.ts
 function compileTableScope(entry, options = {}) {
@@ -3037,31 +3316,6 @@ function deriveScopeAdjacentGeometryEvidence(scope, entry, provider) {
   };
 }
 
-// src/runtime/scopes/multi-paragraph-refusal.ts
-var MULTI_PARAGRAPH_REPLACEMENT_REFUSAL = "compile-refused:scope:multi-paragraph-replace-not-implemented";
-function shapeBlocker(shape) {
-  switch (shape) {
-    case "text":
-      return "compile-refused:scope:multi-paragraph-text-replace-not-implemented";
-    case "fragment":
-      return "compile-refused:scope:multi-paragraph-fragment-replace-not-implemented";
-    default:
-      return "compile-refused:scope:multi-paragraph-replace-shape-not-implemented";
-  }
-}
-function multiParagraphReplacementBlockers(shape = "unknown") {
-  return Object.freeze([
-    MULTI_PARAGRAPH_REPLACEMENT_REFUSAL,
-    shapeBlocker(shape),
-    "capability:scope:block-granular-replacement-lowering-required",
-    "capability:scope:provenance:marker-backed-required",
-    "capability:scope:layout-completeness-required",
-    "capability:scope:geometry-completeness-required",
-    "capability:scope:continuation-state-required",
-    "capability:scope:preservation-verdict-required"
-  ]);
-}
-
 // src/runtime/scopes/capabilities.ts
 var PARAGRAPH_LIKE = /* @__PURE__ */ new Set([
   "paragraph",
@@ -3278,10 +3532,9 @@ function replaceTextCapability(scope, context) {
   if (guard) return blocked(guard);
   if (scope.kind === "list-item") {
     return blocked(
-      "compile-blocked:list-text:authoritative-readback-required",
+      "compile-blocked:list-text:exact-list-text-handle-required",
       [
-        "capability:list-item:authoritative-readback-required",
-        "capability:list-text:export-persistent-target-required"
+        "capability:list-item:exact-list-text-handle-required"
       ]
     );
   }
@@ -3296,6 +3549,19 @@ function replaceTextCapability(scope, context) {
       generatedOrLinked
     );
   }
+  if (scope.kind === "scope") {
+    if (scope.workflow.effectiveMode === "suggest") {
+      return unsupported(
+        "compile-refused:scope:multi-paragraph-suggesting-not-implemented",
+        ["compile-refused:scope:multi-paragraph-suggesting-not-implemented"],
+        ["guard:suggest-mode", ...evidenceWarnings(context)]
+      );
+    }
+    return supported(
+      "compile-supported:scope:multi-paragraph-text-replace",
+      evidenceWarnings(context)
+    );
+  }
   if (!PARAGRAPH_LIKE.has(scope.kind)) {
     if (scope.kind === "table-cell") {
       if (context?.tableCellTextRange?.status === "ok") {
@@ -3317,12 +3583,8 @@ function replaceTextCapability(scope, context) {
         ]
       );
     }
-    const reason = scope.kind === "scope" && scope.replaceability.reason ? MULTI_PARAGRAPH_REPLACEMENT_REFUSAL : `compile-refused:${scope.kind}`;
-    return unsupported(
-      reason,
-      scope.kind === "scope" ? multiParagraphReplacementBlockers("text") : [reason],
-      evidenceWarnings(context)
-    );
+    const reason = `compile-refused:${scope.kind}`;
+    return unsupported(reason, [reason], evidenceWarnings(context));
   }
   if (scope.replaceability.level === "blocked" || scope.replaceability.level === "preserve-only" || scope.replaceability.level === "formatting-only") {
     const reason = scope.replaceability.reason ? `replaceability:${scope.replaceability.reason}` : `replaceability:${scope.replaceability.level}`;
@@ -3350,14 +3612,25 @@ function replaceFragmentCapability(scope, context) {
       generatedOrLinked
     );
   }
-  if (!PARAGRAPH_LIKE.has(scope.kind)) {
-    const reason = scope.kind === "scope" && scope.replaceability.reason ? MULTI_PARAGRAPH_REPLACEMENT_REFUSAL : `compile-refused:${scope.kind}`;
-    return unsupported(
-      reason,
-      scope.kind === "scope" ? multiParagraphReplacementBlockers("fragment") : [reason],
+  if (scope.kind === "scope") {
+    if (scope.workflow.effectiveMode === "suggest") {
+      return unsupported(
+        "compile-refused:scope:multi-paragraph-structured-suggesting-not-implemented",
+        [
+          "compile-refused:scope:multi-paragraph-structured-suggesting-not-implemented"
+        ],
+        ["guard:suggest-mode", ...evidenceWarnings(context)]
+      );
+    }
+    return supported(
+      "compile-supported:scope:multi-paragraph-fragment-replace",
       evidenceWarnings(context)
     );
   }
+  if (!PARAGRAPH_LIKE.has(scope.kind)) {
+    const reason = `compile-refused:${scope.kind}`;
+    return unsupported(reason, [reason], evidenceWarnings(context));
+  }
   if (scope.workflow.effectiveMode === "suggest") {
     return unsupported(
       `compile-refused:${scope.kind}:structured-suggesting-not-implemented`,
@@ -5948,6 +6221,231 @@ function compileScopeBundleById(scopeId, inputs) {
   return compileScopeBundle(compiled, { ...inputs, scopes });
 }
 
+// src/runtime/scopes/editable-graph.ts
+function uniq(values) {
+  return Object.freeze([...new Set(values.filter(Boolean))]);
+}
+function commandFamilyForTarget(target) {
+  const intents = target.runtimeCommand.intents;
+  if (target.table?.operationScope === "text" && target.runtimeCommand.commandFamily === "text-leaf") {
+    return "table-text";
+  }
+  if (intents.some((intent) => intent.startsWith("table-"))) {
+    if (intents.some((intent) => intent.includes("structure"))) {
+      return "table-structure";
+    }
+    return "table-text";
+  }
+  if (intents.some((intent) => intent.startsWith("list-"))) {
+    if (intents.some((intent) => intent.includes("structure"))) {
+      return "list-structure";
+    }
+    return "list-text";
+  }
+  return target.runtimeCommand.commandFamily;
+}
+function familyForTarget(target) {
+  if (target.runtimeCommand.intents.some(
+    (intent) => intent === "table-structure-action" || intent === "table-merge-cells" || intent === "table-split-cell" || intent === "list-structure-action"
+  )) {
+    return "structure";
+  }
+  if (target.runtimeCommand.intents.some(
+    (intent) => intent === "field-update" || intent === "toc-refresh" || intent === "hyperlink-update" || intent === "bookmark-update" || intent === "custom-xml-update"
+  )) {
+    return "value";
+  }
+  if (target.runtimeCommand.commandFamily === "object" || target.runtimeCommand.intents.some(
+    (intent) => intent === "object-edit" || intent === "image-layout" || intent === "image-frame" || intent === "chart-edit" || intent === "embedded-content-update"
+  )) {
+    return "object";
+  }
+  if (target.runtimeCommand.commandFamily === "metadata") return "metadata";
+  if (target.runtimeCommand.commandFamily === "preserve-only-refusal" || target.posture.preserveOnly || target.kind === "opaque-content") {
+    return "preservation";
+  }
+  return "text";
+}
+function statusForTarget(target, family) {
+  if (family === "preservation") return "preserve";
+  if (target.runtimeCommand.status === "supported" && target.runtimeCommand.actionHandle) {
+    return "ready";
+  }
+  if (target.runtimeCommand.status === "supported") return "diagnostic";
+  return "needs-command";
+}
+function blockersForTarget(target) {
+  return uniq([
+    ...target.posture.blockers,
+    ...target.runtimeTextCommand.blockers ?? [],
+    ...target.runtimeCommand.blockers ?? [],
+    ...target.workflowBlockers?.map((blocker) => blocker.blocker) ?? []
+  ]);
+}
+function projectEditableTarget(target) {
+  const family = familyForTarget(target);
+  const commandFamily = commandFamilyForTarget(target);
+  return Object.freeze({
+    targetId: target.targetKey,
+    family,
+    kind: target.kind,
+    relation: target.relation,
+    status: statusForTarget(target, family),
+    commandFamily,
+    ...target.runtimeCommand.actionHandle ? { actionHandle: target.runtimeCommand.actionHandle } : {},
+    ...target.runtimeCommand.canonicalAddress ? { canonicalAddress: target.runtimeCommand.canonicalAddress } : {},
+    ...target.readback ? { readback: target.readback } : {},
+    blockers: blockersForTarget(target),
+    warnings: Object.freeze([]),
+    intents: Object.freeze([...target.runtimeCommand.intents])
+  });
+}
+function projectTableAction(action) {
+  const family = action.family === "table-structure" ? "structure" : "text";
+  const blockers = uniq(action.blockers ?? []);
+  return Object.freeze({
+    targetId: action.handle,
+    family,
+    kind: action.targetKind,
+    relation: action.relation,
+    status: action.status === "supported" && action.actionHandle ? "ready" : action.status === "supported" ? "diagnostic" : "needs-command",
+    commandFamily: action.family,
+    ...action.actionHandle ? { actionHandle: action.actionHandle } : {},
+    ...action.canonicalAddress ? { canonicalAddress: action.canonicalAddress } : {},
+    ...action.readback ? { readback: action.readback } : {},
+    blockers,
+    warnings: Object.freeze([...action.warnings ?? []]),
+    intents: Object.freeze([...action.intents])
+  });
+}
+function metadataTarget(bundle) {
+  return Object.freeze({
+    targetId: `${bundle.scope.handle.scopeId}:metadata`,
+    family: "metadata",
+    kind: "scope-metadata",
+    status: "ready",
+    commandFamily: "metadata",
+    actionHandle: `scope-metadata:${bundle.scope.handle.scopeId}`,
+    blockers: Object.freeze([]),
+    warnings: Object.freeze([]),
+    intents: Object.freeze(["metadata-update"])
+  });
+}
+function scopeReplacementTarget(bundle) {
+  const verdict = bundle.evidence.capabilities?.canReplaceText;
+  if (!verdict?.supported) return null;
+  return Object.freeze({
+    targetId: `${bundle.scope.handle.scopeId}:scope-replace-text`,
+    family: "text",
+    kind: `${bundle.scope.kind}:scope-replacement`,
+    relation: "exact-scope",
+    status: "ready",
+    commandFamily: "scope-replacement",
+    blockers: Object.freeze([]),
+    warnings: Object.freeze([...verdict.warnings ?? []]),
+    intents: Object.freeze(["text-leaf-edit"])
+  });
+}
+function group(targets, family) {
+  return Object.freeze(targets.filter((target) => target.family === family));
+}
+function operation(kind, targets) {
+  const ready = targets.filter((target) => target.status === "ready");
+  const pending = targets.filter((target) => target.status === "needs-command");
+  return Object.freeze({
+    kind,
+    status: ready.length > 0 ? "ready" : pending.length > 0 ? "needs-command" : "needs-target",
+    targetIds: Object.freeze(ready.map((target) => target.targetId)),
+    commandFamilies: uniq(ready.map((target) => target.commandFamily ?? ""))
+  });
+}
+function contentModelFor(textTargets, valueTargets, structureTargets, objectTargets) {
+  const families = [
+    textTargets.length > 0 ? "text" : "",
+    valueTargets.length > 0 ? "value" : "",
+    structureTargets.length > 0 ? "structure" : "",
+    objectTargets.length > 0 ? "object" : ""
+  ].filter(Boolean);
+  if (families.length === 0) return "metadata";
+  if (families.length > 1) return "mixed";
+  return families[0];
+}
+function summaryFor(model, targets) {
+  const ready = targets.filter((target) => target.status === "ready").length;
+  const needsCommand = targets.filter(
+    (target) => target.status === "needs-command"
+  ).length;
+  const preserve = targets.filter((target) => target.status === "preserve").length;
+  return `${model} scope editable graph: ${ready} ready target(s), ${needsCommand} target(s) needing command, ${preserve} preserve target(s)`;
+}
+function compileScopeEditableGraph(bundle) {
+  const scopeTextTarget = scopeReplacementTarget(bundle);
+  const projected = [
+    ...bundle.evidence.editableTargets?.entries.map(projectEditableTarget) ?? [],
+    ...bundle.evidence.table?.actions.map(projectTableAction) ?? [],
+    ...scopeTextTarget ? [scopeTextTarget] : [],
+    metadataTarget(bundle)
+  ];
+  const byId = /* @__PURE__ */ new Map();
+  for (const target of projected) {
+    const existing = byId.get(target.targetId);
+    if (!existing || existing.status !== "ready") {
+      byId.set(target.targetId, target);
+    }
+  }
+  const targets = Object.freeze([...byId.values()]);
+  const textTargets = group(targets, "text");
+  const valueTargets = group(targets, "value");
+  const structureTargets = group(targets, "structure");
+  const objectTargets = group(targets, "object");
+  const metadataTargets = group(targets, "metadata");
+  const preservationTargets = group(targets, "preservation");
+  const contentModel = contentModelFor(
+    textTargets,
+    valueTargets,
+    structureTargets,
+    objectTargets
+  );
+  const operations = Object.freeze([
+    operation("replace-text", textTargets),
+    operation("replace-value", valueTargets),
+    operation("edit-structure", structureTargets),
+    operation("edit-object", objectTargets),
+    operation("attach-metadata", metadataTargets)
+  ]);
+  const readyTargetCount = targets.filter((target) => target.status === "ready").length;
+  const needsCommandTargetCount = targets.filter(
+    (target) => target.status === "needs-command"
+  ).length;
+  const preserveTargetCount = targets.filter(
+    (target) => target.status === "preserve"
+  ).length;
+  const blockers = uniq(targets.flatMap((target) => target.blockers));
+  const warnings = uniq(targets.flatMap((target) => target.warnings));
+  const readiness = Object.freeze({
+    status: readyTargetCount > metadataTargets.length ? needsCommandTargetCount > 0 || preserveTargetCount > 0 ? "partial" : "ready" : "metadata-only",
+    readyTargetCount,
+    needsCommandTargetCount,
+    preserveTargetCount,
+    blockers,
+    warnings
+  });
+  return Object.freeze({
+    scope: bundle.scope.handle,
+    contentModel,
+    targets,
+    textTargets,
+    valueTargets,
+    structureTargets,
+    objectTargets,
+    metadataTargets,
+    preservationTargets,
+    operations,
+    readiness,
+    summary: summaryFor(contentModel, targets)
+  });
+}
+
 // src/runtime/scopes/issue-lifecycle.ts
 function documentHash(doc) {
   let textLength = 0;
@@ -6499,11 +6997,11 @@ function computePreservationVerdict(document, range, positionMap) {
 }
 
 // src/runtime/scopes/action-validation.ts
-function inferActionId(operation, content) {
-  if (operation === "formatting") {
+function inferActionId(operation2, content) {
+  if (operation2 === "formatting") {
     return "fix_formatting";
   }
-  switch (operation) {
+  switch (operation2) {
     case "replace":
       return content.kind === "text" ? "rewrite_paragraph" : "generate_text";
     case "insert-before":
@@ -6654,11 +7152,11 @@ function collectCapabilityVerdict(inputs, blockedReasons, warnings) {
     }
   }
   if (inputs.scope.kind === "list-item" && inputs.operation === "replace" && inputs.proposedContent.kind === "text") {
-    const code = "capability:list-item:authoritative-readback-required";
+    const code = "capability:list-item:exact-list-text-handle-required";
     blockedReasons.push(code);
     warnings.push({
       code,
-      message: "list-item flat text replacement is blocked until the runtime validates an export-persistent list text command path",
+      message: "list-item flat text replacement is blocked unless the caller uses an exact list-text action handle",
       source: "capability"
     });
   }
@@ -6895,11 +7393,44 @@ function compileReplacement(inputs) {
         inputs.posture,
         inputs.tableCellTextRange
       );
+    case "scope":
+      if (inputs.enumeratedScope.kind === "scope") {
+        return compileScopeReplacement(inputs.enumeratedScope, inputs.proposed, {
+          document: inputs.document,
+          posture: inputs.posture
+        });
+      }
+      return null;
     default:
       return null;
   }
 }
 
+// src/runtime/scopes/multi-paragraph-refusal.ts
+var MULTI_PARAGRAPH_REPLACEMENT_REFUSAL = "compile-refused:scope:multi-paragraph-replace-not-implemented";
+function shapeBlocker(shape) {
+  switch (shape) {
+    case "text":
+      return "compile-refused:scope:multi-paragraph-text-replace-not-implemented";
+    case "fragment":
+      return "compile-refused:scope:multi-paragraph-fragment-replace-not-implemented";
+    default:
+      return "compile-refused:scope:multi-paragraph-replace-shape-not-implemented";
+  }
+}
+function multiParagraphReplacementBlockers(shape = "unknown") {
+  return Object.freeze([
+    MULTI_PARAGRAPH_REPLACEMENT_REFUSAL,
+    shapeBlocker(shape),
+    "capability:scope:block-granular-replacement-lowering-required",
+    "capability:scope:provenance:marker-backed-required",
+    "capability:scope:layout-completeness-required",
+    "capability:scope:geometry-completeness-required",
+    "capability:scope:continuation-state-required",
+    "capability:scope:preservation-verdict-required"
+  ]);
+}
+
 // src/runtime/scopes/replacement/apply.ts
 function documentHash2(doc) {
   let hash = 2166136261;
@@ -7062,14 +7593,18 @@ function applyScopeReplacement(inputs) {
   });
   if (!plan) {
     const paragraphLike = resolvedScope.kind === "paragraph" || resolvedScope.kind === "heading" || resolvedScope.kind === "list-item";
-    const blockers = resolvedScope.kind === "scope" ? multiParagraphReplacementBlockers(
+    const blockers = resolvedScope.kind === "scope" && posture === "suggest-mode" ? [
+      proposed.proposedContent.kind === "structured" ? "compile-refused:scope:multi-paragraph-structured-suggesting-not-implemented" : "compile-refused:scope:multi-paragraph-suggesting-not-implemented"
+    ] : resolvedScope.kind === "scope" && proposed.operation !== "replace" ? [
+      `compile-refused:scope:operation-not-implemented:${proposed.operation}`
+    ] : resolvedScope.kind === "scope" ? multiParagraphReplacementBlockers(
       proposed.proposedContent.kind === "structured" ? "fragment" : "text"
     ) : paragraphLike && proposed.operation === "replace" && proposed.preserve?.opaqueFragments === true ? [
       `compile-refused:${resolvedScope.kind}:opaque-preserving-text-target-unavailable`
     ] : resolvedScope.kind === "table-cell" ? [tableCellRefusalBlocker(tableCellTextRange)] : paragraphLike && proposed.operation !== "replace" ? [
       `compile-refused:${resolvedScope.kind}:operation-not-implemented:${proposed.operation}`
     ] : [`compile-refused:${resolvedScope.kind}`];
-    const blocker = resolvedScope.kind === "scope" ? MULTI_PARAGRAPH_REPLACEMENT_REFUSAL : blockers[0] ?? `compile-refused:${resolvedScope.kind}`;
+    const blocker = blockers[0] ?? `compile-refused:${resolvedScope.kind}`;
     const refused = {
       safe: false,
       posture: "hard-refusal",
@@ -7548,10 +8083,10 @@ function createScopeCompilerService(runtime) {
     emitMetadataAudit(request) {
       try {
         const snapshot = request.targetScopeSnapshot;
-        const operation = "annotate";
+        const operation2 = "annotate";
         const proposed = {
           targetHandle: snapshot.handle,
-          operation,
+          operation: operation2,
           proposedContent: {
             kind: "structured",
             structured: {
@@ -7626,6 +8161,10 @@ function createScopeCompilerService(runtime) {
         ...editableTargetCache ? { editableTargetCache } : {}
       });
     },
+    compileEditableGraphById(scopeId, nowUtc) {
+      const bundle = this.compileBundleById(scopeId, nowUtc);
+      return bundle ? compileScopeEditableGraph(bundle) : null;
+    },
     buildReplacementScope(targetHandle, input) {
       return proposeReplacement({
         targetHandle,
@@ -9057,6 +9596,13 @@ export {
   ensureDefaultListInstance,
   allocateNumberingInstance,
   setStartOverride,
+  inlineLengthForScopeCoordinates,
+  computeScopeStoryLayout,
+  findParagraphSlotAtPosition,
+  findOwningBlockSlotAtPosition,
+  sameScopeParagraphPath,
+  replaceParagraphChildrenAtPath,
+  removeScopeMarkersFromBlockList,
   collectScopeLocations,
   resolveScope,
   findAllScopesAt,