@superdoc/mcp 1.9.0-next.7 → 1.9.0-next.8

package/dist/index.js

@@ -31620,7 +31620,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.22.0-next.7";
+var SDK_VERSION = "2.22.0-next.8";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -253967,7 +253967,7 @@ function parseSimpleRunTokens(xml) {
     const tMatch = /^\s*<([\w.-]+):t\b([^>]*)>([\s\S]*?)<\/\1:t>\s*$/.exec(afterRPr);
     if (!tMatch)
       return null;
-    const text = decodeCompareXmlText(tMatch[3] ?? "");
+    const text = decodeXmlTextPreservingInvalidNumericEntities(tMatch[3] ?? "");
     tokens.push({
       rawXml: match[0],
       openTag: `<${prefix}:r${runAttrs}>${rPrXml}`,
@@ -254027,7 +254027,9 @@ function equalWordTokensPreserveFormatting(oldTokens, targetTokens) {
   let targetIndex = 0;
   for (const op of ops) {
     if (op === "equal") {
-      if (oldWords[oldIndex]?.openTag !== targetWords[targetIndex]?.openTag)
+      const oldFormat = oldWords[oldIndex].openTag;
+      const targetFormat = targetWords[targetIndex].openTag;
+      if (oldFormat !== targetFormat)
         return false;
       oldIndex += 1;
       targetIndex += 1;
@@ -254041,24 +254043,165 @@ function equalWordTokensPreserveFormatting(oldTokens, targetTokens) {
   }
   return true;
 }
-function renderWordLevelTrackedRunSegment(oldSegment, targetSegment, getStamp, prefix) {
-  const oldTokens = parseSimpleRunTokens(oldSegment);
-  const targetTokens = parseSimpleRunTokens(targetSegment);
-  if (!oldTokens || !targetTokens)
-    return null;
+function unchangedCompareRunRangesPreserveFormatting(oldTokens, targetTokens, ops, prefix) {
+  const formats = (tokens) => tokens.map((token) => ({
+    end: token.startOffset + token.text.length,
+    signature: compareRunCarrierSignature(`${token.openTag}</${token.runPrefix}:r>`, prefix)
+  }));
+  const oldFormats = formats(oldTokens), targetFormats = formats(targetTokens);
+  let oldIndex = 0, targetIndex = 0;
+  const equalRange = (oldFrom, targetFrom, length) => {
+    while (length > 0) {
+      while (oldFormats[oldIndex].end <= oldFrom)
+        oldIndex += 1;
+      while (targetFormats[targetIndex].end <= targetFrom)
+        targetIndex += 1;
+      const old = oldFormats[oldIndex], target = targetFormats[targetIndex];
+      if (old.signature !== target.signature)
+        return false;
+      const matched = Math.min(length, old.end - oldFrom, target.end - targetFrom);
+      oldFrom += matched;
+      targetFrom += matched;
+      length -= matched;
+    }
+    return true;
+  };
+  let oldCursor = 0, targetCursor = 0;
+  for (const op of ops) {
+    const start = op.type === "insert" ? op.insertAt : op.oldFrom;
+    const retained = start - oldCursor;
+    if (!equalRange(oldCursor, targetCursor, retained))
+      return false;
+    oldCursor = op.type === "insert" ? start : op.oldTo;
+    targetCursor += retained + (op.type === "delete" ? 0 : op.newText.length);
+  }
+  const oldLength = oldFormats.at(-1)?.end ?? 0;
+  return equalRange(oldCursor, targetCursor, oldLength - oldCursor);
+}
+function prepareCompareWordSegment(oldTokens, targetTokens, checkDensity, prefix) {
   const oldText = oldTokens.map((token) => token.text).join("");
   const targetText = targetTokens.map((token) => token.text).join("");
   if (oldText === targetText)
     return null;
-  if (necessarilyExceedsWordDiffRatio(oldText, targetText, WORD_DIFF_FALLBACK_RATIO))
+  if (oldText.includes("\r") || targetText.includes("\r"))
+    return null;
+  if (checkDensity && necessarilyExceedsWordDiffRatio(oldText, targetText, WORD_DIFF_FALLBACK_RATIO))
     return null;
-  if (!equalWordTokensPreserveFormatting(oldTokens, targetTokens))
+  if (!prefix && !equalWordTokensPreserveFormatting(oldTokens, targetTokens))
     return null;
   const ops = getWordChanges(oldText, targetText);
-  if (ops.length === 0)
+  if (ops.length === 0 || checkDensity && shouldFallBackFromWordDiff(ops, oldText.length, targetText.length))
     return null;
-  if (shouldFallBackFromWordDiff(ops, oldText.length, targetText.length))
+  if (prefix && !unchangedCompareRunRangesPreserveFormatting(oldTokens, targetTokens, ops, prefix))
     return null;
+  return { oldTokens, targetTokens, oldText, ops };
+}
+function compareRunCarrierSignature(xml, prefix) {
+  const canonical = canonicalizeXmlForSignature(`<root xmlns:${prefix}="${NS_W}">${xml}</root>`);
+  return canonical.replace(/<w:r\b[^>]*>/g, (run) => run.replace(/\s+w:rsid\w*="[^"]*"/g, ""));
+}
+function splitCompareManualBreakSegments(xml, prefix) {
+  const parsed = collectXmlElementRanges(xml, { fragment: true, additionalNamespaces: { [prefix]: NS_W } });
+  if (parsed.errors.length > 0)
+    return null;
+  const ranges = parsed.ranges.sort((left, right) => left.start - right.start);
+  const spans = [""];
+  const breaks = [];
+  let cursor = 0;
+  for (let index = 0;index < ranges.length; ) {
+    const run = ranges[index++];
+    if (xml.slice(cursor, run.start).trim() || run.tag.namespaceUri !== NS_W || run.tag.localName !== "r" || run.tag.prefix !== prefix || run.tag.isSelfClosing)
+      return null;
+    const children = [];
+    let childCursor = run.openEnd;
+    while (index < ranges.length && ranges[index].start < run.closeStart) {
+      const child = ranges[index++];
+      if (child.start < childCursor)
+        continue;
+      if (xml.slice(childCursor, child.start).trim() || child.end > run.closeStart)
+        return null;
+      children.push(child);
+      childCursor = child.end;
+    }
+    if (xml.slice(childCursor, run.closeStart).trim())
+      return null;
+    const rPr = children[0]?.tag.namespaceUri === NS_W && children[0].tag.localName === "rPr" ? children.shift() : undefined;
+    const openTag = xml.slice(run.start, run.openEnd) + (rPr ? xml.slice(rPr.start, rPr.end) : "");
+    if (children.length === 0)
+      return null;
+    for (const child of children) {
+      if (child.tag.namespaceUri !== NS_W || child.tag.prefix !== prefix)
+        return null;
+      const childXml = xml.slice(child.start, child.end);
+      const carrier = children.length === 1 ? xml.slice(run.start, run.end) : `${openTag}${childXml}</${prefix}:r>`;
+      if (child.tag.localName === "t") {
+        if (child.tag.isSelfClosing || xml.slice(child.openEnd, child.closeStart).includes("<") || child.tag.attributes.some((attr3) => !(attr3.namespaceUri === "http://www.w3.org/XML/1998/namespace" && attr3.localName === "space")))
+          return null;
+        spans[spans.length - 1] += carrier;
+      } else if (child.tag.localName === "br") {
+        if (xml.slice(child.openEnd, child.closeStart).trim() || child.tag.attributes.some((attr3) => attr3.namespaceUri !== NS_W || (attr3.localName === "type" ? attr3.value !== "textWrapping" : attr3.localName !== "clear" || !["none", "left", "right", "all"].includes(attr3.value))))
+          return null;
+        breaks.push(carrier);
+        spans.push("");
+      } else
+        return null;
+    }
+    cursor = run.end;
+  }
+  if (xml.slice(cursor).trim() || breaks.length === 0)
+    return null;
+  return { spans, breaks };
+}
+function renderWordLevelTrackedRunSegment(oldSegment, targetSegment, getStamp, prefix) {
+  const simpleOld = parseSimpleRunTokens(oldSegment);
+  const simpleTarget = parseSimpleRunTokens(targetSegment);
+  if (simpleOld && simpleTarget && !/<[\w.-]+:br\b/.test(oldSegment + targetSegment)) {
+    const prepared2 = prepareCompareWordSegment(simpleOld, simpleTarget, true);
+    return prepared2 ? { xml: renderPreparedCompareWordSegment(prepared2, getStamp, prefix) } : null;
+  }
+  const old = splitCompareManualBreakSegments(oldSegment, prefix);
+  const target = splitCompareManualBreakSegments(targetSegment, prefix);
+  if (!old || !target || old.breaks.length !== target.breaks.length || old.breaks.some((br, index) => compareRunCarrierSignature(br, prefix) !== compareRunCarrierSignature(target.breaks[index], prefix)))
+    return null;
+  const spans = [];
+  for (let index = 0;index < old.spans.length; index += 1) {
+    const oldSpan = old.spans[index];
+    const targetSpan = target.spans[index];
+    const oldTokens = parseSimpleRunTokens(oldSpan);
+    const targetTokens = parseSimpleRunTokens(targetSpan);
+    if (!oldTokens || !targetTokens)
+      return null;
+    if (oldTokens.some((token) => token.text.length === 0) || targetTokens.some((token) => token.text.length === 0))
+      return null;
+    const oldText2 = oldTokens.map((token) => token.text).join("");
+    const targetText2 = targetTokens.map((token) => token.text).join("");
+    spans.push({ oldSpan, oldTokens, targetTokens, oldText: oldText2, targetText: targetText2 });
+  }
+  const oldText = spans.map((span) => span.oldText).join(`
+`);
+  const targetText = spans.map((span) => span.targetText).join(`
+`);
+  if (necessarilyExceedsWordDiffRatio(oldText, targetText, WORD_DIFF_FALLBACK_RATIO))
+    return null;
+  const prepared = [];
+  for (const { oldSpan, oldTokens, targetTokens, oldText: oldText2, targetText: targetText2 } of spans) {
+    if (oldText2 === targetText2) {
+      if (!unchangedCompareRunRangesPreserveFormatting(oldTokens, targetTokens, [], prefix))
+        return null;
+      prepared.push(oldSpan);
+    } else {
+      const span = prepareCompareWordSegment(oldTokens, targetTokens, false, prefix);
+      if (!span)
+        return null;
+      prepared.push(span);
+    }
+  }
+  const ops = prepared.flatMap((span) => typeof span === "string" ? [] : span.ops);
+  if (ops.length === 0 || shouldFallBackFromWordDiff(ops, oldText.length, targetText.length))
+    return null;
+  return { xml: prepared.map((span, index) => (typeof span === "string" ? span : renderPreparedCompareWordSegment(span, getStamp, prefix)) + (old.breaks[index] ?? "")).join("") };
+}
+function renderPreparedCompareWordSegment({ oldTokens, targetTokens, oldText, ops }, getStamp, prefix) {
   let xml = "";
   let oldCursor = 0;
   let newCursor = 0;
@@ -254087,7 +254230,7 @@ function renderWordLevelTrackedRunSegment(oldSegment, targetSegment, getStamp, p
   if (oldCursor < oldText.length) {
     xml += renderCompareRunRange(oldTokens, oldCursor, oldText.length, "passthrough");
   }
-  return { xml };
+  return xml;
 }
 function runCompareBodyFormatEditCommit(input, storyId, step2, changeMode, options, pushHistory, referenceSteps) {
   const { state, txId } = input;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.9.0-next.7",
+  "version": "1.9.0-next.8",
   "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.22.0-next.7",
+    "@superdoc/sdk": "2.22.0-next.8",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.25.0-next.7",
-    "@superdoc/docx-engine": "0.24.0-next.7",
+    "superdoc": "2.25.0-next.8",
+    "@superdoc/docx-engine": "0.24.0-next.8",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",