@superdoc/mcp 1.2.1-next.2 → 1.2.1-next.4

package/dist/index.js

@@ -31314,7 +31314,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.15.1-next.2";
+var SDK_VERSION = "2.15.1-next.4";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { chmodSync, existsSync } from "node:fs";
@@ -118889,6 +118889,11 @@ function validateId(id, operationName) {
     });
   }
 }
+function validateContentControlId(id, operationName) {
+  if (id !== undefined && (typeof id !== "string" || id.length === 0)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} requires a non-empty 'contentControlId' string when provided.`);
+  }
+}
 function validateNamespace(namespace, operationName) {
   if (typeof namespace !== "string" || namespace.length === 0) {
     throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} requires a non-empty 'namespace' string.`, {
@@ -118956,6 +118961,14 @@ function executeAnchoredMetadataList(adapter, query2) {
 }
 function executeAnchoredMetadataGet(adapter, input) {
   validateId(input.id, "metadata.get");
+  validateContentControlId(input.contentControlId, "metadata.get");
+  if (input.contentControlId !== undefined) {
+    if (input.story === undefined)
+      return null;
+    validateStoryLocator(input.story, "metadata.get.story");
+    if (input.story.storyType !== "body")
+      return null;
+  }
   return adapter.get(input);
 }
 function executeAnchoredMetadataUpdate(adapter, input, options) {
@@ -118969,6 +118982,14 @@ function executeAnchoredMetadataRemove(adapter, input, options) {
 }
 function executeAnchoredMetadataResolve(adapter, input) {
   validateId(input.id, "metadata.resolve");
+  validateContentControlId(input.contentControlId, "metadata.resolve");
+  if (input.contentControlId !== undefined) {
+    if (input.story === undefined)
+      return null;
+    validateStoryLocator(input.story, "metadata.resolve.story");
+    if (input.story.storyType !== "body")
+      return null;
+  }
   return adapter.resolve(input);
 }
 var init_anchored_metadata = __esm(() => {
@@ -118976,6 +118997,7 @@ var init_anchored_metadata = __esm(() => {
   init_errors5();
   init_selection_target_validator();
   init_validation_primitives();
+  init_story_validator();
 });
 
 // ../../packages/document-api/dist/protection/protection.js
@@ -162777,7 +162799,7 @@ var init_collapsed_inline_insertion_site = __esm(() => {
 });
 
 // ../../../v2/editor-core/dist/document/transactions/compile-edit-text-inline-plan.js
-function planDirectInlineEdit(paragraphBytes, startOffset, endOffset, newText, collapsedObjectBoundary, collapsedInlineAffinity, inheritedNamespaceBindings = {}) {
+function planDirectInlineEdit(paragraphBytes, startOffset, endOffset, newText, collapsedObjectBoundary, collapsedInlineAffinity, inheritedNamespaceBindings = {}, collapsedOutsideContentControl = false) {
   const xml = TD21.decode(paragraphBytes);
   const model = parseParagraphInlineMap(xml, inheritedNamespaceBindings);
   const leaves = model.leaves();
@@ -162820,7 +162842,7 @@ function planDirectInlineEdit(paragraphBytes, startOffset, endOffset, newText, c
     if (beside)
       return beside;
   }
-  const scope = resolveEditScope(model.pieces, startOffset, endOffset, collapsedInlineAffinity);
+  const scope = resolveEditScope(model.pieces, startOffset, endOffset, collapsedInlineAffinity, collapsedOutsideContentControl);
   if (!scope.ok)
     return { ok: false, reason: scope.reason };
   const pieces = scope.pieces;
@@ -162832,7 +162854,7 @@ function planDirectInlineEdit(paragraphBytes, startOffset, endOffset, newText, c
     return { ok: false, reason: "invalid-range" };
   }
   const hasEditableLeaf = pieces.some((piece) => isVisibleText(piece) || isLiveControl(piece) || startOffset !== endOffset && isLiveNoteReference(piece));
-  if (!hasEditableLeaf) {
+  if (!hasEditableLeaf && !(collapsedOutsideContentControl && startOffset === endOffset && newText.length > 0)) {
     if (newText.length === 0 && scope.wrapperRemovalOps.length > 0) {
       return {
         ok: true,
@@ -162849,7 +162871,7 @@ function planDirectInlineEdit(paragraphBytes, startOffset, endOffset, newText, c
   }
   if (startOffset === endOffset) {
     const plan2 = planCollapsedInsert(paragraphBytes, xml, pieces, leaves, startOffset, newText, visibleLength === 0, inlineContext, collapsedInlineAffinity);
-    return plan2.ok && scope.requiresCollaborationSessionSync ? { ...plan2, requiresCollaborationSessionSync: true } : plan2;
+    return plan2.ok && (scope.requiresCollaborationSessionSync || collapsedOutsideContentControl) ? { ...plan2, requiresCollaborationSessionSync: true } : plan2;
   }
   const plan = planReplace(paragraphBytes, pieces, leaves, startOffset, endOffset, newText, scope.wrapperRemovalOps);
   return plan.ok && (scope.requiresCollaborationSessionSync || preservesCrossedBookmarks) ? { ...plan, requiresCollaborationSessionSync: true } : plan;
@@ -163441,13 +163463,13 @@ function hasNonWordMarkerAtCollapsedMoveBoundary(pieces, at, coordinateSpace = "
 function firstNonFieldRangeStartMarker(markers) {
   return markers.find((piece) => piece.role === "range-start" && !isFieldMarker(piece.markerKind)) ?? null;
 }
-function resolveEditScope(pieces, start, end, collapsedInlineAffinity) {
+function resolveEditScope(pieces, start, end, collapsedInlineAffinity, collapsedOutsideContentControl = false) {
   let current = pieces;
   let descended = false;
   let emptySdt;
   let requiresCollaborationSessionSync = false;
   for (;; ) {
-    const container = current.find((piece) => piece.kind === "container" && containerContainsRange(piece, start, end)) ?? (start === end ? findCollapsedEdgeContainer(current, start, collapsedInlineAffinity == null) : undefined);
+    const container = current.find((piece) => piece.kind === "container" && containerContainsRange(piece, start, end)) ?? (start === end ? findCollapsedEdgeContainer(current, start, collapsedInlineAffinity, collapsedOutsideContentControl) : undefined);
     if (!container) {
       if (start === end) {
         return {
@@ -163550,9 +163572,24 @@ function containerContainsRange(piece, start, end) {
     return piece.visibleStart < start && start < piece.visibleEnd;
   return piece.visibleStart <= start && end <= piece.visibleEnd;
 }
-function findCollapsedEdgeContainer(pieces, at, allowEmptySdt = false) {
+function findCollapsedEdgeContainer(pieces, at, collapsedInlineAffinity, collapsedOutsideContentControl = false) {
   const emptySdtsAtPoint = pieces.filter((piece) => piece.kind === "container" && piece.containerKind === "sdt" && piece.visibleStart === at && piece.visibleEnd === at);
-  return pieces.find((piece) => piece.kind === "container" && (allowEmptySdt && emptySdtsAtPoint.length === 1 && piece.containerKind === "sdt" && piece.visibleStart === at && piece.visibleEnd === at || piece.visibleEnd > piece.visibleStart && (piece.visibleStart === at && (piece.containerKind === "sdt" || !hasVisibleSiblingEndingAt(pieces, at)) || piece.visibleEnd === at && (piece.containerKind === "sdt" ? !hasVisibleSiblingStartingAt(pieces, at, "sdt") : !hasVisibleSiblingStartingAt(pieces, at)))));
+  return pieces.find((piece) => {
+    if (piece.kind !== "container")
+      return false;
+    if (collapsedOutsideContentControl && piece.containerKind === "sdt")
+      return false;
+    if (piece.visibleStart === piece.visibleEnd) {
+      return collapsedInlineAffinity == null && emptySdtsAtPoint.length === 1 && piece.containerKind === "sdt" && piece.visibleStart === at;
+    }
+    if (piece.visibleStart === at) {
+      return piece.containerKind === "sdt" ? collapsedInlineAffinity !== "upstream" : !hasVisibleSiblingEndingAt(pieces, at);
+    }
+    if (piece.visibleEnd === at) {
+      return piece.containerKind === "sdt" ? collapsedInlineAffinity !== "downstream" && !hasVisibleSiblingStartingAt(pieces, at, "sdt") : !hasVisibleSiblingStartingAt(pieces, at);
+    }
+    return false;
+  });
 }
 function planEmptySdtInsert(paragraphBytes, piece, newText) {
   const raw = piece.rawXml;
@@ -196194,7 +196231,7 @@ function rewriteLocalizedDirect(bytes, window2, op, inheritedNamespaceBindings =
       return rewritten;
     return { ok: true, bytes: TE16.encode(rewritten.xml), runPropertiesXml: "" };
   }
-  const plan = planDirectInlineEdit(paragraphBytes, op.on.startOffset, op.on.endOffset, op.newText, op.on.collapsedObjectBoundary, op.on.collapsedInlineAffinity, inheritedNamespaceBindings);
+  const plan = planDirectInlineEdit(paragraphBytes, op.on.startOffset, op.on.endOffset, op.newText, op.on.collapsedObjectBoundary, op.on.collapsedInlineAffinity, inheritedNamespaceBindings, op.on.collapsedOutsideContentControl);
   if (plan.ok) {
     return {
       ok: true,
@@ -209787,7 +209824,7 @@ function planCut(pieces, levelStart, input, rootPieces, chain = []) {
     if (strict.kind === "container" && strict.containerKind === "sdt" && input.allowMetadataAnchorSplit) {
       if (input.space === "tracked")
         return { kind: "reject", reason: "paragraph-split-point-unsupported" };
-      const chunks = anchoredMetadataChunks(strict, input.allocateWId);
+      const chunks = anchoredMetadataChunks(strict, input.allocateWId, input.knownMetadataAnchorIds, input.onMetadataAnchorClone);
       if (!chunks)
         return { kind: "reject", reason: "paragraph-split-point-unsupported" };
       return planCut(strict.children, chunks.contentStart, input, rootPieces, [
@@ -209843,7 +209880,7 @@ function wrapperChunks(piece) {
     contentStart: piece.charStart + openEnd
   };
 }
-function anchoredMetadataChunks(piece, allocateWId) {
+function anchoredMetadataChunks(piece, allocateWId, knownMetadataAnchorIds, onMetadataAnchorClone) {
   if (piece.children.length === 0)
     return null;
   const raw = piece.rawXml;
@@ -209857,16 +209894,23 @@ function anchoredMetadataChunks(piece, allocateWId) {
   const originalId = /<w:id w:val="\d+"\s*\/>/.exec(properties)?.[0];
   const alias = '<w:alias w:val="Anchored metadata"/>';
   const tag = /<w:tag w:val="[^"]+"\/>/.exec(normalizedProperties)?.[0];
+  const tagValue = tag ? /w:val="([^"]+)"/.exec(tag)?.[1] : null;
   const appearance = '<w15:appearance w15:val="hidden"/>';
   const plainText = "<w:text/>";
-  if (!id || !originalId || !tag || !normalizedProperties.includes(alias) || !normalizedProperties.includes(appearance) || !normalizedProperties.includes(plainText) || normalizedProperties !== `<w:sdtPr>${id}${alias}${tag}${appearance}${plainText}</w:sdtPr>`) {
+  const canonical = `<w:sdtPr>${id}${alias}${tag}${appearance}${plainText}</w:sdtPr>`;
+  const legacy = `<w:sdtPr>${id}${tag}${appearance}${plainText}</w:sdtPr>`;
+  if (!id || !originalId || !tag || !tagValue || !knownMetadataAnchorIds?.has(decodeXmlAttributeValue(tagValue)) || !normalizedProperties.includes(appearance) || !normalizedProperties.includes(plainText) || normalizedProperties !== canonical && !(normalizedProperties === legacy && knownMetadataAnchorIds?.has(decodeXmlAttributeValue(tagValue)))) {
     return null;
   }
   const originalPrefix = prefix[0];
   return {
     contentStart: piece.charStart + originalPrefix.length,
     close,
-    reopen: () => originalPrefix.replace(originalId, originalId.replace(/(w:val=")\d+/, (_match, attribute) => `${attribute}${allocateWId()}`))
+    reopen: () => {
+      const cloneId = String(allocateWId());
+      onMetadataAnchorClone?.(decodeXmlAttributeValue(tagValue), /\d+/.exec(originalId)[0], cloneId);
+      return originalPrefix.replace(originalId, originalId.replace(/(w:val=")\d+/, (_match, attribute) => `${attribute}${cloneId}`));
+    }
   };
 }
 function openTagEnd(raw) {
@@ -214161,7 +214205,9 @@ function prepareParagraphSplit(input) {
     space: input.coordinateSpace,
     allocateWId: input.allocateWId,
     atomicObjectsAsCaretSlots: true,
-    allowMetadataAnchorSplit: true
+    allowMetadataAnchorSplit: true,
+    knownMetadataAnchorIds: new Set(input.knownMetadataAnchorIds),
+    onMetadataAnchorClone: input.onMetadataAnchorClone
   });
   if (!slice.ok)
     return slice;
@@ -214196,6 +214242,64 @@ function renderPreparedParagraphSplit(split, trackedStamp) {
   const head = trackedStamp ? injectParagraphMarkTrackedMarker(split.headXml, "ins", trackedStamp) : split.headXml;
   return head + split.tailXml;
 }
+function prepareMetadataSplitStorage(state, bindings, clones) {
+  const perPart = {};
+  const preconditions = [];
+  const parts = new Map;
+  for (const clone3 of clones) {
+    const binding = bindings?.find((candidate2) => candidate2.id === clone3.id);
+    if (!binding || binding.physicalIds && !binding.physicalIds.includes(clone3.originalId))
+      return { ok: false };
+    const entries = parts.get(binding.partUri) ?? [];
+    entries.push({ ...clone3, physicalIds: binding.physicalIds });
+    parts.set(binding.partUri, entries);
+  }
+  for (const [partUri, entries] of parts) {
+    const bytes = state.packageBytes.get(partUri);
+    if (!bytes)
+      return { ok: false };
+    let xml = TD51.decode(bytes);
+    const updatedIds = new Map;
+    for (const entry of entries) {
+      let matched = 0;
+      let updated = 0;
+      xml = xml.replace(/<ref\b[^>]*>/g, (tag) => {
+        const rawId = /\bid="([^"]*)"/.exec(tag)?.[1];
+        if (rawId === undefined || decodeXmlAttributeValue(rawId) !== entry.id)
+          return tag;
+        matched += 1;
+        const bindingAttributes = [...tag.matchAll(/\bsdAnchorIdsV1\s*=\s*(['"])(.*?)\1/g)];
+        const currentIds = updatedIds.get(entry.id);
+        if (bindingAttributes.length > 1 || bindingAttributes.length === 0 && /\bsdAnchorIdsV1\b/.test(tag))
+          return tag;
+        const rawIds = bindingAttributes[0]?.[2];
+        if (rawIds !== undefined && decodeXmlAttributeValue(rawIds) !== (currentIds ?? entry.physicalIds)?.join(","))
+          return tag;
+        if (rawIds === undefined && (entry.physicalIds || currentIds))
+          return tag;
+        const ids = currentIds ?? entry.physicalIds ?? [entry.originalId];
+        if (ids.includes(entry.cloneId))
+          return tag;
+        const attribute = `sdAnchorIdsV1="${[...ids, entry.cloneId].join(",")}"`;
+        updatedIds.set(entry.id, [...ids, entry.cloneId]);
+        updated += 1;
+        return rawIds === undefined ? tag.replace(/>$/, ` ${attribute}>`) : tag.replace(bindingAttributes[0][0], attribute);
+      });
+      if (matched !== 1 || updated !== 1)
+        return { ok: false };
+    }
+    const patches = [{
+      kind: "replaceBytes",
+      order: 0,
+      startByte: 0,
+      endByte: bytes.length,
+      bytes: TE24.encode(xml)
+    }];
+    perPart[partUri] = { kind: "modify", patches };
+    preconditions.push(localizedByteWindowPrecondition2(partUri, bytes, patches));
+  }
+  return { ok: true, perPart, preconditions };
+}
 function runParagraphSplitCommit(input) {
   const op = input.op;
   if (input.options.expectedPackageRevision && input.options.expectedPackageRevision !== input.state.packageRevision) {
@@ -214211,12 +214315,15 @@ function runParagraphSplitCommit(input) {
   const provisionalParaId = op.provisionalParaId ?? mintParaId(input.state, input.state.packageRevision, target.entry.ordinal + 1);
   const tailParaId = provisionalParaId;
   const splitAllocatedWIds = [];
+  const metadataClones = [];
   const primarySplit = prepareParagraphSplit({
     paragraphXml: paraXml,
     partBytes: bytes,
     paragraphByteStart: target.entry.byteStart,
     offset: op.offset,
     coordinateSpace: op.coordinateSpace ?? "visible",
+    knownMetadataAnchorIds: op.knownMetadataAnchorIds,
+    onMetadataAnchorClone: (id, originalId, cloneId) => metadataClones.push({ id, originalId, cloneId }),
     tailParaId,
     allocateWId: () => {
       const wId = allocateRevisionWId(input.state);
@@ -214252,6 +214359,7 @@ function runParagraphSplitCommit(input) {
         paragraphByteStart: context.byteStart,
         offset: op.offset,
         coordinateSpace: op.coordinateSpace ?? "visible",
+        knownMetadataAnchorIds: op.knownMetadataAnchorIds,
         tailParaId,
         allocateWId: () => {
           const wId = splitAllocatedWIds[replayIndex++];
@@ -214278,6 +214386,9 @@ function runParagraphSplitCommit(input) {
   });
   if (!counterpartRewrite.ok)
     return rejected8(input.txId, counterpartRewrite.reason);
+  const metadataStorage = prepareMetadataSplitStorage(input.state, op.metadataAnchorBindings, metadataClones);
+  if (!metadataStorage.ok)
+    return rejected8(input.txId, "paragraph-split-point-unsupported");
   const patch = counterpartRewrite.plan?.patch ?? {
     kind: "replaceBytes",
     order: 0,
@@ -214291,6 +214402,8 @@ function runParagraphSplitCommit(input) {
     partUri: target.entry.partUri,
     partBytes: bytes,
     patches: [patch],
+    extraPerPart: metadataStorage.perPart,
+    extraPreconditions: metadataStorage.preconditions,
     textRangeShifts: [],
     createdRefs: [
       { kind: "block", nodeId: tailParaId, storyId: op.target.storyId },
@@ -271814,7 +271927,7 @@ function ensureCustomXmlPartForNamespace(context, namespace) {
   return listCustomXmlRecords(context).find((record3) => record3.rootNamespace === namespace) ?? null;
 }
 function buildMetadataStorageXml(namespace, refs) {
-  const body = refs.map((ref5) => `<ref id="${xmlEscapeAttr(ref5.id)}" encoding="json">${xmlEscapeAttr(ref5.payloadJson)}</ref>`).join("");
+  const body = refs.map((ref5) => `<ref id="${xmlEscapeAttr(ref5.id)}" encoding="json"${ref5.physicalIds === undefined ? "" : ` sdAnchorIdsV1="${xmlEscapeAttr(ref5.physicalIds?.join(",") ?? "")}"`}>${xmlEscapeAttr(ref5.payloadJson)}</ref>`).join("");
   return `<refs xmlns="${xmlEscapeAttr(namespace)}">${body}</refs>`;
 }
 function buildCustomXmlCreateUpdates(context, input) {
@@ -292203,8 +292316,13 @@ class V2SelectionMutationAdapter {
     const tx = begun.tx;
     const editTextStartedAt = nowMs6();
     const collapsedInlineAffinity = selectionCollapsedInlineAffinity(options);
+    const collapsedOutsideContentControl = options?.collapsedOutsideContentControl === true;
     const kernelEdits = edits.map((edit, index2) => ({
-      on: collapsedInlineAffinity && edit.on.startOffset === edit.on.endOffset ? { ...edit.on, collapsedInlineAffinity } : edit.on,
+      on: edit.on.startOffset === edit.on.endOffset ? {
+        ...edit.on,
+        ...collapsedInlineAffinity ? { collapsedInlineAffinity } : {},
+        ...collapsedOutsideContentControl ? { collapsedOutsideContentControl: true } : {}
+      } : edit.on,
       newText: edit.newText,
       ...options?.changeMode === "tracked" && (isRewrite || edits.length > 1) && !typingHistoryMetadata(options) && story.storyKind !== "textbox" ? {
         rewriteGroupId: `${tx.txId}:0`,
@@ -295198,6 +295316,737 @@ var init_context = __esm(() => {
   init_story_surface();
 });
 
+// ../../../v2/document-api-v2-adapter/dist/metadata/adapter.js
+class V2AnchoredMetadataAdapter {
+  constructor(context) {
+    this.context = context;
+  }
+  attach(input, options) {
+    const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
+    if (mutationGuard)
+      return mutationGuard;
+    const id = input.id ?? newOpaqueId("metadata");
+    const existingRecords = listMetadataRecords(this.context);
+    if (existingRecords.some((record3) => record3.id === id)) {
+      throw operationError("INVALID_INPUT", `metadata id ${id} already exists.`);
+    }
+    const payloadJson = JSON.stringify(input.payload);
+    if (payloadJson === undefined)
+      throw operationError("INVALID_INPUT", "metadata payload must be JSON serializable.");
+    const documentXml = readDocumentXml(this.context);
+    if (findMetadataAnchor(documentXml, id)) {
+      throw operationError("INVALID_INPUT", `metadata id ${id} already exists.`);
+    }
+    const resolvedSegments = input.target.kind === "text" ? resolveMultiSegmentTarget(documentXml, input.target) : resolveSingleSegmentTarget(this.context, documentXml, input.target);
+    if ("error" in resolvedSegments)
+      throw operationError(resolvedSegments.error, resolvedSegments.message);
+    const knownIds = new Set(existingRecords.map((record3) => record3.id));
+    if (hasOverlappingMetadataAnchor(documentXml, resolvedSegments.segments, knownIds)) {
+      return failure2("INVALID_TARGET", "metadata.attach target overlaps an existing metadata anchor.");
+    }
+    const existingPart = ensureCustomXmlPartForNamespace(this.context, input.namespace);
+    const allocatedPart = existingPart ? null : allocateCustomXmlPartNames(this.context);
+    const partName = existingPart?.partName ?? allocatedPart.partName;
+    const partUri = existingPart?.partUri ?? allocatedPart.partUri;
+    const storageXml = existingPart?.content ?? buildMetadataStorageXml(input.namespace, []);
+    const sdtIds = allocateMetadataSdtIds(documentXml, resolvedSegments.segments.length);
+    const refs = readMetadataRefs(storageXml, input.namespace);
+    refs.push({ id, payloadJson, physicalIds: sdtIds.map(String) });
+    const nextStorageXml = buildMetadataStorageXml(input.namespace, refs);
+    const bySegmentPosition = resolvedSegments.segments.map((segment, index) => ({ segment, sdtId: sdtIds[index] })).sort((a, b) => b.segment.para.start - a.segment.para.start);
+    let nextDocumentXml = documentXml;
+    for (const { segment, sdtId } of bySegmentPosition) {
+      const wrapped = wrapTextRangeWithMetadataSdt(segment.para.xml, segment.startOffset, segment.endOffset, id, sdtId);
+      if (!wrapped.ok)
+        throw metadataWrapRejectError(wrapped.reason);
+      nextDocumentXml = replaceRange2(nextDocumentXml, segment.para.start, segment.para.end, wrapped.xml);
+    }
+    if (!dryRunRequested(input, options)) {
+      nextDocumentXml = ensureW15Namespace(nextDocumentXml);
+      const updates = existingPart ? { [partUri]: encodeXml(nextStorageXml) } : buildCustomXmlCreateUpdates(this.context, {
+        id: newGuid(),
+        content: nextStorageXml,
+        partUri,
+        propsPartUri: allocatedPart.propsPartUri,
+        relsPartUri: allocatedPart.relsPartUri
+      });
+      updates[DOCUMENT_PART_URI5] = encodeXml(nextDocumentXml);
+      const committed = commitWholePartUpdates(this.context, "metadata-attach", updates, {
+        expectedRevision: expectedRevisionFrom(input, options),
+        storySurface: {
+          family: "storyAnchor",
+          targetBlockIds: resolvedSegments.segments.map((segment) => segment.blockId)
+        }
+      });
+      if (!committed.ok)
+        return { success: false, failure: { code: committed.code, message: committed.message } };
+    }
+    return { success: true, id, namespace: input.namespace, partName };
+  }
+  list(query3) {
+    let records = listMetadataRecords(this.context);
+    const recordCounts = new Map;
+    for (const record3 of records)
+      recordCounts.set(record3.id, (recordCounts.get(record3.id) ?? 0) + 1);
+    if (query3?.namespace !== undefined)
+      records = records.filter((record3) => record3.namespace === query3.namespace);
+    const documentXml = readDocumentXml(this.context);
+    if (query3?.resolvedOnly === true) {
+      records = records.filter((record3) => recordCounts.get(record3.id) === 1 && groupMetadataAnchor(documentXml, record3.id, new Set([record3.id]), record3.physicalIds) !== null);
+    }
+    if (query3?.within !== undefined) {
+      records = records.filter((record3) => {
+        const resolved = this.resolve({ id: record3.id });
+        return resolved ? overlaps(query3.within, resolved.target) : false;
+      });
+    }
+    const page = pageSlice(records, query3);
+    return buildDiscoveryResult({
+      evaluatedRevision: this.context.currentPublicRevision(),
+      total: records.length,
+      items: page.items.map((record3) => buildDiscoveryItem(record3.id, buildResolvedHandle(`metadata:${record3.id}`, "stable", "ext:metadata"), metadataSummary(record3, documentXml))),
+      page: { offset: page.offset, limit: page.limit, returned: page.items.length }
+    });
+  }
+  get(input) {
+    if (input.contentControlId !== undefined && input.story?.storyType !== "body")
+      return null;
+    const record3 = findMetadataRecord(this.context, input.id);
+    if (record3 && input.contentControlId !== undefined && !matchesPhysicalMetadataAnchor(readDocumentXml(this.context), record3, input.contentControlId))
+      return null;
+    return record3 ? { ...metadataSummary(record3, readDocumentXml(this.context)), payload: record3.payload } : null;
+  }
+  update(input, options) {
+    const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
+    if (mutationGuard)
+      return mutationGuard;
+    if (listMetadataRecords(this.context).filter((candidate2) => candidate2.id === input.id).length > 1) {
+      return failure2("INVALID_TARGET", `metadata ${input.id} has ambiguous payload records.`);
+    }
+    const record3 = findMetadataRecord(this.context, input.id);
+    if (!record3)
+      throw operationError("TARGET_NOT_FOUND", `metadata ${input.id} not found.`);
+    const payloadJson = JSON.stringify(input.payload);
+    if (payloadJson === undefined)
+      throw operationError("INVALID_INPUT", "metadata payload must be JSON serializable.");
+    if (dryRunRequested(input, options))
+      return { success: true, id: input.id };
+    const records = listMetadataRecords(this.context).filter((candidate2) => candidate2.partUri === record3.partUri);
+    const refs = records.map((candidate2) => ({
+      id: candidate2.id,
+      payloadJson: candidate2.id === input.id ? payloadJson : JSON.stringify(candidate2.payload),
+      physicalIds: candidate2.physicalIds
+    }));
+    const committed = commitWholePartUpdates(this.context, "metadata-update", { [record3.partUri]: encodeXml(buildMetadataStorageXml(record3.namespace, refs)) }, { expectedRevision: expectedRevisionFrom(input, options) });
+    if (!committed.ok)
+      return { success: false, failure: { code: committed.code, message: committed.message } };
+    return { success: true, id: input.id };
+  }
+  remove(input, options) {
+    const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
+    if (mutationGuard)
+      return mutationGuard;
+    if (listMetadataRecords(this.context).filter((candidate2) => candidate2.id === input.id).length > 1) {
+      return failure2("INVALID_TARGET", `metadata ${input.id} has ambiguous payload records.`);
+    }
+    const record3 = findMetadataRecord(this.context, input.id);
+    if (!record3)
+      throw operationError("TARGET_NOT_FOUND", `metadata ${input.id} not found.`);
+    const documentXml = readDocumentXml(this.context);
+    const knownIds = new Set(listMetadataRecords(this.context).map((candidate2) => candidate2.id));
+    const matchingAnchors = listMetadataAnchors(documentXml, knownIds).filter((anchor) => anchor.id === input.id);
+    const grouped = groupMetadataAnchor(documentXml, input.id, knownIds, record3.physicalIds);
+    const malformedLegacyAnchor = record3.physicalIds === undefined && matchingAnchors.length === 1 && (matchingAnchors[0].unmatched || unwrapSdt(matchingAnchors[0].xml) === null);
+    if ((matchingAnchors.length > 0 || record3.physicalIds !== undefined) && !grouped && !malformedLegacyAnchor) {
+      return { success: false, failure: { code: "INVALID_TARGET", message: `metadata ${input.id} has ambiguous anchors.` } };
+    }
+    if (dryRunRequested(input, options))
+      return { success: true, id: input.id };
+    const updates = {};
+    if (grouped) {
+      const bySegmentPosition = [...grouped.segments].sort((a, b) => b.start - a.start);
+      let nextDocumentXml = documentXml;
+      for (const anchor of bySegmentPosition) {
+        if (anchor.unmatched)
+          continue;
+        const unwrapped = unwrapSdt(anchor.xml);
+        if (unwrapped === null)
+          continue;
+        nextDocumentXml = replaceRange2(nextDocumentXml, anchor.start, anchor.end, unwrapped);
+      }
+      if (nextDocumentXml !== documentXml)
+        updates[DOCUMENT_PART_URI5] = encodeXml(nextDocumentXml);
+    }
+    const remaining = listMetadataRecords(this.context).filter((candidate2) => candidate2.partUri === record3.partUri && candidate2.id !== input.id).map((candidate2) => ({ id: candidate2.id, payloadJson: JSON.stringify(candidate2.payload), physicalIds: candidate2.physicalIds }));
+    const targetBlockIds2 = grouped ? grouped.segments.map((anchor) => anchor.blockId) : undefined;
+    if (remaining.length > 0) {
+      updates[record3.partUri] = encodeXml(buildMetadataStorageXml(record3.namespace, remaining));
+      const committed = commitWholePartUpdates(this.context, "metadata-remove", updates, {
+        expectedRevision: expectedRevisionFrom(input, options),
+        ...targetBlockIds2 ? { storySurface: { family: "storyAnchor", targetBlockIds: targetBlockIds2 } } : {}
+      });
+      if (!committed.ok)
+        return { success: false, failure: { code: committed.code, message: committed.message } };
+    } else {
+      Object.assign(updates, buildCustomXmlRemoveUpdates(this.context, record3));
+      const committed = commitWholePartUpdates(this.context, "metadata-remove", updates, {
+        expectedRevision: expectedRevisionFrom(input, options),
+        ...targetBlockIds2 ? { storySurface: { family: "storyAnchor", targetBlockIds: targetBlockIds2 } } : {}
+      });
+      if (!committed.ok)
+        return { success: false, failure: { code: committed.code, message: committed.message } };
+    }
+    return { success: true, id: input.id };
+  }
+  resolve(input) {
+    if (input.contentControlId !== undefined && input.story?.storyType !== "body")
+      return null;
+    const record3 = findMetadataRecord(this.context, input.id);
+    if (!record3)
+      return null;
+    const knownIds = new Set(listMetadataRecords(this.context).map((candidate2) => candidate2.id));
+    const grouped = groupMetadataAnchor(readDocumentXml(this.context), input.id, knownIds, record3.physicalIds);
+    if (!grouped)
+      return null;
+    if (input.contentControlId !== undefined && !grouped.segments.some((anchor) => metadataAnchorPhysicalId(anchor) === input.contentControlId))
+      return null;
+    return { id: input.id, target: grouped.target };
+  }
+}
+function matchesPhysicalMetadataAnchor(documentXml, record3, contentControlId) {
+  const grouped = groupMetadataAnchor(documentXml, record3.id, new Set([record3.id]), record3.physicalIds);
+  return grouped !== null && grouped.segments.some((anchor) => metadataAnchorPhysicalId(anchor) === contentControlId);
+}
+function listMetadataSplitBindings(context, paragraphXml) {
+  const candidateIds = new Set([...paragraphXml.matchAll(/<w:tag\b[^>]*\/>/g)].map((match) => attrValue(match[0], "val")).filter((id) => id !== null));
+  if (candidateIds.size === 0)
+    return [];
+  const records = listMetadataRecords(context);
+  const counts = new Map;
+  for (const record3 of records)
+    counts.set(record3.id, (counts.get(record3.id) ?? 0) + 1);
+  const documentXml = readDocumentXml(context);
+  return records.filter((record3) => candidateIds.has(record3.id) && counts.get(record3.id) === 1 && groupMetadataAnchor(documentXml, record3.id, new Set([record3.id]), record3.physicalIds) !== null).map((record3) => ({
+    id: record3.id,
+    partUri: record3.partUri,
+    ...record3.physicalIds ? { physicalIds: record3.physicalIds } : {}
+  }));
+}
+function listMetadataRecords(context) {
+  const out = [];
+  for (const part of listCustomXmlRecords(context)) {
+    if (!part.rootNamespace || !/^<refs\b/.test(part.content.replace(/^<\?xml[^>]*>/, "").trim()))
+      continue;
+    for (const ref5 of readMetadataRefs(part.content, part.rootNamespace)) {
+      let payload = null;
+      try {
+        payload = JSON.parse(ref5.payloadJson);
+      } catch {
+        payload = null;
+      }
+      out.push({
+        id: ref5.id,
+        namespace: part.rootNamespace,
+        partName: part.partName,
+        partUri: part.partUri,
+        ...part.propsPartUri ? { propsPartUri: part.propsPartUri } : {},
+        payload,
+        ...ref5.physicalIds !== undefined ? { physicalIds: ref5.physicalIds } : {}
+      });
+    }
+  }
+  return out;
+}
+function findMetadataRecord(context, id) {
+  const matches = listMetadataRecords(context).filter((record3) => record3.id === id);
+  return matches.length === 1 ? matches[0] : null;
+}
+function metadataSummary(record3, documentXml) {
+  return {
+    id: record3.id,
+    namespace: record3.namespace,
+    partName: record3.partName,
+    anchorStatus: groupMetadataAnchor(documentXml, record3.id, new Set([record3.id]), record3.physicalIds) ? "resolved" : "orphan"
+  };
+}
+function readMetadataRefs(xml, _namespace) {
+  const refs = [];
+  const re = /(<ref\b[^>]*\bid="([^"]*)"[^>]*>)([\s\S]*?)<\/ref>/g;
+  for (let match = re.exec(xml);match; match = re.exec(xml)) {
+    const bindingAttributes = [...match[1].matchAll(/\bsdAnchorIdsV1\s*=\s*(['"])(.*?)\1/g)];
+    const ids = bindingAttributes.length === 0 && !/\bsdAnchorIdsV1\b/.test(match[1]) ? undefined : bindingAttributes.length === 1 ? decodeXmlEntities(bindingAttributes[0][2]).split(",") : [];
+    const validIds = ids && ids.length > 0 && ids.every((value2) => /^(?:0|[1-9]\d*)$/.test(value2)) && new Set(ids).size === ids.length;
+    refs.push({
+      id: decodeXmlEntities(match[2]),
+      payloadJson: decodeXmlEntities(match[3]),
+      ...ids !== undefined ? { physicalIds: validIds ? ids : null } : {}
+    });
+  }
+  return refs;
+}
+function findMetadataAnchor(documentXml, id) {
+  return listMetadataAnchors(documentXml, new Set([id])).find((anchor) => anchor.id === id) ?? null;
+}
+function listMetadataAnchors(documentXml, knownIds) {
+  const anchors = [];
+  for (const sdt of listSdtRanges(documentXml)) {
+    const pr = ownSdtPr(sdt.xml);
+    const tag = attrValue(/<w:tag\b[^>]*\/>/.exec(pr)?.[0] ?? "", "val");
+    if (!tag || !isMetadataAnchorPr(pr, tag, knownIds))
+      continue;
+    const anchor = materializeMetadataAnchor(documentXml, sdt, tag);
+    if (anchor)
+      anchors.push(anchor);
+  }
+  return anchors.sort((left, right) => left.start - right.start);
+}
+function ownSdtPr(sdtXml) {
+  const openTag = /<w:sdt\b[^>]*>/.exec(sdtXml);
+  if (!openTag)
+    return "";
+  const headStart = openTag.index + openTag[0].length;
+  const contentOrNested = /<w:sdtContent\b[^>]*>|<w:sdt\b[^>]*>/.exec(sdtXml.slice(headStart));
+  const head = contentOrNested ? sdtXml.slice(headStart, headStart + contentOrNested.index) : sdtXml.slice(headStart);
+  return /<w:sdtPr\b[^>]*>[\s\S]*?<\/w:sdtPr>/.exec(head)?.[0] ?? "";
+}
+function listSdtRanges(documentXml) {
+  const ranges = [];
+  const stack = [];
+  const tokenRe = /<w:sdt\b[^>]*>|<\/w:sdt>/g;
+  for (let match = tokenRe.exec(documentXml);match; match = tokenRe.exec(documentXml)) {
+    if (match[0].startsWith("</")) {
+      const start = stack.pop();
+      if (start === undefined)
+        continue;
+      const end = tokenRe.lastIndex;
+      ranges.push({ start, end, xml: documentXml.slice(start, end) });
+    } else if (/\/\s*>$/.test(match[0])) {
+      ranges.push({ start: match.index, end: tokenRe.lastIndex, xml: match[0] });
+    } else {
+      stack.push(match.index);
+    }
+  }
+  for (const start of stack) {
+    const end = unmatchedSdtExtent(documentXml, start);
+    ranges.push({ start, end, xml: documentXml.slice(start, end), unmatched: true });
+  }
+  return ranges.sort((left, right) => left.start - right.start);
+}
+function unmatchedSdtExtent(documentXml, start) {
+  const paraClose = documentXml.indexOf("</w:p>", start);
+  return paraClose === -1 ? documentXml.length : paraClose;
+}
+function isMetadataAnchorPr(pr, tag, knownIds) {
+  const alias = attrValue(/<w:alias\b[^>]*\/>/.exec(pr)?.[0] ?? "", "val");
+  if (alias !== null && alias !== METADATA_ANCHOR_ALIAS)
+    return false;
+  const hasHiddenAppearance = attrValue(/<w15:appearance\b[^>]*\/>/.exec(pr)?.[0] ?? "", "val") === "hidden";
+  const hasPlainTextPr = /<w:text\b/.test(pr);
+  return knownIds.has(tag) && hasHiddenAppearance && hasPlainTextPr;
+}
+function materializeMetadataAnchor(documentXml, sdt, id) {
+  const para = findParagraphContaining2(documentXml, sdt.start);
+  if (!para)
+    return null;
+  const startOffset = extractVisibleTextFromXml2(para.xml.slice(0, sdt.start - para.start)).length;
+  const length = extractVisibleTextFromXml2(unwrapSdt(sdt.xml) ?? sdt.xml).length;
+  const endOffset = startOffset + length;
+  return {
+    id,
+    start: sdt.start,
+    end: sdt.end,
+    xml: sdt.xml,
+    blockId: para.blockId,
+    startOffset,
+    endOffset,
+    unmatched: sdt.unmatched === true,
+    target: {
+      kind: "selection",
+      start: { kind: "text", blockId: para.blockId, offset: startOffset, story: bodyStoryLocator2() },
+      end: { kind: "text", blockId: para.blockId, offset: endOffset, story: bodyStoryLocator2() }
+    }
+  };
+}
+function groupMetadataAnchor(documentXml, id, knownIds, physicalIds) {
+  const matches = listMetadataAnchors(documentXml, knownIds).filter((anchor) => anchor.id === id);
+  if (matches.length === 0)
+    return null;
+  if (physicalIds === null)
+    return null;
+  if (physicalIds === undefined && matches.length !== 1)
+    return null;
+  if (physicalIds !== undefined && (matches.length !== physicalIds.length || matches.some((anchor) => {
+    const physicalId = metadataAnchorPhysicalId(anchor);
+    return physicalId === null || !physicalIds.includes(physicalId);
+  }) || new Set(matches.map(metadataAnchorPhysicalId)).size !== matches.length))
+    return null;
+  const controlIdCounts = countBodyControlIds(documentXml);
+  if (!controlIdCounts)
+    return null;
+  if (matches.some((anchor) => controlIdCounts.get(metadataAnchorPhysicalId(anchor) ?? "") !== 1))
+    return null;
+  const kept = contiguousAnchorPrefix(documentXml, matches);
+  if (kept.length !== matches.length)
+    return null;
+  if (kept.some((anchor) => anchor.unmatched || unwrapSdt(anchor.xml) === null))
+    return null;
+  if (kept.length === 1)
+    return { id, segments: kept, target: kept[0].target };
+  const textSegments = [];
+  for (const anchor of kept) {
+    const previous = textSegments.at(-1);
+    if (previous?.blockId === anchor.blockId && previous.range.end === anchor.startOffset) {
+      previous.range.end = anchor.endOffset;
+    } else {
+      textSegments.push({ blockId: anchor.blockId, range: { start: anchor.startOffset, end: anchor.endOffset } });
+    }
+  }
+  if (textSegments.length === 1) {
+    const range = textSegments[0];
+    return {
+      id,
+      segments: kept,
+      target: {
+        kind: "selection",
+        start: { kind: "text", blockId: range.blockId, offset: range.range.start, story: bodyStoryLocator2() },
+        end: { kind: "text", blockId: range.blockId, offset: range.range.end, story: bodyStoryLocator2() }
+      }
+    };
+  }
+  return {
+    id,
+    segments: kept,
+    target: { kind: "text", segments: [textSegments[0], ...textSegments.slice(1)] }
+  };
+}
+function metadataAnchorPhysicalId(anchor) {
+  const idTag = /<w:id\b[^>]*\/>/.exec(ownSdtPr(anchor.xml))?.[0];
+  const value2 = idTag && /\bw:val\s*=\s*(['"])(.*?)\1/.exec(idTag)?.[2];
+  return value2 === undefined ? null : decodeXmlEntities(value2);
+}
+function countBodyControlIds(documentXml) {
+  const counts = new Map;
+  const stack = [];
+  const parser = createXmlSaxParser({ namespaceAware: true });
+  let parseFailed = false;
+  parser.on("error", () => {
+    parseFailed = true;
+  });
+  parser.on("opentag", (tag) => {
+    const parent = stack.at(-1);
+    const owner = stack.at(-2);
+    if (tag.namespaceUri === WORD_NAMESPACE5 && tag.localName === "id" && parent?.namespaceUri === WORD_NAMESPACE5 && parent.localName === "sdtPr" && owner?.namespaceUri === WORD_NAMESPACE5 && owner.localName === "sdt") {
+      const value2 = tag.attributes.find((attribute) => attribute.namespaceUri === WORD_NAMESPACE5 && attribute.localName === "val")?.value;
+      if (value2 !== undefined)
+        counts.set(value2, (counts.get(value2) ?? 0) + 1);
+    }
+    stack.push(tag);
+  });
+  parser.on("closetag", () => {
+    stack.pop();
+  });
+  try {
+    parser.write(documentXml).close();
+  } catch {
+    return null;
+  }
+  return parseFailed ? null : counts;
+}
+function contiguousAnchorPrefix(documentXml, matches) {
+  if (matches.length <= 1)
+    return [...matches];
+  const map3 = buildStructuralBoundaryMap(TEXT_ENCODER.encode(documentXml));
+  const first = map3.byBlockId(matches[0].blockId);
+  if (!first)
+    return [matches[0]];
+  const kept = [matches[0]];
+  let prev = first;
+  for (let i2 = 1;i2 < matches.length; i2 += 1) {
+    const context = map3.byBlockId(matches[i2].blockId);
+    if (!context)
+      break;
+    const sameParagraph = context.ordinal === prev.ordinal;
+    if (sameParagraph) {
+      const previousAnchor = kept.at(-1);
+      if (context.blockId !== previousAnchor.blockId || matches[i2].startOffset !== previousAnchor.endOffset || !isMetadataCarrierGap(documentXml.slice(previousAnchor.end, matches[i2].start)))
+        break;
+    } else if (context.ordinal !== prev.ordinal + 1)
+      break;
+    if (!sameTableCellPath(context.tableCellPath, first.tableCellPath))
+      break;
+    if (!sameOrdinalPath2(context.blockSdtPath, first.blockSdtPath))
+      break;
+    if (!sameOrdinalPath2(context.blockCustomXmlPath, first.blockCustomXmlPath))
+      break;
+    if (context.sectionIndex !== first.sectionIndex)
+      break;
+    if (prev.carriesSectionBreak)
+      break;
+    kept.push(matches[i2]);
+    prev = context;
+  }
+  return kept;
+}
+function isMetadataCarrierGap(xml) {
+  return /^(?:\s*<w:proofErr\s+w:type="(?:spellStart|spellEnd|gramStart|gramEnd)"\s*\/>)*\s*$/.test(xml);
+}
+function sameOrdinalPath2(left, right) {
+  return left.length === right.length && left.every((value2, index) => value2 === right[index]);
+}
+function resolveSingleSegmentTarget(context, documentXml, target) {
+  const resolved = resolveBodySelectionTarget(context, target);
+  if ("error" in resolved)
+    return resolved;
+  if (resolved.startBlockId !== resolved.endBlockId) {
+    return { error: "INVALID_TARGET", message: "metadata.attach requires a same-paragraph text selection." };
+  }
+  if (resolved.startOffset >= resolved.endOffset) {
+    return { error: "INVALID_TARGET", message: "metadata.attach requires a non-empty text range." };
+  }
+  const para = findParagraphById2(documentXml, resolved.startBlockId);
+  if (!para)
+    return { error: "TARGET_NOT_FOUND", message: `paragraph ${resolved.startBlockId} not found.` };
+  return {
+    segments: [{ blockId: para.blockId, startOffset: resolved.startOffset, endOffset: resolved.endOffset, para }]
+  };
+}
+function resolveMultiSegmentTarget(documentXml, target) {
+  if (target.story !== undefined && target.story.storyType !== "body") {
+    return {
+      error: "TARGET_NOT_FOUND",
+      message: "metadata.attach resolves paragraphs against the main document body only."
+    };
+  }
+  if (target.coordinateSpace === "tracked") {
+    return {
+      error: "INVALID_TARGET",
+      message: "metadata.attach does not support a tracked-coordinate-space TextTarget."
+    };
+  }
+  const segments = [];
+  for (const segment of target.segments) {
+    if (segment.range.start >= segment.range.end) {
+      return {
+        error: "INVALID_TARGET",
+        message: "metadata.attach requires a non-empty text range in every TextTarget segment."
+      };
+    }
+    const para = findParagraphById2(documentXml, segment.blockId);
+    if (!para)
+      return { error: "TARGET_NOT_FOUND", message: `paragraph ${segment.blockId} not found.` };
+    segments.push({ blockId: segment.blockId, startOffset: segment.range.start, endOffset: segment.range.end, para });
+  }
+  const boundaryError = validateContiguousStructuralRun(documentXml, segments.map((segment) => segment.blockId));
+  if (boundaryError)
+    return boundaryError;
+  return { segments };
+}
+function validateContiguousStructuralRun(documentXml, blockIds) {
+  if (blockIds.length <= 1)
+    return null;
+  const map3 = buildStructuralBoundaryMap(TEXT_ENCODER.encode(documentXml));
+  const contexts = blockIds.map((blockId) => map3.byBlockId(blockId));
+  const first = contexts[0];
+  if (!first) {
+    return { error: "INVALID_TARGET", message: `paragraph "${blockIds[0]}" is not visible to the structural map.` };
+  }
+  for (let i2 = 1;i2 < contexts.length; i2 += 1) {
+    const context = contexts[i2];
+    const prev = contexts[i2 - 1];
+    if (!context) {
+      return { error: "INVALID_TARGET", message: `paragraph "${blockIds[i2]}" is not visible to the structural map.` };
+    }
+    if (context.ordinal !== prev.ordinal + 1) {
+      return {
+        error: "INVALID_TARGET",
+        message: "metadata.attach TextTarget segments must be contiguous paragraphs in document order."
+      };
+    }
+    if (!sameTableCellPath(context.tableCellPath, first.tableCellPath)) {
+      return { error: "INVALID_TARGET", message: "metadata.attach TextTarget cannot cross a table-cell boundary." };
+    }
+    if (!sameOrdinalPath2(context.blockSdtPath, first.blockSdtPath)) {
+      return {
+        error: "INVALID_TARGET",
+        message: "metadata.attach TextTarget cannot cross a block content-control boundary."
+      };
+    }
+    if (!sameOrdinalPath2(context.blockCustomXmlPath, first.blockCustomXmlPath)) {
+      return {
+        error: "INVALID_TARGET",
+        message: "metadata.attach TextTarget cannot cross a block custom-XML boundary."
+      };
+    }
+    if (context.sectionIndex !== first.sectionIndex) {
+      return { error: "INVALID_TARGET", message: "metadata.attach TextTarget cannot cross a section boundary." };
+    }
+    if (prev.carriesSectionBreak) {
+      return { error: "INVALID_TARGET", message: "metadata.attach TextTarget cannot cross a section boundary." };
+    }
+  }
+  if (contexts[contexts.length - 1].carriesSectionBreak) {
+    return { error: "INVALID_TARGET", message: "metadata.attach TextTarget cannot cross a section boundary." };
+  }
+  return null;
+}
+function hasOverlappingMetadataAnchor(documentXml, segments, knownIds) {
+  const anchors = listMetadataAnchors(documentXml, knownIds);
+  return segments.some((segment) => anchors.some((anchor) => anchor.blockId === segment.blockId && rangesStrictlyOverlap(segment.startOffset, segment.endOffset, anchor.startOffset, anchor.endOffset)));
+}
+function rangesStrictlyOverlap(leftStart, leftEnd, rightStart, rightEnd) {
+  return leftStart < rightEnd && rightStart < leftEnd;
+}
+function bodyStoryLocator2() {
+  return { kind: "story", storyType: "body" };
+}
+function wrapTextRangeWithMetadataSdt(paragraphXml, start, end, id, sdtId) {
+  return wrapRangeWithMarkupInParagraphXml({
+    paragraphXml,
+    rangeStart: start,
+    rangeEnd: end,
+    open: metadataSdtOpenXml(id, sdtId),
+    close: "</w:sdtContent></w:sdt>"
+  });
+}
+function metadataSdtOpenXml(id, sdtId) {
+  return [
+    `<w:sdt xmlns:w15="${W15_NS}"><w:sdtPr>`,
+    `<w:id w:val="${sdtId}"/>`,
+    `<w:alias w:val="${xmlEscapeAttr(METADATA_ANCHOR_ALIAS)}"/>`,
+    `<w:tag w:val="${xmlEscapeAttr(id)}"/>`,
+    '<w15:appearance w15:val="hidden"/>',
+    "<w:text/>",
+    "</w:sdtPr><w:sdtContent>"
+  ].join("");
+}
+function metadataWrapRejectError(reason) {
+  if (reason === "invalid-range") {
+    return operationError("TARGET_NOT_FOUND", "metadata target text range not found.");
+  }
+  return operationError("INVALID_TARGET", `metadata.attach target overlaps unsupported content (${reason}).`);
+}
+function allocateMetadataSdtIds(documentXml, count) {
+  const used = new Set;
+  const idRe = /<w:id\b[^>]*(?:\/>|>)/g;
+  for (let match = idRe.exec(documentXml);match; match = idRe.exec(documentXml)) {
+    const value2 = Number.parseInt(attrValue(match[0], "val") ?? "", 10);
+    if (Number.isInteger(value2))
+      used.add(value2);
+  }
+  const ids = [];
+  for (let i2 = 0;i2 < count; i2 += 1) {
+    let candidate2 = Math.max(1, Math.floor(Math.random() * MAX_SDT_ID));
+    while (used.has(candidate2))
+      candidate2 = candidate2 >= MAX_SDT_ID ? 1 : candidate2 + 1;
+    used.add(candidate2);
+    ids.push(candidate2);
+  }
+  return ids;
+}
+function ensureW15Namespace(documentXml) {
+  return documentXml.replace(/<w:document\b[^>]*>/, (openTag) => {
+    let next = openTag;
+    if (!/\sxmlns:w15\s*=/.test(next))
+      next = next.replace(/>$/, ` xmlns:w15="${W15_NS}">`);
+    const ignorable = /\smc:Ignorable\s*=\s*(["'])([^"']*)\1/.exec(next);
+    if (!ignorable)
+      return next;
+    const prefixes = ignorable[2].split(/\s+/).filter(Boolean);
+    if (prefixes.includes("w15"))
+      return next;
+    return next.replace(ignorable[0], ` mc:Ignorable="${[...prefixes, "w15"].join(" ")}"`);
+  });
+}
+function readDocumentXml(context) {
+  const xml = readPartXml(context, DOCUMENT_PART_URI5);
+  if (!xml)
+    throw operationError("PRECONDITION_FAILED", "document.xml bytes are unavailable.");
+  return xml;
+}
+function findParagraphById2(documentXml, blockId) {
+  const paraRe = /<w:p\b[^>]*>[\s\S]*?<\/w:p>/g;
+  for (let match = paraRe.exec(documentXml);match; match = paraRe.exec(documentXml)) {
+    if (match[0].includes(`w14:paraId="${blockId}"`))
+      return { start: match.index, end: paraRe.lastIndex, xml: match[0], blockId };
+  }
+  return null;
+}
+function findParagraphContaining2(documentXml, index) {
+  const paraRe = /<w:p\b[^>]*>[\s\S]*?<\/w:p>/g;
+  for (let match = paraRe.exec(documentXml);match; match = paraRe.exec(documentXml)) {
+    if (match.index <= index && paraRe.lastIndex >= index) {
+      const open = /^<w:p\b[^>]*>/.exec(match[0])?.[0] ?? "";
+      return {
+        start: match.index,
+        end: paraRe.lastIndex,
+        xml: match[0],
+        blockId: attrValue(open, "paraId") ?? "unknown"
+      };
+    }
+  }
+  return null;
+}
+function unwrapSdt(sdtXml) {
+  const open = /<w:sdtContent\b[^>]*>/.exec(sdtXml);
+  if (!open)
+    return null;
+  if (/\/\s*>$/.test(open[0]))
+    return "";
+  const contentStart = open.index + open[0].length;
+  const tokenRe = /<w:sdtContent\b[^>]*>|<\/w:sdtContent>/g;
+  tokenRe.lastIndex = contentStart;
+  let depth = 0;
+  for (let match = tokenRe.exec(sdtXml);match; match = tokenRe.exec(sdtXml)) {
+    if (match[0].startsWith("</")) {
+      if (depth === 0)
+        return sdtXml.slice(contentStart, match.index);
+      depth -= 1;
+    } else if (!/\/\s*>$/.test(match[0])) {
+      depth += 1;
+    }
+  }
+  return null;
+}
+function replaceRange2(xml, start, end, replacement) {
+  return `${xml.slice(0, start)}${replacement}${xml.slice(end)}`;
+}
+function toFlatSegments(target) {
+  if (target.story !== undefined && target.story.storyType !== "body")
+    return null;
+  if (target.coordinateSpace === "tracked")
+    return null;
+  if (target.kind === "text") {
+    return target.segments.map((segment) => ({
+      blockId: segment.blockId,
+      start: segment.range.start,
+      end: segment.range.end
+    }));
+  }
+  if (target.start.kind !== "text" || target.end.kind !== "text")
+    return null;
+  if (target.start.blockId !== target.end.blockId)
+    return null;
+  return [{ blockId: target.start.blockId, start: target.start.offset, end: target.end.offset }];
+}
+function overlaps(left, right) {
+  const leftSegments = toFlatSegments(left);
+  const rightSegments = toFlatSegments(right);
+  if (!leftSegments || !rightSegments)
+    return false;
+  return leftSegments.some((leftSegment) => rightSegments.some((rightSegment) => leftSegment.blockId === rightSegment.blockId && rangesStrictlyOverlap(leftSegment.start, leftSegment.end, rightSegment.start, rightSegment.end)));
+}
+var TEXT_ENCODER, WORD_NAMESPACE5 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", METADATA_ANCHOR_ALIAS = "Anchored metadata", W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml", MAX_SDT_ID = 2147483646;
+var init_adapter9 = __esm(() => {
+  init_src3();
+  init_sd_document_session_internal();
+  init_visible_text();
+  init_inline();
+  init_adapter2();
+  init_shared();
+  init_xml();
+  TEXT_ENCODER = new TextEncoder;
+});
+
 // ../../../v2/document-api-v2-adapter/dist/core/cooperative-slices.js
 function createCooperativeSliceGate(yieldPoint, sliceTargetMs = COOPERATIVE_SLICE_TARGET_MS) {
   let sliceStartedAt = now();
@@ -295585,11 +296434,14 @@ function prepareNativeCellSplit(resolved, original, columnInsertIndex) {
   if (grids.length !== 1 || rows.length !== original.rows.length)
     return null;
   const grid = grids[0];
-  if (children2(grid).some((range) => !owns(range, "gridCol")))
+  const originalGridChangeXml = original.tblGrid.changeXml;
+  const gridChildren = children2(grid);
+  const gridChanges = gridChildren.filter((range) => owns(range, "tblGridChange"));
+  if (gridChanges.length > 1 || gridChildren.some((range) => !owns(range, "gridCol") && !owns(range, "tblGridChange")) || gridChanges[0] && source.slice(gridChanges[0].start, gridChanges[0].end) !== originalGridChangeXml)
     return null;
   const originalGridXml = source.slice(grid.start, grid.end);
   const originalGridColumns = [...original.tblGrid.gridColXmls];
-  const gridColumns = children2(grid);
+  const gridColumns = gridChildren.filter((range) => owns(range, "gridCol"));
   if (gridColumns.length !== originalGridColumns.length || columnInsertIndex < 0 || columnInsertIndex > gridColumns.length)
     return null;
   const rowFacts = new Map;
@@ -295692,7 +296544,7 @@ function prepareNativeCellSplit(resolved, original, columnInsertIndex) {
       const addedColumns = model.tblGrid.gridColXmls.length - originalGridColumns.length;
       if (addedColumns < 0 || originalGridColumns.some((column, index) => model.tblGrid.gridColXmls[index < columnInsertIndex ? index : index + addedColumns] !== column))
         return null;
-      if (model.tblGrid.changeXml || addedColumns) {
+      if (model.tblGrid.changeXml !== originalGridChangeXml || addedColumns) {
         const gridPatches = [];
         if (addedColumns) {
           const at = columnInsertIndex > 0 ? gridColumns[columnInsertIndex - 1].end : grid.openEnd;
@@ -295702,12 +296554,15 @@ function prepareNativeCellSplit(resolved, original, columnInsertIndex) {
             xml: model.tblGrid.gridColXmls.slice(columnInsertIndex, columnInsertIndex + addedColumns).join("")
           });
         }
-        if (model.tblGrid.changeXml)
+        if (model.tblGrid.changeXml !== originalGridChangeXml) {
+          const previousChange = gridChanges[0];
+          const at = previousChange?.start ?? grid.closeStart;
           gridPatches.push({
-            start: grid.closeStart,
-            end: grid.closeStart,
-            xml: model.tblGrid.changeXml
+            start: at,
+            end: previousChange?.end ?? at,
+            xml: model.tblGrid.changeXml ?? ""
           });
+        }
         patches.push({ start: grid.start, end: grid.end, xml: apply(grid, gridPatches) });
       }
       return apply(table, patches);
@@ -301392,7 +302247,7 @@ function writeAfterPropertyXml(model, spec, wrappedXml) {
   }
 }
 var COLLABORATIVE_TABLE_REWRITE_PREFIXES, TD89, EMPTY_TABLE_CONTEXT_AT_SELECTION, TRACKED_TABLE_COLUMN_RESTORE_NS2 = "urn:superdoc:tracked-table-column", DEFAULT_PAGE_WIDTH_TWIPS = 12240, DEFAULT_PAGE_MARGIN_TWIPS = 1440;
-var init_adapter9 = __esm(() => {
+var init_adapter10 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
   init_tracked_paragraph_body();
@@ -304158,6 +305013,8 @@ class V2BlocksAdapter {
     const paraXml = partBytes ? TD90.decode(partBytes.subarray(resolved.entry.byteStart, resolved.entry.byteEnd)) : "";
     const objectSlack = (paraXml.match(/<[\w.-]+:(?:drawing|pict|object)\b/g) ?? []).length;
     const coordinateSpace = input.coordinateSpace ?? "visible";
+    const metadataAnchorBindings = storyPartUriFromId5(resolved.storyId) === "/word/document.xml" ? listMetadataSplitBindings(this.context, paraXml) : [];
+    const knownMetadataAnchorIds = metadataAnchorBindings.map((binding) => binding.id);
     const offset = coordinateSpace === "tracked" ? Math.max(0, Math.trunc(Number.isFinite(input.offset) ? input.offset : 0)) : clampStructuralOffset(input.offset, resolved.entry.textLength + objectSlack);
     if (options?.dryRun) {
       const policy = this.context.validateMutation(options);
@@ -304170,7 +305027,8 @@ class V2BlocksAdapter {
         partBytes,
         paragraphByteStart: resolved.entry.byteStart,
         offset,
-        coordinateSpace
+        coordinateSpace,
+        knownMetadataAnchorIds
       });
       if (!planned.ok)
         return failure4(mapRejectionReason(planned.reason), planned.reason);
@@ -304184,6 +305042,8 @@ class V2BlocksAdapter {
       target: { storyId: resolved.storyId, paraId: input.target.nodeId },
       offset,
       coordinateSpace,
+      knownMetadataAnchorIds,
+      metadataAnchorBindings,
       changeMode: options?.changeMode ?? "direct"
     });
     const txPerf = createSDTxPerfProbe();
@@ -305373,13 +306233,14 @@ function readTailParaId(provisionalToFinal, createdRefs) {
   return null;
 }
 var TD90, PARAGRAPH_TYPES, TOP_LEVEL_LIST_ROWS_CACHE;
-var init_adapter10 = __esm(() => {
+var init_adapter11 = __esm(() => {
   init_sd_document_session_internal();
+  init_adapter9();
   init_materialize_slot();
   init_adapter();
   init_stories();
   init_text_range_shifts();
-  init_adapter9();
+  init_adapter10();
   init_tracked_pr_change();
   init_note_story();
   init_textbox_story();
@@ -305563,7 +306424,7 @@ function operationError4(code, message) {
   error48.code = code;
   return error48;
 }
-var init_adapter11 = __esm(() => {
+var init_adapter12 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
   init_runtime2();
@@ -329428,7 +330289,7 @@ class V2ContentControlsAdapter {
         }
       }
       if (input.at) {
-        const anchor = input.at.start.kind === "text" ? findParagraphById2(part.xml, input.at.start.blockId) : null;
+        const anchor = input.at.start.kind === "text" ? findParagraphById3(part.xml, input.at.start.blockId) : null;
         if (anchor && /<(?:[\w.-]+:)?(?:ins|del|moveFrom|moveTo)\b/.test(anchor.xml)) {
           this.requireDirectControlStructure(input, options);
         }
@@ -329439,7 +330300,7 @@ class V2ContentControlsAdapter {
       let beforeXml = "";
       let namespaceBindings = new Map(Object.entries(collectXmlElementRanges(part.xml).ranges[0]?.namespaceBindings ?? {}));
       if (input.at?.start.kind === "text") {
-        const anchor = findParagraphById2(part.xml, input.at.start.blockId);
+        const anchor = findParagraphById3(part.xml, input.at.start.blockId);
         if (anchor) {
           namespaceBindings = new Map(contentControlNamespaceBindings(part.xml, anchor.start, true));
           if (input.kind === "block" && extractVisibleTextFromXml2(anchor.xml).trim().length === 0) {
@@ -329481,11 +330342,11 @@ class V2ContentControlsAdapter {
         if (wholeBlocks.kind === "failure") {
           return { success: false, failure: { code: wholeBlocks.code, message: wholeBlocks.message } };
         }
-        const anchor = at.start.kind === "text" ? findParagraphById2(part.xml, at.start.blockId) : null;
+        const anchor = at.start.kind === "text" ? findParagraphById3(part.xml, at.start.blockId) : null;
         if (wholeBlocks.kind === "ok") {
           const selectedXml = part.xml.slice(wholeBlocks.start, wholeBlocks.end);
           const wrapped = replaceSdtContentInTemplate(sdtXml, buildInnerXml(selectedXml));
-          nextXml = replaceRange2(part.xml, wholeBlocks.start, wholeBlocks.end, wrapped);
+          nextXml = replaceRange3(part.xml, wholeBlocks.start, wholeBlocks.end, wrapped);
           targetBlockIds2 = wholeBlocks.blockIds;
         } else if (anchor && at.start.kind === "text" && at.end.kind === "text" && at.start.offset !== at.end.offset && input.content === undefined && input.html === undefined && input.json === undefined) {
           const splitMarker = "<sd-content-control-split/>";
@@ -329526,7 +330387,7 @@ class V2ContentControlsAdapter {
             });
             if (!prepared.ok)
               return { success: false, failure: prepared.failure };
-            nextXml = replaceRange2(part.xml, anchor.start, anchor.end, prepared.xml);
+            nextXml = replaceRange3(part.xml, anchor.start, anchor.end, prepared.xml);
             createRefOptions = {
               createdRefs: prepared.wordIds.map((entityId) => ({
                 kind: "trackedChange",
@@ -329535,7 +330396,7 @@ class V2ContentControlsAdapter {
               }))
             };
           } else {
-            nextXml = replaceRange2(part.xml, anchor.start, anchor.end, replacementXml);
+            nextXml = replaceRange3(part.xml, anchor.start, anchor.end, replacementXml);
           }
           targetBlockIds2 = [at.start.blockId];
         } else {
@@ -329680,7 +330541,7 @@ class V2ContentControlsAdapter {
       const preview = this.validateDryRun(input, options, control.target);
       return preview.success ? { ...preview, updatedRef } : preview;
     }
-    const nextXml = replaceRange2(loaded.documentXml, control.start, control.end, wrapper);
+    const nextXml = replaceRange3(loaded.documentXml, control.start, control.end, wrapper);
     return this.commitDocument(nextXml, "content-control-wrap", input, options, control.target, {
       updatedRef,
       createdRefs,
@@ -329797,7 +330658,7 @@ class V2ContentControlsAdapter {
       const updatedRef = { ...source.target, nodeId: clone3.rootId };
       if (dryRunRequested(input, options))
         return { success: true, contentControl: source.target, updatedRef };
-      const withSource = replaceRange2(loaded.documentXml, source.start, source.end, prepared.sourceXml);
+      const withSource = replaceRange3(loaded.documentXml, source.start, source.end, prepared.sourceXml);
       const offset = destination.offset >= source.end ? destination.offset + prepared.sourceXml.length - source.xml.length : destination.offset;
       const xml2 = withSource.slice(0, offset) + prepared.destinationXml + withSource.slice(offset);
       return this.commitDocument(xml2, "content-control-move", input, options, source.target, {
@@ -329807,7 +330668,7 @@ class V2ContentControlsAdapter {
     }
     if (dryRunRequested(input, options))
       return { success: true, contentControl: source.target };
-    let xml = replaceRange2(loaded.documentXml, source.start, source.end, "");
+    let xml = replaceRange3(loaded.documentXml, source.start, source.end, "");
     const adjustedOffset = destination.offset >= source.end ? destination.offset - (source.end - source.start) : destination.offset;
     const movedXml = destination.wrapInlineInParagraph && source.info.kind === "inline" ? buildParaIdParagraphXml(createParaIdAllocator(this.context)(), source.xml) : source.xml;
     xml = `${xml.slice(0, adjustedOffset)}${movedXml}${xml.slice(adjustedOffset)}`;
@@ -329833,7 +330694,7 @@ class V2ContentControlsAdapter {
     const destinationXml = rewriteContentControlMoveDestinationXml(source.xml, destinationId, createParaIdAllocator(this.context));
     const sourceSideXml = wrapMoveSourceBlock(source.xml, stamp);
     const destinationSideXml = wrapMoveDestinationBlock(destinationXml, stamp);
-    const withSource = replaceRange2(loaded.documentXml, source.start, source.end, sourceSideXml);
+    const withSource = replaceRange3(loaded.documentXml, source.start, source.end, sourceSideXml);
     const inserted = insertAfterExactlyOnce(withSource, destination.xml, destinationSideXml);
     if (!inserted.ok) {
       return { success: false, failure: { code: "INTERNAL_ERROR", message: inserted.message } };
@@ -329860,7 +330721,7 @@ class V2ContentControlsAdapter {
   }
   moveToParagraphCaret(input, options, loaded, source) {
     const blockId = typeof input.destination?.target?.nodeId === "string" ? input.destination.target.nodeId : "";
-    const anchor = findParagraphById2(loaded.documentXml, blockId);
+    const anchor = findParagraphById3(loaded.documentXml, blockId);
     if (!anchor) {
       return {
         success: false,
@@ -329885,7 +330746,7 @@ class V2ContentControlsAdapter {
         requestedOffset = Math.max(beforeSource, requestedOffset - sourceVisible);
     }
     if (source.info.kind === "inline") {
-      const preview = findParagraphById2(replaceRange2(loaded.documentXml, source.start, source.end, ""), blockId);
+      const preview = findParagraphById3(replaceRange3(loaded.documentXml, source.start, source.end, ""), blockId);
       if (!preview || spliceXmlAtVisibleOffset(preview.xml, requestedOffset, source.xml).kind === "shared-run") {
         return { success: false, failure: {
           code: "CAPABILITY_UNAVAILABLE",
@@ -329926,8 +330787,8 @@ class V2ContentControlsAdapter {
     }
     if (dryRunRequested(input, options))
       return { success: true, contentControl: source.target, updatedRef: commitOptions.updatedRef };
-    const withoutSource = replaceRange2(loaded.documentXml, source.start, source.end, sourceReplacement);
-    const para = findParagraphById2(withoutSource, blockId);
+    const withoutSource = replaceRange3(loaded.documentXml, source.start, source.end, sourceReplacement);
+    const para = findParagraphById3(withoutSource, blockId);
     if (!para) {
       return {
         success: false,
@@ -329947,7 +330808,7 @@ class V2ContentControlsAdapter {
         };
       }
       const updatedPara = spliced.kind === "ok" ? spliced.xml : insertXmlIntoParagraphContent(para.xml, destinationXml);
-      nextXml = replaceRange2(withoutSource, para.start, para.end, updatedPara);
+      nextXml = replaceRange3(withoutSource, para.start, para.end, updatedPara);
     } else {
       const insertBefore = requestedOffset === 0 && extractVisibleTextFromXml2(para.xml).trim().length > 0;
       nextXml = insertBefore ? `${withoutSource.slice(0, para.start)}${destinationXml}${withoutSource.slice(para.start)}` : `${withoutSource.slice(0, para.end)}${destinationXml}${withoutSource.slice(para.end)}`;
@@ -330037,7 +330898,7 @@ class V2ContentControlsAdapter {
         return { success: false, failure: replacement.failure };
       if (dryRunRequested(input, options))
         return this.validateDryRun(input, options, control.target);
-      const nextXml2 = replaceRange2(part.xml, control.start, control.end, replaceSdtContentXml(control, replacement.xml));
+      const nextXml2 = replaceRange3(part.xml, control.start, control.end, replaceSdtContentXml(control, replacement.xml));
       return this.commitDocument(nextXml2, "content-control-replace-content", input, options, control.target, {
         partUri: part.partUri,
         storySurface: { family: "storyBlocks", contentControlRewrite: true, targetBlockIds: [] },
@@ -330051,7 +330912,7 @@ class V2ContentControlsAdapter {
     }
     if (dryRunRequested(input, options))
       return this.validateDryRun(input, options, control.target);
-    const nextXml = replaceRange2(part.xml, control.start, control.end, replaceSdtContentXml(control, contentXml));
+    const nextXml = replaceRange3(part.xml, control.start, control.end, replaceSdtContentXml(control, contentXml));
     return this.commitDocument(nextXml, "content-control-replace-content", input, options, control.target, {
       partUri: part.partUri,
       storySurface: { family: "storyBlocks", contentControlRewrite: true, targetBlockIds: [] },
@@ -330109,7 +330970,7 @@ class V2ContentControlsAdapter {
       if (at.start.kind !== "text" || at.end.kind !== "text" || at.start.blockId !== at.end.blockId) {
         throw operationError("CAPABILITY_UNAVAILABLE", "Content-control creation requires a selection within one paragraph.");
       }
-      const paragraph4 = findParagraphById2(part.xml, at.start.blockId);
+      const paragraph4 = findParagraphById3(part.xml, at.start.blockId);
       if (!paragraph4)
         throw operationError("TARGET_NOT_FOUND", `Paragraph ${at.start.blockId} was not found in the target story.`);
       if (![at.start.offset, at.end.offset].every((offset) => Number.isInteger(offset) && offset >= 0 && offset <= parseParagraphInlineMap(paragraph4.xml).visibleLength) || at.start.offset > at.end.offset) {
@@ -330142,7 +331003,7 @@ class V2ContentControlsAdapter {
       return this.validateDryRun(input, options, control.target);
     const part = loaded.parts.find((candidate2) => candidate2.storyId === control.storyId);
     const replacement = replaceSdtContentXml(control, buildTextReplacementContentXml(value2, control.info.kind, createParaIdAllocator(this.context), control.contentXml, false));
-    const nextXml = replaceRange2(part.xml, control.start, control.end, replacement);
+    const nextXml = replaceRange3(part.xml, control.start, control.end, replacement);
     return this.commitDocument(nextXml, "content-control-replace-content", input, options, control.target, {
       partUri: part.partUri,
       storySurface: { family: "storyBlocks", contentControlRewrite: true, targetBlockIds: [] },
@@ -330182,7 +331043,7 @@ class V2ContentControlsAdapter {
         createdRefs: [{ kind: "trackedChange", entityId: String(stamp.revisionId), storyId: body.storyId }]
       };
     }
-    const nextXml = replaceRange2(loaded.documentXml, control.start, control.end, replacement);
+    const nextXml = replaceRange3(loaded.documentXml, control.start, control.end, replacement);
     return this.commitDocument(nextXml, "content-control-pr", input, options, control.target, commitOptions);
   }
   setChoiceListItems(input, options) {
@@ -330404,7 +331265,7 @@ class V2ContentControlsAdapter {
       replacement = prepared.xml;
       createdRefs = prepared.wordIds.map((entityId) => ({ kind: "trackedChange", entityId, storyId: control.storyId }));
     }
-    const nextXml = replaceRange2(part.xml, control.start, control.end, replacement);
+    const nextXml = replaceRange3(part.xml, control.start, control.end, replacement);
     return this.commitDocument(nextXml, prefix, input, options, control.target, {
       partUri: part.partUri,
       storySurface: { family: "storyBlocks", contentControlRewrite: true, targetBlockIds: [] },
@@ -330451,7 +331312,7 @@ class V2ContentControlsAdapter {
     const replacement = !anchor || insertIndex <= 0 ? replaceSdtContentXml(control, `${item}${control.contentXml}`) : `${control.xml.slice(0, anchor.end - control.start)}${item}${control.xml.slice(anchor.end - control.start)}`;
     if (dryRunRequested(input, options))
       return { success: true, contentControl: target };
-    const nextXml = replaceRange2(loaded.documentXml, control.start, control.end, replacement);
+    const nextXml = replaceRange3(loaded.documentXml, control.start, control.end, replacement);
     return this.commitDocument(nextXml, "content-control-repeat-insert", input, options, target, { createdRefs });
   }
   cloneRepeatingItem(input, options) {
@@ -330495,13 +331356,13 @@ class V2ContentControlsAdapter {
       return this.validateDryRun(input, options, control.target);
     const localEnd = item.end - control.start;
     const replacement = `${control.xml.slice(0, localEnd)}${clone3}${control.xml.slice(localEnd)}`;
-    const nextXml = replaceRange2(loaded.documentXml, control.start, control.end, replacement);
+    const nextXml = replaceRange3(loaded.documentXml, control.start, control.end, replacement);
     return this.commitDocument(nextXml, "content-control-repeat-clone", input, options, control.target, { createdRefs });
   }
   deleteRepeatingItem(input, options) {
     return this.mutateControl(input.target, input, options, (control, loaded) => {
       const item = this.repeatingItems(control, loaded)[input.index];
-      return replaceRange2(control.xml, item.start - control.start, item.end - control.start, "");
+      return replaceRange3(control.xml, item.start - control.start, item.end - control.start, "");
     }, "content-control-repeat-delete", (control, loaded) => {
       if (control.info.controlType !== "repeatingSection") {
         throw operationError("INVALID_TARGET", "contentControls.repeatingSection operation requires control type repeatingSection.");
@@ -331770,7 +332631,7 @@ function unwrapSdtXml(sdtXml) {
   const contentRange = findDirectSdtChildRange(sdtXml, "sdtContent");
   return contentRange ? sdtXml.slice(contentRange.openEnd, contentRange.closeStart) : "";
 }
-function replaceRange2(xml, start, end, replacement) {
+function replaceRange3(xml, start, end, replacement) {
   return `${xml.slice(0, start)}${replacement}${xml.slice(end)}`;
 }
 function resolveContentControlMoveDestination(loaded, destination) {
@@ -332312,7 +333173,7 @@ function wrapSelectionInXml(context, documentXml, target, sdtXml, kind, replacem
   if (target?.kind !== "selection" || target.start?.kind !== "text" || target.end?.kind !== "text") {
     return { ok: false, failure: { code: "INVALID_TARGET", message: "A text selection is required." } };
   }
-  const para = findParagraphById2(documentXml, target.start.blockId);
+  const para = findParagraphById3(documentXml, target.start.blockId);
   if (!para)
     return { ok: false, failure: { code: "TARGET_NOT_FOUND", message: "Target paragraph was not found." } };
   if (kind === "inline" && target.start.offset === target.end.offset) {
@@ -332329,12 +333190,12 @@ function wrapSelectionInXml(context, documentXml, target, sdtXml, kind, replacem
     const insertXml = replaceSdtContentInTemplate(sdtXml, buildReplacementContentXml2(hasReplacementContent ? replacementContent : ""));
     const spliced = spliceXmlAtVisibleOffset(para.xml, target.start.offset, insertXml);
     if (spliced.kind === "ok") {
-      return { ok: true, xml: replaceRange2(documentXml, para.start, para.end, spliced.xml) };
+      return { ok: true, xml: replaceRange3(documentXml, para.start, para.end, spliced.xml) };
     }
     if (spliced.kind === "empty") {
       return {
         ok: true,
-        xml: replaceRange2(documentXml, para.start, para.end, insertXmlIntoParagraphContent(para.xml, insertXml))
+        xml: replaceRange3(documentXml, para.start, para.end, insertXmlIntoParagraphContent(para.xml, insertXml))
       };
     }
     return {
@@ -332364,7 +333225,7 @@ function wrapSelectionInXml(context, documentXml, target, sdtXml, kind, replacem
       close: template.close
     });
     if (wrappedRuns.ok) {
-      return { ok: true, xml: replaceRange2(documentXml, para.start, para.end, wrappedRuns.xml) };
+      return { ok: true, xml: replaceRange3(documentXml, para.start, para.end, wrappedRuns.xml) };
     }
     return { ok: false, failure: { code: "CAPABILITY_UNAVAILABLE", message: "Content-control selection spans unsupported inline structures." } };
   }
@@ -332376,7 +333237,7 @@ function wrapSelectionInXml(context, documentXml, target, sdtXml, kind, replacem
       replacementXml: replaceSdtContentInTemplate(sdtXml, buildReplacementContentXml2(replacementContent))
     });
     if (replaced.ok) {
-      return { ok: true, xml: replaceRange2(documentXml, para.start, para.end, replaced.xml) };
+      return { ok: true, xml: replaceRange3(documentXml, para.start, para.end, replaced.xml) };
     }
     return {
       ok: false,
@@ -332392,7 +333253,7 @@ function wrapSelectionInXml(context, documentXml, target, sdtXml, kind, replacem
   });
   if (wrapped === para.xml)
     return { ok: false, failure: { code: "CAPABILITY_UNAVAILABLE", message: "Content-control selection spans unsupported inline structures." } };
-  return { ok: true, xml: replaceRange2(documentXml, para.start, para.end, wrapped) };
+  return { ok: true, xml: replaceRange3(documentXml, para.start, para.end, wrapped) };
 }
 function splitSdtTemplateAroundContent(sdtXml) {
   const sdtRange = findFirstSdtElementRange(sdtXml);
@@ -332416,7 +333277,7 @@ function insertBlockContentControlAtSelection(documentXml, paragraphs, target, s
     throw operationError("TARGET_NOT_FOUND", "Target paragraph was not found.");
   const collapsed = target.start.blockId === target.end.blockId && target.start.offset === target.end.offset;
   if (collapsed && extractVisibleTextFromXml2(anchor.xml).trim().length === 0) {
-    return replaceRange2(documentXml, anchor.start, anchor.end, sdtXml);
+    return replaceRange3(documentXml, anchor.start, anchor.end, sdtXml);
   }
   return `${documentXml.slice(0, anchor.end)}${sdtXml}${documentXml.slice(anchor.end)}`;
 }
@@ -332545,7 +333406,7 @@ function findFirstSdtElementRange(xml) {
   }
   return null;
 }
-function findParagraphById2(documentXml, blockId) {
+function findParagraphById3(documentXml, blockId) {
   const paraRe = /<w:p\b[^>]*?(?:\/>|>[\s\S]*?<\/w:p>)/g;
   for (let match = paraRe.exec(documentXml);match; match = paraRe.exec(documentXml)) {
     if (match[0].includes(`w14:paraId="${blockId}"`)) {
@@ -332659,7 +333520,7 @@ function replaceTextRangeInParagraph2(paragraphXml, start, end, replacement) {
   return paragraphXml;
 }
 var DEFAULT_CHECKED, DEFAULT_UNCHECKED, SECONDARY_STORY_MUTATION_MESSAGE = "Content control mutations outside the document body are not supported by this adapter.", TYPE_TAGS, COOPERATIVE_PARSE_SLICE_PARAGRAPHS = 128, COOPERATIVE_PARSE_SLICE_CONTROLS = 16, RAW_ATTRIBUTE_PATTERN;
-var init_adapter12 = __esm(() => {
+var init_adapter13 = __esm(() => {
   init_sd_document_session_internal();
   init_src6();
   init_part();
@@ -332836,7 +333697,7 @@ var init_tracked_regeneration = __esm(() => {
   init_tracked_pr_change();
   init_runtime2();
   init_xml();
-  init_adapter13();
+  init_adapter14();
 });
 
 // ../../../v2/document-api-v2-adapter/dist/captions/tracked-commit.js
@@ -333136,8 +333997,8 @@ var nativeStamp = (stamp) => ({
 });
 var init_tracked_generated_paragraph = __esm(() => {
   init_sd_document_session_internal();
-  init_adapter15();
   init_adapter16();
+  init_adapter17();
   init_tracked_commit();
   init_tracked_paragraph();
   init_paragraph_ids();
@@ -334028,7 +334889,7 @@ function operationError5(code2, message) {
   return error48;
 }
 var EMPTY_TOC_CONTEXT_AT_SELECTION, TOC_CONFIGURABLE_SWITCH_FLAGS, TOC_SWITCH_FRAGMENT_RE;
-var init_adapter13 = __esm(() => {
+var init_adapter14 = __esm(() => {
   init_tracked_regeneration();
   init_removal();
   init_deletion_locks();
@@ -334205,7 +335066,7 @@ var init_tracked_creation = __esm(() => {
   init_tracked_pr_change();
   init_runtime2();
   init_xml();
-  init_adapter13();
+  init_adapter14();
 });
 
 // ../../../v2/document-api-v2-adapter/dist/sections/adapter.js
@@ -334719,7 +335580,7 @@ function documentFailure(message, code2 = "CAPABILITY_UNAVAILABLE") {
   return { success: false, failure: { code: code2, message } };
 }
 var VALID_BREAK_TYPES, VALID_PAGE_NUMBER_FORMATS, VALID_LINE_NUMBER_RESTARTS, VALID_VERTICAL_ALIGNS, VALID_PAGE_BORDER_DISPLAYS, VALID_PAGE_BORDER_OFFSETS, VALID_PAGE_BORDER_Z_ORDERS;
-var init_adapter14 = __esm(() => {
+var init_adapter15 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
   init_document_reader();
@@ -335849,20 +336710,20 @@ function storyErrorMessage3(error48) {
   }
 }
 var VALUED_TOC_SWITCHES;
-var init_adapter15 = __esm(() => {
+var init_adapter16 = __esm(() => {
   init_sd_document_session_internal();
   init_sd_document_session_internal();
   init_materialize_slot();
-  init_adapter12();
+  init_adapter13();
   init_adapter();
   init_runtime2();
   init_xml();
   init_section_xml();
-  init_adapter9();
+  init_adapter10();
   init_xml3();
-  init_adapter13();
-  init_tracked_creation();
   init_adapter14();
+  init_tracked_creation();
+  init_adapter15();
   init_note_story();
   init_textbox_story();
   init_src6();
@@ -336522,11 +337383,11 @@ function operationError6(code2, message) {
   error48.code = code2;
   return error48;
 }
-var init_adapter16 = __esm(() => {
+var init_adapter17 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
   init_document_reader();
-  init_adapter15();
+  init_adapter16();
   init_composite();
   init_paragraph_ids();
   init_xml();
@@ -346236,7 +347097,7 @@ function commitTrackedImageCaption(context, change, options) {
   });
 }
 var init_tracked_caption = __esm(() => {
-  init_adapter16();
+  init_adapter17();
   init_tracked_commit();
   init_tracked_paragraph();
   init_paragraph_ids();
@@ -350148,7 +351009,7 @@ function escapeRegExp17(value2) {
   return value2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var IMAGE_HYPERLINK_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", EMU_PER_PX5 = 9525, CROP_SCALE2 = 1000, DEFAULT_FLOATING_RELATIVE_HEIGHT = 251659264, DECORATIVE_EXT_URI = "{C183D7F6-B498-43B3-948B-1728B52AA6E4}", DECORATIVE_NAMESPACE = "http://schemas.microsoft.com/office/drawing/2017/decorative", DRAWING_NAMESPACE = "http://schemas.openxmlformats.org/drawingml/2006/main", RELATIONSHIP_NAMESPACE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", CONVERTED_INLINE_ANCHORS, DEFAULT_PAGE_WIDTH_TWIPS2 = 12240, DEFAULT_PAGE_MARGIN_TWIPS2 = 1440, TWIPS_PER_PX = 15;
-var init_adapter17 = __esm(() => {
+var init_adapter18 = __esm(() => {
   init_pending_image_insertion();
   init_src3();
   init_sd_document_session_internal();
@@ -350165,7 +351026,7 @@ var init_adapter17 = __esm(() => {
   init_receipt_entities();
   init_xml_rewrite();
   init_public_model();
-  init_adapter15();
+  init_adapter16();
   init_adapter3();
   init_runtime2();
   init_tracked_caption();
@@ -350439,7 +351300,7 @@ function projectOperationCapabilities(context) {
   return out;
 }
 var V2_SUPPORTED_STEP_OPS, V2_SUPPORTED_NON_UNIFORM_STRATEGIES, V2_SUPPORTED_SET_MARKS, V2_REGEX_LIMITS;
-var init_adapter18 = __esm(() => {
+var init_adapter19 = __esm(() => {
   init_src3();
   init_search();
   init_support_contract();
@@ -350448,8 +351309,8 @@ var init_adapter18 = __esm(() => {
   init_rich_fragment_apply();
   init_digest();
   init_registry3();
-  init_adapter17();
-  init_adapter9();
+  init_adapter18();
+  init_adapter10();
   V2_SUPPORTED_STEP_OPS = MUTATION_PLAN_SUPPORTED_STEP_OPS;
   V2_SUPPORTED_NON_UNIFORM_STRATEGIES = Object.freeze([]);
   V2_SUPPORTED_SET_MARKS = Object.freeze([]);
@@ -351072,10 +351933,10 @@ function operationError8(code2, message) {
   error48.code = code2;
   return error48;
 }
-var init_adapter19 = __esm(() => {
+var init_adapter20 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
-  init_adapter15();
+  init_adapter16();
   init_adapter8();
   init_tracked_generated_paragraph();
   init_tracked_pr_change();
@@ -353371,7 +354232,7 @@ class V2CommentsAdapter {
 function notImplemented(message) {
   return { success: false, failure: { code: "CAPABILITY_UNAVAILABLE", message } };
 }
-var init_adapter20 = __esm(() => {
+var init_adapter21 = __esm(() => {
   init_create2();
   init_edit();
   init_move();
@@ -353660,7 +354521,7 @@ function operationError9(code2, message) {
   error48.code = code2;
   return error48;
 }
-var init_adapter21 = __esm(() => {
+var init_adapter22 = __esm(() => {
   init_src3();
   init_adapter8();
   init_inline();
@@ -354402,7 +355263,7 @@ var TD99, TE56, SETTINGS_PART_URI4 = "/word/settings.xml", WORDPROCESSINGML_NS3
 var init_definitions = __esm(() => {
   init_src2();
   init_sd_document_session_internal();
-  init_adapter14();
+  init_adapter15();
   init_part();
   TD99 = new TextDecoder("utf-8", { fatal: false });
   TE56 = new TextEncoder;
@@ -356265,13 +357126,13 @@ function recordWhole(overlapsByFragment, entry, logical) {
   });
 }
 function normalizeNestedOverlaps(overlapsByFragment, rangeByFragment) {
-  const overlaps = Array.from(overlapsByFragment.values());
+  const overlaps2 = Array.from(overlapsByFragment.values());
   const remove = new Set;
-  for (const parent of overlaps) {
+  for (const parent of overlaps2) {
     const parentRange = rangeByFragment.get(fragmentKey(parent.fragment));
     if (!parentRange || parent.coverage !== "partial")
       continue;
-    for (const child of overlaps) {
+    for (const child of overlaps2) {
       if (child === parent)
         continue;
       const childRange = rangeByFragment.get(fragmentKey(child.fragment));
@@ -356296,7 +357157,7 @@ function normalizeNestedOverlaps(overlapsByFragment, rangeByFragment) {
   }
   return {
     ok: true,
-    overlaps: overlaps.filter((overlap) => !remove.has(fragmentKey(overlap.fragment)))
+    overlaps: overlaps2.filter((overlap) => !remove.has(fragmentKey(overlap.fragment)))
   };
 }
 function fragmentKey(fragment3) {
@@ -357399,12 +358260,12 @@ function pushTextTarget(targets, seen, target) {
   seen.add(key2);
   targets.push(target);
 }
-function shouldExpandWholePairedReplacementSide(overlap, overlaps) {
+function shouldExpandWholePairedReplacementSide(overlap, overlaps2) {
   const logical = overlap.logical;
   if (overlap.coverage !== "whole" || !logical || logical.type !== "replacement" || !logical.sides?.inserted || !logical.sides.deleted) {
     return false;
   }
-  const sameLogicalOverlaps = overlaps.filter((candidate2) => candidate2.logical?.id === logical.id);
+  const sameLogicalOverlaps = overlaps2.filter((candidate2) => candidate2.logical?.id === logical.id);
   return !sameLogicalOverlaps.some((candidate2) => candidate2.coverage === "partial");
 }
 function isLogicalRangeDecideTarget(target) {
@@ -358159,7 +359020,7 @@ function extractStructuralCellTexts(xml, side) {
 }
 function extractStructuralText(xml, side) {
   const readText = side === "deleted" ? extractTrackedTextFromXml : extractVisibleTextFromXml2;
-  const paragraphs = scanParagraphXmlSpans({ bytes: TEXT_ENCODER.encode(xml) });
+  const paragraphs = scanParagraphXmlSpans({ bytes: TEXT_ENCODER2.encode(xml) });
   if (paragraphs.length === 0)
     return readText(xml);
   return paragraphs.map((paragraph4) => readText(paragraph4.xml).trim()).filter(Boolean).join(`
@@ -358734,8 +359595,8 @@ function structuralFieldSemanticSubtype(entry, context, resolveSession) {
   if (!partBytes)
     return null;
   const partXml = decodeTrackedChangePartXml(partBytes, entry.partUri, resolveSession);
-  const entryByteStart = TEXT_ENCODER.encode(partXml.slice(0, entry.documentOrderStart)).byteLength;
-  const entryByteEnd = TEXT_ENCODER.encode(partXml.slice(0, entry.documentOrderEnd)).byteLength;
+  const entryByteStart = TEXT_ENCODER2.encode(partXml.slice(0, entry.documentOrderStart)).byteLength;
+  const entryByteEnd = TEXT_ENCODER2.encode(partXml.slice(0, entry.documentOrderEnd)).byteLength;
   const fields = catalog.fields.filter((candidate2) => candidate2.complete && candidate2.byteStart >= entryByteStart && candidate2.byteEnd <= entryByteEnd);
   const field = fields.length === 1 ? fields[0] : undefined;
   const subtype = field && field.classification !== "unknown" ? field.classification : null;
@@ -359070,8 +359931,8 @@ function createSuccessorRsidAllocator(raw) {
     return counter.toString(16).toUpperCase().padStart(8, "0");
   };
 }
-var resolvedTrackedChangeIdsBySession, TEXT_ENCODER, EMUS_PER_CSS_PIXEL = 9525, BROWSER_RENDERABLE_IMAGE_CONTENT_TYPES, DocumentApiAdapterError, STRUCTURAL_DESCRIPTOR_OPERATIONS;
-var init_adapter22 = __esm(() => {
+var resolvedTrackedChangeIdsBySession, TEXT_ENCODER2, EMUS_PER_CSS_PIXEL = 9525, BROWSER_RENDERABLE_IMAGE_CONTENT_TYPES, DocumentApiAdapterError, STRUCTURAL_DESCRIPTOR_OPERATIONS;
+var init_adapter23 = __esm(() => {
   init_review_read_model();
   init_review_read_model();
   init_src3();
@@ -359087,7 +359948,7 @@ var init_adapter22 = __esm(() => {
   init_logical_view_cache();
   init_local_text_projection();
   resolvedTrackedChangeIdsBySession = new WeakMap;
-  TEXT_ENCODER = new TextEncoder;
+  TEXT_ENCODER2 = new TextEncoder;
   BROWSER_RENDERABLE_IMAGE_CONTENT_TYPES = new Map([
     ["png", "image/png"],
     ["jpg", "image/jpeg"],
@@ -361940,7 +362801,7 @@ var init_legacy_body = __esm(() => {
   init_src3();
   init_document_reader();
   init_adapter();
-  init_adapter22();
+  init_adapter23();
   init_sd_document_session_internal();
   init_payloads();
 });
@@ -364798,13 +365659,13 @@ function stripRootReplayNamespaceDeclarations(xml) {
   return stripReplayNamespaceDeclarations(xml.slice(0, openEnd)) + xml.slice(openEnd);
 }
 var FULL_DIFF_APPLY_SUPPORTED_FAMILIES, TE65, TD109, DOCUMENT_PART_URI6 = "/word/document.xml", NUMBERING_PART_URI4 = "/word/numbering.xml", EMPTY_MAIN_DOCUMENT_SOURCE, WORDPROCESSINGML_NS7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NS2 = "http://schemas.microsoft.com/office/word/2010/wordml", WORDPROCESSING_MATH_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math", MARKUP_COMPATIBILITY_NS3 = "http://schemas.openxmlformats.org/markup-compatibility/2006", VML_NS = "urn:schemas-microsoft-com:vml", STRUCTURAL_PARA_EDIT_DELETE_WML_NAMES, STRUCTURAL_PARA_EDIT_DELETE_MATH_NAMES, STRUCTURAL_PARA_FORMAT_EDIT_WML_NAMES;
-var init_adapter23 = __esm(() => {
+var init_adapter24 = __esm(() => {
   init_tracked_table_property_replay();
   init_src2();
   init_compare();
   init_sd_document_session_internal();
   init_section_xml();
-  init_adapter22();
+  init_adapter23();
   init_header_footer_lifecycle();
   init_errors8();
   init_main_document_revision_closure();
@@ -364912,7 +365773,7 @@ class V2ExportAdapter {
     };
   }
 }
-var init_adapter24 = __esm(() => {
+var init_adapter25 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
 });
@@ -365373,9 +366234,9 @@ function operationError10(code2, message) {
   error48.code = code2;
   return error48;
 }
-var init_adapter25 = __esm(() => {
+var init_adapter26 = __esm(() => {
   init_src3();
-  init_adapter15();
+  init_adapter16();
   init_adapter8();
   init_tracked_field_prefix();
   init_tracked_generated_paragraph();
@@ -370422,7 +371283,7 @@ function readCreatedParagraphRefId(createdRefs, provisionalToFinal) {
   return null;
 }
 var LISTS_XML_DECODER, BULLET_GLYPH_BY_LEVEL;
-var init_adapter26 = __esm(() => {
+var init_adapter27 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
   init_adapter();
@@ -370430,7 +371291,7 @@ var init_adapter26 = __esm(() => {
   init_stories();
   init_text_range_shifts();
   init_adapter7();
-  init_adapter22();
+  init_adapter23();
   init_tracked_pr_change();
   init_receipt_entities();
   init_runtime3();
@@ -370462,7 +371323,7 @@ class V2GetTextAdapter {
   }
 }
 var TD111, extractVisibleTextFromXml4;
-var init_adapter27 = __esm(() => {
+var init_adapter28 = __esm(() => {
   init_sd_document_session_internal();
   init_story_identity();
   init_story_surface();
@@ -370770,7 +371631,7 @@ var init_node_discovery = __esm(() => {
   init_sd_document_session_internal();
   init_document_reader();
   init_paragraph();
-  init_adapter27();
+  init_adapter28();
   init_note_story();
   init_textbox_story();
   init_within();
@@ -371809,7 +372670,7 @@ function txIdPrefixToOperation(prefix) {
   }
 }
 var TD113, TE67;
-var init_adapter28 = __esm(() => {
+var init_adapter29 = __esm(() => {
   init_sd_document_session_internal();
   init_src6();
   init_materialize_slot();
@@ -373606,7 +374467,7 @@ var init_engine3 = __esm(() => {
   init_tracked_text_search();
   init_structural_rewrite_span();
   init_adapter7();
-  init_adapter28();
+  init_adapter29();
   init_adapter6();
   init_composite();
   init_stories();
@@ -373628,7 +374489,7 @@ class V2MutationsAdapter {
     return applyPlan(this.context, input);
   }
 }
-var init_adapter29 = __esm(() => {
+var init_adapter30 = __esm(() => {
   init_engine3();
 });
 
@@ -373762,7 +374623,7 @@ function deleteFailure(code2, message) {
   return { success: false, failure: { code: code2, message } };
 }
 var OPERATION_ID = "v2-textbox-geometry";
-var init_adapter30 = __esm(() => {
+var init_adapter31 = __esm(() => {
   init_sd_document_session_internal();
   init_adapter();
   init_stories();
@@ -374299,7 +375160,7 @@ function containsOnlyZeroWidthReferenceTail(xml) {
   return normalized.length === 0;
 }
 var TD115;
-var init_adapter31 = __esm(() => {
+var init_adapter32 = __esm(() => {
   init_sd_document_session_internal();
   init_materialize_slot();
   init_story_surface();
@@ -374855,9 +375716,9 @@ function operationError11(code2, message) {
   error48.code = code2;
   return error48;
 }
-var init_adapter32 = __esm(() => {
+var init_adapter33 = __esm(() => {
   init_src3();
-  init_adapter15();
+  init_adapter16();
   init_adapter8();
   init_tracked_field_prefix();
   init_tracked_generated_paragraph();
@@ -376195,7 +377056,7 @@ function defaultRelationshipsXml3() {
   return '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
 }
 var HYPERLINK_REL_TYPE3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", TD116, TE68;
-var init_adapter33 = __esm(() => {
+var init_adapter34 = __esm(() => {
   init_sd_document_session_internal();
   init_inline();
   init_adapter();
@@ -376954,12 +377815,12 @@ function failure22(code2, message) {
   return { success: false, failure: { code: code2, message } };
 }
 var IMAGE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", RELATIONSHIPS_CT2 = "application/vnd.openxmlformats-package.relationships+xml", EMPTY_RELATIONSHIPS_XML4, TD117;
-var init_adapter34 = __esm(() => {
+var init_adapter35 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
   init_document_reader();
   init_adapter3();
-  init_adapter17();
+  init_adapter18();
   init_public_model();
   init_section_xml();
   init_xml();
@@ -378037,7 +378898,7 @@ function structuredError4(code2, message) {
   return error48;
 }
 var W14_NS4 = "http://schemas.microsoft.com/office/word/2010/wordml", FOOTNOTES_PART_URI4 = "/word/footnotes.xml", ENDNOTES_PART_URI4 = "/word/endnotes.xml", FOOTNOTES_CT = "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml", ENDNOTES_CT = "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml", FOOTNOTES_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes", ENDNOTES_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes";
-var init_adapter35 = __esm(() => {
+var init_adapter36 = __esm(() => {
   init_src3();
   init_tracked_pr_change();
   init_tracked_structural_wrapper();
@@ -382013,7 +382874,7 @@ function isPasteReason(reason) {
   return !!reason && reason.startsWith("paste-");
 }
 var CLIPBOARD_TD;
-var init_adapter36 = __esm(() => {
+var init_adapter37 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
   init_note_story();
@@ -382065,7 +382926,7 @@ class V2SelectionAdapter {
     };
   }
 }
-var init_adapter37 = __esm(() => {
+var init_adapter38 = __esm(() => {
   init_sd_document_session_internal();
 });
 
@@ -382213,651 +383074,6 @@ var init_clear_content_adapter = __esm(() => {
   TE69 = new TextEncoder;
 });
 
-// ../../../v2/document-api-v2-adapter/dist/metadata/adapter.js
-class V2AnchoredMetadataAdapter {
-  constructor(context) {
-    this.context = context;
-  }
-  attach(input, options) {
-    const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
-    if (mutationGuard)
-      return mutationGuard;
-    const id = input.id ?? newOpaqueId("metadata");
-    const existingRecords = listMetadataRecords(this.context);
-    if (existingRecords.some((record3) => record3.id === id)) {
-      throw operationError("INVALID_INPUT", `metadata id ${id} already exists.`);
-    }
-    const payloadJson = JSON.stringify(input.payload);
-    if (payloadJson === undefined)
-      throw operationError("INVALID_INPUT", "metadata payload must be JSON serializable.");
-    const documentXml = readDocumentXml(this.context);
-    if (findMetadataAnchor(documentXml, id)) {
-      throw operationError("INVALID_INPUT", `metadata id ${id} already exists.`);
-    }
-    const resolvedSegments = input.target.kind === "text" ? resolveMultiSegmentTarget(documentXml, input.target) : resolveSingleSegmentTarget(this.context, documentXml, input.target);
-    if ("error" in resolvedSegments)
-      throw operationError(resolvedSegments.error, resolvedSegments.message);
-    const knownIds = new Set(existingRecords.map((record3) => record3.id));
-    if (hasOverlappingMetadataAnchor(documentXml, resolvedSegments.segments, knownIds)) {
-      return failure2("INVALID_TARGET", "metadata.attach target overlaps an existing metadata anchor.");
-    }
-    const existingPart = ensureCustomXmlPartForNamespace(this.context, input.namespace);
-    const allocatedPart = existingPart ? null : allocateCustomXmlPartNames(this.context);
-    const partName = existingPart?.partName ?? allocatedPart.partName;
-    const partUri = existingPart?.partUri ?? allocatedPart.partUri;
-    const storageXml = existingPart?.content ?? buildMetadataStorageXml(input.namespace, []);
-    const refs = readMetadataRefs(storageXml, input.namespace);
-    refs.push({ id, payloadJson });
-    const nextStorageXml = buildMetadataStorageXml(input.namespace, refs);
-    const sdtIds = allocateMetadataSdtIds(documentXml, resolvedSegments.segments.length);
-    const bySegmentPosition = resolvedSegments.segments.map((segment, index2) => ({ segment, sdtId: sdtIds[index2] })).sort((a, b) => b.segment.para.start - a.segment.para.start);
-    let nextDocumentXml = documentXml;
-    for (const { segment, sdtId } of bySegmentPosition) {
-      const wrapped = wrapTextRangeWithMetadataSdt(segment.para.xml, segment.startOffset, segment.endOffset, id, sdtId);
-      if (!wrapped.ok)
-        throw metadataWrapRejectError(wrapped.reason);
-      nextDocumentXml = replaceRange3(nextDocumentXml, segment.para.start, segment.para.end, wrapped.xml);
-    }
-    if (!dryRunRequested(input, options)) {
-      nextDocumentXml = ensureW15Namespace(nextDocumentXml);
-      const updates = existingPart ? { [partUri]: encodeXml(nextStorageXml) } : buildCustomXmlCreateUpdates(this.context, {
-        id: newGuid(),
-        content: nextStorageXml,
-        partUri,
-        propsPartUri: allocatedPart.propsPartUri,
-        relsPartUri: allocatedPart.relsPartUri
-      });
-      updates[DOCUMENT_PART_URI5] = encodeXml(nextDocumentXml);
-      const committed = commitWholePartUpdates(this.context, "metadata-attach", updates, {
-        expectedRevision: expectedRevisionFrom(input, options),
-        storySurface: {
-          family: "storyAnchor",
-          targetBlockIds: resolvedSegments.segments.map((segment) => segment.blockId)
-        }
-      });
-      if (!committed.ok)
-        return { success: false, failure: { code: committed.code, message: committed.message } };
-    }
-    return { success: true, id, namespace: input.namespace, partName };
-  }
-  list(query3) {
-    let records = listMetadataRecords(this.context);
-    const recordCounts = new Map;
-    for (const record3 of records)
-      recordCounts.set(record3.id, (recordCounts.get(record3.id) ?? 0) + 1);
-    if (query3?.namespace !== undefined)
-      records = records.filter((record3) => record3.namespace === query3.namespace);
-    const documentXml = readDocumentXml(this.context);
-    if (query3?.resolvedOnly === true) {
-      records = records.filter((record3) => recordCounts.get(record3.id) === 1 && groupMetadataAnchor(documentXml, record3.id, new Set([record3.id])) !== null);
-    }
-    if (query3?.within !== undefined) {
-      records = records.filter((record3) => {
-        const resolved = this.resolve({ id: record3.id });
-        return resolved ? overlaps(query3.within, resolved.target) : false;
-      });
-    }
-    const page = pageSlice(records, query3);
-    return buildDiscoveryResult({
-      evaluatedRevision: this.context.currentPublicRevision(),
-      total: records.length,
-      items: page.items.map((record3) => buildDiscoveryItem(record3.id, buildResolvedHandle(`metadata:${record3.id}`, "stable", "ext:metadata"), metadataSummary(record3, documentXml))),
-      page: { offset: page.offset, limit: page.limit, returned: page.items.length }
-    });
-  }
-  get(input) {
-    const record3 = findMetadataRecord(this.context, input.id);
-    return record3 ? { ...metadataSummary(record3, readDocumentXml(this.context)), payload: record3.payload } : null;
-  }
-  update(input, options) {
-    const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
-    if (mutationGuard)
-      return mutationGuard;
-    if (listMetadataRecords(this.context).filter((candidate2) => candidate2.id === input.id).length > 1) {
-      return failure2("INVALID_TARGET", `metadata ${input.id} has ambiguous payload records.`);
-    }
-    const record3 = findMetadataRecord(this.context, input.id);
-    if (!record3)
-      throw operationError("TARGET_NOT_FOUND", `metadata ${input.id} not found.`);
-    const payloadJson = JSON.stringify(input.payload);
-    if (payloadJson === undefined)
-      throw operationError("INVALID_INPUT", "metadata payload must be JSON serializable.");
-    if (dryRunRequested(input, options))
-      return { success: true, id: input.id };
-    const records = listMetadataRecords(this.context).filter((candidate2) => candidate2.partUri === record3.partUri);
-    const refs = records.map((candidate2) => ({
-      id: candidate2.id,
-      payloadJson: candidate2.id === input.id ? payloadJson : JSON.stringify(candidate2.payload)
-    }));
-    const committed = commitWholePartUpdates(this.context, "metadata-update", { [record3.partUri]: encodeXml(buildMetadataStorageXml(record3.namespace, refs)) }, { expectedRevision: expectedRevisionFrom(input, options) });
-    if (!committed.ok)
-      return { success: false, failure: { code: committed.code, message: committed.message } };
-    return { success: true, id: input.id };
-  }
-  remove(input, options) {
-    const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
-    if (mutationGuard)
-      return mutationGuard;
-    if (listMetadataRecords(this.context).filter((candidate2) => candidate2.id === input.id).length > 1) {
-      return failure2("INVALID_TARGET", `metadata ${input.id} has ambiguous payload records.`);
-    }
-    const record3 = findMetadataRecord(this.context, input.id);
-    if (!record3)
-      throw operationError("TARGET_NOT_FOUND", `metadata ${input.id} not found.`);
-    const documentXml = readDocumentXml(this.context);
-    const knownIds = new Set(listMetadataRecords(this.context).map((candidate2) => candidate2.id));
-    const matchingAnchors = listMetadataAnchors(documentXml, knownIds).filter((anchor) => anchor.id === input.id);
-    const grouped = groupMetadataAnchor(documentXml, input.id, knownIds);
-    if (matchingAnchors.length > 0 && !grouped) {
-      return { success: false, failure: { code: "INVALID_TARGET", message: `metadata ${input.id} has ambiguous anchors.` } };
-    }
-    if (dryRunRequested(input, options))
-      return { success: true, id: input.id };
-    const updates = {};
-    if (grouped) {
-      const bySegmentPosition = [...grouped.segments].sort((a, b) => b.start - a.start);
-      let nextDocumentXml = documentXml;
-      for (const anchor of bySegmentPosition) {
-        if (anchor.unmatched)
-          continue;
-        const unwrapped = unwrapSdt(anchor.xml);
-        if (unwrapped === null)
-          continue;
-        nextDocumentXml = replaceRange3(nextDocumentXml, anchor.start, anchor.end, unwrapped);
-      }
-      if (nextDocumentXml !== documentXml)
-        updates[DOCUMENT_PART_URI5] = encodeXml(nextDocumentXml);
-    }
-    const remaining = listMetadataRecords(this.context).filter((candidate2) => candidate2.partUri === record3.partUri && candidate2.id !== input.id).map((candidate2) => ({ id: candidate2.id, payloadJson: JSON.stringify(candidate2.payload) }));
-    const targetBlockIds2 = grouped ? grouped.segments.map((anchor) => anchor.blockId) : undefined;
-    if (remaining.length > 0) {
-      updates[record3.partUri] = encodeXml(buildMetadataStorageXml(record3.namespace, remaining));
-      const committed = commitWholePartUpdates(this.context, "metadata-remove", updates, {
-        expectedRevision: expectedRevisionFrom(input, options),
-        ...targetBlockIds2 ? { storySurface: { family: "storyAnchor", targetBlockIds: targetBlockIds2 } } : {}
-      });
-      if (!committed.ok)
-        return { success: false, failure: { code: committed.code, message: committed.message } };
-    } else {
-      Object.assign(updates, buildCustomXmlRemoveUpdates(this.context, record3));
-      const committed = commitWholePartUpdates(this.context, "metadata-remove", updates, {
-        expectedRevision: expectedRevisionFrom(input, options),
-        ...targetBlockIds2 ? { storySurface: { family: "storyAnchor", targetBlockIds: targetBlockIds2 } } : {}
-      });
-      if (!committed.ok)
-        return { success: false, failure: { code: committed.code, message: committed.message } };
-    }
-    return { success: true, id: input.id };
-  }
-  resolve(input) {
-    const record3 = findMetadataRecord(this.context, input.id);
-    if (!record3)
-      return null;
-    const knownIds = new Set(listMetadataRecords(this.context).map((candidate2) => candidate2.id));
-    const grouped = groupMetadataAnchor(readDocumentXml(this.context), input.id, knownIds);
-    if (!grouped)
-      return null;
-    return { id: input.id, target: grouped.target };
-  }
-}
-function listMetadataRecords(context) {
-  const out = [];
-  for (const part of listCustomXmlRecords(context)) {
-    if (!part.rootNamespace || !/^<refs\b/.test(part.content.replace(/^<\?xml[^>]*>/, "").trim()))
-      continue;
-    for (const ref5 of readMetadataRefs(part.content, part.rootNamespace)) {
-      let payload = null;
-      try {
-        payload = JSON.parse(ref5.payloadJson);
-      } catch {
-        payload = null;
-      }
-      out.push({
-        id: ref5.id,
-        namespace: part.rootNamespace,
-        partName: part.partName,
-        partUri: part.partUri,
-        ...part.propsPartUri ? { propsPartUri: part.propsPartUri } : {},
-        payload
-      });
-    }
-  }
-  return out;
-}
-function findMetadataRecord(context, id) {
-  const matches = listMetadataRecords(context).filter((record3) => record3.id === id);
-  return matches.length === 1 ? matches[0] : null;
-}
-function metadataSummary(record3, documentXml) {
-  return {
-    id: record3.id,
-    namespace: record3.namespace,
-    partName: record3.partName,
-    anchorStatus: groupMetadataAnchor(documentXml, record3.id, new Set([record3.id])) ? "resolved" : "orphan"
-  };
-}
-function readMetadataRefs(xml, _namespace) {
-  const refs = [];
-  const re = /<ref\b[^>]*\bid="([^"]*)"[^>]*>([\s\S]*?)<\/ref>/g;
-  for (let match = re.exec(xml);match; match = re.exec(xml)) {
-    refs.push({ id: decodeXmlEntities(match[1]), payloadJson: decodeXmlEntities(match[2]) });
-  }
-  return refs;
-}
-function findMetadataAnchor(documentXml, id) {
-  return listMetadataAnchors(documentXml, new Set([id])).find((anchor) => anchor.id === id) ?? null;
-}
-function listMetadataAnchors(documentXml, knownIds) {
-  const anchors = [];
-  for (const sdt of listSdtRanges(documentXml)) {
-    const pr = ownSdtPr(sdt.xml);
-    const tag = attrValue(/<w:tag\b[^>]*\/>/.exec(pr)?.[0] ?? "", "val");
-    if (!tag || !isMetadataAnchorPr(pr, tag, knownIds))
-      continue;
-    const anchor = materializeMetadataAnchor(documentXml, sdt, tag);
-    if (anchor)
-      anchors.push(anchor);
-  }
-  return anchors.sort((left, right) => left.start - right.start);
-}
-function ownSdtPr(sdtXml) {
-  const openTag = /<w:sdt\b[^>]*>/.exec(sdtXml);
-  if (!openTag)
-    return "";
-  const headStart = openTag.index + openTag[0].length;
-  const contentOrNested = /<w:sdtContent\b[^>]*>|<w:sdt\b[^>]*>/.exec(sdtXml.slice(headStart));
-  const head = contentOrNested ? sdtXml.slice(headStart, headStart + contentOrNested.index) : sdtXml.slice(headStart);
-  return /<w:sdtPr\b[^>]*>[\s\S]*?<\/w:sdtPr>/.exec(head)?.[0] ?? "";
-}
-function listSdtRanges(documentXml) {
-  const ranges = [];
-  const stack = [];
-  const tokenRe = /<w:sdt\b[^>]*>|<\/w:sdt>/g;
-  for (let match = tokenRe.exec(documentXml);match; match = tokenRe.exec(documentXml)) {
-    if (match[0].startsWith("</")) {
-      const start = stack.pop();
-      if (start === undefined)
-        continue;
-      const end = tokenRe.lastIndex;
-      ranges.push({ start, end, xml: documentXml.slice(start, end) });
-    } else if (/\/\s*>$/.test(match[0])) {
-      ranges.push({ start: match.index, end: tokenRe.lastIndex, xml: match[0] });
-    } else {
-      stack.push(match.index);
-    }
-  }
-  for (const start of stack) {
-    const end = unmatchedSdtExtent(documentXml, start);
-    ranges.push({ start, end, xml: documentXml.slice(start, end), unmatched: true });
-  }
-  return ranges.sort((left, right) => left.start - right.start);
-}
-function unmatchedSdtExtent(documentXml, start) {
-  const paraClose = documentXml.indexOf("</w:p>", start);
-  return paraClose === -1 ? documentXml.length : paraClose;
-}
-function isMetadataAnchorPr(pr, tag, knownIds) {
-  const alias = attrValue(/<w:alias\b[^>]*\/>/.exec(pr)?.[0] ?? "", "val");
-  if (alias !== null && alias !== METADATA_ANCHOR_ALIAS)
-    return false;
-  const hasHiddenAppearance = attrValue(/<w15:appearance\b[^>]*\/>/.exec(pr)?.[0] ?? "", "val") === "hidden";
-  const hasPlainTextPr = /<w:text\b/.test(pr);
-  return knownIds.has(tag) && hasHiddenAppearance && hasPlainTextPr;
-}
-function materializeMetadataAnchor(documentXml, sdt, id) {
-  const para = findParagraphContaining2(documentXml, sdt.start);
-  if (!para)
-    return null;
-  const startOffset = extractVisibleTextFromXml2(para.xml.slice(0, sdt.start - para.start)).length;
-  const length = extractVisibleTextFromXml2(unwrapSdt(sdt.xml) ?? sdt.xml).length;
-  const endOffset = startOffset + length;
-  return {
-    id,
-    start: sdt.start,
-    end: sdt.end,
-    xml: sdt.xml,
-    blockId: para.blockId,
-    startOffset,
-    endOffset,
-    unmatched: sdt.unmatched === true,
-    target: {
-      kind: "selection",
-      start: { kind: "text", blockId: para.blockId, offset: startOffset, story: bodyStoryLocator2() },
-      end: { kind: "text", blockId: para.blockId, offset: endOffset, story: bodyStoryLocator2() }
-    }
-  };
-}
-function groupMetadataAnchor(documentXml, id, knownIds) {
-  const matches = listMetadataAnchors(documentXml, knownIds).filter((anchor) => anchor.id === id);
-  if (matches.length === 0)
-    return null;
-  const kept = contiguousAnchorPrefix(documentXml, matches);
-  if (kept.length !== matches.length)
-    return null;
-  if (kept.length === 1)
-    return { id, segments: kept, target: kept[0].target };
-  const textSegments = [];
-  for (const anchor of kept) {
-    const previous3 = textSegments.at(-1);
-    if (previous3?.blockId === anchor.blockId && previous3.range.end === anchor.startOffset) {
-      previous3.range.end = anchor.endOffset;
-    } else {
-      textSegments.push({ blockId: anchor.blockId, range: { start: anchor.startOffset, end: anchor.endOffset } });
-    }
-  }
-  if (textSegments.length === 1) {
-    const range = textSegments[0];
-    return {
-      id,
-      segments: kept,
-      target: {
-        kind: "selection",
-        start: { kind: "text", blockId: range.blockId, offset: range.range.start, story: bodyStoryLocator2() },
-        end: { kind: "text", blockId: range.blockId, offset: range.range.end, story: bodyStoryLocator2() }
-      }
-    };
-  }
-  return {
-    id,
-    segments: kept,
-    target: { kind: "text", segments: [textSegments[0], ...textSegments.slice(1)] }
-  };
-}
-function contiguousAnchorPrefix(documentXml, matches) {
-  if (matches.length <= 1)
-    return [...matches];
-  const map3 = buildStructuralBoundaryMap(TEXT_ENCODER2.encode(documentXml));
-  const first = map3.byBlockId(matches[0].blockId);
-  if (!first)
-    return [matches[0]];
-  const kept = [matches[0]];
-  let prev = first;
-  for (let i2 = 1;i2 < matches.length; i2 += 1) {
-    const context = map3.byBlockId(matches[i2].blockId);
-    if (!context)
-      break;
-    const sameParagraph = context.ordinal === prev.ordinal;
-    if (sameParagraph) {
-      const previousAnchor = kept.at(-1);
-      if (context.blockId !== previousAnchor.blockId || matches[i2].startOffset !== previousAnchor.endOffset || !isMetadataCarrierGap(documentXml.slice(previousAnchor.end, matches[i2].start)))
-        break;
-    } else if (context.ordinal !== prev.ordinal + 1)
-      break;
-    if (!sameTableCellPath(context.tableCellPath, first.tableCellPath))
-      break;
-    if (!sameOrdinalPath2(context.blockSdtPath, first.blockSdtPath))
-      break;
-    if (!sameOrdinalPath2(context.blockCustomXmlPath, first.blockCustomXmlPath))
-      break;
-    if (context.sectionIndex !== first.sectionIndex)
-      break;
-    if (prev.carriesSectionBreak)
-      break;
-    kept.push(matches[i2]);
-    prev = context;
-  }
-  return kept;
-}
-function isMetadataCarrierGap(xml) {
-  return /^(?:\s*<w:proofErr\s+w:type="(?:spellStart|spellEnd|gramStart|gramEnd)"\s*\/>)*\s*$/.test(xml);
-}
-function sameOrdinalPath2(left, right) {
-  return left.length === right.length && left.every((value2, index2) => value2 === right[index2]);
-}
-function resolveSingleSegmentTarget(context, documentXml, target) {
-  const resolved = resolveBodySelectionTarget(context, target);
-  if ("error" in resolved)
-    return resolved;
-  if (resolved.startBlockId !== resolved.endBlockId) {
-    return { error: "INVALID_TARGET", message: "metadata.attach requires a same-paragraph text selection." };
-  }
-  if (resolved.startOffset >= resolved.endOffset) {
-    return { error: "INVALID_TARGET", message: "metadata.attach requires a non-empty text range." };
-  }
-  const para = findParagraphById3(documentXml, resolved.startBlockId);
-  if (!para)
-    return { error: "TARGET_NOT_FOUND", message: `paragraph ${resolved.startBlockId} not found.` };
-  return {
-    segments: [{ blockId: para.blockId, startOffset: resolved.startOffset, endOffset: resolved.endOffset, para }]
-  };
-}
-function resolveMultiSegmentTarget(documentXml, target) {
-  if (target.story !== undefined && target.story.storyType !== "body") {
-    return {
-      error: "TARGET_NOT_FOUND",
-      message: "metadata.attach resolves paragraphs against the main document body only."
-    };
-  }
-  if (target.coordinateSpace === "tracked") {
-    return {
-      error: "INVALID_TARGET",
-      message: "metadata.attach does not support a tracked-coordinate-space TextTarget."
-    };
-  }
-  const segments = [];
-  for (const segment of target.segments) {
-    if (segment.range.start >= segment.range.end) {
-      return {
-        error: "INVALID_TARGET",
-        message: "metadata.attach requires a non-empty text range in every TextTarget segment."
-      };
-    }
-    const para = findParagraphById3(documentXml, segment.blockId);
-    if (!para)
-      return { error: "TARGET_NOT_FOUND", message: `paragraph ${segment.blockId} not found.` };
-    segments.push({ blockId: segment.blockId, startOffset: segment.range.start, endOffset: segment.range.end, para });
-  }
-  const boundaryError = validateContiguousStructuralRun(documentXml, segments.map((segment) => segment.blockId));
-  if (boundaryError)
-    return boundaryError;
-  return { segments };
-}
-function validateContiguousStructuralRun(documentXml, blockIds) {
-  if (blockIds.length <= 1)
-    return null;
-  const map3 = buildStructuralBoundaryMap(TEXT_ENCODER2.encode(documentXml));
-  const contexts = blockIds.map((blockId) => map3.byBlockId(blockId));
-  const first = contexts[0];
-  if (!first) {
-    return { error: "INVALID_TARGET", message: `paragraph "${blockIds[0]}" is not visible to the structural map.` };
-  }
-  for (let i2 = 1;i2 < contexts.length; i2 += 1) {
-    const context = contexts[i2];
-    const prev = contexts[i2 - 1];
-    if (!context) {
-      return { error: "INVALID_TARGET", message: `paragraph "${blockIds[i2]}" is not visible to the structural map.` };
-    }
-    if (context.ordinal !== prev.ordinal + 1) {
-      return {
-        error: "INVALID_TARGET",
-        message: "metadata.attach TextTarget segments must be contiguous paragraphs in document order."
-      };
-    }
-    if (!sameTableCellPath(context.tableCellPath, first.tableCellPath)) {
-      return { error: "INVALID_TARGET", message: "metadata.attach TextTarget cannot cross a table-cell boundary." };
-    }
-    if (!sameOrdinalPath2(context.blockSdtPath, first.blockSdtPath)) {
-      return {
-        error: "INVALID_TARGET",
-        message: "metadata.attach TextTarget cannot cross a block content-control boundary."
-      };
-    }
-    if (!sameOrdinalPath2(context.blockCustomXmlPath, first.blockCustomXmlPath)) {
-      return {
-        error: "INVALID_TARGET",
-        message: "metadata.attach TextTarget cannot cross a block custom-XML boundary."
-      };
-    }
-    if (context.sectionIndex !== first.sectionIndex) {
-      return { error: "INVALID_TARGET", message: "metadata.attach TextTarget cannot cross a section boundary." };
-    }
-    if (prev.carriesSectionBreak) {
-      return { error: "INVALID_TARGET", message: "metadata.attach TextTarget cannot cross a section boundary." };
-    }
-  }
-  if (contexts[contexts.length - 1].carriesSectionBreak) {
-    return { error: "INVALID_TARGET", message: "metadata.attach TextTarget cannot cross a section boundary." };
-  }
-  return null;
-}
-function hasOverlappingMetadataAnchor(documentXml, segments, knownIds) {
-  const anchors = listMetadataAnchors(documentXml, knownIds);
-  return segments.some((segment) => anchors.some((anchor) => anchor.blockId === segment.blockId && rangesStrictlyOverlap(segment.startOffset, segment.endOffset, anchor.startOffset, anchor.endOffset)));
-}
-function rangesStrictlyOverlap(leftStart, leftEnd, rightStart, rightEnd) {
-  return leftStart < rightEnd && rightStart < leftEnd;
-}
-function bodyStoryLocator2() {
-  return { kind: "story", storyType: "body" };
-}
-function wrapTextRangeWithMetadataSdt(paragraphXml, start, end, id, sdtId) {
-  return wrapRangeWithMarkupInParagraphXml({
-    paragraphXml,
-    rangeStart: start,
-    rangeEnd: end,
-    open: metadataSdtOpenXml(id, sdtId),
-    close: "</w:sdtContent></w:sdt>"
-  });
-}
-function metadataSdtOpenXml(id, sdtId) {
-  return [
-    `<w:sdt xmlns:w15="${W15_NS}"><w:sdtPr>`,
-    `<w:id w:val="${sdtId}"/>`,
-    `<w:alias w:val="${xmlEscapeAttr(METADATA_ANCHOR_ALIAS)}"/>`,
-    `<w:tag w:val="${xmlEscapeAttr(id)}"/>`,
-    '<w15:appearance w15:val="hidden"/>',
-    "<w:text/>",
-    "</w:sdtPr><w:sdtContent>"
-  ].join("");
-}
-function metadataWrapRejectError(reason) {
-  if (reason === "invalid-range") {
-    return operationError("TARGET_NOT_FOUND", "metadata target text range not found.");
-  }
-  return operationError("INVALID_TARGET", `metadata.attach target overlaps unsupported content (${reason}).`);
-}
-function allocateMetadataSdtIds(documentXml, count) {
-  const used = new Set;
-  const idRe = /<w:id\b[^>]*(?:\/>|>)/g;
-  for (let match = idRe.exec(documentXml);match; match = idRe.exec(documentXml)) {
-    const value2 = Number.parseInt(attrValue(match[0], "val") ?? "", 10);
-    if (Number.isInteger(value2))
-      used.add(value2);
-  }
-  const ids = [];
-  for (let i2 = 0;i2 < count; i2 += 1) {
-    let candidate2 = Math.max(1, Math.floor(Math.random() * MAX_SDT_ID));
-    while (used.has(candidate2))
-      candidate2 = candidate2 >= MAX_SDT_ID ? 1 : candidate2 + 1;
-    used.add(candidate2);
-    ids.push(candidate2);
-  }
-  return ids;
-}
-function ensureW15Namespace(documentXml) {
-  return documentXml.replace(/<w:document\b[^>]*>/, (openTag) => {
-    let next = openTag;
-    if (!/\sxmlns:w15\s*=/.test(next))
-      next = next.replace(/>$/, ` xmlns:w15="${W15_NS}">`);
-    const ignorable = /\smc:Ignorable\s*=\s*(["'])([^"']*)\1/.exec(next);
-    if (!ignorable)
-      return next;
-    const prefixes = ignorable[2].split(/\s+/).filter(Boolean);
-    if (prefixes.includes("w15"))
-      return next;
-    return next.replace(ignorable[0], ` mc:Ignorable="${[...prefixes, "w15"].join(" ")}"`);
-  });
-}
-function readDocumentXml(context) {
-  const xml = readPartXml(context, DOCUMENT_PART_URI5);
-  if (!xml)
-    throw operationError("PRECONDITION_FAILED", "document.xml bytes are unavailable.");
-  return xml;
-}
-function findParagraphById3(documentXml, blockId) {
-  const paraRe = /<w:p\b[^>]*>[\s\S]*?<\/w:p>/g;
-  for (let match = paraRe.exec(documentXml);match; match = paraRe.exec(documentXml)) {
-    if (match[0].includes(`w14:paraId="${blockId}"`))
-      return { start: match.index, end: paraRe.lastIndex, xml: match[0], blockId };
-  }
-  return null;
-}
-function findParagraphContaining2(documentXml, index2) {
-  const paraRe = /<w:p\b[^>]*>[\s\S]*?<\/w:p>/g;
-  for (let match = paraRe.exec(documentXml);match; match = paraRe.exec(documentXml)) {
-    if (match.index <= index2 && paraRe.lastIndex >= index2) {
-      const open = /^<w:p\b[^>]*>/.exec(match[0])?.[0] ?? "";
-      return {
-        start: match.index,
-        end: paraRe.lastIndex,
-        xml: match[0],
-        blockId: attrValue(open, "paraId") ?? "unknown"
-      };
-    }
-  }
-  return null;
-}
-function unwrapSdt(sdtXml) {
-  const open = /<w:sdtContent\b[^>]*>/.exec(sdtXml);
-  if (!open)
-    return null;
-  if (/\/\s*>$/.test(open[0]))
-    return "";
-  const contentStart = open.index + open[0].length;
-  const tokenRe = /<w:sdtContent\b[^>]*>|<\/w:sdtContent>/g;
-  tokenRe.lastIndex = contentStart;
-  let depth = 0;
-  for (let match = tokenRe.exec(sdtXml);match; match = tokenRe.exec(sdtXml)) {
-    if (match[0].startsWith("</")) {
-      if (depth === 0)
-        return sdtXml.slice(contentStart, match.index);
-      depth -= 1;
-    } else if (!/\/\s*>$/.test(match[0])) {
-      depth += 1;
-    }
-  }
-  return null;
-}
-function replaceRange3(xml, start, end, replacement) {
-  return `${xml.slice(0, start)}${replacement}${xml.slice(end)}`;
-}
-function toFlatSegments(target) {
-  if (target.story !== undefined && target.story.storyType !== "body")
-    return null;
-  if (target.coordinateSpace === "tracked")
-    return null;
-  if (target.kind === "text") {
-    return target.segments.map((segment) => ({
-      blockId: segment.blockId,
-      start: segment.range.start,
-      end: segment.range.end
-    }));
-  }
-  if (target.start.kind !== "text" || target.end.kind !== "text")
-    return null;
-  if (target.start.blockId !== target.end.blockId)
-    return null;
-  return [{ blockId: target.start.blockId, start: target.start.offset, end: target.end.offset }];
-}
-function overlaps(left, right) {
-  const leftSegments = toFlatSegments(left);
-  const rightSegments = toFlatSegments(right);
-  if (!leftSegments || !rightSegments)
-    return false;
-  return leftSegments.some((leftSegment) => rightSegments.some((rightSegment) => leftSegment.blockId === rightSegment.blockId && rangesStrictlyOverlap(leftSegment.start, leftSegment.end, rightSegment.start, rightSegment.end)));
-}
-var TEXT_ENCODER2, METADATA_ANCHOR_ALIAS = "Anchored metadata", W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml", MAX_SDT_ID = 2147483646;
-var init_adapter38 = __esm(() => {
-  init_src3();
-  init_sd_document_session_internal();
-  init_visible_text();
-  init_inline();
-  init_adapter2();
-  init_shared();
-  init_xml();
-  TEXT_ENCODER2 = new TextEncoder;
-});
-
 // ../../../v2/document-api-v2-adapter/dist/formatting/styles.js
 function applyStylesDocDefaultsPatch(stylesXml, input) {
   const normalized = normalizeStylesWordprocessingMlQNames(stylesXml);
@@ -386012,47 +386228,47 @@ function createV2DocumentApiAdapter(session, options = {}) {
 }
 var init_factory = __esm(() => {
   init_context();
-  init_adapter10();
   init_adapter11();
-  init_adapter16();
-  init_adapter18();
+  init_adapter12();
+  init_adapter17();
   init_adapter19();
   init_adapter20();
-  init_adapter12();
-  init_adapter15();
   init_adapter21();
+  init_adapter13();
+  init_adapter16();
+  init_adapter22();
   init_adapter2();
-  init_adapter23();
   init_adapter24();
-  init_adapter();
   init_adapter25();
+  init_adapter();
   init_adapter26();
-  init_adapter29();
+  init_adapter27();
+  init_adapter30();
   init_adapter6();
   init_adapter7();
-  init_adapter9();
-  init_adapter30();
-  init_adapter13();
-  init_adapter22();
-  init_reader();
+  init_adapter10();
   init_adapter31();
-  init_search2();
+  init_adapter14();
+  init_adapter23();
+  init_reader();
   init_adapter32();
+  init_search2();
   init_adapter33();
+  init_adapter34();
   init_adapter8();
-  init_adapter17();
+  init_adapter18();
   init_adapter3();
-  init_adapter34();
   init_adapter35();
   init_adapter36();
-  init_adapter27();
   init_adapter37();
-  init_clear_content_adapter();
   init_adapter28();
+  init_adapter38();
+  init_clear_content_adapter();
+  init_adapter29();
   init_adapter4();
   init_adapter5();
-  init_adapter38();
-  init_adapter14();
+  init_adapter9();
+  init_adapter15();
   init_adapter39();
   init_adapter40();
   init_read_adapters();
@@ -419956,7 +420172,7 @@ class XmlEmissionContext {
         stack.push(namespaceBindings);
         if (namespaceBindings !== inherited)
           events.push({ offset: end, bindings: namespaceBindings });
-        if (tag.localName !== "p" || tag.namespaceUri !== WORD_NAMESPACE5)
+        if (tag.localName !== "p" || tag.namespaceUri !== WORD_NAMESPACE6)
           return;
         if (paragraphDepth++ > 0)
           return;
@@ -419966,7 +420182,7 @@ class XmlEmissionContext {
         this.paragraphs.set(blockIdForParagraphXmlSpan({ paraId: id2 ?? null, ordinal: paragraphOrdinal++ }), context);
       },
       onCloseTag: ({ tag, end }) => {
-        if (tag.localName === "p" && tag.namespaceUri === WORD_NAMESPACE5)
+        if (tag.localName === "p" && tag.namespaceUri === WORD_NAMESPACE6)
           paragraphDepth -= 1;
         const previous3 = stack.pop();
         const bindings = stack[stack.length - 1] ?? this.initial;
@@ -419991,17 +420207,17 @@ function paragraphEmissionNames(context, preservedXml) {
     bindings[prefix] = namespace;
     return prefix;
   };
-  const word3 = choose("w", WORD_NAMESPACE5);
+  const word3 = choose("w", WORD_NAMESPACE6);
   const word2010 = choose("w14", WORD_2010_NAMESPACE3);
   const declarations = Object.entries({ "": "", ...bindings }).filter(([prefix, uri]) => prefix !== "xml" && (context.inherited[prefix] ?? "") !== uri).sort(([left], [right]) => left.localeCompare(right)).map(([prefix, uri]) => ` xmlns${prefix ? `:${prefix}` : ""}="${xmlEscape(uri)}"`).join("");
   return { word: word3, word2010, declarations };
 }
-var WORD_NAMESPACE5 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORD_2010_NAMESPACE3 = "http://schemas.microsoft.com/office/word/2010/wordml", CANONICAL_NAMESPACES;
+var WORD_NAMESPACE6 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORD_2010_NAMESPACE3 = "http://schemas.microsoft.com/office/word/2010/wordml", CANONICAL_NAMESPACES;
 var init_xml_emission_context = __esm(() => {
   init_sd_document_session_internal();
   init_canonical();
   CANONICAL_NAMESPACES = {
-    w: WORD_NAMESPACE5,
+    w: WORD_NAMESPACE6,
     w14: WORD_2010_NAMESPACE3
   };
 });
@@ -426505,6 +426721,7 @@ function syncTrackedDecisionTableOverlaysFromSession(session, prepared, storyId,
         partUri,
         preparedTxId: prepared.txId,
         lastDeltaKind: "tracked-change.decision.sync",
+        reversibleReviewDecision: prepared.backendExtensions.storySurface?.historyReplay != null,
         tableXml,
         sourceXmlStart,
         sourceXmlEnd: sourceXmlStart + tableXml.length,
@@ -426559,6 +426776,16 @@ function writeTableOverlayState(input) {
     input.tableMap.set(overlayTableNodeId, tableValue);
   }
   const tableState = tableValue;
+  if (input.lastDeltaKind === "tracked-change.decision.sync") {
+    const previousTableXml = tableState.get("xml");
+    const previousGridXml = typeof previousTableXml === "string" ? readDirectChildPropertyXml3(previousTableXml, "tbl", "tblGrid") : "";
+    const nextGridXml = readDirectChildPropertyXml3(input.tableXml, "tbl", "tblGrid");
+    writeTableRevisionDecisionDiff(tableState, "grid", overlayTableNodeId, previousGridXml, nextGridXml, input.reversibleReviewDecision === true);
+    const nextGridChangeXml = readDirectChildPropertyXml3(nextGridXml, "tblGrid", "tblGridChange");
+    if (nextGridChangeXml || tableState.has("gridChange")) {
+      tableState.set("gridChange", nextGridChangeXml || null);
+    }
+  }
   tableState.set("tableNodeId", overlayTableNodeId);
   if (overlayTableNodeId === input.table.tableNodeId)
     tableState.delete("currentTableNodeId");
@@ -426948,6 +427175,7 @@ var init_story_surface_session_sync = __esm(() => {
   init_table_structural_refs();
   init_schema4();
   init_seed();
+  init_table_revision_decisions();
   init_story_surface_origin();
   init_paragraph_inline_sync();
   init_story_surface_origin();