@lotics/xlsx 0.1.0

package/src/xlsx_writer.ts

@@ -0,0 +1,1549 @@
+// =============================================================================
+// .xlsx Export Writer
+// =============================================================================
+//
+// Serializes WorkbookModel → OOXML XML → ZIP (.xlsx).
+// Strategy: preserve unmodified parts from the original ZIP,
+// re-serialize only changed sheets/styles/shared strings.
+// =============================================================================
+
+import { zipSync, strToU8 } from "fflate";
+import type { WorkbookModel, SheetModel, CellModel } from "./workbook_model";
+import type { CellStyle, RichTextPart, RichTextFont } from "./types";
+import type { ParsedChart, ParsedTable, ParsedDrawing, ChartType, ChartSeries } from "./ooxml_chart_types";
+import type { ParsedConditionalFormat, ParsedCfStyle } from "./excel_cf_types";
+import { rowColToRef, refToRowCol, colNumToLetters } from "./excel_utils";
+import { hexToArgb, hexToOoxmlRgb } from "./ooxml_color";
+
+// =============================================================================
+// Pivot round-trip helpers
+// =============================================================================
+//
+// The writer regenerates workbook.xml, workbook.xml.rels, [Content_Types].xml,
+// and every per-sheet rels file. Pivot tables and caches live in their own
+// xml files (xl/pivotTables/*.xml, xl/pivotCache/*.xml) which the writer
+// passes through verbatim from `originalZip`. But we lose the cross-references
+// unless we reconstitute them here.
+//
+// `extractPivotRoundTripInfo` reads the *original* workbook + sheet rels from
+// the loaded ZIP and returns a structured snapshot the regenerated parts can
+// consult.
+// =============================================================================
+
+interface PivotRoundTripInfo {
+  /** cacheId → workbook-relative cache-definition path (e.g. "pivotCache/pivotCacheDefinition1.xml"). */
+  cachesByWorkbook: Map<number, string>;
+  /** Sheet index (0-based, in workbook order) → pivot table file paths
+   *  relative to the sheet (e.g. "../pivotTables/pivotTable1.xml"). */
+  pivotTablesBySheetIndex: Map<number, string[]>;
+  /** All pivot xml file paths (workbook-absolute) discovered in the original
+   *  zip. Used to add Content-Types overrides for each. */
+  pivotXmlPaths: string[];
+}
+
+function readWorkbookSheetOrder(originalZip: Record<string, Uint8Array>): string[] {
+  const wbBytes = originalZip["xl/workbook.xml"];
+  if (!wbBytes) return [];
+  const xml = decode(wbBytes);
+  // Match every <sheet ... r:id="rIdN"/> in document order. Workbook always
+  // emits sheets in the same order they appear here, so the index → rId map
+  // lets us follow the workbook rel target back to the sheet xml path.
+  const out: string[] = [];
+  const re = /<sheet\b[^>]*?r:id="([^"]+)"/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(xml)) !== null) {
+    out.push(m[1]);
+  }
+  return out;
+}
+
+function readWorkbookRels(
+  originalZip: Record<string, Uint8Array>,
+): Map<string, { type: string; target: string }> {
+  const out = new Map<string, { type: string; target: string }>();
+  const bytes = originalZip["xl/_rels/workbook.xml.rels"];
+  if (!bytes) return out;
+  const xml = decode(bytes);
+  const re = /<Relationship\b([^/]*?)\/>/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(xml)) !== null) {
+    const attrs = m[1];
+    const id = /\bId="([^"]+)"/.exec(attrs)?.[1];
+    const type = /\bType="([^"]+)"/.exec(attrs)?.[1] ?? "";
+    const target = /\bTarget="([^"]+)"/.exec(attrs)?.[1] ?? "";
+    if (id) out.set(id, { type, target });
+  }
+  return out;
+}
+
+function readPivotCacheIdMap(
+  originalZip: Record<string, Uint8Array>,
+): Map<number, string> {
+  // Returns cacheId → r:id from original workbook.xml's <pivotCaches>.
+  const out = new Map<number, string>();
+  const bytes = originalZip["xl/workbook.xml"];
+  if (!bytes) return out;
+  const xml = decode(bytes);
+  const re = /<pivotCache\b([^/]*?)\/>/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(xml)) !== null) {
+    const attrs = m[1];
+    const cacheIdMatch = /\bcacheId="(\d+)"/.exec(attrs);
+    const ridMatch = /\br:id="([^"]+)"/.exec(attrs);
+    if (cacheIdMatch && ridMatch) {
+      out.set(parseInt(cacheIdMatch[1], 10), ridMatch[1]);
+    }
+  }
+  return out;
+}
+
+function readSheetPivotPaths(
+  originalZip: Record<string, Uint8Array>,
+  sheetTarget: string,
+): string[] {
+  // sheetTarget is a workbook-rel path like "worksheets/sheet1.xml". The rels
+  // file lives next to it under _rels/. Extract pivot-table targets.
+  const sheetPath = `xl/${sheetTarget}`;
+  const relsPath = sheetPath.replace(/([^/]+)$/, "_rels/$1.rels");
+  const bytes = originalZip[relsPath];
+  if (!bytes) return [];
+  const xml = decode(bytes);
+  const re = /<Relationship\b([^/]*?)\/>/g;
+  const out: string[] = [];
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(xml)) !== null) {
+    const attrs = m[1];
+    const type = /\bType="([^"]+)"/.exec(attrs)?.[1] ?? "";
+    if (!type.includes("/pivotTable")) continue;
+    const target = /\bTarget="([^"]+)"/.exec(attrs)?.[1];
+    if (target) out.push(target);
+  }
+  return out;
+}
+
+function extractPivotRoundTripInfo(
+  originalZip: Record<string, Uint8Array> | undefined,
+): PivotRoundTripInfo {
+  const empty: PivotRoundTripInfo = {
+    cachesByWorkbook: new Map(),
+    pivotTablesBySheetIndex: new Map(),
+    pivotXmlPaths: [],
+  };
+  if (!originalZip) return empty;
+
+  const sheetRIds = readWorkbookSheetOrder(originalZip);
+  const wbRels = readWorkbookRels(originalZip);
+  const cacheRIds = readPivotCacheIdMap(originalZip);
+
+  // Cache id → cache xml path
+  const cachesByWorkbook = new Map<number, string>();
+  for (const [cacheId, rid] of cacheRIds) {
+    const rel = wbRels.get(rid);
+    if (!rel) continue;
+    cachesByWorkbook.set(cacheId, rel.target);
+  }
+
+  // Per-sheet pivot table file paths
+  const pivotTablesBySheetIndex = new Map<number, string[]>();
+  for (let i = 0; i < sheetRIds.length; i++) {
+    const sheetTarget = wbRels.get(sheetRIds[i])?.target;
+    if (!sheetTarget) continue;
+    const paths = readSheetPivotPaths(originalZip, sheetTarget);
+    if (paths.length > 0) pivotTablesBySheetIndex.set(i, paths);
+  }
+
+  // All pivot xml files in the zip (used for content_types overrides)
+  const pivotXmlPaths: string[] = [];
+  for (const path of Object.keys(originalZip)) {
+    if (path.startsWith("xl/pivotTables/") && path.endsWith(".xml")) {
+      pivotXmlPaths.push(path);
+    }
+    if (path.startsWith("xl/pivotCache/") && path.endsWith(".xml")) {
+      pivotXmlPaths.push(path);
+    }
+  }
+
+  return { cachesByWorkbook, pivotTablesBySheetIndex, pivotXmlPaths };
+}
+
+function decode(bytes: Uint8Array): string {
+  return new TextDecoder().decode(bytes);
+}
+
+function pivotContentTypeFor(path: string): string | undefined {
+  if (path.startsWith("xl/pivotTables/") && path.endsWith(".xml")) {
+    return `<Override PartName="/${path}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"/>`;
+  }
+  if (path.includes("/pivotCacheDefinition") && path.endsWith(".xml")) {
+    return `<Override PartName="/${path}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"/>`;
+  }
+  if (path.includes("/pivotCacheRecords") && path.endsWith(".xml")) {
+    return `<Override PartName="/${path}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"/>`;
+  }
+  return undefined;
+}
+
+// =============================================================================
+// Main export function
+// =============================================================================
+
+/**
+ * Export a workbook to .xlsx format.
+ * If originalZip is provided, unmodified entries are preserved.
+ */
+export function exportWorkbook(
+  workbook: WorkbookModel,
+  originalZip?: Record<string, Uint8Array>,
+): Uint8Array {
+  const entries: Record<string, Uint8Array> = {};
+
+  // Styles passthrough mode: when the in-memory model has no style mutations
+  // (no new styles interned, no new numFmtCodes registered) AND we have an
+  // original styles.xml to keep, the writer skips rebuilding the styles part
+  // entirely. Cells then write their original `s=` xf indexes (captured at
+  // load time as `cell.originalXfIndex`). This is the dominant fast path for
+  // value-only template fills (e.g. `generate_excel_from_template`).
+  const stylesPassthrough = !!originalZip && !workbook.styles.dirty && !!originalZip["xl/styles.xml"];
+
+  // Pass through unmodified files from original ZIP, excluding paths
+  // that will be regenerated (prevents stale/orphan entries)
+  if (originalZip) {
+    const regeneratedPaths = new Set<string>();
+    regeneratedPaths.add("xl/sharedStrings.xml");
+    if (!stylesPassthrough) regeneratedPaths.add("xl/styles.xml");
+    regeneratedPaths.add("xl/workbook.xml");
+    regeneratedPaths.add("xl/_rels/workbook.xml.rels");
+    regeneratedPaths.add("[Content_Types].xml");
+    regeneratedPaths.add("_rels/.rels");
+    regeneratedPaths.add("docProps/core.xml");
+    regeneratedPaths.add("docProps/app.xml");
+    for (let i = 0; i < workbook.sheets.length + 10; i++) {
+      regeneratedPaths.add(`xl/worksheets/sheet${i + 1}.xml`);
+      regeneratedPaths.add(`xl/worksheets/_rels/sheet${i + 1}.xml.rels`);
+    }
+    for (const path of Object.keys(originalZip)) {
+      if (path.startsWith("xl/drawings/") || path.startsWith("xl/charts/") || path.startsWith("xl/tables/") || path.startsWith("xl/media/")) {
+        regeneratedPaths.add(path);
+      }
+    }
+    for (const [path, data] of Object.entries(originalZip)) {
+      if (!regeneratedPaths.has(path)) entries[path] = data;
+    }
+  }
+
+  // Build shared strings
+  const sharedStrings = buildSharedStrings(workbook);
+  entries["xl/sharedStrings.xml"] = strToU8(sharedStrings.xml);
+
+  // Build styles only if we're not in passthrough mode. The xfMap is still
+  // needed for cells that don't have an originalXfIndex (e.g. cells created
+  // post-load with a brand-new style — but in that case dirty would be true
+  // and we'd take the regen path).
+  const stylesResult = stylesPassthrough
+    ? { xml: "", xfMap: new Map<string, number>(), numFmtMap: new Map<string, number>(), dxfMap: new Map<string, number>() }
+    : buildStylesXml(workbook);
+  if (!stylesPassthrough) entries["xl/styles.xml"] = strToU8(stylesResult.xml);
+
+  // Pivot round-trip: read original workbook.xml + sheet rels to recover the
+  // (cacheId → cacheDefinition path) and (sheet → pivotTable paths) mappings.
+  // The pivot xml files themselves pass through originalZip; we only need to
+  // re-emit the cross-references in the regenerated parts.
+  const pivotInfo = extractPivotRoundTripInfo(originalZip);
+
+  // Build workbook.xml
+  entries["xl/workbook.xml"] = strToU8(buildWorkbookXml(workbook, pivotInfo));
+
+  // Build workbook relationships
+  entries["xl/_rels/workbook.xml.rels"] = strToU8(
+    buildWorkbookRels(workbook, pivotInfo),
+  );
+
+  // Track extra content types for charts, images, tables
+  const extraContentTypes: string[] = [];
+
+  // Pivot xml files that pass through originalZip still need a content-type
+  // override so Excel doesn't reject them as unknown parts.
+  for (const path of pivotInfo.pivotXmlPaths) {
+    const ct = pivotContentTypeFor(path);
+    if (ct) extraContentTypes.push(ct);
+  }
+  let globalChartIndex = 1;
+  let globalImageIndex = 1;
+  let globalTableIndex = 1;
+
+  // Build each sheet + per-sheet drawings, charts, tables, images
+  for (let i = 0; i < workbook.sheets.length; i++) {
+    const sheet = workbook.sheets[i];
+    const sheetRels: string[] = [];
+    let nextRId = 1;
+
+    const hasCharts = sheet.charts.length > 0;
+    const hasImages = sheet.images.length > 0;
+    const hasDrawings = sheet.drawings.length > 0;
+    const hasTables = sheet.tables.length > 0;
+    const hasHyperlinks = sheet.hyperlinks.size > 0;
+    const needsDrawing = hasCharts || hasImages || hasDrawings;
+
+    // Hyperlink relationships (external links need rId)
+    const hyperlinkRIds = new Map<string, string>();
+    if (hasHyperlinks) {
+      for (const [ref, url] of sheet.hyperlinks) {
+        const rId = `rId${nextRId++}`;
+        hyperlinkRIds.set(ref, rId);
+        sheetRels.push(`<Relationship Id="${rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="${escapeXml(url)}" TargetMode="External"/>`);
+      }
+    }
+
+    // Drawing relationships (charts + images + shapes share a drawing)
+    let drawingRId = "";
+    if (needsDrawing) {
+      drawingRId = `rId${nextRId++}`;
+      sheetRels.push(`<Relationship Id="${drawingRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing" Target="../drawings/drawing${i + 1}.xml"/>`);
+
+      const drawingRels: string[] = [];
+      let drawingRelId = 1;
+      const drawingAnchors: string[] = [];
+
+      // Charts
+      for (const chart of sheet.charts) {
+        const chartRId = `rId${drawingRelId++}`;
+        const chartPath = `xl/charts/chart${globalChartIndex}.xml`;
+        entries[chartPath] = strToU8(buildChartXml(chart));
+        extraContentTypes.push(`<Override PartName="/${chartPath}" ContentType="application/vnd.openxmlformats-officedocument.drawingml.chart+xml"/>`);
+        drawingRels.push(`<Relationship Id="${chartRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart" Target="../charts/chart${globalChartIndex}.xml"/>`);
+        drawingAnchors.push(buildChartAnchorXml(chart, chartRId));
+        globalChartIndex++;
+      }
+
+      // Images
+      for (const image of sheet.images) {
+        const imgRId = `rId${drawingRelId++}`;
+        const ext = getImageExtension(image.dataUrl);
+        const imgPath = `xl/media/image${globalImageIndex}.${ext}`;
+        const imgBytes = dataUrlToBytes(image.dataUrl);
+        if (imgBytes) {
+          entries[imgPath] = imgBytes;
+          drawingRels.push(`<Relationship Id="${imgRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/image${globalImageIndex}.${ext}"/>`);
+          drawingAnchors.push(buildImageAnchorXml(image, imgRId));
+          globalImageIndex++;
+        }
+      }
+
+      // Shapes / textboxes / connectors
+      for (const drawing of sheet.drawings) {
+        drawingAnchors.push(buildShapeAnchorXml(drawing));
+      }
+
+      // Write drawing XML
+      entries[`xl/drawings/drawing${i + 1}.xml`] = strToU8(
+        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n` +
+        `<xdr:wsDr xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart">\n` +
+        drawingAnchors.join("\n") +
+        `\n</xdr:wsDr>`,
+      );
+      extraContentTypes.push(`<Override PartName="/xl/drawings/drawing${i + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.drawing+xml"/>`);
+
+      // Drawing rels
+      if (drawingRels.length > 0) {
+        entries[`xl/drawings/_rels/drawing${i + 1}.xml.rels`] = strToU8(
+          `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">\n${drawingRels.join("\n")}\n</Relationships>`,
+        );
+      }
+    }
+
+    // Tables
+    const tableRIds: string[] = [];
+    if (hasTables) {
+      for (const table of sheet.tables) {
+        const tableRId = `rId${nextRId++}`;
+        tableRIds.push(tableRId);
+        const tablePath = `xl/tables/table${globalTableIndex}.xml`;
+        entries[tablePath] = strToU8(buildTableXml(table, globalTableIndex));
+        extraContentTypes.push(`<Override PartName="/${tablePath}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"/>`);
+        sheetRels.push(`<Relationship Id="${tableRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/table" Target="../tables/table${globalTableIndex}.xml"/>`);
+        globalTableIndex++;
+      }
+    }
+
+    // Pivot tables: re-emit relationships pointing to the original pivot xml
+    // files (which pass through verbatim via originalZip).
+    const pivotTargets = pivotInfo.pivotTablesBySheetIndex.get(i);
+    if (pivotTargets && pivotTargets.length > 0) {
+      for (const target of pivotTargets) {
+        const rId = `rId${nextRId++}`;
+        sheetRels.push(
+          `<Relationship Id="${rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable" Target="${escapeXml(target)}"/>`,
+        );
+      }
+    }
+
+    // Write sheet rels if any
+    if (sheetRels.length > 0) {
+      entries[`xl/worksheets/_rels/sheet${i + 1}.xml.rels`] = strToU8(
+        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">\n${sheetRels.join("\n")}\n</Relationships>`,
+      );
+    }
+
+    // Build sheet XML
+    entries[`xl/worksheets/sheet${i + 1}.xml`] = strToU8(
+      buildSheetXml(sheet, workbook.styles, sharedStrings.index, i === workbook.activeSheetIndex, stylesResult.xfMap, stylesResult.numFmtMap, stylesResult.dxfMap, drawingRId, tableRIds, hyperlinkRIds),
+    );
+  }
+
+  // Document properties (required by Excel for full functionality)
+  entries["docProps/core.xml"] = strToU8(buildCoreProps());
+  entries["docProps/app.xml"] = strToU8(buildAppProps());
+
+  // Content Types
+  entries["[Content_Types].xml"] = strToU8(buildContentTypes(workbook.sheets.length, extraContentTypes));
+
+  // Root rels
+  entries["_rels/.rels"] = strToU8(buildRootRels());
+
+  return zipSync(entries, { level: 6 });
+}
+
+// =============================================================================
+// Shared strings
+// =============================================================================
+
+interface SharedStringsResult {
+  xml: string;
+  index: Map<string, number>;
+}
+
+function buildSharedStrings(workbook: WorkbookModel): SharedStringsResult {
+  const strings: string[] = [];
+  const index = new Map<string, number>();
+  // Track rich text parts for each unique string (first one wins)
+  const richTextMap = new Map<string, RichTextPart[]>();
+  let totalCount = 0;
+
+  for (const sheet of workbook.sheets) {
+    for (const cell of sheet.cells.values()) {
+      // Skip error cells and formula cells with string cached values — they use inline types
+      if (cell.error) continue;
+      if (cell.formula && typeof cell.value === "string") continue;
+
+      if (typeof cell.value === "string") {
+        totalCount++;
+        if (!index.has(cell.value)) {
+          index.set(cell.value, strings.length);
+          strings.push(cell.value);
+          if (cell.richText && cell.richText.length > 0) {
+            richTextMap.set(cell.value, cell.richText);
+          }
+        }
+      }
+    }
+  }
+
+  const siEntries = strings.map((s) => {
+    const richText = richTextMap.get(s);
+    if (richText) {
+      return `<si>${richText.map((part) => buildRichTextRun(part)).join("")}</si>`;
+    }
+    const needsPreserve = s.length === 0 || s !== s.trim();
+    const spaceAttr = needsPreserve ? ' xml:space="preserve"' : "";
+    return `<si><t${spaceAttr}>${escapeXml(s)}</t></si>`;
+  });
+
+  const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${totalCount}" uniqueCount="${strings.length}">
+${siEntries.join("\n")}
+</sst>`;
+
+  return { xml, index };
+}
+
+/** Build a single <r> element for a rich text run. */
+function buildRichTextRun(part: RichTextPart): string {
+  const needsPreserve = part.text.length === 0 || part.text !== part.text.trim();
+  const spaceAttr = needsPreserve ? ' xml:space="preserve"' : "";
+  if (!part.font) {
+    return `<r><t${spaceAttr}>${escapeXml(part.text)}</t></r>`;
+  }
+  return `<r>${buildRichTextRunProps(part.font)}<t${spaceAttr}>${escapeXml(part.text)}</t></r>`;
+}
+
+/** Build <rPr> element from RichTextFont. */
+function buildRichTextRunProps(font: RichTextFont): string {
+  let parts = "";
+  if (font.bold) parts += "<b/>";
+  if (font.italic) parts += "<i/>";
+  if (font.strike) parts += "<strike/>";
+  if (font.underline) parts += `<u val="${font.underline}"/>`;
+  if (font.vertAlign) parts += `<vertAlign val="${font.vertAlign}"/>`;
+  if (font.size) parts += `<sz val="${font.size}"/>`;
+  if (font.color) parts += `<color rgb="${hexToArgb(font.color)}"/>`;
+  if (font.name) parts += `<rFont val="${escapeXml(font.name)}"/>`;
+  return `<rPr>${parts}</rPr>`;
+}
+
+// =============================================================================
+// Styles
+// =============================================================================
+
+interface StylesResult {
+  xml: string;
+  xfMap: Map<string, number>; // "styleIdx:numFmtId" → xf index
+  numFmtMap: Map<string, number>; // numFmtCode → numFmtId
+  dxfMap: Map<string, number>; // serialized ParsedCfStyle → dxf index
+}
+
+function buildStylesXml(workbook: WorkbookModel): StylesResult {
+  // Collect all unique styles
+  const styles: CellStyle[] = [];
+  for (let i = 0; i < workbook.styles.size; i++) {
+    styles.push(workbook.styles.get(i));
+  }
+
+  // Collect unique number formats from cells
+  const numFmtMap = new Map<string, number>(); // numFmtCode → numFmtId
+  let nextNumFmtId = 164; // Excel reserves 0-163 for built-in formats
+  for (const sheet of workbook.sheets) {
+    for (const cell of sheet.cells.values()) {
+      if (cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "") {
+        if (!numFmtMap.has(cell.numFmtCode)) {
+          numFmtMap.set(cell.numFmtCode, nextNumFmtId++);
+        }
+      }
+    }
+  }
+
+  // Build per-cell numFmtId lookup: "sheetIdx:ref" → numFmtId
+  const cellNumFmtIds = new Map<string, number>();
+  for (let si = 0; si < workbook.sheets.length; si++) {
+    for (const [ref, cell] of workbook.sheets[si].cells) {
+      if (cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "") {
+        const id = numFmtMap.get(cell.numFmtCode);
+        if (id !== undefined) cellNumFmtIds.set(`${si}:${ref}`, id);
+      }
+    }
+  }
+
+  // Collect unique fonts
+  const fonts = new Map<string, number>();
+  const fontList: CellStyle[] = [];
+  fonts.set("default", 0);
+  fontList.push({});
+
+  for (const s of styles) {
+    const key = fontKey(s);
+    if (!fonts.has(key)) {
+      fonts.set(key, fontList.length);
+      fontList.push(s);
+    }
+  }
+
+  // Collect unique fills — each fill is keyed by a composite string to deduplicate
+  const fillEntries: string[] = []; // XML strings for each fill
+  const fillMap = new Map<string, number>(); // fillKey → fillId
+
+  // Excel requires exactly these 2 default fills at indices 0 and 1
+  fillEntries.push('<fill><patternFill patternType="none"/></fill>');
+  fillEntries.push('<fill><patternFill patternType="gray125"/></fill>');
+  fillMap.set("", 0); // empty/no fill → index 0
+
+  for (const s of styles) {
+    const fk = fillKey(s);
+    if (fk === "" || fillMap.has(fk)) continue;
+    fillMap.set(fk, fillEntries.length);
+    fillEntries.push(buildFillXml(s));
+  }
+
+  // Collect unique borders
+  const borderEntries: string[] = [];
+  const borderMap = new Map<string, number>();
+
+  // Default empty border at index 0
+  borderEntries.push("<border><left/><right/><top/><bottom/><diagonal/></border>");
+  borderMap.set("", 0);
+
+  for (const s of styles) {
+    const bk = borderKey(s);
+    if (bk === "" || borderMap.has(bk)) continue;
+    borderMap.set(bk, borderEntries.length);
+    borderEntries.push(buildBorderXml(s));
+  }
+
+  const fontsXml = fontList.map((f) => buildFontXml(f)).join("\n");
+  const fillsXml = fillEntries.join("\n");
+  const bordersXml = borderEntries.join("\n");
+
+  // Build numFmts XML
+  let numFmtsXml = "";
+  if (numFmtMap.size > 0) {
+    const entries = Array.from(numFmtMap.entries())
+      .map(([code, id]) => `<numFmt numFmtId="${id}" formatCode="${escapeXml(code)}"/>`)
+      .join("\n");
+    numFmtsXml = `<numFmts count="${numFmtMap.size}">\n${entries}\n</numFmts>\n`;
+  }
+
+  // Build a mapping from styleIndex to the set of numFmtIds used with that style.
+  // Since numFmtCode lives on CellModel, not CellStyle, we need to create separate
+  // xf entries for each (styleIndex, numFmtId) combination.
+  const xfEntries: string[] = [];
+  const xfMap = new Map<string, number>(); // "styleIdx:numFmtId" → xf index
+
+  for (let styleIdx = 0; styleIdx < styles.length; styleIdx++) {
+    const s = styles[styleIdx];
+    const fontId = fonts.get(fontKey(s)) ?? 0;
+    const fillId = fillMap.get(fillKey(s)) ?? 0;
+    const borderId = borderMap.get(borderKey(s)) ?? 0;
+
+    // Default entry: styleIdx with numFmtId=0
+    const xfKey = `${styleIdx}:0`;
+    xfMap.set(xfKey, xfEntries.length);
+    xfEntries.push(buildXfXml(s, fontId, fillId, borderId, 0));
+  }
+
+  // Add additional xf entries for cells that have custom numFmtIds
+  for (const [cellKey, numFmtId] of cellNumFmtIds) {
+    const [siStr, ref] = cellKey.split(":");
+    const cell = workbook.sheets[parseInt(siStr)].cells.get(ref);
+    if (!cell) continue;
+    const xfKey = `${cell.styleIndex}:${numFmtId}`;
+    if (xfMap.has(xfKey)) continue;
+    const s = styles[cell.styleIndex] ?? {};
+    const fontId = fonts.get(fontKey(s)) ?? 0;
+    const fillId = fillMap.get(fillKey(s)) ?? 0;
+    const borderId = borderMap.get(borderKey(s)) ?? 0;
+    xfMap.set(xfKey, xfEntries.length);
+    xfEntries.push(buildXfXml(s, fontId, fillId, borderId, numFmtId));
+  }
+
+  // Collect differential formatting (dxf) entries for style-based conditional formatting
+  const dxfEntries: string[] = [];
+  const dxfMap = new Map<string, number>(); // serialized style → dxf index
+
+  for (const sheet of workbook.sheets) {
+    for (const cf of sheet.conditionalFormats) {
+      for (const rule of cf.rules) {
+        if (rule.ruleType === "style" && rule.style) {
+          const key = JSON.stringify(rule.style);
+          if (!dxfMap.has(key)) {
+            dxfMap.set(key, dxfEntries.length);
+            dxfEntries.push(buildDxfXml(rule.style));
+          }
+        }
+      }
+    }
+  }
+
+  let dxfsXml = '<dxfs count="0"/>';
+  if (dxfEntries.length > 0) {
+    dxfsXml = `<dxfs count="${dxfEntries.length}">\n${dxfEntries.join("\n")}\n</dxfs>`;
+  }
+
+  const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+${numFmtsXml}<fonts count="${fontList.length}">
+${fontsXml}
+</fonts>
+<fills count="${fillEntries.length}">
+${fillsXml}
+</fills>
+<borders count="${borderEntries.length}">
+${bordersXml}
+</borders>
+<cellStyleXfs count="1">
+<xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>
+</cellStyleXfs>
+<cellXfs count="${xfEntries.length}">
+${xfEntries.join("\n")}
+</cellXfs>
+<cellStyles count="1">
+<cellStyle name="Normal" xfId="0" builtinId="0"/>
+</cellStyles>
+${dxfsXml}
+</styleSheet>`;
+
+  return { xml, xfMap, numFmtMap, dxfMap };
+}
+
+/** Build a single <xf> element for cellXfs (references cellStyleXfs via xfId). */
+function buildXfXml(s: CellStyle, fontId: number, fillId: number, borderId: number, numFmtId: number): string {
+  let attrs = `numFmtId="${numFmtId}" fontId="${fontId}" fillId="${fillId}" borderId="${borderId}" xfId="0"`;
+  if (numFmtId > 0) attrs += ' applyNumberFormat="1"';
+  if (fontId > 0) attrs += ' applyFont="1"';
+  if (fillId > 0) attrs += ' applyFill="1"';
+  if (borderId > 0) attrs += ' applyBorder="1"';
+  if (s.horizontalAlign || s.verticalAlign || s.wrapText || s.indent || s.textRotation || s.shrinkToFit) {
+    const hAlign = s.horizontalAlign ? ` horizontal="${s.horizontalAlign}"` : "";
+    const vAlign = s.verticalAlign ? ` vertical="${s.verticalAlign}"` : "";
+    const wrap = s.wrapText ? ' wrapText="1"' : "";
+    const indent = s.indent ? ` indent="${s.indent}"` : "";
+    const rotation = s.textRotation !== undefined ? ` textRotation="${s.textRotation === "vertical" ? 255 : s.textRotation}"` : "";
+    const shrink = s.shrinkToFit ? ' shrinkToFit="1"' : "";
+    return `<xf ${attrs} applyAlignment="1"><alignment${hAlign}${vAlign}${wrap}${indent}${rotation}${shrink}/></xf>`;
+  }
+  return `<xf ${attrs}/>`;
+}
+
+function fontKey(s: CellStyle): string {
+  return `${s.fontName ?? ""}|${s.fontSize ?? 0}|${s.fontBold ? 1 : 0}|${s.fontItalic ? 1 : 0}|${s.fontColor ?? ""}|${s.fontUnderline ?? ""}|${s.fontStrike ? 1 : 0}`;
+}
+
+function buildFontXml(s: CellStyle): string {
+  let parts = "";
+  if (s.fontBold) parts += "<b/>";
+  if (s.fontItalic) parts += "<i/>";
+  if (s.fontStrike) parts += "<strike/>";
+  if (s.fontUnderline) parts += `<u val="${s.fontUnderline}"/>`;
+  parts += `<sz val="${s.fontSize ?? 11}"/>`;
+  if (s.fontColor) {
+    parts += `<color rgb="${hexToArgb(s.fontColor)}"/>`;
+  } else {
+    parts += '<color theme="1"/>';
+  }
+  parts += `<name val="${escapeXml(s.fontName ?? "Calibri")}"/>`;
+  return `<font>${parts}</font>`;
+}
+
+/** Produce a deduplication key for a CellStyle's borders. */
+function borderKey(s: CellStyle): string {
+  const parts: string[] = [];
+  if (s.borderTop) parts.push(`t:${s.borderTop.style}:${s.borderTop.width}:${s.borderTop.color ?? ""}`);
+  if (s.borderRight) parts.push(`r:${s.borderRight.style}:${s.borderRight.width}:${s.borderRight.color ?? ""}`);
+  if (s.borderBottom) parts.push(`b:${s.borderBottom.style}:${s.borderBottom.width}:${s.borderBottom.color ?? ""}`);
+  if (s.borderLeft) parts.push(`l:${s.borderLeft.style}:${s.borderLeft.width}:${s.borderLeft.color ?? ""}`);
+  if (s.borderDiagonal) parts.push(`d:${s.borderDiagonal.style}:${s.borderDiagonal.width}:${s.borderDiagonal.color ?? ""}`);
+  if (s.diagonalUp) parts.push("du");
+  if (s.diagonalDown) parts.push("dd");
+  return parts.join("|");
+}
+
+/**
+ * Convert a CSS-like BorderStyle back to an OOXML border style name.
+ * The parser maps OOXML → CSS (thin→solid/1, medium→solid/2, thick→solid/3).
+ * This reverses that mapping.
+ */
+function toOoxmlBorderStyle(border: { width: number; style: string }): string {
+  // If the style is already an OOXML name, pass through
+  const ooxmlStyles = ["thin", "medium", "thick", "dotted", "dashed", "double", "hair",
+    "mediumDashed", "dashDot", "mediumDashDot", "dashDotDot", "mediumDashDotDot", "slantDashDot"];
+  if (ooxmlStyles.includes(border.style)) return border.style;
+
+  // Reverse the CSS mapping from ooxml_styles.ts
+  if (border.style === "solid") {
+    if (border.width <= 1) return "thin";
+    if (border.width <= 2) return "medium";
+    return "thick";
+  }
+  if (border.style === "dashed") return "dashed";
+  if (border.style === "dotted") return "dotted";
+  if (border.style === "double") return "double";
+  return "thin";
+}
+
+/** Build OOXML <border> element from a CellStyle. */
+function buildBorderXml(s: CellStyle): string {
+  let attrs = "";
+  if (s.diagonalUp) attrs += ' diagonalUp="1"';
+  if (s.diagonalDown) attrs += ' diagonalDown="1"';
+
+  const sides = [
+    { tag: "left", border: s.borderLeft },
+    { tag: "right", border: s.borderRight },
+    { tag: "top", border: s.borderTop },
+    { tag: "bottom", border: s.borderBottom },
+    { tag: "diagonal", border: s.borderDiagonal },
+  ];
+
+  const inner = sides.map(({ tag, border }) => {
+    if (!border) return `<${tag}/>`;
+    const ooxmlStyle = toOoxmlBorderStyle(border);
+    let colorXml = "";
+    if (border.color) {
+      colorXml = `<color rgb="${hexToArgb(border.color)}"/>`;
+    }
+    return `<${tag} style="${ooxmlStyle}">${colorXml}</${tag}>`;
+  }).join("");
+
+  return `<border${attrs}>${inner}</border>`;
+}
+
+/** Produce a deduplication key for a CellStyle's fill. */
+function fillKey(s: CellStyle): string {
+  if (s.gradientData) return `gradient:${JSON.stringify(s.gradientData)}`;
+  if (s.patternType && s.backgroundPattern) return `pattern:${s.patternType}|${s.backgroundPattern}`;
+  if (s.backgroundColor) return `solid:${s.backgroundColor}`;
+  return "";
+}
+
+/** Build OOXML <fill> element from a CellStyle. */
+function buildFillXml(s: CellStyle): string {
+  if (s.gradientData) {
+    const g = s.gradientData;
+    const stops = g.stops.map((stop) => {
+      const hex = hexToArgb(stop.color);
+      return `<stop position="${stop.position}"><color rgb="${hex}"/></stop>`;
+    }).join("");
+    if (g.type === "radial") {
+      return `<fill><gradientFill type="path" left="0.5" right="0.5" top="0.5" bottom="0.5">${stops}</gradientFill></fill>`;
+    }
+    return `<fill><gradientFill degree="${g.degree}">${stops}</gradientFill></fill>`;
+  }
+
+  if (s.patternType && s.backgroundPattern) {
+    const colors = extractFillColors(s.backgroundPattern);
+    let colorAttrs = "";
+    if (colors.fg) colorAttrs += `<fgColor rgb="${hexToArgb(colors.fg)}"/>`;
+    if (colors.bg) colorAttrs += `<bgColor rgb="${hexToArgb(colors.bg)}"/>`;
+    return `<fill><patternFill patternType="${escapeXml(s.patternType)}">${colorAttrs}</patternFill></fill>`;
+  }
+
+  // Solid fill
+  return `<fill><patternFill patternType="solid"><fgColor rgb="${hexToArgb(s.backgroundColor)}"/></patternFill></fill>`;
+}
+
+/** Extract fg/bg colors from a CSS pattern string. */
+function extractFillColors(css: string): { fg: string | undefined; bg: string | undefined } {
+  const colorMatches = css.match(/rgba?\([^)]+\)/g);
+  if (colorMatches) {
+    return { fg: colorMatches[0], bg: colorMatches[1] };
+  }
+  const hexMatches = css.match(/#[0-9a-fA-F]{6}/g);
+  if (hexMatches) {
+    return { fg: hexMatches[0], bg: hexMatches[1] };
+  }
+  return { fg: undefined, bg: undefined };
+}
+
+// =============================================================================
+// Sheet XML
+// =============================================================================
+
+function buildSheetXml(
+  sheet: SheetModel,
+  styles: WorkbookModel["styles"],
+  ssIndex: Map<string, number>,
+  isActive: boolean,
+  xfMap: Map<string, number>,
+  numFmtMap: Map<string, number>,
+  dxfMap: Map<string, number>,
+  drawingRId?: string,
+  tableRIds?: string[],
+  hyperlinkRIds?: Map<string, string>,
+): string {
+  const rows: string[] = [];
+
+  // Group cells by row
+  const rowMap = new Map<number, Array<{ col: number; cell: CellModel }>>();
+  for (const [ref, cell] of sheet.cells) {
+    const rc = refToRowCol(ref);
+    if (!rc) continue;
+    let arr = rowMap.get(rc.row);
+    if (!arr) {
+      arr = [];
+      rowMap.set(rc.row, arr);
+    }
+    arr.push({ col: rc.col, cell });
+  }
+
+  const sortedRows = Array.from(rowMap.keys()).sort((a, b) => a - b);
+  for (const rowNum of sortedRows) {
+    const cells = rowMap.get(rowNum)!;
+    cells.sort((a, b) => a.col - b.col);
+
+    const h = sheet.rowHeights.get(rowNum);
+    const rowAttrs = h ? ` ht="${h}" customHeight="1"` : "";
+    const hidden = sheet.hiddenRows.has(rowNum) ? ' hidden="1"' : "";
+
+    const cellsXml = cells.map(({ col, cell }) => {
+      const ref = rowColToRef(rowNum, col);
+      const type = getCellType(cell, ssIndex);
+      const value = getCellValue(cell, ssIndex);
+      let attrs = `r="${ref}"`;
+
+      // Resolve the correct xf index. In styles-passthrough mode (xfMap is
+      // empty), use the cell's `originalXfIndex` captured at parse time.
+      // Otherwise compute via the rebuilt xfMap keyed by styleIndex+numFmtId.
+      let xfIndex = 0;
+      if (xfMap.size === 0 && cell.originalXfIndex !== undefined) {
+        xfIndex = cell.originalXfIndex;
+      } else {
+        const numFmtId = (cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "")
+          ? (numFmtMap.get(cell.numFmtCode) ?? 0)
+          : 0;
+        const xfKey = `${cell.styleIndex}:${numFmtId}`;
+        xfIndex = xfMap.get(xfKey) ?? 0;
+      }
+      if (xfIndex > 0) attrs += ` s="${xfIndex}"`;
+      if (type) attrs += ` t="${type}"`;
+
+      let inner = "";
+      if (cell.formula) {
+        if (cell.isArrayFormula && cell.arrayRange) {
+          inner += `<f t="array" ref="${cell.arrayRange}">${escapeXml(cell.formula)}</f>`;
+        } else {
+          inner += `<f>${escapeXml(cell.formula)}</f>`;
+        }
+      }
+      if (value !== undefined) inner += `<v>${escapeXml(String(value))}</v>`;
+      return `<c ${attrs}>${inner}</c>`;
+    }).join("");
+
+    rows.push(`<row r="${rowNum}"${rowAttrs}${hidden}>${cellsXml}</row>`);
+  }
+
+  // Column definitions
+  const cols: string[] = [];
+  const allCols = new Set([...sheet.colWidths.keys(), ...sheet.hiddenCols]);
+  for (const c of Array.from(allCols).sort((a, b) => a - b)) {
+    const w = sheet.colWidths.get(c) ?? sheet.defaultColWidth;
+    const hidden = sheet.hiddenCols.has(c) ? ' hidden="1"' : "";
+    cols.push(`<col min="${c}" max="${c}" width="${w}" customWidth="1"${hidden}/>`);
+  }
+
+  // Merged cells
+  let mergeXml = "";
+  if (sheet.mergedCells.length > 0) {
+    const merges = sheet.mergedCells.map((r) => `<mergeCell ref="${r}"/>`).join("");
+    mergeXml = `<mergeCells count="${sheet.mergedCells.length}">${merges}</mergeCells>`;
+  }
+
+  // Freeze pane + selection
+  let paneXml = "";
+  let selectionXml = `<selection activeCell="A1" sqref="A1"/>`;
+  if (sheet.freeze) {
+    const activePane = sheet.freeze.col > 0 && sheet.freeze.row > 0
+      ? "bottomRight"
+      : sheet.freeze.row > 0 ? "bottomLeft" : "topRight";
+    const topLeft = rowColToRef(sheet.freeze.row + 1, sheet.freeze.col + 1);
+    paneXml = `<pane xSplit="${sheet.freeze.col}" ySplit="${sheet.freeze.row}" topLeftCell="${topLeft}" activePane="${activePane}" state="frozen"/>`;
+    selectionXml = `<selection pane="${activePane}" activeCell="${topLeft}" sqref="${topLeft}"/>`;
+  }
+
+  const tabSelected = isActive ? ' tabSelected="1"' : '';
+  const sheetView = `<sheetView${tabSelected} workbookViewId="0"${!sheet.view.showGridLines ? ' showGridLines="0"' : ""}>${paneXml}${selectionXml}</sheetView>`;
+
+  // Auto-filter
+  let autoFilterXml = "";
+  if (sheet.autoFilter) {
+    let filterCols = "";
+    for (const col of sheet.autoFilter.columns) {
+      if (col.filterValues && col.filterValues.length > 0) {
+        const filters = col.filterValues.map((v) => `<filter val="${escapeXml(v)}"/>`).join("");
+        filterCols += `<filterColumn colId="${col.colIndex}"><filters>${filters}</filters></filterColumn>`;
+      }
+    }
+    autoFilterXml = `<autoFilter ref="${sheet.autoFilter.ref}">${filterCols}</autoFilter>`;
+  }
+
+  // Data validations
+  let dvXml = "";
+  if (sheet.dataValidations.length > 0) {
+    const dvEntries = sheet.dataValidations.map((dv) => {
+      let attrs = `sqref="${dv.ref}" type="${dv.type}"`;
+      if (dv.operator) attrs += ` operator="${dv.operator}"`;
+      if (!dv.showDropdown) attrs += ' showDropDown="1"';
+      if (dv.errorStyle) attrs += ` errorStyle="${dv.errorStyle}"`;
+      if (dv.errorTitle) attrs += ` errorTitle="${escapeXml(dv.errorTitle)}"`;
+      if (dv.errorMessage) attrs += ` error="${escapeXml(dv.errorMessage)}"`;
+      if (dv.promptTitle) attrs += ` promptTitle="${escapeXml(dv.promptTitle)}"`;
+      if (dv.promptMessage) attrs += ` prompt="${escapeXml(dv.promptMessage)}"`;
+      let inner = "";
+      if (dv.formula1) inner += `<formula1>${escapeXml(dv.formula1)}</formula1>`;
+      if (dv.formula2) inner += `<formula2>${escapeXml(dv.formula2)}</formula2>`;
+      return `<dataValidation ${attrs}>${inner}</dataValidation>`;
+    }).join("");
+    dvXml = `<dataValidations count="${sheet.dataValidations.length}">${dvEntries}</dataValidations>`;
+  }
+
+  // Conditional formatting
+  let cfXml = "";
+  if (sheet.conditionalFormats.length > 0) {
+    cfXml = sheet.conditionalFormats.map((cf) => buildConditionalFormattingXml(cf, dxfMap)).join("");
+  }
+
+  // Hyperlinks
+  let hyperlinksXml = "";
+  if (hyperlinkRIds && hyperlinkRIds.size > 0) {
+    const hlEntries = Array.from(hyperlinkRIds.entries())
+      .map(([ref, rId]) => `<hyperlink ref="${ref}" r:id="${rId}"/>`)
+      .join("");
+    hyperlinksXml = `<hyperlinks>${hlEntries}</hyperlinks>`;
+  }
+
+  // Drawing reference
+  const drawingXml = drawingRId ? `<drawing r:id="${drawingRId}"/>` : "";
+
+  // Table parts
+  let tablePartsXml = "";
+  if (tableRIds && tableRIds.length > 0) {
+    const parts = tableRIds.map((rId) => `<tablePart r:id="${rId}"/>`).join("");
+    tablePartsXml = `<tableParts count="${tableRIds.length}">${parts}</tableParts>`;
+  }
+
+  // Page setup + header/footer
+  const ps = sheet.pageSetup;
+  const hf = sheet.headerFooter;
+  const fitToPage = ps && (ps.fitToWidth !== undefined || ps.fitToHeight !== undefined);
+  const sheetPrXml = fitToPage
+    ? `<sheetPr><pageSetUpPr fitToPage="1"/></sheetPr>`
+    : "";
+
+  const marginsXml = (() => {
+    const m = ps?.margins;
+    const left = m?.left ?? 0.7;
+    const right = m?.right ?? 0.7;
+    const top = m?.top ?? 0.75;
+    const bottom = m?.bottom ?? 0.75;
+    const header = m?.header ?? 0.3;
+    const footer = m?.footer ?? 0.3;
+    return `<pageMargins left="${left}" right="${right}" top="${top}" bottom="${bottom}" header="${header}" footer="${footer}"/>`;
+  })();
+
+  let pageSetupXml = "";
+  if (ps) {
+    const attrs: string[] = [];
+    if (ps.paperSize !== undefined) attrs.push(`paperSize="${ps.paperSize}"`);
+    if (ps.scale !== undefined) attrs.push(`scale="${ps.scale}"`);
+    if (ps.fitToWidth !== undefined) attrs.push(`fitToWidth="${ps.fitToWidth}"`);
+    if (ps.fitToHeight !== undefined) attrs.push(`fitToHeight="${ps.fitToHeight}"`);
+    if (ps.orientation) attrs.push(`orientation="${ps.orientation}"`);
+    if (attrs.length > 0) pageSetupXml = `<pageSetup ${attrs.join(" ")}/>`;
+  }
+
+  let headerFooterXml = "";
+  if (hf) {
+    const rootAttrs: string[] = [];
+    if (hf.differentOddEven) rootAttrs.push(`differentOddEven="1"`);
+    if (hf.differentFirst) rootAttrs.push(`differentFirst="1"`);
+    const inner: string[] = [];
+    if (hf.oddHeader) inner.push(`<oddHeader>${escapeXml(hf.oddHeader)}</oddHeader>`);
+    if (hf.oddFooter) inner.push(`<oddFooter>${escapeXml(hf.oddFooter)}</oddFooter>`);
+    if (hf.evenHeader) inner.push(`<evenHeader>${escapeXml(hf.evenHeader)}</evenHeader>`);
+    if (hf.evenFooter) inner.push(`<evenFooter>${escapeXml(hf.evenFooter)}</evenFooter>`);
+    if (hf.firstHeader) inner.push(`<firstHeader>${escapeXml(hf.firstHeader)}</firstHeader>`);
+    if (hf.firstFooter) inner.push(`<firstFooter>${escapeXml(hf.firstFooter)}</firstFooter>`);
+    if (inner.length > 0) {
+      const attrStr = rootAttrs.length > 0 ? ` ${rootAttrs.join(" ")}` : "";
+      headerFooterXml = `<headerFooter${attrStr}>${inner.join("")}</headerFooter>`;
+    }
+  }
+
+  // Compute dimension from cell extent
+  let dimensionRef = "A1";
+  if (sortedRows.length > 0) {
+    let minCol = Infinity, maxCol = 0;
+    const minRow = sortedRows[0];
+    const maxRow = sortedRows[sortedRows.length - 1];
+    for (const rowNum of sortedRows) {
+      const cells = rowMap.get(rowNum)!;
+      for (const { col } of cells) {
+        if (col < minCol) minCol = col;
+        if (col > maxCol) maxCol = col;
+      }
+    }
+    dimensionRef = `${rowColToRef(minRow, minCol)}:${rowColToRef(maxRow, maxCol)}`;
+  }
+
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+${sheetPrXml}<dimension ref="${dimensionRef}"/>
+<sheetViews>${sheetView}</sheetViews>
+<sheetFormatPr defaultRowHeight="${sheet.defaultRowHeight}" defaultColWidth="${sheet.defaultColWidth}"/>
+${cols.length > 0 ? `<cols>${cols.join("")}</cols>` : ""}
+<sheetData>
+${rows.join("\n")}
+</sheetData>
+${autoFilterXml}${mergeXml}${cfXml}${dvXml}${hyperlinksXml}${marginsXml}${pageSetupXml}${headerFooterXml}${drawingXml}${tablePartsXml}
+</worksheet>`;
+}
+
+function getCellType(cell: CellModel, ssIndex: Map<string, number>): string | undefined {
+  if (cell.error) return "e";
+  if (cell.formula && typeof cell.value === "string") return "str";
+  if (typeof cell.value === "string" && ssIndex.has(cell.value)) return "s";
+  if (typeof cell.value === "boolean") return "b";
+  return undefined;
+}
+
+function getCellValue(cell: CellModel, ssIndex: Map<string, number>): string | number | undefined {
+  if (cell.value === null) return undefined;
+  if (cell.error) return cell.error;
+  if (cell.formula && typeof cell.value === "string") return cell.value;
+  if (typeof cell.value === "string") {
+    const idx = ssIndex.get(cell.value);
+    return idx !== undefined ? idx : cell.value;
+  }
+  if (typeof cell.value === "boolean") return cell.value ? 1 : 0;
+  return cell.value;
+}
+
+// =============================================================================
+// Workbook XML
+// =============================================================================
+
+/** Wrap sheet name in single quotes if it contains non-alphanumeric chars. */
+function quoteSheetName(name: string): string {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name)
+    ? name
+    : `'${name.replace(/'/g, "''")}'`;
+}
+
+function buildWorkbookXml(workbook: WorkbookModel, pivotInfo?: PivotRoundTripInfo): string {
+  const sheets = workbook.sheets.map((s, i) =>
+    `<sheet name="${escapeXml(s.name)}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`,
+  ).join("\n");
+
+  const nameEntries: string[] = [];
+
+  for (const [name, value] of workbook.namedRanges) {
+    nameEntries.push(`<definedName name="${escapeXml(name)}">${escapeXml(value)}</definedName>`);
+  }
+
+  workbook.sheets.forEach((s, i) => {
+    const pt = s.printTitles;
+    if (!pt || (!pt.repeatRows && !pt.repeatCols)) return;
+    const parts: string[] = [];
+    const sheetName = quoteSheetName(s.name);
+    if (pt.repeatCols) {
+      const [start, end] = pt.repeatCols;
+      parts.push(`${sheetName}!$${colNumToLetters(start)}:$${colNumToLetters(end)}`);
+    }
+    if (pt.repeatRows) {
+      const [start, end] = pt.repeatRows;
+      parts.push(`${sheetName}!$${start}:$${end}`);
+    }
+    nameEntries.push(
+      `<definedName name="_xlnm.Print_Titles" localSheetId="${i}">${escapeXml(parts.join(","))}</definedName>`,
+    );
+  });
+
+  const definedNames = nameEntries.length > 0
+    ? `\n<definedNames>\n${nameEntries.join("\n")}\n</definedNames>`
+    : "";
+
+  // Re-emit <pivotCaches> if the original file had any. The rId for each
+  // cache comes after the per-sheet rIds + styles + sharedStrings, mirroring
+  // the order in `buildWorkbookRels`.
+  let pivotCachesBlock = "";
+  if (pivotInfo && pivotInfo.cachesByWorkbook.size > 0) {
+    const baseRId = workbook.sheets.length + 3; // sheets + styles + sharedStrings
+    const cacheIds = [...pivotInfo.cachesByWorkbook.keys()].sort((a, b) => a - b);
+    const items = cacheIds
+      .map((cacheId, i) => `<pivotCache cacheId="${cacheId}" r:id="rId${baseRId + i}"/>`)
+      .join("\n");
+    pivotCachesBlock = `\n<pivotCaches>\n${items}\n</pivotCaches>`;
+  }
+
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<bookViews>
+<workbookView activeTab="${workbook.activeSheetIndex}"/>
+</bookViews>
+<sheets>
+${sheets}
+</sheets>${definedNames}${pivotCachesBlock}
+<calcPr fullCalcOnLoad="1"/>
+</workbook>`;
+}
+
+function buildWorkbookRels(
+  workbook: WorkbookModel,
+  pivotInfo?: PivotRoundTripInfo,
+): string {
+  const rels = workbook.sheets.map((_, i) =>
+    `<Relationship Id="rId${i + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${i + 1}.xml"/>`,
+  );
+  rels.push(`<Relationship Id="rId${workbook.sheets.length + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`);
+  rels.push(`<Relationship Id="rId${workbook.sheets.length + 2}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`);
+
+  if (pivotInfo && pivotInfo.cachesByWorkbook.size > 0) {
+    const baseRId = workbook.sheets.length + 3;
+    const cacheIds = [...pivotInfo.cachesByWorkbook.keys()].sort((a, b) => a - b);
+    cacheIds.forEach((cacheId, i) => {
+      const target = pivotInfo.cachesByWorkbook.get(cacheId);
+      if (!target) return;
+      rels.push(
+        `<Relationship Id="rId${baseRId + i}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition" Target="${escapeXml(target)}"/>`,
+      );
+    });
+  }
+
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+${rels.join("\n")}
+</Relationships>`;
+}
+
+// =============================================================================
+// Content Types
+// =============================================================================
+
+function buildContentTypes(sheetCount: number, extraTypes: string[] = []): string {
+  const sheetTypes = Array.from({ length: sheetCount }, (_, i) =>
+    `<Override PartName="/xl/worksheets/sheet${i + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`,
+  ).join("\n");
+
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<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"/>
+<Default Extension="png" ContentType="image/png"/>
+<Default Extension="jpeg" ContentType="image/jpeg"/>
+<Default Extension="jpg" ContentType="image/jpeg"/>
+<Default Extension="gif" ContentType="image/gif"/>
+<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+${sheetTypes}
+<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"/>
+${extraTypes.join("\n")}
+</Types>`;
+}
+
+function buildRootRels(): string {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
+<Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
+</Relationships>`;
+}
+
+function buildCoreProps(): string {
+  const now = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<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:xsi="http://www.w3.org/2001/XMLSchema-instance">
+<dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>
+<dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>
+</cp:coreProperties>`;
+}
+
+function buildAppProps(): string {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">
+<Application>Microsoft Excel</Application>
+</Properties>`;
+}
+
+// =============================================================================
+// Chart XML
+// =============================================================================
+
+const CHART_TYPE_MAP: Record<string, string> = {
+  bar: "c:barChart", col: "c:barChart", line: "c:lineChart", pie: "c:pieChart",
+  doughnut: "c:doughnutChart", area: "c:areaChart", scatter: "c:scatterChart",
+  bubble: "c:bubbleChart", radar: "c:radarChart", stock: "c:stockChart",
+  surface: "c:surfaceChart",
+};
+
+function buildSeriesXml(s: ChartSeries, idx: number, chartType: ChartType, categories?: string[]): string {
+  let nameXml = "";
+  if (s.name) nameXml = `<c:tx><c:strRef><c:strCache><c:ptCount val="1"/><c:pt idx="0"><c:v>${escapeXml(s.name)}</c:v></c:pt></c:strCache></c:strRef></c:tx>`;
+
+  let colorXml = "";
+  if (s.color) colorXml = `<c:spPr><a:solidFill><a:srgbClr val="${hexToOoxmlRgb(s.color)}"/></a:solidFill></c:spPr>`;
+
+  const valTag = chartType === "scatter" || chartType === "bubble" ? "c:yVal" : "c:val";
+  const valPts = s.values.map((v, i) => `<c:pt idx="${i}"><c:v>${v}</c:v></c:pt>`).join("");
+  const valXml = `<${valTag}><c:numRef><c:numCache><c:ptCount val="${s.values.length}"/>${valPts}</c:numCache></c:numRef></${valTag}>`;
+
+  let catXml = "";
+  if (categories && categories.length > 0) {
+    const catTag = chartType === "scatter" || chartType === "bubble" ? "c:xVal" : "c:cat";
+    const catPts = categories.map((c, i) => `<c:pt idx="${i}"><c:v>${escapeXml(c)}</c:v></c:pt>`).join("");
+    catXml = `<${catTag}><c:strRef><c:strCache><c:ptCount val="${categories.length}"/>${catPts}</c:strCache></c:strRef></${catTag}>`;
+  }
+
+  let bubbleXml = "";
+  if (s.bubbleSizes) {
+    const bPts = s.bubbleSizes.map((v, i) => `<c:pt idx="${i}"><c:v>${v}</c:v></c:pt>`).join("");
+    bubbleXml = `<c:bubbleSize><c:numRef><c:numCache><c:ptCount val="${s.bubbleSizes.length}"/>${bPts}</c:numCache></c:numRef></c:bubbleSize>`;
+  }
+
+  return `<c:ser><c:idx val="${idx}"/><c:order val="${idx}"/>${nameXml}${colorXml}${catXml}${valXml}${bubbleXml}</c:ser>`;
+}
+
+function buildChartTypeElement(chartType: ChartType, seriesXml: string, needsAxIds: boolean): string {
+  const chartTag = CHART_TYPE_MAP[chartType] ?? "c:barChart";
+  const isBar = chartType === "bar";
+
+  let barDir = "";
+  if (chartTag === "c:barChart") {
+    barDir = isBar ? '<c:barDir val="bar"/>' : '<c:barDir val="col"/>';
+  }
+
+  let grouping = "";
+  if (chartTag === "c:barChart") {
+    grouping = '<c:grouping val="clustered"/>';
+  } else if (chartTag === "c:lineChart" || chartTag === "c:areaChart") {
+    grouping = '<c:grouping val="clustered"/>';
+  }
+
+  const axIds = needsAxIds ? '<c:axId val="1"/><c:axId val="2"/>' : "";
+
+  return `<${chartTag}>${barDir}${grouping}${seriesXml}${axIds}</${chartTag}>`;
+}
+
+function buildChartXml(chart: ParsedChart): string {
+  const needsAxIds = chart.chartType !== "pie" && chart.chartType !== "doughnut";
+
+  let plotArea: string;
+
+  if (chart.chartType === "combo") {
+    // Group series by their seriesChartType
+    const groups = new Map<ChartType, { series: ChartSeries; idx: number }[]>();
+    chart.series.forEach((s, idx) => {
+      const sType = s.seriesChartType ?? "col";
+      let group = groups.get(sType);
+      if (!group) {
+        group = [];
+        groups.set(sType, group);
+      }
+      group.push({ series: s, idx });
+    });
+
+    let chartElements = "";
+    for (const [groupType, groupSeries] of groups) {
+      const groupSeriesXml = groupSeries.map(({ series, idx }) =>
+        buildSeriesXml(series, idx, groupType, chart.categories),
+      ).join("");
+      chartElements += buildChartTypeElement(groupType, groupSeriesXml, true);
+    }
+
+    plotArea = `<c:plotArea><c:layout/>${chartElements}`;
+  } else {
+    const seriesXml = chart.series.map((s, idx) =>
+      buildSeriesXml(s, idx, chart.chartType, chart.categories),
+    ).join("");
+    plotArea = `<c:plotArea><c:layout/>${buildChartTypeElement(chart.chartType, seriesXml, needsAxIds)}`;
+  }
+
+  // Axes (not for pie/doughnut)
+  if (chart.chartType !== "pie" && chart.chartType !== "doughnut") {
+    const axes = chart.axes ?? [{ type: "category" as const }, { type: "value" as const }];
+    for (let i = 0; i < axes.length; i++) {
+      const ax = axes[i];
+      const axId = i + 1;
+      const crossId = i === 0 ? 2 : 1;
+      let axTag: string;
+      switch (ax.type) {
+        case "value": axTag = "c:valAx"; break;
+        case "date": axTag = "c:dateAx"; break;
+        case "series": axTag = "c:serAx"; break;
+        default: axTag = "c:catAx"; break;
+      }
+      let titleXml = "";
+      if (ax.title) titleXml = `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(ax.title)}</a:t></a:r></a:p></c:rich></c:tx></c:title>`;
+      let scalingXml = "<c:scaling><c:orientation val=\"minMax\"/>";
+      if (ax.min !== undefined) scalingXml += `<c:min val="${ax.min}"/>`;
+      if (ax.max !== undefined) scalingXml += `<c:max val="${ax.max}"/>`;
+      scalingXml += "</c:scaling>";
+      const numFmt = ax.numFmt ? `<c:numFmt formatCode="${escapeXml(ax.numFmt)}" sourceLinked="0"/>` : "";
+      plotArea += `<${axTag}><c:axId val="${axId}"/>${scalingXml}${titleXml}${numFmt}<c:crossAx val="${crossId}"/></${axTag}>`;
+    }
+  }
+  plotArea += "</c:plotArea>";
+
+  let titleXml = "";
+  if (chart.title) {
+    titleXml = `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(chart.title)}</a:t></a:r></a:p></c:rich></c:tx></c:title>`;
+  }
+
+  let legendXml = "";
+  if (chart.legendPosition && chart.legendPosition !== "none") {
+    const posMap: Record<string, string> = { top: "t", bottom: "b", left: "l", right: "r" };
+    legendXml = `<c:legend><c:legendPos val="${posMap[chart.legendPosition] ?? "b"}"/></c:legend>`;
+  }
+
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<c:chart>${titleXml}${plotArea}${legendXml}</c:chart>
+</c:chartSpace>`;
+}
+
+// =============================================================================
+// Drawing anchors (charts, images, shapes)
+// =============================================================================
+
+function buildAnchorPosition(pos: { row: number; col: number; rowOffset?: number; colOffset?: number }): string {
+  return `<xdr:col>${pos.col}</xdr:col><xdr:colOff>${pos.colOffset ?? 0}</xdr:colOff><xdr:row>${pos.row}</xdr:row><xdr:rowOff>${pos.rowOffset ?? 0}</xdr:rowOff>`;
+}
+
+function buildChartAnchorXml(chart: ParsedChart, rId: string): string {
+  return `<xdr:twoCellAnchor>
+<xdr:from>${buildAnchorPosition(chart.anchor.from)}</xdr:from>
+<xdr:to>${buildAnchorPosition(chart.anchor.to)}</xdr:to>
+<xdr:graphicFrame macro="">
+<xdr:nvGraphicFramePr><xdr:cNvPr id="0" name="Chart"/><xdr:cNvGraphicFramePr/></xdr:nvGraphicFramePr>
+<xdr:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></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" r:id="${rId}"/></a:graphicData></a:graphic>
+</xdr:graphicFrame>
+<xdr:clientData/>
+</xdr:twoCellAnchor>`;
+}
+
+function buildImageAnchorXml(image: { tl: { row: number; col: number }; br: { row: number; col: number } }, rId: string): string {
+  return `<xdr:twoCellAnchor editAs="oneCell">
+<xdr:from>${buildAnchorPosition(image.tl)}</xdr:from>
+<xdr:to>${buildAnchorPosition(image.br)}</xdr:to>
+<xdr:pic>
+<xdr:nvPicPr><xdr:cNvPr id="0" name="Image"/><xdr:cNvPicPr/></xdr:nvPicPr>
+<xdr:blipFill><a:blip xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:embed="${rId}"/><a:stretch><a:fillRect/></a:stretch></xdr:blipFill>
+<xdr:spPr><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></xdr:spPr>
+</xdr:pic>
+<xdr:clientData/>
+</xdr:twoCellAnchor>`;
+}
+
+function buildShapeAnchorXml(drawing: ParsedDrawing): string {
+  let fillXml = "";
+  if (drawing.fillColor) fillXml = `<a:solidFill><a:srgbClr val="${hexToOoxmlRgb(drawing.fillColor)}"/></a:solidFill>`;
+
+  let outlineXml = "";
+  if (drawing.outlineColor) {
+    const w = Math.round((drawing.outlineWidth ?? 1) * 12700); // points to EMU
+    outlineXml = `<a:ln w="${w}"><a:solidFill><a:srgbClr val="${hexToOoxmlRgb(drawing.outlineColor)}"/></a:solidFill></a:ln>`;
+  }
+
+  const geom = drawing.geometry ?? "rect";
+  let textXml = "";
+  if (drawing.text) textXml = `<xdr:txBody><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(drawing.text)}</a:t></a:r></a:p></xdr:txBody>`;
+
+  return `<xdr:twoCellAnchor>
+<xdr:from>${buildAnchorPosition(drawing.anchor.from)}</xdr:from>
+<xdr:to>${buildAnchorPosition(drawing.anchor.to)}</xdr:to>
+<xdr:sp><xdr:nvSpPr><xdr:cNvPr id="0" name="Shape"/><xdr:cNvSpPr/></xdr:nvSpPr>
+<xdr:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></a:xfrm><a:prstGeom prst="${geom}"><a:avLst/></a:prstGeom>${fillXml}${outlineXml}</xdr:spPr>
+${textXml}</xdr:sp>
+<xdr:clientData/>
+</xdr:twoCellAnchor>`;
+}
+
+// =============================================================================
+// Table XML
+// =============================================================================
+
+function buildTableXml(table: ParsedTable, tableId: number): string {
+  const colsXml = table.columns.map((col) => {
+    let inner = "";
+    if (col.totalsFunction) inner += `<totalsRowFunction>${escapeXml(col.totalsFunction)}</totalsRowFunction>`;
+    if (col.totalsFormula) inner += `<totalsRowFormula>${escapeXml(col.totalsFormula)}</totalsRowFormula>`;
+    return `<tableColumn id="${col.id}" name="${escapeXml(col.name)}">${inner}</tableColumn>`;
+  }).join("");
+
+  const autoFilterXml = table.autoFilter ? `<autoFilter ref="${escapeXml(table.ref)}"/>` : "";
+  const styleName = table.styleName ?? "TableStyleMedium2";
+
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" id="${tableId}" name="${escapeXml(table.name)}" displayName="${escapeXml(table.displayName)}" ref="${escapeXml(table.ref)}" totalsRowCount="${table.totalsRow ? 1 : 0}">
+${autoFilterXml}
+<tableColumns count="${table.columns.length}">${colsXml}</tableColumns>
+<tableStyleInfo name="${escapeXml(styleName)}" showFirstColumn="0" showLastColumn="0" showRowStripes="1" showColumnStripes="0"/>
+</table>`;
+}
+
+// =============================================================================
+// Conditional Formatting XML
+// =============================================================================
+
+function buildConditionalFormattingXml(cf: ParsedConditionalFormat, dxfMap: Map<string, number>): string {
+  const rules = cf.rules.map((rule) => {
+    switch (rule.ruleType) {
+      case "colorScale": {
+        const count = rule.colors.length;
+        const cfvos = count === 2
+          ? '<cfvo type="min"/><cfvo type="max"/>'
+          : '<cfvo type="min"/><cfvo type="percentile" val="50"/><cfvo type="max"/>';
+        const colors = rule.colors.map((c) => `<color rgb="${hexToArgb(c)}"/>`).join("");
+        return `<cfRule type="colorScale" priority="${rule.priority}"><colorScale>${cfvos}${colors}</colorScale></cfRule>`;
+      }
+      case "dataBar": {
+        const showVal = rule.showValue ? "1" : "0";
+        return `<cfRule type="dataBar" priority="${rule.priority}"><dataBar minLength="${rule.minLength}" maxLength="${rule.maxLength}" showValue="${showVal}"><cfvo type="min"/><cfvo type="max"/><color rgb="${hexToArgb(rule.color)}"/></dataBar></cfRule>`;
+      }
+      case "iconSet": {
+        const thresholds = rule.thresholds.map((t) => {
+          if (t.type === "min" || t.type === "autoMin") return '<cfvo type="min"/>';
+          if (t.type === "max" || t.type === "autoMax") return '<cfvo type="max"/>';
+          return `<cfvo type="${t.type}" val="${t.value ?? 0}"/>`;
+        }).join("");
+        const showVal = rule.showValue ? "" : ' showValue="0"';
+        const reverse = rule.reverse ? ' reverse="1"' : "";
+        return `<cfRule type="iconSet" priority="${rule.priority}"><iconSet iconSet="${rule.iconSet}"${showVal}${reverse}>${thresholds}</iconSet></cfRule>`;
+      }
+      case "style": {
+        let attrs = `type="${rule.type}" priority="${rule.priority}"`;
+        if (rule.style) {
+          const dxfId = dxfMap.get(JSON.stringify(rule.style));
+          if (dxfId !== undefined) attrs += ` dxfId="${dxfId}"`;
+        }
+        if (rule.operator) attrs += ` operator="${rule.operator}"`;
+        if (rule.text) attrs += ` text="${escapeXml(rule.text)}"`;
+        if (rule.rank !== undefined) attrs += ` rank="${rule.rank}"`;
+        if (rule.percent) attrs += ' percent="1"';
+        if (rule.bottom) attrs += ' bottom="1"';
+        if (rule.aboveAverage === false) attrs += ' aboveAverage="0"';
+        if (rule.timePeriod) attrs += ` timePeriod="${rule.timePeriod}"`;
+        let inner = "";
+        if (rule.formulae) {
+          inner = rule.formulae.map((f) => `<formula>${escapeXml(String(f))}</formula>`).join("");
+        }
+        return `<cfRule ${attrs}>${inner}</cfRule>`;
+      }
+    }
+  }).join("");
+
+  return `<conditionalFormatting sqref="${cf.ref}">${rules}</conditionalFormatting>`;
+}
+
+/** Build a differential formatting (dxf) entry for style-based CF rules. */
+function buildDxfXml(style: ParsedCfStyle): string {
+  let inner = "";
+  if (style.fontBold || style.fontItalic || style.fontColor) {
+    let fontParts = "";
+    if (style.fontBold) fontParts += "<b/>";
+    if (style.fontItalic) fontParts += "<i/>";
+    if (style.fontColor) fontParts += `<color rgb="${hexToArgb(style.fontColor)}"/>`;
+    inner += `<font>${fontParts}</font>`;
+  }
+  if (style.backgroundColor) {
+    inner += `<fill><patternFill><bgColor rgb="${hexToArgb(style.backgroundColor)}"/></patternFill></fill>`;
+  }
+  return `<dxf>${inner}</dxf>`;
+}
+
+// =============================================================================
+// Image helpers
+// =============================================================================
+
+function getImageExtension(dataUrl: string): string {
+  if (dataUrl.startsWith("data:image/png")) return "png";
+  if (dataUrl.startsWith("data:image/jpeg") || dataUrl.startsWith("data:image/jpg")) return "jpeg";
+  if (dataUrl.startsWith("data:image/gif")) return "gif";
+  return "png"; // default
+}
+
+function dataUrlToBytes(dataUrl: string): Uint8Array | null {
+  const match = dataUrl.match(/^data:[^;]+;base64,(.+)$/);
+  if (!match) return null;
+  const binary = atob(match[1]);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function escapeXml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}