@beyondwork/docx-react-component 1.0.129 → 1.0.131

package/dist/api/v3.cjs

@@ -21,6 +21,43 @@ var __copyProps = (to, from, except, desc) => {
 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;
@@ -263,6 +300,29 @@ function buildRunFormattingMap(block) {
   }
   return runs;
 }
+function hashStable(value) {
+  return fnv1a2(stableStringify3(value)).toString(36);
+}
+function stableStringify3(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify3(item)).join(",")}]`;
+  }
+  if (value instanceof Map) {
+    return stableStringify3(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)}:${stableStringify3(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;
+}
 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"() {
@@ -3591,26 +3651,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 = [];
@@ -3620,33 +3689,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>`;
 }
@@ -4211,79 +4267,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("  ");
 }
@@ -7391,6 +7454,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 = [];
@@ -7412,13 +7482,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) {
@@ -7487,51 +7550,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("  "));
 }
@@ -7705,9 +7777,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)}"`);
@@ -7728,6 +7797,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) {
@@ -7788,47 +7860,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 compareNoteIds(left, right) {
   return Number.parseInt(left.noteId, 10) - Number.parseInt(right.noteId, 10);
 }
@@ -12816,6 +12900,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),
@@ -12824,6 +12909,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)) {
@@ -14923,6 +15118,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,
@@ -15224,6 +15429,12 @@ function projectTableLayoutInput(table, storyKey, blockPath) {
     (row, rowIndex) => projectTableRowLayoutInput(row, tableKey, rowIndex)
   );
   return {
+    identity: createLayoutInputIdentity({
+      storyKey,
+      blockPath,
+      block: table,
+      table: { tableBlockPath: blockPath }
+    }),
     tableKey,
     storyKey,
     blockPath,
@@ -15311,6 +15522,16 @@ function projectDrawingFrameAnchor(node, storyKey, blockPath, inlinePath) {
   const objectKey = `${storyKey}:${inlinePath}`;
   const textBoxBody = projectTextBoxBodyLayoutInput(content, objectKey, sourceRef, `${inlinePath}/txbx`);
   return {
+    identity: {
+      storyKey,
+      blockPath,
+      blockId: objectKey,
+      ...sourceRef !== void 0 ? { sourceRef } : {},
+      object: {
+        objectId: objectKey,
+        ...sourceRef !== void 0 ? { anchorSourceRef: sourceRef } : {}
+      }
+    },
     objectKey,
     storyKey,
     blockPath,
@@ -15432,8 +15653,19 @@ function projectTextBoxRunLayoutInput(inline, paragraphKey, inlineIndex) {
 }
 function projectLegacyImageAnchor(doc, node, storyKey, blockPath, inlinePath) {
   const media = doc.media.items[node.mediaId];
+  const objectKey = `${storyKey}:${inlinePath}`;
   return {
-    objectKey: `${storyKey}:${inlinePath}`,
+    identity: {
+      storyKey,
+      blockPath,
+      blockId: objectKey,
+      ...node.sourceRef !== void 0 ? { sourceRef: node.sourceRef } : {},
+      object: {
+        objectId: objectKey,
+        ...node.sourceRef !== void 0 ? { anchorSourceRef: node.sourceRef } : {}
+      }
+    },
+    objectKey,
     storyKey,
     blockPath,
     inlinePath,
@@ -18409,8 +18641,7 @@ function resolveContentType(path, contentTypes) {
 // 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;
@@ -18429,21 +18660,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;
+    retainInstructionReferences(m[1] ?? "", retained, (value) => {
+      retainAllToc = retainAllToc || value;
     });
   }
-  FLD_SIMPLE_INSTR_DOUBLE_RE.lastIndex = 0;
-  while ((m = FLD_SIMPLE_INSTR_DOUBLE_RE.exec(documentXml)) !== null) {
-    scanFieldInstruction(decodeXmlAttribute(m[1] ?? ""), retained, () => {
-      retainAllToc = true;
-    });
-  }
-  FLD_SIMPLE_INSTR_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);
@@ -18453,17 +18677,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;
@@ -32621,7 +32842,7 @@ async function computeStructuralHash(blocks) {
 }
 
 // src/runtime/layout/layout-engine-version.ts
-var LAYOUT_ENGINE_VERSION = 89;
+var LAYOUT_ENGINE_VERSION = 93;
 var LAYCACHE_SCHEMA_VERSION = 12;
 
 // src/runtime/prerender/customxml-cache.ts
@@ -34343,6 +34564,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 {
@@ -34354,6 +34588,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) {
@@ -34453,13 +34705,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";
@@ -34784,19 +35039,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"]
@@ -34943,7 +35200,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 {
@@ -34964,6 +35221,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]) } : {},
@@ -34979,7 +35237,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(
@@ -34987,8 +35245,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) {
@@ -40795,15 +41064,65 @@ function projectEntry2(entry) {
     ...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
   };
 }
@@ -46803,6 +47122,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;
@@ -46826,6 +47146,7 @@ function createEditorSurfaceSnapshot(document2, _selection, activeStory = { kind
       activeStory.kind !== "main",
       !isInViewport,
       editableTargetsByBlockPath,
+      layoutIdentitiesByBlockPath,
       `${activeStoryBlockPathBase}/block[${index}]`
     );
     if (isInViewport) {
@@ -46892,7 +47213,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;
@@ -46929,6 +47250,7 @@ function createSurfaceBlock(block, document2, cursor, counters, formattingContex
       promoteSecondaryStoryTextBoxes,
       cullBuild,
       editableTargetsByBlockPath,
+      layoutIdentitiesByBlockPath,
       blockPath
     );
   }
@@ -46969,6 +47291,7 @@ function createSurfaceBlock(block, document2, cursor, counters, formattingContex
       promoteSecondaryStoryTextBoxes,
       cullBuild,
       editableTargetsByBlockPath,
+      layoutIdentitiesByBlockPath,
       blockPath
     );
   }
@@ -47051,10 +47374,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) {
@@ -47071,6 +47395,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);
@@ -47086,6 +47411,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: []
       },
@@ -47123,6 +47449,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);
@@ -47211,6 +47538,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 } : {},
@@ -47398,7 +47726,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;
@@ -47415,6 +47743,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);
@@ -47457,7 +47786,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;
@@ -47480,6 +47809,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 ? {
@@ -54146,9 +54476,327 @@ function createEmpiricalProvider() {
   return createEmpiricalBackend();
 }
 
+// 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 cacheKey = serializeCacheKey(key);
+      const entry = entries.get(cacheKey);
+      if (!entry) {
+        counters.misses += 1;
+        return void 0;
+      }
+      entries.delete(cacheKey);
+      entries.set(cacheKey, entry);
+      counters.hits += 1;
+      return entry.value;
+    },
+    set(key, value) {
+      const cacheKey = serializeCacheKey(key);
+      const previous = entries.get(cacheKey);
+      if (previous) {
+        counters.estimatedBytes -= previous.estimatedBytes;
+        entries.delete(cacheKey);
+      }
+      const estimatedBytes = estimateBytes(key, value);
+      entries.set(cacheKey, { 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 [cacheKey, entry] of entries) {
+        if (!predicate(entry.key)) continue;
+        counters.estimatedBytes -= entry.estimatedBytes;
+        entries.delete(cacheKey);
+        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 fnv1a3(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 fnv1a3(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-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;
@@ -54344,8 +54992,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();
@@ -54445,13 +55107,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,
@@ -54563,10 +55232,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];
@@ -54595,7 +55272,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,
@@ -54727,7 +55403,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;
@@ -54812,7 +55492,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;
@@ -54841,6 +55525,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
@@ -58865,7 +59553,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",
@@ -60600,25 +61288,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;
   }
@@ -60775,70 +61454,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",
@@ -60966,36 +61828,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) };
 }