juxscript 1.1.240 → 1.1.244

package/lib/storage/DataFrame.ts

@@ -1,1195 +0,0 @@
-/**
- * DataFrame - A pandas-like data manipulation class for JavaScript
- * 
- * Core capabilities:
- * - Column operations (select, drop, rename, reorder)
- * - Row operations (filter, head, tail, sample, slice)
- * - Data transformation (withColumn, apply, map)
- * - Aggregation (groupBy, agg, pivot)
- * - Joins (merge, concat, union)
- * - Type inference and conversion
- * - Sorting and indexing
- * - Statistics and describe
- * - Missing data handling
- */
-
-export type DataType = 'string' | 'number' | 'boolean' | 'date' | 'null' | 'mixed';
-
-export interface ColumnSchema {
-    name: string;
-    dtype: DataType;
-    nullable: boolean;
-    unique?: number;
-    min?: any;
-    max?: any;
-}
-
-export interface DataFrameOptions {
-    inferTypes?: boolean;
-    columns?: string[];
-}
-
-export class DataFrame {
-    private _columns!: string[];
-    private _data!: Map<string, any[]>;
-    private _height!: number;
-    private _schema: Map<string, ColumnSchema>;
-    private _inferTypes: boolean;
-
-    constructor(
-        data: Record<string, any>[] | Record<string, any[]> | DataFrame,
-        options: DataFrameOptions = {}
-    ) {
-        this._inferTypes = options.inferTypes ?? true;
-        this._schema = new Map();
-
-        if (data instanceof DataFrame) {
-            // Clone from another DataFrame
-            this._columns = [...data._columns];
-            this._data = new Map();
-            data._columns.forEach(col => {
-                this._data.set(col, [...data._data.get(col)!]);
-            });
-            this._height = data._height;
-            this._schema = new Map(data._schema);
-        } else if (Array.isArray(data)) {
-            // Row-oriented: [{col1: val1, col2: val2}, ...]
-            this._initFromRows(data, options.columns);
-        } else {
-            // Column-oriented: {col1: [val1, val2], col2: [val1, val2]}
-            this._initFromColumns(data, options.columns);
-        }
-
-        if (this._inferTypes) {
-            this._inferSchema();
-        }
-    }
-
-    private _initFromRows(rows: Record<string, any>[], columnOrder?: string[]): void {
-        if (rows.length === 0) {
-            this._columns = columnOrder || [];
-            this._data = new Map();
-            this._height = 0;
-            return;
-        }
-
-        // Get all unique columns across all rows
-        const colSet = new Set<string>();
-        rows.forEach(row => Object.keys(row).forEach(k => colSet.add(k)));
-
-        this._columns = columnOrder || Array.from(colSet);
-        this._data = new Map();
-        this._height = rows.length;
-
-        this._columns.forEach(col => {
-            this._data.set(col, rows.map(row => row[col] ?? null));
-        });
-    }
-
-    private _initFromColumns(cols: Record<string, any[]>, columnOrder?: string[]): void {
-        this._columns = columnOrder || Object.keys(cols);
-        this._data = new Map();
-
-        const lengths = this._columns.map(c => cols[c]?.length ?? 0);
-        this._height = Math.max(0, ...lengths);
-
-        this._columns.forEach(col => {
-            const values = cols[col] || [];
-            // Pad shorter columns with null
-            const padded = [...values];
-            while (padded.length < this._height) {
-                padded.push(null);
-            }
-            this._data.set(col, padded);
-        });
-    }
-
-    private _inferSchema(): void {
-        this._columns.forEach(col => {
-            const values = this._data.get(col)!;
-            const schema = this._inferColumnSchema(col, values);
-            this._schema.set(col, schema);
-        });
-    }
-
-    private _inferColumnSchema(name: string, values: any[]): ColumnSchema {
-        let hasNull = false;
-        let hasString = false;
-        let hasNumber = false;
-        let hasBoolean = false;
-        let hasDate = false;
-        let min: any = undefined;
-        let max: any = undefined;
-        const uniqueValues = new Set<any>();
-
-        values.forEach(v => {
-            if (v === null || v === undefined || v === '') {
-                hasNull = true;
-                return;
-            }
-
-            uniqueValues.add(v);
-
-            if (typeof v === 'boolean') {
-                hasBoolean = true;
-            } else if (typeof v === 'number' && !isNaN(v)) {
-                hasNumber = true;
-                if (min === undefined || v < min) min = v;
-                if (max === undefined || v > max) max = v;
-            } else if (v instanceof Date) {
-                hasDate = true;
-            } else if (typeof v === 'string') {
-                // Try to parse as number
-                const num = Number(v);
-                if (!isNaN(num) && v.trim() !== '') {
-                    hasNumber = true;
-                    if (min === undefined || num < min) min = num;
-                    if (max === undefined || num > max) max = num;
-                } else if (v === 'true' || v === 'false') {
-                    hasBoolean = true;
-                } else {
-                    hasString = true;
-                }
-            }
-        });
-
-        let dtype: DataType = 'null';
-        const typeCount = [hasString, hasNumber, hasBoolean, hasDate].filter(Boolean).length;
-
-        if (typeCount === 0) {
-            dtype = 'null';
-        } else if (typeCount > 1) {
-            dtype = 'mixed';
-        } else if (hasNumber) {
-            dtype = 'number';
-        } else if (hasBoolean) {
-            dtype = 'boolean';
-        } else if (hasDate) {
-            dtype = 'date';
-        } else {
-            dtype = 'string';
-        }
-
-        return {
-            name,
-            dtype,
-            nullable: hasNull,
-            unique: uniqueValues.size,
-            min,
-            max
-        };
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * ACCESSORS
-     * ═══════════════════════════════════════════════════ */
-
-    get columns(): string[] {
-        return [...this._columns];
-    }
-
-    get height(): number {
-        return this._height;
-    }
-
-    get width(): number {
-        return this._columns.length;
-    }
-
-    get shape(): [number, number] {
-        return [this._height, this._columns.length];
-    }
-
-    get dtypes(): Record<string, DataType> {
-        const result: Record<string, DataType> = {};
-        this._schema.forEach((schema, col) => {
-            result[col] = schema.dtype;
-        });
-        return result;
-    }
-
-    get schema(): ColumnSchema[] {
-        return this._columns.map(col => this._schema.get(col)!);
-    }
-
-    get isEmpty(): boolean {
-        return this._height === 0;
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * DATA ACCESS
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Get a column as an array
-     */
-    col(name: string): any[] {
-        const data = this._data.get(name);
-        if (!data) throw new Error(`Column '${name}' not found`);
-        return [...data];
-    }
-
-    /**
-     * Get column (alias for col)
-     */
-    getColumn(name: string): any[] {
-        return this.col(name);
-    }
-
-    /**
-     * Get a single row by index
-     */
-    row(index: number): Record<string, any> {
-        if (index < 0 || index >= this._height) {
-            throw new Error(`Row index ${index} out of bounds`);
-        }
-        const result: Record<string, any> = {};
-        this._columns.forEach(col => {
-            result[col] = this._data.get(col)![index];
-        });
-        return result;
-    }
-
-    /**
-     * Get value at specific row and column
-     */
-    at(row: number, col: string): any {
-        const data = this._data.get(col);
-        if (!data) throw new Error(`Column '${col}' not found`);
-        if (row < 0 || row >= this._height) throw new Error(`Row index ${row} out of bounds`);
-        return data[row];
-    }
-
-    /**
-     * Set value at specific row and column (mutates!)
-     */
-    setAt(row: number, col: string, value: any): this {
-        const data = this._data.get(col);
-        if (!data) throw new Error(`Column '${col}' not found`);
-        if (row < 0 || row >= this._height) throw new Error(`Row index ${row} out of bounds`);
-        data[row] = value;
-        return this;
-    }
-
-    /**
-     * Convert to array of row objects
-     */
-    toRows(): Record<string, any>[] {
-        const rows: Record<string, any>[] = [];
-        for (let i = 0; i < this._height; i++) {
-            rows.push(this.row(i));
-        }
-        return rows;
-    }
-
-    /**
-     * Convert to column-oriented object
-     */
-    toColumns(): Record<string, any[]> {
-        const result: Record<string, any[]> = {};
-        this._columns.forEach(col => {
-            result[col] = [...this._data.get(col)!];
-        });
-        return result;
-    }
-
-    /**
-     * Get distinct/unique values in a column
-     */
-    distinct(column: string): any[] {
-        const data = this._data.get(column);
-        if (!data) throw new Error(`Column '${column}' not found`);
-        return [...new Set(data)];
-    }
-
-    /**
-     * Alias for distinct
-     */
-    unique(column: string): any[] {
-        return this.distinct(column);
-    }
-
-    /**
-     * Count occurrences of each value in a column
-     */
-    valueCounts(column: string): Record<any, number> {
-        const data = this._data.get(column);
-        if (!data) throw new Error(`Column '${column}' not found`);
-
-        const counts: Record<any, number> = {};
-        data.forEach(v => {
-            const key = v === null ? '__null__' : String(v);
-            counts[key] = (counts[key] || 0) + 1;
-        });
-        return counts;
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * COLUMN OPERATIONS
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Select specific columns
-     */
-    select(...cols: string[]): DataFrame {
-        const missing = cols.filter(c => !this._data.has(c));
-        if (missing.length > 0) {
-            throw new Error(`Columns not found: ${missing.join(', ')}`);
-        }
-
-        const newData: Record<string, any[]> = {};
-        cols.forEach(col => {
-            newData[col] = [...this._data.get(col)!];
-        });
-
-        return new DataFrame(newData, { columns: cols, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Drop columns
-     */
-    drop(...cols: string[]): DataFrame {
-        const keepCols = this._columns.filter(c => !cols.includes(c));
-        return this.select(...keepCols);
-    }
-
-    /**
-     * Rename columns
-     */
-    rename(mapping: Record<string, string>): DataFrame {
-        const newData: Record<string, any[]> = {};
-        const newCols: string[] = [];
-
-        this._columns.forEach(col => {
-            const newName = mapping[col] || col;
-            newCols.push(newName);
-            newData[newName] = [...this._data.get(col)!];
-        });
-
-        return new DataFrame(newData, { columns: newCols, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Reorder columns
-     */
-    reorder(...cols: string[]): DataFrame {
-        // Include any columns not specified at the end
-        const remaining = this._columns.filter(c => !cols.includes(c));
-        return this.select(...cols, ...remaining);
-    }
-
-    /**
-     * Add or replace a column with computed values
-     */
-    withColumn(name: string, fn: (row: Record<string, any>, index: number) => any): DataFrame {
-        const newValues = this.toRows().map((row, i) => fn(row, i));
-
-        const newData: Record<string, any[]> = {};
-        this._columns.forEach(col => {
-            newData[col] = [...this._data.get(col)!];
-        });
-        newData[name] = newValues;
-
-        const newCols = this._columns.includes(name)
-            ? this._columns
-            : [...this._columns, name];
-
-        return new DataFrame(newData, { columns: newCols, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Add multiple computed columns at once
-     */
-    withColumns(columns: Record<string, (row: Record<string, any>, index: number) => any>): DataFrame {
-        let result: DataFrame = this;
-        Object.entries(columns).forEach(([name, fn]) => {
-            result = result.withColumn(name, fn);
-        });
-        return result;
-    }
-
-    /**
-     * Cast column to a specific type
-     */
-    asType(column: string, dtype: 'string' | 'number' | 'boolean' | 'date'): DataFrame {
-        return this.withColumn(column, (row) => {
-            const val = row[column];
-            if (val === null || val === undefined) return null;
-
-            switch (dtype) {
-                case 'string':
-                    return String(val);
-                case 'number':
-                    const num = Number(val);
-                    return isNaN(num) ? null : num;
-                case 'boolean':
-                    if (typeof val === 'boolean') return val;
-                    if (val === 'true' || val === '1' || val === 1) return true;
-                    if (val === 'false' || val === '0' || val === 0) return false;
-                    return null;
-                case 'date':
-                    const date = new Date(val);
-                    return isNaN(date.getTime()) ? null : date;
-                default:
-                    return val;
-            }
-        });
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * ROW OPERATIONS
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Filter rows by predicate
-     */
-    filter(predicate: (row: Record<string, any>, index: number) => boolean): DataFrame {
-        const rows = this.toRows();
-        const filtered = rows.filter((row, i) => predicate(row, i));
-        return new DataFrame(filtered, { columns: this._columns, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Filter with SQL-like where clause
-     */
-    where(
-        col: string,
-        op: '==' | '!=' | '>' | '<' | '>=' | '<=' | 'in' | 'not in' | 'contains' | 'startsWith' | 'endsWith' | 'isNull' | 'notNull',
-        value?: any
-    ): DataFrame {
-        return this.filter(row => {
-            const v = row[col];
-
-            switch (op) {
-                case '==': return v === value;
-                case '!=': return v !== value;
-                case '>': return v > value;
-                case '<': return v < value;
-                case '>=': return v >= value;
-                case '<=': return v <= value;
-                case 'in': return Array.isArray(value) && value.includes(v);
-                case 'not in': return Array.isArray(value) && !value.includes(v);
-                case 'contains': return String(v).includes(String(value));
-                case 'startsWith': return String(v).startsWith(String(value));
-                case 'endsWith': return String(v).endsWith(String(value));
-                case 'isNull': return v === null || v === undefined || v === '';
-                case 'notNull': return v !== null && v !== undefined && v !== '';
-                default: return true;
-            }
-        });
-    }
-
-    /**
-     * Get first N rows
-     */
-    head(n: number = 5): DataFrame {
-        return this.slice(0, n);
-    }
-
-    /**
-     * Get last N rows
-     */
-    tail(n: number = 5): DataFrame {
-        return this.slice(Math.max(0, this._height - n));
-    }
-
-    /**
-     * Slice rows by index range
-     */
-    slice(start: number, end?: number): DataFrame {
-        const rows = this.toRows().slice(start, end);
-        return new DataFrame(rows, { columns: this._columns, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Get random sample of rows
-     */
-    sample(n: number, seed?: number): DataFrame {
-        const rows = this.toRows();
-        const shuffled = [...rows];
-
-        // Simple shuffle (use seed if provided for reproducibility)
-        for (let i = shuffled.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-        }
-
-        return new DataFrame(shuffled.slice(0, n), { columns: this._columns, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Drop duplicate rows
-     */
-    dropDuplicates(columns?: string[]): DataFrame {
-        const cols = columns || this._columns;
-        const seen = new Set<string>();
-
-        const rows = this.toRows().filter(row => {
-            const key = cols.map(c => JSON.stringify(row[c])).join('|');
-            if (seen.has(key)) return false;
-            seen.add(key);
-            return true;
-        });
-
-        return new DataFrame(rows, { columns: this._columns, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Drop rows with null values
-     */
-    dropna(columns?: string[]): DataFrame {
-        const cols = columns || this._columns;
-        return this.filter(row => {
-            return cols.every(c => row[c] !== null && row[c] !== undefined && row[c] !== '');
-        });
-    }
-
-    /**
-     * Fill null values
-     */
-    fillna(value: any, columns?: string[]): DataFrame {
-        const cols = columns || this._columns;
-        let result: DataFrame = this;
-
-        cols.forEach(col => {
-            result = result.withColumn(col, row => {
-                const v = row[col];
-                return (v === null || v === undefined || v === '') ? value : v;
-            });
-        });
-
-        return result;
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * SORTING
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Sort by column(s)
-     */
-    sort(column: string | string[], descending: boolean | boolean[] = false): DataFrame {
-        const cols = Array.isArray(column) ? column : [column];
-        const descs = Array.isArray(descending) ? descending : cols.map(() => descending);
-
-        const rows = this.toRows();
-        rows.sort((a, b) => {
-            for (let i = 0; i < cols.length; i++) {
-                const col = cols[i];
-                const desc = descs[i] || false;
-                const aVal = a[col];
-                const bVal = b[col];
-
-                if (aVal === bVal) continue;
-                if (aVal === null || aVal === undefined) return 1;
-                if (bVal === null || bVal === undefined) return -1;
-
-                const cmp = aVal < bVal ? -1 : 1;
-                return desc ? -cmp : cmp;
-            }
-            return 0;
-        });
-
-        return new DataFrame(rows, { columns: this._columns, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Sort descending (shorthand)
-     */
-    sortDesc(column: string): DataFrame {
-        return this.sort(column, true);
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * AGGREGATION
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Group by column(s) and aggregate
-     */
-    groupBy(columns: string | string[]): GroupedDataFrame {
-        return new GroupedDataFrame(this, Array.isArray(columns) ? columns : [columns]);
-    }
-
-    /**
-     * Aggregate entire DataFrame
-     */
-    agg(aggregations: Record<string, 'sum' | 'mean' | 'min' | 'max' | 'count' | 'first' | 'last' | ((values: any[]) => any)>): DataFrame {
-        const result: Record<string, any> = {};
-
-        Object.entries(aggregations).forEach(([col, aggFn]) => {
-            const values = this._data.get(col);
-            if (!values) throw new Error(`Column '${col}' not found`);
-
-            const nonNull = values.filter(v => v !== null && v !== undefined);
-
-            if (typeof aggFn === 'function') {
-                result[col] = aggFn(nonNull);
-            } else {
-                switch (aggFn) {
-                    case 'sum':
-                        result[col] = nonNull.reduce((a, b) => a + Number(b), 0);
-                        break;
-                    case 'mean':
-                        result[col] = nonNull.length > 0
-                            ? nonNull.reduce((a, b) => a + Number(b), 0) / nonNull.length
-                            : null;
-                        break;
-                    case 'min':
-                        result[col] = nonNull.length > 0 ? Math.min(...nonNull.map(Number)) : null;
-                        break;
-                    case 'max':
-                        result[col] = nonNull.length > 0 ? Math.max(...nonNull.map(Number)) : null;
-                        break;
-                    case 'count':
-                        result[col] = nonNull.length;
-                        break;
-                    case 'first':
-                        result[col] = nonNull[0] ?? null;
-                        break;
-                    case 'last':
-                        result[col] = nonNull[nonNull.length - 1] ?? null;
-                        break;
-                }
-            }
-        });
-
-        return new DataFrame([result], { inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Count rows
-     */
-    count(): number {
-        return this._height;
-    }
-
-    /**
-     * Sum of numeric column
-     */
-    sum(column: string): number {
-        const values = this._data.get(column);
-        if (!values) throw new Error(`Column '${column}' not found`);
-        return values.reduce((a, b) => a + (Number(b) || 0), 0);
-    }
-
-    /**
-     * Mean of numeric column
-     */
-    mean(column: string): number {
-        const values = this._data.get(column);
-        if (!values) throw new Error(`Column '${column}' not found`);
-        const nonNull = values.filter(v => v !== null && v !== undefined);
-        if (nonNull.length === 0) return 0;
-        return nonNull.reduce((a, b) => a + Number(b), 0) / nonNull.length;
-    }
-
-    /**
-     * Min of column
-     */
-    min(column: string): any {
-        const values = this._data.get(column);
-        if (!values) throw new Error(`Column '${column}' not found`);
-        const nonNull = values.filter(v => v !== null && v !== undefined);
-        if (nonNull.length === 0) return null;
-        return Math.min(...nonNull.map(Number));
-    }
-
-    /**
-     * Max of column
-     */
-    max(column: string): any {
-        const values = this._data.get(column);
-        if (!values) throw new Error(`Column '${column}' not found`);
-        const nonNull = values.filter(v => v !== null && v !== undefined);
-        if (nonNull.length === 0) return null;
-        return Math.max(...nonNull.map(Number));
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * JOINS & MERGING
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Merge with another DataFrame (SQL-like join)
-     */
-    merge(
-        other: DataFrame,
-        options: {
-            on?: string | string[];
-            leftOn?: string | string[];
-            rightOn?: string | string[];
-            how?: 'inner' | 'left' | 'right' | 'outer';
-            suffixes?: [string, string];
-        } = {}
-    ): DataFrame {
-        const {
-            on,
-            leftOn = on,
-            rightOn = on,
-            how = 'inner',
-            suffixes = ['_x', '_y']
-        } = options;
-
-        if (!leftOn || !rightOn) {
-            throw new Error('Must specify join columns with "on" or "leftOn"/"rightOn"');
-        }
-
-        const leftKeys = Array.isArray(leftOn) ? leftOn : [leftOn];
-        const rightKeys = Array.isArray(rightOn) ? rightOn : [rightOn];
-
-        // Build index on right DataFrame
-        const rightIndex = new Map<string, number[]>();
-        other.toRows().forEach((row, i) => {
-            const key = rightKeys.map(k => JSON.stringify(row[k])).join('|');
-            if (!rightIndex.has(key)) rightIndex.set(key, []);
-            rightIndex.get(key)!.push(i);
-        });
-
-        const leftRows = this.toRows();
-        const rightRows = other.toRows();
-        const result: Record<string, any>[] = [];
-
-        // Determine output columns
-        const leftCols = this._columns;
-        const rightCols = other._columns.filter(c => !rightKeys.includes(c));
-
-        // Handle column name conflicts
-        const colMapping: Record<string, string> = {};
-        rightCols.forEach(c => {
-            if (leftCols.includes(c)) {
-                colMapping[c] = c + suffixes[1];
-            } else {
-                colMapping[c] = c;
-            }
-        });
-
-        const matchedRight = new Set<number>();
-
-        // Process left rows
-        leftRows.forEach(leftRow => {
-            const key = leftKeys.map(k => JSON.stringify(leftRow[k])).join('|');
-            const matches = rightIndex.get(key) || [];
-
-            if (matches.length > 0) {
-                matches.forEach(rightIdx => {
-                    matchedRight.add(rightIdx);
-                    const rightRow = rightRows[rightIdx];
-                    const merged: Record<string, any> = { ...leftRow };
-                    rightCols.forEach(c => {
-                        merged[colMapping[c]] = rightRow[c];
-                    });
-                    result.push(merged);
-                });
-            } else if (how === 'left' || how === 'outer') {
-                const merged: Record<string, any> = { ...leftRow };
-                rightCols.forEach(c => {
-                    merged[colMapping[c]] = null;
-                });
-                result.push(merged);
-            }
-        });
-
-        // For right/outer joins, add unmatched right rows
-        if (how === 'right' || how === 'outer') {
-            rightRows.forEach((rightRow, i) => {
-                if (!matchedRight.has(i)) {
-                    const merged: Record<string, any> = {};
-                    leftCols.forEach(c => {
-                        merged[c] = null;
-                    });
-                    // Copy join keys from right
-                    rightKeys.forEach((rk, idx) => {
-                        merged[leftKeys[idx]] = rightRow[rk];
-                    });
-                    rightCols.forEach(c => {
-                        merged[colMapping[c]] = rightRow[c];
-                    });
-                    result.push(merged);
-                }
-            });
-        }
-
-        const outputCols = [
-            ...leftCols,
-            ...rightCols.map(c => colMapping[c])
-        ];
-
-        return new DataFrame(result, { columns: outputCols, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Concatenate DataFrames vertically (union)
-     */
-    concat(other: DataFrame | DataFrame[], ignoreIndex: boolean = true): DataFrame {
-        const others = Array.isArray(other) ? other : [other];
-        const allDfs = [this, ...others];
-
-        // Collect all unique columns
-        const allCols = new Set<string>();
-        allDfs.forEach(df => df._columns.forEach(c => allCols.add(c)));
-        const columns = Array.from(allCols);
-
-        // Combine all rows
-        const rows: Record<string, any>[] = [];
-        allDfs.forEach(df => {
-            df.toRows().forEach(row => {
-                const newRow: Record<string, any> = {};
-                columns.forEach(c => {
-                    newRow[c] = row[c] ?? null;
-                });
-                rows.push(newRow);
-            });
-        });
-
-        return new DataFrame(rows, { columns, inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Union (alias for concat)
-     */
-    union(other: DataFrame): DataFrame {
-        return this.concat(other);
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * TRANSFORMATION
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Apply function to each row
-     */
-    apply(fn: (row: Record<string, any>, index: number) => Record<string, any>): DataFrame {
-        const rows = this.toRows().map((row, i) => fn(row, i));
-        return new DataFrame(rows, { inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Map function over a column
-     */
-    map(column: string, fn: (value: any, index: number) => any): DataFrame {
-        return this.withColumn(column, (row, i) => fn(row[column], i));
-    }
-
-    /**
-     * Pivot table
-     */
-    pivot(
-        index: string,
-        columns: string,
-        values: string,
-        aggFunc: 'sum' | 'mean' | 'count' | 'first' = 'first'
-    ): DataFrame {
-        const pivotValues = this.distinct(columns);
-        const indexValues = this.distinct(index);
-
-        const result: Record<string, any>[] = [];
-
-        indexValues.forEach(idxVal => {
-            const row: Record<string, any> = { [index]: idxVal };
-
-            pivotValues.forEach(pivotVal => {
-                const filtered = this
-                    .where(index, '==', idxVal)
-                    .where(columns, '==', pivotVal);
-
-                const vals = filtered.col(values).filter(v => v !== null && v !== undefined);
-
-                let aggValue: any = null;
-                if (vals.length > 0) {
-                    switch (aggFunc) {
-                        case 'sum':
-                            aggValue = vals.reduce((a, b) => a + Number(b), 0);
-                            break;
-                        case 'mean':
-                            aggValue = vals.reduce((a, b) => a + Number(b), 0) / vals.length;
-                            break;
-                        case 'count':
-                            aggValue = vals.length;
-                            break;
-                        case 'first':
-                            aggValue = vals[0];
-                            break;
-                    }
-                }
-
-                row[String(pivotVal)] = aggValue;
-            });
-
-            result.push(row);
-        });
-
-        return new DataFrame(result, { inferTypes: this._inferTypes });
-    }
-
-    /**
-     * Melt (unpivot) wide format to long format
-     */
-    melt(
-        idVars: string[],
-        valueVars?: string[],
-        varName: string = 'variable',
-        valueName: string = 'value'
-    ): DataFrame {
-        const valueCols = valueVars || this._columns.filter(c => !idVars.includes(c));
-        const result: Record<string, any>[] = [];
-
-        this.toRows().forEach(row => {
-            valueCols.forEach(col => {
-                const newRow: Record<string, any> = {};
-                idVars.forEach(id => {
-                    newRow[id] = row[id];
-                });
-                newRow[varName] = col;
-                newRow[valueName] = row[col];
-                result.push(newRow);
-            });
-        });
-
-        return new DataFrame(result, { inferTypes: this._inferTypes });
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * STATISTICS
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Describe numeric columns
-     */
-    describe(): Record<string, any> {
-        const stats: Record<string, any> = {};
-
-        this._columns.forEach(col => {
-            const values = this._data.get(col)!;
-            const numeric = values.filter(v => typeof v === 'number' && !isNaN(v));
-
-            if (numeric.length === 0) {
-                stats[col] = {
-                    count: values.filter(v => v !== null && v !== undefined).length,
-                    unique: new Set(values).size,
-                    dtype: this._schema.get(col)?.dtype || 'unknown'
-                };
-            } else {
-                const sorted = [...numeric].sort((a, b) => a - b);
-                const sum = numeric.reduce((a, b) => a + b, 0);
-                const mean = sum / numeric.length;
-                const variance = numeric.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / numeric.length;
-
-                stats[col] = {
-                    count: numeric.length,
-                    mean: mean,
-                    std: Math.sqrt(variance),
-                    min: sorted[0],
-                    '25%': sorted[Math.floor(sorted.length * 0.25)],
-                    '50%': sorted[Math.floor(sorted.length * 0.5)],
-                    '75%': sorted[Math.floor(sorted.length * 0.75)],
-                    max: sorted[sorted.length - 1]
-                };
-            }
-        });
-
-        return stats;
-    }
-
-    /**
-     * Get info about DataFrame
-     */
-    info(): {
-        rows: number;
-        columns: number;
-        dtypes: Record<string, DataType>;
-        nullCounts: Record<string, number>;
-        memoryEstimate: number;
-    } {
-        const nullCounts: Record<string, number> = {};
-        let memoryEstimate = 0;
-
-        this._columns.forEach(col => {
-            const values = this._data.get(col)!;
-            nullCounts[col] = values.filter(v => v === null || v === undefined || v === '').length;
-            memoryEstimate += values.reduce((acc, v) => acc + (typeof v === 'string' ? v.length * 2 : 8), 0);
-        });
-
-        return {
-            rows: this._height,
-            columns: this._columns.length,
-            dtypes: this.dtypes,
-            nullCounts,
-            memoryEstimate
-        };
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * EXPORT
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Convert to CSV string
-     */
-    toCSV(delimiter: string = ','): string {
-        const escape = (val: any): string => {
-            if (val === null || val === undefined) return '';
-            const str = String(val);
-            if (str.includes(delimiter) || str.includes('"') || str.includes('\n')) {
-                return `"${str.replace(/"/g, '""')}"`;
-            }
-            return str;
-        };
-
-        const header = this._columns.map(escape).join(delimiter);
-        const rows = this.toRows().map(row =>
-            this._columns.map(col => escape(row[col])).join(delimiter)
-        );
-
-        return [header, ...rows].join('\n');
-    }
-
-    /**
-     * Convert to JSON string
-     */
-    toJSON(orient: 'records' | 'columns' | 'split' = 'records'): string {
-        switch (orient) {
-            case 'records':
-                return JSON.stringify(this.toRows());
-            case 'columns':
-                return JSON.stringify(this.toColumns());
-            case 'split':
-                return JSON.stringify({
-                    columns: this._columns,
-                    data: this.toRows().map(row => this._columns.map(c => row[c]))
-                });
-            default:
-                return JSON.stringify(this.toRows());
-        }
-    }
-
-    /**
-     * Clone the DataFrame
-     */
-    clone(): DataFrame {
-        return new DataFrame(this);
-    }
-
-    /**
-     * Print preview (for debugging)
-     */
-    print(n: number = 10): void {
-        console.log(`DataFrame: ${this._height} rows × ${this._columns.length} columns`);
-        console.log('Columns:', this._columns.join(', '));
-        console.table(this.head(n).toRows());
-    }
-}
-
-/**
- * GroupedDataFrame for group-by operations
- */
-export class GroupedDataFrame {
-    private _df: DataFrame;
-    private _groupCols: string[];
-    private _groups: Map<string, number[]>;
-
-    constructor(df: DataFrame, groupCols: string[]) {
-        this._df = df;
-        this._groupCols = groupCols;
-        this._groups = new Map();
-
-        // Build groups
-        df.toRows().forEach((row, i) => {
-            const key = groupCols.map(c => JSON.stringify(row[c])).join('|');
-            if (!this._groups.has(key)) this._groups.set(key, []);
-            this._groups.get(key)!.push(i);
-        });
-    }
-
-    /**
-     * Aggregate groups
-     */
-    agg(aggregations: Record<string, 'sum' | 'mean' | 'min' | 'max' | 'count' | 'first' | 'last' | ((values: any[]) => any)>): DataFrame {
-        const result: Record<string, any>[] = [];
-        const allRows = this._df.toRows();
-
-        this._groups.forEach((indices, key) => {
-            const groupRows = indices.map(i => allRows[i]);
-            const row: Record<string, any> = {};
-
-            // Add group columns
-            this._groupCols.forEach(c => {
-                row[c] = groupRows[0][c];
-            });
-
-            // Add aggregated values
-            Object.entries(aggregations).forEach(([col, aggFn]) => {
-                const values = groupRows.map(r => r[col]).filter(v => v !== null && v !== undefined);
-
-                if (typeof aggFn === 'function') {
-                    row[col] = aggFn(values);
-                } else {
-                    switch (aggFn) {
-                        case 'sum':
-                            row[col] = values.reduce((a, b) => a + Number(b), 0);
-                            break;
-                        case 'mean':
-                            row[col] = values.length > 0
-                                ? values.reduce((a, b) => a + Number(b), 0) / values.length
-                                : null;
-                            break;
-                        case 'min':
-                            row[col] = values.length > 0 ? Math.min(...values.map(Number)) : null;
-                            break;
-                        case 'max':
-                            row[col] = values.length > 0 ? Math.max(...values.map(Number)) : null;
-                            break;
-                        case 'count':
-                            row[col] = values.length;
-                            break;
-                        case 'first':
-                            row[col] = values[0] ?? null;
-                            break;
-                        case 'last':
-                            row[col] = values[values.length - 1] ?? null;
-                            break;
-                    }
-                }
-            });
-
-            result.push(row);
-        });
-
-        return new DataFrame(result);
-    }
-
-    /**
-     * Count per group
-     */
-    count(): DataFrame {
-        return this.agg({ _count: 'count' }).rename({ _count: 'count' });
-    }
-
-    /**
-     * Sum per group
-     */
-    sum(column: string): DataFrame {
-        return this.agg({ [column]: 'sum' });
-    }
-
-    /**
-     * Mean per group
-     */
-    mean(column: string): DataFrame {
-        return this.agg({ [column]: 'mean' });
-    }
-
-    /**
-     * Get number of groups
-     */
-    get ngroups(): number {
-        return this._groups.size;
-    }
-
-    /**
-     * Get group keys
-     */
-    get groups(): string[] {
-        return Array.from(this._groups.keys());
-    }
-}