@alaarab/ogrid-js 2.1.15 → 2.3.0

package/dist/esm/index.js

@@ -36,14 +36,23 @@ function escapeCsvValue(value) {
 function buildCsvHeader(columns) {
   return columns.map((c) => escapeCsvValue(c.name)).join(",");
 }
-function buildCsvRows(items, columns, getValue) {
+function buildCsvRows(items, columns, getValue, formulaOptions) {
   return items.map(
-    (item) => columns.map((c) => escapeCsvValue(getValue(item, c.columnId))).join(",")
+    (item, rowIdx) => columns.map((col) => {
+      if (formulaOptions?.exportMode === "formulas" && formulaOptions.hasFormula && formulaOptions.getFormula && formulaOptions.columnIdToIndex) {
+        const colIdx = formulaOptions.columnIdToIndex.get(col.columnId);
+        if (colIdx !== void 0 && formulaOptions.hasFormula(colIdx, rowIdx)) {
+          const formula = formulaOptions.getFormula(colIdx, rowIdx);
+          if (formula) return escapeCsvValue(formula);
+        }
+      }
+      return escapeCsvValue(getValue(item, col.columnId));
+    }).join(",")
   );
 }
-function exportToCsv(items, columns, getValue, filename) {
+function exportToCsv(items, columns, getValue, filename, formulaOptions) {
   const header = buildCsvHeader(columns);
-  const rows = buildCsvRows(items, columns, getValue);
+  const rows = buildCsvRows(items, columns, getValue, formulaOptions);
   const csv = [header, ...rows].join("\n");
   triggerCsvDownload(csv, filename ?? `export_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`);
 }
@@ -710,6 +719,66 @@ function calculateDropTarget(params) {
   }
   return { targetIndex, indicatorX };
 }
+function computeVisibleColumnRange(scrollLeft, columnWidths, containerWidth, overscan = 2) {
+  if (columnWidths.length === 0 || containerWidth <= 0) {
+    return { startIndex: 0, endIndex: -1, leftOffset: 0, rightOffset: 0 };
+  }
+  let cumWidth = 0;
+  let rawStart = columnWidths.length;
+  let rawEnd = -1;
+  for (let i = 0; i < columnWidths.length; i++) {
+    const colStart = cumWidth;
+    cumWidth += columnWidths[i];
+    if (cumWidth > scrollLeft && rawStart === columnWidths.length) {
+      rawStart = i;
+    }
+    if (colStart < scrollLeft + containerWidth) {
+      rawEnd = i;
+    }
+  }
+  if (rawStart > rawEnd) {
+    return { startIndex: 0, endIndex: -1, leftOffset: 0, rightOffset: 0 };
+  }
+  const startIndex = Math.max(0, rawStart - overscan);
+  const endIndex = Math.min(columnWidths.length - 1, rawEnd + overscan);
+  let leftOffset = 0;
+  for (let i = 0; i < startIndex; i++) {
+    leftOffset += columnWidths[i];
+  }
+  let rightOffset = 0;
+  for (let i = endIndex + 1; i < columnWidths.length; i++) {
+    rightOffset += columnWidths[i];
+  }
+  return { startIndex, endIndex, leftOffset, rightOffset };
+}
+function partitionColumnsForVirtualization(visibleCols, columnRange, pinnedColumns) {
+  const pinnedLeft = [];
+  const pinnedRight = [];
+  const unpinned = [];
+  for (const col of visibleCols) {
+    const pin = pinnedColumns?.[col.columnId];
+    if (pin === "left") pinnedLeft.push(col);
+    else if (pin === "right") pinnedRight.push(col);
+    else unpinned.push(col);
+  }
+  if (!columnRange || columnRange.endIndex < 0) {
+    return {
+      pinnedLeft,
+      virtualizedUnpinned: unpinned,
+      pinnedRight,
+      leftSpacerWidth: 0,
+      rightSpacerWidth: 0
+    };
+  }
+  const virtualizedUnpinned = unpinned.slice(columnRange.startIndex, columnRange.endIndex + 1);
+  return {
+    pinnedLeft,
+    virtualizedUnpinned,
+    pinnedRight,
+    leftSpacerWidth: columnRange.leftOffset,
+    rightSpacerWidth: columnRange.rightOffset
+  };
+}
 function computeVisibleRange(scrollTop, rowHeight, containerHeight, totalRows, overscan = 5) {
   if (totalRows <= 0 || rowHeight <= 0 || containerHeight <= 0) {
     return { startIndex: 0, endIndex: 0, offsetTop: 0, offsetBottom: 0 };
@@ -737,6 +806,244 @@ function getScrollTopForRow(rowIndex, rowHeight, containerHeight, align = "start
       return Math.max(0, rowTop - containerHeight + rowHeight);
   }
 }
+function workerBody() {
+  const ctx = self;
+  ctx.onmessage = (e) => {
+    const msg = e.data;
+    if (msg.type !== "sort-filter") return;
+    const { requestId, values, filters, sort } = msg;
+    const rowCount = values.length;
+    let indices = [];
+    const filterEntries = Object.entries(filters);
+    if (filterEntries.length === 0) {
+      indices = new Array(rowCount);
+      for (let i = 0; i < rowCount; i++) indices[i] = i;
+    } else {
+      for (let r = 0; r < rowCount; r++) {
+        let pass = true;
+        for (let f = 0; f < filterEntries.length; f++) {
+          const colIdx = Number(filterEntries[f][0]);
+          const filter = filterEntries[f][1];
+          const cellVal = values[r][colIdx];
+          switch (filter.type) {
+            case "text": {
+              const trimmed = filter.value.trim().toLowerCase();
+              if (trimmed && !String(cellVal ?? "").toLowerCase().includes(trimmed)) {
+                pass = false;
+              }
+              break;
+            }
+            case "multiSelect": {
+              if (filter.value.length > 0) {
+                const set = new Set(filter.value);
+                if (!set.has(String(cellVal ?? ""))) {
+                  pass = false;
+                }
+              }
+              break;
+            }
+            case "date": {
+              if (cellVal == null) {
+                pass = false;
+                break;
+              }
+              const ts = new Date(String(cellVal)).getTime();
+              if (isNaN(ts)) {
+                pass = false;
+                break;
+              }
+              if (filter.value.from) {
+                const fromTs = (/* @__PURE__ */ new Date(filter.value.from + "T00:00:00")).getTime();
+                if (ts < fromTs) {
+                  pass = false;
+                  break;
+                }
+              }
+              if (filter.value.to) {
+                const toTs = (/* @__PURE__ */ new Date(filter.value.to + "T23:59:59.999")).getTime();
+                if (ts > toTs) {
+                  pass = false;
+                  break;
+                }
+              }
+              break;
+            }
+          }
+          if (!pass) break;
+        }
+        if (pass) indices.push(r);
+      }
+    }
+    if (sort) {
+      const { columnIndex, direction } = sort;
+      const dir = direction === "asc" ? 1 : -1;
+      indices.sort((a, b) => {
+        const av = values[a][columnIndex];
+        const bv = values[b][columnIndex];
+        if (av == null && bv == null) return 0;
+        if (av == null) return -1 * dir;
+        if (bv == null) return 1 * dir;
+        if (typeof av === "number" && typeof bv === "number") {
+          return av === bv ? 0 : av > bv ? dir : -dir;
+        }
+        const sa = String(av).toLowerCase();
+        const sb = String(bv).toLowerCase();
+        return sa === sb ? 0 : sa > sb ? dir : -dir;
+      });
+    }
+    const response = {
+      type: "sort-filter-result",
+      requestId,
+      indices
+    };
+    ctx.postMessage(response);
+  };
+}
+var workerInstance = null;
+var requestCounter = 0;
+var pendingRequests = /* @__PURE__ */ new Map();
+function createSortFilterWorker() {
+  if (workerInstance) return workerInstance;
+  if (typeof Worker === "undefined" || typeof Blob === "undefined" || typeof URL === "undefined") {
+    return null;
+  }
+  try {
+    const fnStr = workerBody.toString();
+    const blob = new Blob(
+      [`(${fnStr})()`],
+      { type: "application/javascript" }
+    );
+    const url = URL.createObjectURL(blob);
+    workerInstance = new Worker(url);
+    URL.revokeObjectURL(url);
+    workerInstance.onmessage = (e) => {
+      const { requestId, indices } = e.data;
+      const pending = pendingRequests.get(requestId);
+      if (pending) {
+        pendingRequests.delete(requestId);
+        pending.resolve(indices);
+      }
+    };
+    workerInstance.onerror = (err) => {
+      for (const [id, pending] of pendingRequests) {
+        pending.reject(new Error(err.message || "Worker error"));
+        pendingRequests.delete(id);
+      }
+    };
+    return workerInstance;
+  } catch {
+    return null;
+  }
+}
+function terminateSortFilterWorker() {
+  if (workerInstance) {
+    workerInstance.terminate();
+    workerInstance = null;
+  }
+  for (const [id, pending] of pendingRequests) {
+    pending.reject(new Error("Worker terminated"));
+    pendingRequests.delete(id);
+  }
+}
+function extractValueMatrix(data, columns) {
+  const matrix = new Array(data.length);
+  for (let r = 0; r < data.length; r++) {
+    const row = new Array(columns.length);
+    for (let c = 0; c < columns.length; c++) {
+      const val = getCellValue(data[r], columns[c]);
+      if (val == null) {
+        row[c] = null;
+      } else if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+        row[c] = val;
+      } else {
+        row[c] = String(val);
+      }
+    }
+    matrix[r] = row;
+  }
+  return matrix;
+}
+function processClientSideDataAsync(data, columns, filters, sortBy, sortDirection) {
+  if (sortBy) {
+    const sortCol = columns.find((c) => c.columnId === sortBy);
+    if (sortCol?.compare) {
+      return Promise.resolve(processClientSideData(data, columns, filters, sortBy, sortDirection));
+    }
+  }
+  const worker = createSortFilterWorker();
+  if (!worker) {
+    return Promise.resolve(processClientSideData(data, columns, filters, sortBy, sortDirection));
+  }
+  const columnIndexMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < columns.length; i++) {
+    columnIndexMap.set(columns[i].columnId, i);
+  }
+  const values = extractValueMatrix(data, columns);
+  const columnMeta = columns.map((col, idx) => ({
+    type: col.type ?? "text",
+    index: idx
+  }));
+  const workerFilters = {};
+  for (const col of columns) {
+    const filterKey = getFilterField(col);
+    const val = filters[filterKey];
+    if (!val) continue;
+    const colIdx = columnIndexMap.get(col.columnId);
+    if (colIdx === void 0) continue;
+    switch (val.type) {
+      case "text":
+        workerFilters[colIdx] = { type: "text", value: val.value };
+        break;
+      case "multiSelect":
+        workerFilters[colIdx] = { type: "multiSelect", value: val.value };
+        break;
+      case "date":
+        workerFilters[colIdx] = { type: "date", value: { from: val.value.from, to: val.value.to } };
+        break;
+      // 'people' filter has a UserLike object — fall back to sync
+      case "people":
+        return Promise.resolve(processClientSideData(data, columns, filters, sortBy, sortDirection));
+    }
+  }
+  let sort;
+  if (sortBy) {
+    const sortColIdx = columnIndexMap.get(sortBy);
+    if (sortColIdx !== void 0) {
+      sort = { columnIndex: sortColIdx, direction: sortDirection ?? "asc" };
+    }
+  }
+  const requestId = ++requestCounter;
+  return new Promise((resolve, reject) => {
+    pendingRequests.set(requestId, {
+      resolve: (indices) => {
+        const result = new Array(indices.length);
+        for (let i = 0; i < indices.length; i++) {
+          result[i] = data[indices[i]];
+        }
+        resolve(result);
+      },
+      reject
+    });
+    const request = {
+      type: "sort-filter",
+      requestId,
+      values,
+      columnMeta,
+      filters: workerFilters,
+      sort
+    };
+    worker.postMessage(request);
+  });
+}
+var FormulaError = class {
+  constructor(type, message) {
+    this.type = type;
+    this.message = message;
+  }
+  toString() {
+    return this.type;
+  }
+};
 function getHeaderFilterConfig(col, input) {
   const filterable = isFilterConfig(col.filterable) ? col.filterable : null;
   const filterType = filterable?.type ?? "none";
@@ -863,7 +1170,8 @@ function computeCellDescriptor(item, col, rowIndex, colIdx, input) {
   const canEditAny = canEditInline || canEditPopup;
   const isEditing = input.editingCell?.rowId === rowId && input.editingCell?.columnId === col.columnId;
   const isActive = !input.isDragging && input.activeCell?.rowIndex === rowIndex && input.activeCell?.columnIndex === globalColIndex;
-  const isInRange = input.selectionRange != null && isInSelectionRange(input.selectionRange, rowIndex, colIdx);
+  const isSingleCellRange = input.selectionRange != null && input.selectionRange.startRow === input.selectionRange.endRow && input.selectionRange.startCol === input.selectionRange.endCol;
+  const isInRange = input.selectionRange != null && !isSingleCellRange && isInSelectionRange(input.selectionRange, rowIndex, colIdx);
   const isInCutRange = input.cutRange != null && isInSelectionRange(input.cutRange, rowIndex, colIdx);
   const isInCopyRange = input.copyRange != null && isInSelectionRange(input.copyRange, rowIndex, colIdx);
   const isSelectionEndCell = !input.isDragging && input.copyRange == null && input.cutRange == null && input.selectionRange != null && rowIndex === input.selectionRange.endRow && colIdx === input.selectionRange.endCol;
@@ -905,6 +1213,9 @@ function computeCellDescriptor(item, col, rowIndex, colIdx, input) {
   };
 }
 function resolveCellDisplayContent(col, item, displayValue) {
+  if (displayValue instanceof FormulaError) {
+    return displayValue.toString();
+  }
   const c = col;
   if (c.renderCell && typeof c.renderCell === "function") {
     return c.renderCell(item);
@@ -920,10 +1231,14 @@ function resolveCellDisplayContent(col, item, displayValue) {
   }
   return String(displayValue);
 }
-function resolveCellStyle(col, item) {
+function resolveCellStyle(col, item, displayValue) {
   const c = col;
-  if (!c.cellStyle) return void 0;
-  return typeof c.cellStyle === "function" ? c.cellStyle(item) : c.cellStyle;
+  const isError = displayValue instanceof FormulaError;
+  const base = c.cellStyle ? typeof c.cellStyle === "function" ? c.cellStyle(item) : c.cellStyle : void 0;
+  if (isError) {
+    return { ...base, color: "var(--ogrid-formula-error-color, #d32f2f)" };
+  }
+  return base;
 }
 function buildInlineEditorProps(item, col, descriptor, callbacks) {
   return {
@@ -1033,6 +1348,7 @@ var AUTOSIZE_MAX_PX = 520;
 function measureHeaderWidth(th) {
   const cs = getComputedStyle(th);
   const thPadding = (parseFloat(cs.paddingLeft) || 0) + (parseFloat(cs.paddingRight) || 0);
+  const thBorders = (parseFloat(cs.borderLeftWidth) || 0) + (parseFloat(cs.borderRightWidth) || 0);
   let resizeHandleWidth = 0;
   for (let i = 0; i < th.children.length; i++) {
     const child = th.children[i];
@@ -1055,12 +1371,14 @@ function measureHeaderWidth(th) {
           overflow: child.style.overflow,
           flexShrink: child.style.flexShrink,
           width: child.style.width,
-          minWidth: child.style.minWidth
+          minWidth: child.style.minWidth,
+          maxWidth: child.style.maxWidth
         });
         child.style.overflow = "visible";
         child.style.flexShrink = "0";
         child.style.width = "max-content";
         child.style.minWidth = "max-content";
+        child.style.maxWidth = "none";
       }
       expandDescendants(child);
     }
@@ -1078,8 +1396,9 @@ function measureHeaderWidth(th) {
     m.el.style.flexShrink = m.flexShrink;
     m.el.style.width = m.width;
     m.el.style.minWidth = m.minWidth;
+    m.el.style.maxWidth = m.maxWidth;
   }
-  return expandedWidth + resizeHandleWidth + thPadding;
+  return expandedWidth + resizeHandleWidth + thPadding + thBorders;
 }
 function measureColumnContentWidth(columnId, minWidth, container) {
   const minW = minWidth ?? DEFAULT_MIN_COLUMN_WIDTH;
@@ -1290,7 +1609,7 @@ function formatCellValueForTsv(raw, formatted) {
     return "[Object]";
   }
 }
-function formatSelectionAsTsv(items, visibleCols, range) {
+function formatSelectionAsTsv(items, visibleCols, range, formulaOptions) {
   const norm = normalizeSelectionRange(range);
   const rows = [];
   for (let r = norm.startRow; r <= norm.endRow; r++) {
@@ -1299,6 +1618,16 @@ function formatSelectionAsTsv(items, visibleCols, range) {
       if (r >= items.length || c >= visibleCols.length) break;
       const item = items[r];
       const col = visibleCols[c];
+      if (formulaOptions?.hasFormula && formulaOptions?.getFormula) {
+        const flatColIndex = formulaOptions.flatColumns.findIndex((fc) => fc.columnId === col.columnId);
+        if (flatColIndex >= 0 && formulaOptions.hasFormula(flatColIndex, r)) {
+          const formulaStr = formulaOptions.getFormula(flatColIndex, r);
+          if (formulaStr) {
+            cells.push(formulaStr);
+            continue;
+          }
+        }
+      }
       const raw = getCellValue(item, col);
       const clipboard = col.clipboardFormatter ? col.clipboardFormatter(raw, item) : null;
       const formatted = clipboard ?? (col.valueFormatter ? col.valueFormatter(raw, item) : raw);
@@ -1313,7 +1642,7 @@ function parseTsvClipboard(text) {
   const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
   return lines.map((line) => line.split("	"));
 }
-function applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols) {
+function applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols, formulaOptions) {
   const events = [];
   for (let r = 0; r < parsedRows.length; r++) {
     const cells = parsedRows[r];
@@ -1324,9 +1653,16 @@ function applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols)
       const item = items[targetRow];
       const col = visibleCols[targetCol];
       if (!isColumnEditable(col, item)) continue;
-      const rawValue = cells[c] ?? "";
+      const cellText = cells[c] ?? "";
+      if (cellText.startsWith("=") && formulaOptions?.setFormula) {
+        const flatColIndex = formulaOptions.flatColumns.findIndex((fc) => fc.columnId === col.columnId);
+        if (flatColIndex >= 0) {
+          formulaOptions.setFormula(flatColIndex, targetRow, cellText);
+          continue;
+        }
+      }
       const oldValue = getCellValue(item, col);
-      const result = parseValue(rawValue, oldValue, item, col);
+      const result = parseValue(cellText, oldValue, item, col);
       if (!result.valid) continue;
       events.push({
         item,
@@ -1361,12 +1697,111 @@ function applyCutClear(cutRange, items, visibleCols) {
   }
   return events;
 }
-function applyFillValues(range, sourceRow, sourceCol, items, visibleCols) {
+function indexToColumnLetter(index) {
+  let result = "";
+  let n = index;
+  while (n >= 0) {
+    result = String.fromCharCode(n % 26 + 65) + result;
+    n = Math.floor(n / 26) - 1;
+  }
+  return result;
+}
+function formatCellReference(colIndex, rowNumber) {
+  return `${indexToColumnLetter(colIndex)}${rowNumber}`;
+}
+function columnLetterToIndex(letters) {
+  let result = 0;
+  const upper = letters.toUpperCase();
+  for (let i = 0; i < upper.length; i++) {
+    result = result * 26 + (upper.charCodeAt(i) - 64);
+  }
+  return result - 1;
+}
+var CELL_REF_RE = /^(\$?)([A-Za-z]+)(\$?)(\d+)$/;
+var ADJUST_REF_RE = /(?:'[^']*'!|[A-Za-z_]\w*!)?(\$?)([A-Z]+)(\$?)(\d+)/g;
+function parseCellRef(ref) {
+  const m = ref.match(CELL_REF_RE);
+  if (!m) return null;
+  const absCol = m[1] === "$";
+  const colLetters = m[2];
+  const absRow = m[3] === "$";
+  const rowNum = parseInt(m[4], 10);
+  if (rowNum < 1) return null;
+  return {
+    col: columnLetterToIndex(colLetters),
+    row: rowNum - 1,
+    // 0-based internally
+    absCol,
+    absRow
+  };
+}
+function parseRange(rangeStr) {
+  const parts = rangeStr.split(":");
+  if (parts.length !== 2) return null;
+  const start = parseCellRef(parts[0]);
+  const end = parseCellRef(parts[1]);
+  if (!start || !end) return null;
+  return { start, end };
+}
+function formatAddress(addr) {
+  const colStr = (addr.absCol ? "$" : "") + indexToColumnLetter(addr.col);
+  const rowStr = (addr.absRow ? "$" : "") + (addr.row + 1);
+  const cellStr = colStr + rowStr;
+  if (addr.sheet) {
+    const sheetStr = addr.sheet.includes(" ") ? `'${addr.sheet}'` : addr.sheet;
+    return `${sheetStr}!${cellStr}`;
+  }
+  return cellStr;
+}
+function adjustFormulaReferences(formula, colDelta, rowDelta) {
+  ADJUST_REF_RE.lastIndex = 0;
+  return formula.replace(ADJUST_REF_RE, (match, colAbs, colLetters, rowAbs, rowDigits) => {
+    const cellRefStart = match.indexOf(colAbs + colLetters);
+    const sheetPrefix = cellRefStart > 0 ? match.substring(0, cellRefStart) : "";
+    let newCol = colLetters;
+    let newRow = rowDigits;
+    if (colAbs !== "$") {
+      const colIdx = columnLetterToIndex(colLetters) + colDelta;
+      if (colIdx < 0) return "#REF!";
+      newCol = indexToColumnLetter(colIdx);
+    }
+    if (rowAbs !== "$") {
+      const rowNum = parseInt(rowDigits, 10) + rowDelta;
+      if (rowNum < 1) return "#REF!";
+      newRow = String(rowNum);
+    }
+    return `${sheetPrefix}${colAbs}${newCol}${rowAbs}${newRow}`;
+  });
+}
+function toCellKey(col, row, sheet) {
+  if (sheet) return `${sheet}:${col},${row}`;
+  return `${col},${row}`;
+}
+function fromCellKey(key) {
+  const colonIdx = key.indexOf(":");
+  if (colonIdx >= 0 && isNaN(parseInt(key.substring(0, colonIdx), 10))) {
+    const sheet = key.substring(0, colonIdx);
+    const rest = key.substring(colonIdx + 1);
+    const commaIdx = rest.indexOf(",");
+    return {
+      col: parseInt(rest.substring(0, commaIdx), 10),
+      row: parseInt(rest.substring(commaIdx + 1), 10),
+      sheet
+    };
+  }
+  const i = key.indexOf(",");
+  return {
+    col: parseInt(key.substring(0, i), 10),
+    row: parseInt(key.substring(i + 1), 10)
+  };
+}
+function applyFillValues(range, sourceRow, sourceCol, items, visibleCols, formulaOptions) {
   const events = [];
   const startItem = items[range.startRow];
   const startColDef = visibleCols[range.startCol];
   if (!startItem || !startColDef) return events;
   const startValue = getCellValue(startItem, startColDef);
+  const srcFlatColIndex = formulaOptions ? formulaOptions.flatColumns.findIndex((c) => c.columnId === startColDef.columnId) : -1;
   for (let row = range.startRow; row <= range.endRow; row++) {
     for (let col = range.startCol; col <= range.endCol; col++) {
       if (row === sourceRow && col === sourceCol) continue;
@@ -1374,6 +1809,19 @@ function applyFillValues(range, sourceRow, sourceCol, items, visibleCols) {
       const item = items[row];
       const colDef = visibleCols[col];
       if (!isColumnEditable(colDef, item)) continue;
+      if (formulaOptions && formulaOptions.hasFormula && formulaOptions.getFormula && formulaOptions.setFormula && srcFlatColIndex >= 0 && formulaOptions.hasFormula(srcFlatColIndex, sourceRow)) {
+        const srcFormula = formulaOptions.getFormula(srcFlatColIndex, sourceRow);
+        if (srcFormula) {
+          const rowDelta = row - sourceRow;
+          const colDelta = col - sourceCol;
+          const adjusted = adjustFormulaReferences(srcFormula, colDelta, rowDelta);
+          const targetFlatColIdx = formulaOptions.flatColumns.findIndex((c) => c.columnId === colDef.columnId);
+          if (targetFlatColIdx >= 0) {
+            formulaOptions.setFormula(targetFlatColIdx, row, adjusted);
+            continue;
+          }
+        }
+      }
       const oldValue = getCellValue(item, colDef);
       const result = parseValue(startValue, oldValue, item, colDef);
       if (!result.valid) continue;
@@ -1476,118 +1924,3311 @@ var UndoRedoStack = class {
     return lastBatch;
   }
   /**
-   * Pop the most recent redo entry.
-   * Returns the batch of events (in original order) to be re-applied by the caller,
-   * or null if there is nothing to redo.
+   * Pop the most recent redo entry.
+   * Returns the batch of events (in original order) to be re-applied by the caller,
+   * or null if there is nothing to redo.
+   */
+  redo() {
+    const nextBatch = this.redoStack.pop();
+    if (!nextBatch) return null;
+    this.history.push(nextBatch);
+    return nextBatch;
+  }
+  /**
+   * Clear all history and redo state.
+   * Does not affect any open batch — call endBatch() first if needed.
+   */
+  clear() {
+    this.history = [];
+    this.redoStack = [];
+  }
+};
+function validateColumns(columns) {
+  if (!Array.isArray(columns) || columns.length === 0) {
+    console.warn("[OGrid] columns prop is empty or not an array");
+    return;
+  }
+  const isDev = typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+  const ids = /* @__PURE__ */ new Set();
+  for (const col of columns) {
+    if (!col.columnId) {
+      console.warn("[OGrid] Column missing columnId:", col);
+    }
+    if (ids.has(col.columnId)) {
+      console.warn(`[OGrid] Duplicate columnId: "${col.columnId}"`);
+    }
+    ids.add(col.columnId);
+    if (isDev && col.editable === true && col.cellEditor == null) {
+      console.warn(
+        `[OGrid] Column "${col.columnId}" has editable=true but no cellEditor defined. Cells will not open an editor on double-click. Set cellEditor to 'text', 'select', 'checkbox', 'date', or a custom component.`
+      );
+    }
+  }
+}
+function validateVirtualScrollConfig(config) {
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") return;
+  if (config.enabled !== true) return;
+  if (!config.rowHeight || config.rowHeight <= 0) {
+    console.warn(
+      "[OGrid] virtualScroll.enabled is true but rowHeight is missing or <= 0. Set a positive rowHeight (e.g. virtualScroll: { enabled: true, rowHeight: 36 }) for correct virtual scrolling behavior."
+    );
+  }
+}
+function validateRowIds(items, getRowId) {
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
+  if (!getRowId) return;
+  const ids = /* @__PURE__ */ new Set();
+  const limit = Math.min(items.length, 100);
+  for (let i = 0; i < limit; i++) {
+    const id = getRowId(items[i]);
+    if (id == null) {
+      console.warn(`[OGrid] getRowId returned null/undefined for row ${i}`);
+      return;
+    }
+    if (ids.has(id)) {
+      console.warn(
+        `[OGrid] Duplicate row ID "${id}" at index ${i}. getRowId must return unique values.`
+      );
+      return;
+    }
+    ids.add(id);
+  }
+}
+var DEFAULT_DEBOUNCE_MS = 300;
+var PEOPLE_SEARCH_DEBOUNCE_MS = DEFAULT_DEBOUNCE_MS;
+var SIDEBAR_TRANSITION_MS = 300;
+var Z_INDEX = {
+  /** Column resize drag handle */
+  RESIZE_HANDLE: 1,
+  /** Active/editing cell outline */
+  ACTIVE_CELL: 2,
+  /** Fill handle dot */
+  FILL_HANDLE: 3,
+  /** Selection range overlay (marching ants) */
+  SELECTION_OVERLAY: 4,
+  /** Row number column */
+  ROW_NUMBER: 5,
+  /** Clipboard overlay (copy/cut animation) */
+  CLIPBOARD_OVERLAY: 5,
+  /** Sticky pinned body cells */
+  PINNED: 6,
+  /** Selection checkbox column in body */
+  SELECTION_CELL: 7,
+  /** Sticky thead row */
+  THEAD: 8,
+  /** Pinned header cells (sticky both axes) */
+  PINNED_HEADER: 10,
+  /** Focused header cell */
+  HEADER_FOCUS: 11,
+  /** Checkbox column in sticky header (sticky both axes) */
+  SELECTION_HEADER_PINNED: 12,
+  /** Loading overlay within table */
+  LOADING: 2,
+  /** Column reorder drop indicator */
+  DROP_INDICATOR: 100,
+  /** Dropdown menus (column chooser, pagination size select) */
+  DROPDOWN: 1e3,
+  /** Filter popovers */
+  FILTER_POPOVER: 1e3,
+  /** Modal dialogs */
+  MODAL: 2e3,
+  /** Fullscreen grid container */
+  FULLSCREEN: 9999,
+  /** Context menus (right-click grid menu) */
+  CONTEXT_MENU: 1e4
+};
+var REF_ERROR = new FormulaError("#REF!", "Invalid cell reference");
+var DIV_ZERO_ERROR = new FormulaError("#DIV/0!", "Division by zero");
+var VALUE_ERROR = new FormulaError("#VALUE!", "Wrong value type");
+var NAME_ERROR = new FormulaError("#NAME?", "Unknown function or name");
+var CIRC_ERROR = new FormulaError("#CIRC!", "Circular reference");
+var GENERAL_ERROR = new FormulaError("#ERROR!", "Formula error");
+var NA_ERROR = new FormulaError("#N/A", "No match found");
+function isFormulaError(value) {
+  return value instanceof FormulaError;
+}
+var CELL_REF_PATTERN = /^\$?[A-Za-z]+\$?\d+$/;
+var SINGLE_CHAR_OPERATORS = {
+  "+": "PLUS",
+  "-": "MINUS",
+  "*": "MULTIPLY",
+  "/": "DIVIDE",
+  "^": "POWER",
+  "%": "PERCENT",
+  "&": "AMPERSAND",
+  "=": "EQ"
+};
+var DELIMITERS = {
+  "(": "LPAREN",
+  ")": "RPAREN",
+  ",": "COMMA",
+  ":": "COLON"
+};
+function tokenize(input) {
+  const tokens = [];
+  let pos = 0;
+  while (pos < input.length) {
+    const ch = input[pos];
+    if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+      pos++;
+      continue;
+    }
+    if (ch >= "0" && ch <= "9" || ch === "." && pos + 1 < input.length && input[pos + 1] >= "0" && input[pos + 1] <= "9") {
+      const start = pos;
+      while (pos < input.length && input[pos] >= "0" && input[pos] <= "9") {
+        pos++;
+      }
+      if (pos < input.length && input[pos] === ".") {
+        pos++;
+        while (pos < input.length && input[pos] >= "0" && input[pos] <= "9") {
+          pos++;
+        }
+      }
+      tokens.push({ type: "NUMBER", value: input.slice(start, pos), position: start });
+      continue;
+    }
+    if (ch === "'") {
+      const start = pos;
+      pos++;
+      const nameStart = pos;
+      while (pos < input.length && input[pos] !== "'") {
+        pos++;
+      }
+      const sheetName = input.slice(nameStart, pos);
+      if (pos < input.length && input[pos] === "'") {
+        pos++;
+        if (pos < input.length && input[pos] === "!") {
+          pos++;
+          tokens.push({ type: "SHEET_REF", value: sheetName, position: start });
+          continue;
+        }
+      }
+      throw new FormulaError("#ERROR!", `Invalid sheet reference at position ${start}`);
+    }
+    if (ch === '"') {
+      const start = pos;
+      pos++;
+      const scanStart = pos;
+      let hasEscapes = false;
+      while (pos < input.length) {
+        if (input[pos] === '"') {
+          if (pos + 1 < input.length && input[pos + 1] === '"') {
+            hasEscapes = true;
+            pos += 2;
+          } else {
+            break;
+          }
+        } else {
+          pos++;
+        }
+      }
+      let value;
+      if (!hasEscapes) {
+        value = input.slice(scanStart, pos);
+      } else {
+        value = input.slice(scanStart, pos).replace(/""/g, '"');
+      }
+      if (pos < input.length) pos++;
+      tokens.push({ type: "STRING", value, position: start });
+      continue;
+    }
+    if (ch === ">" && pos + 1 < input.length && input[pos + 1] === "=") {
+      tokens.push({ type: "GTE", value: ">=", position: pos });
+      pos += 2;
+      continue;
+    }
+    if (ch === "<" && pos + 1 < input.length && input[pos + 1] === "=") {
+      tokens.push({ type: "LTE", value: "<=", position: pos });
+      pos += 2;
+      continue;
+    }
+    if (ch === "<" && pos + 1 < input.length && input[pos + 1] === ">") {
+      tokens.push({ type: "NEQ", value: "<>", position: pos });
+      pos += 2;
+      continue;
+    }
+    if (ch === ">" || ch === "<") {
+      const type = ch === ">" ? "GT" : "LT";
+      tokens.push({ type, value: ch, position: pos });
+      pos++;
+      continue;
+    }
+    if (SINGLE_CHAR_OPERATORS[ch]) {
+      tokens.push({ type: SINGLE_CHAR_OPERATORS[ch], value: ch, position: pos });
+      pos++;
+      continue;
+    }
+    if (DELIMITERS[ch]) {
+      tokens.push({ type: DELIMITERS[ch], value: ch, position: pos });
+      pos++;
+      continue;
+    }
+    if (ch === "$" || ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z") {
+      const start = pos;
+      while (pos < input.length && (input[pos] >= "A" && input[pos] <= "Z" || input[pos] >= "a" && input[pos] <= "z" || input[pos] >= "0" && input[pos] <= "9" || input[pos] === "$" || input[pos] === "_")) {
+        pos++;
+      }
+      const word = input.slice(start, pos);
+      if (pos < input.length && input[pos] === "!") {
+        pos++;
+        tokens.push({ type: "SHEET_REF", value: word, position: start });
+        continue;
+      }
+      if (pos < input.length && input[pos] === "(") {
+        tokens.push({ type: "FUNCTION", value: word, position: start });
+        continue;
+      }
+      const upper = word.toUpperCase();
+      if (upper === "TRUE" || upper === "FALSE") {
+        tokens.push({ type: "BOOLEAN", value: upper, position: start });
+        continue;
+      }
+      if (CELL_REF_PATTERN.test(word)) {
+        tokens.push({ type: "CELL_REF", value: word, position: start });
+        continue;
+      }
+      tokens.push({ type: "IDENTIFIER", value: word, position: start });
+      continue;
+    }
+    throw new FormulaError("#ERROR!", `Unexpected character: ${ch}`);
+  }
+  tokens.push({ type: "EOF", value: "", position: pos });
+  return tokens;
+}
+function parse(tokens, namedRanges) {
+  let pos = 0;
+  function peek() {
+    return tokens[pos];
+  }
+  function advance() {
+    const token = tokens[pos];
+    pos++;
+    return token;
+  }
+  function expect(type) {
+    const token = peek();
+    if (token && token.type === type) {
+      return advance();
+    }
+    return null;
+  }
+  function errorNode(message) {
+    return { kind: "error", error: new FormulaError("#ERROR!", message) };
+  }
+  function expression() {
+    return comparison();
+  }
+  function comparison() {
+    let left = concat();
+    while (peek()) {
+      const t = peek();
+      let op = null;
+      if (t.type === "GT") op = ">";
+      else if (t.type === "LT") op = "<";
+      else if (t.type === "GTE") op = ">=";
+      else if (t.type === "LTE") op = "<=";
+      else if (t.type === "EQ") op = "=";
+      else if (t.type === "NEQ") op = "<>";
+      else break;
+      advance();
+      const right = concat();
+      left = { kind: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  function concat() {
+    let left = addition();
+    while (peek() && peek().type === "AMPERSAND") {
+      advance();
+      const right = addition();
+      left = { kind: "binaryOp", op: "&", left, right };
+    }
+    return left;
+  }
+  function addition() {
+    let left = multiplication();
+    while (peek()) {
+      const t = peek();
+      let op = null;
+      if (t.type === "PLUS") op = "+";
+      else if (t.type === "MINUS") op = "-";
+      else break;
+      advance();
+      const right = multiplication();
+      left = { kind: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  function multiplication() {
+    let left = power();
+    while (peek()) {
+      const t = peek();
+      let op = null;
+      if (t.type === "MULTIPLY") op = "*";
+      else if (t.type === "DIVIDE") op = "/";
+      else break;
+      advance();
+      const right = power();
+      left = { kind: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  function power() {
+    let left = unary();
+    while (peek() && peek().type === "POWER") {
+      advance();
+      const right = unary();
+      left = { kind: "binaryOp", op: "^", left, right };
+    }
+    return left;
+  }
+  function unary() {
+    const t = peek();
+    if (t && (t.type === "MINUS" || t.type === "PLUS")) {
+      const op = t.type === "MINUS" ? "-" : "+";
+      advance();
+      const operand = unary();
+      return { kind: "unaryOp", op, operand };
+    }
+    return postfix();
+  }
+  function postfix() {
+    let node = primary();
+    if (peek() && peek().type === "PERCENT") {
+      advance();
+      node = { kind: "binaryOp", op: "%", left: node, right: { kind: "number", value: 100 } };
+    }
+    return node;
+  }
+  function primary() {
+    const t = peek();
+    if (!t || t.type === "EOF") {
+      return errorNode("Unexpected end of expression");
+    }
+    if (t.type === "NUMBER") {
+      advance();
+      return { kind: "number", value: parseFloat(t.value) };
+    }
+    if (t.type === "STRING") {
+      advance();
+      return { kind: "string", value: t.value };
+    }
+    if (t.type === "BOOLEAN") {
+      advance();
+      return { kind: "boolean", value: t.value.toUpperCase() === "TRUE" };
+    }
+    if (t.type === "CELL_REF") {
+      return cellRefOrRange();
+    }
+    if (t.type === "FUNCTION") {
+      return functionCall();
+    }
+    if (t.type === "IDENTIFIER") {
+      return namedRangeRef();
+    }
+    if (t.type === "SHEET_REF") {
+      return sheetRef();
+    }
+    if (t.type === "LPAREN") {
+      advance();
+      const node = expression();
+      if (!expect("RPAREN")) {
+        return errorNode("Expected closing parenthesis");
+      }
+      return node;
+    }
+    advance();
+    return errorNode(`Unexpected token: ${t.value}`);
+  }
+  function cellRefOrRange() {
+    const refToken = advance();
+    const address = parseCellRef(refToken.value);
+    if (!address) {
+      return errorNode(`Invalid cell reference: ${refToken.value}`);
+    }
+    if (peek() && peek().type === "COLON") {
+      advance();
+      const endToken = expect("CELL_REF");
+      if (!endToken) {
+        return errorNode('Expected cell reference after ":"');
+      }
+      const endAddress = parseCellRef(endToken.value);
+      if (!endAddress) {
+        return errorNode(`Invalid cell reference: ${endToken.value}`);
+      }
+      return {
+        kind: "range",
+        start: address,
+        end: endAddress,
+        raw: `${refToken.value}:${endToken.value}`
+      };
+    }
+    return {
+      kind: "cellRef",
+      address,
+      raw: refToken.value
+    };
+  }
+  function functionCall() {
+    const nameToken = advance();
+    const name = nameToken.value.toUpperCase();
+    if (!expect("LPAREN")) {
+      return errorNode(`Expected "(" after function name "${name}"`);
+    }
+    const args = [];
+    if (peek() && peek().type !== "RPAREN" && peek().type !== "EOF") {
+      args.push(expression());
+      while (peek() && peek().type === "COMMA") {
+        advance();
+        args.push(expression());
+      }
+    }
+    if (!expect("RPAREN")) {
+      return errorNode(`Expected ")" after function arguments for "${name}"`);
+    }
+    return { kind: "functionCall", name, args };
+  }
+  function namedRangeRef() {
+    const nameToken = advance();
+    const name = nameToken.value.toUpperCase();
+    const ref = namedRanges?.get(name);
+    if (!ref) {
+      return { kind: "error", error: new FormulaError("#NAME?", `Unknown name: ${nameToken.value}`) };
+    }
+    if (ref.includes(":")) {
+      const rangeRef = parseRange(ref);
+      if (rangeRef) {
+        return { kind: "range", start: rangeRef.start, end: rangeRef.end, raw: ref };
+      }
+    }
+    const cellRef = parseCellRef(ref);
+    if (cellRef) {
+      return { kind: "cellRef", address: cellRef, raw: ref };
+    }
+    return { kind: "error", error: new FormulaError("#REF!", `Invalid named range reference: ${ref}`) };
+  }
+  function sheetRef() {
+    const sheetToken = advance();
+    const sheetName = sheetToken.value;
+    const cellToken = expect("CELL_REF");
+    if (!cellToken) {
+      return errorNode(`Expected cell reference after sheet "${sheetName}!"`);
+    }
+    const address = parseCellRef(cellToken.value);
+    if (!address) {
+      return errorNode(`Invalid cell reference: ${cellToken.value}`);
+    }
+    address.sheet = sheetName;
+    if (peek() && peek().type === "COLON") {
+      advance();
+      const endToken = expect("CELL_REF");
+      if (!endToken) {
+        return errorNode('Expected cell reference after ":"');
+      }
+      const endAddress = parseCellRef(endToken.value);
+      if (!endAddress) {
+        return errorNode(`Invalid cell reference: ${endToken.value}`);
+      }
+      endAddress.sheet = sheetName;
+      return {
+        kind: "range",
+        start: address,
+        end: endAddress,
+        raw: `${sheetName}!${cellToken.value}:${endToken.value}`
+      };
+    }
+    return {
+      kind: "cellRef",
+      address,
+      raw: `${sheetName}!${cellToken.value}`
+    };
+  }
+  const result = expression();
+  if (peek() && peek().type !== "EOF") {
+    return errorNode(`Unexpected token after expression: ${peek().value}`);
+  }
+  return result;
+}
+function toNumber(val) {
+  if (val instanceof FormulaError) return val;
+  if (val === null || val === void 0 || val === "") return 0;
+  if (typeof val === "boolean") return val ? 1 : 0;
+  if (typeof val === "number") return val;
+  if (val instanceof Date) return val.getTime();
+  const n = Number(val);
+  if (isNaN(n)) return new FormulaError("#VALUE!", `Cannot convert "${val}" to number`);
+  return n;
+}
+function toString(val) {
+  if (val === null || val === void 0) return "";
+  if (val instanceof FormulaError) return val.toString();
+  if (val instanceof Date) return val.toLocaleDateString();
+  return String(val);
+}
+function toBoolean(val) {
+  if (typeof val === "boolean") return val;
+  if (typeof val === "number") return val !== 0;
+  if (typeof val === "string") {
+    if (val.toUpperCase() === "TRUE") return true;
+    if (val.toUpperCase() === "FALSE") return false;
+    return val.length > 0;
+  }
+  return val !== null && val !== void 0;
+}
+function flattenArgs(args, context, evaluator) {
+  const result = [];
+  for (const arg of args) {
+    if (arg.kind === "range") {
+      const values = context.getRangeValues({ start: arg.start, end: arg.end });
+      for (const row of values) {
+        for (const val of row) {
+          result.push(val);
+        }
+      }
+    } else {
+      result.push(evaluator.evaluate(arg, context));
+    }
+  }
+  return result;
+}
+var FormulaEvaluator = class {
+  constructor(builtInFunctions) {
+    this.functions = new Map(builtInFunctions);
+  }
+  registerFunction(name, fn) {
+    this.functions.set(name.toUpperCase(), fn);
+  }
+  evaluate(node, context) {
+    switch (node.kind) {
+      case "number":
+        return node.value;
+      case "string":
+        return node.value;
+      case "boolean":
+        return node.value;
+      case "error":
+        return node.error;
+      case "cellRef": {
+        const val = context.getCellValue(node.address);
+        return val;
+      }
+      case "range":
+        return context.getCellValue(node.start);
+      case "functionCall":
+        return this.evaluateFunction(node.name, node.args, context);
+      case "binaryOp":
+        return this.evaluateBinaryOp(node.op, node.left, node.right, context);
+      case "unaryOp":
+        return this.evaluateUnaryOp(node.op, node.operand, context);
+    }
+  }
+  evaluateFunction(name, args, context) {
+    const fn = this.functions.get(name);
+    if (!fn) {
+      return new FormulaError("#NAME?", `Unknown function: ${name}`);
+    }
+    if (args.length < fn.minArgs) {
+      return new FormulaError("#ERROR!", `${name} requires at least ${fn.minArgs} argument(s)`);
+    }
+    if (fn.maxArgs >= 0 && args.length > fn.maxArgs) {
+      return new FormulaError("#ERROR!", `${name} accepts at most ${fn.maxArgs} argument(s)`);
+    }
+    return fn.evaluate(args, context, this);
+  }
+  evaluateBinaryOp(op, left, right, context) {
+    if (op === "&") {
+      const l = this.evaluate(left, context);
+      if (l instanceof FormulaError) return l;
+      const r = this.evaluate(right, context);
+      if (r instanceof FormulaError) return r;
+      return toString(l) + toString(r);
+    }
+    if (op === ">" || op === "<" || op === ">=" || op === "<=" || op === "=" || op === "<>") {
+      const l = this.evaluate(left, context);
+      if (l instanceof FormulaError) return l;
+      const r = this.evaluate(right, context);
+      if (r instanceof FormulaError) return r;
+      return this.compare(op, l, r);
+    }
+    const lVal = this.evaluate(left, context);
+    if (lVal instanceof FormulaError) return lVal;
+    const rVal = this.evaluate(right, context);
+    if (rVal instanceof FormulaError) return rVal;
+    const lNum = toNumber(lVal);
+    if (lNum instanceof FormulaError) return lNum;
+    const rNum = toNumber(rVal);
+    if (rNum instanceof FormulaError) return rNum;
+    switch (op) {
+      case "+":
+        return lNum + rNum;
+      case "-":
+        return lNum - rNum;
+      case "*":
+        return lNum * rNum;
+      case "/":
+        if (rNum === 0) return new FormulaError("#DIV/0!");
+        return lNum / rNum;
+      case "^":
+        return Math.pow(lNum, rNum);
+      case "%":
+        return lNum * rNum / 100;
+      default:
+        return new FormulaError("#ERROR!", `Unknown operator: ${op}`);
+    }
+  }
+  evaluateUnaryOp(op, operand, context) {
+    const val = this.evaluate(operand, context);
+    if (val instanceof FormulaError) return val;
+    const num = toNumber(val);
+    if (num instanceof FormulaError) return num;
+    return op === "-" ? -num : num;
+  }
+  compare(op, left, right) {
+    if (typeof left === "number" && typeof right === "number") {
+      return this.numCompare(op, left, right);
+    }
+    if (typeof left === "string" && typeof right === "string") {
+      return this.strCompare(op, left, right);
+    }
+    if (typeof left === "boolean" && typeof right === "boolean") {
+      return this.numCompare(op, left ? 1 : 0, right ? 1 : 0);
+    }
+    const lNum = toNumber(left);
+    const rNum = toNumber(right);
+    if (typeof lNum === "number" && typeof rNum === "number") {
+      return this.numCompare(op, lNum, rNum);
+    }
+    return this.strCompare(op, toString(left), toString(right));
+  }
+  numCompare(op, a, b) {
+    switch (op) {
+      case ">":
+        return a > b;
+      case "<":
+        return a < b;
+      case ">=":
+        return a >= b;
+      case "<=":
+        return a <= b;
+      case "=":
+        return a === b;
+      case "<>":
+        return a !== b;
+      default:
+        return false;
+    }
+  }
+  strCompare(op, a, b) {
+    const al = a.toLowerCase();
+    const bl = b.toLowerCase();
+    switch (op) {
+      case ">":
+        return al > bl;
+      case "<":
+        return al < bl;
+      case ">=":
+        return al >= bl;
+      case "<=":
+        return al <= bl;
+      case "=":
+        return al === bl;
+      case "<>":
+        return al !== bl;
+      default:
+        return false;
+    }
+  }
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DependencyGraph = class {
+  constructor() {
+    this.dependencies = /* @__PURE__ */ new Map();
+    this.dependents = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set the dependencies for a cell, replacing any previous ones.
+   * Updates both the forward (dependencies) and reverse (dependents) maps.
+   */
+  setDependencies(cell, deps) {
+    this.removeDependenciesInternal(cell);
+    this.dependencies.set(cell, deps);
+    for (const dep of deps) {
+      let depSet = this.dependents.get(dep);
+      if (!depSet) {
+        depSet = /* @__PURE__ */ new Set();
+        this.dependents.set(dep, depSet);
+      }
+      depSet.add(cell);
+    }
+  }
+  /**
+   * Remove all dependency information for a cell from both maps.
+   */
+  removeDependencies(cell) {
+    this.removeDependenciesInternal(cell);
+    this.dependencies.delete(cell);
+  }
+  /**
+   * Get all cells that directly or transitively depend on `changedCell`,
+   * returned in topological order (a cell appears AFTER all cells it depends on).
+   *
+   * Uses Kahn's algorithm. If a cycle is detected, cycle participants are
+   * appended at the end (the engine will assign #CIRC! to them).
+   */
+  getRecalcOrder(changedCell) {
+    return this.topologicalSort(/* @__PURE__ */ new Set([changedCell]));
+  }
+  /**
+   * Same as getRecalcOrder but for multiple changed cells.
+   * Union of all transitive dependents, topologically sorted.
+   */
+  getRecalcOrderBatch(changedCells) {
+    return this.topologicalSort(new Set(changedCells));
+  }
+  /**
+   * Check if adding dependencies from `cell` to `deps` would create a cycle.
+   * DFS from each dep: if we can reach `cell`, it would create a cycle.
+   */
+  wouldCreateCycle(cell, deps) {
+    if (deps.has(cell)) {
+      return true;
+    }
+    const visited = /* @__PURE__ */ new Set();
+    for (const dep of deps) {
+      if (this.canReach(dep, cell, visited)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Return direct dependents of a cell (cells whose formulas reference this cell).
+   * Returns an empty set if none.
+   */
+  getDependents(cell) {
+    return this.dependents.get(cell) ?? EMPTY_SET;
+  }
+  /**
+   * Return direct dependencies of a cell (cells referenced in this cell's formula).
+   * Returns an empty set if none.
+   */
+  getDependencies(cell) {
+    return this.dependencies.get(cell) ?? EMPTY_SET;
+  }
+  /**
+   * Clear both maps entirely.
+   */
+  clear() {
+    this.dependencies.clear();
+    this.dependents.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Remove `cell` from the forward dependencies map and clean up reverse
+   * references in the dependents map.
+   */
+  removeDependenciesInternal(cell) {
+    const oldDeps = this.dependencies.get(cell);
+    if (!oldDeps) {
+      return;
+    }
+    for (const oldDep of oldDeps) {
+      const depSet = this.dependents.get(oldDep);
+      if (depSet) {
+        depSet.delete(cell);
+        if (depSet.size === 0) {
+          this.dependents.delete(oldDep);
+        }
+      }
+    }
+    this.dependencies.delete(cell);
+  }
+  /**
+   * Iterative DFS: check if `target` is reachable from `start` by following
+   * the dependency chain. Iterative to avoid stack overflow for deep chains.
+   */
+  canReach(start, target, visited) {
+    if (start === target) return true;
+    if (visited.has(start)) return false;
+    const stack = [start];
+    visited.add(start);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      const deps = this.dependencies.get(current);
+      if (!deps) continue;
+      for (const dep of deps) {
+        if (dep === target) return true;
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          stack.push(dep);
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Topological sort using Kahn's algorithm.
+   *
+   * 1. Collect all cells transitively dependent on the changed cell(s).
+   * 2. Build in-degree map for these cells (count how many of their
+   *    dependencies are in the affected set).
+   * 3. Start with cells whose in-degree is 0 (only depend on unaffected
+   *    cells or the changed cells themselves).
+   * 4. Process queue: for each cell, reduce in-degree of its dependents,
+   *    add to queue when in-degree reaches 0.
+   * 5. If any cells remain unprocessed, they're in a cycle — append them
+   *    at the end (engine marks as #CIRC!).
+   */
+  topologicalSort(changedCells) {
+    const affected = /* @__PURE__ */ new Set();
+    const bfsQueue = [];
+    for (const changed of changedCells) {
+      const directDependents = this.dependents.get(changed);
+      if (directDependents) {
+        for (const dep of directDependents) {
+          if (!affected.has(dep)) {
+            affected.add(dep);
+            bfsQueue.push(dep);
+          }
+        }
+      }
+    }
+    let head = 0;
+    while (head < bfsQueue.length) {
+      const current = bfsQueue[head++];
+      const currentDependents = this.dependents.get(current);
+      if (currentDependents) {
+        for (const dep of currentDependents) {
+          if (!affected.has(dep)) {
+            affected.add(dep);
+            bfsQueue.push(dep);
+          }
+        }
+      }
+    }
+    if (affected.size === 0) {
+      return [];
+    }
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const cell of affected) {
+      let degree = 0;
+      const deps = this.dependencies.get(cell);
+      if (deps) {
+        for (const dep of deps) {
+          if (affected.has(dep)) {
+            degree++;
+          }
+        }
+      }
+      inDegree.set(cell, degree);
+    }
+    const queue = [];
+    for (const [cell, degree] of inDegree) {
+      if (degree === 0) {
+        queue.push(cell);
+      }
+    }
+    const result = [];
+    let queueHead = 0;
+    while (queueHead < queue.length) {
+      const cell = queue[queueHead++];
+      result.push(cell);
+      const cellDependents = this.dependents.get(cell);
+      if (cellDependents) {
+        for (const dependent of cellDependents) {
+          if (affected.has(dependent)) {
+            const newDegree = inDegree.get(dependent) - 1;
+            inDegree.set(dependent, newDegree);
+            if (newDegree === 0) {
+              queue.push(dependent);
+            }
+          }
+        }
+      }
+    }
+    if (result.length < affected.size) {
+      const resultSet = new Set(result);
+      for (const cell of affected) {
+        if (!resultSet.has(cell)) {
+          result.push(cell);
+        }
+      }
+    }
+    return result;
+  }
+};
+function registerMathFunctions(registry) {
+  registry.set("SUM", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let sum = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          sum += val;
+        } else if (typeof val === "boolean") {
+          sum += val ? 1 : 0;
+        }
+      }
+      return sum;
+    }
+  });
+  registry.set("AVERAGE", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let sum = 0;
+      let count = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          sum += val;
+          count++;
+        } else if (typeof val === "boolean") {
+          sum += val ? 1 : 0;
+          count++;
+        }
+      }
+      if (count === 0) return new FormulaError("#DIV/0!", "No numeric values for AVERAGE");
+      return sum / count;
+    }
+  });
+  registry.set("MIN", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let min = Infinity;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          if (val < min) min = val;
+        } else if (typeof val === "boolean") {
+          const n = val ? 1 : 0;
+          if (n < min) min = n;
+        }
+      }
+      return min === Infinity ? 0 : min;
+    }
+  });
+  registry.set("MAX", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let max = -Infinity;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          if (val > max) max = val;
+        } else if (typeof val === "boolean") {
+          const n = val ? 1 : 0;
+          if (n > max) max = n;
+        }
+      }
+      return max === -Infinity ? 0 : max;
+    }
+  });
+  registry.set("COUNT", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let count = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          count++;
+        }
+      }
+      return count;
+    }
+  });
+  registry.set("COUNTA", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let count = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (val !== null && val !== void 0 && val !== "") {
+          count++;
+        }
+      }
+      return count;
+    }
+  });
+  registry.set("ROUND", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      const rawDigits = evaluator.evaluate(args[1], context);
+      if (rawDigits instanceof FormulaError) return rawDigits;
+      const digits = toNumber(rawDigits);
+      if (digits instanceof FormulaError) return digits;
+      const factor = Math.pow(10, Math.trunc(digits));
+      return Math.round(num * factor) / factor;
+    }
+  });
+  registry.set("ABS", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      return Math.abs(num);
+    }
+  });
+  registry.set("CEILING", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      const rawSig = evaluator.evaluate(args[1], context);
+      if (rawSig instanceof FormulaError) return rawSig;
+      const significance = toNumber(rawSig);
+      if (significance instanceof FormulaError) return significance;
+      if (significance === 0) return 0;
+      return Math.ceil(num / significance) * significance;
+    }
+  });
+  registry.set("FLOOR", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      const rawSig = evaluator.evaluate(args[1], context);
+      if (rawSig instanceof FormulaError) return rawSig;
+      const significance = toNumber(rawSig);
+      if (significance instanceof FormulaError) return significance;
+      if (significance === 0) return 0;
+      return Math.floor(num / significance) * significance;
+    }
+  });
+  registry.set("MOD", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      const rawDiv = evaluator.evaluate(args[1], context);
+      if (rawDiv instanceof FormulaError) return rawDiv;
+      const divisor = toNumber(rawDiv);
+      if (divisor instanceof FormulaError) return divisor;
+      if (divisor === 0) return new FormulaError("#DIV/0!", "Division by zero in MOD");
+      return num % divisor;
+    }
+  });
+  registry.set("POWER", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawBase = evaluator.evaluate(args[0], context);
+      if (rawBase instanceof FormulaError) return rawBase;
+      const base = toNumber(rawBase);
+      if (base instanceof FormulaError) return base;
+      const rawExp = evaluator.evaluate(args[1], context);
+      if (rawExp instanceof FormulaError) return rawExp;
+      const exponent = toNumber(rawExp);
+      if (exponent instanceof FormulaError) return exponent;
+      return Math.pow(base, exponent);
+    }
+  });
+  registry.set("SQRT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      if (num < 0) return new FormulaError("#VALUE!", "Cannot take square root of negative number");
+      return Math.sqrt(num);
+    }
+  });
+  registry.set("ROUNDUP", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      const rawDigits = evaluator.evaluate(args[1], context);
+      if (rawDigits instanceof FormulaError) return rawDigits;
+      const digits = toNumber(rawDigits);
+      if (digits instanceof FormulaError) return digits;
+      const factor = Math.pow(10, Math.trunc(digits));
+      return num >= 0 ? Math.ceil(num * factor) / factor : Math.floor(num * factor) / factor;
+    }
+  });
+  registry.set("ROUNDDOWN", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      const rawDigits = evaluator.evaluate(args[1], context);
+      if (rawDigits instanceof FormulaError) return rawDigits;
+      const digits = toNumber(rawDigits);
+      if (digits instanceof FormulaError) return digits;
+      const factor = Math.pow(10, Math.trunc(digits));
+      return Math.trunc(num * factor) / factor;
+    }
+  });
+  registry.set("INT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      return Math.floor(num);
+    }
+  });
+  registry.set("TRUNC", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      let digits = 0;
+      if (args.length >= 2) {
+        const rawD = evaluator.evaluate(args[1], context);
+        if (rawD instanceof FormulaError) return rawD;
+        const d = toNumber(rawD);
+        if (d instanceof FormulaError) return d;
+        digits = Math.trunc(d);
+      }
+      const factor = Math.pow(10, digits);
+      return Math.trunc(num * factor) / factor;
+    }
+  });
+  registry.set("PRODUCT", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let product = 1;
+      let hasNumber = false;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          product *= val;
+          hasNumber = true;
+        }
+      }
+      return hasNumber ? product : 0;
+    }
+  });
+  registry.set("SUMPRODUCT", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const arrays = [];
+      for (const arg of args) {
+        if (arg.kind !== "range") {
+          return new FormulaError("#VALUE!", "SUMPRODUCT arguments must be ranges");
+        }
+        arrays.push(context.getRangeValues({ start: arg.start, end: arg.end }));
+      }
+      if (arrays.length === 0) return 0;
+      const rows = arrays[0].length;
+      const cols = rows > 0 ? arrays[0][0].length : 0;
+      for (let a = 1; a < arrays.length; a++) {
+        if (arrays[a].length !== rows || rows > 0 && arrays[a][0].length !== cols) {
+          return new FormulaError("#VALUE!", "SUMPRODUCT arrays must have same dimensions");
+        }
+      }
+      let sum = 0;
+      for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+          let product = 1;
+          for (let a = 0; a < arrays.length; a++) {
+            const v = toNumber(arrays[a][r][c]);
+            if (v instanceof FormulaError) {
+              product = 0;
+              break;
+            }
+            product *= v;
+          }
+          sum += product;
+        }
+      }
+      return sum;
+    }
+  });
+  registry.set("MEDIAN", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      const nums = [];
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") nums.push(val);
+      }
+      if (nums.length === 0) return new FormulaError("#NUM!", "No numeric values for MEDIAN");
+      nums.sort((a, b) => a - b);
+      const mid = Math.floor(nums.length / 2);
+      return nums.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
+    }
+  });
+  registry.set("LARGE", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "LARGE first argument must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawK = evaluator.evaluate(args[1], context);
+      if (rawK instanceof FormulaError) return rawK;
+      const k = toNumber(rawK);
+      if (k instanceof FormulaError) return k;
+      const nums = [];
+      for (const row of rangeData) {
+        for (const cell of row) {
+          if (typeof cell === "number") nums.push(cell);
+        }
+      }
+      const ki = Math.trunc(k);
+      if (ki < 1 || ki > nums.length) return new FormulaError("#NUM!", "LARGE k out of range");
+      nums.sort((a, b) => b - a);
+      return nums[ki - 1];
+    }
+  });
+  registry.set("SMALL", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "SMALL first argument must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawK = evaluator.evaluate(args[1], context);
+      if (rawK instanceof FormulaError) return rawK;
+      const k = toNumber(rawK);
+      if (k instanceof FormulaError) return k;
+      const nums = [];
+      for (const row of rangeData) {
+        for (const cell of row) {
+          if (typeof cell === "number") nums.push(cell);
+        }
+      }
+      const ki = Math.trunc(k);
+      if (ki < 1 || ki > nums.length) return new FormulaError("#NUM!", "SMALL k out of range");
+      nums.sort((a, b) => a - b);
+      return nums[ki - 1];
+    }
+  });
+  registry.set("RANK", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "RANK second argument must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      let order = 0;
+      if (args.length >= 3) {
+        const rawO = evaluator.evaluate(args[2], context);
+        if (rawO instanceof FormulaError) return rawO;
+        const o = toNumber(rawO);
+        if (o instanceof FormulaError) return o;
+        order = o;
+      }
+      const nums = [];
+      for (const row of rangeData) {
+        for (const cell of row) {
+          if (typeof cell === "number") nums.push(cell);
+        }
+      }
+      if (!nums.includes(num)) return new FormulaError("#N/A", "RANK value not found in range");
+      let rank = 1;
+      for (const n of nums) {
+        if (order === 0 ? n > num : n < num) rank++;
+      }
+      return rank;
+    }
+  });
+  registry.set("SIGN", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      return num > 0 ? 1 : num < 0 ? -1 : 0;
+    }
+  });
+  registry.set("LOG", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      if (num <= 0) return new FormulaError("#NUM!", "LOG requires a positive number");
+      let base = 10;
+      if (args.length >= 2) {
+        const rawB = evaluator.evaluate(args[1], context);
+        if (rawB instanceof FormulaError) return rawB;
+        const b = toNumber(rawB);
+        if (b instanceof FormulaError) return b;
+        if (b <= 0 || b === 1) return new FormulaError("#NUM!", "LOG base must be positive and not 1");
+        base = b;
+      }
+      return Math.log(num) / Math.log(base);
+    }
+  });
+  registry.set("LN", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      if (num <= 0) return new FormulaError("#NUM!", "LN requires a positive number");
+      return Math.log(num);
+    }
+  });
+  registry.set("EXP", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      return Math.exp(num);
+    }
+  });
+  registry.set("PI", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate() {
+      return Math.PI;
+    }
+  });
+  registry.set("RAND", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate() {
+      return Math.random();
+    }
+  });
+  registry.set("RANDBETWEEN", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawLow = evaluator.evaluate(args[0], context);
+      if (rawLow instanceof FormulaError) return rawLow;
+      const low = toNumber(rawLow);
+      if (low instanceof FormulaError) return low;
+      const rawHigh = evaluator.evaluate(args[1], context);
+      if (rawHigh instanceof FormulaError) return rawHigh;
+      const high = toNumber(rawHigh);
+      if (high instanceof FormulaError) return high;
+      const lo = Math.ceil(low);
+      const hi = Math.floor(high);
+      if (lo > hi) return new FormulaError("#NUM!", "RANDBETWEEN bottom must be <= top");
+      return Math.floor(Math.random() * (hi - lo + 1)) + lo;
+    }
+  });
+}
+function flattenArgs2(args, context, evaluator) {
+  const result = [];
+  for (const arg of args) {
+    if (arg.kind === "range") {
+      const values = context.getRangeValues({ start: arg.start, end: arg.end });
+      for (const row of values) {
+        for (const cell of row) {
+          result.push(cell);
+        }
+      }
+    } else {
+      result.push(evaluator.evaluate(arg, context));
+    }
+  }
+  return result;
+}
+function registerLogicalFunctions(registry) {
+  registry.set("IF", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const condition = evaluator.evaluate(args[0], context);
+      if (condition instanceof FormulaError) return condition;
+      if (condition) {
+        return evaluator.evaluate(args[1], context);
+      } else {
+        if (args.length >= 3) {
+          return evaluator.evaluate(args[2], context);
+        }
+        return false;
+      }
+    }
+  });
+  registry.set("AND", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs2(args, context, evaluator);
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (!val) return false;
+      }
+      return true;
+    }
+  });
+  registry.set("OR", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs2(args, context, evaluator);
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (val) return true;
+      }
+      return false;
+    }
+  });
+  registry.set("NOT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return !val;
+    }
+  });
+  registry.set("IFERROR", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) {
+        return evaluator.evaluate(args[1], context);
+      }
+      return val;
+    }
+  });
+  registry.set("IFNA", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError && val.type === "#N/A") {
+        return evaluator.evaluate(args[1], context);
+      }
+      return val;
+    }
+  });
+  registry.set("IFS", {
+    minArgs: 2,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      if (args.length % 2 !== 0) {
+        return new FormulaError("#VALUE!", "IFS requires pairs of condition, value");
+      }
+      for (let i = 0; i < args.length; i += 2) {
+        const condition = evaluator.evaluate(args[i], context);
+        if (condition instanceof FormulaError) return condition;
+        if (condition) {
+          return evaluator.evaluate(args[i + 1], context);
+        }
+      }
+      return new FormulaError("#N/A", "IFS no condition was TRUE");
+    }
+  });
+  registry.set("SWITCH", {
+    minArgs: 3,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const expr = evaluator.evaluate(args[0], context);
+      if (expr instanceof FormulaError) return expr;
+      const hasDefault = (args.length - 1) % 2 !== 0;
+      const pairCount = hasDefault ? (args.length - 2) / 2 : (args.length - 1) / 2;
+      for (let i = 0; i < pairCount; i++) {
+        const caseVal = evaluator.evaluate(args[1 + i * 2], context);
+        if (caseVal instanceof FormulaError) return caseVal;
+        if (expr === caseVal) {
+          return evaluator.evaluate(args[2 + i * 2], context);
+        }
+      }
+      if (hasDefault) {
+        return evaluator.evaluate(args[args.length - 1], context);
+      }
+      return new FormulaError("#N/A", "SWITCH no match found");
+    }
+  });
+  registry.set("CHOOSE", {
+    minArgs: 2,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const rawIdx = evaluator.evaluate(args[0], context);
+      if (rawIdx instanceof FormulaError) return rawIdx;
+      if (typeof rawIdx !== "number") return new FormulaError("#VALUE!", "CHOOSE index must be a number");
+      const idx = Math.trunc(rawIdx);
+      if (idx < 1 || idx >= args.length) {
+        return new FormulaError("#VALUE!", "CHOOSE index out of range");
+      }
+      return evaluator.evaluate(args[idx], context);
+    }
+  });
+  registry.set("XOR", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs2(args, context, evaluator);
+      let trueCount = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (val) trueCount++;
+      }
+      return trueCount % 2 === 1;
+    }
+  });
+}
+function registerLookupFunctions(registry) {
+  registry.set("VLOOKUP", {
+    minArgs: 3,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const lookupValue = evaluator.evaluate(args[0], context);
+      if (lookupValue instanceof FormulaError) return lookupValue;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "VLOOKUP table_array must be a range");
+      }
+      const tableData = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      const rawColIndex = evaluator.evaluate(args[2], context);
+      if (rawColIndex instanceof FormulaError) return rawColIndex;
+      const colIndex = toNumber(rawColIndex);
+      if (colIndex instanceof FormulaError) return colIndex;
+      if (colIndex < 1) return new FormulaError("#VALUE!", "VLOOKUP col_index must be >= 1");
+      if (tableData.length > 0 && colIndex > tableData[0].length) {
+        return new FormulaError("#REF!", "VLOOKUP col_index exceeds table columns");
+      }
+      let rangeLookup = true;
+      if (args.length >= 4) {
+        const rawRL = evaluator.evaluate(args[3], context);
+        if (rawRL instanceof FormulaError) return rawRL;
+        rangeLookup = !!rawRL;
+      }
+      const col = Math.trunc(colIndex) - 1;
+      const lookupLower = typeof lookupValue === "string" ? lookupValue.toLowerCase() : null;
+      if (rangeLookup) {
+        let bestRow = -1;
+        for (let r = 0; r < tableData.length; r++) {
+          const cellVal = tableData[r][0];
+          if (cellVal === null || cellVal === void 0) continue;
+          if (typeof lookupValue === "number" && typeof cellVal === "number") {
+            if (cellVal <= lookupValue) bestRow = r;
+            else break;
+          } else if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() <= lookupLower) bestRow = r;
+            else break;
+          }
+        }
+        if (bestRow === -1) return new FormulaError("#N/A", "VLOOKUP no match found");
+        return tableData[bestRow][col] ?? null;
+      } else {
+        for (let r = 0; r < tableData.length; r++) {
+          const cellVal = tableData[r][0];
+          if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() === lookupLower) {
+              return tableData[r][col] ?? null;
+            }
+          } else if (cellVal === lookupValue) {
+            return tableData[r][col] ?? null;
+          }
+        }
+        return new FormulaError("#N/A", "VLOOKUP no exact match found");
+      }
+    }
+  });
+  registry.set("INDEX", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "INDEX first argument must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawRow = evaluator.evaluate(args[1], context);
+      if (rawRow instanceof FormulaError) return rawRow;
+      const rowNum = toNumber(rawRow);
+      if (rowNum instanceof FormulaError) return rowNum;
+      let colNum = 1;
+      if (args.length >= 3) {
+        const rawCol = evaluator.evaluate(args[2], context);
+        if (rawCol instanceof FormulaError) return rawCol;
+        const c2 = toNumber(rawCol);
+        if (c2 instanceof FormulaError) return c2;
+        colNum = c2;
+      }
+      const r = Math.trunc(rowNum) - 1;
+      const c = Math.trunc(colNum) - 1;
+      if (r < 0 || r >= rangeData.length) {
+        return new FormulaError("#REF!", "INDEX row out of bounds");
+      }
+      if (c < 0 || rangeData.length > 0 && c >= rangeData[0].length) {
+        return new FormulaError("#REF!", "INDEX column out of bounds");
+      }
+      return rangeData[r][c] ?? null;
+    }
+  });
+  registry.set("HLOOKUP", {
+    minArgs: 3,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const lookupValue = evaluator.evaluate(args[0], context);
+      if (lookupValue instanceof FormulaError) return lookupValue;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "HLOOKUP table_array must be a range");
+      }
+      const tableData = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      const rawRowIndex = evaluator.evaluate(args[2], context);
+      if (rawRowIndex instanceof FormulaError) return rawRowIndex;
+      const rowIndex = toNumber(rawRowIndex);
+      if (rowIndex instanceof FormulaError) return rowIndex;
+      if (rowIndex < 1) return new FormulaError("#VALUE!", "HLOOKUP row_index must be >= 1");
+      if (rowIndex > tableData.length) {
+        return new FormulaError("#REF!", "HLOOKUP row_index exceeds table rows");
+      }
+      let rangeLookup = true;
+      if (args.length >= 4) {
+        const rawRL = evaluator.evaluate(args[3], context);
+        if (rawRL instanceof FormulaError) return rawRL;
+        rangeLookup = !!rawRL;
+      }
+      const row = Math.trunc(rowIndex) - 1;
+      const firstRow = tableData[0] || [];
+      const lookupLower = typeof lookupValue === "string" ? lookupValue.toLowerCase() : null;
+      if (rangeLookup) {
+        let bestCol = -1;
+        for (let c = 0; c < firstRow.length; c++) {
+          const cellVal = firstRow[c];
+          if (cellVal === null || cellVal === void 0) continue;
+          if (typeof lookupValue === "number" && typeof cellVal === "number") {
+            if (cellVal <= lookupValue) bestCol = c;
+            else break;
+          } else if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() <= lookupLower) bestCol = c;
+            else break;
+          }
+        }
+        if (bestCol === -1) return new FormulaError("#N/A", "HLOOKUP no match found");
+        return tableData[row][bestCol] ?? null;
+      } else {
+        for (let c = 0; c < firstRow.length; c++) {
+          const cellVal = firstRow[c];
+          if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() === lookupLower) return tableData[row][c] ?? null;
+          } else if (cellVal === lookupValue) {
+            return tableData[row][c] ?? null;
+          }
+        }
+        return new FormulaError("#N/A", "HLOOKUP no exact match found");
+      }
+    }
+  });
+  registry.set("XLOOKUP", {
+    minArgs: 3,
+    maxArgs: 6,
+    evaluate(args, context, evaluator) {
+      const lookupValue = evaluator.evaluate(args[0], context);
+      if (lookupValue instanceof FormulaError) return lookupValue;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "XLOOKUP lookup_array must be a range");
+      }
+      const lookupArray = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      if (args[2].kind !== "range") {
+        return new FormulaError("#VALUE!", "XLOOKUP return_array must be a range");
+      }
+      const returnArray = context.getRangeValues({ start: args[2].start, end: args[2].end });
+      let ifNotFound = new FormulaError("#N/A", "XLOOKUP no match found");
+      if (args.length >= 4) {
+        ifNotFound = evaluator.evaluate(args[3], context);
+      }
+      let matchMode = 0;
+      if (args.length >= 5) {
+        const rawMM = evaluator.evaluate(args[4], context);
+        if (rawMM instanceof FormulaError) return rawMM;
+        const mm = toNumber(rawMM);
+        if (mm instanceof FormulaError) return mm;
+        matchMode = Math.trunc(mm);
+      }
+      let searchMode = 1;
+      if (args.length >= 6) {
+        const rawSM = evaluator.evaluate(args[5], context);
+        if (rawSM instanceof FormulaError) return rawSM;
+        const sm = toNumber(rawSM);
+        if (sm instanceof FormulaError) return sm;
+        searchMode = Math.trunc(sm);
+      }
+      const isRow = lookupArray.length === 1;
+      const len = isRow ? lookupArray[0].length : lookupArray.length;
+      const getVal = isRow ? (i) => lookupArray[0][i] : (i) => lookupArray[i][0];
+      const lookupLower = typeof lookupValue === "string" ? lookupValue.toLowerCase() : null;
+      const eq = (a, b) => {
+        if (lookupLower !== null && typeof a === "string") return a.toLowerCase() === lookupLower;
+        return a === b;
+      };
+      let foundIdx = -1;
+      if (matchMode === 0) {
+        const start = searchMode >= 0 ? 0 : len - 1;
+        const end = searchMode >= 0 ? len : -1;
+        const step = searchMode >= 0 ? 1 : -1;
+        for (let i = start; i !== end; i += step) {
+          if (eq(getVal(i), lookupValue)) {
+            foundIdx = i;
+            break;
+          }
+        }
+      } else if (matchMode === -1) {
+        let best = -1;
+        for (let i = 0; i < len; i++) {
+          const v = getVal(i);
+          if (eq(v, lookupValue)) {
+            foundIdx = i;
+            break;
+          }
+          if (typeof lookupValue === "number" && typeof v === "number" && v < lookupValue) {
+            if (best === -1 || v > getVal(best)) best = i;
+          }
+        }
+        if (foundIdx === -1) foundIdx = best;
+      } else if (matchMode === 1) {
+        let best = -1;
+        for (let i = 0; i < len; i++) {
+          const v = getVal(i);
+          if (eq(v, lookupValue)) {
+            foundIdx = i;
+            break;
+          }
+          if (typeof lookupValue === "number" && typeof v === "number" && v > lookupValue) {
+            if (best === -1 || v < getVal(best)) best = i;
+          }
+        }
+        if (foundIdx === -1) foundIdx = best;
+      }
+      if (foundIdx === -1) return ifNotFound;
+      const isReturnRow = returnArray.length === 1;
+      if (isReturnRow) return returnArray[0][foundIdx] ?? null;
+      return returnArray[foundIdx]?.[0] ?? null;
+    }
+  });
+  registry.set("MATCH", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const lookupValue = evaluator.evaluate(args[0], context);
+      if (lookupValue instanceof FormulaError) return lookupValue;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "MATCH lookup_array must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      const isSingleRow = rangeData.length === 1;
+      const values = isSingleRow ? rangeData[0] : rangeData;
+      const getValue = isSingleRow ? (i) => values[i] : (i) => values[i][0];
+      const valuesLength = isSingleRow ? values.length : values.length;
+      let matchType = 1;
+      if (args.length >= 3) {
+        const rawMT = evaluator.evaluate(args[2], context);
+        if (rawMT instanceof FormulaError) return rawMT;
+        const mt = toNumber(rawMT);
+        if (mt instanceof FormulaError) return mt;
+        matchType = mt;
+      }
+      const lookupLower = typeof lookupValue === "string" ? lookupValue.toLowerCase() : null;
+      if (matchType === 0) {
+        for (let i = 0; i < valuesLength; i++) {
+          const cellVal = getValue(i);
+          if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() === lookupLower) return i + 1;
+          } else if (cellVal === lookupValue) {
+            return i + 1;
+          }
+        }
+        return new FormulaError("#N/A", "MATCH no exact match found");
+      } else if (matchType === 1) {
+        let bestIndex = -1;
+        for (let i = 0; i < valuesLength; i++) {
+          const cellVal = getValue(i);
+          if (cellVal === null || cellVal === void 0) continue;
+          if (typeof lookupValue === "number" && typeof cellVal === "number") {
+            if (cellVal <= lookupValue) bestIndex = i;
+            else break;
+          } else if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() <= lookupLower) bestIndex = i;
+            else break;
+          }
+        }
+        if (bestIndex === -1) return new FormulaError("#N/A", "MATCH no match found");
+        return bestIndex + 1;
+      } else {
+        let bestIndex = -1;
+        for (let i = 0; i < valuesLength; i++) {
+          const cellVal = getValue(i);
+          if (cellVal === null || cellVal === void 0) continue;
+          if (typeof lookupValue === "number" && typeof cellVal === "number") {
+            if (cellVal >= lookupValue) bestIndex = i;
+            else break;
+          } else if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() >= lookupLower) bestIndex = i;
+            else break;
+          }
+        }
+        if (bestIndex === -1) return new FormulaError("#N/A", "MATCH no match found");
+        return bestIndex + 1;
+      }
+    }
+  });
+}
+function registerTextFunctions(registry) {
+  registry.set("CONCATENATE", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      const parts = [];
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        parts.push(toString(val));
+      }
+      return parts.join("");
+    }
+  });
+  registry.set("CONCAT", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      const parts = [];
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        parts.push(toString(val));
+      }
+      return parts.join("");
+    }
+  });
+  registry.set("UPPER", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).toUpperCase();
+    }
+  });
+  registry.set("LOWER", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).toLowerCase();
+    }
+  });
+  registry.set("TRIM", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).trim();
+    }
+  });
+  registry.set("LEFT", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      let numChars = 1;
+      if (args.length >= 2) {
+        const rawNum = evaluator.evaluate(args[1], context);
+        if (rawNum instanceof FormulaError) return rawNum;
+        const n = toNumber(rawNum);
+        if (n instanceof FormulaError) return n;
+        numChars = Math.trunc(n);
+      }
+      if (numChars < 0) return new FormulaError("#VALUE!", "LEFT num_chars must be >= 0");
+      return text.substring(0, numChars);
+    }
+  });
+  registry.set("RIGHT", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      let numChars = 1;
+      if (args.length >= 2) {
+        const rawNum = evaluator.evaluate(args[1], context);
+        if (rawNum instanceof FormulaError) return rawNum;
+        const n = toNumber(rawNum);
+        if (n instanceof FormulaError) return n;
+        numChars = Math.trunc(n);
+      }
+      if (numChars < 0) return new FormulaError("#VALUE!", "RIGHT num_chars must be >= 0");
+      return text.substring(Math.max(0, text.length - numChars));
+    }
+  });
+  registry.set("MID", {
+    minArgs: 3,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      const rawStart = evaluator.evaluate(args[1], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startPos = toNumber(rawStart);
+      if (startPos instanceof FormulaError) return startPos;
+      const rawNum = evaluator.evaluate(args[2], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const numChars = toNumber(rawNum);
+      if (numChars instanceof FormulaError) return numChars;
+      const start = Math.trunc(startPos);
+      const count = Math.trunc(numChars);
+      if (start < 1) return new FormulaError("#VALUE!", "MID start_num must be >= 1");
+      if (count < 0) return new FormulaError("#VALUE!", "MID num_chars must be >= 0");
+      return text.substring(start - 1, start - 1 + count);
+    }
+  });
+  registry.set("LEN", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).length;
+    }
+  });
+  registry.set("SUBSTITUTE", {
+    minArgs: 3,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      const rawOld = evaluator.evaluate(args[1], context);
+      if (rawOld instanceof FormulaError) return rawOld;
+      const oldText = toString(rawOld);
+      const rawNew = evaluator.evaluate(args[2], context);
+      if (rawNew instanceof FormulaError) return rawNew;
+      const newText = toString(rawNew);
+      if (args.length >= 4) {
+        const rawInstance = evaluator.evaluate(args[3], context);
+        if (rawInstance instanceof FormulaError) return rawInstance;
+        const instanceNum = toNumber(rawInstance);
+        if (instanceNum instanceof FormulaError) return instanceNum;
+        const n = Math.trunc(instanceNum);
+        if (n < 1) return new FormulaError("#VALUE!", "SUBSTITUTE instance_num must be >= 1");
+        let count = 0;
+        let result = "";
+        let searchFrom = 0;
+        while (searchFrom <= text.length) {
+          const idx = text.indexOf(oldText, searchFrom);
+          if (idx === -1) {
+            result += text.substring(searchFrom);
+            break;
+          }
+          count++;
+          if (count === n) {
+            result += text.substring(searchFrom, idx) + newText;
+            result += text.substring(idx + oldText.length);
+            break;
+          } else {
+            result += text.substring(searchFrom, idx + oldText.length);
+            searchFrom = idx + oldText.length;
+          }
+        }
+        return result;
+      } else {
+        if (oldText === "") return text;
+        return text.split(oldText).join(newText);
+      }
+    }
+  });
+  registry.set("FIND", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawFind = evaluator.evaluate(args[0], context);
+      if (rawFind instanceof FormulaError) return rawFind;
+      const findText = toString(rawFind);
+      const rawWithin = evaluator.evaluate(args[1], context);
+      if (rawWithin instanceof FormulaError) return rawWithin;
+      const withinText = toString(rawWithin);
+      let startNum = 1;
+      if (args.length >= 3) {
+        const rawStart = evaluator.evaluate(args[2], context);
+        if (rawStart instanceof FormulaError) return rawStart;
+        const s = toNumber(rawStart);
+        if (s instanceof FormulaError) return s;
+        startNum = Math.trunc(s);
+      }
+      if (startNum < 1) return new FormulaError("#VALUE!", "FIND start_num must be >= 1");
+      const idx = withinText.indexOf(findText, startNum - 1);
+      if (idx === -1) return new FormulaError("#VALUE!", "FIND text not found");
+      return idx + 1;
+    }
+  });
+  registry.set("SEARCH", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawFind = evaluator.evaluate(args[0], context);
+      if (rawFind instanceof FormulaError) return rawFind;
+      const findText = toString(rawFind).toLowerCase();
+      const rawWithin = evaluator.evaluate(args[1], context);
+      if (rawWithin instanceof FormulaError) return rawWithin;
+      const withinText = toString(rawWithin).toLowerCase();
+      let startNum = 1;
+      if (args.length >= 3) {
+        const rawStart = evaluator.evaluate(args[2], context);
+        if (rawStart instanceof FormulaError) return rawStart;
+        const s = toNumber(rawStart);
+        if (s instanceof FormulaError) return s;
+        startNum = Math.trunc(s);
+      }
+      if (startNum < 1) return new FormulaError("#VALUE!", "SEARCH start_num must be >= 1");
+      const idx = withinText.indexOf(findText, startNum - 1);
+      if (idx === -1) return new FormulaError("#VALUE!", "SEARCH text not found");
+      return idx + 1;
+    }
+  });
+  registry.set("REPLACE", {
+    minArgs: 4,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const rawText = evaluator.evaluate(args[0], context);
+      if (rawText instanceof FormulaError) return rawText;
+      const text = toString(rawText);
+      const rawStart = evaluator.evaluate(args[1], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startPos = toNumber(rawStart);
+      if (startPos instanceof FormulaError) return startPos;
+      const rawNum = evaluator.evaluate(args[2], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const numChars = toNumber(rawNum);
+      if (numChars instanceof FormulaError) return numChars;
+      const rawNew = evaluator.evaluate(args[3], context);
+      if (rawNew instanceof FormulaError) return rawNew;
+      const newText = toString(rawNew);
+      const start = Math.trunc(startPos) - 1;
+      const count = Math.trunc(numChars);
+      return text.substring(0, start) + newText + text.substring(start + count);
+    }
+  });
+  registry.set("REPT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawText = evaluator.evaluate(args[0], context);
+      if (rawText instanceof FormulaError) return rawText;
+      const text = toString(rawText);
+      const rawTimes = evaluator.evaluate(args[1], context);
+      if (rawTimes instanceof FormulaError) return rawTimes;
+      const times = toNumber(rawTimes);
+      if (times instanceof FormulaError) return times;
+      const n = Math.trunc(times);
+      if (n < 0) return new FormulaError("#VALUE!", "REPT number must be >= 0");
+      return text.repeat(n);
+    }
+  });
+  registry.set("EXACT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawA = evaluator.evaluate(args[0], context);
+      if (rawA instanceof FormulaError) return rawA;
+      const rawB = evaluator.evaluate(args[1], context);
+      if (rawB instanceof FormulaError) return rawB;
+      return toString(rawA) === toString(rawB);
+    }
+  });
+  registry.set("PROPER", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).toLowerCase().replace(/\b\w/g, (c) => c.toUpperCase());
+    }
+  });
+  registry.set("CLEAN", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).replace(/[\x00-\x1F]/g, "");
+    }
+  });
+  registry.set("CHAR", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      const n = Math.trunc(num);
+      if (n < 1 || n > 65535) return new FormulaError("#VALUE!", "CHAR number must be 1-65535");
+      return String.fromCharCode(n);
+    }
+  });
+  registry.set("CODE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      if (text.length === 0) return new FormulaError("#VALUE!", "CODE requires non-empty text");
+      return text.charCodeAt(0);
+    }
+  });
+  registry.set("TEXT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const rawFmt = evaluator.evaluate(args[1], context);
+      if (rawFmt instanceof FormulaError) return rawFmt;
+      const fmt = toString(rawFmt);
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return toString(rawVal);
+      if (fmt.includes("%")) {
+        const decimals2 = (fmt.match(/0/g) || []).length - 1;
+        return (num * 100).toFixed(Math.max(0, decimals2)) + "%";
+      }
+      const decimalMatch = fmt.match(/\.(0+)/);
+      const decimals = decimalMatch ? decimalMatch[1].length : 0;
+      const useCommas = fmt.includes(",");
+      const result = num.toFixed(decimals);
+      if (useCommas) {
+        const [intPart, decPart] = result.split(".");
+        const withCommas = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+        return decPart ? withCommas + "." + decPart : withCommas;
+      }
+      return result;
+    }
+  });
+  registry.set("VALUE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      if (typeof val === "number") return val;
+      const raw = toString(val).trim();
+      const isPercent = raw.endsWith("%");
+      const text = raw.replace(/[,$%\s]/g, "");
+      const n = Number(text);
+      if (isNaN(n)) return new FormulaError("#VALUE!", "VALUE cannot convert text to number");
+      return isPercent ? n / 100 : n;
+    }
+  });
+  registry.set("TEXTJOIN", {
+    minArgs: 3,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const rawDelim = evaluator.evaluate(args[0], context);
+      if (rawDelim instanceof FormulaError) return rawDelim;
+      const delimiter = toString(rawDelim);
+      const rawIgnore = evaluator.evaluate(args[1], context);
+      if (rawIgnore instanceof FormulaError) return rawIgnore;
+      const ignoreEmpty = !!rawIgnore;
+      const parts = [];
+      for (let i = 2; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.kind === "range") {
+          const rangeData = context.getRangeValues({ start: arg.start, end: arg.end });
+          for (const row of rangeData) {
+            for (const cell of row) {
+              if (cell instanceof FormulaError) return cell;
+              const s = toString(cell);
+              if (!ignoreEmpty || s !== "") parts.push(s);
+            }
+          }
+        } else {
+          const val = evaluator.evaluate(args[i], context);
+          if (val instanceof FormulaError) return val;
+          const s = toString(val);
+          if (!ignoreEmpty || s !== "") parts.push(s);
+        }
+      }
+      return parts.join(delimiter);
+    }
+  });
+}
+function toDate(val) {
+  if (val instanceof FormulaError) return val;
+  if (val instanceof Date) {
+    if (isNaN(val.getTime())) return new FormulaError("#VALUE!", "Invalid date");
+    return val;
+  }
+  if (typeof val === "string") {
+    const d = new Date(val);
+    if (isNaN(d.getTime())) return new FormulaError("#VALUE!", `Cannot parse "${val}" as date`);
+    return d;
+  }
+  if (typeof val === "number") {
+    const d = new Date(val);
+    if (isNaN(d.getTime())) return new FormulaError("#VALUE!", "Invalid numeric date");
+    return d;
+  }
+  return new FormulaError("#VALUE!", "Cannot convert value to date");
+}
+function registerDateFunctions(registry) {
+  registry.set("TODAY", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate(_args, context) {
+      const now = context.now();
+      return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    }
+  });
+  registry.set("NOW", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate(_args, context) {
+      return context.now();
+    }
+  });
+  registry.set("YEAR", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getFullYear();
+    }
+  });
+  registry.set("MONTH", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getMonth() + 1;
+    }
+  });
+  registry.set("DAY", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getDate();
+    }
+  });
+  registry.set("DATE", {
+    minArgs: 3,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawY = evaluator.evaluate(args[0], context);
+      if (rawY instanceof FormulaError) return rawY;
+      const y = toNumber(rawY);
+      if (y instanceof FormulaError) return y;
+      const rawM = evaluator.evaluate(args[1], context);
+      if (rawM instanceof FormulaError) return rawM;
+      const m = toNumber(rawM);
+      if (m instanceof FormulaError) return m;
+      const rawD = evaluator.evaluate(args[2], context);
+      if (rawD instanceof FormulaError) return rawD;
+      const d = toNumber(rawD);
+      if (d instanceof FormulaError) return d;
+      return new Date(Math.trunc(y), Math.trunc(m) - 1, Math.trunc(d));
+    }
+  });
+  registry.set("DATEDIF", {
+    minArgs: 3,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawStart = evaluator.evaluate(args[0], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startDate = toDate(rawStart);
+      if (startDate instanceof FormulaError) return startDate;
+      const rawEnd = evaluator.evaluate(args[1], context);
+      if (rawEnd instanceof FormulaError) return rawEnd;
+      const endDate = toDate(rawEnd);
+      if (endDate instanceof FormulaError) return endDate;
+      const rawUnit = evaluator.evaluate(args[2], context);
+      if (rawUnit instanceof FormulaError) return rawUnit;
+      const unit = String(rawUnit).toUpperCase();
+      if (startDate > endDate) return new FormulaError("#NUM!", "DATEDIF start date must be <= end date");
+      switch (unit) {
+        case "Y": {
+          let years = endDate.getFullYear() - startDate.getFullYear();
+          if (endDate.getMonth() < startDate.getMonth() || endDate.getMonth() === startDate.getMonth() && endDate.getDate() < startDate.getDate()) {
+            years--;
+          }
+          return years;
+        }
+        case "M": {
+          let months = (endDate.getFullYear() - startDate.getFullYear()) * 12 + endDate.getMonth() - startDate.getMonth();
+          if (endDate.getDate() < startDate.getDate()) months--;
+          return months;
+        }
+        case "D":
+          return Math.floor((endDate.getTime() - startDate.getTime()) / 864e5);
+        default:
+          return new FormulaError("#VALUE!", "DATEDIF unit must be Y, M, or D");
+      }
+    }
+  });
+  registry.set("EDATE", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawDate = evaluator.evaluate(args[0], context);
+      if (rawDate instanceof FormulaError) return rawDate;
+      const date = toDate(rawDate);
+      if (date instanceof FormulaError) return date;
+      const rawMonths = evaluator.evaluate(args[1], context);
+      if (rawMonths instanceof FormulaError) return rawMonths;
+      const months = toNumber(rawMonths);
+      if (months instanceof FormulaError) return months;
+      const result = new Date(date);
+      result.setMonth(result.getMonth() + Math.trunc(months));
+      return result;
+    }
+  });
+  registry.set("EOMONTH", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawDate = evaluator.evaluate(args[0], context);
+      if (rawDate instanceof FormulaError) return rawDate;
+      const date = toDate(rawDate);
+      if (date instanceof FormulaError) return date;
+      const rawMonths = evaluator.evaluate(args[1], context);
+      if (rawMonths instanceof FormulaError) return rawMonths;
+      const months = toNumber(rawMonths);
+      if (months instanceof FormulaError) return months;
+      const result = new Date(date.getFullYear(), date.getMonth() + Math.trunc(months) + 1, 0);
+      return result;
+    }
+  });
+  registry.set("WEEKDAY", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawDate = evaluator.evaluate(args[0], context);
+      if (rawDate instanceof FormulaError) return rawDate;
+      const date = toDate(rawDate);
+      if (date instanceof FormulaError) return date;
+      let returnType = 1;
+      if (args.length >= 2) {
+        const rawRT = evaluator.evaluate(args[1], context);
+        if (rawRT instanceof FormulaError) return rawRT;
+        const rt = toNumber(rawRT);
+        if (rt instanceof FormulaError) return rt;
+        returnType = Math.trunc(rt);
+      }
+      const day = date.getDay();
+      switch (returnType) {
+        case 1:
+          return day + 1;
+        // 1=Sun, 7=Sat
+        case 2:
+          return day === 0 ? 7 : day;
+        // 1=Mon, 7=Sun
+        case 3:
+          return day === 0 ? 6 : day - 1;
+        // 0=Mon, 6=Sun
+        default:
+          return new FormulaError("#VALUE!", "WEEKDAY return_type must be 1, 2, or 3");
+      }
+    }
+  });
+  registry.set("HOUR", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getHours();
+    }
+  });
+  registry.set("MINUTE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getMinutes();
+    }
+  });
+  registry.set("SECOND", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getSeconds();
+    }
+  });
+  registry.set("NETWORKDAYS", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawStart = evaluator.evaluate(args[0], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startDate = toDate(rawStart);
+      if (startDate instanceof FormulaError) return startDate;
+      const rawEnd = evaluator.evaluate(args[1], context);
+      if (rawEnd instanceof FormulaError) return rawEnd;
+      const endDate = toDate(rawEnd);
+      if (endDate instanceof FormulaError) return endDate;
+      const start = new Date(startDate.getFullYear(), startDate.getMonth(), startDate.getDate());
+      const end = new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate());
+      const sign = end >= start ? 1 : -1;
+      const [from, to] = sign === 1 ? [start, end] : [end, start];
+      let count = 0;
+      const current = new Date(from);
+      while (current <= to) {
+        const day = current.getDay();
+        if (day !== 0 && day !== 6) count++;
+        current.setDate(current.getDate() + 1);
+      }
+      return count * sign;
+    }
+  });
+}
+function makeCriteria(op, value) {
+  return { op, value, valueLower: typeof value === "string" ? value.toLowerCase() : null };
+}
+function parseCriteria(criteria) {
+  if (typeof criteria === "number") {
+    return makeCriteria("=", criteria);
+  }
+  if (typeof criteria !== "string") {
+    return makeCriteria("=", criteria);
+  }
+  const str = criteria.trim();
+  if (str.startsWith(">=")) {
+    return makeCriteria(">=", parseNumericOrString(str.substring(2).trim()));
+  }
+  if (str.startsWith("<=")) {
+    return makeCriteria("<=", parseNumericOrString(str.substring(2).trim()));
+  }
+  if (str.startsWith("<>")) {
+    return makeCriteria("<>", parseNumericOrString(str.substring(2).trim()));
+  }
+  if (str.startsWith(">")) {
+    return makeCriteria(">", parseNumericOrString(str.substring(1).trim()));
+  }
+  if (str.startsWith("<")) {
+    return makeCriteria("<", parseNumericOrString(str.substring(1).trim()));
+  }
+  if (str.startsWith("=")) {
+    return makeCriteria("=", parseNumericOrString(str.substring(1).trim()));
+  }
+  return makeCriteria("=", parseNumericOrString(str));
+}
+function parseNumericOrString(s) {
+  const n = Number(s);
+  if (!isNaN(n) && s !== "") return n;
+  return s;
+}
+function matchesCriteria(cellValue, criteria) {
+  const { op, value } = criteria;
+  let comparableCell = cellValue;
+  if (typeof value === "number" && typeof cellValue !== "number") {
+    const n = toNumber(cellValue);
+    if (n instanceof FormulaError) return false;
+    comparableCell = n;
+  }
+  if (typeof comparableCell === "string" && criteria.valueLower !== null) {
+    const a = comparableCell.toLowerCase();
+    const b = criteria.valueLower;
+    switch (op) {
+      case "=":
+        return a === b;
+      case "<>":
+        return a !== b;
+      case ">":
+        return a > b;
+      case "<":
+        return a < b;
+      case ">=":
+        return a >= b;
+      case "<=":
+        return a <= b;
+    }
+  }
+  if (typeof comparableCell === "number" && typeof value === "number") {
+    switch (op) {
+      case "=":
+        return comparableCell === value;
+      case "<>":
+        return comparableCell !== value;
+      case ">":
+        return comparableCell > value;
+      case "<":
+        return comparableCell < value;
+      case ">=":
+        return comparableCell >= value;
+      case "<=":
+        return comparableCell <= value;
+    }
+  }
+  if (op === "=") return comparableCell === value;
+  if (op === "<>") return comparableCell !== value;
+  return false;
+}
+function registerStatsFunctions(registry) {
+  registry.set("SUMIF", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "SUMIF range must be a cell range");
+      }
+      const criteriaRange = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawCriteria = evaluator.evaluate(args[1], context);
+      if (rawCriteria instanceof FormulaError) return rawCriteria;
+      const criteria = parseCriteria(rawCriteria);
+      let sumRange;
+      if (args.length >= 3) {
+        if (args[2].kind !== "range") {
+          return new FormulaError("#VALUE!", "SUMIF sum_range must be a cell range");
+        }
+        sumRange = context.getRangeValues({ start: args[2].start, end: args[2].end });
+      } else {
+        sumRange = criteriaRange;
+      }
+      let sum = 0;
+      for (let r = 0; r < criteriaRange.length; r++) {
+        for (let c = 0; c < criteriaRange[r].length; c++) {
+          if (matchesCriteria(criteriaRange[r][c], criteria)) {
+            const sumVal = sumRange[r] && sumRange[r][c] !== void 0 ? sumRange[r][c] : null;
+            const n = toNumber(sumVal);
+            if (typeof n === "number") {
+              sum += n;
+            }
+          }
+        }
+      }
+      return sum;
+    }
+  });
+  registry.set("COUNTIF", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "COUNTIF range must be a cell range");
+      }
+      const rangeData = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawCriteria = evaluator.evaluate(args[1], context);
+      if (rawCriteria instanceof FormulaError) return rawCriteria;
+      const criteria = parseCriteria(rawCriteria);
+      let count = 0;
+      for (let r = 0; r < rangeData.length; r++) {
+        for (let c = 0; c < rangeData[r].length; c++) {
+          if (matchesCriteria(rangeData[r][c], criteria)) {
+            count++;
+          }
+        }
+      }
+      return count;
+    }
+  });
+  registry.set("AVERAGEIF", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "AVERAGEIF range must be a cell range");
+      }
+      const criteriaRange = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawCriteria = evaluator.evaluate(args[1], context);
+      if (rawCriteria instanceof FormulaError) return rawCriteria;
+      const criteria = parseCriteria(rawCriteria);
+      let avgRange;
+      if (args.length >= 3) {
+        if (args[2].kind !== "range") {
+          return new FormulaError("#VALUE!", "AVERAGEIF avg_range must be a cell range");
+        }
+        avgRange = context.getRangeValues({ start: args[2].start, end: args[2].end });
+      } else {
+        avgRange = criteriaRange;
+      }
+      let sum = 0;
+      let count = 0;
+      for (let r = 0; r < criteriaRange.length; r++) {
+        for (let c = 0; c < criteriaRange[r].length; c++) {
+          if (matchesCriteria(criteriaRange[r][c], criteria)) {
+            const avgVal = avgRange[r] && avgRange[r][c] !== void 0 ? avgRange[r][c] : null;
+            const n = toNumber(avgVal);
+            if (typeof n === "number") {
+              sum += n;
+              count++;
+            }
+          }
+        }
+      }
+      if (count === 0) return new FormulaError("#DIV/0!", "No matching values for AVERAGEIF");
+      return sum / count;
+    }
+  });
+  registry.set("SUMIFS", {
+    minArgs: 3,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      if ((args.length - 1) % 2 !== 0) {
+        return new FormulaError("#VALUE!", "SUMIFS requires sum_range + pairs of criteria_range, criteria");
+      }
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "SUMIFS sum_range must be a cell range");
+      }
+      const sumRange = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const pairs = [];
+      for (let i = 1; i < args.length; i += 2) {
+        const rangeArg = args[i];
+        if (rangeArg.kind !== "range") {
+          return new FormulaError("#VALUE!", "SUMIFS criteria_range must be a cell range");
+        }
+        const range = context.getRangeValues({ start: rangeArg.start, end: rangeArg.end });
+        const rawCriteria = evaluator.evaluate(args[i + 1], context);
+        if (rawCriteria instanceof FormulaError) return rawCriteria;
+        pairs.push({ range, criteria: parseCriteria(rawCriteria) });
+      }
+      let sum = 0;
+      for (let r = 0; r < sumRange.length; r++) {
+        for (let c = 0; c < sumRange[r].length; c++) {
+          let allMatch = true;
+          for (const pair of pairs) {
+            const cellVal = pair.range[r]?.[c];
+            if (!matchesCriteria(cellVal, pair.criteria)) {
+              allMatch = false;
+              break;
+            }
+          }
+          if (allMatch) {
+            const n = toNumber(sumRange[r][c]);
+            if (typeof n === "number") sum += n;
+          }
+        }
+      }
+      return sum;
+    }
+  });
+  registry.set("COUNTIFS", {
+    minArgs: 2,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      if (args.length % 2 !== 0) {
+        return new FormulaError("#VALUE!", "COUNTIFS requires pairs of criteria_range, criteria");
+      }
+      const pairs = [];
+      for (let i = 0; i < args.length; i += 2) {
+        const rangeArg = args[i];
+        if (rangeArg.kind !== "range") {
+          return new FormulaError("#VALUE!", "COUNTIFS criteria_range must be a cell range");
+        }
+        const range = context.getRangeValues({ start: rangeArg.start, end: rangeArg.end });
+        const rawCriteria = evaluator.evaluate(args[i + 1], context);
+        if (rawCriteria instanceof FormulaError) return rawCriteria;
+        pairs.push({ range, criteria: parseCriteria(rawCriteria) });
+      }
+      const firstRange = pairs[0].range;
+      let count = 0;
+      for (let r = 0; r < firstRange.length; r++) {
+        for (let c = 0; c < firstRange[r].length; c++) {
+          let allMatch = true;
+          for (const pair of pairs) {
+            const cellVal = pair.range[r]?.[c];
+            if (!matchesCriteria(cellVal, pair.criteria)) {
+              allMatch = false;
+              break;
+            }
+          }
+          if (allMatch) count++;
+        }
+      }
+      return count;
+    }
+  });
+  registry.set("AVERAGEIFS", {
+    minArgs: 3,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      if ((args.length - 1) % 2 !== 0) {
+        return new FormulaError("#VALUE!", "AVERAGEIFS requires avg_range + pairs of criteria_range, criteria");
+      }
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "AVERAGEIFS avg_range must be a cell range");
+      }
+      const avgRange = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const pairs = [];
+      for (let i = 1; i < args.length; i += 2) {
+        const rangeArg = args[i];
+        if (rangeArg.kind !== "range") {
+          return new FormulaError("#VALUE!", "AVERAGEIFS criteria_range must be a cell range");
+        }
+        const range = context.getRangeValues({ start: rangeArg.start, end: rangeArg.end });
+        const rawCriteria = evaluator.evaluate(args[i + 1], context);
+        if (rawCriteria instanceof FormulaError) return rawCriteria;
+        pairs.push({ range, criteria: parseCriteria(rawCriteria) });
+      }
+      let sum = 0;
+      let count = 0;
+      for (let r = 0; r < avgRange.length; r++) {
+        for (let c = 0; c < avgRange[r].length; c++) {
+          let allMatch = true;
+          for (const pair of pairs) {
+            const cellVal = pair.range[r]?.[c];
+            if (!matchesCriteria(cellVal, pair.criteria)) {
+              allMatch = false;
+              break;
+            }
+          }
+          if (allMatch) {
+            const n = toNumber(avgRange[r][c]);
+            if (typeof n === "number") {
+              sum += n;
+              count++;
+            }
+          }
+        }
+      }
+      if (count === 0) return new FormulaError("#DIV/0!", "No matching values for AVERAGEIFS");
+      return sum / count;
+    }
+  });
+}
+function registerInfoFunctions(registry) {
+  registry.set("ISBLANK", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return val === null || val === void 0 || val === "";
+    }
+  });
+  registry.set("ISNUMBER", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return typeof val === "number" && !isNaN(val);
+    }
+  });
+  registry.set("ISTEXT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return typeof val === "string";
+    }
+  });
+  registry.set("ISERROR", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return val instanceof FormulaError;
+    }
+  });
+  registry.set("ISNA", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return val instanceof FormulaError && val.type === "#N/A";
+    }
+  });
+  registry.set("TYPE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return 16;
+      if (typeof val === "number") return 1;
+      if (typeof val === "string") return 2;
+      if (typeof val === "boolean") return 4;
+      if (val === null || val === void 0) return 1;
+      return 1;
+    }
+  });
+}
+function createBuiltInFunctions() {
+  const registry = /* @__PURE__ */ new Map();
+  registerMathFunctions(registry);
+  registerLogicalFunctions(registry);
+  registerLookupFunctions(registry);
+  registerTextFunctions(registry);
+  registerDateFunctions(registry);
+  registerStatsFunctions(registry);
+  registerInfoFunctions(registry);
+  return registry;
+}
+function extractDependencies(node) {
+  const deps = /* @__PURE__ */ new Set();
+  function walk(n) {
+    switch (n.kind) {
+      case "cellRef":
+        deps.add(toCellKey(n.address.col, n.address.row, n.address.sheet));
+        break;
+      case "range": {
+        const sheet = n.start.sheet;
+        const minRow = Math.min(n.start.row, n.end.row);
+        const maxRow = Math.max(n.start.row, n.end.row);
+        const minCol = Math.min(n.start.col, n.end.col);
+        const maxCol = Math.max(n.start.col, n.end.col);
+        for (let r = minRow; r <= maxRow; r++) {
+          for (let c = minCol; c <= maxCol; c++) {
+            deps.add(toCellKey(c, r, sheet));
+          }
+        }
+        break;
+      }
+      case "functionCall":
+        for (const arg of n.args) walk(arg);
+        break;
+      case "binaryOp":
+        walk(n.left);
+        walk(n.right);
+        break;
+      case "unaryOp":
+        walk(n.operand);
+        break;
+    }
+  }
+  walk(node);
+  return deps;
+}
+var FormulaEngine = class {
+  constructor(config) {
+    this.formulas = /* @__PURE__ */ new Map();
+    this.parsedFormulas = /* @__PURE__ */ new Map();
+    this.values = /* @__PURE__ */ new Map();
+    this.depGraph = new DependencyGraph();
+    this.namedRanges = /* @__PURE__ */ new Map();
+    this.sheetAccessors = /* @__PURE__ */ new Map();
+    const builtIns = createBuiltInFunctions();
+    if (config?.customFunctions) {
+      for (const [name, fn] of Object.entries(config.customFunctions)) {
+        builtIns.set(name.toUpperCase(), fn);
+      }
+    }
+    if (config?.namedRanges) {
+      for (const [name, ref] of Object.entries(config.namedRanges)) {
+        this.namedRanges.set(name.toUpperCase(), ref);
+      }
+    }
+    this.evaluator = new FormulaEvaluator(builtIns);
+    this.maxChainLength = config?.maxChainLength ?? 1e3;
+  }
+  /**
+   * Set or clear a formula for a cell.
+   */
+  setFormula(col, row, formula, accessor) {
+    const key = toCellKey(col, row);
+    if (formula === null || formula === "") {
+      const oldValue2 = this.values.get(key);
+      this.formulas.delete(key);
+      this.parsedFormulas.delete(key);
+      this.values.delete(key);
+      this.depGraph.removeDependencies(key);
+      return {
+        updatedCells: oldValue2 !== void 0 ? [{ cellKey: key, col, row, oldValue: oldValue2, newValue: void 0 }] : []
+      };
+    }
+    const expression = formula.startsWith("=") ? formula.slice(1) : formula;
+    let ast;
+    try {
+      const tokens = tokenize(expression);
+      ast = parse(tokens, this.namedRanges);
+    } catch (err) {
+      const error = err instanceof FormulaError ? err : new FormulaError("#ERROR!", String(err));
+      ast = { kind: "error", error };
+    }
+    const deps = extractDependencies(ast);
+    if (deps.has(key) || this.depGraph.wouldCreateCycle(key, deps)) {
+      const oldValue2 = this.values.get(key);
+      const circError = new FormulaError("#CIRC!", "Circular reference detected");
+      this.formulas.set(key, formula);
+      this.parsedFormulas.set(key, ast);
+      this.values.set(key, circError);
+      this.depGraph.setDependencies(key, deps);
+      return {
+        updatedCells: [{ cellKey: key, col, row, oldValue: oldValue2, newValue: circError }]
+      };
+    }
+    this.depGraph.setDependencies(key, deps);
+    this.formulas.set(key, formula);
+    this.parsedFormulas.set(key, ast);
+    const oldValue = this.values.get(key);
+    const context = this.createContext(accessor);
+    const newValue = this.evaluator.evaluate(ast, context);
+    this.values.set(key, newValue);
+    const updatedCells = [
+      { cellKey: key, col, row, oldValue, newValue }
+    ];
+    const recalcOrder = this.depGraph.getRecalcOrder(key);
+    this.recalcCells(recalcOrder, accessor, updatedCells);
+    return { updatedCells };
+  }
+  /**
+   * Notify the engine that a non-formula cell's value changed.
+   */
+  onCellChanged(col, row, accessor) {
+    const key = toCellKey(col, row);
+    const recalcOrder = this.depGraph.getRecalcOrder(key);
+    if (recalcOrder.length === 0) return { updatedCells: [] };
+    const updatedCells = [];
+    this.recalcCells(recalcOrder, accessor, updatedCells);
+    return { updatedCells };
+  }
+  /**
+   * Batch notify: multiple cells changed.
+   */
+  onCellsChanged(cells, accessor) {
+    const keys = cells.map((c) => toCellKey(c.col, c.row));
+    const recalcOrder = this.depGraph.getRecalcOrderBatch(keys);
+    if (recalcOrder.length === 0) return { updatedCells: [] };
+    const updatedCells = [];
+    this.recalcCells(recalcOrder, accessor, updatedCells);
+    return { updatedCells };
+  }
+  /**
+   * Get the current computed value for a cell.
+   */
+  getValue(col, row) {
+    return this.values.get(toCellKey(col, row));
+  }
+  /**
+   * Get the formula string for a cell.
+   */
+  getFormula(col, row) {
+    return this.formulas.get(toCellKey(col, row));
+  }
+  /**
+   * Check if a cell has a formula.
+   */
+  hasFormula(col, row) {
+    return this.formulas.has(toCellKey(col, row));
+  }
+  /**
+   * Register a custom function at runtime.
+   */
+  registerFunction(name, fn) {
+    this.evaluator.registerFunction(name, fn);
+  }
+  /**
+   * Full recalculation of all formulas.
+   */
+  recalcAll(accessor) {
+    const updatedCells = [];
+    const context = this.createContext(accessor);
+    if (this.formulas.size === 0) return { updatedCells };
+    const allFormulaKeys = [];
+    for (const key of this.formulas.keys()) allFormulaKeys.push(key);
+    const recalcOrder = this.depGraph.getRecalcOrderBatch(allFormulaKeys);
+    const ordered = new Set(recalcOrder);
+    for (const key of allFormulaKeys) {
+      if (!ordered.has(key)) {
+        const { col, row } = fromCellKey(key);
+        const ast = this.parsedFormulas.get(key);
+        if (!ast) continue;
+        const oldValue = this.values.get(key);
+        const newValue = this.evaluator.evaluate(ast, context);
+        this.values.set(key, newValue);
+        updatedCells.push({ cellKey: key, col, row, oldValue, newValue });
+      }
+    }
+    this.recalcCells(recalcOrder, accessor, updatedCells);
+    return { updatedCells };
+  }
+  /**
+   * Clear all formulas and cached values.
+   */
+  clear() {
+    this.formulas.clear();
+    this.parsedFormulas.clear();
+    this.values.clear();
+    this.depGraph.clear();
+  }
+  /**
+   * Get all formula entries for serialization.
+   */
+  getAllFormulas() {
+    const result = [];
+    for (const [key, formula] of this.formulas) {
+      const { col, row } = fromCellKey(key);
+      result.push({ col, row, formula });
+    }
+    return result;
+  }
+  /**
+   * Bulk-load formulas. Recalculates everything.
+   */
+  loadFormulas(formulas, accessor) {
+    this.clear();
+    for (const { col, row, formula } of formulas) {
+      const key = toCellKey(col, row);
+      const expression = formula.startsWith("=") ? formula.slice(1) : formula;
+      let ast;
+      try {
+        const tokens = tokenize(expression);
+        ast = parse(tokens, this.namedRanges);
+      } catch (err) {
+        const error = err instanceof FormulaError ? err : new FormulaError("#ERROR!", String(err));
+        ast = { kind: "error", error };
+      }
+      this.formulas.set(key, formula);
+      this.parsedFormulas.set(key, ast);
+      const deps = extractDependencies(ast);
+      this.depGraph.setDependencies(key, deps);
+    }
+    return this.recalcAll(accessor);
+  }
+  // --- Named Ranges ---
+  /**
+   * Define a named range (e.g. "Revenue" → "A1:A10").
+   */
+  defineNamedRange(name, ref) {
+    this.namedRanges.set(name.toUpperCase(), ref);
+  }
+  /**
+   * Remove a named range by name.
+   */
+  removeNamedRange(name) {
+    this.namedRanges.delete(name.toUpperCase());
+  }
+  /**
+   * Get all named ranges as a Map (name → ref).
    */
-  redo() {
-    const nextBatch = this.redoStack.pop();
-    if (!nextBatch) return null;
-    this.history.push(nextBatch);
-    return nextBatch;
+  getNamedRanges() {
+    return this.namedRanges;
   }
+  // --- Sheet Accessors ---
   /**
-   * Clear all history and redo state.
-   * Does not affect any open batch — call endBatch() first if needed.
+   * Register a data accessor for a named sheet (for cross-sheet references).
    */
-  clear() {
-    this.history = [];
-    this.redoStack = [];
+  registerSheet(name, accessor) {
+    this.sheetAccessors.set(name, accessor);
   }
-};
-function validateColumns(columns) {
-  if (!Array.isArray(columns) || columns.length === 0) {
-    console.warn("[OGrid] columns prop is empty or not an array");
-    return;
+  /**
+   * Unregister a sheet accessor.
+   */
+  unregisterSheet(name) {
+    this.sheetAccessors.delete(name);
   }
-  const isDev = typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
-  const ids = /* @__PURE__ */ new Set();
-  for (const col of columns) {
-    if (!col.columnId) {
-      console.warn("[OGrid] Column missing columnId:", col);
+  // --- Formula Auditing ---
+  /**
+   * Get all cells that a cell depends on (deep, transitive precedents).
+   */
+  getPrecedents(col, row) {
+    const key = toCellKey(col, row);
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    const directDeps = this.depGraph.getDependencies(key);
+    for (const dep of directDeps) {
+      if (!visited.has(dep)) {
+        visited.add(dep);
+        queue.push(dep);
+      }
     }
-    if (ids.has(col.columnId)) {
-      console.warn(`[OGrid] Duplicate columnId: "${col.columnId}"`);
+    let head = 0;
+    while (head < queue.length) {
+      const current = queue[head++];
+      const parsed = fromCellKey(current);
+      result.push({
+        cellKey: current,
+        col: parsed.col,
+        row: parsed.row,
+        formula: this.formulas.get(current),
+        value: this.values.has(current) ? this.values.get(current) : void 0
+      });
+      const deps = this.depGraph.getDependencies(current);
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          queue.push(dep);
+        }
+      }
     }
-    ids.add(col.columnId);
-    if (isDev && col.editable === true && col.cellEditor == null) {
-      console.warn(
-        `[OGrid] Column "${col.columnId}" has editable=true but no cellEditor defined. Cells will not open an editor on double-click. Set cellEditor to 'text', 'select', 'checkbox', 'date', or a custom component.`
-      );
+    return result;
+  }
+  /**
+   * Get all cells that depend on this cell (deep, transitive dependents).
+   */
+  getDependents(col, row) {
+    const key = toCellKey(col, row);
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    const directDeps = this.depGraph.getDependents(key);
+    for (const dep of directDeps) {
+      if (!visited.has(dep)) {
+        visited.add(dep);
+        queue.push(dep);
+      }
+    }
+    let head = 0;
+    while (head < queue.length) {
+      const current = queue[head++];
+      const parsed = fromCellKey(current);
+      result.push({
+        cellKey: current,
+        col: parsed.col,
+        row: parsed.row,
+        formula: this.formulas.get(current),
+        value: this.values.has(current) ? this.values.get(current) : void 0
+      });
+      const deps = this.depGraph.getDependents(current);
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          queue.push(dep);
+        }
+      }
     }
+    return result;
   }
-}
-function validateVirtualScrollConfig(config) {
-  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") return;
-  if (config.enabled !== true) return;
-  if (!config.rowHeight || config.rowHeight <= 0) {
-    console.warn(
-      "[OGrid] virtualScroll.enabled is true but rowHeight is missing or <= 0. Set a positive rowHeight (e.g. virtualScroll: { enabled: true, rowHeight: 36 }) for correct virtual scrolling behavior."
-    );
+  /**
+   * Get a full audit trail for a cell: target + precedents + dependents.
+   */
+  getAuditTrail(col, row) {
+    const key = toCellKey(col, row);
+    const target = {
+      cellKey: key,
+      col,
+      row,
+      formula: this.formulas.get(key),
+      value: this.values.has(key) ? this.values.get(key) : void 0
+    };
+    return {
+      target,
+      precedents: this.getPrecedents(col, row),
+      dependents: this.getDependents(col, row)
+    };
   }
-}
-function validateRowIds(items, getRowId) {
-  if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
-  if (!getRowId) return;
-  const ids = /* @__PURE__ */ new Set();
-  const limit = Math.min(items.length, 100);
-  for (let i = 0; i < limit; i++) {
-    const id = getRowId(items[i]);
-    if (id == null) {
-      console.warn(`[OGrid] getRowId returned null/undefined for row ${i}`);
-      return;
-    }
-    if (ids.has(id)) {
-      console.warn(
-        `[OGrid] Duplicate row ID "${id}" at index ${i}. getRowId must return unique values.`
-      );
-      return;
+  // --- Private methods ---
+  createContext(accessor) {
+    const contextNow = /* @__PURE__ */ new Date();
+    return {
+      getCellValue: (addr) => {
+        const key = toCellKey(addr.col, addr.row, addr.sheet);
+        const cached = this.values.get(key);
+        if (cached !== void 0) return cached;
+        if (addr.sheet) {
+          const sheetAccessor = this.sheetAccessors.get(addr.sheet);
+          if (!sheetAccessor) return new FormulaError("#REF!", `Unknown sheet: ${addr.sheet}`);
+          return sheetAccessor.getCellValue(addr.col, addr.row);
+        }
+        return accessor.getCellValue(addr.col, addr.row);
+      },
+      getRangeValues: (range) => {
+        const result = [];
+        const sheet = range.start.sheet;
+        const rangeAccessor = sheet ? this.sheetAccessors.get(sheet) : accessor;
+        if (sheet && !rangeAccessor) {
+          return [[new FormulaError("#REF!", `Unknown sheet: ${sheet}`)]];
+        }
+        const minRow = Math.min(range.start.row, range.end.row);
+        const maxRow = Math.max(range.start.row, range.end.row);
+        const minCol = Math.min(range.start.col, range.end.col);
+        const maxCol = Math.max(range.start.col, range.end.col);
+        for (let r = minRow; r <= maxRow; r++) {
+          const row = [];
+          for (let c = minCol; c <= maxCol; c++) {
+            const key = toCellKey(c, r, sheet);
+            const cached = this.values.get(key);
+            if (cached !== void 0) {
+              row.push(cached);
+            } else {
+              row.push(rangeAccessor.getCellValue(c, r));
+            }
+          }
+          result.push(row);
+        }
+        return result;
+      },
+      now: () => contextNow
+    };
+  }
+  recalcCells(order, accessor, updatedCells) {
+    const context = this.createContext(accessor);
+    let count = 0;
+    for (const key of order) {
+      if (count++ > this.maxChainLength) {
+        const { col: col2, row: row2 } = fromCellKey(key);
+        const oldValue2 = this.values.get(key);
+        const circError = new FormulaError("#CIRC!", "Dependency chain too long");
+        this.values.set(key, circError);
+        updatedCells.push({ cellKey: key, col: col2, row: row2, oldValue: oldValue2, newValue: circError });
+        continue;
+      }
+      const ast = this.parsedFormulas.get(key);
+      if (!ast) continue;
+      const { col, row } = fromCellKey(key);
+      const oldValue = this.values.get(key);
+      const newValue = this.evaluator.evaluate(ast, context);
+      this.values.set(key, newValue);
+      updatedCells.push({ cellKey: key, col, row, oldValue, newValue });
     }
-    ids.add(id);
   }
-}
-var DEFAULT_DEBOUNCE_MS = 300;
-var PEOPLE_SEARCH_DEBOUNCE_MS = DEFAULT_DEBOUNCE_MS;
-var SIDEBAR_TRANSITION_MS = 300;
-var Z_INDEX = {
-  /** Column resize drag handle */
-  RESIZE_HANDLE: 1,
-  /** Active/editing cell outline */
-  ACTIVE_CELL: 2,
-  /** Fill handle dot */
-  FILL_HANDLE: 3,
-  /** Selection range overlay (marching ants) */
-  SELECTION_OVERLAY: 4,
-  /** Row number column */
-  ROW_NUMBER: 5,
-  /** Clipboard overlay (copy/cut animation) */
-  CLIPBOARD_OVERLAY: 5,
-  /** Sticky pinned body cells */
-  PINNED: 6,
-  /** Selection checkbox column in body */
-  SELECTION_CELL: 7,
-  /** Sticky thead row */
-  THEAD: 8,
-  /** Pinned header cells (sticky both axes) */
-  PINNED_HEADER: 10,
-  /** Focused header cell */
-  HEADER_FOCUS: 11,
-  /** Checkbox column in sticky header (sticky both axes) */
-  SELECTION_HEADER_PINNED: 12,
-  /** Loading overlay within table */
-  LOADING: 2,
-  /** Column reorder drop indicator */
-  DROP_INDICATOR: 100,
-  /** Dropdown menus (column chooser, pagination size select) */
-  DROPDOWN: 1e3,
-  /** Filter popovers */
-  FILTER_POPOVER: 1e3,
-  /** Modal dialogs */
-  MODAL: 2e3,
-  /** Fullscreen grid container */
-  FULLSCREEN: 9999,
-  /** Context menus (right-click grid menu) */
-  CONTEXT_MENU: 1e4
 };
 
 // src/utils/getCellCoordinates.ts
@@ -1643,6 +5284,8 @@ var GridState = class {
     // Guards against stale fetch responses
     this._abortController = null;
     this._firstDataRendered = false;
+    // Formula engine (optional — wired by OGrid when formulas option is enabled)
+    this._formulaEngine = null;
     // Filter options for client-side data (used by sidebar filters panel & header filter popovers)
     this._filterOptions = {};
     // Column display order (array of columnIds)
@@ -1667,6 +5310,7 @@ var GridState = class {
     this._ariaLabel = options.ariaLabel;
     this._stickyHeader = options.stickyHeader ?? true;
     this._fullScreen = options.fullScreen ?? false;
+    this._workerSort = options.workerSort ?? false;
     if (!this._dataSource) {
       this._filterOptions = deriveFilterOptionsFromData(
         this._data,
@@ -1770,6 +5414,31 @@ var GridState = class {
     const items = filtered.slice(startIdx, endIdx);
     return { items, totalCount };
   }
+  /** Whether worker sort should be used for the current data set. */
+  get useWorkerSort() {
+    return this._workerSort === true || this._workerSort === "auto" && this._data.length > 5e3;
+  }
+  /**
+   * Async version of getProcessedItems that offloads sort/filter to a Web Worker.
+   * Falls back to sync when worker sort is not active.
+   */
+  async getProcessedItemsAsync() {
+    if (this.isServerSide || !this.useWorkerSort) {
+      return this.getProcessedItems();
+    }
+    const filtered = await processClientSideDataAsync(
+      this._data,
+      this._columns,
+      this._filters,
+      this._sort?.field,
+      this._sort?.direction
+    );
+    const totalCount = filtered.length;
+    const startIdx = (this._page - 1) * this._pageSize;
+    const endIdx = startIdx + this._pageSize;
+    const items = filtered.slice(startIdx, endIdx);
+    return { items, totalCount };
+  }
   // --- Server-side fetch ---
   fetchServerData() {
     if (!this._dataSource) return;
@@ -1951,19 +5620,29 @@ var GridState = class {
       },
       getColumnOrder: () => [...this._columnOrder],
       setColumnOrder: (order) => this.setColumnOrder(order),
-      exportToCsv: (filename) => {
+      exportToCsv: (filename, options) => {
         const { items } = this.getProcessedItems();
         const cols = this.visibleColumnDefs.map((c) => ({ columnId: c.columnId, name: c.name }));
+        const formulaOptions = this._formulaEngine?.isEnabled() ? {
+          getFormula: this._formulaEngine.getFormula.bind(this._formulaEngine),
+          hasFormula: this._formulaEngine.hasFormula.bind(this._formulaEngine),
+          columnIdToIndex: new Map(this.visibleColumnDefs.map((c, i) => [c.columnId, i])),
+          exportMode: options?.exportMode ?? "values"
+        } : void 0;
         exportToCsv(items, cols, (item, colId) => {
           const col = this._columns.find((c) => c.columnId === colId);
           if (!col) return "";
           const val = getCellValue(item, col);
           if (col.valueFormatter) return col.valueFormatter(val, item);
           return val != null ? String(val) : "";
-        }, filename);
+        }, filename, formulaOptions);
       }
     };
   }
+  /** Wire in the formula engine so exportToCsv can use it. */
+  setFormulaEngine(engine) {
+    this._formulaEngine = engine;
+  }
   destroy() {
     if (this._abortController) {
       this._abortController.abort();
@@ -2159,6 +5838,9 @@ var TableRenderer = class {
     this.table = document.createElement("table");
     this.table.className = "ogrid-table";
     this.table.setAttribute("role", "grid");
+    if (this.virtualScrollState) {
+      this.table.setAttribute("data-virtual-scroll", "");
+    }
     this.thead = document.createElement("thead");
     if (this.state.stickyHeader) {
       this.thead.classList.add("ogrid-sticky-header");
@@ -2194,6 +5876,7 @@ var TableRenderer = class {
     parts.push(`allSel:${is?.allSelected ?? ""}`);
     parts.push(`someSel:${is?.someSelected ?? ""}`);
     parts.push(`rn:${is?.showRowNumbers ?? ""}`);
+    parts.push(`cl:${is?.showColumnLetters ?? ""}`);
     for (const [colId, config] of this.filterConfigs) {
       const hasActive = this.headerFilterState?.hasActiveFilter(config);
       if (hasActive) parts.push(`flt:${colId}`);
@@ -2395,6 +6078,30 @@ var TableRenderer = class {
     this.thead.innerHTML = "";
     const visibleCols = this.state.visibleColumnDefs;
     const hasCheckbox = this.hasCheckboxColumn();
+    const hasRowNumbers = this.hasRowNumbersColumn();
+    if (this.interactionState?.showColumnLetters) {
+      const letterTr = document.createElement("tr");
+      letterTr.className = "ogrid-column-letter-row";
+      if (hasCheckbox) {
+        const th = document.createElement("th");
+        th.className = "ogrid-column-letter-cell";
+        th.style.width = `${CHECKBOX_COLUMN_WIDTH}px`;
+        letterTr.appendChild(th);
+      }
+      if (hasRowNumbers) {
+        const th = document.createElement("th");
+        th.className = "ogrid-column-letter-cell";
+        th.style.width = `${ROW_NUMBER_COLUMN_WIDTH}px`;
+        letterTr.appendChild(th);
+      }
+      for (let colIdx = 0; colIdx < visibleCols.length; colIdx++) {
+        const th = document.createElement("th");
+        th.className = "ogrid-column-letter-cell";
+        th.textContent = indexToColumnLetter(colIdx);
+        letterTr.appendChild(th);
+      }
+      this.thead.appendChild(letterTr);
+    }
     const headerRows = buildHeaderRows(this.state.allColumns, this.state.visibleColumns);
     if (headerRows.length > 1) {
       for (const row of headerRows) {
@@ -2571,6 +6278,23 @@ var TableRenderer = class {
         this.tbody.appendChild(topSpacer);
       }
     }
+    const colVirtActive = vs?.columnVirtualizationEnabled === true && vs.columnRange != null;
+    let renderCols = visibleCols;
+    let colGlobalIndexMap = null;
+    let colLeftSpacerWidth = 0;
+    let colRightSpacerWidth = 0;
+    if (colVirtActive && vs) {
+      const partition = partitionColumnsForVirtualization(
+        visibleCols,
+        vs.columnRange,
+        this.interactionState?.pinnedColumns
+      );
+      const combined = [...partition.pinnedLeft, ...partition.virtualizedUnpinned, ...partition.pinnedRight];
+      colGlobalIndexMap = combined.map((c) => visibleCols.indexOf(c));
+      renderCols = combined;
+      colLeftSpacerWidth = partition.leftSpacerWidth;
+      colRightSpacerWidth = partition.rightSpacerWidth;
+    }
     for (let rowIndex = startIndex; rowIndex <= endIndex; rowIndex++) {
       const item = items[rowIndex];
       if (!item) continue;
@@ -2610,9 +6334,18 @@ var TableRenderer = class {
         td.textContent = String(rowNumberOffset + rowIndex + 1);
         tr.appendChild(td);
       }
-      for (let colIndex = 0; colIndex < visibleCols.length; colIndex++) {
-        const col = visibleCols[colIndex];
-        const globalColIndex = colIndex + colOffset;
+      if (colLeftSpacerWidth > 0) {
+        const spacerTd = document.createElement("td");
+        spacerTd.style.width = `${colLeftSpacerWidth}px`;
+        spacerTd.style.minWidth = `${colLeftSpacerWidth}px`;
+        spacerTd.style.padding = "0";
+        spacerTd.style.border = "none";
+        spacerTd.setAttribute("aria-hidden", "true");
+        tr.appendChild(spacerTd);
+      }
+      for (let colIndex = 0; colIndex < renderCols.length; colIndex++) {
+        const col = renderCols[colIndex];
+        const globalColIndex = (colGlobalIndexMap ? colGlobalIndexMap[colIndex] : colIndex) + colOffset;
         const td = document.createElement("td");
         td.className = "ogrid-cell";
         td.setAttribute("data-column-id", col.columnId);
@@ -2680,6 +6413,15 @@ var TableRenderer = class {
         }
         tr.appendChild(td);
       }
+      if (colRightSpacerWidth > 0) {
+        const spacerTd = document.createElement("td");
+        spacerTd.style.width = `${colRightSpacerWidth}px`;
+        spacerTd.style.minWidth = `${colRightSpacerWidth}px`;
+        spacerTd.style.padding = "0";
+        spacerTd.style.border = "none";
+        spacerTd.setAttribute("aria-hidden", "true");
+        tr.appendChild(spacerTd);
+      }
       this.tbody.appendChild(tr);
     }
     if (isVirtual && vs) {
@@ -4026,6 +7768,14 @@ var VirtualScrollState = class {
     this._ro = null;
     this._resizeRafId = 0;
     this._cachedRange = { startIndex: 0, endIndex: -1, offsetTop: 0, offsetBottom: 0 };
+    // Column virtualization
+    this._scrollLeft = 0;
+    this._scrollLeftRafId = 0;
+    this._containerWidth = 0;
+    this._columnWidths = [];
+    this._cachedColumnRange = null;
+    this._roWidth = null;
+    this._resizeWidthRafId = 0;
     this._config = config ?? { enabled: false };
     validateVirtualScrollConfig(this._config);
   }
@@ -4054,6 +7804,71 @@ var VirtualScrollState = class {
   get totalHeight() {
     return computeTotalHeight(this._totalRows, this._config.rowHeight ?? DEFAULT_ROW_HEIGHT);
   }
+  /** Whether column virtualization is active. */
+  get columnVirtualizationEnabled() {
+    return this._config.columns === true;
+  }
+  /** Get the current visible column range (null when column virtualization is disabled). */
+  get columnRange() {
+    return this._cachedColumnRange;
+  }
+  /** Set the unpinned column widths for horizontal virtualization. */
+  setColumnWidths(widths) {
+    this._columnWidths = widths;
+    this.recomputeColumnRange();
+  }
+  /** Handle horizontal scroll events. RAF-throttled. */
+  handleHorizontalScroll(scrollLeft) {
+    if (!this.columnVirtualizationEnabled) return;
+    if (this._scrollLeftRafId) cancelAnimationFrame(this._scrollLeftRafId);
+    this._scrollLeftRafId = requestAnimationFrame(() => {
+      this._scrollLeftRafId = 0;
+      this._scrollLeft = scrollLeft;
+      this.recomputeColumnRange();
+    });
+  }
+  /** Observe a container element for width changes (column virtualization). */
+  observeContainerWidth(el) {
+    this.disconnectWidthObserver();
+    if (typeof ResizeObserver !== "undefined") {
+      this._roWidth = new ResizeObserver((entries) => {
+        if (entries.length === 0) return;
+        this._containerWidth = entries[0].contentRect.width;
+        if (this._resizeWidthRafId) cancelAnimationFrame(this._resizeWidthRafId);
+        this._resizeWidthRafId = requestAnimationFrame(() => {
+          this._resizeWidthRafId = 0;
+          this.recomputeColumnRange();
+        });
+      });
+      this._roWidth.observe(el);
+    }
+    this._containerWidth = el.clientWidth;
+  }
+  disconnectWidthObserver() {
+    if (this._roWidth) {
+      this._roWidth.disconnect();
+      this._roWidth = null;
+    }
+  }
+  /** Recompute visible column range and emit if changed. */
+  recomputeColumnRange() {
+    if (!this.columnVirtualizationEnabled || this._columnWidths.length === 0 || this._containerWidth <= 0) {
+      if (this._cachedColumnRange !== null) {
+        this._cachedColumnRange = null;
+        this.emitter.emit("columnRangeChanged", { columnRange: null });
+      }
+      return;
+    }
+    const overscan = this._config.columnOverscan ?? 2;
+    const newRange = computeVisibleColumnRange(this._scrollLeft, this._columnWidths, this._containerWidth, overscan);
+    const prev = this._cachedColumnRange;
+    if (!prev || prev.startIndex !== newRange.startIndex || prev.endIndex !== newRange.endIndex) {
+      this._cachedColumnRange = newRange;
+      this.emitter.emit("columnRangeChanged", { columnRange: newRange });
+    } else {
+      this._cachedColumnRange = newRange;
+    }
+  }
   /** Handle scroll events from the table container. RAF-throttled. */
   handleScroll(scrollTop) {
     if (this.rafId) cancelAnimationFrame(this.rafId);
@@ -4130,6 +7945,10 @@ var VirtualScrollState = class {
     this.emitter.on("rangeChanged", handler);
     return () => this.emitter.off("rangeChanged", handler);
   }
+  onColumnRangeChanged(handler) {
+    this.emitter.on("columnRangeChanged", handler);
+    return () => this.emitter.off("columnRangeChanged", handler);
+  }
   onConfigChanged(handler) {
     this.emitter.on("configChanged", handler);
     return () => this.emitter.off("configChanged", handler);
@@ -4137,7 +7956,10 @@ var VirtualScrollState = class {
   destroy() {
     if (this.rafId) cancelAnimationFrame(this.rafId);
     if (this._resizeRafId) cancelAnimationFrame(this._resizeRafId);
+    if (this._scrollLeftRafId) cancelAnimationFrame(this._scrollLeftRafId);
+    if (this._resizeWidthRafId) cancelAnimationFrame(this._resizeWidthRafId);
     this.disconnectObserver();
+    this.disconnectWidthObserver();
     this.emitter.removeAllListeners();
   }
 };
@@ -4261,7 +8083,7 @@ var KeyboardNavState = class {
       const maxColIndex = visibleCols.length - 1 + colOffset;
       if (items.length === 0) return;
       if (activeCell === null) {
-        if (["ArrowDown", "ArrowUp", "ArrowLeft", "ArrowRight", "Tab", "Enter", "Home", "End"].includes(e.key)) {
+        if (["ArrowDown", "ArrowUp", "ArrowLeft", "ArrowRight", "Tab", "Enter", "Home", "End", "PageDown", "PageUp"].includes(e.key)) {
           this.setActiveCell({ rowIndex: 0, columnIndex: colOffset });
           e.preventDefault();
         }
@@ -4362,6 +8184,43 @@ var KeyboardNavState = class {
           });
           break;
         }
+        case "PageDown":
+        case "PageUp": {
+          e.preventDefault();
+          const wrapper = this.wrapperRef;
+          let pageSize = 10;
+          let rowHeight = 36;
+          if (wrapper) {
+            const firstRow = wrapper.querySelector("tbody tr");
+            if (firstRow && firstRow.offsetHeight > 0) {
+              rowHeight = firstRow.offsetHeight;
+              pageSize = Math.max(1, Math.floor(wrapper.clientHeight / rowHeight));
+            }
+          }
+          const pgDirection = e.key === "PageDown" ? 1 : -1;
+          const newRowPage = Math.max(0, Math.min(rowIndex + pgDirection * pageSize, maxRowIndex));
+          const pgShift = e.shiftKey;
+          if (pgShift) {
+            this.setSelectionRange({
+              startRow: selectionRange?.startRow ?? rowIndex,
+              startCol: selectionRange?.startCol ?? dataColIndex,
+              endRow: newRowPage,
+              endCol: selectionRange?.endCol ?? dataColIndex
+            });
+          } else {
+            this.setSelectionRange({
+              startRow: newRowPage,
+              startCol: dataColIndex,
+              endRow: newRowPage,
+              endCol: dataColIndex
+            });
+          }
+          this.setActiveCell({ rowIndex: newRowPage, columnIndex });
+          if (wrapper) {
+            wrapper.scrollTop = getScrollTopForRow(newRowPage, rowHeight, wrapper.clientHeight, "center");
+          }
+          break;
+        }
         case "Enter":
         case "F2": {
           e.preventDefault();
@@ -4492,8 +8351,9 @@ var ClipboardState = class {
     const range = this.getEffectiveRange();
     if (range == null) return;
     const norm = normalizeSelectionRange(range);
-    const { items, visibleCols } = this.params;
-    const tsv = formatSelectionAsTsv(items, visibleCols, norm);
+    const { items, visibleCols, formulas, flatColumns, getFormula, hasFormula, colOffset } = this.params;
+    const formulaOptions = formulas && flatColumns ? { colOffset, flatColumns, getFormula, hasFormula } : void 0;
+    const tsv = formatSelectionAsTsv(items, visibleCols, norm, formulaOptions);
     this.internalClipboard = tsv;
     this._copyRange = norm;
     this._cutRange = null;
@@ -4536,9 +8396,10 @@ var ClipboardState = class {
     const norm = this.getEffectiveRange();
     const anchorRow = norm ? norm.startRow : 0;
     const anchorCol = norm ? norm.startCol : 0;
-    const { items, visibleCols } = this.params;
+    const { items, visibleCols, formulas, flatColumns, setFormula, colOffset } = this.params;
+    const formulaOptions = formulas && flatColumns ? { colOffset, flatColumns, setFormula } : void 0;
     const parsedRows = parseTsvClipboard(text);
-    const pasteEvents = applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols);
+    const pasteEvents = applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols, formulaOptions);
     for (const evt of pasteEvents) onCellValueChanged(evt);
     if (this._cutRange) {
       const cutEvents = applyCutClear(this._cutRange, items, visibleCols);
@@ -4792,9 +8653,9 @@ var FillHandleState = class {
     this.emitter.emit("fillRangeChange", { fillRange: null });
   }
   applyFillValuesFromCore(norm, start) {
-    const { items, visibleCols, onCellValueChanged, beginBatch, endBatch } = this.params;
+    const { items, visibleCols, onCellValueChanged, beginBatch, endBatch, formulaOptions } = this.params;
     if (!onCellValueChanged) return;
-    const fillEvents = applyFillValues(norm, start.startRow, start.startCol, items, visibleCols);
+    const fillEvents = applyFillValues(norm, start.startRow, start.startCol, items, visibleCols, formulaOptions);
     if (fillEvents.length > 0) {
       beginBatch?.();
       for (const evt of fillEvents) onCellValueChanged(evt);
@@ -5260,6 +9121,8 @@ var InlineCellEditor = class {
         e.stopPropagation();
         this.onCancel?.();
         this.closeEditor();
+      } else if ((e.ctrlKey || e.metaKey) && ["c", "x", "v", "a", "z", "y"].includes(e.key)) {
+        e.stopPropagation();
       }
     });
     input.addEventListener("blur", () => {
@@ -5268,7 +9131,16 @@ var InlineCellEditor = class {
       }
       this.closeEditor();
     });
-    setTimeout(() => input.select(), 0);
+    if (type === "date") {
+      setTimeout(() => {
+        try {
+          input.showPicker();
+        } catch {
+        }
+      }, 0);
+    } else {
+      setTimeout(() => input.select(), 0);
+    }
     return input;
   }
   createTextEditor(value) {
@@ -5346,6 +9218,7 @@ var InlineCellEditor = class {
     dropdown.style.border = "1px solid var(--ogrid-border, rgba(0, 0, 0, 0.12))";
     dropdown.style.zIndex = "1001";
     dropdown.style.boxShadow = "0 4px 16px rgba(0,0,0,0.2)";
+    dropdown.style.textAlign = "left";
     wrapper.appendChild(dropdown);
     let highlightedIndex = Math.max(values.findIndex((v) => String(v) === String(value)), 0);
     const buildOptions = () => {
@@ -5463,6 +9336,7 @@ var InlineCellEditor = class {
     dropdown.style.backgroundColor = "var(--ogrid-bg, #fff)";
     dropdown.style.border = "1px solid var(--ogrid-border, rgba(0, 0, 0, 0.12))";
     dropdown.style.zIndex = "1001";
+    dropdown.style.textAlign = "left";
     wrapper.appendChild(dropdown);
     const values = column.cellEditorParams?.values ?? [];
     const formatValue = column.cellEditorParams?.formatValue ?? ((v) => String(v));
@@ -5510,6 +9384,8 @@ var InlineCellEditor = class {
         e.stopPropagation();
         this.onCancel?.();
         this.closeEditor();
+      } else if ((e.ctrlKey || e.metaKey) && ["c", "x", "v", "a", "z", "y"].includes(e.key)) {
+        e.stopPropagation();
       }
     });
     input.addEventListener("blur", (e) => {
@@ -5919,7 +9795,11 @@ var OGridRendering = class {
       allSelected: rowSelectionState?.isAllSelected(items),
       someSelected: rowSelectionState?.isSomeSelected(items),
       // Row numbers
-      showRowNumbers: options.showRowNumbers,
+      showRowNumbers: options.showRowNumbers || options.cellReferences,
+      // Column letters
+      showColumnLetters: !!options.cellReferences,
+      // Name box
+      showNameBox: !!options.cellReferences,
       // Column pinning
       pinnedColumns: pinningState?.pinnedColumns,
       leftOffsets,
@@ -6258,6 +10138,7 @@ var OGrid = class {
     this.unsubscribes = [];
     this.isFullScreen = false;
     this.fullscreenBtn = null;
+    this.nameBoxEl = null;
     this.options = options;
     this.state = new GridState(options);
     this.api = this.state.getApi();
@@ -6269,6 +10150,13 @@ var OGrid = class {
     this.toolbarEl.className = "ogrid-toolbar";
     const toolbarSpacer = document.createElement("div");
     this.toolbarEl.appendChild(toolbarSpacer);
+    if (options.cellReferences) {
+      this.nameBoxEl = document.createElement("div");
+      this.nameBoxEl.className = "ogrid-name-box";
+      this.nameBoxEl.style.cssText = "display:inline-flex;align-items:center;padding:0 8px;font-family:'Consolas','Courier New',monospace;font-size:12px;border:1px solid var(--ogrid-border, rgba(0,0,0,0.12));border-radius:3px;height:24px;margin-right:8px;background:var(--ogrid-bg, #fff);min-width:40px;color:var(--ogrid-fg-secondary, rgba(0,0,0,0.6));";
+      this.nameBoxEl.textContent = "\u2014";
+      toolbarSpacer.appendChild(this.nameBoxEl);
+    }
     if (options.fullScreen) {
       const toolbarRight = document.createElement("div");
       toolbarRight.style.display = "flex";
@@ -6405,6 +10293,24 @@ var OGrid = class {
         this.cellEditor = result.cellEditor;
         this.contextMenu = result.contextMenu;
         this.unsubscribes.push(...result.unsubscribes);
+        if (this.nameBoxEl && this.selectionState) {
+          const nameBox = this.nameBoxEl;
+          const sel = this.selectionState;
+          let colOffset = 0;
+          if (this.rowSelectionState) colOffset++;
+          if (options.showRowNumbers || options.cellReferences) colOffset++;
+          this.unsubscribes.push(
+            sel.onSelectionChange(({ activeCell }) => {
+              if (activeCell) {
+                const dataColIndex = activeCell.columnIndex - colOffset;
+                const rowNumber = (this.state.page - 1) * this.state.pageSize + activeCell.rowIndex + 1;
+                nameBox.textContent = formatCellReference(dataColIndex, rowNumber);
+              } else {
+                nameBox.textContent = "\u2014";
+              }
+            })
+          );
+        }
       }
       this.unsubscribes.push(
         this.state.onStateChange(() => {
@@ -6427,16 +10333,25 @@ var OGrid = class {
         this.renderer.setVirtualScrollState(this.virtualScrollState);
         const handleScroll = () => {
           this.virtualScrollState?.handleScroll(this.tableContainer.scrollTop);
+          this.virtualScrollState?.handleHorizontalScroll(this.tableContainer.scrollLeft);
         };
         this.tableContainer.addEventListener("scroll", handleScroll, { passive: true });
         this.unsubscribes.push(() => {
           this.tableContainer.removeEventListener("scroll", handleScroll);
         });
+        if (options.virtualScroll?.columns) {
+          this.virtualScrollState.observeContainerWidth(this.tableContainer);
+        }
         this.unsubscribes.push(
           this.virtualScrollState.onRangeChanged(() => {
             this.renderingHelper.updateRendererInteractionState();
           })
         );
+        this.unsubscribes.push(
+          this.virtualScrollState.onColumnRangeChanged(() => {
+            this.renderingHelper.updateRendererInteractionState();
+          })
+        );
         this.api.scrollToRow = (index, opts) => {
           this.virtualScrollState?.scrollToRow(index, this.tableContainer, opts?.align);
         };
@@ -6679,4 +10594,118 @@ var OGrid = class {
   }
 };
 
-export { AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, COLUMN_HEADER_MENU_ITEMS, CellDescriptorCache, ClipboardState, ColumnChooser, ColumnPinningState, ColumnReorderState, ColumnResizeState, ContextMenu, DEFAULT_DEBOUNCE_MS, DEFAULT_MIN_COLUMN_WIDTH, EventEmitter, FillHandleState, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, GridState, HeaderFilter, HeaderFilterState, InlineCellEditor, KeyboardNavState, MAX_PAGE_BUTTONS, MarchingAntsOverlay, OGrid, OGridEventWiring, OGridRendering, PAGE_SIZE_OPTIONS, PEOPLE_SEARCH_DEBOUNCE_MS, PaginationControls, ROW_NUMBER_COLUMN_WIDTH, RowSelectionState, SIDEBAR_TRANSITION_MS, SelectionState, SideBar, SideBarState, StatusBar, TableLayoutState, TableRenderer, UndoRedoStack, UndoRedoState, VirtualScrollState, Z_INDEX, applyCellDeletion, applyCutClear, applyFillValues, applyPastedValues, applyRangeRowSelection, areGridRowPropsEqual, booleanParser, buildCellIndex, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps, buildPopoverEditorProps, calculateDropTarget, clampSelectionToBounds, computeAggregations, computeArrowNavigation, computeAutoScrollSpeed, computeNextSortState, computeRowSelectionState, computeTabNavigation, computeTotalHeight, computeVisibleRange, currencyParser, dateParser, debounce, deriveFilterOptionsFromData, emailParser, escapeCsvValue, exportToCsv, findCtrlArrowTarget, flattenColumns, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, getCellRenderDescriptor, getCellValue, getColumnHeaderMenuItems, getContextMenuHandlers, getDataGridStatusBarConfig, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getPinStateForColumn, getScrollTopForRow, getStatusBarParts, injectGlobalStyles, isColumnEditable, isFilterConfig, isInSelectionRange, isRowInRange, measureColumnContentWidth, measureRange, mergeFilter, normalizeSelectionRange, numberParser, parseTsvClipboard, parseValue, processClientSideData, rangesEqual, reorderColumnArray, resolveCellDisplayContent, resolveCellStyle, toUserLike, triggerCsvDownload, validateColumns, validateRowIds, validateVirtualScrollConfig };
+// src/state/FormulaEngineState.ts
+var FormulaEngineState = class {
+  constructor(options) {
+    this.emitter = new EventEmitter();
+    this.engine = null;
+    this.options = options;
+    if (options.formulas) {
+      this.engine = new FormulaEngine({
+        customFunctions: options.formulaFunctions,
+        namedRanges: options.namedRanges
+      });
+      if (options.sheets) {
+        for (const [name, accessor] of Object.entries(options.sheets)) {
+          this.engine.registerSheet(name, accessor);
+        }
+      }
+    }
+  }
+  /**
+   * Initialize with an accessor — loads `initialFormulas` if provided.
+   * Must be called after the grid data is available so the accessor is valid.
+   */
+  initialize(accessor) {
+    if (!this.engine || !this.options.initialFormulas?.length) return;
+    const result = this.engine.loadFormulas(this.options.initialFormulas, accessor);
+    if (result.updatedCells.length > 0) {
+      this.emitRecalc(result);
+    }
+  }
+  /**
+   * Set or clear a formula for a cell. Triggers recalculation of dependents
+   * and emits `formulaRecalc`.
+   */
+  setFormula(col, row, formula, accessor) {
+    if (!this.engine) return void 0;
+    const result = this.engine.setFormula(col, row, formula, accessor);
+    if (result.updatedCells.length > 0) {
+      this.emitRecalc(result);
+    }
+    return result;
+  }
+  /**
+   * Notify the engine that a non-formula cell's value changed.
+   * Triggers recalculation of any formulas that depend on the changed cell.
+   */
+  onCellChanged(col, row, accessor) {
+    if (!this.engine) return void 0;
+    const result = this.engine.onCellChanged(col, row, accessor);
+    if (result.updatedCells.length > 0) {
+      this.emitRecalc(result);
+    }
+    return result;
+  }
+  /** Get the computed value for a formula cell (or undefined if no formula). */
+  getValue(col, row) {
+    return this.engine?.getValue(col, row);
+  }
+  /** Check if a cell has a formula. */
+  hasFormula(col, row) {
+    return this.engine?.hasFormula(col, row) ?? false;
+  }
+  /** Get the formula string for a cell (or undefined if no formula). */
+  getFormula(col, row) {
+    return this.engine?.getFormula(col, row);
+  }
+  /** Whether the formula engine is active. */
+  isEnabled() {
+    return this.engine !== null;
+  }
+  /** Define a named range. */
+  defineNamedRange(name, ref) {
+    this.engine?.defineNamedRange(name, ref);
+  }
+  /** Remove a named range. */
+  removeNamedRange(name) {
+    this.engine?.removeNamedRange(name);
+  }
+  /** Register a sheet accessor for cross-sheet references. */
+  registerSheet(name, accessor) {
+    this.engine?.registerSheet(name, accessor);
+  }
+  /** Unregister a sheet accessor. */
+  unregisterSheet(name) {
+    this.engine?.unregisterSheet(name);
+  }
+  /** Get all cells that a cell depends on (deep, transitive). */
+  getPrecedents(col, row) {
+    return this.engine?.getPrecedents(col, row) ?? [];
+  }
+  /** Get all cells that depend on a cell (deep, transitive). */
+  getDependents(col, row) {
+    return this.engine?.getDependents(col, row) ?? [];
+  }
+  /** Get full audit trail for a cell. */
+  getAuditTrail(col, row) {
+    return this.engine?.getAuditTrail(col, row) ?? null;
+  }
+  /** Subscribe to the `formulaRecalc` event. Returns an unsubscribe function. */
+  onFormulaRecalc(handler) {
+    this.emitter.on("formulaRecalc", handler);
+    return () => this.emitter.off("formulaRecalc", handler);
+  }
+  /** Clean up all listeners. */
+  destroy() {
+    this.engine = null;
+    this.emitter.removeAllListeners();
+  }
+  // --- Private ---
+  emitRecalc(result) {
+    this.options.onFormulaRecalc?.(result);
+    this.emitter.emit("formulaRecalc", result);
+  }
+};
+
+export { AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, CIRC_ERROR, COLUMN_HEADER_MENU_ITEMS, CellDescriptorCache, ClipboardState, ColumnChooser, ColumnPinningState, ColumnReorderState, ColumnResizeState, ContextMenu, DEFAULT_DEBOUNCE_MS, DEFAULT_MIN_COLUMN_WIDTH, DIV_ZERO_ERROR, DependencyGraph, EventEmitter, FillHandleState, FormulaEngine, FormulaEngineState, FormulaError, FormulaEvaluator, GENERAL_ERROR, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, GridState, HeaderFilter, HeaderFilterState, InlineCellEditor, KeyboardNavState, MAX_PAGE_BUTTONS, MarchingAntsOverlay, NAME_ERROR, NA_ERROR, OGrid, OGridEventWiring, OGridRendering, PAGE_SIZE_OPTIONS, PEOPLE_SEARCH_DEBOUNCE_MS, PaginationControls, REF_ERROR, ROW_NUMBER_COLUMN_WIDTH, RowSelectionState, SIDEBAR_TRANSITION_MS, SelectionState, SideBar, SideBarState, StatusBar, TableLayoutState, TableRenderer, UndoRedoStack, UndoRedoState, VALUE_ERROR, VirtualScrollState, Z_INDEX, adjustFormulaReferences, applyCellDeletion, applyCutClear, applyFillValues, applyPastedValues, applyRangeRowSelection, areGridRowPropsEqual, booleanParser, buildCellIndex, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps, buildPopoverEditorProps, calculateDropTarget, clampSelectionToBounds, columnLetterToIndex, computeAggregations, computeArrowNavigation, computeAutoScrollSpeed, computeNextSortState, computeRowSelectionState, computeTabNavigation, computeTotalHeight, computeVisibleColumnRange, computeVisibleRange, createBuiltInFunctions, createSortFilterWorker, currencyParser, dateParser, debounce, deriveFilterOptionsFromData, emailParser, escapeCsvValue, exportToCsv, extractValueMatrix, findCtrlArrowTarget, flattenArgs, flattenColumns, formatAddress, formatCellReference, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, toString as formulaToString, fromCellKey, getCellRenderDescriptor, getCellValue, getColumnHeaderMenuItems, getContextMenuHandlers, getDataGridStatusBarConfig, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getPinStateForColumn, getScrollTopForRow, getStatusBarParts, indexToColumnLetter, injectGlobalStyles, isColumnEditable, isFilterConfig, isFormulaError, isInSelectionRange, isRowInRange, measureColumnContentWidth, measureRange, mergeFilter, normalizeSelectionRange, numberParser, parse, parseCellRef, parseRange, parseTsvClipboard, parseValue, partitionColumnsForVirtualization, processClientSideData, processClientSideDataAsync, rangesEqual, reorderColumnArray, resolveCellDisplayContent, resolveCellStyle, terminateSortFilterWorker, toBoolean, toCellKey, toNumber, toUserLike, tokenize, triggerCsvDownload, validateColumns, validateRowIds, validateVirtualScrollConfig };