@superdoc/mcp 1.0.0-next.7 → 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.9";
+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;
@@ -691770,7 +691849,7 @@ function parseParagraphXml(xml, inheritedNamespaceBindings = {}, trackedWrapperI
     } else if (tagLocalName === "hyperlink") {
       const inner = stripOuterTag(next.xml);
       const closingTag = extractClosingTag(next.xml);
-      const innerSegments = parseInnerInline(inner, namespaceBindingsForElement(next.openTagInner, paragraphNamespaceBindings));
+      const innerSegments = parseInnerInline(inner, namespaceBindingsForElement(next.openTagInner, paragraphNamespaceBindings), trackedWrapperIdentityState);
       segments.push({
         kind: "atom",
         atomKind: INLINE_ATOM_KIND.preserved,
@@ -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);
@@ -708730,7 +708906,7 @@ function runStorySurfaceMirror(prepared, options, admission, paragraphOnlyReview
       };
     }
   }
-  const familyResult = runFamilyMirror(prepared, extension2, options, admission.directStoryText, paragraphOnlyReviewStoryIds);
+  const familyResult = runFamilyMirror(prepared, extension2, options, admission.directStoryText, admission.trackedDecision, paragraphOnlyReviewStoryIds);
   if (!familyResult.mirrored) {
     return {
       txId: prepared.txId,
@@ -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":
@@ -708788,7 +708964,7 @@ function hasStrictMirrorPrerequisites(prepared, options) {
     }
   }
 }
-function runFamilyMirror(prepared, extension2, options, directStoryText, paragraphOnlyReviewStoryIds) {
+function runFamilyMirror(prepared, extension2, options, directStoryText, trackedDecision, paragraphOnlyReviewStoryIds) {
   if (!options.resolveStoryShard) {
     return {
       mirrored: false,
@@ -708836,7 +709012,7 @@ function runFamilyMirror(prepared, extension2, options, directStoryText, paragra
     return { mirrored: true };
   }
   if (extension2.family === "storyTrackedDecide") {
-    if (usesTrackedDecisionSessionSync(prepared, extension2)) {
+    if (usesTrackedDecisionSessionSync(prepared, extension2, options)) {
       if (!options.session) {
         return {
           mirrored: false,
@@ -708850,14 +709026,32 @@ function runFamilyMirror(prepared, extension2, options, directStoryText, paragra
       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" };
     }
-    return mirrorPreparedTrackedDecide(prepared, extension2, options);
+    if (!trackedDecision) {
+      return {
+        mirrored: false,
+        mirrorPath: "story-tracked-decide",
+        failure: {
+          storyId: prepared.resolvedTargets.stories[0] ?? "",
+          message: "storyTrackedDecide requires an admitted cross-story preflight"
+        }
+      };
+    }
+    return mirrorPreparedTrackedDecide(prepared, trackedDecision);
   }
   if (extension2.family === "compareApply") {
     return {
@@ -709072,30 +709266,11 @@ function mirrorPreparedCommentInsert(prepared, extension2, options) {
   });
   return { mirrored: true, mirrorPath: "session-sync" };
 }
-function mirrorPreparedTrackedDecide(prepared, extension2, options) {
-  const validation = validatePreparedTrackedDecide(prepared, extension2, options);
-  if (!validation.ok) {
-    return {
-      mirrored: false,
-      mirrorPath: "story-tracked-decide",
-      failure: {
-        storyId: prepared.resolvedTargets.stories[0] ?? "",
-        message: validation.failureReason
-      }
-    };
-  }
-  const source = validation.source;
-  const storyDocs = validation.storyDocs;
-  for (const { storyId, doc: doc2 } of storyDocs) {
-    const targets = validation.targets.filter((target) => target.storyId === storyId);
-    if (targets.length === 0)
-      continue;
-    const result = applyTrackedTextDecisionsToStory({
-      doc: doc2,
-      targets,
-      decision: source.decision,
-      txId: prepared.txId,
-      removedCommentIds: collectInvalidatedCommentIds(prepared)
+function mirrorPreparedTrackedDecide(prepared, preflight2) {
+  for (const { storyId, plan } of preflight2.stories) {
+    const result = applyPreflightedTrackedTextDecisionsToStory({
+      plan,
+      txId: prepared.txId
     });
     if (!result.ok) {
       return {
@@ -709169,6 +709344,26 @@ function validatePreparedTrackedDecide(prepared, extension2, options) {
   }
   return { ok: true, source, storyDocs, targets: trackedTextDecide.targets };
 }
+function preflightPreparedTrackedDecide(input) {
+  const stories = [];
+  const removedCommentIds = collectInvalidatedCommentIds(input.prepared);
+  for (const { storyId, doc: doc2 } of input.storyDocs) {
+    const targets = input.targets.filter((target) => target.storyId === storyId);
+    if (targets.length === 0)
+      continue;
+    const result = preflightTrackedTextDecisionsToStory({
+      doc: doc2,
+      targets,
+      decision: input.source.decision,
+      removedCommentIds
+    });
+    if (!result.ok) {
+      return { ok: false, failureReason: `${storyId}: ${result.failureReason}` };
+    }
+    stories.push({ storyId, plan: result.plan });
+  }
+  return { ok: true, preflight: { stories } };
+}
 function isSupportedPreparedTrackedTextKind(kind) {
   return kind === "ins" || kind === "del";
 }
@@ -709205,47 +709400,133 @@ function isSupportedPreparedTrackedCarrier(target) {
     return true;
   return target.carrierKind === "field-insertion" && target.trackedKind === "ins";
 }
-function applyTrackedTextDecisionsToStory(input) {
+function preflightTrackedTextDecisionsToStory(input) {
   const resolved = [];
-  for (const target of input.targets) {
-    const spans = findPreparedLiveTrackedTextSpans(input.doc, target);
-    const alreadyDecided = spans.length === 0 && hasTrackedDecisionLedgerEntry(input.doc, target.rsid);
-    if (spans.length === 0 && !alreadyDecided) {
+  const usedSpanIds = new Set;
+  const candidatesByTarget = input.targets.map((target) => ({
+    target,
+    spans: findPreparedLiveTrackedTextSpans(input.doc, target)
+  }));
+  for (const { target, spans } of candidatesByTarget) {
+    const span = spans.find((candidate) => !usedSpanIds.has(liveTrackedTextSpanId(candidate)));
+    const alreadyDecided = !span && spans.length === 0 && hasTrackedDecisionLedgerEntry(input.doc, target.rsid);
+    if (!span && !alreadyDecided) {
       return { ok: false, failureReason: `tracked decision target ${target.rsid} is not a live tracked text change` };
     }
-    resolved.push({ target, spans });
+    if (span)
+      usedSpanIds.add(liveTrackedTextSpanId(span));
+    resolved.push({ target, spans: span ? [span] : [] });
+  }
+  for (const { target, spans } of candidatesByTarget) {
+    if (spans.some((span) => !usedSpanIds.has(liveTrackedTextSpanId(span)))) {
+      return {
+        ok: false,
+        failureReason: `tracked decision target ${target.rsid} metadata does not cover every matching live carrier`
+      };
+    }
   }
   const live = resolved.filter((entry) => entry.spans.length > 0);
-  if (live.length === 0)
+  try {
+    const removedCommentCarrierIds = collectCommentCarrierIds(input.removedCommentIds);
+    const work = live.flatMap((entry) => entry.spans.map((span) => {
+      const block = findBlockMap(input.doc, span.blockId)?.block;
+      if (!block)
+        throw new Error(`target block ${span.blockId} is not present in the story shard`);
+      return {
+        target: entry.target,
+        span,
+        block,
+        leftBoundaryAtoms: [],
+        leftBoundaryAnchors: []
+      };
+    }));
+    for (const item of work) {
+      const { target, span, block, leftBoundaryAtoms, leftBoundaryAnchors } = item;
+      const blockLength = getBlockText(block).length;
+      if (span.startOffset < 0 || span.startOffset > blockLength) {
+        throw new Error(`tracked text span ${target.rsid} starts outside block ${span.blockId}`);
+      }
+      if (span.trackedKind === "ins" && input.decision === "reject") {
+        if (span.endOffset < span.startOffset || span.endOffset > blockLength) {
+          throw new Error(`tracked insert span ${target.rsid} is outside block ${span.blockId}`);
+        }
+      }
+      if (span.trackedKind === "del" && input.decision === "reject") {
+        let reachedStart = false;
+        const removedTrackedCarrierIds = trackedTextCarrierIds(span, false);
+        getBlockAtoms(block).forEach((atom) => {
+          if (reachedStart)
+            return;
+          const atomId = String(atom.get(ATOM_KEY.id) ?? "");
+          if (atomId === span.startAtomId) {
+            reachedStart = true;
+            return;
+          }
+          if (atomId && Number(atom.get(ATOM_KEY.visibleOffset) ?? -1) === span.startOffset && Number(atom.get(ATOM_KEY.length) ?? 0) === 0) {
+            if (removedCommentCarrierIds.has(atomId))
+              return;
+            if (removedTrackedCarrierIds.has(atomId)) {
+              throw new Error(`left-boundary atom ${atomId} aliases a removed tracked carrier`);
+            }
+            leftBoundaryAtoms.push(atom);
+            const anchorIdentity2 = rangeAnchorIdentityForAtom(atom);
+            if (anchorIdentity2) {
+              const matchingAnchors = getBlockAnchors(block).toArray().filter((anchor) => anchor.get(ANCHOR_KEY.id) === atom.get(ATOM_KEY.id) && anchor.get(ANCHOR_KEY.kind) === anchorIdentity2.kind && anchor.get(ANCHOR_KEY.boundary) === anchorIdentity2.boundary && Number(anchor.get(ANCHOR_KEY.visibleOffset) ?? -1) === span.startOffset);
+              if (matchingAnchors.length !== 1) {
+                throw new Error(`left-boundary atom ${atomId} does not resolve one exact anchor carrier`);
+              }
+              leftBoundaryAnchors.push(matchingAnchors[0]);
+            }
+          }
+        });
+        if (!reachedStart) {
+          throw new Error(`tracked deletion start ${span.startAtomId} is not present in block ${span.blockId}`);
+        }
+      }
+    }
+    return {
+      ok: true,
+      plan: {
+        doc: input.doc,
+        decision: input.decision,
+        removedCommentCarrierIds,
+        resolved,
+        work
+      }
+    };
+  } catch (error50) {
+    return { ok: false, failureReason: error50 instanceof Error ? error50.message : String(error50) };
+  }
+}
+function liveTrackedTextSpanId(span) {
+  return `${span.blockId}\x00${span.startAtomId}\x00${span.endAtomId}`;
+}
+function applyPreflightedTrackedTextDecisionsToStory(input) {
+  if (input.plan.work.length === 0)
     return { ok: true, applied: false, alreadyDecided: true };
   try {
-    resolveStoryShardScope(input.doc).doc.transact(() => {
-      const work = live.flatMap((entry) => entry.spans.map((span) => ({ target: entry.target, span })));
-      for (const { target, span } of work) {
-        const found = findBlockMap(input.doc, span.blockId)?.block;
-        if (!found)
-          throw new Error(`target block ${span.blockId} is not present in the story shard`);
-        removeTrackedTextCarriers(found, span, input.decision === "reject" && target.carrierKind === "field-insertion");
-        removeCommentCarriersByIds(found, input.removedCommentIds);
-      }
-      const sorted = work.sort((left, right) => {
+    resolveStoryShardScope(input.plan.doc).doc.transact(() => {
+      const { decision, doc: doc2, removedCommentCarrierIds, resolved, work } = input.plan;
+      for (const { target, span, block } of work) {
+        removeTrackedTextCarriers(block, span, decision === "reject" && target.carrierKind === "field-insertion");
+        removeCommentCarriersByIds(block, removedCommentCarrierIds);
+      }
+      const sorted = [...work].sort((left, right) => {
         if (left.span.blockId !== right.span.blockId)
           return left.span.blockId < right.span.blockId ? -1 : 1;
         if (left.span.startOffset !== right.span.startOffset)
           return right.span.startOffset - left.span.startOffset;
-        if (left.span.trackedKind === right.span.trackedKind)
-          return 0;
+        if (left.span.trackedKind === right.span.trackedKind) {
+          return right.span.startAtomIndex - left.span.startAtomIndex;
+        }
         return left.span.trackedKind === "ins" ? -1 : 1;
       });
-      for (const { target, span } of sorted) {
-        if (span.trackedKind === "ins" && input.decision === "reject") {
+      for (const { span, leftBoundaryAtoms, leftBoundaryAnchors } of sorted) {
+        if (span.trackedKind === "ins" && decision === "reject") {
           const length3 = span.endOffset - span.startOffset;
-          if (length3 < 0) {
-            throw new Error(`tracked insert span ${target.rsid} is outside block ${span.blockId}`);
-          }
           if (length3 > 0) {
             deleteText2({
-              doc: input.doc,
+              doc: doc2,
               blockId: span.blockId,
               offset: span.startOffset,
               length: length3,
@@ -709253,8 +709534,8 @@ function applyTrackedTextDecisionsToStory(input) {
             });
           }
         }
-        if (span.trackedKind === "del" && input.decision === "reject") {
-          const found = findBlockMap(input.doc, span.blockId)?.block;
+        if (span.trackedKind === "del" && decision === "reject") {
+          const found = findBlockMap(doc2, span.blockId)?.block;
           if (!found)
             throw new Error(`target block ${span.blockId} is not present in the story shard`);
           let offset = span.startOffset;
@@ -709266,7 +709547,7 @@ function applyTrackedTextDecisionsToStory(input) {
               continue;
             }
             insertText2({
-              doc: input.doc,
+              doc: doc2,
               blockId: span.blockId,
               offset,
               text: segment.text,
@@ -709293,10 +709574,12 @@ function applyTrackedTextDecisionsToStory(input) {
           if (restoredBreakXml) {
             throw new Error(`attributed break restoration in ${span.blockId} is incomplete`);
           }
+          leftBoundaryAtoms.forEach((atom) => atom.set(ATOM_KEY.visibleOffset, span.startOffset));
+          leftBoundaryAnchors.forEach((anchor) => anchor.set(ANCHOR_KEY.visibleOffset, span.startOffset));
         }
       }
       for (const { target } of resolved) {
-        recordTrackedDecision(input.doc, target.rsid, input.decision, input.txId);
+        recordTrackedDecision(doc2, target.rsid, decision, input.txId);
       }
     }, STORY_SURFACE_BACKEND_ORIGIN);
   } catch (error50) {
@@ -709375,6 +709658,7 @@ function collectLiveTrackedTextSpansInBlock(block, rsid, trackedKind) {
       blockId,
       startOffset: start.offset,
       endOffset: trackedKind === "del" ? start.offset + deletedTextLength2 : end.offset,
+      startAtomIndex: start.index,
       startAtomId: start.id,
       endAtomId: end.id,
       preservedAtomIds: preservedForSpan.map((atom) => atom.id),
@@ -709386,24 +709670,38 @@ function collectLiveTrackedTextSpansInBlock(block, rsid, trackedKind) {
   return spans;
 }
 function removeTrackedTextCarriers(block, span, removeContainedAtoms) {
-  const ids = new Set([
+  const ids = trackedTextCarrierIds(span, removeContainedAtoms);
+  deleteYMapArrayEntriesByIds(getBlockAtoms(block), ATOM_KEY.id, ids);
+  deleteYMapArrayEntriesByIds(getBlockAnchors(block), ANCHOR_KEY.id, ids);
+}
+function trackedTextCarrierIds(span, includeContainedAtoms) {
+  return new Set([
     span.startAtomId,
     span.endAtomId,
     ...span.preservedAtomIds,
-    ...removeContainedAtoms ? span.containedAtomIds : []
+    ...includeContainedAtoms ? span.containedAtomIds : []
   ]);
-  deleteYMapArrayEntriesByIds(getBlockAtoms(block), ATOM_KEY.id, ids);
-  deleteYMapArrayEntriesByIds(getBlockAnchors(block), ANCHOR_KEY.id, ids);
 }
-function removeCommentCarriersByIds(block, commentIds) {
-  if (commentIds.size === 0)
-    return;
+function rangeAnchorIdentityForAtom(atom) {
+  const atomKind = atom.get(ATOM_KEY.kind);
+  if (atomKind !== INLINE_ATOM_KIND.commentMarker && atomKind !== INLINE_ATOM_KIND.bookmark)
+    return null;
+  const marker = String(asRecord6(atom.get(ATOM_KEY.meta)).marker ?? "");
+  const boundary = marker.endsWith("End") ? "end" : marker.endsWith("Start") ? "start" : "point";
+  return { kind: atomKind === INLINE_ATOM_KIND.commentMarker ? "comment" : "bookmark", boundary };
+}
+function collectCommentCarrierIds(commentIds) {
   const ids = new Set;
   for (const commentId of commentIds) {
     ids.add(`comment:${commentId}:start`);
     ids.add(`comment:${commentId}:end`);
     ids.add(`comment:${commentId}:ref`);
   }
+  return ids;
+}
+function removeCommentCarriersByIds(block, ids) {
+  if (ids.size === 0)
+    return;
   deleteYMapArrayEntriesByIds(getBlockAtoms(block), ATOM_KEY.id, ids);
   deleteYMapArrayEntriesByIds(getBlockAnchors(block), ANCHOR_KEY.id, ids);
 }
@@ -709509,11 +709807,14 @@ 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);
-    return trackedDecision.ok ? { ok: true } : { ok: false, message: trackedDecision.failureReason };
+    if (!trackedDecision.ok)
+      return { ok: false, message: trackedDecision.failureReason };
+    const preflight2 = preflightPreparedTrackedDecide({ prepared, ...trackedDecision });
+    return preflight2.ok ? { ok: true, trackedDecision: preflight2.preflight } : { ok: false, message: preflight2.failureReason };
   }
   if (extension2.family === "storyTable") {
     if (extension2.historyReplay) {
@@ -709584,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.7",
+  "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.9",
+    "@superdoc/sdk": "2.13.0-next.11",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.16.0-next.7",
-    "@superdoc/docx-engine": "0.15.0-next.7",
+    "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",