@beyondwork/docx-react-component 1.0.133 → 1.0.135

package/dist/index.cjs

@@ -12983,10 +12983,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);
@@ -13552,7 +13558,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;
@@ -15747,7 +15754,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;
@@ -22574,6 +22582,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;
@@ -22584,12 +22594,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));
@@ -35768,9 +35787,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",
@@ -35778,7 +35799,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,
@@ -35833,6 +35854,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 {
@@ -36936,6 +36960,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(
         {
@@ -38181,7 +38210,7 @@ function applyTextCommand(state, timestamp, apply) {
   const reviewState = remapReviewStateAfterContentChange(
     state,
     result.document,
-    result.mapping
+    result.mapping ?? createEmptyMapping()
   );
   const scopeTagTouches = collectScopeTagTouches(
     state.document.review.comments,
@@ -38521,6 +38550,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) {
@@ -38593,10 +38654,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) {
@@ -38705,7 +38766,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,
@@ -38770,6 +38831,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,
@@ -38781,6 +38967,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 });
@@ -38790,10 +38980,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;
@@ -49918,11 +50108,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";
@@ -49933,8 +50121,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
@@ -50021,7 +50209,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(
@@ -50030,14 +50218,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 } : {}
@@ -50050,14 +50239,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
         }
@@ -50439,6 +50629,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) {
@@ -50721,6 +51004,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);
+          }
         }
       }
     }
@@ -51206,16 +51500,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)) {
@@ -51269,34 +51559,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) {
@@ -52350,6 +52630,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) {
@@ -54850,9 +55138,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"
@@ -70287,6 +70573,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");
@@ -70479,6 +70795,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) {
@@ -70532,6 +70857,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");
@@ -70572,6 +70898,7 @@ function createDocumentRuntime(options) {
         activeStoryKey,
         surfaceViewportRanges
       ),
+      paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(document2.styles),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -70783,7 +71110,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) {
@@ -70863,19 +71200,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,
@@ -71547,6 +71874,9 @@ function createDocumentRuntime(options) {
         viewportBlockRangesOverride: firstSurfaceViewportBlockRanges
       }) : getCachedSurface(state.document, activeStory)
     );
+    if (firstSurfaceViewportBlockRanges) {
+      scheduleFullSurfaceWarmupAfterCull();
+    }
     const snapshot = {
       documentId: state.documentId,
       sessionId: state.sessionId,
@@ -71660,6 +71990,9 @@ function createDocumentRuntime(options) {
           activeStoryKey,
           viewportBlockRanges
         ),
+        paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(
+          state.document.styles
+        ),
         ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
       }
     );
@@ -72310,7 +72643,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,
@@ -72454,7 +72800,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,
@@ -72875,6 +73234,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) {
+            emit2({
+              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) {
@@ -74857,6 +75260,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);
@@ -75098,6 +75534,9 @@ function createDocumentRuntime(options) {
     });
   }
   function scheduleIdleContextAnalytics(callback) {
+    runOnIdle(callback);
+  }
+  function runOnIdle(callback) {
     const requestIdle = globalThis.requestIdleCallback;
     if (typeof requestIdle === "function") {
       requestIdle(callback, { timeout: 250 });
@@ -76051,7 +76490,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;
@@ -77727,6 +78167,258 @@ function stripStoryTarget2(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,
@@ -94200,7 +94892,8 @@ async function persistAndExport(input) {
     });
     result = withExportDelivery(result, {
       mode: "persisted-by-host",
-      savedAt: saveResult.savedAt
+      savedAt: saveResult.savedAt,
+      ...input.options?.download === false ? { downloadSuppressed: true } : {}
     });
   } catch (error) {
     const normalized = normalizeStorageError(error, {
@@ -94621,18 +95314,7 @@ function findScrollAnchor(root, options) {
         offsetWithinBlock: viewportTopFramePx - blockTop
       };
     }
-  }
-  const rootRect = root.getBoundingClientRect();
-  const rootTop = rootRect.top;
-  for (const block of blocks) {
-    const rect3 = block.getBoundingClientRect();
-    if (rect3.bottom < rootTop) continue;
-    const blockId = block.getAttribute("data-block-id");
-    if (!blockId) continue;
-    return {
-      blockId,
-      offsetWithinBlock: rootTop - rect3.top
-    };
+    return null;
   }
   return null;
 }
@@ -94650,17 +95332,9 @@ function resolveScrollTopForAnchor(root, anchor, options) {
       const rect3 = geometry.rects[0];
       return rect3.topPx + anchor.offsetWithinBlock;
     }
+    return null;
   }
-  const selector = `[data-block-id="${cssEscape(anchor.blockId)}"]`;
-  const block = root.querySelector(selector);
-  if (!block) return null;
-  const rootRect = root.getBoundingClientRect();
-  const blockRect = block.getBoundingClientRect();
-  const delta = blockRect.top - rootRect.top + anchor.offsetWithinBlock;
-  return root.scrollTop + delta;
-}
-function cssEscape(value) {
-  return value.replace(/[^a-zA-Z0-9_-]/g, (ch) => `\\${ch}`);
+  return null;
 }
 
 // src/ui-tailwind/chrome/tw-alert-banner.tsx
@@ -103245,6 +103919,14 @@ var EDITOR_ACTION_REGISTRY = [
     targetKinds: ["generated-field"],
     callback: "onUpdateFields"
   }),
+  mk({
+    id: "toc-refresh",
+    label: "Refresh table of contents",
+    description: "Refresh TOC entries through the runtime table-of-contents updater.",
+    group: "misc",
+    targetKinds: ["toc-field"],
+    callback: "onUpdateTableOfContents"
+  }),
   // -------- Workflow scope --------
   mk({
     id: "scope-open-card",
@@ -104138,6 +104820,18 @@ function hasAncestorAttributeValue(el, attribute, expected, root) {
   }
   return false;
 }
+function hasAncestorAttributeValueInsensitive(el, attribute, expected, root) {
+  const normalizedExpected = expected.toLowerCase();
+  let cursor = el;
+  while (cursor) {
+    if (cursor.getAttribute?.(attribute)?.toLowerCase() === normalizedExpected) {
+      return true;
+    }
+    if (cursor === root) return false;
+    cursor = cursor.parentElement;
+  }
+  return false;
+}
 function resolveTargetKind(target, options = {}) {
   const kinds = [];
   const el = toElement(target);
@@ -104152,7 +104846,12 @@ function resolveTargetKind(target, options = {}) {
     const insideListItem = insideNumberingMarker || hasAncestorAttributeValue(el, "data-numbered", "true", root);
     const insideGeneratedField = hasAncestorAttributeValue(el, "data-generated-field", "true", root) || hasAncestorAttributeValue(el, "data-node-type", "field_ref_atom", root) || hasAncestorAttributeValue(el, "data-node-type", "field_ref", root);
     if (insideListItem) kinds.push("list-item");
-    if (insideGeneratedField) kinds.push("generated-field");
+    if (insideGeneratedField) {
+      kinds.push("generated-field");
+      if (hasAncestorAttributeValueInsensitive(el, "data-field-family", "TOC", root)) {
+        kinds.push("toc-field");
+      }
+    }
     if (hasAncestorTag(el, "a", root)) kinds.push("hyperlink");
     if (!insideNumberingMarker && hasAncestorTag(el, "img", root)) {
       kinds.push("image");
@@ -105225,294 +105924,6 @@ function resolveSkeletalPageOverlayRectsFromLayout(facet) {
   }
   return rects;
 }
-function pageOverlayLastBottom(rects) {
-  let bottom = 0;
-  for (const rect3 of rects) {
-    if (rect3.bottomPx > bottom) bottom = rect3.bottomPx;
-  }
-  return bottom;
-}
-function extendFinalPageOverlayRectToFlowHeight(rects, flowHeightPx) {
-  if (rects.length === 0 || !Number.isFinite(flowHeightPx)) return rects;
-  const last = rects[rects.length - 1];
-  if (flowHeightPx <= last.bottomPx + 1) return rects;
-  return [
-    ...rects.slice(0, -1),
-    {
-      ...last,
-      bottomPx: flowHeightPx,
-      heightPx: Math.max(0, flowHeightPx - last.topPx)
-    }
-  ];
-}
-function extendPageOverlayRectsAcrossTableBoundaryGaps(rects, tableBoundaryIndices) {
-  if (rects.length === 0 || tableBoundaryIndices.length === 0) return rects;
-  const tableBoundaries = new Set(tableBoundaryIndices);
-  const byPageIndex = /* @__PURE__ */ new Map();
-  for (const rect3 of rects) {
-    byPageIndex.set(rect3.pageIndex, rect3);
-  }
-  let changed = false;
-  const bridged = rects.map((rect3) => {
-    if (!tableBoundaries.has(rect3.pageIndex)) return rect3;
-    const next = byPageIndex.get(rect3.pageIndex + 1);
-    if (!next || next.topPx <= rect3.bottomPx + 1) return rect3;
-    changed = true;
-    return {
-      ...rect3,
-      bottomPx: next.topPx,
-      heightPx: Math.max(0, next.topPx - rect3.topPx)
-    };
-  });
-  return changed ? bridged : rects;
-}
-function mergePageOverlayRectsByPageIndex(baseRects, flowRects) {
-  if (baseRects.length === 0 || flowRects.length === 0) return baseRects;
-  const flowByIndex = /* @__PURE__ */ new Map();
-  for (const rect3 of flowRects) {
-    flowByIndex.set(rect3.pageIndex, rect3);
-  }
-  return baseRects.map((rect3) => flowByIndex.get(rect3.pageIndex) ?? rect3);
-}
-function normalizeVisiblePageIndexRange(range, pageCount) {
-  if (!range || pageCount <= 0) return null;
-  const start = Math.max(0, Math.min(range.start, pageCount));
-  const end = Math.max(start, Math.min(range.end, pageCount));
-  if (start >= end) return null;
-  return { start, end };
-}
-function collectBoundaryIndicesForVisibleRange(range, pageCount) {
-  if (pageCount <= 1) return [];
-  const startBoundaryIndex = Math.max(0, range.start - 1);
-  const endBoundaryIndex = Math.min(pageCount - 2, range.end - 1);
-  if (startBoundaryIndex > endBoundaryIndex) return [];
-  const indices = [];
-  for (let index = startBoundaryIndex; index <= endBoundaryIndex; index += 1) {
-    indices.push(index);
-  }
-  return indices;
-}
-function parsePageBoundaryIndex(prevPageId) {
-  const match = /^page-(\d+)$/.exec(prevPageId);
-  if (!match) return void 0;
-  return Number.parseInt(match[1] ?? "", 10);
-}
-function collectTableEmbeddedBoundaryIndices(queryRoot) {
-  if (!queryRoot) return [];
-  const indices = [];
-  const widgets = Array.from(
-    queryRoot.querySelectorAll("[data-page-frame-end]")
-  );
-  for (const widget of widgets) {
-    const prevPageId = widget.getAttribute("data-page-frame-end");
-    if (!prevPageId) continue;
-    const boundaryIndex = parsePageBoundaryIndex(prevPageId);
-    if (boundaryIndex === void 0) continue;
-    if (widget.closest("[data-pm-table-root='true'], table")) {
-      indices.push(boundaryIndex);
-    }
-  }
-  return indices;
-}
-function containsTableBoundaryRisk(queryRoot) {
-  if (!queryRoot) return false;
-  if (queryRoot.getElementsByTagName("table").length > 0) return true;
-  const descendants = queryRoot.getElementsByTagName("*");
-  for (let i = 0; i < descendants.length; i += 1) {
-    const element = descendants[i];
-    if (element.getAttribute("data-pm-table-root") === "true") {
-      return true;
-    }
-  }
-  return false;
-}
-function resolvePageOverlayRects(input, legacyPageCount) {
-  let widgets;
-  let pageCount;
-  let scrollHeight;
-  if (Array.isArray(input)) {
-    const [scrollRoot, count] = input;
-    if (!scrollRoot || count <= 0) return [];
-    widgets = measureWidgetsViaOffsetChain(scrollRoot);
-    pageCount = count;
-    scrollHeight = scrollRoot.clientHeight;
-  } else if (input !== null && typeof input === "object" && "widgets" in input) {
-    widgets = input.widgets;
-    pageCount = input.pageCount;
-    scrollHeight = input.scrollHeight;
-  } else if (input && legacyPageCount !== void 0) {
-    const scrollRoot = input;
-    if (legacyPageCount <= 0) return [];
-    widgets = measureWidgetsViaOffsetChain(scrollRoot);
-    pageCount = legacyPageCount;
-    scrollHeight = scrollRoot.clientHeight;
-  } else {
-    return [];
-  }
-  if (pageCount <= 0) return [];
-  const boundaries = [...widgets].sort((a, b) => a.topPx - b.topPx);
-  const normalizedVisiblePageIndexRange = Array.isArray(input) ? null : normalizeVisiblePageIndexRange(input.visiblePageIndexRange, pageCount);
-  const boundaryByIndex = /* @__PURE__ */ new Map();
-  boundaries.forEach((boundary, index) => {
-    const boundaryIndex = boundary.boundaryIndex ?? parsePageBoundaryIndex(boundary.prevPageId) ?? index;
-    boundaryByIndex.set(boundaryIndex, boundary);
-  });
-  const pageStart = normalizedVisiblePageIndexRange?.start ?? 0;
-  const pageEnd = normalizedVisiblePageIndexRange?.end ?? pageCount;
-  const rects = [];
-  for (let pageIndex = pageStart; pageIndex < pageEnd; pageIndex += 1) {
-    const boundaryBefore = pageIndex === 0 ? null : boundaryByIndex.get(pageIndex - 1) ?? null;
-    const boundaryAfter = pageIndex === pageCount - 1 ? null : boundaryByIndex.get(pageIndex) ?? null;
-    let pageId = null;
-    if (boundaryBefore) pageId = boundaryBefore.nextPageId;
-    else if (boundaryAfter) pageId = boundaryAfter.prevPageId;
-    if (!pageId) pageId = `page-${pageIndex}`;
-    const topPx = boundaryBefore ? boundaryBefore.bottomPx : 0;
-    const bottomPx = boundaryAfter ? boundaryAfter.topPx : scrollHeight;
-    if (bottomPx <= topPx) continue;
-    rects.push({
-      pageId,
-      pageIndex,
-      topPx,
-      bottomPx,
-      heightPx: bottomPx - topPx
-    });
-  }
-  return rects;
-}
-function measureWidgetsViaBoundingRect(queryRoot, originElement, options) {
-  if (!queryRoot || !originElement) return [];
-  const originRect = originElement.getBoundingClientRect();
-  const normalizedVisiblePageIndexRange = normalizeVisiblePageIndexRange(
-    options?.visiblePageIndexRange,
-    options?.pageCount ?? 0
-  );
-  const queryOne = typeof queryRoot.querySelector === "function" ? queryRoot.querySelector.bind(queryRoot) : null;
-  const widgets = normalizedVisiblePageIndexRange && queryOne && options?.pageCount ? collectBoundaryIndicesForVisibleRange(
-    normalizedVisiblePageIndexRange,
-    options.pageCount
-  ).map(
-    (boundaryIndex) => queryOne(`[data-page-frame-end="page-${boundaryIndex}"]`)
-  ).filter((widget) => widget !== null) : Array.from(
-    queryRoot.querySelectorAll("[data-page-frame-end]")
-  );
-  const out = [];
-  for (const widget of widgets) {
-    const prevPageId = widget.getAttribute("data-page-frame-end");
-    const nextPageId = widget.getAttribute("data-page-frame-start");
-    if (!prevPageId || !nextPageId) continue;
-    const rect3 = widget.getBoundingClientRect();
-    out.push({
-      prevPageId,
-      nextPageId,
-      boundaryIndex: parsePageBoundaryIndex(prevPageId),
-      topPx: rect3.top - originRect.top,
-      bottomPx: rect3.bottom - originRect.top
-    });
-  }
-  return out;
-}
-function measureWidgetsViaOffsetChain(scrollRoot, options) {
-  const normalizedVisiblePageIndexRange = normalizeVisiblePageIndexRange(
-    options?.visiblePageIndexRange,
-    options?.pageCount ?? 0
-  );
-  const queryOne = typeof scrollRoot.querySelector === "function" ? scrollRoot.querySelector.bind(scrollRoot) : null;
-  const widgets = normalizedVisiblePageIndexRange && queryOne && options?.pageCount ? collectBoundaryIndicesForVisibleRange(
-    normalizedVisiblePageIndexRange,
-    options.pageCount
-  ).map(
-    (boundaryIndex) => queryOne(`[data-page-frame-end="page-${boundaryIndex}"]`)
-  ).filter((widget) => widget !== null) : Array.from(
-    scrollRoot.querySelectorAll("[data-page-frame-end]")
-  );
-  const out = [];
-  for (const widget of widgets) {
-    const prevPageId = widget.getAttribute("data-page-frame-end");
-    const nextPageId = widget.getAttribute("data-page-frame-start");
-    if (!prevPageId || !nextPageId) continue;
-    const topPx = resolveOffsetTop(widget, scrollRoot);
-    const bottomPx = topPx + resolveOffsetHeight(widget);
-    out.push({
-      prevPageId,
-      nextPageId,
-      boundaryIndex: parsePageBoundaryIndex(prevPageId),
-      topPx,
-      bottomPx
-    });
-  }
-  return out;
-}
-function resolveOffsetTop(widget, scrollRoot) {
-  let node = widget;
-  let top = 0;
-  while (node) {
-    top += node.offsetTop ?? 0;
-    const parent = node.offsetParent;
-    if (parent === scrollRoot || parent === null) break;
-    node = parent;
-  }
-  return top;
-}
-function resolveOffsetHeight(widget) {
-  return widget.offsetHeight ?? 0;
-}
-function readElementFlowHeight(element, options = {}) {
-  if (!element) return 0;
-  let height = 0;
-  height = Math.max(height, element.clientHeight || 0);
-  if (options.includeScrollHeight !== false) {
-    height = Math.max(height, element.scrollHeight || 0);
-  }
-  if (height <= 0) {
-    const rect3 = element.getBoundingClientRect();
-    height = Math.max(height, rect3.height || 0);
-  }
-  return height;
-}
-function readOverlayFlowHeight(origin) {
-  if (!origin) return 0;
-  const parent = origin.parentElement instanceof HTMLElement ? origin.parentElement : null;
-  const parentHeight = readElementFlowHeight(parent);
-  if (parentHeight > 0) return parentHeight;
-  return readElementFlowHeight(origin, { includeScrollHeight: false });
-}
-function reconcilePageStackRectsWithFlow(input) {
-  const { baseRects, pageCount, scrollRoot, originElement } = input;
-  if (baseRects.length === 0 || pageCount <= 0) return baseRects;
-  const flowHeight = readOverlayFlowHeight(originElement);
-  if (flowHeight <= 0) return baseRects;
-  const geometryBottom = pageOverlayLastBottom(baseRects);
-  const tableBoundaryRisk = containsTableBoundaryRisk(scrollRoot);
-  if (!tableBoundaryRisk && flowHeight <= geometryBottom + 1) {
-    return extendFinalPageOverlayRectToFlowHeight(baseRects, flowHeight);
-  }
-  const bridgedBase = extendPageOverlayRectsAcrossTableBoundaryGaps(
-    baseRects,
-    tableBoundaryRisk ? collectTableEmbeddedBoundaryIndices(scrollRoot) : []
-  );
-  const extendedBase = extendFinalPageOverlayRectToFlowHeight(
-    bridgedBase,
-    flowHeight
-  );
-  if (!originElement || !scrollRoot) return extendedBase;
-  if (flowHeight <= pageOverlayLastBottom(bridgedBase) + 1) {
-    return extendedBase;
-  }
-  const widgets = measureWidgetsViaBoundingRect(scrollRoot, originElement, {
-    pageCount,
-    visiblePageIndexRange: null
-  });
-  if (widgets.length === 0) return extendedBase;
-  const flowRects = resolvePageOverlayRects({
-    widgets,
-    pageCount,
-    scrollHeight: flowHeight,
-    visiblePageIndexRange: null
-  });
-  const merged = mergePageOverlayRectsByPageIndex(extendedBase, flowRects);
-  return extendFinalPageOverlayRectToFlowHeight(merged, flowHeight);
-}
 var resolvePageOverlayRectsFromGeometry2 = resolvePageOverlayRectsFromGeometry;
 function resolvePageOverlayRectsFromUiApi(ui, pageCount, visiblePageIndexRange, pageIds) {
   if (pageCount <= 0) return [];
@@ -105570,17 +105981,6 @@ var TwPageStackOverlayLayer = ({
     },
     []
   );
-  const reconcilePaperRectsWithFlow = React23.useCallback(
-    (baseRects, pageCount) => {
-      return reconcilePageStackRectsWithFlow({
-        baseRects,
-        pageCount,
-        scrollRoot,
-        originElement: overlayRootRef.current
-      });
-    },
-    [scrollRoot]
-  );
   const refreshRectsNow = React23.useCallback(() => {
     const pageCount = facet.getPageCount();
     const skeletalRects = resolveSkeletalPageOverlayRectsFromLayout(facet);
@@ -105621,51 +106021,11 @@ var TwPageStackOverlayLayer = ({
       setRectsIfChanged(skeletalRects);
       return;
     }
-    if (!scrollRoot) {
-      setRectsIfChanged(skeletalRects);
-      return;
-    }
-    const origin = overlayRootRef.current;
-    incrementInvalidationCounter("overlay.page.dom_fallback");
-    if (origin) {
-      incrementInvalidationCounter("overlay.page.dom.degraded");
-      const widgets = measureWidgetsViaBoundingRect(scrollRoot, origin, {
-        pageCount,
-        visiblePageIndexRange: null
-      });
-      const originRect = origin.getBoundingClientRect();
-      const domRects = resolvePageOverlayRects({
-        widgets,
-        pageCount,
-        scrollHeight: (
-          // geometry:allow-dom-fallback
-          origin.clientHeight > 0 ? origin.clientHeight : originRect.height
-        ),
-        visiblePageIndexRange: null
-      });
-      const reconciled = reconcilePaperRectsWithFlow(domRects, pageCount);
-      setRectsIfChanged(reconciled.length > 0 ? reconciled : skeletalRects);
-    } else {
-      incrementInvalidationCounter("overlay.page.dom.degraded");
-      const widgets = measureWidgetsViaOffsetChain(scrollRoot, {
-        pageCount,
-        visiblePageIndexRange: null
-      });
-      const domRects = resolvePageOverlayRects({
-        widgets,
-        pageCount,
-        // geometry:allow-dom-fallback
-        scrollHeight: scrollRoot.clientHeight,
-        visiblePageIndexRange: null
-      });
-      const reconciled = reconcilePaperRectsWithFlow(domRects, pageCount);
-      setRectsIfChanged(reconciled.length > 0 ? reconciled : skeletalRects);
-    }
+    incrementInvalidationCounter("overlay.page.skeletal_fallback");
+    setRectsIfChanged(skeletalRects);
   }, [
     facet,
     geometryFacet,
-    reconcilePaperRectsWithFlow,
-    scrollRoot,
     setRectsIfChanged,
     ui
   ]);
@@ -105696,33 +106056,6 @@ var TwPageStackOverlayLayer = ({
       }
     };
   }, [refreshRects, renderFrameRevision, scrollRoot]);
-  React23.useEffect(() => {
-    if (geometryFacet) return;
-    if (!scrollRoot) return;
-    const runtime = scrollRoot.ownerDocument?.defaultView;
-    if (!runtime?.ResizeObserver) return;
-    const observer = new runtime.ResizeObserver(() => refreshRects());
-    observer.observe(scrollRoot);
-    return () => observer.disconnect();
-  }, [geometryFacet, scrollRoot, refreshRects]);
-  React23.useEffect(() => {
-    if (geometryFacet) return;
-    if (!scrollRoot) return;
-    const runtime = scrollRoot.ownerDocument?.defaultView;
-    if (!runtime?.MutationObserver) return;
-    const observer = new runtime.MutationObserver((records) => {
-      const overlay = overlayRootRef.current;
-      if (overlay) {
-        const allSelf = records.every(
-          (r) => r.target instanceof Node && overlay.contains(r.target)
-        );
-        if (allSelf) return;
-      }
-      refreshRects();
-    });
-    observer.observe(scrollRoot, { childList: true, subtree: false });
-    return () => observer.disconnect();
-  }, [geometryFacet, scrollRoot, refreshRects]);
   if (rects.length === 0) {
     return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
       "div",
@@ -107814,25 +108147,23 @@ var TwPageStackChromeLayerInner = ({
     const pageCount = facet.getPageCount();
     const uiRects = resolveUiPageRects(pageCount);
     if (uiRects !== null) return uiRects;
-    if (!geometryFacet) return [];
-    const warm = resolvePageOverlayRectsFromGeometry2(
-      geometryFacet,
-      pageCount,
-      visiblePageIndexRange
+    if (geometryFacet) {
+      const warm = resolvePageOverlayRectsFromGeometry2(
+        geometryFacet,
+        pageCount,
+        visiblePageIndexRange
+      );
+      if (warm !== null) return warm;
+    }
+    return resolveSkeletalPageOverlayRectsFromLayout(facet).filter(
+      (rect3) => !visiblePageIndexRange || rect3.pageIndex >= visiblePageIndexRange.start && rect3.pageIndex < visiblePageIndexRange.end
     );
-    return warm ?? [];
   });
   const overlayRootRef = import_react33.default.useRef(null);
   const rafHandleRef = import_react33.default.useRef(null);
   const [activeStoryPageIndex, setActiveStoryPageIndex] = import_react33.default.useState(null);
   const refreshRectsNow = import_react33.default.useCallback(() => {
     const pageCount = facet.getPageCount();
-    const reconcileDomRects = (baseRects) => reconcilePageStackRectsWithFlow({
-      baseRects,
-      pageCount,
-      scrollRoot,
-      originElement: overlayRootRef.current
-    });
     const uiRects = resolveUiPageRects(pageCount);
     if (uiRects !== null) {
       setRects(uiRects);
@@ -107851,47 +108182,11 @@ var TwPageStackChromeLayerInner = ({
       setRects([]);
       return;
     }
-    if (!scrollRoot) {
-      setRects([]);
-      return;
-    }
-    const origin = overlayRootRef.current;
-    if (origin) {
-      const widgets = measureWidgetsViaBoundingRect(scrollRoot, origin, {
-        pageCount,
-        visiblePageIndexRange
-      });
-      const originRect = origin.getBoundingClientRect();
-      const scrollHeight = (
-        // geometry:allow-dom-fallback
-        origin.clientHeight > 0 ? origin.clientHeight : originRect.height > 0 ? originRect.height : scrollRoot.clientHeight
-      );
-      const domRects = resolvePageOverlayRects({
-        widgets,
-        pageCount,
-        scrollHeight,
-        visiblePageIndexRange
-      });
-      setRects(
-        reconcileDomRects(domRects)
-      );
-    } else {
-      const widgets = measureWidgetsViaOffsetChain(scrollRoot, {
-        pageCount,
-        visiblePageIndexRange
-      });
-      const domRects = resolvePageOverlayRects({
-        widgets,
-        pageCount,
-        // geometry:allow-dom-fallback
-        scrollHeight: scrollRoot.clientHeight,
-        visiblePageIndexRange
-      });
-      setRects(
-        reconcileDomRects(domRects)
-      );
-    }
-  }, [facet, geometryFacet, resolveUiPageRects, scrollRoot, visiblePageIndexRange]);
+    const skeletalRects = resolveSkeletalPageOverlayRectsFromLayout(facet).filter(
+      (rect3) => !visiblePageIndexRange || rect3.pageIndex >= visiblePageIndexRange.start && rect3.pageIndex < visiblePageIndexRange.end
+    );
+    setRects(skeletalRects);
+  }, [facet, geometryFacet, resolveUiPageRects, visiblePageIndexRange]);
   const refreshRects = import_react33.default.useCallback(() => {
     if (!scrollRoot) {
       refreshRectsNow();
@@ -107931,33 +108226,6 @@ var TwPageStackChromeLayerInner = ({
     },
     [onOpenStory]
   );
-  import_react33.default.useEffect(() => {
-    if (geometryFacet) return;
-    if (!scrollRoot) return;
-    const runtime = scrollRoot.ownerDocument?.defaultView;
-    if (!runtime?.ResizeObserver) return;
-    const observer = new runtime.ResizeObserver(() => refreshRects());
-    observer.observe(scrollRoot);
-    return () => observer.disconnect();
-  }, [geometryFacet, scrollRoot, refreshRects]);
-  import_react33.default.useEffect(() => {
-    if (geometryFacet) return;
-    if (!scrollRoot) return;
-    const runtime = scrollRoot.ownerDocument?.defaultView;
-    if (!runtime?.MutationObserver) return;
-    const observer = new runtime.MutationObserver((records) => {
-      const overlay = overlayRootRef.current;
-      if (overlay) {
-        const allSelf = records.every(
-          (r) => r.target instanceof Node && overlay.contains(r.target)
-        );
-        if (allSelf) return;
-      }
-      refreshRects();
-    });
-    observer.observe(scrollRoot, { childList: true, subtree: false });
-    return () => observer.disconnect();
-  }, [geometryFacet, scrollRoot, refreshRects]);
   import_react33.default.useLayoutEffect(() => {
     if (!pmSurfaceElement) return;
     const overlay = overlayRootRef.current;
@@ -108135,6 +108403,10 @@ function TwTableGripLayer({
     tableGeometry,
     plan.columnsTwips
   );
+  const columnWidthCapability = tableContext.operations.setColumnWidth;
+  const rowHeightCapability = tableContext.operations.setRowHeight;
+  const columnResizeDisabled = !!disabled || !onSetColumnWidth || columnWidthCapability?.enabled === false;
+  const rowResizeDisabled = !!disabled || !onSetRowHeight || rowHeightCapability?.enabled === false;
   return /* @__PURE__ */ (0, import_jsx_runtime61.jsxs)(import_jsx_runtime61.Fragment, { children: [
     plan.columnResizeHandles.map((handle) => {
       const rect3 = resolveColumnEdgeRect(
@@ -108149,7 +108421,8 @@ function TwTableGripLayer({
           colIndex: handle.columnIndex,
           originalTwips: plan.columnsTwips[handle.columnIndex] ?? 720,
           pxPerTwip,
-          disabled: !!disabled || !onSetColumnWidth,
+          disabled: columnResizeDisabled,
+          disabledReason: columnWidthCapability?.reason,
           onCommit: onSetColumnWidth
         },
         `col-${blockId}-${handle.columnIndex}`
@@ -108170,7 +108443,8 @@ function TwTableGripLayer({
           rowIndex,
           originalTwips,
           pxPerTwip,
-          disabled: !!disabled || !onSetRowHeight,
+          disabled: rowResizeDisabled,
+          disabledReason: rowHeightCapability?.reason,
           onCommit: onSetRowHeight
         },
         `row-${blockId}-${rowIndex}`
@@ -108260,6 +108534,7 @@ function ColResizeGrip({
   originalTwips,
   pxPerTwip,
   disabled,
+  disabledReason,
   onCommit
 }) {
   const dragRef = (0, import_react34.useRef)(null);
@@ -108318,11 +108593,13 @@ function ColResizeGrip({
       role: "separator",
       "aria-orientation": "vertical",
       "aria-label": `Resize column ${colIndex + 1}`,
+      "aria-disabled": disabled ? "true" : void 0,
       "data-testid": `col-resize-grip-${colIndex}`,
       "data-active": isActive ? "true" : "false",
+      title: disabled ? disabledReason : void 0,
       className: [
-        "wre-table-grip-col pointer-events-auto absolute",
-        disabled ? "opacity-0 cursor-default" : ""
+        "wre-table-grip-col absolute",
+        disabled ? "pointer-events-none opacity-0 cursor-default" : "pointer-events-auto"
       ].filter(Boolean).join(" "),
       style: {
         left: `calc(${pos.left} - ${GRIP_HIT_PX / 2}px)`,
@@ -108340,6 +108617,7 @@ function RowResizeGrip({
   originalTwips,
   pxPerTwip,
   disabled,
+  disabledReason,
   onCommit
 }) {
   const dragRef = (0, import_react34.useRef)(null);
@@ -108399,11 +108677,13 @@ function RowResizeGrip({
       role: "separator",
       "aria-orientation": "horizontal",
       "aria-label": `Resize row ${rowIndex + 1}`,
+      "aria-disabled": disabled ? "true" : void 0,
       "data-testid": `row-resize-grip-${rowIndex}`,
       "data-active": isActive ? "true" : "false",
+      title: disabled ? disabledReason : void 0,
       className: [
-        "wre-table-grip-row pointer-events-auto absolute",
-        disabled ? "opacity-0 cursor-default" : ""
+        "wre-table-grip-row absolute",
+        disabled ? "pointer-events-none opacity-0 cursor-default" : "pointer-events-auto"
       ].filter(Boolean).join(" "),
       style: {
         left: pos.left,
@@ -109439,45 +109719,17 @@ var TwFloatingImageLayer = ({
   const [pageRects, setPageRects] = React39.useState([]);
   const refreshPageRectsNow = React39.useCallback(() => {
     const pageCount = facet.getPageCount();
-    if (geometryFacet) {
-      const geometryRects = resolvePageOverlayRectsFromGeometry2(
-        geometryFacet,
-        pageCount,
-        visiblePageIndexRange
-      );
-      if (geometryRects !== null) {
-        setPageRects(geometryRects);
-        return;
-      }
-      setPageRects([]);
-      return;
-    }
-    if (!scrollRoot) {
+    if (!geometryFacet) {
       setPageRects([]);
       return;
     }
-    const origin = overlayRootRef.current;
-    if (!origin) {
-      setPageRects([]);
-      return;
-    }
-    const widgets = measureWidgetsViaBoundingRect(scrollRoot, origin, {
+    const geometryRects = resolvePageOverlayRectsFromGeometry2(
+      geometryFacet,
       pageCount,
       visiblePageIndexRange
-    });
-    const originRect = origin.getBoundingClientRect();
-    setPageRects(
-      resolvePageOverlayRects({
-        widgets,
-        pageCount,
-        scrollHeight: (
-          // geometry:allow-dom-fallback
-          origin.clientHeight > 0 ? origin.clientHeight : originRect.height
-        ),
-        visiblePageIndexRange
-      })
     );
-  }, [facet, geometryFacet, scrollRoot, visiblePageIndexRange]);
+    setPageRects(geometryRects ?? []);
+  }, [facet, geometryFacet, visiblePageIndexRange]);
   const refreshPageRects = React39.useCallback(() => {
     if (!scrollRoot) {
       refreshPageRectsNow();
@@ -109507,47 +109759,6 @@ var TwFloatingImageLayer = ({
       }
     };
   }, [refreshPageRects, renderFrameRevision, scrollRoot]);
-  React39.useEffect(() => {
-    if (geometryFacet) {
-      return;
-    }
-    if (!scrollRoot) {
-      return;
-    }
-    const runtime = scrollRoot.ownerDocument?.defaultView;
-    if (!runtime?.ResizeObserver) {
-      return;
-    }
-    const observer = new runtime.ResizeObserver(() => refreshPageRects());
-    observer.observe(scrollRoot);
-    return () => observer.disconnect();
-  }, [geometryFacet, refreshPageRects, scrollRoot]);
-  React39.useEffect(() => {
-    if (geometryFacet) {
-      return;
-    }
-    if (!scrollRoot) {
-      return;
-    }
-    const runtime = scrollRoot.ownerDocument?.defaultView;
-    if (!runtime?.MutationObserver) {
-      return;
-    }
-    const observer = new runtime.MutationObserver((records) => {
-      const overlay = overlayRootRef.current;
-      if (overlay) {
-        const allSelf = records.every(
-          (record) => record.target instanceof Node && overlay.contains(record.target)
-        );
-        if (allSelf) {
-          return;
-        }
-      }
-      refreshPageRects();
-    });
-    observer.observe(scrollRoot, { childList: true, subtree: false });
-    return () => observer.disconnect();
-  }, [geometryFacet, refreshPageRects, scrollRoot]);
   const items = React39.useMemo(() => {
     const viewportScale = geometryFacet?.getViewport().pxPerTwip;
     const pxPerTwip = typeof viewportScale === "number" && viewportScale > 0 ? viewportScale : void 0;
@@ -112526,7 +112737,7 @@ function createOverlaysFamily(ctx) {
     return {
       handle: {
         kind: "table-action",
-        id: tableActionHandle2(documentSeed2(), targetKey),
+        id: tableActionHandle2(documentSeed3(), targetKey),
         targetKind,
         commandFamily,
         scope: tableActionScope(entry)
@@ -112550,9 +112761,9 @@ function createOverlaysFamily(ctx) {
     };
   }
   function tableActionHandle2(seed, targetKey) {
-    return `table-action:${hashOpaque3(`${seed}::${targetKey}`)}`;
+    return `table-action:${hashOpaque4(`${seed}::${targetKey}`)}`;
   }
-  function hashOpaque3(input) {
+  function hashOpaque4(input) {
     let h = 2166136261;
     for (let i = 0; i < input.length; i += 1) {
       h ^= input.charCodeAt(i);
@@ -112560,7 +112771,7 @@ function createOverlaysFamily(ctx) {
     }
     return (h >>> 0).toString(36).padStart(7, "0");
   }
-  function documentSeed2() {
+  function documentSeed3() {
     return ctx.handle.getSessionState().documentId ?? "document";
   }
   function modeledTargetSourceIdentity(target) {
@@ -117036,8 +117247,39 @@ function buildPositionMap(surface) {
     }
     return lastStoryRestorableEntry(entries)?.pmEnd ?? 1;
   };
+  const runtimeToPmWithBias = (runtimePos, bias) => {
+    if (bias > 0) return runtimeToPm(runtimePos);
+    const firstEditable = entries.find(isStoryRuntimeRestorableEntry);
+    if (runtimePos <= 0) {
+      return firstEditable?.pmStart ?? 1;
+    }
+    if (runtimePos >= runtimeStorySize) {
+      return lastStoryRestorableEntry(entries)?.pmEnd ?? pmDocSize - 1;
+    }
+    let previous = null;
+    for (const entry of entries) {
+      if (!isStoryRuntimeRestorableEntry(entry)) {
+        continue;
+      }
+      if (entry.runtimeStart === entry.runtimeEnd && runtimePos === entry.runtimeStart) {
+        return previous?.pmEnd ?? entry.pmStart;
+      }
+      if (runtimePos > entry.runtimeStart && runtimePos <= entry.runtimeEnd) {
+        return entry.pmStart + (runtimePos - entry.runtimeStart);
+      }
+      if (runtimePos <= entry.runtimeStart) {
+        if (runtimePos === entry.runtimeStart && previous) {
+          return previous.pmEnd;
+        }
+        return nearestRuntimeGapPm(runtimePos, previous, entry);
+      }
+      previous = entry;
+    }
+    return lastStoryRestorableEntry(entries)?.pmEnd ?? 1;
+  };
   return {
     runtimeToPm,
+    runtimeToPmWithBias,
     runtimeToPmWithContext(input) {
       const targetEntry = input.editableTarget ? findRestorableEntryForTarget(entries, input.editableTarget, input.runtimePos) : void 0;
       if (targetEntry) {
@@ -119785,9 +120027,10 @@ function buildAnchorPmRange(anchor, positionMap) {
     return null;
   }
   if (anchor.kind === "range") {
+    const mapBoundary = (runtimePos, bias) => positionMap.runtimeToPmWithBias ? positionMap.runtimeToPmWithBias(runtimePos, bias) : positionMap.runtimeToPm(runtimePos);
     return {
-      from: positionMap.runtimeToPm(anchor.from),
-      to: positionMap.runtimeToPm(anchor.to),
+      from: mapBoundary(anchor.from, anchor.assoc?.start ?? 1),
+      to: mapBoundary(anchor.to, anchor.assoc?.end ?? -1),
       allowInline: true
     };
   }
@@ -121494,13 +121737,6 @@ function resolvePmPageBodyPatchPlan(input) {
     ...input.patchPlan.addedPages,
     ...input.patchPlan.removedPages
   ];
-  if (membershipChangedPageIds.length > 0 && input.currentDoc.childCount !== input.nextDoc.childCount) {
-    return {
-      status: "fallback",
-      reason: "page-membership-change",
-      pageIds: membershipChangedPageIds
-    };
-  }
   if (input.currentDoc.childCount !== input.previousSurface.blocks.length || input.nextDoc.childCount !== input.nextSurface.blocks.length) {
     return {
       status: "fallback",
@@ -121577,6 +121813,21 @@ function resolvePmPageBodyPatchPlan(input) {
       ]
     );
   }
+  if (membershipChangedPageIds.length > 0 && !input.currentDoc.eq(input.nextDoc)) {
+    const membershipSpan = resolveTopLevelMembershipPatchSpan({
+      pageIds: membershipChangedPageIds,
+      previousSurface: input.previousSurface,
+      nextSurface: input.nextSurface
+    });
+    if (!membershipSpan) {
+      return {
+        status: "fallback",
+        reason: "page-membership-change",
+        pageIds: membershipChangedPageIds
+      };
+    }
+    rawSpans.push(membershipSpan);
+  }
   if (rawSpans.length === 0) {
     if (membershipChangedPageIds.length > 0 && !input.currentDoc.eq(input.nextDoc)) {
       return {
@@ -121653,17 +121904,17 @@ function resolveNestedPatchSpan(input) {
     (id) => findNestedBlockSpanById(input.nextSurface.blocks, input.nextDoc, id)
   );
   if (previousLocated.some((span) => !span) || nextLocated.some((span) => !span)) {
-    return { status: "fallback", reason: "nested-span-unavailable" };
+    return { status: "top-level" };
   }
   if (previousLocated.some(isUnpatchableVerticalMergeContinuationSpan) || nextLocated.some(isUnpatchableVerticalMergeContinuationSpan)) {
-    return { status: "fallback", reason: "split-row-continuation" };
+    return { status: "top-level" };
   }
   const previousSpans = previousLocated;
   const nextSpans = nextLocated;
   const previousKinds = new Set(previousSpans.map((span) => span.block.kind));
   const nextKinds = new Set(nextSpans.map((span) => span.block.kind));
   if (previousKinds.size !== nextKinds.size || [...previousKinds].some((kind) => !nextKinds.has(kind))) {
-    return { status: "fallback", reason: "nested-span-unavailable" };
+    return { status: "top-level" };
   }
   return {
     status: "nested",
@@ -121686,6 +121937,46 @@ function isUnpatchableVerticalMergeContinuationSpan(span) {
     span?.insideVerticalMergeContinuation && span.fromPm >= span.toPm
   );
 }
+function resolveTopLevelMembershipPatchSpan(input) {
+  const previousBlocks = input.previousSurface.blocks;
+  const nextBlocks = input.nextSurface.blocks;
+  let prefix = 0;
+  while (prefix < previousBlocks.length && prefix < nextBlocks.length && sameTopLevelBlockIdentity(previousBlocks[prefix], nextBlocks[prefix])) {
+    prefix += 1;
+  }
+  let suffix = 0;
+  while (suffix < previousBlocks.length - prefix && suffix < nextBlocks.length - prefix && sameTopLevelBlockIdentity(
+    previousBlocks[previousBlocks.length - 1 - suffix],
+    nextBlocks[nextBlocks.length - 1 - suffix]
+  )) {
+    suffix += 1;
+  }
+  let fromBlockIndex = prefix;
+  let toBlockIndex = previousBlocks.length - suffix;
+  let nextFromBlockIndex = prefix;
+  let nextToBlockIndex = nextBlocks.length - suffix;
+  if (fromBlockIndex === toBlockIndex && nextFromBlockIndex === nextToBlockIndex) {
+    if (previousBlocks.length === 0 && nextBlocks.length === 0) return null;
+    fromBlockIndex = 0;
+    toBlockIndex = previousBlocks.length;
+    nextFromBlockIndex = 0;
+    nextToBlockIndex = nextBlocks.length;
+  }
+  return {
+    pageIds: [...input.pageIds],
+    fromBlockIndex,
+    toBlockIndex,
+    nextFromBlockIndex,
+    nextToBlockIndex,
+    replacedBlockCount: Math.max(
+      toBlockIndex - fromBlockIndex,
+      nextToBlockIndex - nextFromBlockIndex
+    )
+  };
+}
+function sameTopLevelBlockIdentity(left, right) {
+  return Boolean(left && right && left.blockId === right.blockId && left.kind === right.kind);
+}
 function resolveTopLevelFragmentPatchSpans(input) {
   const changedIds = uniqueStableFragmentIds(input.changedFragmentIds);
   if (changedIds.length !== input.changedFragmentIds.length || changedIds.length === 0) {
@@ -121753,6 +122044,7 @@ function findBlockSpanByIdInContainer(input) {
   let cursor = input.contentStartPm;
   for (let blockIndex = 0; blockIndex < input.blocks.length; blockIndex += 1) {
     const block = input.blocks[blockIndex];
+    if (blockIndex >= input.containerNode.childCount) return null;
     const childNode = input.containerNode.child(blockIndex);
     const fromPm = cursor;
     const toPm = fromPm + childNode.nodeSize;
@@ -121792,10 +122084,12 @@ function findBlockSpanByIdInTable(input) {
   let rowCursor = input.tableStartPm + 1;
   for (let rowIndex = 0; rowIndex < input.table.rows.length; rowIndex += 1) {
     const row2 = input.table.rows[rowIndex];
+    if (rowIndex >= input.tableNode.childCount) return null;
     const rowNode = input.tableNode.child(rowIndex);
     let cellCursor = rowCursor + 1;
     for (let cellIndex = 0; cellIndex < row2.cells.length; cellIndex += 1) {
       const cell = row2.cells[cellIndex];
+      if (cellIndex >= rowNode.childCount) return null;
       const cellNode = rowNode.child(cellIndex);
       const found = findBlockSpanByIdInContainer({
         blocks: cell.content,
@@ -133061,6 +133355,216 @@ function createOutlineFamily(runtime) {
   };
 }
 
+// src/api/v3/ai/object.ts
+var applyObjectActionMetadata = {
+  name: "ai.applyObjectAction",
+  status: "live-with-adapter",
+  sourceLayer: "runtime-core",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-object-actions.test.ts",
+    commit: "refactor-09-object-actions"
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "image object layout changes"
+  },
+  agentMetadata: {
+    readOrMutate: "mutate",
+    boundedScope: "scope",
+    auditCategory: "object-action-apply",
+    contextPromptShape: "Apply an image object layout operation to an opaque actionHandle from ai.listObjectActions; preserve-only objects return typed blockers."
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  broadcastsVia: "crdt",
+  rwdReference: "\xA7AI API \xA7 ai.applyObjectAction"
+};
+function createObjectActionFamily(runtime) {
+  const compiler = createScopeCompilerService(runtime);
+  return {
+    listObjectActions(input) {
+      const bundle = compiler.compileBundleById(input.handle.scopeId, input.nowUtc);
+      if (!bundle) {
+        return {
+          scopeId: input.handle.scopeId,
+          actions: [],
+          blockers: [`scope-not-resolvable:${input.handle.scopeId}`]
+        };
+      }
+      const seed = documentSeed2(runtime);
+      return {
+        scopeId: input.handle.scopeId,
+        actions: bundle.evidence.editableTargets?.entries.filter(isSupportedImageObjectEvidence).map((entry) => projectObjectDescriptor(runtime, seed, entry)) ?? []
+      };
+    },
+    applyObjectAction(input) {
+      emitUxResponse(runtime, {
+        apiFn: applyObjectActionMetadata.name,
+        intent: "object-action-apply",
+        mockOrLive: applyObjectActionMetadata.status,
+        uiVisible: true,
+        expectedDelta: applyObjectActionMetadata.uxIntent.expectedDelta
+      });
+      const nowUtc = currentAuditTimestamp(runtime);
+      const proposalId = input.proposalId ?? mockId(documentSeed2(runtime), `object-action-${input.actionHandle || "missing-handle"}-${input.operation.kind}`);
+      if (!input.actionHandle) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-handle-required",
+          category: "unresolved-target",
+          message: "Object actions require an actionHandle from ai.listObjectActions.",
+          nextStep: "Call ai.listObjectActions for the owning scope and retry with one returned actionHandle.",
+          operation: input.operation.kind
+        });
+      }
+      const target = resolveObjectActionHandle(runtime, documentSeed2(runtime), input.actionHandle);
+      if (!target) {
+        return blockedResult2(input, proposalId, {
+          code: `object-action-handle-not-found:${input.actionHandle}`,
+          category: "unresolved-target",
+          message: "No current object action matches the supplied opaque action handle.",
+          nextStep: "Refresh the scope bundle or call ai.listObjectActions before retrying.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      if (!isSupportedImageTarget(target)) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-image-target-required",
+          category: "blocked-target",
+          message: "The supplied object action handle no longer identifies a mutable image target.",
+          nextStep: "Refresh object actions; chart, OLE, custom XML, opaque, and stale object targets remain refused.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      const mediaId = target.object?.mediaId;
+      if (!mediaId) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-media-id-required",
+          category: "blocked-target",
+          message: "Image object layout mutation requires a mediaId-backed target.",
+          nextStep: "Retry only with an image action handle whose readback includes mediaId.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      const before = runtime.getCanonicalDocument();
+      runtime.dispatch({
+        type: "image.set-layout",
+        mediaId,
+        dimensions: {
+          widthEmu: input.operation.dimensions.widthEmu,
+          heightEmu: input.operation.dimensions.heightEmu
+        },
+        origin: { source: "api", timestamp: nowUtc }
+      });
+      const changed = runtime.getCanonicalDocument() !== before;
+      if (!changed) {
+        return blockedResult2(input, proposalId, {
+          code: `object-action-noop:${input.operation.kind}:${input.actionHandle}`,
+          category: "runtime-noop",
+          message: "The runtime accepted the image target but the object operation produced no document change.",
+          nextStep: "Refresh object actions and verify the image media item still exists before retrying.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      return {
+        proposalId,
+        applied: true,
+        changed: true,
+        actionHandle: input.actionHandle,
+        operation: input.operation.kind,
+        commandReference: {
+          command: "image.set-layout",
+          actorId: input.actorId ?? "v3-ai-api",
+          origin: input.origin ?? "agent",
+          emittedAtUtc: nowUtc
+        },
+        readback: objectReadback(runtime, target),
+        posture: "supported",
+        support: objectActionSupport()
+      };
+    }
+  };
+}
+function isSupportedImageObjectEvidence(entry) {
+  return entry.kind === "object-anchor" && entry.commandFamily === "object" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("image-layout") && isImageKind(entry.object?.objectKind) && typeof entry.object?.mediaId === "string";
+}
+function projectObjectDescriptor(runtime, seed, entry) {
+  return {
+    actionHandle: objectActionHandle(seed, entry.targetKey),
+    objectKind: entry.object?.objectKind ?? "unknown",
+    targetKind: entry.kind,
+    relation: entry.relation,
+    callableOperations: ["set-image-layout"],
+    supportedOperations: ["set-image-layout"],
+    readback: objectReadback(runtime, entry),
+    reason: entry.runtimeCommand.reason
+  };
+}
+function resolveObjectActionHandle(runtime, seed, actionHandle) {
+  return collectEditableTargetRefs(runtime.getCanonicalDocument()).find(
+    (target) => objectActionHandle(seed, target.targetKey) === actionHandle && isSupportedImageTarget(target)
+  ) ?? null;
+}
+function isSupportedImageTarget(target) {
+  return target.kind === "object-anchor" && target.commandFamily === "object" && isImageKind(target.object?.objectKind) && typeof target.object?.mediaId === "string" && target.object.mediaId.length > 0 && onlyObjectActionBlockers(target.posture.blockers, ["unmodeled-target"]);
+}
+function isImageKind(kind) {
+  return kind === "legacy-image" || kind === "picture";
+}
+function onlyObjectActionBlockers(blockers, allowed) {
+  const allowedSet = new Set(allowed);
+  return blockers.every((blocker2) => allowedSet.has(blocker2));
+}
+function objectReadback(runtime, target) {
+  const mediaId = target.object?.mediaId;
+  if (!mediaId) return {};
+  const media = runtime.getCanonicalDocument().media.items[mediaId];
+  return {
+    mediaId,
+    ...media?.widthEmu !== void 0 ? { widthEmu: media.widthEmu } : {},
+    ...media?.heightEmu !== void 0 ? { heightEmu: media.heightEmu } : {}
+  };
+}
+function blockedResult2(input, proposalId, detail) {
+  return {
+    proposalId,
+    applied: false,
+    changed: false,
+    actionHandle: input.actionHandle,
+    operation: input.operation.kind,
+    reason: detail.code,
+    blockers: [detail.code],
+    blockerDetails: [detail]
+  };
+}
+function objectActionSupport() {
+  return {
+    undo: "supported",
+    replay: "supported",
+    exportReopen: "supported",
+    audit: "command-reference"
+  };
+}
+function objectActionHandle(seed, targetKey) {
+  return `object-action:${hashOpaque3(`${seed}::${targetKey}`)}`;
+}
+function documentSeed2(runtime) {
+  const state = runtime.getSessionState();
+  return state.documentId ?? "document";
+}
+function hashOpaque3(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36).padStart(7, "0");
+}
+
 // src/api/v3/ai/actions.ts
 function actionMethodMetadata(method, readOrMutate, auditCategory, contextPromptShape, uxIntent) {
   return {
@@ -133105,6 +133609,17 @@ var locateAllMetadata = actionMethodMetadata(
   "Find scope/table-text targets by query; table text matches include readback {text,isEmpty}.",
   { uiVisible: false, expectsUxResponse: "none" }
 );
+var createPlaceholderScopesMetadata = actionMethodMetadata(
+  "createPlaceholderScopes",
+  "mutate",
+  "actions-placeholder-scopes",
+  "Create marker-backed workflow scopes for bracketed placeholder matches in paragraphs, tables, and lists using one bounded regex search.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "scope-created",
+    expectedDelta: "placeholder text ranges become workflow scopes"
+  }
+);
 var rewriteMetadata = actionMethodMetadata(
   "rewrite",
   "mutate",
@@ -133317,6 +133832,7 @@ var ACTION_METHODS = Object.freeze([
   "discover",
   "locate",
   "locateAll",
+  "createPlaceholderScopes",
   "rewrite",
   "rewriteAll",
   "insertText",
@@ -133342,6 +133858,8 @@ var DEFAULT_LOCATE_LIMIT = 20;
 var DEFAULT_REWRITE_ALL_LIMIT = 10;
 var DEFAULT_TABLE_TEXT_SCOPE_LIMIT = 3;
 var DEFAULT_PLAN_STEP_LIMIT = 20;
+var DEFAULT_PLACEHOLDER_QUERY = "\\[[^\\[\\]]{1,200}\\]";
+var DEFAULT_PLACEHOLDER_LIMIT = 200;
 function createActionsFamily(runtime) {
   const category = {
     discover(input) {
@@ -133396,6 +133914,9 @@ function createActionsFamily(runtime) {
     locateAll(input) {
       return locateAll(runtime, input);
     },
+    createPlaceholderScopes(input) {
+      return createPlaceholderScopes(runtime, input ?? {});
+    },
     rewrite(input) {
       if (input.text === void 0) {
         return blockedApply(
@@ -134164,6 +134685,169 @@ function locateAll(runtime, input) {
     ...matches.length === 0 ? { blockers: Object.freeze([`actions:locate:not-found:${input.query}`]) } : {}
   };
 }
+function createPlaceholderScopes(runtime, input) {
+  const query = input.query ?? DEFAULT_PLACEHOLDER_QUERY;
+  if (!query) {
+    const detail = blocker(
+      "actions:placeholder-scopes:query-required",
+      "input",
+      "Placeholder scope creation requires a non-empty query.",
+      "Retry with a non-empty query string or omit query to use the bracketed-placeholder default."
+    );
+    return {
+      status: "blocked",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const limit = Math.max(0, input.limit ?? DEFAULT_PLACEHOLDER_LIMIT);
+  let hits;
+  try {
+    hits = runtime.findAllText(query, {
+      regex: input.regex ?? true,
+      matchCase: input.matchCase ?? true,
+      limit
+    });
+  } catch {
+    const detail = blocker(
+      "actions:placeholder-scopes:invalid-query",
+      "input",
+      "The placeholder query could not be compiled or searched.",
+      "Retry with a valid literal query or JavaScript regex pattern."
+    );
+    return {
+      status: "blocked",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  if (hits.length === 0) {
+    return {
+      status: "not-found",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([`actions:placeholder-scopes:not-found:${query}`])
+    };
+  }
+  const surface = runtime.getRenderSnapshot().surface;
+  const orderedHits = hits.filter((hit) => hit.kind === "range").map((hit, originalIndex) => ({
+    hit,
+    originalIndex,
+    text: surface ? textForSurfaceRange(surface.blocks, hit.from, hit.to) : ""
+  })).sort((a, b) => b.hit.from - a.hit.from || b.originalIndex - a.originalIndex);
+  if (orderedHits.length === 0) {
+    const detail = blocker(
+      "actions:placeholder-scopes:no-range-hits",
+      "unsupported",
+      "The placeholder query matched only projections that cannot be converted into workflow ranges.",
+      "Retry with a text query that resolves to concrete document text ranges."
+    );
+    return {
+      status: "blocked",
+      totalHits: hits.length,
+      created: 0,
+      blocked: hits.length,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const compiler = createScopeCompilerService(runtime);
+  const byOriginalIndex = /* @__PURE__ */ new Map();
+  for (const item of orderedHits) {
+    const text = item.text || query;
+    const label = input.labelPrefix === void 0 ? text : `${input.labelPrefix} ${item.originalIndex + 1}`;
+    const result = createScopeFromAnchor(runtime, {
+      anchor: { from: item.hit.from, to: item.hit.to },
+      mode: input.mode ?? "edit",
+      label,
+      ...input.visibility ? { visibility: input.visibility } : {},
+      ...input.guardPolicy ? { guardPolicy: input.guardPolicy } : {},
+      ...input.assoc ? { assoc: input.assoc } : {},
+      ...input.stableRefHint ? { stableRefHint: input.stableRefHint } : {}
+    });
+    if (result.status === "created") {
+      const compiled = compiler.compileScopeById(result.scopeId)?.scope;
+      byOriginalIndex.set(item.originalIndex, {
+        status: "created",
+        text,
+        excerpt: excerpt(text),
+        scopeId: result.scopeId,
+        ...compiled?.handle ? { handle: compiled.handle } : {}
+      });
+      continue;
+    }
+    const detail = blockerWithOwner(
+      `actions:placeholder-scopes:create-refused:${result.reason}`,
+      "blocked",
+      "The placeholder match could not be converted into a workflow scope.",
+      "Refresh the document and retry; if it still refuses, route the target to the workflow/scope writer owner.",
+      "L06"
+    );
+    byOriginalIndex.set(item.originalIndex, {
+      status: "blocked",
+      text,
+      excerpt: excerpt(text),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    });
+  }
+  const scopes = orderedHits.map((item) => byOriginalIndex.get(item.originalIndex)).filter((value) => value !== void 0);
+  const created = scopes.filter((scope) => scope.status === "created").length;
+  const blocked2 = scopes.length - created;
+  const blockerDetails = scopes.flatMap((scope) => scope.blockerDetails ?? []);
+  return {
+    status: created === scopes.length ? "created" : created > 0 ? "partial" : "blocked",
+    totalHits: hits.length,
+    created,
+    blocked: blocked2,
+    scopes: Object.freeze(scopes),
+    ...blockerDetails.length > 0 ? {
+      blockers: Object.freeze(blockerDetails.map((detail) => detail.code)),
+      blockerDetails: Object.freeze(blockerDetails)
+    } : {}
+  };
+}
+function textForSurfaceRange(blocks, from, to) {
+  let acc = "";
+  const visit = (items) => {
+    for (const block of items) {
+      if (block.kind === "paragraph") {
+        for (const segment of block.segments) {
+          if (segment.kind !== "text") continue;
+          if (segment.from >= to) return;
+          if (segment.to <= from) continue;
+          acc += segment.text.slice(
+            Math.max(0, from - segment.from),
+            Math.min(segment.text.length, to - segment.from)
+          );
+        }
+        continue;
+      }
+      if (block.kind === "table") {
+        for (const row2 of block.rows) {
+          for (const cell of row2.cells) visit(cell.content);
+        }
+        continue;
+      }
+      if (block.kind === "sdt_block") {
+        visit(block.children);
+      }
+    }
+  };
+  visit(blocks);
+  return acc;
+}
 function validateTemplateTargets(runtime, input) {
   if (!Array.isArray(input.targets) || input.targets.length === 0) {
     const detail = blocker(
@@ -134584,6 +135268,15 @@ function applyRewrite(runtime, target, input) {
     if (!listTextTarget.ok) return blockedApplyFromResolution(listTextTarget);
     return applyEditableTextRewrite(runtime, listTextTarget.target, input);
   }
+  const tableTextTarget = uniqueTableTextActionForScope(runtime, target.handle);
+  if (tableTextTarget.ok && tableTextTarget.action.readback?.text === target.scope.content.text) {
+    return applyTableScopedMarkerRewrite(
+      runtime,
+      target,
+      tableTextTarget.action,
+      input
+    );
+  }
   const rewriteBlocker = scopeRewriteCapabilityBlocker(target.scope);
   if (rewriteBlocker) {
     return blockedApply(
@@ -134716,6 +135409,106 @@ function applyEditableTextRewrite(runtime, target, input) {
     afterReadback
   };
 }
+function applyTableScopedMarkerRewrite(runtime, target, action, input) {
+  const workflowScope = runtime.getScope(target.handle.scopeId);
+  const editableTarget = tableEditableTargetForActionHandle(
+    runtime,
+    action.actionHandle
+  );
+  if (!workflowScope || workflowScope.anchor.kind !== "range" || !editableTarget) {
+    return blockedApply(
+      `actions:rewrite:table-marker-target-unresolved:${target.handle.scopeId}`,
+      "unresolved-target",
+      "The table-contained marker scope could not be joined to a current table text target.",
+      "Refresh placeholder scopes and retry; route persistent failures to L08 table scope target mapping."
+    );
+  }
+  const before = runtime.getCanonicalDocument();
+  try {
+    runtime.dispatch({
+      type: "selection.set",
+      selection: {
+        anchor: workflowScope.anchor.from,
+        head: workflowScope.anchor.to,
+        isCollapsed: workflowScope.anchor.from === workflowScope.anchor.to,
+        activeRange: {
+          kind: "range",
+          from: workflowScope.anchor.from,
+          to: workflowScope.anchor.to,
+          assoc: workflowScope.anchor.assoc ?? { start: -1, end: 1 }
+        }
+      },
+      origin: actionOrigin(runtime, input)
+    });
+    runtime.applyActiveStoryTextCommand({
+      type: "text.insert",
+      text: input.text,
+      editableTarget,
+      origin: actionOrigin(runtime, input)
+    });
+  } catch {
+    return blockedApply(
+      `actions:rewrite:table-marker-command-refused:${target.handle.scopeId}`,
+      "blocked",
+      "The table-contained marker scope could not be rewritten by the runtime text command.",
+      "Retry with an exact table text actionHandle; route repeated failures to L07 table text command support.",
+      [
+        blockerWithOwner(
+          `actions:rewrite:table-marker-command-refused:${target.handle.scopeId}`,
+          "blocked",
+          "The table-contained marker scope could not be rewritten by the runtime text command.",
+          "Retry with an exact table text actionHandle; route repeated failures to L07 table text command support.",
+          "L07 runtime text command support"
+        )
+      ]
+    );
+  }
+  const changed = runtime.getCanonicalDocument() !== before;
+  const paragraph = resolveParagraphTextTarget2(
+    runtime.getCanonicalDocument(),
+    editableTarget
+  );
+  const afterText = paragraph ? collectInlineText4(paragraph.children) : void 0;
+  const afterReadback = afterText === void 0 ? void 0 : { text: afterText, isEmpty: afterText.length === 0 };
+  if (!changed || afterReadback?.text !== input.text) {
+    return {
+      status: "blocked",
+      applied: false,
+      changed,
+      target: summarizeTarget({ kind: "table-text", action }),
+      posture: "suspect-readback",
+      blockers: Object.freeze([
+        `actions:rewrite:table-marker-readback-mismatch:${target.handle.scopeId}`
+      ]),
+      blockerDetails: Object.freeze([
+        blocker(
+          `actions:rewrite:table-marker-readback-mismatch:${target.handle.scopeId}`,
+          "blocked",
+          "The table-contained marker rewrite did not produce the requested exact table-cell readback.",
+          "Treat the mutation as suspect. Re-read the target and export before claiming success."
+        )
+      ]),
+      ...afterReadback ? { afterReadback } : {}
+    };
+  }
+  return {
+    status: "applied",
+    applied: true,
+    changed: true,
+    target: summarizeTarget({
+      kind: "table-text",
+      action: { ...action, readback: afterReadback }
+    }),
+    commandReference: {
+      command: "text.insert",
+      actorId: input.actorId ?? "v3-ai-api",
+      origin: input.origin ?? "agent",
+      emittedAtUtc: currentAuditTimestamp(runtime)
+    },
+    ...action.readback ? { beforeReadback: action.readback } : {},
+    afterReadback
+  };
+}
 function projectRewriteScopeResult(runtime, result, target, beforeText, proposedText, documentMutated) {
   if (!result.applied) return projectApplyResult(result, target);
   const compiledAfter = createScopeCompilerService(runtime).compileScopeById(
@@ -134832,6 +135625,51 @@ function tableTextActionsForScope(runtime, handle) {
   });
   return result.actions.filter((action) => action.family === "table-text");
 }
+function uniqueTableTextActionForScope(runtime, handle) {
+  const actions2 = tableTextActionsForScope(runtime, handle).filter(
+    (action) => action.readback !== void 0
+  );
+  if (actions2.length === 1 && actions2[0]) {
+    return { ok: true, action: actions2[0] };
+  }
+  if (actions2.length === 0) {
+    return {
+      ok: false,
+      blockers: Object.freeze(["actions:rewrite:table-text-target-missing"]),
+      blockerDetails: Object.freeze([
+        blocker(
+          "actions:rewrite:table-text-target-missing",
+          "unsupported",
+          "The scope does not expose a unique command-safe table text target.",
+          "Use a paragraph/list scope, or retry with an exact table text actionHandle returned by ai.actions.locateAll."
+        )
+      ])
+    };
+  }
+  return {
+    ok: false,
+    blockers: Object.freeze(["actions:rewrite:table-text-target-ambiguous"]),
+    blockerDetails: Object.freeze([
+      blocker(
+        "actions:rewrite:table-text-target-ambiguous",
+        "ambiguous-target",
+        "The scope exposes multiple table text targets, so broad rewrite would be ambiguous.",
+        "Retry with the exact table text actionHandle returned by ai.actions.locateAll or ai.listTableActions."
+      )
+    ])
+  };
+}
+function tableEditableTargetForActionHandle(runtime, actionHandle) {
+  for (const target of collectEditableTargetRefs(runtime.getCanonicalDocument())) {
+    if (target.commandFamily !== "text-leaf" || target.table?.operationScope !== "text") {
+      continue;
+    }
+    if (deriveTableActionHandleForTarget(runtime, target.targetKey) === actionHandle) {
+      return target;
+    }
+  }
+  return null;
+}
 function editableTextActionsForScope(runtime, handle) {
   const bundle = createScopeCompilerService(runtime).compileBundleById(
     handle.scopeId,
@@ -136355,6 +137193,7 @@ function createApiV3(handle, opts) {
     ...createStatsFamily(handle),
     ...createOutlineFamily(handle),
     ...createTableActionFamily(handle),
+    ...createObjectActionFamily(handle),
     ...createActionsFamily(handle)
   };
   const runtime = {
@@ -139162,6 +140001,9 @@ var WordReviewEditor = (0, import_react71.forwardRef)(
         onUpdateFields: () => {
           activeRuntime.updateFields();
         },
+        onUpdateTableOfContents: () => {
+          activeRuntime.updateTableOfContents();
+        },
         onAskAgentForSelection: () => {
           const { selection } = snapshot;
           onEventRef.current?.({