@beyondwork/docx-react-component 1.0.132 → 1.0.133

package/dist/runtime/document-runtime.cjs

@@ -6636,7 +6636,20 @@ function sourceJoinHash(refs) {
   if (sourceIds.length === 0) return void 0;
   return hashText(sourceIds.join("\0"));
 }
+var numberingCatalogHashCache = /* @__PURE__ */ new WeakMap();
+var numberingTargetHashCache = /* @__PURE__ */ new WeakMap();
 function createNumberingCatalogRevisionHash(doc) {
+  const numbering = doc.numbering;
+  if (numbering !== void 0) {
+    const cached = numberingCatalogHashCache.get(numbering);
+    if (cached !== void 0) return cached;
+    const fresh = computeNumberingCatalogRevisionHash(doc);
+    numberingCatalogHashCache.set(numbering, fresh);
+    return fresh;
+  }
+  return computeNumberingCatalogRevisionHash(doc);
+}
+function computeNumberingCatalogRevisionHash(doc) {
   const catalog = doc.numbering ?? { abstractDefinitions: {}, instances: {} };
   const abstractDefinitions = catalog.abstractDefinitions ?? {};
   const instances = catalog.instances ?? {};
@@ -6687,8 +6700,27 @@ function createNumberingCatalogRevisionHash(doc) {
   }));
 }
 function createNumberingTargetRevisionHash(doc) {
+  const numbering = doc.numbering;
+  const styles = doc.styles;
+  if (numbering !== void 0 && styles !== void 0) {
+    let inner = numberingTargetHashCache.get(numbering);
+    if (inner === void 0) {
+      inner = /* @__PURE__ */ new WeakMap();
+      numberingTargetHashCache.set(numbering, inner);
+    }
+    const cached = inner.get(styles);
+    if (cached !== void 0) return cached;
+    const fresh = computeNumberingTargetRevisionHash(doc);
+    inner.set(styles, fresh);
+    return fresh;
+  }
+  return computeNumberingTargetRevisionHash(doc);
+}
+function computeNumberingTargetRevisionHash(doc) {
   const paragraphStyles = doc.styles?.paragraphs ?? {};
   return hashText(JSON.stringify({
+    // Reuses the memoized catalog hash on the hot path so a typing edit
+    // pays for the catalog hash at most once across both helpers.
     numberingCatalogHash: createNumberingCatalogRevisionHash(doc),
     paragraphStyleNumbering: Object.keys(paragraphStyles).sort().map((styleId) => {
       const style = paragraphStyles[styleId];
@@ -10790,8 +10822,8 @@ function toLayoutTabStops(tabStops, source) {
 }
 function mergeLayoutTabStops(...groups) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const group of groups) {
-    for (const tabStop of group ?? []) {
+  for (const group2 of groups) {
+    for (const tabStop of group2 ?? []) {
       const key = [
         tabStop.source,
         tabStop.positionTwips,
@@ -11376,7 +11408,7 @@ function collectParagraphCompatFlags(paragraph) {
   return flags;
 }
 function mergeCompatFlags(...groups) {
-  return [...new Set(groups.flatMap((group) => group ?? []))].sort();
+  return [...new Set(groups.flatMap((group2) => group2 ?? []))].sort();
 }
 function buildRevisionRangeIndex(doc) {
   const records = [];
@@ -13586,7 +13618,38 @@ var TextTransactionError = class extends Error {
     this.code = code;
   }
 };
+function isUsableScopeSurface(surface, document2) {
+  if (surface.viewportBlockRanges !== null) return false;
+  const root = document2.content;
+  if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
+    return false;
+  }
+  return surface.blocks.length === root.children.length;
+}
+function createScopeSurfaceCache(document2, selection, precomputedSurface, telemetry) {
+  let cached;
+  if (precomputedSurface && isUsableScopeSurface(precomputedSurface, document2)) {
+    cached = precomputedSurface;
+    telemetry?.onPrecomputedSurfaceHit?.();
+  }
+  return {
+    get() {
+      if (cached) return cached;
+      telemetry?.onScopeSurfaceBuild?.();
+      cached = createEditorSurfaceSnapshot(document2, selection, void 0, {
+        editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX
+      });
+      return cached;
+    }
+  };
+}
 function applyTextTransaction(document2, selection, intent, options) {
+  const scopeSurfaceCache = createScopeSurfaceCache(
+    document2,
+    selection,
+    options.precomputedSurface,
+    options.surfaceTelemetry
+  );
   if (options.textTarget) {
     if (options.textTarget.kind === "hyperlink-display") {
       const targetedHyperlinkResult = tryApplyHyperlinkDisplayTransaction(
@@ -13622,7 +13685,8 @@ function applyTextTransaction(document2, selection, intent, options) {
       document2,
       selection,
       intent,
-      options
+      options,
+      scopeSurfaceCache
     );
     if (targetedTableResult) {
       return targetedTableResult;
@@ -13636,7 +13700,8 @@ function applyTextTransaction(document2, selection, intent, options) {
     const tableStructureRefusal = resolveTargetlessTableStructureInsertRefusal(
       document2,
       selection,
-      intent
+      intent,
+      scopeSurfaceCache
     );
     if (tableStructureRefusal) {
       throw new TextTransactionError("unsupported_content", tableStructureRefusal);
@@ -13646,7 +13711,8 @@ function applyTextTransaction(document2, selection, intent, options) {
     document2,
     selection,
     intent,
-    options
+    options,
+    scopeSurfaceCache
   );
   if (topLevelParagraphResult) {
     return topLevelParagraphResult;
@@ -13655,7 +13721,8 @@ function applyTextTransaction(document2, selection, intent, options) {
     document2,
     selection,
     intent,
-    options
+    options,
+    scopeSurfaceCache
   );
   if (sdtScopedResult) {
     return sdtScopedResult;
@@ -13664,7 +13731,8 @@ function applyTextTransaction(document2, selection, intent, options) {
     document2,
     selection,
     intent,
-    options
+    options,
+    scopeSurfaceCache
   );
   if (tableScopedResult) {
     return tableScopedResult;
@@ -13717,9 +13785,9 @@ function applyLinearTextTransaction(document2, selection, intent, options) {
     storyText: createPlainText(nextStory)
   };
 }
-function tryApplyTableParagraphTransaction(document2, selection, intent, options) {
+function tryApplyTableParagraphTransaction(document2, selection, intent, options, scopeSurfaceCache) {
   const tableTarget = options.textTarget?.kind === "table-paragraph" ? options.textTarget : void 0;
-  const scope = resolveTableParagraphScope(document2, selection, tableTarget);
+  const scope = resolveTableParagraphScope(document2, selection, tableTarget, scopeSurfaceCache);
   if (!scope) {
     return null;
   }
@@ -13842,7 +13910,11 @@ function tryApplyTargetedTextLeafTransaction(document2, selection, intent, optio
   };
 }
 function tryApplyHyperlinkDisplayTransaction(document2, selection, intent, options) {
-  const scope = resolveTargetedHyperlinkDisplayScope(document2, selection, options.textTarget);
+  const scope = resolveTargetedHyperlinkDisplayScope(
+    document2,
+    selection,
+    options.textTarget
+  );
   if (!scope) {
     return null;
   }
@@ -13900,8 +13972,8 @@ function tryApplyHyperlinkDisplayTransaction(document2, selection, intent, optio
     storyText: localResult.storyText
   };
 }
-function tryApplyTopLevelSdtParagraphTransaction(document2, selection, intent, options) {
-  const scope = resolveTopLevelSdtParagraphScope(document2, selection);
+function tryApplyTopLevelSdtParagraphTransaction(document2, selection, intent, options, scopeSurfaceCache) {
+  const scope = resolveTopLevelSdtParagraphScope(document2, selection, scopeSurfaceCache);
   if (!scope) {
     return null;
   }
@@ -13953,8 +14025,8 @@ function tryApplyTopLevelSdtParagraphTransaction(document2, selection, intent, o
     storyText: localResult.storyText
   };
 }
-function tryApplyTopLevelParagraphTransaction(document2, selection, intent, options) {
-  const scope = resolveTopLevelParagraphScope(document2, selection);
+function tryApplyTopLevelParagraphTransaction(document2, selection, intent, options, scopeSurfaceCache) {
+  const scope = resolveTopLevelParagraphScope(document2, selection, scopeSurfaceCache);
   if (!scope) {
     return null;
   }
@@ -14064,17 +14136,15 @@ function resolveTargetedHyperlinkDisplayScope(document2, selection, target) {
     replace: resolved.replace
   };
 }
-function resolveTableParagraphScope(document2, selection, target) {
+function resolveTableParagraphScope(document2, selection, target, scopeSurfaceCache) {
   if (target) {
-    return resolveTargetedTableParagraphScope(document2, selection, target);
+    return resolveTargetedTableParagraphScope(document2, selection, target, scopeSurfaceCache);
   }
   const root = document2.content;
   if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
     return null;
   }
-  const surface = createEditorSurfaceSnapshot(document2, selection, void 0, {
-    editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX
-  });
+  const surface = scopeSurfaceCache.get();
   const selectionFrom = Math.min(selection.anchor, selection.head);
   const selectionTo = Math.max(selection.anchor, selection.head);
   for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
@@ -14179,7 +14249,7 @@ function resolveTableParagraphScope(document2, selection, target) {
   }
   return null;
 }
-function resolveTargetlessTableStructureInsertRefusal(document2, selection, intent) {
+function resolveTargetlessTableStructureInsertRefusal(document2, selection, intent, scopeSurfaceCache) {
   if (!isCollapsedInsertIntent(intent, selection)) {
     return null;
   }
@@ -14187,9 +14257,7 @@ function resolveTargetlessTableStructureInsertRefusal(document2, selection, inte
   if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
     return null;
   }
-  const surface = createEditorSurfaceSnapshot(document2, selection, void 0, {
-    editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX
-  });
+  const surface = scopeSurfaceCache.get();
   if (!selectionTouchesTableStructureBoundary(surface.blocks, selection.anchor)) {
     return null;
   }
@@ -14203,7 +14271,7 @@ function isCollapsedInsertIntent(intent, selection) {
   const rangeTo = intent.range ? Math.max(intent.range.from, intent.range.to) : Math.max(selection.anchor, selection.head);
   return rangeFrom === rangeTo;
 }
-function resolveTargetedTableParagraphScope(document2, selection, target) {
+function resolveTargetedTableParagraphScope(document2, selection, target, scopeSurfaceCache) {
   const root = document2.content;
   if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
     return null;
@@ -14216,7 +14284,8 @@ function resolveTargetedTableParagraphScope(document2, selection, target) {
       root,
       document2,
       selection,
-      target
+      target,
+      scopeSurfaceCache
     );
     if (targetScope) {
       return targetScope;
@@ -14239,9 +14308,7 @@ function resolveTargetedTableParagraphScope(document2, selection, target) {
   if (cell.verticalMerge === "continue") {
     return "unsupported";
   }
-  const surface = createEditorSurfaceSnapshot(document2, selection, void 0, {
-    editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX
-  });
+  const surface = scopeSurfaceCache.get();
   const surfaceBlock = surface.blocks[target.tableBlockIndex];
   const surfaceRow = surfaceBlock?.kind === "table" ? surfaceBlock.rows[target.rowIndex] : void 0;
   const surfaceCell = surfaceRow?.cells[target.cellIndex];
@@ -14305,16 +14372,14 @@ function resolveTargetedTableParagraphScope(document2, selection, target) {
     }
   };
 }
-function resolveTargetedTableParagraphScopeByPath(root, document2, selection, target) {
+function resolveTargetedTableParagraphScopeByPath(root, document2, selection, target, scopeSurfaceCache) {
   if (!target.blockPath) return null;
   const tokens = parseCanonicalBlockPath(target.blockPath);
   if (!tokens) return null;
   const resolved = resolveBlockPathInCanonicalBlocks(root.children, tokens, 0);
   if (!resolved || resolved.block.type !== "paragraph") return null;
   if (resolved.hasVerticalMergeContinuation) return null;
-  const surface = createEditorSurfaceSnapshot(document2, selection, void 0, {
-    editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX
-  });
+  const surface = scopeSurfaceCache.get();
   const surfaceResolved = resolveBlockPathInSurfaceBlocks(surface.blocks, tokens, 0);
   if (!surfaceResolved || surfaceResolved.kind !== "paragraph") return null;
   if (surfaceResolved.hasVerticalMergeContinuation) return null;
@@ -14769,14 +14834,12 @@ function resolveBlockPathInSurfaceBlocks(blocks, tokens, tokenIndex, hasVertical
     hasVerticalMergeContinuation || cell.verticalMerge === "continue"
   );
 }
-function resolveTopLevelParagraphScope(document2, selection) {
+function resolveTopLevelParagraphScope(document2, selection, scopeSurfaceCache) {
   const root = document2.content;
   if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
     return null;
   }
-  const surface = createEditorSurfaceSnapshot(document2, selection, void 0, {
-    editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX
-  });
+  const surface = scopeSurfaceCache.get();
   const selectionFrom = Math.min(selection.anchor, selection.head);
   const selectionTo = Math.max(selection.anchor, selection.head);
   for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
@@ -14805,14 +14868,12 @@ function resolveTopLevelParagraphScope(document2, selection) {
   }
   return null;
 }
-function resolveTopLevelSdtParagraphScope(document2, selection) {
+function resolveTopLevelSdtParagraphScope(document2, selection, scopeSurfaceCache) {
   const root = document2.content;
   if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
     return null;
   }
-  const surface = createEditorSurfaceSnapshot(document2, selection, void 0, {
-    editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX
-  });
+  const surface = scopeSurfaceCache.get();
   const selectionFrom = Math.min(selection.anchor, selection.head);
   const selectionTo = Math.max(selection.anchor, selection.head);
   for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
@@ -15564,7 +15625,7 @@ function getTableCellRange(table, cell) {
 function breadcrumbItemsEqual(left, right) {
   return left.kind === right.kind && left.label === right.label && left.from === right.from && left.to === right.to;
 }
-function applyFormattingOperationToDocument(document2, snapshot, operation) {
+function applyFormattingOperationToDocument(document2, snapshot, operation2) {
   const surface = snapshot.surface;
   if (!surface) {
     return {
@@ -15578,7 +15639,7 @@ function applyFormattingOperationToDocument(document2, snapshot, operation) {
   let changed = false;
   const selectionFrom = Math.min(snapshot.selection.anchor, snapshot.selection.head);
   const selectionTo = Math.max(snapshot.selection.anchor, snapshot.selection.head);
-  if (operation.type === "set-alignment" || operation.type === "indent" || operation.type === "outdent") {
+  if (operation2.type === "set-alignment" || operation2.type === "indent" || operation2.type === "outdent") {
     visitParagraphBindings(root.children, surface.blocks, (paragraph, paragraphSurface) => {
       if (!selectionTouchesRange(
         snapshot.selection.anchor,
@@ -15588,7 +15649,7 @@ function applyFormattingOperationToDocument(document2, snapshot, operation) {
       )) {
         return;
       }
-      const paragraphChanged = operation.type === "set-alignment" ? applyAlignment(paragraph, operation.alignment) : applyIndentation(paragraph, operation.type === "indent" ? 1 : -1);
+      const paragraphChanged = operation2.type === "set-alignment" ? applyAlignment(paragraph, operation2.alignment) : applyIndentation(paragraph, operation2.type === "indent" ? 1 : -1);
       changed = changed || paragraphChanged;
     });
     return {
@@ -15604,7 +15665,7 @@ function applyFormattingOperationToDocument(document2, snapshot, operation) {
       changed: false
     };
   }
-  const nextMarks = resolveMarkUpdater(snapshot, operation);
+  const nextMarks = resolveMarkUpdater(snapshot, operation2);
   visitParagraphBindings(root.children, surface.blocks, (paragraph, paragraphSurface) => {
     if (!rangesOverlap(
       selectionFrom,
@@ -15633,10 +15694,10 @@ function applyFormattingOperationToDocument(document2, snapshot, operation) {
     changed
   };
 }
-function applyTextMarkOperationToDocumentRange(document2, range, operation) {
+function applyTextMarkOperationToDocumentRange(document2, range, operation2) {
   const inputFrom = Math.min(range.from, range.to);
   const inputTo = Math.max(range.from, range.to);
-  const expandedRange = operation.type === "clear-mark" && operation.expandToFullHighlight === true ? expandRangeToCanonicalHighlightExtent(document2, inputFrom, inputTo) : { from: inputFrom, to: inputTo };
+  const expandedRange = operation2.type === "clear-mark" && operation2.expandToFullHighlight === true ? expandRangeToCanonicalHighlightExtent(document2, inputFrom, inputTo) : { from: inputFrom, to: inputTo };
   const selectionFrom = expandedRange.from;
   const selectionTo = expandedRange.to;
   const selection = {
@@ -15655,17 +15716,17 @@ function applyTextMarkOperationToDocumentRange(document2, range, operation) {
   }
   const nextDocument = structuredClone(document2);
   const root = nextDocument.content;
-  const updateMarks = resolveTextMarkRangeUpdater(operation);
+  const updateMarks = resolveTextMarkRangeUpdater(operation2);
   let changed = false;
   let cursor = 0;
   for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
     const block = root.children[blockIndex];
     const blockFrom = cursor;
-    const blockLength = block?.type === "paragraph" ? block.children.reduce(
+    const blockLength2 = block?.type === "paragraph" ? block.children.reduce(
       (total, child) => total + inlineNodeLength(child),
       0
     ) : 1;
-    const blockTo = blockFrom + blockLength;
+    const blockTo = blockFrom + blockLength2;
     if (block?.type === "paragraph" && rangesOverlap(selectionFrom, selectionTo, blockFrom, blockTo)) {
       const transformed = transformInlineNodes(
         block.children,
@@ -15698,11 +15759,11 @@ function expandRangeToCanonicalHighlightExtent(document2, inputFrom, inputTo) {
   for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
     const block = root.children[blockIndex];
     const blockFrom = cursor;
-    const blockLength = block.type === "paragraph" ? block.children.reduce(
+    const blockLength2 = block.type === "paragraph" ? block.children.reduce(
       (total, child) => total + inlineNodeLength(child),
       0
     ) : 1;
-    const blockTo = blockFrom + blockLength;
+    const blockTo = blockFrom + blockLength2;
     if (block.type === "paragraph" && rangesOverlap(inputFrom, inputTo, blockFrom, blockTo)) {
       const spans = collectInlineHighlightSpans(block.children, blockFrom).spans;
       const expanded = expandRangeWithinHighlightSpans(spans, inputFrom, inputTo);
@@ -15791,39 +15852,39 @@ function marksHaveVisualHighlight(marks) {
     (mark) => mark.type === "highlight" || mark.type === "backgroundColor"
   ) ?? false;
 }
-function resolveTextMarkRangeUpdater(operation) {
-  if (operation.type === "set-mark") {
+function resolveTextMarkRangeUpdater(operation2) {
+  if (operation2.type === "set-mark") {
     return (marks) => {
       const nextMarks = cloneMarks3(marks).filter(
-        (candidate) => candidate.type !== operation.mark.type
+        (candidate) => candidate.type !== operation2.mark.type
       );
-      nextMarks.push({ ...operation.mark });
+      nextMarks.push({ ...operation2.mark });
       return nextMarks.length > 0 ? nextMarks : void 0;
     };
   }
   return (marks) => {
     const nextMarks = cloneMarks3(marks).filter((candidate) => {
-      if (operation.mark === "visualHighlight") {
+      if (operation2.mark === "visualHighlight") {
         return candidate.type !== "highlight" && candidate.type !== "backgroundColor";
       }
-      return candidate.type !== operation.mark;
+      return candidate.type !== operation2.mark;
     });
     return nextMarks.length > 0 ? nextMarks : void 0;
   };
 }
-function resolveMarkUpdater(snapshot, operation) {
+function resolveMarkUpdater(snapshot, operation2) {
   const formatting = getFormattingStateFromRenderSnapshot(snapshot);
-  switch (operation.type) {
+  switch (operation2.type) {
     case "toggle":
-      return (marks) => toggleMarks(marks, operation.mark, !formatting[operation.mark]);
+      return (marks) => toggleMarks(marks, operation2.mark, !formatting[operation2.mark]);
     case "set-font-family":
-      return (marks) => setMarkValue(marks, "fontFamily", sanitizeFontFamily(operation.fontFamily));
+      return (marks) => setMarkValue(marks, "fontFamily", sanitizeFontFamily(operation2.fontFamily));
     case "set-font-size":
-      return (marks) => setMarkValue(marks, "fontSize", sanitizeFontSize(operation.size));
+      return (marks) => setMarkValue(marks, "fontSize", sanitizeFontSize(operation2.size));
     case "set-text-color":
-      return (marks) => setMarkValue(marks, "textColor", sanitizeColor(operation.color));
+      return (marks) => setMarkValue(marks, "textColor", sanitizeColor(operation2.color));
     case "set-highlight-color":
-      return (marks) => setMarkValue(marks, "backgroundColor", sanitizeColor(operation.color));
+      return (marks) => setMarkValue(marks, "backgroundColor", sanitizeColor(operation2.color));
   }
 }
 function applyAlignment(paragraph, alignment) {
@@ -17158,7 +17219,7 @@ function findCellIndexAtColumn(row2, logicalColumn) {
 }
 
 // src/core/commands/table-structure-commands.ts
-function applyTableStructureOperation(document2, snapshot, selectionDescriptor, operation) {
+function applyTableStructureOperation(document2, snapshot, selectionDescriptor, operation2) {
   const root = document2.content;
   const fallbackSelection = toInternalSelectionSnapshot(snapshot.selection);
   if (!root || root.type !== "doc") {
@@ -17172,11 +17233,11 @@ function applyTableStructureOperation(document2, snapshot, selectionDescriptor,
   if (!target || target.type !== "table") {
     return createNoopStructuralMutation(document2, fallbackSelection);
   }
-  switch (operation.type) {
+  switch (operation2.type) {
     case "delete-table":
       return deleteTableBlock(document2, root, effectiveSelection.tableBlockIndex, fallbackSelection);
     case "set-cell-background":
-      return setCellBackground(document2, root, target, effectiveSelection, operation.color, fallbackSelection);
+      return setCellBackground(document2, root, target, effectiveSelection, operation2.color, fallbackSelection);
     case "split-cell":
       return splitSelectedCell(document2, root, target, effectiveSelection, fallbackSelection);
     case "merge-cells":
@@ -17194,20 +17255,20 @@ function applyTableStructureOperation(document2, snapshot, selectionDescriptor,
     case "delete-column":
       return deleteColumn(document2, root, target, effectiveSelection, fallbackSelection);
     case "set-table-width":
-      return patchTable(document2, root, target, effectiveSelection, { width: operation.width }, fallbackSelection);
+      return patchTable(document2, root, target, effectiveSelection, { width: operation2.width }, fallbackSelection);
     case "set-table-alignment":
-      return patchTable(document2, root, target, effectiveSelection, { alignment: operation.alignment }, fallbackSelection);
+      return patchTable(document2, root, target, effectiveSelection, { alignment: operation2.alignment }, fallbackSelection);
     case "set-table-indent":
-      return patchTable(document2, root, target, effectiveSelection, { indent: operation.indent }, fallbackSelection);
+      return patchTable(document2, root, target, effectiveSelection, { indent: operation2.indent }, fallbackSelection);
     case "set-table-layout-mode":
-      return patchTable(document2, root, target, effectiveSelection, { layoutMode: operation.mode }, fallbackSelection);
+      return patchTable(document2, root, target, effectiveSelection, { layoutMode: operation2.mode }, fallbackSelection);
     case "set-table-cell-margins":
       return patchTable(
         document2,
         root,
         target,
         effectiveSelection,
-        { cellMargins: mergeTableCellMargins(target.cellMargins, operation.margins) },
+        { cellMargins: mergeTableCellMargins(target.cellMargins, operation2.margins) },
         fallbackSelection
       );
     case "set-table-borders":
@@ -17216,7 +17277,7 @@ function applyTableStructureOperation(document2, snapshot, selectionDescriptor,
         root,
         target,
         effectiveSelection,
-        { borders: mergeTableBorders(target.borders, operation.borders) },
+        { borders: mergeTableBorders(target.borders, operation2.borders) },
         fallbackSelection
       );
     case "set-table-style":
@@ -17225,7 +17286,7 @@ function applyTableStructureOperation(document2, snapshot, selectionDescriptor,
         root,
         target,
         effectiveSelection,
-        { styleId: operation.styleId ?? void 0 },
+        { styleId: operation2.styleId ?? void 0 },
         fallbackSelection
       );
     case "set-table-caption":
@@ -17234,7 +17295,7 @@ function applyTableStructureOperation(document2, snapshot, selectionDescriptor,
         root,
         target,
         effectiveSelection,
-        { caption: operation.caption ?? void 0 },
+        { caption: operation2.caption ?? void 0 },
         fallbackSelection
       );
     case "set-table-description":
@@ -17243,82 +17304,82 @@ function applyTableStructureOperation(document2, snapshot, selectionDescriptor,
         root,
         target,
         effectiveSelection,
-        { description: operation.description ?? void 0 },
+        { description: operation2.description ?? void 0 },
         fallbackSelection
       );
     case "set-column-width":
-      return setColumnWidth(document2, root, target, effectiveSelection, operation.columnIndex, operation.twips, fallbackSelection);
+      return setColumnWidth(document2, root, target, effectiveSelection, operation2.columnIndex, operation2.twips, fallbackSelection);
     case "distribute-columns-evenly":
-      return distributeColumnsEvenly(document2, root, target, effectiveSelection, operation.columnRange, fallbackSelection);
+      return distributeColumnsEvenly(document2, root, target, effectiveSelection, operation2.columnRange, fallbackSelection);
     case "set-row-height":
-      return patchRow(document2, root, target, effectiveSelection, operation.rowIndex, {
-        height: operation.twips,
-        heightRule: operation.rule
+      return patchRow(document2, root, target, effectiveSelection, operation2.rowIndex, {
+        height: operation2.twips,
+        heightRule: operation2.rule
       }, fallbackSelection);
     case "set-row-cant-split":
-      return patchRow(document2, root, target, effectiveSelection, operation.rowIndex, {
-        cantSplit: operation.value
+      return patchRow(document2, root, target, effectiveSelection, operation2.rowIndex, {
+        cantSplit: operation2.value
       }, fallbackSelection);
     case "set-row-is-header":
-      return patchRow(document2, root, target, effectiveSelection, operation.rowIndex, {
-        isHeader: operation.value
+      return patchRow(document2, root, target, effectiveSelection, operation2.rowIndex, {
+        isHeader: operation2.value
       }, fallbackSelection);
     case "set-row-alignment":
-      return patchRow(document2, root, target, effectiveSelection, operation.rowIndex, {
-        horizontalAlignment: operation.alignment
+      return patchRow(document2, root, target, effectiveSelection, operation2.rowIndex, {
+        horizontalAlignment: operation2.alignment
       }, fallbackSelection);
     case "insert-rows":
-      return insertRows(document2, root, target, effectiveSelection, operation.rowIndex, operation.at, operation.count, fallbackSelection);
+      return insertRows(document2, root, target, effectiveSelection, operation2.rowIndex, operation2.at, operation2.count, fallbackSelection);
     case "insert-columns":
-      return insertColumns(document2, root, target, effectiveSelection, operation.columnIndex, operation.at, operation.count, operation.widths, fallbackSelection);
+      return insertColumns(document2, root, target, effectiveSelection, operation2.columnIndex, operation2.at, operation2.count, operation2.widths, fallbackSelection);
     case "set-cell-borders":
-      return patchCells(document2, root, target, effectiveSelection, operation.locator, (cell) => ({
+      return patchCells(document2, root, target, effectiveSelection, operation2.locator, (cell) => ({
         ...cell,
-        borders: mergeCellBorders(cell.borders, operation.borders)
+        borders: mergeCellBorders(cell.borders, operation2.borders)
       }), fallbackSelection);
     case "set-cell-shading":
-      return patchCells(document2, root, target, effectiveSelection, operation.locator, (cell) => {
-        if (operation.shading === null) {
+      return patchCells(document2, root, target, effectiveSelection, operation2.locator, (cell) => {
+        if (operation2.shading === null) {
           const { shading: _drop, ...rest } = cell;
           return rest;
         }
-        return { ...cell, shading: { ...cell.shading ?? {}, ...operation.shading } };
+        return { ...cell, shading: { ...cell.shading ?? {}, ...operation2.shading } };
       }, fallbackSelection);
     case "clear-cell-shading":
-      return patchCells(document2, root, target, effectiveSelection, operation.locator, (cell) => {
+      return patchCells(document2, root, target, effectiveSelection, operation2.locator, (cell) => {
         const { shading: _drop, ...rest } = cell;
         return rest;
       }, fallbackSelection);
     case "set-cell-margins":
-      return patchCells(document2, root, target, effectiveSelection, operation.locator, (cell) => ({
+      return patchCells(document2, root, target, effectiveSelection, operation2.locator, (cell) => ({
         ...cell,
-        margins: { ...cell.margins ?? {}, ...operation.margins }
+        margins: { ...cell.margins ?? {}, ...operation2.margins }
       }), fallbackSelection);
     case "set-cell-vertical-align":
-      return patchCells(document2, root, target, effectiveSelection, operation.locator, (cell) => ({
+      return patchCells(document2, root, target, effectiveSelection, operation2.locator, (cell) => ({
         ...cell,
-        verticalAlign: operation.align
+        verticalAlign: operation2.align
       }), fallbackSelection);
     case "set-cell-text-direction":
-      return patchCells(document2, root, target, effectiveSelection, operation.locator, (cell) => ({
+      return patchCells(document2, root, target, effectiveSelection, operation2.locator, (cell) => ({
         ...cell,
-        textDirection: operation.direction
+        textDirection: operation2.direction
       }), fallbackSelection);
     case "set-cell-no-wrap":
-      return patchCells(document2, root, target, effectiveSelection, operation.locator, (cell) => ({
+      return patchCells(document2, root, target, effectiveSelection, operation2.locator, (cell) => ({
         ...cell,
-        noWrap: operation.value
+        noWrap: operation2.value
       }), fallbackSelection);
     case "set-cell-fit-text":
-      return patchCells(document2, root, target, effectiveSelection, operation.locator, (cell) => ({
+      return patchCells(document2, root, target, effectiveSelection, operation2.locator, (cell) => ({
         ...cell,
-        fitText: operation.value
+        fitText: operation2.value
       }), fallbackSelection);
     default:
       return createNoopStructuralMutation(document2, fallbackSelection);
   }
 }
-function applyTableStructureOperationForEditableTarget(document2, snapshot, selectionDescriptor, operation, targetRef) {
+function applyTableStructureOperationForEditableTarget(document2, snapshot, selectionDescriptor, operation2, targetRef) {
   const tableIdentity = targetRef.table;
   const fallbackSelection = toInternalSelectionSnapshot(snapshot.selection);
   if (!tableIdentity || targetRef.commandFamily !== "table-structure") {
@@ -17353,7 +17414,7 @@ function applyTableStructureOperationForEditableTarget(document2, snapshot, sele
     localDocument,
     snapshot,
     { ...effectiveSelection, tableBlockIndex: 0 },
-    operation
+    operation2
   );
   if (!localResult.changed) {
     return createNoopStructuralMutation(document2, fallbackSelection);
@@ -21027,13 +21088,14 @@ function mapRecordAnchor(anchor, mapping) {
   return toPublicAnchorProjection(mapAnchor(toInternalAnchorProjection(anchor), mapping));
 }
 function withCommandTextTarget(context, command) {
-  if (!command.textTarget || context.textTarget === command.textTarget) {
-    return context;
+  let next = context;
+  if (next.precomputedSurface === void 0 && next.renderSnapshot?.surface !== void 0) {
+    next = { ...next, precomputedSurface: next.renderSnapshot.surface };
   }
-  return {
-    ...context,
-    textTarget: command.textTarget
-  };
+  if (command.textTarget && next.textTarget !== command.textTarget) {
+    next = { ...next, textTarget: command.textTarget };
+  }
+  return next;
 }
 function listCommandContext(context) {
   return {
@@ -24427,9 +24489,9 @@ function createSuggestionsSnapshot(trackedChanges) {
   const groups = /* @__PURE__ */ new Map();
   for (const revision of trackedChanges.revisions) {
     const suggestionId = revision.suggestionId ?? revision.revisionId;
-    const group = groups.get(suggestionId);
-    if (group) {
-      group.push(revision);
+    const group2 = groups.get(suggestionId);
+    if (group2) {
+      group2.push(revision);
     } else {
       groups.set(suggestionId, [revision]);
     }
@@ -24476,15 +24538,15 @@ function createSuggestionsSnapshot(trackedChanges) {
   };
 }
 
-// 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":
@@ -24496,29 +24558,241 @@ function inlineLength(node) {
       return 1;
   }
 }
-function walkParagraphs2(document2) {
-  const envelope = document2;
-  const root = "content" in envelope ? envelope.content : document2;
-  const out = [];
+function paragraphLengthForScopeCoordinates(paragraph) {
+  return paragraph.children.reduce(
+    (total, child) => total + inlineLengthForScopeCoordinates(child),
+    0
+  );
+}
+function computeScopeStoryLayout(document2) {
+  const root = document2.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 row2 = block.rows[rowIndex];
+      for (let cellIndex = 0; cellIndex < row2.cells.length; cellIndex += 1) {
+        const cell = row2.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((row2, rowIndex) => {
+      if (rowIndex !== head.rowIndex) return row2;
+      const cells = row2.cells.map((cell, cellIndex) => {
+        if (cellIndex !== head.cellIndex) return cell;
+        return {
+          ...cell,
+          children: replaceInBlockList(cell.children, rest, children)
+        };
+      });
+      return { ...row2, 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((row2) => {
+      let rowMutated = false;
+      const cells = row2.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 ? { ...row2, cells } : row2;
+    });
+    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 walkParagraphs2(document2) {
+  const envelope = document2;
+  return computeScopeStoryLayout(envelope).paragraphSlots.map((slot) => ({
+    paragraph: slot.paragraph,
+    from: slot.from
+  }));
+}
+function inlineLength(node) {
+  return inlineLengthForScopeCoordinates(node);
 }
 function collectScopeLocations(document2) {
   const locations = /* @__PURE__ */ new Map();
@@ -25718,7 +25992,7 @@ function buildFormattingDebugEntry(inputs) {
 }
 
 // src/runtime/layout/layout-engine-version.ts
-var LAYOUT_ENGINE_VERSION = 93;
+var LAYOUT_ENGINE_VERSION = 94;
 
 // src/runtime/layout/compat-input-ledger.ts
 var DEFAULT_COMPATIBILITY_MODE = 15;
@@ -26929,9 +27203,13 @@ function appendFragmentLayoutObjectSemanticEntries(input) {
       numberingCanonicalAddressKey: numbering.canonicalAddressKey,
       numberingListAddressKey: numbering.listAddressKey,
       numberingMarkerText: numbering.markerText,
+      numberingMarkerTextPosture: numbering.markerTextPosture,
       numberingMarkerSuffix: numbering.markerSuffix,
       numberingFormat: numbering.format,
       numberingFormatPosture: numbering.formatPosture,
+      numberingPicBulletId: numbering.picBulletId,
+      numberingPicBulletMediaId: numbering.picBulletMediaId,
+      numberingPictureBulletPosture: numbering.pictureBulletPosture,
       numberingUnavailableReasons: numbering.unavailableReasons,
       markerGlyphRect: markerProjection.rect,
       markerLaneRect: markerProjection.markerLaneRect,
@@ -33849,9 +34127,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
@@ -33942,25 +34220,43 @@ function computeBlockPositions(document2) {
   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 row2 of block.rows) {
+      for (const cell of row2.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(document2, blocks) {
   const envelope = document2;
   const root = "content" in envelope ? envelope.content : document2;
@@ -34177,8 +34473,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 {
@@ -35340,6 +35636,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 = {}) {
@@ -36244,31 +36588,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",
@@ -36485,10 +36804,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"
       ]
     );
   }
@@ -36503,6 +36821,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") {
@@ -36524,12 +36855,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}`;
@@ -36557,14 +36884,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`,
@@ -39155,6 +39493,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;
@@ -39307,11 +39870,11 @@ function computePreservationVerdict(document2, 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":
@@ -39462,11 +40025,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"
     });
   }
@@ -39703,11 +40266,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;
@@ -39870,14 +40466,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",
@@ -40356,10 +40956,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: {
@@ -40434,6 +41034,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,
@@ -47368,11 +47972,45 @@ function createLayoutEngine(options = {}) {
   const telemetryBus = options.telemetryBus;
   const dirtyFieldFamilies = /* @__PURE__ */ new Set();
   const listeners = /* @__PURE__ */ new Set();
-  let cachedKey = null;
-  let cachedGraph = null;
-  let cachedFormatting = null;
-  let cachedMapper = null;
+  let cachedFull = null;
+  let cachedWindowed = null;
   let previousPageCount = 0;
+  function isFullViewportKey(key) {
+    return key === FULL_VIEWPORT_WINDOW_KEY;
+  }
+  function getCachedSlot(viewportWindowKeyValue) {
+    return isFullViewportKey(viewportWindowKeyValue) ? cachedFull : cachedWindowed;
+  }
+  function preferredCachedGraph() {
+    return cachedFull?.graph ?? cachedWindowed?.graph ?? null;
+  }
+  function clearAllSlots() {
+    cachedFull = null;
+    cachedWindowed = null;
+  }
+  function clearWindowedSlot() {
+    cachedWindowed = null;
+  }
+  function evictStaleSiblingSlot(freshKey) {
+    const sibling = isFullViewportKey(freshKey.viewportWindowKey) ? cachedWindowed : cachedFull;
+    if (sibling === null) return;
+    if (sibling.key.content === freshKey.content && sibling.key.styles === freshKey.styles && sibling.key.subParts === freshKey.subParts) {
+      return;
+    }
+    if (isFullViewportKey(freshKey.viewportWindowKey)) {
+      cachedWindowed = null;
+    } else {
+      cachedFull = null;
+    }
+  }
+  function commitSlot(slot) {
+    if (isFullViewportKey(slot.key.viewportWindowKey)) {
+      cachedFull = slot;
+    } else {
+      cachedWindowed = slot;
+    }
+    evictStaleSiblingSlot(slot.key);
+  }
   let pendingInvalidation = null;
   function emit(event) {
     for (const listener of listeners) {
@@ -47518,27 +48156,31 @@ function createLayoutEngine(options = {}) {
       subParts: document2.subParts,
       anchors: layoutInputs.anchors
     });
+    const priorGraphForMaterialization = preferredCachedGraph();
     const graph = applyViewportWindowMaterialization(
       measuredGraph,
       viewportWindow,
-      cachedGraph
+      priorGraphForMaterialization
     );
-    const dirtyFamilies = computeFieldDirtiness(cachedGraph, graph);
+    const priorGraphForFieldDirtiness = preferredCachedGraph();
+    const dirtyFamilies = computeFieldDirtiness(priorGraphForFieldDirtiness, graph);
     for (const family of dirtyFamilies) {
       dirtyFieldFamilies.add(family);
     }
     const formatting = buildResolvedFormattingState(document2, mainSurface);
     const currentPageCount = graph.contentPageCount;
     const pageCountDelta = currentPageCount !== previousPageCount ? { previous: previousPageCount, current: currentPageCount } : void 0;
-    cachedKey = {
-      content: document2.content,
-      styles: document2.styles,
-      subParts: document2.subParts,
-      viewportWindowKey: viewportWindowKey(viewportWindow)
-    };
-    cachedGraph = graph;
-    cachedFormatting = formatting;
-    cachedMapper = createPageFragmentMapper(graph);
+    commitSlot({
+      key: {
+        content: document2.content,
+        styles: document2.styles,
+        subParts: document2.subParts,
+        viewportWindowKey: viewportWindowKey(viewportWindow)
+      },
+      graph,
+      formatting,
+      mapper: createPageFragmentMapper(graph)
+    });
     if (pageCountDelta) {
       emit({
         kind: "page_count_changed",
@@ -47579,7 +48221,7 @@ function createLayoutEngine(options = {}) {
     return graph;
   }
   function incrementalRelayout(input, pending) {
-    const priorGraph = cachedGraph;
+    const priorGraph = cachedFull?.graph ?? null;
     const range = pending.result.dirtyPageRange;
     if (!priorGraph || !range) return null;
     const telemetryOn = telemetryBus?.isEnabled("layout") ?? false;
@@ -47672,6 +48314,22 @@ function createLayoutEngine(options = {}) {
       deriveDocumentPageSnapshots(splicedGraph)
     );
     const pageCountDelta = currentPageCount !== previousPageCount ? { previous: previousPageCount, current: currentPageCount } : void 0;
+    const priorMapper = cachedFull?.mapper ?? null;
+    commitSlot({
+      key: {
+        content: document2.content,
+        styles: document2.styles,
+        subParts: document2.subParts,
+        viewportWindowKey: FULL_VIEWPORT_WINDOW_KEY
+      },
+      graph: splicedGraph,
+      formatting,
+      mapper: rebuildMapper(
+        priorMapper ?? createPageFragmentMapper(splicedGraph),
+        splicedGraph,
+        firstDirty
+      )
+    });
     if (pageCountDelta) {
       emit({
         kind: "page_count_changed",
@@ -47701,19 +48359,6 @@ function createLayoutEngine(options = {}) {
       ...dirtyFamilies.length > 0 ? { dirtyFieldFamilies: dirtyFamilies } : {},
       ...pageCountDelta ? { pageCountDelta } : {}
     });
-    cachedKey = {
-      content: document2.content,
-      styles: document2.styles,
-      subParts: document2.subParts,
-      viewportWindowKey: FULL_VIEWPORT_WINDOW_KEY
-    };
-    cachedGraph = splicedGraph;
-    cachedFormatting = formatting;
-    cachedMapper = rebuildMapper(
-      cachedMapper ?? createPageFragmentMapper(splicedGraph),
-      splicedGraph,
-      firstDirty
-    );
     if (telemetryOn) {
       emitRecomputeCompleted(
         "bounded",
@@ -47730,13 +48375,14 @@ function createLayoutEngine(options = {}) {
     const document2 = input.document;
     const normalizedWindow = normalizeViewportPageWindow(input.viewportPageWindow);
     const currentViewportWindowKey = viewportWindowKey(normalizedWindow);
-    const keyEqual = cachedGraph !== null && cachedKey !== null && cachedKey.content === document2.content && cachedKey.styles === document2.styles && cachedKey.subParts === document2.subParts && cachedKey.viewportWindowKey === currentViewportWindowKey;
+    const slot = getCachedSlot(currentViewportWindowKey);
+    const keyEqual = slot !== null && slot.key.content === document2.content && slot.key.styles === document2.styles && slot.key.subParts === document2.subParts && slot.key.viewportWindowKey === currentViewportWindowKey;
     if (keyEqual && pendingInvalidation === null) {
-      return cachedGraph;
+      return slot.graph;
     }
     const pending = pendingInvalidation;
     pendingInvalidation = null;
-    if (pending !== null && pending.result.scope === "bounded" && cachedGraph !== null && normalizedWindow === void 0) {
+    if (pending !== null && pending.result.scope === "bounded" && cachedFull !== null && normalizedWindow === void 0) {
       const spliced = incrementalRelayout(input, pending);
       if (spliced !== null) {
         return spliced;
@@ -47745,16 +48391,39 @@ function createLayoutEngine(options = {}) {
     }
     return fullRebuild(input, pending?.reason);
   }
+  function ensureSlotMapperAndFormatting(slot, document2) {
+    if (slot.mapper === null) {
+      slot.mapper = createPageFragmentMapper(slot.graph);
+    }
+    if (slot.formatting === null) {
+      const mainSurface = createEditorSurfaceSnapshot(
+        document2,
+        createSelectionSnapshot(0, 0),
+        MAIN_STORY_TARGET
+      );
+      slot.formatting = buildResolvedFormattingState(document2, mainSurface);
+    }
+  }
   function getMapper(input) {
     getGraphInternal(input);
-    return cachedMapper;
+    const currentViewportWindowKey = viewportWindowKey(
+      normalizeViewportPageWindow(input.viewportPageWindow)
+    );
+    const slot = getCachedSlot(currentViewportWindowKey);
+    ensureSlotMapperAndFormatting(slot, input.document);
+    return slot.mapper;
   }
   function getFormatting(input) {
     getGraphInternal(input);
-    return cachedFormatting;
+    const currentViewportWindowKey = viewportWindowKey(
+      normalizeViewportPageWindow(input.viewportPageWindow)
+    );
+    const slot = getCachedSlot(currentViewportWindowKey);
+    ensureSlotMapperAndFormatting(slot, input.document);
+    return slot.formatting;
   }
   if (autoUpgradeToCanvas && options.measurementProvider === void 0 && typeof document !== "undefined" && typeof HTMLCanvasElement !== "undefined") {
-    const readCachedRevision = () => cachedGraph?.revision ?? 0;
+    const readCachedRevision = () => preferredCachedGraph()?.revision ?? 0;
     void (async () => {
       try {
         const mod = await Promise.resolve().then(() => (init_measurement_backend_canvas(), measurement_backend_canvas_exports));
@@ -47764,10 +48433,7 @@ function createLayoutEngine(options = {}) {
           options.measurementCache,
           telemetryBus
         );
-        cachedKey = null;
-        cachedGraph = null;
-        cachedFormatting = null;
-        cachedMapper = null;
+        clearAllSlots();
         emit({
           kind: "measurement_backend_ready",
           revision: readCachedRevision(),
@@ -47811,22 +48477,19 @@ function createLayoutEngine(options = {}) {
       return getMapper(input);
     },
     invalidate(reason) {
-      const result = analyzeInvalidation(reason, cachedGraph);
+      const result = analyzeInvalidation(reason, preferredCachedGraph());
       for (const family of result.dirtyFieldFamilies) {
         dirtyFieldFamilies.add(family);
       }
       if (result.scope === "bounded") {
         pendingInvalidation = { reason, result };
       } else {
-        cachedKey = null;
-        cachedGraph = null;
-        cachedFormatting = null;
-        cachedMapper = null;
+        clearAllSlots();
         pendingInvalidation = { reason, result };
       }
     },
     analyzeInvalidation(reason) {
-      return analyzeInvalidation(reason, cachedGraph);
+      return analyzeInvalidation(reason, preferredCachedGraph());
     },
     getDirtyFieldFamilies() {
       return Array.from(dirtyFieldFamilies);
@@ -47854,14 +48517,11 @@ function createLayoutEngine(options = {}) {
         telemetryBus
       );
       if (previousFidelity !== provider.fidelity) {
-        cachedKey = null;
-        cachedGraph = null;
-        cachedFormatting = null;
-        cachedMapper = null;
+        clearAllSlots();
       }
       emit({
         kind: "measurement_backend_ready",
-        revision: cachedGraph?.revision ?? 0,
+        revision: preferredCachedGraph()?.revision ?? 0,
         fidelity: provider.fidelity
       });
     },
@@ -47876,30 +48536,33 @@ function createLayoutEngine(options = {}) {
      */
     invalidateMeasurementCache() {
       measurementProvider.invalidateCache();
-      cachedKey = null;
-      cachedGraph = null;
-      cachedFormatting = null;
-      cachedMapper = null;
+      clearAllSlots();
     },
     getMeasurementCacheStats() {
       if (!isCachedLayoutMeasurementProvider(measurementProvider)) return null;
       return measurementProvider.measurementCacheStats();
     },
     /**
-     * L7 Phase 2.5 — seed the cached graph from a prerender envelope.
-     * Populates both `cachedGraph` and `cachedKey` (keyed on the provided
-     * document's identity-equal slots) so the next getPageGraph query
-     * returns the seeded graph directly. Any subsequent mutation
-     * invalidates normally through the existing path.
+     * L7 Phase 2.5 — seed the full-slot cached graph from a prerender
+     * envelope. Populates the full slot (graph + key, with formatting and
+     * mapper computed lazily on first read) so the next viewport-
+     * independent `getPageGraph` query returns the seeded graph directly.
+     * Any subsequent mutation invalidates normally through the existing
+     * path; sibling eviction in `commitSlot` clears `cachedWindowed` if
+     * it carried a different document tuple.
      */
     seedCachedGraph(graph, document2) {
-      cachedGraph = graph;
-      cachedKey = {
-        content: document2.content,
-        styles: document2.styles,
-        subParts: document2.subParts,
-        viewportWindowKey: FULL_VIEWPORT_WINDOW_KEY
-      };
+      commitSlot({
+        key: {
+          content: document2.content,
+          styles: document2.styles,
+          subParts: document2.subParts,
+          viewportWindowKey: FULL_VIEWPORT_WINDOW_KEY
+        },
+        graph,
+        formatting: null,
+        mapper: null
+      });
       previousPageCount = graph.contentPageCount;
     }
   };
@@ -48167,7 +48830,7 @@ function attachScopeCardModel(input) {
       primaryAnchorRect: null,
       ...anchor ? { anchor } : {},
       ...issue ? { issue } : {},
-      suggestionGroupIds: suggestionGroups.map((group) => group.groupId),
+      suggestionGroupIds: suggestionGroups.map((group2) => group2.groupId),
       suggestionGroups,
       reviewActionCount: reviewActions.length,
       reviewActions,
@@ -48178,7 +48841,7 @@ function attachScopeCardModel(input) {
 }
 function resolveSuggestionGroupsForIssue(issueId, suggestions) {
   if (!issueId || !suggestions?.groups) return [];
-  return suggestions.groups.filter((group) => group.issueId === issueId);
+  return suggestions.groups.filter((group2) => group2.issueId === issueId);
 }
 function resolveReviewActionsForIssue(issueId, metadata, externalResolutions) {
   if (!issueId || !metadata || metadata.length === 0) return [];
@@ -48253,39 +48916,8 @@ function insertScopeMarkers(document2, params) {
       to: normalizedTo
     };
   }
-  const paraSlots = [];
-  let cursor = 0;
-  let fromBlockIndex = -1;
-  let fromBlockKind = null;
-  let toBlockIndex = -1;
-  let toBlockKind = null;
-  let storyLength = 0;
-  for (let i = 0; i < root.children.length; i += 1) {
-    const block = root.children[i];
-    const blockFrom = cursor;
-    let blockLength;
-    if (block.type === "paragraph") {
-      blockLength = block.children.reduce(
-        (total, child) => total + inlineLength4(child),
-        0
-      );
-      paraSlots.push({ index: i, from: blockFrom, to: blockFrom + blockLength });
-    } else {
-      blockLength = 1;
-    }
-    const blockTo = blockFrom + blockLength;
-    if (fromBlockIndex === -1 && normalizedFrom >= blockFrom && normalizedFrom <= blockTo) {
-      fromBlockIndex = i;
-      fromBlockKind = block.type;
-    }
-    if (toBlockIndex === -1 && normalizedTo >= blockFrom && normalizedTo <= blockTo) {
-      toBlockIndex = i;
-      toBlockKind = block.type;
-    }
-    cursor = blockTo;
-    if (i < root.children.length - 1) cursor += 1;
-    storyLength = cursor;
-  }
+  const layout = computeScopeStoryLayout(document2);
+  const storyLength = layout.storyLength;
   if (normalizedFrom < 0 || normalizedTo > storyLength) {
     return {
       status: "range-out-of-bounds",
@@ -48295,73 +48927,71 @@ function insertScopeMarkers(document2, params) {
       storyLength
     };
   }
-  if (fromBlockIndex === -1 || toBlockIndex === -1) {
-    return {
-      status: "range-out-of-bounds",
-      scopeId,
-      from: normalizedFrom,
-      to: normalizedTo,
-      storyLength
-    };
-  }
-  if (fromBlockKind !== "paragraph" || toBlockKind !== "paragraph") {
-    const nonParaIndex = fromBlockKind !== "paragraph" ? fromBlockIndex : toBlockIndex;
-    const nonParaKind = fromBlockKind !== "paragraph" ? fromBlockKind : toBlockKind;
+  const startSlot = findParagraphSlotAtPosition(
+    layout,
+    normalizedFrom,
+    "start"
+  );
+  const endSlot = findParagraphSlotAtPosition(layout, normalizedTo, "end");
+  if (!startSlot || !endSlot) {
+    const offenderPosition = !startSlot ? normalizedFrom : normalizedTo;
+    const owner = findOwningBlockSlotAtPosition(layout, offenderPosition);
     return {
       status: "non-paragraph-target",
       scopeId,
       from: normalizedFrom,
       to: normalizedTo,
-      blockIndex: nonParaIndex,
-      blockKind: nonParaKind ?? "unknown"
+      blockIndex: owner?.rootBlockIndex ?? -1,
+      blockKind: owner?.kind ?? "unknown"
     };
   }
-  const startSlot = paraSlots.find((s) => s.index === fromBlockIndex);
-  const endSlot = paraSlots.find((s) => s.index === toBlockIndex);
-  if (startSlot.index === endSlot.index) {
+  if (sameScopeParagraphPath(startSlot.path, endSlot.path)) {
     const newChildren = injectMarkersIntoInlineList(
-      root.children[startSlot.index].children,
+      startSlot.paragraph.children,
       scopeId,
       normalizedFrom - startSlot.from,
       normalizedTo - startSlot.from,
       "both"
     );
-    const children2 = root.children.map(
-      (block, i) => i === startSlot.index ? { ...block, children: newChildren } : block
+    const nextRoot = replaceParagraphChildrenAtPath(
+      root,
+      startSlot.path,
+      newChildren
     );
     return {
       status: "planted",
-      document: { ...document2, content: { ...root, children: children2 } },
+      document: { ...document2, content: nextRoot },
       scopeId,
       plantedRange: { from: normalizedFrom, to: normalizedTo }
     };
   }
-  const children = root.children.map((block, i) => {
-    if (i === startSlot.index) {
-      const newChildren = injectMarkersIntoInlineList(
-        block.children,
-        scopeId,
-        normalizedFrom - startSlot.from,
-        Number.POSITIVE_INFINITY,
-        "start-only"
-      );
-      return { ...block, children: newChildren };
-    }
-    if (i === endSlot.index) {
-      const newChildren = injectMarkersIntoInlineList(
-        block.children,
-        scopeId,
-        Number.NEGATIVE_INFINITY,
-        normalizedTo - endSlot.from,
-        "end-only"
-      );
-      return { ...block, children: newChildren };
-    }
-    return block;
-  });
+  const startChildren = injectMarkersIntoInlineList(
+    startSlot.paragraph.children,
+    scopeId,
+    normalizedFrom - startSlot.from,
+    Number.POSITIVE_INFINITY,
+    "start-only"
+  );
+  const endChildren = injectMarkersIntoInlineList(
+    endSlot.paragraph.children,
+    scopeId,
+    Number.NEGATIVE_INFINITY,
+    normalizedTo - endSlot.from,
+    "end-only"
+  );
+  const rootWithStart = replaceParagraphChildrenAtPath(
+    root,
+    startSlot.path,
+    startChildren
+  );
+  const rootWithBoth = replaceParagraphChildrenAtPath(
+    rootWithStart,
+    endSlot.path,
+    endChildren
+  );
   return {
     status: "planted",
-    document: { ...document2, content: { ...root, children } },
+    document: { ...document2, content: rootWithBoth },
     scopeId,
     plantedRange: { from: normalizedFrom, to: normalizedTo }
   };
@@ -48369,43 +48999,15 @@ function insertScopeMarkers(document2, params) {
 function removeScopeMarkers(document2, scopeId) {
   const root = document2.content;
   if (!root || root.type !== "doc") return document2;
-  let mutated = false;
-  const children = root.children.map((block) => {
-    if (block.type !== "paragraph") return block;
-    const kept = block.children.filter((child) => {
-      if ((child.type === "scope_marker_start" || child.type === "scope_marker_end") && child.scopeId === scopeId) {
-        mutated = true;
-        return false;
-      }
-      return true;
-    });
-    if (kept.length === block.children.length) return block;
-    return { ...block, children: kept };
-  });
-  if (!mutated) return document2;
+  const result = removeScopeMarkersFromBlockList(root.children, scopeId);
+  if (!result.mutated) return document2;
   return {
     ...document2,
-    content: { ...root, children }
+    content: { ...root, children: result.blocks }
   };
 }
 function inlineLength4(node) {
-  switch (node.type) {
-    case "text":
-      return Array.from(node.text).length;
-    case "hyperlink":
-    case "field":
-      return node.children.reduce(
-        (total, child) => total + inlineLength4(child),
-        0
-      );
-    case "bookmark_start":
-    case "bookmark_end":
-    case "scope_marker_start":
-    case "scope_marker_end":
-      return 0;
-    default:
-      return 1;
-  }
+  return inlineLengthForScopeCoordinates(node);
 }
 function injectMarkersIntoInlineList(inlines, scopeId, startOffset, endOffset, mode) {
   const start = { type: "scope_marker_start", scopeId };
@@ -48673,11 +49275,11 @@ function projectEntries(kind, input) {
 }
 function projectIssueEntries(input) {
   const suggestionGroupsByIssueId = /* @__PURE__ */ new Map();
-  for (const group of input.suggestions?.groups ?? []) {
-    if (!group.issueId) continue;
-    const ids = suggestionGroupsByIssueId.get(group.issueId) ?? [];
-    ids.push(group.groupId);
-    suggestionGroupsByIssueId.set(group.issueId, ids);
+  for (const group2 of input.suggestions?.groups ?? []) {
+    if (!group2.issueId) continue;
+    const ids = suggestionGroupsByIssueId.get(group2.issueId) ?? [];
+    ids.push(group2.groupId);
+    suggestionGroupsByIssueId.set(group2.issueId, ids);
   }
   return (input.workflowMarkup?.metadata ?? []).filter((entry) => entry.metadataId === ISSUE_METADATA_ID).map((entry) => {
     const issueValue = isRecord3(entry.value) ? entry.value : void 0;
@@ -51038,13 +51640,13 @@ function createLayoutFacet(input) {
             createSelectionSnapshot(0, 0)
           );
           let cursor = 0;
-          for (const group of groups) {
-            for (let i = 0; i < group.count; i += 1) {
+          for (const group2 of groups) {
+            for (let i = 0; i < group2.count; i += 1) {
               const blockSnapshot = surface.blocks[cursor + i];
               if (!blockSnapshot) continue;
               blocks.push({
                 blockId: blockSnapshot.blockId,
-                fragmentId: `endnote-${group.noteId}-${i}`,
+                fragmentId: `endnote-${group2.noteId}-${i}`,
                 pageIndex: -1,
                 regionKind: "endnote-area",
                 runtimeFromOffset: blockSnapshot.from,
@@ -51053,7 +51655,7 @@ function createLayoutFacet(input) {
                 blockSnapshot
               });
             }
-            cursor += group.count;
+            cursor += group2.count;
           }
         }
       }
@@ -52448,9 +53050,9 @@ function resolveFootnoteAreaRegionBlocks(node, document2) {
   );
   const blocks = [];
   let cursor = 0;
-  for (const group of groups) {
-    const fragmentBase = group.allocation.fragmentId ?? `note-${node.pageIndex}-${group.allocation.noteId}`;
-    for (let i = 0; i < group.count; i += 1) {
+  for (const group2 of groups) {
+    const fragmentBase = group2.allocation.fragmentId ?? `note-${node.pageIndex}-${group2.allocation.noteId}`;
+    for (let i = 0; i < group2.count; i += 1) {
       const blockSnapshot = surface.blocks[cursor + i];
       if (!blockSnapshot) continue;
       blocks.push({
@@ -52460,11 +53062,11 @@ function resolveFootnoteAreaRegionBlocks(node, document2) {
         regionKind: "footnote-area",
         runtimeFromOffset: blockSnapshot.from,
         runtimeToOffset: blockSnapshot.to,
-        heightTwips: group.allocation.reservedHeightTwips,
+        heightTwips: group2.allocation.reservedHeightTwips,
         blockSnapshot
       });
     }
-    cursor += group.count;
+    cursor += group2.count;
   }
   return Object.freeze(blocks);
 }
@@ -55251,6 +55853,14 @@ function createDocumentRuntime(options) {
   let effectiveMarkupModeProvider;
   const perfCounters = new PerfCounters();
   const hotEditTraces = new HotEditTraceRecorder();
+  const scopeSurfaceTelemetry = {
+    onPrecomputedSurfaceHit: () => {
+      perfCounters.increment("surface.scope.precomputedSurfaceHit");
+    },
+    onScopeSurfaceBuild: () => {
+      perfCounters.increment("surface.scope.builds");
+    }
+  };
   let cachedHotEditPolicy = null;
   function getHotEditPolicy() {
     if (cachedHotEditPolicy?.document === state.document) {
@@ -55699,7 +56309,7 @@ function createDocumentRuntime(options) {
       viewportRangesKey: rangesKey,
       snapshot: surface
     };
-    const fullSurface = fullSurfaceForCache ?? (surface.viewportBlockRanges === null ? surface : void 0);
+    const fullSurface = fullSurfaceForCache?.viewportBlockRanges === null ? fullSurfaceForCache : surface.viewportBlockRanges === null ? surface : void 0;
     if (fullSurface) {
       cachedFullSurface = {
         content: state.document.content,
@@ -57262,6 +57872,7 @@ function createDocumentRuntime(options) {
           documentMode: workflowCoordinator.getEffectiveDocumentMode(commandSelection),
           defaultAuthorId: defaultAuthorId ?? void 0,
           renderSnapshot: cachedRenderSnapshot,
+          surfaceTelemetry: scopeSurfaceTelemetry,
           activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
           editableTargetCache: editableTargetBlockCache,
           ...resolvedFragmentTextTarget ? { textTarget: resolvedFragmentTextTarget } : {}
@@ -57631,9 +58242,9 @@ function createDocumentRuntime(options) {
         emitError(toRuntimeError(error));
       }
     },
-    applyFormattingOperation(operation) {
+    applyFormattingOperation(operation2) {
       try {
-        const commandName = getFormattingOperationCommandName(operation);
+        const commandName = getFormattingOperationCommandName(operation2);
         const snapshot = cachedRenderSnapshot;
         if (!snapshot.isReady || snapshot.readOnly || snapshot.fatalError) {
           return;
@@ -57661,11 +58272,11 @@ function createDocumentRuntime(options) {
         };
         const suggesting = workflowCoordinator.getEffectiveDocumentMode(state.selection) === "suggesting";
         const timestamp = clock();
-        if (snapshot.selection.isCollapsed && operation.type !== "set-alignment" && operation.type !== "indent" && operation.type !== "outdent") {
+        if (snapshot.selection.isCollapsed && operation2.type !== "set-alignment" && operation2.type !== "indent" && operation2.type !== "outdent") {
           const storyKey2 = storyTargetKey(activeStory);
           const nextMarks = updatePendingInsertionMarks(
             pendingInsertionMarksByStory.get(storyKey2)?.marks ?? marksFromFormattingState(getFormattingStateFromRenderSnapshot(snapshot)),
-            operation
+            operation2
           );
           if (nextMarks && nextMarks.length > 0) {
             pendingInsertionMarksByStory.set(storyKey2, {
@@ -57680,7 +58291,7 @@ function createDocumentRuntime(options) {
           return;
         }
         if (suggesting) {
-          if (operation.type === "set-alignment" || operation.type === "indent" || operation.type === "outdent") {
+          if (operation2.type === "set-alignment" || operation2.type === "indent" || operation2.type === "outdent") {
             const paragraphContext = resolveActiveParagraphContext(localSnapshot);
             if (!paragraphContext) {
               return;
@@ -57689,7 +58300,7 @@ function createDocumentRuntime(options) {
             const result3 = applyFormattingOperationToDocument(
               localDocument,
               localSnapshot,
-              operation
+              operation2
             );
             if (!result3.changed) {
               return;
@@ -57736,7 +58347,7 @@ function createDocumentRuntime(options) {
           const result2 = applyFormattingOperationToDocument(
             localDocument,
             localSnapshot,
-            operation
+            operation2
           );
           if (!result2.changed) {
             return;
@@ -57771,7 +58382,7 @@ function createDocumentRuntime(options) {
         const result = applyFormattingOperationToDocument(
           localDocument,
           localSnapshot,
-          operation
+          operation2
         );
         if (!result.changed) {
           return;
@@ -58018,7 +58629,7 @@ function createDocumentRuntime(options) {
         if (step.kind !== "formatting-apply" || !step.range || !step.formattingAction) {
           continue;
         }
-        const operation = step.formattingAction.kind === "clear-mark" ? {
+        const operation2 = step.formattingAction.kind === "clear-mark" ? {
           type: "clear-mark",
           mark: step.formattingAction.mark,
           ...step.formattingAction.expandToFullHighlight === true ? { expandToFullHighlight: true } : {}
@@ -58029,7 +58640,7 @@ function createDocumentRuntime(options) {
         const result = applyTextMarkOperationToDocumentRange(
           state.document,
           step.range,
-          operation
+          operation2
         );
         if (!result.changed) {
           continue;
@@ -59534,7 +60145,8 @@ function createDocumentRuntime(options) {
       applyViewportRanges(getSelectionCorridorViewportRanges(cachedRenderSnapshot.surface));
     }
     const tValidation0 = performance.now();
-    const patchedFullLocalTextSurface = useLocalTextCommitSnapshot ? tryPatchLocalTextSurface(cachedRenderSnapshot.surface, transaction.mapping) : null;
+    const patchSourceSurface = getReusableCachedFullSurface(previous.document, activeStory) ?? cachedRenderSnapshot.surface;
+    const patchedFullLocalTextSurface = useLocalTextCommitSnapshot ? tryPatchLocalTextSurface(patchSourceSurface, transaction.mapping) : null;
     const patchedLocalTextSurface = patchedFullLocalTextSurface ? createLocalTextCorridorSurfaceFromFullSurface(patchedFullLocalTextSurface) : null;
     if (patchedLocalTextSurface) {
       cachePatchedLocalTextSurface(
@@ -59878,11 +60490,14 @@ function createDocumentRuntime(options) {
     }
     const listBoundaryDeleteUsesStoryText = targetResolution?.kind === "accepted" && editableTarget?.listAddress?.operationScope === "list-text" && isTopLevelMainStoryBlockPath(editableTarget.blockPath) && selection.isCollapsed && (commandForDispatch.type === "text.delete-backward" && selection.anchor === targetResolution.range.from || commandForDispatch.type === "text.delete-forward" && selection.anchor === targetResolution.range.to);
     const textTarget = targetResolution?.kind === "accepted" && !listBoundaryDeleteUsesStoryText ? targetResolution.textTarget : legacyTextTarget;
+    const fullScopeSurface = cachedFullSurface?.snapshot;
     const context = {
       timestamp,
       documentMode: textOptions.documentModeOverride ?? workflowCoordinator.getEffectiveDocumentMode(selection),
       defaultAuthorId: defaultAuthorId ?? void 0,
       renderSnapshot: cachedRenderSnapshot,
+      surfaceTelemetry: scopeSurfaceTelemetry,
+      ...fullScopeSurface ? { precomputedSurface: fullScopeSurface } : {},
       activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
       editableTargetCache: editableTargetBlockCache,
       activeStorySize: cachedRenderSnapshot.surface?.storySize,
@@ -60208,6 +60823,7 @@ function createDocumentRuntime(options) {
         documentMode: workflowCoordinator.getEffectiveDocumentMode(state.selection),
         defaultAuthorId: defaultAuthorId ?? void 0,
         renderSnapshot: cachedRenderSnapshot,
+        surfaceTelemetry: scopeSurfaceTelemetry,
         activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
         editableTargetCache: editableTargetBlockCache
       };
@@ -60612,22 +61228,22 @@ function marksFromFormattingState(formatting) {
   }
   return marks;
 }
-function updatePendingInsertionMarks(currentMarks, operation) {
-  switch (operation.type) {
+function updatePendingInsertionMarks(currentMarks, operation2) {
+  switch (operation2.type) {
     case "toggle":
-      return togglePendingMark(currentMarks, operation.mark);
+      return togglePendingMark(currentMarks, operation2.mark);
     case "set-font-family":
-      return setPendingMarkValue(currentMarks, "fontFamily", operation.fontFamily?.trim() || null);
+      return setPendingMarkValue(currentMarks, "fontFamily", operation2.fontFamily?.trim() || null);
     case "set-font-size":
       return setPendingMarkValue(
         currentMarks,
         "fontSize",
-        typeof operation.size === "number" && Number.isFinite(operation.size) ? Math.round(operation.size * 2) : null
+        typeof operation2.size === "number" && Number.isFinite(operation2.size) ? Math.round(operation2.size * 2) : null
       );
     case "set-text-color":
-      return setPendingMarkValue(currentMarks, "textColor", normalizePendingColor(operation.color));
+      return setPendingMarkValue(currentMarks, "textColor", normalizePendingColor(operation2.color));
     case "set-highlight-color":
-      return setPendingMarkValue(currentMarks, "backgroundColor", normalizePendingColor(operation.color));
+      return setPendingMarkValue(currentMarks, "backgroundColor", normalizePendingColor(operation2.color));
   }
 }
 function togglePendingMark(marks, mark) {
@@ -62790,10 +63406,10 @@ function toInternalSelectionSnapshot2(selection) {
     )
   };
 }
-function getFormattingOperationCommandName(operation) {
-  switch (operation.type) {
+function getFormattingOperationCommandName(operation2) {
+  switch (operation2.type) {
     case "toggle":
-      return `toggle${operation.mark.charAt(0).toUpperCase()}${operation.mark.slice(1)}`;
+      return `toggle${operation2.mark.charAt(0).toUpperCase()}${operation2.mark.slice(1)}`;
     case "set-font-family":
       return "setFontFamily";
     case "set-font-size":