@superdoc/mcp 1.2.0-next.13 → 1.2.0-next.15

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.0-next.13";
+var SDK_VERSION = "2.15.0-next.15";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { chmodSync, existsSync } from "node:fs";
@@ -134832,26 +134832,68 @@ function canonicalName(namespace, localName2) {
     return `xml:${localName2}`;
   return namespace ? `{${namespace}}${localName2}` : localName2;
 }
-function computeRunSignature(runXml) {
-  const canonicalXml = canonicalizeXmlForSignature(runXml);
-  const normalized = normalizeRunXmlForSignature(canonicalXml.replace(REVISION_ATTR_RE, (attribute, offset, xml) => {
-    const precedingTag = xml.slice(xml.lastIndexOf("<", offset), offset);
-    return /^<w:proofErr(?:\s|$)/.test(precedingTag) ? attribute : "";
-  }).replace(REVISION_ELEMENT_RE, (markup) => markup.replace(REVISION_ID_ATTR_RE, "")).replace(COMMENT_MARKUP_RE, (markup, name, attributes) => isWordprocessingElement3(name, attributes, canonicalXml) ? "" : markup).replace(NOTE_REFERENCE_MARKUP_RE, (markup, runName, runAttributes, _rPrName, nestedName, nestedAttributes, standaloneName, standaloneAttributes) => {
-    const name = nestedName ?? standaloneName;
-    const attributes = nestedAttributes ?? standaloneAttributes;
-    if (!isWordprocessingElement3(name, attributes, canonicalXml))
-      return markup;
-    if (runName && !isWordprocessingElement3(runName, runAttributes, canonicalXml))
-      return markup;
-    return "";
-  }));
-  let hash2 = 2166136261;
-  for (let i = 0;i < normalized.length; i += 1) {
-    hash2 ^= normalized.charCodeAt(i);
-    hash2 = Math.imul(hash2, 16777619) >>> 0;
+function normalizeBalancedBookmarkIds(canonicalXmls) {
+  const starts = new Map;
+  const ends = new Set;
+  const names = new Set;
+  for (const xml of canonicalXmls) {
+    const tags = [...xml.matchAll(BOOKMARK_TAG_RE)];
+    if (tags.length !== [...xml.matchAll(BOOKMARK_OPENING_RE)].length)
+      return canonicalXmls;
+    for (const tag of tags) {
+      if (tag[1] || !tag[0].endsWith("/>"))
+        return canonicalXmls;
+      const attributes = [...tag[3].matchAll(ATTRIBUTE_RE)];
+      const ids = attributes.filter((attribute) => attribute[1] === "w:id");
+      const bookmarkNames = attributes.filter((attribute) => attribute[1] === "w:name");
+      const id = ids[0]?.[2] ?? ids[0]?.[3];
+      if (ids.length !== 1 || !id || !/^\d+$/u.test(id))
+        return canonicalXmls;
+      if (tag[2] === "Start") {
+        const name = bookmarkNames[0]?.[2] ?? bookmarkNames[0]?.[3];
+        if (bookmarkNames.length !== 1 || !name || starts.has(id) || names.has(name))
+          return canonicalXmls;
+        starts.set(id, name);
+        names.add(name);
+      } else {
+        if (bookmarkNames.length > 0 || !starts.has(id) || ends.has(id))
+          return canonicalXmls;
+        ends.add(id);
+      }
+    }
   }
-  return `v2-run-${hash2.toString(16).padStart(8, "0")}`;
+  if (starts.size !== ends.size)
+    return canonicalXmls;
+  return canonicalXmls.map((xml) => xml.replace(BOOKMARK_TAG_RE, (tag, _closing, _kind, attributes) => {
+    const id = /\bw:id="([^"]*)"/u.exec(attributes)[1];
+    return tag.replace(/\bw:id="[^"]*"/u, `w:id=${JSON.stringify(`bookmark:${starts.get(id)}`)}`);
+  }));
+}
+function computeRunSignatures(runXmls) {
+  const canonicalXmls = normalizeBalancedBookmarkIds(runXmls.map(canonicalizeXmlForSignature));
+  return canonicalXmls.map((canonicalXml) => {
+    const normalized = normalizeRunXmlForSignature(canonicalXml.replace(REVISION_ATTR_RE, (attribute, offset, xml) => {
+      const precedingTag = xml.slice(xml.lastIndexOf("<", offset), offset);
+      return /^<w:proofErr(?:\s|$)/.test(precedingTag) ? attribute : "";
+    }).replace(REVISION_ELEMENT_RE, (markup) => markup.replace(REVISION_ID_ATTR_RE, "")).replace(COMMENT_MARKUP_RE, (markup, name, attributes) => isWordprocessingElement3(name, attributes, canonicalXml) ? "" : markup).replace(NOTE_REFERENCE_MARKUP_RE, (markup, runName, runAttributes, _rPrName, nestedName, nestedAttributes, standaloneName, standaloneAttributes) => {
+      const name = nestedName ?? standaloneName;
+      const attributes = nestedAttributes ?? standaloneAttributes;
+      if (!isWordprocessingElement3(name, attributes, canonicalXml))
+        return markup;
+      if (runName && !isWordprocessingElement3(runName, runAttributes, canonicalXml))
+        return markup;
+      return "";
+    }));
+    let hash2 = 2166136261;
+    for (let i = 0;i < normalized.length; i += 1) {
+      hash2 ^= normalized.charCodeAt(i);
+      hash2 = Math.imul(hash2, 16777619) >>> 0;
+    }
+    return `v2-run-${hash2.toString(16).padStart(8, "0")}`;
+  });
+}
+function computeRunSignature(runXml) {
+  return computeRunSignatures([runXml])[0];
 }
 function normalizeRunXmlForSignature(runXml) {
   const pieces = [];
@@ -134934,7 +134976,7 @@ function isWordprocessingElement3(name, attributes, namespaceContext) {
     return true;
   return (declaration[2] ?? declaration[3] ?? "") === WORDPROCESSINGML_NAMESPACE2;
 }
-var REVISION_ATTR_RE, REVISION_ELEMENT_RE, REVISION_ID_ATTR_RE, COMMENT_MARKUP_RE, PROOFING_BOUNDARY_MARKUP_RE, NOTE_REFERENCE_MARKUP_RE, RUN_RE, RUN_PROPERTIES_RE, EMPTY_RUN_PROPERTIES_RE, TEXTISH_RE, RUN_CONTROL_RE, ATTRIBUTE_RE, WORDPROCESSINGML_NAMESPACE2 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml", MARKUP_COMPATIBILITY_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006", XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace", XML_TAG_RE;
+var REVISION_ATTR_RE, REVISION_ELEMENT_RE, REVISION_ID_ATTR_RE, COMMENT_MARKUP_RE, PROOFING_BOUNDARY_MARKUP_RE, NOTE_REFERENCE_MARKUP_RE, RUN_RE, RUN_PROPERTIES_RE, EMPTY_RUN_PROPERTIES_RE, TEXTISH_RE, RUN_CONTROL_RE, ATTRIBUTE_RE, WORDPROCESSINGML_NAMESPACE2 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml", MARKUP_COMPATIBILITY_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006", XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace", XML_TAG_RE, BOOKMARK_OPENING_RE, BOOKMARK_TAG_RE;
 var init_run_signature = __esm(() => {
   REVISION_ATTR_RE = /\s+(?:w:rsid\w*|w14:paraId|w14:textId)="[^"]*"/g;
   REVISION_ELEMENT_RE = /<w:(?:ins|del|moveFrom|moveTo)\b[^>]*>/g;
@@ -134949,6 +134991,8 @@ var init_run_signature = __esm(() => {
   RUN_CONTROL_RE = /<((?:[\w.-]+:)?(tab|br|cr))\b([^>]*)\/>/g;
   ATTRIBUTE_RE = /([\w.:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
   XML_TAG_RE = /<(\/?)(([A-Za-z_][\w.-]*)(?::([A-Za-z_][\w.-]*))?)((?:(?:"[^"]*"|'[^']*'|[^>"'])*))>/g;
+  BOOKMARK_OPENING_RE = /<\/?w:bookmark(?:Start|End)\b/g;
+  BOOKMARK_TAG_RE = /<(\/?)w:bookmark(Start|End)\b((?:"[^"]*"|[^">])*)>/g;
 });
 
 // ../../../v2/document-compare/src/note-story-projection.ts
@@ -134960,7 +135004,7 @@ function projectCapturedNoteStoryEntries(value) {
   const ranges = collectWordParagraphRanges(value.notePartXml);
   if (!ranges)
     return null;
-  return ranges.flatMap((range, ordinal) => {
+  const entries = ranges.flatMap((range, ordinal) => {
     if (range.start < noteStart || range.end > noteEnd)
       return [];
     const paragraphXml = value.notePartXml.slice(range.start, range.end);
@@ -134974,12 +135018,13 @@ function projectCapturedNoteStoryEntries(value) {
       text: visibleParagraphText(paragraphXml, range.namespaceBindings),
       headingLevel: metadata2.headingLevel,
       styleId: metadata2.styleId,
-      runSignature: computeRunSignature(runXml),
       runXml,
       paragraphPropertiesXml,
       paragraphPropertiesSignature: computeParagraphPropertiesSignature(paragraphPropertiesXml)
     }];
   });
+  const runSignatures = computeRunSignatures(entries.map((entry) => entry.runXml ?? ""));
+  return entries.map((entry, index) => ({ ...entry, runSignature: runSignatures[index] }));
 }
 function collectWordParagraphRanges(xml) {
   let valid = true;
@@ -142136,6 +142181,12 @@ function visitNumericXmlIds(xml, visit) {
     if (value !== null)
       visit(value);
   }
+  CONTENT_CONTROL_ID_RE.lastIndex = 0;
+  while (match = CONTENT_CONTROL_ID_RE.exec(xml)) {
+    const value = parseRevisionWId(decodeXmlTextPreservingInvalidNumericEntities(match[2] ?? ""));
+    if (value !== null)
+      visit(value);
+  }
 }
 function scanMaxNumericXmlId(xml) {
   let max = 0;
@@ -142164,12 +142215,13 @@ function observeRevisionWIdsFromXml(state, xml) {
   if (max > reservation.max)
     reservation.max = max;
 }
-var TD8, NUMERIC_XML_ID_RE;
+var TD8, NUMERIC_XML_ID_RE, CONTENT_CONTROL_ID_RE;
 var init_revision_wid_scan = __esm(() => {
   init_src2();
   init_xml_text();
   TD8 = new TextDecoder;
   NUMERIC_XML_ID_RE = /\b(?:[\w.-]+:)?id\s*=\s*(["'])([^"']*)\1/g;
+  CONTENT_CONTROL_ID_RE = /<(?:[\w.-]+:)?id(?=[\s/>])[^>]*?\b(?:[\w.-]+:)?val\s*=\s*(["'])([^"']*)\1/g;
 });
 
 // ../../../v2/editor-core/dist/document/internal/part-wml-bookmark-start-cache.js
@@ -209365,6 +209417,17 @@ function planCut(pieces, levelStart, input, rootPieces, chain = []) {
         { close: chunks.close, reopen: chunks.open }
       ]);
     }
+    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);
+      if (!chunks)
+        return { kind: "reject", reason: "paragraph-split-point-unsupported" };
+      return planCut(strict.children, chunks.contentStart, input, rootPieces, [
+        ...chain,
+        { close: chunks.close, reopen: chunks.reopen }
+      ]);
+    }
     return { kind: "reject", reason: "paragraph-split-point-unsupported" };
   }
   let boundaryChar = levelStart;
@@ -209413,6 +209476,32 @@ function wrapperChunks(piece) {
     contentStart: piece.charStart + openEnd
   };
 }
+function anchoredMetadataChunks(piece, allocateWId) {
+  if (piece.children.length === 0)
+    return null;
+  const raw = piece.rawXml;
+  const prefix = /^(<w:sdt\b[^>]*>)\s*(<w:sdtPr>[\s\S]*?<\/w:sdtPr>)\s*(<w:sdtContent\b[^>]*>)/.exec(raw);
+  const close = /<\/w:sdtContent>\s*<\/w:sdt>$/.exec(raw)?.[0];
+  if (!prefix || !close)
+    return null;
+  const properties = prefix[2];
+  const normalizedProperties = properties.replace(/\s+\/>/g, "/>").replace(/>\s+</g, "><");
+  const id = /<w:id w:val="\d+"\/>/.exec(normalizedProperties)?.[0];
+  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 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>`) {
+    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()}`))
+  };
+}
 function openTagEnd(raw) {
   let quote = null;
   for (let i2 = 0;i2 < raw.length; i2 += 1) {
@@ -209439,7 +209528,7 @@ function refreshRevisionId(openChunk, allocateWId) {
 }
 function assembleHalves(src, regionStart, regionEnd, plan) {
   const closes = [...plan.chain].reverse().map((element) => element.close).join("");
-  const reopens = plan.chain.map((element) => element.reopen).join("");
+  const reopens = plan.chain.map((element) => typeof element.reopen === "function" ? element.reopen() : element.reopen).join("");
   if (plan.kind === "boundary") {
     const boundaryChar = snapBoundaryPastRunClose(src, plan.boundaryChar, regionEnd);
     return {
@@ -213704,7 +213793,8 @@ function prepareParagraphSplit(input) {
     offset: input.offset,
     space: input.coordinateSpace,
     allocateWId: input.allocateWId,
-    atomicObjectsAsCaretSlots: true
+    atomicObjectsAsCaretSlots: true,
+    allowMetadataAnchorSplit: true
   });
   if (!slice.ok)
     return slice;
@@ -213727,6 +213817,14 @@ function prepareParagraphSplit(input) {
   const headXml = openTag + headProperties + slice.head + closeTag;
   return { ok: true, headXml, tailXml };
 }
+function previewParagraphSplit(input) {
+  const result = prepareParagraphSplit({
+    ...input,
+    tailParaId: "00000000",
+    allocateWId: () => 0
+  });
+  return result.ok ? { ok: true } : result;
+}
 function renderPreparedParagraphSplit(split, trackedStamp) {
   const head = trackedStamp ? injectParagraphMarkTrackedMarker(split.headXml, "ins", trackedStamp) : split.headXml;
   return head + split.tailXml;
@@ -267771,6 +267869,10 @@ var init_registry3 = __esm(() => {
     "blocks.move": {
       supportsDryRun: true,
       dryRunOverrideReason: "The V2 block adapter validates move previews without committing package or history state."
+    },
+    "blocks.split": {
+      supportsDryRun: true,
+      dryRunOverrideReason: "The V2 block adapter validates split previews without committing package or history state."
     }
   };
   COLLABORATIVE_TABLE_REPRESENTED_OPERATIONS = new Set([
@@ -303647,17 +303749,35 @@ class V2BlocksAdapter {
     const resolved = resolveParagraphTarget(this.context, input.target);
     if ("error" in resolved)
       return failure4(resolved.error, resolved.message);
-    const begun = this.context.beginMutation({ expectedRevision: options?.expectedRevision });
-    if ("failure" in begun)
-      return failure4(begun.failure.code, begun.failure.message);
-    const tx = begun.tx;
     const partBytes = getSDDocumentSessionInternalPartBytes(this.context.session, storyPartUriFromId5(resolved.storyId));
     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 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);
+      if (policy)
+        return failure4(policy.code, policy.message);
+      if (!partBytes)
+        return failure4("INVALID_CONTEXT", "paragraph-target-not-found");
+      const planned = previewParagraphSplit({
+        paragraphXml: paraXml,
+        partBytes,
+        paragraphByteStart: resolved.entry.byteStart,
+        offset,
+        coordinateSpace
+      });
+      if (!planned.ok)
+        return failure4(mapRejectionReason(planned.reason), planned.reason);
+      return { success: true, inserted: input.target, affectedStories: [] };
+    }
+    const begun = this.context.beginMutation({ expectedRevision: options?.expectedRevision });
+    if ("failure" in begun)
+      return failure4(begun.failure.code, begun.failure.message);
+    const tx = begun.tx;
     tx.paragraphSplit({
       target: { storyId: resolved.storyId, paraId: input.target.nodeId },
-      offset: coordinateSpace === "tracked" ? Math.max(0, Math.trunc(Number.isFinite(input.offset) ? input.offset : 0)) : clampStructuralOffset(input.offset, resolved.entry.textLength + objectSlack),
+      offset,
       coordinateSpace,
       changeMode: options?.changeMode ?? "direct"
     });
@@ -355004,8 +355124,12 @@ function projectStories(context, slots) {
     if (family === "footnotes" || family === "endnotes")
       requiredPartBytes(context, story.partUri);
     const paragraphs = readStoryParagraphs(context, story.storyId).filter(isWordprocessingParagraph);
+    const runXmls = paragraphs.map((p) => extractParagraphRunXml(p.rawXml, p.namespaceBindings ?? {}));
+    const runSignatures = computeRunSignatures(runXmls);
+    const runXmlByOrdinal = new Map(paragraphs.map((p, i2) => [p.ordinal, runXmls[i2]]));
+    const runSignatureByOrdinal = new Map(paragraphs.map((p, i2) => [p.ordinal, runSignatures[i2]]));
     const projectEntry2 = (p) => {
-      const runXml = extractParagraphRunXml(p.rawXml, p.namespaceBindings ?? {});
+      const runXml = runXmlByOrdinal.get(p.ordinal);
       const paragraphPropertiesXml = extractParagraphPropertiesXml(p.rawXml, p.namespaceBindings ?? {});
       const blockId = family === "header-footer-parts" && isStructurallyBlankStoryParagraph({ text: p.text, runXml }) ? `${slotKey}::blank:${p.ordinal}` : p.blockId;
       return {
@@ -355014,7 +355138,7 @@ function projectStories(context, slots) {
         text: p.text,
         headingLevel: p.headingLevel,
         styleId: p.styleId,
-        runSignature: computeRunSignature(runXml),
+        runSignature: runSignatureByOrdinal.get(p.ordinal),
         runXml,
         trackedChangeAnnotationKeys: trackedChangeAnnotationKeysForParagraph(context, p),
         paragraphPropertiesXml,
@@ -355087,8 +355211,10 @@ function bodyParagraphStructuralScopes(context, paragraphs) {
 function projectBody(context) {
   const paragraphs = readBodyParagraphs(context).filter(isWordprocessingParagraph);
   const scopes = bodyParagraphStructuralScopes(context, paragraphs);
+  const runXmls = paragraphs.map((p) => extractParagraphRunXml(p.rawXml, p.namespaceBindings ?? {}));
+  const runSignatures = computeRunSignatures(runXmls);
   return paragraphs.map((p, ordinal) => {
-    const runXml = extractParagraphRunXml(p.rawXml, p.namespaceBindings ?? {});
+    const runXml = runXmls[ordinal];
     const paragraphPropertiesXml = extractParagraphPropertiesXml(p.rawXml, p.namespaceBindings ?? {});
     return {
       blockId: p.blockId,
@@ -355097,7 +355223,7 @@ function projectBody(context) {
       text: p.text,
       headingLevel: p.headingLevel,
       styleId: p.styleId,
-      runSignature: computeRunSignature(runXml),
+      runSignature: runSignatures[ordinal],
       runXml,
       trackedChangeAnnotationKeys: trackedChangeAnnotationKeysForParagraph(context, p),
       paragraphPropertiesXml,
@@ -359096,9 +359222,14 @@ function buildTrackedTableRowReplayPlan(input) {
     if (baseTable.gridColumnCount !== targetTable.gridColumnCount) {
       return unsafe(`table ${baseTable.tableNodeId} changes its column grid`);
     }
-    const rowKey = (row, bytes) => sliceBytes(bytes, row.rowByteStart, row.rowByteEnd).replace(/\s+w14:paraId="[0-9A-Fa-f]{8}"/g, "");
-    const baseKeys = baseTable.rows.map((row) => rowKey(row, baseBytes));
-    const targetKeys = targetTable.rows.map((row) => rowKey(row, targetBytes));
+    const rowKey = (row, bytes, root) => rowWithoutParagraphIdentities(sliceBytes(bytes, row.rowByteStart, row.rowByteEnd), root.namespaceBindings);
+    const baseKeysWithInvalid = baseTable.rows.map((row) => rowKey(row, baseBytes, baseRoot));
+    const targetKeysWithInvalid = targetTable.rows.map((row) => rowKey(row, targetBytes, targetRoot));
+    if (baseKeysWithInvalid.includes(null) || targetKeysWithInvalid.includes(null)) {
+      return unsafe(`table ${baseTable.tableNodeId} has invalid paragraph identity markup`);
+    }
+    const baseKeys = baseKeysWithInvalid.map((key2) => key2);
+    const targetKeys = targetKeysWithInvalid.map((key2) => key2);
     const baseIsShorter = baseKeys.length <= targetKeys.length;
     const matched = matchRowSubsequence(baseIsShorter ? baseKeys : targetKeys, baseIsShorter ? targetKeys : baseKeys, (baseIsShorter ? baseTable.rows : targetTable.rows).map((row) => row.rowNodeId), (baseIsShorter ? targetTable.rows : baseTable.rows).map((row) => row.rowNodeId));
     if (!matched)
@@ -359376,6 +359507,66 @@ function tableSkeleton(bytes, table) {
 function sliceBytes(bytes, start, end) {
   return new TextDecoder().decode(bytes.subarray(start, end));
 }
+function rowWithoutParagraphIdentities(rowXml, namespaceBindings) {
+  const parsed = collectXmlElementRanges(rowXml, {
+    fragment: true,
+    additionalNamespaces: xmlFragmentAdditionalNamespaces(rowXml, new Map(Object.entries(namespaceBindings)))
+  });
+  if (parsed.errors.length > 0)
+    return null;
+  const deletions = [];
+  for (const paragraph4 of parsed.ranges) {
+    if (paragraph4.tag.namespaceUri !== WORDPROCESSINGML_NS4 || paragraph4.tag.localName !== "p")
+      continue;
+    for (const attribute2 of paragraph4.tag.attributes) {
+      if (attribute2.namespaceUri !== WORDPROCESSINGML_2010_NS || attribute2.localName !== "paraId" || !/^[0-9A-Fa-f]{8}$/.test(attribute2.value))
+        continue;
+      const opening = rowXml.slice(paragraph4.start, paragraph4.openEnd);
+      const span = rawStartTagAttributeSpan(opening, attribute2.name, attribute2.value);
+      if (!span)
+        return null;
+      deletions.push({ start: paragraph4.start + span.start, end: paragraph4.start + span.end });
+    }
+  }
+  return deletions.sort((left, right) => right.start - left.start).reduce((xml, deletion) => xml.slice(0, deletion.start) + xml.slice(deletion.end), rowXml);
+}
+function rawStartTagAttributeSpan(opening, expectedName, expectedValue) {
+  const whitespace = (character) => character !== undefined && /[\x20\t\r\n]/.test(character);
+  let index2 = 1;
+  while (index2 < opening.length && !whitespace(opening[index2]) && opening[index2] !== ">" && opening[index2] !== "/")
+    index2 += 1;
+  while (index2 < opening.length) {
+    const start = index2;
+    while (whitespace(opening[index2]))
+      index2 += 1;
+    if (opening[index2] === ">" || opening[index2] === "/")
+      break;
+    const nameStart = index2;
+    while (index2 < opening.length && !whitespace(opening[index2]) && !["=", ">", "/"].includes(opening[index2]))
+      index2 += 1;
+    const name = opening.slice(nameStart, index2);
+    while (whitespace(opening[index2]))
+      index2 += 1;
+    if (opening[index2] !== "=")
+      return null;
+    index2 += 1;
+    while (whitespace(opening[index2]))
+      index2 += 1;
+    const quote = opening[index2];
+    if (quote !== '"' && quote !== "'")
+      return null;
+    const valueStart = ++index2;
+    while (index2 < opening.length && opening[index2] !== quote)
+      index2 += 1;
+    if (index2 === opening.length)
+      return null;
+    const value2 = opening.slice(valueStart, index2);
+    index2 += 1;
+    if (name === expectedName && value2 === expectedValue)
+      return { start, end: index2 };
+  }
+  return null;
+}
 function documentRootContext(xml) {
   const roots = [];
   let valid = true;
@@ -360667,10 +360858,16 @@ function projectMainDocumentBodyEntries(source, options = {}) {
   });
   const scopes = mapBodyParagraphStructuralScopes(tableCatalog, paragraphIndex.entries);
   const namespaceBindingsByByteStart = scanParagraphNamespaceBindingsByByteStart(source.xml);
-  return paragraphIndex.entries.map((entry) => {
-    const rawXml = TD107.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
+  const rawXmls = paragraphIndex.entries.map((entry) => TD107.decode(bytes.subarray(entry.byteStart, entry.byteEnd)));
+  const runXmls = paragraphIndex.entries.map((entry, index2) => {
+    const namespaceBindings = namespaceBindingsByByteStart.get(entry.byteStart) ?? {};
+    return extractParagraphRunXml(rawXmls[index2], namespaceBindings);
+  });
+  const runSignatures = computeRunSignatures(runXmls);
+  return paragraphIndex.entries.map((entry, index2) => {
+    const rawXml = rawXmls[index2];
     const namespaceBindings = namespaceBindingsByByteStart.get(entry.byteStart) ?? {};
-    const runXml = extractParagraphRunXml(rawXml, namespaceBindings);
+    const runXml = runXmls[index2];
     const paragraphPropertiesXml = extractParagraphPropertiesXml(rawXml, namespaceBindings);
     return {
       blockId: entry.blockId,
@@ -360679,7 +360876,7 @@ function projectMainDocumentBodyEntries(source, options = {}) {
       text: readVisibleParagraphText(rawXml),
       headingLevel: paragraphHeadingLevel(rawXml, { paragraphStyleOutlineLevels }),
       styleId: paragraphStyleId(rawXml),
-      runSignature: computeRunSignature(runXml),
+      runSignature: runSignatures[index2],
       runXml,
       paragraphPropertiesXml,
       paragraphPropertiesSignature: computeParagraphPropertiesSignature2(paragraphPropertiesXml)
@@ -363160,22 +363357,32 @@ function buildCompareApplyEligibility(context, payload, plans) {
       if (bodyDeferredToTableReplay)
         direct.add("body");
     }
+    const trackedBodyOperations = payload.applyPlan.bodyOperations.length > 0 ? payload.applyPlan.bodyOperations : computeCompareBodyOperations(payload.base.body, payload.target.body, {
+      base: payload.base.definitions,
+      target: payload.target.definitions
+    });
     const trackedTablePlan = buildTrackedTableRowReplayPlan({
       base: mainDocument.base,
       target: mainDocument.target,
       baseBody: payload.base.body,
       targetBody: payload.target.body,
-      bodyOperations: payload.applyPlan.bodyOperations.length > 0 ? payload.applyPlan.bodyOperations : computeCompareBodyOperations(payload.base.body, payload.target.body, {
-        base: payload.base.definitions,
-        target: payload.target.definitions
-      })
+      bodyOperations: trackedBodyOperations
     });
+    const trackedBlockPlan = trackedTablePlan.unsafeReasons.length > 0 && !trackedTablePlan.refuseBlockFallback ? buildTrackedTableBlockReplayPlan({
+      base: mainDocument.base,
+      target: mainDocument.target,
+      bodyOperations: trackedBodyOperations,
+      allowTopologyReplacement: true
+    }) : null;
     if (trackedTablePlan.unsafeReasons.length === 0 && trackedTablePlan.steps.length > 0) {
       tracked.add("tables");
       if (bodyDeferredToTableReplay)
         tracked.add("body");
       if (rowReplayCoversContentControls(payload.base.annotations, payload.target.annotations, trackedTablePlan.steps, mainDocument.base.xml, mainDocument.target.xml))
         tracked.add("content-controls");
+    } else if (trackedBlockPlan && trackedBlockPlan.steps.length > 0) {
+      tracked.add("tables");
+      tracked.add("body");
     }
   }
   const packageGraphCoveredByComments = direct.has("comments") && packageGraphKeysNotCoveredByComments(context, payload.base, payload.target, plans.commentPlan.steps).length === 0;
@@ -381859,10 +382066,27 @@ function groupMetadataAnchor(documentXml, id, knownIds) {
   const kept = contiguousAnchorPrefix(documentXml, matches);
   if (kept.length === 1)
     return { id, segments: kept, target: kept[0].target };
-  const textSegments = kept.map((anchor) => ({
-    blockId: anchor.blockId,
-    range: { start: anchor.startOffset, end: anchor.endOffset }
-  }));
+  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,
@@ -381882,7 +382106,12 @@ function contiguousAnchorPrefix(documentXml, matches) {
     const context = map3.byBlockId(matches[i2].blockId);
     if (!context)
       break;
-    if (context.ordinal !== prev.ordinal + 1)
+    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;
@@ -381899,6 +382128,9 @@ function contiguousAnchorPrefix(documentXml, matches) {
   }
   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]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.2.0-next.13",
+  "version": "1.2.0-next.15",
   "description": "Model Context Protocol server for SuperDoc, giving an AI agent tools to read and edit .docx files.",
   "type": "module",
   "license": "AGPL-3.0",
@@ -24,13 +24,13 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@superdoc/sdk": "2.15.0-next.13",
+    "@superdoc/sdk": "2.15.0-next.15",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.18.0-next.13",
-    "@superdoc/docx-engine": "0.17.0-next.15",
+    "superdoc": "2.18.0-next.15",
+    "@superdoc/docx-engine": "0.17.0-next.17",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",