@superdoc/mcp 1.7.0-next.7 → 1.7.0-next.8

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.7";
+var SDK_VERSION = "2.20.0-next.8";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -107235,10 +107235,17 @@ var init_sd_fragment_schema = __esm(() => {
       bottom: { type: "number", minimum: 0 },
       left: { type: "number", minimum: 0 }
     }),
+    SDInboundCellBorders: objectSchema({
+      top: { type: "string" },
+      right: { type: "string" },
+      bottom: { type: "string" },
+      left: { type: "string" }
+    }),
     SDInboundCellProps: objectSchema({
       verticalAlign: { enum: ["top", "center", "bottom"] },
       shading: ref("SDInboundColor"),
-      padding: ref("SDInboundCellPadding")
+      padding: ref("SDInboundCellPadding"),
+      borders: ref("SDInboundCellBorders")
     }),
     SDInboundRun: objectSchema({
       ...idProperty,
@@ -195776,13 +195783,13 @@ function renderPasteTableBlock(spec) {
   const columnWidth = Math.max(1, Math.floor(PASTE_TABLE_GRID_TWIPS / columnCount));
   const grid = `<w:tblGrid>${`<w:gridCol w:w="${columnWidth}"/>`.repeat(columnCount)}</w:tblGrid>`;
   const rows = renderPasteTableRows(spec);
-  return `<w:tbl>${renderPasteTableProperties(spec.styleRef, spec.cellSpacingPt)}${grid}${rows}</w:tbl>`;
+  return `<w:tbl>${renderPasteTableProperties(spec)}${grid}${rows}</w:tbl>`;
 }
 function renderTrackedPasteTableBlock(spec, stamp) {
   const columnCount = tableColumnCount(spec);
   const columnWidth = Math.max(1, Math.floor(PASTE_TABLE_GRID_TWIPS / columnCount));
   const grid = `<w:tblGrid>${`<w:gridCol w:w="${columnWidth}"/>`.repeat(columnCount)}</w:tblGrid>`;
-  return `<w:tbl>${renderPasteTableProperties(spec.styleRef, spec.cellSpacingPt)}${grid}${renderTrackedPasteTableRows(spec, stamp)}</w:tbl>`;
+  return `<w:tbl>${renderPasteTableProperties(spec)}${grid}${renderTrackedPasteTableRows(spec, stamp)}</w:tbl>`;
 }
 function renderPasteTableRows(tableSpec) {
   return tableSpec.rows.map((row) => {
@@ -195811,7 +195818,14 @@ function renderPasteTableCell(cell, renderParagraph = renderPasteParagraphBlock,
   ];
   const margins = marginSides.flatMap(([side, points]) => points === undefined ? [] : [`<w:${side} w:w="${Math.round(points * 20)}" w:type="dxa"/>`]).join("");
   const tcMar = margins ? `<w:tcMar>${margins}</w:tcMar>` : "";
-  const tcPr = `<w:tcPr><w:tcW w:w="0" w:type="auto"/>` + (gridSpan > 1 ? `<w:gridSpan w:val="${gridSpan}"/>` : "") + shading + tcMar + "</w:tcPr>";
+  const borderSides = ["top", "left", "bottom", "right"];
+  const borders = borderSides.flatMap((side) => {
+    const border = cell.borders?.[side];
+    return border ? [border.lineStyle === "nil" ? `<w:${side} w:val="nil"/>` : `<w:${side} w:val="${escapeXmlAttribute(border.lineStyle)}" w:sz="${Math.max(1, Math.round(border.lineWeightPt * 8))}" w:color="${escapeXmlAttribute(border.color.toUpperCase())}"/>`] : [];
+  }).join("");
+  const tcBorders = borders ? `<w:tcBorders>${borders}</w:tcBorders>` : "";
+  const verticalAlign = cell.verticalAlign ? `<w:vAlign w:val="${cell.verticalAlign}"/>` : "";
+  const tcPr = `<w:tcPr><w:tcW w:w="0" w:type="auto"/>` + (gridSpan > 1 ? `<w:gridSpan w:val="${gridSpan}"/>` : "") + tcBorders + shading + tcMar + verticalAlign + "</w:tcPr>";
   return `<w:tc>${tcPr}${cell.paragraphs.map((block) => ("rows" in block) ? renderTable(block) : renderParagraph(block)).join("")}</w:tc>`;
 }
 function renderPasteRunProperties(run, options) {
@@ -196027,10 +196041,17 @@ function renderTrackedChangeOpen(kind, id, stamp, includeRsid, wordPrefix = "w",
 function tableColumnCount(spec) {
   return Math.max(1, ...spec.rows.map((row) => row.cells.reduce((sum, cell) => sum + Math.max(1, cell.gridSpan ?? 1), 0)));
 }
-function renderPasteTableProperties(styleRef, cellSpacingPt) {
+function tableHasExplicitlySuppressedBorders(spec) {
+  return spec.rows.length > 0 && spec.rows.every((row) => row.cells.length > 0 && row.cells.every((cell) => ["top", "right", "bottom", "left"].every((side) => {
+    const border = cell.borders?.[side];
+    return border?.lineStyle === "nil" && border.lineWeightPt === 0 && border.color === "auto";
+  })));
+}
+function renderPasteTableProperties(spec) {
+  const { styleRef, cellSpacingPt } = spec;
   const border = (name) => `<w:${name} w:val="single" w:sz="4" w:space="0" w:color="auto"/>`;
   const style = styleRef ? `<w:tblStyle w:val="${escapeXmlAttribute(styleRef)}"/>` : "";
-  const borders = styleRef ? "" : "<w:tblBorders>" + border("top") + border("left") + border("bottom") + border("right") + border("insideH") + border("insideV") + "</w:tblBorders>";
+  const borders = styleRef || tableHasExplicitlySuppressedBorders(spec) ? "" : "<w:tblBorders>" + border("top") + border("left") + border("bottom") + border("right") + border("insideH") + border("insideV") + "</w:tblBorders>";
   const spacing = cellSpacingPt === undefined ? "" : `<w:tblCellSpacing w:w="${Math.round(cellSpacingPt * 20)}" w:type="dxa"/>`;
   return `<w:tblPr>${style}<w:tblW w:w="5000" w:type="pct"/>${spacing}${borders}</w:tblPr>`;
 }
@@ -227699,6 +227720,8 @@ function pasteTableSpec(block, mintNextParaId, bindW14NamespaceInline, runs = (b
         ...cell.gridSpan !== undefined ? { gridSpan: cell.gridSpan } : {},
         ...cell.shadingColor !== undefined ? { shadingColor: cell.shadingColor } : {},
         ...cell.padding !== undefined ? { padding: cell.padding } : {},
+        ...cell.verticalAlign !== undefined ? { verticalAlign: cell.verticalAlign } : {},
+        ...cell.borders !== undefined ? { borders: cell.borders } : {},
         paragraphs: cell.blocks.map((child) => child.kind === "table" ? pasteTableSpec(child, mintNextParaId, bindW14NamespaceInline, runs) : {
           paraId: mintNextParaId(),
           bindW14NamespaceInline,
@@ -245709,6 +245732,21 @@ function validateBlocks(blocks) {
               if (!hasPaddingSide)
                 return { ok: false, reason: "paste-structure-unsupported" };
             }
+            if (cell.verticalAlign !== undefined && !["top", "center", "bottom"].includes(cell.verticalAlign)) {
+              return { ok: false, reason: "paste-structure-unsupported" };
+            }
+            if (cell.borders !== undefined) {
+              if (typeof cell.borders !== "object" || cell.borders === null || Array.isArray(cell.borders)) {
+                return { ok: false, reason: "paste-structure-unsupported" };
+              }
+              for (const side of ["top", "right", "bottom", "left"]) {
+                const border = cell.borders[side];
+                if (border === undefined)
+                  continue;
+                if (typeof border !== "object" || border === null || Array.isArray(border) || typeof border.lineStyle !== "string" || (border.lineStyle === "nil" ? border.lineWeightPt !== 0 || border.color !== "auto" : !["single", "dashed", "dotted", "double"].includes(border.lineStyle) || typeof border.lineWeightPt !== "number" || !Number.isFinite(border.lineWeightPt) || border.lineWeightPt <= 0 || !Number.isSafeInteger(Math.round(border.lineWeightPt * 8)) || typeof border.color !== "string" || !/^[0-9A-F]{6}$/i.test(border.color)))
+                  return { ok: false, reason: "paste-structure-unsupported" };
+              }
+            }
             budget.blocks += Number(cell.blocks[0]?.kind === "table") + Number(cell.blocks.at(-1)?.kind === "table");
             if (budget.blocks > MAX_PASTE_BLOCKS)
               return { ok: false, reason: "paste-payload-too-large" };
@@ -270802,10 +270840,17 @@ var init_sd_fragment_schema2 = __esm(() => {
       bottom: { type: "number", minimum: 0 },
       left: { type: "number", minimum: 0 }
     }),
+    SDInboundCellBorders: objectSchema3({
+      top: { type: "string" },
+      right: { type: "string" },
+      bottom: { type: "string" },
+      left: { type: "string" }
+    }),
     SDInboundCellProps: objectSchema3({
       verticalAlign: { enum: ["top", "center", "bottom"] },
       shading: ref3("SDInboundColor"),
-      padding: ref3("SDInboundCellPadding")
+      padding: ref3("SDInboundCellPadding"),
+      borders: ref3("SDInboundCellBorders")
     }),
     SDInboundRun: objectSchema3({
       ...idProperty2,
@@ -320447,8 +320492,17 @@ function resolvedDeclarations(element, sheet) {
   if (cached2)
     return cached2;
   const winners = new Map;
+  const rejectedBorders = [];
+  const rejectInvalidBorder = (declaration) => {
+    if (!/^border(?:-(?:top|right|bottom|left))?$/.test(declaration.property) || normalizeCellBorder(declaration.value) !== null)
+      return false;
+    rejectedBorders.push(declaration);
+    return true;
+  };
   for (const rule of matchingRules(element, sheet)) {
     for (const declaration of rule.declarations) {
+      if (rejectInvalidBorder(declaration))
+        continue;
       const current = winners.get(declaration.property);
       if (!current || rule.specificity > current.specificity || rule.specificity === current.specificity && declaration.order >= current.order) {
         winners.set(declaration.property, { ...declaration, specificity: rule.specificity });
@@ -320456,11 +320510,15 @@ function resolvedDeclarations(element, sheet) {
     }
   }
   const styleRange = sourceRangeForAttribute(element, "style");
-  const inline = parseDeclarations(attributeValue2(element, "style") ?? "", () => Number.MAX_SAFE_INTEGER, styleRange);
+  const inlineCss = attributeValue2(element, "style") ?? "";
+  let inlineOrder = Number.MAX_SAFE_INTEGER - inlineCss.length - 1;
+  const inline = parseDeclarations(inlineCss, () => inlineOrder++, styleRange);
   for (const declaration of inline) {
+    if (rejectInvalidBorder(declaration))
+      continue;
     winners.set(declaration.property, { ...declaration, specificity: 1000 });
   }
-  const resolved = [...winners.values()].sort((left, right) => left.order - right.order);
+  const resolved = [...winners.values(), ...rejectedBorders].sort((left, right) => left.order - right.order);
   sheet.resolved.set(element, resolved);
   return resolved;
 }
@@ -320532,6 +320590,12 @@ function parseDeclarations(css, nextOrder, range) {
     if (!property2 || !value2)
       continue;
     const order = nextOrder();
+    if (property2 === "border" && normalizeCellBorder(value2) !== null) {
+      for (const side of ["top", "right", "bottom", "left"]) {
+        declarations.push({ property: `border-${side}`, value: value2, order, ...range ? { range } : {} });
+      }
+      continue;
+    }
     if (property2 === "margin") {
       const tokens = value2.split(/\s+/);
       if (tokens.length >= 1 && tokens.length <= 4) {
@@ -320723,6 +320787,29 @@ function applyCellDeclaration(props, declaration) {
     props.padding = values;
     return true;
   }
+  if (declaration.property === "vertical-align") {
+    const value2 = declaration.value.trim().toLowerCase();
+    if (value2 === "top" || value2 === "bottom")
+      props.verticalAlign = value2;
+    else if (value2 === "middle" || value2 === "center")
+      props.verticalAlign = "center";
+    else
+      return false;
+    return true;
+  }
+  const borderSide = {
+    "border-top": "top",
+    "border-right": "right",
+    "border-bottom": "bottom",
+    "border-left": "left"
+  }[declaration.property];
+  if (declaration.property === "border" || borderSide) {
+    const border = normalizeCellBorder(declaration.value);
+    if (!border)
+      return false;
+    props.borders = declaration.property === "border" ? { top: border, right: border, bottom: border, left: border } : { ...props.borders, [borderSide]: border };
+    return true;
+  }
   const side = {
     "padding-top": "top",
     "padding-right": "right",
@@ -320773,6 +320860,13 @@ function expandBoxLengths(value2) {
   return { top, right, bottom, left };
 }
 function cssLengthToPoints(value2, allowNegative = false) {
+  const points = cssAbsoluteLengthToPoints(value2, allowNegative);
+  if (points === null)
+    return null;
+  const twips = Math.round(points * 20);
+  return Number.isSafeInteger(twips) && Math.abs(points * 20 - twips) <= 0.00000001 ? twips / 20 : null;
+}
+function cssAbsoluteLengthToPoints(value2, allowNegative = false) {
   const trimmed = value2.trim();
   if (trimmed === "0")
     return 0;
@@ -320784,7 +320878,50 @@ function cssLengthToPoints(value2, allowNegative = false) {
     return null;
   const factor = { px: 0.75, pt: 1, in: 72, cm: 72 / 2.54, mm: 72 / 25.4, pc: 12 }[match[2].toLowerCase()];
   const points = amount * factor;
-  return Number.isFinite(points) && Number.isSafeInteger(points * 20) ? points : null;
+  return Number.isFinite(points) ? points : null;
+}
+function normalizeCellBorder(value2) {
+  if (value2.trim().toLowerCase() === "none")
+    return "none";
+  let lineStyle;
+  let lineWeightPt;
+  let zeroWidth = false;
+  let color;
+  for (const token of value2.trim().match(/rgb\([^)]*\)|\S+/gi) ?? []) {
+    const cssStyle = token.toLowerCase();
+    const mappedStyle = { solid: "single", dashed: "dashed", dotted: "dotted", double: "double", none: "nil" }[cssStyle];
+    if (mappedStyle) {
+      if (lineStyle)
+        return null;
+      lineStyle = mappedStyle;
+      continue;
+    }
+    const points = cssAbsoluteLengthToPoints(token);
+    if (points !== null) {
+      if (lineWeightPt !== undefined || zeroWidth)
+        return null;
+      if (!Number.isSafeInteger(Math.round(points * 8)))
+        return null;
+      if (points === 0)
+        zeroWidth = true;
+      else
+        lineWeightPt = points;
+      continue;
+    }
+    const parsedColor = cssColor(token);
+    if (parsedColor?.model === "rgb") {
+      if (color)
+        return null;
+      color = parsedColor.value;
+      continue;
+    }
+    return null;
+  }
+  if (zeroWidth || lineStyle === "nil")
+    return "none";
+  if (!lineStyle || !color)
+    return null;
+  return lineWeightPt !== undefined ? `${lineStyle} ${lineWeightPt}pt #${color}` : null;
 }
 function cssColor(value2) {
   const trimmed = value2.trim();
@@ -320859,9 +320996,15 @@ var init_css = __esm(() => {
     "padding-right",
     "padding-bottom",
     "padding-left",
-    "vertical-align"
+    "vertical-align",
+    "border",
+    "border-top",
+    "border-right",
+    "border-bottom",
+    "border-left"
   ]);
   NAMED_COLORS2 = {
+    windowtext: "000000",
     black: "000000",
     silver: "C0C0C0",
     gray: "808080",
@@ -321815,6 +321958,8 @@ function convertTable(table, context, inherited, path6) {
   const suppressedStyleStart = context.suppressedTableStyleDiagnosticCount;
   context.tableStyleAggregationDepth += 1;
   const tableContext = inlineContextForElement(table, context, inherited, path6);
+  const tableCellProps = cellPropsForElement(table, context.sheet, cssContext(context, path6));
+  const tableBorderSuppression = tableCellProps?.borders && ["top", "right", "bottom", "left"].every((side) => tableCellProps.borders?.[side] === "none");
   const convertedRows = [];
   for (const { row, path: rowPath } of rows) {
     const cells = [];
@@ -321828,7 +321973,14 @@ function convertTable(table, context, inherited, path6) {
       const cellContext = inlineContextForElement(cell, context, tableContext, cellPath, undefined, CELL_NON_RUN_CSS);
       const droppedContentStart = context.droppedContentCount;
       const content = convertFlowChildren(cell.childNodes, context, cellContext, cellPath);
-      const props = cellPropsForElement(cell, context.sheet, cssContext(context, cellPath));
+      const directProps = cellPropsForElement(cell, context.sheet, cssContext(context, cellPath));
+      const props = tableBorderSuppression ? {
+        ...directProps,
+        borders: {
+          ...tableCellProps.borders,
+          ...directProps?.borders
+        }
+      } : directProps;
       cells.push({
         ...props ? { props } : {},
         ...colSpan !== undefined && colSpan > 1 ? { colSpan } : {},
@@ -336087,7 +336239,7 @@ function emphasizeHeaderCellBlock(block) {
 function lowerCellProperties(props, path7) {
   if (!props)
     return {};
-  const supported = new Set(["shading", "padding"]);
+  const supported = new Set(["shading", "padding", "verticalAlign", "borders"]);
   const unsupportedKeys = Object.keys(props).filter((key2) => !supported.has(key2));
   if (unsupportedKeys.length > 0) {
     unsupported4(path7, `Table-cell properties are not materializable: ${unsupportedKeys.sort().join(", ")}.`);
@@ -336105,11 +336257,29 @@ function lowerCellProperties(props, path7) {
     ...props.padding.bottom !== undefined ? { bottomPt: safeScaledNonnegative(props.padding.bottom, 20, [...path7, "padding", "bottom"]) } : {},
     ...props.padding.left !== undefined ? { leftPt: safeScaledNonnegative(props.padding.left, 20, [...path7, "padding", "left"]) } : {}
   } : undefined;
+  const borders = props.borders ? Object.fromEntries(["top", "right", "bottom", "left"].flatMap((side) => {
+    const border = props.borders?.[side];
+    return border ? [[side, lowerCellBorder(border, [...path7, "borders", side])]] : [];
+  })) : undefined;
   return {
     ...shadingColor ? { shadingColor } : {},
-    ...padding && Object.keys(padding).length > 0 ? { padding } : {}
+    ...padding && Object.keys(padding).length > 0 ? { padding } : {},
+    ...props.verticalAlign ? { verticalAlign: props.verticalAlign } : {},
+    ...borders && Object.keys(borders).length > 0 ? { borders } : {}
   };
 }
+function lowerCellBorder(value2, path7) {
+  if (value2 === "none")
+    return { lineStyle: "nil", lineWeightPt: 0, color: "auto" };
+  const match = /^(single|dashed|dotted|double) (\d+(?:\.\d+)?)pt #([0-9A-F]{6})$/.exec(value2);
+  if (!match)
+    unsupported4(path7, "Only normalized solid, dashed, dotted, or double RGB cell borders are materializable.");
+  const lineWeightPt = Number.parseFloat(match[2]);
+  if (!Number.isFinite(lineWeightPt) || lineWeightPt <= 0 || !Number.isSafeInteger(Math.round(lineWeightPt * 8))) {
+    unsupported4(path7, "Cell border weight must produce a positive safe OOXML eighth-point measure.");
+  }
+  return { lineStyle: match[1], lineWeightPt, color: match[3] };
+}
 function positiveInteger(value2, path7) {
   if (!Number.isSafeInteger(value2) || value2 < 1 || value2 > MAX_SIGNED_32_BIT_INTEGER4) {
     invalid3(path7, "Value must be a positive signed 32-bit integer.");
@@ -337374,6 +337544,43 @@ function normalizeTableBlock(block, index2, version2) {
           return fail4("Paste table cell padding requires at least one side.");
         padding = normalized;
       }
+      let verticalAlign;
+      if (cell.verticalAlign !== undefined) {
+        if (cell.verticalAlign !== "top" && cell.verticalAlign !== "center" && cell.verticalAlign !== "bottom") {
+          return fail4("Paste table cell verticalAlign must be top, center, or bottom.");
+        }
+        verticalAlign = cell.verticalAlign;
+      }
+      let borders;
+      if (cell.borders !== undefined) {
+        if (!isRecord14(cell.borders))
+          return fail4("Paste table cell borders must be an object.");
+        const normalized = {};
+        let hasSide = false;
+        for (const side of ["top", "right", "bottom", "left"]) {
+          const border = cell.borders[side];
+          if (border === undefined)
+            continue;
+          if (!isRecord14(border))
+            return fail4(`Paste table cell borders.${side} must be a supported RGB OOXML border.`);
+          const isExplicitNone = border.lineStyle === "nil" && border.lineWeightPt === 0 && border.color === "auto";
+          if (isExplicitNone) {
+            normalized[side] = { lineStyle: "nil", lineWeightPt: 0, color: "auto" };
+          } else {
+            if (typeof border.lineStyle !== "string" || !["single", "dashed", "dotted", "double"].includes(border.lineStyle) || typeof border.lineWeightPt !== "number" || !Number.isFinite(border.lineWeightPt) || border.lineWeightPt <= 0 || !Number.isSafeInteger(Math.round(border.lineWeightPt * 8)) || typeof border.color !== "string" || !/^[0-9a-f]{6}$/i.test(border.color))
+              return fail4(`Paste table cell borders.${side} must be a supported RGB OOXML border.`);
+            normalized[side] = {
+              lineStyle: border.lineStyle,
+              lineWeightPt: border.lineWeightPt,
+              color: border.color.toUpperCase()
+            };
+          }
+          hasSide = true;
+        }
+        if (!hasSide)
+          return fail4("Paste table cell borders requires at least one side.");
+        borders = normalized;
+      }
       const cellBlocks = [];
       for (const [cellBlockIndex, cellBlock] of cell.blocks.entries()) {
         const paragraph3 = normalizeParagraphBlock(cellBlock, ["blocks", index2, "rows", rowIndex, "cells", cellIndex, "blocks", cellBlockIndex], version2, false);
@@ -337389,6 +337596,8 @@ function normalizeTableBlock(block, index2, version2) {
         ...cell.gridSpan !== undefined ? { gridSpan: cell.gridSpan } : {},
         ...shadingColor ? { shadingColor } : {},
         ...padding ? { padding } : {},
+        ...verticalAlign ? { verticalAlign } : {},
+        ...borders ? { borders } : {},
         ...cellSourcePath ? { sourcePath: cellSourcePath } : {}
       });
     }
@@ -339626,18 +339835,17 @@ function readParagraphProperties2(paragraphXml) {
   };
 }
 function readCellFormattingForParagraph(bytes, catalog, paragraphByteStart, notes) {
-  const cell = catalog.tables.flatMap((table) => table.rows).flatMap((row) => row.cells).find((candidate2) => paragraphByteStart >= candidate2.cellByteStart && paragraphByteStart < candidate2.cellByteEnd);
-  if (!cell)
-    return {};
-  const cellXml = SERIALIZE_TD.decode(bytes.subarray(cell.cellByteStart, cell.cellByteEnd));
-  const tcPrMatch = /<(?:[\w.-]+:)?tcPr\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tcPr\s*>)/.exec(cellXml);
-  if (!tcPrMatch)
+  const location2 = catalog.tables.flatMap((table2) => table2.rows.flatMap((row2) => row2.cells.map((cell2) => ({ table: table2, row: row2, cell: cell2 })))).find(({ cell: cell2 }) => paragraphByteStart >= cell2.cellByteStart && paragraphByteStart < cell2.cellByteEnd);
+  if (!location2)
     return {};
-  let tcPr = tcPrMatch[0];
-  if (/<(?:[\w.-]+:)?tcPrChange\b/.test(tcPr)) {
-    tcPr = tcPr.replace(/<(?:[\w.-]+:)?tcPrChange\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tcPrChange\s*>)/g, "");
+  const { table, row, cell } = location2;
+  const originalCellXml = SERIALIZE_TD.decode(bytes.subarray(cell.cellByteStart, cell.cellByteEnd));
+  const cellXml = originalCellXml.replace(/<(?:[\w.-]+:)?tcPrChange\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tcPrChange\s*>)/g, "");
+  if (cellXml !== originalCellXml) {
     notes.add("tcprchange", "Tracked table-cell formatting history is not preserved by copy.", "info");
   }
+  const tcPrMatch = /<(?:[\w.-]+:)?tcPr\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tcPr\s*>)/.exec(cellXml);
+  const tcPr = tcPrMatch?.[0] ?? "";
   let shadingColor;
   const shadingAttrs = /<(?:[\w.-]+:)?shd\b([^>]*)\/>/.exec(tcPr)?.[1];
   if (shadingAttrs !== undefined) {
@@ -339647,6 +339855,57 @@ function readCellFormattingForParagraph(bytes, catalog, paragraphByteStart, note
     else
       notes.add("cell-shading", "Theme or non-solid table-cell shading is not preserved by copy.");
   }
+  const verticalAlignValue = /<(?:[\w.-]+:)?vAlign\b([^>]*)\/?>(?:<\/(?:[\w.-]+:)?vAlign>)?/.exec(tcPr)?.[1];
+  const verticalAlignRaw = verticalAlignValue ? /\b(?:[\w.-]+:)?val\s*=\s*["']([^"']+)["']/.exec(verticalAlignValue)?.[1] : undefined;
+  const verticalAlign = verticalAlignRaw === "top" || verticalAlignRaw === "center" || verticalAlignRaw === "bottom" ? verticalAlignRaw : undefined;
+  if (verticalAlignRaw && !verticalAlign) {
+    notes.add("cell-vertical-alignment", "Unsupported table-cell vertical alignment is not preserved by copy.", "info");
+  }
+  const borders = {};
+  const parseBorder2 = (attrs) => {
+    const value2 = /\b(?:[\w.-]+:)?val\s*=\s*["']([^"']+)["']/.exec(attrs)?.[1];
+    if (value2 === "nil" || value2 === "none")
+      return { lineStyle: "nil", lineWeightPt: 0, color: "auto" };
+    const rawColor = /\b(?:[\w.-]+:)?color\s*=\s*["']([^"']+)["']/.exec(attrs)?.[1];
+    const color2 = rawColor === undefined || rawColor === "auto" ? "000000" : rawColor;
+    const size = /\b(?:[\w.-]+:)?sz\s*=\s*["']([^"']+)["']/.exec(attrs)?.[1];
+    const sizeInEighthPoints = size === undefined ? NaN : Number(size);
+    if (size?.trim() && sizeInEighthPoints === 0 && (value2 === "single" || value2 === "dashed" || value2 === "dotted" || value2 === "double")) {
+      return { lineStyle: "nil", lineWeightPt: 0, color: "auto" };
+    }
+    if ((value2 === "single" || value2 === "dashed" || value2 === "dotted" || value2 === "double") && color2 !== undefined && /^[0-9a-f]{6}$/i.test(color2) && Number.isSafeInteger(sizeInEighthPoints) && sizeInEighthPoints > 0)
+      return { lineStyle: value2, lineWeightPt: sizeInEighthPoints / 8, color: color2.toUpperCase() };
+    notes.add("cell-borders", "Unsupported table-cell border is not preserved by copy.", "info");
+    return;
+  };
+  const readBorders = (container, sides) => Object.fromEntries(sides.flatMap((side) => {
+    const attrs = new RegExp(`<(?:[\\w.-]+:)?${side}\\b([^>]*)\\/?>(?:<\\/(?:[\\w.-]+:)?${side}>)?`).exec(container)?.[1];
+    const border = attrs ? parseBorder2(attrs) : undefined;
+    return border ? [[side, border]] : [];
+  }));
+  const tcBorders = /<(?:[\w.-]+:)?tcBorders\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tcBorders\s*>)/.exec(tcPr)?.[0];
+  Object.assign(borders, tcBorders ? readBorders(tcBorders, ["top", "right", "bottom", "left"]) : {});
+  const tableXml = SERIALIZE_TD.decode(bytes.subarray(table.tableByteStart, table.tableByteEnd)).replace(/<(?:[\w.-]+:)?tblPrChange\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tblPrChange\s*>)/g, "");
+  const tblPr = /<(?:[\w.-]+:)?tblPr\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tblPr\s*>)/.exec(tableXml)?.[0];
+  const tblBorders = tblPr && /<(?:[\w.-]+:)?tblBorders\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tblBorders\s*>)/.exec(tblPr)?.[0];
+  if (tblBorders) {
+    const tableBorders = readBorders(tblBorders, ["top", "right", "bottom", "left", "insideH", "insideV"]);
+    const columnCount = Math.max(table.gridColumnCount, ...table.rows.map((candidate2) => candidate2.gridCellCount));
+    const atTop = row.rowIndex === 0;
+    const atBottom = row.rowIndex === table.rows.length - 1;
+    const atLeft = cell.gridColumnStart === 0;
+    const atRight = cell.gridColumnStart + cell.gridSpan >= columnCount;
+    const fallbackEdges = {
+      top: tableBorders[atTop ? "top" : "insideH"],
+      right: tableBorders[atRight ? "right" : "insideV"],
+      bottom: tableBorders[atBottom ? "bottom" : "insideH"],
+      left: tableBorders[atLeft ? "left" : "insideV"]
+    };
+    for (const side of ["top", "right", "bottom", "left"]) {
+      if (borders[side] === undefined && fallbackEdges[side] !== undefined)
+        borders[side] = fallbackEdges[side];
+    }
+  }
   const padding = {};
   const tcMar = /<(?:[\w.-]+:)?tcMar\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?tcMar\s*>)/.exec(tcPr)?.[0];
   if (tcMar) {
@@ -339668,7 +339927,9 @@ function readCellFormattingForParagraph(bytes, catalog, paragraphByteStart, note
   }
   return {
     ...shadingColor ? { shadingColor } : {},
-    ...Object.keys(padding).length > 0 ? { padding } : {}
+    ...Object.keys(padding).length > 0 ? { padding } : {},
+    ...verticalAlign ? { verticalAlign } : {},
+    ...Object.keys(borders).length > 0 ? { borders } : {}
   };
 }
 function readTableCellSpacingForParagraph(bytes, catalog, paragraphByteStart, notes) {
@@ -339727,6 +339988,8 @@ function groupTableBlocks(blocks) {
         ...coord.gridSpan !== undefined ? { gridSpan: coord.gridSpan } : {},
         ...coord.shadingColor !== undefined ? { shadingColor: coord.shadingColor } : {},
         ...coord.padding !== undefined ? { padding: coord.padding } : {},
+        ...coord.verticalAlign !== undefined ? { verticalAlign: coord.verticalAlign } : {},
+        ...coord.borders !== undefined ? { borders: coord.borders } : {},
         blocks: []
       };
       row.cells.push(cell);
@@ -339808,6 +340071,8 @@ function fragmentBlockFor(grouped) {
         ...cell.gridSpan !== undefined ? { gridSpan: cell.gridSpan } : {},
         ...cell.shadingColor !== undefined ? { shadingColor: cell.shadingColor } : {},
         ...cell.padding !== undefined ? { padding: cell.padding } : {},
+        ...cell.verticalAlign !== undefined ? { verticalAlign: cell.verticalAlign } : {},
+        ...cell.borders !== undefined ? { borders: cell.borders } : {},
         blocks: cell.blocks.map(paragraphFragmentFor)
       }))
     }))
@@ -339825,6 +340090,8 @@ function richFragmentBlockFor(grouped) {
         ...cell.gridSpan !== undefined ? { gridSpan: cell.gridSpan } : {},
         ...cell.shadingColor !== undefined ? { shadingColor: cell.shadingColor } : {},
         ...cell.padding !== undefined ? { padding: cell.padding } : {},
+        ...cell.verticalAlign !== undefined ? { verticalAlign: cell.verticalAlign } : {},
+        ...cell.borders !== undefined ? { borders: cell.borders } : {},
         blocks: cell.blocks.map(richParagraphFragmentFor)
       }))
     }))
@@ -339918,6 +340185,14 @@ function tableCellHtmlStyle(cell) {
   const styles = [];
   if (cell.shadingColor)
     styles.push(`background-color: #${cell.shadingColor}`);
+  if (cell.verticalAlign)
+    styles.push(`vertical-align: ${cell.verticalAlign === "center" ? "middle" : cell.verticalAlign}`);
+  for (const side of ["top", "right", "bottom", "left"]) {
+    const border = cell.borders?.[side];
+    if (!border)
+      continue;
+    styles.push(border.lineStyle === "nil" ? `border-${side}: none` : `border-${side}: ${border.lineStyle === "single" ? "solid" : border.lineStyle} ${border.lineWeightPt}pt #${border.color}`);
+  }
   const padding = cell.padding;
   if (padding) {
     const sides = [padding.topPt, padding.rightPt, padding.bottomPt, padding.leftPt];

package/package.json

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