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

package/dist/index.js

@@ -31330,7 +31330,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.17.0-next.8";
+var SDK_VERSION = "2.17.0-next.9";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -135279,7 +135279,28 @@ function control(xml, element) {
   const locks = children.filter((child) => is(child, "lock"));
   const deletable = locks.every((lock) => attr(lock, "val") === "unlocked" || attr(lock, "val") === "contentLocked");
   const supportedProperties = children.every((child) => child.tag.uri === W3 ? ["id", "tag", "alias", "text", "richText", "lock", "rPr", "placeholder", "showingPlcHdr", "temporary"].includes(child.tag.local) : child.tag.uri === "http://schemas.microsoft.com/office/word/2012/wordml" && child.tag.local === "appearance");
-  return { id, key: `sdt:${attr(key2, "val")}`, xml: fragment2(xml, element), deletable: deletable && supportedProperties };
+  const contentXml = xml.slice(content[0].start, content[0].end);
+  const contentOpenEnd = contentXml.indexOf(">") + 1;
+  const contentCloseStart = contentXml.lastIndexOf("</");
+  const contentRuns = contentCloseStart < contentOpenEnd ? "" : contentXml.slice(contentOpenEnd, contentCloseStart);
+  const offset = content[0].start - element.start;
+  const itemXml = fragment2(xml, element);
+  const head = itemXml.slice(0, offset + contentOpenEnd);
+  const tail = itemXml.slice(offset + Math.max(contentOpenEnd, contentCloseStart));
+  const unlocked = locks.every((lock) => attr(lock, "val") === "unlocked");
+  const editable = locks.every((lock) => attr(lock, "val") === "unlocked" || attr(lock, "val") === "sdtLocked");
+  return {
+    id,
+    key: `sdt:${attr(key2, "val")}`,
+    xml: itemXml,
+    contentXml: contentRuns,
+    head,
+    tail,
+    deletable: deletable && supportedProperties,
+    insertable: unlocked && supportedProperties,
+    editable: editable && supportedProperties,
+    supportedProperties
+  };
 }
 function inspectInlineControlRemoval(beforeXml, afterXml, namespaces = {}) {
   const before = elements(beforeXml, namespaces);
@@ -135366,6 +135387,137 @@ function bodyOperationsCoverInlineControlRemoval(base2, target, operations, matc
   }
   return removed.size === changes.length && changes.every((entry) => entry.baseId !== null && removed.has(entry.baseId));
 }
+function inspectInlineControlReplay(beforeXml, afterXml, namespaces = {}) {
+  const before = elements(beforeXml, namespaces);
+  const after = elements(afterXml, namespaces);
+  if (!before || !after)
+    return null;
+  const xmlns = "http://www.w3.org/2000/xmlns/";
+  const attributes = (root, allowed) => Object.values(root.tag.attributes).every((attribute) => attribute.uri === xmlns || allowed(attribute.uri, attribute.local));
+  const runProperties = (root) => is(root, "rPr") && attributes(root, () => false) && root.children.every((child) => child.tag.uri === W3 && RUN_PROPERTIES.has(child.tag.local) && !child.children.length && attributes(child, (uri) => uri === W3));
+  const simpleRun = (root) => safeRun(root) && attributes(root, (uri, local) => uri === W3 && ["rsidR", "rsidRPr", "rsidDel"].includes(local)) && root.children.filter((child) => is(child, "t")).length === 1 && root.children.every((child) => runProperties(child) || is(child, "t") && !child.tag.isSelfClosing && attributes(child, (uri, local) => uri === "http://www.w3.org/XML/1998/namespace" && local === "space"));
+  const safeControlProperties = (root) => {
+    if (!attributes(root, (uri, local) => uri === W3 && ["rsidR", "rsidRPr", "rsidDel"].includes(local)))
+      return false;
+    const properties = root.children.find((child) => is(child, "sdtPr"));
+    const content = root.children.find((child) => is(child, "sdtContent"));
+    if (!attributes(properties, () => false) || !attributes(content, () => false) || content.tag.isSelfClosing)
+      return false;
+    if (properties.children.filter((child) => is(child, "text") || is(child, "richText")).length > 1)
+      return false;
+    const seen = new Set;
+    for (const child of properties.children) {
+      if (seen.has(child.tag.name))
+        return false;
+      seen.add(child.tag.name);
+      if (!attributes(child, (uri) => uri === W3 || uri === child.tag.uri))
+        return false;
+      if (is(child, "rPr")) {
+        if (!runProperties(child))
+          return false;
+      } else if (is(child, "placeholder")) {
+        if (child.children.some((item) => !is(item, "docPart") || item.children.length || !attributes(item, (uri) => uri === W3)))
+          return false;
+      } else if (child.children.length)
+        return false;
+    }
+    return root.children.filter((child) => is(child, "sdtEndPr")).every((child) => attributes(child, () => false) && child.children.every(runProperties));
+  };
+  const inspect = (xml, roots) => {
+    const result = [];
+    for (const [index, root] of roots.entries()) {
+      if (simpleRun(root))
+        continue;
+      const item = control(xml, root);
+      if (!item || !item.supportedProperties || !safeControlProperties(root) || !root.children.find((child) => is(child, "sdtContent"))?.children.every(simpleRun) || result.some((other) => other.id === item.id || other.key === item.key))
+        return null;
+      result.push({ ...item, index });
+    }
+    return result;
+  };
+  const previous = inspect(beforeXml, before);
+  const next = inspect(afterXml, after);
+  if (!previous || !next || !previous.length && !next.length)
+    return null;
+  const normalized = (xml) => signature(`<scope ${Object.entries(namespaces).filter(([prefix]) => prefix && prefix !== "xml").map(([prefix, uri]) => `xmlns:${prefix}=${JSON.stringify(uri)}`).join(" ")}>${xml}</scope>`);
+  const anchors = [];
+  for (const old of previous) {
+    const current = next.find((item) => item.id === old.id);
+    if (!current || old.key !== current.key || normalized(old.head + old.tail) !== normalized(current.head + current.tail))
+      return null;
+    const changed = normalized(old.xml) !== normalized(current.xml);
+    if (changed && !old.editable)
+      return null;
+    anchors.push({ beforeIndex: old.index, afterIndex: current.index, before: old, after: current, changed });
+  }
+  if (anchors.some((anchor, index) => index > 0 && anchor.afterIndex <= anchors[index - 1].afterIndex))
+    return null;
+  const inserted = next.filter((item) => !previous.some((old) => old.id === item.id));
+  if (inserted.some((item) => !item.insertable))
+    return null;
+  return {
+    anchors,
+    inserted,
+    updated: anchors.filter((anchor) => anchor.changed),
+    beforeRoots: before.map((root) => fragment2(beforeXml, root)),
+    afterRoots: after.map((root) => fragment2(afterXml, root))
+  };
+}
+function bodyOperationsCoverInlineControlReplay(base2, target, operations, match) {
+  const family = match.families.find((item) => item.family === "content-controls");
+  const changes = family?.entityMatch?.entries.filter((entry) => entry.disposition !== "matched" || entry.changed || entry.moved);
+  if (!changes?.length || family?.hasAmbiguity || changes.some((entry) => entry.disposition !== "inserted" && entry.disposition !== "matched" || entry.moved))
+    return false;
+  const counts = (snapshot2) => {
+    const result = new Map;
+    const visit = (root) => {
+      if (is(root, "sdtPr"))
+        for (const child of root.children.filter((item) => is(item, "id"))) {
+          const id = numericIdentity(attr(child, "val"));
+          if (id !== null)
+            result.set(id, (result.get(id) ?? 0) + 1);
+        }
+      root.children.forEach(visit);
+    };
+    for (const entry of [...snapshot2.body, ...(snapshot2.stories ?? []).flatMap((story) => story.entries)]) {
+      const roots = elements(entry.runXml ?? "", {}, true);
+      if (!roots)
+        return null;
+      roots.forEach(visit);
+    }
+    return result;
+  };
+  const oldCounts = counts(base2), newCounts = counts(target);
+  if (!oldCounts || !newCounts)
+    return false;
+  const covered = new Map;
+  for (const operation of operations) {
+    if (operation.kind !== "edit" && operation.kind !== "formatEdit")
+      continue;
+    const previous = base2.body.filter((entry) => entry.blockId === operation.blockId);
+    const next = target.body.filter((entry) => entry.blockId === operation.blockId);
+    if (previous.length !== 1 || next.length !== 1)
+      continue;
+    const before = previous[0], after = next[0];
+    const proof = inspectInlineControlReplay(before.runXml ?? "", after.runXml ?? "");
+    if (!proof)
+      continue;
+    if (!/^[0-9A-Fa-f]{8}$/.test(before.blockId) || (before.structuralScope ?? "body") !== "body" || (after.structuralScope ?? "body") !== "body" || before.trackedChangeAnnotationKeys?.length || before.structuralChangeAnnotationKeys?.length || after.trackedChangeAnnotationKeys?.length || after.structuralChangeAnnotationKeys?.length || operation.targetRunXml !== after.runXml)
+      return false;
+    for (const item of proof.inserted) {
+      if (covered.has(item.key) || oldCounts.has(item.id) || newCounts.get(item.id) !== 1)
+        return false;
+      covered.set(item.key, "inserted");
+    }
+    for (const anchor of proof.updated) {
+      const item = anchor.after;
+      if (covered.has(item.key) || oldCounts.get(item.id) !== 1 || newCounts.get(item.id) !== 1)
+        return false;
+      covered.set(item.key, "matched");
+    }
+  }
+  return covered.size === changes.length && changes.every((entry) => entry.targetId !== null && covered.get(entry.targetId) === entry.disposition);
+}
 var import_saxes3, W3 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", attr = (element, name) => Object.values(element.tag.attributes).find((attribute) => attribute.uri === W3 && attribute.local === name)?.value, is = (element, name) => element.tag.uri === W3 && element.tag.local === name, fragment2 = (xml, element) => xml.slice(element.start, element.end), signature = (xml) => canonicalizeXmlForSignature(xml), RUN_PROPERTIES;
 var init_inline_control_removal = __esm(() => {
   init_run_signature();
@@ -136241,7 +136393,7 @@ function parseXmlStartTag(rawTag) {
   return null;
 }
 function validateRunContents(xml, options) {
-  if (options.baseRunXml !== undefined && inspectInlineControlRemoval(options.baseRunXml, xml)) {
+  if (options.baseRunXml !== undefined && (inspectInlineControlRemoval(options.baseRunXml, xml) || inspectInlineControlReplay(options.baseRunXml, xml))) {
     return { ok: true };
   }
   const baseHasNoteMarker = options.baseRunXml !== undefined && /<(?:[A-Za-z_][\w.-]*:)?(?:footnoteRef|endnoteRef)\b/.test(options.baseRunXml);
@@ -140072,7 +140224,7 @@ function planCompare(base2, target) {
   const trackedRevisionSetChanged = semanticAnalysis.familyDeltas.find((delta) => delta.family === "tracked-changes")?.detectedChange === true;
   const revisionReplay = deriveCompareBodyOperationsWithRevisionReplay(base2, target, matchResult);
   const bodyOperations = revisionReplay.operations;
-  if (bodyOperationsCoverInlineControlRemoval(base2, target, bodyOperations, matchResult)) {
+  if (bodyOperationsCoverInlineControlRemoval(base2, target, bodyOperations, matchResult) || bodyOperationsCoverInlineControlReplay(base2, target, bodyOperations, matchResult)) {
     semanticAnalysis = markFamilySupported(semanticAnalysis, "content-controls");
   }
   const computedStoryOperations = buildStoryOperations(base2, target, semanticAnalysis);
@@ -164393,6 +164545,9 @@ function planDirectInlineEdit(paragraphBytes, startOffset, endOffset, newText, c
       ...enclosingSdts.length > 0 ? { requiresCollaborationSessionSync: true } : {}
     };
   }
+  const sdtProtection = validateSelectedSdtProtection(model.pieces, startOffset, endOffset);
+  if (sdtProtection)
+    return { ok: false, reason: sdtProtection };
   const tocPlan = planTocEntryEdit(paragraphBytes, xml, model, leaves, startOffset, endOffset, newText, inlineContext, authoredTocEntry);
   if (tocPlan)
     return tocPlan;
@@ -164445,7 +164600,13 @@ function planDirectInlineEdits(paragraphBytes, edits, inheritedNamespaceBindings
       return { ok: false, reason: "invalid-range" };
     }
   }
-  const batchLeaves = parseParagraphInlineMap(TD22.decode(paragraphBytes), inheritedNamespaceBindings).leaves();
+  const batchModel = parseParagraphInlineMap(TD22.decode(paragraphBytes), inheritedNamespaceBindings);
+  for (const edit of ordered) {
+    const blocked = validateSelectedSdtProtection(batchModel.pieces, edit.startOffset, edit.endOffset);
+    if (blocked)
+      return { ok: false, reason: blocked };
+  }
+  const batchLeaves = batchModel.leaves();
   if (batchLeaves.some((piece) => piece.kind === "noteReference" && !piece.deleted && ordered.some((edit) => edit.startOffset < piece.visibleEnd && edit.endOffset > piece.visibleStart))) {
     return { ok: false, reason: "unsupported-context" };
   }
@@ -165022,6 +165183,27 @@ function hasNonWordMarkerAtCollapsedMoveBoundary(pieces, at, coordinateSpace = "
 function firstNonFieldRangeStartMarker(markers) {
   return markers.find((piece) => piece.role === "range-start" && !isFieldMarker(piece.markerKind)) ?? null;
 }
+function validateSelectedSdtProtection(pieces, start, end) {
+  if (start === end)
+    return null;
+  for (const piece of pieces) {
+    if (piece.kind !== "container" && piece.kind !== "tracked")
+      continue;
+    if (piece.kind === "container" && piece.containerKind === "sdt" && rangeCrossesContainer(piece, start, end)) {
+      const policy = classifySdtMutationPolicyInternal(piece, true);
+      if (!policy.ok)
+        return policy.reason;
+      const contentOnly = containerContainsRange(piece, start, end);
+      const wholeWrapper = start <= piece.visibleStart && piece.visibleEnd <= end;
+      if (contentOnly && !policy.contentEditable || !contentOnly && !policy.wrapperDeletable || !contentOnly && !wholeWrapper && !policy.contentEditable)
+        return "text-range-in-sdt";
+    }
+    const blocked = validateSelectedSdtProtection(piece.children, start, end);
+    if (blocked)
+      return blocked;
+  }
+  return null;
+}
 function resolveEditScope(pieces, start, end, collapsedInlineAffinity, collapsedOutsideContentControl = false) {
   let current = pieces;
   let descended = false;
@@ -165076,11 +165258,11 @@ function planCrossBoundarySdts(pieces, start, end) {
     const policy = classifySdtMutationPolicy(piece);
     if (!policy.ok)
       return policy;
+    if (!policy.wrapperDeletable)
+      return { ok: false, reason: "text-range-in-sdt" };
     requiresCollaborationSessionSync = true;
     const wholeWrapper = start <= piece.visibleStart && piece.visibleEnd <= end;
     if (wholeWrapper) {
-      if (!policy.wrapperDeletable)
-        return { ok: false, reason: "text-range-in-sdt" };
       const blocked = findBlockingSdtChild(piece.children);
       if (blocked)
         return { ok: false, reason: blocked };
@@ -192934,7 +193116,7 @@ function tryRangeReplacementAcrossTokens(input, allTokens, touched) {
   if (!firstSelected)
     return null;
   const touchedInsertions = touched.filter((entry) => entry.token.kind === "ins");
-  if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 1 || token.nestedDeletions && token.nestedDeletions.length > 0)) {
+  if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 1 && (token !== firstSelected.token || token.commentedBoundary != null) || token.nestedDeletions && token.nestedDeletions.length > 0)) {
     return null;
   }
   const result = input.changeMode === "tracked" ? authorTrackedPureDelete(input, allTokens, touched) : authorDirectPureDelete(input, allTokens, touched);
@@ -193038,7 +193220,7 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
         continue;
       }
       const head2 = token.text.slice(0, localStart2);
-      const removed2 = token.text.slice(localStart2, localEnd2);
+      const removed = token.text.slice(localStart2, localEnd2);
       const tail2 = token.text.slice(localEnd2);
       const headXml = head2.length > 0 ? renderPlainRun(head2, token.runOpen, token.runClose, token.rPr) : "";
       const delXml = buildDelWrapperXml({
@@ -193047,7 +193229,7 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
         author: currentAuthor,
         date: input.txTimestamp,
         rsidDel: input.rsid,
-        inner: { runOpen: token.runOpen, runClose: token.runClose, rPr: token.rPr, text: removed2 }
+        inner: { runOpen: token.runOpen, runClose: token.runClose, rPr: token.rPr, text: removed }
       });
       const insertXml = !replacementInserted && input.newText.length > 0 ? buildInsWrapperXml({
         nsPrefix,
@@ -193080,7 +193262,6 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
       continue;
     }
     const head = token.inner.text.slice(0, localStart);
-    const removed = token.inner.text.slice(localStart, localEnd);
     const tail = token.inner.text.slice(localEnd);
     const classification = token._classification;
     removedAnything = true;
@@ -193109,8 +193290,13 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
         updatedRsids.push(rsid);
       continue;
     }
-    const nestedHead = renderPlainRun(head, token.inner.runOpen, token.inner.runClose, token.inner.rPr);
-    const nestedTail = renderPlainRun(tail, token.inner.runOpen, token.inner.runClose, token.inner.rPr);
+    const runs = token.innerRuns ?? [token.inner];
+    const headRuns = sliceWrappedRuns(runs, 0, localStart);
+    const removedRuns = sliceWrappedRuns(runs, localStart, localEnd);
+    const tailRuns = sliceWrappedRuns(runs, localEnd, token.inner.text.length);
+    const nestedHead = buildInsInnerXmlFromRuns(headRuns);
+    const nestedTail = buildInsInnerXmlFromRuns(tailRuns);
+    const insertMeta = runMetaAtInsertionPoint(token, localStart, true);
     const childIns = !replacementInserted && input.newText.length > 0 && input.rangeStart >= token.visibleStart && input.rangeStart < token.visibleEnd && input.rangeEnd > token.visibleEnd ? buildInsWrapperXml({
       namespaceReferenceOpenTag: token.openTag,
       nsPrefix: token.nsPrefix,
@@ -193119,9 +193305,9 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
       date: input.txTimestamp,
       rsidR: input.insRsid,
       inner: {
-        runOpen: token.inner.runOpen,
-        runClose: token.inner.runClose,
-        rPr: token.inner.rPr,
+        runOpen: insertMeta.runOpen,
+        runClose: insertMeta.runClose,
+        rPr: rPrAtInsertionPoint(token, localStart, true),
         text: input.newText
       }
     }) : "";
@@ -193132,10 +193318,8 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
       author: currentAuthor,
       date: input.txTimestamp,
       rsidDel: input.rsid,
-      inner: { runOpen: token.inner.runOpen, runClose: token.inner.runClose, rPr: token.inner.rPr, text: removed },
-      ...token.commentedBoundary ? {
-        innerXml: renderDelRun(removed, token.inner.runOpen, token.inner.runClose, token.inner.rPr) + token.commentedBoundary.endXml + token.commentedBoundary.referenceRunXml
-      } : {}
+      inner: removedRuns[0],
+      innerXml: buildDelInnerXmlFromRuns(removedRuns) + (token.commentedBoundary?.endXml ?? "") + (token.commentedBoundary?.referenceRunXml ?? "")
     });
     if (token.commentedBoundary) {
       if (!childIns || tail.length > 0)
@@ -193156,7 +193340,8 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
         author: token.author,
         date: token.date,
         rsidR: token.rsidR,
-        inner: { ...token.inner, text: head }
+        inner: headRuns[0],
+        innerXml: nestedHead
       }) : "";
       const tailIns = buildInsWrapperXml({
         openTag: token.openTag,
@@ -193523,6 +193708,20 @@ function foldInsideOwnInsertion(input, allTokens, parent) {
   const rebuilt = rebuildParagraph(allTokens, parent, newInsXml);
   return rebuilt.ok ? markTextInsertionRefined(markExistingRevisionUpdated(rebuilt, input, parent), input, parent, false) : rebuilt;
 }
+function sliceWrappedRuns(runs, start, end) {
+  const result = [];
+  let offset = 0;
+  for (const run of runs) {
+    const runEnd = offset + run.text.length;
+    if (start < runEnd && end > offset) {
+      result.push({ ...run, text: run.text.slice(Math.max(0, start - offset), Math.min(run.text.length, end - offset)) });
+    }
+    offset = runEnd;
+    if (offset >= end)
+      break;
+  }
+  return result;
+}
 function flattenWrappedRuns(runs) {
   const out = [];
   for (const run of runs) {
@@ -193743,8 +193942,10 @@ function splitInsertionAroundChildChange(input, allTokens, parent) {
       detail: "overlap compiler: edit range straddles an existing nested tracked deletion."
     };
   }
-  const headOwnedNested = parent.nestedDeletions?.filter((n) => n.localOffset <= localStart) ?? [];
-  const tailOwnedNested = parent.nestedDeletions?.filter((n) => n.localOffset > localStart) ?? [];
+  const precedesBoundaryDeletion = input.changeMode === "tracked" && input.newText.length > 0 && input.rangeStart === input.rangeEnd && (input.coordinateSpace ?? "visible") === "visible" && input.collapsedInlineAffinity === "upstream";
+  const belongsToHead = (n) => n.localOffset < localStart || n.localOffset === localStart && !precedesBoundaryDeletion;
+  const headOwnedNested = nestedDeletions.filter(belongsToHead);
+  const tailOwnedNested = nestedDeletions.filter((n) => !belongsToHead(n));
   const flat = flattenWrappedRuns(parent.innerRuns ?? [parent.inner]);
   const headRuns = coalesceWrappedRuns(flat.slice(0, localStart));
   const removedRuns = coalesceWrappedRuns(flat.slice(localStart, localEnd));
@@ -193874,7 +194075,7 @@ function splitInsertionAroundChildChange(input, allTokens, parent) {
     ok: true,
     xml,
     emittedRsids,
-    ...removedText.length > 0 || tailParentWId !== parent.wId || liftComment ? { requiresCollaborationSessionSync: true } : {}
+    ...removedText.length > 0 || tailParentWId !== parent.wId || liftComment || precedesBoundaryDeletion && tailOwnedNested.some((n) => n.localOffset === localStart) ? { requiresCollaborationSessionSync: true } : {}
   };
 }
 function insertAtForeignDeletion(input, allTokens, parent, sameUser, side = "after") {
@@ -198958,6 +199159,15 @@ function rewriteTrackedPartialSdtSelection(paragraphXml, startOffset, endOffset,
   const sdts = [...intersectingSdts].sort((left, right) => left.visibleStart - right.visibleStart);
   if (sdts.some((sdt, index) => index > 0 && sdt.visibleStart < sdts[index - 1].visibleEnd))
     return null;
+  for (const sdt of sdts) {
+    if (sdt.visibleStart <= startOffset && endOffset <= sdt.visibleEnd)
+      continue;
+    const policy = classifySdtMutationPolicy(sdt);
+    if (!policy.ok)
+      return policy;
+    if (!policy.wrapperDeletable)
+      return { ok: false, reason: "text-range-in-sdt" };
+  }
   const segments = [];
   let cursor = startOffset;
   for (const sdt of sdts) {
@@ -216135,7 +216345,10 @@ function runParagraphRangeCollapseCommit(input) {
   if (startOffsetMap.charToByte(op.on.startOffset) !== op.on.startByte || endOffsetMap.charToByte(op.on.endOffset) !== op.on.endByte) {
     return rejected8(input.txId, "base-revision-drift");
   }
-  const structuralFailure = validateRangeCollapseStructure(bytes, index.entries, start, end, changeMode, op.startObjectBoundary, op.endObjectBoundary, { allowSectionBoundary: changeMode === "direct" && op.replacementText === undefined && !deleteFullBlocks });
+  const structuralFailure = validateRangeCollapseStructure(bytes, index.entries, start, end, changeMode, op.startObjectBoundary, op.endObjectBoundary, {
+    allowSectionBoundary: changeMode === "direct" && op.replacementText === undefined && !deleteFullBlocks,
+    inlineRange: { startOffset: op.on.startOffset, endOffset: op.on.endOffset, deleteFullBlocks: op.deleteFinalParagraphMark === true }
+  });
   if (structuralFailure)
     return rejected8(input.txId, structuralFailure);
   let replacementBlockId;
@@ -216192,7 +216405,7 @@ function runParagraphRangeCollapseCommit(input) {
       op = expanded.op;
       start = expanded.start;
       end = expanded.end;
-      const expandedStructure = validateRangeCollapseStructure(bytes, index.entries, start, end, changeMode, undefined, undefined, { allowSectionBoundary: true });
+      const expandedStructure = validateRangeCollapseStructure(bytes, index.entries, start, end, changeMode, undefined, undefined, { allowSectionBoundary: true, inlineRange: { startOffset: op.on.startOffset, endOffset: op.on.endOffset } });
       if (expandedStructure)
         return rejected8(input.txId, expandedStructure);
       rangeIntegrity = validateParagraphRangeIntegrity({
@@ -217942,6 +218155,11 @@ function validateRangeCollapseStructure(bytes, entries, start, end, changeMode,
   if (!options.structuralMap && directBodyRangeIsStructurallyPlain(bytes, entries, start, end, changeMode)) {
     return null;
   }
+  if (options.inlineRange) {
+    const failure2 = validateRangeInlineSdtProtection(bytes, entries, start, end, options.inlineRange);
+    if (failure2)
+      return failure2;
+  }
   if (!options.structuralMap)
     recordSDTxPerf("rangeCollapseStructuralFullScans", 1);
   const map3 = options.structuralMap ?? buildStructuralBoundaryMap(bytes);
@@ -218013,6 +218231,46 @@ function validateRangeCollapseStructure(bytes, entries, start, end, changeMode,
   }
   return null;
 }
+function validateRangeInlineSdtProtection(bytes, entries, start, end, range) {
+  for (const entry of entries) {
+    if (entry.ordinal < start.ordinal || entry.ordinal > end.ordinal)
+      continue;
+    const xml = decodeByteRange(bytes, entry.byteStart, entry.byteEnd);
+    if (!/<\s*(?:[\w.-]+:)?sdt\b/.test(xml))
+      continue;
+    const namespaces = namespaceBindingsAtPosition(bytes, entry.byteStart, matchParagraphOpenTag(xml) ?? "");
+    const selectedStart = entry.blockId === start.blockId ? range.startOffset : 0;
+    const selectedEnd = entry.blockId === end.blockId ? range.endOffset : entry.textLength;
+    const wholeParagraph = range.deleteFullBlocks === true || entry.ordinal > start.ordinal && entry.ordinal < end.ordinal;
+    const visit = (pieces) => {
+      for (const piece of pieces) {
+        if (piece.kind !== "container" && piece.kind !== "tracked")
+          continue;
+        if (piece.kind === "container" && piece.containerKind === "sdt") {
+          const touched = wholeParagraph || (piece.visibleStart === piece.visibleEnd ? (entry.blockId !== start.blockId || selectedStart < piece.visibleStart) && piece.visibleEnd <= selectedEnd : selectedStart < piece.visibleEnd && piece.visibleStart < selectedEnd);
+          if (!touched)
+            continue;
+          const policy = classifySdtMutationPolicy(piece);
+          if (!policy.ok)
+            return policy.reason;
+          if (!policy.wrapperDeletable)
+            return "text-range-in-sdt";
+          const wholeWrapper = wholeParagraph || selectedStart <= piece.visibleStart && piece.visibleEnd <= selectedEnd;
+          if (!wholeWrapper && !policy.contentEditable)
+            return "text-range-in-sdt";
+        }
+        const failure3 = visit(piece.children);
+        if (failure3)
+          return failure3;
+      }
+      return null;
+    };
+    const failure2 = visit(parseParagraphInlineMap(xml, namespaces).pieces);
+    if (failure2)
+      return failure2;
+  }
+  return null;
+}
 function directBodyRangeIsStructurallyPlain(bytes, entries, start, end, changeMode) {
   if (!Number.isSafeInteger(start.ordinal) || !Number.isSafeInteger(end.ordinal) || start.ordinal < 0 || end.ordinal <= start.ordinal || end.ordinal >= entries.length || entries[start.ordinal]?.blockId !== start.blockId || entries[start.ordinal]?.byteStart !== start.byteStart || entries[start.ordinal]?.byteEnd !== start.byteEnd || entries[end.ordinal]?.blockId !== end.blockId || entries[end.ordinal]?.byteStart !== end.byteStart || entries[end.ordinal]?.byteEnd !== end.byteEnd || !Number.isSafeInteger(start.byteStart) || !Number.isSafeInteger(end.byteEnd) || start.byteStart < 0 || end.byteEnd <= start.byteStart || end.byteEnd > bytes.byteLength)
     return false;
@@ -224330,7 +224588,7 @@ function runBodyStep(input, storyId, noteId, step2, changeMode, options, pushHis
   if ((step2.kind === "edit" || step2.kind === "formatEdit") && step2.targetRunXml !== undefined) {
     const before = liveCompareBodyRunXml(state, storyId, step2.blockId);
     const partBytes = state.packageBytes.get(storyPartUriFromStoryId2(storyId));
-    if (before !== undefined && partBytes && inspectInlineControlRemoval(before, step2.targetRunXml, textboxNamespaceBindingsFromPartBytes(partBytes))) {
+    if (before !== undefined && partBytes && (inspectInlineControlRemoval(before, step2.targetRunXml, textboxNamespaceBindingsFromPartBytes(partBytes)) || inspectInlineControlReplay(before, step2.targetRunXml, textboxNamespaceBindingsFromPartBytes(partBytes)))) {
       return runInlineControlRemovalCommit(input, storyId, step2, changeMode, options, pushHistory);
     }
   }
@@ -225091,6 +225349,134 @@ function retainedNoteMarkerRuns(oldRuns, targetRuns, storyId) {
     targetRuns: targetMarker.remainingRunXml
   };
 }
+function equivalentSimpleRunContent(before, after) {
+  const previous = parseSimpleRunTokens(before), next = parseSimpleRunTokens(after);
+  if (!previous || !next)
+    return false;
+  const spans = (tokens) => tokens.flatMap((token) => Array.from(token.text, (char) => `${canonicalizeXmlForSignature(token.openTag)}:${char}`));
+  const old = spans(previous), target = spans(next);
+  return old.length === target.length && old.every((value, index) => value === target[index]);
+}
+function inlineComparePieces(proof) {
+  const pieces = [];
+  const gap = (before, roots, rootOffset) => {
+    const tokens = parseSimpleRunTokens(before);
+    if (!tokens)
+      return false;
+    const oldText = tokens.map((token) => token.text).join("");
+    const targets = roots.map((xml, index) => {
+      const control2 = proof.inserted.find((item) => item.index === index + rootOffset);
+      const text = projectCompareReplayCurrentText(control2?.contentXml ?? xml);
+      return text === null ? null : { xml, control: control2, text };
+    });
+    if (targets.some((item) => item === null))
+      return false;
+    const nextText = targets.map((item) => item.text).join("");
+    const operations = getWordChanges(oldText, nextText);
+    const mapOffset = (offset) => {
+      let oldCursor3 = 0, nextCursor3 = 0;
+      for (const op of operations) {
+        const start = op.type === "insert" ? op.insertAt : op.oldFrom;
+        const equalEnd = nextCursor3 + start - oldCursor3;
+        if (offset < equalEnd)
+          return oldCursor3 + offset - nextCursor3;
+        const oldEnd = op.type === "insert" ? start : op.oldTo;
+        const nextEnd = equalEnd + (op.type === "delete" ? 0 : op.newText.length);
+        if (offset < nextEnd)
+          return start;
+        oldCursor3 = oldEnd;
+        nextCursor3 = nextEnd;
+      }
+      return oldCursor3 + offset - nextCursor3;
+    };
+    let oldCursor2 = 0, nextCursor2 = 0;
+    let ordinaryTarget = "";
+    const appendOrdinary = (end) => {
+      pieces.push({
+        beforeXml: renderCompareRunRange(tokens, oldCursor2, end, "passthrough"),
+        afterXml: ordinaryTarget,
+        ordinary: true
+      });
+      ordinaryTarget = "";
+      oldCursor2 = end;
+    };
+    for (const target of targets) {
+      if (!target)
+        return false;
+      if (!target.control) {
+        ordinaryTarget += target.xml;
+        nextCursor2 += target.text.length;
+        continue;
+      }
+      const start = mapOffset(nextCursor2), end = mapOffset(nextCursor2 + target.text.length);
+      if (start < oldCursor2 || end < start || end > oldText.length)
+        return false;
+      appendOrdinary(start);
+      const selected = renderCompareRunRange(tokens, start, end, "passthrough");
+      if (equivalentSimpleRunContent(selected, target.control.contentXml)) {
+        pieces.push({ beforeXml: target.control.contentXml, afterXml: target.xml });
+      } else {
+        pieces.push({ beforeXml: selected, afterXml: "", ordinary: true });
+        pieces.push({ beforeXml: "", afterXml: target.xml });
+      }
+      oldCursor2 = end;
+      nextCursor2 += target.text.length;
+    }
+    appendOrdinary(oldText.length);
+    return true;
+  };
+  let oldCursor = 0, nextCursor = 0;
+  for (const anchor of proof.anchors) {
+    if (!gap(proof.beforeRoots.slice(oldCursor, anchor.beforeIndex).join(""), proof.afterRoots.slice(nextCursor, anchor.afterIndex), nextCursor))
+      return null;
+    if (anchor.changed) {
+      pieces.push({ beforeXml: anchor.before.xml, afterXml: anchor.after.xml });
+    } else
+      pieces.push({ beforeXml: anchor.before.xml, afterXml: anchor.before.xml });
+    oldCursor = anchor.beforeIndex + 1;
+    nextCursor = anchor.afterIndex + 1;
+  }
+  if (!gap(proof.beforeRoots.slice(oldCursor).join(""), proof.afterRoots.slice(nextCursor), nextCursor))
+    return null;
+  return pieces;
+}
+function inspectInlineControlCompareBodyReplay(bytes, startByte, endByte, targetRunXml) {
+  const xml = TD60.decode(bytes);
+  const start = TD60.decode(bytes.subarray(0, startByte)).length;
+  const end = start + TD60.decode(bytes.subarray(startByte, endByte)).length;
+  const parsed = collectXmlElementRanges(xml);
+  if (parsed.errors.length)
+    return null;
+  const body = parsed.ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "body");
+  if (!body || !directXmlChildRanges(parsed.ranges, body).some((range) => range.start === start && range.end === end && range.tag.namespaceUri === NS_W && range.tag.localName === "p"))
+    return null;
+  const proof = inspectInlineControlReplay(extractCompareParagraphRunXml(xml.slice(start, end)), targetRunXml, textboxNamespaceBindingsFromPartBytes(bytes));
+  if (!proof)
+    return null;
+  const counts = new Map;
+  for (const range of parsed.ranges) {
+    if (range.tag.namespaceUri !== NS_W || range.tag.localName !== "sdtPr")
+      continue;
+    for (const id of directXmlChildRanges(parsed.ranges, range).filter((child) => child.tag.namespaceUri === NS_W && child.tag.localName === "id")) {
+      const raw = readXmlAttribute(id.tag, NS_W, "val")?.value;
+      if (raw !== undefined && /^-?\d+$/.test(raw) && Number.isSafeInteger(Number(raw))) {
+        const key2 = String(Number(raw));
+        counts.set(key2, (counts.get(key2) ?? 0) + 1);
+      }
+    }
+  }
+  if (proof.anchors.some((anchor) => counts.get(anchor.before.id) !== 1) || proof.inserted.some((control2) => counts.has(control2.id)))
+    return null;
+  return proof;
+}
+function directlyOwnedBodyParagraph(bytes, startByte, endByte) {
+  const xml = TD60.decode(bytes);
+  const start = TD60.decode(bytes.subarray(0, startByte)).length;
+  const end = start + TD60.decode(bytes.subarray(startByte, endByte)).length;
+  const parsed = collectXmlElementRanges(xml);
+  const body = parsed.ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "body");
+  return !parsed.errors.length && !!body && directXmlChildRanges(parsed.ranges, body).some((range) => range.start === start && range.end === end && range.tag.namespaceUri === NS_W && range.tag.localName === "p");
+}
 function runInlineControlRemovalCommit(input, storyId, step2, changeMode, options, pushHistory) {
   const { state, txId } = input;
   const partUri = storyPartUriFromStoryId2(storyId);
@@ -225106,7 +225492,10 @@ function runInlineControlRemovalCommit(input, storyId, step2, changeMode, option
   const before = extractCompareParagraphRunXml(paragraph);
   const namespaces = textboxNamespaceBindingsFromPartBytes(bytes);
   const proof = inspectInlineControlRemoval(before, step2.targetRunXml, namespaces);
-  if (!proof || /<(?:[\w.-]+:)?\w+Change\b/.test(properties))
+  const replay = inspectInlineControlCompareBodyReplay(bytes, entry.byteStart, entry.byteEnd, step2.targetRunXml);
+  if (replay && !/^[0-9A-Fa-f]{8}$/.test(step2.blockId))
+    return rejected14(txId, "unsupported-context");
+  if (!proof && !replay || !directlyOwnedBodyParagraph(bytes, entry.byteStart, entry.byteEnd) || /<(?:[\w.-]+:)?\w+Change\b/.test(properties))
     return rejected14(txId, "unsupported-context");
   const targetProperties = step2.targetParagraphPropertiesXml === undefined ? properties : rewriteCanonicalWordprocessingPrefix(step2.targetParagraphPropertiesXml, wrapper.wordprocessingPrefix);
   if (!equivalentParagraphProperties(properties, targetProperties))
@@ -225119,7 +225508,9 @@ function runInlineControlRemovalCommit(input, storyId, step2, changeMode, option
       return rejected14(txId, "no-author-configured");
     const namespaceBindings = new Map(Object.entries(namespaces));
     namespaceBindings.set(wrapper.wordprocessingPrefix, W_NS4);
-    const pieces = [];
+    const pieces = replay ? inlineComparePieces(replay) ?? [] : [];
+    if (replay && !pieces.length)
+      return rejected14(txId, "unsupported-context");
     const appendGap = (old, next) => {
       let head = 0;
       while (head < old.length && head < next.length && old[head] === next[head])
@@ -225136,7 +225527,7 @@ function runInlineControlRemovalCommit(input, storyId, step2, changeMode, option
     };
     let oldCursor = 0;
     let nextCursor = 0;
-    for (let index = 0;index < proof.afterRoots.length; index++) {
+    for (let index = 0;proof && !replay && index < proof.afterRoots.length; index++) {
       const root = proof.afterRoots[index];
       if (!/<(?:[\w.-]+:)?sdt\b/.test(root))
         continue;
@@ -225148,12 +225539,33 @@ function runInlineControlRemovalCommit(input, storyId, step2, changeMode, option
       oldCursor = oldIndex + 1;
       nextCursor = index + 1;
     }
-    appendGap(proof.beforeRoots.slice(oldCursor), proof.afterRoots.slice(nextCursor));
+    if (proof && !replay)
+      appendGap(proof.beforeRoots.slice(oldCursor), proof.afterRoots.slice(nextCursor));
     const stamp = { revisionId: 0, author: serializedSessionAuthor(sourceAuthor), date: input.txTimestamp };
     const prepare = (revisionIds) => {
       let xml = "";
       const wordIds = [];
       for (const piece of pieces) {
+        if (piece.beforeXml === piece.afterXml) {
+          xml += piece.beforeXml;
+          continue;
+        }
+        if (piece.ordinary && !/<(?:[\w.-]+:)?sdt\b/.test(piece.beforeXml + piece.afterXml)) {
+          const result2 = renderWordLevelTrackedRunSegment(piece.beforeXml, piece.afterXml, () => {
+            const delId = revisionIds?.[wordIds.length] ?? wordIds.length;
+            wordIds.push(String(delId));
+            const insId = revisionIds?.[wordIds.length] ?? wordIds.length;
+            wordIds.push(String(insId));
+            return {
+              del: { rsid: delId.toString(16).padStart(8, "0"), wId: delId, author: stamp.author, date: stamp.date },
+              ins: { rsid: delId.toString(16).padStart(8, "0"), wId: insId, author: stamp.author, date: stamp.date }
+            };
+          }, wrapper.wordprocessingPrefix);
+          if (result2) {
+            xml += result2.xml;
+            continue;
+          }
+        }
         const result = prepareTrackedSdtXmlReplacement({
           beforeXml: piece.beforeXml,
           afterXml: piece.afterXml,
@@ -236511,7 +236923,7 @@ function resolveFragmentApplyTarget(state, op) {
       const index2 = paragraphIndexForPasteStory(state, target.storyId);
       if (!index2)
         return { ok: false, reason: "unsupported-context" };
-      const structuralFailure = validateRangeCollapseStructure(bytes, index2.entries, anchor.entry, anchor.entry, op.changeMode ?? "direct", undefined, undefined, { allowWholeParagraphReplacement: true });
+      const structuralFailure = validateRangeCollapseStructure(bytes, index2.entries, anchor.entry, anchor.entry, op.changeMode ?? "direct", undefined, undefined, { allowWholeParagraphReplacement: true, inlineRange: { startOffset: 0, endOffset: anchor.entry.textLength, deleteFullBlocks: true } });
       if (structuralFailure)
         return { ok: false, reason: structuralFailure };
       const integrityFailure = validateFragmentRangeIntegrity({
@@ -236587,7 +236999,7 @@ function resolveFragmentApplyTarget(state, op) {
   const crossParagraph = startAnchor.ordinal !== endAnchor.ordinal;
   const replacesContent = crossParagraph || target.charOffset !== explicitEnd.charOffset;
   if (crossParagraph) {
-    const structuralFailure = validateRangeCollapseStructure(residentBytes, index.entries, startAnchor.entry, endAnchor.entry, op.changeMode ?? "direct", target.collapsedObjectBoundary, explicitEnd.objectBoundary, { allowTrackedSdtContent: true });
+    const structuralFailure = validateRangeCollapseStructure(residentBytes, index.entries, startAnchor.entry, endAnchor.entry, op.changeMode ?? "direct", target.collapsedObjectBoundary, explicitEnd.objectBoundary, { allowTrackedSdtContent: true, inlineRange: { startOffset: target.charOffset, endOffset: explicitEnd.charOffset } });
     if (structuralFailure)
       return { ok: false, reason: structuralFailure };
   } else if (replacesContent && residentBytes) {
@@ -255970,6 +256382,7 @@ var init_sd_document_session_internal = __esm(() => {
   init_section_property_references();
   init_bibliography_style();
   init_bibliography_review_resources();
+  init_compile_compare_apply();
 });
 
 // ../../../v2/document-api-v2-adapter/dist/address/story-identity.js
@@ -437273,8 +437686,8 @@ function applyPreflightedTrackedTextDecisionsToStory(input) {
       tx.meta.set(ACTOR_ATTRIBUTION_META_KEY, input.actorType);
       scope.meta.set(STORY_META_KEY.lastEditActorType, input.actorType);
       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");
+      for (const { span, block } of work) {
+        removeTrackedTextCarriers(block, span, decision === "reject" && span.trackedKind === "ins");
         removeCommentCarriersByIds(block, removedCommentCarrierIds);
       }
       const sorted = [...work].sort((left, right) => {
@@ -437291,12 +437704,12 @@ function applyPreflightedTrackedTextDecisionsToStory(input) {
         if (span.trackedKind === "ins" && decision === "reject") {
           const length3 = span.endOffset - span.startOffset;
           if (length3 > 0) {
-            deleteText2({
-              doc: doc2,
-              blockId: span.blockId,
+            deleteTextAtResolvedTarget({
+              target: resolveStoryTextMutationTarget(doc2, span.blockId),
               offset: span.startOffset,
               length: length3,
-              origin: STORY_SURFACE_BACKEND_ORIGIN
+              origin: STORY_SURFACE_BACKEND_ORIGIN,
+              preserveZeroLengthAtStart: true
             });
           }
         }
@@ -437664,8 +438077,19 @@ function validateCompareApplySessionSync(prepared, extension2, options) {
   if (!extension2.storyLocal || prepared.resolvedTargets.stories.length !== 1 || String(prepared.resolvedTargets.stories[0]) !== storyId || ownership.length !== 1 || String(ownership[0]?.storyId) !== storyId || prepared.resolvedTargets.partUris.length !== 1 || String(prepared.resolvedTargets.partUris[0]) !== String(ownership[0]?.partUri)) {
     return { ok: false, message: "compareApply collaboration requires one owned story part" };
   }
-  if (source.bodySteps.length === 0 || source.bodySteps.some((step3) => step3.kind !== "edit") || source.storyGroups?.length || source.storyPackageOperations?.length || source.commentSteps?.length || source.packageRewrites?.length || source.relationshipBackedBodyRewrites?.length || source.headerFooterLifecycle || source.headerFooterSlotSteps?.length || source.tableTopologySteps?.length || source.tableBlockSteps?.length || source.tablePropertySteps?.length || source.sectionReplaySteps?.length || source.referenceReplaySteps?.length) {
-    return { ok: false, message: "compareApply collaboration supports paragraph text edits only" };
+  if (source.bodySteps.length === 0 || source.bodySteps.some((step3) => {
+    if (step3.kind === "edit")
+      return false;
+    if (step3.kind !== "formatEdit" || step3.targetRunXml === undefined)
+      return true;
+    if (extension2.historyReplay)
+      return false;
+    const bytes = getSDDocumentSessionInternalPartBytes(options.session, String(ownership[0].partUri));
+    const entry = getSDDocumentSessionInternalStoryParagraphIndex(options.session, source.storyId)?.byParaId(step3.blockId);
+    const proof = bytes && entry && inspectInlineControlCompareBodyReplay(bytes, entry.byteStart, entry.byteEnd, step3.targetRunXml);
+    return !proof || proof.inserted.length === 0;
+  }) || source.storyGroups?.length || source.storyPackageOperations?.length || source.commentSteps?.length || source.packageRewrites?.length || source.relationshipBackedBodyRewrites?.length || source.headerFooterLifecycle || source.headerFooterSlotSteps?.length || source.tableTopologySteps?.length || source.tableBlockSteps?.length || source.tablePropertySteps?.length || source.sectionReplaySteps?.length || source.referenceReplaySteps?.length) {
+    return { ok: false, message: "compareApply collaboration supports paragraph text edits and proved inline control wrapping only" };
   }
   const targetBlockIds2 = [...new Set(source.bodySteps.map((step3) => step3.blockId))];
   if (targetBlockIds2.length !== extension2.targetBlockIds.length || targetBlockIds2.some((blockId) => !extension2.targetBlockIds.includes(blockId))) {
@@ -438977,6 +439401,7 @@ function atomOverlapsRange(atomOffset, atomLength, rangeStart, rangeEnd) {
 var STORY_SURFACE_TRACE, TRACKED_CHANGE_DECISIONS_LEDGER_KEY = "trackedChangeDecisions", CLEARED_RUN_ATTRIBUTES;
 var init_story_surface_execution_backend = __esm(() => {
   init_yjs();
+  init_sd_document_session_internal();
   init_scope3();
   init_content_control_groups();
   init_story_surface_session_sync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.4.0-next.8",
+  "version": "1.4.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.17.0-next.8",
+    "@superdoc/sdk": "2.17.0-next.9",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.20.0-next.10",
-    "@superdoc/docx-engine": "0.19.0-next.11",
+    "superdoc": "2.20.0-next.11",
+    "@superdoc/docx-engine": "0.19.0-next.12",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",