@superdoc/mcp 1.6.0-next.1 → 1.6.0-next.2

package/dist/index.js

@@ -31443,7 +31443,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.19.0-next.1";
+var SDK_VERSION = "2.19.0-next.2";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -194717,6 +194717,9 @@ function isBreakRunToken(token) {
 }
 function compileOverlapEdit(input) {
   const paragraphInlineMap = input.paragraphInlineMap ?? parseParagraphInlineMap(input.paragraphXml, input.namespaceBindings);
+  const consecutiveBreakInsertion = tryConsecutiveManualBreakInsertion(input, paragraphInlineMap);
+  if (consecutiveBreakInsertion)
+    return consecutiveBreakInsertion;
   const readsComplexDeletionForCollapsedInsert = input.newText.length > 0 && input.rangeStart === input.rangeEnd && ((input.coordinateSpace ?? "visible") === "visible" || input.changeMode === "tracked");
   const readsStructuralDeletionForReplacement = input.changeMode === "tracked" && input.newText.length > 0 && input.rangeStart < input.rangeEnd && paragraphInlineMap.pieces.some((piece) => piece.kind === "tracked" && piece.trackedKind === "del" && piece.visibleStart === piece.visibleEnd && input.rangeStart < piece.visibleStart && input.rangeEnd > piece.visibleEnd && piece.children.some(isSupportedStructuralDeletionChild));
   const readsComplexDeletions = (input.changeMode === "direct" || input.newText.length === 0) && input.rangeStart < input.rangeEnd || readsComplexDeletionForCollapsedInsert || readsStructuralDeletionForReplacement;
@@ -194734,6 +194737,52 @@ function compileOverlapEdit(input) {
   const directInsertAtTrackedEnd = input.changeMode === "direct" && input.rangeStart === input.rangeEnd && input.newText.length > 0 && parsed.tokens.some((token) => token.kind === "ins" && token.visibleEnd === input.rangeStart);
   return result.ok && (directInsertAtTrackedEnd || parsed.descendedEditableContainers.some(({ kind, xml }) => kind === "sdt" && result.xml.split(xml).length < input.paragraphXml.split(xml).length)) ? { ...result, requiresCollaborationSessionSync: true } : result;
 }
+function tryConsecutiveManualBreakInsertion(input, model) {
+  if (input.changeMode !== "tracked" || input.rangeStart !== input.rangeEnd || input.newText.length === 0)
+    return null;
+  const paragraph = findRawXmlElementRangeAt(input.paragraphXml, 0, NS_W3, "p", { w: NS_W3, ...input.namespaceBindings });
+  if (!paragraph || input.paragraphXml.slice(paragraph.end).trim().length > 0)
+    return null;
+  const bindings = new Map(Object.entries(paragraph.namespaceBindings));
+  if (model.pieces.some((piece) => piece.containerStack.length > 0 || !(piece.kind === "text" && piece.textRole === "visible" || piece.kind === "control" && !piece.deleted && isManualBreak(piece, bindings))))
+    return null;
+  const spanStart = (piece) => input.coordinateSpace === "tracked" ? piece.trackedStart : piece.visibleStart;
+  const spanEnd = (piece) => input.coordinateSpace === "tracked" ? piece.trackedEnd : piece.visibleEnd;
+  for (let index = 1;index < model.pieces.length; index++) {
+    const before = model.pieces[index - 1];
+    const after = model.pieces[index];
+    if (before.kind !== "control" || after.kind !== "control" || spanEnd(before) !== input.rangeStart || spanStart(after) !== input.rangeStart)
+      continue;
+    const sharedRun = before.runCharStart === after.runCharStart;
+    const gap = sharedRun ? input.paragraphXml.slice(before.charEnd, after.charStart) : input.paragraphXml.slice(before.runCharEnd, after.runCharStart);
+    if (gap.trim().length > 0)
+      return null;
+    const parsed = collectXmlElementRanges(input.paragraphXml, { fragment: true, additionalNamespaces: paragraph.namespaceBindings });
+    if (parsed.errors.length > 0)
+      return null;
+    const elements2 = new Map(parsed.ranges.map((element) => [element.start, element]));
+    for (const piece of model.pieces) {
+      if (piece.kind !== "text" && piece.kind !== "control")
+        return null;
+      const run = elements2.get(piece.runCharStart);
+      const payload = elements2.get(piece.charStart);
+      if (run?.tag.namespaceUri !== NS_W3 || run.tag.localName !== "r" || run.end !== piece.runCharEnd || payload?.tag.namespaceUri !== NS_W3 || payload.tag.localName !== piece.localName)
+        return null;
+    }
+    const insertion = buildInsWrapperXml({
+      nsPrefix: nsPrefixOfRun(before.runOpenTag),
+      wId: String(resolveNextWId(input)),
+      author: { name: input.currentAuthor.name, initials: input.currentAuthor.initials ?? null, email: input.currentAuthor.email ?? null },
+      date: input.txTimestamp,
+      rsidR: input.insRsid,
+      inner: { runOpen: before.runOpenTag, runClose: before.runCloseTag, rPr: before.runProperties ?? "", text: input.newText }
+    });
+    const at = sharedRun ? after.charStart : before.runCharEnd;
+    const xml = input.paragraphXml.slice(0, at) + (sharedRun ? before.runCloseTag : "") + insertion + (sharedRun ? after.runOpenTag + (after.runProperties ?? "") : "") + input.paragraphXml.slice(at);
+    return { ok: true, xml, emittedRsids: [input.insRsid], requiresCollaborationSessionSync: true };
+  }
+  return null;
+}
 function compileParsedOverlapEdit(input, tokens, descendedEditableContainers) {
   const touched = [];
   const touchedBreaks = [];
@@ -200130,7 +200179,8 @@ function commitTracked(input, view) {
     entityId: revision.rsid,
     storyId: op.on.storyId
   }));
-  const resyncFromSession = usedSpanningDelete || usedBookmarkDelete || spansLiveInlineControl || usedTrackedControlRunFallback;
+  const followsDeletedManualBreak = isPureTrackedInsert(op) && op.on.coordinateSpace === "tracked" && parseParagraphInlineMap(paragraphXml).leaves().some((leaf) => leaf.kind === "control" && leaf.control === "br" && leaf.deleted && leaf.trackedEnd === op.on.startOffset);
+  const resyncFromSession = usedSpanningDelete || usedBookmarkDelete || spansLiveInlineControl || usedTrackedControlRunFallback || followsDeletedManualBreak;
   return finalizeCommit({
     input,
     perPart,
@@ -436243,7 +436293,7 @@ function sortedProjectedAtoms(block, extraAtoms) {
       sequence: block.atoms.length + index2
     }))
   ];
-  return normalizeLiveTrackedWrapperOverlap(sortProjectedAtoms(baseAtoms));
+  return normalizeLiveTrackedWrapperOverlap(sortLiveTrackedWrapperBoundaries(sortProjectedAtoms(baseAtoms)));
 }
 function sortProjectedAtoms(atoms) {
   return [...atoms].sort((left, right) => {
@@ -436256,6 +436306,32 @@ function sortProjectedAtoms(atoms) {
     return left.sequence - right.sequence;
   });
 }
+function sortLiveTrackedWrapperBoundaries(atoms) {
+  const spans = collectLiveTrackedWrapperSpans(atoms).filter((span) => span.kind === "ins");
+  const starts = new Map;
+  for (const span of spans) {
+    if (span.endOffset <= span.startOffset)
+      continue;
+    const atOffset = starts.get(span.startOffset) ?? [];
+    atOffset.push(span);
+    starts.set(span.startOffset, atOffset);
+  }
+  const ordered = [...atoms];
+  for (const span of spans) {
+    if (span.endOffset <= span.startOffset)
+      continue;
+    const closeIndex = ordered.indexOf(span.closeAtom);
+    const reversed = (starts.get(span.endOffset) ?? []).some((following) => following.rsid !== span.rsid && ordered.indexOf(following.openAtom) < closeIndex);
+    if (!reversed)
+      continue;
+    const openIndex = ordered.findIndex((atom, index2) => index2 < closeIndex && atom.visibleOffset === span.endOffset && liveTrackedWrapperInfo(atom)?.position === "start");
+    if (openIndex < 0)
+      continue;
+    ordered.splice(closeIndex, 1);
+    ordered.splice(openIndex, 0, span.closeAtom);
+  }
+  return ordered.map((atom, sequence) => ({ ...atom, sequence }));
+}
 function normalizeLiveTrackedWrapperOverlap(atoms) {
   const spans = collectLiveTrackedWrapperSpans(atoms);
   if (spans.length === 0)
@@ -436279,6 +436355,7 @@ function normalizeLiveTrackedWrapperOverlap(atoms) {
   let nextSequence = atoms.reduce((max5, atom) => Math.max(max5, atom.sequence), -1) + 1;
   const syntheticAtoms = [];
   const coveredParentEdges = new Set;
+  const coveredEndChildren = new Map;
   for (const [parentKey, children2] of foreignChildrenByParent) {
     const parent = spansByKey.get(parentKey);
     if (!parent)
@@ -436309,9 +436386,42 @@ function normalizeLiveTrackedWrapperOverlap(atoms) {
       syntheticAtoms.push(makeSyntheticTrackedWrapperAtom(parent.openAtom, lastChild.endOffset, 110, nextSequence++));
     } else {
       coveredParentEdges.add(parent.closeAtom);
+      coveredEndChildren.set(parent.closeAtom, lastChild.closeAtom);
     }
   }
-  return sortProjectedAtoms([...atoms.filter((atom) => !coveredParentEdges.has(atom)), ...syntheticAtoms]);
+  const childClosings = new Set(coveredEndChildren.values());
+  const atomIndexes = new Map(atoms.map((atom, index2) => [atom, index2]));
+  const closingSlotReplacements = new Map;
+  for (const parentClose of coveredEndChildren.keys()) {
+    if (childClosings.has(parentClose))
+      continue;
+    let earliestClose = parentClose;
+    let survivingClose = parentClose;
+    let childClose = coveredEndChildren.get(survivingClose);
+    while (childClose) {
+      if (atomIndexes.get(childClose) < atomIndexes.get(earliestClose))
+        earliestClose = childClose;
+      survivingClose = childClose;
+      childClose = coveredEndChildren.get(survivingClose);
+    }
+    if (earliestClose === survivingClose)
+      continue;
+    closingSlotReplacements.set(earliestClose, {
+      ...survivingClose,
+      sequence: earliestClose.sequence,
+      sortOrder: earliestClose.sortOrder
+    });
+    coveredParentEdges.add(survivingClose);
+  }
+  return sortProjectedAtoms([
+    ...atoms.flatMap((atom) => {
+      const replacement = closingSlotReplacements.get(atom);
+      if (replacement)
+        return [replacement];
+      return coveredParentEdges.has(atom) ? [] : [atom];
+    }),
+    ...syntheticAtoms
+  ]);
 }
 function collectLiveTrackedWrapperSpans(atoms) {
   const spans = [];
@@ -436342,7 +436452,7 @@ function collectLiveTrackedWrapperSpans(atoms) {
     }
     let openIndex = -1;
     for (let index2 = openStack.length - 1;index2 >= 0; index2 -= 1) {
-      if (openStack[index2].kind === info.kind) {
+      if (openStack[index2].kind === info.kind && openStack[index2].rsid === info.rsid) {
         openIndex = index2;
         break;
       }

package/package.json

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