@beyondwork/docx-react-component 1.0.132 → 1.0.134

package/dist/{chunk-43JAPM2F.js → chunk-EBSI6VQX.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-M6XR534O.js";
 import {
   buildBookmarkNameMap
-} from "./chunk-ZDYGRO2Z.js";
+} from "./chunk-RP76USJE.js";
 import {
   deleteSelectionOrBackward,
   deleteSelectionOrForward,
@@ -22,7 +22,7 @@ import {
   insertText,
   outdentParagraphAtSelection,
   splitParagraph
-} from "./chunk-SZ6BJA4Q.js";
+} from "./chunk-REFHJ2FN.js";
 import {
   applyFormattingOperationToDocument,
   applyTextMarkOperationToDocumentRange,
@@ -32,29 +32,30 @@ import {
   insertImage,
   repositionFloatingImage,
   resizeImage
-} from "./chunk-UFPBYJMA.js";
+} from "./chunk-INLRCC4N.js";
 import {
   applyTextTransaction
-} from "./chunk-N5FTU4HZ.js";
+} from "./chunk-MQ5GAJ54.js";
 import {
   applyTableStructureOperationForEditableTarget,
   removeCellFromRow,
   removeTableRowPure
-} from "./chunk-6TLZ6CMP.js";
+} from "./chunk-WDDFU2N2.js";
 import {
   resolveParagraphScope
-} from "./chunk-C5LXKR54.js";
+} from "./chunk-QTRJLKR2.js";
 import {
   buildGeometryDebugEntry,
   collectLineBoxesForRegion,
   createGeometryFacet
-} from "./chunk-UP2KDOYE.js";
+} from "./chunk-74R5B2EZ.js";
 import {
   AI_ACTION_POLICIES,
   allocateNumberingInstance,
   buildFormattingDebugEntry,
   cloneNumberingCatalog,
   collectScopeLocations,
+  computeScopeStoryLayout,
   createDocumentOutlineSnapshot,
   createDocumentSectionSnapshots,
   createScopeCompilerService,
@@ -64,19 +65,25 @@ import {
   findAllScopesAt,
   findBookmarkNameForOffset,
   findDocumentSectionSnapshot,
+  findOwningBlockSlotAtPosition,
+  findParagraphSlotAtPosition,
   findScopesIntersecting,
   findTextMatches,
   findTextWithStyleMatches,
   getListKind,
+  inlineLengthForScopeCoordinates,
   rebuildFieldRegistry,
+  removeScopeMarkersFromBlockList,
+  replaceParagraphChildrenAtPath,
   resolveEditableCommandTarget,
   resolveEditableTableStructureTarget,
   resolveEditableTextTarget,
   resolveHeadingPath,
   resolveScope,
+  sameScopeParagraphPath,
   serializeFragmentToWordML,
   setStartOverride
-} from "./chunk-XYTWOJII.js";
+} from "./chunk-IJD6D7HU.js";
 import {
   ISSUE_METADATA_ID,
   LAYOUT_ENGINE_VERSION,
@@ -114,7 +121,7 @@ import {
   setWorkspaceMode,
   setZoomLevel,
   snapCommentAnchorAwayFromTable
-} from "./chunk-LPLJZJT2.js";
+} from "./chunk-O4EDZR44.js";
 import {
   countLogicalPositions,
   createPlainText,
@@ -123,6 +130,7 @@ import {
   serializeTextStory
 } from "./chunk-QIO6V46H.js";
 import {
+  NO_EDITABLE_TARGETS_INDEX,
   ThemeColorResolver,
   createEditorSurfaceSnapshot,
   createFieldResolver,
@@ -133,7 +141,7 @@ import {
   replaceStoryBlocks,
   resolvePageFieldDisplayText,
   storyTargetKey
-} from "./chunk-U3UMKA7B.js";
+} from "./chunk-XBQFDBXE.js";
 import {
   createCommentSidebarProjection,
   createCommentStoreFromRuntimeComments
@@ -157,12 +165,12 @@ import {
   persistedSnapshotFromEditorSessionState,
   remapRevisionStore,
   setRevisionStatus
-} from "./chunk-4HGFJ6Z2.js";
+} from "./chunk-PZIEOEJZ.js";
 import {
   isSupportedFieldFamily,
   parseTocLevelRange,
   resolveRefFieldText
-} from "./chunk-RBWJHRNP.js";
+} from "./chunk-T66OS7MN.js";
 import {
   collectEditableTargetRefs,
   collectEditableTargetRefsForStoryBlockRanges,
@@ -171,7 +179,7 @@ import {
   createHeaderFooterStoryKey,
   sha256TextHex,
   validateEditableTargetRef
-} from "./chunk-RYMMKOFI.js";
+} from "./chunk-5KTJKTNE.js";
 import {
   setActiveSerializeTelemetryBus
 } from "./chunk-FM4K4XFJ.js";
@@ -521,9 +529,11 @@ function applyRevisionAction(options) {
     );
   }
   const slice = story.units.slice(range.from, range.to);
-  if (slice.some(
-    (unit) => unit.kind === "paragraph_break" || unit.kind === "opaque_block" || unit.kind === "structural_block"
-  )) {
+  const touchesStructuralContent = slice.some(
+    (unit) => unit.kind === "opaque_block" || unit.kind === "structural_block"
+  );
+  const touchesParagraphBoundary = slice.some((unit) => unit.kind === "paragraph_break");
+  if (touchesStructuralContent || touchesParagraphBoundary && !canApplyRuntimeTextBlockDeletion(revision, options.intent)) {
     return skippedResult(
       options,
       "structural-range",
@@ -531,7 +541,7 @@ function applyRevisionAction(options) {
     );
   }
   if (slice.some(
-    (unit) => unit.kind === "image" || unit.kind === "opaque_inline"
+    (unit) => unit.kind === "image" || unit.kind === "opaque_inline" || unit.kind === "protected_inline"
   )) {
     return skippedResult(
       options,
@@ -586,6 +596,9 @@ function applyRevisionAction(options) {
     detachedRevisionIds: findNewDetachedRevisionIds(options.store, nextStore)
   };
 }
+function canApplyRuntimeTextBlockDeletion(revision, intent) {
+  return revision.metadata.source === "runtime" && (intent === "accept" && revision.kind === "deletion" && (revision.metadata.semanticKind === "replacement" || revision.metadata.semanticKind === "deletion") || intent === "reject" && revision.kind === "insertion" && (revision.metadata.semanticKind === "replacement" || revision.metadata.semanticKind === "structural-change"));
+}
 function applyPairedMoveAction(options, revision) {
   const resultingStatus = toResultingStatus(options.intent);
   return {
@@ -2022,13 +2035,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 {
@@ -2227,6 +2241,11 @@ function executeEditorCommand(state, command, context) {
       );
       return buildDocumentReplaceTransaction(state, context, result);
     }
+    case "fragment.insert-tracked": {
+      const result = applySuggestingFragmentInsert(state, command.fragment, context);
+      if (result) return result;
+      return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+    }
     case "runtime.set-read-only":
       return createTransaction(
         {
@@ -3472,7 +3491,7 @@ function applyTextCommand(state, timestamp, apply) {
   const reviewState = remapReviewStateAfterContentChange(
     state,
     result.document,
-    result.mapping
+    result.mapping ?? createEmptyMapping()
   );
   const scopeTagTouches = collectScopeTagTouches(
     state.document.review.comments,
@@ -3812,6 +3831,38 @@ function isSingleParagraphSuggestingRange(document, from, to) {
   );
   return ranges.some((range) => from >= range.start && to <= range.end);
 }
+function isTextOnlySuggestingRange(document, from, to) {
+  const story = parseTextStory(document.content);
+  const range = normalizeTextStoryRange(story, from, to);
+  if (!range) {
+    return isSingleParagraphSuggestingRange(document, from, to);
+  }
+  const rootStoryTextOnly = story.units.slice(range.from, range.to).every(isSuggestingTextReplacementUnit);
+  if (rootStoryTextOnly) return true;
+  return isSingleParagraphSuggestingRange(document, from, to);
+}
+function normalizeTextStoryRange(story, from, to) {
+  const start = Math.min(from, to);
+  const end = Math.max(from, to);
+  if (start < 0 || end > story.size) return null;
+  return { from: start, to: end };
+}
+function isSuggestingTextReplacementUnit(unit) {
+  switch (unit.kind) {
+    case "text":
+    case "tab":
+    case "hard_break":
+    case "paragraph_break":
+    case "scope_marker":
+      return true;
+    case "protected_inline":
+    case "image":
+    case "opaque_inline":
+    case "opaque_block":
+    case "structural_block":
+      return false;
+  }
+}
 function collectSuggestingParagraphRanges(blocks, startCursor, output, addRootParagraphBoundaries) {
   let cursor = startCursor;
   for (let index = 0; index < blocks.length; index += 1) {
@@ -3884,10 +3935,10 @@ function applySuggestingInsert(state, text, context, formatting) {
   const from = Math.min(selection.anchor, selection.head);
   const to = Math.max(selection.anchor, selection.head);
   const isCollapsed = from === to;
-  if (!isCollapsed && !isSingleParagraphSuggestingRange(state.document, from, to)) {
+  if (!isCollapsed && !isTextOnlySuggestingRange(state.document, from, to)) {
     return createSuggestingUnsupportedTransaction(
       state,
-      "Suggesting mode does not yet support multi-paragraph replacement ranges."
+      "Suggesting mode text replacement ranges must contain only editable text and paragraph breaks."
     );
   }
   if (isCollapsed) {
@@ -3996,7 +4047,7 @@ function applySuggestingInsert(state, text, context, formatting) {
   const reviewState = remapReviewStateAfterContentChange(
     state,
     result.document,
-    result.mapping
+    result.mapping ?? createEmptyMapping()
   );
   const replacementSuggestionId = createSuggestingRevisionId(
     reviewState.document.review.revisions,
@@ -4061,6 +4112,131 @@ function applySuggestingInsert(state, text, context, formatting) {
         activeCommentId: reviewState.activeCommentId
       }
     },
+    {
+      historyBoundary: "push",
+      markDirty: true,
+      mapping: result.mapping ?? createEmptyMapping(),
+      effects: {
+        ...reviewState.effects,
+        revisionAuthored: { changeId: insertionRevision.changeId, kind: "insertion" }
+      }
+    }
+  );
+}
+function applySuggestingFragmentInsert(state, fragment, context) {
+  if (state.readOnly) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+  if (fragment.blocks.length === 0) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+  if (!isTrackableSuggestingFragment(fragment)) {
+    return createSuggestingUnsupportedTransaction(
+      state,
+      "Suggesting mode structured fragment replacement supports paragraph/text fragments only."
+    );
+  }
+  const authorId = context.defaultAuthorId ?? "unknown";
+  const selection = state.selection;
+  const from = Math.min(selection.anchor, selection.head);
+  const to = Math.max(selection.anchor, selection.head);
+  const isCollapsed = from === to;
+  if (!isCollapsed && !isTextOnlySuggestingRange(state.document, from, to)) {
+    return createSuggestingUnsupportedTransaction(
+      state,
+      "Suggesting mode structured fragment replacement ranges must contain only editable text and paragraph breaks."
+    );
+  }
+  const storyBefore = parseTextStory(state.document.content);
+  const insertSelection = createSelectionSnapshot(to, to);
+  const result = structureLayer.applyFragmentInsert(
+    state.document,
+    insertSelection,
+    fragment,
+    context
+  );
+  if (!result.changed) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+  const storyAfter = parseTextStory(result.document.content);
+  const insertedFrom = to;
+  const insertedTo = to + Math.max(0, storyAfter.size - storyBefore.size);
+  if (insertedTo <= insertedFrom) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+  const reviewState = remapReviewStateAfterContentChange(
+    state,
+    result.document,
+    result.mapping ?? createEmptyMapping()
+  );
+  const replacementSuggestionId = !isCollapsed ? createSuggestingRevisionId(
+    reviewState.document.review.revisions,
+    context.timestamp,
+    authorId
+  ) : void 0;
+  let deletionRevision = !isCollapsed ? createAuthoredRevision(
+    reviewState.document.review.revisions,
+    "deletion",
+    from,
+    to,
+    authorId,
+    context.timestamp,
+    createSuggestionMetadata({
+      suggestionId: replacementSuggestionId,
+      semanticKind: "replacement"
+    })
+  ) : void 0;
+  const insertionRevision = createAuthoredRevision(
+    {
+      ...reviewState.document.review.revisions,
+      ...deletionRevision ? { [deletionRevision.changeId]: deletionRevision } : {}
+    },
+    "insertion",
+    insertedFrom,
+    insertedTo,
+    authorId,
+    context.timestamp,
+    createSuggestionMetadata(
+      deletionRevision ? {
+        suggestionId: replacementSuggestionId,
+        semanticKind: "replacement",
+        linkedRevisionIds: [deletionRevision.changeId]
+      } : {
+        semanticKind: "structural-change"
+      }
+    )
+  );
+  if (deletionRevision) {
+    deletionRevision = {
+      ...deletionRevision,
+      metadata: {
+        ...deletionRevision.metadata,
+        linkedRevisionIds: [insertionRevision.changeId]
+      }
+    };
+  }
+  const finalDocument = {
+    ...reviewState.document,
+    review: {
+      ...reviewState.document.review,
+      revisions: {
+        ...reviewState.document.review.revisions,
+        ...deletionRevision ? { [deletionRevision.changeId]: deletionRevision } : {},
+        [insertionRevision.changeId]: insertionRevision
+      }
+    }
+  };
+  return createTransaction(
+    {
+      ...state,
+      document: finalDocument,
+      selection: createSelectionSnapshot(insertedTo, insertedTo),
+      warnings: reviewState.warnings,
+      runtime: {
+        ...state.runtime,
+        activeCommentId: reviewState.activeCommentId
+      }
+    },
     {
       historyBoundary: "push",
       markDirty: true,
@@ -4072,6 +4248,10 @@ function applySuggestingInsert(state, text, context, formatting) {
     }
   );
 }
+function isTrackableSuggestingFragment(fragment) {
+  const story = parseTextStory({ type: "doc", children: fragment.blocks });
+  return story.units.every(isSuggestingTextReplacementUnit);
+}
 function applySuggestingDelete(state, direction, context) {
   if (state.readOnly) {
     return createTransaction(state, { historyBoundary: "skip", markDirty: false });
@@ -4081,10 +4261,10 @@ function applySuggestingDelete(state, direction, context) {
   const from = Math.min(selection.anchor, selection.head);
   const to = Math.max(selection.anchor, selection.head);
   const isCollapsed = from === to;
-  if (!isCollapsed && !isSingleParagraphSuggestingRange(state.document, from, to)) {
+  if (!isCollapsed && !isTextOnlySuggestingRange(state.document, from, to)) {
     return createSuggestingUnsupportedTransaction(
       state,
-      "Suggesting mode does not yet support multi-paragraph deletion ranges."
+      "Suggesting mode text deletion ranges must contain only editable text and paragraph breaks."
     );
   }
   let deleteFrom;
@@ -7232,39 +7412,8 @@ function insertScopeMarkers(document, 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 + inlineLength(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(document);
+  const storyLength = layout.storyLength;
   if (normalizedFrom < 0 || normalizedTo > storyLength) {
     return {
       status: "range-out-of-bounds",
@@ -7274,73 +7423,71 @@ function insertScopeMarkers(document, 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: { ...document, content: { ...root, children: children2 } },
+      document: { ...document, 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: { ...document, content: { ...root, children } },
+    document: { ...document, content: rootWithBoth },
     scopeId,
     plantedRange: { from: normalizedFrom, to: normalizedTo }
   };
@@ -7348,43 +7495,15 @@ function insertScopeMarkers(document, params) {
 function removeScopeMarkers(document, scopeId) {
   const root = document.content;
   if (!root || root.type !== "doc") return document;
-  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 document;
+  const result = removeScopeMarkersFromBlockList(root.children, scopeId);
+  if (!result.mutated) return document;
   return {
     ...document,
-    content: { ...root, children }
+    content: { ...root, children: result.blocks }
   };
 }
 function inlineLength(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),
-        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 };
@@ -12592,6 +12711,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) {
@@ -13040,7 +13167,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,
@@ -14603,6 +14730,7 @@ function createDocumentRuntime(options) {
           documentMode: workflowCoordinator.getEffectiveDocumentMode(commandSelection),
           defaultAuthorId: defaultAuthorId ?? void 0,
           renderSnapshot: cachedRenderSnapshot,
+          surfaceTelemetry: scopeSurfaceTelemetry,
           activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
           editableTargetCache: editableTargetBlockCache,
           ...resolvedFragmentTextTarget ? { textTarget: resolvedFragmentTextTarget } : {}
@@ -14695,7 +14823,20 @@ function createDocumentRuntime(options) {
             selection: prepared.selection
           };
           resolvedReplayTextTarget = prepared.textTarget;
-        } else if (command.type === "field.refresh" || command.type === "toc.refresh" || command.type === "bookmark.edit-content" || command.type === "hyperlink.update-destination") {
+        } else {
+          const selectedListItemDeleteCommand = createSelectedListItemDeleteReplayCommand({
+            command,
+            document: replayState.document,
+            selection: replayState.selection,
+            surface: replaySnapshot.surface?.blocks ?? [],
+            storyTarget: replayStory,
+            timestamp: context.timestamp
+          });
+          if (selectedListItemDeleteCommand) {
+            executableCommand = selectedListItemDeleteCommand;
+          }
+        }
+        if (command.type === "field.refresh" || command.type === "toc.refresh" || command.type === "bookmark.edit-content" || command.type === "hyperlink.update-destination") {
           const prepared = prepareModeledTargetCommandForExecution(
             command,
             replayState.document,
@@ -14839,7 +14980,20 @@ function createDocumentRuntime(options) {
               selection: prepared.selection
             };
             resolvedReplayTextTarget = prepared.textTarget;
-          } else if (command.type === "field.refresh" || command.type === "toc.refresh" || command.type === "bookmark.edit-content" || command.type === "hyperlink.update-destination") {
+          } else {
+            const selectedListItemDeleteCommand = createSelectedListItemDeleteReplayCommand({
+              command,
+              document: stateForCommand.document,
+              selection: stateForCommand.selection,
+              surface: snapshotForCommand.surface?.blocks ?? [],
+              storyTarget: replayStory,
+              timestamp: context.timestamp
+            });
+            if (selectedListItemDeleteCommand) {
+              executableCommand = selectedListItemDeleteCommand;
+            }
+          }
+          if (command.type === "field.refresh" || command.type === "toc.refresh" || command.type === "bookmark.edit-content" || command.type === "hyperlink.update-destination") {
             const prepared = prepareModeledTargetCommandForExecution(
               command,
               stateForCommand.document,
@@ -15260,6 +15414,50 @@ function createDocumentRuntime(options) {
           } catch (error) {
             emitError(toRuntimeError(error));
           }
+        } else if (step.kind === "fragment-replace-tracked" && step.range && step.fragment && Array.isArray(step.fragment.blocks)) {
+          const editableTarget = resolveEditableTargetHint(step.editableTargetHint);
+          if (editableTarget === null) {
+            emit({
+              type: "command_blocked",
+              documentId: state.documentId,
+              command: "applyScopeReplacement",
+              reasons: [{
+                code: "unsupported_surface",
+                message: "Scope replacement editable target no longer resolves."
+              }]
+            });
+            continue;
+          }
+          const dispatchRange = mapSemanticStepRangeToEditableTarget(
+            step.range,
+            step.editableTargetHint,
+            editableTarget?.range
+          );
+          const anchor = {
+            kind: "range",
+            from: dispatchRange.from,
+            to: dispatchRange.to,
+            assoc: { start: -1, end: 1 }
+          };
+          const timestamp = clock();
+          try {
+            applyTextCommandInActiveStory(
+              {
+                type: "fragment.insert-tracked",
+                fragment: step.fragment,
+                ...editableTarget?.target ? { editableTarget: editableTarget.target } : {},
+                origin: createOrigin("api", timestamp)
+              },
+              {
+                selection: createSelectionFromPublicAnchor(anchor),
+                blockedCommandName: "applyScopeReplacement",
+                documentModeOverride: "suggesting",
+                skipWorkflowGuard: true
+              }
+            );
+          } catch (error) {
+            emitError(toRuntimeError(error));
+          }
         } else if (step.kind === "text-insert-tracked" && step.range && typeof step.text === "string") {
           const editableTarget = resolveEditableTargetHint(step.editableTargetHint);
           if (editableTarget === null) {
@@ -16875,7 +17073,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(
@@ -17219,11 +17418,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,
@@ -17238,6 +17440,38 @@ function createDocumentRuntime(options) {
     const preSelection = selection;
     const preActiveStory = activeStory;
     const priorDocument = state.document;
+    const selectedListItemDelete = createSelectedListItemDeleteReplacement({
+      command: commandForDispatch,
+      document: state.document,
+      editableTarget,
+      selection,
+      targetResolution,
+      timestamp
+    });
+    if (selectedListItemDelete && activeStory.kind === "main" && context.documentMode !== "suggesting") {
+      const replacementCommand = {
+        type: "document.replace",
+        document: selectedListItemDelete.document,
+        selection: selectedListItemDelete.selection,
+        mapping: selectedListItemDelete.mapping,
+        protectionSelection: selection,
+        origin: commandForDispatch.origin
+      };
+      const transaction = executeEditorCommand(baseState, replacementCommand, context);
+      commit(transaction);
+      options.onCommandApplied?.(commandForDispatch, transaction, context, {
+        preSelection,
+        activeStory: preActiveStory,
+        priorDocument
+      });
+      return completeDispatch(classifyAck({
+        command: commandForDispatch,
+        opId,
+        priorState: baseState,
+        transaction,
+        newRevisionToken: state.revisionToken
+      }));
+    }
     if (activeStory.kind === "main") {
       const mainTransaction = executeEditorCommand(baseState, commandForDispatch, context);
       commit(mainTransaction);
@@ -17549,6 +17783,7 @@ function createDocumentRuntime(options) {
         documentMode: workflowCoordinator.getEffectiveDocumentMode(state.selection),
         defaultAuthorId: defaultAuthorId ?? void 0,
         renderSnapshot: cachedRenderSnapshot,
+        surfaceTelemetry: scopeSurfaceTelemetry,
         activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
         editableTargetCache: editableTargetBlockCache
       };
@@ -18431,7 +18666,8 @@ function getStoryPlainText(document, storyTarget, cache) {
   const plainText = createEditorSurfaceSnapshot(
     document,
     createSelectionSnapshot(0, 0),
-    storyTarget
+    storyTarget,
+    { editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX }
   ).plainText;
   cache.set(key, plainText);
   return plainText;
@@ -20116,6 +20352,172 @@ function stripStoryTarget(selection) {
 function isTopLevelMainStoryBlockPath(blockPath) {
   return typeof blockPath === "string" && /^main\/block\[\d+\]$/u.test(blockPath);
 }
+function createSelectedListItemDeleteReplacement(input) {
+  const { command, document, editableTarget, selection, targetResolution, timestamp } = input;
+  if (command.type !== "text.delete-backward" && command.type !== "text.delete-forward") {
+    return null;
+  }
+  if (selection.isCollapsed || editableTarget?.listAddress?.operationScope !== "list-text" || targetResolution?.kind !== "accepted") {
+    return null;
+  }
+  const selectionFrom = Math.min(selection.anchor, selection.head);
+  const selectionTo = Math.max(selection.anchor, selection.head);
+  if (selectionFrom !== targetResolution.range.from || selectionTo !== targetResolution.range.to) {
+    return null;
+  }
+  const root = document.content;
+  const replacement = removeNumberedParagraphAtMainStoryPath(root.children, editableTarget.blockPath);
+  if (!replacement) {
+    return null;
+  }
+  const nextDocument = {
+    ...document,
+    updatedAt: timestamp,
+    content: {
+      ...root,
+      children: replacement.blocks
+    }
+  };
+  const nextStorySize = parseTextStory(nextDocument.content).size;
+  const nextAnchor = Math.min(selectionFrom, nextStorySize);
+  return {
+    document: nextDocument,
+    selection: createSelectionSnapshot(nextAnchor, nextAnchor),
+    mapping: {
+      steps: [{
+        from: selectionFrom,
+        to: selectionTo,
+        insertSize: 0
+      }],
+      metadata: {
+        invalidatesStructures: true
+      }
+    }
+  };
+}
+function removeNumberedParagraphAtMainStoryPath(blocks, blockPath) {
+  const tokens = parseMainStoryBlockPathTokens(blockPath);
+  if (!tokens) return null;
+  return removeNumberedParagraphFromBlocks(blocks, tokens);
+}
+function removeNumberedParagraphFromBlocks(blocks, tokens) {
+  const [token, ...rest] = tokens;
+  if (!token || token.kind !== "block") return null;
+  const block = blocks[token.index];
+  if (!block) return null;
+  if (rest.length === 0) {
+    if (block.type !== "paragraph" || !block.numbering) {
+      return null;
+    }
+    if (blocks.length === 1) {
+      return { blocks: [{ type: "paragraph", children: [] }] };
+    }
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  const next = rest[0];
+  if (block.type === "table" && next?.kind === "row") {
+    const updatedTable = removeNumberedParagraphFromTable(block, rest);
+    if (!updatedTable) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        updatedTable,
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  if ((block.type === "sdt" || block.type === "custom_xml") && next?.kind === "block") {
+    const updatedChildren = removeNumberedParagraphFromBlocks(block.children, rest);
+    if (!updatedChildren) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        { ...block, children: updatedChildren.blocks },
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  return null;
+}
+function removeNumberedParagraphFromTable(table, tokens) {
+  const [rowToken, cellToken, ...childTokens] = tokens;
+  if (rowToken?.kind !== "row" || cellToken?.kind !== "cell" || childTokens[0]?.kind !== "block") {
+    return null;
+  }
+  const row2 = table.rows[rowToken.index];
+  const cell = row2?.cells[cellToken.index];
+  if (!row2 || !cell) return null;
+  const updatedChildren = removeNumberedParagraphFromBlocks(cell.children, childTokens);
+  if (!updatedChildren) return null;
+  const nextCells = [
+    ...row2.cells.slice(0, cellToken.index),
+    { ...cell, children: updatedChildren.blocks },
+    ...row2.cells.slice(cellToken.index + 1)
+  ];
+  const nextRows = [
+    ...table.rows.slice(0, rowToken.index),
+    { ...row2, cells: nextCells },
+    ...table.rows.slice(rowToken.index + 1)
+  ];
+  return { ...table, rows: nextRows };
+}
+function createSelectedListItemDeleteReplayCommand(input) {
+  const { command, document, selection, surface, storyTarget, timestamp } = input;
+  if (command.type !== "text.delete-backward" && command.type !== "text.delete-forward") {
+    return null;
+  }
+  const editableTarget = command.editableTarget;
+  if (!editableTarget) {
+    return null;
+  }
+  const targetResolution = resolveEditableTextTarget({
+    document,
+    selection,
+    surface,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
+  });
+  const replacement = createSelectedListItemDeleteReplacement({
+    command,
+    document,
+    editableTarget,
+    selection,
+    targetResolution,
+    timestamp
+  });
+  if (!replacement || storyTarget.kind !== "main") {
+    return null;
+  }
+  return {
+    type: "document.replace",
+    document: replacement.document,
+    selection: replacement.selection,
+    mapping: replacement.mapping,
+    protectionSelection: selection,
+    origin: command.origin
+  };
+}
+function parseMainStoryBlockPathTokens(blockPath) {
+  const parts = blockPath?.split("/") ?? [];
+  if (parts[0] !== "main" || parts.length < 2) {
+    return null;
+  }
+  const tokens = [];
+  for (const part of parts.slice(1)) {
+    const match = /^(block|row|cell)\[(\d+)\]$/u.exec(part);
+    if (!match) return null;
+    tokens.push({
+      kind: match[1],
+      index: Number.parseInt(match[2], 10)
+    });
+  }
+  return tokens;
+}
 function toInternalSelectionSnapshot(selection) {
   return {
     anchor: selection.anchor,