@superdoc/mcp 1.4.1-next.4 → 1.4.1-next.5

package/dist/index.js

@@ -31330,7 +31330,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.17.1-next.4";
+var SDK_VERSION = "2.17.1-next.5";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -193328,7 +193328,7 @@ function tryPreserveCollapsedInsertionAtComplexDeletionBoundary(input, allTokens
   return compileOverlapWithInsertion(input, allTokens, insertion, touched.filter(({ token }) => token.kind !== "del"));
 }
 function tryPreserveCollapsedInsertionAtSimpleDeletionBoundary(input, allTokens, wrappers) {
-  if (input.changeMode !== "tracked" || input.newText.length === 0 || input.rangeStart !== input.rangeEnd || (input.coordinateSpace ?? "visible") !== "visible") {
+  if (input.changeMode !== "tracked" || input.newText.length === 0 || input.rangeStart !== input.rangeEnd) {
     return null;
   }
   const insertions = wrappers.filter((token) => token.kind === "ins");
@@ -193338,6 +193338,10 @@ function tryPreserveCollapsedInsertionAtSimpleDeletionBoundary(input, allTokens,
   const insertion = insertions[0];
   const deletion = deletions[0];
   const classification = insertion._classification;
+  if (input.coordinateSpace === "tracked") {
+    const isTrackedInsertionDeletionBoundary = classification !== "same-user" && deletion.payloadIsExactSingleTextRun === true && insertion.visibleEnd === input.rangeStart && deletion.visibleStart === input.rangeStart && insertion.byteEnd === deletion.byteStart;
+    return isTrackedInsertionDeletionBoundary ? insertAtForeignDeletion(input, allTokens, deletion, false, "before") : null;
+  }
   const sameAuthor3 = !!deletion.author.name && deletion.author.name === insertion.author.name && (!deletion.author.initials || !insertion.author.initials || deletion.author.initials === insertion.author.initials);
   const isEngineReplacementBoundary = deletion.payloadIsExactSingleTextRun === true && deletion.byteEnd === insertion.byteStart && deletion.visibleStart === input.rangeStart && insertion.visibleStart === input.rangeStart && sameAuthor3;
   if (classification === "same-user" || !isEngineReplacementBoundary) {
@@ -193399,7 +193403,7 @@ function tryPureDeleteAcrossTokens(input, allTokens, touched, touchedBreaks = []
   if (input.newText.length !== 0 || input.rangeStart >= input.rangeEnd)
     return null;
   const touchedInsertions = touched.filter((entry) => entry.token.kind === "ins");
-  if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 1 || token.nestedDeletions && token.nestedDeletions.length > 0)) {
+  if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 0 || token.nestedDeletions && token.nestedDeletions.length > 0)) {
     return null;
   }
   return input.changeMode === "tracked" ? authorTrackedPureDelete(input, allTokens, touched, touchedBreaks) : authorDirectPureDelete(input, allTokens, touched, touchedBreaks);
@@ -193419,7 +193423,7 @@ function tryRangeReplacementAcrossTokens(input, allTokens, touched) {
   if (!firstSelected)
     return null;
   const touchedInsertions = touched.filter((entry) => entry.token.kind === "ins");
-  if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 1 && (token !== firstSelected.token || token.commentedBoundary != null) || token.nestedDeletions && token.nestedDeletions.length > 0)) {
+  if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 0 && (token !== firstSelected.token || token.commentedBoundary != null) || token.nestedDeletions && token.nestedDeletions.length > 0)) {
     return null;
   }
   const result = input.changeMode === "tracked" ? authorTrackedPureDelete(input, allTokens, touched) : authorDirectPureDelete(input, allTokens, touched);
@@ -193783,7 +193787,7 @@ function authorDirectPureDelete(input, allTokens, touched, touchedBreaks = []) {
   return result;
 }
 function insertPlainTextInsideTrackedWrapper(input, allTokens, parent, touched) {
-  if (parent.kind === "ins" && parent.innerRuns && parent.innerRuns.length > 1) {
+  if (parent.kind === "ins" && parent.innerRuns && parent.innerRuns.length > 0) {
     return {
       ok: false,
       reason: "text-range-in-unsupported-tracked-wrapper",
@@ -193991,7 +193995,7 @@ function foldInsideOwnInsertion(input, allTokens, parent) {
     const result = markTextInsertionRefined(rebuildParagraph(allTokens, parent, ""), input, parent, true);
     return result.ok && input.changeMode === "direct" ? { ...result, requiresCollaborationSessionSync: true } : result;
   }
-  const innerXml = parent.innerRuns && parent.innerRuns.length > 1 ? buildInsInnerXmlFromRuns(spliceInnerRuns(parent.innerRuns, localStart, localEnd, input.newText, parent, localStart)) : null;
+  const innerXml = parent.innerRuns && parent.innerRuns.length > 0 ? buildInsInnerXmlFromRuns(spliceInnerRuns(parent.innerRuns, localStart, localEnd, input.newText, parent, localStart)) : null;
   const newInsXml = buildInsWrapperXml({
     openTag: parent.openTag,
     namespaceBindings: parent.namespaceBindings,
@@ -194029,7 +194033,13 @@ function flattenWrappedRuns(runs) {
   const out = [];
   for (const run of runs) {
     for (let index = 0;index < run.text.length; index += 1) {
-      out.push({ ch: run.text.charAt(index), rPr: run.rPr, runOpen: run.runOpen, runClose: run.runClose });
+      out.push({
+        ch: run.text.charAt(index),
+        rPr: run.rPr,
+        runOpen: run.runOpen,
+        runClose: run.runClose,
+        ...run.controlXml ? { controlXml: run.controlXml } : {}
+      });
     }
   }
   return out;
@@ -194041,20 +194051,22 @@ function coalesceWrappedRuns(chars) {
   let runOpen = chars[0].runOpen;
   let runClose = chars[0].runClose;
   let rPr = chars[0].rPr;
+  let controlXml = chars[0].controlXml;
   let text = chars[0].ch;
   for (let i2 = 1;i2 < chars.length; i2 += 1) {
     const ch = chars[i2];
-    if (ch.rPr === rPr && ch.runOpen === runOpen && ch.runClose === runClose) {
+    if (!controlXml && !ch.controlXml && ch.rPr === rPr && ch.runOpen === runOpen && ch.runClose === runClose) {
       text += ch.ch;
       continue;
     }
-    out.push({ runOpen, runClose, rPr, text });
+    out.push({ runOpen, runClose, rPr, text, ...controlXml ? { controlXml } : {} });
     runOpen = ch.runOpen;
     runClose = ch.runClose;
     rPr = ch.rPr;
+    controlXml = ch.controlXml;
     text = ch.ch;
   }
-  out.push({ runOpen, runClose, rPr, text });
+  out.push({ runOpen, runClose, rPr, text, ...controlXml ? { controlXml } : {} });
   return out;
 }
 function runMetaAtInsertionPoint(parent, localOffset, preferNextRunAtBoundary = false) {
@@ -194090,7 +194102,7 @@ function spliceInnerRuns(runs, localStart, localEnd, newText, parent, insertOffs
   return coalesceWrappedRuns([...flat.slice(0, localStart), ...inserted, ...flat.slice(localEnd)]);
 }
 function buildInsInnerXmlFromRuns(runs) {
-  return runs.map((run) => renderPlainRun(run.text, run.runOpen, run.runClose, run.rPr)).join("");
+  return runs.map((run) => run.controlXml ? `${run.runOpen}${run.rPr}${run.controlXml}${run.runClose}` : renderPlainRun(run.text, run.runOpen, run.runClose, run.rPr)).join("");
 }
 function buildInsInnerXmlInterleaved(flat, nested, textSliceStart, textSliceEnd) {
   if (nested.length === 0) {
@@ -194120,7 +194132,7 @@ function rPrAtInsertionPoint(parent, localOffset, preferNextRunAtBoundary = fals
   return runs[runs.length - 1].rPr;
 }
 function spanningSameUserInsertion(input, allTokens, parent, touched) {
-  if (parent.innerRuns && parent.innerRuns.length > 1) {
+  if (parent.innerRuns && parent.innerRuns.length > 0) {
     return {
       ok: false,
       reason: "text-range-in-unsupported-tracked-wrapper",
@@ -194812,7 +194824,7 @@ function buildDelWrapperXml(params) {
   return `${openTag}${inner}${closeTag}`;
 }
 function buildDelInnerXmlFromRuns(runs) {
-  return runs.map((run) => renderDelRun(run.text, run.runOpen, run.runClose, run.rPr)).join("");
+  return runs.map((run) => run.controlXml ? `${run.runOpen}${run.rPr}${run.controlXml}${run.runClose}` : renderDelRun(run.text, run.runOpen, run.runClose, run.rPr)).join("");
 }
 function trackedWrapperCloseTag(openTag, fallbackPrefix, localName2) {
   const sourceQName = /^<([^\s/>]+)/.exec(openTag)?.[1];
@@ -195113,6 +195125,22 @@ function readCommentedInsertionBoundary(piece) {
     referenceRunXml
   };
 }
+function isManualBreak(piece, inherited) {
+  if (piece.control === "cr")
+    return true;
+  if (piece.control !== "br")
+    return false;
+  const bindings = new Map(inherited);
+  for (const tag of [piece.runOpenTag, piece.rawXml]) {
+    for (const attribute of scanRawXmlAttributes(tag)) {
+      if (attribute.name === "xmlns" || attribute.prefix === "xmlns") {
+        bindings.set(attribute.name === "xmlns" ? "" : attribute.localName, decodeXmlText(attribute.value));
+      }
+    }
+  }
+  const type = decodeNamespacedAttr(piece.rawXml, bindings, "type");
+  return type == null || type === "textWrapping";
+}
 function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStructuralDeletionPassThrough) {
   const visibleStart = spanStart(piece);
   const visibleEnd = spanEnd(piece);
@@ -195176,8 +195204,8 @@ function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStr
     }
     const firstText = textLeaves2[0];
     const nsPrefix2 = piece.prefix ?? "w";
-    const runStarts2 = [...new Set(textLeaves2.map((leaf) => leaf.runCharStart))].sort((a, b) => a - b);
-    const innerRuns2 = runStarts2.map((runStart) => {
+    const runStarts = [...new Set(textLeaves2.map((leaf) => leaf.runCharStart))].sort((a, b) => a - b);
+    const innerRuns2 = runStarts.map((runStart) => {
       const leaves = textLeaves2.filter((leaf) => leaf.runCharStart === runStart);
       const first = leaves[0];
       return {
@@ -195226,7 +195254,7 @@ function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStr
       }
     };
   }
-  const foreignChild = piece.children.find((child) => child.kind === "container" || child.kind === "unknown" || child.kind === "noteReference" || child.kind === "control" && !(piece.trackedKind === "ins" && child.control === "tab") || child.kind === "marker" && !commentedBoundary);
+  const foreignChild = piece.children.find((child) => child.kind === "container" || child.kind === "unknown" || child.kind === "noteReference" || child.kind === "control" && !(piece.trackedKind === "ins" && (child.control === "tab" || isManualBreak(child, piece.namespaceBindings))) || child.kind === "marker" && !commentedBoundary);
   if (foreignChild) {
     if (foreignChild.kind === "container") {
       return unsupported2(containerRejectionReason(foreignChild.containerKind), `overlap compiler: ${foreignChild.containerKind} inside w:${piece.trackedKind}`);
@@ -195239,21 +195267,36 @@ function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStr
     }
     return unsupported2("text-range-in-unsupported-tracked-wrapper", `overlap compiler: unsupported payload inside w:${piece.trackedKind}`);
   }
-  const textLeaves = piece.children.filter((child) => child.kind === "text" || piece.trackedKind === "ins" && child.kind === "control" && child.control === "tab");
+  const hasManualBreak = piece.trackedKind === "ins" && piece.children.some((child) => child.kind === "control" && isManualBreak(child, piece.namespaceBindings));
+  if (hasManualBreak && piece.children.some((child) => child.kind === "text" && child.textRole !== "visible")) {
+    return unsupported2("text-range-in-unsupported-tracked-wrapper", "overlap compiler: non-visible text beside a manual break");
+  }
+  if (hasManualBreak && !piece.children.some((child) => child.kind === "text" && child.textRole === "visible" && child.decodedText.length > 0)) {
+    return unsupported2("text-payload-unsupported-control-char", "overlap compiler: control-only insertion");
+  }
+  const textLeaves = piece.children.filter((child) => child.kind === "text" || piece.trackedKind === "ins" && child.kind === "control" && (child.control === "tab" || isManualBreak(child, piece.namespaceBindings)));
   if (textLeaves.length === 0 && !(nestedDeletions && nestedDeletions.length > 0)) {
     return unsupported2("text-range-in-unsupported-tracked-wrapper", `overlap compiler: empty w:${piece.trackedKind}`);
   }
-  const runStarts = [...new Set(textLeaves.map((leaf) => leaf.runCharStart))].sort((a, b) => a - b);
-  const innerRuns = runStarts.map((runStart) => {
-    const leaves = textLeaves.filter((leaf) => leaf.runCharStart === runStart);
-    const first = leaves[0];
-    return {
-      runOpen: first.runOpenTag,
-      runClose: first.runCloseTag,
-      rPr: first.runProperties ?? "",
-      text: leaves.map((leaf) => leaf.kind === "control" ? "\t" : leaf.decodedText).join("")
-    };
-  });
+  const innerRuns = [];
+  for (const [index, leaf] of textLeaves.entries()) {
+    const manualBreak = leaf.kind === "control" && isManualBreak(leaf, piece.namespaceBindings);
+    const text = leaf.kind === "control" ? manualBreak ? `
+` : "\t" : leaf.decodedText;
+    const previous = innerRuns[innerRuns.length - 1];
+    const previousLeaf = textLeaves[index - 1];
+    if (!manualBreak && previous && !previous.controlXml && previousLeaf?.runCharStart === leaf.runCharStart) {
+      previous.text += text;
+    } else {
+      innerRuns.push({
+        runOpen: leaf.runOpenTag,
+        runClose: leaf.runCloseTag,
+        rPr: leaf.runProperties ?? "",
+        text,
+        ...manualBreak ? { controlXml: leaf.rawXml } : {}
+      });
+    }
+  }
   if (piece.trackedKind !== "ins" && innerRuns.length > 1) {
     return unsupported2("text-range-in-unsupported-tracked-wrapper", `overlap compiler: multi-run w:${piece.trackedKind} not supported`);
   }
@@ -195289,7 +195332,7 @@ function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStr
       rPr: inner.rPr,
       text: inner.text
     },
-    ...innerRuns.length > 1 ? { innerRuns } : {}
+    ...innerRuns.length > 1 || innerRuns.some((run) => run.controlXml) ? { innerRuns } : {}
   };
   return piece.trackedKind === "ins" ? {
     kind: "ins",
@@ -197716,8 +197759,7 @@ function resolvePlannedDirectInsertRunProperties(beforeParagraphXml, afterParagr
   const properties = collectXmlElementRanges(afterXml, { fragment: true, additionalNamespaces: { ...namespaceBindings } }).ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "rPr" && range.start >= carrier.runCharStart && range.end <= carrier.runCharEnd);
   return properties ? closeNamespaceScope(afterXml.slice(properties.start, properties.end), properties.namespaceBindings, { w: NS_W }, { referencedOnly: true }) : null;
 }
-function projectTrackedParagraphOffsetToVisible(paragraphXml, trackedOffset) {
-  const model = parseParagraphInlineMap(paragraphXml);
+function projectTrackedParagraphOffsetToVisible(paragraphXml, trackedOffset, model = parseParagraphInlineMap(paragraphXml)) {
   if (!Number.isInteger(trackedOffset) || trackedOffset < 0 || trackedOffset > model.trackedLength)
     return null;
   if (trackedOffset === model.trackedLength)
@@ -198741,12 +198783,12 @@ function tryOverlapRewriteDirect(input, bytes, window2, byteBase, inheritedNames
 }
 function tryOverlapRewriteTracked(input, bytes, window2, byteBase, stamp, inlineContext, inheritedNamespaceBindings) {
   const op = input.op;
-  const paragraphXml = inlineContext?.paragraphXml ?? TD40.decode(bytes.subarray(window2.byteStart, window2.byteEnd));
+  let paragraphXml = inlineContext?.paragraphXml ?? TD40.decode(bytes.subarray(window2.byteStart, window2.byteEnd));
   const namespaceBindings = inheritedNamespaceBindings ?? textTargetNamespaceBindings(input, window2, byteBase);
-  const compiled = compileOverlapEdit({
+  const compile = (usePreparedModel) => compileOverlapEdit({
     storyId: op.on.storyId,
     paragraphXml,
-    ...inlineContext ? { paragraphInlineMap: inlineContext.model } : {},
+    ...usePreparedModel && inlineContext ? { paragraphInlineMap: inlineContext.model } : {},
     namespaceBindings,
     rangeStart: op.on.startOffset,
     rangeEnd: op.on.endOffset,
@@ -198763,6 +198805,16 @@ function tryOverlapRewriteTracked(input, bytes, window2, byteBase, stamp, inline
     reserveWId: () => reserveRevisionWIdBlock(input.state, 1),
     revisionOccurrenceAt: createRevisionOccurrenceResolver(input, bytes, window2, byteBase, paragraphXml)
   });
+  let compiled = compile(true);
+  if (!compiled.ok && compiled.reason === "text-payload-unsupported-control-char" && op.on.startOffset === op.on.endOffset && op.newText.length > 0) {
+    const model = inlineContext?.model ?? parseParagraphInlineMap(paragraphXml, namespaceBindings);
+    const visibleOffset = op.on.coordinateSpace === "tracked" ? projectTrackedParagraphOffsetToVisible(paragraphXml, op.on.startOffset, model) : op.on.startOffset;
+    const normalized = visibleOffset == null ? null : splitCompoundRunsForTrackedReplace(paragraphXml, visibleOffset, visibleOffset, true, false, namespaceBindings);
+    if (normalized) {
+      paragraphXml = normalized;
+      compiled = compile(false);
+    }
+  }
   if (!compiled.ok)
     return { ok: false, reason: compiled.reason };
   return {
@@ -200774,10 +200826,10 @@ function rewriteRunSpanText(paragraphXml, startOffset, endOffset, newText) {
 function rewriteSDDirectParagraphText(input) {
   return rewriteRunSpanText(input.paragraphXml, input.startOffset, input.endOffset, input.newText);
 }
-function splitCompoundRunsForTrackedReplace(paragraphXml, startOffset, endOffset, allowCollapsedInsert = false, allowControlBoundary = false) {
+function splitCompoundRunsForTrackedReplace(paragraphXml, startOffset, endOffset, allowCollapsedInsert = false, allowControlBoundary = false, namespaceBindings) {
   if (startOffset > endOffset || startOffset === endOffset && !allowCollapsedInsert)
     return null;
-  const model = parseParagraphInlineMap(paragraphXml);
+  const model = parseParagraphInlineMap(paragraphXml, namespaceBindings);
   const leaves = model.leaves();
   const runs = new Map;
   for (const piece of model.pieces) {
@@ -387898,6 +387950,27 @@ function insertNoteReferenceIntoParagraph(paragraphXml, offset, referenceRunXml)
       }
       continue;
     }
+    if (child.localName === "ins" || child.localName === "del") {
+      const visibleLength = extractVisibleTextFromXml(`${paragraph4.open}${child.xml}${paragraph4.close}`).length;
+      if (!inserted && offset > visible && offset < visible + visibleLength) {
+        return {
+          ok: false,
+          code: "CAPABILITY_UNAVAILABLE",
+          message: "footnotes.insert cannot insert inside an existing tracked revision."
+        };
+      }
+      if (!inserted && offset === visible) {
+        out.push(referenceRunXml);
+        inserted = true;
+      }
+      out.push(child.xml);
+      visible += visibleLength;
+      if (!inserted && offset === visible) {
+        out.push(referenceRunXml);
+        inserted = true;
+      }
+      continue;
+    }
     if (child.localName !== "r") {
       if (isZeroWidthParagraphMarker(child.localName)) {
         out.push(child.xml);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.4.1-next.4",
+  "version": "1.4.1-next.5",
   "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.17.1-next.4",
+    "@superdoc/sdk": "2.17.1-next.5",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.20.1-next.4",
-    "@superdoc/docx-engine": "0.19.1-next.3",
+    "superdoc": "2.20.1-next.5",
+    "@superdoc/docx-engine": "0.19.1-next.4",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",