@beyondwork/docx-react-component 1.0.128 → 1.0.129

package/dist/{chunk-6EROGFUF.js → chunk-PRAZBHNF.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-M6XR534O.js";
 import {
   buildBookmarkNameMap
-} from "./chunk-YD2JE54B.js";
+} from "./chunk-YZDZ4FGR.js";
 import {
   deleteSelectionOrBackward,
   deleteSelectionOrForward,
@@ -22,7 +22,7 @@ import {
   insertText,
   outdentParagraphAtSelection,
   splitParagraph
-} from "./chunk-LZVBNDGU.js";
+} from "./chunk-LJH64PV3.js";
 import {
   applyFormattingOperationToDocument,
   applyTextMarkOperationToDocumentRange,
@@ -32,18 +32,18 @@ import {
   insertImage,
   repositionFloatingImage,
   resizeImage
-} from "./chunk-6F5QW44A.js";
+} from "./chunk-DJU2W4E4.js";
 import {
   applyTextTransaction
-} from "./chunk-KV435YXO.js";
+} from "./chunk-5DSHUYSY.js";
 import {
   applyTableStructureOperationForEditableTarget,
   removeCellFromRow,
   removeTableRowPure
-} from "./chunk-ZDOAUP3V.js";
+} from "./chunk-DDN2AIGE.js";
 import {
   resolveParagraphScope
-} from "./chunk-BYSRJ4FE.js";
+} from "./chunk-W34X3KBR.js";
 import {
   buildGeometryDebugEntry,
   collectLineBoxesForRegion,
@@ -51,30 +51,35 @@ import {
   createRenderKernel,
   incrementInvalidationCounter,
   recordPerfSample
-} from "./chunk-MWSBGJQO.js";
+} from "./chunk-OTQIW2TC.js";
 import {
   AI_ACTION_POLICIES,
+  allocateNumberingInstance,
   buildFormattingDebugEntry,
+  cloneNumberingCatalog,
   collectScopeLocations,
   createDocumentOutlineSnapshot,
   createDocumentSectionSnapshots,
   createScopeCompilerService,
   createSectionLocations,
   createTocSnapshot,
+  ensureDefaultListInstance,
   findAllScopesAt,
   findBookmarkNameForOffset,
   findDocumentSectionSnapshot,
   findScopesIntersecting,
   findTextMatches,
   findTextWithStyleMatches,
+  getListKind,
   rebuildFieldRegistry,
   resolveEditableCommandTarget,
   resolveEditableTableStructureTarget,
   resolveEditableTextTarget,
   resolveHeadingPath,
   resolveScope,
-  serializeFragmentToWordML
-} from "./chunk-XRACP43Q.js";
+  serializeFragmentToWordML,
+  setStartOverride
+} from "./chunk-SKPTKQHF.js";
 import {
   ISSUE_METADATA_ID,
   LAYOUT_ENGINE_VERSION,
@@ -109,7 +114,7 @@ import {
   setWorkspaceMode,
   setZoomLevel,
   snapCommentAnchorAwayFromTable
-} from "./chunk-YHZHPXDB.js";
+} from "./chunk-RMRTQGW3.js";
 import {
   countLogicalPositions,
   createPlainText,
@@ -128,7 +133,7 @@ import {
   replaceStoryBlocks,
   resolvePageFieldDisplayText,
   storyTargetKey
-} from "./chunk-CXSYRB37.js";
+} from "./chunk-HUIHBBAQ.js";
 import {
   createCommentSidebarProjection,
   createCommentStoreFromRuntimeComments
@@ -152,12 +157,12 @@ import {
   persistedSnapshotFromEditorSessionState,
   remapRevisionStore,
   setRevisionStatus
-} from "./chunk-ESJ2MES5.js";
+} from "./chunk-JJGVE5J7.js";
 import {
   isSupportedFieldFamily,
   parseTocLevelRange,
   resolveRefFieldText
-} from "./chunk-4YJVRIUB.js";
+} from "./chunk-Q3QYGKFE.js";
 import {
   collectEditableTargetRefs,
   collectEditableTargetRefsForStoryBlockRanges,
@@ -1282,7 +1287,7 @@ function restartNumbering(document, paragraphIndex, context, startAt = 1, option
       affectedParagraphIndexes: []
     };
   }
-  const catalog = ensureNumberingCatalog(working.numbering);
+  const catalog = cloneNumberingCatalog(working.numbering);
   const existingInstance = catalog.instances[target.numbering.numberingInstanceId];
   if (!existingInstance) {
     return {
@@ -1290,15 +1295,12 @@ function restartNumbering(document, paragraphIndex, context, startAt = 1, option
       affectedParagraphIndexes: []
     };
   }
-  const numberingInstanceId = createNumberingInstanceId(catalog);
-  catalog.instances[numberingInstanceId] = {
-    numberingInstanceId,
-    abstractNumberingId: existingInstance.abstractNumberingId,
-    overrides: mergeOverride(existingInstance.overrides, {
-      level: target.numbering.level,
-      startAt
-    })
-  };
+  const numberingInstanceId = allocateNumberingInstance(
+    catalog,
+    existingInstance.abstractNumberingId,
+    existingInstance.overrides
+  );
+  setStartOverride(catalog, numberingInstanceId, target.numbering.level, startAt);
   const affectedParagraphIndexes = [];
   for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
     const paragraph = paragraphs[index];
@@ -1352,7 +1354,7 @@ function continueNumbering(document, paragraphIndex, context, options = {}) {
       affectedParagraphIndexes: []
     };
   }
-  const catalog = ensureNumberingCatalog(working.numbering);
+  const catalog = cloneNumberingCatalog(working.numbering);
   const currentInstanceId = target.numbering.numberingInstanceId;
   const currentKind = getListKind(catalog, currentInstanceId);
   if (!currentKind) {
@@ -1419,7 +1421,7 @@ function toggleListKind(document, paragraphIndexes, kind, context, options) {
       affectedParagraphIndexes: []
     };
   }
-  const catalog = ensureNumberingCatalog(working.numbering);
+  const catalog = cloneNumberingCatalog(working.numbering);
   const allAlreadyKind = normalizedIndexes.every((index) => {
     const paragraph = paragraphs[index];
     return paragraph.numbering ? getListKind(catalog, paragraph.numbering.numberingInstanceId) === kind : false;
@@ -1434,7 +1436,7 @@ function toggleListKind(document, paragraphIndexes, kind, context, options) {
       affectedParagraphIndexes: normalizedIndexes
     };
   }
-  const numberingInstanceId = findAdjacentCompatibleInstance(paragraphs, catalog, normalizedIndexes[0], kind) ?? ensureDefaultInstance(catalog, kind);
+  const numberingInstanceId = findAdjacentCompatibleInstance(paragraphs, catalog, normalizedIndexes[0], kind) ?? ensureDefaultListInstance(catalog, kind);
   for (const index of normalizedIndexes) {
     const paragraph = paragraphs[index];
     paragraph.numbering = {
@@ -1599,23 +1601,6 @@ function sortJson(value) {
   }
   return value;
 }
-function ensureDefaultInstance(catalog, kind) {
-  const existing = Object.values(catalog.instances).find(
-    (instance) => getListKind(catalog, instance.numberingInstanceId) === kind
-  );
-  if (existing) {
-    return existing.numberingInstanceId;
-  }
-  const abstractNumberingId = createAbstractNumberingId(catalog);
-  catalog.abstractDefinitions[abstractNumberingId] = kind === "bulleted" ? createDefaultBulletedDefinition(abstractNumberingId) : createDefaultNumberedDefinition(abstractNumberingId);
-  const numberingInstanceId = createNumberingInstanceId(catalog);
-  catalog.instances[numberingInstanceId] = {
-    numberingInstanceId,
-    abstractNumberingId,
-    overrides: []
-  };
-  return numberingInstanceId;
-}
 function findAdjacentCompatibleInstance(paragraphs, catalog, fromIndex, kind) {
   const previous = paragraphs[fromIndex - 1];
   if (previous?.numbering) {
@@ -1638,69 +1623,6 @@ function findPreviousCompatibleInstance(paragraphs, catalog, fromIndex, kind) {
   }
   return void 0;
 }
-function getListKind(catalog, numberingInstanceId) {
-  const instance = catalog.instances[numberingInstanceId];
-  const definition = instance ? catalog.abstractDefinitions[instance.abstractNumberingId] : void 0;
-  const levelZero = definition?.levels.find((level) => level.level === 0);
-  if (!levelZero) {
-    return void 0;
-  }
-  return levelZero.format === "bullet" ? "bulleted" : "numbered";
-}
-function mergeOverride(overrides, nextOverride) {
-  const filtered = overrides.filter((override) => override.level !== nextOverride.level);
-  filtered.push(nextOverride);
-  return filtered.sort((left, right) => left.level - right.level);
-}
-function createDefaultNumberedDefinition(abstractNumberingId) {
-  return {
-    abstractNumberingId,
-    levels: [
-      { level: 0, format: "decimal", text: "%1." },
-      { level: 1, format: "decimal", text: "%1.%2." },
-      { level: 2, format: "lowerLetter", text: "(%3)" },
-      { level: 3, format: "lowerRoman", text: "(%4)" },
-      { level: 4, format: "decimal", text: "%5." },
-      { level: 5, format: "lowerLetter", text: "(%6)" },
-      { level: 6, format: "lowerRoman", text: "(%7)" },
-      { level: 7, format: "decimal", text: "%8." },
-      { level: 8, format: "lowerLetter", text: "(%9)" }
-    ]
-  };
-}
-function createDefaultBulletedDefinition(abstractNumberingId) {
-  return {
-    abstractNumberingId,
-    levels: [
-      { level: 0, format: "bullet", text: "\u2022" },
-      { level: 1, format: "bullet", text: "o" },
-      { level: 2, format: "bullet", text: "\u25A0" },
-      { level: 3, format: "bullet", text: "\u2022" },
-      { level: 4, format: "bullet", text: "o" },
-      { level: 5, format: "bullet", text: "\u25A0" },
-      { level: 6, format: "bullet", text: "\u2022" },
-      { level: 7, format: "bullet", text: "o" },
-      { level: 8, format: "bullet", text: "\u25A0" }
-    ]
-  };
-}
-function createAbstractNumberingId(catalog) {
-  let index = 1;
-  while (catalog.abstractDefinitions[`abstract-num:generated-${index}`]) {
-    index += 1;
-  }
-  return `abstract-num:generated-${index}`;
-}
-function createNumberingInstanceId(catalog) {
-  let index = 1;
-  while (catalog.instances[`num:generated-${index}`]) {
-    index += 1;
-  }
-  return `num:generated-${index}`;
-}
-function ensureNumberingCatalog(value) {
-  return structuredClone(value);
-}
 function cloneEnvelope(document, timestamp) {
   return {
     ...structuredClone(document),
@@ -1889,7 +1811,7 @@ function applyFragmentInsert(document, selection, fragment, context) {
     );
     workingDocument = collapseResult.document;
     workingSelection = collapseResult.selection;
-    if (context.textTarget?.kind === "table-paragraph") {
+    if (context.textTarget?.kind === "table-paragraph" || context.textTarget?.kind === "text-leaf") {
       workingContext = {
         ...context,
         textTarget: {
@@ -1911,11 +1833,11 @@ function applyFragmentInsert(document, selection, fragment, context) {
       selection
     };
   }
-  const targetedTablePath = workingContext.textTarget?.kind === "table-paragraph" ? workingContext.textTarget.blockPath : void 0;
-  if (targetedTablePath) {
+  const targetedBlockPath = workingContext.textTarget?.kind === "table-paragraph" || workingContext.textTarget?.kind === "text-leaf" ? workingContext.textTarget.blockPath : void 0;
+  if (targetedBlockPath) {
     const targeted = insertFragmentBlocksAfterPath(
       splitResult.document,
-      targetedTablePath,
+      targetedBlockPath,
       fragment.blocks
     );
     if (targeted) {
@@ -5827,7 +5749,7 @@ function emptyCompatibilityReport() {
 }
 
 // src/runtime/debug/runtime-debug-facet.ts
-function createRuntimeDebugFacet(getRuntime, bus) {
+function createRuntimeDebugFacet(getRuntime, bus, options = {}) {
   return {
     bus,
     getSnapshot(query) {
@@ -5845,10 +5767,321 @@ function createRuntimeDebugFacet(getRuntime, bus) {
     },
     getChannels() {
       return bus.getChannels();
+    },
+    getHotEditTraces() {
+      return options.getHotEditTraces?.() ?? [];
     }
   };
 }
 
+// src/runtime/hot-edit/hot-edit-trace.ts
+var HOT_EDIT_TRACE_LIMIT = 64;
+var HotEditTraceRecorder = class {
+  traces = [];
+  sequence = 0;
+  begin(input) {
+    this.sequence += 1;
+    return {
+      sequence: this.sequence,
+      commandType: input.commandType,
+      startedAtUtc: input.nowUtc,
+      startedAtMs: nowMs(),
+      startCounters: input.counters.snapshot()
+    };
+  }
+  complete(pending, input) {
+    const endCounters = input.counters.snapshot();
+    const refreshAllCount = counterDelta(pending.startCounters, endCounters, "refresh.all");
+    const patchHitCount = counterDelta(pending.startCounters, endCounters, "surface.localText.patchHit");
+    const patchBudgetFallbackCount = counterDelta(
+      pending.startCounters,
+      endCounters,
+      "surface.localText.patchBudgetFallback"
+    );
+    const boundedEditableTargetBuildCount = counterDelta(
+      pending.startCounters,
+      endCounters,
+      "runtime.editableTargets.boundedBuilds"
+    );
+    const tier = refineTier(input.tier, {
+      refreshAllCount,
+      patchHitCount,
+      patchBudgetFallbackCount,
+      boundedEditableTargetBuildCount
+    });
+    const trace = {
+      sequence: pending.sequence,
+      startedAtUtc: pending.startedAtUtc,
+      commandType: pending.commandType,
+      tier,
+      patchMissReason: input.patchMissReason,
+      totalDurationUs: Math.max(0, Math.round((nowMs() - pending.startedAtMs) * 1e3)),
+      refreshAllCount,
+      patchHitCount,
+      patchBudgetFallbackCount,
+      boundedEditableTargetBuildCount
+    };
+    this.traces.push(trace);
+    if (this.traces.length > HOT_EDIT_TRACE_LIMIT) {
+      this.traces.splice(0, this.traces.length - HOT_EDIT_TRACE_LIMIT);
+    }
+    input.counters.increment(`hotEdit.tier.${trace.tier}`);
+    if (trace.patchMissReason !== "none") {
+      input.counters.increment(`hotEdit.patchMiss.${trace.patchMissReason}`);
+    }
+    return trace;
+  }
+  getTraces() {
+    return Object.freeze([...this.traces]);
+  }
+  clear() {
+    this.traces.splice(0, this.traces.length);
+  }
+};
+function refineTier(requested, counters) {
+  if (requested === "blocked") return requested;
+  if (counters.refreshAllCount > 0) return "full-refresh";
+  if (counters.patchBudgetFallbackCount > 0 || counters.boundedEditableTargetBuildCount > 0) {
+    return "bounded-projection";
+  }
+  if (counters.patchHitCount > 0) return "patch";
+  return requested;
+}
+function counterDelta(start, end, key) {
+  return (end[key] ?? 0) - (start[key] ?? 0);
+}
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+
+// src/runtime/hot-edit/surface-local-patcher.ts
+function patchSurfaceTextSegment(surface, patch) {
+  const delta = patch.insertedText.length - Math.max(0, patch.to - patch.from);
+  let patched = false;
+  const blocks = surface.blocks.map((block) => {
+    const result = patchBlock(block, patch, delta);
+    if (result.patched) patched = true;
+    return result.block;
+  });
+  if (!patched) {
+    return { status: "miss", reason: "segment-not-found" };
+  }
+  return {
+    status: "patched",
+    surface: {
+      ...surface,
+      storySize: surface.storySize + delta,
+      plainText: surface.plainText.slice(0, patch.from) + patch.insertedText + surface.plainText.slice(patch.to),
+      blocks
+    }
+  };
+}
+function patchBlock(block, patch, delta) {
+  if (patch.to < block.from) return { block, patched: false };
+  if (patch.from > block.to) {
+    return { block: shiftBlock(block, delta), patched: false };
+  }
+  switch (block.kind) {
+    case "paragraph":
+      return patchParagraph(block, patch, delta);
+    case "sdt_block": {
+      let patched = false;
+      const children = block.children.map((child) => {
+        const result = patchBlock(child, patch, delta);
+        patched ||= result.patched;
+        return result.block;
+      });
+      return {
+        block: patched ? { ...block, to: block.to + delta, children } : block,
+        patched
+      };
+    }
+    case "table": {
+      let patched = false;
+      const rows = block.rows.map((row2) => ({
+        ...row2,
+        cells: row2.cells.map((cell) => ({
+          ...cell,
+          content: cell.content.map((child) => {
+            const result = patchBlock(child, patch, delta);
+            patched ||= result.patched;
+            return result.block;
+          })
+        }))
+      }));
+      return {
+        block: patched ? { ...block, to: block.to + delta, rows } : block,
+        patched
+      };
+    }
+    case "opaque_block":
+      return { block, patched: false };
+  }
+}
+function patchParagraph(block, patch, delta) {
+  if (patch.from < block.from || patch.to > block.to) {
+    return { block, patched: false };
+  }
+  const segmentIndex = block.segments.findIndex(
+    (segment2) => segment2.kind === "text" && patch.from >= segment2.from && patch.to <= segment2.to
+  );
+  if (segmentIndex < 0) return { block, patched: false };
+  const segment = block.segments[segmentIndex];
+  if (segment.kind !== "text") return { block, patched: false };
+  const localFrom = patch.from - segment.from;
+  const localTo = patch.to - segment.from;
+  const segments = block.segments.map((candidate, index) => {
+    if (index < segmentIndex) return candidate;
+    if (index === segmentIndex) {
+      return {
+        ...segment,
+        text: segment.text.slice(0, localFrom) + patch.insertedText + segment.text.slice(localTo),
+        to: segment.to + delta
+      };
+    }
+    return shiftInlineSegment(candidate, delta);
+  });
+  return {
+    block: {
+      ...block,
+      to: block.to + delta,
+      segments
+    },
+    patched: true
+  };
+}
+function shiftBlock(block, delta) {
+  if (delta === 0) return block;
+  switch (block.kind) {
+    case "paragraph":
+      return {
+        ...block,
+        from: block.from + delta,
+        to: block.to + delta,
+        segments: block.segments.map((segment) => shiftInlineSegment(segment, delta))
+      };
+    case "sdt_block":
+      return {
+        ...block,
+        from: block.from + delta,
+        to: block.to + delta,
+        children: block.children.map((child) => shiftBlock(child, delta))
+      };
+    case "table":
+      return {
+        ...block,
+        from: block.from + delta,
+        to: block.to + delta,
+        rows: block.rows.map((row2) => ({
+          ...row2,
+          cells: row2.cells.map((cell) => ({
+            ...cell,
+            content: cell.content.map((child) => shiftBlock(child, delta))
+          }))
+        }))
+      };
+    case "opaque_block":
+      return {
+        ...block,
+        from: block.from + delta,
+        to: block.to + delta
+      };
+  }
+}
+function shiftInlineSegment(segment, delta) {
+  if (delta === 0) return segment;
+  return {
+    ...segment,
+    from: segment.from + delta,
+    to: segment.to + delta
+  };
+}
+
+// src/runtime/hot-edit/hot-edit-profiler.ts
+var HEAVY_REVIEW_ITEM_THRESHOLD = 24;
+var DENSE_BLOCK_NODE_THRESHOLD = 256;
+function deriveHotEditDocumentProfile(document) {
+  const blocks = document.content.children ?? [];
+  let tableBlockCount = 0;
+  let maxNestedSurfaceNodesPerBlock = 0;
+  for (const block of blocks) {
+    if (block.type === "table") tableBlockCount += 1;
+    maxNestedSurfaceNodesPerBlock = Math.max(
+      maxNestedSurfaceNodesPerBlock,
+      countBlockNodes(block)
+    );
+  }
+  const commentCount = Object.keys(document.review.comments ?? {}).length;
+  const revisionCount = Object.keys(document.review.revisions ?? {}).length;
+  const secondaryStoryBlockCount = countSecondaryStoryBlocks(document);
+  return {
+    blockCount: blocks.length,
+    tableBlockCount,
+    maxNestedSurfaceNodesPerBlock,
+    commentCount,
+    revisionCount,
+    secondaryStoryBlockCount,
+    hasHeavyReview: commentCount + revisionCount >= HEAVY_REVIEW_ITEM_THRESHOLD,
+    hasDenseTables: tableBlockCount > 0 && maxNestedSurfaceNodesPerBlock > DENSE_BLOCK_NODE_THRESHOLD
+  };
+}
+function countBlockNodes(block) {
+  const value = block;
+  let total = 1;
+  if (Array.isArray(value.children)) {
+    total += value.children.length;
+    for (const child of value.children) {
+      if (isBlockLike(child)) total += countBlockNodes(child);
+    }
+  }
+  if (Array.isArray(value.rows)) {
+    for (const row2 of value.rows) {
+      total += 1;
+      for (const cell of row2.cells ?? []) {
+        total += 1;
+        for (const child of cell.children ?? []) {
+          total += countBlockNodes(child);
+        }
+      }
+    }
+  }
+  return total;
+}
+function isBlockLike(value) {
+  return Boolean(value && typeof value === "object" && "type" in value);
+}
+function countSecondaryStoryBlocks(document) {
+  const subParts = document.subParts;
+  if (!subParts) return 0;
+  let count = 0;
+  for (const value of Object.values(subParts)) {
+    count += countBlocksInUnknownStory(value);
+  }
+  return count;
+}
+function countBlocksInUnknownStory(value) {
+  if (!value || typeof value !== "object") return 0;
+  const candidate = value;
+  if (Array.isArray(candidate.children)) return candidate.children.length;
+  if (Array.isArray(candidate.content?.children)) return candidate.content.children.length;
+  return Object.values(value).reduce((total, entry) => total + countBlocksInUnknownStory(entry), 0);
+}
+
+// src/runtime/hot-edit/hot-edit-policy.ts
+var DEFAULT_MAX_SHIFTED_SURFACE_NODES = 5e3;
+var DEFAULT_MAX_SHIFTED_NODES_PER_BLOCK = 256;
+var DEFAULT_SELECTION_CORRIDOR_BLOCK_RADIUS = 8;
+var HEAVY_DOCUMENT_SELECTION_CORRIDOR_BLOCK_RADIUS = 12;
+function resolveHotEditPolicy(profile) {
+  const complexGeometry = profile.hasDenseTables || profile.secondaryStoryBlockCount > 0;
+  return {
+    maxShiftedSurfaceNodes: DEFAULT_MAX_SHIFTED_SURFACE_NODES,
+    maxShiftedNodesPerBlock: DEFAULT_MAX_SHIFTED_NODES_PER_BLOCK,
+    selectionCorridorBlockRadius: complexGeometry ? HEAVY_DOCUMENT_SELECTION_CORRIDOR_BLOCK_RADIUS : DEFAULT_SELECTION_CORRIDOR_BLOCK_RADIUS,
+    preferBoundedProjectionForDenseTails: profile.hasDenseTables
+  };
+}
+
 // src/runtime/workflow/query-scopes.ts
 function storyTargetsEqual2(a, b) {
   if (a.kind !== b.kind) return false;
@@ -12245,8 +12478,6 @@ function mapLocalSelectionOnRemoteReplay(selection, mapping) {
 
 // src/runtime/document-runtime.ts
 var CANONICAL_BLOCK_REFS_SYMBOL = /* @__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") {
@@ -12353,6 +12584,17 @@ function createDocumentRuntime(options) {
   const loadScheduler = options.loadScheduler ?? createLoadScheduler({ backendOverride: "sync" });
   let effectiveMarkupModeProvider;
   const perfCounters = new PerfCounters();
+  const hotEditTraces = new HotEditTraceRecorder();
+  let cachedHotEditPolicy = null;
+  function getHotEditPolicy() {
+    if (cachedHotEditPolicy?.document === state.document) {
+      return cachedHotEditPolicy.policy;
+    }
+    const profile = deriveHotEditDocumentProfile(state.document);
+    const policy = resolveHotEditPolicy(profile);
+    cachedHotEditPolicy = { document: state.document, profile, policy };
+    return policy;
+  }
   let analyticsEmitScheduled = false;
   let analyticsEmitScheduleMode = "none";
   let deferNextContextAnalyticsEmit = false;
@@ -12424,7 +12666,6 @@ function createDocumentRuntime(options) {
   let viewportBlockRanges = null;
   let viewportRangesKey = serializeViewportRanges(viewportBlockRanges);
   let viewportBlocksPerPageEstimate = null;
-  const EDITING_CORRIDOR_BLOCK_RADIUS = 8;
   const getRuntimeForLayoutFacet = () => {
     if (!runtimeRef) {
       throw new Error("Document runtime viewport methods are not initialized");
@@ -12758,8 +12999,8 @@ function createDocumentRuntime(options) {
       return viewportBlockRanges;
     }
     const corridor = {
-      start: Math.max(0, caretBlockIndex - EDITING_CORRIDOR_BLOCK_RADIUS),
-      end: Math.min(previousSurface.blocks.length, caretBlockIndex + EDITING_CORRIDOR_BLOCK_RADIUS + 1)
+      start: Math.max(0, caretBlockIndex - getHotEditPolicy().selectionCorridorBlockRadius),
+      end: Math.min(previousSurface.blocks.length, caretBlockIndex + getHotEditPolicy().selectionCorridorBlockRadius + 1)
     };
     return normalizeViewportRanges([...viewportBlockRanges ?? [], corridor]);
   }
@@ -12840,8 +13081,12 @@ function createDocumentRuntime(options) {
         (block2) => block2.kind === "paragraph" && editFrom >= block2.from && editTo <= block2.to
       );
       if (blockIndex < 0) {
-        perfCounters.increment("surface.localText.patchMiss");
-        return null;
+        return tryPatchNestedLocalTextSurface(
+          previousSurface,
+          editFrom,
+          editTo,
+          patch.insertedText
+        );
       }
       const block = previousSurface.blocks[blockIndex];
       if (block.kind !== "paragraph") {
@@ -12916,6 +13161,34 @@ function createDocumentRuntime(options) {
       perfCounters.increment("surface.localText.total.us", Math.round((performance.now() - tTotal0) * 1e3));
     }
   }
+  function tryPatchNestedLocalTextSurface(previousSurface, editFrom, editTo, insertedText) {
+    const shiftBudget = estimateLocalTextPatchShiftBudget(previousSurface.blocks, 0);
+    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 patched = patchSurfaceTextSegment(previousSurface, {
+      from: editFrom,
+      to: editTo,
+      insertedText
+    });
+    if (patched.status !== "patched") {
+      perfCounters.increment("surface.localText.patchMiss");
+      return null;
+    }
+    const refs = getSurfaceCanonicalBlockRefs(previousSurface);
+    if (refs) {
+      const nextRefs = state.document.content.children.map(
+        (block, index) => block ?? refs[index] ?? null
+      );
+      attachSurfaceCanonicalBlockRefs(patched.surface, nextRefs);
+    }
+    perfCounters.increment("surface.localText.patchHit");
+    perfCounters.increment("surface.localText.patchDelta", insertedText.length - (editTo - editFrom));
+    return patched.surface;
+  }
   function shiftSurfaceInlineSegment(segment, delta) {
     if (delta === 0) return segment;
     return {
@@ -12963,25 +13236,26 @@ function createDocumentRuntime(options) {
     }
   }
   function estimateLocalTextPatchShiftBudget(blocks, startIndex) {
+    const policy = getHotEditPolicy();
     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
+          policy.maxShiftedNodesPerBlock,
+          policy.maxShiftedSurfaceNodes - shiftedNodes
         ) + 1
       );
       shiftedNodes += shiftedBlockNodes;
-      if (shiftedBlockNodes > LOCAL_TEXT_PATCH_MAX_SHIFTED_NODES_PER_BLOCK) {
+      if (shiftedBlockNodes > policy.maxShiftedNodesPerBlock) {
         return {
           shiftedBlocks,
           shiftedNodes,
           withinBudget: false
         };
       }
-      if (shiftedNodes > LOCAL_TEXT_PATCH_MAX_SHIFTED_SURFACE_NODES) {
+      if (shiftedNodes > policy.maxShiftedSurfaceNodes) {
         return {
           shiftedBlocks,
           shiftedNodes,
@@ -13945,7 +14219,9 @@ function createDocumentRuntime(options) {
   });
   const r5ScratchReplayState = { ...state };
   const r5ScratchReplaySnapshot = { ...cachedRenderSnapshot };
-  const debugFacet = createRuntimeDebugFacet(() => runtime, telemetryBus);
+  const debugFacet = createRuntimeDebugFacet(() => runtime, telemetryBus, {
+    getHotEditTraces: () => hotEditTraces.getTraces()
+  });
   function prepareTableStructureCommandForExecution(command, document, storyTarget) {
     const resolution = resolveEditableTableStructureTarget({
       document,
@@ -14042,13 +14318,12 @@ function createDocumentRuntime(options) {
     if (!command.editableTarget) {
       return { kind: "accepted", selection };
     }
-    const preserveCallerSelection = command.editableTarget.listAddress?.operationScope === "list-text";
     const resolution = resolveEditableTextTarget({
       document,
       surface,
       target: command.editableTarget,
       activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
-      ...preserveCallerSelection ? { selection } : {},
+      selection,
       editableTargetCache: editableTargetBlockCache
     });
     if (resolution.kind === "rejected") {
@@ -14066,7 +14341,7 @@ function createDocumentRuntime(options) {
     }
     return {
       kind: "accepted",
-      selection: preserveCallerSelection ? selection : createSelectionSnapshot(resolution.range.from, resolution.range.to),
+      selection,
       ...resolution.textTarget ? { textTarget: resolution.textTarget } : {}
     };
   }
@@ -15242,12 +15517,23 @@ function createDocumentRuntime(options) {
       return actionDepth > 0;
     },
     applyActiveStoryTextCommand(command) {
+      const pendingHotEditTrace = hotEditTraces.begin({
+        commandType: command.type,
+        nowUtc: clock(),
+        counters: perfCounters
+      });
       try {
-        return applyTextCommandInActiveStory(command);
+        const ack = applyTextCommandInActiveStory(command);
+        hotEditTraces.complete(pendingHotEditTrace, {
+          tier: classifyHotEditTier(ack),
+          patchMissReason: classifyHotEditPatchMissReason(ack),
+          counters: perfCounters
+        });
+        return ack;
       } catch (error) {
         const runtimeError = toRuntimeError(error);
         emitError(runtimeError);
-        return {
+        const ack = {
           kind: "rejected",
           refreshClass: "blocked",
           opId: command.origin?.opId,
@@ -15259,6 +15545,12 @@ function createDocumentRuntime(options) {
             }
           ]
         };
+        hotEditTraces.complete(pendingHotEditTrace, {
+          tier: "blocked",
+          patchMissReason: "participant-blocked",
+          counters: perfCounters
+        });
+        return ack;
       }
     },
     addComment(params) {
@@ -17034,6 +17326,27 @@ function createDocumentRuntime(options) {
       newRevisionToken: state.revisionToken
     }));
   }
+  function classifyHotEditTier(ack) {
+    if (ack.kind === "rejected" || ack.refreshClass === "blocked") {
+      return "blocked";
+    }
+    if (ack.refreshClass === "full-projection" || ack.kind === "structural-divergence") {
+      return "full-refresh";
+    }
+    if (ack.refreshClass === "local-text-equivalent" || ack.refreshClass === "selection-only" || ack.refreshClass === "surface-only") {
+      return "patch";
+    }
+    return "full-refresh";
+  }
+  function classifyHotEditPatchMissReason(ack) {
+    if (ack.kind === "rejected" || ack.refreshClass === "blocked") {
+      return "participant-blocked";
+    }
+    if (ack.refreshClass === "full-projection" || ack.kind === "structural-divergence") {
+      return "effect-disqualified";
+    }
+    return "none";
+  }
   function classifyAck(params) {
     const { opId, priorState, transaction, newRevisionToken } = params;
     const meta = transaction.mapping.metadata ?? {};