@beyondwork/docx-react-component 1.0.133 → 1.0.134

package/dist/runtime/document-runtime.cjs

@@ -18846,9 +18846,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",
@@ -18856,7 +18858,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,
@@ -18911,6 +18913,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 {
@@ -21294,6 +21299,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(
         {
@@ -22539,7 +22549,7 @@ function applyTextCommand(state, timestamp, apply) {
   const reviewState = remapReviewStateAfterContentChange(
     state,
     result.document,
-    result.mapping
+    result.mapping ?? createEmptyMapping()
   );
   const scopeTagTouches = collectScopeTagTouches(
     state.document.review.comments,
@@ -22879,6 +22889,38 @@ function isSingleParagraphSuggestingRange(document2, from, to) {
   );
   return ranges.some((range) => from >= range.start && to <= range.end);
 }
+function isTextOnlySuggestingRange(document2, from, to) {
+  const story = parseTextStory(document2.content);
+  const range = normalizeTextStoryRange(story, from, to);
+  if (!range) {
+    return isSingleParagraphSuggestingRange(document2, from, to);
+  }
+  const rootStoryTextOnly = story.units.slice(range.from, range.to).every(isSuggestingTextReplacementUnit);
+  if (rootStoryTextOnly) return true;
+  return isSingleParagraphSuggestingRange(document2, 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) {
@@ -22951,10 +22993,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) {
@@ -23063,7 +23105,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,
@@ -23128,6 +23170,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,
@@ -23139,6 +23306,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 });
@@ -23148,10 +23319,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;
@@ -35534,11 +35705,9 @@ function compileParagraphReplacement(entry, proposed, options) {
     };
   }
   if (proposed.proposedContent.kind === "structured") {
-    if (options.posture === "suggest-mode") {
-      return null;
-    }
     const fragment = proposed.proposedContent.structured;
     if (!isStructuredReplacementContent(fragment)) return null;
+    const stepKind = options.posture === "suggest-mode" ? "fragment-replace-tracked" : "fragment-replace";
     const blockCount = fragment.blocks.length;
     const summaryScope = rangeKind === "inline-marker" ? `paragraph #${entry.blockIndex} inline-marker range [${effectiveRange.from}..${effectiveRange.to}]` : rangeKind === "opaque-preserving-text" ? `paragraph #${entry.blockIndex} opaque-preserving text range [${effectiveRange.from}..${effectiveRange.to}]` : `paragraph #${entry.blockIndex}`;
     const actionVerb = proposed.operation === "insert-before" ? "insert before" : proposed.operation === "insert-after" ? "insert after" : "replace";
@@ -35549,8 +35718,8 @@ function compileParagraphReplacement(entry, proposed, options) {
       operation: proposed.operation,
       steps: Object.freeze([
         {
-          kind: "fragment-replace",
-          summary: actionSummary,
+          kind: stepKind,
+          summary: stepKind === "fragment-replace" ? actionSummary : `suggest-mode ${actionSummary}`,
           ...textLeafEditableTargetHint(entry, blockRange) ? { editableTargetHint: textLeafEditableTargetHint(entry, blockRange) } : {},
           range: { from: operationRange.from, to: operationRange.to },
           fragment
@@ -35637,7 +35806,7 @@ function compileScopeKind(entry, options) {
   };
 }
 function compileScopeReplacement(entry, proposed, options) {
-  if (entry.handle.provenance !== "marker-backed" || proposed.operation !== "replace" || options.posture !== "direct-edit") {
+  if (entry.handle.provenance !== "marker-backed" || proposed.operation !== "replace") {
     return null;
   }
   const markerRange = buildScopePositionMap(options.document).markerScopes.get(
@@ -35646,14 +35815,15 @@ function compileScopeReplacement(entry, proposed, options) {
   if (!markerRange) return null;
   if (proposed.proposedContent.kind === "text") {
     const text = proposed.proposedContent.text ?? "";
+    const stepKind = options.posture === "suggest-mode" ? "text-insert-tracked" : "text-replace";
     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})`,
+          kind: stepKind,
+          summary: stepKind === "text-replace" ? `replace multi-paragraph scope ${entry.handle.scopeId} text [${markerRange.from}..${markerRange.to}] (len ${text.length})` : `suggest-mode 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 } : {}
@@ -35666,14 +35836,15 @@ function compileScopeReplacement(entry, proposed, options) {
   if (proposed.proposedContent.kind === "structured") {
     const fragment = proposed.proposedContent.structured;
     if (!isStructuredReplacementContent(fragment)) return null;
+    const stepKind = options.posture === "suggest-mode" ? "fragment-replace-tracked" : "fragment-replace";
     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))`,
+          kind: stepKind,
+          summary: stepKind === "fragment-replace" ? `replace multi-paragraph scope ${entry.handle.scopeId} with structured fragment [${markerRange.from}..${markerRange.to}] (${fragment.blocks.length} block(s))` : `suggest-mode 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
         }
@@ -36055,6 +36226,99 @@ function paragraphFirstMarkerStart(paragraph, knownScopeIds) {
   }
   return null;
 }
+function paragraphHasMarkerEnd(paragraph, scopeId) {
+  return paragraph.children.some(
+    (child) => child.type === "scope_marker_end" && child.scopeId === scopeId
+  );
+}
+function paragraphSameParagraphMarkerScopeId(paragraph, knownScopeIds) {
+  const markerScopeId = paragraphFirstMarkerStart(paragraph, knownScopeIds);
+  if (!markerScopeId) return null;
+  return paragraphHasMarkerEnd(paragraph, markerScopeId) ? markerScopeId : null;
+}
+function markerStableRefOverride(markerScopeId, semanticPath, overlay) {
+  const hint = stableRefHintForScopeId(markerScopeId, overlay);
+  if (hint === "semantic-path") {
+    return {
+      kind: "semantic-path",
+      value: semanticPath.join("/")
+    };
+  }
+  return { kind: "scope-id", value: markerScopeId };
+}
+function enumerateNestedMarkerBackedParagraphs(blocks, input) {
+  const out = [];
+  for (let childIndex = 0; childIndex < blocks.length; childIndex += 1) {
+    const block = blocks[childIndex];
+    if (!block) continue;
+    if (block.type === "paragraph") {
+      const markerScopeId = paragraphSameParagraphMarkerScopeId(
+        block,
+        input.knownOverlayScopeIds
+      );
+      if (!markerScopeId) continue;
+      const kind = detectParagraphKind(block);
+      const semanticPath = [
+        ...input.semanticPrefix,
+        kind,
+        String(childIndex)
+      ];
+      const handle = buildHandle(
+        markerScopeId,
+        input.documentId,
+        semanticPath,
+        "marker-backed",
+        "marker-backed",
+        input.parentScopeId,
+        markerStableRefOverride(markerScopeId, semanticPath, input.overlay)
+      );
+      out.push({
+        kind,
+        handle,
+        paragraph: block,
+        blockIndex: input.rootBlockIndex,
+        classifications: input.classificationIndex.get(markerScopeId) ?? Object.freeze([])
+      });
+      continue;
+    }
+    if (block.type === "sdt") {
+      out.push(
+        ...enumerateNestedMarkerBackedParagraphs(block.children, {
+          ...input,
+          semanticPrefix: [
+            ...input.semanticPrefix,
+            "sdt",
+            String(childIndex)
+          ]
+        })
+      );
+      continue;
+    }
+    if (block.type === "table") {
+      for (let rowIdx = 0; rowIdx < block.rows.length; rowIdx += 1) {
+        const row2 = block.rows[rowIdx];
+        for (let cellIdx = 0; cellIdx < row2.cells.length; cellIdx += 1) {
+          const cell = row2.cells[cellIdx];
+          out.push(
+            ...enumerateNestedMarkerBackedParagraphs(cell.children, {
+              ...input,
+              semanticPrefix: [
+                ...input.semanticPrefix,
+                "table",
+                String(childIndex),
+                "row",
+                String(rowIdx),
+                "cell",
+                String(cellIdx)
+              ]
+            })
+          );
+        }
+      }
+    }
+  }
+  return out;
+}
 function enumerateFieldsInParagraph(paragraph, blockIndex, documentId, parentScopeId) {
   const out = [];
   for (let i = 0; i < paragraph.children.length; i += 1) {
@@ -36337,6 +36601,17 @@ function enumerateScopes(document2, inputs = {}) {
             cellIndex: cellIdx,
             classifications: Object.freeze([])
           });
+          for (const nested of enumerateNestedMarkerBackedParagraphs(cell.children, {
+            documentId,
+            rootBlockIndex: index,
+            semanticPrefix: cellSemanticPath,
+            parentScopeId: cellScopeId,
+            knownOverlayScopeIds,
+            classificationIndex,
+            overlay: inputs.overlay
+          })) {
+            results.push(nested);
+          }
         }
       }
     }
@@ -36822,16 +37097,12 @@ function replaceTextCapability(scope, context) {
     );
   }
   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)
+      [
+        ...scope.workflow.effectiveMode === "suggest" ? ["guard:suggest-mode"] : [],
+        ...evidenceWarnings(context)
+      ]
     );
   }
   if (!PARAGRAPH_LIKE.has(scope.kind)) {
@@ -36885,34 +37156,24 @@ function replaceFragmentCapability(scope, context) {
     );
   }
   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)
+      [
+        ...scope.workflow.effectiveMode === "suggest" ? ["guard:suggest-mode"] : [],
+        ...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`,
-      [`compile-refused:${scope.kind}:structured-suggesting-not-implemented`],
-      ["guard:suggest-mode"]
-    );
-  }
   return supported(
-    "compile-supported:paragraph-like:fragment-replace",
-    evidenceWarnings(context)
+    scope.workflow.effectiveMode === "suggest" ? "compile-supported:paragraph-like:fragment-replace-tracked" : "compile-supported:paragraph-like:fragment-replace",
+    [
+      ...scope.workflow.effectiveMode === "suggest" ? ["guard:suggest-mode"] : [],
+      ...evidenceWarnings(context)
+    ]
   );
 }
 function formattingCapability(scope, context) {
@@ -37966,6 +38227,14 @@ function supportedNonTextCommandEvidence(target) {
   if (target.commandFamily === "link-bookmark") {
     return linkBookmarkCommandEvidence(target, []);
   }
+  if (target.commandFamily === "object" && isImageObjectTarget(target) && typeof target.object?.mediaId === "string" && target.object.mediaId.length > 0 && onlyBlockers(target.posture.blockers, ["unmodeled-target"])) {
+    return {
+      status: "supported",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: "l07:image-layout-target-supported"
+    };
+  }
   return null;
 }
 function onlyBlockers(blockers, allowed) {
@@ -40466,9 +40735,7 @@ function applyScopeReplacement(inputs) {
   });
   if (!plan) {
     const paragraphLike = resolvedScope.kind === "paragraph" || resolvedScope.kind === "heading" || resolvedScope.kind === "list-item";
-    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" ? [
+    const blockers = resolvedScope.kind === "scope" && proposed.operation !== "replace" ? [
       `compile-refused:scope:operation-not-implemented:${proposed.operation}`
     ] : resolvedScope.kind === "scope" ? multiParagraphReplacementBlockers(
       proposed.proposedContent.kind === "structured" ? "fragment" : "text"
@@ -41904,7 +42171,8 @@ function buildResolvedSections(document2) {
   const mainSurface = createEditorSurfaceSnapshot(
     document2,
     createSelectionSnapshot(0, 0),
-    MAIN_STORY_TARGET
+    MAIN_STORY_TARGET,
+    { editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX }
   );
   const sections = [];
   let sectionStart = 0;
@@ -57965,7 +58233,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,
@@ -58109,7 +58390,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,
@@ -58530,6 +58824,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) {
@@ -60512,6 +60850,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);
@@ -61706,7 +62076,8 @@ function getStoryPlainText(document2, storyTarget, cache) {
   const plainText = createEditorSurfaceSnapshot(
     document2,
     createSelectionSnapshot(0, 0),
-    storyTarget
+    storyTarget,
+    { editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX }
   ).plainText;
   cache.set(key, plainText);
   return plainText;
@@ -63391,6 +63762,172 @@ function stripStoryTarget(selection) {
 function isTopLevelMainStoryBlockPath(blockPath) {
   return typeof blockPath === "string" && /^main\/block\[\d+\]$/u.test(blockPath);
 }
+function createSelectedListItemDeleteReplacement(input) {
+  const { command, document: document2, 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 = document2.content;
+  const replacement = removeNumberedParagraphAtMainStoryPath(root.children, editableTarget.blockPath);
+  if (!replacement) {
+    return null;
+  }
+  const nextDocument = {
+    ...document2,
+    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: document2, 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: document2,
+    selection,
+    surface,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
+  });
+  const replacement = createSelectedListItemDeleteReplacement({
+    command,
+    document: document2,
+    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 toInternalSelectionSnapshot2(selection) {
   return {
     anchor: selection.anchor,