doc-codec 1.1.2 → 2.0.0

package/dist/table/decoration.js

@@ -1,6 +1,7 @@
-import { DocFormatError } from "../errors.js";
+import { DocFormatError, DocUnsupportedError } from "../errors.js";
 import { readUint16LE, readUint8 } from "../bytes.js";
 import { autoColorRefBytes, colorRefBytes, decorativeIcoColor, icoColor, nearestIco, readColorRef } from "../color.js";
+import { unrecognizedFillKind } from "document-schema.js";
 //#region src/table/decoration.ts
 /** The four sides of a cell, in the order TC80 declares them ([MS-DOC] 2.9.313: brcTop, brcLeft, brcBottom, brcRight). Used as the iteration order for both directions, so a side can never be read from one offset and written to another. */
 const CELL_BORDER_SIDES = [
@@ -77,6 +78,10 @@ const EIGHTHS_PER_POINT = 8;
 const MIN_DPT_LINE_WIDTH = 2;
 /** dptLineWidth is a single byte, so 255 eighths (31.875pt) is the widest border the format can state at all. */
 const MAX_DPT_LINE_WIDTH = 255;
+/** For BrcType 0x03 (ECMA-376 ST_Border 'double') specifically, dptLineWidth states the width of one of the border's two lines, with the gap between them the same width again, rather than the border's own total rendered width -- neither [MS-DOC] nor [ECMA-376] says so in words, but LibreOffice's own WW8 border-width conversion (editeng/source/items/borderline.cxx: BorderWidthImpl for SvxBorderLineStyle::DOUBLE splits a total width into three equal 1/3 shares for line/gap/line on import, and ConvertBorderWidthToWord divides a total width by 3 on export) states it in code, and this package's own measurements agree with that split exactly: a dptLineWidth of 5 read from a genuine LibreOffice-authored file tripled to 15 eighths (1.875pt) is what LibreOffice's own re-export calls the identical border ~1.8pt double (the small remaining gap is LibreOffice's own twip-rounding on the way through its internal representation, not a further disagreement), and writing a 2pt double border under the pre-fix formula (dptLineWidth 16, i.e. widthPt taken as the field directly) came back from LibreOffice as 6pt double -- 16 read as a single line's width and tripled is exactly 6pt. Scoped to the literal 0x03 value rather than every brcType BRC_TYPE_STYLE collapses onto 'double': the same ConvertBorderWidthToWord gives most of the others their own explicit ratio too, not none -- fWidth/2.0 for THINTHICK_MEDIUMGAP/THICKTHIN_MEDIUMGAP/EMBOSSED/ENGRAVED (BrcTypes 0x0e/0x0f/0x18/0x19), a fixed line/gap width subtracted from the total for THINTHICK_SMALLGAP/THINTHICK_LARGEGAP/THICKTHIN_SMALLGAP/THICKTHIN_LARGEGAP (0x0b/0x11/0x0c/0x12), and that same subtraction halved afterwards for OUTSET/INSET (0x1a/0x1b) -- `std::max(1.0, (fWidth - OUTSET_line1) / 2.0)` and its INSET mirror, not a bare subtraction the way the SMALLGAP/LARGEGAP quartet's own formulas are -- known ratios this package deliberately does not apply, not unknown ones, because BRC_TYPE_STYLE has already collapsed every one of those, plus triple, the three-line thinThickThin gap variants, and doubleWave (none of which LibreOffice's own WW8 exporter writes at all, having no SvxBorderLineStyle member for them), onto ContentStrokeStyle's single 'double' member by the time a ContentBorder reaches dptLineWidthFor on write, so there is no way left to tell which family a given widthPt came from and therefore no way to choose the right one of even the formulas that are known; literal 0x03 is the one case free of that ambiguity, since it is the only BrcType every format in this family's own 'double' token (OOXML's w:val="double", ODF's fo:border-* double) and ContentStrokeStyle's own 'double' member actually mean. Reading one of the other 23 collapsed BrcTypes therefore still reports dptLineWidth's own untripled value as widthPt -- an approximation of unknown accuracy even before this correction existed -- and writing that value back re-emits it as a literal 0x03 with this multiplier applied regardless, a further, compounding approximation on an already-lossy round trip for that narrow, WW8-only decorative corner; decoration.test.ts pins this explicitly rather than leaving it a silent surprise. */
+const DOUBLE_BORDER_WIDTH_MULTIPLIER = 3;
+/** The lowest non-zero dptLineWidth this writer will ever store for a BRC_TYPE_DOUBLE border's own one-third-of-total field, once DOUBLE_BORDER_WIDTH_MULTIPLIER's own division has been applied -- not MIN_DPT_LINE_WIDTH's floor of 2, which belongs to a field that states a border's whole width directly. [MS-DOC]'s "values of less than 2 are considered to be equivalent to 2" is a read-side interpretation rule, not a constraint a producer's own writer has to respect when choosing what to store: LibreOffice's own WW8 export (sw/source/filter/ww8/ww8atr.cxx, TranslateBorderLine, calling editeng's ConvertBorderWidthToWord) applies two separate floors in two different units at two different stages, not one shared floor -- ConvertBorderWidthToWord's own std::max(1.0, fWidth / 3.0) floors double's one-third share to 1.0 twip while the value is still in twips; the result is then converted to eighths-of-a-point ("nWidth = ((nWidth * 8) + 10) / 20", an integer, rounding conversion), which truncates that 1-twip minimum straight down to 0; only then does the "if (0 == nWidth) nWidth = 1; // really thin line, don't omit" floor re-raise it, to 1 eighth-of-a-point (2.5 twips) -- a different, larger unit than the 1.0 twip the first floor stated. The two are analogous in pattern (each is its own never-quite-zero minimum-of-1 rule) but not identical in value, and it is the second, eighths-of-a-point floor MIN_DPT_LINE_WIDTH_DOUBLE mirrors, since that is the one that actually survives into the written BRC. Keeping the general single-line refusal at 2 (MIN_DPT_LINE_WIDTH, a genuinely different field-to-width relationship) while giving double its own floor of 1 keeps refusal for a width the format truly cannot state at all -- below roughly 0.1875pt total, where even a tripled dptLineWidth of 1 rounds down to 0 -- rather than at 0.5625pt, a threshold that only exists as an artefact of applying MIN_DPT_LINE_WIDTH's single-line floor after dividing by three and that no real producer observes: Word's own UI default border width (ooxml.js's own DEFAULT_BORDER_WIDTH_EIGHTH_POINTS, 0.5pt) would otherwise be unwritable as a double border at all. */
+const MIN_DPT_LINE_WIDTH_DOUBLE = 1;
 /** The colour a border with no colour of its own resolves to. [MS-DOC]'s automatic colour (Ico 0x00, or a COLORREF with fAuto set) "designates the default color for the application" and names no components, but ContentBorder.color is required, so a border stating one has to resolve to something. Black is what an automatic border renders as against a default background, and resolving to it keeps the border itself -- which genuinely exists and genuinely renders -- rather than dropping the border outright to avoid stating a colour for it. */
 const AUTOMATIC_BORDER_COLOR = {
 	r: 0,
@@ -86,9 +91,11 @@ const AUTOMATIC_BORDER_COLOR = {
 function borderFrom(dptLineWidth, brcType, color) {
 	const style = BRC_TYPE_STYLE[brcType];
 	if (style === void 0) return void 0;
+	const lineWidthEighths = Math.max(dptLineWidth, MIN_DPT_LINE_WIDTH);
+	const widthEighths = brcType === BRC_TYPE_DOUBLE ? lineWidthEighths * DOUBLE_BORDER_WIDTH_MULTIPLIER : lineWidthEighths;
 	const border = {
 		color: color ?? AUTOMATIC_BORDER_COLOR,
-		widthPt: Math.max(dptLineWidth, MIN_DPT_LINE_WIDTH) / EIGHTHS_PER_POINT
+		widthPt: widthEighths / EIGHTHS_PER_POINT
 	};
 	if (style !== "solid") border.style = style;
 	return border;
@@ -112,6 +119,24 @@ function readBrc(bytes, offset) {
 	if (brcType === BRC_TYPE_NONE) return void 0;
 	return borderFrom(readUint8(bytes, offset + 4), brcType, readColorRef(bytes, offset));
 }
+function readTableBordersFields(operand, fieldSize, readField) {
+	return {
+		top: readField(operand, 1),
+		left: readField(operand, 1 + fieldSize),
+		bottom: readField(operand, 1 + fieldSize * 2),
+		right: readField(operand, 1 + fieldSize * 3),
+		insideHorizontal: readField(operand, 1 + fieldSize * 4),
+		insideVertical: readField(operand, 1 + fieldSize * 5)
+	};
+}
+/** TableBordersOperand's own 49 bytes ([MS-DOC] 2.9.302): cb (1 byte, MUST be 0x30) then six real Brc fields (8 bytes each, 2.9.16) back to back -- brcTop, brcLeft, brcBottom, brcRight, brcHorizontalInside, brcVerticalInside -- each an exact COLORREF exactly like sprmTSetBrc's own per-cell layer. */
+function readTableBordersOperand(operand) {
+	return readTableBordersFields(operand, 8, readBrc);
+}
+/** TableBordersOperand80's own 25 bytes ([MS-DOC] 2.9.303): the Word 97-era spelling, cb (1 byte, MUST be 0x18) then the same six fields as Brc80MayBeNil (4 bytes each, 2.9.18), palette-indexed exactly like TC80's own Brc80 fields. */
+function readTableBordersOperand80(operand) {
+	return readTableBordersFields(operand, 4, readBrc80);
+}
 /** Brc80MayBeNil's own no-border value, [MS-DOC] 2.9.18: "When all bits are set (0xFFFFFFFF when interpreted as a 4-byte unsigned integer), this structure specifies that the region in question has no border." */
 const NIL_BRC80 = [
 	255,
@@ -119,28 +144,36 @@ const NIL_BRC80 = [
 	255,
 	255
 ];
-/** dptLineWidth for a border of `widthPt`, in the 1/8-point increments [MS-DOC] states it in. Refuses a width the single-byte field cannot hold rather than silently clamping it to a thinner border than the caller asked for, matching how every other out-of-range operand in this writer is handled. */
-function dptLineWidthFor(widthPt) {
-	const eighths = Math.round(widthPt * EIGHTHS_PER_POINT);
-	if (eighths < MIN_DPT_LINE_WIDTH || eighths > MAX_DPT_LINE_WIDTH) throw new DocFormatError(`a table cell border is ${widthPt}pt, outside the ${MIN_DPT_LINE_WIDTH / EIGHTHS_PER_POINT}..${MAX_DPT_LINE_WIDTH / EIGHTHS_PER_POINT}pt range [MS-DOC]'s own single-byte dptLineWidth can state in 1/8-point increments`);
+/** dptLineWidth for a border of `widthPt` rendered as `brcType`, in the 1/8-point increments [MS-DOC] states it in. For BRC_TYPE_DOUBLE, `widthPt` is the border's own total rendered width and the field holds one third of it (see DOUBLE_BORDER_WIDTH_MULTIPLIER's own note); every other brcType states `widthPt` directly. Refuses a width the single-byte field cannot hold rather than silently clamping it to a thinner border than the caller asked for, matching how every other out-of-range operand in this writer is handled -- the minimum itself is brcType-dependent (see MIN_DPT_LINE_WIDTH_DOUBLE's own note for why double's own floor is lower than the general one). Accepting a width does not mean it always survives a round trip unchanged, though: for any `double` `widthPt` in the 0.1875pt (inclusive) to 0.5625pt (exclusive) range, the stored dptLineWidth is exactly 1 -- the one value MIN_DPT_LINE_WIDTH_DOUBLE permits that MIN_DPT_LINE_WIDTH would not -- and borderFrom's own read-side floor then raises that 1 to 2 before DOUBLE_BORDER_WIDTH_MULTIPLIER's tripling applies, so e.g. a border written at 0.5pt reads back as 0.75pt, 50% wider than requested. This is a real, [MS-DOC]-consistent narrowing this function deliberately accepts rather than refuses ("values less than 2 are considered to be equivalent to 2" is exactly what a real producer's own reader would apply to the identical bytes), not a silent bug -- decoration.test.ts pins the exact numbers. */
+function dptLineWidthFor(widthPt, brcType) {
+	const multiplier = brcType === BRC_TYPE_DOUBLE ? DOUBLE_BORDER_WIDTH_MULTIPLIER : 1;
+	const minEighths = brcType === BRC_TYPE_DOUBLE ? MIN_DPT_LINE_WIDTH_DOUBLE : MIN_DPT_LINE_WIDTH;
+	const eighths = Math.round(widthPt / multiplier * EIGHTHS_PER_POINT);
+	if (eighths < minEighths || eighths > MAX_DPT_LINE_WIDTH) {
+		const minPt = (minEighths - .5) * multiplier / EIGHTHS_PER_POINT;
+		const maxPt = 255.5 * multiplier / EIGHTHS_PER_POINT;
+		throw new DocFormatError(`a table cell border is ${widthPt}pt, outside the ${minPt}..${maxPt}pt range [MS-DOC]'s own single-byte dptLineWidth can state in 1/8-point increments${brcType === BRC_TYPE_DOUBLE ? " of one line's own width, a double border's field being one third of its total rendered width" : ""}`);
+	}
 	return eighths;
 }
 /** One TC80 border field's own four bytes: the Brc80MayBeNil no-border sentinel for an absent border, otherwise a real Brc80 whose colour is the nearest Ico the fixed palette offers (see color.ts's nearestIco, and borderNeedsExactColor for how the exact colour still reaches the file). dptSpace, fShadow and fFrame are always zero -- ContentBorder models none of the three, so writing anything else would be inventing a fact the input never stated. */
 function writeBrc80(border) {
 	if (border === void 0) return [...NIL_BRC80];
+	const brcType = STYLE_BRC_TYPE[border.style ?? "solid"];
 	return [
-		dptLineWidthFor(border.widthPt),
-		STYLE_BRC_TYPE[border.style ?? "solid"],
+		dptLineWidthFor(border.widthPt, brcType),
+		brcType,
 		nearestIco(border.color),
 		0
 	];
 }
 /** One TableBrcOperand.brc field's own eight bytes: a real Brc carrying the border's colour exactly, as a COLORREF rather than a palette index. Only ever called for a border that exists, since a TableBrcOperand naming no sides is never emitted at all. */
 function writeBrc(border) {
+	const brcType = STYLE_BRC_TYPE[border.style ?? "solid"];
 	return [
 		...colorRefBytes(border.color),
-		dptLineWidthFor(border.widthPt),
-		STYLE_BRC_TYPE[border.style ?? "solid"],
+		dptLineWidthFor(border.widthPt, brcType),
+		brcType,
 		0,
 		0
 	];
@@ -153,41 +186,118 @@ function borderNeedsExactColor(border) {
 	const approximated = colorRefBytes(palette);
 	return wanted[0] !== approximated[0] || wanted[1] !== approximated[1] || wanted[2] !== approximated[2];
 }
-/** ipatAuto, [MS-DOC] 2.9.121: "Clear, ST_Shd: clear" -- the pattern under which a cell simply shows its own cvBack, which is how both Word and LibreOffice spell a flat background colour, and the only pattern this package writes. */
+/** ipatAuto, [MS-DOC] 2.9.121: "Clear, ST_Shd: clear" -- the pattern under which a cell simply shows its own cvBack, which is how both Word and LibreOffice spell a flat background colour. */
 const IPAT_AUTO = 0;
 /** ipatSolid, [MS-DOC] 2.9.121: "Solid ST_Shd: solid" -- the cell is filled entirely with cvFore. */
 const IPAT_SOLID = 1;
 /**
-* One Shd ([MS-DOC] 2.9.247) as a flat background colour, or undefined where it states none.
+* Every Ipat value [MS-DOC] 2.9.121 maps onto a real ECMA-376 ST_Shd token, to the ContentCellPatternType name document-schema.js's own ContentCellPatternTypeSchema gives that same ST_Shd token (see that schema's own top comment for the full citation and the two vocabularies' shared naming rationale). ipatAuto and ipatSolid are handled by their own callers rather than listed here, since each resolves to a 'solid' fill, not a 'pattern' one. The sixteen ipatPctNew* fine percentages [MS-DOC] itself says "SHOULD NOT be used" (2.9.121's own note) and that have no ST_Shd equivalent at all -- 2.5%, 7.5%, 17.5%, 22.5%, 27.5%, 32.5%, 42.5%, 47.5%, 52.5%, 57.5%, 67.5%, 72.5%, 77.5%, 82.5%, 92.5%, 97.5% -- are deliberately absent, exactly as ContentCellPatternTypeSchema deliberately has no member for them; a cell stating one of these reads as no background, the same fallback every other genuinely unrepresentable Ipat value already resolves to.
+*/
+const IPAT_TO_PATTERN_TYPE = {
+	2: "percent5",
+	3: "percent10",
+	4: "percent20",
+	5: "percent25",
+	6: "percent30",
+	7: "percent40",
+	8: "percent50",
+	9: "percent60",
+	10: "percent70",
+	11: "percent75",
+	12: "percent80",
+	13: "percent90",
+	14: "horizontalStripe",
+	15: "verticalStripe",
+	16: "reverseDiagonalStripe",
+	17: "diagonalStripe",
+	18: "horizontalCross",
+	19: "diagonalCross",
+	20: "thinHorizontalStripe",
+	21: "thinVerticalStripe",
+	22: "thinReverseDiagonalStripe",
+	23: "thinDiagonalStripe",
+	24: "thinHorizontalCross",
+	25: "thinDiagonalCross",
+	37: "percent12",
+	38: "percent15",
+	43: "percent35",
+	44: "percent37",
+	46: "percent45",
+	49: "percent55",
+	51: "percent62",
+	52: "percent65",
+	57: "percent85",
+	58: "percent87",
+	60: "percent95"
+};
+/** The inverse of IPAT_TO_PATTERN_TYPE, built from it rather than restated by hand so the two can never drift apart. Every ContentCellPatternType this package's own writer is ever asked to state has an entry, since the Word-family half of the shared vocabulary is exactly IPAT_TO_PATTERN_TYPE's own value set -- the SpreadsheetML-only members (mediumGray through gray0625) are absent, ST_Shd having no equivalent for them at all. */
+const PATTERN_TYPE_TO_IPAT = new Map(Object.entries(IPAT_TO_PATTERN_TYPE).map(([ipat, patternType]) => [patternType, Number(ipat)]));
+/**
+* One Shd ([MS-DOC] 2.9.247) as a ContentCellFill, or undefined where it states none.
 *
-* Only the two patterns that genuinely produce a flat fill resolve: ipatAuto, under which the cell shows cvBack (ECMA-376's own `clear` shading with a fill colour, which is what a real producer writes for a plain cell background), and ipatSolid, under which it shows cvFore. Every other Ipat -- the fourteen percentage fills, the stripe and crosshatch families, and ipatNil -- is a genuine pattern that Color cannot express, and reads as no background rather than as one of its two colours: reporting a 50% grey crosshatch as its own foreground colour would misstate what the cell actually shows. This is the same deliberate judgment xls-codec makes for BIFF8's own FillPattern enumeration, for the same reason, and it costs nothing on a round trip because this package's own writer emits ipatAuto and nothing else.
+* ipatAuto resolves to a 'solid' fill of cvBack (ECMA-376's own `clear` shading with a fill colour, which is what a real producer writes for a plain cell background) and ipatSolid to a 'solid' fill of cvFore. Every other named Ipat resolves to a real 'pattern' fill via IPAT_TO_PATTERN_TYPE, carrying whichever of cvFore/cvBack the cell actually states -- either may be cvAuto (the application's own default) and therefore absent, matching ContentCellFillSchema's own "a colour can defer instead of asserting" convention. ipatNil and the sixteen ipatPctNew* values with no ST_Shd equivalent (see IPAT_TO_PATTERN_TYPE's own note) resolve to no background at all, the same fallback this reader has always used for a pattern it cannot express.
 *
-* A cvAuto colour under either pattern is likewise no background: it designates the application's own default, which for a cell background is "not shaded" rather than a colour to state. ShdAuto and ShdNil -- the two special values [MS-DOC] 2.9.247 names for "no shading is applied" -- both fall out of exactly that, with no separate check: each is a pair of cvAuto colours under ipatAuto.
+* A cvAuto colour under ipatAuto/ipatSolid is likewise no background: it designates the application's own default, which for a cell background is "not shaded" rather than a colour to state. ShdAuto and ShdNil -- the two special values [MS-DOC] 2.9.247 names for "no shading is applied" -- both fall out of exactly that, with no separate check: each is a pair of cvAuto colours under ipatAuto.
 */
 function readShd(bytes, offset) {
-	const ipat = readUint16LE(bytes, offset + 8);
-	if (ipat === IPAT_AUTO) return readColorRef(bytes, offset + 4);
-	if (ipat === IPAT_SOLID) return readColorRef(bytes, offset);
+	return shdFill(readColorRef(bytes, offset), readColorRef(bytes, offset + 4), readUint16LE(bytes, offset + 8));
 }
-/** One Shd's own ten bytes: cvFore left automatic and the background stated as cvBack under ipatAuto, which is exactly how LibreOffice 26.2.5.2 writes a cell fill (confirmed against its own `.doc` output: a #ffff00 cell came back as cvFore cvAuto, cvBack `ff ff 00 00`, ipat 0x0000). An absent background writes ShdAuto -- the all-automatic value [MS-DOC] 2.9.247 defines as "no shading is applied" -- so an undecorated cell inside a row that has decorated ones still states its own lack of shading rather than inheriting a neighbour's. */
-function writeShd(background) {
-	return [
+/** Resolves one cvFore/cvBack/ipat triple -- however the caller sourced the three, whether from Shd's own COLORREFs (readShd) or Shd80's Ico-palette pair (readShd80) -- into the ContentCellFill readShd's own doc comment describes. Shared so the two callers can never disagree about what a given ipat means. */
+function shdFill(cvFore, cvBack, ipat) {
+	if (ipat === IPAT_AUTO) return cvBack === void 0 ? void 0 : {
+		kind: "solid",
+		color: cvBack
+	};
+	if (ipat === IPAT_SOLID) return cvFore === void 0 ? void 0 : {
+		kind: "solid",
+		color: cvFore
+	};
+	const patternType = IPAT_TO_PATTERN_TYPE[ipat];
+	if (patternType === void 0) return void 0;
+	return {
+		kind: "pattern",
+		patternType,
+		...cvFore !== void 0 ? { foregroundColor: cvFore } : {},
+		...cvBack !== void 0 ? { backgroundColor: cvBack } : {}
+	};
+}
+/** One Shd's own ten bytes, the inverse of readShd: a 'solid' fill states cvFore automatic and the fill's own colour as cvBack under ipatAuto, exactly how LibreOffice 26.2.5.2 writes a plain cell fill (confirmed against its own `.doc` output: a #ffff00 cell came back as cvFore cvAuto, cvBack `ff ff 00 00`, ipat 0x0000) -- writing ipatSolid instead would be an equally spec-conformant alternative Shd never needed, since the two patterns are read identically apart from which COLORREF they draw from. A 'pattern' fill states its own foreground/background colours (automatic where the fill left one unstated) under the Ipat value PATTERN_TYPE_TO_IPAT names for it, throwing DocUnsupportedError for a SpreadsheetML-only pattern type ([MS-DOC]'s Ipat vocabulary has no member for one -- see PATTERN_TYPE_TO_IPAT's own note) rather than silently writing the wrong pattern or dropping it. An absent fill writes ShdAuto -- the all-automatic value [MS-DOC] 2.9.247 defines as "no shading is applied" -- so an undecorated cell inside a row that has decorated ones still states its own lack of shading rather than inheriting a neighbour's. */
+function writeShd(fill) {
+	if (fill === void 0) return [
+		...autoColorRefBytes(),
 		...autoColorRefBytes(),
-		...background === void 0 ? autoColorRefBytes() : colorRefBytes(background),
 		0,
 		0
 	];
+	switch (fill.kind) {
+		case "solid": return [
+			...autoColorRefBytes(),
+			...colorRefBytes(fill.color),
+			0,
+			0
+		];
+		case "pattern": {
+			const ipat = PATTERN_TYPE_TO_IPAT.get(fill.patternType);
+			if (ipat === void 0) throw new DocUnsupportedError(`doc-codec cannot write a '${fill.patternType}' cell fill: [MS-DOC]'s own Ipat enumeration has no member for it, that pattern name belonging only to SpreadsheetML's ST_PatternType half of ContentCellPatternType's shared vocabulary`);
+			return [
+				...fill.foregroundColor === void 0 ? autoColorRefBytes() : colorRefBytes(fill.foregroundColor),
+				...fill.backgroundColor === void 0 ? autoColorRefBytes() : colorRefBytes(fill.backgroundColor),
+				ipat & 255,
+				ipat >> 8 & 255
+			];
+		}
+		default: throw new DocUnsupportedError(`doc-codec cannot write a cell fill with kind '${unrecognizedFillKind(fill)}': ContentCellFillSchema's discriminated union only defines 'solid' and 'pattern'`);
+	}
 }
 /** Shd80Nil, [MS-DOC] 2.9.248: icoFore 0x1F, icoBack 0x1F, ipat 0x3F -- every bit set, "specifies that no shading is applied", and explicitly exempt from the Ico and Ipat bounds the fields otherwise carry. */
 const SHD80_NIL = 65535;
-/** One Shd80 ([MS-DOC] 2.9.248) as a flat background colour: the same ipatAuto/ipatSolid reading readShd applies, over the Ico palette rather than COLORREFs. This is the Word 97-era spelling of cell shading, superseded by Shd but still written -- alongside it -- by a real producer, so a file carrying only this one still reads. Never written by this package, which states shading through Shd alone. icoFore/icoBack are each a 5-bit field, so a value the 17-entry palette cannot hold is a real possibility rather than a format-level impossibility; decorativeIcoColor resolves that case to no background instead of aborting the whole document read. */
+/** One Shd80 ([MS-DOC] 2.9.248) as a ContentCellFill: the same Ipat vocabulary readShd resolves, over the Ico palette rather than COLORREFs. This is the Word 97-era spelling of cell shading, superseded by Shd but still written -- alongside it -- by a real producer, so a file carrying only this one still reads. Never written by this package, which states shading through Shd alone. icoFore/icoBack are each a 5-bit field, so a value the 17-entry palette cannot hold is a real possibility rather than a format-level impossibility; decorativeIcoColor resolves that case to no concrete colour (the same fallback cvAuto already gets) instead of aborting the whole document read. */
 function readShd80(value) {
 	if (value === SHD80_NIL) return void 0;
 	const icoFore = value & 31;
 	const icoBack = value >> 5 & 31;
 	const ipat = value >> 10 & 63;
-	if (ipat === IPAT_AUTO) return decorativeIcoColor(icoBack);
-	if (ipat === IPAT_SOLID) return decorativeIcoColor(icoFore);
+	return shdFill(decorativeIcoColor(icoFore), decorativeIcoColor(icoBack), ipat);
 }
 /** A cell's four sides as a ContentCellBorders, or undefined when it has none -- the shape ContentTableCell.borders carries, with an absent side meaning that side has no border rather than an explicitly-null one. */
 function cellBordersFrom(sides) {
@@ -202,4 +312,4 @@ function cellBordersFrom(sides) {
 	return any ? borders : void 0;
 }
 //#endregion
-export { BORDERS_TO_APPLY, BRC80_SIZE, BRC_SIZE, CELL_BORDER_SIDES, SHD80_SIZE, SHD_SIZE, borderNeedsExactColor, cellBordersFrom, readBrc, readBrc80, readShd, readShd80, writeBrc, writeBrc80, writeShd };
+export { BORDERS_TO_APPLY, BRC80_SIZE, BRC_SIZE, CELL_BORDER_SIDES, SHD80_SIZE, SHD_SIZE, borderNeedsExactColor, cellBordersFrom, readBrc, readBrc80, readShd, readShd80, readTableBordersOperand, readTableBordersOperand80, writeBrc, writeBrc80, writeShd };

package/dist/table/read.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_errors = require("../errors.cjs");
 require("../text/special.cjs");
+const require_table_decoration = require("./decoration.cjs");
 const require_table_tap = require("./tap.cjs");
 //#region src/table/read.ts
 const TWIPS_PER_POINT = 20;
@@ -74,6 +75,7 @@ function tryAssembleTable(runEntries) {
 					horzMerge: merge.horzMerge,
 					vertMerge: merge.vertMerge,
 					borders: merge.borders,
+					clearedSides: merge.clearedSides,
 					background: merge.background,
 					blocks: cell.blocks
 				};
@@ -94,10 +96,61 @@ function tryAssembleTable(runEntries) {
 	const columnBoundariesTwips = canonicalColumnBoundariesTwips(rowDefinitions, toleranceTwips);
 	return {
 		kind: "table",
-		rows: buildRows(rawRows, rowDefinitions, columnBoundariesTwips, rowHeights, toleranceTwips),
+		rows: buildRows(applyRowLevelBorderCascade(rawRows, rowDefinitions, columnBoundariesTwips, toleranceTwips), rowDefinitions, columnBoundariesTwips, rowHeights, toleranceTwips),
 		columnWidthsPt: columnWidthsFromBoundaries(columnBoundariesTwips)
 	};
 }
+function applyRowLevelBorderCascade(rows, definitions, canonicalBoundariesTwips, toleranceTwips) {
+	const lastRowIndex = rows.length - 1;
+	const lastRowBorders = definitions[lastRowIndex]?.rowBorders;
+	const logicalRows = rows.map((row, rowIndex) => {
+		const definition = definitions[rowIndex];
+		if (definition === void 0) throw new require_errors.DocFormatError(`internal defect: table row ${rowIndex} has no TAP definition despite the earlier length check`);
+		return logicalCellsForRow(row, definition.columnBoundariesTwips, canonicalBoundariesTwips, toleranceTwips);
+	});
+	return rows.map((cells, rowIndex) => {
+		const rowBorders = definitions[rowIndex]?.rowBorders;
+		if (rowBorders === void 0) return [...cells];
+		const rowBoundariesTwips = definitions[rowIndex]?.columnBoundariesTwips;
+		return cascadeRowBorders(cells, rowBorders, lastRowBorders, rowIndex === 0, rowIndex, lastRowIndex, rowBoundariesTwips, canonicalBoundariesTwips, toleranceTwips, logicalRows);
+	});
+}
+function cascadeRowBorders(cells, rowBorders, lastRowBorders, isFirstRow, rowIndex, lastRowIndex, rowBoundariesTwips, canonicalBoundariesTwips, toleranceTwips, logicalRows) {
+	return cells.map((cell, cellIndex) => {
+		const isFirstCell = cellIndex === 0;
+		const isLastCell = isRightmostPhysicalCell(cells, cellIndex);
+		const isLastRow = cellReachesTableBottom(cell, cellIndex, rowIndex, lastRowIndex, rowBoundariesTwips, canonicalBoundariesTwips, toleranceTwips, logicalRows);
+		const sides = {
+			top: cell.clearedSides?.has("top") ? void 0 : cell.borders?.top ?? (isFirstRow ? rowBorders.top : rowBorders.insideHorizontal),
+			left: cell.clearedSides?.has("left") ? void 0 : cell.borders?.left ?? (isFirstCell ? rowBorders.left : rowBorders.insideVertical),
+			bottom: cell.clearedSides?.has("bottom") ? void 0 : cell.borders?.bottom ?? (isLastRow ? lastRowBorders?.bottom : rowBorders.insideHorizontal),
+			right: cell.clearedSides?.has("right") ? void 0 : cell.borders?.right ?? (isLastCell ? rowBorders.right : rowBorders.insideVertical)
+		};
+		return {
+			...cell,
+			borders: require_table_decoration.cellBordersFrom(sides),
+			clearedSides: void 0
+		};
+	});
+}
+function cellReachesTableBottom(cell, cellIndex, rowIndex, lastRowIndex, rowBoundariesTwips, canonicalBoundariesTwips, toleranceTwips, logicalRows) {
+	if (rowIndex === lastRowIndex) return true;
+	if (cell.vertMerge === 1) return false;
+	const left = rowBoundariesTwips?.[cellIndex];
+	if (left === void 0) throw new require_errors.DocFormatError("a table row's own column-boundary array has fewer entries than its physical cell count requires");
+	const startGridIndex = gridIndexFor(canonicalBoundariesTwips, left, toleranceTwips);
+	const chainLastRow = vertMergeChainLastRow(logicalRows, rowIndex, startGridIndex);
+	if (chainLastRow === lastRowIndex) return true;
+	return !columnCoveredByALaterRow(logicalRows, chainLastRow, startGridIndex);
+}
+function columnCoveredByALaterRow(logicalRows, rowIndex, gridIndex) {
+	for (let laterRow = rowIndex + 1; laterRow < logicalRows.length; laterRow += 1) if (logicalRows[laterRow]?.some((candidate) => gridIndex >= candidate.startGridIndex && gridIndex < candidate.startGridIndex + candidate.colSpan)) return true;
+	return false;
+}
+function isRightmostPhysicalCell(cells, index) {
+	for (let cursor = index + 1; cursor < cells.length; cursor += 1) if (cells[cursor]?.horzMerge !== 1) return false;
+	return true;
+}
 function canonicalColumnBoundariesTwips(definitions, toleranceTwips) {
 	const sorted = definitions.flatMap((definition) => definition.columnBoundariesTwips).sort((left, right) => left - right);
 	const canonical = [];
@@ -151,6 +204,14 @@ function logicalCellsForRow(cells, rowBoundariesTwips, canonicalBoundariesTwips,
 	}
 	return logical;
 }
+function vertMergeChainLastRow(logicalRows, rowIndex, startGridIndex) {
+	let lastRow = rowIndex;
+	for (let r = rowIndex + 1; r < logicalRows.length; r += 1) {
+		if ((logicalRows[r]?.find((candidate) => candidate.startGridIndex === startGridIndex))?.vertMerge !== 1) break;
+		lastRow = r;
+	}
+	return lastRow;
+}
 function buildRows(rawRows, rowDefinitions, canonicalBoundariesTwips, rowHeights, toleranceTwips) {
 	const logicalRows = rawRows.map((row, rowIndex) => {
 		const definition = rowDefinitions[rowIndex];
@@ -168,11 +229,7 @@ function buildRows(rawRows, rowDefinitions, canonicalBoundariesTwips, rowHeights
 				});
 				continue;
 			}
-			let rowSpan = 1;
-			for (let r = rowIndex + 1; r < logicalRows.length; r += 1) {
-				if ((logicalRows[r]?.find((candidate) => candidate.startGridIndex === cell.startGridIndex))?.vertMerge !== 1) break;
-				rowSpan += 1;
-			}
+			const rowSpan = vertMergeChainLastRow(logicalRows, rowIndex, cell.startGridIndex) - rowIndex + 1;
 			cells.push({
 				blocks: cell.blocks,
 				colSpan,

package/dist/table/read.js

@@ -1,5 +1,6 @@
 import { DocFormatError, DocUnsupportedError } from "../errors.js";
 import "../text/special.js";
+import { cellBordersFrom } from "./decoration.js";
 import { applyTableSprms } from "./tap.js";
 //#region src/table/read.ts
 const TWIPS_PER_POINT = 20;
@@ -73,6 +74,7 @@ function tryAssembleTable(runEntries) {
 					horzMerge: merge.horzMerge,
 					vertMerge: merge.vertMerge,
 					borders: merge.borders,
+					clearedSides: merge.clearedSides,
 					background: merge.background,
 					blocks: cell.blocks
 				};
@@ -93,10 +95,61 @@ function tryAssembleTable(runEntries) {
 	const columnBoundariesTwips = canonicalColumnBoundariesTwips(rowDefinitions, toleranceTwips);
 	return {
 		kind: "table",
-		rows: buildRows(rawRows, rowDefinitions, columnBoundariesTwips, rowHeights, toleranceTwips),
+		rows: buildRows(applyRowLevelBorderCascade(rawRows, rowDefinitions, columnBoundariesTwips, toleranceTwips), rowDefinitions, columnBoundariesTwips, rowHeights, toleranceTwips),
 		columnWidthsPt: columnWidthsFromBoundaries(columnBoundariesTwips)
 	};
 }
+function applyRowLevelBorderCascade(rows, definitions, canonicalBoundariesTwips, toleranceTwips) {
+	const lastRowIndex = rows.length - 1;
+	const lastRowBorders = definitions[lastRowIndex]?.rowBorders;
+	const logicalRows = rows.map((row, rowIndex) => {
+		const definition = definitions[rowIndex];
+		if (definition === void 0) throw new DocFormatError(`internal defect: table row ${rowIndex} has no TAP definition despite the earlier length check`);
+		return logicalCellsForRow(row, definition.columnBoundariesTwips, canonicalBoundariesTwips, toleranceTwips);
+	});
+	return rows.map((cells, rowIndex) => {
+		const rowBorders = definitions[rowIndex]?.rowBorders;
+		if (rowBorders === void 0) return [...cells];
+		const rowBoundariesTwips = definitions[rowIndex]?.columnBoundariesTwips;
+		return cascadeRowBorders(cells, rowBorders, lastRowBorders, rowIndex === 0, rowIndex, lastRowIndex, rowBoundariesTwips, canonicalBoundariesTwips, toleranceTwips, logicalRows);
+	});
+}
+function cascadeRowBorders(cells, rowBorders, lastRowBorders, isFirstRow, rowIndex, lastRowIndex, rowBoundariesTwips, canonicalBoundariesTwips, toleranceTwips, logicalRows) {
+	return cells.map((cell, cellIndex) => {
+		const isFirstCell = cellIndex === 0;
+		const isLastCell = isRightmostPhysicalCell(cells, cellIndex);
+		const isLastRow = cellReachesTableBottom(cell, cellIndex, rowIndex, lastRowIndex, rowBoundariesTwips, canonicalBoundariesTwips, toleranceTwips, logicalRows);
+		const sides = {
+			top: cell.clearedSides?.has("top") ? void 0 : cell.borders?.top ?? (isFirstRow ? rowBorders.top : rowBorders.insideHorizontal),
+			left: cell.clearedSides?.has("left") ? void 0 : cell.borders?.left ?? (isFirstCell ? rowBorders.left : rowBorders.insideVertical),
+			bottom: cell.clearedSides?.has("bottom") ? void 0 : cell.borders?.bottom ?? (isLastRow ? lastRowBorders?.bottom : rowBorders.insideHorizontal),
+			right: cell.clearedSides?.has("right") ? void 0 : cell.borders?.right ?? (isLastCell ? rowBorders.right : rowBorders.insideVertical)
+		};
+		return {
+			...cell,
+			borders: cellBordersFrom(sides),
+			clearedSides: void 0
+		};
+	});
+}
+function cellReachesTableBottom(cell, cellIndex, rowIndex, lastRowIndex, rowBoundariesTwips, canonicalBoundariesTwips, toleranceTwips, logicalRows) {
+	if (rowIndex === lastRowIndex) return true;
+	if (cell.vertMerge === 1) return false;
+	const left = rowBoundariesTwips?.[cellIndex];
+	if (left === void 0) throw new DocFormatError("a table row's own column-boundary array has fewer entries than its physical cell count requires");
+	const startGridIndex = gridIndexFor(canonicalBoundariesTwips, left, toleranceTwips);
+	const chainLastRow = vertMergeChainLastRow(logicalRows, rowIndex, startGridIndex);
+	if (chainLastRow === lastRowIndex) return true;
+	return !columnCoveredByALaterRow(logicalRows, chainLastRow, startGridIndex);
+}
+function columnCoveredByALaterRow(logicalRows, rowIndex, gridIndex) {
+	for (let laterRow = rowIndex + 1; laterRow < logicalRows.length; laterRow += 1) if (logicalRows[laterRow]?.some((candidate) => gridIndex >= candidate.startGridIndex && gridIndex < candidate.startGridIndex + candidate.colSpan)) return true;
+	return false;
+}
+function isRightmostPhysicalCell(cells, index) {
+	for (let cursor = index + 1; cursor < cells.length; cursor += 1) if (cells[cursor]?.horzMerge !== 1) return false;
+	return true;
+}
 function canonicalColumnBoundariesTwips(definitions, toleranceTwips) {
 	const sorted = definitions.flatMap((definition) => definition.columnBoundariesTwips).sort((left, right) => left - right);
 	const canonical = [];
@@ -150,6 +203,14 @@ function logicalCellsForRow(cells, rowBoundariesTwips, canonicalBoundariesTwips,
 	}
 	return logical;
 }
+function vertMergeChainLastRow(logicalRows, rowIndex, startGridIndex) {
+	let lastRow = rowIndex;
+	for (let r = rowIndex + 1; r < logicalRows.length; r += 1) {
+		if ((logicalRows[r]?.find((candidate) => candidate.startGridIndex === startGridIndex))?.vertMerge !== 1) break;
+		lastRow = r;
+	}
+	return lastRow;
+}
 function buildRows(rawRows, rowDefinitions, canonicalBoundariesTwips, rowHeights, toleranceTwips) {
 	const logicalRows = rawRows.map((row, rowIndex) => {
 		const definition = rowDefinitions[rowIndex];
@@ -167,11 +228,7 @@ function buildRows(rawRows, rowDefinitions, canonicalBoundariesTwips, rowHeights
 				});
 				continue;
 			}
-			let rowSpan = 1;
-			for (let r = rowIndex + 1; r < logicalRows.length; r += 1) {
-				if ((logicalRows[r]?.find((candidate) => candidate.startGridIndex === cell.startGridIndex))?.vertMerge !== 1) break;
-				rowSpan += 1;
-			}
+			const rowSpan = vertMergeChainLastRow(logicalRows, rowIndex, cell.startGridIndex) - rowIndex + 1;
 			cells.push({
 				blocks: cell.blocks,
 				colSpan,

package/dist/table/tap-write.cjs

@@ -30,8 +30,8 @@ const SHD_ARRAYS = [
 /** A DefTableShdOperand's own rgShd bound, [MS-DOC] 2.9.53: "The number of elements is equal to cb / 10 and MUST NOT exceed 22." */
 const MAX_SHD_PER_ARRAY = 22;
 const TWIPS_PER_POINT = 20;
-/** A table row has "between 1 and 63 table cells" ([MS-DOC] 2.4.3), and TDefTableOperand.NumberOfColumns is itself a single byte "MUST NOT exceed 63". */
-const MAX_COLUMNS = 63;
+/** A table row has "between 1 and 63 table cells" ([MS-DOC] 2.4.3), and TDefTableOperand.NumberOfColumns is itself a single byte "MUST NOT exceed 63". Exported so table/write.ts's own lost-boundary fallback can check a trial split's cell count against this format ceiling BEFORE calling encodeTableRowGrpprl with it -- that function still throws unconditionally past this limit for every other caller (the row actually committed has a genuine internal defect if it ever produces one), but a speculative trial split needs to treat the ceiling as "doesn't fit" and keep trimming rather than crash (ExaDev/documents.js#992). */
+const MAX_TABLE_ROW_CELLS = 63;
 /** sprmPDyaBefore/After's unsigned 2-byte operand range, reused here for XAS column boundaries (also an unsigned 2-byte field in practice for the non-negative widths this writer produces). */
 const MIN_INT16 = -32768;
 const MAX_INT16 = 32767;
@@ -48,7 +48,7 @@ function le16(value) {
 }
 function buildTc80(cell) {
 	return [
-		...le16((cell.vertMerge & 3) << 5),
+		...le16((cell.vertMerge & 3) << 5 | cell.horzMerge),
 		0,
 		0,
 		...require_table_decoration.CELL_BORDER_SIDES.flatMap((side) => require_table_decoration.writeBrc80(cell.borders?.[side]))
@@ -99,7 +99,7 @@ function shadingPrls(cells) {
 }
 function encodeTableRowGrpprl(columnBoundariesTwips, cells, heightPt) {
 	if (columnBoundariesTwips.length !== cells.length + 1) throw new require_errors.DocFormatError(`a table row's column-boundary array must carry exactly one more entry than its cell count (got ${columnBoundariesTwips.length} boundaries for ${cells.length} cells)`);
-	if (cells.length < 1 || cells.length > MAX_COLUMNS) throw new require_errors.DocFormatError(`a table row must have between 1 and ${MAX_COLUMNS} cells, got ${cells.length}`);
+	if (cells.length < 1 || cells.length > 63) throw new require_errors.DocFormatError(`a table row must have between 1 and 63 cells, got ${cells.length}`);
 	const remainder = [
 		cells.length,
 		...columnBoundariesTwips.flatMap((boundary) => int16(boundary, "table column boundary")),
@@ -122,4 +122,5 @@ function encodeTableRowGrpprl(columnBoundariesTwips, cells, heightPt) {
 	return bytes;
 }
 //#endregion
+exports.MAX_TABLE_ROW_CELLS = MAX_TABLE_ROW_CELLS;
 exports.encodeTableRowGrpprl = encodeTableRowGrpprl;

package/dist/table/tap-write.d.cts

@@ -1,13 +1,17 @@
-import { Color, ContentCellBorders } from "document-schema.js";
+import { ContentCellBorders, ContentCellFill } from "document-schema.js";
 //#region src/table/tap-write.d.ts
+/** A table row has "between 1 and 63 table cells" ([MS-DOC] 2.4.3), and TDefTableOperand.NumberOfColumns is itself a single byte "MUST NOT exceed 63". Exported so table/write.ts's own lost-boundary fallback can check a trial split's cell count against this format ceiling BEFORE calling encodeTableRowGrpprl with it -- that function still throws unconditionally past this limit for every other caller (the row actually committed has a genuine internal defect if it ever produces one), but a speculative trial split needs to treat the ceiling as "doesn't fit" and keep trimming rather than crash (ExaDev/documents.js#992). */
+declare const MAX_TABLE_ROW_CELLS = 63;
 interface TableCellToWrite {
   /** VerticalMergeFlag: 0 fvmClear, 1 fvmMerge (continuation), 3 fvmRestart (first cell). */
   readonly vertMerge: 0 | 1 | 3;
+  /** TCGRF.horzMerge, [MS-DOC] 2.9.317: 0 not merged (the ordinary case, see this module's own top-of-file note), 1 a continuation cell of the lost-boundary fallback's own physical split, 2 the anchor of one. Every one of table/write.ts's own flattenRow construction branches states this explicitly -- 0 for an ordinary cell, 2 for a split anchor, 1 for its continuation -- so this field carries no default of its own; the only fallback flattenRow ever applies for the ExaDev/documents.js#992 fallback is deciding WHICH row of a table states a given lost boundary at all, not what a stated cell's own horzMerge value is. */
+  readonly horzMerge: 0 | 1 | 2;
   /** The cell's own four borders, from ContentTableCell.borders; an absent side is written as the Brc80MayBeNil no-border sentinel. */
   readonly borders?: ContentCellBorders;
-  /** The cell's own flat background, from ContentTableCell.background. */
-  readonly background?: Color;
+  /** The cell's own background fill, from ContentTableCell.background. */
+  readonly background?: ContentCellFill;
 }
 declare function encodeTableRowGrpprl(columnBoundariesTwips: readonly number[], cells: readonly TableCellToWrite[], heightPt: number | undefined): number[];
 //#endregion
-export { TableCellToWrite, encodeTableRowGrpprl };
+export { MAX_TABLE_ROW_CELLS, TableCellToWrite, encodeTableRowGrpprl };

package/dist/table/tap-write.d.ts

@@ -1,13 +1,17 @@
-import { Color, ContentCellBorders } from "document-schema.js";
+import { ContentCellBorders, ContentCellFill } from "document-schema.js";
 //#region src/table/tap-write.d.ts
+/** A table row has "between 1 and 63 table cells" ([MS-DOC] 2.4.3), and TDefTableOperand.NumberOfColumns is itself a single byte "MUST NOT exceed 63". Exported so table/write.ts's own lost-boundary fallback can check a trial split's cell count against this format ceiling BEFORE calling encodeTableRowGrpprl with it -- that function still throws unconditionally past this limit for every other caller (the row actually committed has a genuine internal defect if it ever produces one), but a speculative trial split needs to treat the ceiling as "doesn't fit" and keep trimming rather than crash (ExaDev/documents.js#992). */
+declare const MAX_TABLE_ROW_CELLS = 63;
 interface TableCellToWrite {
   /** VerticalMergeFlag: 0 fvmClear, 1 fvmMerge (continuation), 3 fvmRestart (first cell). */
   readonly vertMerge: 0 | 1 | 3;
+  /** TCGRF.horzMerge, [MS-DOC] 2.9.317: 0 not merged (the ordinary case, see this module's own top-of-file note), 1 a continuation cell of the lost-boundary fallback's own physical split, 2 the anchor of one. Every one of table/write.ts's own flattenRow construction branches states this explicitly -- 0 for an ordinary cell, 2 for a split anchor, 1 for its continuation -- so this field carries no default of its own; the only fallback flattenRow ever applies for the ExaDev/documents.js#992 fallback is deciding WHICH row of a table states a given lost boundary at all, not what a stated cell's own horzMerge value is. */
+  readonly horzMerge: 0 | 1 | 2;
   /** The cell's own four borders, from ContentTableCell.borders; an absent side is written as the Brc80MayBeNil no-border sentinel. */
   readonly borders?: ContentCellBorders;
-  /** The cell's own flat background, from ContentTableCell.background. */
-  readonly background?: Color;
+  /** The cell's own background fill, from ContentTableCell.background. */
+  readonly background?: ContentCellFill;
 }
 declare function encodeTableRowGrpprl(columnBoundariesTwips: readonly number[], cells: readonly TableCellToWrite[], heightPt: number | undefined): number[];
 //#endregion
-export { TableCellToWrite, encodeTableRowGrpprl };
+export { MAX_TABLE_ROW_CELLS, TableCellToWrite, encodeTableRowGrpprl };

package/dist/table/tap-write.js

@@ -29,8 +29,8 @@ const SHD_ARRAYS = [
 /** A DefTableShdOperand's own rgShd bound, [MS-DOC] 2.9.53: "The number of elements is equal to cb / 10 and MUST NOT exceed 22." */
 const MAX_SHD_PER_ARRAY = 22;
 const TWIPS_PER_POINT = 20;
-/** A table row has "between 1 and 63 table cells" ([MS-DOC] 2.4.3), and TDefTableOperand.NumberOfColumns is itself a single byte "MUST NOT exceed 63". */
-const MAX_COLUMNS = 63;
+/** A table row has "between 1 and 63 table cells" ([MS-DOC] 2.4.3), and TDefTableOperand.NumberOfColumns is itself a single byte "MUST NOT exceed 63". Exported so table/write.ts's own lost-boundary fallback can check a trial split's cell count against this format ceiling BEFORE calling encodeTableRowGrpprl with it -- that function still throws unconditionally past this limit for every other caller (the row actually committed has a genuine internal defect if it ever produces one), but a speculative trial split needs to treat the ceiling as "doesn't fit" and keep trimming rather than crash (ExaDev/documents.js#992). */
+const MAX_TABLE_ROW_CELLS = 63;
 /** sprmPDyaBefore/After's unsigned 2-byte operand range, reused here for XAS column boundaries (also an unsigned 2-byte field in practice for the non-negative widths this writer produces). */
 const MIN_INT16 = -32768;
 const MAX_INT16 = 32767;
@@ -47,7 +47,7 @@ function le16(value) {
 }
 function buildTc80(cell) {
 	return [
-		...le16((cell.vertMerge & 3) << 5),
+		...le16((cell.vertMerge & 3) << 5 | cell.horzMerge),
 		0,
 		0,
 		...CELL_BORDER_SIDES.flatMap((side) => writeBrc80(cell.borders?.[side]))
@@ -98,7 +98,7 @@ function shadingPrls(cells) {
 }
 function encodeTableRowGrpprl(columnBoundariesTwips, cells, heightPt) {
 	if (columnBoundariesTwips.length !== cells.length + 1) throw new DocFormatError(`a table row's column-boundary array must carry exactly one more entry than its cell count (got ${columnBoundariesTwips.length} boundaries for ${cells.length} cells)`);
-	if (cells.length < 1 || cells.length > MAX_COLUMNS) throw new DocFormatError(`a table row must have between 1 and ${MAX_COLUMNS} cells, got ${cells.length}`);
+	if (cells.length < 1 || cells.length > 63) throw new DocFormatError(`a table row must have between 1 and 63 cells, got ${cells.length}`);
 	const remainder = [
 		cells.length,
 		...columnBoundariesTwips.flatMap((boundary) => int16(boundary, "table column boundary")),
@@ -121,4 +121,4 @@ function encodeTableRowGrpprl(columnBoundariesTwips, cells, heightPt) {
 	return bytes;
 }
 //#endregion
-export { encodeTableRowGrpprl };
+export { MAX_TABLE_ROW_CELLS, encodeTableRowGrpprl };