@beyondwork/docx-react-component 1.0.133 → 1.0.135

package/dist/runtime/document-runtime.cjs

@@ -11011,10 +11011,16 @@ var FormattingContextImpl = class {
   // surface-projection calls `resolveParagraphCascade` on the same
   // paragraph via `resolveParagraph` + numbering resolve + marker-rPr;
   // each of those re-walked the style catalog before.
-  paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+  //
+  // Defaults to a per-context instance, but the runtime can supply a
+  // persistent `WeakMap` via `FormattingContextOptions.paragraphCascadeCache`
+  // so unchanged paragraphs don't re-cascade on every keystroke. See the
+  // contract on the option for invalidation semantics.
+  paragraphCascadeCache;
   constructor(doc, opts) {
     this.doc = doc;
     this.opts = opts;
+    this.paragraphCascadeCache = opts.paragraphCascadeCache ?? /* @__PURE__ */ new WeakMap();
     const canonicalTheme = doc.subParts?.canonicalTheme;
     this.theme = opts.themeResolver ?? (canonicalTheme ? new ThemeColorResolver(canonicalTheme) : void 0);
     this.numbering = opts.numberingPrefixResolver ?? createNumberingPrefixResolver(doc.numbering);
@@ -11580,7 +11586,8 @@ function createEditorSurfaceSnapshot(document2, _selection, activeStory = { kind
   const formattingContext = createFormattingContext(document2, {
     ...options.revisionMarkupMode ? { revisionMarkupMode: options.revisionMarkupMode } : {},
     ...options.getEffectiveMarkupMode ? { getEffectiveMarkupMode: options.getEffectiveMarkupMode } : {},
-    ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {}
+    ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {},
+    ...options.paragraphCascadeCache ? { paragraphCascadeCache: options.paragraphCascadeCache } : {}
   });
   const editableTargetsByBlockPath = options.editableTargetsByBlockPath ?? indexEditableTargetsByBlockPath(document2);
   const layoutIdentitiesByBlockPath = options.layoutIdentitiesByBlockPath;
@@ -18846,9 +18853,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 +18865,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 +18920,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 +21306,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 +22556,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 +22896,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 +23000,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 +23112,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 +23177,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 +23313,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 +23326,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 +35712,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 +35725,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 +35813,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 +35822,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 +35843,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 +36233,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 +36608,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 +37104,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 +37163,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 +38234,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 +40742,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"
@@ -41259,6 +41533,8 @@ function buildSearchPattern(query, options = {}) {
 function findSearchMatches(text, query, options = {}) {
   const pattern = buildSearchPattern(query, options);
   if (!pattern) return [];
+  const limit = normalizeSearchLimit(options.limit);
+  if (limit === 0) return [];
   const results = [];
   let match;
   pattern.lastIndex = 0;
@@ -41269,12 +41545,21 @@ function findSearchMatches(text, query, options = {}) {
       text: match[0],
       index: results.length
     });
+    if (results.length >= limit) {
+      break;
+    }
     if (match[0].length === 0) {
       pattern.lastIndex += 1;
     }
   }
   return results;
 }
+function normalizeSearchLimit(limit) {
+  if (limit === void 0 || !Number.isFinite(limit)) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return Math.max(0, Math.floor(limit));
+}
 function createSearchExcerpt(text, from, to, radius = 24) {
   const safeFrom = Math.max(0, Math.min(from, text.length));
   const safeTo = Math.max(safeFrom, Math.min(to, text.length));
@@ -41904,7 +42189,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;
@@ -55942,6 +56228,36 @@ function createDocumentRuntime(options) {
   let viewportBlockRanges = null;
   let viewportRangesKey = serializeViewportRanges(viewportBlockRanges);
   let viewportBlocksPerPageEstimate = null;
+  let fullSurfaceWarmupScheduled = false;
+  let fullSurfaceWarmupCompleted = false;
+  function scheduleFullSurfaceWarmupAfterCull() {
+    if (fullSurfaceWarmupScheduled || fullSurfaceWarmupCompleted) return;
+    fullSurfaceWarmupScheduled = true;
+    perfCounters.increment("surface.fullSurfaceWarmup.scheduled");
+    runOnIdle(() => {
+      fullSurfaceWarmupScheduled = false;
+      if (cachedFullSurface) {
+        perfCounters.increment("surface.fullSurfaceWarmup.alreadyCached");
+        fullSurfaceWarmupCompleted = true;
+        return;
+      }
+      const t0 = performance.now();
+      try {
+        getCachedFullSurface(state.document, activeStory);
+        fullSurfaceWarmupCompleted = true;
+        perfCounters.increment("surface.fullSurfaceWarmup.committed");
+      } catch (error) {
+        perfCounters.increment("surface.fullSurfaceWarmup.failed");
+        fullSurfaceWarmupCompleted = false;
+        void error;
+      } finally {
+        perfCounters.increment(
+          "surface.fullSurfaceWarmup.us",
+          Math.round((performance.now() - t0) * 1e3)
+        );
+      }
+    });
+  }
   const getRuntimeForLayoutFacet = () => {
     if (!runtimeRef) {
       throw new Error("Document runtime viewport methods are not initialized");
@@ -56134,6 +56450,15 @@ function createDocumentRuntime(options) {
   let cachedSurface;
   let cachedFullSurface;
   const editableTargetBlockCache = createEditableTargetBlockCache();
+  let paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+  let paragraphCascadeCacheStylesRef = null;
+  function ensureParagraphCascadeCacheForStyles(nextStyles) {
+    if (paragraphCascadeCacheStylesRef !== nextStyles) {
+      paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+      paragraphCascadeCacheStylesRef = nextStyles;
+    }
+    return paragraphCascadeCache;
+  }
   let cachedEditableTargetMap = null;
   function getEditableTargetsByBlockPath(document2) {
     if (cachedEditableTargetMap !== null && cachedEditableTargetMap.document === document2) {
@@ -56187,6 +56512,7 @@ function createDocumentRuntime(options) {
     const snapshot = createEditorSurfaceSnapshot(document2, state.selection, nextActiveStory, {
       viewportBlockRanges: null,
       editableTargetsByBlockPath: getEditableTargetsByBlockPath(document2),
+      paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(document2.styles),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -56227,6 +56553,7 @@ function createDocumentRuntime(options) {
         activeStoryKey,
         surfaceViewportRanges
       ),
+      paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(document2.styles),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -56438,7 +56765,17 @@ function createDocumentRuntime(options) {
     }
   }
   function tryPatchNestedLocalTextSurface(previousSurface, editFrom, editTo, insertedText) {
-    const shiftBudget = estimateLocalTextPatchShiftBudget(previousSurface.blocks, 0);
+    const containerIndex = previousSurface.blocks.findIndex(
+      (block) => editFrom >= block.from && editTo <= block.to
+    );
+    if (containerIndex < 0) {
+      perfCounters.increment("surface.localText.patchMiss");
+      return null;
+    }
+    const shiftBudget = estimateLocalTextPatchShiftBudget(
+      previousSurface.blocks,
+      containerIndex + 1
+    );
     perfCounters.increment("surface.localText.shiftedBlocks", shiftBudget.shiftedBlocks);
     perfCounters.increment("surface.localText.shiftedNodes", shiftBudget.shiftedNodes);
     if (!shiftBudget.withinBudget) {
@@ -56518,19 +56855,9 @@ function createDocumentRuntime(options) {
     for (let index = startIndex; index < blocks.length; index += 1) {
       const shiftedBlockNodes = countSurfaceShiftNodesUpTo(
         blocks[index],
-        Math.min(
-          policy.maxShiftedNodesPerBlock,
-          policy.maxShiftedSurfaceNodes - shiftedNodes
-        ) + 1
+        policy.maxShiftedSurfaceNodes - shiftedNodes + 1
       );
       shiftedNodes += shiftedBlockNodes;
-      if (shiftedBlockNodes > policy.maxShiftedNodesPerBlock) {
-        return {
-          shiftedBlocks,
-          shiftedNodes,
-          withinBudget: false
-        };
-      }
       if (shiftedNodes > policy.maxShiftedSurfaceNodes) {
         return {
           shiftedBlocks,
@@ -57202,6 +57529,9 @@ function createDocumentRuntime(options) {
         viewportBlockRangesOverride: firstSurfaceViewportBlockRanges
       }) : getCachedSurface(state.document, activeStory)
     );
+    if (firstSurfaceViewportBlockRanges) {
+      scheduleFullSurfaceWarmupAfterCull();
+    }
     const snapshot = {
       documentId: state.documentId,
       sessionId: state.sessionId,
@@ -57315,6 +57645,9 @@ function createDocumentRuntime(options) {
           activeStoryKey,
           viewportBlockRanges
         ),
+        paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(
+          state.document.styles
+        ),
         ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
       }
     );
@@ -57965,7 +58298,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 +58455,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 +58889,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 +60915,39 @@ function createDocumentRuntime(options) {
     const preSelection = selection;
     const preActiveStory = activeStory;
     const priorDocument = state.document;
+    const selectedListItemDelete = createSelectedListItemDeleteReplacement({
+      command: commandForDispatch,
+      document: state.document,
+      editableTarget,
+      selection,
+      storyTarget: activeStory,
+      targetResolution,
+      timestamp
+    });
+    if (selectedListItemDelete && 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);
@@ -60753,6 +61189,9 @@ function createDocumentRuntime(options) {
     });
   }
   function scheduleIdleContextAnalytics(callback) {
+    runOnIdle(callback);
+  }
+  function runOnIdle(callback) {
     const requestIdle = globalThis.requestIdleCallback;
     if (typeof requestIdle === "function") {
       requestIdle(callback, { timeout: 250 });
@@ -61706,7 +62145,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 +63831,258 @@ 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, storyTarget, 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 storyBlocks = getStoryBlocks(document2, storyTarget);
+  const replacement = removeNumberedParagraphAtStoryPath(storyBlocks, editableTarget.blockPath, storyTarget);
+  if (!replacement) {
+    return null;
+  }
+  const nextDocument = replaceStoryBlocks({
+    ...document2,
+    updatedAt: timestamp
+  }, storyTarget, replacement.blocks);
+  const nextStorySize = parseTextStory({
+    type: "doc",
+    children: [...getStoryBlocks(nextDocument, storyTarget)]
+  }).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 removeNumberedParagraphAtStoryPath(blocks, blockPath, storyTarget) {
+  const tokens = parseStoryBlockPathTokens(blockPath, storyTarget);
+  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)
+      ]
+    };
+  }
+  if (block.type === "paragraph" && next?.kind === "inline") {
+    const updatedParagraph = removeNumberedParagraphFromTextBoxInline(block, rest);
+    if (!updatedParagraph) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        updatedParagraph,
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  return null;
+}
+function removeNumberedParagraphFromTextBoxInline(paragraph, tokens) {
+  const [inlineToken, textBoxToken, ...childTokens] = tokens;
+  if (inlineToken?.kind !== "inline" || textBoxToken?.kind !== "txbx" || childTokens[0]?.kind !== "block") {
+    return null;
+  }
+  const inline = paragraph.children[inlineToken.index];
+  if (!inline) return null;
+  const updatedInline = removeNumberedParagraphFromInlineTextBox(inline, childTokens);
+  if (!updatedInline) return null;
+  return {
+    ...paragraph,
+    children: [
+      ...paragraph.children.slice(0, inlineToken.index),
+      updatedInline,
+      ...paragraph.children.slice(inlineToken.index + 1)
+    ]
+  };
+}
+function removeNumberedParagraphFromInlineTextBox(inline, tokens) {
+  if (inline.type === "shape" && inline.txbxBlocks) {
+    const updatedBlocks = removeNumberedParagraphFromBlocks(inline.txbxBlocks, tokens);
+    return updatedBlocks ? { ...inline, txbxBlocks: updatedBlocks.blocks } : null;
+  }
+  if (inline.type === "drawing_frame" && inline.content.type === "shape" && inline.content.txbxBlocks) {
+    const updatedBlocks = removeNumberedParagraphFromBlocks(inline.content.txbxBlocks, tokens);
+    return updatedBlocks ? {
+      ...inline,
+      content: {
+        ...inline.content,
+        txbxBlocks: updatedBlocks.blocks
+      }
+    } : null;
+  }
+  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 resolvedEditableTarget = targetResolution.kind === "accepted" ? editableTarget : storyTarget.kind !== "main" && blockPathBelongsToStoryTarget(editableTarget.blockPath, storyTarget) ? resolveEditableCommandTarget({
+    document: document2,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+    commandFamilies: ["text-leaf"]
+  }) : null;
+  const selectedRange = {
+    from: Math.min(selection.anchor, selection.head),
+    to: Math.max(selection.anchor, selection.head)
+  };
+  const replacement = createSelectedListItemDeleteReplacement({
+    command,
+    document: document2,
+    editableTarget: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? resolvedEditableTarget.target : editableTarget,
+    selection,
+    storyTarget,
+    targetResolution: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? {
+      kind: "accepted",
+      range: selectedRange
+    } : targetResolution,
+    timestamp
+  });
+  if (!replacement) {
+    return null;
+  }
+  return {
+    type: "document.replace",
+    document: replacement.document,
+    selection: replacement.selection,
+    mapping: replacement.mapping,
+    protectionSelection: selection,
+    origin: command.origin
+  };
+}
+function parseStoryBlockPathTokens(blockPath, storyTarget) {
+  if (!blockPath) {
+    return null;
+  }
+  const firstTokenMatch = /\/(?:block|row|cell)\[\d+\]/u.exec(blockPath);
+  if (!firstTokenMatch?.index) {
+    return null;
+  }
+  const storyPrefix = blockPath.slice(0, firstTokenMatch.index);
+  if (!blockPathBelongsToStoryTarget(storyPrefix, storyTarget)) {
+    return null;
+  }
+  const parts = blockPath.slice(firstTokenMatch.index + 1).split("/");
+  const tokens = [];
+  for (const part of parts) {
+    if (part === "txbx") {
+      tokens.push({ kind: "txbx" });
+      continue;
+    }
+    const match = /^(block|row|cell|inline)\[(\d+)\]$/u.exec(part);
+    if (!match) return null;
+    const kind = match[1];
+    tokens.push({
+      kind,
+      index: Number.parseInt(match[2], 10)
+    });
+  }
+  return tokens;
+}
+function blockPathBelongsToStoryTarget(storyPrefix, storyTarget) {
+  switch (storyTarget.kind) {
+    case "main":
+      return storyPrefix === "main" || storyPrefix.startsWith("main/");
+    case "header":
+      return storyPrefix.startsWith("header:");
+    case "footer":
+      return storyPrefix.startsWith("footer:");
+    case "footnote":
+      return storyPrefix === `footnote:${storyTarget.noteId}` || storyPrefix.startsWith(`footnote:${storyTarget.noteId}/`);
+    case "endnote":
+      return storyPrefix === `endnote:${storyTarget.noteId}` || storyPrefix.startsWith(`endnote:${storyTarget.noteId}/`);
+  }
+}
 function toInternalSelectionSnapshot2(selection) {
   return {
     anchor: selection.anchor,