@rowsncolumns/toolkit 24.4.1

package/dist/esm/exporter/xlsx/xlsx-export.js

@@ -0,0 +1,4062 @@
+import { cellRangeToAddress, cellToAddress, escapeCharacters, getCellEffectiveFormat, getCellEffectiveValue, getCellFormattedValue, getCellUserEnteredFormat, getCellUserEnteredValue, getExtendedValueBool, getExtendedValueError, getExtendedValueFormula, getExtendedValueNumber, getExtendedValueString, isNil, sortSheetsByIndex, } from "@rowsncolumns/utils";
+import { zipSync } from "fflate";
+import { omitInvalidDataValidationError } from "../invalid-data-validation";
+import { buildAutoFilterConditionXml } from "../../autofilter-condition";
+import { applyPowerQueryParts } from "./power-query-builder";
+import { qualifyFutureFunctions } from "./future-functions";
+import { PERSON_CONTENT_TYPE, PERSON_REL_TYPE, PersonRegistry, THREADED_COMMENT_REL_TYPE, THREADED_COMMENTS_CONTENT_TYPE, ThreadedCommentsCollector, } from "./threaded-comments-builder";
+import { CFBEncryptor } from "../../excel-parser/cfb-encryptor";
+import { columnPixelToChars, imageUrlToBase64 } from "../../helpers";
+import { generateThemeXml } from "../../helpers/theme-xml-generator";
+import theme1Xml from "../../theme1";
+import { tokenize as defaultTokenizer } from "@rowsncolumns/calculator";
+import { CellXfsRegistry, deriveEffectiveNumberFormatFromFormula, } from "@rowsncolumns/spreadsheet-state";
+import { buildChartXml } from "./chart-builder";
+import { buildPivotCacheDefinitionXml, buildPivotTableRelsXml, buildPivotTableXml, } from "./pivot-builder";
+import { buildSlicerCacheXml, buildSlicerXml } from "./slicer-builder";
+import { buildSparklineGroupsXml } from "./sparkline-builder";
+import { StyleBuilder } from "./style-builder";
+const BLANK_LABEL = "(Blanks)";
+const isStyleReference = (value) => !!value && typeof value === "object" && "sid" in value;
+const DEFAULT_COLUMN_WIDTH_PX = 100;
+const DEFAULT_ROW_HEIGHT_PX = 21;
+const pixelToPoints = (px) => Math.max(1, Number(((px * 72) / 96).toFixed(2)));
+export const createExcelFile = async ({ conditionalFormats: _conditionalFormats, dataValidations: _dataValidations, sheets, sheetData, sharedStrings: sourceSharedStrings, tables: _tables = [], cellXfs, theme, defaultFont, embeds = [], charts = [], slicers = [], pivotTables = [], externalLinks = [], namedRanges = [], namedCellStyles, customTableStyles, iterativeCalculationOptions, ignoreFormulaPatterns, citations, comments, password, locale, use1904 = false, properties, powerQuery, }) => {
+    const sortedSheets = sortSheetsByIndex(sheets, true);
+    const sharedStrings = new SharedStrings();
+    // Workbook-scoped author registry shared across every sheet's threaded
+    // comments, so an author maps to a single `person` entry / personId.
+    const personRegistry = new PersonRegistry();
+    const styleBuilder = new StyleBuilder();
+    if (defaultFont) {
+        styleBuilder.setDefaultFont(defaultFont);
+    }
+    if (namedCellStyles && namedCellStyles.length > 0) {
+        styleBuilder.setNamedCellStyles(namedCellStyles);
+    }
+    if (customTableStyles && customTableStyles.length > 0) {
+        styleBuilder.setCustomTableStyles(customTableStyles);
+    }
+    // Drop tables with invalid coords or overlapping ranges — Excel rejects them
+    // and would trigger a recovery prompt. Filter once so the id remap and the
+    // prepared output stay in lockstep.
+    const exportableTables = filterExportableTables(_tables ?? []);
+    // Create table ID mapping before prepareTables changes them
+    const tableIdMap = new Map();
+    exportableTables.forEach((table, index) => {
+        tableIdMap.set(table.id, index + 1);
+        tableIdMap.set(String(table.id), index + 1);
+    });
+    const preparedTables = prepareTables(exportableTables);
+    const embedsBySheet = groupEmbedsBySheet(embeds ?? []);
+    const textBoxesBySheet = groupTextBoxesBySheet(embeds ?? []);
+    const shapesBySheet = groupShapesBySheet(embeds ?? []);
+    const chartsBySheet = groupChartsBySheet(charts ?? []);
+    // Remap slicer tableIds to match prepared table IDs
+    const remappedSlicers = slicers.map((slicer) => {
+        if (slicer.spec.type !== "table")
+            return slicer;
+        const remappedTableIds = slicer.spec.tableIds
+            .map((tid) => tableIdMap.get(tid))
+            .filter((id) => id !== undefined)
+            .map(String); // Keep as strings for consistency
+        return {
+            ...slicer,
+            spec: {
+                ...slicer.spec,
+                tableIds: remappedTableIds,
+            },
+        };
+    });
+    const slicersBySheet = groupSlicersBySheet(remappedSlicers ?? []);
+    const workbookSheetNames = buildWorkbookSheetNames(sortedSheets);
+    const sheetNameById = new Map();
+    sortedSheets.forEach((sheet, index) => {
+        sheetNameById.set(sheet.sheetId ?? index + 1, workbookSheetNames[index]);
+    });
+    const dataValidationsById = _dataValidations?.reduce((acc, rule) => {
+        acc[rule.id] = rule;
+        return acc;
+    }, {}) ?? undefined;
+    // Initialize slicer tracking variables
+    let globalSlicerIndex = 1;
+    const slicerCacheEntries = [];
+    const slicerEntries = [];
+    // Phase D2 — pivot table tracking. PivotCacheDefinition lives
+    // workbook-wide (referenced from workbook.xml's <pivotCaches>);
+    // pivotTable lives per-sheet, attached to the target sheet's
+    // relationships. We track:
+    //   - cache entries: pivotCacheDefinition<N>.xml + its .rels
+    //   - table entries: pivotTable<N>.xml + its .rels (links to cache)
+    //   - per-cache rId on the workbook (for <pivotCaches>)
+    let globalPivotIndex = 1;
+    const pivotCacheEntries = [];
+    const pivotCacheRelsEntries = [];
+    const pivotTableEntries = [];
+    const pivotTableRelsEntries = [];
+    // Group pivots by the sheet they render on (targetPosition.sheetId).
+    const pivotsByTargetSheet = new Map();
+    for (const p of pivotTables) {
+        const sid = p.targetPosition?.sheetId;
+        if (sid == null)
+            continue;
+        const list = pivotsByTargetSheet.get(sid);
+        if (list)
+            list.push(p);
+        else
+            pivotsByTargetSheet.set(sid, [p]);
+    }
+    // Records pivot caches that need a workbook-level entry (added
+    // after the sheet loop closes). Each entry: { cacheIndex, rIdOnWorkbook }
+    const workbookPivotCacheRefs = [];
+    const worksheetEntries = sortedSheets.map((sheet, index) => {
+        const rows = getRowsForSheet(sheetData, sheet.sheetId);
+        const sheetRelationships = new RelationshipsBuilder();
+        const sheetTables = preparedTables.filter((table) => table.sheetId === sheet.sheetId);
+        const embedImages = embedsBySheet.get(sheet.sheetId) ?? [];
+        const textBoxes = textBoxesBySheet.get(sheet.sheetId) ?? [];
+        const sheetShapes = shapesBySheet.get(sheet.sheetId) ?? [];
+        const sheetCharts = chartsBySheet.get(sheet.sheetId) ?? [];
+        const sheetSlicers = slicersBySheet.get(sheet.sheetId) ?? [];
+        const worksheetSlicerRelIds = [];
+        const drawingSlicers = [];
+        const sheetConditionalFormats = (_conditionalFormats ?? []).filter((rule) => rule.ranges?.some((range) => range.sheetId === sheet.sheetId));
+        const drawingContext = new DrawingContext(sheetRelationships, `../drawings/drawing${index + 1}.xml`, embedImages.length > 0 ||
+            textBoxes.length > 0 ||
+            sheetShapes.length > 0 ||
+            sheetCharts.length > 0 ||
+            sheetSlicers.length > 0);
+        const sheetCitations = citations?.filter((citation) => citation.range.sheetId === sheet.sheetId);
+        // Generate slicer XML for this sheet
+        for (const placement of sheetSlicers) {
+            const { slicer } = placement;
+            const cacheIndex = globalSlicerIndex;
+            const slicerIndex = globalSlicerIndex;
+            const cacheName = buildSlicerCacheName(slicer.spec.title || `Slicer${slicerIndex}`);
+            // Create slicer cache XML
+            const slicerCacheXml = buildSlicerCacheXml(slicer, sheetTables, cacheName);
+            if (slicerCacheXml) {
+                slicerCacheEntries.push({
+                    path: `xl/slicerCaches/slicerCache${cacheIndex}.xml`,
+                    xml: slicerCacheXml,
+                });
+                // Create slicer XML
+                const slicerXml = buildSlicerXml(slicer, cacheName);
+                slicerEntries.push({
+                    path: `xl/slicers/slicer${slicerIndex}.xml`,
+                    xml: slicerXml,
+                });
+                // Add relationship from worksheet to slicer
+                const worksheetSlicerRelId = sheetRelationships.add(SLICER_REL_TYPE, `../slicers/slicer${slicerIndex}.xml`);
+                worksheetSlicerRelIds.push(worksheetSlicerRelId);
+                drawingSlicers.push({
+                    slicerIndex,
+                    title: slicer.spec.title || `Slicer ${slicerIndex}`,
+                    rowIndex: placement.rowIndex,
+                    columnIndex: placement.columnIndex,
+                    offsetX: placement.offsetX,
+                    offsetY: placement.offsetY,
+                    width: placement.width,
+                    height: placement.height,
+                });
+                globalSlicerIndex += 1;
+            }
+        }
+        // Phase D2 — emit pivot table XMLs + relationships for this
+        // sheet. PivotTable lives on the rendering sheet; its cache
+        // definition is workbook-scoped (added to <pivotCaches> after
+        // this loop).
+        const sheetPivots = pivotsByTargetSheet.get(sheet.sheetId) ?? [];
+        for (const pivot of sheetPivots) {
+            const cacheIndex = globalPivotIndex;
+            const tableIndex = globalPivotIndex;
+            const sourceSheet = sortedSheets.find((s) => s.sheetId === pivot.source?.sheetId);
+            const sourceSheetName = sourceSheet?.title ?? sheet.title ?? `Sheet${sheet.sheetId}`;
+            // Field universe: union of every field referenced by the
+            // pivot. PivotCacheDefinition requires one <cacheField>
+            // entry per field, and pivotTable.fld indices reference them.
+            const fieldNameList = [];
+            const fieldIndex = new Map();
+            const registerField = (name) => {
+                if (!name || fieldIndex.has(name))
+                    return;
+                fieldIndex.set(name, fieldNameList.length);
+                fieldNameList.push(name);
+            };
+            for (const r of pivot.rows ?? [])
+                registerField(r.field);
+            for (const c of pivot.columns ?? [])
+                registerField(c.field);
+            for (const v of pivot.values ?? [])
+                registerField(v.field);
+            const cacheXml = buildPivotCacheDefinitionXml(pivot, sourceSheetName, fieldNameList);
+            const tableXml = buildPivotTableXml(pivot, cacheIndex, fieldIndex);
+            if (!cacheXml || !tableXml)
+                continue;
+            pivotCacheEntries.push({
+                path: `xl/pivotCache/pivotCacheDefinition${cacheIndex}.xml`,
+                xml: cacheXml,
+            });
+            pivotTableEntries.push({
+                path: `xl/pivotTables/pivotTable${tableIndex}.xml`,
+                xml: tableXml,
+            });
+            // pivotTable<N>.xml.rels → links to its cache definition.
+            pivotTableRelsEntries.push({
+                path: `xl/pivotTables/_rels/pivotTable${tableIndex}.xml.rels`,
+                xml: buildPivotTableRelsXml("rId1", `../pivotCache/pivotCacheDefinition${cacheIndex}.xml`),
+            });
+            // sheet → pivotTable relationship.
+            sheetRelationships.add(PIVOT_TABLE_REL_TYPE, `../pivotTables/pivotTable${tableIndex}.xml`);
+            // Record the cache for the workbook-level <pivotCaches> list.
+            workbookPivotCacheRefs.push({ cacheIndex });
+            globalPivotIndex += 1;
+        }
+        const result = buildWorksheetXml({
+            sheet,
+            rows,
+            sharedStrings,
+            sourceSharedStrings,
+            cellXfs,
+            styleBuilder,
+            tables: sheetTables,
+            relationships: sheetRelationships,
+            drawingContext,
+            conditionalFormats: sheetConditionalFormats,
+            dataValidationsById,
+            dataValidations: _dataValidations,
+            ignoreFormulaPatterns,
+            citations: sheetCitations,
+            comments,
+            personRegistry,
+            slicerRelIds: worksheetSlicerRelIds,
+            sheetData,
+            sheets: sortedSheets,
+            locale,
+        });
+        return {
+            index,
+            path: `xl/worksheets/sheet${index + 1}.xml`,
+            relationshipsPath: `xl/worksheets/_rels/sheet${index + 1}.xml.rels`,
+            content: result.xml,
+            relationshipsXml: result.relationshipsXml,
+            drawingPath: `xl/drawings/drawing${index + 1}.xml`,
+            drawingRelsPath: `xl/drawings/_rels/drawing${index + 1}.xml.rels`,
+            cellImages: result.images,
+            embedImages,
+            textBoxes,
+            shapes: sheetShapes,
+            charts: sheetCharts,
+            slicers: drawingSlicers,
+            sheet,
+            commentsXml: result.commentsXml,
+            vmlDrawingXml: result.vmlDrawingXml,
+            threadedCommentsXml: result.threadedCommentsXml,
+        };
+    });
+    const { xml: workbookRelationshipsXml, sheetRelationshipIds, slicerCacheRelationshipIds, pivotCacheRelationshipIds, externalLinkRelationshipIds, } = buildWorkbookRelationships(worksheetEntries.length, slicerCacheEntries.length, externalLinks.length, pivotCacheEntries.length, !personRegistry.isEmpty());
+    const workbookXml = buildWorkbookXml(sortedSheets, sheetRelationshipIds, workbookSheetNames, namedRanges, iterativeCalculationOptions, slicerCacheRelationshipIds, use1904, externalLinkRelationshipIds, pivotCacheRelationshipIds);
+    const sharedStringsXml = buildSharedStringsXml(sharedStrings);
+    const rootRelationshipsXml = buildRootRelationshipsXml();
+    const appXml = buildAppXml(workbookSheetNames, properties);
+    const coreXml = buildCoreXml(properties);
+    const stylesXml = styleBuilder.toXml();
+    const themeXml = theme ? generateThemeXml(theme) : theme1Xml;
+    const files = {
+        "_rels/.rels": encodeXml(rootRelationshipsXml),
+        "docProps/app.xml": encodeXml(appXml),
+        "docProps/core.xml": encodeXml(coreXml),
+        "xl/workbook.xml": encodeXml(workbookXml),
+        "xl/_rels/workbook.xml.rels": encodeXml(workbookRelationshipsXml),
+        "xl/sharedStrings.xml": encodeXml(sharedStringsXml),
+        "xl/styles.xml": encodeXml(stylesXml),
+        "xl/theme/theme1.xml": encodeXml(themeXml),
+    };
+    for (const entry of worksheetEntries) {
+        files[entry.path] = encodeXml(entry.content);
+        if (entry.relationshipsXml) {
+            files[entry.relationshipsPath] = encodeXml(entry.relationshipsXml);
+        }
+        if (entry.commentsXml) {
+            files[`xl/comments${entry.sheet.sheetId}.xml`] = encodeXml(entry.commentsXml);
+        }
+        if (entry.vmlDrawingXml) {
+            files[`xl/drawings/vmlDrawing${entry.sheet.sheetId}.vml`] = encodeXml(entry.vmlDrawingXml);
+        }
+        if (entry.threadedCommentsXml) {
+            files[`xl/threadedComments/threadedComment${entry.sheet.sheetId}.xml`] =
+                encodeXml(entry.threadedCommentsXml);
+        }
+    }
+    // Workbook-level author list shared by every sheet's threaded comments.
+    const personsXml = personRegistry.toXml();
+    if (personsXml) {
+        files["xl/persons/person.xml"] = encodeXml(personsXml);
+    }
+    for (const table of preparedTables) {
+        const rows = getRowsForSheet(sheetData, table.sheetId);
+        const tableXml = buildTableXml(table, rows, sourceSharedStrings, styleBuilder);
+        if (tableXml) {
+            files[table.path] = encodeXml(tableXml);
+        }
+    }
+    let globalImageIndex = 1;
+    let globalChartIndex = 1;
+    const drawingSheets = [];
+    const imageExtensions = new Set();
+    const chartEntries = [];
+    for (const entry of worksheetEntries) {
+        const placements = [...entry.cellImages, ...entry.embedImages];
+        const textBoxesForSheet = entry.textBoxes ?? [];
+        const shapesForSheet = entry.shapes ?? [];
+        const chartsForSheet = entry.charts ?? [];
+        const slicersForSheet = entry.slicers ?? [];
+        if (!placements.length &&
+            !textBoxesForSheet.length &&
+            !shapesForSheet.length &&
+            !chartsForSheet.length &&
+            !slicersForSheet.length)
+            continue;
+        const drawingParts = await buildDrawingParts({
+            sheet: entry.sheet,
+            placements,
+            textBoxes: textBoxesForSheet,
+            shapes: shapesForSheet,
+            startImageIndex: globalImageIndex,
+            startChartIndex: globalChartIndex,
+            charts: chartsForSheet,
+            slicers: slicersForSheet,
+            sheetNameById,
+        });
+        if (!drawingParts)
+            continue;
+        files[entry.drawingPath] = encodeXml(drawingParts.xml);
+        if (drawingParts.relsXml) {
+            files[entry.drawingRelsPath] = encodeXml(drawingParts.relsXml);
+        }
+        for (const media of drawingParts.media) {
+            files[media.path] = media.data;
+            imageExtensions.add(media.extension);
+        }
+        for (const chartEntry of drawingParts.charts) {
+            chartEntries.push(chartEntry);
+        }
+        globalImageIndex = drawingParts.nextImageIndex;
+        globalChartIndex = drawingParts.nextChartIndex;
+        drawingSheets.push(entry.index + 1);
+    }
+    for (const chartEntry of chartEntries) {
+        files[chartEntry.path] = encodeXml(chartEntry.xml);
+    }
+    for (const slicerCacheEntry of slicerCacheEntries) {
+        files[slicerCacheEntry.path] = encodeXml(slicerCacheEntry.xml);
+    }
+    for (const slicerEntry of slicerEntries) {
+        files[slicerEntry.path] = encodeXml(slicerEntry.xml);
+    }
+    // Phase D2 — emit pivot files.
+    for (const cacheEntry of pivotCacheEntries) {
+        files[cacheEntry.path] = encodeXml(cacheEntry.xml);
+    }
+    for (const cacheRels of pivotCacheRelsEntries) {
+        files[cacheRels.path] = encodeXml(cacheRels.xml);
+    }
+    for (const tableEntry of pivotTableEntries) {
+        files[tableEntry.path] = encodeXml(tableEntry.xml);
+    }
+    for (const tableRels of pivotTableRelsEntries) {
+        files[tableRels.path] = encodeXml(tableRels.xml);
+    }
+    // Add external link files (for formulas referencing other workbooks)
+    for (let i = 0; i < externalLinks.length; i++) {
+        const link = externalLinks[i];
+        const linkPath = `xl/externalLinks/externalLink${i + 1}.xml`;
+        files[linkPath] = encodeXml(link.xmlContent);
+        // Add the relationship file if present
+        if (link.relsContent) {
+            const relsPath = `xl/externalLinks/_rels/externalLink${i + 1}.xml.rels`;
+            files[relsPath] = encodeXml(link.relsContent);
+        }
+    }
+    const commentsSheets = worksheetEntries
+        .filter((entry) => entry.commentsXml)
+        .map((entry) => entry.sheet.sheetId ?? entry.index + 1);
+    const threadedCommentsSheets = worksheetEntries
+        .filter((entry) => entry.threadedCommentsXml)
+        .map((entry) => entry.sheet.sheetId ?? entry.index + 1);
+    const contentTypesXml = buildContentTypesXml({
+        sheetCount: worksheetEntries.length,
+        tableCount: preparedTables.length,
+        drawingSheets,
+        mediaExtensions: Array.from(imageExtensions),
+        chartCount: chartEntries.length,
+        slicerCount: slicerEntries.length,
+        slicerCacheCount: slicerCacheEntries.length,
+        pivotTableCount: pivotTableEntries.length,
+        pivotCacheCount: pivotCacheEntries.length,
+        commentsSheets,
+        threadedCommentsSheets,
+        hasPersons: !personRegistry.isEmpty(),
+        externalLinkCount: externalLinks.length,
+    });
+    files["[Content_Types].xml"] = encodeXml(contentTypesXml);
+    // Preserved Power Query machinery (DataMashup customXml, connections.xml, queryTable parts) is
+    // re-emitted verbatim as a post-pass over the assembled files, re-attaching each queryTable to
+    // its regenerated table part when the table still matches. No-op without an envelope.
+    applyPowerQueryParts(files, powerQuery);
+    const zipBytes = zipSync(files);
+    if (password?.trim()) {
+        return CFBEncryptor.encrypt(zipBytes, password.trim());
+    }
+    return zipBytes;
+};
+const XML_DECLARATION = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`;
+const WORKSHEET_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+const REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+const PACKAGE_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+const DEFAULT_PAGE_MARGINS = '<pageMargins left="0.7" right="0.7" top="0.75" bottom="0.75" header="0.3" footer="0.3"/>';
+const TABLE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/table";
+const DRAWING_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing";
+const IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+const CHART_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+const SLICER_REL_TYPE = "http://schemas.microsoft.com/office/2007/relationships/slicer";
+const SLICER_CACHE_REL_TYPE = "http://schemas.microsoft.com/office/2007/relationships/slicerCache";
+// Phase D2 — XLSX pivot relationship types (ECMA-376).
+const PIVOT_TABLE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable";
+const PIVOT_CACHE_DEFINITION_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition";
+const HYPERLINK_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+const COMMENTS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
+const EMUS_PER_PIXEL = 9525;
+const CREATOR = "Rows n Columns";
+const textEncoder = new TextEncoder();
+class RelationshipsBuilder {
+    nextId = 1;
+    entries = [];
+    add(type, target, mode) {
+        const id = `rId${this.nextId++}`;
+        this.entries.push({ id, type, target, mode });
+        return id;
+    }
+    isEmpty() {
+        return this.entries.length === 0;
+    }
+    toXml() {
+        if (!this.entries.length) {
+            return undefined;
+        }
+        const relationships = this.entries
+            .map((entry) => `<Relationship Id="${entry.id}" Type="${entry.type}" Target="${escapeXmlAttr(entry.target)}"${entry.mode ? ` TargetMode="${entry.mode}"` : ""}/>`)
+            .join("");
+        return `${XML_DECLARATION}<Relationships xmlns="${PACKAGE_REL_NS}">${relationships}</Relationships>`;
+    }
+}
+class DrawingContext {
+    relationships;
+    target;
+    constructor(relationships, target, hasExisting) {
+        this.relationships = relationships;
+        this.target = target;
+        if (hasExisting) {
+            this.relId = this.relationships.add(DRAWING_REL_TYPE, this.target);
+        }
+    }
+    relId;
+    ensureRel() {
+        if (!this.relId) {
+            this.relId = this.relationships.add(DRAWING_REL_TYPE, this.target);
+        }
+        return this.relId;
+    }
+    hasDrawing() {
+        return !!this.relId;
+    }
+}
+const SQREF_A1_RANGE = /^\$?([A-Z]+)\$?(\d+)(?::\$?([A-Z]+)\$?(\d+))?$/;
+const sqrefColNumber = (letters) => letters.split("").reduce((acc, ch) => acc * 26 + (ch.charCodeAt(0) - 64), 0);
+/**
+ * Normalize a dataValidation sqref list: collapse degenerate ranges
+ * (`C7:C7` → `C7`), drop exact duplicates, and drop members fully contained
+ * in another member. The collector receives both range-form refs and
+ * per-cell addresses for the same rule, which otherwise emits noisy
+ * `sqref="C7:C7 C8:C8 C7 C8"` lists.
+ */
+export const normalizeSqrefMembers = (refs) => {
+    const parsed = refs.map((raw) => {
+        const m = SQREF_A1_RANGE.exec(raw);
+        if (!m)
+            return { ref: raw };
+        const c1 = sqrefColNumber(m[1]);
+        const r1 = Number(m[2]);
+        const c2 = m[3] ? sqrefColNumber(m[3]) : c1;
+        const r2 = m[4] ? Number(m[4]) : r1;
+        const rect = {
+            c1: Math.min(c1, c2),
+            r1: Math.min(r1, r2),
+            c2: Math.max(c1, c2),
+            r2: Math.max(r1, r2),
+        };
+        const ref = rect.c1 === rect.c2 && rect.r1 === rect.r2
+            ? `${m[1]}${m[2]}`
+            : raw;
+        return { ref, rect };
+    });
+    const contains = (a, b) => a.c1 <= b.c1 && a.r1 <= b.r1 && a.c2 >= b.c2 && a.r2 >= b.r2;
+    const out = [];
+    const seen = new Set();
+    for (let i = 0; i < parsed.length; i++) {
+        const { ref, rect } = parsed[i];
+        if (seen.has(ref))
+            continue;
+        if (rect) {
+            const covered = parsed.some((other, j) => j !== i &&
+                other.rect &&
+                contains(other.rect, rect) &&
+                // ties (identical rects) keep the earliest occurrence only
+                !(contains(rect, other.rect) && j > i));
+            if (covered)
+                continue;
+        }
+        seen.add(ref);
+        out.push(ref);
+    }
+    return out;
+};
+class DataValidationCollector {
+    entries = new Map();
+    add(address, rule) {
+        const config = convertDataValidationRule(rule);
+        if (!config)
+            return;
+        const key = getDataValidationKey(config);
+        const existing = this.entries.get(key);
+        if (existing) {
+            existing.refs.push(address);
+            return;
+        }
+        this.entries.set(key, {
+            config,
+            refs: [address],
+        });
+    }
+    toXml() {
+        if (!this.entries.size) {
+            return "";
+        }
+        const items = Array.from(this.entries.values()).map((entry) => buildDataValidationXml(entry.config, entry.refs));
+        return `<dataValidations count="${this.entries.size}">${items.join("")}</dataValidations>`;
+    }
+}
+class CommentsCollector {
+    entries = [];
+    add(address, text, author = "System") {
+        this.entries.push({ address, text, author });
+    }
+    isEmpty() {
+        return this.entries.length === 0;
+    }
+    toXml() {
+        if (!this.entries.length) {
+            return undefined;
+        }
+        const authors = Array.from(new Set(this.entries.map((e) => e.author)));
+        const authorsXml = authors
+            .map((a) => `<author>${escapeXmlText(a)}</author>`)
+            .join("");
+        const commentsXml = this.entries
+            .map((entry) => {
+            const authorId = authors.indexOf(entry.author);
+            return `<comment ref="${entry.address}" authorId="${authorId}"><text><r><rPr><b/><sz val="9"/><color indexed="81"/><rFont val="Tahoma"/><charset val="1"/></rPr><t>${escapeXmlText(entry.text)}</t></r></text></comment>`;
+        })
+            .join("");
+        return `${XML_DECLARATION}<comments xmlns="${WORKSHEET_NS}"><authors>${authorsXml}</authors><commentList>${commentsXml}</commentList></comments>`;
+    }
+    toVmlXml() {
+        if (!this.entries.length) {
+            return undefined;
+        }
+        const shapes = this.entries
+            .map((entry, index) => {
+            const shapeId = `_x0000_s${1026 + index}`;
+            // Parse cell address to get row and column
+            const match = entry.address.match(/^([A-Z]+)(\d+)$/);
+            if (!match)
+                return "";
+            const col = match[1];
+            const row = parseInt(match[2]);
+            const colIndex = col
+                .split("")
+                .reduce((acc, char) => acc * 26 + (char.charCodeAt(0) - 64), 0) - 1;
+            return `<v:shape id="${shapeId}" type="#_x0000_t202" style='position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;z-index:${index + 1};visibility:hidden' fillcolor="#ffffe1" o:insetmode="auto"><v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/><v:path o:connecttype="none"/><v:textbox style='mso-direction-alt:auto'><div style='text-align:left'></div></v:textbox><x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>1, 15, 0, 2, 3, 15, 3, 16</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>${row - 1}</x:Row><x:Column>${colIndex}</x:Column></x:ClientData></v:shape>`;
+        })
+            .join("");
+        return `<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel"><o:shapelayout v:ext="edit"><o:idmap v:ext="edit" data="1"/></o:shapelayout><v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe"><v:stroke joinstyle="miter"/><v:path gradientshapeok="t" o:connecttype="rect"/></v:shapetype>${shapes}</xml>`;
+    }
+}
+const INVALID_XML_CHAR_REGEX = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g;
+const sanitizeXmlText = (value) => {
+    if (!value)
+        return value;
+    return value.replace(INVALID_XML_CHAR_REGEX, "");
+};
+class SharedStrings {
+    plainIndex = new Map();
+    entries = [];
+    totalCount = 0;
+    /**
+     * Compatibility shim: existing callers iterate `sharedStrings.values`
+     * (a `string[]`). Plain entries surface their text; rich entries
+     * surface the concatenated text so existing consumers still see a
+     * sensible plain string.
+     */
+    get values() {
+        return this.entries.map((e) => e.text);
+    }
+    add(value) {
+        const normalized = sanitizeXmlText(value ?? "");
+        const existing = this.plainIndex.get(normalized);
+        this.totalCount += 1;
+        if (typeof existing === "number") {
+            return existing;
+        }
+        const nextIndex = this.entries.length;
+        this.plainIndex.set(normalized, nextIndex);
+        this.entries.push({ kind: "plain", text: normalized });
+        return nextIndex;
+    }
+    /**
+     * Reserve a fresh sharedStrings slot carrying per-segment runs. Skips
+     * dedup so two cells with the same plain text but different runs get
+     * separate slots.
+     */
+    addRich(value, runs) {
+        const normalized = sanitizeXmlText(value ?? "");
+        this.totalCount += 1;
+        const nextIndex = this.entries.length;
+        this.entries.push({ kind: "rich", text: normalized, runs });
+        return nextIndex;
+    }
+}
+const encodeXml = (content) => textEncoder.encode(content);
+const getRowsForSheet = (sheetData, sheetId) => {
+    return (sheetData[sheetId] ??
+        sheetData[String(sheetId)] ??
+        sheetData[Number(sheetId)] ??
+        []);
+};
+const buildWorksheetXml = ({ sheet, rows, sharedStrings, sourceSharedStrings, cellXfs, styleBuilder, tables, relationships, drawingContext, conditionalFormats, dataValidationsById, dataValidations, ignoreFormulaPatterns, citations, comments, personRegistry, slicerRelIds, sheetData, sheets, locale, }) => {
+    const tableNameMap = buildTableNameMap(tables);
+    const bounds = {
+        minRow: Number.POSITIVE_INFINITY,
+        maxRow: 0,
+        minColumn: Number.POSITIVE_INFINITY,
+        maxColumn: 0,
+    };
+    const rowMetadata = sheet.rowMetadata ?? [];
+    const maxRows = Math.max(rows.length, rowMetadata.length);
+    const defaultRowHeightPx = getDefaultRowHeightPx(sheet);
+    const rowXmlChunks = [];
+    const collectedImages = [];
+    const dataValidationCollector = new DataValidationCollector();
+    const hyperlinkEntries = [];
+    const commentsCollector = new CommentsCollector();
+    const threadedCommentsCollector = new ThreadedCommentsCollector(comments, personRegistry ?? new PersonRegistry());
+    // Process citations for this sheet
+    if (citations) {
+        for (const citation of citations) {
+            if (citation.range.sheetId !== sheet.sheetId)
+                continue;
+            // Citation ranges are worksheet-based (1-based).
+            for (let rowIndex = citation.range.startRowIndex; rowIndex <= citation.range.endRowIndex; rowIndex++) {
+                for (let colIndex = citation.range.startColumnIndex; colIndex <= citation.range.endColumnIndex; colIndex++) {
+                    const address = cellToAddress({ rowIndex, columnIndex: colIndex });
+                    if (address) {
+                        commentsCollector.add(address, `${citation.citation_string}`, citation.created_by || "System");
+                    }
+                }
+            }
+        }
+    }
+    if (dataValidations) {
+        for (const rule of dataValidations) {
+            if (!rule.ranges)
+                continue;
+            for (const range of rule.ranges) {
+                if (range.sheetId !== sheet.sheetId)
+                    continue;
+                // Ranges from the DV import are already 1-indexed (addressToSelection
+                // produces 1-indexed coords). cellRangeToAddress also expects
+                // 1-indexed input, so pass through verbatim. The previous `+1` on
+                // every coordinate produced sqrefs shifted by one row + one column.
+                const address = cellRangeToAddress(undefined, range);
+                if (address) {
+                    dataValidationCollector.add(address, rule);
+                }
+            }
+        }
+    }
+    // Pre-scan for valid shared-formula leaders in this sheet. The cell-emit
+    // path uses this set to decide whether a follower (`sf.si` without `ref`)
+    // can safely emit as `<f t="shared" si="N"/>` or must fall back to its
+    // expanded standalone formula. A follower's leader can be missing if:
+    //  (a) the user edited the leader (its `sf` was dropped by
+    //      `setFormulaValue`'s invalidation), or
+    //  (b) the source had a malformed reference and the leader never imported.
+    // Emitting an orphaned follower would produce a broken xlsx — Excel would
+    // see `<f t="shared" si="N"/>` with no corresponding leader and read the
+    // cell as having no formula at all.
+    const validSharedFormulaLeaders = new Set();
+    for (let rowIndex = 1; rowIndex < maxRows; rowIndex++) {
+        const row = rows[rowIndex];
+        const rowValues = row?.values;
+        if (!Array.isArray(rowValues))
+            continue;
+        for (const cell of rowValues) {
+            const sf = cell?.sf;
+            if (sf && sf.ref && Number.isFinite(sf.si)) {
+                validSharedFormulaLeaders.add(sf.si);
+            }
+        }
+    }
+    for (let rowIndex = 1; rowIndex < maxRows; rowIndex++) {
+        const row = rows[rowIndex];
+        const metadata = rowMetadata[rowIndex];
+        const result = buildWorksheetRow({
+            rowNumber: rowIndex,
+            row,
+            rowMetadata: metadata,
+            defaultRowHeightPx,
+            sharedStrings,
+            sourceSharedStrings,
+            cellXfs,
+            styleBuilder,
+            dataValidationsById,
+            tableNameMap,
+            tables,
+            ignoreFormulaPatterns,
+            commentsCollector,
+            sheetId: sheet.sheetId,
+            sheetData,
+            sheets,
+            locale,
+            validSharedFormulaLeaders,
+            onImage: (image) => {
+                collectedImages.push(image);
+                drawingContext.ensureRel();
+            },
+            onHyperlink: (entry) => {
+                hyperlinkEntries.push(entry);
+            },
+            onDataValidation: (entry) => {
+                dataValidationCollector.add(entry.address, entry.rule);
+            },
+            onCommentThread: (address, threadId) => {
+                threadedCommentsCollector.addCell(address, threadId);
+            },
+        });
+        if (!result)
+            continue;
+        rowXmlChunks.push(result.xml);
+        if (result.minColumn) {
+            bounds.minColumn = Math.min(bounds.minColumn, result.minColumn);
+        }
+        if (result.maxColumn) {
+            bounds.maxColumn = Math.max(bounds.maxColumn, result.maxColumn);
+        }
+        bounds.minRow = Math.min(bounds.minRow, rowIndex);
+        bounds.maxRow = Math.max(bounds.maxRow, rowIndex);
+    }
+    const merges = normalizeMergeRanges(sheet.merges ?? []).map((range) => {
+        bounds.minRow = Math.min(bounds.minRow, range.startRowIndex);
+        bounds.maxRow = Math.max(bounds.maxRow, range.endRowIndex);
+        bounds.minColumn = Math.min(bounds.minColumn, range.startColumnIndex);
+        bounds.maxColumn = Math.max(bounds.maxColumn, range.endColumnIndex);
+        return cellRangeToAddress(undefined, range);
+    });
+    const dimension = buildDimension(bounds);
+    const sheetViews = buildSheetViewsXml(sheet);
+    const sheetPrXml = buildSheetPropertiesXml(sheet);
+    const columnXml = buildColumnsXml(sheet, bounds);
+    const mergeXml = merges.length
+        ? `<mergeCells count="${merges.length}">${merges
+            .map((ref) => `<mergeCell ref="${ref}"/>`)
+            .join("")}</mergeCells>`
+        : "";
+    const basicFilterXml = buildWorksheetAutoFilterXml(sheet, rows, styleBuilder);
+    const dataValidationsXml = dataValidationCollector.toXml();
+    const hyperlinksXml = buildHyperlinksXml(hyperlinkEntries, relationships);
+    const conditionalFormattingXml = buildConditionalFormattingXml({
+        sheetId: sheet.sheetId,
+        conditionalFormats,
+        styleBuilder,
+    });
+    const tablePartsXml = buildTablePartsXml(tables, relationships);
+    const drawingXml = drawingContext.hasDrawing()
+        ? `<drawing r:id="${drawingContext.relId}"/>`
+        : "";
+    // Threaded comments (Excel's "Comments"). Build the modern part, then push
+    // each thread's down-level mirror into the legacy notes collector so the
+    // comments part + VML + relationships below cover both. Order matters: feed
+    // the mirror BEFORE serializing commentsCollector.
+    const threadedCommentsXml = threadedCommentsCollector.toXml();
+    if (threadedCommentsXml) {
+        for (const entry of threadedCommentsCollector.legacyEntries()) {
+            commentsCollector.add(entry.address, entry.text, entry.author);
+        }
+        relationships.add(THREADED_COMMENT_REL_TYPE, `../threadedComments/threadedComment${sheet.sheetId}.xml`);
+    }
+    // Generate comments XML (notes) and add relationships if there are comments
+    const commentsXml = commentsCollector.toXml();
+    let legacyDrawingXml = "";
+    if (commentsXml) {
+        relationships.add(COMMENTS_REL_TYPE, `../comments${sheet.sheetId}.xml`);
+        const legacyDrawingRelId = relationships.add("http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing", `../drawings/vmlDrawing${sheet.sheetId}.vml`);
+        legacyDrawingXml = `<legacyDrawing r:id="${legacyDrawingRelId}"/>`;
+    }
+    const sheetDataXml = `<sheetData>${rowXmlChunks.join("")}</sheetData>`;
+    const pageMargins = DEFAULT_PAGE_MARGINS;
+    // Build row data map for sparkline detection
+    const rowDataMap = {};
+    for (let rowIndex = 1; rowIndex < maxRows; rowIndex++) {
+        const row = rows[rowIndex];
+        if (row?.values) {
+            const rowValues = {};
+            for (const [colIndex, cell] of Object.entries(row.values)) {
+                if (cell) {
+                    rowValues[parseInt(colIndex, 10)] = cell;
+                }
+            }
+            if (Object.keys(rowValues).length > 0) {
+                rowDataMap[rowIndex] = rowValues;
+            }
+        }
+    }
+    // Build sparkline XML from SPARKLINE formulas
+    const sparklineXml = buildSparklineGroupsXml(sheet, rowDataMap);
+    // Build combined extLst with sparklines and slicers
+    const extLstXml = buildWorksheetExtLstXml(sparklineXml, slicerRelIds ?? []);
+    const defaultRowHeightPt = pixelToPoints(getDefaultRowHeightPx(sheet));
+    // Only emit ``defaultColWidth`` when the sheet has an explicit
+    // workbook-level override. Emitting the engine's internal default for
+    // every export forces Excel to use that value as the workbook default,
+    // overriding the user's "Default Width" preference and producing
+    // visibly narrower / wider columns than untouched openpyxl output.
+    const explicitDefaultColumnWidthPx = sheet
+        ?.defaultColumnWidth;
+    const sheetFormatPrAttrs = [`defaultRowHeight="${defaultRowHeightPt}"`];
+    if (typeof explicitDefaultColumnWidthPx === "number" &&
+        explicitDefaultColumnWidthPx > 0) {
+        sheetFormatPrAttrs.push(`defaultColWidth="${columnPixelToChars(explicitDefaultColumnWidthPx).toFixed(2)}"`);
+    }
+    const worksheetXml = `${XML_DECLARATION}<worksheet xmlns="${WORKSHEET_NS}" xmlns:r="${REL_NS}">${sheetPrXml}<dimension ref="${dimension}"/>${sheetViews}<sheetFormatPr ${sheetFormatPrAttrs.join(" ")}/>${columnXml}${sheetDataXml}${basicFilterXml}${mergeXml}${conditionalFormattingXml}${dataValidationsXml}${hyperlinksXml}${pageMargins}${drawingXml}${legacyDrawingXml}${tablePartsXml}${extLstXml}</worksheet>`;
+    return {
+        xml: worksheetXml,
+        relationshipsXml: relationships.toXml(),
+        images: collectedImages,
+        commentsXml,
+        vmlDrawingXml: commentsCollector.toVmlXml(),
+        threadedCommentsXml,
+    };
+};
+/**
+ * Build combined extLst XML for worksheet (sparklines + slicers)
+ */
+const buildWorksheetExtLstXml = (sparklineExtXml, slicerRelIds) => {
+    const parts = [];
+    // Add sparkline ext if present
+    if (sparklineExtXml) {
+        parts.push(sparklineExtXml);
+    }
+    // Add slicer ext if present
+    if (slicerRelIds.length > 0) {
+        const slicersXml = slicerRelIds
+            .map((relId) => `<x14:slicer r:id="${relId}"/>`)
+            .join("");
+        parts.push(`<ext uri="{3A4CF648-6AED-40f4-86FF-DC5316D8AED3}" xmlns:x15="http://schemas.microsoft.com/office/spreadsheetml/2010/11/main"><x14:slicerList xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main">${slicersXml}</x14:slicerList></ext>`);
+    }
+    if (parts.length === 0) {
+        return "";
+    }
+    return `<extLst>${parts.join("")}</extLst>`;
+};
+const sanitizeMergeRange = (range) => {
+    const startRow = sanitizeIndex(range?.startRowIndex);
+    const endRow = sanitizeIndex(range?.endRowIndex);
+    const startColumn = sanitizeIndex(range?.startColumnIndex);
+    const endColumn = sanitizeIndex(range?.endColumnIndex);
+    if (startRow == null ||
+        endRow == null ||
+        startColumn == null ||
+        endColumn == null) {
+        return null;
+    }
+    if (startRow > endRow || startColumn > endColumn) {
+        return null;
+    }
+    if (startRow === endRow && startColumn === endColumn) {
+        return null;
+    }
+    return {
+        startRowIndex: startRow,
+        endRowIndex: endRow,
+        startColumnIndex: startColumn,
+        endColumnIndex: endColumn,
+    };
+};
+const sanitizeIndex = (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    return Math.max(1, Math.floor(value));
+};
+const normalizeMergeRanges = (ranges) => {
+    if (!ranges?.length)
+        return [];
+    const sanitized = ranges
+        .map((range) => sanitizeMergeRange(range))
+        .filter((range) => Boolean(range));
+    if (!sanitized.length)
+        return [];
+    const sorted = sanitized.sort((a, b) => {
+        if (a.startRowIndex !== b.startRowIndex) {
+            return a.startRowIndex - b.startRowIndex;
+        }
+        if (a.startColumnIndex !== b.startColumnIndex) {
+            return a.startColumnIndex - b.startColumnIndex;
+        }
+        if (a.endRowIndex !== b.endRowIndex) {
+            return b.endRowIndex - a.endRowIndex;
+        }
+        return b.endColumnIndex - a.endColumnIndex;
+    });
+    const valid = [];
+    let active = [];
+    for (const merge of sorted) {
+        if (active.length) {
+            active = active.filter((entry) => entry.endRowIndex >= merge.startRowIndex);
+        }
+        const isContained = active.some((entry) => entry.startColumnIndex <= merge.startColumnIndex &&
+            entry.endColumnIndex >= merge.endColumnIndex &&
+            entry.endRowIndex >= merge.endRowIndex);
+        if (!isContained) {
+            valid.push(merge);
+            active.push(merge);
+        }
+    }
+    return valid;
+};
+const convertDataValidationRule = (rule) => {
+    if (!rule)
+        return undefined;
+    const allowBlank = rule.allowBlank !== false;
+    const alert = rule.alert;
+    const inputMessage = rule.inputMessage;
+    const baseConfig = {
+        allowBlank,
+        showInputMessage: Boolean(inputMessage?.message || inputMessage?.title),
+        showErrorMessage: Boolean(alert),
+        errorStyle: alert?.style,
+        errorTitle: alert?.message?.title ?? undefined,
+        error: alert?.message?.message ?? undefined,
+        promptTitle: inputMessage?.title ?? undefined,
+        prompt: inputMessage?.message ?? undefined,
+    };
+    // Round-trip path: when the rule was imported from xlsx, replay the
+    // verbatim source representation. Preserves type/operator/formulas
+    // exactly, including `whole`/`textLength`/`time` types and user-written
+    // custom formulas without `INDIRECT("RC",FALSE)` rewriting.
+    const src = rule.xlsxSource;
+    if (src && src.type && typeof src.formula1 === "string" && src.formula1) {
+        return {
+            type: src.type,
+            operator: src.operator,
+            formula1: src.formula1,
+            formula2: src.formula2,
+            showDropDown: src.type === "list" && rule.displayStyle === "plain" ? true : undefined,
+            ...baseConfig,
+        };
+    }
+    if (!rule.condition?.type) {
+        // Prompt-only DV (no validation rule, just an input-message tooltip
+        // and/or an error alert). Emit it with no type/formula so Excel still
+        // shows the tooltip when the cell is selected.
+        if (baseConfig.showInputMessage || baseConfig.showErrorMessage) {
+            return baseConfig;
+        }
+        return undefined;
+    }
+    const { condition } = rule;
+    const values = condition.values ?? [];
+    const currentCell = 'INDIRECT("RC",FALSE)';
+    const escapeFormulaText = (value) => value.replace(/"/g, '""');
+    const ensureFormula = (value) => value.startsWith("=") ? value : `=${value}`;
+    const ifErrorWrap = (formula) => `IFERROR(${formula},TRUE)`;
+    if (condition.type === "ONE_OF_LIST") {
+        const entries = values
+            .map((value) => value.userEnteredValue)
+            .filter((value) => typeof value === "string");
+        if (!entries.length)
+            return undefined;
+        const sanitized = entries.map((entry) => entry.replace(/"/g, '""'));
+        return {
+            type: "list",
+            formula1: `"${sanitized.join(",")}"`,
+            showDropDown: rule.displayStyle === "plain" ? true : undefined,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "ONE_OF_RANGE") {
+        const references = values
+            .map((value) => value.userEnteredValue)
+            .filter((value) => typeof value === "string");
+        if (!references.length)
+            return undefined;
+        const formula1 = references.join(",");
+        return {
+            type: "list",
+            formula1: formula1.startsWith("=") ? formula1 : `=${formula1}`,
+            showDropDown: rule.displayStyle === "plain" ? true : undefined,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "CUSTOM_FORMULA") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        return {
+            type: "custom",
+            formula1: ensureFormula(raw),
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "BOOLEAN") {
+        return {
+            type: "custom",
+            formula1: `=OR(${currentCell}=TRUE,${currentCell}=FALSE)`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "BLANK") {
+        return {
+            type: "custom",
+            formula1: `=${currentCell}=""`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "NOT_BLANK") {
+        return {
+            type: "custom",
+            formula1: `=${currentCell}<>""`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "TEXT_EQ" || condition.type === "TEXT_NOT_EQ") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        const op = condition.type === "TEXT_EQ" ? "=" : "<>";
+        return {
+            type: "custom",
+            formula1: `=${currentCell}${op}"${escapeFormulaText(raw)}"`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "TEXT_CONTAINS") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        return {
+            type: "custom",
+            formula1: `=ISNUMBER(SEARCH("${escapeFormulaText(raw)}",${currentCell}))`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "TEXT_NOT_CONTAINS") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        return {
+            type: "custom",
+            formula1: `=ISERROR(SEARCH("${escapeFormulaText(raw)}",${currentCell}))`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "TEXT_STARTS_WITH") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        const text = escapeFormulaText(raw);
+        return {
+            type: "custom",
+            formula1: `=LEFT(${currentCell},LEN("${text}"))="${text}"`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "TEXT_ENDS_WITH") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        const text = escapeFormulaText(raw);
+        return {
+            type: "custom",
+            formula1: `=RIGHT(${currentCell},LEN("${text}"))="${text}"`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "TEXT_IS_EMAIL") {
+        return {
+            type: "custom",
+            formula1: `=AND(ISNUMBER(SEARCH("@",${currentCell})),ISNUMBER(SEARCH(".",${currentCell})))`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "TEXT_IS_URL") {
+        return {
+            type: "custom",
+            formula1: `=OR(LEFT(${currentCell},7)="http://",LEFT(${currentCell},8)="https://")`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "NUMBER_BETWEEN" ||
+        condition.type === "NUMBER_NOT_BETWEEN" ||
+        condition.type === "NUMBER_EQ" ||
+        condition.type === "NUMBER_NOT_EQ" ||
+        condition.type === "NUMBER_GREATER" ||
+        condition.type === "NUMBER_GREATER_THAN_EQ" ||
+        condition.type === "NUMBER_LESS" ||
+        condition.type === "NUMBER_LESS_THAN_EQ") {
+        const first = values[0]?.userEnteredValue ?? "";
+        if (!first)
+            return undefined;
+        const second = values[1]?.userEnteredValue ?? "";
+        const operatorMap = {
+            NUMBER_BETWEEN: "between",
+            NUMBER_NOT_BETWEEN: "notBetween",
+            NUMBER_EQ: "equal",
+            NUMBER_NOT_EQ: "notEqual",
+            NUMBER_GREATER: "greaterThan",
+            NUMBER_GREATER_THAN_EQ: "greaterThanOrEqual",
+            NUMBER_LESS: "lessThan",
+            NUMBER_LESS_THAN_EQ: "lessThanOrEqual",
+        };
+        return {
+            type: "decimal",
+            operator: operatorMap[condition.type],
+            formula1: first,
+            formula2: condition.type === "NUMBER_BETWEEN" ||
+                condition.type === "NUMBER_NOT_BETWEEN"
+                ? second
+                : undefined,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "NUMBER_GREATER_THAN_PREVIOUS" ||
+        condition.type === "NUMBER_GREATER_THAN_EQ_PREVIOUS" ||
+        condition.type === "NUMBER_LESS_THAN_PREVIOUS" ||
+        condition.type === "NUMBER_LESS_THAN_EQ_PREVIOUS") {
+        const opMap = {
+            NUMBER_GREATER_THAN_PREVIOUS: ">",
+            NUMBER_GREATER_THAN_EQ_PREVIOUS: ">=",
+            NUMBER_LESS_THAN_PREVIOUS: "<",
+            NUMBER_LESS_THAN_EQ_PREVIOUS: "<=",
+        };
+        const op = opMap[condition.type];
+        return {
+            type: "custom",
+            formula1: `=${ifErrorWrap(`${currentCell}${op}INDIRECT("R[-1]C",FALSE)`)}`,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "DATE_EQ" ||
+        condition.type === "DATE_NOT_EQ" ||
+        condition.type === "DATE_BEFORE" ||
+        condition.type === "DATE_AFTER" ||
+        condition.type === "DATE_ON_OR_BEFORE" ||
+        condition.type === "DATE_ON_OR_AFTER" ||
+        condition.type === "DATE_BETWEEN" ||
+        condition.type === "DATE_NOT_BETWEEN") {
+        const first = values[0]?.userEnteredValue ?? "";
+        if (!first)
+            return undefined;
+        const second = values[1]?.userEnteredValue ?? "";
+        const operatorMap = {
+            DATE_EQ: "equal",
+            DATE_NOT_EQ: "notEqual",
+            DATE_BEFORE: "lessThan",
+            DATE_AFTER: "greaterThan",
+            DATE_ON_OR_BEFORE: "lessThanOrEqual",
+            DATE_ON_OR_AFTER: "greaterThanOrEqual",
+            DATE_BETWEEN: "between",
+            DATE_NOT_BETWEEN: "notBetween",
+        };
+        return {
+            type: "date",
+            operator: operatorMap[condition.type],
+            formula1: first,
+            formula2: condition.type === "DATE_BETWEEN" ||
+                condition.type === "DATE_NOT_BETWEEN"
+                ? second
+                : undefined,
+            ...baseConfig,
+        };
+    }
+    if (condition.type === "DATE_IS_VALID") {
+        return {
+            type: "custom",
+            formula1: `=ISNUMBER(${currentCell})`,
+            ...baseConfig,
+        };
+    }
+    return undefined;
+};
+const getDataValidationKey = (config) => {
+    return [
+        config.type,
+        config.operator ?? "",
+        config.allowBlank ? "1" : "0",
+        config.formula1,
+        config.formula2 ?? "",
+        config.showInputMessage ? "1" : "0",
+        config.showErrorMessage ? "1" : "0",
+        config.errorStyle ?? "",
+        config.errorTitle ?? "",
+        config.error ?? "",
+        config.promptTitle ?? "",
+        config.prompt ?? "",
+        config.showDropDown ? "1" : "0",
+    ].join("|");
+};
+const buildDataValidationXml = (config, refs) => {
+    const attrs = [];
+    if (config.type) {
+        attrs.push(`type="${config.type}"`);
+    }
+    if (config.operator) {
+        attrs.push(`operator="${config.operator}"`);
+    }
+    if (config.allowBlank) {
+        attrs.push(`allowBlank="1"`);
+    }
+    if (config.showInputMessage) {
+        attrs.push(`showInputMessage="1"`);
+    }
+    if (config.showErrorMessage) {
+        attrs.push(`showErrorMessage="1"`);
+    }
+    if (config.errorStyle) {
+        attrs.push(`errorStyle="${config.errorStyle}"`);
+    }
+    if (config.errorTitle) {
+        attrs.push(`errorTitle="${escapeXmlAttr(config.errorTitle)}"`);
+    }
+    if (config.error) {
+        attrs.push(`error="${escapeXmlAttr(config.error)}"`);
+    }
+    if (config.promptTitle) {
+        attrs.push(`promptTitle="${escapeXmlAttr(config.promptTitle)}"`);
+    }
+    if (config.prompt) {
+        attrs.push(`prompt="${escapeXmlAttr(config.prompt)}"`);
+    }
+    if (config.showDropDown) {
+        attrs.push(`showDropDown="1"`);
+    }
+    const sqref = normalizeSqrefMembers(refs).join(" ");
+    // Prompt-only DVs have no formula; emit a self-closing tag in that case.
+    if (!config.type && !config.formula1) {
+        return `<dataValidation ${attrs.join(" ")} sqref="${sqref}"/>`;
+    }
+    const formula2 = config.formula2
+        ? `<formula2>${escapeXmlText(config.formula2)}</formula2>`
+        : "";
+    return `<dataValidation ${attrs.join(" ")} sqref="${sqref}"><formula1>${escapeXmlText(config.formula1 ?? "")}</formula1>${formula2}</dataValidation>`;
+};
+const resolveCellDataValidation = (cell, map) => {
+    if (!cell)
+        return undefined;
+    const raw = cell?.dataValidation;
+    if (!raw)
+        return undefined;
+    if (typeof raw === "string" || typeof raw === "number") {
+        return map?.[raw];
+    }
+    return raw;
+};
+const buildWorksheetRow = ({ rowNumber, row, rowMetadata, defaultRowHeightPx, sharedStrings, sourceSharedStrings, cellXfs, styleBuilder, onImage, onHyperlink, dataValidationsById, onDataValidation, tableNameMap, tables, ignoreFormulaPatterns, commentsCollector, onCommentThread, sheetId, sheetData, sheets, locale, validSharedFormulaLeaders, }) => {
+    const values = row?.values ?? [];
+    const cellXmlChunks = [];
+    let minColumn = Number.POSITIVE_INFINITY;
+    let maxColumn = 0;
+    for (let columnIndex = 1; columnIndex < values.length; columnIndex++) {
+        const cell = values[columnIndex];
+        const cellXml = buildCellXml({
+            rowNumber,
+            columnIndex,
+            cell,
+            sharedStrings,
+            sourceSharedStrings,
+            cellXfs,
+            styleBuilder,
+            onImage,
+            onHyperlink,
+            dataValidationsById,
+            onDataValidation,
+            tableNameMap,
+            tables,
+            ignoreFormulaPatterns,
+            commentsCollector,
+            onCommentThread,
+            sheetId,
+            sheetData,
+            sheets,
+            locale,
+            validSharedFormulaLeaders,
+        });
+        if (!cellXml)
+            continue;
+        cellXmlChunks.push(cellXml);
+        minColumn = Math.min(minColumn, columnIndex);
+        maxColumn = Math.max(maxColumn, columnIndex);
+    }
+    const hasCells = cellXmlChunks.length > 0;
+    const rowSize = rowMetadata?.size && rowMetadata.size > 0 ? rowMetadata.size : undefined;
+    const hasHiddenFlag = Boolean(rowMetadata?.hiddenByUser ||
+        rowMetadata?.hiddenByFilter ||
+        rowMetadata?.hiddenByGroup);
+    // Emit ``ht`` / ``customHeight`` when either:
+    //  (a) the row height differs from the workbook default, OR
+    //  (b) the import-side captured the source xlsx's ``customHeight="1"``
+    //      marker — Excel preserves that flag on round-trip even when the
+    //      value matches the default, and the fidelity comparator catches
+    //      its loss as a regression.
+    // The `customHeight="1"` marker is emitted in two distinct cases:
+    //  1. The import-only `customHeight` flag is set — preserves the source
+    //     xlsx's `customHeight="1"` verbatim, even when the height equals
+    //     the sheet default (xlsx files do carry that combination; Excel
+    //     reads it as "user locked this row even though it happens to
+    //     match the default").
+    //  2. `resizedByUser=true` AND the height is non-default — covers the
+    //     UI/runtime path where a user explicitly resized a row to a
+    //     non-default value. We deliberately exclude `resizedByUser` on
+    //     default-height rows because that flag is shared with runtime
+    //     engine state (autofit chains, column-resize side effects) and
+    //     a stray flip there used to stamp every default-height row with
+    //     `customHeight="1"`, which Excel reads as "user locked this row"
+    //     and refuses to auto-fit.
+    const hasExplicitHeight = Boolean(rowSize && Math.abs(rowSize - defaultRowHeightPx) > 0.01);
+    const hasUserLockedHeight = Boolean(rowSize &&
+        (rowMetadata?.customHeight ||
+            (hasExplicitHeight && rowMetadata?.resizedByUser)));
+    const outlineLevel = rowMetadata?.outlineLevel ?? 0;
+    const isCollapsed = Boolean(rowMetadata?.collapsed);
+    const hasOutlineMetadata = outlineLevel > 0 || isCollapsed;
+    const needsMetadata = hasHiddenFlag ||
+        hasExplicitHeight ||
+        hasUserLockedHeight ||
+        hasOutlineMetadata;
+    if (!hasCells && !needsMetadata) {
+        return null;
+    }
+    const attrs = [`r="${rowNumber}"`];
+    if ((hasExplicitHeight || hasUserLockedHeight) && rowSize) {
+        const height = pixelToPoints(rowSize);
+        if (hasUserLockedHeight) {
+            attrs.push(`customHeight="1"`);
+        }
+        attrs.push(`ht="${height}"`);
+    }
+    if (hasHiddenFlag) {
+        attrs.push(`hidden="1"`);
+    }
+    if (outlineLevel > 0) {
+        attrs.push(`outlineLevel="${Math.min(7, Math.trunc(outlineLevel))}"`);
+    }
+    if (isCollapsed) {
+        attrs.push(`collapsed="1"`);
+    }
+    const rowXml = `<row ${attrs.join(" ")}>${cellXmlChunks.join("")}</row>`;
+    return {
+        xml: rowXml,
+        minColumn: isFinite(minColumn) ? minColumn : undefined,
+        maxColumn: maxColumn || undefined,
+    };
+};
+const buildCellXml = ({ rowNumber, columnIndex, cell, sharedStrings, sourceSharedStrings, cellXfs, styleBuilder, onImage, onHyperlink, dataValidationsById, onDataValidation, tableNameMap, tables, ignoreFormulaPatterns, commentsCollector, onCommentThread, sheetId, sheetData, sheets, locale, validSharedFormulaLeaders, }) => {
+    const normalizedCell = cell;
+    if (!normalizedCell)
+        return undefined;
+    const userEnteredValue = getCellUserEnteredValue(normalizedCell);
+    const effectiveValue = getCellEffectiveValue(normalizedCell) ?? userEnteredValue;
+    // Excel-style: only `uf` is serialized. Read `uf` first, fall back to
+    // legacy `ef` so old saved data still exports with its original format.
+    let effectiveFormat = getCellUserEnteredFormat(normalizedCell) ??
+        getCellEffectiveFormat(normalizedCell);
+    if (effectiveFormat && isStyleReference(effectiveFormat)) {
+        const styleId = effectiveFormat.sid ?? effectiveFormat.styleId;
+        effectiveFormat = styleId ? cellXfs?.get(styleId) : undefined;
+    }
+    let formattedValue = getCellFormattedValue(normalizedCell);
+    // The data-validation Invalid marker is UI-only and must never export as
+    // a real error cell — strip it so the cell's underlying value exports.
+    const valueSource = omitInvalidDataValidationError(effectiveValue) ??
+        omitInvalidDataValidationError(userEnteredValue);
+    const numberValue = getExtendedValueNumber(valueSource);
+    const boolValue = getExtendedValueBool(valueSource);
+    const rawFormulaValue = getExtendedValueFormula(userEnteredValue);
+    const formulaValue = shouldIgnoreFormula(rawFormulaValue, ignoreFormulaPatterns)
+        ? undefined
+        : rawFormulaValue;
+    let exportedFormulaValue = formulaValue
+        ? rewriteStructuredReferenceFormula(formulaValue, tableNameMap, tables, rowNumber, columnIndex)
+        : formulaValue;
+    // If formula contains property references (e.g., =A1.propertyName),
+    // use formatted value instead of exporting unsupported formula
+    if (hasPropertyReference(exportedFormulaValue)) {
+        exportedFormulaValue = undefined;
+    }
+    const errorValue = getExtendedValueError(valueSource);
+    let stringValue = getExtendedValueString(valueSource);
+    const sharedStringIndex = normalizedCell?.ss;
+    const sharedStringValue = sharedStringIndex != null && sourceSharedStrings
+        ? sourceSharedStrings.get(String(sharedStringIndex))
+        : null;
+    if (sharedStringValue != null) {
+        // SharedStrings entries can be either plain strings or rich
+        // `{ text, runs }` objects. Surface the text for the cell value;
+        // the rich runs are picked up separately below to write `<si><r>`.
+        stringValue =
+            typeof sharedStringValue === "string"
+                ? sharedStringValue
+                : sharedStringValue.text ?? "";
+        formattedValue = undefined;
+    }
+    const isDateLike = effectiveFormat?.numberFormat?.type === "DATE" ||
+        effectiveFormat?.numberFormat?.type === "DATE_TIME";
+    // Only treat as date string if the number is a valid Excel date serial
+    // Large numbers outside the valid date range should export as numbers
+    if (isDateLike && formattedValue && isValidExcelDateSerial(numberValue)) {
+        stringValue = formattedValue;
+    }
+    if (formulaValue &&
+        (stringValue != null || formattedValue != null) &&
+        stringValue == null) {
+        stringValue = String(formattedValue ?? "");
+    }
+    const hasExplicitValue = !isNil(numberValue) ||
+        !isNil(boolValue) ||
+        !isNil(formulaValue) ||
+        !isNil(errorValue) ||
+        stringValue != null;
+    if (!hasExplicitValue && formattedValue === "") {
+        formattedValue = undefined;
+    }
+    // For formula cells with no explicit number format, derive the format
+    // Excel/Sheets would auto-apply from precedents and pass it into the
+    // style registration. The cellData itself stays untouched. Without this,
+    // Excel displays formula results without their inherited format until
+    // the user manually recalculates.
+    //
+    // Skip cells whose `uf` is a `{ sid }` style reference: that's the shape
+    // xlsx import produces, and an untouched imported cell's source xf already
+    // says what Excel showed — General there is a decision, not a gap, and
+    // deriving from precedents would restyle it away from the source file.
+    const importedStyleRef = typeof normalizedCell.uf === "object" &&
+        normalizedCell.uf !== null &&
+        "sid" in normalizedCell.uf;
+    let derivedNumberFormat;
+    if (formulaValue &&
+        !importedStyleRef &&
+        !effectiveFormat?.numberFormat &&
+        sheetData &&
+        sheets &&
+        sheetId != null) {
+        const sheetIdByName = new Map();
+        for (const s of sheets) {
+            if (s?.title)
+                sheetIdByName.set(s.title, s.sheetId);
+        }
+        // A real CellXfsRegistry so `SheetCell.assign` inside the derive
+        // helper can resolve precedent cells whose `uf` is a `{ sid }` style
+        // reference (the shape xlsx-imported workbooks produce).
+        const cellXfsRegistry = cellXfs ? new CellXfsRegistry(cellXfs) : undefined;
+        derivedNumberFormat =
+            deriveEffectiveNumberFormatFromFormula(formulaValue, sheetId, rowNumber, columnIndex, sheetData, (input) => defaultTokenizer(input), (name) => sheetIdByName.get(name) ?? sheetId, locale, cellXfsRegistry, undefined, typeof numberValue === "number" ? numberValue : null) ?? undefined;
+    }
+    const styleId = styleBuilder.registerCell(normalizedCell, cellXfs, derivedNumberFormat);
+    const address = cellToAddress({
+        rowIndex: rowNumber,
+        columnIndex,
+    });
+    if (!address)
+        return undefined;
+    // Check if cell has a note and add it to comments collector
+    if (normalizedCell.note) {
+        commentsCollector.add(address, normalizedCell.note, "User");
+    }
+    // A cell that anchors a comment thread carries only the thread id; the
+    // resolver matches it against the workbook's threads to emit threaded
+    // comments (+ a down-level note mirror).
+    if (normalizedCell.commentThreadId != null) {
+        onCommentThread?.(address, normalizedCell.commentThreadId);
+    }
+    const hyperlinkValue = normalizeHyperlinkValue(normalizedCell?.hyperlink);
+    if (hyperlinkValue) {
+        onHyperlink({ ref: address, hyperlink: hyperlinkValue });
+    }
+    const validationRule = resolveCellDataValidation(normalizedCell, dataValidationsById);
+    if (validationRule) {
+        onDataValidation?.({ address, rule: validationRule });
+    }
+    if (normalizedCell.imageUrl) {
+        onImage({
+            kind: "cell",
+            imageUrl: normalizedCell.imageUrl,
+            rowIndex: rowNumber,
+            columnIndex,
+        });
+    }
+    const xmlParts = [];
+    let typeAttr = "";
+    if (exportedFormulaValue) {
+        // Array formula anchor: emit <f t="array" ref="..."/>. Spilled cells in
+        // the range carry no `ue` formula (they're populated by the calculator
+        // as side-effects of the anchor's evaluation), so they never reach this
+        // branch and correctly emit only <v>.
+        const arrayRef = normalizedCell.af;
+        // Shared formula: emit `<f t="shared" si="N" ref="A1:A10">FORMULA</f>`
+        // on the leader cell (carries both `si` and `ref`) and
+        // `<f t="shared" si="N"/>` on followers (carries only `si` — no formula
+        // text, no `ref`). Excel rebuilds the followers' formulas from the
+        // leader's expression. Array takes precedence if both somehow apply
+        // since they're mutually exclusive `t="…"` types.
+        const sharedSpec = normalizedCell.sf;
+        if (arrayRef) {
+            xmlParts.push(`<f t="array" ref="${escapeXmlAttr(arrayRef)}">${escapeXmlText(stripFormula(exportedFormulaValue))}</f>`);
+        }
+        else if (sharedSpec && Number.isFinite(sharedSpec.si)) {
+            if (sharedSpec.ref) {
+                // Leader cell — emit full formula plus the shared-range ref.
+                xmlParts.push(`<f t="shared" ref="${escapeXmlAttr(sharedSpec.ref)}" si="${sharedSpec.si}">${escapeXmlText(stripFormula(exportedFormulaValue))}</f>`);
+            }
+            else if (validSharedFormulaLeaders?.has(sharedSpec.si)) {
+                // Follower cell with a known leader — self-closing, no formula text.
+                // Excel reads `si` back through the leader's expression and applies
+                // relative-ref adjustments based on cell position.
+                xmlParts.push(`<f t="shared" si="${sharedSpec.si}"/>`);
+            }
+            else {
+                // Follower whose leader is missing (typically because the leader
+                // was edited by the user and lost its `sf` provenance). Falling
+                // back to the standalone formula keeps the cell evaluating — the
+                // `exportedFormulaValue` was already expanded with the right
+                // relative refs on import via `formulaToRelativeReference`.
+                xmlParts.push(`<f>${escapeXmlText(stripFormula(exportedFormulaValue))}</f>`);
+            }
+        }
+        else {
+            xmlParts.push(`<f>${escapeXmlText(stripFormula(exportedFormulaValue))}</f>`);
+        }
+    }
+    if (errorValue) {
+        typeAttr = ` t="e"`;
+        const errorText = typeof errorValue === "string"
+            ? errorValue
+            : errorValue?.name ||
+                errorValue?.type ||
+                errorValue?.message ||
+                "#VALUE!";
+        xmlParts.push(`<v>${escapeXmlText(normalizeExcelError(errorText))}</v>`);
+    }
+    else if (!isNil(numberValue)) {
+        xmlParts.push(`<v>${numberValue}</v>`);
+    }
+    else if (!isNil(boolValue)) {
+        typeAttr = ` t="b"`;
+        xmlParts.push(`<v>${boolValue ? 1 : 0}</v>`);
+    }
+    else if (formulaValue && stringValue != null) {
+        typeAttr = ` t="str"`;
+        xmlParts.push(`<v>${escapeXmlText(String(stringValue))}</v>`);
+    }
+    else if (stringValue != null || formattedValue != null) {
+        const text = stringValue ?? formattedValue;
+        if (text == null) {
+            return undefined;
+        }
+        // If this cell references a shared-string entry that carries runs
+        // (rich SST entry in `sourceSharedStrings`), reuse that entry so
+        // the formatting persists; otherwise intern a plain entry.
+        const sourceEntry = normalizedCell.ss != null
+            ? sourceSharedStrings?.get(String(normalizedCell.ss))
+            : undefined;
+        const richRuns = sourceEntry &&
+            typeof sourceEntry === "object" &&
+            Array.isArray(sourceEntry.runs)
+            ? sourceEntry.runs
+            : undefined;
+        const stringIndex = richRuns
+            ? sharedStrings.addRich(String(text), richRuns)
+            : sharedStrings.add(String(text));
+        typeAttr = ` t="s"`;
+        xmlParts.push(`<v>${stringIndex}</v>`);
+    }
+    const styleAttr = styleId ? ` s="${styleId}"` : "";
+    if (!xmlParts.length) {
+        if (!styleId && !hyperlinkValue) {
+            return undefined;
+        }
+        return `<c r="${address}"${styleAttr}/>`;
+    }
+    return `<c r="${address}"${typeAttr}${styleAttr}>${xmlParts.join("")}</c>`;
+};
+const normalizeHyperlinkValue = (hyperlink) => {
+    if (!hyperlink) {
+        return undefined;
+    }
+    if (typeof hyperlink === "string") {
+        return { kind: "external", url: hyperlink };
+    }
+    return hyperlink;
+};
+// Excel rejects hyperlink targets that aren't valid URIs. Targets seen in the
+// wild that need normalizing: `<email@host>` (angle-bracket form), bare emails
+// (`user@host` without `mailto:`), and comma-separated lists. Returns undefined
+// to skip emitting the hyperlink rel entirely when we can't make it valid.
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const sanitizeHyperlinkUrl = (url) => {
+    if (!url || typeof url !== "string")
+        return undefined;
+    let t = url.trim();
+    if (!t)
+        return undefined;
+    if (t.startsWith("<") && t.endsWith(">")) {
+        t = t.slice(1, -1).trim();
+    }
+    if (t.includes(",")) {
+        t = t.split(",")[0].trim();
+    }
+    if (/^(https?|mailto|ftp|file):/i.test(t) || t.startsWith("#")) {
+        return t;
+    }
+    if (EMAIL_RE.test(t)) {
+        return `mailto:${t}`;
+    }
+    return undefined;
+};
+const buildHyperlinksXml = (entries, relationships) => {
+    if (!entries.length) {
+        return "";
+    }
+    const items = entries
+        .map((entry) => {
+        const hyperlink = entry.hyperlink;
+        const displayAttr = hyperlink.display
+            ? ` display="${escapeXmlAttr(hyperlink.display)}"`
+            : "";
+        const tooltipAttr = hyperlink.tooltip
+            ? ` tooltip="${escapeXmlAttr(hyperlink.tooltip)}"`
+            : "";
+        if (hyperlink.kind === "external") {
+            const url = sanitizeHyperlinkUrl(hyperlink.url);
+            if (!url) {
+                return "";
+            }
+            const relId = relationships.add(HYPERLINK_REL_TYPE, url, "External");
+            return `<hyperlink ref="${entry.ref}" r:id="${relId}"${displayAttr}${tooltipAttr}/>`;
+        }
+        if (!hyperlink.location) {
+            return "";
+        }
+        return `<hyperlink ref="${entry.ref}" location="${escapeXmlAttr(hyperlink.location)}"${displayAttr}${tooltipAttr}/>`;
+    })
+        .filter(Boolean)
+        .join("");
+    if (!items) {
+        return "";
+    }
+    return `<hyperlinks>${items}</hyperlinks>`;
+};
+function shouldIgnoreFormula(formula, patterns) {
+    if (!formula)
+        return false;
+    // Always ignore SPARKLINE formulas - they're exported as native Excel sparklines
+    if (formula.toUpperCase().startsWith("=SPARKLINE(")) {
+        return true;
+    }
+    if (!patterns)
+        return false;
+    const normalized = formula.startsWith("=") ? formula.slice(1) : formula;
+    const list = Array.isArray(patterns) ? patterns : [patterns];
+    return list.some((pattern) => pattern.test(formula) || pattern.test(normalized));
+}
+function stripFormula(formula) {
+    const trimmed = formula.startsWith("=") ? formula.slice(1) : formula;
+    return sanitizeFormulaText(trimmed);
+}
+function hasPropertyReference(formula) {
+    if (!formula)
+        return false;
+    // Detects cell references with property access: A1.property, $A$1.nested.value, etc.
+    const propertyReferencePattern = /[$]?[A-Za-z]{1,3}[$]?[1-9][0-9]*\./;
+    return propertyReferencePattern.test(formula);
+}
+// Excel date serial: 1 = Jan 1, 1900, max ~2958465 = Dec 31, 9999
+// Numbers outside this range should not be treated as dates
+const MIN_EXCEL_DATE_SERIAL = 0;
+const MAX_EXCEL_DATE_SERIAL = 2958465;
+function isValidExcelDateSerial(value) {
+    if (value == null || !Number.isFinite(value))
+        return false;
+    return value >= MIN_EXCEL_DATE_SERIAL && value <= MAX_EXCEL_DATE_SERIAL;
+}
+function rewriteTableNamesInFormula(formula, tableNameMap) {
+    if (!tableNameMap?.size)
+        return formula;
+    let normalized = formula;
+    for (const [tableName, exportedName] of tableNameMap) {
+        if (!tableName || tableName === exportedName)
+            continue;
+        const escaped = escapeCharacters(tableName);
+        if (!escaped)
+            continue;
+        normalized = normalized.replace(new RegExp(`${escaped}(?=\\[)`, "g"), exportedName);
+    }
+    return normalized;
+}
+function findTableForCell(tables, rowNumber, columnIndex) {
+    if (!tables?.length)
+        return undefined;
+    return tables.find((table) => {
+        const range = table.range;
+        if (!range)
+            return false;
+        return (rowNumber >= range.startRowIndex &&
+            rowNumber <= range.endRowIndex &&
+            columnIndex >= range.startColumnIndex &&
+            columnIndex <= range.endColumnIndex);
+    });
+}
+function prefixUnqualifiedStructuredReferences(formula, tableName) {
+    if (!tableName)
+        return formula;
+    let normalized = "";
+    let inString = false;
+    let depth = 0;
+    for (let i = 0; i < formula.length; i++) {
+        const char = formula[i];
+        if (char === '"') {
+            normalized += char;
+            if (inString) {
+                if (formula[i + 1] === '"') {
+                    normalized += '"';
+                    i += 1;
+                }
+                else {
+                    inString = false;
+                }
+            }
+            else {
+                inString = true;
+            }
+            continue;
+        }
+        if (inString) {
+            normalized += char;
+            continue;
+        }
+        if (char === "[") {
+            const prev = i > 0 ? formula[i - 1] : "";
+            if (depth === 0 && !/[A-Za-z0-9_\]\[]/.test(prev)) {
+                normalized += tableName;
+            }
+            depth += 1;
+            normalized += char;
+            continue;
+        }
+        if (char === "]" && depth > 0) {
+            depth -= 1;
+            normalized += char;
+            continue;
+        }
+        normalized += char;
+    }
+    return normalized;
+}
+function normalizeThisRowStructuredReferences(formula, tableName) {
+    if (!tableName)
+        return formula;
+    let normalized = formula;
+    const escapedTable = escapeCharacters(tableName);
+    if (!escapedTable)
+        return normalized;
+    const bracketed = new RegExp(`${escapedTable}\\[\\@\\[([^\\]]+)\\]\\]`, "g");
+    const simple = new RegExp(`${escapedTable}\\[\\@([^\\]]+)\\]`, "g");
+    normalized = normalized.replace(bracketed, `${tableName}[[#This Row],[$1]]`);
+    normalized = normalized.replace(simple, `${tableName}[[#This Row],[$1]]`);
+    return normalized;
+}
+function normalizeCalculatedColumnFormula(formula, table) {
+    const tableNameMap = new Map();
+    const tableTitle = table.title ?? table.name;
+    if (tableTitle && tableTitle !== table.name) {
+        tableNameMap.set(tableTitle, table.name);
+    }
+    let normalized = rewriteTableNamesInFormula(formula, tableNameMap.size ? tableNameMap : undefined);
+    normalized = prefixUnqualifiedStructuredReferences(normalized, table.name);
+    normalized = normalizeThisRowStructuredReferences(normalized, table.name);
+    return normalized;
+}
+function rewriteStructuredReferenceFormula(formula, tableNameMap, tables, rowNumber, columnIndex) {
+    const normalized = rewriteTableNamesInFormula(formula, tableNameMap);
+    const table = findTableForCell(tables, rowNumber, columnIndex);
+    if (!table?.name)
+        return normalized;
+    const qualified = prefixUnqualifiedStructuredReferences(normalized, table.name);
+    return normalizeThisRowStructuredReferences(qualified, table.name);
+}
+function sanitizeFormulaText(formula) {
+    const normalized = sanitizeXmlText(formula);
+    return qualifyFutureFunctions(normalized.replace(/\r\n|\r|\n/g, " "));
+}
+function escapeXmlBase(value) {
+    return sanitizeXmlText(value)
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Escape a value for an XML attribute. Newlines must be written as
+ * character references (`&#10;`) because attribute-value normalization
+ * folds raw line breaks into spaces.
+ */
+function escapeXmlAttr(value) {
+    return escapeXmlBase(value)
+        .replace(/\r\n/g, "&#10;")
+        .replace(/\r/g, "&#10;")
+        .replace(/\n/g, "&#10;");
+}
+/**
+ * Escape a value for XML element text. Raw LF is legal and preserved
+ * verbatim in text nodes (Excel, rust_xlsxwriter, and the ODS exporter
+ * all write raw newlines there); emitting `&#10;` instead leaks a
+ * literal entity into importers that don't decode numeric character
+ * references.
+ */
+function escapeXmlText(value) {
+    return escapeXmlBase(value).replace(/\r\n|\r/g, "\n");
+}
+const EXCEL_ERROR_VALUES = new Set([
+    "#NULL!",
+    "#DIV/0!",
+    "#VALUE!",
+    "#REF!",
+    "#NAME?",
+    "#NUM!",
+    "#N/A",
+    "#GETTING_DATA",
+    "#SPILL!",
+    "#CALC!",
+    "#CONNECT!",
+    "#BLOCKED!",
+    "#FIELD!",
+]);
+function normalizeExcelError(value) {
+    if (!value)
+        return "#VALUE!";
+    const trimmed = value.trim();
+    if (!trimmed)
+        return "#VALUE!";
+    if (EXCEL_ERROR_VALUES.has(trimmed)) {
+        return trimmed;
+    }
+    return "#VALUE!";
+}
+const serializeColorXml = (color) => {
+    if (!color)
+        return undefined;
+    if (typeof color === "string") {
+        const hex = normalizeHex(color);
+        return `rgb="${hex}"`;
+    }
+    const tintAttr = typeof color.tint === "number" ? ` tint="${color.tint}"` : "";
+    return `theme="${color.theme}"${tintAttr}`;
+};
+const normalizeHex = (color) => {
+    const normalized = color.startsWith("#") ? color.slice(1) : color;
+    return normalized.length === 6 ? `FF${normalized}` : normalized;
+};
+const buildDimension = (bounds) => {
+    if (!isFinite(bounds.minRow) ||
+        !isFinite(bounds.minColumn) ||
+        bounds.maxRow === 0 ||
+        bounds.maxColumn === 0) {
+        return "A1";
+    }
+    const startCol = columnIndexToLetter(bounds.minColumn);
+    const endCol = columnIndexToLetter(bounds.maxColumn);
+    return `${startCol}${bounds.minRow}:${endCol}${bounds.maxRow}`;
+};
+const buildColumnsXml = (sheet, bounds) => {
+    const metadata = sheet.columnMetadata ?? [];
+    const maxColumns = Math.max(metadata.length - 1, bounds.maxColumn || 0);
+    if (!maxColumns) {
+        return "";
+    }
+    // Only emit ``<col>`` entries for columns the caller actually customized
+    // (explicit width, hidden, or outline level). Emitting a `<col>` with the
+    // engine's internal default width for every column — and stamping it with
+    // ``customWidth="1"`` — overrides Excel's natural default-column-width
+    // behavior and makes columns visibly narrower / wider than the equivalent
+    // untouched openpyxl output. This matches stock openpyxl, which omits
+    // ``<col>`` for non-customized columns and relies on Excel's default.
+    const cols = [];
+    for (let columnIndex = 1; columnIndex <= maxColumns; columnIndex += 1) {
+        const props = metadata[columnIndex];
+        if (!props)
+            continue;
+        const hasExplicitSize = Boolean(props.size && props.size > 0);
+        const hasHiddenFlag = Boolean(props.hiddenByUser || props.hiddenByFilter || props.hiddenByGroup);
+        const outlineLevel = props.outlineLevel ?? 0;
+        const isCollapsed = Boolean(props.collapsed);
+        const hasOutlineMetadata = outlineLevel > 0 || isCollapsed;
+        if (!hasExplicitSize && !hasHiddenFlag && !hasOutlineMetadata)
+            continue;
+        const attributes = [`min="${columnIndex}"`, `max="${columnIndex}"`];
+        if (hasExplicitSize) {
+            const width = columnPixelToChars(getColumnWidthPx(sheet, columnIndex - 1));
+            attributes.push(`width="${width.toFixed(2)}"`);
+            attributes.push(`customWidth="1"`);
+        }
+        if (hasHiddenFlag) {
+            attributes.push(`hidden="1"`);
+        }
+        if (outlineLevel > 0) {
+            attributes.push(`outlineLevel="${Math.min(7, Math.trunc(outlineLevel))}"`);
+        }
+        if (isCollapsed) {
+            attributes.push(`collapsed="1"`);
+        }
+        cols.push(`<col ${attributes.join(" ")}/>`);
+    }
+    if (!cols.length)
+        return "";
+    return `<cols>${cols.join("")}</cols>`;
+};
+const buildTablePartsXml = (tables, relationships) => {
+    if (!tables.length) {
+        return "";
+    }
+    const parts = tables
+        .map((table) => {
+        const relId = relationships.add(TABLE_REL_TYPE, table.target);
+        return `<tablePart r:id="${relId}"/>`;
+    })
+        .join("");
+    return `<tableParts count="${tables.length}">${parts}</tableParts>`;
+};
+const buildSheetViewsXml = (sheet) => {
+    const showGridLines = sheet.showGridLines ?? true;
+    const showRowColHeaders = sheet.showRowColHeaders ?? true;
+    const showZeros = sheet.showZeros ?? true;
+    const zoomScale = sheet.zoomScale;
+    const attrs = [`workbookViewId="0"`];
+    if (!showGridLines) {
+        attrs.push(`showGridLines="0"`);
+    }
+    if (!showRowColHeaders) {
+        attrs.push(`showRowColHeaders="0"`);
+    }
+    if (!showZeros) {
+        attrs.push(`showZeros="0"`);
+    }
+    // Only emit zoomScale when set to a non-default value (Excel default = 100).
+    if (typeof zoomScale === "number" &&
+        zoomScale >= 10 &&
+        zoomScale <= 400 &&
+        zoomScale !== 100) {
+        attrs.push(`zoomScale="${zoomScale}"`);
+    }
+    const panes = [];
+    const frozenRows = sheet.frozenRowCount ?? 0;
+    const frozenColumns = sheet.frozenColumnCount ?? 0;
+    if (frozenRows > 0 || frozenColumns > 0) {
+        const paneAttrs = [`state="frozen"`];
+        if (frozenColumns > 0) {
+            paneAttrs.push(`xSplit="${frozenColumns}"`);
+        }
+        if (frozenRows > 0) {
+            paneAttrs.push(`ySplit="${frozenRows}"`);
+        }
+        // Default view anchor = the first unfrozen cell. A preserved source
+        // scroll position (`sheet.paneTopLeftCell`) wins when it's a valid A1
+        // ref at or beyond that anchor, so an untouched import/export keeps the
+        // user's saved scroll instead of snapping back to the freeze corner.
+        let topLeftCell = `${columnIndexToLetter(Math.max(1, frozenColumns + 1))}${frozenRows + 1}`;
+        const savedTopLeft = sheet
+            .paneTopLeftCell;
+        if (typeof savedTopLeft === "string") {
+            const m = /^([A-Z]+)([0-9]+)$/.exec(savedTopLeft);
+            if (m) {
+                const col = m[1]
+                    .split("")
+                    .reduce((acc, ch) => acc * 26 + (ch.charCodeAt(0) - 64), 0);
+                const row = Number(m[2]);
+                if (row >= frozenRows + 1 && col >= Math.max(1, frozenColumns + 1)) {
+                    topLeftCell = savedTopLeft;
+                }
+            }
+        }
+        paneAttrs.push(`topLeftCell="${topLeftCell}"`);
+        // Anchor active selection in the unfrozen quadrant. Excel writes
+        // `pane="bottomRight"` when both rows AND columns are frozen,
+        // `bottomLeft` when only rows, `topRight` when only columns. Without
+        // this the cursor lands in A1 (the frozen region) on first open.
+        let activePane;
+        if (frozenRows > 0 && frozenColumns > 0) {
+            activePane = "bottomRight";
+        }
+        else if (frozenRows > 0) {
+            activePane = "bottomLeft";
+        }
+        else {
+            activePane = "topRight";
+        }
+        paneAttrs.push(`activePane="${activePane}"`);
+        panes.push(`<pane ${paneAttrs.join(" ")}/>`);
+        panes.push(`<selection pane="${activePane}" activeCell="${topLeftCell}" sqref="${topLeftCell}"/>`);
+    }
+    return `<sheetViews><sheetView ${attrs.join(" ")}>${panes.join("")}</sheetView></sheetViews>`;
+};
+const columnIndexToLetter = (index) => {
+    let dividend = Math.max(1, index);
+    let columnName = "";
+    while (dividend > 0) {
+        const modulo = (dividend - 1) % 26;
+        columnName = String.fromCharCode(65 + modulo) + columnName;
+        dividend = Math.floor((dividend - modulo) / 26);
+    }
+    return columnName;
+};
+/**
+ * Build the `<rPr>` block for one rich-text run. Maps our internal
+ * TextFormat keys to OOXML run-properties. Only emits properties that
+ * differ from the cell-level base — Excel falls back to the parent
+ * cell's `<xf>` style for anything absent, matching what users expect.
+ */
+const buildRichRunProperties = (format) => {
+    const parts = [];
+    if (format?.bold)
+        parts.push(`<b/>`);
+    if (format?.italic)
+        parts.push(`<i/>`);
+    if (format?.underline)
+        parts.push(`<u/>`);
+    if (format?.strikethrough)
+        parts.push(`<strike/>`);
+    if (format?.baselineOffset === "superscript") {
+        parts.push(`<vertAlign val="superscript"/>`);
+    }
+    else if (format?.baselineOffset === "subscript") {
+        parts.push(`<vertAlign val="subscript"/>`);
+    }
+    if (typeof format?.fontSize === "number") {
+        parts.push(`<sz val="${format.fontSize}"/>`);
+    }
+    if (typeof format?.fontFamily === "string" && format.fontFamily) {
+        parts.push(`<rFont val="${escapeXmlAttr(format.fontFamily)}"/>`);
+    }
+    if (format?.color) {
+        // Color may be a string ("#RRGGBB" or "rgb(...)") or a theme/tint
+        // object. We only emit the simple `rgb=` form for now — theme
+        // colors round-trip lossless via `<color theme="N" tint="X"/>`
+        // but require additional resolution we don't need yet.
+        const colorValue = format.color;
+        if (typeof colorValue === "string") {
+            const hex = colorValue.replace(/^#/, "").toUpperCase();
+            // Excel expects ARGB; default alpha = FF if a 6-digit hex.
+            const rgb = hex.length === 6 ? `FF${hex}` : hex;
+            if (/^[0-9A-F]{8}$/.test(rgb)) {
+                parts.push(`<color rgb="${rgb}"/>`);
+            }
+        }
+        else if (typeof colorValue === "object" && colorValue !== null) {
+            const c = colorValue;
+            if (typeof c.rgba === "string") {
+                const hex = c.rgba.replace(/^#/, "").toUpperCase();
+                const rgb = hex.length === 6 ? `FF${hex}` : hex;
+                if (/^[0-9A-F]{8}$/.test(rgb)) {
+                    parts.push(`<color rgb="${rgb}"/>`);
+                }
+            }
+            else if (typeof c.theme === "number") {
+                const tintAttr = typeof c.tint === "number" && c.tint !== 0
+                    ? ` tint="${c.tint}"`
+                    : "";
+                parts.push(`<color theme="${c.theme}"${tintAttr}/>`);
+            }
+        }
+    }
+    return parts.length ? `<rPr>${parts.join("")}</rPr>` : "";
+};
+/**
+ * Slice a value string into `<r>` blocks based on the run array. Runs
+ * are assumed non-overlapping and sorted; gaps between runs become
+ * unformatted `<r><t>...</t></r>` blocks (matching how Excel emits
+ * sequential plain segments). Newline characters survive verbatim in
+ * `<t>` — Excel honours them only when the cell carries the wrap
+ * style flag, but that's a cell-style concern, not a sharedString one.
+ */
+const buildRichTextRuns = (text, runs) => {
+    const sorted = [...runs].sort((a, b) => a.startIndex - b.startIndex);
+    const out = [];
+    let cursor = 0;
+    const emit = (segment, rPr) => {
+        if (!segment)
+            return;
+        const needsSpace = /^\s|\s$|[\r\n]/.test(segment);
+        const spaceAttr = needsSpace ? ' xml:space="preserve"' : "";
+        out.push(`<r>${rPr}<t${spaceAttr}>${escapeXmlText(segment)}</t></r>`);
+    };
+    for (const run of sorted) {
+        const start = Math.max(0, Math.min(text.length, run.startIndex));
+        const end = Math.max(start, Math.min(text.length, run.endIndex));
+        if (start > cursor) {
+            emit(text.slice(cursor, start), "");
+        }
+        if (start < end) {
+            if (run.nodeType === "mention") {
+                // Mentions don't carry inline formatting on the XLSX side —
+                // emit as plain text (their label is already inline in the value).
+                emit(text.slice(start, end), "");
+            }
+            else {
+                emit(text.slice(start, end), buildRichRunProperties(run.format));
+            }
+        }
+        if (end > cursor)
+            cursor = end;
+    }
+    if (cursor < text.length) {
+        emit(text.slice(cursor), "");
+    }
+    return out.join("");
+};
+const buildSharedStringsXml = (sharedStrings) => {
+    const entries = sharedStrings.entries
+        .map((entry) => {
+        if (entry.kind === "rich") {
+            return `<si>${buildRichTextRuns(entry.text, entry.runs)}</si>`;
+        }
+        const needsSpace = /^\s|\s$|[\r\n]/.test(entry.text);
+        const spaceAttr = needsSpace ? ' xml:space="preserve"' : "";
+        return `<si><t${spaceAttr}>${escapeXmlText(entry.text)}</t></si>`;
+    })
+        .join("");
+    return `${XML_DECLARATION}<sst xmlns="${WORKSHEET_NS}" count="${sharedStrings.totalCount}" uniqueCount="${sharedStrings.entries.length}">${entries}</sst>`;
+};
+const buildTableNameMap = (tables) => {
+    const map = new Map();
+    for (const table of tables) {
+        const tableTitle = table.title ?? table.name;
+        if (!tableTitle || tableTitle === table.name)
+            continue;
+        map.set(tableTitle, table.name);
+    }
+    return map;
+};
+// Excel rejects tables whose range starts at row/column 0 (1-indexed only) or
+// whose box intersects another table on the same sheet. Drop both before
+// emitting so the workbook opens without "We found a problem" recovery prompts.
+const filterExportableTables = (tables) => {
+    const isValidBox = (range) => {
+        if (!range)
+            return false;
+        const { startRowIndex, startColumnIndex, endRowIndex, endColumnIndex } = range;
+        if (typeof startRowIndex !== "number" ||
+            typeof startColumnIndex !== "number" ||
+            typeof endRowIndex !== "number" ||
+            typeof endColumnIndex !== "number") {
+            return false;
+        }
+        if (startRowIndex < 1 || startColumnIndex < 1)
+            return false;
+        if (endRowIndex < startRowIndex || endColumnIndex < startColumnIndex) {
+            return false;
+        }
+        return true;
+    };
+    const boxesIntersect = (a, b) => !(a.endRowIndex < b.startRowIndex ||
+        b.endRowIndex < a.startRowIndex ||
+        a.endColumnIndex < b.startColumnIndex ||
+        b.endColumnIndex < a.startColumnIndex);
+    const keptBySheet = new Map();
+    const result = [];
+    for (const table of tables) {
+        if (!isValidBox(table.range))
+            continue;
+        const sheetKept = keptBySheet.get(table.sheetId) ?? [];
+        if (sheetKept.some((r) => boxesIntersect(table.range, r)))
+            continue;
+        sheetKept.push(table.range);
+        keptBySheet.set(table.sheetId, sheetKept);
+        result.push(table);
+    }
+    return result;
+};
+const prepareTables = (tables) => {
+    const result = [];
+    tables.forEach((table, index) => {
+        const ref = gridRangeToRef(table.range);
+        if (!ref)
+            return;
+        const id = index + 1;
+        const sanitized = sanitizeTableName(table.title ?? `Table${id}`);
+        result.push({
+            ...table,
+            id,
+            ref,
+            path: `xl/tables/table${id}.xml`,
+            target: `../tables/table${id}.xml`,
+            name: sanitized,
+            displayName: sanitized,
+        });
+    });
+    return result;
+};
+const sanitizeTableName = (name) => {
+    const cleaned = name.replace(/[^A-Za-z0-9_]/g, "") || "Table";
+    if (/^\d/.test(cleaned)) {
+        return `T${cleaned}`;
+    }
+    return cleaned;
+};
+const buildTableXml = (table, rows, sourceSharedStrings, styleBuilder) => {
+    const rangeRef = table.ref;
+    const columnCount = Math.max(table.columns?.length ?? 0, (table.range.endColumnIndex ?? table.range.startColumnIndex) -
+        table.range.startColumnIndex +
+        1);
+    const headerRowCount = table.headerRow === false ? 0 : 1;
+    const totalsRowCount = table.totalRow ? 1 : 0;
+    const headerRowIndex = table.range.startRowIndex;
+    const columnNames = Array.from({ length: columnCount }, (_, index) => {
+        // Always read from cell data first - this is the source of truth for what Excel sees
+        if (headerRowCount > 0) {
+            const columnIndex = table.range.startColumnIndex + index;
+            const cell = rows[headerRowIndex]?.values?.[columnIndex];
+            // Check shared string first - this matches what gets written to the cell XML
+            const sharedStringIndex = cell?.ss;
+            if (sharedStringIndex != null && sourceSharedStrings) {
+                const raw = sourceSharedStrings.get(String(sharedStringIndex));
+                const sharedStringValue = typeof raw === "string"
+                    ? raw
+                    : raw && typeof raw === "object"
+                        ? raw.text
+                        : undefined;
+                if (sharedStringValue != null && sharedStringValue.trim() !== "") {
+                    return sharedStringValue;
+                }
+            }
+            // Try formattedValue first, then extract string from effectiveValue/userEnteredValue
+            const formattedValue = getCellFormattedValue(cell);
+            if (formattedValue != null && String(formattedValue).trim() !== "") {
+                return String(formattedValue);
+            }
+            const effectiveValue = getCellEffectiveValue(cell);
+            const effectiveString = getExtendedValueString(effectiveValue);
+            if (effectiveString != null && effectiveString.trim() !== "") {
+                return effectiveString;
+            }
+            const userEnteredValue = getCellUserEnteredValue(cell);
+            const userEnteredString = getExtendedValueString(userEnteredValue);
+            if (userEnteredString != null && userEnteredString.trim() !== "") {
+                return userEnteredString;
+            }
+        }
+        // Fallback to table.columns name or generic name
+        return table.columns?.[index]?.name ?? `Column${index + 1}`;
+    });
+    const tableColumns = `<tableColumns count="${columnCount}">${columnNames
+        .map((name, idx) => {
+        const columnFormula = table.columns?.[idx]?.formula;
+        const normalizedFormula = columnFormula
+            ? normalizeCalculatedColumnFormula(columnFormula, table)
+            : undefined;
+        const formulaXml = normalizedFormula
+            ? `<calculatedColumnFormula>${escapeXmlText(stripFormula(normalizedFormula))}</calculatedColumnFormula>`
+            : "";
+        return `<tableColumn id="${idx + 1}" name="${escapeXmlAttr(name)}">${formulaXml}</tableColumn>`;
+    })
+        .join("")}</tableColumns>`;
+    const isBuiltInStyle = table.theme && /^TableStyle(Light|Medium|Dark)\d+$/.test(table.theme);
+    const tableStyleName = isBuiltInStyle ? table.theme : "TableStyleMedium2";
+    const tableStyleInfo = `<tableStyleInfo name="${tableStyleName}" showFirstColumn="${table.showFirstColumn ? 1 : 0}" showLastColumn="${table.showLastColumn ? 1 : 0}" showRowStripes="${table.showRowStripes ? 1 : 0}" showColumnStripes="${table.showColumnStripes ? 1 : 0}"/>`;
+    const autoFilter = headerRowCount > 0 && table.filterButton !== false
+        ? (() => {
+            const filterColumns = buildFilterColumnsXml(table.filterSpecs ?? [], table.range, rows, table.headerRow ?? true, table.totalRow ?? false, styleBuilder);
+            return filterColumns
+                ? `<autoFilter ref="${rangeRef}">${filterColumns}</autoFilter>`
+                : `<autoFilter ref="${rangeRef}"/>`;
+        })()
+        : "";
+    return `${XML_DECLARATION}<table xmlns="${WORKSHEET_NS}" id="${table.id}" name="${escapeXmlAttr(table.name)}" displayName="${escapeXmlAttr(table.displayName)}" ref="${rangeRef}" totalsRowCount="${totalsRowCount}" headerRowCount="${headerRowCount}">${autoFilter}${tableColumns}${tableStyleInfo}</table>`;
+};
+const getFilterVisibleValues = (spec, range, rows, headerRow = true, totalRow = false) => {
+    const values = new Set();
+    const startRowIndex = range.startRowIndex + (headerRow ? 1 : 0);
+    const endRowIndex = range.endRowIndex - (totalRow ? 1 : 0);
+    const columnIndex = range.startColumnIndex + spec.columnIndex;
+    for (let rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++) {
+        const cell = rows[rowIndex]?.values?.[columnIndex];
+        const formattedValue = getCellFormattedValue(cell);
+        const fallbackValue = formattedValue ??
+            getCellEffectiveValue(cell) ??
+            getCellUserEnteredValue(cell);
+        if (isNil(fallbackValue) || fallbackValue === "") {
+            values.add(BLANK_LABEL);
+            continue;
+        }
+        values.add(String(fallbackValue));
+    }
+    return [...values];
+};
+const buildWorksheetAutoFilterXml = (sheet, rows, styleBuilder) => {
+    const basicFilter = sheet.basicFilter;
+    if (!basicFilter?.range)
+        return "";
+    const ref = cellRangeToAddress(undefined, basicFilter.range);
+    if (!ref)
+        return "";
+    const filterColumns = buildFilterColumnsXml(basicFilter.filterSpecs, basicFilter.range, rows, true, false, styleBuilder);
+    if (filterColumns) {
+        return `<autoFilter ref="${ref}">${filterColumns}</autoFilter>`;
+    }
+    return `<autoFilter ref="${ref}"/>`;
+};
+const buildSheetPropertiesXml = (sheet) => {
+    const tabColor = serializeColorXml(sheet.tabColor ?? undefined);
+    // <outlinePr> mirrors the sheet's `outlinePr` setting; both attrs
+    // default to true in Excel, so only emit when explicitly false. If
+    // the user only customised one half, the other half stays implicit.
+    const outlinePr = sheet.outlinePr;
+    const outlineAttrs = [];
+    if (outlinePr?.summaryBelow === false) {
+        outlineAttrs.push(`summaryBelow="0"`);
+    }
+    if (outlinePr?.summaryRight === false) {
+        outlineAttrs.push(`summaryRight="0"`);
+    }
+    const outlineXml = outlineAttrs.length
+        ? `<outlinePr ${outlineAttrs.join(" ")}/>`
+        : "";
+    if (!tabColor && !outlineXml)
+        return "";
+    const inner = `${tabColor ? `<tabColor ${tabColor}/>` : ""}${outlineXml}`;
+    return `<sheetPr>${inner}</sheetPr>`;
+};
+const buildFilterColumnsXml = (filterSpecs, range, rows, headerRow = true, totalRow = false, styleBuilder) => {
+    if (!filterSpecs?.length)
+        return "";
+    const entries = filterSpecs
+        .map((spec) => buildFilterColumnXml(spec, range, rows, headerRow, totalRow, styleBuilder))
+        .filter((entry) => Boolean(entry));
+    return entries.join("");
+};
+const buildFilterColumnXml = (spec, range, rows, headerRow = true, totalRow = false, styleBuilder) => {
+    const parts = [];
+    // <colorFilter dxfId="N" cellColor="1|0"/> — Excel matches against the
+    // dxf table. We register the color as a dxf and emit the resulting id.
+    const colorFilter = spec.filterCriteria?.colorFilter;
+    if (colorFilter && styleBuilder) {
+        const dxfId = colorFilter.mode === "cellColor"
+            ? styleBuilder.registerDifferentialFormat({
+                backgroundColor: colorFilter.color,
+            })
+            : styleBuilder.registerDifferentialFormat({
+                textFormat: { color: colorFilter.color },
+            });
+        if (typeof dxfId === "number") {
+            const cellColorAttr = colorFilter.mode === "cellColor" ? "1" : "0";
+            parts.push(`<colorFilter dxfId="${dxfId}" cellColor="${cellColorAttr}"/>`);
+        }
+    }
+    // <iconFilter iconSet="…" iconId="…"/>
+    const iconFilter = spec.filterCriteria?.iconFilter;
+    if (iconFilter?.iconSet) {
+        parts.push(`<iconFilter iconSet="${escapeXmlAttr(iconFilter.iconSet)}" iconId="${iconFilter.iconId ?? 0}"/>`);
+    }
+    // A condition filter (greater-than / contains / between / relative-date /
+    // above-average …) takes precedence over a value-list and is emitted as
+    // <customFilters> or <dynamicFilter>. Falls back to the value list when the
+    // condition has no AutoFilter representation.
+    const conditionXml = buildAutoFilterConditionXml(spec.filterCriteria?.condition);
+    if (conditionXml) {
+        parts.push(conditionXml);
+    }
+    else {
+        // <filters><filter val=…/></filters>
+        const values = spec.filterCriteria?.visibleValues ??
+            getFilterVisibleValues(spec, range, rows, headerRow, totalRow);
+        if (values?.length) {
+            const filters = values
+                .map((value) => `<filter val="${escapeXmlAttr(value)}"/>`)
+                .join("");
+            parts.push(`<filters>${filters}</filters>`);
+        }
+    }
+    if (!parts.length)
+        return "";
+    return `<filterColumn colId="${spec.columnIndex}">${parts.join("")}</filterColumn>`;
+};
+const gridRangeToRef = (range) => {
+    if (!range)
+        return undefined;
+    try {
+        const ref = cellRangeToAddress(undefined, range);
+        return ref ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const groupEmbedsBySheet = (embeds) => {
+    const result = new Map();
+    for (const embed of embeds ?? []) {
+        if (!embed.position?.overlayPosition)
+            continue;
+        if (embed.spec?.type !== "image")
+            continue;
+        const overlay = embed.position.overlayPosition;
+        const placement = {
+            kind: "embed",
+            imageUrl: embed.spec.imageUrl,
+            rowIndex: overlay.anchorCell.rowIndex,
+            columnIndex: overlay.anchorCell.columnIndex,
+            offsetX: overlay.offsetXPixels ?? 0,
+            offsetY: overlay.offsetYPixels ?? 0,
+            width: overlay.widthPixels ?? 120,
+            height: overlay.heightPixels ?? 120,
+        };
+        const list = result.get(embed.position.sheetId) ?? [];
+        list.push(placement);
+        result.set(embed.position.sheetId, list);
+    }
+    return result;
+};
+const groupTextBoxesBySheet = (embeds) => {
+    const result = new Map();
+    for (const embed of embeds ?? []) {
+        if (!embed.position?.overlayPosition)
+            continue;
+        if (embed.spec?.type !== "textbox")
+            continue;
+        const overlay = embed.position.overlayPosition;
+        const placement = {
+            textBox: embed,
+            rowIndex: overlay.anchorCell.rowIndex,
+            columnIndex: overlay.anchorCell.columnIndex,
+            offsetX: overlay.offsetXPixels ?? 0,
+            offsetY: overlay.offsetYPixels ?? 0,
+            width: overlay.widthPixels ?? 120,
+            height: overlay.heightPixels ?? 60,
+        };
+        const list = result.get(embed.position.sheetId) ?? [];
+        list.push(placement);
+        result.set(embed.position.sheetId, list);
+    }
+    return result;
+};
+const groupShapesBySheet = (embeds) => {
+    const result = new Map();
+    for (const embed of embeds ?? []) {
+        if (!embed.position?.overlayPosition)
+            continue;
+        if (embed.spec?.type !== "shape")
+            continue;
+        const overlay = embed.position.overlayPosition;
+        const placement = {
+            shape: embed,
+            rowIndex: overlay.anchorCell.rowIndex,
+            columnIndex: overlay.anchorCell.columnIndex,
+            offsetX: overlay.offsetXPixels ?? 0,
+            offsetY: overlay.offsetYPixels ?? 0,
+            width: overlay.widthPixels ?? 120,
+            height: overlay.heightPixels ?? 60,
+        };
+        const list = result.get(embed.position.sheetId) ?? [];
+        list.push(placement);
+        result.set(embed.position.sheetId, list);
+    }
+    return result;
+};
+const groupChartsBySheet = (charts) => {
+    const result = new Map();
+    for (const chart of charts ?? []) {
+        const overlay = chart.position?.overlayPosition;
+        if (!overlay)
+            continue;
+        const placement = {
+            chart,
+            rowIndex: overlay.anchorCell.rowIndex,
+            columnIndex: overlay.anchorCell.columnIndex,
+            offsetX: overlay.offsetXPixels ?? 0,
+            offsetY: overlay.offsetYPixels ?? 0,
+            width: overlay.widthPixels ?? 300,
+            height: overlay.heightPixels ?? 200,
+        };
+        const list = result.get(chart.position.sheetId) ?? [];
+        list.push(placement);
+        result.set(chart.position.sheetId, list);
+    }
+    return result;
+};
+const groupSlicersBySheet = (slicers) => {
+    const result = new Map();
+    for (const slicer of slicers ?? []) {
+        const overlay = slicer.position?.overlayPosition;
+        if (!overlay || typeof slicer.position !== "object")
+            continue;
+        const placement = {
+            slicer,
+            rowIndex: overlay.anchorCell.rowIndex,
+            columnIndex: overlay.anchorCell.columnIndex,
+            offsetX: overlay.offsetXPixels ?? 0,
+            offsetY: overlay.offsetYPixels ?? 0,
+            width: overlay.widthPixels ?? 200,
+            height: overlay.heightPixels ?? 200,
+        };
+        const list = result.get(slicer.position.sheetId) ?? [];
+        list.push(placement);
+        result.set(slicer.position.sheetId, list);
+    }
+    return result;
+};
+const buildConditionalFormattingXml = ({ conditionalFormats, sheetId, styleBuilder, }) => {
+    if (!conditionalFormats?.length) {
+        return "";
+    }
+    let priority = 1;
+    const orderedRules = conditionalFormats
+        .map((rule, index) => ({ rule, index }))
+        .sort((left, right) => {
+        const leftPriority = left.rule.priority;
+        const rightPriority = right.rule.priority;
+        if (leftPriority == null && rightPriority == null) {
+            return left.index - right.index;
+        }
+        if (leftPriority == null) {
+            return 1;
+        }
+        if (rightPriority == null) {
+            return -1;
+        }
+        if (leftPriority === rightPriority) {
+            return left.index - right.index;
+        }
+        return leftPriority - rightPriority;
+    })
+        .map(({ rule }) => rule);
+    const parts = [];
+    for (const rule of orderedRules) {
+        if (rule.enabled === false)
+            continue;
+        const ranges = (rule.ranges ?? []).filter((range) => range.sheetId === sheetId);
+        const sqrefParts = ranges
+            .map((range) => cellRangeToAddress(undefined, range))
+            .filter((ref) => Boolean(ref));
+        if (!sqrefParts.length)
+            continue;
+        const baseCellAddress = ranges.length
+            ? cellToAddress({
+                rowIndex: ranges[0].startRowIndex,
+                columnIndex: ranges[0].startColumnIndex,
+            }) ?? undefined
+            : undefined;
+        const basePriority = rule.priority ?? priority;
+        const cfRulesXml = buildConditionalFormattingRuleXml({
+            rule,
+            styleBuilder,
+            priority: basePriority,
+            baseCellAddress,
+        });
+        if (!cfRulesXml?.length)
+            continue;
+        const ruleXmlEntries = Array.isArray(cfRulesXml)
+            ? cfRulesXml
+            : [cfRulesXml];
+        priority = Math.max(priority, basePriority + ruleXmlEntries.length);
+        parts.push(`<conditionalFormatting sqref="${sqrefParts.join(" ")}">${ruleXmlEntries.join("")}</conditionalFormatting>`);
+    }
+    return parts.join("");
+};
+// Lazy-loaded XMLBuilder for re-serializing opaque cfRule subtrees
+// (colorScale/dataBar/iconSet) captured from the source xlsx during import.
+let _cfChildBuilder = null;
+const getCfChildBuilder = () => {
+    if (_cfChildBuilder)
+        return _cfChildBuilder;
+    // Defer the require so this module stays tree-shakeable when the cf
+    // passthrough path isn't exercised.
+    const { XMLBuilder } = require("fast-xml-parser");
+    _cfChildBuilder = new XMLBuilder({
+        ignoreAttributes: false,
+        attributesGroupName: "a$",
+        textNodeName: "t$",
+        suppressEmptyNode: true,
+        format: false,
+    });
+    return _cfChildBuilder;
+};
+const buildXlsxSourceCfRuleXml = (rule, styleBuilder, priority) => {
+    // Round-trip path for imported rules: build the cfRule XML directly from
+    // the verbatim source attrs/formulas in `xlsxSource`. Preserves the
+    // original cfRule type, operator, formula text, and `text`/`timePeriod`/
+    // `rank`/`percent`/`aboveAverage`/etc. attributes that the synthesizer
+    // would otherwise drop or rewrite.
+    const src = rule.xlsxSource;
+    if (!src?.type)
+        return undefined;
+    // Format → dxfId via the existing CellFormat path. We pull the format from
+    // whichever rule shape currently holds it (booleanRule/topBottomRule/
+    // distinctRule) — the import always populates one of these alongside
+    // xlsxSource for non-colorScale rules, so we get a faithful dxfId.
+    const format = rule.booleanRule?.format ??
+        rule.topBottomRule?.format ??
+        rule.distinctRule?.format;
+    const dxfId = format !== undefined
+        ? styleBuilder.registerDifferentialFormat(format)
+        : undefined;
+    const stopIfTrueAttr = rule.stopIfTrue ? ' stopIfTrue="1"' : "";
+    const attrs = [`type="${src.type}"`];
+    if (dxfId != null) {
+        attrs.push(`dxfId="${dxfId}"`);
+    }
+    attrs.push(`priority="${priority}"`);
+    if (src.operator) {
+        attrs.push(`operator="${src.operator}"`);
+    }
+    if (src.text !== undefined) {
+        attrs.push(`text="${escapeXmlAttr(src.text)}"`);
+    }
+    if (src.timePeriod) {
+        attrs.push(`timePeriod="${src.timePeriod}"`);
+    }
+    if (typeof src.rank === "number") {
+        attrs.push(`rank="${src.rank}"`);
+    }
+    if (src.percent) {
+        attrs.push(`percent="1"`);
+    }
+    if (src.bottom) {
+        attrs.push(`bottom="1"`);
+    }
+    if (src.aboveAverage === false) {
+        attrs.push(`aboveAverage="0"`);
+    }
+    if (src.equalAverage) {
+        attrs.push(`equalAverage="1"`);
+    }
+    if (typeof src.stdDev === "number") {
+        attrs.push(`stdDev="${src.stdDev}"`);
+    }
+    if (rule.stopIfTrue) {
+        // already added via stopIfTrueAttr below — placeholder kept to mirror
+        // intent if attr ordering changes
+    }
+    const formulasXml = src.formulas
+        ?.map((f) => `<formula>${escapeXmlText(f)}</formula>`)
+        .join("") ?? "";
+    // Re-emit any opaque child subtrees (colorScale/dataBar/iconSet) captured
+    // verbatim during import. These elements have rich structure (cfvo stops,
+    // colors, value thresholds, icon set IDs) that the high-level model
+    // can't fully represent — the only way to round-trip them losslessly is
+    // to serialize the parsed XML back as-is.
+    const builder = src.colorScale || src.dataBar || src.iconSet
+        ? getCfChildBuilder()
+        : null;
+    const childXmlParts = [];
+    if (src.colorScale && builder) {
+        childXmlParts.push(builder.build({ colorScale: src.colorScale }));
+    }
+    if (src.dataBar && builder) {
+        childXmlParts.push(builder.build({ dataBar: src.dataBar }));
+    }
+    if (src.iconSet && builder) {
+        childXmlParts.push(builder.build({ iconSet: src.iconSet }));
+    }
+    return `<cfRule ${attrs.join(" ")}${stopIfTrueAttr}>${formulasXml}${childXmlParts.join("")}</cfRule>`;
+};
+const buildConditionalFormattingRuleXml = ({ rule, styleBuilder, priority, baseCellAddress, }) => {
+    // Round-trip via xlsxSource when present (imported rules). Falls through
+    // to synthesizer for rules without source metadata (UI-created).
+    if (rule.xlsxSource?.type) {
+        const xml = buildXlsxSourceCfRuleXml(rule, styleBuilder, priority);
+        if (xml)
+            return xml;
+    }
+    const rules = [];
+    const baseCell = baseCellAddress ?? undefined;
+    const stopIfTrueAttr = rule.stopIfTrue ? ' stopIfTrue="1"' : "";
+    const escapeFormulaText = (value) => value.replace(/"/g, '""');
+    const buildCellIsRule = (dxfId, operator, formula1, formula2) => {
+        const parts = [
+            `<cfRule type="cellIs" operator="${operator}" dxfId="${dxfId}" priority="${priority + rules.length}"${stopIfTrueAttr}>`,
+            `<formula>${escapeXmlText(formula1)}</formula>`,
+        ];
+        if (formula2) {
+            parts.push(`<formula>${escapeXmlText(formula2)}</formula>`);
+        }
+        parts.push(`</cfRule>`);
+        return parts.join("");
+    };
+    const buildExpressionRule = (dxfId, formula) => `<cfRule type="expression" dxfId="${dxfId}" priority="${priority + rules.length}"${stopIfTrueAttr}><formula>${escapeXmlText(formula)}</formula></cfRule>`;
+    const buildBooleanRuleXml = () => {
+        const booleanRule = rule.booleanRule;
+        if (!booleanRule?.condition?.type) {
+            return undefined;
+        }
+        const dxfId = styleBuilder.registerDifferentialFormat(booleanRule.format);
+        if (dxfId == null)
+            return undefined;
+        const { condition } = booleanRule;
+        const values = condition.values ?? [];
+        if (condition.type === "CUSTOM_FORMULA") {
+            const formula = condition.values?.[0]?.userEnteredValue ?? booleanRule.formula;
+            if (!formula)
+                return undefined;
+            const cleanedFormula = stripFormula(formula);
+            return buildExpressionRule(dxfId, cleanedFormula);
+        }
+        if (condition.type === "NUMBER_ABOVE_AVERAGE" ||
+            condition.type === "NUMBER_BELOW_AVERAGE") {
+            const attrs = [
+                `type="aboveAverage"`,
+                `dxfId="${dxfId}"`,
+                `priority="${priority + rules.length}"`,
+            ];
+            if (rule.stopIfTrue) {
+                attrs.push(`stopIfTrue="1"`);
+            }
+            if (condition.type === "NUMBER_BELOW_AVERAGE") {
+                attrs.push(`aboveAverage="0"`);
+            }
+            return `<cfRule ${attrs.join(" ")}/>`;
+        }
+        if (condition.type === "ERROR" || condition.type === "NOT_ERROR") {
+            const type = condition.type === "ERROR" ? "containsErrors" : "notContainsErrors";
+            return `<cfRule type="${type}" dxfId="${dxfId}" priority="${priority + rules.length}"${stopIfTrueAttr}/>`;
+        }
+        if (condition.type === "DATE_TODAY" ||
+            condition.type === "DATE_YESTERDAY" ||
+            condition.type === "DATE_TOMORROW" ||
+            condition.type === "DATE_LAST_7_DAYS" ||
+            condition.type === "DATE_LAST_WEEK" ||
+            condition.type === "DATE_THIS_WEEK" ||
+            condition.type === "DATE_NEXT_WEEK" ||
+            condition.type === "DATE_LAST_MONTH" ||
+            condition.type === "DATE_THIS_MONTH" ||
+            condition.type === "DATE_NEXT_MONTH") {
+            if (!baseCell)
+                return undefined;
+            const timePeriodMap = {
+                DATE_TODAY: "today",
+                DATE_YESTERDAY: "yesterday",
+                DATE_TOMORROW: "tomorrow",
+                DATE_LAST_7_DAYS: "last7Days",
+                DATE_LAST_WEEK: "lastWeek",
+                DATE_THIS_WEEK: "thisWeek",
+                DATE_NEXT_WEEK: "nextWeek",
+                DATE_LAST_MONTH: "lastMonth",
+                DATE_THIS_MONTH: "thisMonth",
+                DATE_NEXT_MONTH: "nextMonth",
+            };
+            const normalizedCell = `INT(${baseCell})`;
+            const weekStart = "TODAY()-WEEKDAY(TODAY(),2)+1";
+            const periodFormulaMap = {
+                DATE_TODAY: `${normalizedCell}=TODAY()`,
+                DATE_YESTERDAY: `${normalizedCell}=TODAY()-1`,
+                DATE_TOMORROW: `${normalizedCell}=TODAY()+1`,
+                DATE_LAST_7_DAYS: `AND(${normalizedCell}>=TODAY()-6,${normalizedCell}<=TODAY())`,
+                DATE_THIS_WEEK: `AND(${normalizedCell}>=${weekStart},${normalizedCell}<=${weekStart}+6)`,
+                DATE_LAST_WEEK: `AND(${normalizedCell}>=${weekStart}-7,${normalizedCell}<=${weekStart}-1)`,
+                DATE_NEXT_WEEK: `AND(${normalizedCell}>=${weekStart}+7,${normalizedCell}<=${weekStart}+13)`,
+                DATE_THIS_MONTH: `AND(${normalizedCell}>=EOMONTH(TODAY(),-1)+1,${normalizedCell}<=EOMONTH(TODAY(),0))`,
+                DATE_LAST_MONTH: `AND(${normalizedCell}>=EOMONTH(TODAY(),-2)+1,${normalizedCell}<=EOMONTH(TODAY(),-1))`,
+                DATE_NEXT_MONTH: `AND(${normalizedCell}>=EOMONTH(TODAY(),0)+1,${normalizedCell}<=EOMONTH(TODAY(),1))`,
+            };
+            const timePeriod = timePeriodMap[condition.type];
+            const periodFormula = periodFormulaMap[condition.type];
+            if (!timePeriod || !periodFormula)
+                return undefined;
+            return `<cfRule type="timePeriod" timePeriod="${timePeriod}" dxfId="${dxfId}" priority="${priority + rules.length}"${stopIfTrueAttr}><formula>${escapeXmlText(periodFormula)}</formula></cfRule>`;
+        }
+        if (condition.type === "TEXT_EQ" || condition.type === "TEXT_NOT_EQ") {
+            const raw = values[0]?.userEnteredValue ?? "";
+            if (!raw)
+                return undefined;
+            const op = condition.type === "TEXT_EQ" ? "equal" : "notEqual";
+            const text = `"${escapeFormulaText(raw)}"`;
+            return buildCellIsRule(dxfId, op, text);
+        }
+        if (condition.type === "NUMBER_BETWEEN" ||
+            condition.type === "NUMBER_NOT_BETWEEN" ||
+            condition.type === "NUMBER_EQ" ||
+            condition.type === "NUMBER_NOT_EQ" ||
+            condition.type === "NUMBER_GREATER" ||
+            condition.type === "NUMBER_GREATER_THAN_EQ" ||
+            condition.type === "NUMBER_LESS" ||
+            condition.type === "NUMBER_LESS_THAN_EQ") {
+            const firstRaw = values[0]?.userEnteredValue ?? "";
+            if (!firstRaw)
+                return undefined;
+            const secondRaw = values[1]?.userEnteredValue ?? "";
+            const operatorMap = {
+                NUMBER_BETWEEN: "between",
+                NUMBER_NOT_BETWEEN: "notBetween",
+                NUMBER_EQ: "equal",
+                NUMBER_NOT_EQ: "notEqual",
+                NUMBER_GREATER: "greaterThan",
+                NUMBER_GREATER_THAN_EQ: "greaterThanOrEqual",
+                NUMBER_LESS: "lessThan",
+                NUMBER_LESS_THAN_EQ: "lessThanOrEqual",
+            };
+            const operator = operatorMap[condition.type];
+            const first = stripFormula(firstRaw);
+            const second = stripFormula(secondRaw);
+            if ((operator === "between" || operator === "notBetween") && !secondRaw) {
+                return undefined;
+            }
+            return buildCellIsRule(dxfId, operator, first, operator === "between" || operator === "notBetween"
+                ? second
+                : undefined);
+        }
+        if (condition.type === "DATE_EQ" ||
+            condition.type === "DATE_NOT_EQ" ||
+            condition.type === "DATE_BEFORE" ||
+            condition.type === "DATE_AFTER" ||
+            condition.type === "DATE_ON_OR_BEFORE" ||
+            condition.type === "DATE_ON_OR_AFTER" ||
+            condition.type === "DATE_BETWEEN" ||
+            condition.type === "DATE_NOT_BETWEEN") {
+            const firstRaw = values[0]?.userEnteredValue ?? "";
+            if (!firstRaw)
+                return undefined;
+            const secondRaw = values[1]?.userEnteredValue ?? "";
+            const operatorMap = {
+                DATE_EQ: "equal",
+                DATE_NOT_EQ: "notEqual",
+                DATE_BEFORE: "lessThan",
+                DATE_AFTER: "greaterThan",
+                DATE_ON_OR_BEFORE: "lessThanOrEqual",
+                DATE_ON_OR_AFTER: "greaterThanOrEqual",
+                DATE_BETWEEN: "between",
+                DATE_NOT_BETWEEN: "notBetween",
+            };
+            const normalizeDateValue = (raw) => {
+                const trimmed = raw.trim();
+                if (!trimmed)
+                    return "";
+                if (trimmed.startsWith("=")) {
+                    return stripFormula(trimmed);
+                }
+                if (!isNaN(Number(trimmed))) {
+                    return trimmed;
+                }
+                return `DATEVALUE("${escapeFormulaText(trimmed)}")`;
+            };
+            const first = normalizeDateValue(firstRaw);
+            const second = normalizeDateValue(secondRaw);
+            const operator = operatorMap[condition.type];
+            if ((operator === "between" || operator === "notBetween") && !secondRaw) {
+                return undefined;
+            }
+            return buildCellIsRule(dxfId, operator, first, operator === "between" || operator === "notBetween"
+                ? second
+                : undefined);
+        }
+        if (!baseCell)
+            return undefined;
+        const buildExpressionFormula = () => {
+            const raw = values[0]?.userEnteredValue ?? "";
+            const text = raw ? `"${escapeFormulaText(raw)}"` : '""';
+            switch (condition.type) {
+                case "TEXT_CONTAINS":
+                    return raw ? `ISNUMBER(SEARCH(${text},${baseCell}))` : undefined;
+                case "TEXT_NOT_CONTAINS":
+                    return raw ? `ISERROR(SEARCH(${text},${baseCell}))` : undefined;
+                case "TEXT_STARTS_WITH":
+                    return raw ? `LEFT(${baseCell},LEN(${text}))=${text}` : undefined;
+                case "TEXT_ENDS_WITH":
+                    return raw ? `RIGHT(${baseCell},LEN(${text}))=${text}` : undefined;
+                case "TEXT_IS_EMAIL":
+                    return `AND(ISNUMBER(SEARCH("@",${baseCell})),ISNUMBER(SEARCH(".",${baseCell})))`;
+                case "TEXT_IS_URL":
+                    return `OR(LEFT(${baseCell},7)="http://",LEFT(${baseCell},8)="https://")`;
+                case "BLANK":
+                    return `${baseCell}=""`;
+                case "NOT_BLANK":
+                    return `${baseCell}<>""`;
+                case "BOOLEAN":
+                    return `OR(${baseCell}=TRUE,${baseCell}=FALSE)`;
+                case "DATE_IS_VALID":
+                    return `ISNUMBER(${baseCell})`;
+                case "NUMBER_GREATER_THAN_PREVIOUS":
+                    return `IFERROR(${baseCell}>INDIRECT("R[-1]C",FALSE),TRUE)`;
+                case "NUMBER_GREATER_THAN_EQ_PREVIOUS":
+                    return `IFERROR(${baseCell}>=INDIRECT("R[-1]C",FALSE),TRUE)`;
+                case "NUMBER_LESS_THAN_PREVIOUS":
+                    return `IFERROR(${baseCell}<INDIRECT("R[-1]C",FALSE),TRUE)`;
+                case "NUMBER_LESS_THAN_EQ_PREVIOUS":
+                    return `IFERROR(${baseCell}<=INDIRECT("R[-1]C",FALSE),TRUE)`;
+                case "ONE_OF_LIST": {
+                    const entries = values
+                        .map((value) => value.userEnteredValue)
+                        .filter((value) => typeof value === "string");
+                    if (!entries.length)
+                        return undefined;
+                    const conditions = entries.map((entry) => {
+                        if (entry.startsWith("=")) {
+                            return `${baseCell}=${stripFormula(entry)}`;
+                        }
+                        if (!isNaN(Number(entry))) {
+                            return `${baseCell}=${entry}`;
+                        }
+                        return `${baseCell}="${escapeFormulaText(entry)}"`;
+                    });
+                    return `OR(${conditions.join(",")})`;
+                }
+                case "ONE_OF_RANGE": {
+                    const rangeRef = values[0]?.userEnteredValue ?? "";
+                    if (!rangeRef)
+                        return undefined;
+                    return `COUNTIF(${stripFormula(rangeRef)},${baseCell})>0`;
+                }
+                default:
+                    return undefined;
+            }
+        };
+        const expression = buildExpressionFormula();
+        return expression ? buildExpressionRule(dxfId, expression) : undefined;
+    };
+    const buildGradientRuleXml = () => {
+        const gradientRule = rule.gradientRule;
+        if (!gradientRule)
+            return undefined;
+        const points = [
+            gradientRule.minpoint,
+            gradientRule.midpoint,
+            gradientRule.maxpoint,
+        ].filter(Boolean);
+        if (!points.length)
+            return undefined;
+        const typeMap = {
+            MIN: "min",
+            MAX: "max",
+            NUMBER: "num",
+            PERCENT: "percent",
+            PERCENTILE: "percentile",
+        };
+        const cfvos = [];
+        const colors = [];
+        points.forEach((point) => {
+            if (!point?.type || !point.color)
+                return;
+            const type = typeMap[String(point.type).toUpperCase()] ?? "num";
+            const valueAttr = point.value !== undefined && point.value !== null
+                ? ` val="${escapeXmlAttr(String(point.value))}"`
+                : "";
+            cfvos.push(`<cfvo type="${type}"${valueAttr}/>`);
+            const colorAttr = serializeColorXml(point.color);
+            if (colorAttr) {
+                colors.push(`<color ${colorAttr}/>`);
+            }
+        });
+        if (!cfvos.length || !colors.length)
+            return undefined;
+        return `<cfRule type="colorScale" priority="${priority + rules.length}"><colorScale>${cfvos.join("")}${colors.join("")}</colorScale></cfRule>`;
+    };
+    const buildTopBottomRuleXml = () => {
+        const topBottomRule = rule.topBottomRule;
+        if (!topBottomRule)
+            return undefined;
+        const dxfId = styleBuilder.registerDifferentialFormat(topBottomRule.format);
+        if (dxfId == null)
+            return undefined;
+        const rank = Number.isFinite(topBottomRule.rank)
+            ? Math.max(1, topBottomRule.rank)
+            : 10;
+        const attrs = [
+            `type="top10"`,
+            `dxfId="${dxfId}"`,
+            `priority="${priority + rules.length}"`,
+            `rank="${rank}"`,
+        ];
+        if (rule.stopIfTrue) {
+            attrs.push(`stopIfTrue="1"`);
+        }
+        if (topBottomRule.isPercent) {
+            attrs.push(`percent="1"`);
+        }
+        if (topBottomRule.type === "BOTTOM") {
+            attrs.push(`bottom="1"`);
+        }
+        return `<cfRule ${attrs.join(" ")}/>`;
+    };
+    const buildDistinctRuleXml = () => {
+        const distinctRule = rule.distinctRule;
+        if (!distinctRule)
+            return undefined;
+        const dxfId = styleBuilder.registerDifferentialFormat(distinctRule.format);
+        if (dxfId == null)
+            return undefined;
+        const type = distinctRule.type === "UNIQUE" ? "uniqueValues" : "duplicateValues";
+        return `<cfRule type="${type}" dxfId="${dxfId}" priority="${priority + rules.length}"${stopIfTrueAttr}/>`;
+    };
+    const cfThresholdTypeMap = {
+        MIN: "min",
+        MAX: "max",
+        NUMBER: "num",
+        PERCENT: "percent",
+        PERCENTILE: "percentile",
+        FORMULA: "formula",
+    };
+    const buildCfvo = (t) => {
+        if (!t?.type)
+            return "";
+        const type = cfThresholdTypeMap[String(t.type).toUpperCase()] ?? "num";
+        const valueAttr = t.value !== undefined && t.value !== null
+            ? ` val="${escapeXmlAttr(String(t.value))}"`
+            : "";
+        return `<cfvo type="${type}"${valueAttr}/>`;
+    };
+    const buildIconSetRuleXml = () => {
+        const iconSetRule = rule.iconSetRule;
+        if (!iconSetRule)
+            return undefined;
+        // OOXML expects (iconCount) cfvos with a leading 0% min stop. Our engine
+        // model keeps only the (iconCount - 1) user-meaningful thresholds, so we
+        // prepend a synthetic 0% cfvo on export.
+        const cfvos = [
+            `<cfvo type="percent" val="0"/>`,
+            ...iconSetRule.thresholds.map(buildCfvo),
+        ].join("");
+        const attrs = [
+            `iconSet="${iconSetRule.iconSet}"`,
+            ...(iconSetRule.reverse ? [`reverse="1"`] : []),
+            ...(iconSetRule.showValue === false ? [`showValue="0"`] : []),
+        ];
+        return `<cfRule type="iconSet" priority="${priority + rules.length}"${stopIfTrueAttr}><iconSet ${attrs.join(" ")}>${cfvos}</iconSet></cfRule>`;
+    };
+    const buildDataBarRuleXml = () => {
+        const dataBarRule = rule.dataBarRule;
+        if (!dataBarRule)
+            return undefined;
+        const cfvos = buildCfvo(dataBarRule.minpoint) + buildCfvo(dataBarRule.maxpoint);
+        const colorAttr = serializeColorXml(dataBarRule.color);
+        if (!colorAttr)
+            return undefined;
+        const showValueAttr = dataBarRule.showValue === false ? ` showValue="0"` : "";
+        return `<cfRule type="dataBar" priority="${priority + rules.length}"${stopIfTrueAttr}><dataBar${showValueAttr}>${cfvos}<color ${colorAttr}/></dataBar></cfRule>`;
+    };
+    const booleanXml = buildBooleanRuleXml();
+    if (booleanXml)
+        rules.push(booleanXml);
+    const gradientXml = buildGradientRuleXml();
+    if (gradientXml)
+        rules.push(gradientXml);
+    const topBottomXml = buildTopBottomRuleXml();
+    if (topBottomXml)
+        rules.push(topBottomXml);
+    const distinctXml = buildDistinctRuleXml();
+    if (distinctXml)
+        rules.push(distinctXml);
+    const iconSetXml = buildIconSetRuleXml();
+    if (iconSetXml)
+        rules.push(iconSetXml);
+    const dataBarXml = buildDataBarRuleXml();
+    if (dataBarXml)
+        rules.push(dataBarXml);
+    return rules.length ? rules : undefined;
+};
+const buildDrawingParts = async ({ placements, textBoxes, shapes = [], startImageIndex, startChartIndex, charts, slicers, sheet, sheetNameById, }) => {
+    if (!placements.length &&
+        !textBoxes.length &&
+        !shapes.length &&
+        !charts.length &&
+        !slicers.length)
+        return null;
+    const anchors = [];
+    const relationships = new RelationshipsBuilder();
+    const media = [];
+    let imageIndex = startImageIndex;
+    let chartIndex = startChartIndex;
+    let pictureId = 1;
+    let frameId = 1;
+    const chartEntries = [];
+    for (const placement of charts) {
+        const chartXml = buildChartXml(placement.chart, sheetNameById);
+        if (!chartXml)
+            continue;
+        const relId = relationships.add(CHART_REL_TYPE, `../charts/chart${chartIndex}.xml`);
+        anchors.push(createChartAnchor({
+            sheet,
+            placement,
+            relId,
+            frameId,
+        }));
+        chartEntries.push({
+            path: `xl/charts/chart${chartIndex}.xml`,
+            xml: chartXml,
+        });
+        chartIndex += 1;
+        frameId += 1;
+    }
+    for (const placement of slicers) {
+        anchors.push(createSlicerAnchor({
+            sheet,
+            placement,
+            frameId,
+        }));
+        frameId += 1;
+    }
+    for (const placement of textBoxes) {
+        anchors.push(createTextBoxAnchor({
+            sheet,
+            placement,
+            frameId,
+        }));
+        frameId += 1;
+    }
+    for (const placement of shapes) {
+        anchors.push(createShapeAnchor({
+            sheet,
+            placement,
+            frameId,
+        }));
+        frameId += 1;
+    }
+    for (const placement of placements) {
+        const dataUrl = await resolveImageDataUrl(placement.imageUrl);
+        if (!dataUrl)
+            continue;
+        const buffer = dataUriToBuffer(dataUrl, placement.imageUrl);
+        if (!buffer)
+            continue;
+        const mediaPath = `xl/media/image${imageIndex}.${buffer.extension}`;
+        media.push({
+            path: mediaPath,
+            data: buffer.data,
+            extension: buffer.extension,
+        });
+        const relId = relationships.add(IMAGE_REL_TYPE, `../media/image${imageIndex}.${buffer.extension}`);
+        anchors.push(createTwoCellAnchor({
+            sheet,
+            placement,
+            relId,
+            pictureId,
+        }));
+        imageIndex += 1;
+        pictureId += 1;
+    }
+    const drawingXml = `${XML_DECLARATION}<xdr:wsDr xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="${REL_NS}">${anchors.join("")}</xdr:wsDr>`;
+    return {
+        xml: drawingXml,
+        relsXml: relationships.toXml(),
+        media,
+        charts: chartEntries,
+        nextImageIndex: imageIndex,
+        nextChartIndex: chartIndex,
+    };
+};
+const createTwoCellAnchor = ({ placement, relId, pictureId, sheet, }) => {
+    const fromRow = Math.max(0, placement.rowIndex - 1);
+    const fromColumn = Math.max(0, placement.columnIndex - 1);
+    const offsetX = Math.max(0, placement.offsetX ?? 0);
+    const offsetY = Math.max(0, placement.offsetY ?? 0);
+    const defaultWidth = placement.kind === "cell" ? getColumnWidthPx(sheet, fromColumn) : 120;
+    const defaultHeight = placement.kind === "cell" ? getRowHeightPx(sheet, fromRow) : 120;
+    const widthPx = Math.max(5, placement.width ?? defaultWidth);
+    const heightPx = Math.max(5, placement.height ?? defaultHeight);
+    const toColumn = resolveAnchorEndpoint({
+        startIndex: fromColumn,
+        startOffset: offsetX,
+        span: widthPx,
+        getSize: (index) => getColumnWidthPx(sheet, index, true),
+    });
+    const toRow = resolveAnchorEndpoint({
+        startIndex: fromRow,
+        startOffset: offsetY,
+        span: heightPx,
+        getSize: (index) => getRowHeightPx(sheet, index, true),
+    });
+    const fromXml = `<xdr:from><xdr:col>${fromColumn}</xdr:col><xdr:colOff>${Math.round(offsetX * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${fromRow}</xdr:row><xdr:rowOff>${Math.round(offsetY * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:from>`;
+    const toXml = `<xdr:to><xdr:col>${toColumn.index}</xdr:col><xdr:colOff>${Math.round(toColumn.offset * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${toRow.index}</xdr:row><xdr:rowOff>${Math.round(toRow.offset * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:to>`;
+    return `<xdr:twoCellAnchor editAs="oneCell">${fromXml}${toXml}<xdr:pic><xdr:nvPicPr><xdr:cNvPr id="${pictureId}" name="Picture ${pictureId}"/><xdr:cNvPicPr/></xdr:nvPicPr><xdr:blipFill><a:blip r:embed="${relId}"/><a:stretch><a:fillRect/></a:stretch></xdr:blipFill><xdr:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${Math.round(widthPx * EMUS_PER_PIXEL)}" cy="${Math.round(heightPx * EMUS_PER_PIXEL)}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></xdr:spPr></xdr:pic><xdr:clientData/></xdr:twoCellAnchor>`;
+};
+const createChartAnchor = ({ placement, relId, frameId, sheet, }) => {
+    const fromRow = Math.max(0, placement.rowIndex - 1);
+    const fromColumn = Math.max(0, placement.columnIndex - 1);
+    const offsetX = Math.max(0, placement.offsetX ?? 0);
+    const offsetY = Math.max(0, placement.offsetY ?? 0);
+    const widthPx = Math.max(5, placement.width ?? 300);
+    const heightPx = Math.max(5, placement.height ?? 200);
+    const toColumn = resolveAnchorEndpoint({
+        startIndex: fromColumn,
+        startOffset: offsetX,
+        span: widthPx,
+        getSize: (index) => getColumnWidthPx(sheet, index, true),
+    });
+    const toRow = resolveAnchorEndpoint({
+        startIndex: fromRow,
+        startOffset: offsetY,
+        span: heightPx,
+        getSize: (index) => getRowHeightPx(sheet, index, true),
+    });
+    const fromXml = `<xdr:from><xdr:col>${fromColumn}</xdr:col><xdr:colOff>${Math.round(offsetX * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${fromRow}</xdr:row><xdr:rowOff>${Math.round(offsetY * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:from>`;
+    const toXml = `<xdr:to><xdr:col>${toColumn.index}</xdr:col><xdr:colOff>${Math.round(toColumn.offset * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${toRow.index}</xdr:row><xdr:rowOff>${Math.round(toRow.offset * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:to>`;
+    return `<xdr:twoCellAnchor>${fromXml}${toXml}<xdr:graphicFrame><xdr:nvGraphicFramePr><xdr:cNvPr id="${frameId}" name="Chart ${frameId}"/><xdr:cNvGraphicFramePr/></xdr:nvGraphicFramePr><xdr:xfrm><a:off x="0" y="0"/><a:ext cx="${Math.round(widthPx * EMUS_PER_PIXEL)}" cy="${Math.round(heightPx * EMUS_PER_PIXEL)}"/></xdr:xfrm><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:r="${REL_NS}" r:id="${relId}"/></a:graphicData></a:graphic></xdr:graphicFrame><xdr:clientData/></xdr:twoCellAnchor>`;
+};
+const createSlicerAnchor = ({ placement, frameId, sheet, }) => {
+    const fromRow = Math.max(0, placement.rowIndex - 1);
+    const fromColumn = Math.max(0, placement.columnIndex - 1);
+    const offsetX = Math.max(0, placement.offsetX ?? 0);
+    const offsetY = Math.max(0, placement.offsetY ?? 0);
+    const widthPx = Math.max(50, placement.width ?? 200);
+    const heightPx = Math.max(50, placement.height ?? 200);
+    const toColumn = resolveAnchorEndpoint({
+        startIndex: fromColumn,
+        startOffset: offsetX,
+        span: widthPx,
+        getSize: (index) => getColumnWidthPx(sheet, index, true),
+    });
+    const toRow = resolveAnchorEndpoint({
+        startIndex: fromRow,
+        startOffset: offsetY,
+        span: heightPx,
+        getSize: (index) => getRowHeightPx(sheet, index, true),
+    });
+    const fromXml = `<xdr:from><xdr:col>${fromColumn}</xdr:col><xdr:colOff>${Math.round(offsetX * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${fromRow}</xdr:row><xdr:rowOff>${Math.round(offsetY * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:from>`;
+    const toXml = `<xdr:to><xdr:col>${toColumn.index}</xdr:col><xdr:colOff>${Math.round(toColumn.offset * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${toRow.index}</xdr:row><xdr:rowOff>${Math.round(toRow.offset * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:to>`;
+    return `<xdr:twoCellAnchor editAs="absolute">${fromXml}${toXml}<mc:AlternateContent xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"><mc:Choice xmlns:sle15="http://schemas.microsoft.com/office/drawing/2012/slicer" Requires="sle15"><xdr:graphicFrame macro=""><xdr:nvGraphicFramePr><xdr:cNvPr id="${frameId}" name="${escapeXmlAttr(placement.title)}"/><xdr:cNvGraphicFramePr/></xdr:nvGraphicFramePr><xdr:xfrm><a:off x="0" y="0"/><a:ext cx="${Math.round(widthPx * EMUS_PER_PIXEL)}" cy="${Math.round(heightPx * EMUS_PER_PIXEL)}"/></xdr:xfrm><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/drawing/2010/slicer"><sle:slicer xmlns:sle="http://schemas.microsoft.com/office/drawing/2010/slicer" name="${escapeXmlAttr(placement.title)}"/></a:graphicData></a:graphic></xdr:graphicFrame></mc:Choice></mc:AlternateContent><xdr:clientData/></xdr:twoCellAnchor>`;
+};
+const createTextBoxAnchor = ({ placement, frameId, sheet, }) => {
+    const fromRow = Math.max(0, placement.rowIndex - 1);
+    const fromColumn = Math.max(0, placement.columnIndex - 1);
+    const offsetX = Math.max(0, placement.offsetX ?? 0);
+    const offsetY = Math.max(0, placement.offsetY ?? 0);
+    const widthPx = Math.max(50, placement.width ?? 200);
+    const heightPx = Math.max(50, placement.height ?? 60);
+    const toColumn = resolveAnchorEndpoint({
+        startIndex: fromColumn,
+        startOffset: offsetX,
+        span: widthPx,
+        getSize: (index) => getColumnWidthPx(sheet, index, true),
+    });
+    const toRow = resolveAnchorEndpoint({
+        startIndex: fromRow,
+        startOffset: offsetY,
+        span: heightPx,
+        getSize: (index) => getRowHeightPx(sheet, index, true),
+    });
+    const fromXml = `<xdr:from><xdr:col>${fromColumn}</xdr:col><xdr:colOff>${Math.round(offsetX * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${fromRow}</xdr:row><xdr:rowOff>${Math.round(offsetY * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:from>`;
+    const toXml = `<xdr:to><xdr:col>${toColumn.index}</xdr:col><xdr:colOff>${Math.round(toColumn.offset * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${toRow.index}</xdr:row><xdr:rowOff>${Math.round(toRow.offset * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:to>`;
+    const spec = placement.textBox.spec;
+    const textBodyXml = buildTextBodyXml(spec);
+    const shapePropertiesXml = buildShapePropertiesXml(spec, widthPx, heightPx);
+    return `<xdr:twoCellAnchor editAs="oneCell">${fromXml}${toXml}<xdr:sp><xdr:nvSpPr><xdr:cNvPr id="${frameId}" name="TextBox ${frameId}"/><xdr:cNvSpPr txBox="1"/></xdr:nvSpPr>${shapePropertiesXml}${textBodyXml}</xdr:sp><xdr:clientData/></xdr:twoCellAnchor>`;
+};
+/** ColorIndex slots → canonical DrawingML scheme names (inverse of the importer's map). */
+const THEME_INDEX_TO_SCHEME = [
+    "lt1",
+    "dk1",
+    "lt2",
+    "dk2",
+    "accent1",
+    "accent2",
+    "accent3",
+    "accent4",
+    "accent5",
+    "accent6",
+    "hlink",
+];
+/**
+ * Serialize a `Color` (+optional 0–1 opacity) as a DrawingML color element.
+ * Theme colors keep their scheme reference; a positive tint exports as
+ * Excel's lumMod/lumOff pair ("lighter N%"), a negative one as lumMod alone
+ * ("darker N%") — the exact encodings the importer maps back onto `tint`.
+ */
+const buildDrawingColorXml = (color, opacity) => {
+    const mods = [];
+    if (opacity !== undefined && opacity !== null && opacity < 1) {
+        mods.push(`<a:alpha val="${Math.round(opacity * 100000)}"/>`);
+    }
+    if (typeof color === "string") {
+        const val = escapeXmlAttr(color.replace("#", "").toUpperCase());
+        return mods.length
+            ? `<a:srgbClr val="${val}">${mods.join("")}</a:srgbClr>`
+            : `<a:srgbClr val="${val}"/>`;
+    }
+    const scheme = THEME_INDEX_TO_SCHEME[color.theme] ?? "accent1";
+    const tint = color.tint ?? 0;
+    if (tint > 0) {
+        mods.push(`<a:lumMod val="${Math.round((1 - tint) * 100000)}"/>`, `<a:lumOff val="${Math.round(tint * 100000)}"/>`);
+    }
+    else if (tint < 0) {
+        mods.push(`<a:lumMod val="${Math.round((1 + tint) * 100000)}"/>`);
+    }
+    return mods.length
+        ? `<a:schemeClr val="${scheme}">${mods.join("")}</a:schemeClr>`
+        : `<a:schemeClr val="${scheme}"/>`;
+};
+/** Renderer preset names → OOXML `prst` values where they differ. */
+const PRESET_TO_OOXML = {
+    rightTriangle: "rtTriangle",
+    snipSingleCornerRect: "snip1Rect",
+};
+const SHAPE_DASH_TO_OOXML = {
+    solid: "solid",
+    dot: "dot",
+    dash: "dash",
+    dashDot: "dashDot",
+    longDash: "lgDash",
+    longDashDot: "lgDashDot",
+    longDashDotDot: "lgDashDotDot",
+};
+const buildShapeFillXml = (fill) => {
+    if (!fill)
+        return "";
+    switch (fill.kind) {
+        case "none":
+            return "<a:noFill/>";
+        case "solid":
+            return `<a:solidFill>${buildDrawingColorXml(fill.color, fill.opacity)}</a:solidFill>`;
+        case "gradient": {
+            const stops = fill.stops
+                .map((stop) => `<a:gs pos="${Math.round(stop.position * 100000)}">${buildDrawingColorXml(stop.color, stop.opacity)}</a:gs>`)
+                .join("");
+            const direction = fill.shading === "radial"
+                ? `<a:path path="circle"><a:fillToRect l="50000" t="50000" r="50000" b="50000"/></a:path>`
+                : `<a:lin ang="${Math.round((fill.angle ?? 90) * 60000)}" scaled="1"/>`;
+            return `<a:gradFill><a:gsLst>${stops}</a:gsLst>${direction}</a:gradFill>`;
+        }
+    }
+};
+const buildShapeOutlineXml = (outline) => {
+    if (!outline)
+        return "";
+    if (outline.width === 0)
+        return "<a:ln><a:noFill/></a:ln>";
+    const wAttr = outline.width
+        ? ` w="${Math.round(outline.width * EMUS_PER_PIXEL)}"`
+        : "";
+    const fill = outline.color
+        ? `<a:solidFill>${buildDrawingColorXml(outline.color, outline.opacity)}</a:solidFill>`
+        : "";
+    const dash = outline.dash
+        ? `<a:prstDash val="${SHAPE_DASH_TO_OOXML[outline.dash]}"/>`
+        : "";
+    return `<a:ln${wAttr}>${fill}${dash}</a:ln>`;
+};
+const buildShapeShadowXml = (shadow) => {
+    if (!shadow)
+        return "";
+    const dx = shadow.offsetXPixels ?? 0;
+    const dy = shadow.offsetYPixels ?? 0;
+    const dist = Math.round(Math.hypot(dx, dy) * EMUS_PER_PIXEL);
+    const dirDeg = (Math.atan2(dy, dx) * 180) / Math.PI;
+    const dir = Math.round(((dirDeg + 360) % 360) * 60000);
+    const blur = Math.round((shadow.blurRadius ?? 0) * EMUS_PER_PIXEL);
+    const color = buildDrawingColorXml(shadow.color ?? "#000000", shadow.opacity);
+    return `<a:effectLst><a:outerShdw blurRad="${blur}" dist="${dist}" dir="${dir}">${color}</a:outerShdw></a:effectLst>`;
+};
+const buildShapeStyleRefXml = (tag, ref) => ref
+    ? `<a:${tag} idx="${ref.index}">${buildDrawingColorXml(ref.color)}</a:${tag}>`
+    : `<a:${tag} idx="0"/>`;
+/** Export an `EmbedShapeSpec` embed as an `<xdr:sp>` two-cell anchor. */
+const createShapeAnchor = ({ placement, frameId, sheet, }) => {
+    const spec = placement.shape.spec;
+    const fromRow = Math.max(0, placement.rowIndex - 1);
+    const fromColumn = Math.max(0, placement.columnIndex - 1);
+    const offsetX = Math.max(0, placement.offsetX ?? 0);
+    const offsetY = Math.max(0, placement.offsetY ?? 0);
+    const widthPx = Math.max(10, placement.width ?? 120);
+    const heightPx = Math.max(10, placement.height ?? 60);
+    const toColumn = resolveAnchorEndpoint({
+        startIndex: fromColumn,
+        startOffset: offsetX,
+        span: widthPx,
+        getSize: (index) => getColumnWidthPx(sheet, index, true),
+    });
+    const toRow = resolveAnchorEndpoint({
+        startIndex: fromRow,
+        startOffset: offsetY,
+        span: heightPx,
+        getSize: (index) => getRowHeightPx(sheet, index, true),
+    });
+    const fromXml = `<xdr:from><xdr:col>${fromColumn}</xdr:col><xdr:colOff>${Math.round(offsetX * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${fromRow}</xdr:row><xdr:rowOff>${Math.round(offsetY * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:from>`;
+    const toXml = `<xdr:to><xdr:col>${toColumn.index}</xdr:col><xdr:colOff>${Math.round(toColumn.offset * EMUS_PER_PIXEL)}</xdr:colOff><xdr:row>${toRow.index}</xdr:row><xdr:rowOff>${Math.round(toRow.offset * EMUS_PER_PIXEL)}</xdr:rowOff></xdr:to>`;
+    const xfrmAttrs = [
+        placement.shape.rotation
+            ? ` rot="${Math.round(placement.shape.rotation * 60000)}"`
+            : "",
+        spec.flipHorizontal ? ' flipH="1"' : "",
+        spec.flipVertical ? ' flipV="1"' : "",
+    ].join("");
+    const xfrm = `<a:xfrm${xfrmAttrs}><a:off x="0" y="0"/><a:ext cx="${Math.round(widthPx * EMUS_PER_PIXEL)}" cy="${Math.round(heightPx * EMUS_PER_PIXEL)}"/></a:xfrm>`;
+    const prst = PRESET_TO_OOXML[spec.geometry.preset] ?? spec.geometry.preset;
+    const adjustments = spec.geometry.adjustments ?? {};
+    const gds = Object.entries(adjustments)
+        .map(([gdName, value]) => `<a:gd name="${escapeXmlAttr(gdName)}" fmla="val ${Math.round(value)}"/>`)
+        .join("");
+    const geometry = `<a:prstGeom prst="${escapeXmlAttr(prst)}"><a:avLst>${gds}</a:avLst></a:prstGeom>`;
+    const spPr = `<xdr:spPr>${xfrm}${geometry}${buildShapeFillXml(spec.fill)}${buildShapeOutlineXml(spec.outline)}${buildShapeShadowXml(spec.shadow)}</xdr:spPr>`;
+    // <xdr:style> child order is fixed by the schema: ln, fill, effect, font.
+    let styleXml = "";
+    if (spec.styleRefs) {
+        const font = spec.styleRefs.font;
+        const fontXml = `<a:fontRef idx="${font?.scheme ?? "minor"}">${font?.color ? buildDrawingColorXml(font.color) : ""}</a:fontRef>`;
+        styleXml = `<xdr:style>${buildShapeStyleRefXml("lnRef", spec.styleRefs.line)}${buildShapeStyleRefXml("fillRef", spec.styleRefs.fill)}${buildShapeStyleRefXml("effectRef", spec.styleRefs.effect)}${fontXml}</xdr:style>`;
+    }
+    const textBodyXml = spec.textBody
+        ? buildTextBodyXml(spec.textBody)
+        : `<xdr:txBody><a:bodyPr vertOverflow="clip" horzOverflow="clip" rtlCol="0" anchor="t"/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></xdr:txBody>`;
+    const name = escapeXmlAttr(spec.name ?? `Shape ${frameId}`);
+    return `<xdr:twoCellAnchor editAs="oneCell">${fromXml}${toXml}<xdr:sp><xdr:nvSpPr><xdr:cNvPr id="${frameId}" name="${name}"/><xdr:cNvSpPr/></xdr:nvSpPr>${spPr}${styleXml}${textBodyXml}</xdr:sp><xdr:clientData/></xdr:twoCellAnchor>`;
+};
+const buildTextWithTabs = (text, rPrXml) => {
+    const parts = text.split("\t");
+    if (parts.length === 1) {
+        return `<a:r>${rPrXml}<a:t>${escapeXmlText(text)}</a:t></a:r>`;
+    }
+    return parts
+        .map((part, index) => {
+        if (index === 0) {
+            return `<a:r>${rPrXml}<a:t>${escapeXmlText(part)}</a:t></a:r>`;
+        }
+        return `<a:r>${rPrXml}<a:tab/></a:r><a:r>${rPrXml}<a:t>${escapeXmlText(part)}</a:t></a:r>`;
+    })
+        .join("");
+};
+const buildTextBodyXml = (spec) => {
+    const richText = spec.richText || [];
+    const plainText = spec.text || "";
+    // Build vertical alignment and wrap attributes
+    let bodyPrAttrs = "";
+    if (spec.verticalAlignment === "top") {
+        bodyPrAttrs += ' anchor="t"';
+    }
+    else if (spec.verticalAlignment === "bottom") {
+        bodyPrAttrs += ' anchor="b"';
+    }
+    else if (spec.verticalAlignment === "middle") {
+        bodyPrAttrs += ' anchor="ctr"';
+    }
+    // Add wrap strategy
+    if (spec.wrapStrategy === "wrap") {
+        bodyPrAttrs += ' wrap="square"';
+    }
+    else if (spec.wrapStrategy === "overflow") {
+        bodyPrAttrs += ' wrap="none"';
+    }
+    // Add padding (convert pixels to EMUs)
+    if (spec.padding) {
+        const paddingEmu = Math.round(spec.padding * EMUS_PER_PIXEL);
+        bodyPrAttrs += ` lIns="${paddingEmu}" rIns="${paddingEmu}" tIns="${paddingEmu}" bIns="${paddingEmu}"`;
+    }
+    let paragraphsXml = "";
+    if (richText.length > 0) {
+        // Group runs into paragraphs by newlines
+        const paragraphs = [[]];
+        for (const run of richText) {
+            if (run.text === "\n") {
+                paragraphs.push([]);
+            }
+            else {
+                paragraphs[paragraphs.length - 1].push(run);
+            }
+        }
+        paragraphsXml = paragraphs
+            .filter((runs) => runs.length > 0)
+            .map((runs) => {
+            // Detect indentation and bullets from first run
+            const firstRun = runs[0];
+            let pPrXml = "";
+            let processedRuns = runs;
+            if (firstRun && firstRun.text) {
+                const text = firstRun.text;
+                // Detect bullet (expanded to support more types)
+                const bulletMatch = text.match(/^([•\-◦▪○●✓✔✖✗➢►▶→⇒❯»*+>§¶])\s/);
+                if (bulletMatch) {
+                    pPrXml = `<a:pPr><a:buChar char="${escapeXmlAttr(bulletMatch[1])}"/></a:pPr>`;
+                    // Remove bullet from text
+                    processedRuns = [
+                        { ...firstRun, text: text.substring(bulletMatch[0].length) },
+                        ...runs.slice(1),
+                    ];
+                }
+                else {
+                    // Detect indentation (leading spaces)
+                    const spaceMatch = text.match(/^(\s+)/);
+                    if (spaceMatch) {
+                        const spaces = spaceMatch[1].length;
+                        const indentEmu = Math.round(spaces * 90000);
+                        pPrXml = `<a:pPr marL="${indentEmu}"/>`;
+                        // Remove leading spaces
+                        processedRuns = [
+                            { ...firstRun, text: text.substring(spaces) },
+                            ...runs.slice(1),
+                        ];
+                    }
+                }
+            }
+            const runsXml = processedRuns
+                .map((run) => {
+                const rPrXml = buildRunPropertiesXml(run.format);
+                return buildTextWithTabs(run.text, rPrXml);
+            })
+                .join("");
+            return `<a:p>${pPrXml}${runsXml}</a:p>`;
+        })
+            .join("");
+    }
+    else {
+        // Plain text - split by newlines
+        const lines = plainText.split("\n");
+        paragraphsXml = lines
+            .map((line) => {
+            let pPrXml = "";
+            let processedText = line;
+            // Detect bullet (expanded to support more types)
+            const bulletMatch = line.match(/^([•\-◦▪○●✓✔✖✗➢►▶→⇒❯»*+>§¶])\s/);
+            if (bulletMatch) {
+                pPrXml = `<a:pPr><a:buChar char="${escapeXmlAttr(bulletMatch[1])}"/></a:pPr>`;
+                processedText = line.substring(bulletMatch[0].length);
+            }
+            else {
+                // Detect indentation
+                const spaceMatch = line.match(/^(\s+)/);
+                if (spaceMatch) {
+                    const spaces = spaceMatch[1].length;
+                    const indentEmu = Math.round(spaces * 90000);
+                    pPrXml = `<a:pPr marL="${indentEmu}"/>`;
+                    processedText = line.substring(spaces);
+                }
+            }
+            const rPrXml = buildRunPropertiesXml(spec.textFormat);
+            const runsXml = buildTextWithTabs(processedText, rPrXml);
+            return `<a:p>${pPrXml}${runsXml}</a:p>`;
+        })
+            .join("");
+    }
+    return `<xdr:txBody><a:bodyPr${bodyPrAttrs}/><a:lstStyle/>${paragraphsXml}</xdr:txBody>`;
+};
+const buildRunPropertiesXml = (format) => {
+    if (!format)
+        return "<a:rPr/>";
+    let attrs = "";
+    let childElements = "";
+    // Font size (convert points to hundredths of a point)
+    if (format.fontSize) {
+        attrs += ` sz="${Math.round(format.fontSize * 100)}"`;
+    }
+    // Bold
+    if (format.bold) {
+        attrs += ' b="1"';
+    }
+    // Italic
+    if (format.italic) {
+        attrs += ' i="1"';
+    }
+    // Underline
+    if (format.underline) {
+        attrs += ' u="sng"';
+    }
+    // Strikethrough
+    if (format.strikethrough) {
+        attrs += ' strike="sngStrike"';
+    }
+    // Font family
+    if (format.fontFamily) {
+        childElements += `<a:latin typeface="${escapeXmlAttr(format.fontFamily)}"/>`;
+    }
+    // Text color
+    if (format.color) {
+        let colorHex = "000000";
+        if (typeof format.color === "string") {
+            colorHex = format.color.replace("#", "");
+        }
+        else if (format.color.rgbColor) {
+            colorHex = format.color.rgbColor.replace("#", "");
+        }
+        else if (format.color.red !== undefined &&
+            format.color.green !== undefined &&
+            format.color.blue !== undefined) {
+            const r = Math.round(format.color.red * 255)
+                .toString(16)
+                .padStart(2, "0");
+            const g = Math.round(format.color.green * 255)
+                .toString(16)
+                .padStart(2, "0");
+            const b = Math.round(format.color.blue * 255)
+                .toString(16)
+                .padStart(2, "0");
+            colorHex = `${r}${g}${b}`.toUpperCase();
+        }
+        childElements += `<a:solidFill><a:srgbClr val="${colorHex}"/></a:solidFill>`;
+    }
+    return `<a:rPr${attrs}>${childElements}</a:rPr>`;
+};
+const buildShapePropertiesXml = (spec, widthPx, heightPx) => {
+    let fillXml = "";
+    // Background color
+    if (spec.backgroundColor) {
+        let bgColor = "FFFFFF";
+        if (typeof spec.backgroundColor === "string") {
+            bgColor = spec.backgroundColor.replace("#", "");
+        }
+        else if (spec.backgroundColor.rgbColor) {
+            bgColor = spec.backgroundColor.rgbColor.replace("#", "");
+        }
+        else if (spec.backgroundColor.red !== undefined &&
+            spec.backgroundColor.green !== undefined &&
+            spec.backgroundColor.blue !== undefined) {
+            const r = Math.round(spec.backgroundColor.red * 255)
+                .toString(16)
+                .padStart(2, "0");
+            const g = Math.round(spec.backgroundColor.green * 255)
+                .toString(16)
+                .padStart(2, "0");
+            const b = Math.round(spec.backgroundColor.blue * 255)
+                .toString(16)
+                .padStart(2, "0");
+            bgColor = `${r}${g}${b}`.toUpperCase();
+        }
+        fillXml = `<a:solidFill><a:srgbClr val="${bgColor}"/></a:solidFill>`;
+    }
+    else {
+        fillXml = "<a:noFill/>";
+    }
+    // Borders (outline)
+    let outlineXml = "<a:ln><a:noFill/></a:ln>";
+    if (spec.borders) {
+        // For simplicity, use the first available border style
+        const border = spec.borders.top ||
+            spec.borders.right ||
+            spec.borders.bottom ||
+            spec.borders.left;
+        if (border) {
+            let borderColor = "000000";
+            if (typeof border.color === "string") {
+                borderColor = border.color.replace("#", "");
+            }
+            else if (border.color?.rgbColor) {
+                borderColor = border.color.rgbColor.replace("#", "");
+            }
+            else if (border.color?.red !== undefined &&
+                border.color?.green !== undefined &&
+                border.color?.blue !== undefined) {
+                const r = Math.round(border.color.red * 255)
+                    .toString(16)
+                    .padStart(2, "0");
+                const g = Math.round(border.color.green * 255)
+                    .toString(16)
+                    .padStart(2, "0");
+                const b = Math.round(border.color.blue * 255)
+                    .toString(16)
+                    .padStart(2, "0");
+                borderColor = `${r}${g}${b}`.toUpperCase();
+            }
+            const borderWidth = Math.round((border.width || 1) * 12700); // Convert to EMUs
+            outlineXml = `<a:ln w="${borderWidth}"><a:solidFill><a:srgbClr val="${borderColor}"/></a:solidFill></a:ln>`;
+        }
+    }
+    return `<xdr:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${Math.round(widthPx * EMUS_PER_PIXEL)}" cy="${Math.round(heightPx * EMUS_PER_PIXEL)}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom>${fillXml}${outlineXml}</xdr:spPr>`;
+};
+const resolveAnchorEndpoint = ({ startIndex, startOffset, span, getSize, }) => {
+    let index = startIndex;
+    let offset = Math.max(0, startOffset);
+    let remaining = Math.max(0, span);
+    while (remaining > 0) {
+        const rawSize = getSize(index);
+        // Hidden rows/columns have 0 size - skip over them
+        if (rawSize <= 0) {
+            index += 1;
+            offset = 0;
+            continue;
+        }
+        const size = Math.max(5, rawSize);
+        const available = Math.max(0, size - offset);
+        if (remaining <= available) {
+            return {
+                index,
+                offset: Math.min(size, offset + remaining),
+            };
+        }
+        remaining -= available;
+        index += 1;
+        offset = 0;
+    }
+    return {
+        index,
+        offset,
+    };
+};
+const getDefaultColumnWidthPx = (sheet) => {
+    if (sheet?.defaultColumnWidth) {
+        return Number(sheet.defaultColumnWidth) || DEFAULT_COLUMN_WIDTH_PX;
+    }
+    return DEFAULT_COLUMN_WIDTH_PX;
+};
+const getDefaultRowHeightPx = (sheet) => {
+    if (sheet?.defaultRowHeight) {
+        return Number(sheet.defaultRowHeight) || DEFAULT_ROW_HEIGHT_PX;
+    }
+    return DEFAULT_ROW_HEIGHT_PX;
+};
+const getColumnWidthPx = (sheet, columnIndex, forAnchor = false) => {
+    const metadata = sheet.columnMetadata?.[columnIndex + 1];
+    // For anchor calculations, hidden columns have 0 width
+    if (forAnchor && (metadata?.hiddenByUser || metadata?.hiddenByFilter)) {
+        return 0;
+    }
+    if (metadata?.size && metadata.size > 0) {
+        return metadata.size;
+    }
+    return getDefaultColumnWidthPx(sheet);
+};
+const getRowHeightPx = (sheet, rowIndex, forAnchor = false) => {
+    const metadata = sheet.rowMetadata?.[rowIndex + 1];
+    // For anchor calculations, hidden rows have 0 height
+    if (forAnchor && (metadata?.hiddenByUser || metadata?.hiddenByFilter)) {
+        return 0;
+    }
+    if (metadata?.size && metadata.size > 0) {
+        return metadata.size;
+    }
+    return getDefaultRowHeightPx(sheet);
+};
+const resolveImageDataUrl = async (imageUrl) => {
+    if (imageUrl.startsWith("data:")) {
+        return imageUrl;
+    }
+    try {
+        return await imageUrlToBase64(imageUrl);
+    }
+    catch {
+        return undefined;
+    }
+};
+const dataUriToBuffer = (dataUrl, fallbackName) => {
+    const match = /^data:(.+?);base64,(.+)$/.exec(dataUrl);
+    if (!match)
+        return undefined;
+    const [, mime, base64] = match;
+    const binaryString = decodeBase64(base64);
+    const buffer = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        buffer[i] = binaryString.charCodeAt(i);
+    }
+    const extension = mime.split("/")[1] ?? fallbackName?.split(".").pop() ?? "bin";
+    return {
+        data: buffer,
+        extension: extension.toLowerCase(),
+        contentType: mime,
+    };
+};
+const decodeBase64 = (value) => {
+    if (typeof atob === "function") {
+        return atob(value);
+    }
+    const bufferCtor = globalThis.Buffer;
+    if (bufferCtor) {
+        return bufferCtor.from(value, "base64").toString("binary");
+    }
+    throw new Error("Base64 decoding is not supported in this environment");
+};
+const sanitizeSheetName = (name, used, fallback) => {
+    const invalidChars = /[\\/:?*\[\]]/g;
+    const controlChars = /[\u0000-\u001F]/g;
+    let cleaned = sanitizeXmlText(name)
+        .replace(invalidChars, " ")
+        .replace(controlChars, "")
+        .replace(/^'+|'+$/g, "");
+    // Preserve trailing/internal whitespace in sheet names (Excel allows
+    // them — "Total Bookings " is a valid name and round-trip identity
+    // lookups (shared-formula keys, named-range refs) depend on byte-equal
+    // sheet names). Fall back to default only when the result is fully empty
+    // after whitespace.
+    if (!cleaned.trim())
+        cleaned = fallback;
+    if (cleaned.length > 31) {
+        cleaned = cleaned.slice(0, 31);
+    }
+    let unique = cleaned;
+    let suffix = 1;
+    while (used.has(unique)) {
+        suffix += 1;
+        const tail = ` (${suffix})`;
+        const baseLength = Math.max(0, 31 - tail.length);
+        unique = `${cleaned.slice(0, baseLength)}${tail}`;
+    }
+    used.add(unique);
+    return unique;
+};
+const buildWorkbookSheetNames = (sheets) => {
+    const usedNames = new Set();
+    return sheets.map((sheet, index) => {
+        const sheetId = index + 1;
+        const fallback = `Sheet${sheetId}`;
+        return sanitizeSheetName(sheet.title ?? fallback, usedNames, fallback);
+    });
+};
+const buildSlicerCacheName = (value) => {
+    const normalized = sanitizeXmlText(value)
+        .replace(/[^A-Za-z0-9_]/g, "_")
+        .replace(/^_+|_+$/g, "");
+    const base = normalized || "Slicer";
+    return base.startsWith("Slicer_") ? base : `Slicer_${base}`;
+};
+const buildCalcPrXml = (iterativeCalculationOptions) => {
+    if (!iterativeCalculationOptions)
+        return "";
+    const attrs = [
+        `iterate="${iterativeCalculationOptions.enabled ? 1 : 0}"`,
+    ];
+    if (typeof iterativeCalculationOptions.maxIterations === "number") {
+        attrs.push(`iterateCount="${Math.max(0, Math.floor(iterativeCalculationOptions.maxIterations))}"`);
+    }
+    if (typeof iterativeCalculationOptions.maxChange === "number") {
+        attrs.push(`iterateDelta="${iterativeCalculationOptions.maxChange}"`);
+    }
+    return `<calcPr ${attrs.join(" ")}/>`;
+};
+const buildWorkbookXml = (sheets, sheetRelIds, sheetNames, namedRanges, iterativeCalculationOptions, slicerCacheRelIds = [], use1904 = false, externalLinkRelIds = [], pivotCacheRelIds = []) => {
+    const sheetEntries = sheets
+        .map((sheet, index) => {
+        const relId = sheetRelIds[index];
+        // Preserve the source's sheetId verbatim. Real-world workbooks have
+        // non-sequential sheetIds (gaps left behind after sheet deletions —
+        // Excel never renumbers), and tools that compare bytes (diff,
+        // sensitivity-label scanners, version control) flag any renumber.
+        // Display order is controlled by iteration order, not by sheetId
+        // value, so preserving it has no UX impact. Fall back to index+1
+        // only for newly-created sheets that don't carry one yet.
+        const sheetId = sheet.sheetId ?? index + 1;
+        const fallbackName = `Sheet${index + 1}`;
+        const name = sheetNames[index] ?? fallbackName;
+        // visibility is the rich source of truth (visible/hidden/veryHidden).
+        // Fall back to the legacy `hidden` boolean when the field isn't set.
+        const state = sheet.visibility === "veryHidden"
+            ? "veryHidden"
+            : sheet.visibility === "hidden" || sheet.hidden
+                ? "hidden"
+                : "visible";
+        return `<sheet name="${escapeXmlAttr(name)}" sheetId="${sheetId}" r:id="${relId}" state="${state}"/>`;
+    })
+        .join("");
+    const sheetNameById = new Map();
+    sheets.forEach((sheet, index) => {
+        sheetNameById.set(sheet.sheetId ?? index + 1, sheetNames[index]);
+    });
+    const definedNamesXml = buildDefinedNamesXml(namedRanges, sheetNameById);
+    const calcPrXml = buildCalcPrXml(iterativeCalculationOptions);
+    const slicerCachesXml = buildWorkbookSlicerCachesXml(slicerCacheRelIds);
+    // Phase D2 — <pivotCaches> element. Each <pivotCache> pairs a
+    // workbook-unique cacheId (we use 1-based sequential matching the
+    // order pivotCacheDefinition<N>.xml files were emitted) with the
+    // workbook-level relationship rId pointing at that cache XML.
+    const pivotCachesXml = pivotCacheRelIds.length
+        ? `<pivotCaches>${pivotCacheRelIds
+            .map((rId, i) => `<pivotCache cacheId="${i + 1}" r:id="${rId}"/>`)
+            .join("")}</pivotCaches>`
+        : "";
+    // External-link references — needed so Excel knows `[1]Sheet!A1`
+    // formulas resolve through the relationships we wrote into the rels
+    // file. The position in the externalLinkRelIds array determines the
+    // formula's `[N]` index (1-based).
+    const externalReferencesXml = externalLinkRelIds.length
+        ? `<externalReferences>${externalLinkRelIds
+            .map((id) => `<externalReference r:id="${id}"/>`)
+            .join("")}</externalReferences>`
+        : "";
+    // `date1904="1"` shifts every date serial by 1462 days. Emit only when
+    // the workbook is explicitly 1904-anchored so the default file matches
+    // Excel's own writer (no attribute → 1900 epoch).
+    const workbookPrXml = use1904
+        ? `<workbookPr date1904="1"/>`
+        : `<workbookPr/>`;
+    return `${XML_DECLARATION}<workbook xmlns="${WORKSHEET_NS}" xmlns:r="${REL_NS}">${workbookPrXml}${calcPrXml}<bookViews><workbookView activeTab="0" firstSheet="0"/></bookViews><sheets>${sheetEntries}</sheets>${definedNamesXml}${externalReferencesXml}${pivotCachesXml}${slicerCachesXml}</workbook>`;
+};
+const buildDefinedNamesXml = (namedRanges, sheetNameById) => {
+    if (!namedRanges?.length)
+        return "";
+    const entries = [];
+    for (const namedRange of namedRanges) {
+        if (!namedRange?.name)
+            continue;
+        const hiddenAttr = namedRange.hidden ? ` hidden="1"` : "";
+        if (namedRange.range?.sheetId) {
+            const sheetName = sheetNameById.get(namedRange.range.sheetId);
+            if (!sheetName)
+                continue;
+            const ref = cellRangeToAddress(undefined, namedRange.range);
+            if (!ref)
+                continue;
+            const address = `${escapeSheetName(sheetName)}!${toAbsoluteRef(ref)}`;
+            entries.push(`<definedName name="${escapeXmlAttr(namedRange.name)}"${hiddenAttr}>${escapeXmlText(address)}</definedName>`);
+            continue;
+        }
+        const rawValue = namedRange.value;
+        if (typeof rawValue !== "string")
+            continue;
+        const trimmed = rawValue.trim();
+        if (!trimmed)
+            continue;
+        const expression = trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+        entries.push(`<definedName name="${escapeXmlAttr(namedRange.name)}"${hiddenAttr}>${escapeXmlText(expression)}</definedName>`);
+    }
+    if (!entries.length)
+        return "";
+    return `<definedNames>${entries.join("")}</definedNames>`;
+};
+const toAbsoluteRef = (ref) => {
+    return ref
+        .split(":")
+        .map((part) => part.replace(/(\$?)([A-Za-z]+)(\$?)(\d+)/g, (_match, _c, col, _r, row) => {
+        return `$${col}$${row}`;
+    }))
+        .join(":");
+};
+const escapeSheetName = (name) => {
+    if (/[^A-Za-z0-9_]/.test(name)) {
+        return `'${name.replace(/'/g, "''")}'`;
+    }
+    return name;
+};
+const buildWorkbookSlicerCachesXml = (slicerCacheRelIds) => {
+    if (!slicerCacheRelIds.length) {
+        return "";
+    }
+    const cacheEntries = slicerCacheRelIds
+        .map((relId) => `<x14:slicerCache xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" r:id="${relId}"/>`)
+        .join("");
+    return `<extLst><ext uri="{46BE6895-7355-4a93-B00E-2C351335B9C9}" xmlns:x15="http://schemas.microsoft.com/office/spreadsheetml/2010/11/main"><x15:slicerCaches xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main">${cacheEntries}</x15:slicerCaches></ext></extLst>`;
+};
+const buildWorkbookRelationships = (sheetCount, slicerCacheCount = 0, externalLinkCount = 0, pivotCacheCount = 0, hasPersons = false) => {
+    const relationships = [];
+    const sheetRelIds = [];
+    const slicerCacheRelIds = [];
+    for (let i = 0; i < sheetCount; i++) {
+        const relId = `rId${i + 1}`;
+        sheetRelIds.push(relId);
+        relationships.push(`<Relationship Id="${relId}" Type="${REL_NS}/worksheet" Target="worksheets/sheet${i + 1}.xml"/>`);
+    }
+    const stylesId = `rId${sheetCount + 1}`;
+    const themeId = `rId${sheetCount + 2}`;
+    const sharedStringsId = `rId${sheetCount + 3}`;
+    relationships.push(`<Relationship Id="${stylesId}" Type="${REL_NS}/styles" Target="styles.xml"/>`);
+    relationships.push(`<Relationship Id="${themeId}" Type="${REL_NS}/theme" Target="theme/theme1.xml"/>`);
+    relationships.push(`<Relationship Id="${sharedStringsId}" Type="${REL_NS}/sharedStrings" Target="sharedStrings.xml"/>`);
+    let nextRelId = sheetCount + 4;
+    for (let i = 0; i < slicerCacheCount; i++) {
+        const relId = `rId${nextRelId++}`;
+        slicerCacheRelIds.push(relId);
+        relationships.push(`<Relationship Id="${relId}" Type="${SLICER_CACHE_REL_TYPE}" Target="slicerCaches/slicerCache${i + 1}.xml"/>`);
+    }
+    // Add external link relationships. Capture the rIds so the workbook
+    // XML can reference them in <externalReferences>; without that element
+    // Excel can't resolve `[1]Sheet!A1` formulas even though the files exist.
+    const externalLinkRelIds = [];
+    for (let i = 0; i < externalLinkCount; i++) {
+        const relId = `rId${nextRelId++}`;
+        externalLinkRelIds.push(relId);
+        relationships.push(`<Relationship Id="${relId}" Type="${REL_NS}/externalLink" Target="externalLinks/externalLink${i + 1}.xml"/>`);
+    }
+    // Phase D2 — pivotCacheDefinition relationships. workbook.xml's
+    // <pivotCaches> element references these by rId. The corresponding
+    // <pivotCache> entry pairs cacheId (sequential, starts at 1) with
+    // r:id (the relationship rId we collect here).
+    const pivotCacheRelIds = [];
+    for (let i = 0; i < pivotCacheCount; i++) {
+        const relId = `rId${nextRelId++}`;
+        pivotCacheRelIds.push(relId);
+        relationships.push(`<Relationship Id="${relId}" Type="${PIVOT_CACHE_DEFINITION_REL_TYPE}" Target="pivotCache/pivotCacheDefinition${i + 1}.xml"/>`);
+    }
+    // Workbook → persons part (threaded-comment authors).
+    if (hasPersons) {
+        relationships.push(`<Relationship Id="rId${nextRelId++}" Type="${PERSON_REL_TYPE}" Target="persons/person.xml"/>`);
+    }
+    return {
+        xml: `${XML_DECLARATION}<Relationships xmlns="${PACKAGE_REL_NS}">${relationships.join("")}</Relationships>`,
+        sheetRelationshipIds: sheetRelIds,
+        pivotCacheRelationshipIds: pivotCacheRelIds,
+        externalLinkRelationshipIds: externalLinkRelIds,
+        slicerCacheRelationshipIds: slicerCacheRelIds,
+    };
+};
+const buildContentTypesXml = ({ sheetCount, tableCount, drawingSheets, mediaExtensions, chartCount, slicerCount = 0, slicerCacheCount = 0, pivotTableCount = 0, pivotCacheCount = 0, commentsSheets = [], threadedCommentsSheets = [], hasPersons = false, externalLinkCount = 0, }) => {
+    const sheetOverrides = Array.from({ length: sheetCount }, (_, index) => {
+        return `<Override PartName="/xl/worksheets/sheet${index + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`;
+    }).join("");
+    const tableOverrides = Array.from({ length: tableCount }, (_, index) => {
+        return `<Override PartName="/xl/tables/table${index + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"/>`;
+    }).join("");
+    const drawingOverrides = drawingSheets
+        .map((sheetIndex) => `<Override PartName="/xl/drawings/drawing${sheetIndex}.xml" ContentType="application/vnd.openxmlformats-officedocument.drawing+xml"/>`)
+        .join("");
+    const chartOverrides = Array.from({ length: chartCount }, (_, index) => {
+        return `<Override PartName="/xl/charts/chart${index + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.drawingml.chart+xml"/>`;
+    }).join("");
+    const slicerOverrides = Array.from({ length: slicerCount }, (_, index) => {
+        return `<Override PartName="/xl/slicers/slicer${index + 1}.xml" ContentType="application/vnd.ms-excel.slicer+xml"/>`;
+    }).join("");
+    const slicerCacheOverrides = Array.from({ length: slicerCacheCount }, (_, index) => {
+        return `<Override PartName="/xl/slicerCaches/slicerCache${index + 1}.xml" ContentType="application/vnd.ms-excel.slicerCache+xml"/>`;
+    }).join("");
+    // Phase D2 — pivotTable + pivotCacheDefinition overrides.
+    const pivotTableOverrides = Array.from({ length: pivotTableCount }, (_, index) => `<Override PartName="/xl/pivotTables/pivotTable${index + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"/>`).join("");
+    const pivotCacheOverrides = Array.from({ length: pivotCacheCount }, (_, index) => `<Override PartName="/xl/pivotCache/pivotCacheDefinition${index + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"/>`).join("");
+    const commentsOverrides = commentsSheets
+        .map((sheetId) => `<Override PartName="/xl/comments${sheetId}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"/>`)
+        .join("");
+    const threadedCommentsOverrides = threadedCommentsSheets
+        .map((sheetId) => `<Override PartName="/xl/threadedComments/threadedComment${sheetId}.xml" ContentType="${THREADED_COMMENTS_CONTENT_TYPE}"/>`)
+        .join("");
+    const personOverride = hasPersons
+        ? `<Override PartName="/xl/persons/person.xml" ContentType="${PERSON_CONTENT_TYPE}"/>`
+        : "";
+    const externalLinkOverrides = Array.from({ length: externalLinkCount }, (_, index) => {
+        return `<Override PartName="/xl/externalLinks/externalLink${index + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml"/>`;
+    }).join("");
+    const mediaDefaults = mediaExtensions
+        .map((extension) => `<Default Extension="${extension}" ContentType="image/${extension}"/>`)
+        .join("");
+    const vmlDefault = commentsSheets.length
+        ? `<Default Extension="vml" ContentType="application/vnd.openxmlformats-officedocument.vmlDrawing"/>`
+        : "";
+    return `${XML_DECLARATION}<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/>${vmlDefault}${mediaDefaults}<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>${sheetOverrides}${tableOverrides}${drawingOverrides}${chartOverrides}${slicerOverrides}${slicerCacheOverrides}${pivotTableOverrides}${pivotCacheOverrides}${externalLinkOverrides}${commentsOverrides}${threadedCommentsOverrides}${personOverride}<Override PartName="/xl/theme/theme1.xml" ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/><Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/><Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/><Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/><Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/></Types>`;
+};
+const buildRootRelationshipsXml = () => {
+    return `${XML_DECLARATION}<Relationships xmlns="${PACKAGE_REL_NS}"><Relationship Id="rId1" Type="${REL_NS}/officeDocument" Target="xl/workbook.xml"/><Relationship Id="rId2" Type="${REL_NS}/extended-properties" Target="docProps/app.xml"/><Relationship Id="rId3" Type="${REL_NS}/core-properties" Target="docProps/core.xml"/></Relationships>`;
+};
+const buildAppXml = (sheetNames, properties) => {
+    const titles = sheetNames
+        .map((name) => `<vt:lpstr>${escapeXmlText(name)}</vt:lpstr>`)
+        .join("");
+    const application = properties?.application ?? CREATOR;
+    const companyTag = properties?.company
+        ? `<Company>${escapeXmlText(properties.company)}</Company>`
+        : "";
+    const managerTag = properties?.manager
+        ? `<Manager>${escapeXmlText(properties.manager)}</Manager>`
+        : "";
+    return `${XML_DECLARATION}<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"><Application>${escapeXmlText(application)}</Application><DocSecurity>0</DocSecurity><ScaleCrop>false</ScaleCrop><HeadingPairs><vt:vector size="2" baseType="variant"><vt:variant><vt:lpstr>Worksheets</vt:lpstr></vt:variant><vt:variant><vt:i4>${sheetNames.length}</vt:i4></vt:variant></vt:vector></HeadingPairs><TitlesOfParts><vt:vector size="${sheetNames.length}" baseType="lpstr">${titles}</vt:vector></TitlesOfParts>${companyTag}${managerTag}</Properties>`;
+};
+const buildCoreXml = (properties) => {
+    const now = new Date().toISOString();
+    const creator = properties?.creator ?? CREATOR;
+    const lastModifiedBy = properties?.lastModifiedBy ?? creator;
+    const created = properties?.created ?? now;
+    const modified = properties?.modified ?? now;
+    const tag = (name, value) => value ? `<${name}>${escapeXmlText(value)}</${name}>` : "";
+    return `${XML_DECLARATION}<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">${tag("dc:title", properties?.title)}${tag("dc:subject", properties?.subject)}<dc:creator>${escapeXmlText(creator)}</dc:creator>${tag("cp:keywords", properties?.keywords)}${tag("dc:description", properties?.description)}<cp:lastModifiedBy>${escapeXmlText(lastModifiedBy)}</cp:lastModifiedBy>${tag("cp:category", properties?.category)}<dcterms:created xsi:type="dcterms:W3CDTF">${escapeXmlText(created)}</dcterms:created><dcterms:modified xsi:type="dcterms:W3CDTF">${escapeXmlText(modified)}</dcterms:modified></cp:coreProperties>`;
+};