@superdoc/mcp 1.6.0-next.16 → 1.6.0-next.18

package/dist/index.js

@@ -31600,7 +31600,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.19.0-next.16";
+var SDK_VERSION = "2.19.0-next.18";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -195388,7 +195388,7 @@ function isBreakRunToken(token) {
 }
 function compileOverlapEdit(input) {
   const paragraphInlineMap = input.paragraphInlineMap ?? parseParagraphInlineMap(input.paragraphXml, input.namespaceBindings);
-  const consecutiveBreakInsertion = tryConsecutiveManualBreakInsertion(input, paragraphInlineMap);
+  const consecutiveBreakInsertion = input.newTextRunsXml === undefined ? tryConsecutiveManualBreakInsertion(input, paragraphInlineMap) : null;
   if (consecutiveBreakInsertion)
     return consecutiveBreakInsertion;
   const readsComplexDeletionForCollapsedInsert = input.newText.length > 0 && input.rangeStart === input.rangeEnd && ((input.coordinateSpace ?? "visible") === "visible" || input.changeMode === "tracked");
@@ -195483,6 +195483,12 @@ function compileParsedOverlapEdit(input, tokens, descendedEditableContainers) {
   if (touched.length === 0 && touchedBreaks.length === 0) {
     return { ok: false, reason: "invalid-range", detail: "overlap compiler: no tokens touched by the range." };
   }
+  if (input.newTextRunsXml !== undefined) {
+    const parent = touched.length === 1 ? touched[0].token : null;
+    if (input.changeMode !== "tracked" || input.rangeStart !== input.rangeEnd || !input.newText.length || parent?.kind !== "ins" || input.rangeStart <= parent.visibleStart || input.rangeStart >= parent.visibleEnd || parent.nestedDeletions?.length || parent.commentedBoundary || descendedEditableContainers.length || !parent.sourceIdentity.rsid && !parent.sourceIdentity.wId) {
+      return { ok: false, reason: "text-range-in-unsupported-tracked-wrapper" };
+    }
+  }
   if (touchedBreaks.length > 0) {
     const withBreaks = tryPureDeleteAcrossTokens(input, tokens, touched, touchedBreaks);
     if (withBreaks)
@@ -196587,7 +196593,10 @@ function foldInsideOwnInsertion(input, allTokens, parent) {
     return result2.ok && input.changeMode === "direct" ? { ...result2, requiresCollaborationSessionSync: true } : result2;
   }
   let innerXml = null;
-  if (nestedDeletions.length > 0) {
+  if (input.newTextRunsXml !== undefined) {
+    const runs = parent.innerRuns ?? [parent.inner];
+    innerXml = buildInsInnerXmlFromRuns(sliceWrappedRuns(runs, 0, localStart)) + input.newTextRunsXml + buildInsInnerXmlFromRuns(sliceWrappedRuns(runs, localEnd, text.length));
+  } else if (nestedDeletions.length > 0) {
     const runs = spliceInnerRuns(parent.innerRuns ?? [parent.inner], localStart, localEnd, input.newText, parent, localStart);
     const delta = input.newText.length - (localEnd - localStart);
     const preservedDeletions = nestedDeletions.map((entry) => {
@@ -196988,7 +196997,8 @@ function splitInsertionAroundChildChange(input, allTokens, parent) {
         runClose: insertMeta.runClose,
         rPr: insertRPr,
         text: input.newText
-      }
+      },
+      ...input.newTextRunsXml !== undefined ? { innerXml: input.newTextRunsXml } : {}
     });
     const closed = closeFreshInsertionScope(childInsXml, Object.fromEntries(parent.namespaceBindings), input.namespaceBindings ?? {});
     if (closed == null)
@@ -221707,7 +221717,12 @@ function planDirectParagraphRangeRewrite(input) {
   if (!bytes || end.partUri !== start.partUri)
     return { ok: false, reason: "unsupported-context" };
   const partXml = TD56.decode(bytes);
-  const cascadingComments = expandCommentThreadWIds(state, collectCommentsTouchedByByteRange(partXml, input.selectionStartByte, input.selectionEndByte));
+  const commentMarkers = collectBodyCommentMarkers(partXml);
+  const touchedComments = collectCommentsTouchedByByteRange(commentMarkers, input.selectionStartByte, input.selectionEndByte);
+  const retainedStarts = retainedCommentStarts(input, bytes, commentMarkers, touchedComments);
+  for (const marker of retainedStarts)
+    touchedComments.delete(marker.id);
+  const cascadingComments = expandCommentThreadWIds(state, touchedComments);
   const startXml = decodeByteRange2(bytes, start.byteStart, start.byteEnd);
   const endXml = decodeByteRange2(bytes, end.byteStart, end.byteEnd);
   const beforeWindowXml = decodeByteRange2(bytes, start.byteStart, end.byteEnd);
@@ -221741,7 +221756,13 @@ function planDirectParagraphRangeRewrite(input) {
     });
     if (!endSlice.ok)
       return endSlice;
-    const collapsed = sectionCollapse ? sectionCollapse.render(startSlice.head, endSlice.tail) : renderCollapsedParagraph(startXml, startSlice.head, endSlice.tail);
+    let movedStarts = "";
+    if (retainedStarts.length > 0) {
+      const destinationNamespaces = namespaceBindingsAtPosition(bytes, start.byteStart, matchParagraphOpenTag(startXml) ?? "");
+      const retainedHeadStarts = collectBodyCommentMarkers(startSlice.head, destinationNamespaces).filter((marker) => marker.kind === "commentRangeStart").map((marker) => marker.id);
+      movedStarts = retainedStarts.filter((marker) => !retainedHeadStarts.includes(marker.id)).map((marker) => commentMarkerWithNamespaces(bytes, marker, destinationNamespaces)).join("");
+    }
+    const collapsed = sectionCollapse ? sectionCollapse.render(startSlice.head + movedStarts, endSlice.tail) : renderCollapsedParagraph(startXml, startSlice.head + movedStarts, endSlice.tail);
     if (!collapsed)
       return { ok: false, reason: "invalid-range" };
     collapsedXml = collapsed;
@@ -223555,14 +223576,42 @@ function collectCascadingComments(paraXml, resolveNamespaceBindings) {
     return new Set;
   return new Set(collectBodyCommentMarkers(paraXml, resolveNamespaceBindings()).map((marker) => marker.id));
 }
-function collectCommentsTouchedByByteRange(xml, startByte, endByte) {
+function collectCommentsTouchedByByteRange(markers, startByte, endByte) {
   const touched = new Set;
-  for (const marker of collectBodyCommentMarkers(xml)) {
+  for (const marker of markers) {
     if (marker.range.byteStart < endByte && marker.range.byteEnd > startByte)
       touched.add(marker.id);
   }
   return touched;
 }
+function retainedCommentStarts(input, bytes, markers, touched) {
+  if (input.fullBlockReplacementXml !== undefined)
+    return [];
+  return markers.filter((marker) => {
+    if (marker.kind !== "commentRangeStart" || !touched.has(marker.id))
+      return false;
+    const anchors = markers.filter((candidate2) => candidate2.id === marker.id);
+    const end = anchors.find((candidate2) => candidate2.kind === "commentRangeEnd");
+    const reference = anchors.find((candidate2) => candidate2.kind === "commentReference");
+    if (anchors.length !== 3 || !end || !reference || marker.range.byteStart < input.selectionStartByte || marker.range.byteEnd > input.selectionEndByte || end.range.byteStart < input.selectionEndByte || reference.range.byteStart < end.range.byteEnd)
+      return false;
+    const endEntry = input.indexEntries.find((entry) => end.range.byteStart >= entry.byteStart && end.range.byteStart < entry.byteEnd);
+    if (!endEntry || endEntry.ordinal < input.end.ordinal)
+      return false;
+    const endXml = decodeByteRange2(bytes, endEntry.byteStart, endEntry.byteEnd);
+    const model = parseParagraphInlineMap(endXml, end.paragraph?.namespaceBindings);
+    const endMarkerOffset = resolveParagraphVisibleOffsetAtByte(model, end.range.byteStart - endEntry.byteStart);
+    const remainingChars = endEntry.ordinal === input.end.ordinal ? endMarkerOffset - input.endOffset : input.end.textLength - input.endOffset + endMarkerOffset + input.indexEntries.filter((entry) => entry.ordinal > input.end.ordinal && entry.ordinal < endEntry.ordinal).reduce((sum, entry) => sum + entry.textLength, 0);
+    return remainingChars > 0;
+  });
+}
+function commentMarkerWithNamespaces(bytes, marker, destinationNamespaces) {
+  const xml = decodeByteRange2(bytes, marker.range.byteStart, marker.range.byteEnd);
+  const openTag = xml.match(/^<(?:"[^"]*"|'[^']*'|[^>"'])*>/)?.[0] ?? "";
+  const localNamespaces = namespaceBindingsAtPosition(TE25.encode(xml), 0, openTag);
+  const declarations = Object.entries(namespaceBindingsAtPosition(bytes, marker.range.byteStart)).filter(([prefix, uri]) => localNamespaces[prefix] === undefined && destinationNamespaces[prefix] !== uri).map(([prefix, uri]) => ` xmlns${prefix ? `:${prefix}` : ""}="${escapeXmlAttribute(uri)}"`).join("");
+  return xml.replace(/^<[\w.-]+(?::[\w.-]+)?\b/, (tag) => tag + declarations);
+}
 function stripCommentAnchorsFromXml(xml, commentIds, resolveNamespaceBindings) {
   const bytes = TE25.encode(xml);
   if (commentIds.size === 0)
@@ -238014,6 +238063,50 @@ var init_types6 = __esm(() => {
 });
 
 // ../../../v2/editor-core/dist/document/transactions/compile-paste-splice.js
+function planTrackedInsertionSplice(input) {
+  const block = input.blocks.length === 1 ? input.blocks[0] : null;
+  const stamp = input.trackedStamp;
+  if (!stamp || input.wrapAllTracked === false || input.collapsedObjectBoundary || (input.replaceToOffset ?? input.charOffset) !== input.charOffset || block?.kind !== "paragraph" || block.styleRef || block.numbering || block.listIntent || block.paragraphProps || block.pPrXml || block.blockSdts?.length || block.complete)
+    return null;
+  const runs = input.inlineSpecs?.get(block) ?? block.runs.map(toPasteTextRunSpec);
+  if (runs.some((run) => run.kind !== undefined && run.kind !== "text" || ("commentIds" in run) && run.commentIds?.length || ("trackedInsertion" in run) && run.trackedInsertion))
+    return null;
+  const newText = runs.map((run) => ("text" in run) ? run.text : "").join("");
+  if (!newText)
+    return null;
+  const envelope = parseParagraphEnvelope(input.anchorXml);
+  if (!envelope)
+    return null;
+  const newTextRunsXml = renderPasteRuns(runs).replace(/<w:r(?=[\s>])/g, '<w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"');
+  const overlap = compileOverlapEdit({
+    storyId: input.storyId,
+    paragraphXml: input.anchorXml,
+    namespaceBindings: namespaceBindingsAtPosition(input.partBytes, input.paragraphStartByte, envelope.open),
+    rangeStart: input.charOffset,
+    rangeEnd: input.charOffset,
+    newText,
+    newTextRunsXml,
+    changeMode: "tracked",
+    currentAuthor: stamp.author,
+    txTimestamp: stamp.date,
+    rsid: stamp.rsid,
+    insRsid: stamp.rsid,
+    nextWId: () => stamp.allocateWId(),
+    reserveWId: () => stamp.allocateWId()
+  });
+  if (!overlap.ok)
+    return { ok: false, reason: overlap.reason };
+  return {
+    ok: true,
+    xml: overlap.xml,
+    createdParaIds: [],
+    destinationParaIdsByBlock: [[input.anchorParaId ?? ""]],
+    insertedVisibleChars: newText.length,
+    removedVisibleChars: 0,
+    anchorParagraphUnchanged: false,
+    trackedChangeRsids: { created: overlap.emittedRsids, updated: overlap.updatedRsids ?? [] }
+  };
+}
 function planParagraphSplice(input) {
   const start = input.charOffset;
   const end = input.replaceToOffset ?? input.charOffset;
@@ -238341,6 +238434,7 @@ function withTrackedRsid(openTag, rsid) {
 var init_compile_paste_splice = __esm(() => {
   init_paragraph_inline_model();
   init_xml_text();
+  init_overlap_edit_compiler();
   init_paragraph_contribution();
   init_paragraph_para_id_attrs();
 });
@@ -242680,7 +242774,7 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
         return deleted;
       rewrittenXml = deleted.xml;
     }
-    return planParagraphSplice({
+    const spliceInput = {
       anchorXml: rewrittenXml,
       anchorParaId: anchor.entry.blockId,
       blocks: resolvedBlocks,
@@ -242695,7 +242789,12 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
       ...stamp ? { trackedStamp: stamp, wrapAllTracked } : {},
       ...listExtras.commentIdMap ? { commentIdMap: listExtras.commentIdMap } : {},
       ...listExtras.noteIdMap ? { noteIdMap: listExtras.noteIdMap } : {}
-    });
+    };
+    const ordinary = planParagraphSplice(spliceInput);
+    if (!ordinary.ok && ordinary.reason === "paste-target-unsupported" && wrapAllTracked && (target.replaceToOffset ?? target.charOffset) === target.charOffset) {
+      return planTrackedInsertionSplice({ ...spliceInput, storyId: target.storyId }) ?? ordinary;
+    }
+    return ordinary;
   };
   const plan = planForParagraph(anchorXml, trackedStamp, () => mintParaId(state, state.packageRevision, anchor.ordinal + 1 + (mintSalt += 1)));
   if (!plan.ok)
@@ -242767,8 +242866,9 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
     nodeId: paraId,
     storyId: target.storyId
   }));
-  if (trackedStamp) {
-    createdRefs.push({ kind: "trackedChange", entityId: trackedStamp.rsid, storyId: target.storyId });
+  const createdTrackedRsids = plan.trackedChangeRsids?.created ?? (trackedStamp ? [trackedStamp.rsid] : []);
+  for (const entityId of createdTrackedRsids) {
+    createdRefs.push({ kind: "trackedChange", entityId, storyId: target.storyId });
   }
   if (listExtras.createdRefs)
     createdRefs.push(...listExtras.createdRefs);
@@ -242780,7 +242880,14 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
     textRangeShifts,
     createdParaIds: [...plan.createdParaIds],
     createdRefs,
-    updatedRefs: [{ kind: "block", nodeId: target.paraId, storyId: target.storyId }],
+    updatedRefs: [
+      { kind: "block", nodeId: target.paraId, storyId: target.storyId },
+      ...(plan.trackedChangeRsids?.updated ?? []).map((entityId) => ({
+        kind: "trackedChange",
+        entityId,
+        storyId: target.storyId
+      }))
+    ],
     relativeToBlockId: target.paraId,
     provisionalToFinal: buildPasteProvisionalMappings(txId, plan.createdParaIds, resolvedBlocks, plan.destinationParaIdsByBlock),
     extraPatchMaps: listExtras.patchMaps,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.6.0-next.16",
+  "version": "1.6.0-next.18",
   "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.19.0-next.16",
+    "@superdoc/sdk": "2.19.0-next.18",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.22.0-next.15",
-    "@superdoc/docx-engine": "0.21.0-next.16",
+    "superdoc": "2.22.0-next.17",
+    "@superdoc/docx-engine": "0.21.0-next.18",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",