juxscript 1.1.239 → 1.1.243

package/lib/storage/TabularDriver.ts

@@ -1,874 +0,0 @@
-import { DataFrame } from './DataFrame.js';
-
-export interface StoredTable {
-    id: string;
-    name: string;
-    columns: string[];
-    rows: any[][];
-    rowCount: number;
-    delimiter: string;
-    timestamp: number;
-    metadata?: Record<string, any>;
-}
-
-export interface ParseOptions {
-    delimiter?: string;
-    hasHeader?: boolean;
-    chunkSize?: number;
-    onProgress?: (parsed: number, total: number | null) => void;
-    maxRows?: number;
-    skipRows?: number;
-    columns?: string[];
-    sheet?: string | number;
-    maxSheetSize?: number; // ✅ NEW: Max rows per sheet to prevent memory issues
-    sheetChunkSize?: number; // ✅ NEW: Process Excel in chunks
-    headerRow?: number; // ✅ NEW: Which row contains headers (default: 0)
-    autoDetectDelimiter?: boolean; // ✅ NEW: Auto-detect delimiter from first lines
-}
-
-export class TabularDriver {
-    private _dbName: string;
-    private _storeName: string;
-    private _db: IDBDatabase | null = null;
-
-    constructor(dbName: string = 'jux-tabular', storeName: string = 'tables') {
-        this._dbName = dbName;
-        this._storeName = storeName;
-    }
-
-    async open(): Promise<IDBDatabase> {
-        if (this._db) return this._db;
-
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open(this._dbName, 1);
-
-            request.onupgradeneeded = (e) => {
-                const db = (e.target as IDBOpenDBRequest).result;
-                if (!db.objectStoreNames.contains(this._storeName)) {
-                    const store = db.createObjectStore(this._storeName, { keyPath: 'id' });
-                    store.createIndex('name', 'name', { unique: false });
-                    store.createIndex('timestamp', 'timestamp', { unique: false });
-                }
-            };
-
-            request.onsuccess = (e) => {
-                this._db = (e.target as IDBOpenDBRequest).result;
-                resolve(this._db);
-            };
-
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * CSV / TSV PARSING
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * ✅ NEW: Auto-detect delimiter from first N lines of CSV
-     * Checks for: , | \t ;
-     */
-    private _detectDelimiter(text: string, sampleLines: number = 5): string {
-        const lines = this._splitLines(text).slice(0, sampleLines).filter(l => l.trim());
-        if (lines.length === 0) return ',';
-
-        const delimiters = [',', '|', '\t', ';'];
-        const scores: Record<string, number> = {};
-
-        delimiters.forEach(delim => {
-            const counts = lines.map(line => {
-                // Count occurrences of delimiter NOT inside quotes
-                let count = 0;
-                let inQuotes = false;
-                for (let i = 0; i < line.length; i++) {
-                    if (line[i] === '"') inQuotes = !inQuotes;
-                    if (!inQuotes && line[i] === delim) count++;
-                }
-                return count;
-            });
-
-            // Delimiter should have consistent count across lines
-            const avg = counts.reduce((sum, c) => sum + c, 0) / counts.length;
-            const variance = counts.reduce((sum, c) => sum + Math.pow(c - avg, 2), 0) / counts.length;
-
-            // Score: high count, low variance
-            scores[delim] = avg > 0 ? avg / (1 + variance) : 0;
-        });
-
-        // Return delimiter with highest score
-        const best = Object.entries(scores).sort((a, b) => b[1] - a[1])[0];
-        return best[0];
-    }
-
-    /**
-     * ✅ NEW: Detect which row contains the header
-     * Looks for first row with mostly string values
-     */
-    private _detectHeaderRow(text: string, delimiter: string, maxCheck: number = 10): number {
-        const lines = this._splitLines(text).slice(0, maxCheck).filter(l => l.trim());
-
-        for (let i = 0; i < lines.length; i++) {
-            const values = this._parseLine(lines[i], delimiter);
-
-            // Skip if mostly empty
-            const nonEmpty = values.filter(v => v.trim()).length;
-            if (nonEmpty < values.length * 0.5) continue;
-
-            // Check if mostly non-numeric (likely headers)
-            const nonNumeric = values.filter(v => {
-                const trimmed = v.trim();
-                return isNaN(Number(trimmed)) && trimmed !== '';
-            }).length;
-
-            if (nonNumeric >= values.length * 0.7) {
-                return i;
-            }
-        }
-
-        return 0; // Fallback to first row
-    }
-
-    /**
-     * Parse a CSV/TSV string into a DataFrame
-     */
-    parseCSV(text: string, options: ParseOptions = {}): DataFrame {
-        const {
-            delimiter: userDelimiter,
-            hasHeader = true,
-            maxRows,
-            skipRows: userSkipRows = 0,
-            columns: selectCols,
-            headerRow: userHeaderRow,
-            autoDetectDelimiter = true
-        } = options;
-
-        // ✅ Auto-detect delimiter if not provided
-        const delimiter = userDelimiter || (autoDetectDelimiter ? this._detectDelimiter(text) : ',');
-
-        // ✅ Auto-detect header row if not provided
-        const headerRow = userHeaderRow !== undefined ? userHeaderRow : (hasHeader ? this._detectHeaderRow(text, delimiter) : -1);
-
-        const lines = this._splitLines(text);
-        let headers: string[];
-
-        // Skip rows before header
-        let startIdx = userSkipRows;
-
-        if (hasHeader && headerRow >= 0) {
-            const headerLine = lines[headerRow + userSkipRows];
-            if (headerLine) {
-                headers = this._parseLine(headerLine, delimiter);
-                startIdx = headerRow + userSkipRows + 1;
-            } else {
-                const firstLine = this._parseLine(lines[startIdx] || '', delimiter);
-                headers = firstLine.map((_, i) => `col_${i}`);
-            }
-        } else {
-            const firstLine = this._parseLine(lines[startIdx] || '', delimiter);
-            headers = firstLine.map((_, i) => `col_${i}`);
-        }
-
-        const rows: Record<string, any>[] = [];
-        const end = maxRows ? Math.min(startIdx + maxRows, lines.length) : lines.length;
-
-        for (let i = startIdx; i < end; i++) {
-            if (!lines[i].trim()) continue;
-            const values = this._parseLine(lines[i], delimiter);
-            const row: Record<string, any> = {};
-
-            headers.forEach((h, j) => {
-                row[h] = this._autoType(values[j]);
-            });
-
-            rows.push(row);
-        }
-
-        let df = new DataFrame(rows);
-
-        if (selectCols) {
-            df = df.select(...selectCols);
-        }
-
-        return df;
-    }
-
-    /**
-     * Stream-parse a File into a DataFrame, with progress callback.
-     * Auto-detects XLSX/XLS and routes accordingly.
-     */
-    async streamFile(file: File, options: ParseOptions = {}): Promise<DataFrame> {
-        const ext = file.name.split('.').pop()?.toLowerCase();
-
-        if (ext === 'xlsx' || ext === 'xls') {
-            return this._parseXLSX(file, options);
-        }
-
-        const {
-            delimiter = file.name.endsWith('.tsv') ? '\t' : ',',
-            hasHeader = true,
-            chunkSize = 64 * 1024,
-            onProgress,
-            maxRows,
-            skipRows = 0,
-            columns: selectCols
-        } = options;
-
-        const totalSize = file.size;
-        let bytesRead = 0;
-        let headers: string[] | null = null;
-        let lineBuffer = '';
-        let rowCount = 0;
-        let skipped = 0;
-        const rows: Record<string, any>[] = [];
-
-        const reader = file.stream().getReader();
-        const decoder = new TextDecoder();
-
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            bytesRead += value.byteLength;
-            lineBuffer += decoder.decode(value, { stream: !done });
-
-            const lines = lineBuffer.split('\n');
-            lineBuffer = lines.pop() || '';
-
-            for (const line of lines) {
-                if (!line.trim()) continue;
-
-                if (!headers && hasHeader) {
-                    headers = this._parseLine(line, delimiter);
-                    continue;
-                }
-
-                if (!headers) {
-                    const vals = this._parseLine(line, delimiter);
-                    headers = vals.map((_, i) => `col_${i}`);
-                }
-
-                if (skipped < skipRows) {
-                    skipped++;
-                    continue;
-                }
-
-                if (maxRows && rowCount >= maxRows) break;
-
-                const values = this._parseLine(line, delimiter);
-                const row: Record<string, any> = {};
-                headers.forEach((h, j) => {
-                    row[h] = this._autoType(values[j]);
-                });
-                rows.push(row);
-                rowCount++;
-            }
-
-            if (onProgress) {
-                onProgress(bytesRead, totalSize);
-            }
-
-            if (maxRows && rowCount >= maxRows) break;
-        }
-
-        // Handle remaining buffer
-        if (lineBuffer.trim() && (!maxRows || rowCount < maxRows)) {
-            if (!headers) {
-                headers = this._parseLine(lineBuffer, delimiter).map((_, i) => `col_${i}`);
-            } else {
-                const values = this._parseLine(lineBuffer, delimiter);
-                const row: Record<string, any> = {};
-                headers.forEach((h, j) => {
-                    row[h] = this._autoType(values[j]);
-                });
-                rows.push(row);
-            }
-        }
-
-        if (onProgress) onProgress(totalSize, totalSize);
-
-        let df = new DataFrame(rows);
-        if (selectCols) df = df.select(...selectCols);
-
-        return df;
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * XLSX / XLS PARSING (ExcelJS)
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Parse an XLSX/XLS file into a DataFrame using ExcelJS
-     */
-    private async _parseXLSX(file: File, options: ParseOptions = {}): Promise<DataFrame> {
-        const { maxRows, skipRows = 0, columns: selectCols, sheet, onProgress, hasHeader = true } = options;
-
-        let ExcelJS: any;
-        try {
-            ExcelJS = await import('exceljs');
-        } catch {
-            throw new Error(
-                'XLSX support requires the "exceljs" package. Install it with: npm install exceljs'
-            );
-        }
-
-        if (onProgress) onProgress(0, file.size);
-
-        const buffer = await file.arrayBuffer();
-
-        if (onProgress) onProgress(file.size * 0.5, file.size);
-
-        const workbook = new ExcelJS.Workbook();
-        await workbook.xlsx.load(buffer);
-
-        // Select sheet
-        let worksheet: any;
-        if (typeof sheet === 'number') {
-            worksheet = workbook.worksheets[sheet] || workbook.worksheets[0];
-        } else if (typeof sheet === 'string') {
-            worksheet = workbook.getWorksheet(sheet) || workbook.worksheets[0];
-        } else {
-            worksheet = workbook.worksheets[0];
-        }
-
-        if (!worksheet) {
-            const names = workbook.worksheets.map((ws: any) => ws.name).join(', ');
-            throw new Error(`No worksheet found. Available: ${names}`);
-        }
-
-        if (onProgress) onProgress(file.size * 0.7, file.size);
-
-        // Read all rows
-        const allRows: Record<string, any>[] = [];
-        let headers: string[] | null = null;
-
-        worksheet.eachRow({ includeEmpty: false }, (row: any, rowNumber: number) => {
-            const values = this._excelRowToArray(row, worksheet.columnCount);
-
-            if (!headers && hasHeader) {
-                headers = values.map((v: any, i: number) => {
-                    if (v === null || v === undefined || String(v).trim() === '') return `col_${i}`;
-                    return String(v).trim();
-                });
-                return;
-            }
-
-            if (!headers) {
-                headers = values.map((_: any, i: number) => `col_${i}`);
-            }
-
-            const rowObj: Record<string, any> = {};
-            headers.forEach((h, j) => {
-                rowObj[h] = this._autoType(values[j] === null || values[j] === undefined ? '' : String(values[j]));
-            });
-            allRows.push(rowObj);
-        });
-
-        if (onProgress) onProgress(file.size * 0.9, file.size);
-
-        let rows = allRows;
-        if (skipRows > 0) rows = rows.slice(skipRows);
-        if (maxRows !== undefined) rows = rows.slice(0, maxRows);
-
-        if (onProgress) onProgress(file.size, file.size);
-
-        let df = new DataFrame(rows);
-        if (selectCols) df = df.select(...selectCols);
-        return df;
-    }
-
-    /**
-     * Get sheet names from an XLSX file
-     */
-    async getSheetNames(file: File): Promise<string[]> {
-        let ExcelJS: any;
-        try {
-            ExcelJS = await import('exceljs');
-        } catch {
-            throw new Error('XLSX support requires the "exceljs" package. Install it with: npm install exceljs');
-        }
-
-        const buffer = await file.arrayBuffer();
-        const workbook = new ExcelJS.Workbook();
-        await workbook.xlsx.load(buffer);
-        return workbook.worksheets.map((ws: any) => ws.name);
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * INDEXEDDB PERSISTENCE
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Store a DataFrame to IndexedDB
-     */
-    async store(name: string, df: DataFrame, metadata?: Record<string, any>): Promise<string> {
-        const db = await this.open();
-
-        const table: StoredTable = {
-            id: `${name}-${Date.now()}`,
-            name,
-            columns: df.columns,
-            rows: df.toRows().map(row => df.columns.map(c => row[c])),
-            rowCount: df.height,
-            delimiter: ',',
-            timestamp: Date.now(),
-            metadata
-        };
-
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readwrite');
-            const store = tx.objectStore(this._storeName);
-            const request = store.put(table);
-            request.onsuccess = () => resolve(table.id);
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    /**
-     * Load a DataFrame from IndexedDB by ID
-     */
-    async load(id: string): Promise<DataFrame | null> {
-        const db = await this.open();
-
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readonly');
-            const store = tx.objectStore(this._storeName);
-            const request = store.get(id);
-
-            request.onsuccess = () => {
-                const table: StoredTable = request.result;
-                if (!table) return resolve(null);
-
-                const rows = table.rows.map(row => {
-                    const obj: Record<string, any> = {};
-                    table.columns.forEach((col, i) => { obj[col] = row[i]; });
-                    return obj;
-                });
-
-                resolve(new DataFrame(rows));
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    /**
-     * Load the most recent table by name
-     */
-    async loadByName(name: string): Promise<DataFrame | null> {
-        const db = await this.open();
-
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readonly');
-            const store = tx.objectStore(this._storeName);
-            const index = store.index('name');
-            const request = index.getAll(name);
-
-            request.onsuccess = () => {
-                const tables: StoredTable[] = request.result || [];
-                if (tables.length === 0) return resolve(null);
-
-                tables.sort((a, b) => b.timestamp - a.timestamp);
-                const table = tables[0];
-
-                const rows = table.rows.map(row => {
-                    const obj: Record<string, any> = {};
-                    table.columns.forEach((col, i) => { obj[col] = row[i]; });
-                    return obj;
-                });
-
-                resolve(new DataFrame(rows));
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    /**
-     * List all stored tables (metadata only)
-     */
-    async list(): Promise<Array<{ id: string; name: string; columns: string[]; rowCount: number; timestamp: number }>> {
-        const db = await this.open();
-
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readonly');
-            const store = tx.objectStore(this._storeName);
-            const request = store.getAll();
-
-            request.onsuccess = () => {
-                resolve((request.result || []).map((t: StoredTable) => ({
-                    id: t.id,
-                    name: t.name,
-                    columns: t.columns,
-                    rowCount: t.rowCount,
-                    timestamp: t.timestamp
-                })));
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    /**
-     * Delete a stored table
-     */
-    async delete(id: string): Promise<void> {
-        const db = await this.open();
-
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readwrite');
-            const store = tx.objectStore(this._storeName);
-            const request = store.delete(id);
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    async clear(): Promise<void> {
-        const db = await this.open();
-
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readwrite');
-            const store = tx.objectStore(this._storeName);
-            const request = store.clear();
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * STREAM FROM URL
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Fetch and stream-parse a remote CSV/TSV file
-     */
-    async fetch(url: string, options: ParseOptions = {}): Promise<DataFrame> {
-        const response = await globalThis.fetch(url);
-        if (!response.ok) throw new Error(`Failed to fetch: ${response.status}`);
-        if (!response.body) throw new Error('No response body');
-
-        const contentLength = Number(response.headers.get('content-length')) || null;
-        const ext = url.split('.').pop()?.toLowerCase();
-        const delimiter = options.delimiter ?? (ext === 'tsv' ? '\t' : ',');
-
-        const { hasHeader = true, chunkSize, onProgress, maxRows, skipRows = 0, columns: selectCols } = options;
-
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-
-        let headers: string[] | null = null;
-        let lineBuffer = '';
-        let rowCount = 0;
-        let skipped = 0;
-        let bytesRead = 0;
-        const rows: Record<string, any>[] = [];
-
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            bytesRead += value.byteLength;
-            lineBuffer += decoder.decode(value, { stream: true });
-
-            const lines = lineBuffer.split('\n');
-            lineBuffer = lines.pop() || '';
-
-            for (const line of lines) {
-                if (!line.trim()) continue;
-
-                if (!headers && hasHeader) {
-                    headers = this._parseLine(line, delimiter);
-                    continue;
-                }
-
-                if (!headers) {
-                    const vals = this._parseLine(line, delimiter);
-                    headers = vals.map((_, i) => `col_${i}`);
-                }
-
-                if (skipped < skipRows) { skipped++; continue; }
-                if (maxRows && rowCount >= maxRows) break;
-
-                const values = this._parseLine(line, delimiter);
-                const row: Record<string, any> = {};
-                headers.forEach((h, j) => { row[h] = this._autoType(values[j]); });
-                rows.push(row);
-                rowCount++;
-            }
-
-            if (onProgress) onProgress(bytesRead, contentLength);
-            if (maxRows && rowCount >= maxRows) break;
-        }
-
-        if (lineBuffer.trim() && (!maxRows || rowCount < maxRows)) {
-            if (headers) {
-                const values = this._parseLine(lineBuffer, delimiter);
-                const row: Record<string, any> = {};
-                headers.forEach((h, j) => { row[h] = this._autoType(values[j]); });
-                rows.push(row);
-            }
-        }
-
-        if (onProgress) onProgress(bytesRead, bytesRead);
-
-        let df = new DataFrame(rows);
-        if (selectCols) df = df.select(...selectCols);
-        return df;
-    }
-
-    /**
-     * Read raw cell values from first sheet of an Excel file.
-     * Returns rows with their 0-based row indices.
-     * Used by both the preview UI and the parser to ensure consistency.
-     */
-    async readRawExcelRows(file: File, maxRows: number = 15): Promise<{ sheetRow: number; values: any[] }[]> {
-        let ExcelJS: any;
-        try {
-            ExcelJS = await import('exceljs');
-        } catch {
-            throw new Error('XLSX support requires the "exceljs" package.');
-        }
-
-        const buffer = await file.arrayBuffer();
-        const workbook = new ExcelJS.Workbook();
-        await workbook.xlsx.load(buffer);
-
-        const worksheet = workbook.worksheets[0];
-        if (!worksheet) return [];
-
-        const colCount = worksheet.columnCount;
-        const rows: { sheetRow: number; values: any[] }[] = [];
-        let count = 0;
-
-        // ExcelJS eachRow gives 1-based rowNumber; we expose 0-based to the UI
-        // But we need to also show truly empty rows, so iterate by index
-        const totalRows = Math.min(worksheet.rowCount, maxRows);
-
-        for (let r = 1; r <= totalRows; r++) {
-            const row = worksheet.getRow(r);
-            const values = this._excelRowToArray(row, colCount);
-            // sheetRow is 0-based (r-1) to match what we pass back to streamFileMultiSheet
-            rows.push({ sheetRow: r - 1, values });
-            count++;
-            if (count >= maxRows) break;
-        }
-
-        console.log(`[readRawExcelRows] ${rows.length} rows, colCount=${colCount}`);
-        rows.forEach(r => console.log(`  sheetRow ${r.sheetRow}:`, r.values.slice(0, 5)));
-
-        return rows;
-    }
-
-    /**
-     * Stream Excel file with optional headerRow override.
-     * headerRow is 0-based (same as sheetRow from readRawExcelRows).
-     */
-    async streamFileMultiSheet(file: File, options: ParseOptions = {}): Promise<Record<string, DataFrame>> {
-        const { maxSheetSize = 100000, onProgress, headerRow = 0 } = options;
-
-        let ExcelJS: any;
-        try {
-            ExcelJS = await import('exceljs');
-        } catch {
-            throw new Error('XLSX support requires the "exceljs" package. Install it with: npm install exceljs');
-        }
-
-        if (onProgress) onProgress(0, file.size);
-
-        const buffer = await file.arrayBuffer();
-
-        if (onProgress) onProgress(file.size * 0.3, file.size);
-
-        const workbook = new ExcelJS.Workbook();
-        await workbook.xlsx.load(buffer);
-
-        const sheets: Record<string, DataFrame> = {};
-        const totalSheets = workbook.worksheets.length;
-        let processedSheets = 0;
-
-        for (const worksheet of workbook.worksheets) {
-            const sheetName = worksheet.name;
-            const colCount = worksheet.columnCount;
-            const rowCount = worksheet.rowCount;
-
-            if (rowCount === 0 || colCount === 0) {
-                processedSheets++;
-                continue;
-            }
-
-            // headerRow is 0-based; ExcelJS rows are 1-based
-            const headerExcelRow = headerRow + 1;
-
-            console.log(`[TabularDriver] Sheet "${sheetName}": rowCount=${rowCount}, colCount=${colCount}`);
-            console.log(`[TabularDriver] headerRow=${headerRow} (0-based), excelRow=${headerExcelRow} (1-based)`);
-
-            if (headerExcelRow > rowCount) {
-                console.warn(`[TabularDriver] headerRow ${headerRow} exceeds rowCount ${rowCount}`);
-                processedSheets++;
-                continue;
-            }
-
-            // Read header row
-            const headerRowObj = worksheet.getRow(headerExcelRow);
-            const headerValues = this._excelRowToArray(headerRowObj, colCount);
-            console.log(`[TabularDriver] Raw header values at row ${headerRow}:`, headerValues);
-
-            const headers: string[] = headerValues.map((h: any, i: number) => {
-                if (h === null || h === undefined || String(h).trim() === '') {
-                    return `__EMPTY${i > 0 ? '_' + i : ''}`;
-                }
-                return String(h).trim();
-            });
-
-            const validHeaders = headers.filter(h => !h.startsWith('__EMPTY'));
-            console.log(`[TabularDriver] Headers (${validHeaders.length} valid / ${headers.length} total):`, headers);
-
-            if (validHeaders.length === 0) {
-                console.warn(`[TabularDriver] No valid headers found at row ${headerRow} in sheet "${sheetName}"`);
-                // Debug surrounding rows
-                for (let debugR = Math.max(1, headerExcelRow - 2); debugR <= Math.min(rowCount, headerExcelRow + 2); debugR++) {
-                    const debugRow = worksheet.getRow(debugR);
-                    console.log(`[TabularDriver]   row ${debugR - 1}:`, this._excelRowToArray(debugRow, colCount));
-                }
-                processedSheets++;
-                continue;
-            }
-
-            // Build data rows: everything after the header row
-            const rows: Record<string, any>[] = [];
-            const maxDataRow = Math.min(rowCount, headerExcelRow + maxSheetSize);
-
-            for (let r = headerExcelRow + 1; r <= maxDataRow; r++) {
-                const row = worksheet.getRow(r);
-                const rowData = this._excelRowToArray(row, colCount);
-
-                // Skip completely empty rows
-                const hasContent = rowData.some((cell: any) =>
-                    cell !== null && cell !== undefined && String(cell).trim() !== ''
-                );
-                if (!hasContent) continue;
-
-                const rowObj: Record<string, any> = {};
-                for (let j = 0; j < headers.length; j++) {
-                    rowObj[headers[j]] = rowData[j];
-                }
-                rows.push(rowObj);
-            }
-
-            console.log(`[TabularDriver] Built ${rows.length} data rows for sheet "${sheetName}"`);
-            if (rows.length > 0) {
-                console.log(`[TabularDriver] First row:`, rows[0]);
-            }
-
-            if (rows.length > 0) {
-                sheets[sheetName] = new DataFrame(rows);
-            }
-
-            processedSheets++;
-            if (onProgress) {
-                const progress = 0.3 + (0.6 * (processedSheets / totalSheets));
-                onProgress(file.size * progress, file.size);
-            }
-        }
-
-        if (onProgress) onProgress(file.size, file.size);
-
-        return sheets;
-    }
-
-    /**
-     * Extract cell values from an ExcelJS row into a plain array.
-     * ExcelJS row.values is 1-based (index 0 is undefined), so we normalize.
-     */
-    private _excelRowToArray(row: any, colCount: number): any[] {
-        const values: any[] = [];
-        for (let c = 1; c <= colCount; c++) {
-            const cell = row.getCell(c);
-            if (!cell || cell.value === null || cell.value === undefined) {
-                values.push(null);
-            } else if (cell.type === 8 /* FormulaType */ && cell.result !== undefined) {
-                values.push(cell.result);
-            } else if (typeof cell.value === 'object' && cell.value !== null) {
-                // Handle rich text, hyperlinks, etc.
-                if (cell.value.richText) {
-                    values.push(cell.value.richText.map((rt: any) => rt.text).join(''));
-                } else if (cell.value.text) {
-                    values.push(cell.value.text);
-                } else if (cell.value.hyperlink) {
-                    values.push(cell.value.text || cell.value.hyperlink);
-                } else {
-                    values.push(String(cell.value));
-                }
-            } else {
-                values.push(cell.value);
-            }
-        }
-        return values;
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * INTERNAL PARSING HELPERS
-     * ═══════════════════════════════════════════════════ */
-
-    private _splitLines(text: string): string[] {
-        return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
-    }
-
-    private _parseLine(line: string, delimiter: string): string[] {
-        const result: string[] = [];
-        let current = '';
-        let inQuotes = false;
-
-        for (let i = 0; i < line.length; i++) {
-            const ch = line[i];
-
-            if (inQuotes) {
-                if (ch === '"') {
-                    if (i + 1 < line.length && line[i + 1] === '"') {
-                        current += '"';
-                        i++;
-                    } else {
-                        inQuotes = false;
-                    }
-                } else {
-                    current += ch;
-                }
-            } else {
-                if (ch === '"') {
-                    inQuotes = true;
-                } else if (ch === delimiter) {
-                    result.push(current.trim());
-                    current = '';
-                } else {
-                    current += ch;
-                }
-            }
-        }
-
-        result.push(current.trim());
-        return result;
-    }
-
-    private _autoType(value: string | undefined): any {
-        if (value === undefined || value === '' || value === null) return null;
-
-        if (value === 'true') return true;
-        if (value === 'false') return false;
-
-        const num = Number(value);
-        if (!isNaN(num) && value.trim() !== '') return num;
-
-        return value;
-    }
-
-    close(): void {
-        if (this._db) {
-            this._db.close();
-            this._db = null;
-        }
-    }
-}
-
-/**
- * Factory
- */
-export function tabularDriver(dbName?: string, storeName?: string): TabularDriver {
-    return new TabularDriver(dbName, storeName);
-}