@justybase/spreadsheet-tasks 2.1.1 → 3.0.0

package/dist/esm/index.js

@@ -112,6 +112,143 @@ var BigBuffer = class {
   }
 };
 
+// src/Formats.ts
+var F = {
+  THOUSANDS_SEP: "#,##0",
+  CURRENCY_PLN: '#,##0.00 "z\u0142"',
+  CURRENCY_EUR: "#,##0.00 \u20AC",
+  PERCENTAGE: "0%",
+  SCIENTIFIC: "0.00E+00",
+  TWO_DECIMALS: "#,##0.00",
+  TEXT: "@",
+  LEADING_ZEROS: "000000000",
+  DATE_SHORT: "dd.mm.yyyy",
+  DATE_LONG: "d mmmm yyyy",
+  DATE_DAY_MONTH_YEAR: "dd-mm-yyyy",
+  DATE_ISO: "yyyy-mm-dd",
+  DATE_MONTH_YEAR: "mmmm yyyy",
+  DATE_WEEKDAY: "dddd, d mmmm yyyy",
+  DATE_DAY_MONTH: "d mmmm",
+  DATE_YEAR_ONLY: "yyyy",
+  DATETIME_SHORT: "dd.mm.yyyy hh:mm",
+  DATETIME_LONG: "d mmmm yyyy hh:mm:ss",
+  TIME_HH_MM: "hh:mm",
+  TIME_HH_MM_SS: "hh:mm:ss",
+  TIME_12H: "h:mm AM/PM",
+  DATETIME_24H: "dd.mm.yyyy hh:mm:ss",
+  DATETIME_ISO: 'yyyy-mm-dd"T"hh:mm:ss',
+  TIME_MS: "hh:mm:ss.000"
+};
+function isFormattedCell(val) {
+  return val !== null && val !== void 0 && typeof val === "object" && "format" in val && typeof val.format === "string";
+}
+function unwrapCell(val) {
+  if (isFormattedCell(val)) {
+    return val.value;
+  }
+  return val;
+}
+function getFormat(val) {
+  if (isFormattedCell(val)) {
+    return val.format;
+  }
+  return null;
+}
+
+// src/writerHelpers.ts
+var OA_EPOCH_1900 = Date.UTC(1899, 11, 30);
+var MARCH_1_1900 = Date.UTC(1900, 2, 1);
+function oaDateToTime(oaDate, epochMs) {
+  let serial = oaDate;
+  if (epochMs === OA_EPOCH_1900 && serial >= 1 && serial < 60) {
+    serial += 1;
+  }
+  return Math.round(serial * 864e5) + epochMs;
+}
+function timeToOaDate(timeMs, epochMs) {
+  let serial = (timeMs - epochMs) / 864e5;
+  if (epochMs === OA_EPOCH_1900 && timeMs < MARCH_1_1900) {
+    serial -= 1;
+  }
+  return serial;
+}
+var INVALID_SHEET_NAME_CHARS = /[\\/*?[\]:]/g;
+function sanitizeSheetName(name, sheetCount) {
+  if (!name || typeof name !== "string") {
+    return `Sheet${sheetCount + 1}`;
+  }
+  let sanitized = name.replace(INVALID_SHEET_NAME_CHARS, "_");
+  if (sanitized.length > 31) {
+    sanitized = sanitized.substring(0, 31);
+  }
+  if (sanitized.trim().length === 0) {
+    sanitized = `Sheet${sheetCount + 1}`;
+  }
+  return sanitized;
+}
+var MAX_ROWS = 1048576;
+var MAX_COLS = 16384;
+var MAX_CELL_CHARS = 32767;
+function assertCellTextLength(text) {
+  if (text.length > MAX_CELL_CHARS) {
+    throw new Error(
+      `Excel cell text exceeds ${MAX_CELL_CHARS} UTF-16 code units (got ${text.length}).`
+    );
+  }
+}
+function assertColumnCount(columnCount) {
+  if (!Number.isInteger(columnCount) || columnCount < 1 || columnCount > MAX_COLS) {
+    throw new Error(
+      `Excel column count must be 1..${MAX_COLS} (got ${columnCount}).`
+    );
+  }
+}
+function assertRowFitsColumns(kind, length, columnCount) {
+  if (length > columnCount) {
+    throw new Error(
+      `Excel ${kind} length ${length} exceeds columnCount ${columnCount}.`
+    );
+  }
+}
+function assertRowCount(totalRows) {
+  if (totalRows > MAX_ROWS) {
+    throw new Error(
+      `Excel row count exceeds ${MAX_ROWS} (got ${totalRows}).`
+    );
+  }
+}
+function initColWidths(columnCount) {
+  return new Array(columnCount).fill(-1);
+}
+function applyHeaderWidths(colWidths, headers, columnCount) {
+  for (let i = 0; i < columnCount; i++) {
+    const len = headers[i] ? headers[i].length + 1 : 0;
+    let width = 1.25 * len + 2;
+    if (width > 80) width = 80;
+    if (colWidths[i] < width) colWidths[i] = width;
+  }
+}
+function updateColWidthsFromRows(colWidths, rows, sampleLimit = 100) {
+  for (let r = 0; r < Math.min(rows.length, sampleLimit); r++) {
+    const row = rows[r];
+    for (let c = 0; c < row.length; c++) {
+      const raw = row[c];
+      if (raw === null || raw === void 0) continue;
+      const val = isFormattedCell(raw) ? raw.value : raw;
+      const len = val instanceof Date ? 20 : String(val).length + 1;
+      let width = 1.25 * len + 2;
+      if (width > 80) width = 80;
+      if (colWidths[c] < width) colWidths[c] = width;
+    }
+  }
+}
+function defaultColWidth(width, floor = false) {
+  if (width > 0) {
+    return floor ? Math.floor(width) : width;
+  }
+  return 10;
+}
+
 // src/ExcelReaderAbstract.ts
 var ExcelReaderAbstract = class {
   constructor() {
@@ -126,8 +263,7 @@ var ExcelReaderAbstract = class {
   dispose() {
   }
   getDateTimeFromOaDate(oaDate) {
-    const ms = oaDate * 864e5 + this._oaEpoch;
-    return new Date(ms);
+    return new Date(oaDateToTime(oaDate, this._oaEpoch));
   }
 };
 
@@ -387,168 +523,6 @@ var BiffReaderWriter = class {
 
 // src/XlsbReader.ts
 import AdmZip from "adm-zip";
-var XlsbReader = class extends ExcelReaderAbstract {
-  constructor() {
-    super();
-    this.zip = null;
-    this.sharedStrings = [];
-    this.sheetNames = [];
-    this.sheets = [];
-    this._currentSheetIndex = -1;
-    this._reader = null;
-    this._currentRow = [];
-    this._pendingRowIndex = -1;
-    this._eof = false;
-    this.xfIdToNumFmtId = [];
-    this.customDateFormats = null;
-  }
-  async open(path3, readSharedStrings = true) {
-    this.zip = new AdmZip(path3);
-    const wbEntry = this.zip.getEntry("xl/workbook.bin");
-    if (wbEntry) {
-      const buf = wbEntry.getData();
-      const reader = new BiffReaderWriter(buf);
-      while (reader.readWorkbook()) {
-        if (reader._isSheet) {
-          const name = reader._workbookName;
-          const rId = reader._recId;
-          this.sheetNames.push(name);
-          this.sheets.push({ name, rId, path: null });
-        }
-      }
-    }
-    const relsEntry = this.zip.getEntry("xl/_rels/workbook.bin.rels");
-    if (relsEntry) {
-      const xml = relsEntry.getData().toString("utf8");
-      const relRegex = /<Relationship[^>]*Id="([^"]*)"[^>]*Target="([^"]*)"/g;
-      let match;
-      const rIdToTarget = {};
-      while ((match = relRegex.exec(xml)) !== null) {
-        rIdToTarget[match[1]] = match[2];
-      }
-      for (const sheet of this.sheets) {
-        let target = rIdToTarget[sheet.rId];
-        if (target) {
-          if (target.startsWith("/")) target = target.substring(1);
-          if (!target.startsWith("xl/")) target = "xl/" + target;
-          sheet.path = target;
-        }
-      }
-    }
-    if (readSharedStrings) {
-      const ssPath = "xl/sharedStrings.bin";
-      if (this.zip.getEntry(ssPath)) {
-        this._readSharedStrings(ssPath);
-      }
-    }
-    const stylesPath = "xl/styles.bin";
-    if (this.zip.getEntry(stylesPath)) {
-      this._readStyles(stylesPath);
-    }
-    this.resultsCount = this.sheets.length;
-    this._currentSheetIndex = -1;
-  }
-  _readSharedStrings(path3) {
-    const entry = this.zip.getEntry(path3);
-    if (!entry) return;
-    const reader = new BiffReaderWriter(entry.getData());
-    while (reader.readSharedStrings()) {
-      if (reader._sharedStringValue !== null) {
-        this.sharedStrings.push(reader._sharedStringValue);
-      }
-    }
-  }
-  _readStyles(path3) {
-    const entry = this.zip.getEntry(path3);
-    if (!entry) return;
-    const reader = new BiffReaderWriter(entry.getData());
-    while (reader.readStyles()) {
-    }
-    this.xfIdToNumFmtId = reader._xfIndexToNumFmtId;
-    this.customDateFormats = reader._customNumFmts;
-  }
-  getSheetNames() {
-    return this.sheetNames;
-  }
-  async read() {
-    if (this._currentSheetIndex === -1) {
-      this._currentSheetIndex = 0;
-      if (!this._initSheet(0)) return false;
-    }
-    if (this._eof) return false;
-    this._currentRow = [];
-    while (true) {
-      const hasRecord = this._reader.readWorksheet();
-      if (!hasRecord) {
-        this._eof = true;
-        return true;
-      }
-      if (this._reader._rowIndex !== -1 && this._reader._rowIndex !== this._pendingRowIndex) {
-        this._pendingRowIndex = this._reader._rowIndex;
-        return true;
-      }
-      if (this._reader._readCell) {
-        const col = this._reader._columnNum;
-        let val = null;
-        switch (this._reader._cellType) {
-          case 2:
-            val = this.sharedStrings[this._reader._intValue];
-            break;
-          case 3: {
-            val = this._reader._doubleVal;
-            const xfIndex = this._reader._xfIndex;
-            let numFmtId = 0;
-            if (this.xfIdToNumFmtId && xfIndex < this.xfIdToNumFmtId.length) {
-              numFmtId = this.xfIdToNumFmtId[xfIndex];
-            }
-            const isDate = numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47 || this.customDateFormats && this.customDateFormats.has(numFmtId);
-            if (isDate) {
-              try {
-                val = this.getDateTimeFromOaDate(val);
-              } catch {
-              }
-            }
-            break;
-          }
-          case 4:
-            val = this._reader._boolValue;
-            break;
-          case 5:
-            val = this._reader._stringValue;
-            break;
-          default:
-            val = null;
-        }
-        this._currentRow[col] = val;
-        if (col >= this.fieldCount) this.fieldCount = col + 1;
-      }
-    }
-  }
-  _initSheet(index) {
-    if (index >= this.sheets.length) return false;
-    const sheet = this.sheets[index];
-    const entry = this.zip.getEntry(sheet.path);
-    if (!entry) return false;
-    this._reader = new BiffReaderWriter(entry.getData());
-    this._eof = false;
-    this._pendingRowIndex = -1;
-    while (this._reader.readWorksheet()) {
-      if (this._reader._rowIndex !== -1) {
-        this._pendingRowIndex = this._reader._rowIndex;
-        return true;
-      }
-    }
-    this._eof = true;
-    return false;
-  }
-  getValue(i) {
-    if (i < 0 || i >= this._currentRow.length) return null;
-    return this._currentRow[i];
-  }
-};
-
-// src/XlsxReader.ts
-import yauzl from "yauzl";
 
 // src/xmlUtils.ts
 function hasInvalidControlChars(str) {
@@ -582,8 +556,57 @@ function escapeXmlText(str) {
 }
 function unescapeXml(str) {
   if (!str || str.indexOf("&") === -1) return str;
-  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
-}
+  return str.replace(/&(?:amp|lt|gt|quot|apos|#\d+|#x[0-9a-fA-F]+);/g, (entity) => {
+    switch (entity) {
+      case "&amp;":
+        return "&";
+      case "&lt;":
+        return "<";
+      case "&gt;":
+        return ">";
+      case "&quot;":
+        return '"';
+      case "&apos;":
+        return "'";
+      default: {
+        if (entity[1] === "#") {
+          const body = entity.slice(2, -1);
+          const code = body[0] === "x" || body[0] === "X" ? parseInt(body.slice(1), 16) : parseInt(body, 10);
+          if (Number.isFinite(code)) {
+            try {
+              return String.fromCodePoint(code);
+            } catch {
+              return entity;
+            }
+          }
+        }
+        return entity;
+      }
+    }
+  });
+}
+function parseTagAttributes(tag) {
+  const attrs = {};
+  const re = /([A-Za-z_][\w.:-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+  let m;
+  while ((m = re.exec(tag)) !== null) {
+    const name = m[1];
+    const value = m[3] !== void 0 ? m[3] : m[4];
+    attrs[name] = value;
+    const colon = name.indexOf(":");
+    if (colon !== -1) {
+      const local = name.slice(colon + 1);
+      if (!(local in attrs)) attrs[local] = value;
+    }
+  }
+  return attrs;
+}
+function resolveRelTarget(target) {
+  if (!target) return target;
+  if (target.startsWith("/")) return target.slice(1);
+  if (target.startsWith("xl/")) return target;
+  return "xl/" + target;
+}
 function columnIndexToLetter(colIndex) {
   let n = colIndex + 1;
   let result = "";
@@ -611,31 +634,341 @@ function trimTrailingEmptyRows(rows) {
 }
 function parseSharedStringsXml(xml) {
   const result = [];
+  const itemRegex = /<(?:(?:[A-Za-z_][\w.-]*):)?si\b[^>]*>([\s\S]*?)<\/(?:(?:[A-Za-z_][\w.-]*):)?si\s*>|<(?:(?:[A-Za-z_][\w.-]*):)?si\b[^>]*\/>/gi;
+  let itemMatch;
+  while ((itemMatch = itemRegex.exec(xml)) !== null) {
+    const full = itemMatch[0];
+    if (full.endsWith("/>") && itemMatch[1] === void 0) {
+      result.push("");
+      continue;
+    }
+    let content = itemMatch[1] ?? "";
+    content = content.replace(/<(?:(?:[A-Za-z_][\w.-]*):)?rPh\b[^>]*>[\s\S]*?<\/(?:(?:[A-Za-z_][\w.-]*):)?rPh\s*>/gi, "");
+    content = content.replace(/<(?:(?:[A-Za-z_][\w.-]*):)?rPh\b[^>]*\/>/gi, "");
+    const textRegex = /<(?:(?:[A-Za-z_][\w.-]*):)?t\b[^>]*>([\s\S]*?)<\/(?:(?:[A-Za-z_][\w.-]*):)?t\s*>/gi;
+    let value = "";
+    let textMatch;
+    while ((textMatch = textRegex.exec(content)) !== null) {
+      value += textMatch[1];
+    }
+    result.push(unescapeXml(value));
+  }
+  return result;
+}
+
+// src/biff12Utils.ts
+function readVlq(buf, pos) {
+  let value = 0;
+  let shift = 0;
+  let byte;
+  do {
+    byte = buf[pos++];
+    value |= (byte & 127) << shift;
+    shift += 7;
+  } while ((byte & 128) !== 0);
+  return { value, nextPos: pos };
+}
+function vlqBytes(value) {
+  const out = [];
+  while (value >= 128) {
+    out.push(value & 127 | 128);
+    value >>>= 7;
+  }
+  out.push(value & 127);
+  return out;
+}
+function readRecord(buf, pos, rec) {
+  const idRes = readVlq(buf, pos);
+  if (idRes.nextPos > buf.length) return false;
+  const lenRes = readVlq(buf, idRes.nextPos);
+  if (lenRes.nextPos + lenRes.value > buf.length) return false;
+  rec.headerStart = pos;
+  rec.dataStart = lenRes.nextPos;
+  rec.dataEnd = lenRes.nextPos + lenRes.value;
+  rec.id = idRes.value;
+  rec.len = lenRes.value;
+  return true;
+}
+function buildRecord(id, payload) {
+  const idBytes = vlqBytes(id);
+  const lenBytes = vlqBytes(payload.length);
+  const header = Buffer.alloc(idBytes.length + lenBytes.length);
+  idBytes.forEach((b, i) => header[i] = b);
+  lenBytes.forEach((b, i) => header[idBytes.length + i] = b);
+  return Buffer.concat([header, payload]);
+}
+function readUtf16(buf, start, charCount) {
+  const end = start + charCount * 2;
+  if (end > buf.length) return "";
+  return buf.toString("utf16le", start, end);
+}
+function parseSharedStringsBin(buf) {
+  const values = [];
+  let total = 0;
+  let unique = 0;
+  let endSstOffset = buf.length;
+  const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
   let pos = 0;
-  while (true) {
-    const siStart = xml.indexOf("<si>", pos);
-    if (siStart === -1) break;
-    const siEnd = xml.indexOf("</si>", siStart);
-    if (siEnd === -1) break;
-    const content = xml.substring(siStart, siEnd);
-    let val = "";
-    let tPos = 0;
-    while (true) {
-      const tStart = content.indexOf("<t", tPos);
-      if (tStart === -1) break;
-      const tagEnd = content.indexOf(">", tStart);
-      const tEnd = content.indexOf("</t>", tagEnd);
-      if (tEnd === -1) break;
-      val += content.substring(tagEnd + 1, tEnd);
-      tPos = tEnd + 4;
+  while (readRecord(buf, pos, rec)) {
+    pos = rec.dataEnd;
+    if (rec.id === 159) {
+      total = buf.readUInt32LE(rec.dataStart);
+      unique = buf.readUInt32LE(rec.dataStart + 4);
+    } else if (rec.id === 19) {
+      const cch = buf.readUInt32LE(rec.dataStart + 1);
+      values.push(readUtf16(buf, rec.dataStart + 5, cch));
+    } else if (rec.id === 160) {
+      endSstOffset = rec.headerStart;
     }
-    result.push(unescapeXml(val));
-    pos = siEnd + 5;
   }
-  return result;
+  return { values, total, unique, endSstOffset };
 }
 
+// src/XlsbReader.ts
+var XlsbReader = class extends ExcelReaderAbstract {
+  constructor() {
+    super();
+    this.zip = null;
+    this.sharedStrings = [];
+    this.sheetNames = [];
+    this.sheets = [];
+    this._currentSheetIndex = -1;
+    this._reader = null;
+    this._currentRow = [];
+    this._pendingRowIndex = -1;
+    this._nextExpectedRow = 0;
+    this._eof = false;
+    this.xfIdToNumFmtId = [];
+    this.customDateFormats = null;
+  }
+  async open(path9, readSharedStrings = true) {
+    await this.close();
+    this.sheetNames = [];
+    this.sheets = [];
+    this.sharedStrings = [];
+    this.xfIdToNumFmtId = [];
+    this.customDateFormats = /* @__PURE__ */ new Set();
+    this.fieldCount = 0;
+    this.resultsCount = 0;
+    this.actualSheetName = "";
+    this._currentSheetIndex = -1;
+    this._currentRow = [];
+    this._pendingRowIndex = -1;
+    this._nextExpectedRow = 0;
+    this._eof = false;
+    this._reader = null;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    this.zip = new AdmZip(path9);
+    const wbEntry = this.zip.getEntry("xl/workbook.bin");
+    if (wbEntry) {
+      const buf = wbEntry.getData();
+      const reader = new BiffReaderWriter(buf);
+      while (reader.readWorkbook()) {
+        if (reader._isSheet) {
+          const name = reader._workbookName;
+          const rId = reader._recId;
+          this.sheetNames.push(name);
+          this.sheets.push({ name, rId, path: null });
+        }
+      }
+    }
+    const relsEntry = this.zip.getEntry("xl/_rels/workbook.bin.rels");
+    if (relsEntry) {
+      const xml = relsEntry.getData().toString("utf8");
+      const relTagRe = /<Relationship\b[^>]*>/g;
+      let tagMatch;
+      const rIdToTarget = {};
+      while ((tagMatch = relTagRe.exec(xml)) !== null) {
+        const attrs = parseTagAttributes(tagMatch[0]);
+        const id = attrs["Id"] ?? attrs["id"];
+        const target = attrs["Target"] ?? attrs["target"];
+        if (id !== void 0 && target !== void 0) {
+          rIdToTarget[id] = target;
+        }
+      }
+      for (const sheet of this.sheets) {
+        const target = rIdToTarget[sheet.rId];
+        if (target) {
+          sheet.path = resolveRelTarget(target);
+        }
+      }
+    }
+    try {
+      const raw = wbEntry ? wbEntry.getData() : null;
+      if (raw) {
+        const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+        let pos = 0;
+        while (readRecord(raw, pos, rec)) {
+          if (rec.id === 153 && rec.len >= 4) {
+            const is1904 = (raw[rec.dataStart] & 1) !== 0;
+            this._oaEpoch = is1904 ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+            break;
+          }
+          pos = rec.dataEnd;
+        }
+      }
+    } catch {
+    }
+    if (readSharedStrings) {
+      const ssPath = "xl/sharedStrings.bin";
+      if (this.zip.getEntry(ssPath)) {
+        this._readSharedStrings(ssPath);
+      }
+    }
+    const stylesPath = "xl/styles.bin";
+    if (this.zip.getEntry(stylesPath)) {
+      this._readStyles(stylesPath);
+    }
+    this.resultsCount = this.sheets.length;
+    this._currentSheetIndex = -1;
+  }
+  _readSharedStrings(path9) {
+    const entry = this.zip.getEntry(path9);
+    if (!entry) return;
+    const reader = new BiffReaderWriter(entry.getData());
+    while (reader.readSharedStrings()) {
+      if (reader._sharedStringValue !== null) {
+        this.sharedStrings.push(reader._sharedStringValue);
+      }
+    }
+  }
+  _readStyles(path9) {
+    const entry = this.zip.getEntry(path9);
+    if (!entry) return;
+    const reader = new BiffReaderWriter(entry.getData());
+    while (reader.readStyles()) {
+    }
+    this.xfIdToNumFmtId = reader._xfIndexToNumFmtId;
+    this.customDateFormats = reader._customNumFmts;
+  }
+  getSheetNames() {
+    return this.sheetNames;
+  }
+  async selectSheet(nameOrIndex) {
+    let index = -1;
+    if (typeof nameOrIndex === "number") {
+      index = nameOrIndex;
+    } else {
+      index = this.sheetNames.indexOf(nameOrIndex);
+      if (index === -1) throw new Error(`Sheet '${nameOrIndex}' not found`);
+    }
+    if (index < 0 || index >= this.sheets.length) {
+      throw new Error(`Sheet index ${String(nameOrIndex)} out of range`);
+    }
+    this._currentSheetIndex = index;
+    if (!this._initSheet(index)) {
+      throw new Error(`XlsbReader: worksheet part missing for sheet '${this.sheetNames[index]}'.`);
+    }
+  }
+  async nextResult() {
+    const next = this._currentSheetIndex + 1;
+    if (next >= this.sheets.length) return false;
+    this._currentSheetIndex = next;
+    if (!this._initSheet(next)) {
+      throw new Error(`XlsbReader: worksheet part missing for sheet '${this.sheetNames[next]}'.`);
+    }
+    return true;
+  }
+  async read() {
+    if (this._currentSheetIndex === -1) {
+      this._currentSheetIndex = 0;
+      if (!this._initSheet(0)) return false;
+    }
+    if (this._eof) return false;
+    if (this._pendingRowIndex > this._nextExpectedRow && this._pendingRowIndex < MAX_ROWS) {
+      this._currentRow = [];
+      this._nextExpectedRow++;
+      return true;
+    }
+    this._currentRow = [];
+    while (true) {
+      const hasRecord = this._reader.readWorksheet();
+      if (!hasRecord) {
+        this._eof = true;
+        this._nextExpectedRow = this._pendingRowIndex + 1;
+        return true;
+      }
+      if (this._reader._rowIndex !== -1 && this._reader._rowIndex !== this._pendingRowIndex) {
+        const completed = this._pendingRowIndex;
+        this._pendingRowIndex = this._reader._rowIndex;
+        this._nextExpectedRow = completed + 1;
+        return true;
+      }
+      if (this._reader._readCell) {
+        const col = this._reader._columnNum;
+        let val = null;
+        switch (this._reader._cellType) {
+          case 2:
+            val = this.sharedStrings[this._reader._intValue];
+            break;
+          case 3: {
+            val = this._reader._doubleVal;
+            const xfIndex = this._reader._xfIndex;
+            let numFmtId = 0;
+            if (this.xfIdToNumFmtId && xfIndex < this.xfIdToNumFmtId.length) {
+              numFmtId = this.xfIdToNumFmtId[xfIndex];
+            }
+            const isDate = numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47 || this.customDateFormats && this.customDateFormats.has(numFmtId);
+            if (isDate) {
+              try {
+                val = this.getDateTimeFromOaDate(val);
+              } catch {
+              }
+            }
+            break;
+          }
+          case 4:
+            val = this._reader._boolValue;
+            break;
+          case 5:
+            val = this._reader._stringValue;
+            break;
+          default:
+            val = null;
+        }
+        this._currentRow[col] = val;
+        if (col >= this.fieldCount) this.fieldCount = col + 1;
+      }
+    }
+  }
+  _initSheet(index) {
+    if (index < 0 || index >= this.sheets.length) return false;
+    const sheet = this.sheets[index];
+    const entry = sheet.path ? this.zip.getEntry(sheet.path) : void 0;
+    if (!entry) return false;
+    this._reader = new BiffReaderWriter(entry.getData());
+    this._eof = false;
+    this._pendingRowIndex = -1;
+    this._nextExpectedRow = 0;
+    this._currentRow = [];
+    this.fieldCount = 0;
+    this.actualSheetName = sheet.name;
+    while (this._reader.readWorksheet()) {
+      if (this._reader._rowIndex !== -1) {
+        this._pendingRowIndex = this._reader._rowIndex;
+        return true;
+      }
+    }
+    this._eof = true;
+    return true;
+  }
+  getValue(i) {
+    if (i < 0 || i >= this._currentRow.length) return null;
+    return this._currentRow[i];
+  }
+};
+
 // src/XlsxReader.ts
+import yauzl from "yauzl";
+function parseIsoDateUtc(value) {
+  let text = value.trim().replace(" ", "T");
+  if (!text) return null;
+  if (!/z$|[+-]\d{2}:?\d{2}$/i.test(text) && text.includes("T")) {
+    text += "Z";
+  }
+  const date = new Date(text);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
 var XlsxReader = class extends ExcelReaderAbstract {
   constructor() {
     super();
@@ -647,13 +980,34 @@ var XlsxReader = class extends ExcelReaderAbstract {
     this._currentSheetIndex = -1;
     this._sheetXml = null;
     this._xmlPos = 0;
+    /** End of the sheetData element; row tags must not be searched past it. */
+    this._xmlEnd = 0;
     this._currentRow = [];
+    this._expectedRowNum = 1;
+    this._pendingEmptyCount = 0;
     this.xfIdToNumFmtId = [];
     this.customDateFormats = /* @__PURE__ */ new Set();
   }
-  async open(path3, readSharedStrings = true) {
-    return new Promise((resolve2, reject) => {
-      yauzl.open(path3, { lazyEntries: true, autoClose: false }, async (err, zipfile) => {
+  async open(path9, readSharedStrings = true) {
+    await this.close();
+    this.sheetNames = [];
+    this.sheets = [];
+    this.sharedStrings = [];
+    this.xfIdToNumFmtId = [];
+    this.customDateFormats = /* @__PURE__ */ new Set();
+    this.fieldCount = 0;
+    this.resultsCount = 0;
+    this.actualSheetName = "";
+    this._currentSheetIndex = -1;
+    this._sheetXml = null;
+    this._xmlPos = 0;
+    this._xmlEnd = 0;
+    this._currentRow = [];
+    this._expectedRowNum = 1;
+    this._pendingEmptyCount = 0;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    return new Promise((resolve6, reject) => {
+      yauzl.open(path9, { lazyEntries: true, autoClose: false }, async (err, zipfile) => {
         if (err) return reject(err);
         this.zipfile = zipfile;
         this.entries = /* @__PURE__ */ new Map();
@@ -666,28 +1020,40 @@ var XlsxReader = class extends ExcelReaderAbstract {
             const wbRelsContent = await this._readZipEntryContent("xl/_rels/workbook.xml.rels");
             const rIdToTarget = {};
             if (wbRelsContent) {
-              const relRegex = /<Relationship[^>]*Id="([^"]*)"[^>]*Target="([^"]*)"/g;
-              let match;
-              while ((match = relRegex.exec(wbRelsContent)) !== null) {
-                rIdToTarget[match[1]] = match[2];
+              const relTagRe = /<Relationship\b[^>]*>/g;
+              let tagMatch;
+              while ((tagMatch = relTagRe.exec(wbRelsContent)) !== null) {
+                const attrs = parseTagAttributes(tagMatch[0]);
+                const id = attrs["Id"] ?? attrs["id"];
+                const target = attrs["Target"] ?? attrs["target"];
+                if (id !== void 0 && target !== void 0) {
+                  rIdToTarget[id] = target;
+                }
               }
             }
             const wbContent = await this._readZipEntryContent("xl/workbook.xml");
             if (wbContent) {
-              const sheetRegex = /<sheet[^>]*name="([^"]*)"[^>]*sheetId="([^"]*)"[^>]*r:id="([^"]*)"/g;
-              let match;
-              while ((match = sheetRegex.exec(wbContent)) !== null) {
-                const name = unescapeXml(match[1]);
-                const sheetId = match[2];
-                const rId = match[3];
+              const sheetTagRe = /<sheet\b[^>]*>/g;
+              let tagMatch;
+              while ((tagMatch = sheetTagRe.exec(wbContent)) !== null) {
+                const attrs = parseTagAttributes(tagMatch[0]);
+                const rawName = attrs["name"];
+                const sheetId = attrs["sheetId"] ?? "";
+                const rId = attrs["r:id"] ?? attrs["id"] ?? attrs["rId"];
+                if (rawName === void 0 || rId === void 0) continue;
+                const name = unescapeXml(rawName);
                 const target = rIdToTarget[rId];
-                let fullPath = target;
-                if (!fullPath.startsWith("xl/")) {
-                  fullPath = "xl/" + fullPath;
-                }
+                if (!target) continue;
+                const fullPath = resolveRelTarget(target);
                 this.sheetNames.push(name);
                 this.sheets.push({ name, sheetId, rId, path: fullPath });
               }
+              const wbPrMatch = /<workbookPr\b[^>]*>/i.exec(wbContent);
+              if (wbPrMatch) {
+                const wbPrAttrs = parseTagAttributes(wbPrMatch[0]);
+                const v = (wbPrAttrs["date1904"] ?? "").trim().toLowerCase();
+                this._oaEpoch = v === "1" || v === "true" ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+              }
             }
             if (readSharedStrings) {
               const ssContent = await this._readZipEntryContent("xl/sharedStrings.xml");
@@ -701,7 +1067,7 @@ var XlsxReader = class extends ExcelReaderAbstract {
             }
             this.resultsCount = this.sheets.length;
             this._currentSheetIndex = -1;
-            resolve2();
+            resolve6();
           } catch (e) {
             reject(e);
           }
@@ -715,16 +1081,16 @@ var XlsxReader = class extends ExcelReaderAbstract {
       this.zipfile.close();
     }
   }
-  async _readZipEntryContent(path3) {
-    const entry = this.entries.get(path3);
+  async _readZipEntryContent(path9) {
+    const entry = this.entries.get(path9);
     if (!entry) return null;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve6, reject) => {
       this.zipfile.openReadStream(entry, (err, readStream) => {
         if (err) return reject(err);
         const chunks = [];
         readStream.on("data", (chunk) => chunks.push(chunk));
         readStream.on("end", () => {
-          resolve2(Buffer.concat(chunks).toString("utf8"));
+          resolve6(Buffer.concat(chunks).toString("utf8"));
         });
         readStream.on("error", reject);
       });
@@ -772,6 +1138,27 @@ var XlsxReader = class extends ExcelReaderAbstract {
       return false;
     }
   }
+  async selectSheet(nameOrIndex) {
+    let index = -1;
+    if (typeof nameOrIndex === "number") {
+      index = nameOrIndex;
+    } else {
+      index = this.sheetNames.indexOf(nameOrIndex);
+      if (index === -1) throw new Error(`Sheet '${nameOrIndex}' not found`);
+    }
+    if (index < 0 || index >= this.sheets.length) {
+      throw new Error(`Sheet index ${String(nameOrIndex)} out of range`);
+    }
+    this._currentSheetIndex = index;
+    await this._initSheet(index);
+  }
+  async nextResult() {
+    const next = this._currentSheetIndex + 1;
+    if (next >= this.sheets.length) return false;
+    this._currentSheetIndex = next;
+    await this._initSheet(next);
+    return true;
+  }
   async _initSheet(index) {
     if (index >= this.sheets.length) return;
     const sheet = this.sheets[index];
@@ -781,23 +1168,106 @@ var XlsxReader = class extends ExcelReaderAbstract {
       this._sheetXml = "";
     }
     this._xmlPos = 0;
+    this._xmlEnd = this._sheetXml.length;
+    this._expectedRowNum = 1;
+    this._pendingEmptyCount = 0;
+    this._currentRow = [];
+    this.fieldCount = 0;
     const sd = this._sheetXml.indexOf("<sheetData>");
-    if (sd !== -1) this._xmlPos = sd + 11;
+    if (sd !== -1) {
+      this._xmlPos = sd + 11;
+      const se = this._sheetXml.indexOf("</sheetData>", this._xmlPos);
+      if (se !== -1) this._xmlEnd = se;
+    } else {
+      const m = /<(?:[A-Za-z_][\w.-]*:)?sheetData\b[^>]*>/i.exec(this._sheetXml);
+      if (m && m.index !== void 0) {
+        this._xmlPos = m.index + m[0].length;
+        if (/\/>\s*$/.test(m[0])) {
+          this._xmlEnd = this._xmlPos;
+        } else {
+          const se = this._sheetXml.indexOf("</sheetData>", this._xmlPos);
+          if (se !== -1) this._xmlEnd = se;
+        }
+      }
+    }
   }
   _readNextRow() {
     if (!this._sheetXml) return false;
-    const rowStart = this._sheetXml.indexOf("<row", this._xmlPos);
+    if (this._pendingEmptyCount > 0) {
+      this._pendingEmptyCount--;
+      this._currentRow = [];
+      this._expectedRowNum++;
+      return true;
+    }
+    const rowStart = this._findRowTagStart(this._xmlPos);
     if (rowStart === -1) return false;
+    const rowTagEnd = this._sheetXml.indexOf(">", rowStart);
+    if (rowTagEnd === -1) return false;
+    const rowTag = this._sheetXml.substring(rowStart, rowTagEnd + 1);
+    const isSelfClosing = this._sheetXml.charCodeAt(rowTagEnd - 1) === 47;
+    const rowAttrs = parseTagAttributes(rowTag);
+    const rRaw = rowAttrs["r"];
+    let rowNum = this._expectedRowNum;
+    if (rRaw !== void 0) {
+      const parsed = parseInt(rRaw, 10);
+      if (Number.isFinite(parsed) && parsed >= 1 && parsed <= MAX_ROWS) rowNum = parsed;
+    }
+    if (rowNum > this._expectedRowNum) {
+      const gap = rowNum - this._expectedRowNum;
+      this._pendingEmptyCount = gap - 1;
+      this._currentRow = [];
+      this._expectedRowNum++;
+      return true;
+    }
+    if (rowNum < this._expectedRowNum) {
+      if (isSelfClosing) {
+        this._xmlPos = rowTagEnd + 1;
+        this._currentRow = [];
+        return true;
+      }
+      const rowEnd2 = this._sheetXml.indexOf("</row>", rowStart);
+      if (rowEnd2 === -1) return false;
+      this._xmlPos = rowEnd2 + 6;
+      this._parseRowByIndex(rowStart, rowEnd2);
+      this._expectedRowNum = Math.max(this._expectedRowNum + 1, rowNum + 1);
+      return true;
+    }
+    if (isSelfClosing) {
+      this._xmlPos = rowTagEnd + 1;
+      this._currentRow = [];
+      this._expectedRowNum = rowNum + 1;
+      return true;
+    }
     const rowEnd = this._sheetXml.indexOf("</row>", rowStart);
     if (rowEnd === -1) return false;
     this._xmlPos = rowEnd + 6;
     this._parseRowByIndex(rowStart, rowEnd);
+    this._expectedRowNum = rowNum + 1;
     return true;
   }
+  /**
+   * Find the next `<row …>` start, ignoring similarly named elements such as
+   * `<rowBreaks>` that follow `</sheetData>`.
+   */
+  _findRowTagStart(from) {
+    const xml = this._sheetXml;
+    let pos = from;
+    while (pos < this._xmlEnd) {
+      const idx = xml.indexOf("<row", pos);
+      if (idx === -1 || idx >= this._xmlEnd) return -1;
+      const next = xml.charCodeAt(idx + 4);
+      if (next === 62 || next === 47 || next === 32 || next === 9 || next === 10 || next === 13) {
+        return idx;
+      }
+      pos = idx + 4;
+    }
+    return -1;
+  }
   _parseRowByIndex(rowStart, rowEnd) {
     this._currentRow = [];
     const xml = this._sheetXml;
     let pos = xml.indexOf(">", rowStart) + 1;
+    let nextCol = 0;
     while (pos < rowEnd) {
       const cStart = xml.indexOf("<c", pos);
       if (cStart === -1 || cStart >= rowEnd) break;
@@ -831,6 +1301,7 @@ var XlsxReader = class extends ExcelReaderAbstract {
         }
       }
       let val = null;
+      let inlineVals = null;
       if (xml.charCodeAt(nextTagClose - 1) === 47) {
         pos = nextTagClose + 1;
       } else {
@@ -845,20 +1316,28 @@ var XlsxReader = class extends ExcelReaderAbstract {
           }
         } else {
           if (type === "inlineStr") {
-            const tStart = xml.indexOf("<t", nextTagClose);
-            if (tStart !== -1 && tStart < cellContentEnd) {
-              const tContentStart = xml.indexOf(">", tStart) + 1;
+            inlineVals = [];
+            let tSearch = nextTagClose;
+            while (true) {
+              const tStart = xml.indexOf("<t", tSearch);
+              if (tStart === -1 || tStart >= cellContentEnd) break;
+              const tClose = xml.indexOf(">", tStart);
+              if (tClose === -1 || tClose >= cellContentEnd) break;
+              const tContentStart = tClose + 1;
               const tEnd = xml.indexOf("</t>", tContentStart);
-              if (tEnd !== -1 && tEnd < cellContentEnd) {
-                val = xml.substring(tContentStart, tEnd);
-              }
+              if (tEnd === -1 || tEnd > cellContentEnd) break;
+              inlineVals.push(xml.substring(tContentStart, tEnd));
+              tSearch = tEnd + 4;
             }
+            if (inlineVals.length === 0) inlineVals = null;
           }
         }
         pos = cellContentEnd + 4;
       }
       let finalVal = null;
-      if (val !== null) {
+      if (inlineVals !== null) {
+        finalVal = unescapeXml(inlineVals.join(""));
+      } else if (val !== null) {
         if (type === "s") {
           const idx = parseInt(val, 10);
           finalVal = this.sharedStrings[idx];
@@ -866,148 +1345,66 @@ var XlsxReader = class extends ExcelReaderAbstract {
           finalVal = val === "1" || val === "true";
         } else if (type === "inlineStr") {
           finalVal = unescapeXml(val);
+        } else if (type === "str") {
+          finalVal = unescapeXml(val);
+        } else if (type === "e") {
+          finalVal = unescapeXml(val);
+        } else if (type === "d") {
+          finalVal = parseIsoDateUtc(val) ?? unescapeXml(val);
         } else if (type === "n" || type === "") {
           finalVal = parseFloat(val);
           if (styleIndex > 0 && this.xfIdToNumFmtId) {
             let numFmtId = 0;
-            if (styleIndex < this.xfIdToNumFmtId.length) {
-              numFmtId = this.xfIdToNumFmtId[styleIndex];
-            }
-            const isDate = numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47 || this.customDateFormats && this.customDateFormats.has(numFmtId);
-            if (isDate) {
-              try {
-                finalVal = this.getDateTimeFromOaDate(finalVal);
-              } catch {
-              }
-            }
-          }
-        }
-      }
-      if (colIndex !== -1) {
-        this._currentRow[colIndex] = finalVal;
-        if (colIndex >= this.fieldCount) this.fieldCount = colIndex + 1;
-      }
-    }
-  }
-  getValue(i) {
-    if (i < 0 || i >= this._currentRow.length) return null;
-    return this._currentRow[i];
-  }
-};
-
-// src/ReaderFactory.ts
-import * as path from "path";
-var ReaderFactory = class {
-  /**
-   * @param filePath Path ending in `.xlsb` or `.xlsx`
-   * @throws if the extension is unsupported
-   */
-  static create(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    if (ext === ".xlsx") {
-      return new XlsxReader();
-    } else if (ext === ".xlsb") {
-      return new XlsbReader();
-    } else {
-      throw new Error(`Unsupported extension: ${ext}`);
-    }
-  }
-};
-
-// src/XlsbWriter.ts
-import * as fs from "fs";
-import archiver from "archiver";
-import { Readable } from "stream";
-
-// src/Formats.ts
-var F = {
-  THOUSANDS_SEP: "#,##0",
-  CURRENCY_PLN: '#,##0.00 "z\u0142"',
-  CURRENCY_EUR: "#,##0.00 \u20AC",
-  PERCENTAGE: "0%",
-  SCIENTIFIC: "0.00E+00",
-  TWO_DECIMALS: "#,##0.00",
-  TEXT: "@",
-  LEADING_ZEROS: "000000000",
-  DATE_SHORT: "dd.mm.yyyy",
-  DATE_LONG: "d mmmm yyyy",
-  DATE_DAY_MONTH_YEAR: "dd-mm-yyyy",
-  DATE_ISO: "yyyy-mm-dd",
-  DATE_MONTH_YEAR: "mmmm yyyy",
-  DATE_WEEKDAY: "dddd, d mmmm yyyy",
-  DATE_DAY_MONTH: "d mmmm",
-  DATE_YEAR_ONLY: "yyyy",
-  DATETIME_SHORT: "dd.mm.yyyy hh:mm",
-  DATETIME_LONG: "d mmmm yyyy hh:mm:ss",
-  TIME_HH_MM: "hh:mm",
-  TIME_HH_MM_SS: "hh:mm:ss",
-  TIME_12H: "h:mm AM/PM",
-  DATETIME_24H: "dd.mm.yyyy hh:mm:ss",
-  DATETIME_ISO: 'yyyy-mm-dd"T"hh:mm:ss',
-  TIME_MS: "hh:mm:ss.000"
-};
-function isFormattedCell(val) {
-  return val !== null && val !== void 0 && typeof val === "object" && "format" in val && typeof val.format === "string";
-}
-function unwrapCell(val) {
-  if (isFormattedCell(val)) {
-    return val.value;
-  }
-  return val;
-}
-function getFormat(val) {
-  if (isFormattedCell(val)) {
-    return val.format;
-  }
-  return null;
-}
-
-// src/writerHelpers.ts
-var INVALID_SHEET_NAME_CHARS = /[\\/*?[\]:]/g;
-function sanitizeSheetName(name, sheetCount) {
-  if (!name || typeof name !== "string") {
-    return `Sheet${sheetCount + 1}`;
-  }
-  let sanitized = name.replace(INVALID_SHEET_NAME_CHARS, "_");
-  if (sanitized.length > 31) {
-    sanitized = sanitized.substring(0, 31);
-  }
-  if (sanitized.trim().length === 0) {
-    sanitized = `Sheet${sheetCount + 1}`;
-  }
-  return sanitized;
-}
-function initColWidths(columnCount) {
-  return new Array(columnCount).fill(-1);
-}
-function applyHeaderWidths(colWidths, headers, columnCount) {
-  for (let i = 0; i < columnCount; i++) {
-    const len = headers[i] ? headers[i].length + 1 : 0;
-    let width = 1.25 * len + 2;
-    if (width > 80) width = 80;
-    if (colWidths[i] < width) colWidths[i] = width;
-  }
-}
-function updateColWidthsFromRows(colWidths, rows, sampleLimit = 100) {
-  for (let r = 0; r < Math.min(rows.length, sampleLimit); r++) {
-    const row = rows[r];
-    for (let c = 0; c < row.length; c++) {
-      const raw = row[c];
-      if (raw === null || raw === void 0) continue;
-      const val = isFormattedCell(raw) ? raw.value : raw;
-      const len = val instanceof Date ? 20 : String(val).length + 1;
-      let width = 1.25 * len + 2;
-      if (width > 80) width = 80;
-      if (colWidths[c] < width) colWidths[c] = width;
+            if (styleIndex < this.xfIdToNumFmtId.length) {
+              numFmtId = this.xfIdToNumFmtId[styleIndex];
+            }
+            const isDate = numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47 || this.customDateFormats && this.customDateFormats.has(numFmtId);
+            if (isDate) {
+              try {
+                finalVal = this.getDateTimeFromOaDate(finalVal);
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      if (colIndex === -1) colIndex = nextCol;
+      nextCol = colIndex + 1;
+      this._currentRow[colIndex] = finalVal;
+      if (colIndex >= this.fieldCount) this.fieldCount = colIndex + 1;
     }
   }
-}
-function defaultColWidth(width, floor = false) {
-  if (width > 0) {
-    return floor ? Math.floor(width) : width;
+  getValue(i) {
+    if (i < 0 || i >= this._currentRow.length) return null;
+    return this._currentRow[i];
   }
-  return 10;
-}
+};
+
+// src/ReaderFactory.ts
+import * as path from "path";
+var ReaderFactory = class {
+  /**
+   * @param filePath Path ending in `.xlsb` or `.xlsx`
+   * @throws if the extension is unsupported
+   */
+  static create(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".xlsx") {
+      return new XlsxReader();
+    } else if (ext === ".xlsb") {
+      return new XlsbReader();
+    } else {
+      throw new Error(`Unsupported extension: ${ext}`);
+    }
+  }
+};
+
+// src/XlsbWriter.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import { randomUUID } from "crypto";
+import archiver from "archiver";
+import { Readable } from "stream";
 
 // src/StreamingSheetState.ts
 var StreamingSheetState = class {
@@ -1061,6 +1458,8 @@ var XlsbWriter = class _XlsbWriter {
    * @param filePath Destination `.xlsb` path on disk.
    */
   constructor(filePath) {
+    this._outputError = null;
+    this._finalized = false;
     this.sheetCount = 0;
     this.sheetList = [];
     this.sstDic = /* @__PURE__ */ new Map();
@@ -1071,8 +1470,20 @@ var XlsbWriter = class _XlsbWriter {
     this._nextXfIdx = 4;
     this._stFmtRecords = /* @__PURE__ */ new Map();
     this.stream = new StreamingSheetState();
-    this.output = fs.createWriteStream(filePath);
+    this._targetPath = path2.resolve(filePath);
+    fs.mkdirSync(path2.dirname(this._targetPath), { recursive: true });
+    this._tempPath = path2.join(
+      path2.dirname(this._targetPath),
+      `.${path2.basename(this._targetPath)}.${randomUUID()}.tmp`
+    );
+    this.output = fs.createWriteStream(this._tempPath);
+    this.output.on("error", (err) => {
+      this._outputError = err;
+    });
     this.archive = archiver("zip");
+    this.archive.on("error", (err) => {
+      this._outputError = err;
+    });
     this.archive.pipe(this.output);
     this._oaEpoch = Date.UTC(1899, 11, 30);
     this._sheet1Bytes = Buffer.from([
@@ -2942,6 +3353,11 @@ var XlsbWriter = class _XlsbWriter {
    * @param options Optional settings (hidden, doAutofilter)
    */
   startSheet(sheetName, columnCount, headers, options = {}) {
+    assertColumnCount(columnCount);
+    if (headers !== void 0) {
+      assertRowFitsColumns("header", headers.length, columnCount);
+      for (const h of headers) assertCellTextLength(h);
+    }
     const { hidden = false, doAutofilter = true, sampleRows } = options;
     this.addSheet(sheetName, hidden);
     this.stream.begin(columnCount, doAutofilter && headers !== void 0, new BigBuffer());
@@ -3007,6 +3423,7 @@ var XlsbWriter = class _XlsbWriter {
         `Row length mismatch. Expected ${this.stream.endCol - this.stream.startCol} columns, got ${row.length}`
       );
     }
+    assertRowCount(this.stream.rowNum + 1);
     this.createRowHeader(bigBuf, this.stream.rowNum, this.stream.startCol, this.stream.endCol);
     for (let c = 0; c < row.length; c++) {
       const raw = row[c];
@@ -3029,7 +3446,7 @@ var XlsbWriter = class _XlsbWriter {
       } else if (typeof val === "boolean") {
         this.writeBool(bigBuf, val, c);
       } else if (val instanceof Date) {
-        const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+        const oaDate = timeToOaDate(val.getTime(), this._oaEpoch);
         this.writeDouble(bigBuf, oaDate, c, fmtString !== null ? styleNum : 1);
       } else if (val !== null && val !== void 0) {
         this.writeString(bigBuf, val.toString(), c, false, fmtString !== null ? styleNum : void 0);
@@ -3086,6 +3503,16 @@ var XlsbWriter = class _XlsbWriter {
     } else if (headers) {
       columnCount = headers.length;
     }
+    if (columnCount > 0) assertColumnCount(columnCount);
+    const totalRowsCheck = rows.length + (headers ? 1 : 0);
+    assertRowCount(totalRowsCheck);
+    if (headers) {
+      assertRowFitsColumns("header", headers.length, columnCount);
+      for (const h of headers) assertCellTextLength(h);
+    }
+    for (let r = 0; r < rows.length; r++) {
+      assertRowFitsColumns("row", rows[r].length, columnCount);
+    }
     const colWidths = initColWidths(columnCount);
     if (headers) {
       applyHeaderWidths(colWidths, headers, columnCount);
@@ -3161,7 +3588,7 @@ var XlsbWriter = class _XlsbWriter {
         } else if (typeof val === "boolean") {
           this.writeBool(bigBuf, val, c);
         } else if (val instanceof Date) {
-          const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+          const oaDate = timeToOaDate(val.getTime(), this._oaEpoch);
           this.writeDouble(bigBuf, oaDate, c, fmtString !== null ? styleNum : 1);
         } else if (val !== null && val !== void 0) {
           this.writeString(bigBuf, val.toString(), c, false, fmtString !== null ? styleNum : void 0);
@@ -3244,13 +3671,14 @@ var XlsbWriter = class _XlsbWriter {
     bigBuf.writeUnsafeByte(val ? 1 : 0);
   }
   writeDateTime(bigBuf, date, colNum) {
-    const oaDate = (date.getTime() - this._oaEpoch) / 864e5;
+    const oaDate = timeToOaDate(date.getTime(), this._oaEpoch);
     this.writeDouble(bigBuf, oaDate, colNum, 1);
   }
   _getDateWidth(_date) {
     return 19;
   }
   writeString(bigBuf, val, colNum, bolded = false, styleOverride) {
+    assertCellTextLength(val);
     let index;
     if (this.sstDic.has(val)) {
       index = this.sstDic.get(val);
@@ -3276,8 +3704,8 @@ var XlsbWriter = class _XlsbWriter {
     bigBuf.writeByte(159);
     bigBuf.writeByte(1);
     bigBuf.writeByte(8);
-    bigBuf.writeInt32LE(this.sstCntUnique);
     bigBuf.writeInt32LE(this.sstCntAll);
+    bigBuf.writeInt32LE(this.sstCntUnique);
     for (const [txt] of this.sstDic) {
       const txtLen = txt.length;
       bigBuf.writeByte(19);
@@ -3330,8 +3758,61 @@ var XlsbWriter = class _XlsbWriter {
    * Must be awaited before the file is fully written.
    */
   finalize() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve6, reject) => {
+      if (this._finalized) {
+        reject(new Error("XlsbWriter: already finalized"));
+        return;
+      }
+      this._finalized = true;
+      let settled = false;
+      const cleanupTemp = () => {
+        try {
+          if (fs.existsSync(this._tempPath)) fs.rmSync(this._tempPath);
+        } catch {
+        }
+      };
+      const fail = (err) => {
+        if (settled) return;
+        settled = true;
+        try {
+          this.archive.abort();
+        } catch {
+        }
+        try {
+          this.output.destroy();
+        } catch {
+        }
+        cleanupTemp();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      const succeed = () => {
+        if (settled) return;
+        if (this._outputError) {
+          fail(this._outputError);
+          return;
+        }
+        settled = true;
+        try {
+          const fd = fs.openSync(this._tempPath, "r+");
+          try {
+            fs.fsyncSync(fd);
+          } finally {
+            fs.closeSync(fd);
+          }
+          try {
+            const existing = fs.statSync(this._targetPath);
+            fs.chmodSync(this._tempPath, existing.mode & 511);
+          } catch {
+          }
+          fs.renameSync(this._tempPath, this._targetPath);
+          resolve6();
+        } catch (err) {
+          cleanupTemp();
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      };
       try {
+        if (this._outputError) throw this._outputError;
         this.saveSst();
         this.archive.append(this._buildStylesBin(), { name: "xl/styles.bin" });
         const wbBuffers = [];
@@ -3428,11 +3909,12 @@ var XlsbWriter = class _XlsbWriter {
 </Relationships>`;
           this.archive.append(wsRels, { name: `xl/worksheets/_rels/${sheet.nameInArchive}.rels` });
         }
-        this.output.on("close", () => resolve2());
-        this.archive.on("error", (err) => reject(err));
+        this.output.once("close", succeed);
+        this.output.once("error", fail);
+        this.archive.once("error", fail);
         this.archive.finalize();
       } catch (err) {
-        reject(err);
+        fail(err);
       }
     });
   }
@@ -3440,27 +3922,17 @@ var XlsbWriter = class _XlsbWriter {
 
 // src/XlsxWriter.ts
 import * as fs2 from "fs";
+import * as path3 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 import archiver2 from "archiver";
 import { Readable as Readable2 } from "stream";
-var COLUMN_LETTERS = (() => {
-  const letters = [];
-  for (let i = 65; i < 91; i++) {
-    letters.push(String.fromCharCode(i));
-  }
-  const temp = [];
-  for (const p of letters) {
-    for (let i = 65; i < 91; i++) {
-      temp.push(p + String.fromCharCode(i));
-    }
-  }
-  letters.push(...temp);
-  return letters;
-})();
 var XlsxWriter = class {
   /**
    * @param filePath Destination `.xlsx` path on disk.
    */
   constructor(filePath) {
+    this._outputError = null;
+    this._finalized = false;
     this.sheetCount = 0;
     this.sheetList = [];
     this.sstArray = [];
@@ -3474,13 +3946,25 @@ var XlsxWriter = class {
     this._nextXfIndex = 4;
     this.stream = new StreamingSheetState();
     this.currentColLetters = [];
-    this.output = fs2.createWriteStream(filePath);
+    this._targetPath = path3.resolve(filePath);
+    fs2.mkdirSync(path3.dirname(this._targetPath), { recursive: true });
+    this._tempPath = path3.join(
+      path3.dirname(this._targetPath),
+      `.${path3.basename(this._targetPath)}.${randomUUID2()}.tmp`
+    );
+    this.output = fs2.createWriteStream(this._tempPath);
+    this.output.on("error", (err) => {
+      this._outputError = err;
+    });
     this.archive = archiver2("zip");
+    this.archive.on("error", (err) => {
+      this._outputError = err;
+    });
     this.archive.pipe(this.output);
     this._oaEpoch = Date.UTC(1899, 11, 30);
   }
   _getColumnLetter(colIndex) {
-    return colIndex < COLUMN_LETTERS.length ? COLUMN_LETTERS[colIndex] : "A";
+    return columnIndexToLetter(colIndex);
   }
   /** @deprecated Internal; kept for unit-test access. Prefer sanitizeSheetName(). */
   _sanitizeSheetName(name) {
@@ -3532,6 +4016,11 @@ var XlsxWriter = class {
    * Start streaming a sheet. Call `writeRow` for each row, then `endSheet`.
    */
   startSheet(sheetName, columnCount, headers, options = {}) {
+    assertColumnCount(columnCount);
+    if (headers !== void 0) {
+      assertRowFitsColumns("header", headers.length, columnCount);
+      for (const h of headers) assertCellTextLength(h);
+    }
     const { hidden = false, doAutofilter = true, sampleRows } = options;
     this.addSheet(sheetName, hidden);
     this.stream.begin(columnCount, doAutofilter && headers !== void 0, new BigBuffer());
@@ -3588,6 +4077,7 @@ var XlsxWriter = class {
       );
     }
     this.stream.rowNum++;
+    assertRowCount(this.stream.rowNum);
     bigBuf.writeString(`<row r="${this.stream.rowNum}">`);
     for (let c = 0; c < row.length; c++) {
       const raw = row[c];
@@ -3651,6 +4141,16 @@ var XlsxWriter = class {
     } else if (headers) {
       columnCount = headers.length;
     }
+    if (columnCount > 0) assertColumnCount(columnCount);
+    const totalRows = rows.length + (headers ? 1 : 0);
+    assertRowCount(totalRows);
+    if (headers) {
+      assertRowFitsColumns("header", headers.length, columnCount);
+      for (const h of headers) assertCellTextLength(h);
+    }
+    for (let r = 0; r < rows.length; r++) {
+      assertRowFitsColumns("row", rows[r].length, columnCount);
+    }
     const colWidths = initColWidths(columnCount);
     const colLetters = new Array(columnCount);
     for (let i = 0; i < columnCount; i++) {
@@ -3662,7 +4162,6 @@ var XlsxWriter = class {
     updateColWidthsFromRows(colWidths, rows);
     bigBuf.writeString('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>');
     bigBuf.writeString('<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">');
-    const totalRows = rows.length + (headers ? 1 : 0);
     if (totalRows > 0 && columnCount > 0) {
       bigBuf.writeString(`<dimension ref="A1:${colLetters[columnCount - 1]}${totalRows}"/>`);
     } else {
@@ -3748,6 +4247,7 @@ var XlsxWriter = class {
     });
   }
   _writeStringCell(bigBuf, val, colRef, rowNum, styleOverride) {
+    assertCellTextLength(val);
     let index = this.sstMap.get(val);
     if (index === void 0) {
       index = this.sstArray.length;
@@ -3769,29 +4269,79 @@ var XlsxWriter = class {
     return xfIndex;
   }
   _toOADate(date) {
-    return (date.getTime() - this._oaEpoch) / 864e5;
+    return timeToOaDate(date.getTime(), this._oaEpoch);
   }
   _getDateWidth(_date) {
     return 19;
   }
   /** Finalize the ZIP package and close the output stream. */
   finalize() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve6, reject) => {
+      if (this._finalized) {
+        reject(new Error("XlsxWriter: already finalized"));
+        return;
+      }
+      this._finalized = true;
+      let settled = false;
+      const cleanupTemp = () => {
+        try {
+          if (fs2.existsSync(this._tempPath)) fs2.rmSync(this._tempPath);
+        } catch {
+        }
+      };
+      const fail = (err) => {
+        if (settled) return;
+        settled = true;
+        try {
+          this.archive.abort();
+        } catch {
+        }
+        try {
+          this.output.destroy();
+        } catch {
+        }
+        cleanupTemp();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      const succeed = () => {
+        if (settled) return;
+        if (this._outputError) {
+          fail(this._outputError);
+          return;
+        }
+        settled = true;
+        try {
+          const fd = fs2.openSync(this._tempPath, "r+");
+          try {
+            fs2.fsyncSync(fd);
+          } finally {
+            fs2.closeSync(fd);
+          }
+          try {
+            const existing = fs2.statSync(this._targetPath);
+            fs2.chmodSync(this._tempPath, existing.mode & 511);
+          } catch {
+          }
+          fs2.renameSync(this._tempPath, this._targetPath);
+          resolve6();
+        } catch (err) {
+          cleanupTemp();
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      };
       try {
+        if (this._outputError) throw this._outputError;
         this._writeSharedStrings();
         this._writeStyles();
         this._writeWorkbook();
         this._writeContentTypes();
         this._writeRels();
-        this.output.on("close", () => {
-          resolve2();
-        });
-        this.archive.on("error", (err) => {
-          reject(err);
-        });
+        this.output.once("close", succeed);
+        this.output.once("error", fail);
+        this.archive.once("error", fail);
         this.archive.finalize();
       } catch (err) {
-        reject(err);
+        fail(err);
       }
     });
   }
@@ -3871,63 +4421,324 @@ ${xfEntries.join("\n")}
       const escapedName = this._escapeSheetNameForXml(sheet.name);
       xml += `<sheet name="${escapedName}" sheetId="${sheet.sheetId}"${state} r:id="${sheet.rId}"/>`;
     }
-    xml += `</sheets>`;
-    if (this._autofilterIsOn) {
-      xml += "<definedNames>";
-      for (const sheet of this.sheetList) {
-        if (sheet.filterHeaderRange) {
-          const localSheetId = sheet.sheetId - 1;
-          const escapedRange = this._escape(sheet.filterHeaderRange);
-          xml += `<definedName name="_xlnm._FilterDatabase" localSheetId="${localSheetId}" hidden="1">${escapedRange}</definedName>`;
-        }
+    xml += `</sheets>`;
+    if (this._autofilterIsOn) {
+      xml += "<definedNames>";
+      for (const sheet of this.sheetList) {
+        if (sheet.filterHeaderRange) {
+          const localSheetId = sheet.sheetId - 1;
+          const escapedRange = this._escape(sheet.filterHeaderRange);
+          xml += `<definedName name="_xlnm._FilterDatabase" localSheetId="${localSheetId}" hidden="1">${escapedRange}</definedName>`;
+        }
+      }
+      xml += "</definedNames>";
+    }
+    xml += '<calcPr calcId="124519" fullCalcOnLoad="1"/>';
+    xml += `</workbook>`;
+    this.archive.append(xml, { name: "xl/workbook.xml" });
+  }
+  _writeContentTypes() {
+    let xml = `<?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"/>
+<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+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"/>`;
+    for (const sheet of this.sheetList) {
+      xml += `<Override PartName="/${sheet.pathInArchive}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`;
+    }
+    xml += `</Types>`;
+    this.archive.append(xml, { name: "[Content_Types].xml" });
+  }
+  _writeRels() {
+    const globalRels = `<?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"/>
+</Relationships>`;
+    this.archive.append(globalRels, { name: "_rels/.rels" });
+    let wbRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`;
+    for (const sheet of this.sheetList) {
+      wbRels += `<Relationship Id="${sheet.rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/${sheet.nameInArchive}"/>`;
+    }
+    let nextId = this.sheetList.length + 1;
+    wbRels += `<Relationship Id="rId${nextId++}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`;
+    wbRels += `<Relationship Id="rId${nextId++}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`;
+    wbRels += `</Relationships>`;
+    this.archive.append(wbRels, { name: "xl/_rels/workbook.xml.rels" });
+  }
+};
+
+// src/XlsxUpdater.ts
+import * as fs5 from "fs";
+import * as os from "os";
+import * as path6 from "path";
+import AdmZip2 from "adm-zip";
+
+// src/atomicFile.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+var realFileOperations = {
+  exists: (filePath) => fs3.existsSync(filePath),
+  rename: (sourcePath, destinationPath) => fs3.renameSync(sourcePath, destinationPath),
+  remove: (filePath) => fs3.rmSync(filePath)
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function destinationExistsError(destinationPath) {
+  return new Error(
+    `Excel conversion: destination already exists (pass { overwrite: true } to replace it): ${destinationPath}`
+  );
+}
+function readDestinationMode(target) {
+  try {
+    if (!fs3.existsSync(target)) return void 0;
+    return fs3.statSync(target).mode & 511;
+  } catch {
+    return void 0;
+  }
+}
+function installTemporaryOutput(temporaryPath, destinationPath, overwrite, operations = realFileOperations) {
+  const backupPath = `${destinationPath}.${randomUUID3()}.replacement-backup`;
+  let backupCreated = false;
+  let installed = false;
+  if (operations.exists(destinationPath)) {
+    if (!overwrite) {
+      throw destinationExistsError(destinationPath);
+    }
+    operations.rename(destinationPath, backupPath);
+    backupCreated = true;
+  }
+  try {
+    try {
+      operations.rename(temporaryPath, destinationPath);
+      installed = true;
+    } catch (error) {
+      if (overwrite && !backupCreated && operations.exists(destinationPath)) {
+        operations.rename(destinationPath, backupPath);
+        backupCreated = true;
+        operations.rename(temporaryPath, destinationPath);
+        installed = true;
+      } else {
+        throw error;
+      }
+    }
+    if (backupCreated) {
+      operations.remove(backupPath);
+    }
+  } catch (error) {
+    if (backupCreated && !installed) {
+      if (!operations.exists(destinationPath)) {
+        try {
+          operations.rename(backupPath, destinationPath);
+          backupCreated = false;
+        } catch (rollbackError) {
+          throw new Error(
+            `Excel conversion: final destination install failed (${errorMessage(error)}), and restoring the original destination also failed (${errorMessage(rollbackError)}). Original file remains at ${backupPath}.`
+          );
+        }
+      } else {
+        throw new Error(
+          `Excel conversion: final destination install failed (${errorMessage(error)}). A concurrent destination was preserved; the original file remains at ${backupPath}.`
+        );
+      }
+    }
+    throw error;
+  }
+}
+function writeBufferAtomically(buffer, destinationPath) {
+  const target = path4.resolve(destinationPath);
+  fs3.mkdirSync(path4.dirname(target), { recursive: true });
+  const temporaryPath = path4.join(
+    path4.dirname(target),
+    `.${path4.basename(target)}.${randomUUID3()}.tmp`
+  );
+  const destinationMode = readDestinationMode(target);
+  try {
+    const fd = fs3.openSync(temporaryPath, "w", destinationMode ?? 438);
+    try {
+      if (destinationMode !== void 0) {
+        try {
+          fs3.fchmodSync(fd, destinationMode);
+        } catch {
+        }
+      }
+      fs3.writeFileSync(fd, buffer);
+      fs3.fsyncSync(fd);
+    } finally {
+      fs3.closeSync(fd);
+    }
+    if (destinationMode !== void 0) {
+      try {
+        fs3.chmodSync(temporaryPath, destinationMode);
+      } catch {
+      }
+    }
+    fs3.renameSync(temporaryPath, target);
+  } finally {
+    if (fs3.existsSync(temporaryPath)) {
+      try {
+        fs3.rmSync(temporaryPath);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/streamingZip.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { finished } from "stream/promises";
+import { Readable as Readable3 } from "stream";
+import archiver3 from "archiver";
+function readDestinationMode2(target) {
+  try {
+    if (!fs4.existsSync(target)) return void 0;
+    return fs4.statSync(target).mode & 511;
+  } catch {
+    return void 0;
+  }
+}
+function appendAndWait(archive, source, name, output) {
+  return new Promise((resolve6, reject) => {
+    const cleanup = () => {
+      archive.off("entry", onEntry);
+      archive.off("error", onError);
+      const maybeEmitter2 = source;
+      if (typeof maybeEmitter2.off === "function") {
+        maybeEmitter2.off("error", onError);
+      }
+      if (output) {
+        output.off("error", onError);
+      }
+    };
+    const onEntry = () => {
+      cleanup();
+      resolve6();
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    archive.once("entry", onEntry);
+    archive.once("error", onError);
+    if (output) {
+      output.once("error", onError);
+    }
+    const maybeEmitter = source;
+    if (typeof maybeEmitter.once === "function") {
+      maybeEmitter.once("error", onError);
+    }
+    try {
+      archive.append(source, { name });
+    } catch (error) {
+      cleanup();
+      reject(error);
+    }
+  });
+}
+async function writeAdmZipStreaming(zip, stagedParts, destinationPath) {
+  const target = path5.resolve(destinationPath);
+  fs4.mkdirSync(path5.dirname(target), { recursive: true });
+  const temporaryPath = path5.join(
+    path5.dirname(target),
+    `.${path5.basename(target)}.${randomUUID4()}.tmp`
+  );
+  const destinationMode = readDestinationMode2(target);
+  let output = null;
+  let archive = null;
+  try {
+    output = fs4.createWriteStream(
+      temporaryPath,
+      destinationMode !== void 0 ? { mode: destinationMode } : {}
+    );
+    let outputError = null;
+    output.on("error", (err) => {
+      outputError = err;
+      try {
+        archive == null ? void 0 : archive.abort();
+      } catch {
+      }
+    });
+    archive = archiver3("zip");
+    archive.on("error", (err) => {
+      outputError = err;
+    });
+    archive.pipe(output);
+    for (const entry of zip.getEntries()) {
+      if (outputError) throw outputError;
+      const stagedPath = stagedParts.get(entry.entryName);
+      if (stagedPath) {
+        await appendAndWait(archive, fs4.createReadStream(stagedPath), entry.entryName, output);
+      } else {
+        await appendAndWait(archive, Readable3.from([entry.getData()]), entry.entryName, output);
       }
-      xml += "</definedNames>";
     }
-    xml += '<calcPr calcId="124519" fullCalcOnLoad="1"/>';
-    xml += `</workbook>`;
-    this.archive.append(xml, { name: "xl/workbook.xml" });
-  }
-  _writeContentTypes() {
-    let xml = `<?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"/>
-<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+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"/>`;
-    for (const sheet of this.sheetList) {
-      xml += `<Override PartName="/${sheet.pathInArchive}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`;
+    if (outputError) throw outputError;
+    await archive.finalize();
+    await finished(output);
+    if (outputError) throw outputError;
+    if (destinationMode !== void 0) {
+      try {
+        fs4.chmodSync(temporaryPath, destinationMode);
+      } catch {
+      }
     }
-    xml += `</Types>`;
-    this.archive.append(xml, { name: "[Content_Types].xml" });
-  }
-  _writeRels() {
-    const globalRels = `<?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"/>
-</Relationships>`;
-    this.archive.append(globalRels, { name: "_rels/.rels" });
-    let wbRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`;
-    for (const sheet of this.sheetList) {
-      wbRels += `<Relationship Id="${sheet.rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/${sheet.nameInArchive}"/>`;
+    const fd = fs4.openSync(temporaryPath, "r+");
+    try {
+      fs4.fsyncSync(fd);
+    } finally {
+      fs4.closeSync(fd);
+    }
+    fs4.renameSync(temporaryPath, target);
+  } catch (error) {
+    try {
+      archive == null ? void 0 : archive.abort();
+    } catch {
+    }
+    throw error;
+  } finally {
+    if (output && !output.closed) {
+      output.destroy();
+    }
+    if (fs4.existsSync(temporaryPath)) {
+      try {
+        fs4.rmSync(temporaryPath);
+      } catch {
+      }
     }
-    let nextId = this.sheetList.length + 1;
-    wbRels += `<Relationship Id="rId${nextId++}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`;
-    wbRels += `<Relationship Id="rId${nextId++}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`;
-    wbRels += `</Relationships>`;
-    this.archive.append(wbRels, { name: "xl/_rels/workbook.xml.rels" });
   }
-};
+}
 
 // src/XlsxUpdater.ts
-import * as fs3 from "fs";
-import AdmZip2 from "adm-zip";
-var XlsxUpdater = class {
+function parseCellRange(ref) {
+  const m = /^\$?([A-Za-z]+)\$?(\d+)(?::\$?([A-Za-z]+)\$?(\d+))?$/.exec(ref.trim());
+  if (!m) return null;
+  const c1 = columnLetterToIndex(m[1].toUpperCase());
+  const r1 = parseInt(m[2], 10);
+  const c2 = m[3] ? columnLetterToIndex(m[3].toUpperCase()) : c1;
+  const r2 = m[4] ? parseInt(m[4], 10) : r1;
+  if (!Number.isFinite(c1) || !Number.isFinite(r1) || !Number.isFinite(c2) || !Number.isFinite(r2)) {
+    return null;
+  }
+  return {
+    c1: Math.min(c1, c2),
+    r1: Math.min(r1, r2),
+    c2: Math.max(c1, c2),
+    r2: Math.max(r1, r2)
+  };
+}
+var XlsxUpdater = class _XlsxUpdater {
   /**
    * @param path Path to an existing `.xlsx` file.
    */
-  constructor(path3) {
+  constructor(filePath) {
+    this.temporaryDirectory = null;
+    this.stagedParts = /* @__PURE__ */ new Map();
     this.sheetNameToPath = /* @__PURE__ */ new Map();
     this.pivotCacheDefs = [];
     this.pivotTableDefPaths = [];
@@ -3935,13 +4746,15 @@ var XlsxUpdater = class {
     this.sharedStringsValues = [];
     this.sharedStringsOriginalLength = 0;
     this.sharedStringsCount = 0;
+    this.sharedStringsPending = [];
+    this.sharedStringsDirty = false;
     this.stringIndexMap = /* @__PURE__ */ new Map();
-    this.sourcePath = path3;
+    this.sourcePath = filePath;
     this._oaEpoch = Date.UTC(1899, 11, 30);
-    if (!fs3.existsSync(path3)) {
-      throw new Error(`XlsxUpdater: file not found: ${path3}`);
+    if (!fs5.existsSync(filePath)) {
+      throw new Error(`XlsxUpdater: file not found: ${filePath}`);
     }
-    this.zip = new AdmZip2(path3);
+    this.zip = new AdmZip2(filePath);
     if (this.zip.getEntry("xl/workbook.bin")) {
       throw new Error(
         "XlsxUpdater: XLSB files are not supported yet. Convert the workbook to XLSX first."
@@ -3975,8 +4788,15 @@ var XlsxUpdater = class {
     if (!entry) {
       throw new Error(`XlsxUpdater: worksheet part missing for sheet "${sheetName}".`);
     }
-    const sheetXml = entry.getData().toString("utf8");
+    const sheetXml = this._entryData(sheetPath).toString("utf8");
     this._ensureSharedStringsLoaded();
+    if (this.sharedStringsXml !== null) {
+      this.sharedStringsCount = Math.max(
+        0,
+        this.sharedStringsCount - this._sharedStringRefCount(sheetXml)
+      );
+      this.sharedStringsDirty = true;
+    }
     let colStyles = /* @__PURE__ */ new Map();
     let headerStyles = /* @__PURE__ */ new Map();
     let dateStyle = null;
@@ -3991,12 +4811,177 @@ var XlsxUpdater = class {
     const newSheetData = this._buildSheetData(rows, headers, colStyles, headerStyles, dateStyle);
     const newXml = this._patchSheetXml(sheetXml, newSheetData, totalRows, lastCol);
     this.zip.updateFile(sheetPath, Buffer.from(newXml, "utf8"));
+    this._discardStagedPart(sheetPath);
     if (this.sharedStringsXml !== null) {
       this._commitSharedStrings();
     }
     const dimRef = totalRows > 0 && lastCol >= 0 ? `A1:${columnIndexToLetter(lastCol)}${totalRows}` : "A1";
     this._updatePivotCaches(sheetName, dimRef, rows.length);
     this._addRefreshOnLoadToPivotTables();
+    this._removeCalcChain();
+    this._updateTableRefs(sheetName, dimRef);
+  }
+  /**
+   * Replace worksheet rows from a one-pass source without materialising the
+   * complete result set. Use {@link saveStreaming} to keep the final ZIP
+   * write streaming as well.
+   */
+  async replaceSheetDataStream(sheetName, rows, options = {}) {
+    const { headers, styleFallback = "inherit" } = options;
+    if (styleFallback !== "inherit" && styleFallback !== "general") {
+      throw new Error("XlsxUpdater: styleFallback must be 'inherit' or 'general'.");
+    }
+    const sheetPath = this.sheetNameToPath.get(sheetName);
+    if (!sheetPath) {
+      throw new Error(`XlsxUpdater: sheet "${sheetName}" not found in the workbook.`);
+    }
+    const entry = this.zip.getEntry(sheetPath);
+    if (!entry) {
+      throw new Error(`XlsxUpdater: worksheet part missing for sheet "${sheetName}".`);
+    }
+    const oldStage = this.stagedParts.get(sheetPath);
+    const beforeValuesLength = this.sharedStringsValues.length;
+    const beforePendingLength = this.sharedStringsPending.length;
+    const beforeSharedStringsCount = this.sharedStringsCount;
+    const beforeSharedStringsDirty = this.sharedStringsDirty;
+    const beforeSharedStringsXml = this.sharedStringsXml;
+    const beforeSharedStringsOriginalLength = this.sharedStringsOriginalLength;
+    const beforeStringIndexMap = new Map(this.stringIndexMap);
+    const sharedStringsEntry = this.zip.getEntry("xl/sharedStrings.xml");
+    const beforeSharedStringsBytes = sharedStringsEntry || this.stagedParts.has("xl/sharedStrings.xml") ? Buffer.from(this._entryData("xl/sharedStrings.xml")) : null;
+    const createdParts = [];
+    const oldSheetXml = this._entryData(sheetPath).toString("utf8");
+    const rowsPath = this._temporaryPath(".rows");
+    const outputPath = this._temporaryPath(".xml");
+    createdParts.push(rowsPath, outputPath);
+    let output = null;
+    try {
+      this._ensureSharedStringsLoaded();
+      if (this.sharedStringsXml !== null) {
+        this.sharedStringsCount = Math.max(
+          0,
+          this.sharedStringsCount - this._sharedStringRefCount(oldSheetXml)
+        );
+        this.sharedStringsDirty = true;
+      }
+      let colStyles = /* @__PURE__ */ new Map();
+      let headerStyles = /* @__PURE__ */ new Map();
+      let dateStyle = null;
+      if (styleFallback !== "general") {
+        const collected = this._collectExistingStyles(oldSheetXml);
+        colStyles = collected.dataStyles;
+        headerStyles = collected.headerStyles;
+        dateStyle = this._findDateStyleIndex();
+      }
+      const prefixMatch = /<([A-Za-z_][\w.-]*:)?sheetData\b/.exec(oldSheetXml);
+      const prefix = (prefixMatch == null ? void 0 : prefixMatch[1]) ?? "";
+      const rowOutput = fs5.createWriteStream(rowsPath);
+      output = rowOutput;
+      let outputError = null;
+      rowOutput.on("error", (error) => {
+        outputError = error;
+      });
+      let nextRow = 1;
+      let width = (headers == null ? void 0 : headers.length) ?? 0;
+      let dataRowsSeen = 0;
+      let keptDataRows = 0;
+      let lastKeptEnd = 0;
+      let pendingEmptyWidth = 0;
+      let writtenBytes = 0;
+      const write = async (data) => {
+        if (outputError) throw outputError;
+        writtenBytes += data.length;
+        if (rowOutput.write(data)) return;
+        await new Promise((resolve6, reject) => {
+          const onDrain = () => {
+            cleanup();
+            resolve6();
+          };
+          const onError = (error) => {
+            cleanup();
+            reject(error);
+          };
+          const cleanup = () => {
+            rowOutput.off("drain", onDrain);
+            rowOutput.off("error", onError);
+          };
+          rowOutput.once("drain", onDrain);
+          rowOutput.once("error", onError);
+        });
+      };
+      if (headers !== void 0) {
+        const cells = headers.map((value, column) => this._valueCell(value, column, nextRow, headerStyles, dateStyle));
+        const header = `<${prefix}row r="${nextRow}">${cells.join("")}</${prefix}row>`;
+        await write(Buffer.from(header, "utf8"));
+        lastKeptEnd = writtenBytes;
+        nextRow++;
+      }
+      for await (const sourceRow of rows) {
+        if (typeof sourceRow === "string" || sourceRow instanceof Uint8Array) {
+          throw new TypeError("Each row must be an iterable of cells, not text");
+        }
+        const row = Array.from(sourceRow);
+        const cells = row.map((value, column) => value === null || value === void 0 ? "" : this._valueCell(value, column, nextRow, colStyles, dateStyle));
+        const rowXml = `<${prefix}row r="${nextRow}">${cells.join("")}</${prefix}row>`;
+        await write(Buffer.from(rowXml, "utf8"));
+        dataRowsSeen++;
+        nextRow++;
+        if (row.every((value) => value === null || value === void 0)) {
+          pendingEmptyWidth = Math.max(pendingEmptyWidth, row.length);
+        } else {
+          width = Math.max(width, pendingEmptyWidth, row.length);
+          pendingEmptyWidth = 0;
+          keptDataRows = dataRowsSeen;
+          lastKeptEnd = writtenBytes;
+        }
+      }
+      await new Promise((resolve6, reject) => {
+        rowOutput.once("close", resolve6);
+        rowOutput.once("error", reject);
+        rowOutput.end();
+      });
+      if (outputError) throw outputError;
+      const rowsFd = fs5.openSync(rowsPath, "r+");
+      try {
+        fs5.ftruncateSync(rowsFd, lastKeptEnd);
+      } finally {
+        fs5.closeSync(rowsFd);
+      }
+      const totalRows = keptDataRows + (headers !== void 0 ? 1 : 0);
+      const lastCol = width - 1;
+      const dimRef = totalRows > 0 && lastCol >= 0 ? `A1:${columnIndexToLetter(lastCol)}${totalRows}` : "A1";
+      this._patchSheetFile(oldSheetXml, rowsPath, outputPath, dimRef);
+      this._stagePart(sheetPath, outputPath);
+      this._commitSharedStrings();
+      this._updatePivotCaches(sheetName, dimRef, keptDataRows);
+      this._addRefreshOnLoadToPivotTables();
+      this._removeCalcChain();
+      this._updateTableRefs(sheetName, dimRef);
+      if (oldStage && oldStage !== outputPath) {
+        this._removeTemporaryFile(oldStage);
+      }
+      createdParts.splice(createdParts.indexOf(outputPath), 1);
+    } catch (error) {
+      this.sharedStringsValues.length = beforeValuesLength;
+      this.sharedStringsPending.length = beforePendingLength;
+      this.sharedStringsCount = beforeSharedStringsCount;
+      this.sharedStringsDirty = beforeSharedStringsDirty;
+      this.sharedStringsXml = beforeSharedStringsXml;
+      this.sharedStringsOriginalLength = beforeSharedStringsOriginalLength;
+      this.stringIndexMap.clear();
+      for (const [value, index] of beforeStringIndexMap) this.stringIndexMap.set(value, index);
+      if (beforeSharedStringsBytes) {
+        this.zip.updateFile("xl/sharedStrings.xml", beforeSharedStringsBytes);
+      }
+      if (oldStage) this.stagedParts.set(sheetPath, oldStage);
+      else this.stagedParts.delete(sheetPath);
+      throw error;
+    } finally {
+      if (output && !output.closed) output.destroy();
+      for (const temporaryPath of createdParts) {
+        this._removeTemporaryFile(temporaryPath);
+      }
+    }
   }
   /**
    * Write the updated workbook to disk.
@@ -4004,12 +4989,89 @@ var XlsxUpdater = class {
    */
   save(outputPath) {
     const target = outputPath ?? this.sourcePath;
-    fs3.writeFileSync(target, this.zip.toBuffer());
+    this._materializeStagedParts();
+    writeBufferAtomically(this.zip.toBuffer(), target);
+  }
+  /** Save staged streaming replacements without materialising the ZIP. */
+  async saveStreaming(outputPath) {
+    const target = outputPath ?? this.sourcePath;
+    await writeAdmZipStreaming(this.zip, this.stagedParts, target);
+    this._materializeStagedParts();
   }
   /** The updated workbook as an in-memory ZIP buffer. */
   toBuffer() {
+    this._materializeStagedParts();
     return this.zip.toBuffer();
   }
+  /**
+   * Release the staging directory and any unsaved staged parts.
+   * The updater remains usable; a new staging directory is created lazily
+   * on the next streaming replacement.
+   */
+  dispose() {
+    for (const stagedPath of this.stagedParts.values()) {
+      try {
+        fs5.rmSync(stagedPath, { force: true });
+      } catch {
+      }
+    }
+    this.stagedParts.clear();
+    if (this.temporaryDirectory !== null) {
+      try {
+        fs5.rmSync(this.temporaryDirectory, { recursive: true, force: true });
+      } catch {
+      }
+      this.temporaryDirectory = null;
+    }
+  }
+  /** Support `using` declarations for automatic staging cleanup. */
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  _ensureTemporaryDirectory() {
+    if (this.temporaryDirectory === null) {
+      this.temporaryDirectory = fs5.mkdtempSync(path6.join(os.tmpdir(), "spreadsheet-updater-"));
+    } else {
+      try {
+        fs5.mkdirSync(this.temporaryDirectory, { recursive: true });
+      } catch {
+      }
+    }
+    return this.temporaryDirectory;
+  }
+  _temporaryPath(suffix) {
+    return path6.join(this._ensureTemporaryDirectory(), `part-${Date.now()}-${Math.random().toString(16).slice(2)}${suffix}`);
+  }
+  _removeTemporaryFile(filePath) {
+    try {
+      fs5.rmSync(filePath);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  _entryData(name) {
+    const stagedPath = this.stagedParts.get(name);
+    if (stagedPath) return fs5.readFileSync(stagedPath);
+    const entry = this.zip.getEntry(name);
+    if (!entry) throw new Error(`XlsxUpdater: ZIP member missing: ${name}`);
+    return entry.getData();
+  }
+  _stagePart(name, filePath) {
+    this.stagedParts.set(name, filePath);
+  }
+  _discardStagedPart(name) {
+    const stagedPath = this.stagedParts.get(name);
+    if (!stagedPath) return;
+    this._removeTemporaryFile(stagedPath);
+    this.stagedParts.delete(name);
+  }
+  _materializeStagedParts() {
+    for (const [name, stagedPath] of this.stagedParts) {
+      this.zip.updateFile(name, fs5.readFileSync(stagedPath));
+      this._removeTemporaryFile(stagedPath);
+    }
+    this.stagedParts.clear();
+  }
   // ------------------------------------------------------------------
   // Workbook structure
   // ------------------------------------------------------------------
@@ -4018,10 +5080,15 @@ var XlsxUpdater = class {
     const rIdToTarget = {};
     if (relsEntry) {
       const rels = relsEntry.getData().toString("utf8");
-      const relRegex = /<Relationship[^>]*Id="([^"]*)"[^>]*Target="([^"]*)"/g;
-      let match2;
-      while ((match2 = relRegex.exec(rels)) !== null) {
-        rIdToTarget[match2[1]] = match2[2];
+      const relTagRe = /<Relationship\b[^>]*>/g;
+      let tagMatch;
+      while ((tagMatch = relTagRe.exec(rels)) !== null) {
+        const attrs = parseTagAttributes(tagMatch[0]);
+        const id = attrs["Id"] ?? attrs["id"];
+        const target = attrs["Target"] ?? attrs["target"];
+        if (id !== void 0 && target !== void 0) {
+          rIdToTarget[id] = target;
+        }
       }
     }
     const wbEntry = this.zip.getEntry("xl/workbook.xml");
@@ -4030,21 +5097,23 @@ var XlsxUpdater = class {
     let match;
     while ((match = sheetRe.exec(wbXml)) !== null) {
       const tag = match[0];
-      const nameMatch = /name="([^"]*)"/.exec(tag);
-      const rIdMatch = /r:id="([^"]*)"/.exec(tag);
-      if (!nameMatch || !rIdMatch) continue;
-      const name = nameMatch[1].replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
-      const target = rIdToTarget[rIdMatch[1]] ?? "";
-      let fullPath = target;
-      if (fullPath.startsWith("/")) {
-        fullPath = fullPath.substring(1);
-      } else if (!fullPath.startsWith("xl/")) {
-        fullPath = "xl/" + fullPath;
-      }
+      const attrs = parseTagAttributes(tag);
+      const rawName = attrs["name"];
+      const rId = attrs["r:id"] ?? attrs["id"] ?? attrs["rId"];
+      if (rawName === void 0 || rId === void 0) continue;
+      const name = unescapeXml(rawName);
+      const target = rIdToTarget[rId] ?? "";
+      const fullPath = resolveRelTarget(target);
       if (fullPath) {
         this.sheetNameToPath.set(name, fullPath);
       }
     }
+    const wbPrMatch = /<workbookPr\b[^>]*>/i.exec(wbXml);
+    if (wbPrMatch) {
+      const wbPrAttrs = parseTagAttributes(wbPrMatch[0]);
+      const v = (wbPrAttrs["date1904"] ?? "").trim().toLowerCase();
+      this._oaEpoch = v === "1" || v === "true" ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+    }
     for (const entry of this.zip.getEntries()) {
       const name = entry.entryName;
       if (/^xl\/pivotCache\/pivotCacheDefinition\d*\.xml$/.test(name)) {
@@ -4062,47 +5131,59 @@ var XlsxUpdater = class {
       return;
     }
     const entry = this.zip.getEntry("xl/sharedStrings.xml");
-    if (!entry) {
+    if (!entry && !this.stagedParts.has("xl/sharedStrings.xml")) {
       this.sharedStringsXml = null;
       return;
     }
-    this.sharedStringsXml = entry.getData().toString("utf8");
+    this.sharedStringsXml = this._entryData("xl/sharedStrings.xml").toString("utf8");
     this.sharedStringsValues = parseSharedStringsXml(this.sharedStringsXml);
-    const countMatch = /<sst\b[^>]*>/.exec(this.sharedStringsXml);
-    const countAttr = countMatch ? /count="(\d+)"/.exec(countMatch[0]) : null;
-    this.sharedStringsCount = countAttr ? parseInt(countAttr[1], 10) : 0;
+    const countMatch = /<(?:[A-Za-z_][\w.-]*:)?sst\b[^>]*>/i.exec(this.sharedStringsXml);
+    const countAttr = countMatch ? /(?:^|\s)count\s*=\s*["'](\d+)["']/.exec(countMatch[0]) : null;
+    this.sharedStringsCount = countAttr ? parseInt(countAttr[1], 10) : this.sharedStringsValues.length;
     this.sharedStringsValues.forEach((value, index) => {
       if (!this.stringIndexMap.has(value)) {
         this.stringIndexMap.set(value, index);
       }
     });
     this.sharedStringsOriginalLength = this.sharedStringsValues.length;
+    this.sharedStringsPending = [];
+    this.sharedStringsDirty = false;
   }
   _commitSharedStrings() {
-    if (this.sharedStringsXml === null || this.sharedStringsValues.length === this.sharedStringsOriginalLength) {
+    var _a;
+    if (this.sharedStringsXml === null || !this.sharedStringsDirty) {
       return;
     }
     let xml = this.sharedStringsXml;
-    const sstStart = xml.indexOf("<sst");
-    const sstTagEnd = xml.indexOf(">", sstStart);
-    if (sstStart !== -1 && sstTagEnd !== -1) {
-      const tag = xml.substring(sstStart, sstTagEnd + 1);
-      const newTag = tag.replace(/count="\d+"/, `count="${this.sharedStringsCount}"`).replace(/uniqueCount="\d+"/, `uniqueCount="${this.sharedStringsValues.length}"`);
-      xml = xml.substring(0, sstStart) + newTag + xml.substring(sstTagEnd + 1);
-    }
-    const sstEnd = xml.lastIndexOf("</sst>");
-    if (sstEnd === -1) {
-      return;
+    const sstMatch = /<(?<prefix>[A-Za-z_][\w.-]*:)?sst\b[^>]*>/i.exec(xml);
+    if (!sstMatch || sstMatch.index === void 0) {
+      throw new Error("XlsxUpdater: sharedStrings.xml has no sst element.");
+    }
+    const tag = sstMatch[0];
+    const prefix = ((_a = sstMatch.groups) == null ? void 0 : _a.prefix) ?? "";
+    const newTag = _XlsxUpdater._replaceOrAddXmlAttribute(
+      _XlsxUpdater._replaceOrAddXmlAttribute(tag, "count", String(this.sharedStringsCount)),
+      "uniqueCount",
+      String(this.sharedStringsValues.length)
+    );
+    xml = xml.substring(0, sstMatch.index) + newTag + xml.substring(sstMatch.index + tag.length);
+    const closingRe = new RegExp(`</${prefix}sst\\s*>\\s*$`, "i");
+    const closingMatch = closingRe.exec(xml);
+    if (!closingMatch || closingMatch.index === void 0) {
+      throw new Error("XlsxUpdater: sharedStrings.xml has no closing sst element.");
     }
-    let appended = "";
-    for (let i = this.sharedStringsOriginalLength; i < this.sharedStringsValues.length; i++) {
-      const txt = this.sharedStringsValues[i];
+    const appended = this.sharedStringsPending.map((txt) => {
       const clean = escapeXmlText(txt);
       const preserve = clean.length > 0 && (clean[0] === " " || clean[clean.length - 1] === " " || /[\t\n\r]/.test(clean));
-      appended += preserve ? `<si><t xml:space="preserve">${clean}</t></si>` : `<si><t>${clean}</t></si>`;
-    }
-    xml = xml.substring(0, sstEnd) + appended + xml.substring(sstEnd);
+      const tAttr = preserve ? ' xml:space="preserve"' : "";
+      return `<${prefix}si><${prefix}t${tAttr}>${clean}</${prefix}t></${prefix}si>`;
+    }).join("");
+    xml = xml.substring(0, closingMatch.index) + appended + xml.substring(closingMatch.index);
     this.zip.updateFile("xl/sharedStrings.xml", Buffer.from(xml, "utf8"));
+    this.sharedStringsXml = xml;
+    this.sharedStringsOriginalLength = this.sharedStringsValues.length;
+    this.sharedStringsPending = [];
+    this.sharedStringsDirty = false;
   }
   // ------------------------------------------------------------------
   // Styles
@@ -4227,7 +5308,7 @@ var XlsxUpdater = class {
       return `<c r="${colRef}${rowNum}" t="b"${colStyle > 0 ? ` s="${colStyle}"` : ""}><v>${val ? 1 : 0}</v></c>`;
     }
     if (val instanceof Date) {
-      const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+      const oaDate = timeToOaDate(val.getTime(), this._oaEpoch);
       if (Number.isFinite(oaDate)) {
         const style = colStyle > 0 ? colStyle : dateStyle !== null ? dateStyle : 0;
         return `<c r="${colRef}${rowNum}"${style > 0 ? ` s="${style}"` : ""}><v>${oaDate}</v></c>`;
@@ -4253,10 +5334,25 @@ var XlsxUpdater = class {
       index = this.sharedStringsValues.length;
       this.sharedStringsValues.push(text);
       this.stringIndexMap.set(text, index);
+      this.sharedStringsPending.push(text);
     }
     this.sharedStringsCount++;
+    this.sharedStringsDirty = true;
     return `<c r="${colRef}${rowNum}" t="s"${styleAttr}><v>${index}</v></c>`;
   }
+  static _replaceOrAddXmlAttribute(tag, name, value) {
+    const escaped = escapeXmlText(value);
+    const attribute = new RegExp(`(\\s${name}\\s*=\\s*["'])[^"']*(["'])`, "i");
+    if (attribute.test(tag)) {
+      return tag.replace(attribute, `$1${escaped}$2`);
+    }
+    const insertion = ` ${name}="${escaped}"`;
+    return tag.endsWith("/>") ? `${tag.slice(0, -2)}${insertion}/>` : `${tag.slice(0, -1)}${insertion}>`;
+  }
+  _sharedStringRefCount(sheetXml) {
+    const cellTags = sheetXml.match(/<(?:(?:[A-Za-z_][\w.-]*):)?c\b[^>]*>/gi) ?? [];
+    return cellTags.filter((tag) => /(?:^|\s)t\s*=\s*["']s["']/i.test(tag)).length;
+  }
   // ------------------------------------------------------------------
   // Worksheet XML patching
   // ------------------------------------------------------------------
@@ -4298,6 +5394,109 @@ var XlsxUpdater = class {
     }
     return xml;
   }
+  _patchSheetFile(sheetXml, rowsPath, outputPath, dimensionRef) {
+    var _a, _b, _c, _d;
+    const source = Buffer.from(sheetXml, "utf8");
+    const text = sheetXml;
+    const replacements = [];
+    const emptySheetData = /<(?<prefix>[A-Za-z_][\w.-]*:)?sheetData\b(?<attrs>[^>]*)\/>/i.exec(text);
+    if (emptySheetData && emptySheetData.index !== void 0) {
+      const prefix = ((_a = emptySheetData.groups) == null ? void 0 : _a.prefix) ?? "";
+      replacements.push({
+        start: emptySheetData.index,
+        end: emptySheetData.index + emptySheetData[0].length,
+        data: Buffer.from(`<${prefix}sheetData${((_b = emptySheetData.groups) == null ? void 0 : _b.attrs) ?? ""}>`, "utf8"),
+        rows: true,
+        suffix: Buffer.from(`</${prefix}sheetData>`, "utf8")
+      });
+    } else {
+      const opening = /<(?<prefix>[A-Za-z_][\w.-]*:)?sheetData\b[^>]*>/i.exec(text);
+      if (!opening || opening.index === void 0) {
+        throw new Error("XlsxUpdater: <sheetData> element not found in worksheet XML.");
+      }
+      const prefix = ((_c = opening.groups) == null ? void 0 : _c.prefix) ?? "";
+      const closeRe = new RegExp(`</${prefix}sheetData\\s*>`, "i");
+      const closing = closeRe.exec(text.slice(opening.index + opening[0].length));
+      if (!closing || closing.index === void 0) {
+        throw new Error("XlsxUpdater: <sheetData> element not closed in worksheet XML.");
+      }
+      const closingStart = opening.index + opening[0].length + closing.index;
+      replacements.push({
+        start: opening.index + opening[0].length,
+        end: closingStart,
+        rows: true
+      });
+    }
+    const dimension = /<(?<prefix>[A-Za-z_][\w.-]*:)?dimension\b[^>]*>/i.exec(text);
+    if (dimension && dimension.index !== void 0) {
+      replacements.push({
+        start: dimension.index,
+        end: dimension.index + dimension[0].length,
+        data: Buffer.from(
+          _XlsxUpdater._replaceOrAddXmlAttribute(dimension[0], "ref", dimensionRef)
+        )
+      });
+    } else {
+      const root = /<(?<prefix>[A-Za-z_][\w.-]*:)?worksheet\b[^>]*>/i.exec(text);
+      if (root && root.index !== void 0) {
+        const prefix = ((_d = root.groups) == null ? void 0 : _d.prefix) ?? "";
+        const insertAt = root.index + root[0].length;
+        replacements.push({
+          start: insertAt,
+          end: insertAt,
+          data: Buffer.from(`<${prefix}dimension ref="${dimensionRef}"/>`, "utf8")
+        });
+      }
+    }
+    const autoFilter = /<(?<prefix>[A-Za-z_][\w.-]*:)?autoFilter\b[^>]*>/i.exec(text);
+    if (autoFilter && autoFilter.index !== void 0) {
+      replacements.push({
+        start: autoFilter.index,
+        end: autoFilter.index + autoFilter[0].length,
+        data: Buffer.from(
+          _XlsxUpdater._replaceOrAddXmlAttribute(autoFilter[0], "ref", dimensionRef),
+          "utf8"
+        )
+      });
+    }
+    replacements.sort((a, b) => a.start - b.start || a.end - b.end);
+    const fd = fs5.openSync(outputPath, "w");
+    let cursor = 0;
+    const writeBuffer = (data) => {
+      fs5.writeSync(fd, data);
+    };
+    const copyRows = () => {
+      const rowsFd = fs5.openSync(rowsPath, "r");
+      try {
+        const chunk = Buffer.alloc(1024 * 1024);
+        const length = fs5.statSync(rowsPath).size;
+        let position = 0;
+        while (position < length) {
+          const count = fs5.readSync(rowsFd, chunk, 0, Math.min(chunk.length, length - position), position);
+          if (count <= 0) throw new Error("XlsxUpdater: failed to read staged rows.");
+          fs5.writeSync(fd, chunk, 0, count);
+          position += count;
+        }
+      } finally {
+        fs5.closeSync(rowsFd);
+      }
+    };
+    try {
+      for (const replacement of replacements) {
+        const startByte = Buffer.byteLength(text.slice(0, replacement.start), "utf8");
+        const endByte = Buffer.byteLength(text.slice(0, replacement.end), "utf8");
+        if (startByte < cursor) throw new Error("XlsxUpdater: overlapping worksheet replacements.");
+        writeBuffer(source.subarray(cursor, startByte));
+        if (replacement.data) writeBuffer(replacement.data);
+        if (replacement.rows) copyRows();
+        if (replacement.suffix) writeBuffer(replacement.suffix);
+        cursor = endByte;
+      }
+      writeBuffer(source.subarray(cursor));
+    } finally {
+      fs5.closeSync(fd);
+    }
+  }
   // ------------------------------------------------------------------
   // Pivot table integration
   // ------------------------------------------------------------------
@@ -4326,93 +5525,251 @@ var XlsxUpdater = class {
     }
   }
   _addRefreshOnLoadToPivotTables() {
-    for (const path3 of this.pivotTableDefPaths) {
-      const entry = this.zip.getEntry(path3);
+    for (const path9 of this.pivotTableDefPaths) {
+      const entry = this.zip.getEntry(path9);
       if (!entry) continue;
       let xml = entry.getData().toString("utf8");
       const rootRe = /<pivotTableDefinition\b[^>]*>/;
       const rootMatch = rootRe.exec(xml);
-      if (!rootMatch || rootMatch[0].includes("refreshOnLoad")) continue;
-      const newTag = rootMatch[0].replace(/(\/?>)$/, ' refreshOnLoad="1"$1');
-      xml = xml.substring(0, rootMatch.index) + newTag + xml.substring(rootMatch.index + rootMatch[0].length);
-      this.zip.updateFile(path3, Buffer.from(xml, "utf8"));
-    }
-  }
-};
-
-// src/XlsbUpdater.ts
-import * as fs4 from "fs";
-import AdmZip3 from "adm-zip";
-
-// src/biff12Utils.ts
-function readVlq(buf, pos) {
-  let value = 0;
-  let shift = 0;
-  let byte;
-  do {
-    byte = buf[pos++];
-    value |= (byte & 127) << shift;
-    shift += 7;
-  } while ((byte & 128) !== 0);
-  return { value, nextPos: pos };
-}
-function vlqBytes(value) {
-  const out = [];
-  while (value >= 128) {
-    out.push(value & 127 | 128);
-    value >>>= 7;
-  }
-  out.push(value & 127);
-  return out;
-}
-function readRecord(buf, pos, rec) {
-  const idRes = readVlq(buf, pos);
-  if (idRes.nextPos > buf.length) return false;
-  const lenRes = readVlq(buf, idRes.nextPos);
-  if (lenRes.nextPos + lenRes.value > buf.length) return false;
-  rec.headerStart = pos;
-  rec.dataStart = lenRes.nextPos;
-  rec.dataEnd = lenRes.nextPos + lenRes.value;
-  rec.id = idRes.value;
-  rec.len = lenRes.value;
-  return true;
-}
-function buildRecord(id, payload) {
-  const idBytes = vlqBytes(id);
-  const lenBytes = vlqBytes(payload.length);
-  const header = Buffer.alloc(idBytes.length + lenBytes.length);
-  idBytes.forEach((b, i) => header[i] = b);
-  lenBytes.forEach((b, i) => header[idBytes.length + i] = b);
-  return Buffer.concat([header, payload]);
-}
-function readUtf16(buf, start, charCount) {
-  const end = start + charCount * 2;
-  if (end > buf.length) return "";
-  return buf.toString("utf16le", start, end);
-}
-function parseSharedStringsBin(buf) {
-  const values = [];
-  let total = 0;
-  let unique = 0;
-  let endSstOffset = buf.length;
-  const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
-  let pos = 0;
-  while (readRecord(buf, pos, rec)) {
-    pos = rec.dataEnd;
-    if (rec.id === 159) {
-      total = buf.readUInt32LE(rec.dataStart);
-      unique = buf.readUInt32LE(rec.dataStart + 4);
-    } else if (rec.id === 19) {
-      const cch = buf.readUInt32LE(rec.dataStart + 1);
-      values.push(readUtf16(buf, rec.dataStart + 5, cch));
-    } else if (rec.id === 160) {
-      endSstOffset = rec.headerStart;
+      if (!rootMatch || rootMatch[0].includes("refreshOnLoad")) continue;
+      const newTag = rootMatch[0].replace(/(\/?>)$/, ' refreshOnLoad="1"$1');
+      xml = xml.substring(0, rootMatch.index) + newTag + xml.substring(rootMatch.index + rootMatch[0].length);
+      this.zip.updateFile(path9, Buffer.from(xml, "utf8"));
     }
   }
-  return { values, total, unique, endSstOffset };
-}
+  /**
+   * Remove the stale calculation chain (xl/calcChain.xml). Excel rebuilds it
+   * on open; keeping stale <c> entries for the replaced sheet would force a
+   * repair prompt. Removes the part, its Content_Types override and its
+   * workbook rels entry (xlspy parity).
+   */
+  _removeCalcChain() {
+    const calcPath = "xl/calcChain.xml";
+    if (!this.zip.getEntry(calcPath) && !this.stagedParts.has(calcPath)) {
+      this._ensureCalcPrFullCalc();
+      return;
+    }
+    try {
+      this.zip.deleteFile(calcPath);
+    } catch {
+    }
+    const stagedCalc = this.stagedParts.get(calcPath);
+    if (stagedCalc) {
+      this.stagedParts.delete(calcPath);
+      try {
+        fs5.rmSync(stagedCalc, { force: true });
+      } catch {
+      }
+    }
+    const ctEntry = this.zip.getEntry("[Content_Types].xml");
+    if (ctEntry || this.stagedParts.has("[Content_Types].xml")) {
+      try {
+        let ct = this._entryData("[Content_Types].xml").toString("utf8");
+        const before = ct;
+        ct = ct.replace(/<Override\b[^>]*PartName="\/xl\/calcChain\.xml"[^>]*\/?>/gi, "");
+        if (ct !== before) {
+          this._writePartText("[Content_Types].xml", ct);
+        }
+      } catch {
+      }
+    }
+    const relsPath = "xl/_rels/workbook.xml.rels";
+    if (this.zip.getEntry(relsPath) || this.stagedParts.has(relsPath)) {
+      try {
+        const rels = this._entryData(relsPath).toString("utf8");
+        const relTagRe = /<Relationship\b[^>]*>/g;
+        let m;
+        let out = "";
+        let last = 0;
+        let changed = false;
+        while ((m = relTagRe.exec(rels)) !== null) {
+          const attrs = parseTagAttributes(m[0]);
+          const type = attrs["Type"] ?? attrs["type"] ?? "";
+          const target = attrs["Target"] ?? attrs["target"] ?? "";
+          const isCalcChain = type.endsWith("/calcChain") && resolveRelTarget(target) === "xl/calcChain.xml";
+          if (isCalcChain) {
+            out += rels.substring(last, m.index);
+            last = m.index + m[0].length;
+            changed = true;
+          }
+        }
+        if (changed) {
+          out += rels.substring(last);
+          this._writePartText(relsPath, out);
+        }
+      } catch {
+      }
+    }
+    this._ensureCalcPrFullCalc();
+  }
+  _writePartText(name, text) {
+    if (this.stagedParts.has(name)) {
+      fs5.writeFileSync(this.stagedParts.get(name), text, "utf8");
+    } else {
+      this.zip.updateFile(name, Buffer.from(text, "utf8"));
+    }
+  }
+  _ensureCalcPrFullCalc() {
+    try {
+      const wbPath = "xl/workbook.xml";
+      if (!this.zip.getEntry(wbPath) && !this.stagedParts.has(wbPath)) return;
+      let xml = this._entryData(wbPath).toString("utf8");
+      const calcPrRe = /<(?:[A-Za-z_][\w.-]*:)?calcPr\b[^>]*>/i;
+      const match = calcPrRe.exec(xml);
+      if (match && match.index !== void 0) {
+        const newTag = _XlsxUpdater._replaceOrAddXmlAttribute(match[0], "fullCalcOnLoad", "1");
+        xml = xml.substring(0, match.index) + newTag + xml.substring(match.index + match[0].length);
+      } else {
+        const insertAt = _XlsxUpdater._calcPrInsertPosition(xml);
+        if (insertAt < 0) return;
+        xml = xml.substring(0, insertAt) + '<calcPr fullCalcOnLoad="1"/>' + xml.substring(insertAt);
+      }
+      this._writePartText(wbPath, xml);
+    } catch {
+    }
+  }
+  /**
+   * Insertion offset for a missing `<calcPr>`. The element follows
+   * sheets/externalReferences/definedNames in the workbook schema, so insert
+   * after the last of those that exists instead of right after `<workbook>`.
+   */
+  static _calcPrInsertPosition(xml) {
+    const prefixed = "(?:[A-Za-z_][\\w.-]*:)?";
+    const candidates = [
+      new RegExp(`</${prefixed}sheets\\s*>`, "i"),
+      new RegExp(`<${prefixed}externalReferences\\b[^>]*/>`, "i"),
+      new RegExp(`<${prefixed}externalReferences\\b[^>]*>[\\s\\S]*?</${prefixed}externalReferences\\s*>`, "i"),
+      new RegExp(`<${prefixed}definedNames\\b[^>]*/>`, "i"),
+      new RegExp(`<${prefixed}definedNames\\b[^>]*>[\\s\\S]*?</${prefixed}definedNames\\s*>`, "i")
+    ];
+    let insertAt = -1;
+    for (const re of candidates) {
+      const m = re.exec(xml);
+      if (m && m.index !== void 0) {
+        insertAt = Math.max(insertAt, m.index + m[0].length);
+      }
+    }
+    if (insertAt >= 0) return insertAt;
+    const close = new RegExp(`</${prefixed}workbook\\s*>`, "i").exec(xml);
+    if (close && close.index !== void 0) return close.index;
+    const root = new RegExp(`<${prefixed}workbook\\b[^>]*>`, "i").exec(xml);
+    if (!root || root.index === void 0) return -1;
+    return root.index + root[0].length;
+  }
+  /**
+   * Update ListObject table ranges (xl/tables/*.xml) for the replaced sheet.
+   * Only tables anchored at A1 are updated to the new dimension; tables
+   * elsewhere are left untouched (moving them would corrupt the sheet).
+   * Empty replacements (dimRef "A1") do not shrink multi-column tables.
+   */
+  _updateTableRefs(sheetName, dimRef) {
+    const sheetPath = this.sheetNameToPath.get(sheetName);
+    if (!sheetPath) return;
+    const slash = sheetPath.lastIndexOf("/");
+    const dir = slash >= 0 ? sheetPath.substring(0, slash + 1) : "";
+    const base = slash >= 0 ? sheetPath.substring(slash + 1) : sheetPath;
+    const sheetRelsPath = `${dir}_rels/${base}.rels`;
+    const sheetRelsEntry = this.zip.getEntry(sheetRelsPath);
+    const hasStagedRels = this.stagedParts.has(sheetRelsPath);
+    if (!sheetRelsEntry && !hasStagedRels) return;
+    const tableTargets = [];
+    try {
+      const relsXml = this._entryData(sheetRelsPath).toString("utf8");
+      const relTagRe = /<Relationship\b[^>]*>/g;
+      let m;
+      while ((m = relTagRe.exec(relsXml)) !== null) {
+        const attrs = parseTagAttributes(m[0]);
+        const type = attrs["Type"] ?? attrs["type"] ?? "";
+        const target = attrs["Target"] ?? attrs["target"] ?? "";
+        if (!type.includes("/table") || !target) continue;
+        let tablePath;
+        if (target.startsWith("/")) {
+          tablePath = resolveRelTarget(target);
+        } else {
+          const combined = dir + target;
+          const parts = [];
+          for (const seg of combined.split("/")) {
+            if (seg === "..") parts.pop();
+            else if (seg !== "." && seg !== "") parts.push(seg);
+          }
+          tablePath = parts.join("/");
+        }
+        tableTargets.push(tablePath);
+      }
+    } catch {
+      return;
+    }
+    if (tableTargets.length === 0) return;
+    const tables = [];
+    for (const tablePath of tableTargets) {
+      try {
+        const hasEntry = !!this.zip.getEntry(tablePath);
+        const hasStaged = this.stagedParts.has(tablePath);
+        if (!hasEntry && !hasStaged) continue;
+        const xml = this._entryData(tablePath).toString("utf8");
+        const tableTagRe = /<(?:[A-Za-z_][\w.-]*:)?table\b[^>]*>/i;
+        const tableMatch = tableTagRe.exec(xml);
+        if (!tableMatch || tableMatch.index === void 0) continue;
+        const refMatch = /\bref\s*=\s*("([^"]*)"|'([^']*)')/i.exec(tableMatch[0]);
+        const ref = refMatch ? refMatch[2] ?? refMatch[3] ?? "" : "";
+        tables.push({
+          path: tablePath,
+          xml,
+          tag: tableMatch[0],
+          tagIndex: tableMatch.index,
+          ref,
+          range: parseCellRange(ref),
+          staged: hasStaged
+        });
+      } catch {
+      }
+    }
+    if (tables.length === 0) return;
+    const dimRange = parseCellRange(dimRef);
+    if (!dimRange) return;
+    for (const table of tables) {
+      try {
+        const origRange = table.range;
+        if (!origRange) continue;
+        if (origRange.r1 !== 1 || origRange.c1 !== 0) continue;
+        if (dimRef === "A1" && !/^A1$/i.test(table.ref)) continue;
+        const origCols = origRange.c2 - origRange.c1 + 1;
+        const newCols = dimRange.c2 - dimRange.c1 + 1;
+        if (newCols !== origCols) continue;
+        let lastRow = dimRange.r2;
+        for (const other of tables) {
+          if (other === table || !other.range) continue;
+          if (other.range.r1 <= 1) continue;
+          if (other.range.c1 > origRange.c2 || other.range.c2 < origRange.c1) continue;
+          lastRow = Math.min(lastRow, other.range.r1 - 1);
+        }
+        if (lastRow < 1) continue;
+        const newRef = origRange.c2 === 0 && lastRow === 1 ? "A1" : `A1:${columnIndexToLetter(origRange.c2)}${lastRow}`;
+        let xml = table.xml;
+        const newTag = _XlsxUpdater._replaceOrAddXmlAttribute(table.tag, "ref", newRef);
+        xml = xml.substring(0, table.tagIndex) + newTag + xml.substring(table.tagIndex + table.tag.length);
+        const afRe = /<(?:[A-Za-z_][\w.-]*:)?autoFilter\b[^>]*>/i;
+        const afMatch = afRe.exec(xml);
+        if (afMatch && afMatch.index !== void 0) {
+          const newAf = _XlsxUpdater._replaceOrAddXmlAttribute(afMatch[0], "ref", newRef);
+          xml = xml.substring(0, afMatch.index) + newAf + xml.substring(afMatch.index + afMatch[0].length);
+        }
+        if (table.staged) {
+          fs5.writeFileSync(this.stagedParts.get(table.path), xml, "utf8");
+        } else {
+          this.zip.updateFile(table.path, Buffer.from(xml, "utf8"));
+        }
+      } catch {
+      }
+    }
+  }
+};
 
 // src/XlsbUpdater.ts
+import * as fs6 from "fs";
+import * as os2 from "os";
+import * as path7 from "path";
+import AdmZip3 from "adm-zip";
 var CELL_RECORDS = /* @__PURE__ */ new Set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
 var RK_INT_LOWER = -1 << 29;
 var RK_INT_UPPER = (1 << 29) - 1;
@@ -4420,7 +5777,9 @@ var XlsbUpdater = class {
   /**
    * @param path Path to an existing `.xlsb` file.
    */
-  constructor(path3) {
+  constructor(filePath) {
+    this.temporaryDirectory = null;
+    this.stagedParts = /* @__PURE__ */ new Map();
     this.sheetNameToPath = /* @__PURE__ */ new Map();
     this.pivotCacheDefPaths = [];
     this.sharedStringsBuf = null;
@@ -4429,16 +5788,17 @@ var XlsbUpdater = class {
     this.sharedStringsUnique = 0;
     this.sharedStringsEndSst = 0;
     this.stringIndexMap = /* @__PURE__ */ new Map();
+    this.sharedStringsDirty = false;
     // ------------------------------------------------------------------
     // Shared strings
     // ------------------------------------------------------------------
     this._appendCount = 0;
-    this.sourcePath = path3;
+    this.sourcePath = filePath;
     this._oaEpoch = Date.UTC(1899, 11, 30);
-    if (!fs4.existsSync(path3)) {
-      throw new Error(`XlsbUpdater: file not found: ${path3}`);
+    if (!fs6.existsSync(filePath)) {
+      throw new Error(`XlsbUpdater: file not found: ${filePath}`);
     }
-    this.zip = new AdmZip3(path3);
+    this.zip = new AdmZip3(filePath);
     if (!this.zip.getEntry("xl/workbook.bin")) {
       throw new Error(
         "XlsbUpdater: not an XLSB workbook (xl/workbook.bin missing). Convert the file to XLSB first."
@@ -4469,8 +5829,15 @@ var XlsbUpdater = class {
     if (!entry) {
       throw new Error(`XlsbUpdater: worksheet part missing for sheet "${sheetName}".`);
     }
-    const sheetBuf = entry.getData();
+    const sheetBuf = this._entryData(sheetPath);
     this._ensureSharedStringsLoaded();
+    if (this.sharedStringsBuf !== null) {
+      this.sharedStringsTotal = Math.max(
+        0,
+        this.sharedStringsTotal - this._sharedStringRefCount(sheetBuf)
+      );
+      this.sharedStringsDirty = true;
+    }
     let dataStyles = /* @__PURE__ */ new Map();
     let headerStyles = /* @__PURE__ */ new Map();
     let dateXf = null;
@@ -4499,12 +5866,222 @@ var XlsbUpdater = class {
     }
     this._patchDimension(newSheet, lastRowIdx, lastCol);
     this.zip.updateFile(sheetPath, newSheet);
-    if (this.sharedStringsBuf !== null && this._appendCount > 0) {
+    this._discardStagedPart(sheetPath);
+    if (this.sharedStringsBuf !== null) {
       this._commitSharedStrings();
     }
     const rwLast = Math.max(0, rows.length + (headers ? 1 : 0) - 1);
     const colLast = lastCol;
     this._patchPivotCaches(sheetName, rwLast, colLast);
+    this._removeCalcChain();
+  }
+  /** Replace worksheet rows from a one-pass source. */
+  async replaceSheetDataStream(sheetName, rows, options = {}) {
+    const { headers, styleFallback = "inherit" } = options;
+    if (styleFallback !== "inherit" && styleFallback !== "general") {
+      throw new Error("XlsbUpdater: styleFallback must be 'inherit' or 'general'.");
+    }
+    const sheetPath = this.sheetNameToPath.get(sheetName);
+    if (!sheetPath) {
+      throw new Error(`XlsbUpdater: sheet "${sheetName}" not found in the workbook.`);
+    }
+    const entry = this.zip.getEntry(sheetPath);
+    if (!entry) {
+      throw new Error(`XlsbUpdater: worksheet part missing for sheet "${sheetName}".`);
+    }
+    const oldStage = this.stagedParts.get(sheetPath);
+    const beforeValuesLength = this.sharedStringsValues.length;
+    const beforeAppendCount = this._appendCount;
+    const beforeSharedStringsTotal = this.sharedStringsTotal;
+    const beforeSharedStringsUnique = this.sharedStringsUnique;
+    const beforeSharedStringsEndSst = this.sharedStringsEndSst;
+    const beforeSharedStringsDirty = this.sharedStringsDirty;
+    const beforeStringIndexMap = new Map(this.stringIndexMap);
+    const sharedStringsEntry = this.zip.getEntry("xl/sharedStrings.bin");
+    const beforeSharedStringsBytes = sharedStringsEntry || this.stagedParts.has("xl/sharedStrings.bin") ? Buffer.from(this._entryData("xl/sharedStrings.bin")) : null;
+    const beforeSharedStringsBuf = this.sharedStringsBuf ? Buffer.from(this.sharedStringsBuf) : null;
+    const oldSheet = this._entryData(sheetPath);
+    const rowsPath = this._temporaryPath(".rows");
+    const outputPath = this._temporaryPath(".bin");
+    const createdParts = [rowsPath, outputPath];
+    let output = null;
+    try {
+      this._ensureSharedStringsLoaded();
+      if (this.sharedStringsBuf !== null) {
+        this.sharedStringsTotal = Math.max(
+          0,
+          this.sharedStringsTotal - this._sharedStringRefCount(oldSheet)
+        );
+        this.sharedStringsDirty = true;
+      }
+      let dataStyles = /* @__PURE__ */ new Map();
+      let headerStyles = /* @__PURE__ */ new Map();
+      let dateXf = null;
+      if (styleFallback !== "general") {
+        const collected = this._collectStyles(oldSheet);
+        dataStyles = collected.dataStyles;
+        headerStyles = collected.headerStyles;
+        dateXf = this._findDateXf();
+      }
+      const rowOutput = fs6.createWriteStream(rowsPath);
+      output = rowOutput;
+      let outputError = null;
+      rowOutput.on("error", (error) => {
+        outputError = error;
+      });
+      let writtenBytes = 0;
+      let lastKeptEnd = 0;
+      let width = (headers == null ? void 0 : headers.length) ?? 0;
+      let dataRowsSeen = 0;
+      let keptDataRows = 0;
+      let pendingEmptyWidth = 0;
+      let nextRow = 0;
+      const rowHeaderOffsets = [];
+      const write = async (data) => {
+        if (outputError) throw outputError;
+        writtenBytes += data.length;
+        if (rowOutput.write(data)) return;
+        await new Promise((resolve6, reject) => {
+          const onDrain = () => {
+            cleanup();
+            resolve6();
+          };
+          const onError = (error) => {
+            cleanup();
+            reject(error);
+          };
+          const cleanup = () => {
+            rowOutput.off("drain", onDrain);
+            rowOutput.off("error", onError);
+          };
+          rowOutput.once("drain", onDrain);
+          rowOutput.once("error", onError);
+        });
+      };
+      const writeRow = async (rowNumber, cells) => {
+        rowHeaderOffsets.push(writtenBytes);
+        const header = Buffer.alloc(27);
+        header[0] = 0;
+        header[1] = 25;
+        header.writeInt32LE(rowNumber, 2);
+        header[10] = 44;
+        header[11] = 1;
+        header[15] = 1;
+        header.writeInt32LE(0, 19);
+        header.writeInt32LE(0, 23);
+        await write(header);
+        for (const cell of cells) await write(cell);
+      };
+      if (headers !== void 0) {
+        await writeRow(0, headers.map((value, column) => this._stringCellBytes(column, styleFallback === "general" ? 0 : headerStyles.get(column) ?? 0, value)));
+        lastKeptEnd = writtenBytes;
+        nextRow = 1;
+      }
+      for await (const sourceRow of rows) {
+        if (typeof sourceRow === "string" || sourceRow instanceof Uint8Array) {
+          throw new TypeError("Each row must be an iterable of cells, not text");
+        }
+        const row = Array.from(sourceRow);
+        const cells = row.map((value, column) => value === null || value === void 0 ? null : this._valueCellBytes(value, column, dataStyles, dateXf)).filter((cell) => cell !== null);
+        await writeRow(nextRow, cells);
+        dataRowsSeen++;
+        nextRow++;
+        if (row.every((value) => value === null || value === void 0)) {
+          pendingEmptyWidth = Math.max(pendingEmptyWidth, row.length);
+        } else {
+          width = Math.max(width, pendingEmptyWidth, row.length);
+          pendingEmptyWidth = 0;
+          keptDataRows = dataRowsSeen;
+          lastKeptEnd = writtenBytes;
+        }
+      }
+      await new Promise((resolve6, reject) => {
+        rowOutput.once("close", resolve6);
+        rowOutput.once("error", reject);
+        rowOutput.end();
+      });
+      if (outputError) throw outputError;
+      const rowsFd = fs6.openSync(rowsPath, "r+");
+      try {
+        fs6.ftruncateSync(rowsFd, lastKeptEnd);
+      } finally {
+        fs6.closeSync(rowsFd);
+      }
+      const lastCol = Math.max(0, width - 1);
+      const rowPatchFd = fs6.openSync(rowsPath, "r+");
+      try {
+        const lastColBuffer = Buffer.alloc(4);
+        lastColBuffer.writeInt32LE(lastCol, 0);
+        for (const offset of rowHeaderOffsets) {
+          if (offset >= lastKeptEnd) continue;
+          fs6.writeSync(rowPatchFd, lastColBuffer, 0, lastColBuffer.length, offset + 23);
+        }
+      } finally {
+        fs6.closeSync(rowPatchFd);
+      }
+      const { rowsStart, rowsEnd, autoFilterRanges } = this._findRowsRegion(oldSheet);
+      const oldLength = oldSheet.length;
+      const newRowsLength = fs6.statSync(rowsPath).size;
+      const delta = newRowsLength - (rowsEnd - rowsStart);
+      const outputFd = fs6.openSync(outputPath, "w");
+      try {
+        fs6.writeSync(outputFd, oldSheet, 0, rowsStart, null);
+        const rowsFdRead = fs6.openSync(rowsPath, "r");
+        try {
+          const chunk = Buffer.alloc(1024 * 1024);
+          let position = 0;
+          while (position < newRowsLength) {
+            const count = fs6.readSync(rowsFdRead, chunk, 0, Math.min(chunk.length, newRowsLength - position), position);
+            if (count <= 0) throw new Error("XlsbUpdater: failed to read staged rows.");
+            fs6.writeSync(outputFd, chunk, 0, count);
+            position += count;
+          }
+        } finally {
+          fs6.closeSync(rowsFdRead);
+        }
+        fs6.writeSync(outputFd, oldSheet, rowsEnd, oldLength - rowsEnd, rowsStart + newRowsLength);
+      } finally {
+        fs6.closeSync(outputFd);
+      }
+      this._patchSheetMetadataFile(
+        outputPath,
+        oldSheet,
+        rowsEnd,
+        delta,
+        autoFilterRanges,
+        Math.max(0, keptDataRows + (headers !== void 0 ? 1 : 0) - 1),
+        lastCol
+      );
+      this._stagePart(sheetPath, outputPath);
+      this._commitSharedStrings();
+      this._patchPivotCaches(
+        sheetName,
+        Math.max(0, keptDataRows + (headers !== void 0 ? 1 : 0) - 1),
+        lastCol
+      );
+      this._removeCalcChain();
+      if (oldStage && oldStage !== outputPath) this._removeTemporaryFile(oldStage);
+      createdParts.splice(createdParts.indexOf(outputPath), 1);
+    } catch (error) {
+      this.sharedStringsValues.length = beforeValuesLength;
+      this._appendCount = beforeAppendCount;
+      this.sharedStringsTotal = beforeSharedStringsTotal;
+      this.sharedStringsUnique = beforeSharedStringsUnique;
+      this.sharedStringsEndSst = beforeSharedStringsEndSst;
+      this.sharedStringsDirty = beforeSharedStringsDirty;
+      this.sharedStringsBuf = beforeSharedStringsBuf;
+      this.stringIndexMap.clear();
+      for (const [value, index] of beforeStringIndexMap) this.stringIndexMap.set(value, index);
+      if (beforeSharedStringsBytes) {
+        this.zip.updateFile("xl/sharedStrings.bin", beforeSharedStringsBytes);
+      }
+      if (oldStage) this.stagedParts.set(sheetPath, oldStage);
+      else this.stagedParts.delete(sheetPath);
+      throw error;
+    } finally {
+      if (output && !output.closed) output.destroy();
+      for (const temporaryPath of createdParts) this._removeTemporaryFile(temporaryPath);
+    }
   }
   /**
    * Write the updated workbook to disk.
@@ -4512,12 +6089,89 @@ var XlsbUpdater = class {
    */
   save(outputPath) {
     const target = outputPath ?? this.sourcePath;
-    fs4.writeFileSync(target, this.zip.toBuffer());
+    this._materializeStagedParts();
+    writeBufferAtomically(this.zip.toBuffer(), target);
+  }
+  /** Save staged streaming replacements without materialising the ZIP. */
+  async saveStreaming(outputPath) {
+    const target = outputPath ?? this.sourcePath;
+    await writeAdmZipStreaming(this.zip, this.stagedParts, target);
+    this._materializeStagedParts();
   }
   /** The updated workbook as an in-memory ZIP buffer. */
   toBuffer() {
+    this._materializeStagedParts();
     return this.zip.toBuffer();
   }
+  /**
+   * Release the staging directory and any unsaved staged parts.
+   * The updater remains usable; a new staging directory is created lazily
+   * on the next streaming replacement.
+   */
+  dispose() {
+    for (const stagedPath of this.stagedParts.values()) {
+      try {
+        fs6.rmSync(stagedPath, { force: true });
+      } catch {
+      }
+    }
+    this.stagedParts.clear();
+    if (this.temporaryDirectory !== null) {
+      try {
+        fs6.rmSync(this.temporaryDirectory, { recursive: true, force: true });
+      } catch {
+      }
+      this.temporaryDirectory = null;
+    }
+  }
+  /** Support `using` declarations for automatic staging cleanup. */
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  _ensureTemporaryDirectory() {
+    if (this.temporaryDirectory === null) {
+      this.temporaryDirectory = fs6.mkdtempSync(path7.join(os2.tmpdir(), "spreadsheet-updater-"));
+    } else {
+      try {
+        fs6.mkdirSync(this.temporaryDirectory, { recursive: true });
+      } catch {
+      }
+    }
+    return this.temporaryDirectory;
+  }
+  _temporaryPath(suffix) {
+    return path7.join(this._ensureTemporaryDirectory(), `part-${Date.now()}-${Math.random().toString(16).slice(2)}${suffix}`);
+  }
+  _removeTemporaryFile(filePath) {
+    try {
+      fs6.rmSync(filePath);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  _entryData(name) {
+    const stagedPath = this.stagedParts.get(name);
+    if (stagedPath) return fs6.readFileSync(stagedPath);
+    const entry = this.zip.getEntry(name);
+    if (!entry) throw new Error(`XlsbUpdater: ZIP member missing: ${name}`);
+    return entry.getData();
+  }
+  _stagePart(name, filePath) {
+    this.stagedParts.set(name, filePath);
+  }
+  _discardStagedPart(name) {
+    const stagedPath = this.stagedParts.get(name);
+    if (!stagedPath) return;
+    this._removeTemporaryFile(stagedPath);
+    this.stagedParts.delete(name);
+  }
+  _materializeStagedParts() {
+    for (const [name, stagedPath] of this.stagedParts) {
+      this.zip.updateFile(name, fs6.readFileSync(stagedPath));
+      this._removeTemporaryFile(stagedPath);
+    }
+    this.stagedParts.clear();
+  }
   // ------------------------------------------------------------------
   // Workbook structure
   // ------------------------------------------------------------------
@@ -4526,10 +6180,15 @@ var XlsbUpdater = class {
     const rIdToTarget = {};
     if (relsEntry) {
       const rels = relsEntry.getData().toString("utf8");
-      const relRegex = /<Relationship[^>]*Id="([^"]*)"[^>]*Target="([^"]*)"/g;
-      let match;
-      while ((match = relRegex.exec(rels)) !== null) {
-        rIdToTarget[match[1]] = match[2];
+      const relTagRe = /<Relationship\b[^>]*>/g;
+      let tagMatch;
+      while ((tagMatch = relTagRe.exec(rels)) !== null) {
+        const attrs = parseTagAttributes(tagMatch[0]);
+        const id = attrs["Id"] ?? attrs["id"];
+        const target = attrs["Target"] ?? attrs["target"];
+        if (id !== void 0 && target !== void 0) {
+          rIdToTarget[id] = target;
+        }
       }
     }
     const wbEntry = this.zip.getEntry("xl/workbook.bin");
@@ -4549,12 +6208,24 @@ var XlsbUpdater = class {
         o += 4;
         const name = readUtf16(wbBuf, o, nameLen);
         let target = rIdToTarget[rId] ?? "";
-        if (target.startsWith("/")) target = target.substring(1);
-        else if (!target.startsWith("xl/")) target = "xl/" + target;
+        target = resolveRelTarget(target);
         if (target) {
           this.sheetNameToPath.set(name, target);
         }
       }
+      try {
+        const rec1904 = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+        let p1904 = 0;
+        while (readRecord(wbBuf, p1904, rec1904)) {
+          if (rec1904.id === 153 && rec1904.len >= 4) {
+            const is1904 = (wbBuf[rec1904.dataStart] & 1) !== 0;
+            this._oaEpoch = is1904 ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+            break;
+          }
+          p1904 = rec1904.dataEnd;
+        }
+      } catch {
+      }
     }
     for (const e of this.zip.getEntries()) {
       if (/^xl\/pivotCache\/pivotCacheDefinition\d*\.bin$/.test(e.entryName)) {
@@ -4567,11 +6238,11 @@ var XlsbUpdater = class {
       return;
     }
     const entry = this.zip.getEntry("xl/sharedStrings.bin");
-    if (!entry) {
+    if (!entry && !this.stagedParts.has("xl/sharedStrings.bin")) {
       this.sharedStringsBuf = null;
       return;
     }
-    this.sharedStringsBuf = entry.getData();
+    this.sharedStringsBuf = this._entryData("xl/sharedStrings.bin");
     const parsed = parseSharedStringsBin(this.sharedStringsBuf);
     this.sharedStringsValues = parsed.values;
     this.sharedStringsTotal = parsed.total;
@@ -4583,9 +6254,10 @@ var XlsbUpdater = class {
       }
     });
     this._appendCount = 0;
+    this.sharedStringsDirty = false;
   }
   _commitSharedStrings() {
-    if (this.sharedStringsBuf === null || this._appendCount === 0) return;
+    if (this.sharedStringsBuf === null || !this.sharedStringsDirty) return;
     const originalValuesLength = this.sharedStringsValues.length - this._appendCount;
     let newItems = Buffer.alloc(0);
     for (let i = originalValuesLength; i < this.sharedStringsValues.length; i++) {
@@ -4611,6 +6283,9 @@ var XlsbUpdater = class {
       pos = rec.dataEnd;
     }
     this.zip.updateFile("xl/sharedStrings.bin", out);
+    this.sharedStringsBuf = out;
+    this._appendCount = 0;
+    this.sharedStringsDirty = false;
   }
   // ------------------------------------------------------------------
   // Styles
@@ -4659,27 +6334,15 @@ var XlsbUpdater = class {
   _findDateXf() {
     const entry = this.zip.getEntry("xl/styles.bin");
     if (!entry) return null;
-    const stylesBuf = entry.getData();
-    const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
-    let pos = 0;
-    let inCellXfs = false;
-    let xfIndex = 0;
-    while (readRecord(stylesBuf, pos, rec)) {
-      pos = rec.dataEnd;
-      if (rec.id === 617) {
-        inCellXfs = true;
-        xfIndex = 0;
-        continue;
-      }
-      if (rec.id === 618) {
-        inCellXfs = false;
-        continue;
-      }
-      if (inCellXfs && rec.id === 47 && rec.len >= 4) {
-        const numFmtId = stylesBuf.readUInt16LE(rec.dataStart + 2);
-        const isDate = numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47;
-        if (isDate) return xfIndex;
-        xfIndex++;
+    const reader = new BiffReaderWriter(entry.getData());
+    while (reader.readStyles()) {
+    }
+    const numFmtIds = reader._xfIndexToNumFmtId;
+    const customDates = reader._customNumFmts;
+    for (let i = 0; i < numFmtIds.length; i++) {
+      const numFmtId = numFmtIds[i];
+      if (numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47 || customDates.has(numFmtId)) {
+        return i;
       }
     }
     return null;
@@ -4759,7 +6422,7 @@ var XlsbUpdater = class {
       return buildRecord(4, payload);
     }
     if (val instanceof Date) {
-      const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+      const oaDate = timeToOaDate(val.getTime(), this._oaEpoch);
       if (Number.isFinite(oaDate)) {
         const style = colStyle > 0 ? colStyle : dateXf !== null ? dateXf : 0;
         const payload = Buffer.alloc(16);
@@ -4793,12 +6456,51 @@ var XlsbUpdater = class {
       this._appendCount++;
     }
     this.sharedStringsTotal++;
+    this.sharedStringsDirty = true;
     const payload = Buffer.alloc(12);
     payload.writeUInt32LE(col, 0);
     payload.writeUInt32LE(style, 4);
     payload.writeUInt32LE(index, 8);
     return buildRecord(7, payload);
   }
+  _sharedStringRefCount(sheetBuf) {
+    const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+    let pos = 0;
+    let count = 0;
+    while (readRecord(sheetBuf, pos, rec)) {
+      if (rec.id === 7) count++;
+      pos = rec.dataEnd;
+    }
+    return count;
+  }
+  _patchSheetMetadataFile(filePath, originalSheet, rowsEnd, delta, autoFilterRanges, lastRowIdx, lastCol) {
+    const fd = fs6.openSync(filePath, "r+");
+    try {
+      const patchInt32 = (offset, value) => {
+        const bytes = Buffer.alloc(4);
+        bytes.writeInt32LE(value, 0);
+        fs6.writeSync(fd, bytes, 0, bytes.length, offset);
+      };
+      for (const filterOffset of autoFilterRanges) {
+        const newOffset = filterOffset >= rowsEnd ? filterOffset + delta : filterOffset;
+        patchInt32(newOffset + 4, lastRowIdx);
+        patchInt32(newOffset + 12, lastCol);
+      }
+      const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+      let pos = 0;
+      while (readRecord(originalSheet, pos, rec)) {
+        if (rec.id === 148 && rec.len >= 16) {
+          const shift = rec.dataStart >= rowsEnd ? delta : 0;
+          patchInt32(rec.dataStart + shift + 4, lastRowIdx);
+          patchInt32(rec.dataStart + shift + 12, lastCol);
+          break;
+        }
+        pos = rec.dataEnd;
+      }
+    } finally {
+      fs6.closeSync(fd);
+    }
+  }
   // ------------------------------------------------------------------
   // Rows region detection
   // ------------------------------------------------------------------
@@ -4829,8 +6531,8 @@ var XlsbUpdater = class {
     return { rowsStart, rowsEnd, autoFilterRanges };
   }
   /**
-   * Keep the sheet dimension record (0x98) in sync with the new data.
-   * Excel uses its rwLast (payload offset 24) and colLast (payload offset 32)
+   * Keep the sheet dimension record (0x94) in sync with the new data.
+   * Excel uses its rwLast (payload offset 4) and colLast (payload offset 12)
    * fields to read the full row range; stale values make the last written row
    * invisible to Excel (and drop it from pivot refreshes).
    */
@@ -4838,9 +6540,9 @@ var XlsbUpdater = class {
     const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
     let pos = 0;
     while (readRecord(sheetBuf, pos, rec)) {
-      if (rec.id === 152 && rec.len >= 36) {
-        sheetBuf.writeInt32LE(lastRowIdx, rec.dataStart + 24);
-        sheetBuf.writeInt32LE(lastCol, rec.dataStart + 32);
+      if (rec.id === 148 && rec.len >= 16) {
+        sheetBuf.writeInt32LE(lastRowIdx, rec.dataStart + 4);
+        sheetBuf.writeInt32LE(lastCol, rec.dataStart + 12);
         return;
       }
       pos = rec.dataEnd;
@@ -4850,8 +6552,8 @@ var XlsbUpdater = class {
   // Pivot cache integration
   // ------------------------------------------------------------------
   _patchPivotCaches(sheetName, rwLast, colLast) {
-    for (const path3 of this.pivotCacheDefPaths) {
-      const entry = this.zip.getEntry(path3);
+    for (const path9 of this.pivotCacheDefPaths) {
+      const entry = this.zip.getEntry(path9);
       if (!entry) continue;
       const buf = Buffer.from(entry.getData());
       const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
@@ -4883,84 +6585,85 @@ var XlsbUpdater = class {
         }
       }
       if (patched) {
-        this.zip.updateFile(path3, buf);
+        this.zip.updateFile(path9, buf);
       }
     }
   }
-};
-
-// src/ExcelConverter.ts
-import * as fs6 from "fs";
-import * as path2 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-import { spawn } from "child_process";
-
-// src/atomicFile.ts
-import * as fs5 from "fs";
-import { randomUUID } from "crypto";
-var realFileOperations = {
-  exists: (filePath) => fs5.existsSync(filePath),
-  rename: (sourcePath, destinationPath) => fs5.renameSync(sourcePath, destinationPath),
-  remove: (filePath) => fs5.rmSync(filePath)
-};
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function destinationExistsError(destinationPath) {
-  return new Error(
-    `Excel conversion: destination already exists (pass { overwrite: true } to replace it): ${destinationPath}`
-  );
-}
-function installTemporaryOutput(temporaryPath, destinationPath, overwrite, operations = realFileOperations) {
-  const backupPath = `${destinationPath}.${randomUUID()}.replacement-backup`;
-  let backupCreated = false;
-  let installed = false;
-  if (operations.exists(destinationPath)) {
-    if (!overwrite) {
-      throw destinationExistsError(destinationPath);
-    }
-    operations.rename(destinationPath, backupPath);
-    backupCreated = true;
-  }
-  try {
+  /**
+   * Remove the stale calculation chain (xl/calcChain.bin). Excel rebuilds it
+   * on open. Removes the part, its Content_Types override and its workbook
+   * rels entry. XLSB tables are not patched (documented limitation).
+   */
+  _removeCalcChain() {
+    const calcPath = "xl/calcChain.bin";
+    if (!this.zip.getEntry(calcPath) && !this.stagedParts.has(calcPath)) return;
     try {
-      operations.rename(temporaryPath, destinationPath);
-      installed = true;
-    } catch (error) {
-      if (overwrite && !backupCreated && operations.exists(destinationPath)) {
-        operations.rename(destinationPath, backupPath);
-        backupCreated = true;
-        operations.rename(temporaryPath, destinationPath);
-        installed = true;
-      } else {
-        throw error;
+      this.zip.deleteFile(calcPath);
+    } catch {
+    }
+    const stagedCalc = this.stagedParts.get(calcPath);
+    if (stagedCalc) {
+      this.stagedParts.delete(calcPath);
+      try {
+        fs6.rmSync(stagedCalc, { force: true });
+      } catch {
       }
     }
-    if (backupCreated) {
-      operations.remove(backupPath);
+    const ctPath = "[Content_Types].xml";
+    if (this.zip.getEntry(ctPath) || this.stagedParts.has(ctPath)) {
+      try {
+        const ct = this._entryData(ctPath).toString("utf8");
+        const updated = ct.replace(
+          /<Override\b[^>]*PartName="\/xl\/calcChain\.bin"[^>]*\/?>/gi,
+          ""
+        );
+        if (updated !== ct) this._writePartText(ctPath, updated);
+      } catch {
+      }
     }
-  } catch (error) {
-    if (backupCreated && !installed) {
-      if (!operations.exists(destinationPath)) {
-        try {
-          operations.rename(backupPath, destinationPath);
-          backupCreated = false;
-        } catch (rollbackError) {
-          throw new Error(
-            `Excel conversion: final destination install failed (${errorMessage(error)}), and restoring the original destination also failed (${errorMessage(rollbackError)}). Original file remains at ${backupPath}.`
-          );
+    const relsPath = "xl/_rels/workbook.bin.rels";
+    if (this.zip.getEntry(relsPath) || this.stagedParts.has(relsPath)) {
+      try {
+        const rels = this._entryData(relsPath).toString("utf8");
+        const relTagRe = /<Relationship\b[^>]*>/g;
+        let m;
+        let out = "";
+        let last = 0;
+        let changed = false;
+        while ((m = relTagRe.exec(rels)) !== null) {
+          const attrs = parseTagAttributes(m[0]);
+          const type = attrs["Type"] ?? attrs["type"] ?? "";
+          const target = attrs["Target"] ?? attrs["target"] ?? "";
+          if (type.endsWith("/calcChain") && resolveRelTarget(target) === "xl/calcChain.bin") {
+            out += rels.substring(last, m.index);
+            last = m.index + m[0].length;
+            changed = true;
+          }
         }
-      } else {
-        throw new Error(
-          `Excel conversion: final destination install failed (${errorMessage(error)}). A concurrent destination was preserved; the original file remains at ${backupPath}.`
-        );
+        if (changed) {
+          out += rels.substring(last);
+          this._writePartText(relsPath, out);
+        }
+      } catch {
       }
     }
-    throw error;
   }
-}
+  /** Write an XML/text part to its staged file when present, else into the ZIP. */
+  _writePartText(name, text) {
+    const stagedPath = this.stagedParts.get(name);
+    if (stagedPath) {
+      fs6.writeFileSync(stagedPath, text, "utf8");
+    } else {
+      this.zip.updateFile(name, Buffer.from(text, "utf8"));
+    }
+  }
+};
 
 // src/ExcelConverter.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+import { spawn } from "child_process";
 var POWERSHELL_CONVERSION_SCRIPT = `
 $ErrorActionPreference = 'Stop'
 $inputPath = [Environment]::GetEnvironmentVariable('JUSTYBASE_EXCEL_INPUT')
@@ -5005,29 +6708,29 @@ function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function validateConversionPaths(inputPath, outputPath, inputExtension, outputExtension, overwrite) {
-  const input = path2.resolve(inputPath);
-  const output = path2.resolve(outputPath);
-  if (path2.extname(input).toLowerCase() !== inputExtension) {
+  const input = path8.resolve(inputPath);
+  const output = path8.resolve(outputPath);
+  if (path8.extname(input).toLowerCase() !== inputExtension) {
     throw new Error(
       `Excel conversion: source must have the ${inputExtension} extension: ${inputPath}`
     );
   }
-  if (path2.extname(output).toLowerCase() !== outputExtension) {
+  if (path8.extname(output).toLowerCase() !== outputExtension) {
     throw new Error(
       `Excel conversion: destination must have the ${outputExtension} extension: ${outputPath}`
     );
   }
-  if (!fs6.existsSync(input)) {
+  if (!fs7.existsSync(input)) {
     throw new Error(`Excel conversion: source file not found: ${inputPath}`);
   }
-  if (!fs6.statSync(input).isFile()) {
+  if (!fs7.statSync(input).isFile()) {
     throw new Error(`Excel conversion: source path is not a file: ${inputPath}`);
   }
-  if (!fs6.existsSync(path2.dirname(output))) {
-    throw new Error(`Excel conversion: destination directory not found: ${path2.dirname(output)}`);
+  if (!fs7.existsSync(path8.dirname(output))) {
+    throw new Error(`Excel conversion: destination directory not found: ${path8.dirname(output)}`);
   }
-  if (fs6.existsSync(output)) {
-    if (fs6.statSync(output).isDirectory()) {
+  if (fs7.existsSync(output)) {
+    if (fs7.statSync(output).isDirectory()) {
       throw new Error(`Excel conversion: destination path is a directory: ${outputPath}`);
     }
     if (!overwrite) {
@@ -5049,7 +6752,7 @@ function runPowerShellConversion(inputPath, outputPath, fileFormat) {
     JUSTYBASE_EXCEL_OUTPUT: outputPath,
     JUSTYBASE_EXCEL_FORMAT: String(fileFormat)
   };
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve6, reject) => {
     var _a, _b, _c, _d;
     let stdout = "";
     let stderr = "";
@@ -5084,7 +6787,7 @@ function runPowerShellConversion(inputPath, outputPath, fileFormat) {
       if (settled) return;
       settled = true;
       if (code === 0) {
-        resolve2();
+        resolve6();
         return;
       }
       const details = (stderr || stdout).replace(/\s+/g, " ").trim();
@@ -5105,22 +6808,22 @@ async function convertExcelFile(inputPath, outputPath, inputExtension, outputExt
   if (process.platform !== "win32") {
     throw new Error("Excel conversion requires Windows with desktop Microsoft Excel and COM automation.");
   }
-  const temporaryOutput = path2.join(
-    path2.dirname(output),
-    `.${path2.basename(output, outputExtension)}.${randomUUID2()}.conversion${outputExtension}`
+  const temporaryOutput = path8.join(
+    path8.dirname(output),
+    `.${path8.basename(output, outputExtension)}.${randomUUID5()}.conversion${outputExtension}`
   );
   try {
     await runPowerShellConversion(input, temporaryOutput, fileFormat);
-    if (!fs6.existsSync(temporaryOutput)) {
+    if (!fs7.existsSync(temporaryOutput)) {
       throw new Error("Excel conversion completed without creating the destination file.");
     }
     installTemporaryOutput(temporaryOutput, output, options.overwrite === true);
   } catch (error) {
     throw new Error(`Excel conversion ${inputExtension} -> ${outputExtension}: ${errorMessage2(error)}`);
   } finally {
-    if (fs6.existsSync(temporaryOutput)) {
+    if (fs7.existsSync(temporaryOutput)) {
       try {
-        fs6.rmSync(temporaryOutput);
+        fs7.rmSync(temporaryOutput);
       } catch {
       }
     }
@@ -5138,22 +6841,38 @@ export {
   ExcelReaderAbstract,
   F,
   INVALID_SHEET_NAME_CHARS,
+  MAX_CELL_CHARS,
+  MAX_COLS,
+  MAX_ROWS,
   ReaderFactory,
   StreamingSheetState,
   XlsbReader,
   XlsbUpdater,
   XlsbWriter,
+  XlsxUpdater as XlsmUpdater,
   XlsxReader,
   XlsxUpdater,
   XlsxWriter,
   applyHeaderWidths,
+  assertCellTextLength,
+  assertColumnCount,
+  assertRowCount,
+  assertRowFitsColumns,
+  columnIndexToLetter,
+  columnLetterToIndex,
   convertXlsbToXlsx,
   convertXlsxToXlsb,
   defaultColWidth,
+  escapeXmlText,
   getFormat,
   initColWidths,
   isFormattedCell,
+  parseSharedStringsXml,
+  parseTagAttributes,
+  resolveRelTarget,
   sanitizeSheetName,
+  trimTrailingEmptyRows,
+  unescapeXml,
   unwrapCell,
   updateColWidthsFromRows
 };