reamkit 1.15.2 → 1.15.4

package/dist/esm/core/bytes.d.ts

@@ -8,4 +8,15 @@ export declare function toBase64(bytes: Uint8Array): string;
  * Naive scan for an ASCII `needle` inside raw `haystack` bytes — used by reader
  * sniffs to spot OPC part names (e.g. `'word/document.xml'`) without unzipping.
  */
+/**
+ * Scan raw package bytes for an OPC part name (e.g. `'xl/workbook.xml'`)
+ * without unzipping — the reader sniffs' cheap format probe. Accepts both the
+ * spec's `/` separator and the `\` that Windows producers write.
+ */
+export declare function bytesIncludePartName(haystack: Uint8Array, partName: string): boolean;
+/**
+ * Naive scan for an ASCII `needle` inside raw `haystack` bytes. Prefer
+ * {@link bytesIncludePartName} for OPC part names — it also accepts the
+ * backslash spelling real archives use.
+ */
 export declare function bytesInclude(haystack: Uint8Array, needle: string): boolean;

package/dist/esm/core/bytes.js

@@ -13,6 +13,20 @@ function toBase64(bytes) {
 * Naive scan for an ASCII `needle` inside raw `haystack` bytes — used by reader
 * sniffs to spot OPC part names (e.g. `'word/document.xml'`) without unzipping.
 */
+/**
+* Scan raw package bytes for an OPC part name (e.g. `'xl/workbook.xml'`)
+* without unzipping — the reader sniffs' cheap format probe. Accepts both the
+* spec's `/` separator and the `\` that Windows producers write.
+*/
+function bytesIncludePartName(haystack, partName) {
+	if (bytesInclude(haystack, partName)) return true;
+	return partName.includes("/") && bytesInclude(haystack, partName.replace(/\//g, "\\"));
+}
+/**
+* Naive scan for an ASCII `needle` inside raw `haystack` bytes. Prefer
+* {@link bytesIncludePartName} for OPC part names — it also accepts the
+* backslash spelling real archives use.
+*/
 function bytesInclude(haystack, needle) {
 	const n = new TextEncoder().encode(needle);
 	outer: for (let i = 0; i + n.length <= haystack.length; i++) {
@@ -22,4 +36,4 @@ function bytesInclude(haystack, needle) {
 	return false;
 }
 //#endregion
-export { bytesInclude, toBase64 };
+export { bytesInclude, bytesIncludePartName, toBase64 };

package/dist/esm/core/ir/sheet.d.ts

@@ -80,12 +80,15 @@ export interface SheetFormControl {
 }
 /**
  * An ActiveX control resolved against its activeX part (E-SHEET W10): the control
- * class (`type`, from the `<oleObject progId>`) plus the visible state persisted
- * in the property bag — `caption`, `value` (checked/text/number, as a string)
- * and OptionButton `groupName`. Render-only.
+ * class (`type`, from the `<oleObject progId>` or, for a §18.3.1.19 `<control>`,
+ * its class id) plus the visible state persisted in the property bag —
+ * `caption`, `value` (checked/text/number, as a string) and OptionButton
+ * `groupName`. Render-only.
  */
 export interface SheetActiveXControl {
     readonly type: string;
+    /** §18.3.1.19 `<control name>` — the control's identifier, when it came that way. */
+    readonly name?: string;
     readonly caption?: string;
     readonly value?: string;
     readonly groupName?: string;

package/dist/esm/core/opc/package.js

@@ -42,6 +42,7 @@ var OpcPackage = class OpcPackage {
 				violation ??= `more than ${maxEntries} entries`;
 				return false;
 			}
+			if (info.originalSize === 4294967295) return true;
 			if (info.originalSize > maxEntry) {
 				violation ??= `entry "${info.name}" declares ${info.originalSize} bytes (limit ${maxEntry})`;
 				return false;
@@ -138,7 +139,8 @@ var OpcPackage = class OpcPackage {
 	}
 };
 function normalizePath(p) {
-	return p.startsWith("/") ? p.slice(1) : p;
+	const slashed = p.includes("\\") ? p.replace(/\\/g, "/") : p;
+	return slashed.startsWith("/") ? slashed.slice(1) : slashed;
 }
 function resolveTarget(sourcePath, target) {
 	if (target.startsWith("/")) return normalizePath(target);

package/dist/esm/core/spreadsheet-model/types.d.ts

@@ -83,6 +83,27 @@ export interface ParsedWorksheet {
     readonly columns: ReadonlyArray<ColumnWidth>;
     readonly merges: ReadonlyArray<MergedRange>;
     readonly rowHeights: ReadonlyArray<RowHeight>;
+    /**
+     * ECMA-376 §18.3.1.81 `<sheetFormatPr defaultRowHeight>` — the height, in
+     * points, of every row that carries no `ht` of its own. A row in a
+     * spreadsheet always has a definite height; it is not decided by whatever
+     * leading the text happens to want. Absent ⇒ Excel's 15pt (its default theme
+     * font, Calibri 11).
+     */
+    readonly defaultRowHeightPt?: number;
+    /**
+     * §18.3.1.81 `<sheetFormatPr defaultColWidth>` — the width, in characters, of
+     * every column no `<col>` covers. Absent ⇒ derived from
+     * {@link ParsedWorksheet.baseColWidthChars}, else Excel's 8.43.
+     */
+    readonly defaultColWidthChars?: number;
+    /**
+     * §18.3.1.81 `<sheetFormatPr baseColWidth>` — the character width the default
+     * column is computed FROM when `defaultColWidth` is absent. Excel's own
+     * default is 8; a sheet that says 10 wants every unlisted column that much
+     * wider, and ignoring it makes the whole grid narrow.
+     */
+    readonly baseColWidthChars?: number;
     readonly pageMargins?: XlsxPageMargins;
     readonly pageSetup?: XlsxPageSetup;
     /**

package/dist/esm/excel/activex-parser.d.ts

@@ -22,6 +22,15 @@ export declare function parseActiveX(data: Uint8Array): ActiveXProps;
  * unknown progId falls back to a generic `'control'`.
  */
 export declare function activeXType(progId: string | undefined): string;
+/**
+ * The affordance key for an `<ax:ocx ax:classid>`, for controls reached through
+ * §18.3.1.19 `<control>` rather than `<oleObject progId>` — the `<control>`
+ * element carries no progId, so the class id is all there is to type it by.
+ *
+ * @param xmlData The `activeX#.xml` part bytes.
+ * @returns The affordance key, or `'control'` when the class id is unknown.
+ */
+export declare function activeXTypeFromPart(xmlData: Uint8Array): string;
 /**
  * The `<ax:ocx r:id>` of a control whose state is persisted to a binary stream
  * (`persistStreamInit` / `persistStream` / `persistStorage`) rather than to

package/dist/esm/excel/activex-parser.js

@@ -62,6 +62,20 @@ function strAttr(obj, key) {
 	const v = obj[`@_${key}`];
 	return typeof v === "string" ? v : void 0;
 }
+var ACTIVEX_CLASS_TYPES = new Map([["8BD21D40-EC42-11CE-9E0D-00AA006002F3", "checkbox"], ["8BD21D50-EC42-11CE-9E0D-00AA006002F3", "option"]]);
+/**
+* The affordance key for an `<ax:ocx ax:classid>`, for controls reached through
+* §18.3.1.19 `<control>` rather than `<oleObject progId>` — the `<control>`
+* element carries no progId, so the class id is all there is to type it by.
+*
+* @param xmlData The `activeX#.xml` part bytes.
+* @returns The affordance key, or `'control'` when the class id is unknown.
+*/
+function activeXTypeFromPart(xmlData) {
+	const ocx = asObject(parser.parse(decoder.decode(xmlData))["ocx"]);
+	const key = (ocx ? strAttr(ocx, "classid") : void 0)?.replace(/[{}]/g, "").toUpperCase() ?? "";
+	return ACTIVEX_CLASS_TYPES.get(key) ?? "control";
+}
 /**
 * The `<ax:ocx r:id>` of a control whose state is persisted to a binary stream
 * (`persistStreamInit` / `persistStream` / `persistStorage`) rather than to
@@ -209,4 +223,4 @@ function parseActiveXBin(data) {
 	};
 }
 //#endregion
-export { activeXBinRelId, activeXType, parseActiveX, parseActiveXBin };
+export { activeXBinRelId, activeXType, activeXTypeFromPart, parseActiveX, parseActiveXBin };

package/dist/esm/excel/column-bands.js

@@ -100,13 +100,7 @@ function withColSpan(cell, span) {
 function blankCell(span) {
 	return {
 		properties: span > 1 ? { colSpan: span } : {},
-		content: [{
-			kind: "paragraph",
-			paragraph: {
-				properties: {},
-				runs: []
-			}
-		}]
+		content: []
 	};
 }
 //#endregion

package/dist/esm/excel/print-model.d.ts

@@ -1,12 +1,25 @@
 import { BodyElement, SectionProperties, Table } from '../core/document-model/index.js';
 import { CellRange, DefinedName, ParsedWorksheet, SheetRichRun, WorksheetCell, XlsxStyles } from './index.js';
 import { SheetHyperlink, SheetSlicer } from '../core/ir/sheet.js';
+import { Loss } from '../core/ir/loss.js';
 /**
- * Excel "character width" → twips. Calibri 11pt default Maximum Digit Width is
- * ~7 px ≈ 5.25 pt ≈ 105 twips. This is a coarse approximation but the auto-fit
- * pass refines column widths against the actual cell text anyway.
+ * Excel "character width" → twips: the default font's Maximum Digit Width,
+ * ~7 px at 96 DPI ≈ 5.25 pt ≈ 105 twips.
  */
 export declare const TWIPS_PER_EXCEL_CHAR = 105;
+/**
+ * ECMA-376 §18.3.1.13 — a `<col width>` measures characters of text, and the
+ * rendered column is that many Maximum Digit Widths PLUS a fixed 5-pixel
+ * padding: `px = chars × MDW + 5`. 5 px at 96 DPI = 3.75 pt = 75 twips.
+ *
+ * Omitting it made every column 75 twips narrow, which compounds: on a sheet of
+ * equal 12-character columns the third one landed ~37 pt left of where
+ * LibreOffice puts it. That {@link DEFAULT_COL_TWIPS} below is 960 is the proof
+ * the padding belongs — 8.43 characters only reaches Excel's documented 64 px
+ * default with it (8.43 × 7 + 5 = 64.01 px = 48.01 pt = 960 twips), so the
+ * default was derived from the full formula while the explicit path dropped it.
+ */
+export declare const COL_PADDING_TWIPS = 75;
 /**
  * Excel's default column width is 8.43 "characters" ≈ 64px ≈ 960 twips. Used for
  * columns without an explicit `<col width="..">`.
@@ -19,10 +32,16 @@ export declare const DEFAULT_COL_TWIPS = 960;
 export declare const DEFAULT_ROW_TWIPS = 300;
 /**
  * Build the page section (paper size + margins) from a worksheet's `<pageSetup>`
- * / `<pageMargins>`. Returns `undefined` when neither is set, so the renderer
- * applies its A4 default.
+ * / `<pageMargins>`.
+ *
+ * Margins are always set, to Excel's own defaults when the worksheet declares
+ * none (§18.3.1.62) — the renderer's fallback is a word processor's inch, which
+ * is not what a spreadsheet prints. The paper size is left unset when the
+ * worksheet names none, because there the file genuinely holds no answer: Excel
+ * picks by locale and printer, and the renderer's deterministic A4 is as good
+ * as anything we could invent.
  */
-export declare function sectionFromWorksheet(worksheet: ParsedWorksheet): SectionProperties | undefined;
+export declare function sectionFromWorksheet(worksheet: ParsedWorksheet): SectionProperties;
 /**
  * ECMA-376 §18.2.5 — resolve the sheet-scoped `_xlnm.Print_Area` defined name
  * (`localSheetId` = the sheet's 0-based index) into a clipping range.
@@ -46,6 +65,7 @@ interface PrintModelOptions {
     readonly hyperlinks?: ReadonlyArray<SheetHyperlink>;
     readonly sharedStringRuns?: ReadonlyArray<ReadonlyArray<SheetRichRun> | undefined>;
     readonly now?: Date;
+    readonly losses?: Array<Loss>;
 }
 /**
  * Project one worksheet's grid into Flow body elements — a single {@link Table}

package/dist/esm/excel/print-model.js

@@ -1,9 +1,23 @@
 import { eighthPtToPt, halfPtToPt, pt, twipsToPt } from "../core/ir/units.js";
+import { FEATURES } from "../core/ir/features.js";
 import { parseAreaRef, parseTitleRowRange } from "./defined-name-ref.js";
 import { applyNumberFormat } from "./number-format.js";
 import "./index.js";
 import { bandedTables, computeColumnBands } from "./column-bands.js";
 import { buildConditionalFormatter } from "./conditional-format.js";
+/**
+* Excel insets a cell's text by ~2 px each side (1.5 pt at 96 DPI). The layout
+* engine's default is a word processor's 108 twips (5.4 pt), which is nearly
+* four times as much.
+*/
+var EXCEL_CELL_INSET_PT = 1.5;
+/**
+* ECMA-376 §18.3.1.81 — the row height Excel uses when a sheet declares no
+* `<sheetFormatPr defaultRowHeight>`: 15pt, the line height of its default
+* theme font (Calibri 11). Independent of whatever font we end up rendering
+* with — the height belongs to the document, not to the typesetter.
+*/
+var EXCEL_DEFAULT_ROW_HEIGHT_PT = 15;
 var TWIPS_PER_POINT = 20;
 var TWIPS_PER_INCH = 1440;
 var PAPER_SIZES_TWIPS = new Map([
@@ -18,16 +32,20 @@ var PAPER_SIZES_TWIPS = new Map([
 var DEFAULT_PAPER_TWIPS = [11906, 16838];
 /**
 * Build the page section (paper size + margins) from a worksheet's `<pageSetup>`
-* / `<pageMargins>`. Returns `undefined` when neither is set, so the renderer
-* applies its A4 default.
+* / `<pageMargins>`.
+*
+* Margins are always set, to Excel's own defaults when the worksheet declares
+* none (§18.3.1.62) — the renderer's fallback is a word processor's inch, which
+* is not what a spreadsheet prints. The paper size is left unset when the
+* worksheet names none, because there the file genuinely holds no answer: Excel
+* picks by locale and printer, and the renderer's deterministic A4 is as good
+* as anything we could invent.
 */
 function sectionFromWorksheet(worksheet) {
 	const pageSize = pageSizeFromSetup(worksheet.pageSetup);
-	const margins = marginsFromXlsx(worksheet.pageMargins);
-	if (!pageSize && !margins) return void 0;
 	return {
 		...pageSize ? { pageSize } : {},
-		...margins ? { margins } : {},
+		margins: marginsFromXlsx(worksheet.pageMargins),
 		headers: [],
 		footers: []
 	};
@@ -44,8 +62,23 @@ function pageSizeFromSetup(setup) {
 		orientation
 	};
 }
+/**
+* ECMA-376 §18.3.1.62 — the page margins Excel writes when the user has not
+* touched them, in inches. A worksheet may omit `<pageMargins>` entirely, and
+* falling through to the renderer's default (a word processor's 1 inch) put the
+* grid 0.3 inch — 21.6 pt — right of where Excel and LibreOffice print it, on
+* every such sheet.
+*/
+var EXCEL_DEFAULT_MARGINS = {
+	left: twipsToPt(Math.round(.7 * TWIPS_PER_INCH)),
+	right: twipsToPt(Math.round(.7 * TWIPS_PER_INCH)),
+	top: twipsToPt(Math.round(.75 * TWIPS_PER_INCH)),
+	bottom: twipsToPt(Math.round(.75 * TWIPS_PER_INCH)),
+	header: twipsToPt(Math.round(.3 * TWIPS_PER_INCH)),
+	footer: twipsToPt(Math.round(.3 * TWIPS_PER_INCH))
+};
 function marginsFromXlsx(margins) {
-	if (!margins) return void 0;
+	if (!margins) return EXCEL_DEFAULT_MARGINS;
 	return {
 		top: twipsToPt(Math.round(margins.topInches * TWIPS_PER_INCH)),
 		right: twipsToPt(Math.round(margins.rightInches * TWIPS_PER_INCH)),
@@ -73,16 +106,16 @@ function sheetContentWidthTwips(worksheet) {
 	const pageSize = pageSizeFromSetup(worksheet.pageSetup);
 	const pageWidthTwips = pageSize ? Math.round(pageSize.width * 20) : DEFAULT_PAPER_TWIPS[0];
 	const margins = marginsFromXlsx(worksheet.pageMargins);
-	const left = margins ? Math.round(margins.left * 20) : TWIPS_PER_INCH;
-	const right = margins ? Math.round(margins.right * 20) : TWIPS_PER_INCH;
+	const left = Math.round(margins.left * 20);
+	const right = Math.round(margins.right * 20);
 	return Math.max(TWIPS_PER_INCH / 2, pageWidthTwips - left - right);
 }
 function sheetContentHeightTwips(worksheet) {
 	const pageSize = pageSizeFromSetup(worksheet.pageSetup);
 	const pageHeightTwips = pageSize ? Math.round(pageSize.height * 20) : DEFAULT_PAPER_TWIPS[1];
 	const margins = marginsFromXlsx(worksheet.pageMargins);
-	const top = margins ? Math.round(margins.top * 20) : TWIPS_PER_INCH;
-	const bottom = margins ? Math.round(margins.bottom * 20) : TWIPS_PER_INCH;
+	const top = Math.round(margins.top * 20);
+	const bottom = Math.round(margins.bottom * 20);
 	return Math.max(TWIPS_PER_INCH / 2, pageHeightTwips - top - bottom);
 }
 function computePrintScale(worksheet, totalGridTwips, contentWidthTwips, totalGridHeightTwips, contentHeightTwips) {
@@ -127,11 +160,14 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	if (worksheet.maxRow < 0 || worksheet.maxColumn < 0) return [];
 	let usedRow = -1;
 	let usedCol = -1;
+	const contentAt = /* @__PURE__ */ new Set();
 	for (const c of worksheet.cells) if (c.rawValue !== "" || c.inlineText !== void 0) {
+		contentAt.add(key(c.row, c.column));
 		if (c.row > usedRow) usedRow = c.row;
 		if (c.column > usedCol) usedCol = c.column;
 	}
 	for (const m of worksheet.merges) {
+		if (!contentAt.has(key(m.startRow, m.startColumn))) continue;
 		if (m.endRow > usedRow) usedRow = m.endRow;
 		if (m.endColumn > usedCol) usedCol = m.endColumn;
 	}
@@ -153,12 +189,35 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		colEnd = Math.min(usedCol, print.printArea.endColumn);
 	}
 	if (rowEnd < rowStart || colEnd < colStart) return [];
-	const MAX_GRID_COLS = 1024;
-	const rowCount = Math.min(rowEnd - rowStart + 1, 5e4);
-	const colCount = Math.min(colEnd - colStart + 1, MAX_GRID_COLS);
+	const MAX_GRID_COLS = 16384;
+	const MAX_GRID_ROWS = 5e4;
+	const MAX_GRID_CELLS = 1e6;
+	const wantRows = rowEnd - rowStart + 1;
+	const wantCols = colEnd - colStart + 1;
+	let colCount = Math.min(wantCols, MAX_GRID_COLS);
+	let rowCount = Math.max(1, Math.min(wantRows, MAX_GRID_ROWS, Math.floor(MAX_GRID_CELLS / colCount)));
+	if (rowCount < wantRows) rowCount = Math.max(1, lastContentRow(worksheet, rowStart, rowCount, colStart, colCount) + 1);
+	if (colCount < wantCols) colCount = Math.max(1, lastContentColumn(worksheet, rowStart, rowCount, colStart, colCount) + 1);
+	if (rowCount < wantRows) print.losses?.push({
+		severity: "dropped",
+		feature: FEATURES.tables,
+		detail: `grid clipped to the first ${rowCount} rows of ${wantRows} in the used range (memory guard)`,
+		...print.sheetName ? { where: `sheet "${print.sheetName}"` } : {}
+	});
+	if (colCount < wantCols) print.losses?.push({
+		severity: "dropped",
+		feature: FEATURES.tables,
+		detail: `grid clipped to the first ${colCount} columns of ${wantCols} in the used range (memory guard)`,
+		...print.sheetName ? { where: `sheet "${print.sheetName}"` } : {}
+	});
 	const rowWindowEnd = rowStart + rowCount - 1;
 	const colWindowEnd = colStart + colCount - 1;
+	const defaultRowTwips = Math.round((worksheet.defaultRowHeightPt ?? EXCEL_DEFAULT_ROW_HEIGHT_PT) * TWIPS_PER_POINT);
 	const rowHeightMap = /* @__PURE__ */ new Map();
+	for (let r = 0; r < rowCount; r++) rowHeightMap.set(r, {
+		heightTwips: defaultRowTwips,
+		heightRule: "atLeast"
+	});
 	for (const h of worksheet.rowHeights) {
 		const local = h.row - rowStart;
 		if (local < 0 || local >= rowCount) continue;
@@ -184,9 +243,11 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		const cEnd = Math.min(m.endColumn, colWindowEnd);
 		for (let r = Math.max(m.startRow, rowStart); r <= rEnd; r++) for (let c = Math.max(m.startColumn, colStart); c <= cEnd; c++) if (!(r === m.startRow && c === m.startColumn)) insideMerge.add(key(r, c));
 	}
-	const columnWidths = new Array(colCount).fill(960);
+	const defaultColChars = worksheet.defaultColWidthChars ?? worksheet.baseColWidthChars;
+	const defaultColTwips = defaultColChars !== void 0 ? Math.round(defaultColChars * 105 + 75) : 960;
+	const columnWidths = new Array(colCount).fill(defaultColTwips);
 	for (const col of worksheet.columns) {
-		const twips = Math.round(col.widthChars * 105);
+		const twips = Math.round(col.widthChars * 105 + 75);
 		for (let abs = col.min - 1; abs <= col.max - 1; abs++) {
 			const i = abs - colStart;
 			if (i >= 0 && i < colCount) columnWidths[i] = twips;
@@ -199,6 +260,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	const scaled = printScale < .999;
 	const breakRows = new Set(worksheet.rowBreaks ?? []);
 	let textBudget = MAX_SHEET_TEXT_CHARS;
+	let textBudgetReported = false;
 	const runPropsByXf = /* @__PURE__ */ new Map();
 	const cellRunProps = (xf) => {
 		let props = runPropsByXf.get(xf);
@@ -226,7 +288,9 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	for (let r = 0; r < rowCount; r++) {
 		const absR = r + rowStart;
 		const cells = [];
+		const overflowed = /* @__PURE__ */ new Set();
 		for (let c = 0; c < colCount; c++) {
+			if (overflowed.has(c)) continue;
 			const absC = c + colStart;
 			const merge = mergeOrigins.get(key(absR, absC));
 			if (insideMerge.has(key(absR, absC)) && !merge) {
@@ -237,11 +301,22 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 			const ws = cellMatrix[r]?.[c];
 			let text = ws ? resolveCellText(ws, sharedStrings, styles, date1904) : "";
 			const cfText = text.length > 0 ? text : void 0;
-			if (text.length > textBudget) text = text.slice(0, Math.max(0, textBudget));
+			if (text.length > textBudget) {
+				text = text.slice(0, Math.max(0, textBudget));
+				if (!textBudgetReported) {
+					textBudgetReported = true;
+					print.losses?.push({
+						severity: "dropped",
+						feature: FEATURES.text,
+						detail: `per-sheet text budget of ${MAX_SHEET_TEXT_CHARS} characters exhausted; the remaining cells render empty`,
+						...print.sheetName ? { where: `sheet "${print.sheetName}"` } : {}
+					});
+				}
+			}
 			textBudget -= text.length;
 			const xf = ws && ws.styleIndex !== void 0 ? styles.cellXfs[ws.styleIndex] : void 0;
 			let runProps = cellRunProps(xf);
-			const alignment = xf ? alignmentFromXf(xf) : void 0;
+			const alignment = alignmentFromXf(xf, ws?.type);
 			let shading = xf ? shadingFromXf(xf, styles) : void 0;
 			const tableFmt = tableFormatByCell.get(key(absR, absC));
 			if (!shading && tableFmt?.shading) shading = tableFmt.shading;
@@ -262,14 +337,16 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 					runProps = applyCfOverride(runProps, over);
 				}
 			}
+			let overflowSpan = 1;
 			const wrapText = xf?.alignment?.wrapText === true;
 			const rotation = xf?.alignment?.textRotation;
 			const rotated = rotation !== void 0 && rotation !== 0 && text.length > 0;
 			const shrinkToFit = xf?.alignment?.shrinkToFit === true && !wrapText && !rotated;
-			if (text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && ws && (ws.type === "s" || ws.type === "str" || ws.type === "inlineStr") && (alignment === void 0 || alignment === "left")) {
+			if (text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && ws && (ws.type === "s" || ws.type === "str" || ws.type === "inlineStr") && alignment === "left") {
 				let availTwips = columnWidths[c];
 				let cc = c + 1;
-				while (cc < colCount && !cellHasContent(cellMatrix[r]?.[cc])) {
+				const neighbourIsFree = (col) => !cellHasContent(cellMatrix[r]?.[col]) && !cellPaintsSomething(cellMatrix[r]?.[col], styles) && !sparklineByCell.has(key(absR, col + colStart)) && !(dropdownRanges.length > 0 && rangesCover(dropdownRanges, absR, col + colStart));
+				while (cc < colCount && neighbourIsFree(cc)) {
 					availTwips += columnWidths[cc];
 					cc++;
 				}
@@ -277,6 +354,10 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 					const charsFit = Math.max(1, Math.round(availTwips / 105));
 					if (text.length > charsFit) text = text.slice(0, charsFit);
 				}
+				if (cc > c + 1) {
+					overflowSpan = cc - c;
+					for (let k = c + 1; k < cc; k++) overflowed.add(k);
+				}
 			}
 			if (shrinkToFit && ws && text.length > 0) {
 				const charsFit = Math.max(1, columnWidths[c] / 105);
@@ -293,7 +374,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 			const href = print.hyperlinks && print.hyperlinks.length > 0 ? hyperlinkUrlAt(print.hyperlinks, absR, absC) : void 0;
 			const visibleEndCol = merge ? Math.min(merge.endColumn, colWindowEnd) : 0;
 			const properties = {
-				...merge && visibleEndCol > merge.startColumn ? { colSpan: visibleEndCol - merge.startColumn + 1 } : {},
+				...merge && visibleEndCol > merge.startColumn ? { colSpan: visibleEndCol - merge.startColumn + 1 } : overflowSpan > 1 ? { colSpan: overflowSpan } : {},
 				...merge && Math.min(merge.endRow, rowWindowEnd) > merge.startRow ? { merge: "start" } : {},
 				...shading ? { shading } : {},
 				...dataBar ? { dataBar } : {},
@@ -318,7 +399,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 				properties: runProps,
 				...href ? { href } : {}
 			}] : [];
-			const content = rotated ? stackedVerticalContent(text, runProps, href) : [{
+			const content = rotated ? stackedVerticalContent(text, runProps, href) : cellRuns.length === 0 ? [] : [{
 				kind: "paragraph",
 				paragraph: {
 					properties: paragraphProps,
@@ -352,6 +433,13 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	};
 	const centered = worksheet.printOptions?.horizontalCentered === true;
 	const tableProperties = {
+		defaultCellMargins: {
+			left: pt(EXCEL_CELL_INSET_PT),
+			right: pt(EXCEL_CELL_INSET_PT),
+			top: pt(0),
+			bottom: pt(0)
+		},
+		layout: "fixed",
 		...print.gridLines ? { borders: {
 			top: thin,
 			bottom: thin,
@@ -386,7 +474,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 				...tableProperties,
 				frozen
 			} : tableProperties,
-			grid: columnWidths.map((w) => twipsToPt(w)),
+			grid: bandWidths.map((w) => twipsToPt(w)),
 			rows
 		}
 	}];
@@ -477,10 +565,29 @@ function applyCfOverride(base, o) {
 		...o.italic !== void 0 ? { italic: o.italic } : {}
 	};
 }
-function alignmentFromXf(xf) {
-	const align = xf.alignment;
-	if (!align) return void 0;
-	return mapAlignment(align.horizontal);
+/**
+* ECMA-376 §18.8.1 — a cell's horizontal alignment, falling back to `general`.
+*
+* "General" is not "left": it is decided by the VALUE. Numbers, dates and times
+* go right, booleans and errors centre, text goes left. Treating an absent
+* `<alignment>` as no alignment at all left every number hugging the left edge
+* of its column, tens of points from where Excel and LibreOffice put it — on
+* the sheets where it matters most, since a column of figures is the common
+* case.
+*/
+function alignmentFromXf(xf, type) {
+	const explicit = xf?.alignment ? mapAlignment(xf.alignment.horizontal) : void 0;
+	if (explicit) return explicit;
+	return generalAlignment(type);
+}
+function generalAlignment(type) {
+	switch (type) {
+		case "n":
+		case "d": return "right";
+		case "b":
+		case "e": return "center";
+		default: return "left";
+	}
 }
 function mapAlignment(h) {
 	if (!h) return void 0;
@@ -640,7 +747,7 @@ function buildSparklineLookup(worksheet, print) {
 		const host = parseAreaRef(sp.sqref);
 		const area = parseAreaRef(sp.dataRange);
 		if (!host || !area) continue;
-		const values = collectSeriesValues(resolveSeriesGrid(sp.dataRange, worksheet, print.sheetGrids).cells, area);
+		const values = collectSeriesValues(resolveSeriesGrid(sp.dataRange, worksheet, print.sheetGrids).cells, area, print);
 		if (values.length === 0 || values.every((v) => v === null)) continue;
 		out.set(key(host.startRow, host.startColumn), {
 			kind: sp.kind,
@@ -660,7 +767,7 @@ function resolveSeriesGrid(dataRange, current, sheetGrids) {
 	return sheetGrids.get(name) ?? current;
 }
 var MAX_SPARKLINE_POINTS = 1e3;
-function collectSeriesValues(cells, area) {
+function collectSeriesValues(cells, area, print) {
 	const byKey = /* @__PURE__ */ new Map();
 	for (const c of cells) {
 		if (c.row < area.startRow || c.row > area.endRow) continue;
@@ -669,7 +776,14 @@ function collectSeriesValues(cells, area) {
 		const v = Number(c.rawValue);
 		if (Number.isFinite(v)) byKey.set(key(c.row, c.column), v);
 	}
-	if ((area.endRow - area.startRow + 1) * (area.endColumn - area.startColumn + 1) > MAX_SPARKLINE_POINTS) {
+	const cellCount = (area.endRow - area.startRow + 1) * (area.endColumn - area.startColumn + 1);
+	if (cellCount > MAX_SPARKLINE_POINTS) {
+		print.losses?.push({
+			severity: "degraded",
+			feature: FEATURES.charts,
+			detail: `sparkline range spans ${cellCount} cells (over ${MAX_SPARKLINE_POINTS}); plotted as the compact populated series, so blank gaps no longer hold their x-positions`,
+			...print.sheetName ? { where: `sheet "${print.sheetName}"` } : {}
+		});
 		const pts = [...byKey.entries()].map(([k, v]) => {
 			const [r, col] = k.split(",").map(Number);
 			return {
@@ -732,6 +846,56 @@ function buildTableFormatLookup(worksheet) {
 function cellHasContent(cell) {
 	return !!cell && (cell.rawValue !== "" || cell.inlineText !== void 0);
 }
+/**
+* The window-local index of the last row inside `[rowStart, rowStart+rowCount)`
+* that carries anything — a value, or a merge reaching into the window. `-1`
+* when the window is entirely blank.
+*/
+function lastContentRow(worksheet, rowStart, rowCount, colStart, colCount) {
+	const rowEnd = rowStart + rowCount - 1;
+	const colEnd = colStart + colCount - 1;
+	let last = -1;
+	for (const c of worksheet.cells) {
+		if (!cellHasContent(c)) continue;
+		if (c.row < rowStart || c.row > rowEnd || c.column < colStart || c.column > colEnd) continue;
+		if (c.row - rowStart > last) last = c.row - rowStart;
+	}
+	for (const m of worksheet.merges) {
+		if (m.startColumn > colEnd || m.endColumn < colStart) continue;
+		const reach = Math.min(m.endRow, rowEnd) - rowStart;
+		if (reach > last) last = reach;
+	}
+	return last;
+}
+/** The column twin of {@link lastContentRow}. */
+function lastContentColumn(worksheet, rowStart, rowCount, colStart, colCount) {
+	const rowEnd = rowStart + rowCount - 1;
+	const colEnd = colStart + colCount - 1;
+	let last = -1;
+	for (const c of worksheet.cells) {
+		if (!cellHasContent(c)) continue;
+		if (c.row < rowStart || c.row > rowEnd || c.column < colStart || c.column > colEnd) continue;
+		if (c.column - colStart > last) last = c.column - colStart;
+	}
+	for (const m of worksheet.merges) {
+		if (m.startRow > rowEnd || m.endRow < rowStart) continue;
+		const reach = Math.min(m.endColumn, colEnd) - colStart;
+		if (reach > last) last = reach;
+	}
+	return last;
+}
+/**
+* Whether an EMPTY cell still draws something of its own — a fill or a border.
+*
+* Such a cell cannot be swallowed by a neighbour's overflowing text: the span
+* that gives the text its width would take the paint with it.
+*/
+function cellPaintsSomething(cell, styles) {
+	if (!cell || cell.styleIndex === void 0) return false;
+	const xf = styles.cellXfs[cell.styleIndex];
+	if (!xf) return false;
+	return shadingFromXf(xf, styles) !== void 0 || bordersFromXf(xf, styles) !== void 0;
+}
 var SLICER_WIDTH_PT = 108;
 var SLICER_ROW_PT = 16;
 var SLICER_UNSELECTED_HEX = "F2F2F2";

package/dist/esm/excel/sheet-to-flow.d.ts

@@ -1,4 +1,5 @@
 import { FlowDoc } from '../core/ir/flow.js';
+import { Loss } from '../core/ir/loss.js';
 import { SheetDoc } from '../core/ir/sheet.js';
 /**
  * Projection knobs (E-SHEET W9).
@@ -11,6 +12,15 @@ export interface ProjectSheetOptions {
      * byte-identical to before.
      */
     readonly now?: Date;
+    /**
+     * Sink the projection writes its {@link Loss} entries into — the print
+     * model's defence-in-depth caps (grid size, per-sheet text budget, sparkline
+     * range) fire on pathological input, and a cap that fires without saying so
+     * is a silent wrongness. {@link readXlsx} always supplies one and returns it
+     * as the read result's loss report; omitted ⇒ the caps still apply but go
+     * unreported.
+     */
+    readonly losses?: Array<Loss>;
 }
 /**
  * Project a {@link SheetDoc} into a {@link FlowDoc} (E-SHEET SA2): each grid sheet

package/dist/esm/excel/sheet-to-flow.js

@@ -18,12 +18,16 @@ var FOOTER_REL = "_xlsxFooterDefault";
 */
 function projectSheetDoc(sheet, options = {}) {
 	const body = [];
+	const sheetSections = [];
+	const sheetEnds = [];
 	let firstSheetSection;
 	const headersFooters = /* @__PURE__ */ new Map();
 	const sheetGrids = new Map(sheet.sheets.map((s) => [s.name, s.grid]));
 	for (let sheetIdx = 0; sheetIdx < sheet.sheets.length; sheetIdx++) {
 		const ws = sheet.sheets[sheetIdx];
-		if (sheetIdx === 0) firstSheetSection = withHeaderFooter(sectionFromWorksheet(ws.grid), ws, headersFooters);
+		const sheetSection = sheetIdx === 0 ? withHeaderFooter(sectionFromWorksheet(ws.grid), ws, headersFooters) : sectionFromWorksheet(ws.grid);
+		if (sheetIdx === 0) firstSheetSection = sheetSection;
+		sheetSections.push(sheetSection);
 		if (sheetIdx > 0) body.push({
 			kind: "paragraph",
 			paragraph: {
@@ -43,7 +47,8 @@ function projectSheetDoc(sheet, options = {}) {
 			definedNames: sheet.definedNames,
 			...ws.hyperlinks ? { hyperlinks: ws.hyperlinks } : {},
 			...sheet.sharedStringRuns ? { sharedStringRuns: sheet.sharedStringRuns } : {},
-			...options.now ? { now: options.now } : {}
+			...options.now ? { now: options.now } : {},
+			...options.losses ? { losses: options.losses } : {}
 		}));
 		for (const ref of ws.charts ?? []) body.push({
 			kind: "chart",
@@ -74,11 +79,16 @@ function projectSheetDoc(sheet, options = {}) {
 		if (ws.comments && ws.comments.length > 0) body.push(...commentBlocks(ws.comments));
 		if (ws.formControls && ws.formControls.length > 0) body.push(...formControlBlocks(ws.formControls));
 		if (ws.activeXControls && ws.activeXControls.length > 0) body.push(...activeXBlocks(ws.activeXControls));
+		sheetEnds.push(body.length);
 	}
+	const sections = sheetSections.length > 1 ? sheetSections.map((properties, i) => ({
+		properties,
+		endIndex: sheetEnds[i]
+	})) : [];
 	return {
 		kind: "flow",
 		body: resolveBodyStyles(body, EMPTY_STYLE_SHEET),
-		sections: [],
+		sections,
 		...firstSheetSection ? { section: firstSheetSection } : {},
 		styles: EMPTY_STYLE_SHEET,
 		resources: sheet.resources,
@@ -220,10 +230,7 @@ function withHeaderFooter(section, ws, headersFooters) {
 	}
 	if (headers.length === 0 && footers.length === 0) return section;
 	return {
-		...section ?? {
-			headers: [],
-			footers: []
-		},
+		...section,
 		headers,
 		footers
 	};

package/dist/esm/excel/worksheet-parser.js

@@ -54,6 +54,7 @@ function parseWorksheet(data) {
 	const sparklines = parseSparklines(wsObj);
 	const tablePartRelIds = parseTableParts(wsObj);
 	const printModel = {
+		...parseSheetFormatPr(wsObj),
 		...pageMargins ? { pageMargins } : {},
 		...pageSetup ? { pageSetup } : {},
 		...fitToPage ? { fitToPage } : {},
@@ -245,6 +246,27 @@ function parseNumericAttr(obj, key) {
 	const n = Number(raw);
 	return Number.isFinite(n) ? n : void 0;
 }
+/**
+* ECMA-376 §18.3.1.81 `<sheetFormatPr>` — the sheet's default row height and
+* column width, which apply to every row/column that does not override them.
+*
+* Both were previously ignored, so a row without an explicit `ht` had no height
+* at all and ended up however tall its text wanted to be. A spreadsheet row has
+* a definite height; text metrics do not get a vote.
+*/
+function parseSheetFormatPr(ws) {
+	const node = ws["sheetFormatPr"];
+	if (!node || typeof node !== "object") return {};
+	const obj = node;
+	const height = parseNumericAttr(obj, "defaultRowHeight");
+	const width = parseNumericAttr(obj, "defaultColWidth");
+	const base = parseNumericAttr(obj, "baseColWidth");
+	return {
+		...height !== void 0 && height > 0 ? { defaultRowHeightPt: height } : {},
+		...width !== void 0 && width > 0 ? { defaultColWidthChars: width } : {},
+		...base !== void 0 && base > 0 ? { baseColWidthChars: base } : {}
+	};
+}
 function parseColumns(ws) {
 	const colsNode = ws["cols"];
 	if (!colsNode || typeof colsNode !== "object") return [];
@@ -762,16 +784,17 @@ function parseCell(c, fallbackRow, fallbackCol) {
 	if (!c || typeof c !== "object") return null;
 	const obj = c;
 	const ref = strAttr(obj, "r");
+	const implied = {
+		column: fallbackCol,
+		row: fallbackRow
+	};
 	let address;
 	if (ref) try {
 		address = parseCellRef(ref);
 	} catch {
-		return null;
+		address = numericRef(ref, fallbackRow) ?? implied;
 	}
-	else address = {
-		column: fallbackCol,
-		row: fallbackRow
-	};
+	else address = implied;
 	const type = validateCellType(strAttr(obj, "t") ?? "n");
 	const styleStr = strAttr(obj, "s");
 	const styleIndex = styleStr !== void 0 ? Number(styleStr) : void 0;
@@ -784,7 +807,8 @@ function parseCell(c, fallbackRow, fallbackCol) {
 	};
 	if (type === "inlineStr") {
 		const is = obj["is"];
-		const inlineText = inlineStringText(is);
+		const fromIs = inlineStringText(is);
+		const inlineText = fromIs !== "" ? fromIs : rawValue;
 		return {
 			...base,
 			rawValue: "",
@@ -798,6 +822,38 @@ function parseCell(c, fallbackRow, fallbackCol) {
 		...Number.isFinite(styleIndex) ? { styleIndex } : {}
 	};
 }
+var NUMERIC_REF = /^(\d+)_(\d+)$/;
+/**
+* Decode a numeric `"4_2"`-style reference, but only when the file corroborates
+* the reading.
+*
+* This is not a spec spelling and there is no obligation to understand it. What
+* makes it safe to act on is that the file states its own convention and can be
+* checked against itself: every ref inside `<row r="2">` ends in `_2`. So the
+* row half must agree with the row the cell actually sits in — and when it does
+* not, the reference has told us nothing and document order (§18.3.1.4) remains
+* the answer. A guess that cannot be checked is worse than the fallback; this
+* one can be.
+*
+* The alternative is not harmless: these cells are sparse (columns 1, 4, 5, 7,
+* 11, 13, 22 …), so packing them consecutively files every value under the
+* wrong heading.
+*
+* @param ref      The unparseable `r` attribute.
+* @param rowIndex The 0-based row the cell sits in.
+* @returns The address, or undefined when the reading is not corroborated.
+*/
+function numericRef(ref, rowIndex) {
+	const m = NUMERIC_REF.exec(ref);
+	if (!m) return void 0;
+	const column = Number(m[1]);
+	const row = Number(m[2]);
+	if (column < 1 || row !== rowIndex + 1) return void 0;
+	return {
+		column: column - 1,
+		row: rowIndex
+	};
+}
 function validateCellType(t) {
 	if (t === "n" || t === "s" || t === "str" || t === "b" || t === "d" || t === "e" || t === "inlineStr") return t;
 	return "n";

package/dist/esm/excel/xlsx-reader.d.ts

@@ -4,12 +4,16 @@ import { SheetDoc } from '../core/ir/sheet.js';
 import { ProjectSheetOptions } from './sheet-to-flow.js';
 /**
  * Read a `.xlsx` and project it to a {@link FlowDoc} in one step:
- * {@link readXlsxToSheetDoc} then {@link projectSheetDoc}. The xlsx reader
- * records no read-time losses.
+ * {@link readXlsxToSheetDoc} then {@link projectSheetDoc}.
+ *
+ * Parsing itself is lossless — SpreadsheetML maps cleanly onto the sheet IR.
+ * The losses come from the projection: the print model's defence-in-depth caps
+ * (grid size, per-sheet text budget, sparkline range) clip pathological sheets,
+ * and each clip is reported rather than applied in silence.
  *
  * @param xlsx    The `.xlsx` (OPC ZIP) bytes.
  * @param options Projection knobs (the W9 reference date).
- * @returns The flow document plus an (empty) loss list.
+ * @returns The flow document plus whatever the projection had to clip.
  */
 export declare function readXlsx(xlsx: Uint8Array, options?: ProjectSheetOptions): ReadResult<FlowDoc>;
 /**

package/dist/esm/excel/xlsx-reader.js

@@ -1,6 +1,6 @@
 import { ResourceStore } from "../core/ir/resources.js";
 import { FEATURES } from "../core/ir/features.js";
-import { bytesInclude } from "../core/bytes.js";
+import { bytesInclude, bytesIncludePartName } from "../core/bytes.js";
 import { DEFAULT_THEME_PALETTE, makeColorResolver } from "../core/drawingml/colors.js";
 import { parseChart, withChartColorStyle } from "../core/drawingml/chart-parser.js";
 import { parseTheme } from "../core/drawingml/theme-parser.js";
@@ -21,7 +21,7 @@ import { parsePivotTablePart } from "./pivot-table-parser.js";
 import { parseSlicerCachePart, parseSlicerPart } from "./slicer-parser.js";
 import { parseLegacyComments, parsePersons, parseThreadedComments } from "./comments-parser.js";
 import { parseFormControlProps } from "./form-control-parser.js";
-import { activeXBinRelId, activeXType, parseActiveX, parseActiveXBin } from "./activex-parser.js";
+import { activeXBinRelId, activeXType, activeXTypeFromPart, parseActiveX, parseActiveXBin } from "./activex-parser.js";
 import { parseSheetShapes } from "./sheet-shape-parser.js";
 import { projectSheetDoc } from "./sheet-to-flow.js";
 //#region src/excel/xlsx-reader.ts
@@ -34,19 +34,28 @@ var SLICER_CACHE_REL_TAIL = "/slicerCache";
 var THREADED_COMMENTS_REL_TAIL = "/threadedComment";
 var PERSON_REL_TAIL = "/person";
 var MAX_SLICER_ITEMS = 256;
+var ACTIVEX_PART = /^xl\/activeX\//i;
 /**
 * Read a `.xlsx` and project it to a {@link FlowDoc} in one step:
-* {@link readXlsxToSheetDoc} then {@link projectSheetDoc}. The xlsx reader
-* records no read-time losses.
+* {@link readXlsxToSheetDoc} then {@link projectSheetDoc}.
+*
+* Parsing itself is lossless — SpreadsheetML maps cleanly onto the sheet IR.
+* The losses come from the projection: the print model's defence-in-depth caps
+* (grid size, per-sheet text budget, sparkline range) clip pathological sheets,
+* and each clip is reported rather than applied in silence.
 *
 * @param xlsx    The `.xlsx` (OPC ZIP) bytes.
 * @param options Projection knobs (the W9 reference date).
-* @returns The flow document plus an (empty) loss list.
+* @returns The flow document plus whatever the projection had to clip.
 */
 function readXlsx(xlsx, options = {}) {
+	const losses = [];
 	return {
-		doc: projectSheetDoc(readXlsxToSheetDoc(xlsx), options),
-		losses: []
+		doc: projectSheetDoc(readXlsxToSheetDoc(xlsx), {
+			...options,
+			losses
+		}),
+		losses
 	};
 }
 /**
@@ -211,13 +220,33 @@ function readXlsxToSheetDoc(xlsx) {
 			}
 			if (resolvedComments.length > 0) comments = resolvedComments;
 		}
+		const wsRels = pkg.getPartRelationships(resolved.path);
+		const resolvedAx = [];
+		const activeXState = (part) => {
+			const props = parseActiveX(part.data);
+			const binRelId = activeXBinRelId(part.data);
+			const binRel = binRelId ? pkg.getPartRelationships(part.path).find((r) => r.id === binRelId) : void 0;
+			const binPart = binRel ? pkg.resolveRelatedPart(part.path, binRel) : void 0;
+			return {
+				type: "control",
+				...binPart ? parseActiveXBin(binPart.data) : {},
+				...props
+			};
+		};
 		let formControls;
 		if (worksheet.formControls && worksheet.formControls.length > 0) {
-			const wsRels = pkg.getPartRelationships(resolved.path);
 			const resolvedControls = [];
 			for (const fc of worksheet.formControls) {
 				const rel = wsRels.find((r) => r.id === fc.relId);
 				const part = rel ? pkg.resolveRelatedPart(resolved.path, rel) : void 0;
+				if (part && ACTIVEX_PART.test(part.path)) {
+					resolvedAx.push({
+						...activeXState(part),
+						type: activeXTypeFromPart(part.data),
+						...fc.name ? { name: fc.name } : {}
+					});
+					continue;
+				}
 				const props = part ? parseFormControlProps(part.data) : {};
 				resolvedControls.push({
 					...fc.name ? { name: fc.name } : {},
@@ -226,29 +255,15 @@ function readXlsxToSheetDoc(xlsx) {
 			}
 			if (resolvedControls.length > 0) formControls = resolvedControls;
 		}
-		let activeXControls;
-		if (worksheet.oleObjects && worksheet.oleObjects.length > 0) {
-			const wsRels = pkg.getPartRelationships(resolved.path);
-			const resolvedAx = [];
-			for (const ole of worksheet.oleObjects) {
-				const rel = wsRels.find((r) => r.id === ole.relId);
-				const part = rel ? pkg.resolveRelatedPart(resolved.path, rel) : void 0;
-				const props = part ? parseActiveX(part.data) : {};
-				let binProps = {};
-				if (part) {
-					const binRelId = activeXBinRelId(part.data);
-					const binRel = binRelId ? pkg.getPartRelationships(part.path).find((r) => r.id === binRelId) : void 0;
-					const binPart = binRel ? pkg.resolveRelatedPart(part.path, binRel) : void 0;
-					if (binPart) binProps = parseActiveXBin(binPart.data);
-				}
-				resolvedAx.push({
-					type: activeXType(ole.progId),
-					...binProps,
-					...props
-				});
-			}
-			if (resolvedAx.length > 0) activeXControls = resolvedAx;
+		if (worksheet.oleObjects && worksheet.oleObjects.length > 0) for (const ole of worksheet.oleObjects) {
+			const rel = wsRels.find((r) => r.id === ole.relId);
+			const part = rel ? pkg.resolveRelatedPart(resolved.path, rel) : void 0;
+			resolvedAx.push({
+				...part ? activeXState(part) : {},
+				type: activeXType(ole.progId)
+			});
 		}
+		const activeXControls = resolvedAx.length > 0 ? resolvedAx : void 0;
 		const grid = tables || pivotTables ? {
 			...worksheet,
 			...tables ? { tables } : {},
@@ -414,7 +429,7 @@ var xlsxReader = {
 	id: "xlsx",
 	produces: "sheet",
 	supports: new Set([FEATURES.text, FEATURES.tables]),
-	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesInclude(bytes, "xl/workbook.xml"),
+	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesIncludePartName(bytes, "xl/workbook.xml"),
 	read: (bytes) => ({
 		doc: readXlsxToSheetDoc(bytes),
 		losses: []

package/dist/esm/layout/styled-layout.js

@@ -1891,6 +1891,7 @@ var PageAssembler = class {
 		this.bookmarkPositions = bookmarkPositions;
 		this.ctx = sectionCtxs[0];
 		this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
+		this.colStartY = this.cursorY;
 	}
 	pages = [];
 	ctx;
@@ -1908,18 +1909,33 @@ var PageAssembler = class {
 	*/
 	colIdx = 0;
 	colStartLen = 0;
+	/** The cursor's y at the top of the current column — see {@link colHasContent}. */
+	colStartY;
 	/** The current column's left edge (`marginLeft` plus the column x-offset). */
 	colLeft = () => this.ctx.marginLeft + (this.ctx.columns?.[this.colIdx]?.xOffsetPt ?? 0);
 	/** The current column's width (the section content width when single-column). */
 	colWidth = () => this.ctx.columns?.[this.colIdx]?.widthPt ?? this.ctx.contentWidth;
-	/** Whether the current column has received any items yet. */
-	colHasContent = () => this.current.length > this.colStartLen;
+	/**
+	* Whether the current column is already in use.
+	*
+	* This gates every overflow break, so that a block too tall for an empty page
+	* is placed rather than looping forever. It used to ask whether the column had
+	* received any drawable ITEM, which is not the same question: a run of empty
+	* table rows consumes vertical space and draws nothing, so the guard stayed
+	* false, no break ever fired, and the rows marched off the bottom of the page.
+	* A spreadsheet is full of such rows — the sheet in tdf171828.xlsx has 162 of
+	* them — and they were silently costing whole pages of pagination.
+	*
+	* Consumed space counts as use, whether or not any ink went with it.
+	*/
+	colHasContent = () => this.current.length > this.colStartLen || this.cursorY < this.colStartY;
 	/** Overflow step: next column on this page, or a fresh page after the last. */
 	advanceColumn = () => {
 		if (this.ctx.columns && this.colIdx + 1 < this.ctx.columns.length) {
 			this.colIdx++;
 			this.colStartLen = this.current.length;
 			this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
+			this.colStartY = this.cursorY;
 		} else this.flushPage();
 	};
 	/**
@@ -2098,7 +2114,7 @@ var PageAssembler = class {
 	*              guarantee one page for a header/footer-only document).
 	*/
 	flushPage = (force = false) => {
-		if (this.current.length === 0 && !force) return;
+		if (this.current.length === 0 && this.cursorY >= this.colStartY && !force) return;
 		const band = bandForPage(this.pageInSection, this.globalPageIdx, this.ctx.titlePg, this.ctx.evenAndOddHeaders);
 		const header = pickBand(this.ctx.headerSet, band);
 		const footer = pickBand(this.ctx.footerSet, band);
@@ -2137,6 +2153,7 @@ var PageAssembler = class {
 		this.pageInSection++;
 		this.globalPageIdx++;
 		this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
+		this.colStartY = this.cursorY;
 	};
 };
 function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", notes, bookmarkPositions, reflowParagraph) {

package/dist/esm/pptx/pptx-reader.js

@@ -4,7 +4,7 @@ import { FEATURES } from "../core/ir/features.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
 import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs } from "../core/po-helpers.js";
-import { bytesInclude } from "../core/bytes.js";
+import { bytesIncludePartName } from "../core/bytes.js";
 import { DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver } from "../core/drawingml/colors.js";
 import { parseChart, withChartColorStyle } from "../core/drawingml/chart-parser.js";
 import { parseTheme } from "../core/drawingml/theme-parser.js";
@@ -269,7 +269,7 @@ var pptxReader = {
 		FEATURES.charts,
 		FEATURES.tables
 	]),
-	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesInclude(bytes, "ppt/presentation.xml"),
+	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesIncludePartName(bytes, "ppt/presentation.xml"),
 	read: (bytes) => readPptx(bytes)
 };
 //#endregion

package/dist/esm/word/docx-reader.js

@@ -5,7 +5,7 @@ import { EMPTY_STYLE_SHEET, resolveBodyStyles, resolveHeadersFootersStyles } fro
 import { resolveTableStyles } from "../core/style-cascade/table.js";
 import "../core/style-cascade/index.js";
 import { poFindDescendant } from "../core/po-helpers.js";
-import { bytesInclude } from "../core/bytes.js";
+import { bytesIncludePartName } from "../core/bytes.js";
 import { DEFAULT_THEME_PALETTE, makeColorResolver } from "../core/drawingml/colors.js";
 import { parseChart, withChartColorStyle } from "../core/drawingml/chart-parser.js";
 import { parseTheme } from "../core/drawingml/theme-parser.js";
@@ -144,7 +144,7 @@ var docxReader = {
 		FEATURES.trackedChanges,
 		FEATURES.fontsEmbedding
 	]),
-	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesInclude(bytes, "word/document.xml"),
+	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesIncludePartName(bytes, "word/document.xml"),
 	read: (bytes) => readDocx(bytes)
 };
 function infoFromCore(core) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reamkit",
-  "version": "1.15.2",
+  "version": "1.15.4",
   "description": "Ream — convert DOCX, XLSX, PPTX and PDF to PDF, SVG, HTML, DOCX and XLSX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
   "license": "MIT",
   "author": "Alex Krassavin <info@reamkit.dev>",
@@ -70,7 +70,10 @@
     "corpus:sandbox:build": "docker build -t docgen-losandbox:latest scripts/corpus/sandbox/",
     "corpus": "tsx scripts/corpus/run.ts",
     "corpus:roundtrip": "tsx scripts/corpus/roundtrip.ts",
-    "corpus:roundtrip:xlsx": "tsx scripts/corpus/xlsx-roundtrip.ts"
+    "corpus:roundtrip:xlsx": "tsx scripts/corpus/xlsx-roundtrip.ts",
+    "corpus:xlsx:invariants": "tsx scripts/corpus/xlsx-invariants.ts",
+    "corpus:fixtures": "tsx scripts/corpus/sync-real-fixtures.ts",
+    "corpus:golden": "tsx scripts/corpus/make-golden.ts"
   },
   "dependencies": {
     "fast-xml-parser": "5.7.0",