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

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.9";
 
 // ../../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 (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;
-  if (shouldFallBackFromWordDiff(ops, oldText.length, targetText.length))
+  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;
@@ -328116,6 +328259,7 @@ function convertHtmlToFragment(html, options = {}) {
   }
   const context = {
     source: html,
+    tableSpanPolicy: options.tableSpanPolicy ?? "html",
     limits,
     sheet,
     diagnostics,
@@ -328806,6 +328950,8 @@ function usesDefaultWordOrderedLevelShape(descriptor) {
 function convertTable(table, context, inherited, path6) {
   let structurallyRejected = false;
   const rows = collectTableRows(table, path6);
+  if (context.tableSpanPolicy === "strict" && !validateTableSpans(rows, context))
+    return null;
   for (const { row, path: rowPath } of rows) {
     let rowGridColumns = 0;
     for (let cellIndex = 0;cellIndex < row.childNodes.length; cellIndex += 1) {
@@ -329321,6 +329467,72 @@ function orderedListItemValue(item, definition, context, path6) {
   });
   return null;
 }
+function validateTableSpans(rows, context) {
+  const occupiedUntil = Array.from({ length: MAX_WORD_TABLE_GRID_COLUMNS }, () => 0);
+  let valid = true;
+  const reject2 = (cell, path6, attribute2, message) => {
+    valid = false;
+    addDiagnostic(context, {
+      code: "conversion-malformed-input",
+      severity: "error",
+      message,
+      construct: attribute2 === "rowspan" ? "rowSpan" : "colSpan",
+      disposition: "rejected",
+      lossy: true,
+      path: [...path6, `@${attribute2}`],
+      range: sourceRangeForAttribute(cell, attribute2) ?? sourceRangeForNode(cell)
+    });
+  };
+  const span = (cell, path6, attribute2) => {
+    const raw = attributeValue2(cell, attribute2);
+    if (raw === undefined)
+      return 1;
+    const trimmed = raw.replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "");
+    const value2 = Number(trimmed);
+    if (/^\d+$/.test(trimmed) && Number.isSafeInteger(value2) && value2 >= (attribute2 === "rowspan" ? 0 : 1))
+      return value2;
+    reject2(cell, path6, attribute2, `Table cell ${attribute2} must be a valid ${attribute2 === "rowspan" ? "non-negative" : "positive"} integer.`);
+    return;
+  };
+  for (let rowIndex = 0;rowIndex < rows.length; rowIndex += 1) {
+    const { row, path: path6, remainingGroupRows } = rows[rowIndex];
+    let column = 0;
+    for (let cellIndex = 0;cellIndex < row.childNodes.length; cellIndex += 1) {
+      const cell = row.childNodes[cellIndex];
+      if (!isElement(cell) || cell.tagName !== "td" && cell.tagName !== "th")
+        continue;
+      const cellPath = [...path6, cellIndex];
+      const authoredRowSpan = span(cell, cellPath, "rowspan");
+      const rowSpan = authoredRowSpan === 0 ? remainingGroupRows : authoredRowSpan;
+      const colSpan = span(cell, cellPath, "colspan");
+      if (rowSpan === undefined || colSpan === undefined)
+        continue;
+      if (rowSpan > remainingGroupRows) {
+        reject2(cell, cellPath, "rowspan", "Table cell rowspan extends beyond its HTML row group.");
+        continue;
+      }
+      while (column < MAX_WORD_TABLE_GRID_COLUMNS && occupiedUntil[column] > rowIndex)
+        column += 1;
+      if (column + colSpan > MAX_WORD_TABLE_GRID_COLUMNS) {
+        reject2(cell, cellPath, "colspan", `Table rows cannot exceed ${MAX_WORD_TABLE_GRID_COLUMNS} grid columns, including vertical continuations.`);
+        break;
+      }
+      let overlaps2 = false;
+      for (let slot = column;slot < column + colSpan; slot += 1) {
+        if (occupiedUntil[slot] > rowIndex)
+          overlaps2 = true;
+      }
+      if (overlaps2) {
+        reject2(cell, cellPath, "colspan", "Table cell colspan overlaps an active rowspan.");
+      } else {
+        for (let slot = column;slot < column + colSpan; slot += 1)
+          occupiedUntil[slot] = rowIndex + rowSpan;
+      }
+      column += colSpan;
+    }
+  }
+  return valid;
+}
 function positiveIntegerAttribute(element, attribute2, context, path6, construct) {
   const raw = attributeValue2(element, attribute2);
   if (raw === undefined)
@@ -341082,7 +341294,7 @@ var init_markdown = __esm(() => {
 
 // ../../../v2/document-api-v2-adapter/dist/conversion/convert-to-fragment.js
 function convertContentToFragment(request) {
-  return request.format === "html" ? convertHtmlToFragment(request.source, request.options) : convertMarkdownToFragment(request.source, request.options);
+  return request.format === "html" ? convertHtmlToFragment(request.source, { tableSpanPolicy: "strict", ...request.options }) : convertMarkdownToFragment(request.source, request.options);
 }
 var init_convert_to_fragment = __esm(() => {
   init_html2();
@@ -341631,6 +341843,9 @@ function lowerTable(node4, path7, images) {
       if (col + gridSpan > MAX_WORD_TABLE_GRID_COLUMNS3) {
         invalid3([...rowPath, "cells"], `Table rows cannot exceed ${MAX_WORD_TABLE_GRID_COLUMNS3} grid columns.`);
       }
+      if (activeSpans.some((span) => span.remaining > 0 && span.col > col && span.col < col + gridSpan)) {
+        invalid3([...cellPath, "colSpan"], "Table cell colspan overlaps an active rowspan.");
+      }
       if (cell.content.length === 0)
         invalid3([...cellPath, "content"], "Table cells must contain a paragraph.");
       const blocks = cell.content.flatMap((content3, contentIndex) => {
@@ -344335,7 +344550,7 @@ function planFromHtml(payload, html, options, rejectUnsafeContent = false) {
   const converted = convertContentToFragment({
     format: "html",
     source: rewritten,
-    options: { limits: {
+    options: { tableSpanPolicy: "html", limits: {
       maxSourceCodeUnits: DEFAULT_HTML_CONVERSION_LIMITS.maxSourceCodeUnits + allowance,
       maxOutputCodeUnits: DEFAULT_HTML_CONVERSION_LIMITS.maxOutputCodeUnits + allowance,
       ...allowance > 0 ? { maxNestingDepth: MAX_WORD_VML_RECOVERY_NESTING_DEPTH } : {}
@@ -469219,7 +469434,7 @@ function mirrorStorySurfaceFromSession(input) {
         const actorType = readActorAttributionFromPrepared(input.prepared);
         tx.meta.set(ACTOR_ATTRIBUTION_META_KEY, actorType);
         scope.meta.set(STORY_META_KEY.lastEditActorType, actorType);
-        const groups = extension2.contentControlRewrite || hasContentControlGroups(scope) ? prepareStoryContentControlGroups(input.session, storyId, doc2) : null;
+        const groups = extension2.contentControlRewrite || extension2.family === "storyPaste" || hasContentControlGroups(scope) ? prepareStoryContentControlGroups(input.session, storyId, doc2) : null;
         mirrorFamilyIntoStory({
           session: input.session,
           prepared: input.prepared,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.9.0-next.7",
+  "version": "1.9.0-next.9",
   "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.9",
     "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.9",
+    "@superdoc/docx-engine": "0.24.0-next.9",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",