@superdoc/mcp 1.0.0-next.8 → 1.0.0-next.9

package/dist/index.js

@@ -349815,7 +349815,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.13.0-next.10";
+var SDK_VERSION = "2.13.0-next.11";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { chmodSync, existsSync } from "node:fs";
@@ -489460,7 +489460,8 @@ function tryRangeReplacementAcrossTokens(input, allTokens, touched) {
   if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 1 || token.nestedDeletions && token.nestedDeletions.length > 0)) {
     return null;
   }
-  return input.changeMode === "tracked" ? authorTrackedPureDelete(input, allTokens, touched) : authorDirectPureDelete(input, allTokens, touched);
+  const result = input.changeMode === "tracked" ? authorTrackedPureDelete(input, allTokens, touched) : authorDirectPureDelete(input, allTokens, touched);
+  return result?.ok && input.changeMode === "tracked" ? { ...result, requiresCollaborationSessionSync: true } : result;
 }
 function renderBreakRunPureDelete(token, input, mode, wrapDeleted) {
   const { controlXml, runOpen, runClose, rPr, text, controlVisibleStart } = token.inertBreakRun;
@@ -491550,11 +491551,16 @@ function buildCoalescedDeletionReplacement(change, partXml) {
       return null;
     if (index > 0) {
       const previous = orderedFragments[index - 1];
-      xml += partXml.slice(previous.byteEnd, fragment2.byteStart);
+      const interstitialXml = partXml.slice(previous.byteEnd, fragment2.byteStart);
+      if (/<(?:[\w.-]+:)?(?:fldChar|fldSimple|instrText)\b/.test(interstitialXml))
+        return null;
+      xml += interstitialXml;
     }
     xml += parts.innerXml;
   }
   xml += firstParts.closeTag;
+  if (parseXmlForError(`<root>${xml}</root>`, { namespaceAware: false }) !== null)
+    return null;
   return { start: first.byteStart, end: last.byteEnd, xml };
 }
 function readTrackedWrapperParts(partXml, fragment2, expectedKind) {
@@ -491689,6 +491695,7 @@ function escapeRegExp6(value) {
 }
 var DECODER, ENCODER;
 var init_export_projection = __esm(() => {
+  init_xml_sax();
   init_catalog3();
   init_logical_catalog();
   init_move_stamps();
@@ -493652,6 +493659,9 @@ function commitTracked(input, view) {
   }
   if (!localized.ok)
     return rejected2(txId, localized.reason);
+  if (compileOp.on.coordinateSpace !== "tracked" && requiresStructuralTrackedRewriteSessionSync(paragraphXml, inlineContext.model.leaves(), compileOp.on.startOffset, compileOp.on.endOffset)) {
+    localized = { ...localized, requiresCollaborationSessionSync: true };
+  }
   if (op.newText.includes("\t"))
     localized = { ...localized, requiresCollaborationSessionSync: true };
   if (localized.foldedInsRsid != null) {
@@ -494691,6 +494701,36 @@ function rewriteLocalizedDirect(bytes, window2, op, inheritedNamespaceBindings =
   }
   return { ok: false, reason: plan.reason };
 }
+function requiresStructuralTrackedRewriteSessionSync(paragraphXml, leaves, startOffset, endOffset) {
+  if (startOffset >= endOffset)
+    return false;
+  const transparentMarkerRe = /<[\w.-]+:(?:proofErr|lastRenderedPageBreak)\b[^>]*\/?>/g;
+  for (const match of paragraphXml.matchAll(transparentMarkerRe)) {
+    const markerStart = match.index;
+    const markerEnd = markerStart + match[0].length;
+    let before;
+    for (let index = leaves.length - 1;index >= 0; index -= 1) {
+      if (leaves[index].charEnd <= markerStart) {
+        before = leaves[index];
+        break;
+      }
+    }
+    const after = leaves.find((piece) => piece.charStart >= markerEnd);
+    const markerOffset = before?.visibleEnd ?? after?.visibleStart;
+    if (markerOffset != null && startOffset < markerOffset && endOffset > markerOffset)
+      return true;
+  }
+  const affected = leaves.filter((piece) => {
+    const overlapsVisibleRange = startOffset < piece.visibleEnd && endOffset > piece.visibleStart;
+    const crossesZeroWidthPiece = startOffset < piece.visibleStart && endOffset > piece.visibleEnd;
+    return overlapsVisibleRange || crossesZeroWidthPiece;
+  });
+  if (affected.some((piece) => piece.kind !== "text" && piece.kind !== "control"))
+    return true;
+  const structuralStack = (piece) => JSON.stringify(piece.containerStack.filter((scope) => scope.kind !== "ins" && scope.kind !== "del" && scope.kind !== "moveFrom" && scope.kind !== "moveTo").map((scope) => [scope.kind, scope.qname]));
+  const textStacks = affected.filter((piece) => piece.kind === "text").map(structuralStack);
+  return textStacks.some((stack) => stack !== textStacks[0]);
+}
 function rewriteLocalizedTracked(bytes, window2, op, stamp, preparedContext) {
   const paragraphBytes = bytes.subarray(window2.byteStart, window2.byteEnd);
   const inlineContext = preparedContext ?? prepareParagraphInlineEditContext(paragraphBytes);
@@ -496464,7 +496504,7 @@ function rewriteRunSpanTrackedReplace(paragraphXml, startOffset, endOffset, stam
       return { ok: false, reason: "tracked-inline-control-unsupported" };
     }
   }
-  if (collected.markerIntegrity.hasPreservableMarker) {
+  if (collected.markerIntegrity.hasPreservableMarker || stamp.newText.length > 0 && requiresStructuralTrackedRewriteSessionSync(paragraphXml, parseParagraphInlineMap(paragraphXml).leaves(), startOffset, endOffset)) {
     return rewriteRunSpanTrackedReplacePreservingMarkers(paragraphXml, span, stamp, paragraphMarkFallback.rPr);
   }
   const first = span.runs[span.firstRunIdx];
@@ -503109,7 +503149,7 @@ function runTrackedChangeDecideCommit(input) {
     fragmentsByPart,
     structuralTargets
   });
-  const sessionSyncedTextDecision = trackedTextDecide && (hasNestedTextDecision(catalog, fragmentsByPart) || hasStructuralInlineDeletionDecision(state, fragmentsByPart));
+  const sessionSyncedTextDecision = trackedTextDecide && (hasNestedTextDecision(catalog, fragmentsByPart) || hasStructuralInlineDeletionDecision(state, fragmentsByPart) || hasMarkerSeparatedTextDecision(state, fragmentsByPart));
   const prepared = {
     txId,
     source: op,
@@ -503479,6 +503519,45 @@ function hasStructuralInlineDeletionDecision(state, fragmentsByPart) {
   }
   return false;
 }
+function hasMarkerSeparatedTextDecision(state, fragmentsByPart) {
+  for (const [partUri, fragments] of fragmentsByPart) {
+    const partBytes = state.packageBytes.get(partUri);
+    if (!partBytes)
+      continue;
+    const textFragments = fragments.filter((fragment2) => fragment2.kind === "ins" || fragment2.kind === "del");
+    const paragraphByFragment = findParagraphsContainingFragments(state, textFragments);
+    const grouped = new Map;
+    for (const fragment2 of textFragments) {
+      const paragraph = paragraphByFragment.get(fragment2);
+      if (!paragraph)
+        continue;
+      const key2 = `${fragment2.storyId}|${paragraph.blockId}|${fragment2.kind}|${fragment2.rsid}`;
+      const group = grouped.get(key2) ?? [];
+      group.push(fragment2);
+      grouped.set(key2, group);
+    }
+    for (const group of grouped.values()) {
+      if (group.length < 2)
+        continue;
+      const ordered = [...group].sort((left, right) => {
+        const leftRange = preparedFragmentSourceRange(left);
+        const rightRange = preparedFragmentSourceRange(right);
+        return leftRange.start - rightRange.start;
+      });
+      for (let index = 1;index < ordered.length; index += 1) {
+        const previous = preparedFragmentSourceRange(ordered[index - 1]);
+        const current = preparedFragmentSourceRange(ordered[index]);
+        if (!previous || !current || previous.end > current.start)
+          continue;
+        const separator = TD44.decode(partBytes.subarray(previous.end, current.start));
+        if (/<[\w.-]+:(?:bookmarkStart|bookmarkEnd|commentRangeStart|commentRangeEnd|commentReference)\b/.test(separator)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
 function buildPreparedTrackedTextDecide(input) {
   if (input.op.targets.some((target) => target.partial || target.formatting || target.derivedStructural || (target.moveRangeMarkers?.ids.length ?? 0) > 0)) {
     return;
@@ -707175,44 +707254,130 @@ function syncParagraphMarkerCarriers(carriers, next, create10) {
     offset += carrier.text.length;
     return { ...carrier, start, end: offset, next: [] };
   });
-  for (const marker of next) {
-    const position2 = Number(marker.visibleOffset ?? 0);
-    const owner = windows.find((window2) => window2.markers.toArray().some((existing) => readInlineControlOffset(existing) + window2.start === position2 && sameMarker(existing, marker))) ?? windows.find((window2) => position2 < window2.end) ?? windows[windows.length - 1];
-    owner.next.push({ ...marker, visibleOffset: position2 - owner.start });
+  for (let markerIndex = 0;markerIndex < next.length; ) {
+    const position2 = Number(next[markerIndex].visibleOffset ?? 0);
+    let groupEnd = markerIndex + 1;
+    while (groupEnd < next.length && Number(next[groupEnd].visibleOffset ?? 0) === position2)
+      groupEnd += 1;
+    const group = next.slice(markerIndex, groupEnd);
+    const retainedOwners = windows.filter((window2) => group.some((marker) => window2.markers.toArray().some((existing) => readInlineControlOffset(existing) + window2.start === position2 && sameMarker(existing, marker))));
+    const sharedOwner = retainedOwners.length === 1 ? retainedOwners[0] : null;
+    for (const marker of group) {
+      const owner = sharedOwner ?? windows.find((window2) => window2.markers.toArray().some((existing) => readInlineControlOffset(existing) + window2.start === position2 && sameMarker(existing, marker))) ?? windows.find((window2) => position2 < window2.end) ?? windows[windows.length - 1];
+      owner.next.push({ ...marker, visibleOffset: position2 - owner.start });
+    }
+    markerIndex = groupEnd;
   }
   for (const window2 of windows)
     syncParagraphMarkers(window2.markers, window2.next, create10);
 }
 function syncParagraphMarkers(array3, next, create10) {
   const previous3 = array3.toArray();
-  let prefix = 0;
-  while (prefix < previous3.length && prefix < next.length && sameMarker(previous3[prefix], next[prefix]))
-    prefix += 1;
-  let suffix = 0;
-  while (suffix < previous3.length - prefix && suffix < next.length - prefix && sameMarker(previous3[previous3.length - suffix - 1], next[next.length - suffix - 1]))
-    suffix += 1;
-  const removed = previous3.length - prefix - suffix;
-  if (removed > 0)
-    array3.delete(prefix, removed);
-  const additions = next.slice(prefix, next.length - suffix);
-  const inserted = additions.map(create10);
-  if (inserted.length > 0)
-    array3.insert(prefix, inserted);
+  const retained = longestSharedMarkerSubsequence(previous3, next);
+  const anchors2 = [
+    { previous: -1, next: -1 },
+    ...retained,
+    { previous: previous3.length, next: next.length }
+  ];
+  for (let anchorIndex = anchors2.length - 2;anchorIndex >= 0; anchorIndex -= 1) {
+    const left = anchors2[anchorIndex];
+    const right = anchors2[anchorIndex + 1];
+    const start = left.previous + 1;
+    const removed = right.previous - start;
+    if (removed > 0)
+      array3.delete(start, removed);
+    const additions = next.slice(left.next + 1, right.next);
+    const inserted = additions.map(create10);
+    if (inserted.length > 0)
+      array3.insert(start, inserted);
+    assignInsertedTrackedMarkerIds(array3, inserted, additions, start);
+  }
+  next.forEach((value2, index2) => {
+    const marker = array3.get(index2);
+    if (marker.get("visibleOffset") !== value2.visibleOffset)
+      marker.set("visibleOffset", value2.visibleOffset);
+    anchorInlineControl(marker, Number(value2.visibleOffset));
+  });
+}
+function longestSharedMarkerSubsequence(previous3, next) {
+  const exactCells = (previous3.length + 1) * (next.length + 1);
+  if (exactCells > 1e6)
+    return orderedSharedMarkerSubsequence(previous3, next);
+  const lengths = Array.from({ length: previous3.length + 1 }, () => new Uint32Array(next.length + 1));
+  for (let previousIndex2 = previous3.length - 1;previousIndex2 >= 0; previousIndex2 -= 1) {
+    for (let nextIndex2 = next.length - 1;nextIndex2 >= 0; nextIndex2 -= 1) {
+      lengths[previousIndex2][nextIndex2] = sameMarker(previous3[previousIndex2], next[nextIndex2]) ? 1 + lengths[previousIndex2 + 1][nextIndex2 + 1] : Math.max(lengths[previousIndex2 + 1][nextIndex2], lengths[previousIndex2][nextIndex2 + 1]);
+    }
+  }
+  const retained = [];
+  let previousIndex = 0;
+  let nextIndex = 0;
+  while (previousIndex < previous3.length && nextIndex < next.length) {
+    if (sameMarker(previous3[previousIndex], next[nextIndex]) && lengths[previousIndex][nextIndex] === 1 + lengths[previousIndex + 1][nextIndex + 1]) {
+      retained.push({ previous: previousIndex, next: nextIndex });
+      previousIndex += 1;
+      nextIndex += 1;
+    } else if (lengths[previousIndex + 1][nextIndex] >= lengths[previousIndex][nextIndex + 1]) {
+      previousIndex += 1;
+    } else {
+      nextIndex += 1;
+    }
+  }
+  return retained;
+}
+function orderedSharedMarkerSubsequence(previous3, next) {
+  const positions = new Map;
+  previous3.forEach((marker, index2) => {
+    const key2 = markerDiscriminator((name) => marker.get(name));
+    const indexes = positions.get(key2);
+    if (indexes)
+      indexes.push(index2);
+    else
+      positions.set(key2, [index2]);
+  });
+  const retained = [];
+  let minimumPrevious = 0;
+  next.forEach((marker, nextIndex) => {
+    const indexes = positions.get(markerDiscriminator((name) => marker[name]));
+    if (!indexes)
+      return;
+    let low = 0;
+    let high = indexes.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (indexes[middle] < minimumPrevious)
+        low = middle + 1;
+      else
+        high = middle;
+    }
+    while (low < indexes.length && !sameMarker(previous3[indexes[low]], marker))
+      low += 1;
+    if (low === indexes.length)
+      return;
+    const previousIndex = indexes[low];
+    retained.push({ previous: previousIndex, next: nextIndex });
+    minimumPrevious = previousIndex + 1;
+  });
+  return retained;
+}
+function markerDiscriminator(read) {
+  return JSON.stringify([
+    read("kind"),
+    read("xml"),
+    read("length"),
+    read("meta")
+  ]);
+}
+function assignInsertedTrackedMarkerIds(array3, inserted, additions, start) {
   inserted.forEach((marker, index2) => {
     const value2 = additions[index2];
     const meta3 = value2.meta;
     const trackedCarrier = value2.kind === "tracked-wrapper" || value2.kind === "preserved" && (meta3?.tag === "delTextRun" || meta3?.container === "tracked-deletion");
     if (trackedCarrier) {
-      const item = createRelativePositionFromTypeIndex(array3, prefix + index2).item;
+      const item = createRelativePositionFromTypeIndex(array3, start + index2).item;
       marker.set("id", `${value2.id}:sync:${item.client.toString(36)}:${item.clock.toString(36)}`);
     }
   });
-  next.forEach((value2, index2) => {
-    const marker = array3.get(index2);
-    if (marker.get("visibleOffset") !== value2.visibleOffset)
-      marker.set("visibleOffset", value2.visibleOffset);
-    anchorInlineControl(marker, Number(value2.visibleOffset));
-  });
 }
 var init_paragraph_inline_sync = __esm(() => {
   init_yjs();
@@ -707239,13 +707404,14 @@ function mirrorStorySurfaceFromSession(input) {
       };
     }
     try {
+      const extension2 = storyScopedTrackedDecisionExtension(input.extension, storyId);
       const scope = resolveStoryShardScope(doc2);
       scope.doc.transact(() => {
-        const groups = input.extension.contentControlRewrite || hasContentControlGroups(scope) ? prepareStoryContentControlGroups(input.session, storyId, doc2) : null;
+        const groups = extension2.contentControlRewrite || hasContentControlGroups(scope) ? prepareStoryContentControlGroups(input.session, storyId, doc2) : null;
         mirrorFamilyIntoStory({
           session: input.session,
           prepared: input.prepared,
-          extension: input.extension,
+          extension: extension2,
           paragraphOnlyReviewStoryIds: input.paragraphOnlyReviewStoryIds,
           storyId,
           doc: doc2
@@ -707265,6 +707431,16 @@ function mirrorStorySurfaceFromSession(input) {
   }
   return { mirrored: true };
 }
+function storyScopedTrackedDecisionExtension(extension2, storyId) {
+  if (extension2.family !== "storyTrackedDecide" || !extension2.trackedTextDecide)
+    return extension2;
+  const targets = extension2.trackedTextDecide.targets.filter((target) => target.storyId === storyId);
+  return {
+    ...extension2,
+    targetBlockIds: [...new Set(targets.map((target) => target.blockId))],
+    trackedTextDecide: { ...extension2.trackedTextDecide, targets }
+  };
+}
 function prepareStoryContentControlGroups(session, storyId, doc2) {
   const scope = resolveStoryShardScope(doc2);
   const source = readContentControlBlockGroups(loadStorySyncContext(session, storyId).bytes);
@@ -708769,7 +708945,7 @@ function hasStrictMirrorPrerequisites(prepared, options) {
     case "storyText":
       return !extension2.historyReplay && !extension2.resyncFromSession && !extension2.sessionSync ? true : options.session != null;
     case "storyTrackedDecide":
-      return !usesTrackedDecisionSessionSync(prepared, extension2) || options.session != null;
+      return !usesTrackedDecisionSessionSync(prepared, extension2, options) || options.session != null;
     case "storyTable":
       return true;
     case "storyBlocks":
@@ -708836,7 +709012,7 @@ function runFamilyMirror(prepared, extension2, options, directStoryText, tracked
     return { mirrored: true };
   }
   if (extension2.family === "storyTrackedDecide") {
-    if (usesTrackedDecisionSessionSync(prepared, extension2)) {
+    if (usesTrackedDecisionSessionSync(prepared, extension2, options)) {
       if (!options.session) {
         return {
           mirrored: false,
@@ -708850,11 +709026,19 @@ function runFamilyMirror(prepared, extension2, options, directStoryText, tracked
       const sessionSync = mirrorStorySurfaceFromSession({
         session: options.session,
         prepared,
-        extension: extension2,
+        extension: extension2.sessionSync || !extension2.trackedTextDecide ? extension2 : { ...extension2, sessionSync: { reason: "structural-inline-edit" } },
         storyIds: storyIdsRequiringShards(prepared, extension2),
         paragraphOnlyReviewStoryIds,
         resolveStoryShard: options.resolveStoryShard
       });
+      if (sessionSync.mirrored && extension2.trackedTextDecide) {
+        for (const target of extension2.trackedTextDecide.targets) {
+          const doc2 = options.resolveStoryShard(target.storyId);
+          if (doc2) {
+            recordTrackedDecision(doc2, target.rsid, extension2.trackedTextDecide.decision, prepared.txId);
+          }
+        }
+      }
       return { ...sessionSync, mirrorPath: "session-sync" };
     }
     if (!trackedDecision) {
@@ -709623,7 +709807,7 @@ function admitPreparedStorySurfaceMutation(prepared, options) {
     return options.session && extension2.family === "storyBlocks" && extension2.contentControlRewrite && storyIds.length === 1 ? { ok: true } : { ok: false, message: "Content-control rewrite requires a prepared structural delta and owning session." };
   }
   if (extension2.family === "storyTrackedDecide") {
-    if (usesTrackedDecisionSessionSync(prepared, extension2)) {
+    if (usesTrackedDecisionSessionSync(prepared, extension2, options)) {
       return options.session ? { ok: true } : { ok: false, message: "tracked-change decision session sync requires an authoritative session" };
     }
     const trackedDecision = validatePreparedTrackedDecide(prepared, extension2, options);
@@ -709701,14 +709885,28 @@ function touchesOwnedStoryPart(prepared) {
   const touchedParts = new Set(prepared.resolvedTargets.partUris.map((partUri) => String(partUri)));
   return prepared.resolvedTargets.storyPartOwnership.some((entry) => touchedParts.has(String(entry.partUri)));
 }
-function usesTrackedDecisionSessionSync(prepared, extension2) {
+function usesTrackedDecisionSessionSync(prepared, extension2, options) {
   if (extension2.historyReplay || extension2.sessionSync)
     return true;
   if (hasPreparedCommentRefRemaps(prepared))
     return true;
-  if (extension2.trackedTextDecide || prepared.source.kind !== "trackedChangeDecide")
-    return false;
-  return prepared.source.targets.some((target) => target.formatting !== undefined || target.structural !== undefined || target.derivedStructural !== undefined);
+  if (!extension2.trackedTextDecide) {
+    if (prepared.source.kind !== "trackedChangeDecide")
+      return false;
+    return prepared.source.targets.some((target) => target.formatting !== undefined || target.structural !== undefined || target.derivedStructural !== undefined);
+  }
+  return extension2.trackedTextDecide.targets.some((target) => {
+    const doc2 = options.resolveStoryShard(target.storyId);
+    if (!doc2)
+      return false;
+    const liveSpans = collectLiveTrackedTextSpans(doc2, target.rsid, target.trackedKind, [target.blockId]);
+    if (liveSpans.length > 1)
+      return true;
+    if (!hasTrackedDecisionLedgerEntry(doc2, target.rsid) || findPreparedLiveTrackedTextSpans(doc2, target).length > 0) {
+      return false;
+    }
+    return liveSpans.length > 0;
+  });
 }
 function tryMirrorStoryText(prepared, extension2, options, admitted) {
   const validation = admitted ?? validateDirectStoryText(prepared, extension2, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.0.0-next.8",
+  "version": "1.0.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.13.0-next.10",
+    "@superdoc/sdk": "2.13.0-next.11",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.16.0-next.8",
-    "@superdoc/docx-engine": "0.15.0-next.8",
+    "superdoc": "2.16.0-next.9",
+    "@superdoc/docx-engine": "0.15.0-next.9",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",