@beyondwork/docx-react-component 1.0.124 → 1.0.126

package/dist/index.cjs

@@ -6965,7 +6965,7 @@ function createParagraphEditableTarget(paragraph, kind, storyKey2, blockPath, ta
     context: { storyKey: storyKey2, insideSdt: contentControl !== void 0 },
     ...tableTarget
   }) : void 0;
-  const listAddress = tableIdentity === void 0 && paragraph.numbering !== void 0 ? createCanonicalAddress({
+  const listAddress = paragraph.numbering !== void 0 ? createCanonicalAddress({
     addressKind: "list-item-text",
     storyKey: storyKey2,
     staleCheckKind: "paragraph",
@@ -6999,6 +6999,7 @@ function createParagraphEditableTarget(paragraph, kind, storyKey2, blockPath, ta
     ...contentControl !== void 0 ? { contentControl } : {},
     ...tableIdentity !== void 0 ? { table: tableIdentity } : {},
     ...editableOwner !== void 0 ? { editableOwner } : {},
+    ...listAddress !== void 0 ? { listAddress } : {},
     ...tableIdentity !== void 0 ? {
       canonicalAddress: createTableTargetCanonicalAddress(
         tableIdentity,
@@ -7862,6 +7863,9 @@ function validateEditableTargetRef(value, path = "$") {
   if (record.canonicalAddress !== void 0) {
     validateTargetCanonicalAddress(record.canonicalAddress, `${path}.canonicalAddress`, issues);
   }
+  if (record.listAddress !== void 0) {
+    validateTargetCanonicalAddress(record.listAddress, `${path}.listAddress`, issues);
+  }
   const staleCheck = asPlainObject(record.staleCheck, `${path}.staleCheck`, issues);
   if (staleCheck) {
     if (staleCheck.paragraphTextHash !== void 0) {
@@ -9850,6 +9854,7 @@ function mergeLevelDefinition(base, override, startOverride, fallbackLevel) {
   );
   const runProperties = override?.runProperties ?? base?.runProperties;
   const restartAfterLevel = override?.restartAfterLevel ?? base?.restartAfterLevel;
+  const picBulletId = override?.picBulletId ?? base?.picBulletId;
   return {
     level,
     format,
@@ -9860,7 +9865,8 @@ function mergeLevelDefinition(base, override, startOverride, fallbackLevel) {
     ...override?.suffix ?? base?.suffix ? { suffix: override?.suffix ?? base?.suffix } : {},
     ...paragraphGeometry ? { paragraphGeometry } : {},
     ...runProperties ? { runProperties } : {},
-    ...restartAfterLevel !== void 0 ? { restartAfterLevel } : {}
+    ...restartAfterLevel !== void 0 ? { restartAfterLevel } : {},
+    ...picBulletId !== void 0 ? { picBulletId } : {}
   };
 }
 function withDefaultStartAt(level) {
@@ -9988,7 +9994,7 @@ function resolveHangingWidth(indentation) {
 // src/runtime/formatting/numbering/prefix.ts
 function createNumberingPrefixResolver(catalog) {
   const sequenceStates = /* @__PURE__ */ new Map();
-  function resolveInternal(numbering, paragraph) {
+  function resolveInternal(numbering, paragraph, options = {}) {
     const resolved = resolveNumberingDefinitionSet(
       catalog,
       paragraph?.numbering ?? numbering,
@@ -10001,29 +10007,44 @@ function createNumberingPrefixResolver(catalog) {
     if (!resolvedNumbering) {
       return null;
     }
-    const sequenceState = getSequenceState(sequenceStates, resolvedNumbering.numberingInstanceId);
-    advanceSequence(sequenceState, resolved.effectiveLevel.level, resolved.effectiveLevels);
+    const advance = options.advance !== false;
+    const sequenceState = getSequenceState(
+      sequenceStates,
+      resolvedNumbering.numberingInstanceId,
+      { create: advance }
+    );
+    if (!sequenceState) {
+      return null;
+    }
+    const workingState = advance ? sequenceState : cloneSequenceState(sequenceState);
+    advanceSequence(workingState, resolved.effectiveLevel.level, resolved.effectiveLevels);
+    const currentCounter = workingState.counters[resolved.effectiveLevel.level];
     const effectiveLevelDefs = resolved.effectiveLevel.isLegalNumbering ? new Map(
       Array.from(resolved.effectiveLevels.entries()).map(([level, definition]) => [
         level,
         { ...definition, format: "decimal" }
       ])
     ) : resolved.effectiveLevels;
+    const picBulletId = resolved.effectiveLevel.picBulletId;
     const text = renderLevelText(
       resolved.effectiveLevel.text,
-      sequenceState.counters,
+      workingState.counters,
       effectiveLevelDefs
     );
-    if (resolved.effectiveLevel.format !== "none" && text === null) {
+    if (picBulletId == null && resolved.effectiveLevel.format !== "none" && text === null) {
       return null;
     }
     const visibleText = resolved.effectiveLevel.format === "none" ? null : text;
-    const picBulletId = resolved.effectiveLevel.picBulletId;
+    const formatPosture = getNumberingFormatPosture(
+      resolved.effectiveLevel.format,
+      currentCounter
+    );
     const picBulletMediaId = picBulletId != null ? catalog.numPicBullets?.[picBulletId]?.mediaId : void 0;
     return {
       text: visibleText,
       level: resolved.effectiveLevel.level,
       format: resolved.effectiveLevel.format,
+      ...formatPosture !== void 0 ? { formatPosture } : {},
       startAt: resolved.effectiveLevel.startAt ?? DEFAULT_NUMBERING_START_AT,
       ...resolved.effectiveLevel.suffix ? { suffix: resolved.effectiveLevel.suffix } : {},
       ...resolved.effectiveLevel.paragraphStyleId ? { paragraphStyleId: resolved.effectiveLevel.paragraphStyleId } : {},
@@ -10034,23 +10055,26 @@ function createNumberingPrefixResolver(catalog) {
     };
   }
   return {
-    resolve(numbering) {
-      const result = resolveInternal(numbering);
+    resolve(numbering, options) {
+      const result = resolveInternal(numbering, void 0, options);
       return result?.text ?? null;
     },
-    resolveDetailed(numbering, paragraph) {
-      return resolveInternal(numbering, paragraph);
+    resolveDetailed(numbering, paragraph, options) {
+      return resolveInternal(numbering, paragraph, options);
     },
-    resolveParagraph(paragraph) {
-      return resolveInternal(paragraph.numbering, paragraph);
+    resolveParagraph(paragraph, options) {
+      return resolveInternal(paragraph.numbering, paragraph, options);
     }
   };
 }
-function getSequenceState(states, numberingInstanceId) {
+function getSequenceState(states, numberingInstanceId, options = { create: true }) {
   const existing = states.get(numberingInstanceId);
   if (existing) {
     return existing;
   }
+  if (options.create === false) {
+    return { counters: [], lastLevel: null };
+  }
   const created = {
     counters: [],
     lastLevel: null
@@ -10058,6 +10082,12 @@ function getSequenceState(states, numberingInstanceId) {
   states.set(numberingInstanceId, created);
   return created;
 }
+function cloneSequenceState(state) {
+  return {
+    counters: [...state.counters],
+    lastLevel: state.lastLevel
+  };
+}
 function advanceSequence(state, currentLevel, levelDefinitions) {
   for (let level = currentLevel + 1; level < state.counters.length; level += 1) {
     if (shouldResetDeeperLevel(level, currentLevel, levelDefinitions)) {
@@ -10089,6 +10119,25 @@ function shouldResetDeeperLevel(level, triggeringLevel, levelDefinitions) {
 function getLevelStartAt(level, levelDefinitions) {
   return levelDefinitions.get(level)?.startAt ?? DEFAULT_NUMBERING_START_AT;
 }
+function getNumberingFormatPosture(format, value) {
+  if (!isSupportedNumberingFormat(format)) {
+    return {
+      status: "approximated",
+      requestedFormat: format,
+      renderedFormat: "decimal",
+      reason: "unsupported-numbering-format-decimal-fallback"
+    };
+  }
+  if (value !== void 0 && ((format === "upperRoman" || format === "lowerRoman") && (value <= 0 || value >= 4e3) || (format === "cardinalText" || format === "ordinalText") && (!Number.isInteger(value) || value < 1 || value > 999) || (format === "upperLetter" || format === "lowerLetter" || format === "chicago") && value < 1)) {
+    return {
+      status: "approximated",
+      requestedFormat: format,
+      renderedFormat: "decimal",
+      reason: "numbering-format-range-decimal-fallback"
+    };
+  }
+  return void 0;
+}
 function renderLevelText(text, counters, levelDefinitions) {
   if (!text) {
     return null;
@@ -10931,6 +10980,7 @@ function toNumberingLayoutInput(numbering) {
     associatedTabStops: toLayoutTabStops(numbering.geometry.tabStops, "numbering"),
     level: numbering.level,
     format: numbering.format,
+    ...numbering.formatPosture !== void 0 ? { formatPosture: { ...numbering.formatPosture } } : {},
     startAt: numbering.startAt,
     ...numbering.isLegalNumbering ? { isLegalNumbering: true } : {},
     ...numbering.picBulletMediaId ? { pictureBulletMediaId: numbering.picBulletMediaId } : {}
@@ -11160,13 +11210,10 @@ var FormattingContextImpl = class {
     const effectiveNumbering = this.resolveEffectiveParagraphNumbering(para);
     if (!effectiveNumbering) return null;
     if (!emitGeometry) {
-      if (advance) this.numbering.resolve(effectiveNumbering);
+      this.numbering.resolve(effectiveNumbering, { advance });
       return null;
     }
-    if (!advance) {
-      console.warn("[formatting-context] resolveParagraphNumbering({advance:false}) is not supported; counter always advances");
-    }
-    return this.numbering.resolveDetailed(effectiveNumbering, para);
+    return this.numbering.resolveDetailed(effectiveNumbering, para, { advance });
   }
   resolveNumberingLayoutInput(para, options = {}) {
     return toNumberingLayoutInput(this.resolveParagraphNumbering(para, options));
@@ -13442,6 +13489,7 @@ function toSurfaceResolvedNumbering(numbering) {
   return {
     level: numbering.level,
     format: numbering.format,
+    ...numbering.formatPosture !== void 0 ? { formatPosture: { ...numbering.formatPosture } } : {},
     ...numbering.text !== null ? { text: numbering.text } : {},
     startAt: numbering.startAt,
     ...numbering.paragraphStyleId ? { paragraphStyleId: numbering.paragraphStyleId } : {},
@@ -18161,8 +18209,9 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
   const perPageCounter = /* @__PURE__ */ new Map();
   const fieldRegionsByParagraphIndex = buildFieldRegionsByParagraphIndex(fieldRegions);
   const generatedTargets = buildGeneratedTargets(editableTargets);
+  const numberingTargets = buildNumberingTargets(editableTargets);
   const bookmarkRanges = buildBookmarkRanges(editableTargets);
-  const numberingByParagraphIndex = buildNumberingByParagraphIndex(numberingInputs);
+  const numberingIndex = buildNumberingInputIndex(numberingInputs);
   const pushFragment = (pageIndex, fragment) => {
     const existing = byPage.get(pageIndex);
     if (existing) {
@@ -18198,8 +18247,9 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
           },
           fieldRegionsByParagraphIndex,
           generatedTargets,
+          numberingTargets,
           bookmarkRanges,
-          numberingByParagraphIndex,
+          numberingIndex,
           blockPath
         );
         continue;
@@ -18220,8 +18270,9 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
         },
         fieldRegionsByParagraphIndex,
         generatedTargets,
+        numberingTargets,
         bookmarkRanges,
-        numberingByParagraphIndex,
+        numberingIndex,
         blockPath
       );
       continue;
@@ -18253,8 +18304,9 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
         paginationRole: "whole",
         fieldRegionsByParagraphIndex,
         generatedTargets,
+        numberingTargets,
         bookmarkRanges,
-        numberingByParagraphIndex,
+        numberingIndex,
         blockPath
       }),
       ...columnIndex !== void 0 ? { columnIndex } : {}
@@ -18401,7 +18453,7 @@ function buildRunAnchorsForLine(input) {
   }
   return anchors;
 }
-function emitSlicedParagraph(block, slices, emit2, fieldRegionsByParagraphIndex = /* @__PURE__ */ new Map(), generatedTargets = [], bookmarkRanges = [], numberingByParagraphIndex = /* @__PURE__ */ new Map(), blockPath) {
+function emitSlicedParagraph(block, slices, emit2, fieldRegionsByParagraphIndex = /* @__PURE__ */ new Map(), generatedTargets = [], numberingTargets = [], bookmarkRanges = [], numberingIndex = EMPTY_NUMBERING_INPUT_INDEX, blockPath) {
   for (let i = 0; i < slices.length; i += 1) {
     const slice = slices[i];
     const heightTwips = slice.heightTwips ?? estimateSliceHeightFromLines(slice.lineRange);
@@ -18426,8 +18478,9 @@ function emitSlicedParagraph(block, slices, emit2, fieldRegionsByParagraphIndex
         paginationRole: slice.lineRange.from > 0 ? "continuation" : "slice",
         fieldRegionsByParagraphIndex,
         generatedTargets,
+        numberingTargets,
         bookmarkRanges,
-        numberingByParagraphIndex,
+        numberingIndex,
         blockPath
       })
     };
@@ -18448,7 +18501,7 @@ function estimateSliceHeightFromLines(lineRange) {
   const lines = Math.max(0, lineRange.to - lineRange.from);
   return lines * 240;
 }
-function emitSlicedTable(block, slices, emit2, fieldRegionsByParagraphIndex = /* @__PURE__ */ new Map(), generatedTargets = [], bookmarkRanges = [], numberingByParagraphIndex = /* @__PURE__ */ new Map(), blockPath) {
+function emitSlicedTable(block, slices, emit2, fieldRegionsByParagraphIndex = /* @__PURE__ */ new Map(), generatedTargets = [], numberingTargets = [], bookmarkRanges = [], numberingIndex = EMPTY_NUMBERING_INPUT_INDEX, blockPath) {
   for (let i = 0; i < slices.length; i += 1) {
     const slice = slices[i];
     const heightTwips = slice.heightTwips ?? estimateSliceHeightFromRows(slice.rowRange);
@@ -18472,8 +18525,9 @@ function emitSlicedTable(block, slices, emit2, fieldRegionsByParagraphIndex = /*
         paginationRole: slice.rowRange.from > 0 ? "continuation" : "slice",
         fieldRegionsByParagraphIndex,
         generatedTargets,
+        numberingTargets,
         bookmarkRanges,
-        numberingByParagraphIndex,
+        numberingIndex,
         blockPath
       }),
       ...slice.columnIndex !== void 0 ? { columnIndex: slice.columnIndex } : {}
@@ -18547,7 +18601,8 @@ function buildFragmentLayoutObject(input) {
   const numberingRows = collectNumberingLayoutFactsForBlock(
     input.block,
     input.blockPath,
-    input.numberingByParagraphIndex
+    input.numberingIndex,
+    input.numberingTargets
   );
   const numbering = input.block.kind === "paragraph" ? numberingRows[0] : void 0;
   const fieldRegions = collectFieldRegionLayoutFacts(
@@ -18718,6 +18773,11 @@ function buildGeneratedTargets(targets) {
     (target) => target.kind === "field-result-text" || target.kind === "hyperlink-text" || target.kind === "hyperlink-destination" || target.kind === "bookmark-anchor" || target.kind === "bookmark-content-range"
   );
 }
+function buildNumberingTargets(targets) {
+  return targets.filter(
+    (target) => target.listAddress !== void 0 || target.canonicalAddress?.addressKind === "list-item-text"
+  );
+}
 function buildBookmarkRanges(targets) {
   const anchors = /* @__PURE__ */ new Map();
   const contentRanges = /* @__PURE__ */ new Map();
@@ -18765,14 +18825,27 @@ function buildBookmarkRanges(targets) {
   }
   return ranges;
 }
-function buildNumberingByParagraphIndex(numberingInputs) {
+var EMPTY_NUMBERING_INPUT_INDEX = {
+  byNumberingKey: /* @__PURE__ */ new Map(),
+  byBlockPath: /* @__PURE__ */ new Map(),
+  byParagraphIndex: /* @__PURE__ */ new Map()
+};
+function buildNumberingInputIndex(numberingInputs) {
+  const byNumberingKey = /* @__PURE__ */ new Map();
+  const byBlockPath = /* @__PURE__ */ new Map();
   const byParagraph = /* @__PURE__ */ new Map();
   for (const input of numberingInputs) {
+    if (!byNumberingKey.has(input.numberingKey)) {
+      byNumberingKey.set(input.numberingKey, input);
+    }
+    if (!byBlockPath.has(input.blockPath)) {
+      byBlockPath.set(input.blockPath, input);
+    }
     if (!byParagraph.has(input.paragraphIndex)) {
       byParagraph.set(input.paragraphIndex, input);
     }
   }
-  return byParagraph;
+  return { byNumberingKey, byBlockPath, byParagraphIndex: byParagraph };
 }
 function collectBookmarkRangeLayoutFacts(fragmentId, blockPath, bookmarkRanges) {
   if (!blockPath || !bookmarkRanges || bookmarkRanges.length === 0) return [];
@@ -18853,6 +18926,7 @@ function collectNumberingLayoutFacts(block) {
     ...block.numbering?.numberingInstanceId !== void 0 ? { numberingInstanceId: block.numbering.numberingInstanceId } : {},
     ...block.numbering?.level !== void 0 ? { level: block.numbering.level } : {},
     ...block.resolvedNumbering?.format !== void 0 ? { format: block.resolvedNumbering.format } : {},
+    ...block.resolvedNumbering?.formatPosture !== void 0 ? { formatPosture: { ...block.resolvedNumbering.formatPosture } } : {},
     ...block.numberingPrefix !== void 0 ? { markerText: block.numberingPrefix } : {},
     ...block.numberingSuffix !== void 0 ? { markerSuffix: block.numberingSuffix } : {},
     ...block.resolvedNumbering?.geometry.markerJustification !== void 0 ? { markerJustification: block.resolvedNumbering.geometry.markerJustification } : {},
@@ -18880,15 +18954,21 @@ function collectNumberingLayoutFacts(block) {
     } : {}
   };
 }
-function collectNumberingLayoutFactsForBlock(block, blockPath, numberingByParagraphIndex) {
+function collectNumberingLayoutFactsForBlock(block, blockPath, numberingIndex, numberingTargets = []) {
   const rows = [];
   const seen = /* @__PURE__ */ new Set();
   visitParagraphBlocks(block, (paragraph, context) => {
     const numbering = collectNumberingLayoutFacts(paragraph);
     if (!numbering) return;
     const paragraphIndex = parseParagraphBlockIndex(paragraph.blockId);
-    const canonical = paragraphIndex !== void 0 ? numberingByParagraphIndex?.get(paragraphIndex) : void 0;
     const numberingKey = context.path !== void 0 ? `main:${context.path}:numbering` : void 0;
+    const canonical = lookupNumberingInput(
+      numberingIndex,
+      numberingKey,
+      context.path,
+      paragraphIndex
+    );
+    const target = findNumberingTarget(numberingTargets, context.path);
     const numberingLayoutId = numberingKey ?? [
       "numbering",
       paragraph.blockId,
@@ -18897,6 +18977,7 @@ function collectNumberingLayoutFactsForBlock(block, blockPath, numberingByParagr
     ].join(":");
     if (seen.has(numberingLayoutId)) return;
     seen.add(numberingLayoutId);
+    const unavailableReasons = collectNumberingUnavailableReasons(numbering, canonical);
     rows.push({
       numberingLayoutId,
       ...numberingKey !== void 0 ? { numberingKey } : {},
@@ -18904,6 +18985,10 @@ function collectNumberingLayoutFactsForBlock(block, blockPath, numberingByParagr
       ...canonical?.blockPath !== void 0 ? { sourceBlockPath: canonical.blockPath } : context.path !== void 0 ? { sourceBlockPath: context.path } : {},
       sourceBlockId: paragraph.blockId,
       ...paragraphIndex !== void 0 ? { paragraphIndex } : {},
+      ...target?.targetKey !== void 0 ? { targetKey: target.targetKey } : {},
+      ...target?.kind !== void 0 ? { targetKind: target.kind } : {},
+      ...target?.canonicalAddress?.addressKey !== void 0 ? { canonicalAddressKey: target.canonicalAddress.addressKey } : {},
+      ...target?.listAddress?.addressKey !== void 0 ? { listAddressKey: target.listAddress.addressKey } : {},
       ...canonical?.sourceRef !== void 0 ? { sourceRef: { ...canonical.sourceRef } } : {},
       ...canonical?.numberingSourceRef !== void 0 ? { numberingSourceRef: { ...canonical.numberingSourceRef } } : {},
       ...canonical?.numberingOrigin !== void 0 ? { numberingOrigin: canonical.numberingOrigin } : {},
@@ -18911,11 +18996,41 @@ function collectNumberingLayoutFactsForBlock(block, blockPath, numberingByParagr
       ...canonical?.numberingInstanceSourceRef !== void 0 ? { numberingInstanceSourceRef: { ...canonical.numberingInstanceSourceRef } } : {},
       ...canonical?.abstractNumberingId !== void 0 ? { abstractNumberingId: canonical.abstractNumberingId } : {},
       ...canonical?.abstractNumberingSourceRef !== void 0 ? { abstractNumberingSourceRef: { ...canonical.abstractNumberingSourceRef } } : {},
-      ...numbering
+      ...numbering,
+      ...unavailableReasons.length > 0 ? { unavailableReasons } : {}
     });
   }, blockPath);
   return rows;
 }
+function findNumberingTarget(numberingTargets, blockPath) {
+  if (blockPath === void 0) return void 0;
+  return numberingTargets.find((target) => target.blockPath === blockPath);
+}
+function lookupNumberingInput(numberingIndex, numberingKey, blockPath, paragraphIndex) {
+  if (!numberingIndex) return void 0;
+  if (numberingKey !== void 0) {
+    const byKey = numberingIndex.byNumberingKey.get(numberingKey);
+    if (byKey !== void 0) return byKey;
+  }
+  if (blockPath !== void 0) {
+    const byPath = numberingIndex.byBlockPath.get(blockPath);
+    if (byPath !== void 0) return byPath;
+  }
+  return paragraphIndex !== void 0 ? numberingIndex.byParagraphIndex.get(paragraphIndex) : void 0;
+}
+function collectNumberingUnavailableReasons(numbering, canonical) {
+  const reasons = [];
+  if (canonical === void 0) {
+    reasons.push("canonical-numbering-input-missing");
+  }
+  if (numbering.markerLane === void 0) {
+    reasons.push("numbering-marker-lane-unavailable");
+  }
+  if (numbering.textColumn === void 0) {
+    reasons.push("numbering-text-column-unavailable");
+  }
+  return reasons;
+}
 function findPageIndexForOffset(pages, offset) {
   for (let i = 0; i < pages.length; i += 1) {
     const page = pages[i];
@@ -19320,8 +19435,8 @@ async function createCanvasProvider(fontLoader) {
 }
 
 // src/runtime/layout/layout-engine-version.ts
-var LAYOUT_ENGINE_VERSION = 87;
-var LAYCACHE_SCHEMA_VERSION = 11;
+var LAYOUT_ENGINE_VERSION = 88;
+var LAYCACHE_SCHEMA_VERSION = 12;
 
 // src/runtime/layout/layout-engine-instance.ts
 var FULL_VIEWPORT_WINDOW_KEY = "full";
@@ -21886,19 +22001,19 @@ function clamp(value, min, max) {
 }
 
 // src/core/commands/list-commands.ts
-function toggleNumberedList(document2, paragraphIndexes, context) {
-  return toggleListKind(document2, paragraphIndexes, "numbered", context);
+function toggleNumberedList(document2, paragraphIndexes, context, options = {}) {
+  return toggleListKind(document2, paragraphIndexes, "numbered", context, options);
 }
-function toggleBulletedList(document2, paragraphIndexes, context) {
-  return toggleListKind(document2, paragraphIndexes, "bulleted", context);
+function toggleBulletedList(document2, paragraphIndexes, context, options = {}) {
+  return toggleListKind(document2, paragraphIndexes, "bulleted", context, options);
 }
-function indentListItems(document2, paragraphIndexes, context) {
-  return adjustListLevels(document2, paragraphIndexes, 1, context);
+function indentListItems(document2, paragraphIndexes, context, options = {}) {
+  return adjustListLevels(document2, paragraphIndexes, 1, context, options);
 }
-function outdentListItems(document2, paragraphIndexes, context) {
-  return adjustListLevels(document2, paragraphIndexes, -1, context);
+function outdentListItems(document2, paragraphIndexes, context, options = {}) {
+  return adjustListLevels(document2, paragraphIndexes, -1, context, options);
 }
-function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context) {
+function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context, options = {}) {
   if (!paragraphIsEmpty) {
     return {
       document: document2,
@@ -21908,7 +22023,30 @@ function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context
   }
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const target = paragraphs[paragraphIndex];
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    [paragraphIndex],
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      action: "blocked",
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const resolvedParagraphIndex = resolved.paragraphIndexes[0];
+  if (resolvedParagraphIndex === void 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      action: "split"
+    };
+  }
+  const target = paragraphs[resolvedParagraphIndex];
   if (!target?.numbering) {
     return {
       document: working,
@@ -21923,21 +22061,44 @@ function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context
     };
     return {
       document: working,
-      affectedParagraphIndexes: [paragraphIndex],
+      affectedParagraphIndexes: [resolvedParagraphIndex],
       action: "outdented"
     };
   }
   delete target.numbering;
   return {
     document: working,
-    affectedParagraphIndexes: [paragraphIndex],
+    affectedParagraphIndexes: [resolvedParagraphIndex],
     action: "removed"
   };
 }
-function backspaceAtListStart(document2, paragraphIndex, context) {
+function backspaceAtListStart(document2, paragraphIndex, context, options = {}) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const target = paragraphs[paragraphIndex];
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    [paragraphIndex],
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      handled: true,
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const resolvedParagraphIndex = resolved.paragraphIndexes[0];
+  if (resolvedParagraphIndex === void 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      handled: false
+    };
+  }
+  const target = paragraphs[resolvedParagraphIndex];
   if (!target?.numbering) {
     return {
       document: working,
@@ -21955,14 +22116,35 @@ function backspaceAtListStart(document2, paragraphIndex, context) {
   }
   return {
     document: working,
-    affectedParagraphIndexes: [paragraphIndex],
+    affectedParagraphIndexes: [resolvedParagraphIndex],
     handled: true
   };
 }
-function restartNumbering(document2, paragraphIndex, context, startAt = 1) {
+function restartNumbering(document2, paragraphIndex, context, startAt = 1, options = {}) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const target = paragraphs[paragraphIndex];
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    [paragraphIndex],
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const resolvedParagraphIndex = resolved.paragraphIndexes[0];
+  if (resolvedParagraphIndex === void 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: []
+    };
+  }
+  const target = paragraphs[resolvedParagraphIndex];
   if (!target?.numbering) {
     return {
       document: working,
@@ -21987,7 +22169,7 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1) {
     })
   };
   const affectedParagraphIndexes = [];
-  for (let index = paragraphIndex; index < paragraphs.length; index += 1) {
+  for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
     const paragraph = paragraphs[index];
     if (!paragraph?.numbering) {
       break;
@@ -22008,10 +22190,31 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1) {
     createdNumberingInstanceId: numberingInstanceId
   };
 }
-function continueNumbering(document2, paragraphIndex, context) {
+function continueNumbering(document2, paragraphIndex, context, options = {}) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const target = paragraphs[paragraphIndex];
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    [paragraphIndex],
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const resolvedParagraphIndex = resolved.paragraphIndexes[0];
+  if (resolvedParagraphIndex === void 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: []
+    };
+  }
+  const target = paragraphs[resolvedParagraphIndex];
   if (!target?.numbering) {
     return {
       document: working,
@@ -22030,7 +22233,7 @@ function continueNumbering(document2, paragraphIndex, context) {
   const compatibleInstanceId = findPreviousCompatibleInstance(
     paragraphs,
     catalog,
-    paragraphIndex,
+    resolvedParagraphIndex,
     currentKind
   );
   if (!compatibleInstanceId || compatibleInstanceId === currentInstanceId) {
@@ -22040,7 +22243,7 @@ function continueNumbering(document2, paragraphIndex, context) {
     };
   }
   const affectedParagraphIndexes = [];
-  for (let index = paragraphIndex; index < paragraphs.length; index += 1) {
+  for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
     const paragraph = paragraphs[index];
     if (!paragraph?.numbering) {
       break;
@@ -22061,10 +22264,24 @@ function continueNumbering(document2, paragraphIndex, context) {
     createdNumberingInstanceId: compatibleInstanceId
   };
 }
-function toggleListKind(document2, paragraphIndexes, kind, context) {
+function toggleListKind(document2, paragraphIndexes, kind, context, options) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const normalizedIndexes = normalizeParagraphIndexes(paragraphs, paragraphIndexes);
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    paragraphIndexes,
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const normalizedIndexes = resolved.paragraphIndexes;
   if (normalizedIndexes.length === 0) {
     return {
       document: working,
@@ -22101,10 +22318,24 @@ function toggleListKind(document2, paragraphIndexes, kind, context) {
     createdNumberingInstanceId: numberingInstanceId
   };
 }
-function adjustListLevels(document2, paragraphIndexes, delta, context) {
+function adjustListLevels(document2, paragraphIndexes, delta, context, options) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const affectedParagraphIndexes = normalizeParagraphIndexes(paragraphs, paragraphIndexes).filter(
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    paragraphIndexes,
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const affectedParagraphIndexes = resolved.paragraphIndexes.filter(
     (index) => Boolean(paragraphs[index]?.numbering)
   );
   for (const index of affectedParagraphIndexes) {
@@ -22122,6 +22353,121 @@ function adjustListLevels(document2, paragraphIndexes, delta, context) {
     affectedParagraphIndexes
   };
 }
+function normalizeListCommandTargets(options) {
+  if (options.editableTargets !== void 0) return options.editableTargets;
+  return options.editableTarget ? [options.editableTarget] : [];
+}
+function resolveListCommandParagraphIndexes(document2, paragraphs, paragraphIndexes, context, editableTargets) {
+  if (editableTargets.length === 0) {
+    return { paragraphIndexes: normalizeParagraphIndexes(paragraphs, paragraphIndexes) };
+  }
+  const currentTargets = collectEditableTargetRefs(document2, context.editableTargetCache);
+  const paragraphIndexByTargetKey = /* @__PURE__ */ new Map();
+  let paragraphIndex = 0;
+  for (const target of currentTargets) {
+    if (!isParagraphTextTarget(target)) continue;
+    if (!paragraphIndexByTargetKey.has(target.targetKey)) {
+      paragraphIndexByTargetKey.set(target.targetKey, paragraphIndex);
+      paragraphIndex += 1;
+    }
+  }
+  const resolvedIndexes = [];
+  for (const target of editableTargets) {
+    const blockedReason = validateListCommandTarget(target, currentTargets, context);
+    if (blockedReason) return { paragraphIndexes: [], blockedReason };
+    const current = findCurrentListCommandTarget(target, currentTargets);
+    if (!current) {
+      return {
+        paragraphIndexes: [],
+        blockedReason: {
+          code: "list_target_not_found",
+          message: "List editable target no longer resolves in the current canonical document."
+        }
+      };
+    }
+    if (!sameResolvedListCommandTarget(target, current)) {
+      return {
+        paragraphIndexes: [],
+        blockedReason: {
+          code: "list_target_stale",
+          message: "List editable target is stale for the current canonical document."
+        }
+      };
+    }
+    const currentIndex = paragraphIndexByTargetKey.get(current.targetKey);
+    if (currentIndex === void 0) {
+      return {
+        paragraphIndexes: [],
+        blockedReason: {
+          code: "list_target_position_unavailable",
+          message: "List editable target resolved but could not be mapped to a current paragraph."
+        }
+      };
+    }
+    resolvedIndexes.push(currentIndex);
+  }
+  return { paragraphIndexes: normalizeParagraphIndexes(paragraphs, resolvedIndexes) };
+}
+function validateListCommandTarget(target, currentTargets, context) {
+  const shapeIssues = validateEditableTargetRef(target);
+  if (shapeIssues.length > 0) {
+    return {
+      code: "list_target_malformed",
+      message: `List editable target is malformed: ${shapeIssues[0]?.path ?? "$"}.`
+    };
+  }
+  if (context.activeStoryKey !== void 0 && target.storyKey !== context.activeStoryKey) {
+    return {
+      code: "list_target_wrong_story",
+      message: "List editable target does not belong to the active story."
+    };
+  }
+  if (target.commandFamily !== "text-leaf" || target.listAddress === void 0) {
+    return {
+      code: "list_target_required",
+      message: "List commands require a validated list item editable target."
+    };
+  }
+  if (target.editability !== "editable" || target.posture.blockers.length > 0) {
+    return {
+      code: "list_target_non_editable",
+      message: target.posture.blockers.length > 0 ? `List editable target is not editable: ${target.posture.blockers.join(", ")}.` : "List editable target is not editable."
+    };
+  }
+  if (!findCurrentListCommandTarget(target, currentTargets)) {
+    return {
+      code: "list_target_not_found",
+      message: "List editable target no longer resolves in the current canonical document."
+    };
+  }
+  return void 0;
+}
+function findCurrentListCommandTarget(target, currentTargets) {
+  return currentTargets.find(
+    (candidate) => isParagraphTextTarget(candidate) && candidate.listAddress !== void 0 && (candidate.targetKey === target.targetKey || candidate.listAddress.addressKey === target.listAddress?.addressKey)
+  );
+}
+function sameResolvedListCommandTarget(left, right) {
+  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength && left.staleCheck.inlineCount === right.staleCheck.inlineCount && left.staleCheck.blockType === right.staleCheck.blockType && left.listAddress?.addressKey === right.listAddress?.addressKey && left.listAddress?.resolver?.staleHash === right.listAddress?.resolver?.staleHash && jsonStable(left.sourceRef) === jsonStable(right.sourceRef);
+}
+function isParagraphTextTarget(target) {
+  return target.commandFamily === "text-leaf" && target.staleCheck.blockType === "paragraph" && target.leafPath.endsWith("/inline");
+}
+function jsonStable(value) {
+  return JSON.stringify(sortJson(value));
+}
+function sortJson(value) {
+  if (Array.isArray(value)) return value.map(sortJson);
+  if (value && typeof value === "object") {
+    const record = value;
+    const sorted = {};
+    for (const key of Object.keys(record).sort()) {
+      sorted[key] = sortJson(record[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
 function ensureDefaultInstance(catalog, kind) {
   const existing = Object.values(catalog.instances).find(
     (instance) => getListKind(catalog, instance.numberingInstanceId) === kind
@@ -22287,7 +22633,8 @@ function applyListAwareTextCommand(context, command, deps) {
       const result = indentListItems(
         context.localDocument,
         [paragraphContext.paragraphIndex],
-        { timestamp: context.timestamp }
+        listCommandContext(context),
+        listCommandTargetOptions(context, paragraphContext)
       );
       return createListMutationResult(result, context.localSnapshot.selection, deps);
     }
@@ -22295,7 +22642,8 @@ function applyListAwareTextCommand(context, command, deps) {
       const result = outdentListItems(
         context.localDocument,
         [paragraphContext.paragraphIndex],
-        { timestamp: context.timestamp }
+        listCommandContext(context),
+        listCommandTargetOptions(context, paragraphContext)
       );
       return createListMutationResult(result, context.localSnapshot.selection, deps);
     }
@@ -22306,7 +22654,8 @@ function applyListAwareTextCommand(context, command, deps) {
       const result = backspaceAtListStart(
         context.localDocument,
         paragraphContext.paragraphIndex,
-        { timestamp: context.timestamp }
+        listCommandContext(context),
+        listCommandTargetOptions(context, paragraphContext)
       );
       return result.handled ? createListMutationResult(result, context.localSnapshot.selection, deps) : null;
     }
@@ -22318,14 +22667,30 @@ function applyListAwareTextCommand(context, command, deps) {
         context.localDocument,
         paragraphContext.paragraphIndex,
         true,
-        { timestamp: context.timestamp }
+        listCommandContext(context),
+        listCommandTargetOptions(context, paragraphContext)
       );
+      if (result.blockedReason) {
+        return createListMutationResult(result, context.localSnapshot.selection, deps);
+      }
       return result.action === "split" ? null : createListMutationResult(result, context.localSnapshot.selection, deps);
     }
     default:
       return null;
   }
 }
+function listCommandContext(context) {
+  return {
+    timestamp: context.timestamp,
+    ...context.activeStory.kind === "main" ? { activeStoryKey: "main" } : {}
+  };
+}
+function listCommandTargetOptions(context, paragraphContext) {
+  if (context.activeStory.kind !== "main" || !paragraphContext.paragraph.editableTarget) {
+    return {};
+  }
+  return { editableTargets: [paragraphContext.paragraph.editableTarget] };
+}
 function createListMutationResult(result, selection, deps) {
   return {
     changed: result.affectedParagraphIndexes.length > 0,
@@ -26518,7 +26883,7 @@ function parseCanonicalTextLeafPath(path) {
     if (normalized[offset] !== "/") return null;
     offset += 1;
   }
-  return tokens.some((token) => token.kind === "txbx") ? tokens : null;
+  return tokens.length > 0 ? tokens : null;
 }
 function parseCanonicalHyperlinkPath(path) {
   const blockStart = path.indexOf("/block[");
@@ -33493,7 +33858,7 @@ function validateResult(result, context) {
   return { ...result, selection: validated };
 }
 function getPostMutationMaxOffset(result, context) {
-  if (typeof context.activeStorySize !== "number" || context.textTarget?.kind === "text-leaf") {
+  if (typeof context.activeStorySize !== "number" || isTargetLocalTextLeaf(context.textTarget)) {
     return result.storyText.length;
   }
   let storySize = context.activeStorySize;
@@ -33502,6 +33867,9 @@ function getPostMutationMaxOffset(result, context) {
   }
   return Math.max(result.storyText.length, storySize);
 }
+function isTargetLocalTextLeaf(textTarget) {
+  return textTarget?.kind === "text-leaf" && textTarget.blockPath.includes("/txbx/");
+}
 var editLayer = {
   applyTextInsert(doc, selection, text, context, formatting) {
     return validateResult(insertText(doc, selection, text, context, formatting), context);
@@ -33764,6 +34132,13 @@ function withCommandTextTarget(context, command) {
     textTarget: command.textTarget
   };
 }
+function listCommandContext2(context) {
+  return {
+    timestamp: context.timestamp,
+    ...context.activeStoryKey !== void 0 ? { activeStoryKey: context.activeStoryKey } : {},
+    ...context.editableTargetCache !== void 0 ? { editableTargetCache: context.editableTargetCache } : {}
+  };
+}
 function executeEditorCommand(state, command, context) {
   switch (command.type) {
     case "selection.set":
@@ -34405,7 +34780,17 @@ function executeEditorCommand(state, command, context) {
       });
     }
     case "list.toggle": {
-      const result = command.kind === "bulleted" ? toggleBulletedList(state.document, command.paragraphIndexes, { timestamp: context.timestamp }) : toggleNumberedList(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      const result = command.kind === "bulleted" ? toggleBulletedList(
+        state.document,
+        command.paragraphIndexes ?? [],
+        listCommandContext2(context),
+        { editableTargets: command.editableTargets }
+      ) : toggleNumberedList(
+        state.document,
+        command.paragraphIndexes ?? [],
+        listCommandContext2(context),
+        { editableTargets: command.editableTargets }
+      );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
         document: result.document,
@@ -34413,7 +34798,12 @@ function executeEditorCommand(state, command, context) {
       });
     }
     case "list.indent": {
-      const result = indentListItems(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      const result = indentListItems(
+        state.document,
+        command.paragraphIndexes ?? [],
+        listCommandContext2(context),
+        { editableTargets: command.editableTargets }
+      );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
         document: result.document,
@@ -34421,7 +34811,12 @@ function executeEditorCommand(state, command, context) {
       });
     }
     case "list.outdent": {
-      const result = outdentListItems(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      const result = outdentListItems(
+        state.document,
+        command.paragraphIndexes ?? [],
+        listCommandContext2(context),
+        { editableTargets: command.editableTargets }
+      );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
         document: result.document,
@@ -34431,9 +34826,10 @@ function executeEditorCommand(state, command, context) {
     case "list.restart-numbering": {
       const result = restartNumbering(
         state.document,
-        command.paragraphIndex,
-        { timestamp: context.timestamp },
-        command.startAt
+        command.paragraphIndex ?? -1,
+        listCommandContext2(context),
+        command.startAt,
+        { editableTarget: command.editableTarget }
       );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
@@ -34444,8 +34840,9 @@ function executeEditorCommand(state, command, context) {
     case "list.continue-numbering": {
       const result = continueNumbering(
         state.document,
-        command.paragraphIndex,
-        { timestamp: context.timestamp }
+        command.paragraphIndex ?? -1,
+        listCommandContext2(context),
+        { editableTarget: command.editableTarget }
       );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
@@ -38407,6 +38804,27 @@ function hitTestRegion(index, region, point) {
     (target2) => target2.regionId === region.regionId
   );
   const containing = targets.filter((target2) => containsPoint(target2.rect, point));
+  const generatedTarget = containing.find(
+    (target2) => target2.generatedContentKind === "numbering-marker"
+  );
+  if (generatedTarget) {
+    const anchorHit2 = firstLineAnchor(index, generatedTarget)?.runtimeOffset !== void 0 ? {
+      runtimeOffset: firstLineAnchor(index, generatedTarget).runtimeOffset,
+      assoc: "before"
+    } : resolveLineAnchorHit(index, generatedTarget, point);
+    return {
+      pageIndex: generatedTarget.pageIndex,
+      regionKind: generatedTarget.regionKind,
+      blockId: generatedTarget.blockId,
+      fragmentId: generatedTarget.fragmentId,
+      lineIndex: generatedTarget.lineIndex,
+      runtimeOffset: anchorHit2?.runtimeOffset ?? 0,
+      assoc: "before",
+      generatedContentKind: generatedTarget.generatedContentKind,
+      generatedContentBoundary: generatedTarget.generatedContentBoundary?.policy,
+      semanticEntryId: generatedTarget.targetId.startsWith("hit:") ? generatedTarget.targetId.slice("hit:".length) : generatedTarget.targetId
+    };
+  }
   const target = nearestTarget(containing, point) ?? nearestTarget(targets, point);
   if (!target) return null;
   const anchorHit = resolveLineAnchorHit(index, target, point);
@@ -38783,6 +39201,7 @@ function projectGeometryIndexFromFrame(frame, options) {
           identities,
           storyKey: storyKey2,
           entries: semanticEntries,
+          hitTargets,
           projectedBlocksByStory,
           projectedCommandTargetsByKey,
           precision,
@@ -39053,6 +39472,7 @@ function appendBlockSemanticEntries(input) {
     identities,
     storyKey: storyKey2,
     entries,
+    hitTargets,
     projectedBlocksByStory,
     projectedCommandTargetsByKey,
     precision,
@@ -39082,6 +39502,7 @@ function appendBlockSemanticEntries(input) {
     block,
     sourceIdentity: sliceIdentity,
     entries,
+    hitTargets,
     projectedCommandTargetsByKey,
     precision,
     frameCompleteness,
@@ -39263,6 +39684,7 @@ function appendFragmentLayoutObjectSemanticEntries(input) {
     block,
     sourceIdentity,
     entries,
+    hitTargets,
     projectedCommandTargetsByKey,
     precision,
     frameCompleteness,
@@ -39347,18 +39769,57 @@ function appendFragmentLayoutObjectSemanticEntries(input) {
     }
     return;
   }
-  if (layoutObject.kind === "numbered-paragraph") {
-    const markerProjection = resolveNumberingMarkerProjection(block);
+  const numberingRows = layoutObject.numberingRows && layoutObject.numberingRows.length > 0 ? layoutObject.numberingRows : layoutObject.kind === "numbered-paragraph" && layoutObject.numbering ? [layoutObject.numbering] : [];
+  for (let index = 0; index < numberingRows.length; index += 1) {
+    const numbering = numberingRows[index];
+    const markerProjection = resolveNumberingMarkerProjection(block, numbering);
+    const entryId = layoutObject.kind === "numbered-paragraph" && index === 0 ? `semantic:numbering-marker:${base.sliceId}` : `semantic:numbering-marker:${base.sliceId}:${stableGeometryId(
+      numbering.numberingLayoutId ?? numbering.numberingKey ?? String(index)
+    )}`;
+    const source = numberingSourceIdentity(numbering, sourceIdentity);
     entries.push({
       ...base,
-      entryId: `semantic:numbering-marker:${base.sliceId}`,
+      entryId,
       kind: "numbering-marker",
       layoutObjectId: layoutObject.objectId,
+      numberingLayoutId: numbering.numberingLayoutId,
+      numberingKey: numbering.numberingKey,
+      numberingTargetKey: numbering.targetKey,
+      numberingTargetKind: numbering.targetKind,
+      numberingCanonicalAddressKey: numbering.canonicalAddressKey,
+      numberingListAddressKey: numbering.listAddressKey,
+      numberingMarkerText: numbering.markerText,
+      numberingMarkerSuffix: numbering.markerSuffix,
+      numberingFormat: numbering.format,
+      numberingFormatPosture: numbering.formatPosture,
+      numberingUnavailableReasons: numbering.unavailableReasons,
+      markerGlyphRect: markerProjection.rect,
+      markerLaneRect: markerProjection.markerLaneRect,
+      textColumnRect: markerProjection.textColumnRect,
+      markerBoundary: markerProjection.markerBoundary,
       rect: markerProjection.rect,
       status: markerProjection.status,
       precision: markerProjection.precision,
       frameCompleteness,
-      ...sourceIdentity ? { sourceIdentity } : {}
+      ...source ? { sourceIdentity: source } : {}
+    });
+    hitTargets.push({
+      targetId: `hit:${entryId}`,
+      pageId: base.pageId,
+      pageIndex: base.pageIndex,
+      regionId: base.regionId,
+      regionKind: base.regionKind,
+      blockId: base.blockId,
+      fragmentId: base.fragmentId,
+      lineIndex: firstLineIndex(block),
+      rect: markerProjection.rect,
+      precision: markerProjection.precision,
+      generatedContentKind: "numbering-marker",
+      generatedContentBoundary: {
+        policy: "snap-to-authored-text",
+        authoredTextStartsAtPx: markerProjection.markerBoundary.authoredTextStartsAtPx,
+        selectionPolicy: "exclude-generated-marker"
+      }
     });
     recordPrecision(precision, markerProjection.precision);
   }
@@ -39449,8 +39910,8 @@ function bookmarkRangeSourceIdentity(fact, fallback) {
     joinKind: "block-scoped"
   };
 }
-function resolveNumberingMarkerProjection(block) {
-  const metadata = resolveNumberingMarkerProjectionMetadata(block);
+function resolveNumberingMarkerProjection(block, numbering) {
+  const metadata = resolveNumberingMarkerProjectionMetadata(block, numbering);
   const blockFrame = block.frame;
   if (metadata.markerLane && metadata.measuredWidthTwips !== void 0) {
     const markerLane = metadata.markerLane;
@@ -39461,14 +39922,25 @@ function resolveNumberingMarkerProjection(block) {
     const rawRightPx = rawLeftPx + markerLane.widthTwips * pxPerTwip;
     const leftPx = clamp3(rawLeftPx, blockLeftPx, blockRightPx);
     const rightPx = clamp3(rawRightPx, leftPx, blockRightPx);
+    const markerLaneRect = {
+      leftPx,
+      topPx: blockFrame.topPx,
+      widthPx: rightPx - leftPx,
+      heightPx: blockFrame.heightPx,
+      space: "frame",
+      precision: metadata.precision
+    };
+    const textColumnRect = metadata.textColumn ? projectTextColumnRect(blockFrame, metadata.measuredWidthTwips, metadata.textColumn) : void 0;
     return {
-      rect: {
-        leftPx,
-        topPx: blockFrame.topPx,
-        widthPx: rightPx - leftPx,
-        heightPx: blockFrame.heightPx,
-        space: "frame",
-        precision: metadata.precision
+      rect: markerLaneRect,
+      markerLaneRect,
+      ...textColumnRect ? { textColumnRect } : {},
+      markerBoundary: {
+        generatedContent: "numbering-marker",
+        caretPolicy: "snap-to-authored-text",
+        selectionPolicy: "exclude-marker-unless-list-item-action",
+        coordinateSpace: "frame-px",
+        ...textColumnRect ? { authoredTextStartsAtPx: textColumnRect.leftPx } : {}
       },
       precision: metadata.precision,
       status: metadata.status
@@ -39487,20 +39959,28 @@ function resolveNumberingMarkerProjection(block) {
       space: "frame",
       precision: metadata.precision
     },
+    markerBoundary: {
+      generatedContent: "numbering-marker",
+      caretPolicy: "snap-to-authored-text",
+      selectionPolicy: "exclude-marker-unless-list-item-action",
+      coordinateSpace: "frame-px"
+    },
     precision: metadata.precision,
     status: metadata.status
   };
 }
-function resolveNumberingMarkerProjectionMetadata(block) {
+function resolveNumberingMarkerProjectionMetadata(block, numbering) {
   const blockFrame = block.frame;
   const layoutObject = block.fragment.layoutObject;
-  const markerLane = layoutObject?.kind === "numbered-paragraph" ? layoutObject.numbering?.markerLane : void 0;
+  const markerLane = numbering?.markerLane ?? (layoutObject?.kind === "numbered-paragraph" ? layoutObject.numbering?.markerLane : void 0);
+  const textColumn = numbering?.textColumn ?? (layoutObject?.kind === "numbered-paragraph" ? layoutObject.numbering?.textColumn : void 0);
   const measuredWidthTwips = layoutObject?.measuredExtentTwips.widthTwips;
   if (markerLane && markerLane.widthTwips > 0 && measuredWidthTwips !== void 0 && measuredWidthTwips > 0 && Number.isFinite(blockFrame.widthPx)) {
     return {
       precision: "within-tolerance",
       status: "realized",
       markerLane,
+      ...textColumn ? { textColumn } : {},
       measuredWidthTwips
     };
   }
@@ -39509,6 +39989,42 @@ function resolveNumberingMarkerProjectionMetadata(block) {
     status: "requires-rehydration"
   };
 }
+function projectTextColumnRect(blockFrame, measuredWidthTwips, textColumn) {
+  if (measuredWidthTwips <= 0 || !Number.isFinite(blockFrame.widthPx)) {
+    return void 0;
+  }
+  const pxPerTwip = blockFrame.widthPx / measuredWidthTwips;
+  const leftPx = blockFrame.leftPx + textColumn.startTwips * pxPerTwip;
+  const rightInsetPx = (textColumn.rightTwips ?? 0) * pxPerTwip;
+  const rightPx = blockFrame.leftPx + blockFrame.widthPx - rightInsetPx;
+  if (rightPx < leftPx) return void 0;
+  return {
+    leftPx,
+    topPx: blockFrame.topPx,
+    widthPx: rightPx - leftPx,
+    heightPx: blockFrame.heightPx,
+    space: "frame",
+    precision: "within-tolerance"
+  };
+}
+function numberingSourceIdentity(numbering, fallback) {
+  const storyKey2 = numbering.storyKey ?? fallback?.storyKey;
+  if (!storyKey2) return fallback;
+  return {
+    storyKey: storyKey2,
+    ...numbering.sourceBlockPath ?? fallback?.blockPath ? { blockPath: numbering.sourceBlockPath ?? fallback?.blockPath } : {},
+    ...numbering.numberingKey ?? fallback?.scopeKey ? { scopeKey: numbering.numberingKey ?? fallback?.scopeKey } : {},
+    ...numbering.numberingInstanceId ?? fallback?.scopeId ? { scopeId: numbering.numberingInstanceId ?? fallback?.scopeId } : {},
+    ...numbering.numberingSourceRef ?? numbering.sourceRef ?? fallback?.sourceRef ? { sourceRef: numbering.numberingSourceRef ?? numbering.sourceRef ?? fallback?.sourceRef } : {},
+    joinKind: "block-scoped"
+  };
+}
+function stableGeometryId(value) {
+  return value.replace(/[^A-Za-z0-9_.:-]+/gu, "_");
+}
+function firstLineIndex(block) {
+  return block.lines[0]?.line.lineIndex ?? 0;
+}
 function countBlockSemanticEntries(block) {
   const counts = createPrecisionCounts();
   const layoutObject = block.fragment.layoutObject;
@@ -45908,6 +46424,24 @@ function refusalIdForPostureBlocker(target, blocker2) {
       return "editable_target_opaque_content";
     case "synthetic-layout-cell":
       return "editable_target_synthetic_layout_cell";
+    case "list-text-readback-missing":
+      return "list_text_readback_missing";
+    case "list-structure-command-missing":
+      return "list_structure_command_missing";
+    case "list-target-stale":
+      return "list_target_stale";
+    case "list-secondary-story-unsupported":
+      return "list_secondary_story_unsupported";
+    case "list-table-target-missing":
+      return "list_table_target_missing";
+    case "list-export-persistence-missing":
+      return "list_export_persistence_missing";
+    case "numbering-format-unsupported":
+      return "numbering_format_unsupported";
+    case "picture-bullet-preserve-only":
+      return "picture_bullet_preserve_only";
+    case "marker-geometry-unavailable":
+      return "marker_geometry_unavailable";
     case "unmodeled-target":
       return target.commandFamily === "link-bookmark" ? "editable_target_linked_content_unmodeled" : "editable_target_unmodeled";
   }
@@ -45930,12 +46464,42 @@ function auditCategoryForPostureBlocker(target, blocker2) {
       return target.commandFamily === "link-bookmark" ? "linked-content" : "unsupported-command";
     case "synthetic-layout-cell":
       return "synthetic-cell";
+    case "list-target-stale":
+      return "stale-ref";
+    case "picture-bullet-preserve-only":
+    case "list-export-persistence-missing":
+      return "preserve-only";
+    case "list-text-readback-missing":
+    case "list-structure-command-missing":
+    case "list-secondary-story-unsupported":
+    case "list-table-target-missing":
+    case "numbering-format-unsupported":
+    case "marker-geometry-unavailable":
+      return "unsupported-command";
   }
 }
 function messageForPostureBlocker(blocker2) {
   switch (blocker2) {
     case "synthetic-layout-cell":
       return "Hidden vertical-merge continuation or synthetic layout cells are not editable targets.";
+    case "list-text-readback-missing":
+      return "List text edits need an authoritative list-item text target before mutation.";
+    case "list-structure-command-missing":
+      return "List structure changes need a supported list command envelope before mutation.";
+    case "list-target-stale":
+      return "List target identity is stale for the current canonical document.";
+    case "list-secondary-story-unsupported":
+      return "List edits in this secondary story are not yet supported.";
+    case "list-table-target-missing":
+      return "Table-contained list item is missing a command-safe list target.";
+    case "list-export-persistence-missing":
+      return "List mutation is blocked until export/reopen persistence is available.";
+    case "numbering-format-unsupported":
+      return "Numbering format is unsupported for this list command.";
+    case "picture-bullet-preserve-only":
+      return "Picture bullet lists are preserve-only until picture bullet mutation is supported.";
+    case "marker-geometry-unavailable":
+      return "List marker geometry is unavailable for this target.";
     default:
       return void 0;
   }
@@ -47219,6 +47783,21 @@ function compileParagraphScope(entry, options = {}) {
     partial: true
   };
 }
+function storyKeyFromHandle(handle) {
+  const target = handle.storyTarget;
+  if (target.kind === "main") return "main";
+  return null;
+}
+function textLeafEditableTargetHint(entry, semanticBlockRange) {
+  const storyKey2 = storyKeyFromHandle(entry.handle);
+  if (!storyKey2) return void 0;
+  return {
+    kind: "text-leaf",
+    storyKey: storyKey2,
+    blockPath: `${storyKey2}/block[${entry.blockIndex}]`,
+    semanticBlockRange
+  };
+}
 function compileParagraphReplacement(entry, proposed, options) {
   if (proposed.operation !== "replace" && proposed.operation !== "insert-before" && proposed.operation !== "insert-after") {
     return null;
@@ -47274,6 +47853,7 @@ function compileParagraphReplacement(entry, proposed, options) {
         {
           kind: stepKind,
           summary: stepKind === "text-replace" ? actionSummary : `suggest-mode ${actionSummary}`,
+          ...textLeafEditableTargetHint(entry, blockRange) ? { editableTargetHint: textLeafEditableTargetHint(entry, blockRange) } : {},
           range: { from: operationRange.from, to: operationRange.to },
           text,
           ...proposed.formatting ? { formatting: proposed.formatting } : {}
@@ -47301,6 +47881,7 @@ function compileParagraphReplacement(entry, proposed, options) {
         {
           kind: "fragment-replace",
           summary: actionSummary,
+          ...textLeafEditableTargetHint(entry, blockRange) ? { editableTargetHint: textLeafEditableTargetHint(entry, blockRange) } : {},
           range: { from: operationRange.from, to: operationRange.to },
           fragment
         }
@@ -49223,14 +49804,17 @@ function paragraphHasBookmarkId(paragraph, bookmarkId) {
 function commandActionHandleForAddress(commandFamily, address) {
   return address ? `scope-command:${commandFamily}:${address.addressKey}` : void 0;
 }
-function withCommandAction(evidence, target) {
-  if (evidence.status !== "supported" || !target.canonicalAddress) return evidence;
+function withCommandAction(evidence, target, canonicalAddress = target.canonicalAddress) {
+  if (evidence.status !== "supported" || !canonicalAddress) return evidence;
   return {
     ...evidence,
-    actionHandle: commandActionHandleForAddress(target.commandFamily, target.canonicalAddress),
-    canonicalAddress: target.canonicalAddress
+    actionHandle: commandActionHandleForAddress(target.commandFamily, canonicalAddress),
+    canonicalAddress
   };
 }
+function commandAddressForTarget(target, scopeKind) {
+  return scopeKind === "list-item" && target.listAddress !== void 0 ? target.listAddress : target.canonicalAddress;
+}
 function runtimeTextCommandEvidence(target, workflowBlockers) {
   const shapeIssues = validateEditableTargetRef(target);
   if (shapeIssues.length > 0) {
@@ -49283,6 +49867,9 @@ var TABLE_TEXT_TARGET_KINDS2 = /* @__PURE__ */ new Set([
 var LIST_TEXT_TARGET_KINDS2 = /* @__PURE__ */ new Set([
   "paragraph-text",
   "sdt-paragraph-text",
+  "table-cell-paragraph-text",
+  "nested-table-cell-paragraph-text",
+  "sdt-table-cell-paragraph-text",
   "secondary-story-paragraph-text"
 ]);
 function tableTextScopeReplacementPosture(target) {
@@ -49333,7 +49920,7 @@ function runtimeCommandEvidence(target, workflowBlockers, textCommand, scopeKind
       intents: commandIntentsForTarget(target, scopeKind),
       reason: textCommand.reason,
       ...textCommand.blockers ? { blockers: textCommand.blockers } : {}
-    }, target);
+    }, target, commandAddressForTarget(target, scopeKind));
   }
   if (target.commandFamily === "comment-revision") {
     const isOpen = target.review?.status === "open";
@@ -55385,6 +55972,16 @@ function createLayoutFacet(input) {
   function currentGraph() {
     return engine.getPageGraph(getQueryInput());
   }
+  function fullGraphForViewportIndependentReads() {
+    const query = getQueryInput();
+    if (!query.viewportPageWindow) {
+      return engine.getPageGraph(query);
+    }
+    return engine.getPageGraph({
+      document: query.document,
+      ...query.viewState ? { viewState: query.viewState } : {}
+    });
+  }
   function currentMapper() {
     return engine.getFragmentMapper(getQueryInput());
   }
@@ -55522,7 +56119,7 @@ function createLayoutFacet(input) {
       return graph.sections.map((section) => toPublicSectionNode(graph, section.index)).filter((node) => node !== null);
     },
     getPageForOffset(offset, story) {
-      const graph = currentGraph();
+      const graph = fullGraphForViewportIndependentReads();
       const page = findPageForOffsetAndStory(graph, offset, story);
       return page ? toPublicPageNode(page, graph) : null;
     },
@@ -55834,7 +56431,7 @@ function createLayoutFacet(input) {
       return null;
     },
     getBlockHeightsTwips() {
-      const graph = currentGraph();
+      const graph = fullGraphForViewportIndependentReads();
       if (blockHeightsCache.revision === graph.revision && blockHeightsCache.map) {
         return blockHeightsCache.map;
       }
@@ -58602,7 +59199,8 @@ async function collectEditorStateForSerialize(args) {
 // src/io/ooxml/parse-bookmark-references.ts
 var HYPERLINK_ANCHOR_RE = /<(?:\w+:)?hyperlink\b[^>]*\bw:anchor\s*=\s*"([^"]*)"/gi;
 var INSTR_TEXT_RE = /<(?:\w+:)?instrText\b[^>]*>([\s\S]*?)<\/(?:\w+:)?instrText>/gi;
-var FLD_SIMPLE_INSTR_RE = /<(?:\w+:)?fldSimple\b[^>]*(?:\bw:instr|\binstr)\s*=\s*(["'])([\s\S]*?)\1/gi;
+var FLD_SIMPLE_INSTR_DOUBLE_RE = /<(?:\w+:)?fldSimple\b[^>]*?\b(?:w:)?instr\s*=\s*"([^"]*)"/gi;
+var FLD_SIMPLE_INSTR_SINGLE_RE = /<(?:\w+:)?fldSimple\b[^>]*?\b(?:w:)?instr\s*=\s*'([^']*)'/gi;
 var TOC_FIELD_RE = /\bTOC\b/;
 var REFLIKE_FIELD_RE = /\b(?:HYPERLINK|REF|PAGEREF|NOTEREF)\s+([A-Za-z0-9_:.\-]+)/g;
 var DATA_BINDING_RE = /<(?:\w+:)?dataBinding\b/i;
@@ -58621,11 +59219,22 @@ function scanBookmarkReferences(documentXml, callerAllowlist = []) {
   }
   INSTR_TEXT_RE.lastIndex = 0;
   while ((m = INSTR_TEXT_RE.exec(documentXml)) !== null) {
-    if (scanInstructionText(m[1] ?? "", retained)) retainAllToc = true;
+    const instrText = m[1] ?? "";
+    scanFieldInstruction(instrText, retained, () => {
+      retainAllToc = true;
+    });
+  }
+  FLD_SIMPLE_INSTR_DOUBLE_RE.lastIndex = 0;
+  while ((m = FLD_SIMPLE_INSTR_DOUBLE_RE.exec(documentXml)) !== null) {
+    scanFieldInstruction(decodeXmlAttribute(m[1] ?? ""), retained, () => {
+      retainAllToc = true;
+    });
   }
-  FLD_SIMPLE_INSTR_RE.lastIndex = 0;
-  while ((m = FLD_SIMPLE_INSTR_RE.exec(documentXml)) !== null) {
-    if (scanInstructionText(m[2] ?? "", retained)) retainAllToc = true;
+  FLD_SIMPLE_INSTR_SINGLE_RE.lastIndex = 0;
+  while ((m = FLD_SIMPLE_INSTR_SINGLE_RE.exec(documentXml)) !== null) {
+    scanFieldInstruction(decodeXmlAttribute(m[1] ?? ""), retained, () => {
+      retainAllToc = true;
+    });
   }
   retainRevisionBoundedBookmarks(documentXml, retained);
   return {
@@ -58634,14 +59243,16 @@ function scanBookmarkReferences(documentXml, callerAllowlist = []) {
     retainAll
   };
 }
-function scanInstructionText(instrText, retained) {
-  const hasTocField = TOC_FIELD_RE.test(instrText);
+function scanFieldInstruction(instrText, retained, retainToc) {
+  if (TOC_FIELD_RE.test(instrText)) retainToc();
   REFLIKE_FIELD_RE.lastIndex = 0;
   let r;
   while ((r = REFLIKE_FIELD_RE.exec(instrText)) !== null) {
     if (r[1]) retained.add(r[1]);
   }
-  return hasTocField;
+}
+function decodeXmlAttribute(value) {
+  return value.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
 }
 function retainRevisionBoundedBookmarks(documentXml, retained) {
   const starts = /* @__PURE__ */ new Map();
@@ -58994,18 +59605,23 @@ function parseNumberingXml(xml, context) {
   const abstractDefinitions = {};
   const instances = {};
   const numPicBullets = {};
+  const topLevelOrdinals = /* @__PURE__ */ new Map();
   for (const child of numberingElement.children) {
     if (child.type !== "element") {
       continue;
     }
-    if (localName(child.name) === "numPicBullet") {
+    const childName = localName(child.name);
+    const childOrdinal = (topLevelOrdinals.get(childName) ?? 0) + 1;
+    topLevelOrdinals.set(childName, childOrdinal);
+    const childXmlPath = `/numbering[1]/${childName}[${childOrdinal}]`;
+    if (childName === "numPicBullet") {
       const rawId = readStringAttr(child, "w:numPicBulletId");
       if (rawId) {
-        numPicBullets[rawId] = readNumPicBullet(child, rawId, context);
+        numPicBullets[rawId] = readNumPicBullet(child, rawId, context, childXmlPath);
       }
       continue;
     }
-    switch (localName(child.name)) {
+    switch (childName) {
       case "abstractNum": {
         const rawId = readStringAttr(child, "w:abstractNumId");
         if (!rawId) {
@@ -59025,7 +59641,7 @@ function parseNumberingXml(xml, context) {
         const numStyleLink = numStyleLinkEl ? readStringAttr(numStyleLinkEl, "w:val") : void 0;
         abstractDefinitions[abstractNumberingId] = {
           abstractNumberingId,
-          ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "abstractNum", rawId) } : {},
+          ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "abstractNum", rawId, childXmlPath) } : {},
           levels: readLevels(child),
           ...nsid ? { nsid } : {},
           ...multiLevelType ? { multiLevelType } : {},
@@ -59045,7 +59661,7 @@ function parseNumberingXml(xml, context) {
         const numberingInstanceId = toCanonicalNumberingInstanceId(rawId);
         instances[numberingInstanceId] = {
           numberingInstanceId,
-          ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "num", rawId) } : {},
+          ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "num", rawId, childXmlPath) } : {},
           abstractNumberingId: toCanonicalAbstractNumberingId(rawAbstractId),
           overrides: readOverrides(child)
         };
@@ -59059,15 +59675,16 @@ function parseNumberingXml(xml, context) {
     ...Object.keys(numPicBullets).length > 0 ? { numPicBullets } : {}
   };
 }
-function createNumberingSourceRef(partPath, element, rawId) {
+function createNumberingSourceRef(partPath, element, rawId, xmlPath) {
   return {
     sourceId: `part:${partPath}#${element}:${rawId}`,
     partPath,
     storyKind: "numbering",
-    element
+    element,
+    ...xmlPath !== void 0 ? { xmlPath } : {}
   };
 }
-function readNumPicBullet(node, numPicBulletId, context) {
+function readNumPicBullet(node, numPicBulletId, context, xmlPath) {
   let widthEmu;
   let heightEmu;
   let mediaId;
@@ -59130,6 +59747,7 @@ function readNumPicBullet(node, numPicBulletId, context) {
   }
   return {
     numPicBulletId,
+    ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "numPicBullet", numPicBulletId, xmlPath) } : {},
     rawXml: serializeXmlElementToString(node),
     ...widthEmu !== void 0 ? { widthEmu } : {},
     ...heightEmu !== void 0 ? { heightEmu } : {},
@@ -63096,7 +63714,11 @@ function parseBodyChild(node, sourceXml, relationshipMap, relationships, mediaPa
     switch (localName(child.name)) {
       case "pPr":
         styleId = readParagraphStyleId(child);
-        numbering = readParagraphNumbering(child, sourcePartPath);
+        numbering = readParagraphNumbering(
+          child,
+          sourcePartPath,
+          `${sourceXmlPath}/pPr[${countPriorElementSiblingsByName(node, child) + 1}]`
+        );
         alignment = readParagraphAlignment(child);
         spacing = readParagraphSpacing2(child);
         contextualSpacing = readOptionalOnOffParagraphProperty(child, "contextualSpacing");
@@ -64179,7 +64801,7 @@ function readParagraphStyleId(node) {
   }
   return void 0;
 }
-function readParagraphNumbering(node, sourcePartPath) {
+function readParagraphNumbering(node, sourcePartPath, sourceXmlPath) {
   const numberingProperties = node.children.find(
     (child) => child.type === "element" && localName(child.name) === "numPr"
   );
@@ -64199,16 +64821,22 @@ function readParagraphNumbering(node, sourcePartPath) {
   }
   return {
     numberingInstanceId: toCanonicalNumberingInstanceId(rawInstanceId),
-    sourceRef: createElementSourceRef(sourcePartPath, "numPr", numberingProperties),
+    sourceRef: createElementSourceRef(
+      sourcePartPath,
+      "numPr",
+      numberingProperties,
+      sourceXmlPath !== void 0 ? `${sourceXmlPath}/numPr[${countPriorElementSiblingsByName(node, numberingProperties) + 1}]` : void 0
+    ),
     level: Number.parseInt(rawLevel, 10)
   };
 }
-function createElementSourceRef(partPath, element, node) {
+function createElementSourceRef(partPath, element, node, xmlPath) {
   return {
     sourceId: `part:${partPath}#${element}:${node.start}`,
     partPath,
     storyKind: storyKindFromPartPath(partPath),
     element,
+    ...xmlPath !== void 0 ? { xmlPath } : {},
     startOffset: node.start,
     endOffset: node.end
   };
@@ -66367,7 +66995,8 @@ function rejectCommand(code, message) {
   };
 }
 function sameResolvedTarget2(left, right) {
-  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && sameTextTargetStaleCheck(left, right) && left.staleCheck.inlineCount === right.staleCheck.inlineCount && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.targetTextLength === right.staleCheck.targetTextLength && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && left.staleCheck.wordParaId === right.staleCheck.wordParaId && left.staleCheck.wordTextId === right.staleCheck.wordTextId && jsonStable(left.staleCheck.sourceRef) === jsonStable(right.staleCheck.sourceRef) && jsonStable(left.sourceRef) === jsonStable(right.sourceRef) && jsonStable(left.table) === jsonStable(right.table) && jsonStable(left.editableOwner) === jsonStable(right.editableOwner);
+  const textTargetLengthDrift = hasTextTargetLengthDrift(left, right);
+  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && sameTextTargetStaleCheck(left, right) && left.staleCheck.inlineCount === right.staleCheck.inlineCount && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.targetTextLength === right.staleCheck.targetTextLength && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && left.staleCheck.wordParaId === right.staleCheck.wordParaId && left.staleCheck.wordTextId === right.staleCheck.wordTextId && (textTargetLengthDrift || jsonStable2(left.staleCheck.sourceRef) === jsonStable2(right.staleCheck.sourceRef)) && (textTargetLengthDrift || jsonStable2(left.sourceRef) === jsonStable2(right.sourceRef)) && jsonStable2(left.table) === jsonStable2(right.table) && jsonStable2(left.editableOwner) === jsonStable2(right.editableOwner);
 }
 function sameTextTargetStaleCheck(left, right) {
   if (left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength) {
@@ -66375,6 +67004,9 @@ function sameTextTargetStaleCheck(left, right) {
   }
   return left.commandFamily === "text-leaf" && left.staleCheck.paragraphTextLength !== void 0 && right.staleCheck.paragraphTextLength !== void 0 && left.staleCheck.paragraphTextLength !== right.staleCheck.paragraphTextLength;
 }
+function hasTextTargetLengthDrift(left, right) {
+  return left.commandFamily === "text-leaf" && left.staleCheck.paragraphTextLength !== void 0 && right.staleCheck.paragraphTextLength !== void 0 && left.staleCheck.paragraphTextLength !== right.staleCheck.paragraphTextLength;
+}
 function locateTargetRange(document2, surface, target) {
   if (target.kind === "hyperlink-text") {
     return locateHyperlinkDisplayRange(document2, surface, target);
@@ -66405,19 +67037,19 @@ function locateTargetRange(document2, surface, target) {
     if (!sdt || sdt.kind !== "sdt_block") return null;
     const paragraph = sdt.children[sdtPath.childIndex];
     if (!paragraph || paragraph.kind !== "paragraph") return null;
-    return { from: paragraph.from, to: paragraph.to };
+    return textLeafTargetRange(target, paragraph.from, paragraph.to);
   }
   const paragraphPath = parseTopLevelParagraphPath(target.blockPath);
   if (paragraphPath) {
     const paragraph = surface[paragraphPath.blockIndex];
     if (!paragraph || paragraph.kind !== "paragraph") return null;
-    return { from: paragraph.from, to: paragraph.to };
+    return textLeafTargetRange(target, paragraph.from, paragraph.to);
   }
   const secondaryParagraphPath = parseSecondaryStoryParagraphPath(target.blockPath);
   if (secondaryParagraphPath) {
     const paragraph = surface[secondaryParagraphPath.blockIndex];
     if (!paragraph || paragraph.kind !== "paragraph") return null;
-    return { from: paragraph.from, to: paragraph.to };
+    return textLeafTargetRange(target, paragraph.from, paragraph.to);
   }
   if (target.kind === "textbox-paragraph-text") {
     return {
@@ -66433,6 +67065,18 @@ function locateTargetRange(document2, surface, target) {
   }
   return null;
 }
+function textLeafTargetRange(target, from, to) {
+  return {
+    from,
+    to,
+    textTarget: {
+      kind: "text-leaf",
+      blockPath: target.blockPath,
+      paragraphStart: from,
+      paragraphEnd: to
+    }
+  };
+}
 function locateHyperlinkDisplayRange(document2, surface, target) {
   const canonical = resolveHyperlinkDisplayPath(document2, target.blockPath);
   if (!canonical) return null;
@@ -66654,7 +67298,7 @@ function resolveBlockPathInSurfaceBlocks2(blocks, tokens, tokenIndex, hasVertica
     hasVerticalMergeContinuation || cell.verticalMerge === "continue"
   );
 }
-function jsonStable(value) {
+function jsonStable2(value) {
   return value === void 0 ? "" : JSON.stringify(value);
 }
 
@@ -66791,20 +67435,20 @@ function tableAnchorCell(table) {
   };
 }
 function sameResolvedTableStructureTarget(left, right) {
-  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && jsonStable2(left.staleCheck.sourceRef) === jsonStable2(right.staleCheck.sourceRef) && jsonStable2(left.sourceRef) === jsonStable2(right.sourceRef) && jsonStable2(left.table) === jsonStable2(right.table);
+  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && jsonStable3(left.staleCheck.sourceRef) === jsonStable3(right.staleCheck.sourceRef) && jsonStable3(left.sourceRef) === jsonStable3(right.sourceRef) && jsonStable3(left.table) === jsonStable3(right.table);
 }
-function jsonStable2(value) {
-  return JSON.stringify(sortJson(value));
+function jsonStable3(value) {
+  return JSON.stringify(sortJson2(value));
 }
-function sortJson(value) {
+function sortJson2(value) {
   if (Array.isArray(value)) {
-    return value.map(sortJson);
+    return value.map(sortJson2);
   }
   if (value && typeof value === "object") {
     const record = value;
     const sorted = {};
     for (const key of Object.keys(record).sort()) {
-      sorted[key] = sortJson(record[key]);
+      sorted[key] = sortJson2(record[key]);
     }
     return sorted;
   }
@@ -66813,6 +67457,8 @@ function sortJson(value) {
 
 // src/runtime/document-runtime.ts
 var CANONICAL_BLOCK_REFS_SYMBOL2 = /* @__PURE__ */ Symbol.for("wre.canonical-block-refs");
+var LOCAL_TEXT_PATCH_MAX_SHIFTED_SURFACE_NODES = 5e3;
+var LOCAL_TEXT_PATCH_MAX_SHIFTED_NODES_PER_BLOCK = 256;
 function getLocalTextPatchMetadata(mapping) {
   const metadata = mapping.metadata?.localTextPatch;
   if (!metadata || typeof metadata !== "object") {
@@ -66985,8 +67631,10 @@ function createDocumentRuntime(options) {
   void upgradeMeasurementProvider(layoutEngine, fontLoader);
   let renderKernelRef = null;
   let runtimeRef = null;
+  const normalizedInitialSurfaceViewportRanges = options.initialSurfaceViewportBlockRanges && options.initialSurfaceViewportBlockRanges.length > 0 ? normalizeViewportRanges(options.initialSurfaceViewportBlockRanges) : null;
+  let initialSurfaceViewportBlockRanges = normalizedInitialSurfaceViewportRanges && normalizedInitialSurfaceViewportRanges.length > 0 ? normalizedInitialSurfaceViewportRanges : null;
   let viewportBlockRanges = null;
-  let viewportRangesKey = serializeViewportRanges(null);
+  let viewportRangesKey = serializeViewportRanges(viewportBlockRanges);
   let viewportBlocksPerPageEstimate = null;
   const EDITING_CORRIDOR_BLOCK_RADIUS = 8;
   const getRuntimeForLayoutFacet = () => {
@@ -67226,10 +67874,11 @@ function createDocumentRuntime(options) {
   const cachedContextAnalyticsSnapshots = /* @__PURE__ */ new Map();
   let lastEmittedContextAnalyticsSnapshots;
   function getCachedFullSurface(document2, nextActiveStory) {
-    const activeStoryKey = storyTargetKey(nextActiveStory);
-    if (cachedFullSurface && cachedFullSurface.content === document2.content && cachedFullSurface.subParts === document2.subParts && cachedFullSurface.styles === document2.styles && cachedFullSurface.numbering === document2.numbering && cachedFullSurface.media === document2.media && cachedFullSurface.preservation === document2.preservation && cachedFullSurface.review === document2.review && cachedFullSurface.effectiveMarkupModeProvider === effectiveMarkupModeProvider && cachedFullSurface.activeStoryKey === activeStoryKey) {
-      return cachedFullSurface.snapshot;
+    const cached = getReusableCachedFullSurface(document2, nextActiveStory);
+    if (cached) {
+      return cached;
     }
+    const activeStoryKey = storyTargetKey(nextActiveStory);
     const snapshot = createEditorSurfaceSnapshot(document2, state.selection, nextActiveStory, {
       viewportBlockRanges: null,
       editableTargetsByBlockPath: getEditableTargetsByBlockPath(document2),
@@ -67251,6 +67900,13 @@ function createDocumentRuntime(options) {
     };
     return snapshot;
   }
+  function getReusableCachedFullSurface(document2, nextActiveStory) {
+    const activeStoryKey = storyTargetKey(nextActiveStory);
+    if (cachedFullSurface && cachedFullSurface.content === document2.content && cachedFullSurface.subParts === document2.subParts && cachedFullSurface.styles === document2.styles && cachedFullSurface.numbering === document2.numbering && cachedFullSurface.media === document2.media && cachedFullSurface.preservation === document2.preservation && cachedFullSurface.review === document2.review && cachedFullSurface.effectiveMarkupModeProvider === effectiveMarkupModeProvider && cachedFullSurface.activeStoryKey === activeStoryKey) {
+      return cachedFullSurface.snapshot;
+    }
+    return void 0;
+  }
   function getCachedSurface(document2, nextActiveStory, options2 = {}) {
     const activeStoryKey = storyTargetKey(nextActiveStory);
     const surfaceViewportRanges = "viewportBlockRangesOverride" in options2 ? options2.viewportBlockRangesOverride ?? null : viewportBlockRanges;
@@ -67261,12 +67917,20 @@ function createDocumentRuntime(options) {
     }
     const snapshot = createEditorSurfaceSnapshot(document2, state.selection, nextActiveStory, {
       viewportBlockRanges: surfaceViewportRanges,
-      editableTargetsByBlockPath: options2.editableTargetsByBlockPathOverride ?? getEditableTargetsByBlockPath(document2),
+      editableTargetsByBlockPath: options2.editableTargetsByBlockPathOverride ?? getEditableTargetsByBlockPathForRanges(
+        document2,
+        activeStoryKey,
+        surfaceViewportRanges
+      ),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
     incrementInvalidationCounter("runtime.snapshot.surfaceMisses");
-    const enrichedSnapshot = options2.enrichCulledPlaceholders === false ? snapshot : enrichCulledPlaceholdersWithHeights(snapshot);
+    const enrichedSnapshot = options2.enrichCulledPlaceholders === false ? snapshot : enrichCulledPlaceholdersWithHeights(
+      snapshot,
+      document2,
+      nextActiveStory
+    );
     if (surfaceViewportRanges === null) {
       cachedFullSurface = {
         content: document2.content,
@@ -67324,7 +67988,7 @@ function createDocumentRuntime(options) {
     }
     return -1;
   }
-  function cachePatchedLocalTextSurface(surface) {
+  function cachePatchedLocalTextSurface(surface, fullSurfaceForCache) {
     const activeStoryKey = storyTargetKey(activeStory);
     const rangesKey = serializeViewportRanges(surface.viewportBlockRanges);
     cachedSurface = {
@@ -67340,7 +68004,8 @@ function createDocumentRuntime(options) {
       viewportRangesKey: rangesKey,
       snapshot: surface
     };
-    if (surface.viewportBlockRanges === null) {
+    const fullSurface = fullSurfaceForCache ?? (surface.viewportBlockRanges === null ? surface : void 0);
+    if (fullSurface) {
       cachedFullSurface = {
         content: state.document.content,
         subParts: state.document.subParts,
@@ -67351,11 +68016,15 @@ function createDocumentRuntime(options) {
         review: state.document.review,
         effectiveMarkupModeProvider,
         activeStoryKey,
-        snapshot: surface
+        snapshot: fullSurface
       };
     }
     cachedSurfaceFingerprint = `${activeStoryKey}|${rangesKey}|${String(state.selection.anchor)}:${String(state.selection.head)}`;
   }
+  function createLocalTextCorridorSurfaceFromFullSurface(fullSurface) {
+    const ranges = getSelectionCorridorViewportRanges(fullSurface);
+    return ranges ? createViewportCulledSurfaceFromFullSurface(fullSurface, ranges) : fullSurface;
+  }
   function tryPatchLocalTextSurface(previousSurface, mapping) {
     const tTotal0 = performance.now();
     try {
@@ -67391,6 +68060,13 @@ function createDocumentRuntime(options) {
         perfCounters.increment("surface.localText.patchMiss");
         return null;
       }
+      const shiftBudget = estimateLocalTextPatchShiftBudget(previousSurface.blocks, blockIndex + 1);
+      perfCounters.increment("surface.localText.shiftedBlocks", shiftBudget.shiftedBlocks);
+      perfCounters.increment("surface.localText.shiftedNodes", shiftBudget.shiftedNodes);
+      if (!shiftBudget.withinBudget) {
+        perfCounters.increment("surface.localText.patchBudgetFallback");
+        return null;
+      }
       const segmentIndex = block.segments.findIndex(
         (segment2) => segment2.kind === "text" && editFrom >= segment2.from && editTo <= segment2.to
       );
@@ -67498,7 +68174,83 @@ function createDocumentRuntime(options) {
         };
     }
   }
-  function enrichCulledPlaceholdersWithHeights(snapshot) {
+  function estimateLocalTextPatchShiftBudget(blocks, startIndex) {
+    const shiftedBlocks = Math.max(0, blocks.length - startIndex);
+    let shiftedNodes = 0;
+    for (let index = startIndex; index < blocks.length; index += 1) {
+      const shiftedBlockNodes = countSurfaceShiftNodesUpTo(
+        blocks[index],
+        Math.min(
+          LOCAL_TEXT_PATCH_MAX_SHIFTED_NODES_PER_BLOCK,
+          LOCAL_TEXT_PATCH_MAX_SHIFTED_SURFACE_NODES - shiftedNodes
+        ) + 1
+      );
+      shiftedNodes += shiftedBlockNodes;
+      if (shiftedBlockNodes > LOCAL_TEXT_PATCH_MAX_SHIFTED_NODES_PER_BLOCK) {
+        return {
+          shiftedBlocks,
+          shiftedNodes,
+          withinBudget: false
+        };
+      }
+      if (shiftedNodes > LOCAL_TEXT_PATCH_MAX_SHIFTED_SURFACE_NODES) {
+        return {
+          shiftedBlocks,
+          shiftedNodes,
+          withinBudget: false
+        };
+      }
+    }
+    return {
+      shiftedBlocks,
+      shiftedNodes,
+      withinBudget: true
+    };
+  }
+  function countSurfaceShiftNodesUpTo(block, limit) {
+    if (limit <= 0) {
+      return 1;
+    }
+    switch (block.kind) {
+      case "paragraph":
+        return 1 + block.segments.length;
+      case "opaque_block":
+        return 1;
+      case "sdt_block": {
+        let total = 1;
+        for (const child of block.children) {
+          total += countSurfaceShiftNodesUpTo(child, limit - total);
+          if (total > limit) {
+            return total;
+          }
+        }
+        return total;
+      }
+      case "table": {
+        let total = 1;
+        for (const row2 of block.rows) {
+          total += 1;
+          if (total > limit) {
+            return total;
+          }
+          for (const cell of row2.cells) {
+            total += 1;
+            if (total > limit) {
+              return total;
+            }
+            for (const child of cell.content) {
+              total += countSurfaceShiftNodesUpTo(child, limit - total);
+              if (total > limit) {
+                return total;
+              }
+            }
+          }
+        }
+        return total;
+      }
+    }
+  }
+  function enrichCulledPlaceholdersWithHeights(snapshot, document2, nextActiveStory, fullSurfaceForPlaceholders) {
     let heights;
     try {
       heights = layoutFacet.getBlockHeightsTwips();
@@ -67506,17 +68258,19 @@ function createDocumentRuntime(options) {
       return snapshot;
     }
     if (heights.size === 0) return snapshot;
+    const fullSurface = fullSurfaceForPlaceholders ?? getReusableCachedFullSurface(document2, nextActiveStory);
+    if (!fullSurface) return snapshot;
     let changed = false;
     const enrichedBlocks = snapshot.blocks.map((block) => {
       if (block.kind !== "opaque_block" || block.state !== "placeholder-culled") {
         return block;
       }
-      const realBlockIdFromOffset = resolveBlockIdFromRuntimeOffset(
-        layoutFacet,
-        block.from
+      const realBlock = resolveFullSurfaceBlockForPlaceholder(
+        fullSurface,
+        block
       );
-      if (!realBlockIdFromOffset) return block;
-      const heightTwips = heights.get(realBlockIdFromOffset);
+      if (!realBlock) return block;
+      const heightTwips = heights.get(realBlock.blockId);
       if (typeof heightTwips !== "number" || heightTwips <= 0) return block;
       changed = true;
       return { ...block, placeholderHeightTwips: heightTwips };
@@ -67524,13 +68278,20 @@ function createDocumentRuntime(options) {
     if (!changed) return snapshot;
     return { ...snapshot, blocks: enrichedBlocks };
   }
-  function resolveBlockIdFromRuntimeOffset(facet, runtimeOffset) {
-    try {
-      const frag = facet.getFragmentForOffset?.(runtimeOffset);
-      return frag?.blockId ?? null;
-    } catch {
-      return null;
+  function resolveFullSurfaceBlockForPlaceholder(fullSurface, placeholder) {
+    const index = parsePlaceholderCulledIndex(placeholder.blockId);
+    if (index !== null) {
+      return fullSurface.blocks[index] ?? null;
     }
+    return fullSurface.blocks.find(
+      (block) => block.from === placeholder.from && block.to === placeholder.to
+    ) ?? null;
+  }
+  function parsePlaceholderCulledIndex(blockId) {
+    const match = /^placeholder-culled-(\d+)$/.exec(blockId);
+    if (!match) return null;
+    const index = Number(match[1]);
+    return Number.isSafeInteger(index) ? index : null;
   }
   function getCachedFieldSnapshot(document2) {
     const blockCount = document2.content.children.length;
@@ -68095,7 +68856,14 @@ function createDocumentRuntime(options) {
       revisionToken: state.revisionToken
     });
     perfCounters.increment("refresh.all");
-    const surface = timeFacet("surface", () => getCachedSurface(state.document, activeStory));
+    const firstSurfaceViewportBlockRanges = initialSurfaceViewportBlockRanges;
+    initialSurfaceViewportBlockRanges = null;
+    const surface = timeFacet(
+      "surface",
+      () => firstSurfaceViewportBlockRanges ? getCachedSurface(state.document, activeStory, {
+        viewportBlockRangesOverride: firstSurfaceViewportBlockRanges
+      }) : getCachedSurface(state.document, activeStory)
+    );
     const snapshot = {
       documentId: state.documentId,
       sessionId: state.sessionId,
@@ -68193,8 +68961,10 @@ function createDocumentRuntime(options) {
     if (options2.forceProjection) {
       cachedFullSurface = void 0;
     }
-    const newSurface = viewportBlockRanges !== null && options2.forceProjection !== true ? createViewportCulledSurfaceFromFullSurface(
-      getCachedFullSurface(state.document, activeStory),
+    const reusableFullSurface = viewportBlockRanges !== null && options2.forceProjection !== true ? getReusableCachedFullSurface(state.document, activeStory) : void 0;
+    const derivedFromFull = viewportBlockRanges !== null && reusableFullSurface !== void 0;
+    const projectedSurface = derivedFromFull ? createViewportCulledSurfaceFromFullSurface(
+      reusableFullSurface,
       viewportBlockRanges
     ) : createEditorSurfaceSnapshot(
       state.document,
@@ -68202,11 +68972,21 @@ function createDocumentRuntime(options) {
       activeStory,
       {
         viewportBlockRanges,
-        editableTargetsByBlockPath: getEditableTargetsByBlockPath(state.document),
+        editableTargetsByBlockPath: getEditableTargetsByBlockPathForRanges(
+          state.document,
+          activeStoryKey,
+          viewportBlockRanges
+        ),
         ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
       }
     );
-    if (viewportBlockRanges !== null && options2.forceProjection !== true) {
+    const newSurface = viewportBlockRanges !== null ? enrichCulledPlaceholdersWithHeights(
+      projectedSurface,
+      state.document,
+      activeStory,
+      reusableFullSurface
+    ) : projectedSurface;
+    if (derivedFromFull) {
       perfCounters.increment("runtime.viewport.derivedSurfaceRefreshes");
     } else {
       recordPerfSample("snapshot.surface");
@@ -68750,6 +69530,8 @@ function createDocumentRuntime(options) {
           documentMode: workflowCoordinator.getEffectiveDocumentMode(commandSelection),
           defaultAuthorId: defaultAuthorId ?? void 0,
           renderSnapshot: cachedRenderSnapshot,
+          activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
+          editableTargetCache: editableTargetBlockCache,
           ...resolvedFragmentTextTarget ? { textTarget: resolvedFragmentTextTarget } : {}
         };
         const preSelection = commandSelection;
@@ -69277,12 +70059,86 @@ function createDocumentRuntime(options) {
       }
     },
     applyScopeReplacement(plan) {
+      const resolveEditableTargetHint = (hint) => {
+        if (!hint) return void 0;
+        const activeStoryKey = storyTargetKey(activeStory);
+        if (hint.storyKey !== activeStoryKey) return null;
+        const currentTargets = collectEditableTargetRefs(
+          state.document,
+          editableTargetBlockCache
+        );
+        const target = currentTargets.find(
+          (target2) => target2.storyKey === hint.storyKey && target2.blockPath === hint.blockPath && target2.commandFamily === "text-leaf"
+        );
+        if (!target) return null;
+        const fallbackTextTarget = {
+          kind: "text-leaf",
+          blockPath: target.blockPath,
+          paragraphStart: hint.semanticBlockRange.from,
+          paragraphEnd: hint.semanticBlockRange.to
+        };
+        const resolved = resolveEditableTextTarget({
+          document: state.document,
+          surface: cachedRenderSnapshot.surface?.blocks ?? [],
+          target,
+          activeStoryKey,
+          editableTargetCache: editableTargetBlockCache
+        });
+        if (resolved.kind === "rejected") {
+          return {
+            textTarget: fallbackTextTarget,
+            range: hint.semanticBlockRange
+          };
+        }
+        return {
+          target,
+          textTarget: resolved.textTarget ?? fallbackTextTarget,
+          range: resolved.range
+        };
+      };
+      const mapSemanticStepRangeToEditableTarget = (stepRange, hint, editableRange) => {
+        if (!hint || !editableRange) return stepRange;
+        const semanticFrom = hint.semanticBlockRange.from;
+        const semanticTo = hint.semanticBlockRange.to;
+        const localFrom = Math.max(0, stepRange.from - semanticFrom);
+        const localTo = Math.max(localFrom, stepRange.to - semanticFrom);
+        const semanticLength = Math.max(0, semanticTo - semanticFrom);
+        const editableLength = Math.max(0, editableRange.to - editableRange.from);
+        if (semanticLength === editableLength) {
+          return {
+            from: editableRange.from + localFrom,
+            to: editableRange.from + localTo
+          };
+        }
+        if (stepRange.from === semanticFrom && stepRange.to === semanticTo) {
+          return editableRange;
+        }
+        return stepRange;
+      };
       for (const step of plan.steps) {
         if (step.kind === "text-replace" && step.range && typeof step.text === "string") {
+          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: step.range.from,
-            to: step.range.to,
+            from: dispatchRange.from,
+            to: dispatchRange.to,
             assoc: { start: -1, end: 1 }
           };
           const timestamp = clock();
@@ -69291,6 +70147,8 @@ function createDocumentRuntime(options) {
               {
                 type: "text.insert",
                 text: step.text,
+                ...editableTarget?.target ? { editableTarget: editableTarget.target } : {},
+                ...editableTarget?.textTarget ? { textTarget: editableTarget.textTarget } : {},
                 ...step.formatting ? { formatting: step.formatting } : {},
                 origin: createOrigin("api", timestamp)
               },
@@ -69328,10 +70186,28 @@ function createDocumentRuntime(options) {
             emitError(toRuntimeError(error));
           }
         } else if (step.kind === "text-insert-tracked" && step.range && typeof step.text === "string") {
+          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: step.range.from,
-            to: step.range.to,
+            from: dispatchRange.from,
+            to: dispatchRange.to,
             assoc: { start: -1, end: 1 }
           };
           const timestamp = clock();
@@ -69340,6 +70216,8 @@ function createDocumentRuntime(options) {
               {
                 type: "text.insert",
                 text: step.text,
+                ...editableTarget?.target ? { editableTarget: editableTarget.target } : {},
+                ...editableTarget?.textTarget ? { textTarget: editableTarget.textTarget } : {},
                 ...step.formatting ? { formatting: step.formatting } : {},
                 origin: createOrigin("api", timestamp)
               },
@@ -69354,10 +70232,28 @@ function createDocumentRuntime(options) {
             emitError(toRuntimeError(error));
           }
         } else if (step.kind === "text-delete-tracked" && step.range && step.range.to > step.range.from) {
+          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: step.range.from,
-            to: step.range.to,
+            from: dispatchRange.from,
+            to: dispatchRange.to,
             assoc: { start: -1, end: 1 }
           };
           const timestamp = clock();
@@ -69365,6 +70261,8 @@ function createDocumentRuntime(options) {
             applyTextCommandInActiveStory(
               {
                 type: "text.delete-forward",
+                ...editableTarget?.target ? { editableTarget: editableTarget.target } : {},
+                ...editableTarget?.textTarget ? { textTarget: editableTarget.textTarget } : {},
                 origin: createOrigin("api", timestamp)
               },
               {
@@ -70885,9 +71783,13 @@ function createDocumentRuntime(options) {
       applyViewportRanges(getSelectionCorridorViewportRanges(cachedRenderSnapshot.surface));
     }
     const tValidation0 = performance.now();
-    const patchedLocalTextSurface = useLocalTextCommitSnapshot ? tryPatchLocalTextSurface(cachedRenderSnapshot.surface, transaction.mapping) : null;
+    const patchedFullLocalTextSurface = useLocalTextCommitSnapshot ? tryPatchLocalTextSurface(cachedRenderSnapshot.surface, transaction.mapping) : null;
+    const patchedLocalTextSurface = patchedFullLocalTextSurface ? createLocalTextCorridorSurfaceFromFullSurface(patchedFullLocalTextSurface) : null;
     if (patchedLocalTextSurface) {
-      cachePatchedLocalTextSurface(patchedLocalTextSurface);
+      cachePatchedLocalTextSurface(
+        patchedLocalTextSurface,
+        patchedFullLocalTextSurface ?? void 0
+      );
       perfCounters.increment("commit.localTextValidation.storySizeOnly");
     }
     const localTextViewportRanges = useLocalTextCommitSnapshot && !patchedLocalTextSurface ? getSelectionCorridorViewportRanges(cachedRenderSnapshot.surface) : void 0;
@@ -70927,7 +71829,8 @@ function createDocumentRuntime(options) {
     cachedRenderSnapshot = useLocalTextCommitSnapshot ? refreshLocalTextCommitSnapshot(surfaceForValidation, transaction.mapping) : refreshRenderSnapshot();
     perfCounters.increment("commit.refresh.us", Math.round((performance.now() - tRefresh0) * 1e3));
     const tNotify0 = performance.now();
-    deferNextContextAnalyticsEmit = useLocalTextCommitSnapshot;
+    const shouldDeferContextAnalyticsEmit = transaction.markDirty && transaction.mapping.steps.length > 0;
+    deferNextContextAnalyticsEmit = shouldDeferContextAnalyticsEmit;
     try {
       notify(previous, state, {
         ...transaction,
@@ -71228,6 +72131,8 @@ function createDocumentRuntime(options) {
       documentMode: textOptions.documentModeOverride ?? workflowCoordinator.getEffectiveDocumentMode(selection),
       defaultAuthorId: defaultAuthorId ?? void 0,
       renderSnapshot: cachedRenderSnapshot,
+      activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
+      editableTargetCache: editableTargetBlockCache,
       activeStorySize: cachedRenderSnapshot.surface?.storySize,
       textTarget,
       rejectTargetlessTableStructureInsert: true
@@ -71528,7 +72433,9 @@ function createDocumentRuntime(options) {
         timestamp: clock(),
         documentMode: workflowCoordinator.getEffectiveDocumentMode(state.selection),
         defaultAuthorId: defaultAuthorId ?? void 0,
-        renderSnapshot: cachedRenderSnapshot
+        renderSnapshot: cachedRenderSnapshot,
+        activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
+        editableTargetCache: editableTargetBlockCache
       };
       try {
         const transaction = executeEditorCommand(
@@ -89321,6 +90228,12 @@ function openDocxSync(opts) {
   return loadDocxSessionSync(opts);
 }
 
+// src/api/mounted-surface-residency.ts
+var MOUNTED_SURFACE_VIEWPORT_BLOCK_THRESHOLD = 250;
+function shouldUseMountedSurfaceViewportCulling(totalBlockCount) {
+  return totalBlockCount > MOUNTED_SURFACE_VIEWPORT_BLOCK_THRESHOLD;
+}
+
 // src/ui/browser-export.ts
 function withExportDelivery(result, delivery) {
   return {
@@ -89891,6 +90804,9 @@ function createRuntime(args, handlers = {}) {
     )
   ));
   const runtimeSessionState = snapshotExportResolution?.barrier ? applySessionExportBarrier(initialSessionState, snapshotExportResolution.barrier) : initialSessionState;
+  const initialSurfaceViewportBlockRanges = getMountedInitialSurfaceViewportBlockRanges(
+    runtimeSessionState
+  );
   const baseRuntime = createDocumentRuntime({
     documentId: args.documentId,
     initialSessionState: runtimeSessionState,
@@ -89902,6 +90818,7 @@ function createRuntime(args, handlers = {}) {
     fatalError: docxSession?.fatalError,
     protectionSnapshot: docxSession?.protectionSnapshot,
     ...args.source.preloadedLaycacheGraph ? { seedLayoutCache: args.source.preloadedLaycacheGraph } : {},
+    ...initialSurfaceViewportBlockRanges ? { initialSurfaceViewportBlockRanges } : {},
     exportDocx: async (sessionState, options) => {
       if (docxSession) {
         return docxSession.exportDocx(sessionState, options);
@@ -89984,6 +90901,18 @@ function createRuntime(args, handlers = {}) {
   });
   return runtime;
 }
+function getMountedInitialSurfaceViewportBlockRanges(sessionState) {
+  const blockCount = sessionState.canonicalDocument.content.children.length;
+  if (!shouldUseMountedSurfaceViewportCulling(blockCount)) {
+    return void 0;
+  }
+  return Object.freeze([
+    Object.freeze({
+      start: 0,
+      end: MOUNTED_SURFACE_VIEWPORT_BLOCK_THRESHOLD
+    })
+  ]);
+}
 function createLoadingSnapshot(documentId, readOnly, sourceLabel) {
   return {
     documentId,
@@ -106337,26 +107266,42 @@ function resolveTopBarCommentAvailability(input) {
 
 // src/ui-tailwind/review-workspace/use-status-bar-page-facts.ts
 var import_react39 = require("react");
-function useStatusBarPageFacts(options) {
-  const { layoutFacet, selectionPosition, activeStory, renderFrameRevision } = options;
-  return (0, import_react39.useMemo)(() => {
-    const facet = layoutFacet;
-    if (!facet) {
-      return {
-        displayPageNumber: null,
-        pageCount: null,
-        measurementFidelity: void 0
-      };
-    }
-    const pageRef = facet.getPageForOffset(selectionPosition, activeStory);
-    const displayPageNumber = pageRef !== null && typeof pageRef.pageIndex === "number" ? facet.getDisplayPageNumber(pageRef.pageIndex) ?? pageRef.pageIndex + 1 : null;
-    const pageCount = facet.getPageCount();
+function resolveStatusBarPageFacts(options) {
+  const { layoutFacet: facet, selectionPosition, activeStory, viewportPageIndexRange } = options;
+  if (!facet) {
     return {
-      displayPageNumber,
-      pageCount,
-      measurementFidelity: facet.getMeasurementFidelity()
+      displayPageNumber: null,
+      pageCount: null,
+      measurementFidelity: void 0
     };
-  }, [layoutFacet, selectionPosition, activeStory, renderFrameRevision]);
+  }
+  const pageCount = facet.getPageCount();
+  const viewportPageIndex = viewportPageIndexRange && viewportPageIndexRange.start >= 0 && viewportPageIndexRange.start < pageCount ? viewportPageIndexRange.start : null;
+  const pageRef = viewportPageIndex !== null ? { pageIndex: viewportPageIndex } : facet.getPageForOffset(selectionPosition, activeStory);
+  const displayPageNumber = normalizeStatusDisplayPageNumber(
+    pageRef !== null && typeof pageRef.pageIndex === "number" ? facet.getDisplayPageNumber(pageRef.pageIndex) : null,
+    pageRef !== null && typeof pageRef.pageIndex === "number" ? pageRef.pageIndex : null
+  );
+  return {
+    displayPageNumber,
+    pageCount,
+    measurementFidelity: facet.getMeasurementFidelity()
+  };
+}
+function normalizeStatusDisplayPageNumber(displayPageNumber, pageIndex) {
+  if (pageIndex === null) return null;
+  return typeof displayPageNumber === "number" && displayPageNumber > 0 ? displayPageNumber : pageIndex + 1;
+}
+function useStatusBarPageFacts(options) {
+  const { layoutFacet, selectionPosition, activeStory, renderFrameRevision, viewportPageIndexRange } = options;
+  return (0, import_react39.useMemo)(() => {
+    return resolveStatusBarPageFacts({
+      layoutFacet,
+      selectionPosition,
+      activeStory,
+      viewportPageIndexRange
+    });
+  }, [layoutFacet, selectionPosition, activeStory, viewportPageIndexRange, renderFrameRevision]);
 }
 
 // src/ui-tailwind/review-workspace/use-grabbed-segment-offsets.ts
@@ -107364,7 +108309,7 @@ function pageMarkersEqual(a, b) {
   }
   return true;
 }
-function useGeometryVisiblePageIndexRange(input) {
+function useGeometryVisiblePageIndexRanges(input) {
   const {
     scrollRoot,
     geometryFacet,
@@ -107374,10 +108319,12 @@ function useGeometryVisiblePageIndexRange(input) {
     renderFrameRevision,
     viewportScale
   } = input;
-  const [range, setRange] = (0, import_react46.useState)(null);
+  const [ranges, setRanges] = (0, import_react46.useState)({ visiblePageIndexRange: null, viewportPageIndexRange: null });
   (0, import_react46.useEffect)(() => {
     if (!scrollRoot || !geometryFacet) {
-      setRange((prev) => prev === null ? prev : null);
+      setRanges(
+        (prev) => prev.visiblePageIndexRange === null && prev.viewportPageIndexRange === null ? prev : { visiblePageIndexRange: null, viewportPageIndexRange: null }
+      );
       return void 0;
     }
     const runtime = scrollRoot.ownerDocument?.defaultView;
@@ -107387,7 +108334,7 @@ function useGeometryVisiblePageIndexRange(input) {
       if (disposed) return;
       const pageCount = layoutFacet?.getPageCount() ?? pageMarkerCount;
       const scale = typeof viewportScale === "number" && Number.isFinite(viewportScale) && viewportScale > 0 ? viewportScale : 1;
-      const next = resolveVisiblePageIndexRangeFromViewport({
+      const nextVisible = resolveVisiblePageIndexRangeFromViewport({
         pageCount,
         viewportTopPx: scrollRoot.scrollTop / scale,
         viewportHeightPx: scrollRoot.clientHeight / scale,
@@ -107397,7 +108344,22 @@ function useGeometryVisiblePageIndexRange(input) {
           return page ? page.frame : null;
         }
       });
-      setRange((prev) => pageRangeEqual(prev, next) ? prev : next);
+      const nextViewport = resolveVisiblePageIndexRangeFromViewport({
+        pageCount,
+        viewportTopPx: scrollRoot.scrollTop / scale,
+        viewportHeightPx: scrollRoot.clientHeight / scale,
+        overscanPages: 0,
+        getPageFrame: (pageIndex) => {
+          const page = geometryFacet.getPage(pageIndex);
+          return page ? page.frame : null;
+        }
+      });
+      setRanges(
+        (prev) => pageRangeEqual(prev.visiblePageIndexRange, nextVisible) && pageRangeEqual(prev.viewportPageIndexRange, nextViewport) ? prev : {
+          visiblePageIndexRange: nextVisible,
+          viewportPageIndexRange: nextViewport
+        }
+      );
     };
     const schedule = () => {
       if (disposed || rafHandle !== null) return;
@@ -107434,7 +108396,7 @@ function useGeometryVisiblePageIndexRange(input) {
     scrollRoot,
     viewportScale
   ]);
-  return range;
+  return ranges;
 }
 function shouldUseCompatibilityPageMarkerScan(input) {
   return !input.geometryFacet || !input.layoutFacet;
@@ -107535,7 +108497,11 @@ function usePageMarkers(options) {
     pageMarkers,
     overscanPages
   });
-  const geometryVisiblePageIndexRange = useGeometryVisiblePageIndexRange({
+  const markerViewportPageIndexRange = useVisiblePageIndexRange({
+    pageMarkers,
+    overscanPages: 0
+  });
+  const geometryPageIndexRanges = useGeometryVisiblePageIndexRanges({
     scrollRoot: pageStackScrollRoot,
     geometryFacet,
     layoutFacet,
@@ -107544,7 +108510,8 @@ function usePageMarkers(options) {
     renderFrameRevision,
     viewportScale
   });
-  const visiblePageIndexRange = geometryVisiblePageIndexRange ?? markerVisiblePageIndexRange;
+  const visiblePageIndexRange = geometryPageIndexRanges.visiblePageIndexRange ?? markerVisiblePageIndexRange;
+  const viewportPageIndexRange = geometryPageIndexRanges.viewportPageIndexRange ?? markerViewportPageIndexRange;
   const visibleBlockRangesFromPageOffsets = (0, import_react46.useMemo)(
     () => visiblePageIndexRange && layoutFacet ? resolveVisibleBlockRangesFromPageOffsets({
       blocks: snapshot.surface?.blocks ?? [],
@@ -107580,9 +108547,11 @@ function usePageMarkers(options) {
     ]
   );
   const visibleBlockRanges = visibleBlockRangesFromPageOffsets ?? visibleBlockRangesFromPageRange ?? markerVisibleBlockRanges;
+  const totalBlockCount = snapshot.surface?.blocks.length ?? 0;
+  const shouldCullSurface = shouldUseMountedSurfaceViewportCulling(totalBlockCount);
   const visibleRangesKey = (0, import_react46.useMemo)(
-    () => visibleBlockRanges.map((r) => `${r.start}:${r.end}`).join("|"),
-    [visibleBlockRanges]
+    () => shouldCullSurface ? visibleBlockRanges.map((r) => `${r.start}:${r.end}`).join("|") : "full",
+    [shouldCullSurface, visibleBlockRanges]
   );
   (0, import_react46.useEffect)(() => {
     if (!layoutFacet) return;
@@ -107591,13 +108560,19 @@ function usePageMarkers(options) {
       layoutFacet.requestViewportRefresh();
       return;
     }
+    if (!shouldCullSurface) {
+      layoutFacet.setVisibleBlockRanges([]);
+      layoutFacet.requestViewportRefresh();
+      return;
+    }
     layoutFacet.setVisibleBlockRanges(visibleBlockRanges);
     layoutFacet.requestViewportRefresh();
-  }, [layoutFacet, visibleRangesKey]);
+  }, [layoutFacet, shouldCullSurface, visibleRangesKey]);
   return {
     pageMarkers,
     visibleBlockRanges,
-    visiblePageIndexRange: VIEWPORT_CULLING_ENABLED ? visiblePageIndexRange : null
+    visiblePageIndexRange: VIEWPORT_CULLING_ENABLED ? visiblePageIndexRange : null,
+    viewportPageIndexRange: VIEWPORT_CULLING_ENABLED ? viewportPageIndexRange : null
   };
 }
 
@@ -110024,11 +110999,20 @@ function TwReviewWorkspace(inputProps) {
     selectionToolbarRootRef
   });
   const activePage = props.documentNavigation?.pages[props.documentNavigation.activePageIndex] ?? null;
+  const { visiblePageIndexRange, viewportPageIndexRange } = usePageMarkers({
+    pageStackScrollRoot,
+    snapshot,
+    layoutFacet: props.layoutFacet,
+    geometryFacet: props.geometryFacet,
+    renderFrameRevision,
+    viewportScale: zoomScale
+  });
   const grabbedSegmentOffsets = useGrabbedSegmentOffsets(snapshot);
   const statusBarPageFacts = useStatusBarPageFacts({
     layoutFacet: props.layoutFacet,
     selectionPosition,
     activeStory: snapshot.activeStory,
+    viewportPageIndexRange,
     renderFrameRevision
   });
   const hidePageBorderForActiveEditing = isPageWorkspace && snapshot.activeStory.kind === "main" && shouldHidePageBorderForSelection(viewState.selection);
@@ -110054,14 +111038,6 @@ function TwReviewWorkspace(inputProps) {
   });
   const suppressFloatingToolDuringEditorInput = viewState.editorRole === "editor" && viewState.selection.isCollapsed;
   const shouldRenderFloatingSelectionTool = chromeVisibility.selectionOverlay && gatedSelectionTool && !suppressFloatingToolDuringEditorInput && shouldRenderSelectionToolKind(scopedChromePolicy, gatedSelectionTool.kind);
-  const { visiblePageIndexRange } = usePageMarkers({
-    pageStackScrollRoot,
-    snapshot,
-    layoutFacet: props.layoutFacet,
-    geometryFacet: props.geometryFacet,
-    renderFrameRevision,
-    viewportScale: zoomScale
-  });
   const { dismissSelectionToolbar, runWithSelectionToolbarDismiss } = useWorkspaceSideEffects({
     layoutFacet: props.layoutFacet,
     activeParagraphLayout,
@@ -127403,6 +128379,17 @@ var hyperlinkDestinationEditMetadata = actionMethodMetadata(
     expectedDelta: "hyperlink destination changes"
   }
 );
+var hyperlinkTextEditMetadata = actionMethodMetadata(
+  "hyperlinkTextEdit",
+  "mutate",
+  "actions-link-bookmark",
+  "Edit supported hyperlink display text through the L07 text-leaf command target; broad carrier scope rewrite remains refused.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "hyperlink display text changes"
+  }
+);
 var listOperationMetadata = actionMethodMetadata(
   "listOperation",
   "mutate",
@@ -127462,6 +128449,7 @@ var ACTION_METHODS = Object.freeze([
   "tocRefresh",
   "bookmarkEdit",
   "hyperlinkDestinationEdit",
+  "hyperlinkTextEdit",
   "listOperation",
   "tableFragment",
   "tableSelection",
@@ -127471,6 +128459,9 @@ var DEFAULT_LOCATE_LIMIT = 20;
 var DEFAULT_REWRITE_ALL_LIMIT = 10;
 var DEFAULT_TABLE_TEXT_SCOPE_LIMIT = 3;
 var DEFAULT_PLAN_STEP_LIMIT = 20;
+function documentContentHash(runtime) {
+  return JSON.stringify(runtime.getCanonicalDocument().content);
+}
 function createActionsFamily(runtime) {
   const category = {
     discover(input) {
@@ -127717,6 +128708,14 @@ function createActionsFamily(runtime) {
           ...readback ? { text: readback.text, excerpt: excerpt(readback.text) } : {}
         };
       }
+      if (resolved.target.kind === "editable-text") {
+        return {
+          status: "read",
+          target: summarizeTarget(resolved.target),
+          text: resolved.target.readback.text,
+          excerpt: excerpt(resolved.target.readback.text)
+        };
+      }
       const text = resolved.target.scope.content.text;
       return {
         status: "read",
@@ -127797,6 +128796,31 @@ function createActionsFamily(runtime) {
         input
       );
     },
+    hyperlinkTextEdit(input) {
+      if (input.text === void 0) {
+        return blockedApply(
+          "actions:hyperlink-text-edit:text-required",
+          "input",
+          "Hyperlink display text edit actions require a text value.",
+          "Retry with a text string."
+        );
+      }
+      const resolved = resolveTarget(runtime, input.target);
+      if (!resolved.ok) return blockedApplyFromResolution(resolved);
+      if (resolved.target.kind !== "editable-text" || resolved.target.targetKind !== "hyperlink-text") {
+        return blockedApply(
+          "actions:hyperlink-text-edit:hyperlink-text-handle-required",
+          "unsupported",
+          "Hyperlink display text edits require an exact hyperlink-text actionHandle.",
+          "Call ai.actions.locateAll and retry with a returned scope-command:text-leaf actionHandle."
+        );
+      }
+      return applyEditableTextRewrite(runtime, resolved.target, {
+        text: input.text,
+        actorId: input.actorId,
+        origin: input.origin
+      });
+    },
     listOperation(input) {
       return applyListOperation(runtime, input);
     },
@@ -127845,6 +128869,7 @@ function runPlan(runtime, input) {
   for (const step of input.steps) {
     const result = runPlanStep(runtime, mode, step, input);
     results.push(result);
+    if (isSuspectMutationStep(result)) break;
     if (stopOnBlocker && (result.status === "blocked" || result.status === "unsupported")) {
       break;
     }
@@ -127909,24 +128934,27 @@ function runPlanStep(runtime, mode, step, plan) {
       ...before.readback ? { beforeReadback: before.readback } : {}
     };
   }
+  const documentHashBeforeApply = documentContentHash(runtime);
   const applied = applyPlanStep(runtime, step, plan);
+  const documentHashAfterApply = documentContentHash(runtime);
+  const projectedApply = !applied.applied && documentHashAfterApply !== documentHashBeforeApply ? withSuspectMutationApplyResult(applied, step.id, applied.target ?? before.target) : applied;
   const after = step.kind === "flag" ? before : step.target ? readPlanTarget(runtime, step.target) : before;
   return {
     id: step.id,
     kind: step.kind,
-    status: applied.status === "unsupported" ? "unsupported" : applied.applied ? "applied" : "blocked",
-    applied: applied.applied,
-    changed: applied.changed,
-    ...applied.target ?? before.target ? { target: applied.target ?? before.target } : {},
+    status: projectedApply.status === "unsupported" ? "unsupported" : projectedApply.applied ? "applied" : "blocked",
+    applied: projectedApply.applied,
+    changed: projectedApply.changed,
+    ...projectedApply.target ?? before.target ? { target: projectedApply.target ?? before.target } : {},
     ...before.tableAction ? { tableAction: before.tableAction } : {},
     ...before.readback ? { beforeReadback: before.readback } : {},
     ...after.ok && after.readback ? { afterReadback: after.readback } : {},
-    ...applied.proposalId ? { proposalId: applied.proposalId } : {},
-    ...applied.posture ? { posture: applied.posture } : {},
-    ...applied.blockers ? { blockers: applied.blockers } : {},
-    ...applied.blockerDetails ? { blockerDetails: applied.blockerDetails } : {},
-    ...applied.auditReference ? { auditReference: applied.auditReference } : {},
-    ...applied.commandReference ? { commandReference: applied.commandReference } : {}
+    ...projectedApply.proposalId ? { proposalId: projectedApply.proposalId } : {},
+    ...projectedApply.posture ? { posture: projectedApply.posture } : {},
+    ...projectedApply.blockers ? { blockers: projectedApply.blockers } : {},
+    ...projectedApply.blockerDetails ? { blockerDetails: projectedApply.blockerDetails } : {},
+    ...projectedApply.auditReference ? { auditReference: projectedApply.auditReference } : {},
+    ...projectedApply.commandReference ? { commandReference: projectedApply.commandReference } : {}
   };
 }
 function runPlanTableActionStep(runtime, mode, step, plan) {
@@ -128054,6 +129082,23 @@ function locateAll(runtime, input) {
       isEmpty: text.trim().length === 0
     });
   }
+  if (matches.length < limit && !input.kind) {
+    for (const scope of scopes) {
+      if (matches.length >= limit) break;
+      for (const action of editableTextActionsForScope(runtime, scope.handle)) {
+        if (matches.length >= limit) break;
+        if (!textMatches(action.readback.text, input.query, input.matchCase)) continue;
+        matches.push({
+          kind: action.targetKind,
+          text: action.readback.text,
+          excerpt: excerpt(action.readback.text),
+          actionHandle: action.actionHandle,
+          readback: action.readback,
+          isEmpty: action.readback.isEmpty
+        });
+      }
+    }
+  }
   if (matches.length < limit && shouldScanTableText) {
     const tableTextScopeLimit = Math.max(
       0,
@@ -128088,23 +129133,27 @@ function locateAll(runtime, input) {
 function resolveTarget(runtime, target) {
   if ("actionHandle" in target) {
     const action = findTableAction(runtime, target.actionHandle);
-    if (!action) {
-      return blockedResolution(
-        `actions:target:action-handle-not-found:${target.actionHandle}`,
-        "unresolved-target",
-        "No current table text action matches the supplied actionHandle.",
-        "Call ai.actions.locateAll or ai.listTableActions again and retry with a fresh actionHandle."
-      );
+    if (action) {
+      if (action.family !== "table-text") {
+        return blockedResolution(
+          `actions:target:action-handle-not-text:${target.actionHandle}`,
+          "unsupported",
+          "This actionHandle is not a table text action.",
+          "Use table structure handles with ai.applyTableAction, or use a table text actionHandle for rewrite."
+        );
+      }
+      return { ok: true, target: { kind: "table-text", action } };
     }
-    if (action.family !== "table-text") {
-      return blockedResolution(
-        `actions:target:action-handle-not-text:${target.actionHandle}`,
-        "unsupported",
-        "This actionHandle is not a table text action.",
-        "Use table structure handles with ai.applyTableAction, or use a table text actionHandle for rewrite."
-      );
+    const editableTextAction = findEditableTextAction(runtime, target.actionHandle);
+    if (editableTextAction) {
+      return { ok: true, target: editableTextAction };
     }
-    return { ok: true, target: { kind: "table-text", action } };
+    return blockedResolution(
+      `actions:target:action-handle-not-found:${target.actionHandle}`,
+      "unresolved-target",
+      "No current table text or editable text action matches the supplied actionHandle.",
+      "Call ai.actions.locateAll again and retry with a fresh actionHandle."
+    );
   }
   if ("handle" in target) {
     const compiled = createScopeCompilerService(runtime).compileScopeById(target.handle.scopeId);
@@ -128189,7 +129238,21 @@ function applyRewrite(runtime, target, input) {
       ...result2.afterReadback ? { afterReadback: result2.afterReadback } : {}
     };
   }
+  if (target.kind === "editable-text") {
+    return applyEditableTextRewrite(runtime, target, input);
+  }
+  const rewriteBlocker = scopeRewriteCapabilityBlocker(target.scope);
+  if (rewriteBlocker) {
+    return blockedApply(
+      rewriteBlocker.code,
+      rewriteBlocker.category,
+      rewriteBlocker.message,
+      rewriteBlocker.nextStep,
+      [rewriteBlocker]
+    );
+  }
   const beforeText = target.scope.content.text;
+  const documentHashBeforeApply = documentContentHash(runtime);
   const result = createReplacementFamily(runtime).applyReplacementScope({
     targetScopeId: target.handle.scopeId,
     operation: "replace",
@@ -128201,7 +129264,22 @@ function applyRewrite(runtime, target, input) {
     ...input.origin ? { origin: input.origin } : {},
     ...input.proposalId ? { proposalId: input.proposalId } : {}
   });
-  return projectRewriteScopeResult(runtime, result, target, beforeText, input.text);
+  const documentMutated = documentContentHash(runtime) !== documentHashBeforeApply;
+  if (!result.applied) {
+    return documentMutated ? withSuspectMutationApplyResult(
+      projectApplyResult(result, target),
+      target.handle.scopeId,
+      summarizeTarget(target)
+    ) : projectApplyResult(result, target);
+  }
+  return projectRewriteScopeResult(
+    runtime,
+    result,
+    target,
+    beforeText,
+    input.text,
+    documentMutated
+  );
 }
 function projectApplyResult(result, target) {
   return {
@@ -128222,7 +129300,79 @@ function projectApplyResult(result, target) {
     ...result.auditReference ? { auditReference: result.auditReference } : {}
   };
 }
-function projectRewriteScopeResult(runtime, result, target, beforeText, proposedText) {
+function applyEditableTextRewrite(runtime, target, input) {
+  const before = runtime.getCanonicalDocument();
+  runtime.dispatch({
+    type: "selection.set",
+    selection: target.selection,
+    origin: actionOrigin(runtime, input)
+  });
+  runtime.applyActiveStoryTextCommand({
+    type: "text.insert",
+    text: input.text,
+    editableTarget: target.editableTarget,
+    origin: actionOrigin(runtime, input)
+  });
+  const changed = runtime.getCanonicalDocument() !== before;
+  if (!changed) {
+    return blockedApply(
+      `actions:editable-text:runtime-noop:${target.actionHandle}`,
+      "blocked",
+      "The editable text command was accepted but produced no document change.",
+      "Refresh the action handle with ai.actions.locateAll and retry; route persistent failures to L07 text command support.",
+      [
+        blockerWithOwner(
+          `actions:editable-text:runtime-noop:${target.actionHandle}`,
+          "blocked",
+          "The editable text command was accepted but produced no document change.",
+          "Refresh the action handle with ai.actions.locateAll and retry; route persistent failures to L07 text command support.",
+          "L07 runtime text command support"
+        )
+      ]
+    );
+  }
+  const afterTarget = findEditableTextActionByTargetKey(
+    runtime,
+    target.editableTarget.targetKey
+  );
+  const afterReadback = afterTarget?.readback ?? editableTextTargetState(
+    runtime.getCanonicalDocument(),
+    target.editableTarget
+  )?.readback;
+  if (!afterReadback || afterReadback.text !== input.text) {
+    return {
+      status: "blocked",
+      applied: false,
+      changed: true,
+      target: summarizeTarget(afterTarget ?? target),
+      posture: "suspect-readback",
+      blockers: Object.freeze([`actions:editable-text:readback-mismatch:${target.actionHandle}`]),
+      blockerDetails: Object.freeze([
+        blocker(
+          `actions:editable-text:readback-mismatch:${target.actionHandle}`,
+          "blocked",
+          "The editable text command changed the document, but exact target readback did not match the proposed text.",
+          "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(afterTarget ?? { ...target, readback: afterReadback }),
+    commandReference: {
+      command: "text.insert",
+      actorId: input.actorId ?? "v3-ai-api",
+      origin: input.origin ?? "agent",
+      emittedAtUtc: currentAuditTimestamp(runtime)
+    },
+    afterReadback
+  };
+}
+function projectRewriteScopeResult(runtime, result, target, beforeText, proposedText, documentMutated) {
   if (!result.applied) return projectApplyResult(result, target);
   const compiledAfter = createScopeCompilerService(runtime).compileScopeById(
     target.handle.scopeId
@@ -128233,7 +129383,8 @@ function projectRewriteScopeResult(runtime, result, target, beforeText, proposed
       target,
       `actions:rewrite:authoritative-readback-unresolvable:${target.handle.scopeId}`,
       "The replacement primitive reported success, but the target scope could not be re-read afterwards.",
-      "Treat the mutation as untrusted. Re-locate the target and retry only after the scope resolves, or create an issue flag instead."
+      "Treat the mutation as untrusted. Re-locate the target and retry only after the scope resolves, or create an issue flag instead.",
+      documentMutated
     );
   }
   const afterText = compiledAfter.scope.content.text;
@@ -128245,7 +129396,8 @@ function projectRewriteScopeResult(runtime, result, target, beforeText, proposed
       { ...target, scope: compiledAfter.scope, handle: compiledAfter.scope.handle },
       `actions:rewrite:authoritative-readback-unchanged:${target.handle.scopeId}`,
       "The replacement primitive reported success, but authoritative scope readback showed unchanged text.",
-      "Treat the mutation as not applied. Retry with a narrower scope or create an issue flag; do not claim the replacement succeeded."
+      "Treat the mutation as not applied. Retry with a narrower scope or create an issue flag; do not claim the replacement succeeded.",
+      documentMutated
     );
   }
   if (!expectedPresent) {
@@ -128254,7 +129406,8 @@ function projectRewriteScopeResult(runtime, result, target, beforeText, proposed
       { ...target, scope: compiledAfter.scope, handle: compiledAfter.scope.handle },
       `actions:rewrite:authoritative-readback-mismatch:${target.handle.scopeId}`,
       "The replacement primitive reported success, but authoritative scope readback did not contain the proposed text.",
-      "Treat the mutation as suspect. Re-read the target, inspect the exported package when available, and retry only with a verified target."
+      "Treat the mutation as suspect. Re-read the target, inspect the exported package when available, and retry only with a verified target.",
+      documentMutated
     );
   }
   return {
@@ -128271,17 +129424,27 @@ function projectRewriteScopeResult(runtime, result, target, beforeText, proposed
     ...result.auditReference ? { auditReference: result.auditReference } : {}
   };
 }
-function blockedRewriteReadback(result, target, code, message, nextStep) {
+function blockedRewriteReadback(result, target, code, message, nextStep, documentMutated = false) {
   const detail = blocker(code, "blocked", message, nextStep);
+  const details = documentMutated ? [
+    detail,
+    blockerWithOwner(
+      `actions:rewrite:suspect-mutation:${target.handle.scopeId}`,
+      "blocked",
+      "The document changed even though authoritative target readback failed.",
+      "Abort the plan, inspect the export/readback evidence, and route the target to L08/L07 scope edit-target mapping before retrying.",
+      "L08 semantic scopes and L07 runtime text commands"
+    )
+  ] : [detail];
   return {
     status: "blocked",
     applied: false,
-    changed: false,
+    changed: documentMutated,
     target: summarizeTarget(target),
     proposalId: result.proposalId,
-    posture: "suspect-readback",
-    blockers: Object.freeze([detail.code]),
-    blockerDetails: Object.freeze([detail]),
+    posture: documentMutated ? "suspect-mutation" : "suspect-readback",
+    blockers: Object.freeze(details.map((entry) => entry.code)),
+    blockerDetails: Object.freeze(details),
     ...result.auditReference ? { auditReference: result.auditReference } : {}
   };
 }
@@ -128297,11 +129460,23 @@ function summarizeTarget(target) {
       canMark: false
     };
   }
+  if (target.kind === "editable-text") {
+    return {
+      kind: target.targetKind,
+      handle: target.ownerHandle,
+      actionHandle: target.actionHandle,
+      readback: target.readback,
+      canRewriteText: true,
+      canInsertAdjacentText: false,
+      canFlag: false,
+      canMark: false
+    };
+  }
   return {
     kind: target.scope.kind,
     handle: target.handle,
     canRewriteText: canRewriteScopeText(target.scope),
-    canInsertAdjacentText: canRewriteScopeText(target.scope),
+    canInsertAdjacentText: canInsertAdjacentScopeText(target.scope),
     canFlag: true,
     canMark: canMarkScope(target.scope)
   };
@@ -128313,6 +129488,34 @@ function tableTextActionsForScope(runtime, handle) {
   });
   return result.actions.filter((action) => action.family === "table-text");
 }
+function editableTextActionsForScope(runtime, handle) {
+  const bundle = createScopeCompilerService(runtime).compileBundleById(
+    handle.scopeId,
+    currentAuditTimestamp(runtime)
+  );
+  const entries = bundle?.evidence.editableTargets?.entries ?? [];
+  const currentTargets = collectEditableTargetRefs(runtime.getCanonicalDocument());
+  const actions2 = [];
+  for (const entry of entries) {
+    if (entry.kind !== "hyperlink-text" || entry.commandFamily !== "text-leaf" || entry.runtimeCommand.status !== "supported" || !entry.runtimeCommand.actionHandle) {
+      continue;
+    }
+    const currentTarget = currentTargets.find((target) => target.targetKey === entry.targetKey);
+    if (!currentTarget || currentTarget.kind !== "hyperlink-text") continue;
+    const targetState = editableTextTargetState(runtime.getCanonicalDocument(), currentTarget);
+    if (!targetState) continue;
+    actions2.push({
+      kind: "editable-text",
+      targetKind: "hyperlink-text",
+      actionHandle: entry.runtimeCommand.actionHandle,
+      editableTarget: currentTarget,
+      ownerHandle: handle,
+      readback: targetState.readback,
+      selection: targetState.selection
+    });
+  }
+  return Object.freeze(actions2);
+}
 function findTableAction(runtime, actionHandle) {
   const action = findAnyTableAction(runtime, actionHandle);
   return action?.family === "table-text" ? action : null;
@@ -128332,6 +129535,27 @@ function findAnyTableAction(runtime, actionHandle) {
   }
   return null;
 }
+function findEditableTextAction(runtime, actionHandle) {
+  if (!actionHandle.startsWith("scope-command:text-leaf:")) return null;
+  const compiler = createScopeCompilerService(runtime);
+  for (const scope of compiler.compileAllScopes()) {
+    const action = editableTextActionsForScope(runtime, scope.handle).find(
+      (candidate) => candidate.actionHandle === actionHandle
+    );
+    if (action) return action;
+  }
+  return null;
+}
+function findEditableTextActionByTargetKey(runtime, targetKey) {
+  const compiler = createScopeCompilerService(runtime);
+  for (const scope of compiler.compileAllScopes()) {
+    const action = editableTextActionsForScope(runtime, scope.handle).find(
+      (candidate) => candidate.editableTarget.targetKey === targetKey
+    );
+    if (action) return action;
+  }
+  return null;
+}
 function readDocumentPlanTarget(runtime) {
   const document2 = createInspectFamily(runtime).inspectDocument();
   return {
@@ -128388,6 +129612,18 @@ function readPlanTarget(runtime, target) {
       ])
     };
   }
+  const editableText = findEditableTextAction(runtime, target.actionHandle);
+  if (editableText) {
+    return {
+      ok: true,
+      target: summarizeTarget(editableText),
+      readback: {
+        text: editableText.readback.text,
+        excerpt: excerpt(editableText.readback.text),
+        isEmpty: editableText.readback.isEmpty
+      }
+    };
+  }
   return readPlanTableAction(runtime, target.actionHandle);
 }
 function readPlanTableAction(runtime, actionHandle) {
@@ -128450,6 +129686,15 @@ function checkPlanStepCapability(runtime, step, before) {
       "Regenerate the plan with a ScopeHandle or opaque actionHandle returned by L09."
     );
   }
+  if (step.kind === "rewrite" && target.kind === "list-item") {
+    return blockerWithOwner(
+      "capability:list-item:authoritative-readback-required",
+      "blocked",
+      "List-item text replacement is not yet backed by an authoritative mutation/readback route.",
+      "Use listOperation for numbering changes, or create an issue/explanation until L08/L07 list-item text replacement is proven.",
+      "L08 semantic scopes and L07 runtime text commands"
+    );
+  }
   if (step.kind === "rewrite" && !target.canRewriteText) {
     return blocker(
       `actions:plan:target-not-rewriteable:${step.id}`,
@@ -128482,7 +129727,20 @@ function checkPlanStepCapability(runtime, step, before) {
       "Use a supported semantic scope or create an issue flag instead."
     );
   }
-  if (step.kind === "fieldRefresh" || step.kind === "tocRefresh" || step.kind === "bookmarkEdit" || step.kind === "hyperlinkDestinationEdit") {
+  if (step.kind === "fieldRefresh" || step.kind === "tocRefresh" || step.kind === "bookmarkEdit" || step.kind === "hyperlinkDestinationEdit" || step.kind === "hyperlinkTextEdit") {
+    if (step.kind === "hyperlinkTextEdit") {
+      const resolved2 = resolveTarget(runtime, step.target);
+      if (!resolved2.ok) return resolved2.blockerDetails[0] ?? null;
+      if (resolved2.target.kind !== "editable-text" || resolved2.target.targetKind !== "hyperlink-text") {
+        return blocker(
+          `actions:hyperlink-text-edit:hyperlink-text-handle-required:${step.id}`,
+          "unsupported",
+          "Hyperlink display text plan steps require an exact hyperlink-text actionHandle.",
+          "Regenerate the plan with a scope-command:text-leaf actionHandle returned by ai.actions.locateAll."
+        );
+      }
+      return null;
+    }
     const resolved = resolveScopeExactTarget(runtime, step.target, step.kind);
     if (!resolved.ok) return resolved.blockerDetails[0] ?? null;
     const targetRef = resolveModeledEditableTarget(runtime, resolved.target, step.kind);
@@ -128587,6 +129845,13 @@ function applyPlanStep(runtime, step, plan) {
         actorId: step.actorId ?? plan.actorId,
         origin: step.origin ?? plan.origin
       });
+    case "hyperlinkTextEdit":
+      return createActionsFamily(runtime).actions.hyperlinkTextEdit({
+        target: step.target,
+        text: step.text,
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin
+      });
     case "listOperation":
       return createActionsFamily(runtime).actions.listOperation({
         target: step.target,
@@ -128903,11 +130168,159 @@ function isTableFamilyScope(kind) {
   return kind === "table" || kind === "table-row" || kind === "table-cell";
 }
 function canRewriteScopeText(scope) {
+  return !isTableFamilyScope(scope.kind) && scope.kind !== "list-item" && (scope.replaceability.level === "full" || scope.replaceability.level === "text-only");
+}
+function canInsertAdjacentScopeText(scope) {
   return !isTableFamilyScope(scope.kind) && (scope.replaceability.level === "full" || scope.replaceability.level === "text-only");
 }
+function scopeRewriteCapabilityBlocker(scope) {
+  if (scope.kind === "list-item") {
+    return blockerWithOwner(
+      "capability:list-item:authoritative-readback-required",
+      "blocked",
+      "List-item text replacement is not yet backed by an authoritative mutation/readback route.",
+      "Use listOperation for numbering changes, or create an issue/explanation until L08/L07 list-item text replacement is proven.",
+      "L08 semantic scopes and L07 runtime text commands"
+    );
+  }
+  if (!canRewriteScopeText(scope)) {
+    return blocker(
+      `actions:rewrite:target-not-rewriteable:${scope.handle.scopeId}`,
+      "unsupported",
+      "The target capability posture does not allow text rewrite.",
+      "Use a supported text target, table text actionHandle, or create an issue flag instead."
+    );
+  }
+  return null;
+}
 function canMarkScope(scope) {
   return !isTableFamilyScope(scope.kind) && scope.replaceability.level !== "blocked" && scope.replaceability.level !== "preserve-only";
 }
+function editableTextTargetState(document2, target) {
+  if (target.kind !== "hyperlink-text") return void 0;
+  const resolved = resolveHyperlinkTarget(document2, target);
+  if (!resolved) return void 0;
+  const text = collectInlineText3(resolved.hyperlink.children);
+  return {
+    readback: { text, isEmpty: text.length === 0 },
+    selection: {
+      anchor: resolved.from,
+      head: resolved.to,
+      isCollapsed: resolved.from === resolved.to,
+      activeRange: {
+        kind: "range",
+        from: resolved.from,
+        to: resolved.to,
+        assoc: { start: -1, end: 1 }
+      }
+    }
+  };
+}
+function resolveHyperlinkTarget(document2, target) {
+  const parsed = parseBlockInlinePath(target.blockPath);
+  if (!parsed) return null;
+  let blocks = document2.content.children;
+  let block;
+  let row2;
+  let offset = 0;
+  for (const token of parsed) {
+    switch (token.kind) {
+      case "block":
+        for (let index = 0; index < token.index; index += 1) {
+          offset += blockTextLength(blocks[index]);
+        }
+        block = blocks[token.index];
+        row2 = void 0;
+        if (!block) return null;
+        break;
+      case "row":
+        if (block?.type !== "table") return null;
+        row2 = block.rows[token.index];
+        block = void 0;
+        if (!row2) return null;
+        break;
+      case "cell": {
+        const cell = row2?.cells[token.index];
+        if (!cell) return null;
+        blocks = cell.children;
+        block = void 0;
+        row2 = void 0;
+        break;
+      }
+      case "inline": {
+        if (block?.type !== "paragraph") return null;
+        for (let index = 0; index < token.index; index += 1) {
+          offset += inlineTextLength(block.children[index]);
+        }
+        const inline = block.children[token.index];
+        if (inline?.type !== "hyperlink") return null;
+        const length = collectInlineText3(inline.children).length;
+        return { hyperlink: inline, from: offset, to: offset + length };
+      }
+    }
+  }
+  return null;
+}
+function parseBlockInlinePath(path) {
+  if (!path.startsWith("main/")) return null;
+  const tokens = [];
+  const re = /(block|row|cell|inline)\[(\d+)\]/gu;
+  let match;
+  while ((match = re.exec(path)) !== null) {
+    const kind = match[1];
+    tokens.push({ kind, index: Number(match[2]) });
+  }
+  return tokens.length > 0 ? Object.freeze(tokens) : null;
+}
+function collectInlineText3(inlines) {
+  let text = "";
+  for (const inline of inlines) {
+    switch (inline.type) {
+      case "text":
+        text += inline.text;
+        break;
+      case "hyperlink":
+      case "field":
+        text += collectInlineText3(inline.children);
+        break;
+      default:
+        break;
+    }
+  }
+  return text;
+}
+function blockTextLength(block) {
+  if (!block) return 0;
+  switch (block.type) {
+    case "paragraph":
+      return collectInlineText3(block.children).length;
+    case "table":
+      return block.rows.reduce(
+        (rowSum, row2) => rowSum + row2.cells.reduce(
+          (cellSum, cell) => cellSum + cell.children.reduce((blockSum, child) => blockSum + blockTextLength(child), 0),
+          0
+        ),
+        0
+      );
+    case "sdt":
+    case "custom_xml":
+      return block.children.reduce((sum, child) => sum + blockTextLength(child), 0);
+    default:
+      return 0;
+  }
+}
+function inlineTextLength(inline) {
+  if (!inline) return 0;
+  switch (inline.type) {
+    case "text":
+      return inline.text.length;
+    case "hyperlink":
+    case "field":
+      return collectInlineText3(inline.children).length;
+    default:
+      return 0;
+  }
+}
 function textMatches(text, query, matchCase) {
   if (matchCase) return text.includes(query);
   return text.toLocaleLowerCase().includes(query.toLocaleLowerCase());
@@ -128966,6 +130379,30 @@ function blockedApplyFromResolution(resolution) {
     blockerDetails: resolution.blockerDetails
   };
 }
+function withSuspectMutationApplyResult(result, stepOrScopeId, target) {
+  const detail = blockerWithOwner(
+    `actions:plan:suspect-mutation:${stepOrScopeId}`,
+    "blocked",
+    "The document changed even though the action did not return an applied result.",
+    "Abort the remaining plan, inspect authoritative readback/export evidence, and route the target to the owning edit-target/readback layer before retrying.",
+    "L08 semantic scopes and L07 runtime text commands"
+  );
+  return {
+    ...result,
+    status: "blocked",
+    applied: false,
+    changed: true,
+    ...target ? { target } : {},
+    posture: "suspect-mutation",
+    blockers: Object.freeze([...result.blockers ?? [], detail.code]),
+    blockerDetails: Object.freeze([...result.blockerDetails ?? [], detail])
+  };
+}
+function isSuspectMutationStep(step) {
+  return step.posture === "suspect-mutation" || (step.blockers ?? []).some(
+    (code) => code.startsWith("actions:plan:suspect-mutation:") || code.startsWith("actions:rewrite:suspect-mutation:")
+  );
+}
 function blockedPlan(mode, code, category, message, nextStep) {
   const detail = blocker(code, category, message, nextStep);
   return {