@beyondwork/docx-react-component 1.0.128 → 1.0.130

package/dist/{chunk-XRACP43Q.js → chunk-7G5GR3VV.js}

@@ -7,30 +7,31 @@ import {
   resolveSectionForStoryTarget,
   searchSecondaryStories,
   searchSurfaceBlocks
-} from "./chunk-YHZHPXDB.js";
+} from "./chunk-THVM6EP5.js";
 import {
   createEditorSurfaceSnapshot,
   createFormattingContext,
   resolveTableStyleResolution
-} from "./chunk-CXSYRB37.js";
+} from "./chunk-A3GSNB4G.js";
 import {
   createSelectionSnapshot
 } from "./chunk-OYGMRRR7.js";
 import {
   normalizeParsedTextDocument
-} from "./chunk-ESJ2MES5.js";
+} from "./chunk-4YCWECLZ.js";
 import {
   buildFieldRegistry,
   parseMainDocumentXml,
   parseTocLevelRange
-} from "./chunk-4YJVRIUB.js";
+} from "./chunk-M7YRJX6V.js";
 import {
   collectEditableTargetRefs,
+  collectLayoutInputIdentities,
   validateEditableTargetRef
-} from "./chunk-5DGKFNQT.js";
+} from "./chunk-A66ZVUAT.js";
 import {
   serializeMainDocument
-} from "./chunk-EB6M3GE6.js";
+} from "./chunk-FM4K4XFJ.js";
 import {
   findOpaqueFragmentsIntersectingRange
 } from "./chunk-UFVDIR2C.js";
@@ -858,6 +859,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":
@@ -996,6 +1003,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",
@@ -1700,6 +1712,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;
@@ -2288,6 +2349,8 @@ function compileScope(entry, optionsOrCatalog) {
       });
     case "field":
       return compileFieldScope(entry);
+    case "image":
+      return compileImageScope(entry);
     case "comment-thread":
       return compileCommentThreadScope(entry);
     case "revision":
@@ -2476,6 +2539,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(document, documentId) {
   const review = document.review;
   const comments = review?.comments;
@@ -2606,6 +2707,8 @@ function enumerateScopes(document, 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") {
@@ -2995,6 +3098,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]);
 }
@@ -3539,6 +3651,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),
@@ -3555,7 +3696,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)
   };
 }
 
@@ -3827,6 +3969,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;
   }
@@ -3910,6 +4057,19 @@ function paragraphHasBookmarkId(paragraph, bookmarkId) {
 function commandActionHandleForAddress(commandFamily, address) {
   return address ? `scope-command:${commandFamily}:${address.addressKey}` : void 0;
 }
+function layoutIdentityIndexes(document) {
+  const byTargetKey = /* @__PURE__ */ new Map();
+  const byStoryBlockPath = /* @__PURE__ */ new Map();
+  for (const identity of collectLayoutInputIdentities(document)) {
+    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 {
@@ -3921,6 +4081,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) {
@@ -4020,13 +4198,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";
@@ -4351,19 +4532,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"]
@@ -4510,7 +4693,7 @@ function readbackForTarget(document, target, runtimeTextCommand) {
     source: "canonical-text-leaf"
   };
 }
-function projectTarget(document, target, relation, workflowBlockers, scopeKind) {
+function projectTarget(document, target, relation, workflowBlockers, scopeKind, layoutIdentity) {
   const runtimeTextCommand = runtimeTextCommandEvidence(target, workflowBlockers);
   const readback = readbackForTarget(document, target, runtimeTextCommand);
   return {
@@ -4531,6 +4714,7 @@ function projectTarget(document, 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]) } : {},
@@ -4546,7 +4730,7 @@ function deriveScopeEditableTargetEvidence(document, scope, entry, options = {})
     facts.push(projectWorkflowBlockerFact(fact));
     factsByTargetKey.set(fact.targetKey, facts);
   }
-  const entries = collectEditableTargetRefs(document, options.editableTargetCache).map((target) => {
+  const relatedTargets = collectEditableTargetRefs(document, options.editableTargetCache).map((target) => {
     const relation = relationForTarget(target, scope, entry);
     if (!relation) return null;
     const workflowBlockers = Object.freeze(
@@ -4554,8 +4738,19 @@ function deriveScopeEditableTargetEvidence(document, scope, entry, options = {})
         (left, right) => left.source.localeCompare(right.source) || left.blocker.localeCompare(right.blocker) || left.refusalId.localeCompare(right.refusalId)
       )
     );
-    return projectTarget(document, 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(document) : void 0;
+  const entries = relatedTargets.map(
+    ({ target, relation, workflowBlockers }) => projectTarget(
+      document,
+      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) {
@@ -4574,6 +4769,114 @@ function deriveScopeEditableTargetEvidence(document, scope, entry, options = {})
   };
 }
 
+// src/runtime/scopes/object-evidence.ts
+var OBJECT_INTENTS = /* @__PURE__ */ new Set([
+  "image-layout",
+  "image-frame",
+  "chart-edit",
+  "custom-xml-update",
+  "embedded-content-update",
+  "opaque-content-preserve",
+  "object-edit",
+  "preserve-only-refusal"
+]);
+function unique(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 unique([
+    ...entry.posture.blockers,
+    ...entry.runtimeCommand.blockers ?? [],
+    ...entry.runtimeTextCommand.blockers ?? [],
+    ...(entry.workflowBlockers ?? []).flatMap((blocker) => [
+      blocker.blocker,
+      blocker.refusalId
+    ]),
+    entry.runtimeCommand.status === "blocked" ? entry.runtimeCommand.reason : ""
+  ]);
+}
+function projectEntry2(entry) {
+  const blockers = blockersFor(entry);
+  return {
+    targetKey: entry.targetKey,
+    kind: entry.kind,
+    ...entry.object?.objectKind ? { objectKind: entry.object.objectKind } : {},
+    relation: entry.relation,
+    commandFamily: entry.commandFamily,
+    editability: entry.editability,
+    ...entry.sourceRef ? { sourceRef: entry.sourceRef } : {},
+    ...entry.object ? { object: entry.object } : {},
+    runtimeCommand: entry.runtimeCommand,
+    blockers,
+    ...entry.posture.preserveOnly ? { preserveOnly: true } : {}
+  };
+}
+function 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: unique(sortedEntries.map((entry) => entry.targetKey)),
+    relations: unique(sortedEntries.map((entry) => entry.relation)),
+    commandFamilies: unique(sortedEntries.map((entry) => entry.commandFamily)),
+    runtimeIntents: unique(
+      sortedEntries.flatMap((entry) => [...entry.runtimeCommand.intents])
+    ),
+    blockers: unique(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 = unique(entries.flatMap((entry) => [...entry.blockers]));
+  const families = summarizeFamilies(entries);
+  return {
+    status: entries.length > 0 ? "present" : "none",
+    count: entries.length,
+    blockers,
+    families,
+    entries
+  };
+}
+
 // src/runtime/scopes/table-evidence.ts
 function isTableFamilyEntry(entry) {
   return entry?.kind === "table" || entry?.kind === "table-row" || entry?.kind === "table-cell";
@@ -5143,7 +5446,7 @@ function deriveScopeGeometryEvidence(scopeId, provider, context) {
 function freezeList2(values) {
   return values ? Object.freeze([...values]) : void 0;
 }
-function unique(values) {
+function unique2(values) {
   return Object.freeze([...new Set(values)]);
 }
 function parseTableFamilyScopeId2(scopeId) {
@@ -5173,7 +5476,7 @@ function candidateTableBlockIds(blockIndex, mapped) {
   const mappedId = mapped?.get(blockIndex);
   if (mappedId) ids.push(mappedId);
   ids.push(`table-${blockIndex}`, `table:${blockIndex}`, `block-${blockIndex}`);
-  return unique(ids);
+  return unique2(ids);
 }
 function rowInFragment(fragment, rowIndex) {
   const range = fragment.tableRowRange;
@@ -5210,19 +5513,19 @@ function projectTableFramePage(fragment) {
     ...fragment.tableRowRange ? { rowRange: { ...fragment.tableRowRange } } : {},
     ...fragment.continuation?.continuesFromPreviousPage !== void 0 ? { continuesFromPreviousPage: fragment.continuation.continuesFromPreviousPage } : {},
     ...fragment.continuation?.continuesToNextPage !== void 0 ? { continuesToNextPage: fragment.continuation.continuesToNextPage } : {},
-    ...repeated ? { repeatedHeaderRowIndexes: unique(repeated) } : {},
+    ...repeated ? { repeatedHeaderRowIndexes: unique2(repeated) } : {},
     ...splitRowCarry ? { splitRowCarry: Object.freeze(splitRowCarry.map((item) => ({ ...item }))) } : {},
     ...carry ? { verticalMergeCarry: Object.freeze(carry.map((item) => ({ ...item }))) } : {}
   };
 }
 function projectTableFrame(blockId, parsed, fragments) {
-  const pageIds = unique(fragments.map((fragment) => fragment.pageId));
-  const pageSliceIds = unique(fragments.map((fragment) => fragment.fragmentId));
-  const layoutObjectIds = unique(
+  const pageIds = unique2(fragments.map((fragment) => fragment.pageId));
+  const pageSliceIds = unique2(fragments.map((fragment) => fragment.fragmentId));
+  const layoutObjectIds = unique2(
     fragments.map((fragment) => fragment.layoutObject?.objectId).filter((objectId) => typeof objectId === "string" && objectId.length > 0)
   );
   const rowRangesByPage = Object.freeze(fragments.map(projectTableFramePage));
-  const repeatedHeaderRowIndexes = unique(
+  const repeatedHeaderRowIndexes = unique2(
     fragments.flatMap((fragment) => fragment.continuation?.repeatedHeaderRowIndexes ?? [])
   );
   const verticalMergeCarry = Object.freeze(
@@ -5247,7 +5550,7 @@ function projectTableFrame(blockId, parsed, fragments) {
   };
 }
 function continuationFromTableFrame(fragments) {
-  const pageIds = unique(fragments.map((fragment) => fragment.pageId));
+  const pageIds = unique2(fragments.map((fragment) => fragment.pageId));
   return {
     ...pageIds.length > 0 ? { pageIds } : {},
     pageCount: pageIds.length,
@@ -5545,6 +5848,7 @@ function composeEvidence(inputs) {
     ...editableTargets ? { editableTargets } : {},
     layout
   });
+  const objects = deriveScopeObjectEvidence(editableTargets);
   return {
     formattingSummary: formattingSummaryOf(scope),
     reviewItemIds,
@@ -5555,6 +5859,7 @@ function composeEvidence(inputs) {
     ...adjacentGeometry ? { adjacentGeometry } : {},
     visualization: deriveScopeVisualization(scope),
     ...editableTargets ? { editableTargets } : {},
+    objects,
     ...table ? { table } : {},
     contentControls,
     capabilities,
@@ -8599,6 +8904,133 @@ function sortJson(value) {
   return value;
 }
 
+// src/io/ooxml/numbering-catalog-mutation.ts
+function cloneNumberingCatalog(catalog) {
+  return structuredClone(catalog);
+}
+function getListKind(catalog, numberingInstanceId) {
+  const instance = catalog.instances[numberingInstanceId];
+  const definition = instance ? catalog.abstractDefinitions[instance.abstractNumberingId] : void 0;
+  const levelZero = definition?.levels.find((level) => level.level === 0);
+  if (!levelZero) return void 0;
+  return levelZero.format === "bullet" ? "bulleted" : "numbered";
+}
+function ensureDefaultListInstance(catalog, kind) {
+  const existing = Object.values(catalog.instances).find(
+    (instance) => getListKind(catalog, instance.numberingInstanceId) === kind
+  );
+  if (existing) return existing.numberingInstanceId;
+  const abstractNumberingId = allocateAbstractDefinition(catalog, {
+    levels: defaultLevels(kind),
+    multiLevelType: "hybridMultilevel"
+  });
+  return allocateNumberingInstance(catalog, abstractNumberingId);
+}
+function allocateNumberingInstance(catalog, abstractNumberingId, overrides = []) {
+  const numberingInstanceId = nextCanonicalNumericId(
+    "num:",
+    Object.keys(catalog.instances)
+  );
+  catalog.instances[numberingInstanceId] = {
+    numberingInstanceId,
+    abstractNumberingId,
+    overrides: cloneOverrides(overrides)
+  };
+  return numberingInstanceId;
+}
+function allocateAbstractDefinition(catalog, input) {
+  const abstractNumberingId = input.abstractNumberingId && !catalog.abstractDefinitions[input.abstractNumberingId] ? input.abstractNumberingId : nextCanonicalNumericId("abstract-num:", Object.keys(catalog.abstractDefinitions));
+  catalog.abstractDefinitions[abstractNumberingId] = {
+    abstractNumberingId,
+    levels: structuredClone(input.levels),
+    ...input.nsid ? { nsid: input.nsid } : { nsid: freshLongHex(catalog, abstractNumberingId, "nsid") },
+    ...input.multiLevelType ? { multiLevelType: input.multiLevelType } : {},
+    ...input.tplc ? { tplc: input.tplc } : { tplc: freshLongHex(catalog, abstractNumberingId, "tmpl") },
+    ...input.styleLink ? { styleLink: input.styleLink } : {},
+    ...input.numStyleLink ? { numStyleLink: input.numStyleLink } : {}
+  };
+  return abstractNumberingId;
+}
+function setStartOverride(catalog, numberingInstanceId, level, startAt) {
+  const instance = catalog.instances[numberingInstanceId];
+  if (!instance) return;
+  catalog.instances[numberingInstanceId] = {
+    ...instance,
+    overrides: mergeOverride(instance.overrides, { level, startAt })
+  };
+}
+function mergeOverride(overrides, nextOverride) {
+  return [
+    ...overrides.filter((override) => override.level !== nextOverride.level),
+    structuredClone(nextOverride)
+  ].sort((left, right) => left.level - right.level);
+}
+function cloneOverrides(overrides) {
+  return overrides.map((override) => structuredClone(override));
+}
+function defaultLevels(kind) {
+  if (kind === "bulleted") {
+    return [
+      { level: 0, format: "bullet", text: "\u2022" },
+      { level: 1, format: "bullet", text: "o" },
+      { level: 2, format: "bullet", text: "\u25A0" },
+      { level: 3, format: "bullet", text: "\u2022" },
+      { level: 4, format: "bullet", text: "o" },
+      { level: 5, format: "bullet", text: "\u25A0" },
+      { level: 6, format: "bullet", text: "\u2022" },
+      { level: 7, format: "bullet", text: "o" },
+      { level: 8, format: "bullet", text: "\u25A0" }
+    ];
+  }
+  return [
+    { level: 0, format: "decimal", text: "%1." },
+    { level: 1, format: "decimal", text: "%1.%2." },
+    { level: 2, format: "lowerLetter", text: "(%3)" },
+    { level: 3, format: "lowerRoman", text: "(%4)" },
+    { level: 4, format: "decimal", text: "%5." },
+    { level: 5, format: "lowerLetter", text: "(%6)" },
+    { level: 6, format: "lowerRoman", text: "(%7)" },
+    { level: 7, format: "decimal", text: "%8." },
+    { level: 8, format: "lowerLetter", text: "(%9)" }
+  ];
+}
+function nextCanonicalNumericId(prefix, ids) {
+  return `${prefix}${nextNumericString(ids.map((id) => stripPrefix(id, prefix)))}`;
+}
+function nextNumericString(ids) {
+  const used = new Set(ids);
+  let next = 1;
+  for (const id of ids) {
+    const parsed = Number.parseInt(id, 10);
+    if (Number.isFinite(parsed) && parsed >= next) next = parsed + 1;
+  }
+  while (used.has(String(next))) next += 1;
+  return String(next);
+}
+function stripPrefix(value, prefix) {
+  return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+}
+function freshLongHex(catalog, abstractNumberingId, salt) {
+  const existing = new Set(
+    Object.values(catalog.abstractDefinitions).map((definition) => salt === "nsid" ? definition.nsid : definition.tplc).filter((value) => Boolean(value))
+  );
+  let attempt = 0;
+  while (attempt < 1e3) {
+    const candidate = hashLongHex(`${salt}:${abstractNumberingId}:${attempt}`);
+    if (!existing.has(candidate)) return candidate;
+    attempt += 1;
+  }
+  return hashLongHex(`${salt}:${abstractNumberingId}:${Date.now()}`);
+}
+function hashLongHex(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).toUpperCase().padStart(8, "0").slice(-8);
+}
+
 // src/runtime/formatting/projector.ts
 function buildFormattingDebugEntry(inputs) {
   const { doc, revisionMarkupMode, recentSamples } = inputs;
@@ -8620,6 +9052,11 @@ function buildFormattingDebugEntry(inputs) {
 }
 
 export {
+  cloneNumberingCatalog,
+  getListKind,
+  ensureDefaultListInstance,
+  allocateNumberingInstance,
+  setStartOverride,
   collectScopeLocations,
   resolveScope,
   findAllScopesAt,