@beyondwork/docx-react-component 1.0.128 → 1.0.130

package/dist/index.cjs

@@ -31,6 +31,43 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/runtime/layout/resolved-formatting-state.ts
+function createLayoutReadyFormattingSnapshot(formatting, runs = /* @__PURE__ */ new Map()) {
+  const snapshot = {
+    version: 1,
+    paragraph: {
+      spacingBefore: formatting.spacingBefore,
+      spacingAfter: formatting.spacingAfter,
+      lineHeight: formatting.lineHeight,
+      lineRule: formatting.lineRule,
+      indentLeft: formatting.indentLeft,
+      indentRight: formatting.indentRight,
+      firstLineIndent: formatting.firstLineIndent,
+      hangingIndent: formatting.hangingIndent,
+      fontSizeHalfPoints: formatting.fontSizeHalfPoints,
+      averageCharWidthTwips: formatting.averageCharWidthTwips,
+      tabStops: formatting.tabStops.map((tab) => ({ ...tab })),
+      defaultTabInterval: formatting.defaultTabInterval,
+      keepNext: formatting.keepNext,
+      keepLines: formatting.keepLines,
+      pageBreakBefore: formatting.pageBreakBefore,
+      widowControl: formatting.widowControl,
+      contextualSpacing: formatting.contextualSpacing,
+      ...formatting.numberingMarkerBox ? { numberingMarkerBox: { ...formatting.numberingMarkerBox } } : {}
+    },
+    runs: Array.from(runs.entries()).map(([runId, run]) => ({
+      runId,
+      ...run.fontFamily ? { fontFamily: run.fontFamily } : {},
+      ...typeof run.fontSizeHalfPoints === "number" ? { fontSizeHalfPoints: run.fontSizeHalfPoints } : {},
+      bold: Boolean(run.bold),
+      italic: Boolean(run.italic),
+      verticalAlign: run.verticalAlign ?? "baseline"
+    })).sort((a, b) => a.runId.localeCompare(b.runId))
+  };
+  return {
+    ...snapshot,
+    hash: hashStable(snapshot)
+  };
+}
 function resolveBlockFormatting(block, defaultTabInterval = 720, themeFonts) {
   if (block.kind !== "paragraph") {
     return null;
@@ -273,6 +310,29 @@ function buildRunFormattingMap(block) {
   }
   return runs;
 }
+function hashStable(value) {
+  return fnv1a(stableStringify(value)).toString(36);
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (value instanceof Map) {
+    return stableStringify(Array.from(value.entries()));
+  }
+  const object = value;
+  const keys = Object.keys(object).filter((key) => object[key] !== void 0 && typeof object[key] !== "function").sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
+}
+function fnv1a(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
 var FONT_AVG_CHAR_WIDTH, DEFAULT_FONT_AVG_CHAR_WIDTH, DEFAULT_FONT_SIZE_HALF_POINTS, DEFAULT_LINE_HEIGHT_FACTOR, TWIPS_PER_POINT;
 var init_resolved_formatting_state = __esm({
   "src/runtime/layout/resolved-formatting-state.ts"() {
@@ -2877,7 +2937,7 @@ function toStableJsonValue(value) {
   }
   return result;
 }
-function stableStringify(value) {
+function stableStringify2(value) {
   return JSON.stringify(toStableJsonValue(value));
 }
 
@@ -3041,7 +3101,7 @@ function migrateReviewRecordAnchor(record) {
   return record;
 }
 function createCanonicalDocumentSignature(document2) {
-  return stableStringify(document2);
+  return stableStringify2(document2);
 }
 function assertCanonicalDocument(value) {
   const issues = validateCanonicalDocument(value);
@@ -6296,6 +6356,7 @@ function collectCanonicalLayoutInputs(doc) {
   const blockContexts = collectStoryBlockContexts(doc);
   return {
     stories: collectCanonicalStoryIdentities(doc),
+    layoutIdentities: collectLayoutInputIdentities(doc, blockContexts),
     fieldRegions: collectCanonicalFieldRegionIdentities(doc),
     numbering: collectCanonicalNumberingLayoutInputs(doc, blockContexts),
     tables: collectCanonicalTableLayoutInputs(blockContexts),
@@ -6304,6 +6365,116 @@ function collectCanonicalLayoutInputs(doc) {
     editableTargets: collectEditableTargetRefs(doc)
   };
 }
+function collectLayoutInputIdentities(doc, contexts = collectStoryBlockContexts(doc)) {
+  const identities = [];
+  const editableTargets = collectEditableTargetRefs(doc);
+  const editableByStoryBlock = new Map(
+    editableTargets.map((target) => [`${target.storyKey}:${target.blockPath}`, target])
+  );
+  for (const context of contexts) {
+    walkBlocks(context.blocks, context.storyKey, context.basePath, {
+      paragraph(paragraph, blockPath) {
+        const styleNumbering = paragraph.numbering === void 0 && paragraph.styleId !== void 0 ? resolveParagraphStyleNumbering(doc, paragraph.styleId) : void 0;
+        const numbering = paragraph.numbering ?? styleNumbering;
+        const editableTargetRef = editableByStoryBlock.get(`${context.storyKey}:${blockPath}`);
+        identities.push(
+          createLayoutInputIdentity({
+            storyKey: context.storyKey,
+            blockPath,
+            block: paragraph,
+            ...editableTargetRef !== void 0 ? { editableTargetRef } : {},
+            ...numbering !== void 0 ? {
+              list: {
+                numberingInstanceId: numbering.numberingInstanceId,
+                level: numbering.level ?? 0,
+                ...paragraph.numbering?.sourceRef !== void 0 ? { markerSourceRef: paragraph.numbering.sourceRef } : {}
+              }
+            } : {}
+          })
+        );
+      },
+      table(table, blockPath) {
+        identities.push(
+          createLayoutInputIdentity({
+            storyKey: context.storyKey,
+            blockPath,
+            block: table,
+            table: { tableBlockPath: blockPath }
+          })
+        );
+      },
+      inline(inline, blockPath, inlinePath) {
+        const objectId = objectIdForInline(inline);
+        if (!objectId) return;
+        const sourceRef = sourceRefForInline(inline);
+        identities.push({
+          storyKey: context.storyKey,
+          blockPath,
+          blockId: `${context.storyKey}:${inlinePath}`,
+          ...sourceRef !== void 0 ? { sourceRef } : {},
+          object: {
+            objectId,
+            ...sourceRef !== void 0 ? { anchorSourceRef: sourceRef } : {}
+          }
+        });
+      }
+    });
+  }
+  return identities;
+}
+function createLayoutInputIdentity(input) {
+  const sourceRef = sourceRefForBlock(input.block);
+  const blockId = input.block.type === "paragraph" && input.block.wordExtensionIds?.paraId ? `para:${input.block.wordExtensionIds.paraId}` : sourceRef?.sourceId !== void 0 ? `source:${sourceRef.sourceId}` : `${input.storyKey}:${input.blockPath}`;
+  return {
+    storyKey: input.storyKey,
+    blockPath: input.blockPath,
+    blockId,
+    ...sourceRef !== void 0 ? { sourceRef } : {},
+    ...input.editableTargetRef !== void 0 ? { editableTargetRef: input.editableTargetRef } : {},
+    ...input.table !== void 0 ? { table: input.table } : {},
+    ...input.list !== void 0 ? { list: input.list } : {}
+  };
+}
+function sourceRefForBlock(block) {
+  return "sourceRef" in block ? block.sourceRef : void 0;
+}
+function sourceRefForInline(inline) {
+  return "sourceRef" in inline ? inline.sourceRef : void 0;
+}
+function objectIdForInline(inline) {
+  switch (inline.type) {
+    case "image":
+      return inline.mediaId;
+    case "drawing_frame":
+      return objectIdForDrawingContent(inline.content) ?? inline.sourceRef?.sourceId;
+    case "shape":
+    case "vml_shape":
+    case "wordart":
+      return inline.preserveOnlyObject?.sourceId ?? `raw:${sha256TextHex(inline.rawXml).slice(0, 16)}`;
+    case "chart_preview":
+    case "smartart_preview":
+      return inline.previewMediaId ?? `raw:${sha256TextHex(inline.rawXml).slice(0, 16)}`;
+    case "ole_embed":
+      return inline.relationshipId ?? inline.id ?? inline.sourceRef?.sourceId;
+    case "opaque_inline":
+      return inline.fragmentId;
+    default:
+      return void 0;
+  }
+}
+function objectIdForDrawingContent(content) {
+  switch (content.type) {
+    case "picture":
+      return content.mediaId ?? content.packagePartName ?? content.blipRef;
+    case "chart_preview":
+    case "smartart_preview":
+      return content.previewMediaId ?? `raw:${sha256TextHex(content.rawXml).slice(0, 16)}`;
+    case "shape":
+      return content.preserveOnlyObject?.sourceId ?? `raw:${sha256TextHex(content.rawXml).slice(0, 16)}`;
+    case "opaque":
+      return content.preserveOnlyObject?.sourceId ?? `raw:${sha256TextHex(content.rawXml).slice(0, 16)}`;
+  }
+}
 function collectEditableTargetRefs(doc, cache) {
   const targets = [];
   for (const context of collectStoryBlockContexts(doc)) {
@@ -8452,6 +8623,16 @@ function collectCanonicalNumberingLayoutInputs(doc, contexts = collectStoryBlock
         const instance = doc.numbering.instances[numbering.numberingInstanceId];
         const abstractDefinition = instance?.abstractNumberingId === void 0 ? void 0 : doc.numbering.abstractDefinitions[instance.abstractNumberingId];
         inputs.push({
+          identity: createLayoutInputIdentity({
+            storyKey: context.storyKey,
+            blockPath,
+            block: paragraph,
+            list: {
+              numberingInstanceId: numbering.numberingInstanceId,
+              level: numbering.level ?? 0,
+              ...paragraph.numbering?.sourceRef !== void 0 ? { markerSourceRef: paragraph.numbering.sourceRef } : {}
+            }
+          }),
           numberingKey: `${context.storyKey}:${blockPath}:numbering`,
           storyKey: context.storyKey,
           blockPath,
@@ -8753,6 +8934,12 @@ function projectTableLayoutInput(table, storyKey2, blockPath) {
     (row2, rowIndex) => projectTableRowLayoutInput(row2, tableKey, rowIndex)
   );
   return {
+    identity: createLayoutInputIdentity({
+      storyKey: storyKey2,
+      blockPath,
+      block: table,
+      table: { tableBlockPath: blockPath }
+    }),
     tableKey,
     storyKey: storyKey2,
     blockPath,
@@ -8840,6 +9027,16 @@ function projectDrawingFrameAnchor(node, storyKey2, blockPath, inlinePath) {
   const objectKey = `${storyKey2}:${inlinePath}`;
   const textBoxBody = projectTextBoxBodyLayoutInput(content, objectKey, sourceRef, `${inlinePath}/txbx`);
   return {
+    identity: {
+      storyKey: storyKey2,
+      blockPath,
+      blockId: objectKey,
+      ...sourceRef !== void 0 ? { sourceRef } : {},
+      object: {
+        objectId: objectKey,
+        ...sourceRef !== void 0 ? { anchorSourceRef: sourceRef } : {}
+      }
+    },
     objectKey,
     storyKey: storyKey2,
     blockPath,
@@ -8961,8 +9158,19 @@ function projectTextBoxRunLayoutInput(inline, paragraphKey, inlineIndex) {
 }
 function projectLegacyImageAnchor(doc, node, storyKey2, blockPath, inlinePath) {
   const media = doc.media.items[node.mediaId];
+  const objectKey = `${storyKey2}:${inlinePath}`;
   return {
-    objectKey: `${storyKey2}:${inlinePath}`,
+    identity: {
+      storyKey: storyKey2,
+      blockPath,
+      blockId: objectKey,
+      ...node.sourceRef !== void 0 ? { sourceRef: node.sourceRef } : {},
+      object: {
+        objectId: objectKey,
+        ...node.sourceRef !== void 0 ? { anchorSourceRef: node.sourceRef } : {}
+      }
+    },
+    objectKey,
     storyKey: storyKey2,
     blockPath,
     inlinePath,
@@ -10120,12 +10328,13 @@ function getLevelStartAt(level, levelDefinitions) {
   return levelDefinitions.get(level)?.startAt ?? DEFAULT_NUMBERING_START_AT;
 }
 function getNumberingFormatPosture(format, value) {
-  if (!isSupportedNumberingFormat(format)) {
+  const registryEntry = getNumberingFormatRegistryEntry(format);
+  if (!registryEntry || registryEntry.renderSupport === "approximated") {
     return {
       status: "approximated",
       requestedFormat: format,
       renderedFormat: "decimal",
-      reason: "unsupported-numbering-format-decimal-fallback"
+      reason: registryEntry?.fallbackReason ?? "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)) {
@@ -10156,56 +10365,148 @@ function renderLevelText(text, counters, levelDefinitions) {
   });
   return rendered.trim().length > 0 ? rendered : null;
 }
-var SUPPORTED_NUMBERING_FORMATS = /* @__PURE__ */ new Set([
-  "decimal",
-  "decimalZero",
-  "upperLetter",
-  "lowerLetter",
-  "upperRoman",
-  "lowerRoman",
-  "hex",
-  "ordinal",
-  "cardinalText",
-  "ordinalText",
-  "chicago",
-  "bullet",
-  "none"
-]);
 function isSupportedNumberingFormat(format) {
-  return SUPPORTED_NUMBERING_FORMATS.has(format);
+  return getNumberingFormatRegistryEntry(format)?.renderSupport === "supported";
+}
+function getNumberingFormatRegistryEntry(format) {
+  return NUMBERING_FORMAT_REGISTRY.get(format);
 }
 function formatCounter(value, format) {
-  switch (format) {
-    case "decimal":
-      return String(value);
-    case "decimalZero":
-      return String(value).padStart(2, "0");
-    case "upperLetter":
-      return toAlphabetic2(value).toUpperCase();
-    case "lowerLetter":
-      return toAlphabetic2(value).toLowerCase();
-    case "upperRoman":
-      return toRoman2(value).toUpperCase();
-    case "lowerRoman":
-      return toRoman2(value).toLowerCase();
-    case "hex":
-      return value >= 0 ? value.toString(16).toUpperCase() : String(value);
-    case "ordinal":
-      return toOrdinal2(value);
-    case "cardinalText":
-      return toCardinalText2(value);
-    case "ordinalText":
-      return toOrdinalText2(value);
-    case "chicago":
-      return toChicago2(value);
-    case "bullet":
-      return "";
-    case "none":
-      return "";
-    default:
-      return String(value);
-  }
+  return getNumberingFormatRegistryEntry(format)?.render(value) ?? String(value);
 }
+var exactNumberingFormatEntries = [
+  {
+    format: "decimal",
+    renderSupport: "supported",
+    renderedFormat: "decimal",
+    supportsMutation: true,
+    render: (value) => String(value)
+  },
+  {
+    format: "decimalZero",
+    renderSupport: "supported",
+    renderedFormat: "decimalZero",
+    supportsMutation: true,
+    render: (value) => String(value).padStart(2, "0")
+  },
+  {
+    format: "upperLetter",
+    renderSupport: "supported",
+    renderedFormat: "upperLetter",
+    supportsMutation: true,
+    render: (value) => toAlphabetic2(value).toUpperCase()
+  },
+  {
+    format: "lowerLetter",
+    renderSupport: "supported",
+    renderedFormat: "lowerLetter",
+    supportsMutation: true,
+    render: (value) => toAlphabetic2(value).toLowerCase()
+  },
+  {
+    format: "upperRoman",
+    renderSupport: "supported",
+    renderedFormat: "upperRoman",
+    supportsMutation: true,
+    render: (value) => toRoman2(value).toUpperCase()
+  },
+  {
+    format: "lowerRoman",
+    renderSupport: "supported",
+    renderedFormat: "lowerRoman",
+    supportsMutation: true,
+    render: (value) => toRoman2(value).toLowerCase()
+  },
+  {
+    format: "hex",
+    renderSupport: "supported",
+    renderedFormat: "hex",
+    supportsMutation: true,
+    render: (value) => value >= 0 ? value.toString(16).toUpperCase() : String(value)
+  },
+  {
+    format: "ordinal",
+    renderSupport: "supported",
+    renderedFormat: "ordinal",
+    supportsMutation: true,
+    render: toOrdinal2
+  },
+  {
+    format: "cardinalText",
+    renderSupport: "supported",
+    renderedFormat: "cardinalText",
+    supportsMutation: true,
+    render: toCardinalText2
+  },
+  {
+    format: "ordinalText",
+    renderSupport: "supported",
+    renderedFormat: "ordinalText",
+    supportsMutation: true,
+    render: toOrdinalText2
+  },
+  {
+    format: "chicago",
+    renderSupport: "supported",
+    renderedFormat: "chicago",
+    supportsMutation: true,
+    render: toChicago2
+  },
+  {
+    format: "bullet",
+    renderSupport: "supported",
+    renderedFormat: "bullet",
+    supportsMutation: true,
+    render: () => ""
+  },
+  {
+    format: "none",
+    renderSupport: "supported",
+    renderedFormat: "none",
+    supportsMutation: true,
+    render: () => ""
+  }
+];
+var approximatedDecimalFormats = [
+  "decimalEnclosedCircle",
+  "decimalEnclosedFullstop",
+  "decimalEnclosedParen",
+  "decimalFullWidth",
+  "decimalHalfWidth",
+  "aiueo",
+  "iroha",
+  "ganada",
+  "chosung",
+  "russianLower",
+  "russianUpper",
+  "hebrew1",
+  "hebrew2",
+  "arabicAlpha",
+  "arabicAbjad",
+  "thaiLetters",
+  "thaiNumbers",
+  "hindiLetters",
+  "hindiNumbers",
+  "ideographDigital",
+  "ideographTraditional",
+  "chineseCounting",
+  "japaneseCounting",
+  "japaneseLegal"
+];
+var approximatedNumberingFormatEntries = approximatedDecimalFormats.map((format) => ({
+  format,
+  renderSupport: "approximated",
+  renderedFormat: "decimal",
+  supportsMutation: false,
+  fallbackReason: "unsupported-numbering-format-decimal-fallback",
+  render: (value) => String(value)
+}));
+var NUMBERING_FORMAT_REGISTRY = new Map(
+  [...exactNumberingFormatEntries, ...approximatedNumberingFormatEntries].map((entry) => [
+    entry.format,
+    entry
+  ])
+);
 function toOrdinal2(value) {
   if (value <= 0) return String(value);
   const lastTwo = value % 100;
@@ -10859,12 +11160,36 @@ var DEFAULT_HYPERLINK_COLOR_HEX = "0563C1";
 function resolveHyperlinkRunFormatting(input, catalog, resolver) {
   const augmentedInput = input.characterStyleId === void 0 ? { ...input, characterStyleId: HYPERLINK_CHARACTER_STYLE_ID } : input;
   const cascade = resolveEffectiveRunFormatting(augmentedInput, catalog);
-  const resolvedColor = resolveHyperlinkColorHex(cascade, resolver);
+  const resolvedColor = resolveHyperlinkColorHex(
+    stripInheritedColorHexForImplicitHyperlink(input, catalog, cascade),
+    resolver
+  );
   if (resolvedColor && resolvedColor !== cascade.colorHex) {
     return { ...cascade, colorHex: resolvedColor };
   }
   return cascade;
 }
+function hasDirectNonAutoColor(input) {
+  return Boolean(input.direct?.colorHex && input.direct.colorHex !== "auto");
+}
+function characterStyleDeclaresColorHex(styleId, catalog) {
+  if (!catalog) return false;
+  const chain = resolveCharacterStyleChain(styleId, catalog);
+  return chain.some((chainStyleId) => {
+    const colorHex = catalog.characters[chainStyleId]?.runProperties?.colorHex;
+    return Boolean(colorHex && colorHex !== "auto");
+  });
+}
+function stripInheritedColorHexForImplicitHyperlink(originalInput, catalog, cascade) {
+  if (originalInput.characterStyleId !== void 0 || hasDirectNonAutoColor(originalInput) || !cascade.colorHex || cascade.colorHex === "auto" || characterStyleDeclaresColorHex(HYPERLINK_CHARACTER_STYLE_ID, catalog)) {
+    return cascade;
+  }
+  const inheritedCascade = resolveEffectiveRunFormatting(originalInput, catalog);
+  if (inheritedCascade.colorHex !== cascade.colorHex) {
+    return cascade;
+  }
+  return { ...cascade, colorHex: void 0 };
+}
 function resolveHyperlinkColorHex(cascade, resolver) {
   if (cascade.colorHex && cascade.colorHex !== "auto") {
     return cascade.colorHex;
@@ -11096,7 +11421,7 @@ function buildEffectiveLayoutFormatting(input) {
   };
 }
 function createStructuralHash(value) {
-  const stable = stableStringify2(value);
+  const stable = stableStringify3(value);
   let hash = 2166136261;
   for (let i = 0; i < stable.length; i += 1) {
     hash ^= stable.charCodeAt(i);
@@ -11104,16 +11429,16 @@ function createStructuralHash(value) {
   }
   return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
 }
-function stableStringify2(value) {
+function stableStringify3(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
   }
   if (Array.isArray(value)) {
-    return `[${value.map((entry) => stableStringify2(entry)).join(",")}]`;
+    return `[${value.map((entry) => stableStringify3(entry)).join(",")}]`;
   }
   const record = value;
   const keys = Object.keys(record).filter((key) => record[key] !== void 0).sort();
-  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify2(record[key])}`).join(",")}}`;
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify3(record[key])}`).join(",")}}`;
 }
 
 // src/runtime/formatting/formatting-context.ts
@@ -11704,6 +12029,7 @@ function createEditorSurfaceSnapshot(document2, _selection, activeStory = { kind
     ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {}
   });
   const editableTargetsByBlockPath = options.editableTargetsByBlockPath ?? indexEditableTargetsByBlockPath(document2);
+  const layoutIdentitiesByBlockPath = options.layoutIdentitiesByBlockPath;
   const activeStoryBlockPathBase = getActiveStoryBlockPathBase(document2, activeStory);
   chartModelStore.beginBuildPass(document2);
   const unsupportedNumberingFormatsSeen = options.emitFormattingTelemetry ? /* @__PURE__ */ new Set() : null;
@@ -11727,6 +12053,7 @@ function createEditorSurfaceSnapshot(document2, _selection, activeStory = { kind
       activeStory.kind !== "main",
       !isInViewport,
       editableTargetsByBlockPath,
+      layoutIdentitiesByBlockPath,
       `${activeStoryBlockPathBase}/block[${index}]`
     );
     if (isInViewport) {
@@ -11793,7 +12120,7 @@ function isIndexInAnyRange(index, ranges) {
   }
   return false;
 }
-function createSurfaceBlock(block, document2, cursor, counters, formattingContext, promoteSecondaryStoryTextBoxes, cullBuild = false, editableTargetsByBlockPath = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH, blockPath) {
+function createSurfaceBlock(block, document2, cursor, counters, formattingContext, promoteSecondaryStoryTextBoxes, cullBuild = false, editableTargetsByBlockPath = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH, layoutIdentitiesByBlockPath, blockPath) {
   if (block.type === "opaque_block") {
     const fragment = getOpaqueFragment(document2.preservation, block.fragmentId);
     const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
@@ -11830,6 +12157,7 @@ function createSurfaceBlock(block, document2, cursor, counters, formattingContex
       promoteSecondaryStoryTextBoxes,
       cullBuild,
       editableTargetsByBlockPath,
+      layoutIdentitiesByBlockPath,
       blockPath
     );
   }
@@ -11870,6 +12198,7 @@ function createSurfaceBlock(block, document2, cursor, counters, formattingContex
       promoteSecondaryStoryTextBoxes,
       cullBuild,
       editableTargetsByBlockPath,
+      layoutIdentitiesByBlockPath,
       blockPath
     );
   }
@@ -11952,10 +12281,11 @@ function createSurfaceBlock(block, document2, cursor, counters, formattingContex
     cullBuild,
     editableTargetsByBlockPath,
     blockPath,
-    blockPath !== void 0 ? editableTargetsByBlockPath.get(blockPath) : void 0
+    blockPath !== void 0 ? editableTargetsByBlockPath.get(blockPath) : void 0,
+    blockPath !== void 0 ? layoutIdentitiesByBlockPath?.get(blockPath) : void 0
   );
 }
-function createTableBlock(tableIndex, table, document2, cursor, counters, formattingContext, promoteSecondaryStoryTextBoxes, cullBuild = false, editableTargetsByBlockPath = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH, tablePath) {
+function createTableBlock(tableIndex, table, document2, cursor, counters, formattingContext, promoteSecondaryStoryTextBoxes, cullBuild = false, editableTargetsByBlockPath = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH, layoutIdentitiesByBlockPath, tablePath) {
   const lockedFragmentIds = [];
   let innerCursor = cursor;
   if (cullBuild) {
@@ -11972,6 +12302,7 @@ function createTableBlock(tableIndex, table, document2, cursor, counters, format
             promoteSecondaryStoryTextBoxes,
             true,
             editableTargetsByBlockPath,
+            layoutIdentitiesByBlockPath,
             tablePath !== void 0 ? `${tablePath}/row[${rowIndex}]/cell[${cellIndex}]/block[${childIndex}]` : void 0
           );
           lockedFragmentIds.push(...result.lockedFragmentIds);
@@ -11987,6 +12318,7 @@ function createTableBlock(tableIndex, table, document2, cursor, counters, format
         to: innerCursor,
         styleId: table.styleId,
         ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
+        ...tablePath !== void 0 && layoutIdentitiesByBlockPath?.get(tablePath) !== void 0 ? { layoutIdentity: layoutIdentitiesByBlockPath.get(tablePath) } : {},
         gridColumns: table.gridColumns,
         rows: []
       },
@@ -12024,6 +12356,7 @@ function createTableBlock(tableIndex, table, document2, cursor, counters, format
           promoteSecondaryStoryTextBoxes,
           cullBuild,
           editableTargetsByBlockPath,
+          layoutIdentitiesByBlockPath,
           tablePath !== void 0 ? `${tablePath}/row[${rowIndex}]/cell[${cellIndex}]/block[${childIndex}]` : void 0
         );
         cellContent.push(result.block);
@@ -12112,6 +12445,7 @@ function createTableBlock(tableIndex, table, document2, cursor, counters, format
       to: innerCursor,
       styleId: table.styleId,
       ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
+      ...tablePath !== void 0 && layoutIdentitiesByBlockPath?.get(tablePath) !== void 0 ? { layoutIdentity: layoutIdentitiesByBlockPath.get(tablePath) } : {},
       gridColumns: table.gridColumns,
       ...gridColumnsRelative ? { gridColumnsRelative } : {},
       ...resolvedTable.table?.alignment ? { alignment: resolvedTable.table.alignment } : {},
@@ -12299,7 +12633,7 @@ function resolveCellBorderStyles(borders, tableBorders, position) {
   if (left) result.borderLeft = left;
   return result;
 }
-function createSdtBlock(sdtIndex, block, document2, cursor, counters, formattingContext, promoteSecondaryStoryTextBoxes, cullBuild = false, editableTargetsByBlockPath = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH, sdtPath) {
+function createSdtBlock(sdtIndex, block, document2, cursor, counters, formattingContext, promoteSecondaryStoryTextBoxes, cullBuild = false, editableTargetsByBlockPath = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH, layoutIdentitiesByBlockPath, sdtPath) {
   const children = [];
   const lockedFragmentIds = [];
   let innerCursor = cursor;
@@ -12316,6 +12650,7 @@ function createSdtBlock(sdtIndex, block, document2, cursor, counters, formatting
       promoteSecondaryStoryTextBoxes,
       cullBuild,
       editableTargetsByBlockPath,
+      layoutIdentitiesByBlockPath,
       sdtPath !== void 0 ? `${sdtPath}/block[${childIndex}]` : void 0
     );
     children.push(result.block);
@@ -12358,7 +12693,7 @@ function getRecursableSdtBlockedReasonCode(block) {
   ].filter(Boolean).join(" ").toLowerCase();
   return searchText.includes("table of contents") || /\btoc\b/u.test(searchText) ? "workflow_preserve_only" : null;
 }
-function createParagraphBlock(paragraphIndex, paragraph, document2, start, formattingContext, promoteSecondaryStoryTextBoxes, cullBuild = false, editableTargetsByBlockPath = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH, blockPath, editableTarget) {
+function createParagraphBlock(paragraphIndex, paragraph, document2, start, formattingContext, promoteSecondaryStoryTextBoxes, cullBuild = false, editableTargetsByBlockPath = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH, blockPath, editableTarget, layoutIdentity) {
   const themeResolver = formattingContext.theme;
   const effectiveNumbering = formattingContext.resolveEffectiveParagraphNumbering(paragraph);
   let resolvedNumbering = null;
@@ -12381,6 +12716,7 @@ function createParagraphBlock(paragraphIndex, paragraph, document2, start, forma
     from: start,
     to: start,
     ...editableTarget !== void 0 ? { editableTarget } : {},
+    ...layoutIdentity !== void 0 ? { layoutIdentity } : {},
     ...paragraph.styleId ? { styleId: paragraph.styleId } : {},
     ...effectiveNumbering ? { numbering: effectiveNumbering } : {},
     ...resolvedNumbering ? {
@@ -16572,6 +16908,14 @@ function paginateSectionBlocksWithSplits(section, blocks, layout, footnotes, mea
         pushPage(block.from);
         continue;
       }
+      if (isStandalonePageBreakParagraph(block)) {
+        if (columnHeight > 0) {
+          pushPage(nextBoundary);
+        } else {
+          pageStart = Math.max(pageStart, Math.min(nextBoundary, section.end));
+        }
+        break;
+      }
       const effectiveNoteHeight = estimateFootnoteReservation(
         block,
         footnotes,
@@ -16746,6 +17090,21 @@ function hasPageBreak(block) {
   }
   return nestedBlocks(block).some(hasPageBreak);
 }
+function isStandalonePageBreakParagraph(block) {
+  if (block.kind !== "paragraph") return false;
+  let sawPageBreak = false;
+  for (const segment of block.segments) {
+    if (segment.kind === "opaque_inline" && segment.label === "Page break") {
+      sawPageBreak = true;
+      continue;
+    }
+    if (segment.kind === "text" && segment.text.trim().length === 0) {
+      continue;
+    }
+    return false;
+  }
+  return sawPageBreak;
+}
 function nestedBlocks(block) {
   if (block.kind === "sdt_block") {
     return block.children;
@@ -18230,6 +18589,9 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
   for (let blockIndex = 0; blockIndex < surface.blocks.length; blockIndex += 1) {
     const block = surface.blocks[blockIndex];
     const blockPath = `main/block[${blockIndex}]`;
+    if (isStandalonePageBreakParagraph2(block)) {
+      continue;
+    }
     if (block.kind === "table") {
       const tableSliceList = splits?.tablesByBlockId.get(block.blockId);
       if (tableSliceList && tableSliceList.length > 1) {
@@ -18315,6 +18677,23 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
   }
   return byPage;
 }
+function isStandalonePageBreakParagraph2(block) {
+  if (block.kind !== "paragraph") {
+    return false;
+  }
+  let sawPageBreak = false;
+  for (const segment of block.segments) {
+    if (segment.kind === "opaque_inline" && segment.label === "Page break") {
+      sawPageBreak = true;
+      continue;
+    }
+    if (segment.kind === "text" && segment.text.trim().length === 0) {
+      continue;
+    }
+    return false;
+  }
+  return sawPageBreak;
+}
 function projectLineBoxesForPageFragments(pages, fragmentsByPageIndex, fragmentMeasurementsByPageIndex, surface) {
   const byPage = /* @__PURE__ */ new Map();
   const blocksById = surface ? new Map(surface.blocks.map((block) => [block.blockId, block])) : /* @__PURE__ */ new Map();
@@ -18827,13 +19206,11 @@ function buildBookmarkRanges(targets) {
 }
 var EMPTY_NUMBERING_INPUT_INDEX = {
   byNumberingKey: /* @__PURE__ */ new Map(),
-  byBlockPath: /* @__PURE__ */ new Map(),
-  byParagraphIndex: /* @__PURE__ */ new Map()
+  byBlockPath: /* @__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);
@@ -18841,11 +19218,8 @@ function buildNumberingInputIndex(numberingInputs) {
     if (!byBlockPath.has(input.blockPath)) {
       byBlockPath.set(input.blockPath, input);
     }
-    if (!byParagraph.has(input.paragraphIndex)) {
-      byParagraph.set(input.paragraphIndex, input);
-    }
   }
-  return { byNumberingKey, byBlockPath, byParagraphIndex: byParagraph };
+  return { byNumberingKey, byBlockPath };
 }
 function collectBookmarkRangeLayoutFacts(fragmentId, blockPath, bookmarkRanges) {
   if (!blockPath || !bookmarkRanges || bookmarkRanges.length === 0) return [];
@@ -18965,8 +19339,7 @@ function collectNumberingLayoutFactsForBlock(block, blockPath, numberingIndex, n
     const canonical = lookupNumberingInput(
       numberingIndex,
       numberingKey,
-      context.path,
-      paragraphIndex
+      context.path
     );
     const target = findNumberingTarget(numberingTargets, context.path);
     const numberingLayoutId = numberingKey ?? [
@@ -19006,7 +19379,7 @@ function findNumberingTarget(numberingTargets, blockPath) {
   if (blockPath === void 0) return void 0;
   return numberingTargets.find((target) => target.blockPath === blockPath);
 }
-function lookupNumberingInput(numberingIndex, numberingKey, blockPath, paragraphIndex) {
+function lookupNumberingInput(numberingIndex, numberingKey, blockPath) {
   if (!numberingIndex) return void 0;
   if (numberingKey !== void 0) {
     const byKey = numberingIndex.byNumberingKey.get(numberingKey);
@@ -19016,7 +19389,7 @@ function lookupNumberingInput(numberingIndex, numberingKey, blockPath, paragraph
     const byPath = numberingIndex.byBlockPath.get(blockPath);
     if (byPath !== void 0) return byPath;
   }
-  return paragraphIndex !== void 0 ? numberingIndex.byParagraphIndex.get(paragraphIndex) : void 0;
+  return void 0;
 }
 function collectNumberingUnavailableReasons(numbering, canonical) {
   const reasons = [];
@@ -19434,13 +19807,331 @@ async function createCanvasProvider(fontLoader) {
   }
 }
 
+// src/runtime/layout/persistent-layout-measurement-cache.ts
+init_resolved_formatting_state();
+var DEFAULT_MAX_ENTRIES = 1e4;
+var DEFAULT_MAX_ESTIMATED_BYTES = 50 * 1024 * 1024;
+function createPersistentLayoutMeasurementCache(options = {}) {
+  const maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_MAX_ENTRIES);
+  const maxEstimatedBytes = Math.max(
+    1024,
+    options.maxEstimatedBytes ?? DEFAULT_MAX_ESTIMATED_BYTES
+  );
+  const entries = /* @__PURE__ */ new Map();
+  const counters = {
+    hits: 0,
+    misses: 0,
+    sets: 0,
+    evictions: 0,
+    clears: 0,
+    estimatedBytes: 0,
+    invalidatedByReason: {}
+  };
+  function evictOldest() {
+    const oldest = entries.keys().next();
+    if (oldest.done) return;
+    const entry = entries.get(oldest.value);
+    if (entry) {
+      counters.estimatedBytes -= entry.estimatedBytes;
+    }
+    entries.delete(oldest.value);
+    counters.evictions += 1;
+  }
+  return {
+    get(key) {
+      const cacheKey2 = serializeCacheKey(key);
+      const entry = entries.get(cacheKey2);
+      if (!entry) {
+        counters.misses += 1;
+        return void 0;
+      }
+      entries.delete(cacheKey2);
+      entries.set(cacheKey2, entry);
+      counters.hits += 1;
+      return entry.value;
+    },
+    set(key, value) {
+      const cacheKey2 = serializeCacheKey(key);
+      const previous = entries.get(cacheKey2);
+      if (previous) {
+        counters.estimatedBytes -= previous.estimatedBytes;
+        entries.delete(cacheKey2);
+      }
+      const estimatedBytes = estimateBytes(key, value);
+      entries.set(cacheKey2, { key, value, estimatedBytes });
+      counters.estimatedBytes += estimatedBytes;
+      counters.sets += 1;
+      while (entries.size > maxEntries || counters.estimatedBytes > maxEstimatedBytes) {
+        evictOldest();
+      }
+    },
+    invalidate(reason, predicate) {
+      if (!predicate) {
+        const removed2 = entries.size;
+        counters.estimatedBytes = 0;
+        entries.clear();
+        counters.invalidatedByReason[reason] = (counters.invalidatedByReason[reason] ?? 0) + removed2;
+        return;
+      }
+      let removed = 0;
+      for (const [cacheKey2, entry] of entries) {
+        if (!predicate(entry.key)) continue;
+        counters.estimatedBytes -= entry.estimatedBytes;
+        entries.delete(cacheKey2);
+        removed += 1;
+      }
+      counters.invalidatedByReason[reason] = (counters.invalidatedByReason[reason] ?? 0) + removed;
+    },
+    clear(reason) {
+      const removed = entries.size;
+      counters.estimatedBytes = 0;
+      entries.clear();
+      counters.clears += 1;
+      counters.invalidatedByReason[reason] = (counters.invalidatedByReason[reason] ?? 0) + removed;
+    },
+    stats() {
+      return {
+        hits: counters.hits,
+        misses: counters.misses,
+        sets: counters.sets,
+        evictions: counters.evictions,
+        clears: counters.clears,
+        size: entries.size,
+        estimatedBytes: Math.max(0, counters.estimatedBytes),
+        invalidatedByReason: { ...counters.invalidatedByReason }
+      };
+    }
+  };
+}
+function createCachedLayoutMeasurementProvider(delegate, options = {}) {
+  const cache = options.cache ?? createPersistentLayoutMeasurementCache(options);
+  function emitCounter(type, key) {
+    const telemetryBus = options.telemetryBus;
+    if (!telemetryBus?.isEnabled("layout")) return;
+    telemetryBus.emitLazy("layout", () => ({
+      type,
+      payload: key ? {
+        measurementKind: key.measurementKind,
+        blockId: key.blockId,
+        backendVersion: key.backendVersion
+      } : void 0
+    }));
+  }
+  return {
+    get fidelity() {
+      return delegate.fidelity;
+    },
+    measurementCache: cache,
+    measurementCacheStats() {
+      return cache.stats();
+    },
+    whenReady() {
+      return delegate.whenReady();
+    },
+    measureLineFragments(input) {
+      const key = buildLineFragmentsKey(input, delegate, options);
+      const cached = cache.get(key);
+      if (cached) {
+        emitCounter("pageRender.measurement.hit", key);
+        return cloneMeasuredLineFragments(cached);
+      }
+      emitCounter("pageRender.measurement.miss", key);
+      const measured = delegate.measureLineFragments(input);
+      cache.set(key, cloneMeasuredLineFragments(measured));
+      return measured;
+    },
+    measureInlineObject(input) {
+      const key = buildInlineObjectKey(input, delegate, options);
+      const cached = cache.get(key);
+      if (cached) {
+        emitCounter("pageRender.measurement.hit", key);
+        return { ...cached };
+      }
+      emitCounter("pageRender.measurement.miss", key);
+      const measured = delegate.measureInlineObject(input);
+      cache.set(key, { ...measured });
+      return measured;
+    },
+    measureTableBlock(input) {
+      const key = buildTableBlockKey(input, delegate, options);
+      const cached = cache.get(key);
+      if (cached) {
+        emitCounter("pageRender.measurement.hit", key);
+        return cloneMeasuredTableBlock(cached);
+      }
+      emitCounter("pageRender.measurement.miss", key);
+      const measured = delegate.measureTableBlock(input);
+      cache.set(key, cloneMeasuredTableBlock(measured));
+      return measured;
+    },
+    invalidateCache() {
+      delegate.invalidateCache();
+      cache.clear("provider.invalidateCache");
+      emitCounter("pageRender.measurement.invalidated.provider.invalidateCache");
+    }
+  };
+}
+function isCachedLayoutMeasurementProvider(provider) {
+  return typeof provider.measurementCacheStats === "function";
+}
+function buildLineFragmentsKey(input, delegate, options) {
+  const block = input.block;
+  const identity = measurementIdentityForBlock(block);
+  return {
+    measurementKind: "line-fragments",
+    blockId: identity.blockId,
+    blockPath: identity.blockPath,
+    contentHash: hashStable2({
+      kind: block.kind,
+      identity: identity.identityHash,
+      segments: block.segments,
+      numbering: block.numbering,
+      numberingPrefix: block.numberingPrefix,
+      numberingSuffix: block.numberingSuffix,
+      resolvedNumbering: block.resolvedNumbering
+    }),
+    formattingHash: createLayoutReadyFormattingSnapshot(
+      input.formatting,
+      input.runs
+    ).hash,
+    constraintsHash: hashStable2({ columnWidth: input.columnWidth }),
+    sectionHash: resolveOptionValue(options.sectionHash, "section:provider-input"),
+    fontEpoch: resolveOptionValue(options.fontEpoch, "font:default"),
+    backendVersion: resolveOptionValue(options.backendVersion, delegate.fidelity),
+    displayModeHash: resolveOptionValue(options.displayModeHash, "display:default")
+  };
+}
+function buildInlineObjectKey(input, delegate, options) {
+  return {
+    measurementKind: "inline-object",
+    blockId: "inline-object",
+    blockPath: "inline-object",
+    contentHash: hashStable2({ display: input.display }),
+    formattingHash: "format:none",
+    constraintsHash: hashStable2({
+      widthTwips: input.widthTwips,
+      heightTwips: input.heightTwips
+    }),
+    sectionHash: resolveOptionValue(options.sectionHash, "section:provider-input"),
+    fontEpoch: resolveOptionValue(options.fontEpoch, "font:default"),
+    backendVersion: resolveOptionValue(options.backendVersion, delegate.fidelity),
+    displayModeHash: resolveOptionValue(options.displayModeHash, "display:default")
+  };
+}
+function buildTableBlockKey(input, delegate, options) {
+  const block = input.block;
+  const identity = measurementIdentityForBlock(block);
+  return {
+    measurementKind: "table-block",
+    blockId: identity.blockId,
+    blockPath: identity.blockPath,
+    contentHash: hashStable2({
+      kind: block.kind,
+      identity: identity.identityHash,
+      rows: block.rows,
+      gridColumns: block.gridColumns,
+      gridColumnsRelative: block.gridColumnsRelative,
+      tableResolved: block.tableResolved,
+      tblLook: block.tblLook
+    }),
+    formattingHash: hashStable2({
+      styleId: block.styleId,
+      alignment: block.alignment
+    }),
+    constraintsHash: hashStable2({ columnWidth: input.columnWidth }),
+    sectionHash: resolveOptionValue(options.sectionHash, "section:provider-input"),
+    fontEpoch: resolveOptionValue(options.fontEpoch, "font:default"),
+    backendVersion: resolveOptionValue(options.backendVersion, delegate.fidelity),
+    displayModeHash: resolveOptionValue(options.displayModeHash, "display:default")
+  };
+}
+function measurementIdentityForBlock(block) {
+  const identity = block.layoutIdentity;
+  if (!identity) {
+    return {
+      blockId: block.blockId,
+      blockPath: blockPathForBlock(block),
+      identityHash: "identity:legacy"
+    };
+  }
+  return {
+    blockId: identity.blockId,
+    blockPath: identity.blockPath,
+    identityHash: hashStable2({
+      storyKey: identity.storyKey,
+      blockId: identity.blockId,
+      blockPath: identity.blockPath,
+      sourceRef: identity.sourceRef,
+      table: identity.table,
+      list: identity.list,
+      field: identity.field,
+      object: identity.object
+    })
+  };
+}
+function blockPathForBlock(block) {
+  return `${block.from}:${block.to}`;
+}
+function resolveOptionValue(option, fallback) {
+  if (typeof option === "function") return option();
+  return option ?? fallback;
+}
+function serializeCacheKey(key) {
+  return stableStringify4(key);
+}
+function estimateBytes(key, value) {
+  return stableStringify4(key).length + stableStringify4(value).length;
+}
+function cloneMeasuredLineFragments(value) {
+  return {
+    lineCount: value.lineCount,
+    maxLineWidth: value.maxLineWidth,
+    lineHeights: [...value.lineHeights]
+  };
+}
+function cloneMeasuredTableBlock(value) {
+  return {
+    totalHeightTwips: value.totalHeightTwips,
+    rowHeights: [...value.rowHeights]
+  };
+}
+function hashStable2(value) {
+  return fnv1a2(stableStringify4(value)).toString(36);
+}
+function stableStringify4(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify4(item)).join(",")}]`;
+  }
+  if (value instanceof Map) {
+    return stableStringify4(Array.from(value.entries()));
+  }
+  const object = value;
+  const keys = Object.keys(object).filter((key) => object[key] !== void 0 && typeof object[key] !== "function").sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify4(object[key])}`).join(",")}}`;
+}
+function fnv1a2(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
 // src/runtime/layout/layout-engine-version.ts
-var LAYOUT_ENGINE_VERSION = 88;
+var LAYOUT_ENGINE_VERSION = 93;
 var LAYCACHE_SCHEMA_VERSION = 12;
 
 // src/runtime/layout/layout-engine-instance.ts
 var FULL_VIEWPORT_WINDOW_KEY = "full";
 var DEFAULT_VIEWPORT_PAGE_WINDOW_BUFFER = 1;
+function indexLayoutIdentitiesByBlockPath(identities) {
+  return new Map(identities.map((identity) => [identity.blockPath, identity]));
+}
+function indexEditableTargetsByBlockPath2(targets) {
+  return new Map(targets.map((target) => [target.blockPath, target]));
+}
 function normalizeViewportPageWindow(window2) {
   if (!window2) return void 0;
   const buffer = Number.isFinite(window2.bufferPages) ? Math.max(0, Math.floor(window2.bufferPages ?? 0)) : DEFAULT_VIEWPORT_PAGE_WINDOW_BUFFER;
@@ -19636,8 +20327,22 @@ function recordFullRebuildReason(reasonKind) {
   probe.invalidationCounts[totalKey] = (probe.invalidationCounts[totalKey] ?? 0) + 1;
   probe.invalidationCounts[byReasonKey] = (probe.invalidationCounts[byReasonKey] ?? 0) + 1;
 }
+function wrapMeasurementProvider(provider, measurementCache, telemetryBus) {
+  if (!measurementCache || isCachedLayoutMeasurementProvider(provider)) {
+    return provider;
+  }
+  const cacheOptions = measurementCache === true ? {} : measurementCache;
+  return createCachedLayoutMeasurementProvider(provider, {
+    ...cacheOptions,
+    ...telemetryBus ? { telemetryBus } : {}
+  });
+}
 function createLayoutEngine(options = {}) {
-  let measurementProvider = options.measurementProvider ?? createEmpiricalMeasurementProvider();
+  let measurementProvider = wrapMeasurementProvider(
+    options.measurementProvider ?? createEmpiricalMeasurementProvider(),
+    options.measurementCache,
+    options.telemetryBus
+  );
   const autoUpgradeToCanvas = options.autoUpgradeToCanvasBackend !== false;
   const telemetryBus = options.telemetryBus;
   const dirtyFieldFamilies = /* @__PURE__ */ new Set();
@@ -19737,13 +20442,20 @@ function createLayoutEngine(options = {}) {
     const pageCountBeforeRecompute = previousPageCount;
     const document2 = input.document;
     const viewportWindow = normalizeViewportPageWindow(input.viewportPageWindow);
+    const layoutInputs = collectCanonicalLayoutInputs(document2);
+    const layoutIdentitiesByBlockPath = indexLayoutIdentitiesByBlockPath(
+      layoutInputs.layoutIdentities
+    );
+    const editableTargetsByBlockPath = indexEditableTargetsByBlockPath2(
+      layoutInputs.editableTargets
+    );
     const mainSurface = createEditorSurfaceSnapshot(
       document2,
       createSelectionSnapshot(0, 0),
-      MAIN_STORY_TARGET
+      MAIN_STORY_TARGET,
+      { editableTargetsByBlockPath, layoutIdentitiesByBlockPath }
     );
     const sections = buildResolvedSections(document2);
-    const layoutInputs = collectCanonicalLayoutInputs(document2);
     const fieldRegions = layoutInputs.fieldRegions;
     const pageStack = buildPageStackWithSplits(
       document2,
@@ -19855,10 +20567,18 @@ function createLayoutEngine(options = {}) {
     const firstDirty = range.firstPageIndex;
     if (firstDirty < 0 || firstDirty >= priorGraph.pages.length) return null;
     const document2 = input.document;
+    const layoutInputs = collectCanonicalLayoutInputs(document2);
+    const layoutIdentitiesByBlockPath = indexLayoutIdentitiesByBlockPath(
+      layoutInputs.layoutIdentities
+    );
+    const editableTargetsByBlockPath = indexEditableTargetsByBlockPath2(
+      layoutInputs.editableTargets
+    );
     const mainSurface = createEditorSurfaceSnapshot(
       document2,
       createSelectionSnapshot(0, 0),
-      MAIN_STORY_TARGET
+      MAIN_STORY_TARGET,
+      { editableTargetsByBlockPath, layoutIdentitiesByBlockPath }
     );
     const sections = buildResolvedSections(document2);
     const dirtyPage = priorGraph.pages[firstDirty];
@@ -19887,7 +20607,6 @@ function createLayoutEngine(options = {}) {
     const freshSnapshotsToRebuild = freshSnapshots.slice(0, convergenceIndex);
     const convergedTailStart = convergenceIndex < freshSnapshots.length ? firstDirty + convergenceIndex : void 0;
     const freshStories = resolvePageStories(freshSnapshotsToRebuild);
-    const layoutInputs = collectCanonicalLayoutInputs(document2);
     const fieldRegions = layoutInputs.fieldRegions;
     const freshBodyFragmentsByPageIndex = projectSurfaceBlocksToPageFragments(
       mainSurface,
@@ -20019,7 +20738,11 @@ function createLayoutEngine(options = {}) {
       try {
         const mod = await Promise.resolve().then(() => (init_measurement_backend_canvas(), measurement_backend_canvas_exports));
         const canvasProvider = mod.createCanvasBackend();
-        measurementProvider = canvasProvider;
+        measurementProvider = wrapMeasurementProvider(
+          canvasProvider,
+          options.measurementCache,
+          telemetryBus
+        );
         cachedKey = null;
         cachedGraph = null;
         cachedFormatting = null;
@@ -20104,7 +20827,11 @@ function createLayoutEngine(options = {}) {
     },
     swapMeasurementProvider(provider) {
       const previousFidelity = measurementProvider.fidelity;
-      measurementProvider = provider;
+      measurementProvider = wrapMeasurementProvider(
+        provider,
+        options.measurementCache,
+        telemetryBus
+      );
       if (previousFidelity !== provider.fidelity) {
         cachedKey = null;
         cachedGraph = null;
@@ -20133,6 +20860,10 @@ function createLayoutEngine(options = {}) {
       cachedFormatting = null;
       cachedMapper = null;
     },
+    getMeasurementCacheStats() {
+      if (!isCachedLayoutMeasurementProvider(measurementProvider)) return null;
+      return measurementProvider.measurementCacheStats();
+    },
     /**
      * L7 Phase 2.5 — seed the cached graph from a prerender envelope.
      * Populates both `cachedGraph` and `cachedKey` (keyed on the provided
@@ -22000,6 +22731,133 @@ function clamp(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
 
+// src/io/ooxml/numbering-catalog-mutation.ts
+function cloneNumberingCatalog(catalog) {
+  return structuredClone(catalog);
+}
+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 ensureDefaultListInstance(catalog, kind) {
+  const existing = Object.values(catalog.instances).find(
+    (instance) => getListKind(catalog, instance.numberingInstanceId) === kind
+  );
+  if (existing) return existing.numberingInstanceId;
+  const abstractNumberingId = allocateAbstractDefinition(catalog, {
+    levels: defaultLevels(kind),
+    multiLevelType: "hybridMultilevel"
+  });
+  return allocateNumberingInstance(catalog, abstractNumberingId);
+}
+function allocateNumberingInstance(catalog, abstractNumberingId, overrides = []) {
+  const numberingInstanceId = nextCanonicalNumericId(
+    "num:",
+    Object.keys(catalog.instances)
+  );
+  catalog.instances[numberingInstanceId] = {
+    numberingInstanceId,
+    abstractNumberingId,
+    overrides: cloneOverrides(overrides)
+  };
+  return numberingInstanceId;
+}
+function allocateAbstractDefinition(catalog, input) {
+  const abstractNumberingId = input.abstractNumberingId && !catalog.abstractDefinitions[input.abstractNumberingId] ? input.abstractNumberingId : nextCanonicalNumericId("abstract-num:", Object.keys(catalog.abstractDefinitions));
+  catalog.abstractDefinitions[abstractNumberingId] = {
+    abstractNumberingId,
+    levels: structuredClone(input.levels),
+    ...input.nsid ? { nsid: input.nsid } : { nsid: freshLongHex(catalog, abstractNumberingId, "nsid") },
+    ...input.multiLevelType ? { multiLevelType: input.multiLevelType } : {},
+    ...input.tplc ? { tplc: input.tplc } : { tplc: freshLongHex(catalog, abstractNumberingId, "tmpl") },
+    ...input.styleLink ? { styleLink: input.styleLink } : {},
+    ...input.numStyleLink ? { numStyleLink: input.numStyleLink } : {}
+  };
+  return abstractNumberingId;
+}
+function setStartOverride(catalog, numberingInstanceId, level, startAt) {
+  const instance = catalog.instances[numberingInstanceId];
+  if (!instance) return;
+  catalog.instances[numberingInstanceId] = {
+    ...instance,
+    overrides: mergeOverride(instance.overrides, { level, startAt })
+  };
+}
+function mergeOverride(overrides, nextOverride) {
+  return [
+    ...overrides.filter((override) => override.level !== nextOverride.level),
+    structuredClone(nextOverride)
+  ].sort((left, right) => left.level - right.level);
+}
+function cloneOverrides(overrides) {
+  return overrides.map((override) => structuredClone(override));
+}
+function defaultLevels(kind) {
+  if (kind === "bulleted") {
+    return [
+      { 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" }
+    ];
+  }
+  return [
+    { 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 nextCanonicalNumericId(prefix, ids) {
+  return `${prefix}${nextNumericString(ids.map((id) => stripPrefix(id, prefix)))}`;
+}
+function nextNumericString(ids) {
+  const used = new Set(ids);
+  let next = 1;
+  for (const id of ids) {
+    const parsed = Number.parseInt(id, 10);
+    if (Number.isFinite(parsed) && parsed >= next) next = parsed + 1;
+  }
+  while (used.has(String(next))) next += 1;
+  return String(next);
+}
+function stripPrefix(value, prefix) {
+  return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+}
+function freshLongHex(catalog, abstractNumberingId, salt) {
+  const existing = new Set(
+    Object.values(catalog.abstractDefinitions).map((definition) => salt === "nsid" ? definition.nsid : definition.tplc).filter((value) => Boolean(value))
+  );
+  let attempt = 0;
+  while (attempt < 1e3) {
+    const candidate = hashLongHex(`${salt}:${abstractNumberingId}:${attempt}`);
+    if (!existing.has(candidate)) return candidate;
+    attempt += 1;
+  }
+  return hashLongHex(`${salt}:${abstractNumberingId}:${Date.now()}`);
+}
+function hashLongHex(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).toUpperCase().padStart(8, "0").slice(-8);
+}
+
 // src/core/commands/list-commands.ts
 function toggleNumberedList(document2, paragraphIndexes, context, options = {}) {
   return toggleListKind(document2, paragraphIndexes, "numbered", context, options);
@@ -22151,7 +23009,7 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1, optio
       affectedParagraphIndexes: []
     };
   }
-  const catalog = ensureNumberingCatalog(working.numbering);
+  const catalog = cloneNumberingCatalog(working.numbering);
   const existingInstance = catalog.instances[target.numbering.numberingInstanceId];
   if (!existingInstance) {
     return {
@@ -22159,15 +23017,12 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1, optio
       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];
@@ -22221,7 +23076,7 @@ function continueNumbering(document2, 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) {
@@ -22288,7 +23143,7 @@ function toggleListKind(document2, 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;
@@ -22303,7 +23158,7 @@ function toggleListKind(document2, 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 = {
@@ -22468,23 +23323,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) {
@@ -22507,69 +23345,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(document2, timestamp) {
   return {
     ...structuredClone(document2),
@@ -33916,7 +34691,7 @@ function applyFragmentInsert(document2, 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: {
@@ -33938,11 +34713,11 @@ function applyFragmentInsert(document2, 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) {
@@ -41572,6 +42347,76 @@ function diffRenderFrames(prev, next) {
   }
   return { addedPages, removedPages, unchangedPages, changedPages };
 }
+function createPagePatchPlan(prev, next, diff = diffRenderFrames(prev, next), options = {}) {
+  const prevByIndex = indexPagesByIndex(prev?.pages ?? []);
+  const nextByIndex = indexPagesByIndex(next.pages);
+  const addedPages = diff.addedPages.map(
+    (pageIndex) => pageIdForIndex(nextByIndex, pageIndex)
+  );
+  const removedPages = diff.removedPages.map(
+    (pageIndex) => pageIdForIndex(prevByIndex, pageIndex)
+  );
+  const unchangedPages = diff.unchangedPages.map(
+    (pageIndex) => pageIdForIndex(nextByIndex, pageIndex)
+  );
+  const changedPages = diff.changedPages.map(
+    (entry) => createPagePatchEntry(entry, pageIdForIndex(nextByIndex, entry.pageIndex), options)
+  );
+  return {
+    layoutRevision: options.layoutRevision ?? next.revision,
+    geometryRevision: options.geometryRevision ?? next.revision,
+    addedPages,
+    removedPages,
+    unchangedPages,
+    changedPages,
+    mountChanges: resolveMountChanges({
+      addedPages,
+      removedPages,
+      mountedPageIds: options.mountedPageIds,
+      requestedMountPageIds: options.requestedMountPageIds
+    })
+  };
+}
+function createPagePatchEntry(entry, pageId, options) {
+  const regionChanges = entry.regions.map((region) => region.kind);
+  const fragmentChanges = uniqueStrings(
+    entry.regions.flatMap((region) => region.changedBlockIds)
+  );
+  const overlayLaneChanges = !entry.pageFrameChanged && entry.regions.length === 0 ? ["chrome-reservations"] : [];
+  return {
+    pageId,
+    pageIndex: entry.pageIndex,
+    frameChanged: entry.pageFrameChanged === true,
+    regionChanges,
+    fragmentChanges,
+    lineBoxChanges: fragmentChanges,
+    overlayLaneChanges,
+    reason: options.reason ?? (overlayLaneChanges.length > 0 ? "overlay" : "layout")
+  };
+}
+function resolveMountChanges(input) {
+  if (!input.mountedPageIds || !input.requestedMountPageIds) {
+    return {
+      mountPageIds: input.addedPages,
+      unmountPageIds: input.removedPages
+    };
+  }
+  const mounted = new Set(input.mountedPageIds);
+  const requested = new Set(input.requestedMountPageIds);
+  return {
+    mountPageIds: input.requestedMountPageIds.filter((pageId) => !mounted.has(pageId)),
+    unmountPageIds: input.mountedPageIds.filter((pageId) => !requested.has(pageId))
+  };
+}
+function indexPagesByIndex(pages) {
+  return new Map(pages.map((page) => [page.page.pageIndex, page]));
+}
+function pageIdForIndex(pages, pageIndex) {
+  return pages.get(pageIndex)?.page.pageId ?? `page:${pageIndex}`;
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
 function diffPage(prev, next, prevIndex, nextIndex) {
   const changed = [];
   const bodyChanges = diffRegion(prev.regions.body, next.regions.body, prevIndex, nextIndex);
@@ -41792,10 +42637,12 @@ function createRenderKernel(input) {
         emit2({ kind: "frame_built", revision: frame.revision, reason: "full" });
         const diffT0 = typeof performance !== "undefined" ? performance.now() : 0;
         const diff = diffRenderFrames(lastEmittedFrame, frame);
+        const patchPlan = createPagePatchPlan(lastEmittedFrame, frame, diff);
+        recordPagePatchPlanTelemetry(patchPlan);
         if (diffT0 > 0) {
           recordPerfSample("render.frame_diff", performance.now() - diffT0);
         }
-        emit2({ kind: "frame_diff", revision: frame.revision, diff });
+        emit2({ kind: "frame_diff", revision: frame.revision, diff, patchPlan });
         lastEmittedFrame = frame;
       }
       return frame;
@@ -41818,6 +42665,35 @@ function createRenderKernel(input) {
     }
   };
 }
+function recordPagePatchPlanTelemetry(plan) {
+  incrementInvalidationCounter(
+    "pageRender.patch.addedPages",
+    plan.addedPages.length
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.removedPages",
+    plan.removedPages.length
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.unchangedPages",
+    plan.unchangedPages.length
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.changedFragments",
+    plan.changedPages.reduce(
+      (total, page) => total + page.fragmentChanges.length,
+      0
+    )
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.mountedPages",
+    plan.mountChanges.mountPageIds.length
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.unmountedPages",
+    plan.mountChanges.unmountPageIds.length
+  );
+}
 function buildPage(page, topPx, zoom, activeStory, facet) {
   const layout = page.layout;
   const widthPx = layout.pageWidth * zoom.pxPerTwip;
@@ -43194,7 +44070,7 @@ function emptyCompatibilityReport() {
 }
 
 // src/runtime/debug/runtime-debug-facet.ts
-function createRuntimeDebugFacet(getRuntime, bus) {
+function createRuntimeDebugFacet(getRuntime, bus, options = {}) {
   return {
     bus,
     getSnapshot(query) {
@@ -43212,10 +44088,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(document2) {
+  const blocks = document2.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(document2.review.comments ?? {}).length;
+  const revisionCount = Object.keys(document2.review.revisions ?? {}).length;
+  const secondaryStoryBlockCount = countSecondaryStoryBlocks(document2);
+  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(document2) {
+  const subParts = document2.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/io/export/serialize-ffdata.ts
 function regenerateFFDataRawXml(node) {
   const parts = ["<w:ffData>"];
@@ -44638,26 +45825,35 @@ function buildParagraphPropertiesXml(paragraph) {
     if (frameXml) children.push(frameXml);
   }
   pushOnOffParagraphProperty(children, "widowControl", paragraph.widowControl);
-  if (paragraph.outlineLevel !== void 0) {
-    children.push(`<w:outlineLvl w:val="${paragraph.outlineLevel}"/>`);
-  }
   if (paragraph.numbering) {
     children.push(serializeParagraphNumberingProperties(paragraph.numbering));
   }
+  pushOnOffParagraphProperty(children, "suppressLineNumbers", paragraph.suppressLineNumbers);
+  if (paragraph.borders) {
+    const bordersXml = serializeParagraphBorders(paragraph.borders);
+    if (bordersXml) children.push(bordersXml);
+  }
+  if (paragraph.shading) {
+    const shadingXml = serializeParagraphShading(paragraph.shading);
+    if (shadingXml) children.push(shadingXml);
+  }
+  if (paragraph.tabStops && paragraph.tabStops.length > 0) {
+    const tabsXml = paragraph.tabStops.map((tab) => {
+      const leaderAttr = tab.leader ? ` w:leader="${escapeXmlAttribute2(tab.leader)}"` : "";
+      return `<w:tab w:val="${escapeXmlAttribute2(tab.align)}" w:pos="${twip(tab.position)}"${leaderAttr}/>`;
+    }).join("");
+    children.push(`<w:tabs>${tabsXml}</w:tabs>`);
+  }
+  pushOnOffParagraphProperty(children, "bidi", paragraph.bidi);
   if (paragraph.spacing) {
     const s = paragraph.spacing;
     const attrs = [];
     if (s.before !== void 0) attrs.push(`w:before="${twip(s.before)}"`);
     if (s.after !== void 0) attrs.push(`w:after="${twip(s.after)}"`);
     if (s.line !== void 0) attrs.push(`w:line="${twip(s.line)}"`);
-    if (s.lineRule !== void 0) attrs.push(`w:lineRule="${s.lineRule}"`);
+    if (s.lineRule !== void 0) attrs.push(`w:lineRule="${escapeXmlAttribute2(s.lineRule)}"`);
     if (attrs.length > 0) children.push(`<w:spacing ${attrs.join(" ")}/>`);
   }
-  if (paragraph.contextualSpacing === true) {
-    children.push("<w:contextualSpacing/>");
-  } else if (paragraph.contextualSpacing === false) {
-    children.push(`<w:contextualSpacing w:val="false"/>`);
-  }
   if (paragraph.indentation) {
     const ind = paragraph.indentation;
     const attrs = [];
@@ -44667,33 +45863,20 @@ function buildParagraphPropertiesXml(paragraph) {
     if (ind.hanging !== void 0) attrs.push(`w:hanging="${twip(ind.hanging)}"`);
     if (attrs.length > 0) children.push(`<w:ind ${attrs.join(" ")}/>`);
   }
-  if (paragraph.alignment) {
-    children.push(`<w:jc w:val="${paragraph.alignment}"/>`);
+  if (paragraph.contextualSpacing === true) {
+    children.push("<w:contextualSpacing/>");
+  } else if (paragraph.contextualSpacing === false) {
+    children.push(`<w:contextualSpacing w:val="false"/>`);
   }
-  if (paragraph.borders) {
-    const bordersXml = serializeParagraphBorders(paragraph.borders);
-    if (bordersXml) {
-      children.push(bordersXml);
-    }
+  if (paragraph.alignment) {
+    children.push(`<w:jc w:val="${escapeXmlAttribute2(paragraph.alignment)}"/>`);
   }
-  if (paragraph.shading) {
-    const shadingXml = serializeParagraphShading(paragraph.shading);
-    if (shadingXml) {
-      children.push(shadingXml);
-    }
+  if (paragraph.outlineLevel !== void 0) {
+    children.push(`<w:outlineLvl w:val="${paragraph.outlineLevel}"/>`);
   }
-  pushOnOffParagraphProperty(children, "bidi", paragraph.bidi);
-  pushOnOffParagraphProperty(children, "suppressLineNumbers", paragraph.suppressLineNumbers);
   if (paragraph.cnfStyle) {
     children.push(`<w:cnfStyle w:val="${escapeXmlAttribute2(paragraph.cnfStyle)}"/>`);
   }
-  if (paragraph.tabStops && paragraph.tabStops.length > 0) {
-    const tabsXml = paragraph.tabStops.map((tab) => {
-      const leaderAttr = tab.leader ? ` w:leader="${tab.leader}"` : "";
-      return `<w:tab w:val="${tab.align}" w:pos="${twip(tab.position)}"${leaderAttr}/>`;
-    }).join("");
-    children.push(`<w:tabs>${tabsXml}</w:tabs>`);
-  }
   if (children.length === 0) return "";
   return `<w:pPr>${children.join("")}</w:pPr>`;
 }
@@ -45258,79 +46441,86 @@ function serializeRunProperties(marks) {
   if (!marks || marks.length === 0) {
     return "";
   }
+  const orderedTypes = [
+    "fontFamily",
+    "bold",
+    "italic",
+    "allCaps",
+    "smallCaps",
+    "strikethrough",
+    "doubleStrikethrough",
+    "shadow",
+    "emboss",
+    "imprint",
+    "vanish",
+    "textColor",
+    "charSpacing",
+    "kerning",
+    "position",
+    "fontSize",
+    "highlight",
+    "underline",
+    "backgroundColor",
+    "lang",
+    "textFill"
+  ];
   const markParts = [];
-  for (const mark of marks) {
-    switch (mark.type) {
-      case "bold":
-        markParts.push("<w:b/>");
-        break;
-      case "italic":
-        markParts.push("<w:i/>");
-        break;
-      case "underline":
-        markParts.push(`<w:u w:val="single"/>`);
-        break;
-      case "strikethrough":
-        markParts.push("<w:strike/>");
-        break;
-      case "doubleStrikethrough":
-        markParts.push("<w:dstrike/>");
-        break;
-      case "vanish":
-        markParts.push("<w:vanish/>");
-        break;
-      case "lang":
-        markParts.push(`<w:lang w:val="${escapeXmlAttribute2(mark.val)}"/>`);
-        break;
-      case "highlight":
-        markParts.push(`<w:highlight w:val="${escapeXmlAttribute2(mark.val)}"/>`);
-        break;
-      case "backgroundColor":
-        markParts.push(
-          `<w:shd w:val="clear" w:color="auto" w:fill="${escapeXmlAttribute2(mark.color)}"/>`
-        );
-        break;
-      case "charSpacing":
-        markParts.push(`<w:spacing w:val="${mark.val}"/>`);
-        break;
-      case "kerning":
-        markParts.push(`<w:kern w:val="${mark.val}"/>`);
-        break;
-      case "emboss":
-        markParts.push("<w:emboss/>");
-        break;
-      case "imprint":
-        markParts.push("<w:imprint/>");
-        break;
-      case "shadow":
-        markParts.push("<w:shadow/>");
-        break;
-      case "position":
-        markParts.push(`<w:position w:val="${mark.val}"/>`);
-        break;
-      case "textFill":
-        markParts.push(mark.xml);
-        break;
-      case "fontFamily":
-        markParts.push(`<w:rFonts w:ascii="${escapeXmlAttribute2(mark.val)}" w:hAnsi="${escapeXmlAttribute2(mark.val)}"/>`);
-        break;
-      case "fontSize":
-        markParts.push(`<w:sz w:val="${mark.val}"/>`);
-        break;
-      case "textColor":
-        markParts.push(`<w:color w:val="${escapeXmlAttribute2(mark.color)}"/>`);
-        break;
-      case "smallCaps":
-        markParts.push("<w:smallCaps/>");
-        break;
-      case "allCaps":
-        markParts.push("<w:caps/>");
-        break;
+  for (const type of orderedTypes) {
+    for (const mark of marks) {
+      if (mark.type !== type) continue;
+      const xml = serializeRunPropertyMark(mark);
+      if (xml) markParts.push(xml);
     }
   }
   const children = markParts.join("");
   return children.length > 0 ? `<w:rPr>${children}</w:rPr>` : "";
 }
+function serializeRunPropertyMark(mark) {
+  switch (mark.type) {
+    case "bold":
+      return "<w:b/>";
+    case "italic":
+      return "<w:i/>";
+    case "underline":
+      return `<w:u w:val="single"/>`;
+    case "strikethrough":
+      return "<w:strike/>";
+    case "doubleStrikethrough":
+      return "<w:dstrike/>";
+    case "vanish":
+      return "<w:vanish/>";
+    case "lang":
+      return `<w:lang w:val="${escapeXmlAttribute2(mark.val)}"/>`;
+    case "highlight":
+      return `<w:highlight w:val="${escapeXmlAttribute2(mark.val)}"/>`;
+    case "backgroundColor":
+      return `<w:shd w:val="clear" w:color="auto" w:fill="${escapeXmlAttribute2(mark.color)}"/>`;
+    case "charSpacing":
+      return `<w:spacing w:val="${mark.val}"/>`;
+    case "kerning":
+      return `<w:kern w:val="${mark.val}"/>`;
+    case "emboss":
+      return "<w:emboss/>";
+    case "imprint":
+      return "<w:imprint/>";
+    case "shadow":
+      return "<w:shadow/>";
+    case "position":
+      return `<w:position w:val="${mark.val}"/>`;
+    case "textFill":
+      return mark.xml;
+    case "fontFamily":
+      return `<w:rFonts w:ascii="${escapeXmlAttribute2(mark.val)}" w:hAnsi="${escapeXmlAttribute2(mark.val)}"/>`;
+    case "fontSize":
+      return `<w:sz w:val="${mark.val}"/>`;
+    case "textColor":
+      return `<w:color w:val="${escapeXmlAttribute2(mark.color)}"/>`;
+    case "smallCaps":
+      return "<w:smallCaps/>";
+    case "allCaps":
+      return "<w:caps/>";
+  }
+}
 function requiresPreservedSpace(text) {
   return /^\s/.test(text) || /\s$/.test(text) || text.includes("  ");
 }
@@ -46755,6 +47945,12 @@ function resolveScopeRange(entry, handle, positionMap) {
       if (inlineRange) return inlineRange;
       return positionMap.blocks.get(entry.blockIndex) ?? null;
     }
+    case "image": {
+      const key = `${entry.blockIndex}:${entry.inlineIndex}`;
+      const inlineRange = positionMap.inlines.get(key);
+      if (inlineRange) return inlineRange;
+      return positionMap.blocks.get(entry.blockIndex) ?? null;
+    }
     case "comment-thread":
       return anchorToRange(entry.thread.anchor);
     case "revision":
@@ -46893,6 +48089,11 @@ function deriveReplaceability(kind, provenance) {
         level: "preserve-only",
         reason: "field-result-is-computed-preserve-only"
       };
+    case "image":
+      return {
+        level: "preserve-only",
+        reason: "image-object-command-required"
+      };
     case "comment-thread":
       return {
         level: "preserve-only",
@@ -47597,6 +48798,55 @@ function compileHeadingScope(entry, options = {}) {
   };
 }
 
+// src/runtime/scopes/scope-kinds/image.ts
+function imageAltText(image) {
+  if (image.type === "image") return image.altText ?? "";
+  return image.anchor.docPr?.descr ?? image.anchor.docPr?.name ?? "";
+}
+function imageMediaId(image) {
+  if (image.type === "image") return image.mediaId;
+  return image.content.type === "picture" ? image.content.mediaId : void 0;
+}
+function imageDisplay(image) {
+  if (image.type === "image") return image.display;
+  return image.anchor.display;
+}
+function imageSourceKind(image) {
+  return image.type === "image" ? "legacy-image" : "drawing-picture";
+}
+function compileImageScope(entry) {
+  const { handle, image } = entry;
+  const altText = imageAltText(image);
+  const mediaId = imageMediaId(image);
+  const display = imageDisplay(image);
+  const sourceKind = imageSourceKind(image);
+  return {
+    handle,
+    kind: "image",
+    classifications: entry.classifications,
+    content: {
+      text: altText,
+      excerpt: buildExcerpt(altText),
+      authority: "structural-summary"
+    },
+    formatting: {},
+    layout: display ? { flowKind: display } : {},
+    geometry: {},
+    workflow: { scopeIds: [], effectiveMode: "edit" },
+    replaceability: deriveReplaceability("image", handle.provenance),
+    audit: {
+      source: "runtime",
+      derivedFrom: [
+        "canonical",
+        `image-source:${sourceKind}`,
+        ...mediaId ? [`media-id:${mediaId}`] : []
+      ],
+      confidence: "medium"
+    },
+    partial: true
+  };
+}
+
 // src/runtime/scopes/scope-kinds/list-item.ts
 function compileListItemScope(entry, options = {}) {
   const { handle, paragraph } = entry;
@@ -48185,6 +49435,8 @@ function compileScope(entry, optionsOrCatalog) {
       });
     case "field":
       return compileFieldScope(entry);
+    case "image":
+      return compileImageScope(entry);
     case "comment-thread":
       return compileCommentThreadScope(entry);
     case "revision":
@@ -48373,6 +49625,44 @@ function enumerateFieldsInParagraph(paragraph, blockIndex, documentId, parentSco
   }
   return out;
 }
+function isImageInline(child) {
+  return child.type === "image" || child.type === "drawing_frame" && child.content.type === "picture";
+}
+function enumerateImagesInParagraph(paragraph, blockIndex, documentId, parentScopeId) {
+  const out = [];
+  for (let i = 0; i < paragraph.children.length; i += 1) {
+    const child = paragraph.children[i];
+    if (!isImageInline(child)) continue;
+    const semanticPath = [
+      "body",
+      "paragraph",
+      String(blockIndex),
+      "image",
+      String(i)
+    ];
+    const scopeId = `image:${blockIndex}:${i}`;
+    const handle = {
+      scopeId,
+      documentId,
+      storyTarget: MAIN_STORY2,
+      semanticPath,
+      parentScopeId,
+      stableRef: { kind: "semantic-path", value: semanticPath.join("/") },
+      provenance: "derived",
+      rangePrecision: "canonical"
+    };
+    out.push({
+      kind: "image",
+      handle,
+      image: child,
+      paragraph,
+      blockIndex,
+      inlineIndex: i,
+      classifications: Object.freeze([])
+    });
+  }
+  return out;
+}
 function enumerateCommentThreads(document2, documentId) {
   const review = document2.review;
   const comments = review?.comments;
@@ -48503,6 +49793,8 @@ function enumerateScopes(document2, inputs = {}) {
       });
       const fields = enumerateFieldsInParagraph(block, index, documentId, scopeId);
       for (const field of fields) results.push(field);
+      const images = enumerateImagesInParagraph(block, index, documentId, scopeId);
+      for (const image of images) results.push(image);
       continue;
     }
     if (block.type === "table") {
@@ -48892,6 +50184,15 @@ var LIST_TEXT_TARGET_KINDS = /* @__PURE__ */ new Set([
   "sdt-paragraph-text",
   "secondary-story-paragraph-text"
 ]);
+var OBJECT_COMMAND_INTENTS = /* @__PURE__ */ new Set([
+  "image-layout",
+  "image-frame",
+  "chart-edit",
+  "custom-xml-update",
+  "embedded-content-update",
+  "opaque-content-preserve",
+  "object-edit"
+]);
 function freezeList(values) {
   return Object.freeze([...values]);
 }
@@ -49436,6 +50737,35 @@ function listStructureCapability(scope, context) {
     ]
   );
 }
+function objectEditCapability(context) {
+  const objectTargets = (context?.editableTargets?.entries ?? []).filter(
+    (entry) => entry.kind === "object-anchor" || entry.kind === "custom-xml-content" || entry.kind === "opaque-content" || entry.commandFamily === "object" || entry.commandFamily === "preserve-only-refusal" || entry.runtimeCommand.intents.some((intent) => OBJECT_COMMAND_INTENTS.has(intent))
+  );
+  const supportedTargets = objectTargets.filter(
+    (entry) => entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.some((intent) => OBJECT_COMMAND_INTENTS.has(intent))
+  );
+  if (supportedTargets.length > 0) {
+    return supportedCommand(
+      "compile-supported:object-edit:editable-target",
+      supportedTargets
+    );
+  }
+  if (objectTargets.length > 0) {
+    const blockers = commandTargetBlockers(objectTargets);
+    return blocked(
+      "compile-blocked:object-edit:target-ref-blocked",
+      blockers.length > 0 ? blockers : ["compile-blocked:object-edit:target-ref-blocked"]
+    );
+  }
+  return unsupported(
+    "compile-unsupported:object-edit:no-target-family",
+    [
+      "compile-unsupported:object-edit:no-target-family",
+      "capability:object-edit:l02-object-target-required",
+      "capability:object-edit:l07-command-support-required"
+    ]
+  );
+}
 function deriveScopeCapabilities(scope, context = {}) {
   return {
     canReplaceText: replaceTextCapability(scope, context),
@@ -49452,7 +50782,8 @@ function deriveScopeCapabilities(scope, context = {}) {
     canEditTableStructure: tableStructureCapability(scope, context),
     canUseTableContinuationEvidence: tableContinuationEvidenceCapability(scope, context),
     canEditListText: listTextCapability(scope, context),
-    canEditListStructure: listStructureCapability(scope, context)
+    canEditListStructure: listStructureCapability(scope, context),
+    canEditObject: objectEditCapability(context)
   };
 }
 
@@ -49724,6 +51055,11 @@ function tokensForScope(entry) {
         { kind: "row", index: entry.rowIndex },
         { kind: "cell", index: entry.cellIndex }
       ]);
+    case "image":
+      return Object.freeze([
+        { kind: "block", index: entry.blockIndex },
+        { kind: "inline", index: entry.inlineIndex }
+      ]);
     default:
       return null;
   }
@@ -49807,6 +51143,19 @@ function paragraphHasBookmarkId(paragraph, bookmarkId) {
 function commandActionHandleForAddress(commandFamily, address) {
   return address ? `scope-command:${commandFamily}:${address.addressKey}` : void 0;
 }
+function layoutIdentityIndexes(document2) {
+  const byTargetKey = /* @__PURE__ */ new Map();
+  const byStoryBlockPath = /* @__PURE__ */ new Map();
+  for (const identity of collectLayoutInputIdentities(document2)) {
+    byStoryBlockPath.set(`${identity.storyKey}:${identity.blockPath}`, identity);
+    const targetKey = identity.editableTargetRef?.targetKey;
+    if (targetKey) byTargetKey.set(targetKey, identity);
+  }
+  return { byTargetKey, byStoryBlockPath };
+}
+function layoutIdentityForTarget(target, indexes) {
+  return indexes.byTargetKey.get(target.targetKey) ?? indexes.byStoryBlockPath.get(`${target.storyKey}:${target.blockPath}`);
+}
 function withCommandAction(evidence, target, canonicalAddress = target.canonicalAddress) {
   if (evidence.status !== "supported" || !canonicalAddress) return evidence;
   return {
@@ -49818,6 +51167,24 @@ function withCommandAction(evidence, target, canonicalAddress = target.canonical
 function commandAddressForTarget(target, scopeKind) {
   return scopeKind === "list-item" && target.listAddress !== void 0 ? target.listAddress : target.canonicalAddress;
 }
+function freezeCommandIntents(intents) {
+  return Object.freeze([...new Set(intents)]);
+}
+function relatedListActionHandlesForTarget(target, primaryAddress) {
+  if (target.commandFamily !== "text-leaf" || target.listAddress === void 0 || !LIST_TEXT_TARGET_KINDS2.has(target.kind) || target.listAddress.addressKey === primaryAddress?.addressKey) {
+    return void 0;
+  }
+  const actionHandle = commandActionHandleForAddress(target.commandFamily, target.listAddress);
+  if (!actionHandle) return void 0;
+  return Object.freeze([
+    {
+      actionHandle,
+      canonicalAddress: target.listAddress,
+      intents: freezeCommandIntents(["list-text-edit", "list-structure-action"]),
+      reason: "l07:list-address-target-supported"
+    }
+  ]);
+}
 function runtimeTextCommandEvidence(target, workflowBlockers) {
   const shapeIssues = validateEditableTargetRef(target);
   if (shapeIssues.length > 0) {
@@ -49917,13 +51284,16 @@ function runtimeCommandEvidence(target, workflowBlockers, textCommand, scopeKind
     };
   }
   if (target.commandFamily === "text-leaf") {
+    const canonicalAddress = commandAddressForTarget(target, scopeKind);
+    const relatedActionHandles = relatedListActionHandlesForTarget(target, canonicalAddress);
     return withCommandAction({
       status: textCommand.status,
       commandFamily: target.commandFamily,
       intents: commandIntentsForTarget(target, scopeKind),
       reason: textCommand.reason,
+      ...relatedActionHandles !== void 0 ? { relatedActionHandles } : {},
       ...textCommand.blockers ? { blockers: textCommand.blockers } : {}
-    }, target, commandAddressForTarget(target, scopeKind));
+    }, target, canonicalAddress);
   }
   if (target.commandFamily === "comment-revision") {
     const isOpen = target.review?.status === "open";
@@ -50248,19 +51618,21 @@ function commandIntentsForTarget(target, scopeKind) {
       if (target.kind === "hyperlink-text") {
         return Object.freeze(["text-leaf-edit", "hyperlink-display-text-edit"]);
       }
-      if (target.table?.operationScope === "text") {
-        return Object.freeze([
-          "text-leaf-edit",
-          "table-text-paste",
-          "table-text-drop",
-          "table-structured-fragment-paste",
-          "table-structured-fragment-drop"
-        ]);
-      }
-      if (scopeKind === "list-item" && LIST_TEXT_TARGET_KINDS2.has(target.kind)) {
-        return Object.freeze(["text-leaf-edit", "list-text-edit", "list-structure-action"]);
+      {
+        const intents = ["text-leaf-edit"];
+        if (target.table?.operationScope === "text") {
+          intents.push(
+            "table-text-paste",
+            "table-text-drop",
+            "table-structured-fragment-paste",
+            "table-structured-fragment-drop"
+          );
+        }
+        if ((scopeKind === "list-item" || target.listAddress !== void 0) && LIST_TEXT_TARGET_KINDS2.has(target.kind)) {
+          intents.push("list-text-edit", "list-structure-action");
+        }
+        return freezeCommandIntents(intents);
       }
-      return Object.freeze(["text-leaf-edit"]);
     case "field":
       return Object.freeze(
         target.field?.fieldFamily === "TOC" ? ["toc-refresh", "field-update"] : ["field-update"]
@@ -50407,7 +51779,7 @@ function readbackForTarget(document2, target, runtimeTextCommand) {
     source: "canonical-text-leaf"
   };
 }
-function projectTarget(document2, target, relation, workflowBlockers, scopeKind) {
+function projectTarget(document2, target, relation, workflowBlockers, scopeKind, layoutIdentity) {
   const runtimeTextCommand = runtimeTextCommandEvidence(target, workflowBlockers);
   const readback = readbackForTarget(document2, target, runtimeTextCommand);
   return {
@@ -50428,6 +51800,7 @@ function projectTarget(document2, target, relation, workflowBlockers, scopeKind)
     ...target.table ? { table: target.table } : {},
     ...target.editableOwner ? { editableOwner: target.editableOwner } : {},
     ...target.canonicalAddress ? { canonicalAddress: target.canonicalAddress } : {},
+    ...layoutIdentity ? { layoutIdentity } : {},
     staleCheck: target.staleCheck,
     posture: target.posture,
     ...workflowBlockers.length > 0 ? { workflowBlockers: Object.freeze([...workflowBlockers]) } : {},
@@ -50443,7 +51816,7 @@ function deriveScopeEditableTargetEvidence(document2, scope, entry, options = {}
     facts.push(projectWorkflowBlockerFact(fact));
     factsByTargetKey.set(fact.targetKey, facts);
   }
-  const entries = collectEditableTargetRefs(document2, options.editableTargetCache).map((target) => {
+  const relatedTargets = collectEditableTargetRefs(document2, options.editableTargetCache).map((target) => {
     const relation = relationForTarget(target, scope, entry);
     if (!relation) return null;
     const workflowBlockers = Object.freeze(
@@ -50451,8 +51824,19 @@ function deriveScopeEditableTargetEvidence(document2, scope, entry, options = {}
         (left, right) => left.source.localeCompare(right.source) || left.blocker.localeCompare(right.blocker) || left.refusalId.localeCompare(right.refusalId)
       )
     );
-    return projectTarget(document2, target, relation, workflowBlockers, scope.kind);
-  }).filter((target) => target !== null).sort((a, b) => a.targetKey.localeCompare(b.targetKey));
+    return { target, relation, workflowBlockers };
+  }).filter((target) => target !== null);
+  const layoutIndexes = relatedTargets.length > 0 ? layoutIdentityIndexes(document2) : void 0;
+  const entries = relatedTargets.map(
+    ({ target, relation, workflowBlockers }) => projectTarget(
+      document2,
+      target,
+      relation,
+      workflowBlockers,
+      scope.kind,
+      layoutIndexes ? layoutIdentityForTarget(target, layoutIndexes) : void 0
+    )
+  ).sort((a, b) => a.targetKey.localeCompare(b.targetKey));
   const blockers = /* @__PURE__ */ new Set();
   let supportedTextTargetCount = 0;
   for (const target of entries) {
@@ -50471,6 +51855,114 @@ function deriveScopeEditableTargetEvidence(document2, scope, entry, options = {}
   };
 }
 
+// src/runtime/scopes/object-evidence.ts
+var OBJECT_INTENTS = /* @__PURE__ */ new Set([
+  "image-layout",
+  "image-frame",
+  "chart-edit",
+  "custom-xml-update",
+  "embedded-content-update",
+  "opaque-content-preserve",
+  "object-edit",
+  "preserve-only-refusal"
+]);
+function unique2(values) {
+  return Object.freeze([...new Set(values.filter((value) => value.length > 0))]);
+}
+function isObjectTarget(entry) {
+  return entry.object !== void 0 || entry.kind === "object-anchor" || entry.kind === "custom-xml-content" || entry.kind === "opaque-content" || entry.commandFamily === "object" || entry.runtimeCommand.intents.some((intent) => OBJECT_INTENTS.has(intent));
+}
+function blockersFor(entry) {
+  return unique2([
+    ...entry.posture.blockers,
+    ...entry.runtimeCommand.blockers ?? [],
+    ...entry.runtimeTextCommand.blockers ?? [],
+    ...(entry.workflowBlockers ?? []).flatMap((blocker2) => [
+      blocker2.blocker,
+      blocker2.refusalId
+    ]),
+    entry.runtimeCommand.status === "blocked" ? entry.runtimeCommand.reason : ""
+  ]);
+}
+function projectEntry2(entry) {
+  const blockers = blockersFor(entry);
+  return {
+    targetKey: entry.targetKey,
+    kind: entry.kind,
+    ...entry.object?.objectKind ? { objectKind: entry.object.objectKind } : {},
+    relation: entry.relation,
+    commandFamily: entry.commandFamily,
+    editability: entry.editability,
+    ...entry.sourceRef ? { sourceRef: entry.sourceRef } : {},
+    ...entry.object ? { object: entry.object } : {},
+    runtimeCommand: entry.runtimeCommand,
+    blockers,
+    ...entry.posture.preserveOnly ? { preserveOnly: true } : {}
+  };
+}
+function familyKindFor(entry) {
+  return entry.objectKind ?? "unknown";
+}
+function familyStatusFor(entries) {
+  if (entries.some((entry) => entry.runtimeCommand.status === "supported")) {
+    return "supported";
+  }
+  if (entries.length > 0 && entries.every(
+    (entry) => entry.preserveOnly === true || entry.commandFamily === "preserve-only-refusal"
+  )) {
+    return "preserve-only";
+  }
+  return "blocked";
+}
+function summarizeFamily(objectKind, entries) {
+  const sortedEntries = [...entries].sort(
+    (left, right) => left.targetKey.localeCompare(right.targetKey)
+  );
+  const preserveOnly = sortedEntries.some((entry) => entry.preserveOnly === true);
+  return {
+    objectKind,
+    status: familyStatusFor(sortedEntries),
+    count: sortedEntries.length,
+    targetKeys: unique2(sortedEntries.map((entry) => entry.targetKey)),
+    relations: unique2(sortedEntries.map((entry) => entry.relation)),
+    commandFamilies: unique2(sortedEntries.map((entry) => entry.commandFamily)),
+    runtimeIntents: unique2(
+      sortedEntries.flatMap((entry) => [...entry.runtimeCommand.intents])
+    ),
+    blockers: unique2(sortedEntries.flatMap((entry) => [...entry.blockers])),
+    ...preserveOnly ? { preserveOnly: true } : {}
+  };
+}
+function summarizeFamilies(entries) {
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const objectKind = familyKindFor(entry);
+    const bucket = byFamily.get(objectKind);
+    if (bucket) {
+      bucket.push(entry);
+      continue;
+    }
+    byFamily.set(objectKind, [entry]);
+  }
+  return Object.freeze(
+    [...byFamily.entries()].map(([objectKind, familyEntries]) => summarizeFamily(objectKind, familyEntries)).sort((left, right) => left.objectKind.localeCompare(right.objectKind))
+  );
+}
+function deriveScopeObjectEvidence(editableTargets) {
+  const entries = Object.freeze(
+    [...editableTargets?.entries ?? []].filter(isObjectTarget).map(projectEntry2).sort((left, right) => left.targetKey.localeCompare(right.targetKey))
+  );
+  const blockers = unique2(entries.flatMap((entry) => [...entry.blockers]));
+  const families = summarizeFamilies(entries);
+  return {
+    status: entries.length > 0 ? "present" : "none",
+    count: entries.length,
+    blockers,
+    families,
+    entries
+  };
+}
+
 // src/runtime/scopes/table-evidence.ts
 function isTableFamilyEntry(entry) {
   return entry?.kind === "table" || entry?.kind === "table-row" || entry?.kind === "table-cell";
@@ -51040,7 +52532,7 @@ function deriveScopeGeometryEvidence(scopeId, provider, context) {
 function freezeList2(values) {
   return values ? Object.freeze([...values]) : void 0;
 }
-function unique2(values) {
+function unique3(values) {
   return Object.freeze([...new Set(values)]);
 }
 function parseTableFamilyScopeId2(scopeId) {
@@ -51070,7 +52562,7 @@ function candidateTableBlockIds(blockIndex, mapped) {
   const mappedId = mapped?.get(blockIndex);
   if (mappedId) ids.push(mappedId);
   ids.push(`table-${blockIndex}`, `table:${blockIndex}`, `block-${blockIndex}`);
-  return unique2(ids);
+  return unique3(ids);
 }
 function rowInFragment(fragment, rowIndex) {
   const range = fragment.tableRowRange;
@@ -51107,19 +52599,19 @@ function projectTableFramePage(fragment) {
     ...fragment.tableRowRange ? { rowRange: { ...fragment.tableRowRange } } : {},
     ...fragment.continuation?.continuesFromPreviousPage !== void 0 ? { continuesFromPreviousPage: fragment.continuation.continuesFromPreviousPage } : {},
     ...fragment.continuation?.continuesToNextPage !== void 0 ? { continuesToNextPage: fragment.continuation.continuesToNextPage } : {},
-    ...repeated ? { repeatedHeaderRowIndexes: unique2(repeated) } : {},
+    ...repeated ? { repeatedHeaderRowIndexes: unique3(repeated) } : {},
     ...splitRowCarry ? { splitRowCarry: Object.freeze(splitRowCarry.map((item) => ({ ...item }))) } : {},
     ...carry ? { verticalMergeCarry: Object.freeze(carry.map((item) => ({ ...item }))) } : {}
   };
 }
 function projectTableFrame(blockId, parsed, fragments) {
-  const pageIds = unique2(fragments.map((fragment) => fragment.pageId));
-  const pageSliceIds = unique2(fragments.map((fragment) => fragment.fragmentId));
-  const layoutObjectIds = unique2(
+  const pageIds = unique3(fragments.map((fragment) => fragment.pageId));
+  const pageSliceIds = unique3(fragments.map((fragment) => fragment.fragmentId));
+  const layoutObjectIds = unique3(
     fragments.map((fragment) => fragment.layoutObject?.objectId).filter((objectId) => typeof objectId === "string" && objectId.length > 0)
   );
   const rowRangesByPage = Object.freeze(fragments.map(projectTableFramePage));
-  const repeatedHeaderRowIndexes = unique2(
+  const repeatedHeaderRowIndexes = unique3(
     fragments.flatMap((fragment) => fragment.continuation?.repeatedHeaderRowIndexes ?? [])
   );
   const verticalMergeCarry = Object.freeze(
@@ -51144,7 +52636,7 @@ function projectTableFrame(blockId, parsed, fragments) {
   };
 }
 function continuationFromTableFrame(fragments) {
-  const pageIds = unique2(fragments.map((fragment) => fragment.pageId));
+  const pageIds = unique3(fragments.map((fragment) => fragment.pageId));
   return {
     ...pageIds.length > 0 ? { pageIds } : {},
     pageCount: pageIds.length,
@@ -51442,6 +52934,7 @@ function composeEvidence(inputs) {
     ...editableTargets ? { editableTargets } : {},
     layout
   });
+  const objects = deriveScopeObjectEvidence(editableTargets);
   return {
     formattingSummary: formattingSummaryOf(scope),
     reviewItemIds,
@@ -51452,6 +52945,7 @@ function composeEvidence(inputs) {
     ...adjacentGeometry ? { adjacentGeometry } : {},
     visualization: deriveScopeVisualization(scope),
     ...editableTargets ? { editableTargets } : {},
+    objects,
     ...table ? { table } : {},
     contentControls,
     capabilities,
@@ -58679,7 +60173,7 @@ function shouldYield(scheduler, lastYieldAt) {
   const deadline = scheduler.frameDeadlineMs ?? DEFAULT_FRAME_DEADLINE_MS;
   return now3 - lastYieldAt >= deadline;
 }
-function nowMs() {
+function nowMs2() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 function createLoadScheduler(options = {}) {
@@ -59247,8 +60741,7 @@ 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_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 FLD_SIMPLE_INSTR_RE = /<(?:\w+:)?fldSimple\b[^>]*\bw:instr\s*=\s*(["'])([\s\S]*?)\1/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;
@@ -59267,21 +60760,14 @@ function scanBookmarkReferences(documentXml, callerAllowlist = []) {
   }
   INSTR_TEXT_RE.lastIndex = 0;
   while ((m = INSTR_TEXT_RE.exec(documentXml)) !== null) {
-    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;
+    retainInstructionReferences(m[1] ?? "", retained, (value) => {
+      retainAllToc = retainAllToc || value;
     });
   }
-  FLD_SIMPLE_INSTR_SINGLE_RE.lastIndex = 0;
-  while ((m = FLD_SIMPLE_INSTR_SINGLE_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) {
+    retainInstructionReferences(m[2] ?? "", retained, (value) => {
+      retainAllToc = retainAllToc || value;
     });
   }
   retainRevisionBoundedBookmarks(documentXml, retained);
@@ -59291,17 +60777,14 @@ function scanBookmarkReferences(documentXml, callerAllowlist = []) {
     retainAll
   };
 }
-function scanFieldInstruction(instrText, retained, retainToc) {
-  if (TOC_FIELD_RE.test(instrText)) retainToc();
+function retainInstructionReferences(instrText, retained, setRetainAllToc) {
+  if (TOC_FIELD_RE.test(instrText)) setRetainAllToc(true);
   REFLIKE_FIELD_RE.lastIndex = 0;
   let r;
   while ((r = REFLIKE_FIELD_RE.exec(instrText)) !== null) {
     if (r[1]) retained.add(r[1]);
   }
 }
-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();
   BOOKMARK_START_RE.lastIndex = 0;
@@ -59690,7 +61173,7 @@ function parseNumberingXml(xml, context) {
         abstractDefinitions[abstractNumberingId] = {
           abstractNumberingId,
           ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "abstractNum", rawId, childXmlPath) } : {},
-          levels: readLevels(child),
+          levels: readLevels(child, context, childXmlPath, rawId),
           ...nsid ? { nsid } : {},
           ...multiLevelType ? { multiLevelType } : {},
           ...tplc ? { tplc } : {},
@@ -59711,7 +61194,7 @@ function parseNumberingXml(xml, context) {
           numberingInstanceId,
           ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "num", rawId, childXmlPath) } : {},
           abstractNumberingId: toCanonicalAbstractNumberingId(rawAbstractId),
-          overrides: readOverrides(child)
+          overrides: readOverrides(child, context, childXmlPath, rawId)
         };
         break;
       }
@@ -59732,6 +61215,16 @@ function createNumberingSourceRef(partPath, element, rawId, xmlPath) {
     ...xmlPath !== void 0 ? { xmlPath } : {}
   };
 }
+function createNumberingChildSourceRef(partPath, element, sourceIdSuffix, xmlPath) {
+  if (partPath === void 0) return void 0;
+  return {
+    sourceId: `part:${partPath}#${sourceIdSuffix}`,
+    partPath,
+    storyKind: "numbering",
+    element,
+    ...xmlPath !== void 0 ? { xmlPath } : {}
+  };
+}
 function readNumPicBullet(node, numPicBulletId, context, xmlPath) {
   let widthEmu;
   let heightEmu;
@@ -59808,18 +61301,29 @@ function toCanonicalAbstractNumberingId(value) {
 function toCanonicalNumberingInstanceId(value) {
   return value.startsWith("num:") ? value : `num:${value}`;
 }
-function readLevels(abstractNode) {
+function readLevels(abstractNode, context, abstractXmlPath, rawAbstractId) {
   const levels = [];
+  let levelOrdinal = 0;
   for (const child of abstractNode.children) {
     if (child.type !== "element" || localName(child.name) !== "lvl") {
       continue;
     }
+    levelOrdinal += 1;
     const rawLevel = readStringAttr(child, "w:ilvl");
     const level = rawLevel === void 0 ? void 0 : parseInteger(rawLevel);
     if (level === void 0) {
       continue;
     }
-    const definition = readLevelDefinition(child, level);
+    const definition = readLevelDefinition(
+      child,
+      level,
+      createNumberingChildSourceRef(
+        context?.partPath,
+        "lvl",
+        `abstractNum:${rawAbstractId}:lvl:${level}`,
+        `${abstractXmlPath}/lvl[${levelOrdinal}]`
+      )
+    );
     if (!definition) {
       continue;
     }
@@ -59827,12 +61331,14 @@ function readLevels(abstractNode) {
   }
   return levels.sort((left, right) => left.level - right.level);
 }
-function readOverrides(numNode) {
+function readOverrides(numNode, context, numXmlPath, rawNumId) {
   const overrides = [];
+  let overrideOrdinal = 0;
   for (const child of numNode.children) {
     if (child.type !== "element" || localName(child.name) !== "lvlOverride") {
       continue;
     }
+    overrideOrdinal += 1;
     const rawLevel = readStringAttr(child, "w:ilvl");
     const level = rawLevel === void 0 ? void 0 : parseInteger(rawLevel);
     if (level === void 0) {
@@ -59842,8 +61348,26 @@ function readOverrides(numNode) {
     const rawStart = startOverrideNode ? readStringAttr(startOverrideNode, "w:val") : void 0;
     const startAt = rawStart === void 0 ? void 0 : parseInteger(rawStart);
     const levelDefinitionNode = findChildElementOptional(child, "lvl");
-    const levelDefinition = levelDefinitionNode ? readLevelOverrideDefinition(levelDefinitionNode, level) : void 0;
+    const overrideXmlPath = `${numXmlPath}/lvlOverride[${overrideOrdinal}]`;
+    const levelDefinition = levelDefinitionNode ? readLevelOverrideDefinition(
+      levelDefinitionNode,
+      level,
+      createNumberingChildSourceRef(
+        context?.partPath,
+        "lvl",
+        `num:${rawNumId}:lvlOverride:${level}:lvl`,
+        `${overrideXmlPath}/lvl[1]`
+      )
+    ) : void 0;
     overrides.push({
+      ...context?.partPath !== void 0 ? {
+        sourceRef: createNumberingChildSourceRef(
+          context.partPath,
+          "lvlOverride",
+          `num:${rawNumId}:lvlOverride:${level}`,
+          overrideXmlPath
+        )
+      } : {},
       level,
       ...startAt !== void 0 ? { startAt } : {},
       ...levelDefinition ? { levelDefinition } : {}
@@ -59851,7 +61375,7 @@ function readOverrides(numNode) {
   }
   return overrides.sort((left, right) => left.level - right.level);
 }
-function readLevelDefinition(levelNode, fallbackLevel) {
+function readLevelDefinition(levelNode, fallbackLevel, sourceRef) {
   const rawLevel = readStringAttr(levelNode, "w:ilvl");
   const level = rawLevel === void 0 ? fallbackLevel : parseInteger(rawLevel);
   if (level === void 0) {
@@ -59881,6 +61405,7 @@ function readLevelDefinition(levelNode, fallbackLevel) {
   const lvlPicBulletNode = findChildElementOptional(levelNode, "lvlPicBulletId");
   const picBulletId = lvlPicBulletNode ? readStringAttr(lvlPicBulletNode, "w:val") : void 0;
   return {
+    ...sourceRef ? { sourceRef } : {},
     level,
     format,
     text,
@@ -59894,7 +61419,7 @@ function readLevelDefinition(levelNode, fallbackLevel) {
     ...picBulletId !== void 0 ? { picBulletId } : {}
   };
 }
-function readLevelOverrideDefinition(levelNode, fallbackLevel) {
+function readLevelOverrideDefinition(levelNode, fallbackLevel, sourceRef) {
   const rawLevel = readStringAttr(levelNode, "w:ilvl");
   const level = rawLevel === void 0 ? fallbackLevel : parseInteger(rawLevel);
   if (level === void 0) {
@@ -59928,6 +61453,7 @@ function readLevelOverrideDefinition(levelNode, fallbackLevel) {
     return void 0;
   }
   return {
+    ...sourceRef ? { sourceRef } : {},
     level,
     ...startAt !== void 0 ? { startAt } : {},
     ...format !== void 0 ? { format } : {},
@@ -66121,7 +67647,7 @@ async function normalizeParsedTextDocumentAsync(document2, packagePartName = "/w
   };
   const children = [];
   let previousParagraph = false;
-  let lastYieldAt = nowMs();
+  let lastYieldAt = nowMs2();
   for (let i = 0; i < document2.blocks.length; i += 1) {
     const block = document2.blocks[i];
     const normalizedBlocks = normalizeBlocks(block, state, packagePartName);
@@ -66134,7 +67660,7 @@ async function normalizeParsedTextDocumentAsync(document2, packagePartName = "/w
     }
     if (i > 0 && i % NORMALIZE_YIELD_STRIDE === 0 && shouldYield(scheduler, lastYieldAt)) {
       await scheduler.yield();
-      lastYieldAt = nowMs();
+      lastYieldAt = nowMs2();
     }
   }
   const content = { type: "doc", children };
@@ -67505,8 +69031,6 @@ function sortJson2(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") {
@@ -67613,6 +69137,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;
@@ -67684,7 +69219,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");
@@ -68018,8 +69552,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]);
   }
@@ -68100,8 +69634,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") {
@@ -68176,6 +69714,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 {
@@ -68223,25 +69789,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,
@@ -69205,7 +70772,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, document2, storyTarget) {
     const resolution = resolveEditableTableStructureTarget({
       document: document2,
@@ -69302,13 +70871,12 @@ function createDocumentRuntime(options) {
     if (!command.editableTarget) {
       return { kind: "accepted", selection };
     }
-    const preserveCallerSelection = command.editableTarget.listAddress?.operationScope === "list-text";
     const resolution = resolveEditableTextTarget({
       document: document2,
       surface,
       target: command.editableTarget,
       activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
-      ...preserveCallerSelection ? { selection } : {},
+      selection,
       editableTargetCache: editableTargetBlockCache
     });
     if (resolution.kind === "rejected") {
@@ -69326,7 +70894,7 @@ function createDocumentRuntime(options) {
     }
     return {
       kind: "accepted",
-      selection: preserveCallerSelection ? selection : createSelectionSnapshot(resolution.range.from, resolution.range.to),
+      selection,
       ...resolution.textTarget ? { textTarget: resolution.textTarget } : {}
     };
   }
@@ -70502,12 +72070,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,
@@ -70519,6 +72098,12 @@ function createDocumentRuntime(options) {
             }
           ]
         };
+        hotEditTraces.complete(pendingHotEditTrace, {
+          tier: "blocked",
+          patchMissReason: "participant-blocked",
+          counters: perfCounters
+        });
+        return ack;
       }
     },
     addComment(params) {
@@ -72294,6 +73879,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 ?? {};
@@ -75285,11 +76891,11 @@ function computeBaseDocFingerprint(envelope) {
     fieldRegistry: envelope.fieldRegistry,
     fontTable: envelope.fontTable
   };
-  const serialized = stableStringify3(subset);
+  const serialized = stableStringify5(subset);
   const bytes = new TextEncoder().encode(serialized);
   return sha256Hex3(bytes);
 }
-function stableStringify3(value) {
+function stableStringify5(value) {
   if (value === null) return "null";
   if (value === void 0) return "null";
   const t = typeof value;
@@ -75299,7 +76905,7 @@ function stableStringify3(value) {
   if (Array.isArray(value)) {
     const parts = [];
     for (const item of value) {
-      parts.push(item === void 0 ? "null" : stableStringify3(item));
+      parts.push(item === void 0 ? "null" : stableStringify5(item));
     }
     return "[" + parts.join(",") + "]";
   }
@@ -75314,7 +76920,7 @@ function stableStringify3(value) {
     keys.sort();
     const parts = [];
     for (const key of keys) {
-      parts.push(JSON.stringify(key) + ":" + stableStringify3(obj[key]));
+      parts.push(JSON.stringify(key) + ":" + stableStringify5(obj[key]));
     }
     return "{" + parts.join(",") + "}";
   }
@@ -80646,6 +82252,13 @@ function buildParagraphPropertiesXml2(paragraph) {
     const frameXml = buildFrameXml(paragraph.frameProperties);
     if (frameXml) parts.push(frameXml);
   }
+  if (paragraph.tabStops && paragraph.tabStops.length > 0) {
+    const tabsXml = paragraph.tabStops.map((tab) => {
+      const leaderAttr = tab.leader ? ` w:leader="${escapeXmlAttribute2(tab.leader)}"` : "";
+      return `<w:tab w:val="${escapeXmlAttribute2(tab.align)}" w:pos="${twip(tab.position)}"${leaderAttr}/>`;
+    }).join("");
+    parts.push(`<w:tabs>${tabsXml}</w:tabs>`);
+  }
   if (paragraph.spacing) {
     const s = paragraph.spacing;
     const attrs = [];
@@ -80667,13 +82280,6 @@ function buildParagraphPropertiesXml2(paragraph) {
   if (paragraph.alignment) {
     parts.push(`<w:jc w:val="${escapeXmlAttribute2(paragraph.alignment)}"/>`);
   }
-  if (paragraph.tabStops && paragraph.tabStops.length > 0) {
-    const tabsXml = paragraph.tabStops.map((tab) => {
-      const leaderAttr = tab.leader ? ` w:leader="${escapeXmlAttribute2(tab.leader)}"` : "";
-      return `<w:tab w:val="${tab.align}" w:pos="${twip(tab.position)}"${leaderAttr}/>`;
-    }).join("");
-    parts.push(`<w:tabs>${tabsXml}</w:tabs>`);
-  }
   return parts.length > 0 ? `<w:pPr>${parts.join("")}</w:pPr>` : "";
 }
 function serializeInlineNode2(node) {
@@ -80742,51 +82348,60 @@ function buildRunPropertiesXml2(marks) {
   if (!marks || marks.length === 0) {
     return "";
   }
+  const orderedTypes = [
+    "fontFamily",
+    "bold",
+    "italic",
+    "allCaps",
+    "smallCaps",
+    "strikethrough",
+    "doubleStrikethrough",
+    "textColor",
+    "fontSize",
+    "highlight",
+    "underline",
+    "backgroundColor"
+  ];
   const parts = [];
-  for (const mark of marks) {
-    switch (mark.type) {
-      case "bold":
-        parts.push("<w:b/>");
-        break;
-      case "italic":
-        parts.push("<w:i/>");
-        break;
-      case "underline":
-        parts.push('<w:u w:val="single"/>');
-        break;
-      case "strikethrough":
-        parts.push("<w:strike/>");
-        break;
-      case "doubleStrikethrough":
-        parts.push("<w:dstrike/>");
-        break;
-      case "fontFamily":
-        parts.push(`<w:rFonts w:ascii="${escapeXmlAttribute2(mark.val)}" w:hAnsi="${escapeXmlAttribute2(mark.val)}"/>`);
-        break;
-      case "fontSize":
-        parts.push(`<w:sz w:val="${twip(mark.val)}"/>`);
-        break;
-      case "textColor":
-        parts.push(`<w:color w:val="${escapeXmlAttribute2(mark.color)}"/>`);
-        break;
-      case "highlight":
-        parts.push(`<w:highlight w:val="${escapeXmlAttribute2(mark.val)}"/>`);
-        break;
-      case "backgroundColor":
-        parts.push(`<w:shd w:val="clear" w:color="auto" w:fill="${escapeXmlAttribute2(mark.color)}"/>`);
-        break;
-      case "smallCaps":
-        parts.push("<w:smallCaps/>");
-        break;
-      case "allCaps":
-        parts.push("<w:caps/>");
-        break;
-      default:
-        break;
+  for (const type of orderedTypes) {
+    for (const mark of marks) {
+      if (mark.type !== type) continue;
+      const xml = serializeRunPropertyMark2(mark);
+      if (xml) parts.push(xml);
     }
   }
   return parts.length > 0 ? `<w:rPr>${parts.join("")}</w:rPr>` : "";
 }
+function serializeRunPropertyMark2(mark) {
+  switch (mark.type) {
+    case "bold":
+      return "<w:b/>";
+    case "italic":
+      return "<w:i/>";
+    case "underline":
+      return `<w:u w:val="single"/>`;
+    case "strikethrough":
+      return "<w:strike/>";
+    case "doubleStrikethrough":
+      return "<w:dstrike/>";
+    case "fontFamily":
+      return `<w:rFonts w:ascii="${escapeXmlAttribute2(mark.val)}" w:hAnsi="${escapeXmlAttribute2(mark.val)}"/>`;
+    case "fontSize":
+      return `<w:sz w:val="${twip(mark.val)}"/>`;
+    case "textColor":
+      return `<w:color w:val="${escapeXmlAttribute2(mark.color)}"/>`;
+    case "highlight":
+      return `<w:highlight w:val="${escapeXmlAttribute2(mark.val)}"/>`;
+    case "backgroundColor":
+      return `<w:shd w:val="clear" w:color="auto" w:fill="${escapeXmlAttribute2(mark.color)}"/>`;
+    case "smallCaps":
+      return "<w:smallCaps/>";
+    case "allCaps":
+      return "<w:caps/>";
+    default:
+      return "";
+  }
+}
 function requiresPreservedSpace3(text) {
   return text.length > 0 && (text[0] === " " || text[text.length - 1] === " " || text.includes("  "));
 }
@@ -80960,9 +82575,6 @@ function buildParagraphPropertiesXml3(paragraph) {
     const frameXml = buildFrameXml(paragraph.frameProperties);
     if (frameXml) parts.push(frameXml);
   }
-  if (paragraph.alignment) {
-    parts.push(`<w:jc w:val="${escapeXmlAttribute2(paragraph.alignment)}"/>`);
-  }
   if (paragraph.spacing) {
     const attrs = [];
     if (paragraph.spacing.before !== void 0) attrs.push(`w:before="${twip(paragraph.spacing.before)}"`);
@@ -80983,6 +82595,9 @@ function buildParagraphPropertiesXml3(paragraph) {
       parts.push(`<w:ind ${attrs.join(" ")}/>`);
     }
   }
+  if (paragraph.alignment) {
+    parts.push(`<w:jc w:val="${escapeXmlAttribute2(paragraph.alignment)}"/>`);
+  }
   return parts.length > 0 ? `<w:pPr>${parts.join("")}</w:pPr>` : "";
 }
 function serializeInlineNode3(node) {
@@ -81043,47 +82658,59 @@ function buildRunPropertiesXml3(marks) {
   if (!marks || marks.length === 0) {
     return "";
   }
-  const parts = [];
+  const orderedTypes = [
+    "fontFamily",
+    "bold",
+    "italic",
+    "allCaps",
+    "smallCaps",
+    "strikethrough",
+    "doubleStrikethrough",
+    "textColor",
+    "fontSize",
+    "underline"
+  ];
+  const supportedTypes = new Set(orderedTypes);
   for (const mark of marks) {
-    switch (mark.type) {
-      case "bold":
-        parts.push("<w:b/>");
-        break;
-      case "italic":
-        parts.push("<w:i/>");
-        break;
-      case "underline":
-        parts.push('<w:u w:val="single"/>');
-        break;
-      case "strikethrough":
-        parts.push("<w:strike/>");
-        break;
-      case "doubleStrikethrough":
-        parts.push("<w:dstrike/>");
-        break;
-      case "fontFamily":
-        parts.push(
-          `<w:rFonts w:ascii="${escapeXmlAttribute2(mark.val)}" w:hAnsi="${escapeXmlAttribute2(mark.val)}"/>`
-        );
-        break;
-      case "fontSize":
-        parts.push(`<w:sz w:val="${twip(mark.val)}"/>`);
-        break;
-      case "textColor":
-        parts.push(`<w:color w:val="${escapeXmlAttribute2(mark.color)}"/>`);
-        break;
-      case "smallCaps":
-        parts.push("<w:smallCaps/>");
-        break;
-      case "allCaps":
-        parts.push("<w:caps/>");
-        break;
-      default:
-        throw new Error(`Cannot safely serialize ${mark.type} marks in note sub-parts.`);
+    if (!supportedTypes.has(mark.type)) {
+      throw new Error(`Cannot safely serialize ${mark.type} marks in note sub-parts.`);
+    }
+  }
+  const parts = [];
+  for (const type of orderedTypes) {
+    for (const mark of marks) {
+      if (mark.type !== type) continue;
+      parts.push(serializeRunPropertyMark3(mark));
     }
   }
   return parts.length > 0 ? `<w:rPr>${parts.join("")}</w:rPr>` : "";
 }
+function serializeRunPropertyMark3(mark) {
+  switch (mark.type) {
+    case "bold":
+      return "<w:b/>";
+    case "italic":
+      return "<w:i/>";
+    case "underline":
+      return `<w:u w:val="single"/>`;
+    case "strikethrough":
+      return "<w:strike/>";
+    case "doubleStrikethrough":
+      return "<w:dstrike/>";
+    case "fontFamily":
+      return `<w:rFonts w:ascii="${escapeXmlAttribute2(mark.val)}" w:hAnsi="${escapeXmlAttribute2(mark.val)}"/>`;
+    case "fontSize":
+      return `<w:sz w:val="${twip(mark.val)}"/>`;
+    case "textColor":
+      return `<w:color w:val="${escapeXmlAttribute2(mark.color)}"/>`;
+    case "smallCaps":
+      return "<w:smallCaps/>";
+    case "allCaps":
+      return "<w:caps/>";
+    default:
+      throw new Error(`Cannot safely serialize ${mark.type} marks in note sub-parts.`);
+  }
+}
 function compareNoteIds2(left, right) {
   return Number.parseInt(left.noteId, 10) - Number.parseInt(right.noteId, 10);
 }
@@ -88683,11 +90310,11 @@ function extractFilename2(target) {
 }
 function mintManifestId(partPath, relationshipId, size) {
   const material = `${partPath}
${relationshipId}
${size}`;
-  const a = fnv1a(material, 2166136261);
-  const b = fnv1a(material, 461845907);
+  const a = fnv1a3(material, 2166136261);
+  const b = fnv1a3(material, 461845907);
   return `emb:${toHex8(a)}${toHex8(b)}`;
 }
-function fnv1a(input, seed) {
+function fnv1a3(input, seed) {
   let hash = seed >>> 0;
   for (let i = 0; i < input.length; i++) {
     hash ^= input.charCodeAt(i);
@@ -91398,6 +93025,9 @@ function createLoadingDebugFacet() {
     },
     getChannels() {
       return bus.getChannels();
+    },
+    getHotEditTraces() {
+      return [];
     }
   };
 }
@@ -116085,6 +117715,16 @@ function resolveSelectionEditableTarget(anchorTarget, headTarget) {
   if (!anchorTarget || !headTarget) return void 0;
   return anchorTarget.targetKey === headTarget.targetKey ? anchorTarget : void 0;
 }
+function resolveCurrentEditableTarget(state, positionMap) {
+  if (!positionMap) return void 0;
+  if (state.selection instanceof import_prosemirror_state2.NodeSelection) {
+    return positionMap.pmToRuntimeWithContext(state.selection.from).editableTarget;
+  }
+  const { anchor, head } = state.selection;
+  const anchorContext = positionMap.pmToRuntimeWithContext(anchor);
+  const headContext = positionMap.pmToRuntimeWithContext(head);
+  return resolveSelectionEditableTarget(anchorContext.editableTarget, headContext.editableTarget);
+}
 function createCommandBridgePlugins(callbacks, options) {
   let isComposing = false;
   let pendingCompositionText = null;
@@ -116263,11 +117903,13 @@ function createCommandBridgePlugins(callbacks, options) {
         if (isComposing) return true;
         const dragEvent = event;
         resolveDropSelectionFromCoordinates(_view, dragEvent);
-        if (!isPmEditTargetEditable(_view.state, callbacks.getPositionMap())) {
+        const positionMap = callbacks.getPositionMap();
+        if (!isPmEditTargetEditable(_view.state, positionMap)) {
           callbacks.onBlockedInput?.("drop", NON_EDITABLE_INPUT_MESSAGE);
           dragSourceRange = null;
           return true;
         }
+        const editableTarget = resolveCurrentEditableTarget(_view.state, positionMap);
         const dt = dragEvent.dataTransfer;
         if (!dt) {
           callbacks.onBlockedInput?.("drop", "Drop data was not available.");
@@ -116284,6 +117926,7 @@ function createCommandBridgePlugins(callbacks, options) {
               callbacks.onDropFragment({
                 fragment: parsed.fragment,
                 effect,
+                ...editableTarget ? { editableTarget } : {},
                 ...sourceRange ? { sourceRange } : {}
               });
               dragSourceRange = null;
@@ -116414,7 +118057,7 @@ var import_prosemirror_view3 = require("prosemirror-view");
 
 // src/ui-tailwind/editor-surface/pm-decorations.ts
 var import_prosemirror_view2 = require("prosemirror-view");
-function nowMs2() {
+function nowMs3() {
   return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
 }
 function sanitizeRevisionAuthorColor(raw) {
@@ -116688,7 +118331,7 @@ function buildDecorations(doc, positionMap, commentModel, revisionModel, markupD
   const activeScopeIds = new Set(activeWorkflowScopeIds ?? []);
   const effectiveWorkflowScopes = workflowScopes ?? [];
   const lockedPmRanges = collectLockedPmRanges(workflowLockedZones, activeStory, positionMap);
-  const commentsStartMs = nowMs2();
+  const commentsStartMs = nowMs3();
   let commentCount = 0;
   if (commentModel) {
     for (const thread of commentModel.threads) {
@@ -116712,11 +118355,11 @@ function buildDecorations(doc, positionMap, commentModel, revisionModel, markupD
       }
     }
   }
-  recordPerfSample("pm.decorations.comments", nowMs2() - commentsStartMs);
+  recordPerfSample("pm.decorations.comments", nowMs3() - commentsStartMs);
   if (commentCount > 0) {
     incrementInvalidationCounter("pm.decorations.comments.count", commentCount);
   }
-  const revisionsStartMs = nowMs2();
+  const revisionsStartMs = nowMs3();
   let revisionCount = 0;
   if (revisionModel) {
     for (const rev of revisionModel.revisions) {
@@ -116825,11 +118468,11 @@ function buildDecorations(doc, positionMap, commentModel, revisionModel, markupD
       revisionCount += 1;
     }
   }
-  recordPerfSample("pm.decorations.revisions", nowMs2() - revisionsStartMs);
+  recordPerfSample("pm.decorations.revisions", nowMs3() - revisionsStartMs);
   if (revisionCount > 0) {
     incrementInvalidationCounter("pm.decorations.revisions.count", revisionCount);
   }
-  const workflowStartMs = nowMs2();
+  const workflowStartMs = nowMs3();
   const workflowDecorationsBefore = decorations.length;
   if (effectiveWorkflowScopes.length > 0) {
     for (const scope of effectiveWorkflowScopes) {
@@ -116947,7 +118590,7 @@ function buildDecorations(doc, positionMap, commentModel, revisionModel, markupD
       }, railRangeCache);
     }
   }
-  recordPerfSample("pm.decorations.workflow", nowMs2() - workflowStartMs);
+  recordPerfSample("pm.decorations.workflow", nowMs3() - workflowStartMs);
   const workflowDecorationCount = decorations.length - workflowDecorationsBefore;
   if (workflowDecorationCount > 0) {
     incrementInvalidationCounter(
@@ -117024,11 +118667,11 @@ function applyRuntimeDecorationInputs(view, inputs) {
   const tr = view.state.tr.setMeta(runtimeDecorationPluginKey, {
     inputs
   });
-  const startedAt = nowMs3();
+  const startedAt = nowMs4();
   view.dispatch(tr);
-  recordPerfSample("pm.decorations.apply", nowMs3() - startedAt);
+  recordPerfSample("pm.decorations.apply", nowMs4() - startedAt);
 }
-function nowMs3() {
+function nowMs4() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 
@@ -122818,6 +124461,7 @@ var LAYER_DEBUG_PANES = [
     snippets: [
       { label: "Selection context", expression: "ref?.getRuntimeContextAnalytics?.()" },
       { label: "Document context", expression: "ref?.getRuntimeContextAnalytics?.({ scopeKind: 'document' })" },
+      { label: "Hot edit trace", expression: "runtime?.debug?.getHotEditTraces?.().at(-1)" },
       { label: "View state", expression: "ref?.getViewState?.()" }
     ],
     routed: [
@@ -122874,6 +124518,7 @@ var LAYER_DEBUG_PANES = [
     snippets: [
       { label: "Navigation", expression: "ref?.getDocumentNavigationSnapshot?.()" },
       { label: "Review surface", expression: "({ comments: ref?.getCommentSidebarSnapshot?.(), changes: ref?.getTrackedChangesSnapshot?.() })" },
+      { label: "Hot edit traces", expression: "runtime?.debug?.getHotEditTraces?.()" },
       { label: "Compatibility", expression: "ref?.getCompatibilityReport?.()" }
     ],
     routed: [
@@ -124299,6 +125944,10 @@ function extractNLHaystack(entry) {
       }
       return out.slice(0, 200).toLowerCase();
     }
+    case "image": {
+      const text = entry.image.type === "image" ? entry.image.altText ?? "" : entry.image.anchor.docPr?.descr ?? entry.image.anchor.docPr?.name ?? "";
+      return text.slice(0, 200).toLowerCase();
+    }
     case "table":
     case "table-row":
     case "table-cell":
@@ -126134,6 +127783,391 @@ function createViewportFamily2(runtime) {
   };
 }
 
+// src/api/v3/runtime/lists.ts
+var SUPPORTED_COMMANDS = [
+  "toggle-numbered",
+  "toggle-bulleted",
+  "indent",
+  "outdent",
+  "restart-numbering",
+  "continue-numbering"
+];
+var UNSUPPORTED_COMMANDS = [
+  "create",
+  "attach",
+  "detach",
+  "join",
+  "separate",
+  "split",
+  "set-value",
+  "apply-template",
+  "capture-template",
+  "apply-preset",
+  "set-level-numbering",
+  "set-level-bullet",
+  "set-level-picture-bullet",
+  "set-level-alignment",
+  "set-level-indents",
+  "set-level-trailing-character",
+  "set-level-marker-font",
+  "set-level-text",
+  "set-level-start",
+  "set-level-layout",
+  "convert-to-text",
+  "paste-fragment",
+  "drop-fragment"
+];
+var applyCommandMetadata = {
+  name: "runtime.lists.applyCommand",
+  status: "live-with-adapter",
+  sourceLayer: "runtime-core",
+  liveEvidence: {
+    runnerTest: "test/api/v3/runtime/lists.test.ts",
+    commit: "refactor-07-runtime-lists-namespace"
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "surface-refresh",
+    expectedDelta: "list structure changes through the L07 list command surface"
+  },
+  agentMetadata: { readOrMutate: "mutate", boundedScope: "scope", auditCategory: "list-command" },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  broadcastsVia: "crdt",
+  rwdReference: "\xA7Runtime API \xA7 runtime.lists.applyCommand. Dispatches only proven L07 list commands through opaque list targets; future commands return owner-routed blockers until command/export/readback support lands."
+};
+function createListsFamily(runtime) {
+  return {
+    list(input = {}) {
+      const document2 = runtime.getCanonicalDocument();
+      const rows = currentListTargets(document2).filter((entry) => input.storyKey === void 0 || entry.target.storyKey === input.storyKey).map((entry) => toReadback(document2, entry.target, entry.paragraph));
+      return input.limit === void 0 ? rows : rows.slice(0, Math.max(0, input.limit));
+    },
+    get(input) {
+      const resolved = resolveCurrentListTarget(runtime.getCanonicalDocument(), input);
+      return resolved.kind === "resolved" ? toReadback(runtime.getCanonicalDocument(), resolved.target, resolved.paragraph) : null;
+    },
+    previewCommand(input) {
+      return previewListCommand(runtime.getCanonicalDocument(), input);
+    },
+    applyCommand(input) {
+      const preview = previewListCommand(runtime.getCanonicalDocument(), input);
+      if (!preview.supported || !preview.target) {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: preview.blockers
+        };
+      }
+      const resolved = resolveCurrentListTarget(runtime.getCanonicalDocument(), {
+        addressKey: preview.target.addressKey
+      });
+      if (resolved.kind !== "resolved") {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: [resolved.blocker]
+        };
+      }
+      const command = editorCommandForListCommand(
+        input.command,
+        resolved.target,
+        runtime.now(),
+        input.startAt
+      );
+      if (!command) {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: [
+            unsupportedCommandBlocker(input.command, {
+              targetKey: preview.target.targetKey,
+              addressKey: preview.target.addressKey
+            })
+          ]
+        };
+      }
+      const beforeDocument = runtime.getCanonicalDocument();
+      runtime.dispatch(command);
+      const afterDocument = runtime.getCanonicalDocument();
+      const after = resolveCurrentListTarget(afterDocument, { targetKey: preview.target.targetKey });
+      emitUxResponse(runtime, {
+        apiFn: applyCommandMetadata.name,
+        intent: applyCommandMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live",
+        uiVisible: true,
+        expectedDelta: applyCommandMetadata.uxIntent.expectedDelta
+      });
+      return {
+        applied: beforeDocument !== afterDocument,
+        command: input.command,
+        before: preview.target,
+        ...after.kind === "resolved" ? { after: toReadback(afterDocument, after.target, after.paragraph) } : {},
+        blockers: []
+      };
+    }
+  };
+}
+function previewListCommand(document2, input) {
+  const resolved = resolveCurrentListTarget(document2, input);
+  if (resolved.kind !== "resolved") {
+    return {
+      command: input.command,
+      supported: false,
+      affectedTargets: [],
+      blockers: [resolved.blocker]
+    };
+  }
+  const target = toReadback(document2, resolved.target, resolved.paragraph);
+  const targetRef = { targetKey: target.targetKey, addressKey: target.addressKey };
+  if (!SUPPORTED_COMMANDS.includes(input.command)) {
+    return {
+      command: input.command,
+      supported: false,
+      target,
+      affectedTargets: [target],
+      blockers: [unsupportedCommandBlocker(input.command, targetRef)]
+    };
+  }
+  const canContinuePrevious = canContinuePreviousSequence(document2, resolved.paragraphIndex);
+  const canJoin = canJoinPreviousSequence(document2, resolved.paragraphIndex);
+  const blockers = [];
+  if (input.command === "continue-numbering" && !canContinuePrevious) {
+    blockers.push({
+      code: "list-continue-target-missing",
+      ownerLayer: "L07",
+      message: "No previous compatible list sequence is available for continue-numbering.",
+      ...targetRef
+    });
+  }
+  return {
+    command: input.command,
+    supported: blockers.length === 0,
+    target,
+    affectedTargets: [target],
+    blockers,
+    canJoin,
+    canContinuePrevious
+  };
+}
+function editorCommandForListCommand(command, editableTarget, timestamp, startAt) {
+  const origin = { source: "api", timestamp };
+  switch (command) {
+    case "toggle-numbered":
+      return { type: "list.toggle", kind: "numbered", editableTargets: [editableTarget], origin };
+    case "toggle-bulleted":
+      return { type: "list.toggle", kind: "bulleted", editableTargets: [editableTarget], origin };
+    case "indent":
+      return { type: "list.indent", editableTargets: [editableTarget], origin };
+    case "outdent":
+      return { type: "list.outdent", editableTargets: [editableTarget], origin };
+    case "restart-numbering":
+      return {
+        type: "list.restart-numbering",
+        editableTarget,
+        ...startAt !== void 0 ? { startAt } : {},
+        origin
+      };
+    case "continue-numbering":
+      return { type: "list.continue-numbering", editableTarget, origin };
+    default:
+      return void 0;
+  }
+}
+function resolveCurrentListTarget(document2, input) {
+  if (input.editableTarget) {
+    const shapeIssues = validateEditableTargetRef(input.editableTarget);
+    if (shapeIssues.length > 0) {
+      return {
+        kind: "blocked",
+        blocker: {
+          code: "list-target-malformed",
+          ownerLayer: "L07",
+          message: `List target is malformed: ${shapeIssues[0]?.path ?? "$"}.`,
+          targetKey: input.editableTarget.targetKey,
+          addressKey: input.editableTarget.listAddress?.addressKey
+        }
+      };
+    }
+  }
+  const requestedTargetKey = input.editableTarget?.targetKey ?? input.targetKey;
+  const requestedAddressKey = input.editableTarget?.listAddress?.addressKey ?? input.addressKey;
+  if (!requestedTargetKey && !requestedAddressKey) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-required",
+        ownerLayer: "L07",
+        message: "runtime.lists requires a targetKey, addressKey, or editableTarget."
+      }
+    };
+  }
+  const currentTargets = currentListTargets(document2);
+  const resolved = currentTargets.find(
+    ({ target }) => requestedTargetKey !== void 0 && target.targetKey === requestedTargetKey || requestedAddressKey !== void 0 && target.listAddress?.addressKey === requestedAddressKey
+  );
+  if (!resolved) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-not-found",
+        ownerLayer: "L07",
+        message: "List target no longer resolves in the current canonical document.",
+        ...requestedTargetKey !== void 0 ? { targetKey: requestedTargetKey } : {},
+        ...requestedAddressKey !== void 0 ? { addressKey: requestedAddressKey } : {}
+      }
+    };
+  }
+  if (input.editableTarget && !sameTargetStaleHash(input.editableTarget, resolved.target)) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-stale",
+        ownerLayer: "L07",
+        message: "List target resolved by identity but stale discriminators changed.",
+        targetKey: input.editableTarget.targetKey,
+        addressKey: input.editableTarget.listAddress?.addressKey
+      }
+    };
+  }
+  if (resolved.target.editability !== "editable" || resolved.target.posture.blockers.length > 0) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-non-editable",
+        ownerLayer: "L07",
+        message: resolved.target.posture.blockers.length > 0 ? `List target is not editable: ${resolved.target.posture.blockers.join(", ")}.` : "List target is not editable.",
+        targetKey: resolved.target.targetKey,
+        addressKey: resolved.target.listAddress?.addressKey
+      }
+    };
+  }
+  return { kind: "resolved", ...resolved };
+}
+function currentListTargets(document2) {
+  const paragraphs = collectParagraphEntries(document2.content.children, "main");
+  const targets = collectEditableTargetRefs(document2).filter(isListTextTarget);
+  const byBlockPath = /* @__PURE__ */ new Map();
+  for (const target of targets) byBlockPath.set(target.blockPath, target);
+  const out = [];
+  for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex += 1) {
+    const entry = paragraphs[paragraphIndex];
+    if (!entry?.paragraph.numbering) continue;
+    const target = byBlockPath.get(entry.blockPath);
+    if (!target) continue;
+    out.push({ target, paragraph: entry.paragraph, paragraphIndex });
+  }
+  return out;
+}
+function collectParagraphEntries(blocks, basePath) {
+  const out = [];
+  collectParagraphEntriesInto(blocks, basePath, out);
+  return out;
+}
+function collectParagraphEntriesInto(blocks, basePath, out) {
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+    const block = blocks[blockIndex];
+    if (!block) continue;
+    const blockPath = `${basePath}/block[${blockIndex}]`;
+    switch (block.type) {
+      case "paragraph":
+        out.push({ paragraph: block, blockPath });
+        break;
+      case "table":
+        for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+          const row2 = block.rows[rowIndex];
+          if (!row2) continue;
+          for (let cellIndex = 0; cellIndex < row2.cells.length; cellIndex += 1) {
+            const cell = row2.cells[cellIndex];
+            if (!cell) continue;
+            collectParagraphEntriesInto(
+              cell.children,
+              `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`,
+              out
+            );
+          }
+        }
+        break;
+      case "sdt":
+        collectParagraphEntriesInto(block.children, blockPath, out);
+        break;
+      case "custom_xml":
+        break;
+      default:
+        break;
+    }
+  }
+}
+function isListTextTarget(target) {
+  return target.commandFamily === "text-leaf" && target.listAddress?.operationScope === "list-text" && target.listAddress.addressKind === "list-item-text";
+}
+function sameTargetStaleHash(left, right) {
+  return left.targetKey === right.targetKey && left.listAddress?.addressKey === right.listAddress?.addressKey && left.listAddress?.resolver?.staleHash === right.listAddress?.resolver?.staleHash && left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength && left.staleCheck.inlineCount === right.staleCheck.inlineCount;
+}
+function toReadback(document2, target, paragraph) {
+  const numbering = paragraph.numbering;
+  const instance = document2.numbering.instances[numbering.numberingInstanceId];
+  const listKind = instance ? getListKind(document2.numbering, numbering.numberingInstanceId) : void 0;
+  return {
+    targetKey: target.targetKey,
+    actionHandle: `list-action:${target.listAddress.addressKey}`,
+    kind: target.kind,
+    storyKey: target.storyKey,
+    blockPath: target.blockPath,
+    leafPath: target.leafPath,
+    addressKey: target.listAddress.addressKey,
+    numberingInstanceId: numbering.numberingInstanceId,
+    ...instance?.abstractNumberingId ? { abstractNumberingId: instance.abstractNumberingId } : {},
+    level: numbering.level,
+    ...listKind ? { listKind } : {},
+    editability: target.editability,
+    blockers: target.posture.blockers,
+    supportedCommands: SUPPORTED_COMMANDS,
+    unsupportedCommands: UNSUPPORTED_COMMANDS,
+    staleDiscriminators: {
+      paragraphTextHash: target.staleCheck.paragraphTextHash,
+      paragraphTextLength: target.staleCheck.paragraphTextLength,
+      inlineCount: target.staleCheck.inlineCount,
+      listAddressStaleHash: target.listAddress?.resolver?.staleHash
+    }
+  };
+}
+function canContinuePreviousSequence(document2, paragraphIndex) {
+  const paragraphs = collectParagraphEntries(document2.content.children, "main");
+  const current = paragraphs[paragraphIndex]?.paragraph;
+  if (!current?.numbering) return false;
+  const currentKind = getListKind(document2.numbering, current.numbering.numberingInstanceId);
+  if (!currentKind) return false;
+  for (let index = paragraphIndex - 1; index >= 0; index -= 1) {
+    const previous = paragraphs[index]?.paragraph;
+    if (!previous?.numbering) continue;
+    const previousKind = getListKind(document2.numbering, previous.numbering.numberingInstanceId);
+    return previousKind === currentKind && previous.numbering.numberingInstanceId !== current.numbering.numberingInstanceId;
+  }
+  return false;
+}
+function canJoinPreviousSequence(document2, paragraphIndex) {
+  const paragraphs = collectParagraphEntries(document2.content.children, "main");
+  const current = paragraphs[paragraphIndex]?.paragraph;
+  const previous = paragraphs[paragraphIndex - 1]?.paragraph;
+  if (!current?.numbering || !previous?.numbering) return false;
+  const currentKind = getListKind(document2.numbering, current.numbering.numberingInstanceId);
+  const previousKind = getListKind(document2.numbering, previous.numbering.numberingInstanceId);
+  return Boolean(currentKind) && currentKind === previousKind && current.numbering.numberingInstanceId !== previous.numbering.numberingInstanceId;
+}
+function unsupportedCommandBlocker(command, target) {
+  return {
+    code: "list-command-unsupported",
+    ownerLayer: "L07",
+    message: `runtime.lists.${command} is reserved but not implemented by the L07 command surface yet.`,
+    ...target.targetKey !== void 0 ? { targetKey: target.targetKey } : {},
+    ...target.addressKey !== void 0 ? { addressKey: target.addressKey } : {}
+  };
+}
+
 // src/api/v3/ai/_pe2-evidence.ts
 function copyCoverage(coverage) {
   return {
@@ -127861,6 +129895,17 @@ function createTableActionFamily(runtime) {
             operationScope: target.table?.operationScope
           });
         }
+        if (fragmentContent && fragmentContent.blocks.length === 0) {
+          return blockedResult(input, proposalId, {
+            code: `table-action-structured-fragment-empty:${input.operation.kind}`,
+            category: "unsupported-operation",
+            message: "Structured table text actions require a canonical document fragment with at least one block.",
+            nextStep: 'Retry with operation.content.kind="structured" and a CanonicalDocumentFragment whose blocks array contains the paragraph or table content to paste/drop.',
+            actionHandle: input.actionHandle,
+            operation: input.operation.kind,
+            operationScope: target.table?.operationScope
+          });
+        }
         const resolution2 = resolveEditableTextTarget({
           document: runtime.getCanonicalDocument(),
           surface: runtime.getRenderSnapshot().surface?.blocks ?? [],
@@ -127883,6 +129928,7 @@ function createTableActionFamily(runtime) {
           runtime.dispatch({
             type: "fragment.insert",
             fragment: fragmentContent,
+            selection: createSelectionSnapshot(resolution2.range.to, resolution2.range.to),
             editableTarget: target,
             origin: { source: "api", timestamp: nowUtc }
           });
@@ -127895,6 +129941,17 @@ function createTableActionFamily(runtime) {
           });
         }
         const changed2 = runtime.getCanonicalDocument() !== before2;
+        if (!changed2) {
+          return blockedResult(input, proposalId, {
+            code: `table-action-noop:${input.operation.kind}:${input.actionHandle}`,
+            category: "runtime-noop",
+            message: "The runtime accepted the table text target but the operation produced no document change.",
+            nextStep: "Refresh the table action list and verify the target is still editable, the payload is non-empty when required, and structured fragments are dispatched through a command-safe table text action.",
+            actionHandle: input.actionHandle,
+            operation: input.operation.kind,
+            operationScope: target.table?.operationScope
+          });
+        }
         const afterReadback = tableTextReadback(readEditableTargetText(runtime.getCanonicalDocument(), target));
         return {
           proposalId,
@@ -128502,7 +130559,7 @@ var listOperationMetadata = actionMethodMetadata(
   "listOperation",
   "mutate",
   "actions-list-operation",
-  "Apply list toggle, indent, outdent, restart, or continue-numbering commands to paragraph-like scope handles.",
+  "Apply list toggle, indent, outdent, restart, or continue-numbering commands through opaque list action handles or command-safe list scope targets.",
   {
     uiVisible: true,
     expectsUxResponse: "inline-change",
@@ -130237,25 +132294,16 @@ function checkPlanStepCapability(runtime, step, before) {
     return null;
   }
   if (step.kind === "listOperation") {
-    const resolved = resolveScopeExactTarget(runtime, step.target, step.kind);
+    const resolved = resolveListOperationTarget(runtime, step.target);
     if (!resolved.ok) return resolved.blockerDetails[0] ?? null;
-    const scope = resolved.target.scope;
-    if (scope.kind !== "list-item" && scope.kind !== "paragraph" && scope.kind !== "heading") {
-      return blocker(
-        `actions:list-operation:target-kind-unsupported:${scope.kind}`,
-        "unsupported",
-        "List operations require a paragraph-like scope handle.",
-        "Use ai.actions.locateAll or ai.listScopes to select a paragraph, heading, or list-item handle."
-      );
-    }
-    if (paragraphIndexFromHandle(scope.handle) === null) {
-      return blockerWithOwner(
-        `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
-        "blocked",
-        "The list operation target did not resolve to a current paragraph index.",
-        "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
-        "L08 semantic scope compiler"
-      );
+    const command = runtimeListCommandForOperation(step.operation);
+    const preview = createListsFamily(runtime).previewCommand({
+      ...resolved.input,
+      command,
+      ...step.operation.kind === "restart-numbering" && step.operation.startAt !== void 0 ? { startAt: step.operation.startAt } : {}
+    });
+    if (preview.blockers.length > 0) {
+      return listBlockerDetails("actions:list-operation:preflight", preview.blockers)[0] ?? null;
     }
     return null;
   }
@@ -130412,70 +132460,253 @@ function applyModeledCommand(runtime, targetInput, kind, commandInput, reference
   };
 }
 function applyListOperation(runtime, input) {
-  const resolvedScope = resolveScopeExactTarget(runtime, input.target, "listOperation");
-  if (!resolvedScope.ok) return blockedApplyFromResolution(resolvedScope);
+  const resolvedTarget = resolveListOperationTarget(runtime, input.target);
+  if (!resolvedTarget.ok) return blockedApplyFromResolution(resolvedTarget);
+  const command = runtimeListCommandForOperation(input.operation);
+  const result = createListsFamily(runtime).applyCommand({
+    ...resolvedTarget.input,
+    command,
+    ...input.operation.kind === "restart-numbering" && input.operation.startAt !== void 0 ? { startAt: input.operation.startAt } : {}
+  });
+  if (!result.applied) {
+    const details = result.blockers.length > 0 ? listBlockerDetails("actions:list-operation", result.blockers) : [
+      blockerWithOwner(
+        `actions:list-operation:runtime-noop:${resolvedTarget.before?.addressKey ?? "unknown"}`,
+        "blocked",
+        "The runtime list command produced no document change for the selected list target.",
+        "Refresh the list action handle and retry; route persistent failures with before/after readback to L07 runtime list commands.",
+        "L07 runtime list commands"
+      )
+    ];
+    return {
+      status: details.some((detail) => detail.category === "unsupported") ? "unsupported" : "blocked",
+      applied: false,
+      changed: false,
+      target: summarizeListTarget(resolvedTarget, result.before ?? resolvedTarget.before),
+      blockers: Object.freeze(details.map((detail) => detail.code)),
+      blockerDetails: Object.freeze(details),
+      listReadback: listOperationReadback(result, resolvedTarget.before)
+    };
+  }
+  const compiledAfter = resolvedTarget.scopeHandle ? createScopeCompilerService(runtime).compileScopeById(resolvedTarget.scopeHandle.scopeId) : null;
+  const target = compiledAfter ? summarizeTarget({ kind: "scope", scope: compiledAfter.scope, handle: compiledAfter.scope.handle }) : summarizeListTarget(resolvedTarget, result.after ?? result.before ?? resolvedTarget.before);
+  return {
+    status: "applied",
+    applied: true,
+    changed: result.applied,
+    target,
+    commandReference: {
+      command: commandReferenceForListCommand(result.command),
+      actorId: input.actorId ?? "v3-ai-api",
+      origin: input.origin ?? "agent",
+      emittedAtUtc: currentAuditTimestamp(runtime)
+    },
+    listReadback: listOperationReadback(result, resolvedTarget.before)
+  };
+}
+function resolveListOperationTarget(runtime, targetInput) {
+  const lists = createListsFamily(runtime);
+  if ("actionHandle" in targetInput) {
+    const addressKey = listAddressKeyFromActionHandle(targetInput.actionHandle);
+    if (!addressKey) {
+      const detail = blockerWithOwner(
+        `actions:list-operation:action-handle-malformed:${targetInput.actionHandle}`,
+        "unsupported",
+        "List operations require an opaque list action handle from runtime.lists or list editable-target evidence.",
+        "Call runtime.lists.list or refresh the scope bundle and retry with a list-action:* or scope-command:text-leaf:* list handle.",
+        "L07 runtime list commands and L08 semantic scopes"
+      );
+      return {
+        ok: false,
+        blockers: Object.freeze([detail.code]),
+        blockerDetails: Object.freeze([detail])
+      };
+    }
+    const before2 = lists.get({ addressKey });
+    if (!before2) {
+      const detail = blockerWithOwner(
+        `actions:list-operation:action-handle-not-found:${targetInput.actionHandle}`,
+        "unresolved-target",
+        "No current list target matches the supplied opaque action handle.",
+        "Refresh runtime.lists.list or the scope bundle, then retry with the current list action handle.",
+        "L07 runtime list commands"
+      );
+      return {
+        ok: false,
+        blockers: Object.freeze([detail.code]),
+        blockerDetails: Object.freeze([detail])
+      };
+    }
+    return { ok: true, input: { addressKey }, before: before2 };
+  }
+  const resolvedScope = resolveScopeExactTarget(runtime, targetInput, "listOperation");
+  if (!resolvedScope.ok) return resolvedScope;
   const scope = resolvedScope.target.scope;
   if (scope.kind !== "list-item" && scope.kind !== "paragraph" && scope.kind !== "heading") {
-    return blockedApply(
+    const detail = blocker(
       `actions:list-operation:target-kind-unsupported:${scope.kind}`,
       "unsupported",
-      "List operations require a paragraph-like scope handle.",
-      "Use ai.actions.locateAll or ai.listScopes to select a paragraph, heading, or list-item handle."
+      "List operations require a list item or command-safe paragraph-like scope target.",
+      "Use ai.actions.locateAll, ai.listScopes, or runtime.lists.list to select a current list item target."
     );
+    return {
+      ok: false,
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
   }
-  const paragraphIndex = paragraphIndexFromHandle(scope.handle);
-  if (paragraphIndex === null) {
-    return blockedApply(
-      `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
+  const bundle = createScopeCompilerService(runtime).compileBundleById(
+    scope.handle.scopeId,
+    currentAuditTimestamp(runtime)
+  );
+  const entries = bundle?.evidence.editableTargets?.entries ?? [];
+  const listEntry = entries.find(
+    (entry) => entry.commandFamily === "text-leaf" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("list-structure-action") && entry.runtimeCommand.canonicalAddress?.operationScope === "list-text" && entry.runtimeCommand.canonicalAddress.addressKind === "list-item-text"
+  );
+  if (!listEntry) {
+    const detail = blockerWithOwner(
+      `actions:list-operation:list-target-missing:${scope.handle.scopeId}`,
       "blocked",
-      "The list operation target did not resolve to a current paragraph index.",
-      "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
-      [
-        blockerWithOwner(
-          `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
-          "blocked",
-          "The list operation target did not resolve to a current paragraph index.",
-          "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
-          "L08 semantic scope compiler"
-        )
-      ]
+      "The selected scope does not expose a command-safe list structure target.",
+      "Refresh the scope bundle and route missing list editable-target evidence to L08/L07; do not derive a paragraph index from the scope handle.",
+      "L08 semantic scopes and L07 runtime list commands"
     );
+    return {
+      ok: false,
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
   }
-  const command = listCommandForOperation(input.operation, paragraphIndex, actionOrigin(runtime, input));
-  const before = runtime.getCanonicalDocument();
-  runtime.dispatch(command);
-  const changed = runtime.getCanonicalDocument() !== before;
-  if (!changed) {
-    return blockedApply(
-      `actions:list-operation:runtime-noop:${scope.handle.scopeId}`,
+  const currentTarget = collectEditableTargetRefs(runtime.getCanonicalDocument()).find(
+    (target) => target.targetKey === listEntry.targetKey || target.listAddress?.addressKey === listEntry.runtimeCommand.canonicalAddress?.addressKey
+  );
+  if (!currentTarget) {
+    const detail = blockerWithOwner(
+      `actions:list-operation:list-target-not-current:${scope.handle.scopeId}`,
+      "unresolved-target",
+      "The list editable target evidence is stale in the current document.",
+      "Refresh the scope bundle and retry with the current opaque list target.",
+      "L08 semantic scopes and L07 runtime list commands"
+    );
+    return {
+      ok: false,
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const before = lists.get({ editableTarget: currentTarget });
+  if (!before) {
+    const detail = blockerWithOwner(
+      `actions:list-operation:list-readback-missing:${scope.handle.scopeId}`,
       "blocked",
-      "The list runtime command produced no document change for the selected scope.",
-      "Select a list-compatible paragraph and retry, or route to L03/L07 list command support with the scope handle.",
-      [
-        blockerWithOwner(
-          `actions:list-operation:runtime-noop:${scope.handle.scopeId}`,
-          "blocked",
-          "The list runtime command produced no document change for the selected scope.",
-          "Select a list-compatible paragraph and retry, or route to L03/L07 list command support with the scope handle.",
-          "L03 numbering/list semantics and L07 runtime list commands"
-        )
-      ]
+      "The list target was present in scope evidence but runtime.lists could not produce readback.",
+      "Route the target with editable-target evidence to L07 runtime list readback.",
+      "L07 runtime list commands"
     );
+    return {
+      ok: false,
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
   }
-  const compiledAfter = createScopeCompilerService(runtime).compileScopeById(scope.handle.scopeId);
   return {
-    status: "applied",
-    applied: true,
-    changed: true,
-    target: compiledAfter ? summarizeTarget({ kind: "scope", scope: compiledAfter.scope, handle: compiledAfter.scope.handle }) : summarizeTarget(resolvedScope.target),
-    commandReference: {
-      command: command.type,
-      actorId: input.actorId ?? "v3-ai-api",
-      origin: input.origin ?? "agent",
-      emittedAtUtc: command.origin?.timestamp ?? currentAuditTimestamp(runtime)
-    }
+    ok: true,
+    input: { editableTarget: currentTarget },
+    before,
+    scopeHandle: scope.handle
+  };
+}
+function listAddressKeyFromActionHandle(actionHandle) {
+  const listPrefix = "list-action:";
+  if (actionHandle.startsWith(listPrefix)) return actionHandle.slice(listPrefix.length) || null;
+  const scopeCommandPrefix = "scope-command:text-leaf:";
+  if (actionHandle.startsWith(scopeCommandPrefix)) {
+    return actionHandle.slice(scopeCommandPrefix.length) || null;
+  }
+  return null;
+}
+function runtimeListCommandForOperation(operation) {
+  switch (operation.kind) {
+    case "toggle":
+      return operation.listKind === "numbered" ? "toggle-numbered" : "toggle-bulleted";
+    case "indent":
+      return "indent";
+    case "outdent":
+      return "outdent";
+    case "restart-numbering":
+      return "restart-numbering";
+    case "continue-numbering":
+      return "continue-numbering";
+  }
+}
+function commandReferenceForListCommand(command) {
+  switch (command) {
+    case "toggle-numbered":
+    case "toggle-bulleted":
+      return "list.toggle";
+    case "indent":
+      return "list.indent";
+    case "outdent":
+      return "list.outdent";
+    case "restart-numbering":
+      return "list.restart-numbering";
+    case "continue-numbering":
+      return "list.continue-numbering";
+    default:
+      return "list.toggle";
+  }
+}
+function listOperationReadback(result, fallbackBefore) {
+  const before = sanitizeListReadback(result.before ?? fallbackBefore);
+  const after = sanitizeListReadback(result.after);
+  return {
+    ...before ? { before } : {},
+    ...after ? { after } : {}
+  };
+}
+function sanitizeListReadback(readback) {
+  if (!readback) return void 0;
+  return {
+    actionHandle: readback.actionHandle,
+    kind: readback.kind,
+    storyKey: readback.storyKey,
+    addressKey: readback.addressKey,
+    numberingInstanceId: readback.numberingInstanceId,
+    ...readback.abstractNumberingId ? { abstractNumberingId: readback.abstractNumberingId } : {},
+    level: readback.level,
+    ...readback.listKind ? { listKind: readback.listKind } : {},
+    editability: readback.editability,
+    blockers: readback.blockers,
+    supportedCommands: readback.supportedCommands,
+    unsupportedCommands: readback.unsupportedCommands,
+    staleDiscriminators: readback.staleDiscriminators
+  };
+}
+function summarizeListTarget(target, readback) {
+  const current = readback ?? target.before;
+  return {
+    kind: "list-item",
+    ...target.scopeHandle ? { handle: target.scopeHandle } : {},
+    ...current?.actionHandle ? { actionHandle: current.actionHandle } : {},
+    canRewriteText: current?.editability === "editable" && (current.blockers.length ?? 0) === 0,
+    canInsertAdjacentText: false,
+    canFlag: Boolean(target.scopeHandle),
+    canMark: Boolean(target.scopeHandle)
   };
 }
+function listBlockerDetails(prefix, blockers) {
+  return Object.freeze(
+    blockers.map(
+      (entry) => blockerWithOwner(
+        `${prefix}:${entry.code}:${entry.addressKey ?? entry.targetKey ?? "unknown"}`,
+        entry.code === "list-command-unsupported" ? "unsupported" : "blocked",
+        entry.message,
+        "Refresh the opaque list target/readback and route persistent blockers to the owning runtime list layer.",
+        entry.ownerLayer === "L07" ? "L07 runtime list commands" : entry.ownerLayer
+      )
+    )
+  );
+}
 function projectTableApplyResult(result) {
   return {
     status: result.applied ? "applied" : "blocked",
@@ -130603,36 +132834,6 @@ function tableSelectionStepHasDescriptor(operation) {
     operation && "selectionDescriptor" in operation && operation.selectionDescriptor
   );
 }
-function listCommandForOperation(operation, paragraphIndex, origin) {
-  switch (operation.kind) {
-    case "toggle":
-      return {
-        type: "list.toggle",
-        kind: operation.listKind,
-        paragraphIndexes: [paragraphIndex],
-        origin
-      };
-    case "indent":
-      return { type: "list.indent", paragraphIndexes: [paragraphIndex], origin };
-    case "outdent":
-      return { type: "list.outdent", paragraphIndexes: [paragraphIndex], origin };
-    case "restart-numbering":
-      return {
-        type: "list.restart-numbering",
-        paragraphIndex,
-        ...operation.startAt !== void 0 ? { startAt: operation.startAt } : {},
-        origin
-      };
-    case "continue-numbering":
-      return { type: "list.continue-numbering", paragraphIndex, origin };
-  }
-}
-function paragraphIndexFromHandle(handle) {
-  const raw = handle.semanticPath[handle.semanticPath.length - 1];
-  if (raw === void 0) return null;
-  const index = Number(raw);
-  return Number.isSafeInteger(index) && index >= 0 ? index : null;
-}
 function actionOrigin(runtime, input) {
   return { source: "api", timestamp: currentAuditTimestamp(runtime) };
 }
@@ -130997,7 +133198,8 @@ function createApiV3(handle, opts) {
     chart: createChartFamily(handle),
     search: createSearchFamily(handle),
     table: createTableFamily(handle),
-    viewport: createViewportFamily2(handle)
+    viewport: createViewportFamily2(handle),
+    lists: createListsFamily(handle)
   };
   const ui = opts?.ui ? createUiApi(handle, opts.ui) : void 0;
   const api = ui ? { runtime, ai, ui } : { runtime, ai };
@@ -133363,6 +135565,7 @@ var WordReviewEditor = (0, import_react71.forwardRef)(
       // auto-bracketing in insertFragment + our explicit startAction around
       // the delete, so the undo history sees a single atomic action.
       onDropFragment: (meta) => {
+        const dropEditableTarget = meta.editableTarget ?? activeRuntime.getRenderSnapshot().selection.editableTarget;
         if (meta.effect === "move" && meta.sourceRange) {
           activeRuntime.startAction("drag-move");
           try {
@@ -133372,16 +135575,21 @@ var WordReviewEditor = (0, import_react71.forwardRef)(
               to: meta.sourceRange.to,
               assoc: { start: -1, end: 1 }
             });
-            activeRuntime.insertFragment(meta.fragment);
+            const currentEditableTarget = activeRuntime.getRenderSnapshot().selection.editableTarget;
+            const editableTarget = currentEditableTarget?.targetKey === dropEditableTarget?.targetKey ? currentEditableTarget : dropEditableTarget;
+            activeRuntime.insertFragment(
+              meta.fragment,
+              void 0,
+              editableTarget ? { editableTarget } : void 0
+            );
           } finally {
             activeRuntime.endAction();
           }
         } else {
-          const editableTarget = activeRuntime.getRenderSnapshot().selection.editableTarget;
           activeRuntime.insertFragment(
             meta.fragment,
             void 0,
-            editableTarget ? { editableTarget } : void 0
+            dropEditableTarget ? { editableTarget: dropEditableTarget } : void 0
           );
         }
       },
@@ -136363,7 +138571,7 @@ function normalizeForHashing(doc) {
   };
 }
 async function computeCanonicalDocumentHash(doc) {
-  return sha256Hex5(stableStringify(normalizeForHashing(doc)));
+  return sha256Hex5(stableStringify2(normalizeForHashing(doc)));
 }
 
 // src/runtime/prerender/font-fingerprint.ts