@beyondwork/docx-react-component 1.0.127 → 1.0.129

package/dist/runtime/document-runtime.cjs

@@ -9317,12 +9317,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)) {
@@ -9353,56 +9354,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;
@@ -10056,12 +10149,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;
@@ -18920,6 +19037,133 @@ function rangesOverlap2(leftFrom, leftTo, rightFrom, rightTo) {
   return leftFrom < rightTo && leftTo > rightFrom;
 }
 
+// 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);
@@ -18964,7 +19208,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 {
@@ -18972,15 +19216,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];
@@ -19034,7 +19275,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) {
@@ -19101,7 +19342,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;
@@ -19116,7 +19357,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 = {
@@ -19281,23 +19522,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) {
@@ -19320,69 +19544,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),
@@ -20108,7 +20269,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: {
@@ -20130,11 +20291,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) {
@@ -25010,7 +25171,7 @@ function buildFormattingDebugEntry(inputs) {
 }
 
 // src/runtime/layout/layout-engine-version.ts
-var LAYOUT_ENGINE_VERSION = 88;
+var LAYOUT_ENGINE_VERSION = 89;
 
 // src/runtime/layout/compat-input-ledger.ts
 var DEFAULT_COMPATIBILITY_MODE = 15;
@@ -29695,7 +29856,7 @@ function emptyCompatibilityReport() {
 }
 
 // src/runtime/debug/runtime-debug-facet.ts
-function createRuntimeDebugFacet(getRuntime, bus) {
+function createRuntimeDebugFacet(getRuntime, bus, options = {}) {
   return {
     bus,
     getSnapshot(query) {
@@ -29713,7 +29874,318 @@ 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
   };
 }
 
@@ -32943,6 +33415,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":
@@ -33081,6 +33559,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",
@@ -33785,6 +34268,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;
@@ -34373,6 +34905,8 @@ function compileScope(entry, optionsOrCatalog) {
       });
     case "field":
       return compileFieldScope(entry);
+    case "image":
+      return compileImageScope(entry);
     case "comment-thread":
       return compileCommentThreadScope(entry);
     case "revision":
@@ -34561,6 +35095,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;
@@ -34691,6 +35263,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") {
@@ -35080,6 +35654,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]);
 }
@@ -35624,6 +36207,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),
@@ -35640,7 +36252,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)
   };
 }
 
@@ -35912,6 +36525,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;
   }
@@ -36659,6 +37277,64 @@ 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((blocker) => [
+      blocker.blocker,
+      blocker.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 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]));
+  return {
+    status: entries.length > 0 ? "present" : "none",
+    count: entries.length,
+    blockers,
+    entries
+  };
+}
+
 // src/runtime/scopes/table-evidence.ts
 function isTableFamilyEntry(entry) {
   return entry?.kind === "table" || entry?.kind === "table-row" || entry?.kind === "table-cell";
@@ -37228,7 +37904,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) {
@@ -37258,7 +37934,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;
@@ -37295,19 +37971,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(
@@ -37332,7 +38008,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,
@@ -37630,6 +38306,7 @@ function composeEvidence(inputs) {
     ...editableTargets ? { editableTargets } : {},
     layout
   });
+  const objects = deriveScopeObjectEvidence(editableTargets);
   return {
     formattingSummary: formattingSummaryOf(scope),
     reviewItemIds,
@@ -37640,6 +38317,7 @@ function composeEvidence(inputs) {
     ...adjacentGeometry ? { adjacentGeometry } : {},
     visualization: deriveScopeVisualization(scope),
     ...editableTargets ? { editableTargets } : {},
+    objects,
     ...table ? { table } : {},
     contentControls,
     capabilities,
@@ -42492,6 +43170,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,
@@ -42666,6 +43352,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;
@@ -44150,6 +44851,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) {
@@ -44235,6 +44939,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();
@@ -44747,13 +45468,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);
@@ -44761,11 +45480,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 [];
@@ -44885,8 +45601,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 ?? [
@@ -44926,7 +45641,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);
@@ -44936,7 +45651,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 = [];
@@ -53301,8 +54016,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") {
@@ -53409,6 +54122,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;
@@ -53480,7 +54204,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");
@@ -53814,8 +54537,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]);
   }
@@ -53896,8 +54619,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") {
@@ -53972,6 +54699,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 {
@@ -54019,25 +54774,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,
@@ -55001,7 +55757,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,
@@ -55094,15 +55852,16 @@ function createDocumentRuntime(options) {
       ...resolution.textTarget ? { textTarget: resolution.textTarget } : {}
     };
   }
-  function prepareFragmentInsertCommandForExecution(command, document2, surface, storyTarget) {
+  function prepareFragmentInsertCommandForExecution(command, document2, surface, storyTarget, selection) {
     if (!command.editableTarget) {
-      return { kind: "accepted", selection: state.selection };
+      return { kind: "accepted", selection };
     }
     const resolution = resolveEditableTextTarget({
       document: document2,
       surface,
       target: command.editableTarget,
       activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+      selection,
       editableTargetCache: editableTargetBlockCache
     });
     if (resolution.kind === "rejected") {
@@ -55120,7 +55879,7 @@ function createDocumentRuntime(options) {
     }
     return {
       kind: "accepted",
-      selection: createSelectionSnapshot(resolution.range.from, resolution.range.to),
+      selection,
       ...resolution.textTarget ? { textTarget: resolution.textTarget } : {}
     };
   }
@@ -55292,7 +56051,8 @@ function createDocumentRuntime(options) {
           command,
           state.document,
           cachedRenderSnapshot.surface?.blocks ?? [],
-          activeStory
+          activeStory,
+          commandSelection
         );
         if (prepared.kind === "rejected") {
           return;
@@ -55455,7 +56215,8 @@ function createDocumentRuntime(options) {
             command,
             replayState.document,
             replaySnapshot.surface?.blocks ?? [],
-            replayStory
+            replayStory,
+            replayState.selection
           );
           if (prepared.kind === "rejected") {
             return;
@@ -55598,7 +56359,8 @@ function createDocumentRuntime(options) {
               command,
               stateForCommand.document,
               snapshotForCommand.surface?.blocks ?? [],
-              replayStory
+              replayStory,
+              stateForCommand.selection
             );
             if (prepared.kind === "rejected") {
               continue;
@@ -56162,7 +56924,7 @@ function createDocumentRuntime(options) {
       try {
         const timestamp = clock();
         const selection = target ? createSelectionFromPublicAnchor(target) : state.selection;
-        const editableTarget = editContext?.editableTarget && isTableParagraphEditableTarget(editContext.editableTarget) ? editContext.editableTarget : inferEditableTargetForFragmentInsert(
+        const editableTarget = editContext?.editableTarget && isFragmentInsertEditableTarget(editContext.editableTarget) ? editContext.editableTarget : inferEditableTargetForFragmentInsert(
           cachedRenderSnapshot.surface?.blocks ?? [],
           selection
         );
@@ -56293,12 +57055,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,
@@ -56310,6 +57083,12 @@ function createDocumentRuntime(options) {
             }
           ]
         };
+        hotEditTraces.complete(pendingHotEditTrace, {
+          tier: "blocked",
+          patchMissReason: "participant-blocked",
+          counters: perfCounters
+        });
+        return ack;
       }
     },
     addComment(params) {
@@ -57980,7 +58759,7 @@ function createDocumentRuntime(options) {
       editableTargetCache: editableTargetBlockCache,
       activeStorySize: cachedRenderSnapshot.surface?.storySize,
       textTarget,
-      preserveNumberingOnSplit: commandForDispatch.type === "paragraph.split" && targetResolution?.kind === "accepted" && editableTarget?.listAddress?.operationScope === "list-text",
+      preserveNumberingOnSplit: (commandForDispatch.type === "paragraph.split" || commandForDispatch.type === "fragment.insert") && targetResolution?.kind === "accepted" && editableTarget?.listAddress?.operationScope === "list-text",
       rejectTargetlessTableStructureInsert: true
     };
     const baseState = selection === state.selection ? state : {
@@ -58085,6 +58864,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 ?? {};
@@ -58802,7 +59602,7 @@ function canonicalEditableTargetStoryKey(storyTarget) {
 function inferEditableTargetForFragmentInsert(blocks, selection) {
   const position = Math.min(selection.anchor, selection.head);
   const target = findEditableTargetAtSurfacePosition(blocks, position);
-  return target && isTableParagraphEditableTarget(target) ? target : void 0;
+  return target && isFragmentInsertEditableTarget(target) ? target : void 0;
 }
 function findEditableTargetAtSurfacePosition(blocks, position) {
   for (const block of blocks) {
@@ -58831,8 +59631,14 @@ function findEditableTargetInSurfaceCell(cell, position) {
   }
   return findEditableTargetAtSurfacePosition(cell.content, position);
 }
-function isTableParagraphEditableTarget(target) {
-  return target.editability === "editable" && target.posture.blockers.length === 0 && target.commandFamily === "text-leaf" && (target.kind === "table-cell-paragraph-text" || target.kind === "nested-table-cell-paragraph-text" || target.kind === "sdt-table-cell-paragraph-text");
+function isFragmentInsertEditableTarget(target) {
+  if (target.editability !== "editable" || target.posture.blockers.length > 0 || target.commandFamily !== "text-leaf") {
+    return false;
+  }
+  if (target.listAddress?.operationScope === "list-text") {
+    return true;
+  }
+  return target.kind === "table-cell-paragraph-text" || target.kind === "nested-table-cell-paragraph-text" || target.kind === "sdt-table-cell-paragraph-text";
 }
 function extractSelectionFragment(document2, selection, activeStory) {
   const from = Math.min(selection.anchor, selection.head);