@superdoc/mcp 1.7.0-next.11 → 1.7.0-next.13

package/dist/index.js

@@ -31600,7 +31600,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.20.0-next.11";
+var SDK_VERSION = "2.20.0-next.13";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -167575,6 +167575,130 @@ function extractNamespaceClosedParagraphMarkRunPropertiesFromParagraph(paragraph
     return null;
   return namespaceClosedOpenTag + runPropertiesXml.slice(runPropertiesNode.openEnd);
 }
+function namespaceCloseParagraphPropertiesForRelocation(paragraphPropertiesXml, paragraphXml, inheritedNamespaceBindings, ancestorOpenTags = []) {
+  const paragraph = readValidatedXmlNodeAt(paragraphXml, 0);
+  if (!paragraph || paragraph.kind !== "element" || xmlLocalName(paragraph.qname) !== "p" || paragraph.selfClosing || paragraphXml.slice(paragraph.end).trim())
+    return null;
+  const paragraphOpenTag = paragraphXml.slice(0, paragraph.openEnd);
+  const ancestorPolicySources = readAncestorPolicySources(ancestorOpenTags);
+  if (ancestorPolicySources == null)
+    return null;
+  const { pPr } = splitLeadingParagraphPropertyBlock(paragraphXml.slice(paragraph.openEnd, paragraph.closeStart));
+  const sourcePropertiesStart = pPr.search(/<(?:[\w.-]+:)?pPr\b/);
+  const sourceProperties = sourcePropertiesStart >= 0 ? readValidatedXmlNodeAt(pPr, sourcePropertiesStart) : null;
+  if (sourceProperties && (sourceProperties.kind !== "element" || xmlLocalName(sourceProperties.qname) !== "pPr"))
+    return null;
+  const sourcePropertiesOpenTag = sourceProperties ? pPr.slice(sourcePropertiesStart, sourceProperties.openEnd) : "";
+  const paragraphDeclarations = readLocalNamespaceDeclarations(paragraphOpenTag);
+  if (paragraphDeclarations == null)
+    return null;
+  const sourceBindings = { ...inheritedNamespaceBindings };
+  for (const declaration of paragraphDeclarations)
+    sourceBindings[declaration.prefix] = declaration.namespaceUri;
+  const paragraphBindings = { ...sourceBindings };
+  const sourcePropertiesDeclarations = readLocalNamespaceDeclarations(sourcePropertiesOpenTag);
+  if (sourcePropertiesDeclarations == null)
+    return null;
+  for (const declaration of sourcePropertiesDeclarations)
+    sourceBindings[declaration.prefix] = declaration.namespaceUri;
+  return closePropertyFragmentWithCompatibilityPolicy(paragraphPropertiesXml, "pPr", sourceBindings, [
+    ...ancestorPolicySources,
+    [paragraphOpenTag, paragraphBindings],
+    [sourcePropertiesOpenTag, sourceBindings]
+  ]);
+}
+function namespaceCloseRunPropertiesWithAncestorPolicy(runPropertiesXml, paragraphOpenTag, inheritedNamespaceBindings, ancestorOpenTags) {
+  if (!runPropertiesXml)
+    return "";
+  const ancestorPolicySources = readAncestorPolicySources(ancestorOpenTags);
+  const declarations = readLocalNamespaceDeclarations(paragraphOpenTag);
+  if (ancestorPolicySources == null || declarations == null)
+    return null;
+  const bindings = { ...inheritedNamespaceBindings };
+  for (const declaration of declarations)
+    bindings[declaration.prefix] = declaration.namespaceUri;
+  return closePropertyFragmentWithCompatibilityPolicy(runPropertiesXml, "rPr", bindings, [
+    ...ancestorPolicySources,
+    [paragraphOpenTag, bindings]
+  ]);
+}
+function readAncestorPolicySources(ancestorOpenTags) {
+  const sources = [];
+  const bindings = {};
+  for (const openTag of ancestorOpenTags) {
+    const declarations = readLocalNamespaceDeclarations(openTag);
+    if (declarations == null)
+      return null;
+    for (const declaration of declarations)
+      bindings[declaration.prefix] = declaration.namespaceUri;
+    sources.push([openTag, { ...bindings }]);
+  }
+  return sources;
+}
+function closePropertyFragmentWithCompatibilityPolicy(propertiesXml, propertyName, inheritedNamespaceBindings, policySources) {
+  const node2 = readValidatedXmlNodeAt(propertiesXml, 0);
+  if (!node2 || node2.kind !== "element" || xmlLocalName(node2.qname) !== propertyName || node2.end !== propertiesXml.length)
+    return null;
+  let openTag = propertiesXml.slice(0, node2.openEnd);
+  const localDeclarations = readLocalNamespaceDeclarations(openTag);
+  if (localDeclarations == null)
+    return null;
+  const bindings = { ...inheritedNamespaceBindings };
+  for (const declaration of localDeclarations)
+    bindings[declaration.prefix] = declaration.namespaceUri;
+  const prefix = parseRawXmlElementTag(openTag)?.prefix;
+  if (prefix == null)
+    return null;
+  if (bindings[prefix] == null)
+    bindings[prefix] = NS_W;
+  if (bindings[prefix] !== NS_W)
+    return null;
+  for (const [sourceOpenTag, policyBindings] of policySources) {
+    const policyPrefixes = markupCompatibilityValuePrefixes(sourceOpenTag, new Map(Object.entries(policyBindings)));
+    if (policyPrefixes == null || [...policyPrefixes].some((key2) => policyBindings[key2] !== bindings[key2]))
+      return null;
+    for (const attribute of scanRawXmlAttributes(sourceOpenTag)) {
+      if (policyBindings[attribute.prefix] !== NS_MC)
+        continue;
+      if (bindings[attribute.prefix] !== NS_MC)
+        return null;
+      const existing = [...scanRawXmlAttributes(openTag)].find((candidate) => bindings[candidate.prefix] === NS_MC && candidate.localName === attribute.localName);
+      if (existing) {
+        const currentValue = decodeXmlText(existing.value);
+        const sourceValue = decodeXmlText(attribute.value);
+        if (currentValue !== sourceValue) {
+          if (!INHERITED_MC_LIST_ATTRIBUTES.has(attribute.localName))
+            return null;
+          const tokens = [...new Set([...currentValue.split(/\s+/), ...sourceValue.split(/\s+/)].filter(Boolean))];
+          openTag = openTag.slice(0, existing.valueStart) + escapeXmlAttribute(tokens.join(" ")) + openTag.slice(existing.valueEnd);
+        }
+      } else {
+        const sourceXml = sourceOpenTag.slice(attribute.sourceStart, attribute.sourceEnd);
+        openTag = openTag.replace(/\s*(\/?)>$/, (_match, slash) => ` ${sourceXml.trim()}${slash}>`);
+      }
+    }
+  }
+  const fragment3 = openTag + propertiesXml.slice(node2.openEnd);
+  const required2 = namespacePrefixesRequiredByFragment(fragment3);
+  const compatibilityPrefixes = markupCompatibilityValuePrefixes(openTag, new Map(Object.entries(bindings)));
+  if (required2 == null || compatibilityPrefixes == null)
+    return null;
+  const declarations = [];
+  for (const requiredPrefix of new Set([...required2, ...compatibilityPrefixes])) {
+    if (requiredPrefix === "xml")
+      continue;
+    const namespaceUri = bindings[requiredPrefix];
+    if (!namespaceUri || namespaceUri.startsWith("urn:superdoc:unresolved-namespace-prefix:"))
+      return null;
+    declarations.push({
+      prefix: requiredPrefix,
+      namespaceUri,
+      sourceXml: requiredPrefix ? ` xmlns:${requiredPrefix}="${escapeXmlAttribute(namespaceUri)}"` : ` xmlns="${escapeXmlAttribute(namespaceUri)}"`
+    });
+  }
+  const closed = addNamespaceDeclarations(openTag, declarations);
+  return closed == null ? null : closed + propertiesXml.slice(node2.openEnd);
+}
 function namespaceCloseRunPropertiesForRelocation(runPropertiesXml, namespaceSourceOpenTag, inheritedNamespaceBindings = {}) {
   const runPropertiesNode = readValidatedXmlNodeAt(runPropertiesXml, 0);
   if (!runPropertiesNode || runPropertiesNode.kind !== "element" || runPropertiesNode.selfClosing || xmlLocalName(runPropertiesNode.qname) !== "rPr" || runPropertiesNode.end !== runPropertiesXml.length) {
@@ -168117,11 +168241,12 @@ function addNamespaceDeclarations(openTag, sourceNamespaces, inheritedNamespaceB
   }
   return additions.length > 0 ? openTag.replace(/\s*(\/?)>$/, (_match, selfClosing) => `${additions}${selfClosing}>`) : openTag;
 }
-var PARAGRAPH_MARK_REVISION_CHILDREN;
+var PARAGRAPH_MARK_REVISION_CHILDREN, INHERITED_MC_LIST_ATTRIBUTES;
 var init_paragraph_property_block = __esm(() => {
   init_xml_text();
   init_xml_sax();
   PARAGRAPH_MARK_REVISION_CHILDREN = new Set(["ins", "del", "moveFrom", "moveTo", "rPrChange"]);
+  INHERITED_MC_LIST_ATTRIBUTES = new Set(["Ignorable", "PreserveAttributes", "PreserveElements", "ProcessContent"]);
 });
 
 // ../../../v2/editor-core/dist/document/transactions/collapsed-inline-insertion-site.js
@@ -188004,11 +188129,18 @@ var init_part_wml_scan_cache = __esm(() => {
 
 // ../../../v2/editor-core/dist/document/transactions/paragraph-para-id-attrs.js
 function namespaceBindingsAtPosition(bytes, byteOffset, localOpenTag = "") {
+  return namespaceContextAtPosition(bytes, byteOffset, localOpenTag).bindings;
+}
+function namespaceContextAtPosition(bytes, byteOffset, localOpenTag = "") {
+  const scopes = readNamespaceScopesBeforeByte(bytes, byteOffset);
   const bindings = {
-    ...readNamespacesBeforeByte(bytes, byteOffset),
+    ...scopes.reduce((acc, frame) => ({ ...acc, ...frame.namespaces }), {}),
     ...readNamespaceDeclarations2(localOpenTag)
   };
-  return Object.fromEntries(Object.entries(bindings).filter((entry) => entry[1] != null));
+  return {
+    bindings: Object.fromEntries(Object.entries(bindings).filter((entry) => entry[1] != null)),
+    ancestorOpenTags: scopes.map((frame) => frame.openTag)
+  };
 }
 function matchParagraphOpenTag(paragraphXml) {
   return paragraphXml.match(PARAGRAPH_OPEN_TAG_RE2)?.[0] ?? null;
@@ -188036,6 +188168,9 @@ function readPartRootNamespaces(bytes) {
   return readNamespaceDeclarations2(rootOpenTag);
 }
 function readNamespacesBeforeByte(bytes, byteOffset) {
+  return readNamespaceScopesBeforeByte(bytes, byteOffset).reduce((acc, frame) => ({ ...acc, ...frame.namespaces }), {});
+}
+function readNamespaceScopesBeforeByte(bytes, byteOffset) {
   ancestorNamespacePrefixScanCount += 1;
   const prefix = stripXmlCommentsAndCdata(TD33.decode(bytes.subarray(0, Math.max(0, byteOffset))));
   const stack = [];
@@ -188058,9 +188193,9 @@ function readNamespacesBeforeByte(bytes, byteOffset) {
     const namespaces = readNamespaceDeclarations2(match[0]);
     if (/\/\s*>$/.test(match[0]))
       continue;
-    stack.push({ name, namespaces });
+    stack.push({ name, namespaces, openTag: match[0] });
   }
-  return stack.reduce((acc, frame) => ({ ...acc, ...frame.namespaces }), {});
+  return stack;
 }
 function stripXmlCommentsAndCdata(xml) {
   let result = "";
@@ -219349,7 +219484,7 @@ function resolveInsertionFormattingContext(state, input) {
   const style = resolveInsertionStyle(state, paragraphXml, input.anchor, input.styleRef, inheritance, input.fallbackToDocumentDefaultStyle ?? false);
   if (!style.ok)
     return style;
-  const direct = inheritance === "anchor" && paragraphXml != null ? resolveDirectInsertionFormatting(paragraphXml, input.anchor.placement, readAnchorNamespaceBindings(state, input.anchor.entry)) : {
+  const direct = inheritance === "anchor" && paragraphXml != null ? resolveDirectInsertionFormatting(paragraphXml, input.anchor.placement, readAnchorNamespaceBindings(state, input.anchor.entry), input.includeRunProperties ?? true) : {
     paragraphPropertiesXml: null,
     paragraphMarkRunPropertiesXml: null,
     runPropertiesXml: null,
@@ -219512,10 +219647,10 @@ function lookupNextStyle(state, styleId) {
 function readWordAttribute2(tag, namespaceUri, localName2) {
   return readXmlAttribute(tag, namespaceUri, localName2)?.value;
 }
-function resolveDirectInsertionFormatting(paragraphXml, placement2, inheritedNamespaceBindings = {}) {
+function resolveDirectInsertionFormatting(paragraphXml, placement2, inheritedNamespaceBindings = {}, includeRunProperties = true) {
   const paragraphPropertiesXml = cloneDirectParagraphPropertiesForInsert(paragraphXml);
   const paragraphMarkRunPropertiesXml = cloneParagraphMarkRunPropertiesForInsert(paragraphXml);
-  const adjacentRunProperties = cloneAdjacentRunPropertiesForInsert(paragraphXml, placement2, paragraphMarkRunPropertiesXml, inheritedNamespaceBindings);
+  const adjacentRunProperties = includeRunProperties ? cloneAdjacentRunPropertiesForInsert(paragraphXml, placement2, paragraphMarkRunPropertiesXml, inheritedNamespaceBindings) : { ok: true, runPropertiesXml: null };
   if (!adjacentRunProperties.ok)
     return adjacentRunProperties;
   const runPropertiesXml = adjacentRunProperties.runPropertiesXml;
@@ -241424,31 +241559,32 @@ var init_compile_paste_lists = __esm(() => {
 });
 
 // ../../../v2/editor-core/dist/document/transactions/match-destination-paste.js
-function normalizeMatchDestinationBlocks(blocks) {
-  return blocks.map((block) => {
-    if (block.kind !== "paragraph")
-      return block;
-    return {
-      kind: "paragraph",
-      runs: block.runs.map((run) => ({ text: run.text, ...run.sourcePath ? { sourcePath: run.sourcePath } : {} })),
-      ...block.sourcePath ? { sourcePath: block.sourcePath } : {},
-      ...block.inlines ? {
-        inlines: block.inlines.map((inline) => inline.kind === "text" ? {
-          kind: "text",
-          text: inline.text,
-          ...inline.sourcePath ? { sourcePath: inline.sourcePath } : {}
-        } : inline.kind === "hyperlink" ? {
-          ...inline,
-          inlines: inline.inlines.map((child) => child.kind === "text" ? {
-            kind: "text",
-            text: child.text,
-            ...child.sourcePath ? { sourcePath: child.sourcePath } : {}
-          } : child)
-        } : inline)
-      } : {}
-    };
-  });
+function normalizeMatchDestinationBlocks(blocks, destinationTableParagraphPropertiesXml) {
+  return blocks.map((block) => block.kind === "table" ? mapPasteTableParagraphs(block, (paragraph) => ({
+    ...normalizeMatchDestinationParagraph(paragraph),
+    ...destinationTableParagraphPropertiesXml ? { pPrXml: destinationTableParagraphPropertiesXml, complete: true } : {}
+  })) : block.kind === "paragraph" ? normalizeMatchDestinationParagraph(block) : block);
 }
+function normalizeMatchDestinationParagraph(block) {
+  return {
+    kind: "paragraph",
+    runs: block.runs.map(withoutSourceMarks),
+    ...block.sourcePath ? { sourcePath: block.sourcePath } : {},
+    ...block.inlines ? {
+      inlines: block.inlines.map((inline) => inline.kind === "text" ? withoutSourceMarks(inline) : inline.kind === "hyperlink" ? {
+        ...inline,
+        inlines: inline.inlines.map((child) => child.kind === "text" ? withoutSourceMarks(child) : child)
+      } : inline)
+    } : {}
+  };
+}
+function withoutSourceMarks(run) {
+  const { marks: _sourceMarks, ...retained } = run;
+  return retained;
+}
+var init_match_destination_paste = __esm(() => {
+  init_paste_blocks();
+});
 
 // ../../../v2/editor-core/dist/document/transactions/image-catalog.js
 function buildImageCatalog(input) {
@@ -243932,7 +244068,32 @@ function preparePasteFragmentMutation(input) {
   if (!isMaterializablePasteBlocks(blocks)) {
     return rejected18(txId, "paste-structure-unsupported");
   }
-  const normalizedBlocks = isTextTarget2(pasteTarget) && op.formattingMode === "match-destination" ? normalizeMatchDestinationBlocks(blocks) : blocks;
+  let destinationTableParagraphPropertiesXml = null;
+  if (isTextTarget2(pasteTarget) && op.formattingMode === "match-destination" && blocks.some((block) => block.kind === "table")) {
+    const anchor = resolveParagraph3(state, pasteTarget.storyId, pasteTarget.paraId);
+    if (!anchor)
+      return rejected18(txId, "paste-target-unsupported");
+    const destination = resolveInsertionFormattingContext(state, {
+      anchor: { entry: anchor.entry, placement: "before" },
+      includeRunProperties: false
+    });
+    if (!destination.ok)
+      return rejected18(txId, destination.reason);
+    if (destination.context.paragraphPropertiesXml) {
+      const bytes = state.packageBytes.get(anchor.partUri);
+      if (!bytes)
+        return rejected18(txId, "paste-target-unsupported");
+      const paragraphXml = TD70.decode(bytes.subarray(anchor.byteStart, anchor.byteEnd));
+      const openTag = matchParagraphOpenTag(paragraphXml);
+      if (!openTag)
+        return rejected18(txId, "paste-target-unsupported");
+      const namespaceContext = namespaceContextAtPosition(bytes, anchor.byteStart, openTag);
+      destinationTableParagraphPropertiesXml = namespaceCloseParagraphPropertiesForRelocation(destination.context.paragraphPropertiesXml, paragraphXml, namespaceContext.bindings, namespaceContext.ancestorOpenTags);
+      if (destinationTableParagraphPropertiesXml == null)
+        return rejected18(txId, "paste-structure-unsupported");
+    }
+  }
+  const normalizedBlocks = isTextTarget2(pasteTarget) && op.formattingMode === "match-destination" ? normalizeMatchDestinationBlocks(blocks, destinationTableParagraphPropertiesXml) : blocks;
   const imageValidation = validateImageFragment(op.fragment);
   if (!imageValidation.ok)
     return rejected18(txId, imageValidation.reason);
@@ -244032,7 +244193,13 @@ function preparePasteFragmentMutation(input) {
         if (!anchor || !bytes)
           return rejected18(txId, "paste-target-unsupported");
         const anchorXml = TD70.decode(bytes.subarray(anchor.byteStart, anchor.byteEnd));
-        const destination = resolveCaretRunPropertiesForInsertion(anchorXml, target.start.charOffset, namespaceBindingsAtPosition(bytes, anchor.byteStart, matchParagraphOpenTag(anchorXml) ?? ""), anchor.entry.textLength);
+        const destination = resolveDestinationPasteRunProperties({
+          paragraphXml: anchorXml,
+          charOffset: target.start.charOffset,
+          partBytes: bytes,
+          paragraphStartByte: anchor.byteStart,
+          replaceToOffset: anchor.entry.textLength
+        });
         if (!destination.ok)
           return rejected18(txId, destination.reason);
         imageExtras.value = {
@@ -244945,6 +245112,24 @@ function tryRunTableRowPasteCommit(input, pasteTarget, pastedBlocks, additionalP
   const targetTableLocation = findContainingTableCell(tableCatalog, targetParagraph);
   if (!targetTableLocation)
     return null;
+  if (input.op.formattingMode === "match-destination" && storyPartBytes) {
+    const paragraphXml = TD70.decode(storyPartBytes.subarray(targetParagraph.byteStart, targetParagraph.byteEnd));
+    const destination = resolveDestinationPasteRunProperties({
+      paragraphXml,
+      charOffset: pasteTarget.charOffset,
+      partBytes: storyPartBytes,
+      paragraphStartByte: targetParagraph.byteStart,
+      replaceToOffset: pasteTarget.replaceToOffset,
+      collapsedInlineAffinity: pasteTarget.collapsedInlineAffinity,
+      collapsedObjectBoundary: pasteTarget.collapsedObjectBoundary
+    });
+    if (!destination.ok)
+      return rejected18(transactionId, destination.reason);
+    pastedImageExtras = {
+      ...pastedImageExtras,
+      inlineSpecs: inheritDestinationInlineSpecs(pastedImageExtras.inlineSpecs, pastedBlocks, destination.runPropertiesXml ?? "")
+    };
+  }
   if (targetTableLocation.table.hasVMerge) {
     return rejected18(transactionId, "paste-target-unsupported");
   }
@@ -245444,7 +245629,15 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
   const anchorXml = TD70.decode(bytes.subarray(paragraphStartByte, paragraphEndByte));
   let inlineSpecs = imageExtras.inlineSpecs;
   if (input.op.formattingMode === "match-destination") {
-    const destination = resolveCaretRunPropertiesForInsertion(anchorXml, target.charOffset, namespaceBindingsAtPosition(bytes, paragraphStartByte, matchParagraphOpenTag(anchorXml) ?? ""), target.replaceToOffset, target.collapsedInlineAffinity, target.collapsedObjectBoundary);
+    const destination = resolveDestinationPasteRunProperties({
+      paragraphXml: anchorXml,
+      charOffset: target.charOffset,
+      partBytes: bytes,
+      paragraphStartByte,
+      replaceToOffset: target.replaceToOffset,
+      collapsedInlineAffinity: target.collapsedInlineAffinity,
+      collapsedObjectBoundary: target.collapsedObjectBoundary
+    });
     if (!destination.ok)
       return rejected18(txId, destination.reason);
     inlineSpecs = inheritDestinationInlineSpecs(inlineSpecs, resolvedBlocks, destination.runPropertiesXml ?? "");
@@ -245610,9 +245803,20 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
     }
   });
 }
+function resolveDestinationPasteRunProperties(input) {
+  const openTag = matchParagraphOpenTag(input.paragraphXml);
+  if (!openTag)
+    return { ok: false, reason: "unsupported-context" };
+  const context = namespaceContextAtPosition(input.partBytes, input.paragraphStartByte, openTag);
+  const destination = resolveCaretRunPropertiesForInsertion(input.paragraphXml, input.charOffset, context.bindings, input.replaceToOffset, input.collapsedInlineAffinity, input.collapsedObjectBoundary);
+  if (!destination.ok)
+    return destination;
+  const runPropertiesXml = namespaceCloseRunPropertiesWithAncestorPolicy(destination.runPropertiesXml ?? "", openTag, context.bindings, context.ancestorOpenTags);
+  return runPropertiesXml == null ? { ok: false, reason: "unsupported-context" } : { ok: true, runPropertiesXml };
+}
 function inheritDestinationInlineSpecs(inlineSpecs, blocks, runPropertiesXml) {
   const inherited = new Map(inlineSpecs);
-  for (const block of blocks) {
+  for (const block of walkPasteBlocks(blocks)) {
     if (block.kind !== "paragraph")
       continue;
     inherited.set(block, (inlineSpecs.get(block) ?? block.runs.map(toPasteTextRunSpec)).map((run) => withDestinationRunProperties(run, runPropertiesXml)));
@@ -246869,8 +247073,10 @@ var init_compile_paste_fragment = __esm(() => {
   init_compile_paste_splice();
   init_compile_paste_lists();
   init_paste_blocks();
+  init_match_destination_paste();
   init_paragraph_para_id_attrs();
   init_insertion_formatting_context();
+  init_paragraph_property_block();
   init_table_catalog();
   init_comments_catalog();
   init_comment_package_profile();
@@ -312270,6 +312476,7 @@ function convertHtmlToFragment(html, options = {}) {
       range: { startOffset: 0, endOffset: html.length }
     }), limits.maxDiagnostics);
   }
+  attachSiblingListsToPreviousItems(tree);
   const treeViolation = inspectTreeLimits(tree, limits);
   if (treeViolation) {
     appendBoundedConversionDiagnostic(diagnostics, htmlDiagnostic({
@@ -312331,6 +312538,34 @@ function convertHtmlToFragment(html, options = {}) {
     diagnostics
   };
 }
+function attachSiblingListsToPreviousItems(parent) {
+  const pending = [parent];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if ("tagName" in current && (current.tagName === "ul" || current.tagName === "ol")) {
+      let previousItem = null;
+      const retained = [];
+      for (const child of current.childNodes) {
+        if (isElement(child) && child.tagName === "li") {
+          previousItem = child;
+          retained.push(child);
+        } else if (previousItem && isElement(child) && (child.tagName === "ul" || child.tagName === "ol")) {
+          previousItem.childNodes.push(child);
+          child.parentNode = previousItem;
+        } else {
+          if (!isText(child) || child.value.trim() !== "")
+            previousItem = null;
+          retained.push(child);
+        }
+      }
+      current.childNodes = retained;
+    }
+    for (const child of current.childNodes) {
+      if (isElement(child))
+        pending.push(child);
+    }
+  }
+}
 function parseErrorDiagnostic(error48) {
   return htmlDiagnostic({
     code: "conversion-malformed-input",
@@ -312708,9 +312943,9 @@ function convertSemanticList(root, context, inherited, path6) {
         level,
         path: canonicalPath,
         ...itemValue !== undefined && itemValue !== null ? { marker: `${itemValue}${definition.text?.endsWith(")") ? ")" : "."}` } : {},
-        content: content.length > 0 ? content : [
+        content: applyListItemParagraphMarkRunProps(content.length > 0 ? content : [
           paragraph2(context, [], undefined, itemPath, context.droppedContentCount === droppedContentStart)
-        ]
+        ], itemContext.runProps)
       });
       for (let nestedIndex = 0;nestedIndex < child.childNodes.length; nestedIndex += 1) {
         const nested = child.childNodes[nestedIndex];
@@ -312778,7 +313013,7 @@ function convertSemanticList(root, context, inherited, path6) {
         level,
         path: canonicalPath,
         ...itemValue !== undefined && itemValue !== null ? { marker: `${itemValue}${definition.text?.endsWith(")") ? ")" : "."}` } : {},
-        content: nestedContent
+        content: applyListItemParagraphMarkRunProps(nestedContent, itemContext.runProps)
       });
     }
     if (nestedItems.length === 0)
@@ -312892,7 +313127,7 @@ function convertWordListGroup(group, context, inherited) {
       level: descriptor.level,
       path: canonicalPath,
       ...exceptionalMarker ? { marker: exceptionalMarker } : {},
-      content: applyWordListParagraphMarkRunProps(itemContent, itemContext.runProps)
+      content: applyListItemParagraphMarkRunProps(itemContent, itemContext.runProps)
     });
     previousLevel = descriptor.level;
   }
@@ -312904,7 +313139,7 @@ function convertWordListGroup(group, context, inherited) {
     list: { levels: [...levels.values()].sort((a, b) => a.level - b.level), items }
   };
 }
-function applyWordListParagraphMarkRunProps(content, runProps) {
+function applyListItemParagraphMarkRunProps(content, runProps) {
   if (Object.keys(runProps).length === 0)
     return content;
   let applied = false;
@@ -326116,22 +326351,50 @@ function comparablePlainTokenVariants(plan, plain) {
   return variants;
 }
 function normalizeRepresentedListMarkers(plan, lines) {
-  const listTexts = plan.blocks.flatMap((block) => block.kind === "paragraph" && block.listIntent ? [comparableText(blockText(block))] : []);
-  if (listTexts.length === 0)
+  const representedTokens = [];
+  const listStarts = new Set;
+  for (const block of plan.blocks) {
+    const tokens = comparableTokens(blockText(block));
+    if (tokens.length > 0 && block.kind === "paragraph" && block.listIntent) {
+      listStarts.add(representedTokens.length);
+    }
+    for (const token of tokens)
+      representedTokens.push(token);
+  }
+  if (listStarts.size === 0)
     return null;
-  let listIndex = 0;
+  let tokenIndex = 0;
+  const matchesNext = (tokens) => tokens.length > 0 && tokens.every((token, index2) => token === representedTokens[tokenIndex + index2]);
   let changed = false;
   const normalized = lines.map((line) => {
-    if (!hasPlainListMarker(line) || listIndex >= listTexts.length)
+    const tokens = comparableTokens(line);
+    if (matchesNext(tokens)) {
+      tokenIndex += tokens.length;
+      return line;
+    }
+    if (!listStarts.has(tokenIndex))
       return line;
-    const withoutMarker = stripPlainListMarker(line);
-    if (comparableText(withoutMarker) !== listTexts[listIndex])
+    const withoutMarker = stripRepresentedListMarker(line);
+    if (withoutMarker === null)
       return line;
-    listIndex += 1;
+    const withoutMarkerTokens = comparableTokens(withoutMarker);
+    if (!matchesNext(withoutMarkerTokens))
+      return line;
+    tokenIndex += withoutMarkerTokens.length;
     changed = true;
     return withoutMarker;
   });
-  return changed && listIndex === listTexts.length ? normalized : null;
+  return changed && tokenIndex === representedTokens.length ? normalized : null;
+}
+function stripRepresentedListMarker(line) {
+  if (hasPlainListMarker(line))
+    return stripPlainListMarker(line);
+  const separator = line.indexOf("\t");
+  if (separator < 1)
+    return null;
+  if (!/^(?:o|[\uE000-\uF8FF])$/u.test(line.slice(0, separator).trim()))
+    return null;
+  return line.slice(separator).replace(/^\t+/u, "");
 }
 function hasPlainListMarker(value2) {
   return PLAIN_LIST_MARKER_PATTERN.test(value2);
@@ -326167,7 +326430,7 @@ function isSubsequence(needles, haystack) {
 var PLAIN_LIST_MARKER_PATTERN;
 var init_html_plain_reconciliation = __esm(() => {
   init_contracts();
-  PLAIN_LIST_MARKER_PATTERN = /^(?:[•◦▪‣⁃●○■*+-]|\d{1,9}[.)]|[A-Za-z][.)]|[ivxlcdmIVXLCDM]{1,8}[.)])(?:[\t ]+)/u;
+  PLAIN_LIST_MARKER_PATTERN = /^(?:[•◦▪‣⁃●○■□▫◻◽*+-]|\d{1,9}[.)]|[A-Za-z][.)]|[ivxlcdmIVXLCDM]{1,8}[.)])(?:[\t ]+)/u;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/clipboard/parse-v1-slice.js
@@ -328302,15 +328565,14 @@ function* serializeSelectionRangeSteps(context, target, includeHtml, options) {
     let numbering = properties.numbering;
     const listState = readListStateForSession(context.session, resolved.storyId, entry.blockId);
     let listKind = listState?.isListItem ? listState.numFmt === "bullet" ? "bullet" : listState.numFmt ? "ordered" : undefined : undefined;
+    const marker = fullyCovered || listKind ? resolveNumberingLevelForMarker({
+      resolverParams: styleModel.resolverParams,
+      numId: listState?.isListItem && listState.numId != null ? Number(listState.numId) : properties.numbering ? Number(properties.numbering.numId) : undefined,
+      ilvl: listState?.isListItem ? listState.ilvl : properties.numbering ? Number(properties.numbering.ilvl) : undefined,
+      paragraphStyleId: properties.styleRef
+    }) : null;
     if (fullyCovered) {
-      const model = copyStyleModel ?? (copyStyleModel = compileCopyStyleModel(context));
-      const marker = resolveNumberingLevelForMarker({
-        resolverParams: model.resolverParams,
-        numId: properties.numbering ? Number(properties.numbering.numId) : undefined,
-        ilvl: properties.numbering ? Number(properties.numbering.ilvl) : undefined,
-        paragraphStyleId: properties.styleRef
-      });
-      if (marker.definition && !marker.definition.suppressed) {
+      if (marker?.definition && !marker.definition.suppressed) {
         numbering = {
           numId: String(marker.definition.numId),
           ilvl: String(marker.definition.ilvl)
@@ -328358,7 +328620,8 @@ function* serializeSelectionRangeSteps(context, target, includeHtml, options) {
           ...cellFormatting
         }
       } : {},
-      ...listKind ? { listKind } : {},
+      ...listKind ? { listKind, listLevel: listState?.isListItem ? listState.ilvl : listLevel ?? 0 } : {},
+      ...listKind && marker?.definition ? { listMarkerStyle: portableListMarkerStyle(marker.definition, styleModel, paragraphXml) } : {},
       ...semanticHeadingLevel != null && semanticHeadingLevel >= 1 && semanticHeadingLevel <= 6 ? { headingLevel: semanticHeadingLevel } : {},
       parts
     });
@@ -329568,14 +329831,14 @@ function paragraphPaintedLength(xml) {
   const map3 = parseParagraphInlineMap(xml);
   return map3.visibleLength + map3.leaves().filter(isVisibleZeroWidthObjectPiece).length;
 }
-function blockInlineHtml(block, assets) {
-  return block.parts.map((part) => renderHtmlPart(part, assets)).join("");
+function blockInlineHtml(block, assets, defaultTextColor) {
+  return block.parts.map((part) => renderHtmlPart(part, assets, defaultTextColor)).join("");
 }
-function renderHtmlPart(part, assets) {
+function renderHtmlPart(part, assets, defaultTextColor) {
   if (part.kind === "break")
     return "<br/>";
   if (part.kind === "run")
-    return renderHtmlRun(part.run);
+    return renderHtmlRun(part.run, defaultTextColor);
   if (part.kind === "image") {
     const asset = assets.get(part.image.assetId);
     if (!asset)
@@ -329584,18 +329847,17 @@ function renderHtmlPart(part, assets) {
     return `<img src="data:${asset.mimeType};base64,${asset.data}" width="${widthPx}" height="${heightPx}"` + (alt ? ` alt="${escapeHtmlAttribute(alt)}"` : "") + (title2 ? ` title="${escapeHtmlAttribute(title2)}"` : "") + "/>";
   }
   if (part.kind === "sdt")
-    return part.parts.map((child) => renderHtmlPart(child, assets)).join("");
+    return part.parts.map((child) => renderHtmlPart(child, assets, defaultTextColor)).join("");
   const href = part.target.kind === "external" ? part.target.url : `#${part.target.anchor}`;
   const title = part.tooltip ? ` title="${escapeHtmlAttribute(part.tooltip)}"` : "";
-  return `<a href="${escapeHtmlAttribute(href)}"${title}>${part.parts.map((child) => renderHtmlPart(child, assets)).join("")}</a>`;
+  return `<a href="${escapeHtmlAttribute(href)}"${title}>${part.parts.map((child) => renderHtmlPart(child, assets, defaultTextColor)).join("")}</a>`;
 }
 function buildHtmlFlavor(grouped, assets) {
   const out = [];
-  let openList = null;
+  const openLists = [];
   const closeList = () => {
-    if (openList) {
-      out.push(`</${openList}>`);
-      openList = null;
+    while (openLists.length > 0) {
+      out.push(`</li></${openLists.pop().tag}>`);
     }
   };
   for (const entry of grouped) {
@@ -329605,15 +329867,41 @@ function buildHtmlFlavor(grouped, assets) {
       continue;
     }
     const block = entry.block;
-    const inline = blockInlineHtml(block, assets);
+    const inline = blockInlineHtml(block, assets, block.listMarkerStyle?.color && block.listMarkerStyle.color !== "000000" ? "000000" : undefined);
     if (block.listKind) {
       const tag = block.listKind === "bullet" ? "ul" : "ol";
-      if (openList !== tag) {
-        closeList();
-        out.push(`<${tag}>`);
-        openList = tag;
-      }
-      out.push(`<li>${inline}</li>`);
+      const styleType = block.listMarkerStyle?.type;
+      const level = block.listLevel ?? 0;
+      if (openLists.length > 0)
+        openLists[0].sourceLevel = Math.min(openLists[0].sourceLevel, level);
+      while (openLists.length > 1 && openLists[openLists.length - 1].sourceLevel > level) {
+        out.push(`</li></${openLists.pop().tag}>`);
+      }
+      const depth = openLists.length === 0 ? 0 : level > openLists[openLists.length - 1].sourceLevel ? openLists.length : openLists.length - 1;
+      if (openLists.length === depth + 1) {
+        out.push("</li>");
+        if (openLists[depth].tag !== tag || openLists[depth].styleType !== styleType) {
+          out.push(`</${openLists.pop().tag}>`);
+        }
+      }
+      if (openLists.length === depth) {
+        const listStyles = [
+          ...styleType ? [`list-style-type: ${styleType}`] : [],
+          ...openLists[depth - 1]?.currentItemHasMarkerColor ? ["color: #000000"] : []
+        ];
+        const orderedType = tag === "ol" ? orderedListTypeAttribute(styleType) : undefined;
+        out.push(`<${tag}${orderedType ? ` type="${orderedType}"` : ""}` + `${listStyles.length > 0 ? ` style="${listStyles.join("; ")}"` : ""}>`);
+        openLists.push({ tag, sourceLevel: level, ...styleType ? { styleType } : {}, currentItemHasMarkerColor: false });
+      }
+      const markerColor = block.listMarkerStyle?.color;
+      const previousItemHadColoredMarker = openLists[openLists.length - 1].currentItemHasMarkerColor;
+      const itemColor = markerColor && markerColor !== "000000" ? markerColor : previousItemHadColoredMarker ? "000000" : undefined;
+      const itemStyles = [
+        ...styleType ? [`list-style-type: ${styleType}`] : [],
+        ...itemColor ? [`color: #${itemColor}`] : []
+      ];
+      out.push(`<li${itemStyles.length > 0 ? ` style="${itemStyles.join("; ")}"` : ""}>${inline}`);
+      openLists[openLists.length - 1].currentItemHasMarkerColor = Boolean(markerColor && markerColor !== "000000");
       continue;
     }
     closeList();
@@ -329625,6 +329913,63 @@ function buildHtmlFlavor(grouped, assets) {
   closeList();
   return out.join("");
 }
+function portableListMarkerStyle(definition2, model, paragraphXml) {
+  const glyph = definition2.lvlText?.trim();
+  const type = definition2.numFmt === "bullet" ? glyph === "•" || glyph === "●" || glyph === "" ? "disc" : glyph === "◦" || glyph === "○" ? "circle" : glyph === "▪" || glyph === "■" || glyph === "◼" ? "square" : undefined : portableOrderedListStyleType(definition2.numFmt);
+  const runContext = {
+    themeColors: model.themeColors,
+    themeFontScheme: model.themeFontScheme
+  };
+  const directParagraphProperties = parseWordParagraphPropertiesXml(paragraphXml);
+  const resolvedParagraphProperties = model.resolveParagraph({ inlineProps: directParagraphProperties });
+  const markerRun = model.resolveRun({
+    inlineRpr: parseWordRunPropertiesXml(extractParagraphMarkRPrXml(paragraphXml)),
+    resolvedParagraphProperties,
+    isListNumber: true,
+    numberingDefinedInline: directParagraphProperties.numberingProperties != null
+  });
+  const markerColor = normalizeRunAttrsFromOoxml(markerRun, runContext).color;
+  const color2 = markerColor && /^#[0-9a-f]{6}$/i.test(markerColor) ? markerColor.slice(1).toUpperCase() : undefined;
+  return {
+    ...type ? { type } : {},
+    ...color2 ? { color: color2 } : {}
+  };
+}
+function portableOrderedListStyleType(numFmt) {
+  switch (numFmt) {
+    case "decimal":
+      return "decimal";
+    case "decimalZero":
+      return "decimal-leading-zero";
+    case "lowerLetter":
+      return "lower-alpha";
+    case "upperLetter":
+      return "upper-alpha";
+    case "lowerRoman":
+      return "lower-roman";
+    case "upperRoman":
+      return "upper-roman";
+    default:
+      return;
+  }
+}
+function orderedListTypeAttribute(styleType) {
+  switch (styleType) {
+    case "decimal":
+    case "decimal-leading-zero":
+      return "1";
+    case "lower-alpha":
+      return "a";
+    case "upper-alpha":
+      return "A";
+    case "lower-roman":
+      return "i";
+    case "upper-roman":
+      return "I";
+    default:
+      return;
+  }
+}
 function tableCellHtmlStyle(cell) {
   const styles = [];
   if (cell.shadingColor)
@@ -329655,14 +330000,15 @@ function tableCellHtmlStyle(cell) {
   }
   return styles.length > 0 ? ` style="${styles.join("; ")}"` : "";
 }
-function renderHtmlRun(run) {
+function renderHtmlRun(run, defaultTextColor) {
   let html = escapeHtmlText(run.text);
-  const marks = run.marks;
-  if (!marks)
+  if (!run.marks && !defaultTextColor)
     return html;
+  const marks = run.marks ?? {};
   const styles = [];
-  if (marks.color)
-    styles.push(`color: #${marks.color}`);
+  const color2 = marks.color ?? defaultTextColor;
+  if (color2)
+    styles.push(`color: #${color2}`);
   if (marks.fontSizePt)
     styles.push(`font-size: ${marks.fontSizePt}pt`);
   if (marks.fontFamily)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.7.0-next.11",
+  "version": "1.7.0-next.13",
   "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.20.0-next.11",
+    "@superdoc/sdk": "2.20.0-next.13",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.23.0-next.11",
-    "@superdoc/docx-engine": "0.22.0-next.11",
+    "superdoc": "2.23.0-next.13",
+    "@superdoc/docx-engine": "0.22.0-next.13",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",