@superdoc/mcp 1.10.0-next.12 → 1.10.0-next.13

package/dist/index.js

@@ -31630,7 +31630,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.23.0-next.12";
+var SDK_VERSION = "2.23.0-next.13";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -93757,7 +93757,7 @@ async function runInsertParagraphs(doc2, args, formatArgs) {
       kind: "placement",
       at: placement.kind === "documentStart" ? "document_start" : "document_end"
     });
-    const preRows = pre.complete ? await listBlockRows(doc2) : anchor ? [anchor] : [];
+    let preRows = pre.complete ? await listBlockRows(doc2) : anchor ? [anchor] : [];
     let currentPlacement = placement;
     const nodeIds = [];
     const specs = [];
@@ -93795,6 +93795,16 @@ async function runInsertParagraphs(doc2, args, formatArgs) {
       if (!pre.complete) {
         const created = await post.page({ nodeIds, limit: Math.max(nodeIds.length, 1) });
         localRows = [...anchor ? [anchor] : [], ...created].sort((a, b) => a.ordinal - b.ordinal);
+        const placed = anchor && texts.some((text) => typedMarkerPrefixOf(text)) ? await post.block(anchor.nodeId) : null;
+        if (placed) {
+          const span = TYPED_SIBLING_WINDOW + nodeIds.length;
+          const window2 = await post.page({ offset: Math.max(0, placed.ordinal - 1 - span), limit: 2 * span + 1 });
+          const createdIds = new Set(nodeIds);
+          if (nodeIds.every((id) => window2.some((row) => row.nodeId === id))) {
+            preRows = window2.filter((row) => !createdIds.has(row.nodeId));
+            localRows = window2;
+          }
+        }
       }
       const count = context.executedOperations.length;
       formatted = await matchInsertedBlockFormatting(context.document, preRows, context.receipt("insert_paragraphs", []), formatArgs, localRows);
@@ -94122,6 +94132,164 @@ async function runDeleteText(doc2, args) {
     return failedReceipt("delete_text", err, pre);
   }
 }
+function enumerationSlotOf(block) {
+  const numbering = blockNumbering(block);
+  const path5 = numbering?.path;
+  if (Array.isArray(path5) && path5.length > 0) {
+    return { key: `scheme:${path5.slice(0, -1).join(".")}:${path5.length}`, depth: path5.length, typed: null };
+  }
+  const markerShape = numbering?.marker ? markerShapeOf(numbering.marker) : null;
+  if (markerShape)
+    return { key: `scheme-marker:${markerShape.wrapper}:${markerShape.kind}`, depth: null, typed: null };
+  const text = block.text || block.textPreview || "";
+  const typedMarker = typedMarkerPrefixOf(text)?.marker;
+  const typedShape = typedMarker ? markerShapeOf(text) : null;
+  if (!typedMarker || !typedShape)
+    return null;
+  const parent = typedShape.kind === "digit" ? typedDigitParentOf(typedMarker) : "";
+  return { key: `typed:${typedShape.wrapper}:${typedShape.kind}:${parent}`, depth: null, typed: typedShape };
+}
+function typedDigitParentOf(marker) {
+  const segments = marker.replace(/^\(/, "").replace(/[.)]$/, "").split(".");
+  return `${segments.length}:${segments.slice(0, -1).join(".")}`;
+}
+function markerValueOf(token, shape) {
+  const core2 = token.replace(/^\(/, "").replace(/[.)]$/, "").toLowerCase();
+  if (shape.kind === "digit")
+    return Number(core2.split(".").pop());
+  if (shape.kind === "lower-roman" || shape.kind === "upper-roman") {
+    let total = 0;
+    for (let i = 0;i < core2.length; i += 1) {
+      const value = ROMAN_DIGITS[core2[i]] ?? 0;
+      total += value < (ROMAN_DIGITS[core2[i + 1] ?? ""] ?? 0) ? -value : value;
+    }
+    return total;
+  }
+  const letter = core2.charCodeAt(0) - 96;
+  return core2.length === 1 ? letter : 26 * (core2.length - 1) + letter;
+}
+function enumerationRunOf(blocks, index, slot, textOf) {
+  const typed = slot.typed;
+  const valueOf = (block) => {
+    if (!typed) {
+      const path5 = blockNumbering(block)?.path;
+      return Array.isArray(path5) && path5.length > 0 ? Number(path5[path5.length - 1]) : null;
+    }
+    const token = typed ? typedMarkerPrefixOf(textOf(block))?.marker : null;
+    return token && typed ? markerValueOf(token, typed) : null;
+  };
+  const walk = (step) => {
+    const found = [];
+    let edge = valueOf(blocks[index]);
+    let crossed = false;
+    for (let i = index + step;i >= 0 && i < blocks.length; i += step) {
+      const block = blocks[i];
+      if (textOf(block).length === 0)
+        continue;
+      const other = enumerationSlotOf(block);
+      const continuesAsLetter = typed != null && other?.typed != null && markerShapeFits(typed, other.typed) && edge != null && valueOf(block) === edge + step;
+      if (other?.key === slot.key || continuesAsLetter) {
+        const value = valueOf(block);
+        if (value != null && edge != null) {
+          const advance = (value - edge) * step;
+          if (advance <= 0 || (crossed || !typed) && advance !== 1)
+            break;
+        }
+        found.push(block);
+        edge = value;
+        crossed = false;
+        continue;
+      }
+      if (typed && other?.typed) {
+        if (step === -1 && edge != null) {
+          const prefix = typedMarkerPrefixOf(textOf(block)).prefix;
+          const inline = new RegExp(String.raw`(?:^|\s)(${TYPED_MARKER_TOKEN}) `).exec(textOf(block).slice(prefix.length));
+          const inlineShape = inline ? markerShapeOf(inline[1]) : null;
+          if (inline && sameMarkerShape(inlineShape, typed) && markerValueOf(inline[1], typed) === edge - 1) {
+            found.push(block);
+            break;
+          }
+        }
+        crossed = true;
+        continue;
+      }
+      if (slot.depth != null && other?.depth != null && other.depth > slot.depth)
+        continue;
+      break;
+    }
+    return found;
+  };
+  return [...walk(-1).reverse(), blocks[index], ...walk(1)];
+}
+function listPunctuationAfterDelete(blocks, deletedIds) {
+  const textOf = (block) => (block.text || (block.textPreview ?? "").replace(/…\s*$/, "")).trimEnd();
+  const endingOf = (block) => {
+    const text = textOf(block);
+    const closers = ITEM_CLOSERS.exec(text)?.[0] ?? "";
+    const body = text.slice(0, text.length - closers.length).trimEnd();
+    const ending = ITEM_ENDING.exec(body);
+    return {
+      core: ending?.[0].trim() ?? "",
+      real: ending ? `${ending[0].trim()}${closers}` : closers,
+      closers,
+      conjunction: CONJUNCTION_TAIL.exec(body)?.[0].trim() ?? null
+    };
+  };
+  const quote = (block) => {
+    const text = textOf(block);
+    return JSON.stringify(text.length > 40 ? `...${text.slice(-40)}` : text);
+  };
+  const change = (block, to) => {
+    const ending = endingOf(block);
+    return `change the ending of ${quote(block)} (nodeId ${block.nodeId}) from "${ending.real}" to "${to}${ending.closers}"`;
+  };
+  const entries = [];
+  const covered = new Set;
+  blocks.forEach((block, index) => {
+    if (!deletedIds.has(block.nodeId) || covered.has(block.nodeId))
+      return;
+    const slot = enumerationSlotOf(block);
+    if (!slot)
+      return;
+    const run = enumerationRunOf(blocks, index, slot, textOf);
+    for (const item of run)
+      covered.add(item.nodeId);
+    const survivors = run.filter((item) => !deletedIds.has(item.nodeId));
+    if (survivors.length === 0)
+      return;
+    const last = survivors[survivors.length - 1];
+    const penultimate = survivors.length >= 2 ? survivors[survivors.length - 2] : undefined;
+    const originalPenultimate = run[run.length - 2];
+    if (run.some((item) => item !== originalPenultimate && endingOf(item).conjunction))
+      return;
+    const runEnd = run[run.length - 1];
+    if (!deletedIds.has(runEnd.nodeId))
+      return;
+    const tail = originalPenultimate ? endingOf(originalPenultimate).conjunction : null;
+    const separator = tail ? tail.charAt(0) : ";";
+    const closing = endingOf(runEnd).core || ".";
+    const lastEnding = endingOf(last);
+    if (lastEnding.core === ":")
+      return;
+    const needsClose = lastEnding.core !== closing && (lastEnding.conjunction != null || lastEnding.core === separator);
+    const needsTail = penultimate != null && tail != null && endingOf(penultimate).core !== ":" && !endingOf(penultimate).conjunction;
+    if (!needsClose && !(needsTail && lastEnding.core !== closing))
+      return;
+    const edits = [
+      `end ${quote(last)} (nodeId ${last.nodeId}) with "${closing}${lastEnding.closers}" instead of "${lastEnding.real}"`
+    ];
+    if (needsTail)
+      edits.push(change(penultimate, tail));
+    entries.push({
+      deleted: runEnd.nodeId,
+      lastItem: last.nodeId,
+      lastItemEnds: lastEnding.real,
+      ...penultimate ? { penultimate: penultimate.nodeId, penultimateEnds: endingOf(penultimate).real } : {},
+      suggestion: `The run now ends at ${quote(last)}: ${edits.join(", and ")}, using replace_text.`
+    });
+  });
+  return entries;
+}
 async function runDeleteBlocks(doc2, args) {
   const domains = new Set(["blocks", "trackedChanges"]);
   for (const selector of args.selectors) {
@@ -94235,6 +94403,10 @@ async function runDeleteBlocks(doc2, args) {
     }
     const allApplied = deleted.length === targets.length && errors4.length === 0;
     const verified = verification.every((v) => v.passed);
+    let listPunctuation = [];
+    try {
+      listPunctuation = listPunctuationAfterDelete(pre.blocks, new Set(deleted.map((entry) => entry.nodeId)));
+    } catch {}
     return {
       status: !verified || deleted.length === 0 ? "failed" : allApplied ? "ok" : "partial",
       intent: `delete_blocks: ${deleted.length} block(s)`,
@@ -94244,6 +94416,7 @@ async function runDeleteBlocks(doc2, args) {
       executedOperations,
       verification,
       deletedBlocks: deleted,
+      ...listPunctuation.length > 0 ? { listPunctuation } : {},
       ...errors4.length ? { errors: errors4 } : {},
       ...errors4.length ? { nextStep: "Re-inspect the document and retry the selectors that did not resolve to one block." } : {}
     };
@@ -96706,8 +96879,9 @@ async function runScopedReplaceUnchecked(doc2, args) {
       occurrences: spans.length,
       ...edit.occurrence != null ? { occurrence: edit.occurrence } : {}
     });
-    for (const span of spans)
-      allSpans.push({ ...span, replace: edit.replace, find: edit.find });
+    for (const span of spans) {
+      allSpans.push({ ...span, replace: edit.replace, find: edit.find, editIndex: perEdit.length - 1 });
+    }
   }
   const appliedEdits = perEdit.filter((e) => e.occurrences > 0);
   const skippedEdits = perEdit.filter((e) => e.occurrences === 0);
@@ -96741,6 +96915,23 @@ async function runScopedReplaceUnchecked(doc2, args) {
     planned.push(span);
     lastEnd = span.end;
   }
+  planned.forEach((span, at) => {
+    if (span.replace.trim().length > 0)
+      return;
+    const text = block.text;
+    if (text.charAt(span.start - 1) !== " " || text.charAt(span.end) !== " ")
+      return;
+    if (text.charAt(span.start - 2) === " " || text.charAt(span.end + 1) === " ")
+      return;
+    if (/[.!?]["'\u201d\u2019)\]]*$/.test(text.slice(0, span.start - 1)))
+      return;
+    if ((planned[at + 1]?.start ?? Infinity) <= span.end || (planned[at - 1]?.end ?? -1) >= span.start - 1)
+      return;
+    if (span.replace.length > 0)
+      span.start -= 1;
+    span.end += 1;
+    perEdit[span.editIndex].collapsedSpace = true;
+  });
   const expected = planned.reduceRight((text, span) => text.slice(0, span.start) + span.replace + text.slice(span.end), block.text);
   const tracked = (args.changeMode ?? "direct") === "tracked";
   const uniqueFinds = new Set(planned.map((s) => caseSensitive ? s.find : s.find.toLowerCase()));
@@ -96913,6 +97104,8 @@ function leadInShapeOf(blockText, labelText, quote) {
   return null;
 }
 function leadInSpanOf(text, shape) {
+  if (shape.kind === "typed")
+    return typedCaptionSpanOf(text, shape.delimiter);
   if (shape.kind === "word") {
     const next = text.charAt(shape.label.length);
     return text.startsWith(shape.label) && (next === "" || /\s/.test(next)) ? { start: 0, end: shape.label.length } : null;
@@ -96940,6 +97133,71 @@ function leadInSpanOf(text, shape) {
   const end = leadInEndOf(text, shape.delimiter);
   return end == null ? null : { start: 0, end };
 }
+function typedMarkerPrefixOf(text) {
+  const match = TYPED_MARKER_PREFIX.exec(text);
+  return match ? { prefix: match[0], marker: match[1] } : null;
+}
+function markerShapeOf(text) {
+  const match = LEADING_MARKER_TOKEN.exec(text);
+  if (!match)
+    return null;
+  const token = match[1];
+  const wrapper = token.startsWith("(") ? "paren" : token.endsWith(".") ? "period" : "close";
+  const core2 = token.replace(/^\(/, "").replace(/[.)]$/, "");
+  let kind;
+  if (/^\d/.test(core2))
+    kind = "digit";
+  else if (/^[ivx]+$/.test(core2))
+    kind = "lower-roman";
+  else if (/^[IVX]+$/.test(core2))
+    kind = "upper-roman";
+  else if (/^[a-z]+$/.test(core2))
+    kind = "lower-alpha";
+  else if (/^[A-Z]+$/.test(core2))
+    kind = "upper-alpha";
+  else
+    return null;
+  return { wrapper, kind };
+}
+function sameMarkerShape(a, b) {
+  return a != null && b != null && a.wrapper === b.wrapper && a.kind === b.kind;
+}
+function markerShapeFits(reference, created) {
+  if (!reference || reference.wrapper !== created.wrapper)
+    return false;
+  if (reference.kind === created.kind)
+    return true;
+  return created.kind === "lower-roman" && reference.kind === "lower-alpha" || created.kind === "upper-roman" && reference.kind === "upper-alpha";
+}
+function continuesAlphabet(referenceText, createdText, referenceBefore) {
+  const letterOf = (text) => /^[a-zA-Z]$/.exec(LEADING_MARKER_TOKEN.exec(text)?.[1]?.replace(/[().]/g, "") ?? "")?.[0];
+  const reference = letterOf(referenceText);
+  const created = letterOf(createdText);
+  return reference != null && created != null && created.charCodeAt(0) - reference.charCodeAt(0) === (referenceBefore ? 1 : -1);
+}
+function isTitleLike(caption) {
+  const words = caption.match(/\p{L}+/gu) ?? [];
+  const capitalised = words.filter((word) => /^\p{Lu}/u.test(word)).length;
+  return words.length > 0 && words.every((word) => word.length < 4 || /^\p{Lu}/u.test(word)) && capitalised * 2 >= words.length;
+}
+function typedCaptionSpanOf(text, delimiter = ".") {
+  const typed = typedMarkerPrefixOf(text);
+  const mark = delimiter.trim();
+  if (!typed || !mark)
+    return null;
+  const start = typed.prefix.length;
+  for (let at = text.indexOf(mark, start);at >= 0; at = text.indexOf(mark, at + 1)) {
+    const end = at + mark.length;
+    if (end - start > TYPED_CAPTION_MAX_CHARS)
+      return null;
+    if (at === start || !/\s/.test(text.charAt(end)))
+      continue;
+    if (!isTitleLike(text.slice(start, at)))
+      return null;
+    return text.slice(end).trim().length > 0 ? { start, end } : null;
+  }
+  return null;
+}
 function sliceWholeChars(text, end) {
   if (end >= text.length)
     return text;
@@ -96980,7 +97238,10 @@ async function listItemRunPattern(doc2, text, blockId) {
   if (!queryFn || !text.trim())
     return null;
   const delimiterAt = leadInEndOf(text);
-  const windowEnd = delimiterAt != null ? delimiterAt + LEAD_IN_BODY_SAMPLE_CHARS : LEAD_IN_BODY_SAMPLE_CHARS;
+  let windowEnd = delimiterAt != null ? delimiterAt + LEAD_IN_BODY_SAMPLE_CHARS : LEAD_IN_BODY_SAMPLE_CHARS;
+  const typedCaption = typedCaptionSpanOf(text);
+  if (typedCaption)
+    windowEnd = Math.max(windowEnd, typedCaption.end + LEAD_IN_BODY_SAMPLE_CHARS);
   const pattern = sliceWholeChars(text, windowEnd);
   const result = asRecord2(await queryFn({ select: { type: "text", pattern } }));
   const items = Array.isArray(result?.items) ? result.items : [];
@@ -96994,6 +97255,9 @@ async function listItemRunPattern(doc2, text, blockId) {
       const runs = (Array.isArray(rec?.runs) ? rec.runs : []).filter((r) => runTextOf(r).length > 0);
       if (runs.length === 0)
         continue;
+      const typedLead = typedPrefixLabelOf(runs, runTextOf);
+      if (typedLead)
+        return typedLead;
       const blockText = asString2(rec?.text, "") ?? "";
       const opener = runTextOf(runs[0]).trim();
       const quote = LEAD_IN_QUOTES.find((q) => opener === q);
@@ -97017,6 +97281,59 @@ async function listItemRunPattern(doc2, text, blockId) {
   }
   return null;
 }
+function typedPrefixLabelOf(runs, runTextOf) {
+  const typed = typedMarkerPrefixOf(runs.map(runTextOf).join(""));
+  if (!typed)
+    return null;
+  const markerEnd = typed.prefix.indexOf(typed.marker) + typed.marker.length;
+  let covered = 0;
+  let labelIndex = 0;
+  while (labelIndex < runs.length && covered + runTextOf(runs[labelIndex]).length <= typed.prefix.length) {
+    covered += runTextOf(runs[labelIndex]).length;
+    labelIndex += 1;
+  }
+  if (covered < markerEnd || labelIndex + 1 >= runs.length)
+    return null;
+  const underlined = (run) => asRecord2(asRecord2(asRecord2(run)?.styles)?.effective)?.underline === true;
+  const emphasisOf = (run) => {
+    const style = matchRunStyle(run);
+    return `${style.bold}/${style.italic}/${underlined(run)}`;
+  };
+  const label = runs[labelIndex];
+  if (emphasisOf(label) === "false/false/false")
+    return null;
+  const isBlank = (run) => runTextOf(run).trim().length === 0;
+  const continuesLabel = (index) => {
+    if (emphasisOf(runs[index]) === emphasisOf(label))
+      return true;
+    let next = index;
+    while (next < runs.length && isBlank(runs[next]))
+      next += 1;
+    return next > index && next < runs.length && emphasisOf(runs[next]) === emphasisOf(label);
+  };
+  let bodyIndex = labelIndex + 1;
+  while (bodyIndex < runs.length && continuesLabel(bodyIndex))
+    bodyIndex += 1;
+  while (bodyIndex < runs.length - 1 && isBlank(runs[bodyIndex]))
+    bodyIndex += 1;
+  if (bodyIndex >= runs.length)
+    return null;
+  const labelText = runs.slice(labelIndex, bodyIndex).map(runTextOf).join("").trim();
+  if (labelText.length === 0 || labelText.length > LEAD_IN_MAX_CHARS)
+    return null;
+  const delimiter = [".", ...LEAD_IN_DELIMITERS.map((d) => d.trim())].find((d) => labelText.endsWith(d) && labelText.length > d.length);
+  if (!delimiter)
+    return null;
+  const body = runs[bodyIndex];
+  const leadStyle = matchRunStyle(label);
+  const bodyStyle = matchRunStyle(body);
+  const leadUnderline = underlined(label);
+  const bodyUnderline = underlined(body);
+  const look = inlineFromMatchStyle(leadStyle, bodyStyle);
+  if (leadUnderline || bodyUnderline)
+    look.underline = leadUnderline;
+  return { body: inlineFromMatchStyle(bodyStyle), lead: { look, shape: { kind: "typed", delimiter } } };
+}
 function paragraphIndentOf(payload) {
   const node = isRecord(payload) ? payload.node : null;
   if (!isRecord(node))
@@ -97707,6 +98024,7 @@ async function matchOneBlock(doc2, postBlocks, preIds, created, createdIndex, an
     }
     if (!reference)
       return null;
+    reference = typedShapeReference(postBlocks, preIds, created, createdIndex, createdText, reference, compatibleHeading);
     const applied = {};
     const refNumbering = blockNumbering(reference);
     if (allowNumberingAttach && refNumbering && !blockNumbering(created)) {
@@ -97726,7 +98044,8 @@ async function matchOneBlock(doc2, postBlocks, preIds, created, createdIndex, an
       }
     }
     if (reference.styleId && reference.styleId !== created.styleId) {
-      const setStyleFn = maybeMethod2(doc2, ["styles", "paragraph", "setStyle"]);
+      const keepRunMarks = !allowLeadPattern;
+      const setStyleFn = (keepRunMarks ? maybeMethod2(doc2, ["styles", "paragraph", "setStyleRef"]) : null) ?? maybeMethod2(doc2, ["styles", "paragraph", "setStyle"]);
       if (setStyleFn) {
         const target = { kind: "block", nodeType: created.nodeType, nodeId: created.nodeId };
         let canCopyStyle = true;
@@ -97801,6 +98120,38 @@ async function matchOneBlock(doc2, postBlocks, preIds, created, createdIndex, an
     return { matchedSibling: null, skipped: reasonOf(err) };
   }
 }
+function typedShapeReference(postBlocks, preIds, created, createdIndex, createdText, reference, compatible) {
+  const typed = createdText ? typedMarkerPrefixOf(createdText) : null;
+  if (!typed || createdText.slice(typed.prefix.length).trim().length === 0)
+    return reference;
+  const shape = markerShapeOf(createdText);
+  const referenceShape = markerShapeOf(reference.textPreview ?? "");
+  if (!shape || sameMarkerShape(referenceShape, shape))
+    return reference;
+  const usable = (row) => !!row && preIds.has(row.nodeId) && row.nodeType === created.nodeType && !row.isEmpty && compatible(row);
+  const before = postBlocks.slice(0, createdIndex).reverse().find(usable);
+  const after = postBlocks.slice(createdIndex + 1).find(usable);
+  const continued = [reference, before, after].find((row) => !!row && markerShapeFits(markerShapeOf(row.textPreview ?? ""), shape) && continuesAlphabet(row.textPreview ?? "", createdText, postBlocks.findIndex((b) => b.nodeId === row.nodeId) < createdIndex));
+  if (continued)
+    return continued;
+  const candidate = (row) => {
+    if (!usable(row))
+      return null;
+    const preview = row.textPreview ?? "";
+    return typedMarkerPrefixOf(preview) ? markerShapeOf(preview) : null;
+  };
+  const nearest = (accepts) => {
+    for (let distance = 1;distance < postBlocks.length; distance += 1) {
+      for (const index of [createdIndex - distance, createdIndex + distance]) {
+        const row = postBlocks[index];
+        if (index >= 0 && accepts(candidate(row)))
+          return row;
+      }
+    }
+    return null;
+  };
+  return nearest((rowShape) => sameMarkerShape(rowShape, shape)) ?? nearest((rowShape) => markerShapeFits(rowShape, shape)) ?? reference;
+}
 async function matchLeadMarkerPattern(doc2, reference, created, createdText) {
   const createdPreview = created.textPreview ?? "";
   if (!reference.nodeId || !created.nodeId || !createdPreview)
@@ -97878,7 +98229,7 @@ async function matchBlockRunPattern(doc2, reference, created, createdText) {
   }
   if (pattern.lead) {
     const span = leadInSpanOf(fullText, pattern.lead.shape);
-    const range = span ?? (Object.keys(pattern.body).length === 0 ? { start: 0, end } : null);
+    const range = span ?? (Object.keys(pattern.body).length === 0 && pattern.lead.shape.kind !== "typed" ? { start: 0, end } : null);
     if (range && await applyInlineQuiet(formatFn, { blockId: created.nodeId, ...range, inline: pattern.lead.look })) {
       applied.lead = { ...pattern.lead.look, range: [range.start, range.end] };
     }
@@ -97898,7 +98249,7 @@ async function matchInsertedBlockFormatting(doc2, preBlocks, receipt, args, avai
     const anchorSelector = placement && isRecord(placement.selector) ? placement.selector : null;
     const anchorId = anchorSelector && typeof anchorSelector.nodeId === "string" ? anchorSelector.nodeId : null;
     const anchorRow = anchorId ? postBlocks.find((b) => b.nodeId === anchorId) ?? null : null;
-    const rawTexts = Array.isArray(args?.texts) ? args.texts : [];
+    const rawTexts = Array.isArray(args?.texts) ? args.texts : args?.text != null ? [args.text] : [];
     const hasExplicitStyling = rawTexts.some((entry) => isRecord(entry) && (Array.isArray(entry.runs) || entry.marks != null));
     const insertedTexts = rawTexts.map((entry) => {
       if (typeof entry === "string")
@@ -98056,7 +98407,7 @@ async function runAttachNumbering(doc2, args) {
       errors: [
         {
           code: "TARGET_NOT_FOUND",
-          message: `no block renders marker ${JSON.stringify(likeMarker)}. Available: ${available.join(" ")}`,
+          message: available.length > 0 ? `no block renders marker ${JSON.stringify(likeMarker)}. Available: ${available.join(" ")}` : rows.some((r) => typedMarkerPrefixOf(r.textPreview ?? "") != null) ? `no block renders marker ${JSON.stringify(likeMarker)}: this document has no numbering scheme; its clause numbers are typed text. ` + `Copy the sibling's typed prefix (tab, next number, tab) into the paragraph text with insert_paragraphs or replace_text, ` + `then renumber the following typed markers with replace_text.` : `no block renders marker ${JSON.stringify(likeMarker)}: no block in this document carries numbering. ` + `To add a paragraph that matches its neighbours use insert_paragraphs next to them; ` + `to start a numbered list use append_list or convert_list.`,
           recovery: { kind: "reinspect" }
         }
       ]
@@ -98983,7 +99334,7 @@ function parseSelector(value) {
   }
   return;
 }
-var ACTION_DEFINITIONS, ACTION_NAMES, ACTION_HINTS, ACTION_ARGS, ACTION_DISPOSITIONS, ACTION_GROUP_LABELS, ACTION_GROUPS, DELETABLE_BLOCK_NODE_TYPES, RUN_BOOL_MARKS, NAMED_COLORS, HEX_COLOR_PATTERN, TWIPS_PER_POINT = 20, LEAD_IN_DELIMITERS, LEAD_IN_MAX_CHARS = 90, LEAD_IN_BODY_SAMPLE_CHARS = 40, LEAD_IN_QUOTES, LEAD_IN_TAIL_DELIMITERS, normMarker = (m) => m.trim().replace(/\.$/, ""), LEAD_MARKER_PATTERN, ACTION_NAMES_LIST;
+var ACTION_DEFINITIONS, ACTION_NAMES, ACTION_HINTS, ACTION_ARGS, ACTION_DISPOSITIONS, ACTION_GROUP_LABELS, ACTION_GROUPS, TYPED_SIBLING_WINDOW = 20, CONJUNCTION_TAIL, ITEM_ENDING, ITEM_CLOSERS, ROMAN_DIGITS, DELETABLE_BLOCK_NODE_TYPES, RUN_BOOL_MARKS, NAMED_COLORS, HEX_COLOR_PATTERN, TWIPS_PER_POINT = 20, LEAD_IN_DELIMITERS, LEAD_IN_MAX_CHARS = 90, LEAD_IN_BODY_SAMPLE_CHARS = 40, LEAD_IN_QUOTES, LEAD_IN_TAIL_DELIMITERS, TYPED_MARKER_CORE, TYPED_MARKER_TOKEN, TYPED_MARKER_PREFIX, LEADING_MARKER_TOKEN, TYPED_CAPTION_MAX_CHARS = 60, normMarker = (m) => m.trim().replace(/\.$/, ""), LEAD_MARKER_PATTERN, ACTION_NAMES_LIST;
 var init_actions = __esm(() => {
   init_action_descriptors();
   init_execution_context();
@@ -99016,6 +99367,10 @@ var init_actions = __esm(() => {
     label,
     actions: ACTION_NAMES.filter((name) => ACTION_DEFINITIONS[name].group === label).sort((left, right) => ACTION_DEFINITIONS[left].groupOrder - ACTION_DEFINITIONS[right].groupOrder)
   }));
+  CONJUNCTION_TAIL = /[;,]\s*(and|or)\s*$/i;
+  ITEM_ENDING = /(?:[;,]\s*(?:and|or)|[.;,:])\s*$/i;
+  ITEM_CLOSERS = /["'”’)\]]+$/;
+  ROMAN_DIGITS = { i: 1, v: 5, x: 10 };
   DELETABLE_BLOCK_NODE_TYPES = new Set(["paragraph", "heading", "listItem"]);
   RUN_BOOL_MARKS = ["bold", "italic", "underline", "strike"];
   NAMED_COLORS = {
@@ -99036,6 +99391,10 @@ var init_actions = __esm(() => {
   LEAD_IN_DELIMITERS = [":", " — ", " – ", " - ", "—", "–"];
   LEAD_IN_QUOTES = ['"', "“", "‘", "'"];
   LEAD_IN_TAIL_DELIMITERS = [". ", ": ", ...LEAD_IN_DELIMITERS];
+  TYPED_MARKER_CORE = String.raw`(?:\d{1,3}(?:\.\d{1,3})*|[ivx]{1,6}|[IVX]{1,6}|[a-z]{1,2}|[A-Z])`;
+  TYPED_MARKER_TOKEN = String.raw`(?:\(${TYPED_MARKER_CORE}\)|${TYPED_MARKER_CORE}[.)])`;
+  TYPED_MARKER_PREFIX = new RegExp(String.raw`^[ \t]*(${TYPED_MARKER_TOKEN})\t[\t ]*`);
+  LEADING_MARKER_TOKEN = new RegExp(String.raw`^\s*(${TYPED_MARKER_TOKEN})(?=\s|$)`);
   LEAD_MARKER_PATTERN = /^\(?(?:[a-zA-Z]{1,3}|\d{1,3})[).:\]]/;
   ACTION_NAMES_LIST = ACTION_NAMES;
 });
@@ -100224,8 +100583,8 @@ Users speak in what they SEE, not in file-format terms. Translate their words in
 - PLACEMENT: when the user names a position, honor it exactly. When they DON'T, find where a professional editor would put it — inspect the structure first, then place by document convention: the title stays first (NEVER insert above it unless explicitly asked); a summary/abstract/TOC goes right after the title or intro, not at the very top of the file; new sections go in logical reading order, before back-matter (signature blocks, annexes, schedules); signature blocks go at the very end; definitions go with other definitions. Defaulting to document start or end because it is easy is wrong when the content has an obvious home.
 - LEGAL DOCUMENTS ARE CROSS-REFERENCED. Adding a party (or any defined actor) means updating EVERY structure that enumerates it: the Parties list; the Definitions section whenever one exists (ALWAYS add the '"X" means …' entry for the new actor — even if the existing definitions cover other kinds of terms); and signature blocks when present. Same for removals. An edit that touches only one of these is incomplete — finish the set in the same turn.
 - CLEANUP is part of the job. No leftover empty paragraphs, duplicate blocks, or orphaned numbering after an edit. If your edit creates debris, remove it in the same turn.
-- NUMBERS COME FROM SCHEMES, NEVER FROM TEXT. Do not type "11." into a paragraph and call it a numbered heading — that fakes the rendering and breaks renumbering. Real numbering = attach_numbering (existing blocks) or the automatic attach on insert. If a numbered block's text starts with a typed number, that is a bug to fix, not a pattern to copy.
-- NEW SECTIONS in clause-numbered documents (clauses 1.–10.): "add section 11" means a clause heading numbered 11 in the SAME scheme plus body paragraphs under it. Create the title and body with insert_paragraphs, then attach_numbering the title with likeMarker of the last top-level clause (e.g. "10.") — it renders as "11." automatically.
+- CLAUSE NUMBERS follow the siblings. SCHEME numbering (inspect shows numbering.marker on the blocks): never type a number into the text; a new clause = insert_paragraphs, then attach_numbering with likeMarker of the last sibling (e.g. "10.") and the rest renumbers itself. TYPED numbering (counts.lists is 0 and the siblings' text starts with the number: "\\t4.\\t", "\\t(b)\\t", "\\t(i)\\t"): copy that exact shape into the inserted text (leading tab, next number, tab, caption, two spaces), style a sub-item like an existing sub-item (apply_style likeText), never attach_numbering or append_list there, and renumber what follows yourself in ONE replace_text call: the later markers of the SAME sequence (a new top-level clause shifts the top-level clauses after it, not their (a)/(i) sub-runs, not an attachment's own clauses) AND every "Section N" cross-reference to a moved clause (a clause's reference to itself takes its new number). Schedule, Exhibit, Annex and Appendix labels are not clause numbers: leave them alone. A typed number is the document's convention, not a bug to fix.
+- REMOVING an item from a lettered or numbered run ("(a) …, (b) … and (c) …", sub-clauses ending "; and") reletters the items that follow and moves the closing conjunction to the new penultimate item, so the last one ends the way the list ends: deleting (iv) from "(ii) …; (iii) …; and (iv) …." takes TWO edits, (ii) "…;" becomes "…; and" and (iii) "…; and" becomes "…." (read (ii) first; it is in the paragraph above). Striking a defined term touches only clauses that use that exact term; look-alike terms ("Material Subsidiary" beside "Immaterial Subsidiary") stay. Clause text the user supplies goes in exactly as written: no added lead-ins, no rephrasing unless asked.
 - NEVER END THE TURN WITH THE DOCUMENT WORSE THAN YOU FOUND IT. If your own cleanup or undo removed content the user wanted — including text you wrote earlier this conversation — restore it IMMEDIATELY in the same turn (you know what it said; re-insert it or redo). Do not ask permission to repair damage you caused.
 - REVIEW means READING. "Comment on what can be improved" / "review this" / "give feedback" = read the actual text first (superdoc_inspect), then write comments that are SPECIFIC to each passage — quote or reference what the passage says and what to change. Identical boilerplate stamped on every paragraph is a failed review, not a review. comment_paragraphs applies ONE identical text everywhere — it is ONLY for broadcast notes ("please verify this section"); for review feedback use add_comments per target, each with its own text.
 - ACT when intent is plain; ask only when the request is genuinely ambiguous AND the wrong guess would be destructive. One clarifying question maximum, with your best-guess default stated.
@@ -100250,15 +100609,15 @@ ACTIONS (superdoc_perform_action with flat args)
 - insert_paragraphs: texts (in final order) — or a single text for one paragraph. headingLevel makes the first item a heading (1-6). changeMode:"tracked" if asked. Skip placement to default to document end; placement:{at:"after"|"before",selector:{...}} to position. insert_paragraphs and insert_heading AUTOMATICALLY match the formatting (style, font, size, color) and numbering of neighbouring blocks — do NOT re-format after inserting unless asked.
 - insert_heading: text, level (1-6).
 - append_list: items (string array), kind:"ordered"|"bullet". headingText/headingLevel only if asked for a heading above. placement:{at:"after"|"before",selector:{...}} builds the list at that block instead of document end — when the list belongs inside a section, ALWAYS pass placement. The receipt's placement-honored check is the truth.
-- add_list_items: entries:[{text, level?}] (level relative to the anchor: 0 = same level, 1 = nested sub-item) — or items:[…] plain strings at the list level. Locate the list by anchorText (text inside one of its items) or listOrdinal (1-based). THE way to ADD items into an EXISTING list — reuses its numbering + markers, matches the anchor item's font/size/bold/colour automatically (receipt.formattingMatched — do NOT re-format after adding unless asked), joins imported list-looking paragraphs in place, and is tracked-safe. NOT append_list (which starts a brand-new list).
+- add_list_items: entries:[{text, level?}] (level relative to the anchor: 0 = same level, 1 = nested sub-item) — or items:[…] plain strings at the list level. Locate the list by anchorText (text inside one of its items) or listOrdinal (1-based). THE way to ADD items into an EXISTING list or scheme-numbered sequence (never a typed one) — reuses its numbering + markers, matches the anchor item's font/size/bold/colour automatically (receipt.formattingMatched — do NOT re-format after adding unless asked), joins imported list-looking paragraphs in place, and is tracked-safe. NOT append_list (which starts a brand-new list).
 - convert_list: kind:"ordered"|"bullet", with listOrdinal or anchorText for real lists, OR fromMarker+toMarker (rendered clause numbers from inspect, e.g. "2.1.", "2.3.") for NUMBERED-CLAUSE ranges — including heading-styled clauses, OR fromText+toText (exact text inside the FIRST and LAST of consecutive plain paragraphs) to convert existing paragraphs into a list IN PLACE. Sub-clauses in range included automatically. THE way to convert numbering<->bullets AND the way to make existing paragraphs a list; never rewrite text to fake it, never recreate-the-content-then-delete-the-originals (two chances to lose text — convert_list fromText/toText is one lossless call).
 - split_list: anchorText (text inside the item that should START the second list), restartNumbering? (default true). Splits ONE list into two at that item — the new list restarts at 1, nested sub-items stay with their parent. THE way to "split the list starting at item N into a new list with reset numbering"; never fake it with convert_list/attach_numbering. changeMode:"tracked" records the change for review.
 - undo_changes: untilMarker (rendered marker from the original state, e.g. "2.1.") or steps (1-25). Deterministic revert — steps history back until the marker reappears; the receipt proves it. NEVER use steps > 1 blindly: prefer untilMarker, and after ANY undo verify (superdoc_inspect) that content you meant to KEEP still exists — if you overshot, redo_changes {steps:N} steps forward again to recover it.
 - redo_changes: steps (1-25, default 1). Steps history FORWARD to re-apply edits a prior undo removed — THE recovery for an undo overshoot. Only reaches the forward branch until a NEW edit is made.
-- attach_numbering: anchorText (text of the block) or nodeId, likeMarker (rendered marker of a sibling clause, e.g. "10."). Makes an EXISTING block a numbered clause at the same scheme/level — "make this the section 11 heading" in a clause-numbered document is exactly this (it will render as the next number).
+- attach_numbering: anchorText (text of the block) or nodeId, likeMarker (rendered marker of a sibling clause, e.g. "10."). Scheme numbering only (it fails where the numbers are typed text). Makes an EXISTING block a numbered clause at the same scheme/level — "make this the section 11 heading" in a clause-numbered document is exactly this (it will render as the next number).
 - replace_text: edits:[{find,replace,occurrence?}], caseSensitive default false. selector to scope. Keep find/replace spans MINIMAL. If the find appears more than once in the selected block and only one should change, give that edit occurrence (1 = first match in the block; needs selector; not selector.occurrence). With occurrence, also pass expectedRevision from your latest inspect or receipt; on REVISION_CONFLICT inspect again and recount. changeMode:"tracked" if asked. The receipt reports editsApplied and editsSkipped per find — READ IT: a skipped find is not in the selected block; re-target instead of assuming success.
 - delete_text: finds:[string]. selector to scope deletions to ONE block — REQUIRED for whitespace-only finds (unscoped whitespace matches document-wide and is refused). changeMode:"tracked" if asked. Deletes TEXT ONLY: the block survives, so a list item keeps its bullet/number and an accepted tracked deletion leaves an empty numbered item behind. To remove the item itself use delete_blocks.
-- delete_blocks: selectors:[…], each resolving to ONE block (list item, paragraph or heading). changeMode:"tracked" if asked. THE way to DELETE a whole LIST ITEM, paragraph or heading — the bullet/number goes with it and the remaining items renumber. "Delete the first item under Article II" / "remove that clause" is exactly this, NOT delete_text. Pass every target in ONE call. Use delete_table for a whole table.
+- delete_blocks: selectors:[…], each resolving to ONE block (list item, paragraph or heading). changeMode:"tracked" if asked. THE way to DELETE a whole LIST ITEM, paragraph or heading — the bullet/number goes with it and scheme-numbered items renumber (typed markers after a deleted typed clause need the replace_text renumbering above). "Delete the first item under Article II" / "remove that clause" is exactly this, NOT delete_text. Pass every target in ONE call. Use delete_table for a whole table. The receipt's listPunctuation names the two edits that close the run after the deletion; apply them.
 - rewrite_block: selector, text. Inspect first to gather current text; never ask the user to paste text already in the doc.
 - create_table: rows, columns, optional cellTexts (2D array). rows counts ALL rows INCLUDING the header — header plus one data row is rows:2. placement defaults to document end. changeMode:"tracked" if asked ("track-changes table") — the insertion itself becomes a tracked change.
 - comment_paragraphs: commentText. excludeBlockQuotes:true to skip block quotes. Applies the SAME text to every BODY paragraph (it does NOT comment the title/heading) — broadcast notes only, never review feedback (see REVIEW rule). To comment a heading too, add_comments on it explicitly.
@@ -100304,7 +100663,7 @@ OPERATING RULES
 - REVERTS: "undo / revert / make it back" = superdoc_perform_action undo_changes with untilMarker from the original state (a convert receipt's revertHint contains the exact call) — NEVER re-convert or re-edit to approximate the old state.
 - If the request names a target descriptively ("the indented heading", "the second clause"), inspect FIRST and use the block's actual text or nodeId — never invent find text.
 - Numbered legal clauses ("2.3.") usually live on numbered HEADINGS, not lists: if counts.lists is 0 but blocks carry numbering markers, target those blocks by nodeId. "Add item 2.4" = insert_paragraphs (one text) after the "2.3." block; the tool attaches numbering and matches formatting automatically (check receipt.contextualFormatting).
-- ADDING SEVERAL items to an existing list or numbered sequence = ONE add_list_items call (it joins the sequence and is tracked-safe — it works even when the "list" is clause numbering and counts.lists is 0). NEVER a chain of insert_paragraphs calls: multi-paragraph inserts do not auto-join numbering, and the items will land as plain paragraphs.
+- ADDING SEVERAL items to an existing list or scheme-numbered sequence = ONE add_list_items call (it joins the sequence and is tracked-safe — it works even when the "list" is clause numbering with markers and counts.lists is 0). NEVER a chain of insert_paragraphs calls there: multi-paragraph inserts do not auto-join numbering, and the items will land as plain paragraphs. TYPED sequences are the exception: ONE insert_paragraphs call whose texts carry the typed markers.
 - New SECTION headings use the SAME headingLevel as sibling section headings (title is usually level 1; sections 2+). Never default to level 1.
 - paragraphOrdinal counts visible non-empty paragraphs; bodyParagraphOrdinal counts substantive body paragraphs after front matter. Prefer paragraphOrdinal for "first/second paragraph".
 - For literal ordinal rewrites, do not switch paragraphs because the matched one looks title-like or short. If a rewrite is a no-op, keep the target and change the rewrite.
@@ -327464,7 +327823,8 @@ function insertXmlAtCollapsedTopLevelWrapperBoundary(paragraphXml, offset, inser
     const childTextEnd = childTextStart + visibleTextLength3(childXml);
     textCursor = childTextEnd;
     cursor = childEnd;
-    if (!COLLAPSED_INSERTION_BOUNDARY_WRAPPERS.has(localName2) || childTextStart === childTextEnd) {
+    const boundaryChild = COLLAPSED_INSERTION_BOUNDARY_WRAPPERS.has(localName2) || localName2 === "r" && !parsePlainRun2(childXml, childTextStart, childStart, childEnd).ok;
+    if (!boundaryChild || childTextStart === childTextEnd) {
       continue;
     }
     if (offset === childTextStart) {
@@ -327596,7 +327956,9 @@ function insertXmlAtRangeStartInSimpleFieldResultInParagraphXml(input) {
   return { ok: true, xml };
 }
 function projectMatchRuns(input) {
-  const collected = collectPlainTextRuns2(input.paragraphXml, input.rangeStart, input.rangeEnd);
+  const collected = collectPlainTextRuns2(input.paragraphXml, input.rangeStart, input.rangeEnd, {
+    splitMixedRuns: true
+  });
   if (!collected.ok) {
     input.onProjectionUnavailable?.();
     return [
@@ -327682,7 +328044,7 @@ function collectPlainTextRuns2(paragraphXml, rangeStart, rangeEnd, options = {})
       const markers = scanComplexFieldMarkers2(childXml);
       complexFieldDepth = Math.max(0, complexFieldDepth + markers.begins - markers.ends);
       complexFieldResultDepth = Math.max(0, complexFieldResultDepth + markers.separates - markers.ends);
-      const parsed = parsePlainRun2(childXml, childTextStart, cursor - childXml.length, cursor);
+      const parsed = options.splitMixedRuns ? parsePlainRunLeaves(childXml, childTextStart, cursor - childXml.length, cursor) : parsePlainRun2(childXml, childTextStart, cursor - childXml.length, cursor);
       if (!parsed.ok) {
         if (intersects) {
           return { ok: false, reason: parsed.reason };
@@ -327698,7 +328060,10 @@ function collectPlainTextRuns2(paragraphXml, rangeStart, rangeEnd, options = {})
       if (fieldDepthBefore > 0 && fieldResultDepthBefore > 0 && !options.allowFieldResultContent && rangesOverlap7(childTextStart, childTextEnd, rangeStart, rangeEnd)) {
         return { ok: false, reason: "text-range-in-field" };
       }
-      runs.push(parsed.run);
+      if ("runs" in parsed)
+        runs.push(...parsed.runs);
+      else
+        runs.push(parsed.run);
       continue;
     }
     if (localName2 === "ins" || localName2 === "del" || localName2 === "moveFrom" || localName2 === "moveTo") {
@@ -327791,6 +328156,63 @@ function parsePlainRun2(runXml, textStart, xmlStart, xmlEnd) {
     }
   };
 }
+function parsePlainRunLeaves(runXml, textStart, xmlStart, xmlEnd) {
+  const single = parsePlainRun2(runXml, textStart, xmlStart, xmlEnd);
+  if (single.ok)
+    return { ok: true, runs: [single.run] };
+  if (single.reason !== "invalid-range")
+    return single;
+  const run = parseContainerXml(runXml, "r");
+  if (!run)
+    return single;
+  const children2 = parseTopLevelChildren(run.inner);
+  const rPr = getChildXml(children2, "rPr") ?? "";
+  const runs = [];
+  let cursor = textStart;
+  for (const child of children2) {
+    if (child.localName === "rPr")
+      continue;
+    let text;
+    let kind;
+    if (child.localName === "t") {
+      text = decodeXmlText8(child.xml.replace(/^<[\w.-]+:t\b[^>]*>|<\/[\w.-]+:t>$/g, ""));
+      kind = "text";
+    } else if (child.localName === "tab") {
+      text = "\t";
+      kind = "tab";
+    } else if (child.localName === "br" || child.localName === "cr") {
+      const breakType = child.localName === "br" ? readAttr2(child.xml, "type") : null;
+      if (child.localName === "br" && breakType && breakType !== "textWrapping") {
+        return { ok: false, reason: "unsupported-context" };
+      }
+      text = `
+`;
+      kind = child.localName;
+    } else {
+      const marker = child.localName === "bookmarkStart" || child.localName === "bookmarkEnd" || child.localName === "commentRangeStart" || child.localName === "commentRangeEnd" || child.localName === "commentReference";
+      if (marker)
+        continue;
+      return single;
+    }
+    runs.push({
+      kind,
+      xmlStart,
+      xmlEnd,
+      xml: runXml,
+      open: run.open,
+      prefix: run.prefix,
+      textStart: cursor,
+      textEnd: cursor + text.length,
+      text,
+      rPr,
+      leafXml: kind === "text" ? null : child.xml
+    });
+    cursor += text.length;
+  }
+  if (runs.length === 0 || cursor - textStart !== visibleTextLength3(runXml))
+    return single;
+  return { ok: true, runs };
+}
 function buildRunSpan2(runs, rangeStart, rangeEnd) {
   if (rangeEnd <= rangeStart)
     return { ok: false, reason: "invalid-range" };

package/package.json

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