omni-viewer-core 0.1.0

package/dist/parsers/excel/index.d.ts

@@ -0,0 +1,17 @@
+import type * as XLSX from 'xlsx';
+import type { ParseOptions, ParseOutcome } from '../types.js';
+import type { ExcelWorkbook } from './model.js';
+export type { CellRange, CellStyle, ExcelCell, ExcelCellType, ExcelSheet, ExcelWorkbook, SheetAoa } from './model.js';
+export { sheetToAoa } from './model.js';
+export { serializeWorkbook } from './serialize.js';
+/** SheetJS is provided by the caller; the base entry never imports it. */
+export interface ExcelParseDeps {
+    xlsx: typeof XLSX;
+}
+/** Input ownership: the parser consumes the input (DESIGN.md §3-①). */
+export declare const EXCEL_INPUT_OWNERSHIP: "consumes";
+/** Default cap on the archive's declared uncompressed total (matches
+ *  ARCHIVE_DEFAULT_LIMITS.maxDecompressedBytes); override via
+ *  `options.limits.maxDecompressedBytes`. */
+export declare const EXCEL_MAX_DECOMPRESSED_BYTES: number;
+export declare function parseExcel(input: Uint8Array, deps: ExcelParseDeps, options?: ParseOptions): ParseOutcome<ExcelWorkbook>;

package/dist/parsers/excel/index.js

@@ -0,0 +1,406 @@
+// Excel parser entry — the core contract surface (docs/viewers/excel.md §2,
+// DESIGN.md §3-①). parseExcel(bytes) -> ParseOutcome<ExcelWorkbook>.
+//
+// SheetJS (`xlsx`) is an optional peer dependency and is **injected** rather
+// than imported at runtime (ExcelParseDeps), so this base entry carries no
+// `import 'xlsx'` — the bundler of a platform that doesn't use the Excel viewer
+// never has to resolve it (ADR 14, X8). Type-only imports below are erased.
+//
+// Input-caused failures never throw; they return `status: 'failed'` (ADR 11).
+// Input ownership is `consumes` — after parsing, the original bytes are not
+// needed (no verbatim view), so a Worker may transfer them (X4, DESIGN §3-①).
+import { DEFAULT_LIMITS, LimitTracker } from '../types.js';
+import { declaredZipUncompressedBytes } from '../zip-scan.js';
+export { sheetToAoa } from './model.js';
+export { serializeWorkbook } from './serialize.js';
+/** Input ownership: the parser consumes the input (DESIGN.md §3-①). */
+export const EXCEL_INPUT_OWNERSHIP = 'consumes';
+/** Default cap on the archive's declared uncompressed total (matches
+ *  ARCHIVE_DEFAULT_LIMITS.maxDecompressedBytes); override via
+ *  `options.limits.maxDecompressedBytes`. */
+export const EXCEL_MAX_DECOMPRESSED_BYTES = 1024 * 1024 * 1024;
+export function parseExcel(input, deps, options = {}) {
+    const started = Date.now();
+    const limits = { ...DEFAULT_LIMITS, ...options.limits };
+    const diagnostics = [];
+    const finish = (result) => ({
+        result,
+        execution: {
+            workerUsed: false,
+            // maxDecompressedBytes is checked against the ZIP central directory's
+            // declared sizes before read (zip-scan.ts), but SheetJS decompresses
+            // internally, so an archive that lies in its headers is not bounded
+            // during inflate — only maxInputBytes (pre-load) and maxEntries
+            // (post-read cell cap) are hard here (X4, follow-up: Worker).
+            hardLimitEnforced: false,
+            elapsedMillis: Date.now() - started
+        }
+    });
+    if (input.byteLength > limits.maxInputBytes) {
+        return finish(fail('limit-exceeded', false, 'diag.limit-exceeded.input', diagnostics, {
+            maxBytes: limits.maxInputBytes
+        }));
+    }
+    if (options.signal?.aborted) {
+        return finish(fail('aborted', true, 'diag.aborted', diagnostics));
+    }
+    // Zip-bomb pre-scan: reject archives whose central directory declares more
+    // uncompressed data than the cap before SheetJS inflates anything. Legacy
+    // .xls (CFB) and other non-ZIP inputs return null and pass through.
+    const maxDecompressed = limits.maxDecompressedBytes ?? EXCEL_MAX_DECOMPRESSED_BYTES;
+    const declared = declaredZipUncompressedBytes(input);
+    if (declared !== null && declared > maxDecompressed) {
+        return finish(fail('limit-exceeded', false, 'diag.limit-exceeded.decompressed', diagnostics, {
+            maxBytes: maxDecompressed
+        }));
+    }
+    let wb;
+    try {
+        wb = deps.xlsx.read(input, {
+            type: 'array',
+            cellDates: true,
+            cellNF: true,
+            cellText: true,
+            cellStyles: true // grid mode (X3): populate cell.s / !cols / !rows
+        });
+    }
+    catch (err) {
+        const message = String(err?.message ?? err).toLowerCase();
+        if (message.includes('password') || message.includes('encrypt')) {
+            return finish(fail('password-required', true, 'diag.excel.password-required', diagnostics));
+        }
+        return finish(fail('invalid-format', false, 'diag.excel.invalid-format', diagnostics));
+    }
+    const date1904 = readDate1904(wb);
+    const sheetNames = Array.isArray(wb.SheetNames) ? [...wb.SheetNames] : [];
+    const tracker = new LimitTracker(limits, options.signal);
+    const sheets = [];
+    let truncated = false;
+    let aborted = false;
+    let nonEmptySheets = 0;
+    for (const name of sheetNames) {
+        const ws = wb.Sheets[name];
+        const built = ws ? buildSheet(name, ws, deps.xlsx, tracker, limits.maxEntries) : emptySheet(name);
+        sheets.push(built.sheet);
+        if (built.sheet.usedRange)
+            nonEmptySheets++;
+        if (built.aborted) {
+            aborted = true;
+            break;
+        }
+        if (built.truncated) {
+            truncated = true;
+            break;
+        }
+    }
+    if (aborted) {
+        return finish(fail('aborted', true, 'diag.aborted', diagnostics));
+    }
+    if (sheetNames.length === 0 || nonEmptySheets === 0) {
+        diagnostics.push({
+            severity: 'info',
+            code: 'excel.empty-workbook',
+            messageKey: 'diag.excel.empty-workbook'
+        });
+    }
+    const document = { sheetNames, sheets, date1904 };
+    if (truncated) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'limit-exceeded',
+            messageKey: 'diag.limit-exceeded.cells',
+            args: { count: tracker.entryCount }
+        });
+        return finish({ status: 'partial', document, diagnostics });
+    }
+    return finish({ status: 'ok', document, diagnostics });
+}
+function fail(code, retryable, messageKey, diagnostics, args) {
+    return {
+        status: 'failed',
+        failure: args ? { code, retryable, messageKey, args } : { code, retryable, messageKey },
+        diagnostics
+    };
+}
+function emptySheet(name) {
+    return {
+        sheet: { name, usedRange: null, cells: [], rowCount: 0, columnCount: 0 },
+        truncated: false,
+        aborted: false
+    };
+}
+function buildSheet(name, ws, xlsx, tracker, maxEntries) {
+    const usedRange = resolveUsedRange(ws, xlsx);
+    if (!usedRange) {
+        return emptySheet(name);
+    }
+    // Collect present cells only (sparse) and emit row-major for deterministic
+    // order regardless of the object key order SheetJS produced.
+    const addresses = [];
+    for (const key of Object.keys(ws)) {
+        if (key.charCodeAt(0) === 0x21 /* '!' */)
+            continue;
+        const decoded = xlsx.utils.decode_cell(key);
+        addresses.push({ r: decoded.r, c: decoded.c, addr: key });
+    }
+    addresses.sort((a, b) => (a.r - b.r) || (a.c - b.c));
+    const cells = [];
+    let truncated = false;
+    let aborted = false;
+    for (let i = 0; i < addresses.length; i++) {
+        const entry = addresses[i];
+        const raw = ws[entry.addr];
+        if (!raw || raw.t === 'z' || raw.t === undefined)
+            continue; // blank/stub
+        tracker.addEntries(1);
+        // Amortize abort/limit checks: every 512 cells or once over the cap.
+        if (i % 512 === 0 || tracker.entryCount > maxEntries) {
+            const violation = tracker.checkpoint();
+            if (violation?.kind === 'aborted') {
+                aborted = true;
+                break;
+            }
+            if (violation) {
+                truncated = true;
+                break;
+            }
+        }
+        cells.push(mapCell(entry.r, entry.c, raw));
+    }
+    const sheet = {
+        name,
+        usedRange,
+        cells,
+        rowCount: usedRange.r1 - usedRange.r0 + 1,
+        columnCount: usedRange.c1 - usedRange.c0 + 1
+    };
+    // Grid-mode presentation (X3): merges + column/row sizes. Optional — only
+    // set when present, so the data mode and existing snapshots are unaffected.
+    const merges = ws['!merges']?.map((m) => ({
+        r0: m.s.r,
+        c0: m.s.c,
+        r1: m.e.r,
+        c1: m.e.c
+    }));
+    if (merges && merges.length)
+        sheet.merges = merges;
+    const cols = ws['!cols'];
+    if (cols) {
+        const widths = {};
+        cols.forEach((col, c) => {
+            const px = colWidthPx(col);
+            if (px !== null)
+                widths[c] = px;
+        });
+        if (Object.keys(widths).length)
+            sheet.columnWidthsPx = widths;
+    }
+    const rows = ws['!rows'];
+    if (rows) {
+        const heights = {};
+        rows.forEach((row, r) => {
+            const px = rowHeightPx(row);
+            if (px !== null)
+                heights[r] = px;
+        });
+        if (Object.keys(heights).length)
+            sheet.rowHeightsPx = heights;
+    }
+    return { sheet, truncated, aborted };
+}
+/** Column width in px from SheetJS ColInfo (ported from omni-viewer-web). */
+function colWidthPx(col) {
+    if (!col)
+        return null;
+    if (typeof col.wpx === 'number')
+        return clampPx(col.wpx, 24, 800);
+    if (typeof col.wch === 'number')
+        return clampPx(col.wch * 8 + 12, 24, 800);
+    if (typeof col.width === 'number')
+        return clampPx((col.width / 256) * 8 + 12, 24, 800);
+    return null;
+}
+/** Row height in px from SheetJS RowInfo (ported from omni-viewer-web). */
+function rowHeightPx(row) {
+    if (!row)
+        return null;
+    if (typeof row.hpx === 'number')
+        return clampPx(row.hpx, 20, 240);
+    if (typeof row.hpt === 'number')
+        return clampPx((row.hpt * 96) / 72, 20, 240);
+    return null;
+}
+function clampPx(value, min, max) {
+    return Math.max(min, Math.min(max, Math.round(value)));
+}
+function resolveUsedRange(ws, xlsx) {
+    const ref = ws['!ref'];
+    if (ref) {
+        try {
+            const range = xlsx.utils.decode_range(ref);
+            if (range.e.r >= range.s.r && range.e.c >= range.s.c) {
+                return { r0: range.s.r, c0: range.s.c, r1: range.e.r, c1: range.e.c };
+            }
+        }
+        catch {
+            // fall through to manual reconstruction
+        }
+    }
+    let r0 = Infinity, c0 = Infinity, r1 = -1, c1 = -1;
+    for (const key of Object.keys(ws)) {
+        if (key.charCodeAt(0) === 0x21)
+            continue;
+        const cell = xlsx.utils.decode_cell(key);
+        if (cell.r < r0)
+            r0 = cell.r;
+        if (cell.c < c0)
+            c0 = cell.c;
+        if (cell.r > r1)
+            r1 = cell.r;
+        if (cell.c > c1)
+            c1 = cell.c;
+    }
+    if (r1 < 0 || c1 < 0)
+        return null;
+    return { r0, c0, r1, c1 };
+}
+function mapCell(r, c, cell) {
+    const w = cell.w != null ? String(cell.w) : (cell.v == null ? '' : String(cell.v));
+    let t;
+    let v;
+    switch (cell.t) {
+        case 'n':
+            t = 'number';
+            v = typeof cell.v === 'number' ? cell.v : Number(cell.v);
+            break;
+        case 'b':
+            t = 'boolean';
+            v = Boolean(cell.v);
+            break;
+        case 'd':
+            t = 'date';
+            v = cell.v instanceof Date ? dateToIso(cell.v) : String(cell.v ?? '');
+            break;
+        case 'e':
+            t = 'error';
+            v = w;
+            break;
+        default: // 's' | 'str' (formula string result) | anything else
+            t = 'text';
+            v = cell.v == null ? '' : String(cell.v);
+            break;
+    }
+    const style = mapStyle(cell.s);
+    return style ? { r, c, t, v, w, style } : { r, c, t, v, w };
+}
+/** Map a SheetJS cell style object to the semantic CellStyle (grid mode, X3).
+ *  Ported from omni-viewer-web `mapCellStyle`; stores semantic values, not CSS. */
+function mapStyle(s) {
+    if (!s || typeof s !== 'object')
+        return undefined;
+    const style = s;
+    const out = {};
+    const font = style.font;
+    if (font?.bold)
+        out.bold = true;
+    if (font?.italic)
+        out.italic = true;
+    if (typeof font?.sz === 'number')
+        out.fontSizePx = Math.max(8, Math.min(64, font.sz));
+    const color = normalizeColor(font?.color);
+    if (color)
+        out.color = color;
+    const fill = style.fill;
+    const bg = normalizeColor(fill?.fgColor) ?? normalizeColor(fill?.bgColor);
+    if (bg && fill?.patternType && fill.patternType !== 'none')
+        out.background = bg;
+    const align = style.alignment;
+    const h = align?.horizontal !== undefined ? String(align.horizontal) : '';
+    if (h === 'left' || h === 'center' || h === 'right' || h === 'justify')
+        out.align = h;
+    else if (h === 'centerContinuous')
+        out.align = 'center';
+    else if (h === 'distributed')
+        out.align = 'justify';
+    const va = align?.vertical !== undefined ? String(align.vertical) : '';
+    if (va === 'top' || va === 'center' || va === 'bottom')
+        out.valign = va;
+    if (align?.wrapText)
+        out.wrap = true;
+    const border = style.border;
+    if (border) {
+        const edges = {};
+        const toEdge = (edge) => {
+            if (!edge || typeof edge !== 'object')
+                return undefined;
+            const e = edge;
+            const c = normalizeColor(e.color) ?? '#808080';
+            return `${borderStyle(typeof e.style === 'string' ? e.style : undefined)} ${c}`;
+        };
+        const top = toEdge(border.top);
+        const right = toEdge(border.right);
+        const bottom = toEdge(border.bottom);
+        const left = toEdge(border.left);
+        if (top)
+            edges.top = top;
+        if (right)
+            edges.right = right;
+        if (bottom)
+            edges.bottom = bottom;
+        if (left)
+            edges.left = left;
+        if (Object.keys(edges).length)
+            out.borders = edges;
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+function normalizeColor(color) {
+    if (!color || typeof color !== 'object')
+        return undefined;
+    const rgb = color.rgb;
+    if (typeof rgb !== 'string')
+        return undefined;
+    const raw = rgb.replace('#', '');
+    const hex = raw.length > 6 ? raw.slice(-6) : raw;
+    return /^[0-9A-Fa-f]{6}$/.test(hex) ? `#${hex}` : undefined;
+}
+function borderStyle(style) {
+    switch (style) {
+        case 'medium': return '2px solid';
+        case 'thick': return '3px solid';
+        case 'dashed': return '1px dashed';
+        case 'dotted': return '1px dotted';
+        case 'double': return '3px double';
+        default: return '1px solid'; // thin / hair / unknown
+    }
+}
+/**
+ * Format a SheetJS date cell to a calendar-preserving ISO string. SheetJS
+ * (>=0.20) constructs the Date from the serial's parts in UTC; reading them
+ * back with UTC getters round-trips the intended calendar date on any host
+ * timezone (deterministic), so we never call local getters (X5, determinism
+ * rule). Requires xlsx >=0.20.2 (the peer range) — 0.18 built these Dates
+ * from local-time parts, which this would misread.
+ */
+function dateToIso(d) {
+    if (Number.isNaN(d.getTime()))
+        return '';
+    const pad = (n, width = 2) => String(n).padStart(width, '0');
+    const y = pad(d.getUTCFullYear(), 4);
+    const mo = pad(d.getUTCMonth() + 1);
+    const da = pad(d.getUTCDate());
+    const h = d.getUTCHours();
+    const mi = d.getUTCMinutes();
+    const s = d.getUTCSeconds();
+    const ms = d.getUTCMilliseconds();
+    if (h === 0 && mi === 0 && s === 0 && ms === 0)
+        return `${y}-${mo}-${da}`;
+    const base = `${y}-${mo}-${da}T${pad(h)}:${pad(mi)}:${pad(s)}`;
+    return ms ? `${base}.${pad(ms, 3)}` : base;
+}
+function readDate1904(wb) {
+    // SheetJS types this as boolean | undefined, but files can carry 1/"1";
+    // coerce defensively without tripping strict comparisons.
+    const flag = wb.Workbook?.WBProps?.date1904;
+    return flag === true || flag === 1 || flag === '1' || flag === 'true';
+}

package/dist/parsers/excel/model.d.ts

@@ -0,0 +1,80 @@
+export type ExcelCellType = 'number' | 'text' | 'boolean' | 'date' | 'error';
+/**
+ * Semantic (non-CSS) presentation attributes for the grid render mode (X3).
+ * Populated only when the parser reads styles; the data (AOA) mode ignores it.
+ * Colors are `#rrggbb`; borders are CSS shorthand strings (e.g. '1px solid #333').
+ */
+export interface CellStyle {
+    bold?: boolean;
+    italic?: boolean;
+    fontSizePx?: number;
+    color?: string;
+    background?: string;
+    align?: 'left' | 'center' | 'right' | 'justify';
+    valign?: 'top' | 'center' | 'bottom';
+    wrap?: boolean;
+    borders?: {
+        top?: string;
+        right?: string;
+        bottom?: string;
+        left?: string;
+    };
+}
+/** Inclusive 0-based cell range (used for merges and used ranges). */
+export interface CellRange {
+    r0: number;
+    c0: number;
+    r1: number;
+    c1: number;
+}
+export interface ExcelCell {
+    /** 0-based absolute row index (sheet origin). */
+    r: number;
+    /** 0-based absolute column index. */
+    c: number;
+    t: ExcelCellType;
+    /**
+     * Raw value. Dates are calendar-preserving ISO-8601 strings (see
+     * `dateToIso`); numbers are float64 (SheetJS reads workbook numbers as JS
+     * numbers, so values beyond 2^53 already lost precision upstream — X5);
+     * errors carry the error text (e.g. '#DIV/0!').
+     */
+    v: string | number | boolean | null;
+    /** Display text as formatted by the source file's number format (`w`). */
+    w: string;
+    /** Presentation attributes for grid mode (X3); absent when unstyled. */
+    style?: CellStyle;
+}
+export interface ExcelSheet {
+    name: string;
+    /** Inclusive 0-based bounds of the used range, or null when empty. */
+    usedRange: CellRange | null;
+    /** Sparse — only cells present in the file, row-major (r, then c). */
+    cells: ExcelCell[];
+    rowCount: number;
+    columnCount: number;
+    /** Merged cell ranges (grid mode, X3). */
+    merges?: CellRange[];
+    /** Absolute column index → width in px (grid mode, X3). */
+    columnWidthsPx?: Record<number, number>;
+    /** Absolute row index → height in px (grid mode, X3). */
+    rowHeightsPx?: Record<number, number>;
+}
+export interface ExcelWorkbook {
+    sheetNames: string[];
+    sheets: ExcelSheet[];
+    /** 1904 date system flag (affects how date serials map to calendar dates). */
+    date1904: boolean;
+}
+export interface SheetAoa {
+    headers: string[];
+    rows: string[][];
+}
+/**
+ * Derive a dense AOA (header row + data rows) of display strings from a sparse
+ * sheet. Missing cells become '' (X5). When `hasHeader`, the first used row is
+ * the header; otherwise headers are empty and every used row is a data row.
+ * Pure and deterministic — the core viewer/controller calls this; the parser
+ * does not, keeping the model grid-shaped.
+ */
+export declare function sheetToAoa(sheet: ExcelSheet, hasHeader?: boolean): SheetAoa;

package/dist/parsers/excel/model.js

@@ -0,0 +1,48 @@
+// Excel document model (docs/viewers/excel.md §2, X1). The parser preserves a
+// sparse, coordinate-bearing grid — cell address + type + raw value (`v`) +
+// the source file's formatted text (`w`). The AOA text table that the core
+// viewer renders is *derived* from this model (see `sheetToAoa`), so the model
+// stays the single source and web can keep its own grid renderer on top of it
+// (ADR 33). Cell styles / merges / column widths are optional follow-up fields
+// (X3) and are not populated in v1.
+/**
+ * Derive a dense AOA (header row + data rows) of display strings from a sparse
+ * sheet. Missing cells become '' (X5). When `hasHeader`, the first used row is
+ * the header; otherwise headers are empty and every used row is a data row.
+ * Pure and deterministic — the core viewer/controller calls this; the parser
+ * does not, keeping the model grid-shaped.
+ */
+export function sheetToAoa(sheet, hasHeader = true) {
+    if (!sheet.usedRange)
+        return { headers: [], rows: [] };
+    const { r0, c0, r1, c1 } = sheet.usedRange;
+    const width = c1 - c0 + 1;
+    // Bucket cell display text by row for O(cells) fill instead of O(rows*cols)
+    // address lookups.
+    const byRow = new Map();
+    for (const cell of sheet.cells) {
+        let row = byRow.get(cell.r);
+        if (!row) {
+            row = new Array(width).fill('');
+            byRow.set(cell.r, row);
+        }
+        const col = cell.c - c0;
+        if (col >= 0 && col < width)
+            row[col] = cell.w;
+    }
+    const rowAt = (r) => byRow.get(r) ?? new Array(width).fill('');
+    let headers;
+    let dataStart;
+    if (hasHeader) {
+        headers = rowAt(r0);
+        dataStart = r0 + 1;
+    }
+    else {
+        headers = new Array(width).fill('');
+        dataStart = r0;
+    }
+    const rows = [];
+    for (let r = dataStart; r <= r1; r++)
+        rows.push(rowAt(r));
+    return { headers, rows };
+}

package/dist/parsers/excel/serialize.d.ts

@@ -0,0 +1,3 @@
+import type * as XLSX from 'xlsx';
+import type { ExcelWorkbook } from './model.js';
+export declare function serializeWorkbook(workbook: ExcelWorkbook, xlsx: typeof XLSX): Uint8Array;

package/dist/parsers/excel/serialize.js

@@ -0,0 +1,78 @@
+// Type-preserving XLSX export (docs/viewers/excel.md §2, X7). Re-serializes the
+// original parsed model — using each cell's typed value (`v`/`t`), NOT the
+// display string (`w`) — so numbers stay numbers, booleans stay booleans, and
+// dates stay date-typed cells. Building a worksheet from `w` strings would make
+// everything a text cell (the bug this replaces).
+//
+// Dates: the model stores a calendar-preserving ISO string (model.ts). We
+// rebuild a Date from its numeric components — `Date.UTC(y, m, d, …)`, which is
+// well-defined (not the impl-defined string parse the parser avoided) — and let
+// SheetJS serialize it. SheetJS (>=0.20) maps Dates to serials from their UTC
+// parts, and its own Date→serial→date round-trip is exact, whereas
+// hand-computed serials pick up a sub-minute read-back rounding error.
+// `xlsx` is injected (base entries never import it — ADR 14).
+const ISO_RE = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?)?$/;
+export function serializeWorkbook(workbook, xlsx) {
+    const wb = xlsx.utils.book_new();
+    const sheets = workbook.sheets.length
+        ? workbook.sheets
+        : [{ name: 'Sheet1', usedRange: null, cells: [], rowCount: 0, columnCount: 0 }];
+    for (const sheet of sheets) {
+        const ws = {};
+        for (const cell of sheet.cells) {
+            const address = xlsx.utils.encode_cell({ r: cell.r, c: cell.c });
+            ws[address] = toCellObject(cell);
+        }
+        ws['!ref'] = sheet.usedRange
+            ? xlsx.utils.encode_range({
+                s: { r: sheet.usedRange.r0, c: sheet.usedRange.c0 },
+                e: { r: sheet.usedRange.r1, c: sheet.usedRange.c1 }
+            })
+            : 'A1';
+        // book_append_sheet enforces the 31-char / uniqueness rules SheetJS
+        // expects; it also wires SheetNames + Sheets.
+        xlsx.utils.book_append_sheet(wb, ws, sheet.name);
+    }
+    if (workbook.date1904) {
+        wb.Workbook = { ...(wb.Workbook ?? {}), WBProps: { ...(wb.Workbook?.WBProps ?? {}), date1904: true } };
+    }
+    return new Uint8Array(xlsx.write(wb, { type: 'array', bookType: 'xlsx' }));
+}
+function toCellObject(cell) {
+    switch (cell.t) {
+        case 'number':
+            return { t: 'n', v: typeof cell.v === 'number' ? cell.v : Number(cell.v) };
+        case 'boolean':
+            return { t: 'b', v: Boolean(cell.v) };
+        case 'date': {
+            const date = typeof cell.v === 'string' ? isoToDate(cell.v) : null;
+            if (!date) {
+                // Non-ISO date value — keep the visible text rather than guess.
+                return { t: 's', v: cell.w || String(cell.v ?? '') };
+            }
+            // A date-typed cell + date number format makes SheetJS emit a serial
+            // and read it back as a date on the next parse (type preserved).
+            return { t: 'd', v: date, z: 'yyyy-mm-dd' };
+        }
+        case 'error':
+            return { t: 's', v: cell.w };
+        default:
+            return { t: 's', v: cell.v == null ? '' : String(cell.v) };
+    }
+}
+/** Rebuild a Date from ISO components via `Date.UTC` — mirrors the parser's
+ *  UTC-getter formatting (SheetJS >=0.20 serializes date cells from UTC
+ *  parts) so the calendar date round-trips. */
+function isoToDate(iso) {
+    const m = ISO_RE.exec(iso);
+    if (!m)
+        return null;
+    const year = Number(m[1]);
+    const month = Number(m[2]);
+    const day = Number(m[3]);
+    const hour = m[4] !== undefined ? Number(m[4]) : 0;
+    const minute = m[5] !== undefined ? Number(m[5]) : 0;
+    const second = m[6] !== undefined ? Number(m[6]) : 0;
+    const millis = m[7] !== undefined ? Number(m[7].padEnd(3, '0')) : 0;
+    return new Date(Date.UTC(year, month - 1, day, hour, minute, second, millis));
+}