@beyondwork/docx-react-component 1.0.128 → 1.0.129

package/dist/api/v3.cjs

@@ -18852,7 +18852,7 @@ function parseNumberingXml(xml, context) {
         abstractDefinitions[abstractNumberingId] = {
           abstractNumberingId,
           ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "abstractNum", rawId, childXmlPath) } : {},
-          levels: readLevels(child),
+          levels: readLevels(child, context, childXmlPath, rawId),
           ...nsid ? { nsid } : {},
           ...multiLevelType ? { multiLevelType } : {},
           ...tplc ? { tplc } : {},
@@ -18873,7 +18873,7 @@ function parseNumberingXml(xml, context) {
           numberingInstanceId,
           ...context?.partPath !== void 0 ? { sourceRef: createNumberingSourceRef(context.partPath, "num", rawId, childXmlPath) } : {},
           abstractNumberingId: toCanonicalAbstractNumberingId(rawAbstractId),
-          overrides: readOverrides(child)
+          overrides: readOverrides(child, context, childXmlPath, rawId)
         };
         break;
       }
@@ -18894,6 +18894,16 @@ function createNumberingSourceRef(partPath, element, rawId, xmlPath) {
     ...xmlPath !== void 0 ? { xmlPath } : {}
   };
 }
+function createNumberingChildSourceRef(partPath, element, sourceIdSuffix, xmlPath) {
+  if (partPath === void 0) return void 0;
+  return {
+    sourceId: `part:${partPath}#${sourceIdSuffix}`,
+    partPath,
+    storyKind: "numbering",
+    element,
+    ...xmlPath !== void 0 ? { xmlPath } : {}
+  };
+}
 function readNumPicBullet(node, numPicBulletId, context, xmlPath) {
   let widthEmu;
   let heightEmu;
@@ -18970,18 +18980,29 @@ function toCanonicalAbstractNumberingId(value) {
 function toCanonicalNumberingInstanceId(value) {
   return value.startsWith("num:") ? value : `num:${value}`;
 }
-function readLevels(abstractNode) {
+function readLevels(abstractNode, context, abstractXmlPath, rawAbstractId) {
   const levels = [];
+  let levelOrdinal = 0;
   for (const child of abstractNode.children) {
     if (child.type !== "element" || localName(child.name) !== "lvl") {
       continue;
     }
+    levelOrdinal += 1;
     const rawLevel = readStringAttr(child, "w:ilvl");
     const level = rawLevel === void 0 ? void 0 : parseInteger(rawLevel);
     if (level === void 0) {
       continue;
     }
-    const definition = readLevelDefinition(child, level);
+    const definition = readLevelDefinition(
+      child,
+      level,
+      createNumberingChildSourceRef(
+        context?.partPath,
+        "lvl",
+        `abstractNum:${rawAbstractId}:lvl:${level}`,
+        `${abstractXmlPath}/lvl[${levelOrdinal}]`
+      )
+    );
     if (!definition) {
       continue;
     }
@@ -18989,12 +19010,14 @@ function readLevels(abstractNode) {
   }
   return levels.sort((left, right) => left.level - right.level);
 }
-function readOverrides(numNode) {
+function readOverrides(numNode, context, numXmlPath, rawNumId) {
   const overrides = [];
+  let overrideOrdinal = 0;
   for (const child of numNode.children) {
     if (child.type !== "element" || localName(child.name) !== "lvlOverride") {
       continue;
     }
+    overrideOrdinal += 1;
     const rawLevel = readStringAttr(child, "w:ilvl");
     const level = rawLevel === void 0 ? void 0 : parseInteger(rawLevel);
     if (level === void 0) {
@@ -19004,8 +19027,26 @@ function readOverrides(numNode) {
     const rawStart = startOverrideNode ? readStringAttr(startOverrideNode, "w:val") : void 0;
     const startAt = rawStart === void 0 ? void 0 : parseInteger(rawStart);
     const levelDefinitionNode = findChildElementOptional2(child, "lvl");
-    const levelDefinition = levelDefinitionNode ? readLevelOverrideDefinition(levelDefinitionNode, level) : void 0;
+    const overrideXmlPath = `${numXmlPath}/lvlOverride[${overrideOrdinal}]`;
+    const levelDefinition = levelDefinitionNode ? readLevelOverrideDefinition(
+      levelDefinitionNode,
+      level,
+      createNumberingChildSourceRef(
+        context?.partPath,
+        "lvl",
+        `num:${rawNumId}:lvlOverride:${level}:lvl`,
+        `${overrideXmlPath}/lvl[1]`
+      )
+    ) : void 0;
     overrides.push({
+      ...context?.partPath !== void 0 ? {
+        sourceRef: createNumberingChildSourceRef(
+          context.partPath,
+          "lvlOverride",
+          `num:${rawNumId}:lvlOverride:${level}`,
+          overrideXmlPath
+        )
+      } : {},
       level,
       ...startAt !== void 0 ? { startAt } : {},
       ...levelDefinition ? { levelDefinition } : {}
@@ -19013,7 +19054,7 @@ function readOverrides(numNode) {
   }
   return overrides.sort((left, right) => left.level - right.level);
 }
-function readLevelDefinition(levelNode, fallbackLevel) {
+function readLevelDefinition(levelNode, fallbackLevel, sourceRef) {
   const rawLevel = readStringAttr(levelNode, "w:ilvl");
   const level = rawLevel === void 0 ? fallbackLevel : parseInteger(rawLevel);
   if (level === void 0) {
@@ -19043,6 +19084,7 @@ function readLevelDefinition(levelNode, fallbackLevel) {
   const lvlPicBulletNode = findChildElementOptional2(levelNode, "lvlPicBulletId");
   const picBulletId = lvlPicBulletNode ? readStringAttr(lvlPicBulletNode, "w:val") : void 0;
   return {
+    ...sourceRef ? { sourceRef } : {},
     level,
     format,
     text,
@@ -19056,7 +19098,7 @@ function readLevelDefinition(levelNode, fallbackLevel) {
     ...picBulletId !== void 0 ? { picBulletId } : {}
   };
 }
-function readLevelOverrideDefinition(levelNode, fallbackLevel) {
+function readLevelOverrideDefinition(levelNode, fallbackLevel, sourceRef) {
   const rawLevel = readStringAttr(levelNode, "w:ilvl");
   const level = rawLevel === void 0 ? fallbackLevel : parseInteger(rawLevel);
   if (level === void 0) {
@@ -19090,6 +19132,7 @@ function readLevelOverrideDefinition(levelNode, fallbackLevel) {
     return void 0;
   }
   return {
+    ...sourceRef ? { sourceRef } : {},
     level,
     ...startAt !== void 0 ? { startAt } : {},
     ...format !== void 0 ? { format } : {},
@@ -32578,7 +32621,7 @@ async function computeStructuralHash(blocks) {
 }
 
 // src/runtime/layout/layout-engine-version.ts
-var LAYOUT_ENGINE_VERSION = 88;
+var LAYOUT_ENGINE_VERSION = 89;
 var LAYCACHE_SCHEMA_VERSION = 12;
 
 // src/runtime/prerender/customxml-cache.ts
@@ -33232,6 +33275,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]);
 }
@@ -33776,6 +33828,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),
@@ -33792,7 +33873,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)
   };
 }
 
@@ -34041,6 +34123,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":
@@ -34167,6 +34255,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;
   }
@@ -35913,6 +36006,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",
@@ -37093,12 +37191,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)) {
@@ -37129,56 +37228,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;
@@ -37832,12 +38023,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;
@@ -39092,6 +39307,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;
@@ -39675,6 +39939,8 @@ function compileScope(entry, optionsOrCatalog) {
       });
     case "field":
       return compileFieldScope(entry);
+    case "image":
+      return compileImageScope(entry);
     case "comment-thread":
       return compileCommentThreadScope(entry);
     case "revision":
@@ -39863,6 +40129,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_STORY,
+      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;
@@ -39993,6 +40297,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") {
@@ -40444,6 +40750,64 @@ function createIssue(runtime, input) {
   };
 }
 
+// src/runtime/scopes/object-evidence.ts
+var OBJECT_INTENTS = /* @__PURE__ */ new Set([
+  "image-layout",
+  "image-frame",
+  "chart-edit",
+  "custom-xml-update",
+  "embedded-content-update",
+  "opaque-content-preserve",
+  "object-edit",
+  "preserve-only-refusal"
+]);
+function unique2(values) {
+  return Object.freeze([...new Set(values.filter((value) => value.length > 0))]);
+}
+function isObjectTarget(entry) {
+  return entry.object !== void 0 || entry.kind === "object-anchor" || entry.kind === "custom-xml-content" || entry.kind === "opaque-content" || entry.commandFamily === "object" || entry.runtimeCommand.intents.some((intent) => OBJECT_INTENTS.has(intent));
+}
+function blockersFor(entry) {
+  return unique2([
+    ...entry.posture.blockers,
+    ...entry.runtimeCommand.blockers ?? [],
+    ...entry.runtimeTextCommand.blockers ?? [],
+    ...(entry.workflowBlockers ?? []).flatMap((blocker2) => [
+      blocker2.blocker,
+      blocker2.refusalId
+    ]),
+    entry.runtimeCommand.status === "blocked" ? entry.runtimeCommand.reason : ""
+  ]);
+}
+function projectEntry2(entry) {
+  const blockers = blockersFor(entry);
+  return {
+    targetKey: entry.targetKey,
+    kind: entry.kind,
+    ...entry.object?.objectKind ? { objectKind: entry.object.objectKind } : {},
+    relation: entry.relation,
+    commandFamily: entry.commandFamily,
+    editability: entry.editability,
+    ...entry.sourceRef ? { sourceRef: entry.sourceRef } : {},
+    ...entry.object ? { object: entry.object } : {},
+    runtimeCommand: entry.runtimeCommand,
+    blockers,
+    ...entry.posture.preserveOnly ? { preserveOnly: true } : {}
+  };
+}
+function 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/evidence.ts
 function anchorRange(anchor) {
   switch (anchor.kind) {
@@ -40626,6 +40990,7 @@ function composeEvidence(inputs) {
     ...editableTargets ? { editableTargets } : {},
     layout
   });
+  const objects = deriveScopeObjectEvidence(editableTargets);
   return {
     formattingSummary: formattingSummaryOf(scope),
     reviewItemIds,
@@ -40636,6 +41001,7 @@ function composeEvidence(inputs) {
     ...adjacentGeometry ? { adjacentGeometry } : {},
     visualization: deriveScopeVisualization(scope),
     ...editableTargets ? { editableTargets } : {},
+    objects,
     ...table ? { table } : {},
     contentControls,
     capabilities,
@@ -40832,6 +41198,10 @@ function extractNLHaystack(entry) {
       }
       return out.slice(0, 200).toLowerCase();
     }
+    case "image": {
+      const text = entry.image.type === "image" ? entry.image.altText ?? "" : entry.image.anchor.docPr?.descr ?? entry.image.anchor.docPr?.name ?? "";
+      return text.slice(0, 200).toLowerCase();
+    }
     case "table":
     case "table-row":
     case "table-cell":
@@ -50928,6 +51298,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,
@@ -51102,6 +51480,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;
@@ -52563,6 +52956,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) {
@@ -52648,6 +53044,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();
@@ -53160,13 +53573,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);
@@ -53174,11 +53585,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 [];
@@ -53298,8 +53706,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 ?? [
@@ -53339,7 +53746,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);
@@ -53349,7 +53756,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 = [];
@@ -55047,6 +55454,400 @@ function createViewportFamily(runtime) {
   };
 }
 
+// src/io/ooxml/numbering-catalog-mutation.ts
+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";
+}
+
+// src/api/v3/runtime/lists.ts
+var SUPPORTED_COMMANDS = [
+  "toggle-numbered",
+  "toggle-bulleted",
+  "indent",
+  "outdent",
+  "restart-numbering",
+  "continue-numbering"
+];
+var UNSUPPORTED_COMMANDS = [
+  "create",
+  "attach",
+  "detach",
+  "join",
+  "separate",
+  "split",
+  "set-value",
+  "apply-template",
+  "capture-template",
+  "apply-preset",
+  "set-level-numbering",
+  "set-level-bullet",
+  "set-level-picture-bullet",
+  "set-level-alignment",
+  "set-level-indents",
+  "set-level-trailing-character",
+  "set-level-marker-font",
+  "set-level-text",
+  "set-level-start",
+  "set-level-layout",
+  "convert-to-text",
+  "paste-fragment",
+  "drop-fragment"
+];
+var applyCommandMetadata = {
+  name: "runtime.lists.applyCommand",
+  status: "live-with-adapter",
+  sourceLayer: "runtime-core",
+  liveEvidence: {
+    runnerTest: "test/api/v3/runtime/lists.test.ts",
+    commit: "refactor-07-runtime-lists-namespace"
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "surface-refresh",
+    expectedDelta: "list structure changes through the L07 list command surface"
+  },
+  agentMetadata: { readOrMutate: "mutate", boundedScope: "scope", auditCategory: "list-command" },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  broadcastsVia: "crdt",
+  rwdReference: "\xA7Runtime API \xA7 runtime.lists.applyCommand. Dispatches only proven L07 list commands through opaque list targets; future commands return owner-routed blockers until command/export/readback support lands."
+};
+function createListsFamily(runtime) {
+  return {
+    list(input = {}) {
+      const document2 = runtime.getCanonicalDocument();
+      const rows = currentListTargets(document2).filter((entry) => input.storyKey === void 0 || entry.target.storyKey === input.storyKey).map((entry) => toReadback(document2, entry.target, entry.paragraph));
+      return input.limit === void 0 ? rows : rows.slice(0, Math.max(0, input.limit));
+    },
+    get(input) {
+      const resolved = resolveCurrentListTarget(runtime.getCanonicalDocument(), input);
+      return resolved.kind === "resolved" ? toReadback(runtime.getCanonicalDocument(), resolved.target, resolved.paragraph) : null;
+    },
+    previewCommand(input) {
+      return previewListCommand(runtime.getCanonicalDocument(), input);
+    },
+    applyCommand(input) {
+      const preview = previewListCommand(runtime.getCanonicalDocument(), input);
+      if (!preview.supported || !preview.target) {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: preview.blockers
+        };
+      }
+      const resolved = resolveCurrentListTarget(runtime.getCanonicalDocument(), {
+        addressKey: preview.target.addressKey
+      });
+      if (resolved.kind !== "resolved") {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: [resolved.blocker]
+        };
+      }
+      const command = editorCommandForListCommand(
+        input.command,
+        resolved.target,
+        runtime.now(),
+        input.startAt
+      );
+      if (!command) {
+        return {
+          applied: false,
+          command: input.command,
+          before: preview.target,
+          blockers: [
+            unsupportedCommandBlocker(input.command, {
+              targetKey: preview.target.targetKey,
+              addressKey: preview.target.addressKey
+            })
+          ]
+        };
+      }
+      const beforeDocument = runtime.getCanonicalDocument();
+      runtime.dispatch(command);
+      const afterDocument = runtime.getCanonicalDocument();
+      const after = resolveCurrentListTarget(afterDocument, { targetKey: preview.target.targetKey });
+      emitUxResponse(runtime, {
+        apiFn: applyCommandMetadata.name,
+        intent: applyCommandMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live",
+        uiVisible: true,
+        expectedDelta: applyCommandMetadata.uxIntent.expectedDelta
+      });
+      return {
+        applied: beforeDocument !== afterDocument,
+        command: input.command,
+        before: preview.target,
+        ...after.kind === "resolved" ? { after: toReadback(afterDocument, after.target, after.paragraph) } : {},
+        blockers: []
+      };
+    }
+  };
+}
+function previewListCommand(document2, input) {
+  const resolved = resolveCurrentListTarget(document2, input);
+  if (resolved.kind !== "resolved") {
+    return {
+      command: input.command,
+      supported: false,
+      affectedTargets: [],
+      blockers: [resolved.blocker]
+    };
+  }
+  const target = toReadback(document2, resolved.target, resolved.paragraph);
+  const targetRef = { targetKey: target.targetKey, addressKey: target.addressKey };
+  if (!SUPPORTED_COMMANDS.includes(input.command)) {
+    return {
+      command: input.command,
+      supported: false,
+      target,
+      affectedTargets: [target],
+      blockers: [unsupportedCommandBlocker(input.command, targetRef)]
+    };
+  }
+  const canContinuePrevious = canContinuePreviousSequence(document2, resolved.paragraphIndex);
+  const canJoin = canJoinPreviousSequence(document2, resolved.paragraphIndex);
+  const blockers = [];
+  if (input.command === "continue-numbering" && !canContinuePrevious) {
+    blockers.push({
+      code: "list-continue-target-missing",
+      ownerLayer: "L07",
+      message: "No previous compatible list sequence is available for continue-numbering.",
+      ...targetRef
+    });
+  }
+  return {
+    command: input.command,
+    supported: blockers.length === 0,
+    target,
+    affectedTargets: [target],
+    blockers,
+    canJoin,
+    canContinuePrevious
+  };
+}
+function editorCommandForListCommand(command, editableTarget, timestamp, startAt) {
+  const origin = { source: "api", timestamp };
+  switch (command) {
+    case "toggle-numbered":
+      return { type: "list.toggle", kind: "numbered", editableTargets: [editableTarget], origin };
+    case "toggle-bulleted":
+      return { type: "list.toggle", kind: "bulleted", editableTargets: [editableTarget], origin };
+    case "indent":
+      return { type: "list.indent", editableTargets: [editableTarget], origin };
+    case "outdent":
+      return { type: "list.outdent", editableTargets: [editableTarget], origin };
+    case "restart-numbering":
+      return {
+        type: "list.restart-numbering",
+        editableTarget,
+        ...startAt !== void 0 ? { startAt } : {},
+        origin
+      };
+    case "continue-numbering":
+      return { type: "list.continue-numbering", editableTarget, origin };
+    default:
+      return void 0;
+  }
+}
+function resolveCurrentListTarget(document2, input) {
+  if (input.editableTarget) {
+    const shapeIssues = validateEditableTargetRef(input.editableTarget);
+    if (shapeIssues.length > 0) {
+      return {
+        kind: "blocked",
+        blocker: {
+          code: "list-target-malformed",
+          ownerLayer: "L07",
+          message: `List target is malformed: ${shapeIssues[0]?.path ?? "$"}.`,
+          targetKey: input.editableTarget.targetKey,
+          addressKey: input.editableTarget.listAddress?.addressKey
+        }
+      };
+    }
+  }
+  const requestedTargetKey = input.editableTarget?.targetKey ?? input.targetKey;
+  const requestedAddressKey = input.editableTarget?.listAddress?.addressKey ?? input.addressKey;
+  if (!requestedTargetKey && !requestedAddressKey) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-required",
+        ownerLayer: "L07",
+        message: "runtime.lists requires a targetKey, addressKey, or editableTarget."
+      }
+    };
+  }
+  const currentTargets = currentListTargets(document2);
+  const resolved = currentTargets.find(
+    ({ target }) => requestedTargetKey !== void 0 && target.targetKey === requestedTargetKey || requestedAddressKey !== void 0 && target.listAddress?.addressKey === requestedAddressKey
+  );
+  if (!resolved) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-not-found",
+        ownerLayer: "L07",
+        message: "List target no longer resolves in the current canonical document.",
+        ...requestedTargetKey !== void 0 ? { targetKey: requestedTargetKey } : {},
+        ...requestedAddressKey !== void 0 ? { addressKey: requestedAddressKey } : {}
+      }
+    };
+  }
+  if (input.editableTarget && !sameTargetStaleHash(input.editableTarget, resolved.target)) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-stale",
+        ownerLayer: "L07",
+        message: "List target resolved by identity but stale discriminators changed.",
+        targetKey: input.editableTarget.targetKey,
+        addressKey: input.editableTarget.listAddress?.addressKey
+      }
+    };
+  }
+  if (resolved.target.editability !== "editable" || resolved.target.posture.blockers.length > 0) {
+    return {
+      kind: "blocked",
+      blocker: {
+        code: "list-target-non-editable",
+        ownerLayer: "L07",
+        message: resolved.target.posture.blockers.length > 0 ? `List target is not editable: ${resolved.target.posture.blockers.join(", ")}.` : "List target is not editable.",
+        targetKey: resolved.target.targetKey,
+        addressKey: resolved.target.listAddress?.addressKey
+      }
+    };
+  }
+  return { kind: "resolved", ...resolved };
+}
+function currentListTargets(document2) {
+  const paragraphs = collectParagraphEntries(document2.content.children, "main");
+  const targets = collectEditableTargetRefs(document2).filter(isListTextTarget);
+  const byBlockPath = /* @__PURE__ */ new Map();
+  for (const target of targets) byBlockPath.set(target.blockPath, target);
+  const out = [];
+  for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex += 1) {
+    const entry = paragraphs[paragraphIndex];
+    if (!entry?.paragraph.numbering) continue;
+    const target = byBlockPath.get(entry.blockPath);
+    if (!target) continue;
+    out.push({ target, paragraph: entry.paragraph, paragraphIndex });
+  }
+  return out;
+}
+function collectParagraphEntries(blocks, basePath) {
+  const out = [];
+  collectParagraphEntriesInto(blocks, basePath, out);
+  return out;
+}
+function collectParagraphEntriesInto(blocks, basePath, out) {
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+    const block = blocks[blockIndex];
+    if (!block) continue;
+    const blockPath = `${basePath}/block[${blockIndex}]`;
+    switch (block.type) {
+      case "paragraph":
+        out.push({ paragraph: block, blockPath });
+        break;
+      case "table":
+        for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+          const row = block.rows[rowIndex];
+          if (!row) continue;
+          for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+            const cell = row.cells[cellIndex];
+            if (!cell) continue;
+            collectParagraphEntriesInto(
+              cell.children,
+              `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`,
+              out
+            );
+          }
+        }
+        break;
+      case "sdt":
+        collectParagraphEntriesInto(block.children, blockPath, out);
+        break;
+      case "custom_xml":
+        break;
+      default:
+        break;
+    }
+  }
+}
+function isListTextTarget(target) {
+  return target.commandFamily === "text-leaf" && target.listAddress?.operationScope === "list-text" && target.listAddress.addressKind === "list-item-text";
+}
+function sameTargetStaleHash(left, right) {
+  return left.targetKey === right.targetKey && left.listAddress?.addressKey === right.listAddress?.addressKey && left.listAddress?.resolver?.staleHash === right.listAddress?.resolver?.staleHash && left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength && left.staleCheck.inlineCount === right.staleCheck.inlineCount;
+}
+function toReadback(document2, target, paragraph) {
+  const numbering = paragraph.numbering;
+  const instance = document2.numbering.instances[numbering.numberingInstanceId];
+  const listKind = instance ? getListKind(document2.numbering, numbering.numberingInstanceId) : void 0;
+  return {
+    targetKey: target.targetKey,
+    actionHandle: `list-action:${target.listAddress.addressKey}`,
+    kind: target.kind,
+    storyKey: target.storyKey,
+    blockPath: target.blockPath,
+    leafPath: target.leafPath,
+    addressKey: target.listAddress.addressKey,
+    numberingInstanceId: numbering.numberingInstanceId,
+    ...instance?.abstractNumberingId ? { abstractNumberingId: instance.abstractNumberingId } : {},
+    level: numbering.level,
+    ...listKind ? { listKind } : {},
+    editability: target.editability,
+    blockers: target.posture.blockers,
+    supportedCommands: SUPPORTED_COMMANDS,
+    unsupportedCommands: UNSUPPORTED_COMMANDS,
+    staleDiscriminators: {
+      paragraphTextHash: target.staleCheck.paragraphTextHash,
+      paragraphTextLength: target.staleCheck.paragraphTextLength,
+      inlineCount: target.staleCheck.inlineCount,
+      listAddressStaleHash: target.listAddress?.resolver?.staleHash
+    }
+  };
+}
+function canContinuePreviousSequence(document2, paragraphIndex) {
+  const paragraphs = collectParagraphEntries(document2.content.children, "main");
+  const current = paragraphs[paragraphIndex]?.paragraph;
+  if (!current?.numbering) return false;
+  const currentKind = getListKind(document2.numbering, current.numbering.numberingInstanceId);
+  if (!currentKind) return false;
+  for (let index = paragraphIndex - 1; index >= 0; index -= 1) {
+    const previous = paragraphs[index]?.paragraph;
+    if (!previous?.numbering) continue;
+    const previousKind = getListKind(document2.numbering, previous.numbering.numberingInstanceId);
+    return previousKind === currentKind && previous.numbering.numberingInstanceId !== current.numbering.numberingInstanceId;
+  }
+  return false;
+}
+function canJoinPreviousSequence(document2, paragraphIndex) {
+  const paragraphs = collectParagraphEntries(document2.content.children, "main");
+  const current = paragraphs[paragraphIndex]?.paragraph;
+  const previous = paragraphs[paragraphIndex - 1]?.paragraph;
+  if (!current?.numbering || !previous?.numbering) return false;
+  const currentKind = getListKind(document2.numbering, current.numbering.numberingInstanceId);
+  const previousKind = getListKind(document2.numbering, previous.numbering.numberingInstanceId);
+  return Boolean(currentKind) && currentKind === previousKind && current.numbering.numberingInstanceId !== previous.numbering.numberingInstanceId;
+}
+function unsupportedCommandBlocker(command, target) {
+  return {
+    code: "list-command-unsupported",
+    ownerLayer: "L07",
+    message: `runtime.lists.${command} is reserved but not implemented by the L07 command surface yet.`,
+    ...target.targetKey !== void 0 ? { targetKey: target.targetKey } : {},
+    ...target.addressKey !== void 0 ? { addressKey: target.addressKey } : {}
+  };
+}
+
 // src/api/v3/ai/_pe2-evidence.ts
 function copyCoverage(coverage) {
   return {
@@ -57400,6 +58201,17 @@ function createTableActionFamily(runtime) {
             operationScope: target.table?.operationScope
           });
         }
+        if (fragmentContent && fragmentContent.blocks.length === 0) {
+          return blockedResult(input, proposalId, {
+            code: `table-action-structured-fragment-empty:${input.operation.kind}`,
+            category: "unsupported-operation",
+            message: "Structured table text actions require a canonical document fragment with at least one block.",
+            nextStep: 'Retry with operation.content.kind="structured" and a CanonicalDocumentFragment whose blocks array contains the paragraph or table content to paste/drop.',
+            actionHandle: input.actionHandle,
+            operation: input.operation.kind,
+            operationScope: target.table?.operationScope
+          });
+        }
         const resolution2 = resolveEditableTextTarget({
           document: runtime.getCanonicalDocument(),
           surface: runtime.getRenderSnapshot().surface?.blocks ?? [],
@@ -57422,6 +58234,7 @@ function createTableActionFamily(runtime) {
           runtime.dispatch({
             type: "fragment.insert",
             fragment: fragmentContent,
+            selection: createSelectionSnapshot(resolution2.range.to, resolution2.range.to),
             editableTarget: target,
             origin: { source: "api", timestamp: nowUtc }
           });
@@ -57434,6 +58247,17 @@ function createTableActionFamily(runtime) {
           });
         }
         const changed2 = runtime.getCanonicalDocument() !== before2;
+        if (!changed2) {
+          return blockedResult(input, proposalId, {
+            code: `table-action-noop:${input.operation.kind}:${input.actionHandle}`,
+            category: "runtime-noop",
+            message: "The runtime accepted the table text target but the operation produced no document change.",
+            nextStep: "Refresh the table action list and verify the target is still editable, the payload is non-empty when required, and structured fragments are dispatched through a command-safe table text action.",
+            actionHandle: input.actionHandle,
+            operation: input.operation.kind,
+            operationScope: target.table?.operationScope
+          });
+        }
         const afterReadback = tableTextReadback(readEditableTargetText(runtime.getCanonicalDocument(), target));
         return {
           proposalId,
@@ -62615,7 +63439,8 @@ function createApiV3(handle, opts) {
     chart: createChartFamily(handle),
     search: createSearchFamily(handle),
     table: createTableFamily(handle),
-    viewport: createViewportFamily(handle)
+    viewport: createViewportFamily(handle),
+    lists: createListsFamily(handle)
   };
   const ui = opts?.ui ? createUiApi(handle, opts.ui) : void 0;
   const api = ui ? { runtime, ai, ui } : { runtime, ai };