@iyulab/u-insight 0.12.0 → 0.12.2

package/README.md

@@ -399,6 +399,19 @@ Feature importance via permutation, ANOVA, or mutual information.
 { "method": "permutation", "features": [{ "name": "f1", "index": 0, "score": 0.8, "std_dev": 0.1 }], "baseline_score": 0.5 }
 ```
 
+## npm (WebAssembly)
+
+```bash
+npm install @iyulab/u-insight
+```
+
+The package resolves per environment via a conditional `exports` map:
+
+| Environment | Entry |
+|---|---|
+| Bundlers (webpack, Vite, …) | ESM + WebAssembly ESM-integration (`default` condition) |
+| Node.js — `require()`, ESM `import`, CJS TS runners (`tsx`, `ts-node`) | CJS glue loading the wasm from the filesystem (`node` condition) — no loader hooks or flags |
+
 ## Related
 
 - [u-analytics](https://github.com/iyulab/u-analytics) -- Statistical analytics

package/node/u_insight.cjs

@@ -0,0 +1,782 @@
+/* @ts-self-types="./u_insight.d.cts" */
+
+/**
+ * 2-norm condition number of the sample covariance matrix.
+ *
+ * # Input
+ * ```json
+ * { "col1": [...], "col2": [...] }
+ * ```
+ *
+ * # Output
+ * `{ condition_number, names }`
+ *
+ * Standard threshold: `cond > 30` indicates multicollinearity (Belsley 1991).
+ * Returns `Infinity` for numerically singular input.
+ * @param {any} data
+ * @returns {any}
+ */
+function condition_number_diagnostic(data) {
+    const ret = wasm.condition_number_diagnostic(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.condition_number_diagnostic = condition_number_diagnostic;
+
+/**
+ * Computes a correlation matrix for a column-major dataset.
+ *
+ * # Input
+ * ```json
+ * { "col1": [1.0, 2.0, 3.0], "col2": [4.0, 5.0, 6.0], "_method": "pearson" }
+ * ```
+ *
+ * `_method` ∈ `{"pearson", "spearman", "kendall"}` — optional, defaults
+ * to `"pearson"`. Reserved key (prefix `_`) so it never collides with a
+ * column name.
+ *
+ * # Output
+ * `{ names, matrix (flattened n×n), n, high_pairs }`
+ * @param {any} data
+ * @returns {any}
+ */
+function correlation_matrix(data) {
+    const ret = wasm.correlation_matrix(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.correlation_matrix = correlation_matrix;
+
+/**
+ * Runs DBSCAN density-based clustering on row-major data.
+ *
+ * # Input
+ *
+ * `data`: row-major points `[[x,y,...], ...]`
+ *
+ * `config`: `{ "epsilon": 1.5, "min_samples": 3 }`
+ *
+ * # Output
+ *
+ * `{ labels, n_clusters, noise_count, cluster_sizes, core_points }`
+ * @param {any} data
+ * @param {any} config
+ * @returns {any}
+ */
+function dbscan(data, config) {
+    const ret = wasm.dbscan(data, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.dbscan = dbscan;
+
+/**
+ * Returns descriptive statistics for each column in a column-major dataset.
+ *
+ * # Input
+ *
+ * Accepts mixed-type columns (numbers, booleans, strings, null):
+ * ```json
+ * { "age": [30, 25, null], "name": ["Alice", "Bob", null], "active": [true, false, true] }
+ * ```
+ *
+ * Also accepts numeric-only columns (backward-compatible):
+ * ```json
+ * { "col1": [1.0, 2.0, 3.0], "col2": [4.0, 5.0, 6.0] }
+ * ```
+ *
+ * # Output
+ * Array of column profile objects, one per column.
+ * @param {any} data
+ * @returns {any}
+ */
+function describe(data) {
+    const ret = wasm.describe(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.describe = describe;
+
+/**
+ * @param {any} data
+ * @returns {any}
+ */
+function detect_univariate_outliers(data) {
+    const ret = wasm.detect_univariate_outliers(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.detect_univariate_outliers = detect_univariate_outliers;
+
+/**
+ * Runs distribution analysis on a 1-D numeric array.
+ *
+ * # Input
+ *
+ * `data`: flat array `[1.0, 2.0, 3.0, ...]`
+ *
+ * `config`: `{ "bin_method": "freedman_diaconis", "bins": null,
+ *   "significance_level": 0.05, "compute_ecdf": true, "compute_histogram": true,
+ *   "compute_qq_plot": true, "fit_distributions": false }`
+ *
+ * `bins` (optional, >= 1): explicit histogram bin count; when set it takes
+ * precedence over `bin_method`. The histogram `method` field echoes
+ * `"Fixed(n)"` in that case.
+ *
+ * # Output
+ *
+ * `{ n, ecdf, histogram, qq_plot, normality, fits }`
+ * @param {any} data
+ * @param {any} config
+ * @returns {any}
+ */
+function distribution_analysis(data, config) {
+    const ret = wasm.distribution_analysis(data, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.distribution_analysis = distribution_analysis;
+
+/**
+ * Computes feature importance using one of three methods.
+ *
+ * # Input
+ *
+ * `data`:
+ * ```json
+ * {
+ *   "features": { "f1": [1,2,3,4,5], "f2": [5,4,3,2,1] },
+ *   "target": [0, 0, 1, 1, 1],
+ *   "method": "permutation",
+ *   "n_repeats": 5,
+ *   "seed": 42
+ * }
+ * ```
+ *
+ * Methods: `"permutation"` (regression target), `"anova"` (class target),
+ * `"mutual_info"` (class target).
+ *
+ * # Output
+ *
+ * `{ method, features: [{ name, index, score, std_dev?, p_value? }], baseline_score?, selected_indices? }`
+ * @param {any} data
+ * @returns {any}
+ */
+function feature_importance(data) {
+    const ret = wasm.feature_importance(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.feature_importance = feature_importance;
+
+/**
+ * Runs hierarchical agglomerative clustering on row-major data.
+ *
+ * # Input
+ *
+ * `data`: row-major points `[[x,y,...], ...]`
+ *
+ * `config`: `{ "linkage": "ward", "n_clusters": 3 }` or
+ * `{ "linkage": "single", "distance_threshold": 5.0 }`
+ *
+ * # Output
+ *
+ * `{ merges, labels, n_clusters }`
+ * @param {any} data
+ * @param {any} config
+ * @returns {any}
+ */
+function hierarchical(data, config) {
+    const ret = wasm.hierarchical(data, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.hierarchical = hierarchical;
+
+/**
+ * Runs Isolation Forest anomaly detection on row-major data.
+ *
+ * # Input
+ *
+ * `data`: row-major points `[[x,y,...], ...]`
+ *
+ * `config`: `{ "n_estimators": 100, "contamination": 0.1, "seed": 42 }`
+ *
+ * # Output
+ *
+ * `{ scores, anomalies, threshold, anomaly_count, anomaly_fraction }`
+ * @param {any} data
+ * @param {any} config
+ * @returns {any}
+ */
+function isolation_forest(data, config) {
+    const ret = wasm.isolation_forest(data, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.isolation_forest = isolation_forest;
+
+/**
+ * Runs K-Means++ clustering on row-major data.
+ *
+ * # Input
+ * ```json
+ * [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]
+ * ```
+ *
+ * # Output
+ * `{ k, labels, centroids, wcss, iterations, cluster_sizes }`
+ * @param {any} data
+ * @param {number} k
+ * @returns {any}
+ */
+function kmeans(data, k) {
+    const ret = wasm.kmeans(data, k);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.kmeans = kmeans;
+
+/**
+ * Runs Local Outlier Factor anomaly detection on row-major data.
+ *
+ * # Input
+ *
+ * `data`: row-major points `[[x,y,...], ...]`
+ *
+ * `config`: `{ "k": 20, "threshold": 1.5 }`
+ *
+ * # Output
+ *
+ * `{ scores, anomalies, threshold, anomaly_count, anomaly_fraction }`
+ * @param {any} data
+ * @param {any} config
+ * @returns {any}
+ */
+function lof(data, config) {
+    const ret = wasm.lof(data, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.lof = lof;
+
+/**
+ * Runs Principal Component Analysis on row-major data.
+ *
+ * # Input
+ * ```json
+ * [[1.0, 0.1], [2.0, 0.2], [3.0, 0.3]]
+ * ```
+ *
+ * # Output
+ * `{ n_components, n_features, eigenvalues, explained_variance_ratio, ... }`
+ * @param {any} data
+ * @param {number} n_components
+ * @returns {any}
+ */
+function pca(data, n_components) {
+    const ret = wasm.pca(data, n_components);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pca = pca;
+
+/**
+ * Runs OLS regression analysis.
+ *
+ * # Input
+ *
+ * `data`:
+ * ```json
+ * {
+ *   "predictors": { "x1": [1,2,3,4,5], "x2": [2,4,6,8,10] },
+ *   "target": [2.1, 3.9, 6.1, 7.9, 10.1],
+ *   "target_name": "y"
+ * }
+ * ```
+ *
+ * # Output
+ *
+ * `{ target_name, predictor_names, r_squared, adj_r_squared, coefficients, p_values, vif, f_p_value }`
+ * @param {any} data
+ * @returns {any}
+ */
+function regression(data) {
+    const ret = wasm.regression(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.regression = regression;
+
+/**
+ * Computes silhouette scores for an existing clustering assignment.
+ *
+ * # Input
+ * `data`: row-major points `[[x,y,...], ...]`
+ * `labels`: cluster id per sample `[0, 0, 1, 1, ...]` (each value `< k`)
+ * `k`: number of distinct clusters
+ *
+ * # Output
+ * `{ avg, per_sample }` — `avg` is the mean silhouette across samples that
+ * had a defined silhouette; `per_sample[i]` is the silhouette of sample `i`
+ * (0.0 for singleton-cluster points).
+ *
+ * O(n²) — use sparingly on very large inputs.
+ * @param {any} data
+ * @param {any} labels
+ * @param {number} k
+ * @returns {any}
+ */
+function silhouette(data, labels, k) {
+    const ret = wasm.silhouette(data, labels, k);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.silhouette = silhouette;
+
+/**
+ * Variance Inflation Factor diagnostics for column-major numeric data.
+ *
+ * # Input
+ * ```json
+ * { "col1": [...], "col2": [...], "_threshold": 10.0 }
+ * ```
+ * `_threshold` is optional (default 10.0).
+ *
+ * # Output
+ * `{ vif_per_column, high_vif_columns, threshold, names }`
+ * @param {any} data
+ * @returns {any}
+ */
+function vif_diagnostic(data) {
+    const ret = wasm.vif_diagnostic(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.vif_diagnostic = vif_diagnostic;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_ef53bc310eb298a0: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_bigint_get_as_i64_38130e98eecd467d: function(arg0, arg1) {
+            const v = arg1;
+            const ret = typeof(v) === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_boolean_get_1a45e2c38d4d41b9: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_0accd80f45e5faa2: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_in_70a403a56e771704: function(arg0, arg1) {
+            const ret = arg0 in arg1;
+            return ret;
+        },
+        __wbg___wbindgen_is_bigint_6ffd6468a9bc44b9: function(arg0) {
+            const ret = typeof(arg0) === 'bigint';
+            return ret;
+        },
+        __wbg___wbindgen_is_function_754e9f305ff6029e: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_object_56732c2bc353f41d: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_eq_1068e624fa87f6ab: function(arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_2c56564c75129511: function(arg0, arg1) {
+            const ret = arg0 == arg1;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_9bb1761122181af2: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_string_get_72bdf95d3ae505b1: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_8a89609d89f6608a: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_done_60cf307fcc680536: function(arg0) {
+            const ret = arg0.done;
+            return ret;
+        },
+        __wbg_entries_04b37a02507f1713: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
+        __wbg_get_1f8f054ddbaa7db2: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_2b48c7d0d006a781: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_unchecked_33f6e5c9e2f2d6b2: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_instanceof_ArrayBuffer_8f49811467741499: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Map_9fc06d9a951bcee6: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_86f30649f63ef9c2: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_67c2c9c4313f4448: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
+        __wbg_isSafeInteger_66acec27e09e99a7: function(arg0) {
+            const ret = Number.isSafeInteger(arg0);
+            return ret;
+        },
+        __wbg_iterator_8732428d309e270e: function() {
+            const ret = Symbol.iterator;
+            return ret;
+        },
+        __wbg_length_4a591ecaa01354d9: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_66f1a4b2e9026940: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_new_578aeef4b6b94378: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
+        __wbg_new_ce1ab61c1c2b300d: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_d90091b82fdf5b91: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_next_9e03acdf51c4960d: function(arg0) {
+            const ret = arg0.next;
+            return ret;
+        },
+        __wbg_next_eb8ca7351fa27906: function() { return handleError(function (arg0) {
+            const ret = arg0.next();
+            return ret;
+        }, arguments); },
+        __wbg_prototypesetcall_3249fc62a0fafa30: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_dca99999bba88a9a: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbg_value_f3625092ee4b37f4: function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./u_insight_bg.js": import0,
+    };
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/u_insight_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/node/u_insight.d.cts

@@ -0,0 +1,241 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * 2-norm condition number of the sample covariance matrix.
+ *
+ * # Input
+ * ```json
+ * { "col1": [...], "col2": [...] }
+ * ```
+ *
+ * # Output
+ * `{ condition_number, names }`
+ *
+ * Standard threshold: `cond > 30` indicates multicollinearity (Belsley 1991).
+ * Returns `Infinity` for numerically singular input.
+ */
+export function condition_number_diagnostic(data: any): any;
+
+/**
+ * Computes a correlation matrix for a column-major dataset.
+ *
+ * # Input
+ * ```json
+ * { "col1": [1.0, 2.0, 3.0], "col2": [4.0, 5.0, 6.0], "_method": "pearson" }
+ * ```
+ *
+ * `_method` ∈ `{"pearson", "spearman", "kendall"}` — optional, defaults
+ * to `"pearson"`. Reserved key (prefix `_`) so it never collides with a
+ * column name.
+ *
+ * # Output
+ * `{ names, matrix (flattened n×n), n, high_pairs }`
+ */
+export function correlation_matrix(data: any): any;
+
+/**
+ * Runs DBSCAN density-based clustering on row-major data.
+ *
+ * # Input
+ *
+ * `data`: row-major points `[[x,y,...], ...]`
+ *
+ * `config`: `{ "epsilon": 1.5, "min_samples": 3 }`
+ *
+ * # Output
+ *
+ * `{ labels, n_clusters, noise_count, cluster_sizes, core_points }`
+ */
+export function dbscan(data: any, config: any): any;
+
+/**
+ * Returns descriptive statistics for each column in a column-major dataset.
+ *
+ * # Input
+ *
+ * Accepts mixed-type columns (numbers, booleans, strings, null):
+ * ```json
+ * { "age": [30, 25, null], "name": ["Alice", "Bob", null], "active": [true, false, true] }
+ * ```
+ *
+ * Also accepts numeric-only columns (backward-compatible):
+ * ```json
+ * { "col1": [1.0, 2.0, 3.0], "col2": [4.0, 5.0, 6.0] }
+ * ```
+ *
+ * # Output
+ * Array of column profile objects, one per column.
+ */
+export function describe(data: any): any;
+
+export function detect_univariate_outliers(data: any): any;
+
+/**
+ * Runs distribution analysis on a 1-D numeric array.
+ *
+ * # Input
+ *
+ * `data`: flat array `[1.0, 2.0, 3.0, ...]`
+ *
+ * `config`: `{ "bin_method": "freedman_diaconis", "bins": null,
+ *   "significance_level": 0.05, "compute_ecdf": true, "compute_histogram": true,
+ *   "compute_qq_plot": true, "fit_distributions": false }`
+ *
+ * `bins` (optional, >= 1): explicit histogram bin count; when set it takes
+ * precedence over `bin_method`. The histogram `method` field echoes
+ * `"Fixed(n)"` in that case.
+ *
+ * # Output
+ *
+ * `{ n, ecdf, histogram, qq_plot, normality, fits }`
+ */
+export function distribution_analysis(data: any, config: any): any;
+
+/**
+ * Computes feature importance using one of three methods.
+ *
+ * # Input
+ *
+ * `data`:
+ * ```json
+ * {
+ *   "features": { "f1": [1,2,3,4,5], "f2": [5,4,3,2,1] },
+ *   "target": [0, 0, 1, 1, 1],
+ *   "method": "permutation",
+ *   "n_repeats": 5,
+ *   "seed": 42
+ * }
+ * ```
+ *
+ * Methods: `"permutation"` (regression target), `"anova"` (class target),
+ * `"mutual_info"` (class target).
+ *
+ * # Output
+ *
+ * `{ method, features: [{ name, index, score, std_dev?, p_value? }], baseline_score?, selected_indices? }`
+ */
+export function feature_importance(data: any): any;
+
+/**
+ * Runs hierarchical agglomerative clustering on row-major data.
+ *
+ * # Input
+ *
+ * `data`: row-major points `[[x,y,...], ...]`
+ *
+ * `config`: `{ "linkage": "ward", "n_clusters": 3 }` or
+ * `{ "linkage": "single", "distance_threshold": 5.0 }`
+ *
+ * # Output
+ *
+ * `{ merges, labels, n_clusters }`
+ */
+export function hierarchical(data: any, config: any): any;
+
+/**
+ * Runs Isolation Forest anomaly detection on row-major data.
+ *
+ * # Input
+ *
+ * `data`: row-major points `[[x,y,...], ...]`
+ *
+ * `config`: `{ "n_estimators": 100, "contamination": 0.1, "seed": 42 }`
+ *
+ * # Output
+ *
+ * `{ scores, anomalies, threshold, anomaly_count, anomaly_fraction }`
+ */
+export function isolation_forest(data: any, config: any): any;
+
+/**
+ * Runs K-Means++ clustering on row-major data.
+ *
+ * # Input
+ * ```json
+ * [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]
+ * ```
+ *
+ * # Output
+ * `{ k, labels, centroids, wcss, iterations, cluster_sizes }`
+ */
+export function kmeans(data: any, k: number): any;
+
+/**
+ * Runs Local Outlier Factor anomaly detection on row-major data.
+ *
+ * # Input
+ *
+ * `data`: row-major points `[[x,y,...], ...]`
+ *
+ * `config`: `{ "k": 20, "threshold": 1.5 }`
+ *
+ * # Output
+ *
+ * `{ scores, anomalies, threshold, anomaly_count, anomaly_fraction }`
+ */
+export function lof(data: any, config: any): any;
+
+/**
+ * Runs Principal Component Analysis on row-major data.
+ *
+ * # Input
+ * ```json
+ * [[1.0, 0.1], [2.0, 0.2], [3.0, 0.3]]
+ * ```
+ *
+ * # Output
+ * `{ n_components, n_features, eigenvalues, explained_variance_ratio, ... }`
+ */
+export function pca(data: any, n_components: number): any;
+
+/**
+ * Runs OLS regression analysis.
+ *
+ * # Input
+ *
+ * `data`:
+ * ```json
+ * {
+ *   "predictors": { "x1": [1,2,3,4,5], "x2": [2,4,6,8,10] },
+ *   "target": [2.1, 3.9, 6.1, 7.9, 10.1],
+ *   "target_name": "y"
+ * }
+ * ```
+ *
+ * # Output
+ *
+ * `{ target_name, predictor_names, r_squared, adj_r_squared, coefficients, p_values, vif, f_p_value }`
+ */
+export function regression(data: any): any;
+
+/**
+ * Computes silhouette scores for an existing clustering assignment.
+ *
+ * # Input
+ * `data`: row-major points `[[x,y,...], ...]`
+ * `labels`: cluster id per sample `[0, 0, 1, 1, ...]` (each value `< k`)
+ * `k`: number of distinct clusters
+ *
+ * # Output
+ * `{ avg, per_sample }` — `avg` is the mean silhouette across samples that
+ * had a defined silhouette; `per_sample[i]` is the silhouette of sample `i`
+ * (0.0 for singleton-cluster points).
+ *
+ * O(n²) — use sparingly on very large inputs.
+ */
+export function silhouette(data: any, labels: any, k: number): any;
+
+/**
+ * Variance Inflation Factor diagnostics for column-major numeric data.
+ *
+ * # Input
+ * ```json
+ * { "col1": [...], "col2": [...], "_threshold": 10.0 }
+ * ```
+ * `_threshold` is optional (default 10.0).
+ *
+ * # Output
+ * `{ vif_per_column, high_vif_columns, threshold, names }`
+ */
+export function vif_diagnostic(data: any): any;

package/package.json

@@ -5,7 +5,7 @@
     "iyulab"
   ],
   "description": "Statistical analysis and data profiling engine with C FFI bindings.",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -15,18 +15,31 @@
     "u_insight_bg.wasm",
     "u_insight.js",
     "u_insight_bg.js",
-    "u_insight.d.ts"
+    "u_insight.d.ts",
+    "node"
   ],
   "main": "u_insight.js",
   "types": "u_insight.d.ts",
   "sideEffects": [
     "./u_insight.js",
-    "./snippets/*"
+    "./snippets/*",
+    "./node/u_insight.cjs"
   ],
   "keywords": [
     "statistics",
     "profiling",
     "analytics",
     "ffi"
-  ]
+  ],
+  "exports": {
+    ".": {
+      "node": {
+        "types": "./node/u_insight.d.cts",
+        "default": "./node/u_insight.cjs"
+      },
+      "types": "./u_insight.d.ts",
+      "default": "./u_insight.js"
+    },
+    "./package.json": "./package.json"
+  }
 }