linreg-core 0.4.0 → 0.5.0

package/README.md

@@ -4,8 +4,10 @@
 [![Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/jesse-anderson/linreg-core/main/.github/coverage-badge.json)](https://github.com/jesse-anderson/linreg-core/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue)](LICENSE-MIT)
 [![Crates.io](https://img.shields.io/crates/v/linreg-core?color=orange)](https://crates.io/crates/linreg-core)
+[![npm](https://img.shields.io/npm/v/linreg-core?color=red)](https://www.npmjs.com/package/linreg-core)
+[![PyPI](https://img.shields.io/pypi/v/linreg-core)](https://pypi.org/project/linreg-core/)
 [![docs.rs](https://img.shields.io/badge/docs.rs-linreg__core-green)](https://docs.rs/linreg-core)
-[![PyPI](https://img.shields.io/badge/pypi-0.4.0-blue)](https://pypi.org/project/linreg-core/)
+
 
 A lightweight, self-contained linear regression library written in Rust. Compiles to WebAssembly for browser use, Python bindings via PyO3, or runs as a native Rust crate.
 
@@ -30,17 +32,19 @@ A lightweight, self-contained linear regression library written in Rust. Compile
 ## Features
 
 ### Regression Methods
-- **OLS Regression:** Coefficients, standard errors, t-statistics, p-values, confidence intervals
-- **Ridge Regression:** L2-regularized regression with optional standardization
-- **Lasso Regression:** L1-regularized regression via coordinate descent
-- **Elastic Net:** Combined L1 + L2 regularization for variable selection with multicollinearity handling
+- **OLS Regression:** Coefficients, standard errors, t-statistics, p-values, confidence intervals, model selection criteria (AIC, BIC, log-likelihood)
+- **Ridge Regression:** L2-regularized regression with optional standardization, effective degrees of freedom, model selection criteria
+- **Lasso Regression:** L1-regularized regression via coordinate descent with automatic variable selection, convergence tracking, model selection criteria
+- **Elastic Net:** Combined L1 + L2 regularization for variable selection with multicollinearity handling, active set convergence, model selection criteria
+- **LOESS:** Locally estimated scatterplot smoothing for non-parametric curve fitting with configurable span, polynomial degree, and robust fitting
 - **Lambda Path Generation:** Create regularization paths for cross-validation
 
 ### Model Statistics
-- R-squared, Adjusted R-squared, F-statistic, F-test p-value
-- Residuals, fitted values, leverage (hat matrix diagonal)
-- Mean Squared Error (MSE)
-- Variance Inflation Factor (VIF) for multicollinearity detection
+- **Fit Metrics:** R-squared, Adjusted R-squared, F-statistic, F-test p-value
+- **Error Metrics:** Mean Squared Error (MSE), Root Mean Squared Error (RMSE), Mean Absolute Error (MAE)
+- **Model Selection:** Log-likelihood, AIC (Akaike Information Criterion), BIC (Bayesian Information Criterion)
+- **Residuals:** Raw residuals, standardized residuals, fitted values, leverage (hat matrix diagonal)
+- **Multicollinearity:** Variance Inflation Factor (VIF) for each predictor
 
 ### Diagnostic Tests
 | Category | Tests |
@@ -49,7 +53,8 @@ A lightweight, self-contained linear regression library written in Rust. Compile
 | **Heteroscedasticity** | Breusch-Pagan (Koenker variant), White Test (R & Python methods) |
 | **Normality** | Jarque-Bera, Shapiro-Wilk (n ≤ 5000), Anderson-Darling |
 | **Autocorrelation** | Durbin-Watson, Breusch-Godfrey (higher-order) |
-| **Influence** | Cook's Distance |
+| **Multicollinearity** | Variance Inflation Factor (VIF) |
+| **Influence** | Cook's Distance, DFBETAS, DFFITS |
 
 ---
 
@@ -59,7 +64,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-linreg-core = { version = "0.4", default-features = false }
+linreg-core = { version = "0.5", default-features = false }
 ```
 
 ### OLS Regression (Rust)
@@ -77,6 +82,9 @@ fn main() -> Result<(), linreg_core::Error> {
     println!("Coefficients: {:?}", result.coefficients);
     println!("R-squared: {:.4}", result.r_squared);
     println!("F-statistic: {:.4}", result.f_statistic);
+    println!("Log-likelihood: {:.4}", result.log_likelihood);
+    println!("AIC: {:.4}", result.aic);
+    println!("BIC: {:.4}", result.bic);
 
     Ok(())
 }
@@ -107,6 +115,10 @@ fn main() -> Result<(), linreg_core::Error> {
     let result = ridge_fit(&x, &y, &options)?;
     println!("Intercept: {}", result.intercept);
     println!("Coefficients: {:?}", result.coefficients);
+    println!("R-squared: {:.4}", result.r_squared);
+    println!("Effective degrees of freedom: {:.2}", result.effective_df);
+    println!("AIC: {:.4}", result.aic);
+    println!("BIC: {:.4}", result.bic);
 
     Ok(())
 }
@@ -139,6 +151,8 @@ fn main() -> Result<(), linreg_core::Error> {
     println!("Intercept: {}", result.intercept);
     println!("Coefficients: {:?}", result.coefficients);
     println!("Non-zero coefficients: {}", result.n_nonzero);
+    println!("AIC: {:.4}", result.aic);
+    println!("BIC: {:.4}", result.bic);
 
     Ok(())
 }
@@ -172,6 +186,8 @@ fn main() -> Result<(), linreg_core::Error> {
     println!("Intercept: {}", result.intercept);
     println!("Coefficients: {:?}", result.coefficients);
     println!("Non-zero coefficients: {}", result.n_nonzero);
+    println!("AIC: {:.4}", result.aic);
+    println!("BIC: {:.4}", result.bic);
 
     Ok(())
 }
@@ -265,6 +281,9 @@ async function run() {
     const result = JSON.parse(resultJson);
     console.log("Coefficients:", result.coefficients);
     console.log("R-squared:", result.r_squared);
+    console.log("Log-likelihood:", result.log_likelihood);
+    console.log("AIC:", result.aic);
+    console.log("BIC:", result.bic);
 }
 
 run();
@@ -282,6 +301,10 @@ const result = JSON.parse(ridge_regression(
 ));
 
 console.log("Coefficients:", result.coefficients);
+console.log("R-squared:", result.r_squared);
+console.log("Effective degrees of freedom:", result.effective_df);
+console.log("AIC:", result.aic);
+console.log("BIC:", result.bic);
 ```
 
 ### Lasso Regression (WASM)
@@ -299,6 +322,8 @@ const result = JSON.parse(lasso_regression(
 
 console.log("Coefficients:", result.coefficients);
 console.log("Non-zero coefficients:", result.n_nonzero);
+console.log("AIC:", result.aic);
+console.log("BIC:", result.bic);
 ```
 
 ### Elastic Net Regression (WASM)
@@ -317,6 +342,8 @@ const result = JSON.parse(elastic_net_regression(
 
 console.log("Coefficients:", result.coefficients);
 console.log("Non-zero coefficients:", result.n_nonzero);
+console.log("AIC:", result.aic);
+console.log("BIC:", result.bic);
 ```
 
 ### Lambda Path Generation (WASM)
@@ -333,6 +360,22 @@ console.log("Lambda sequence:", path.lambda_path);
 console.log("Lambda max:", path.lambda_max);
 ```
 
+### LOESS Regression (WASM)
+
+```javascript
+const result = JSON.parse(loess_fit(
+    JSON.stringify(y),
+    JSON.stringify(x[0]),    // Single predictor only (flattened array)
+    0.5,      // span (smoothing parameter: 0-1)
+    1,        // degree (0=constant, 1=linear, 2=quadratic)
+    "direct", // surface method ("direct" or "interpolate")
+    0         // robust iterations (0=disabled, >0=number of iterations)
+));
+
+console.log("Fitted values:", result.fitted_values);
+console.log("Residuals:", result.residuals);
+```
+
 ### Diagnostic Tests (WASM)
 
 ```javascript
@@ -405,6 +448,25 @@ const cd = JSON.parse(cooks_distance_test(
     JSON.stringify(x)
 ));
 
+// DFBETAS (influence on coefficients)
+const dfbetas = JSON.parse(dfbetas_test(
+    JSON.stringify(y),
+    JSON.stringify(x)
+));
+
+// DFFITS (influence on fitted values)
+const dffits = JSON.parse(dffits_test(
+    JSON.stringify(y),
+    JSON.stringify(x)
+));
+
+// VIF test (multicollinearity)
+const vif = JSON.parse(vif_test(
+    JSON.stringify(y),
+    JSON.stringify(x)
+));
+console.log("VIF values:", vif.vif_values);
+
 // RESET test (functional form)
 const reset = JSON.parse(reset_test(
     JSON.stringify(y),
@@ -458,7 +520,7 @@ console.log("Numeric columns:", parsed.numeric_columns);
 ### Helper Functions (WASM)
 
 ```javascript
-const version = get_version();  // e.g., "0.4.0"
+const version = get_version();  // e.g., "0.5.0"
 const msg = test();             // "Rust WASM is working!"
 ```
 
@@ -519,7 +581,7 @@ print(result.summary())
 ```
 
 **Result objects** provide:
-- Direct attribute access (`result.r_squared`, `result.coefficients`)
+- Direct attribute access (`result.r_squared`, `result.coefficients`, `result.aic`, `result.bic`, `result.log_likelihood`)
 - `summary()` method for formatted output
 - `to_dict()` method for JSON serialization
 
@@ -536,6 +598,9 @@ result = linreg_core.ols_regression(y, x, names)
 print(f"Coefficients: {result.coefficients}")
 print(f"R-squared: {result.r_squared}")
 print(f"F-statistic: {result.f_statistic}")
+print(f"Log-likelihood: {result.log_likelihood}")
+print(f"AIC: {result.aic}")
+print(f"BIC: {result.bic}")
 ```
 
 ### Ridge Regression (Python)
@@ -548,6 +613,9 @@ result = linreg_core.ridge_regression(
 )
 print(f"Intercept: {result.intercept}")
 print(f"Coefficients: {result.coefficients}")
+print(f"Effective degrees of freedom: {result.effective_df:.2f}")
+print(f"AIC: {result.aic}")
+print(f"BIC: {result.bic}")
 ```
 
 ### Lasso Regression (Python)
@@ -564,6 +632,8 @@ print(f"Intercept: {result.intercept}")
 print(f"Coefficients: {result.coefficients}")
 print(f"Non-zero: {result.n_nonzero}")
 print(f"Converged: {result.converged}")
+print(f"AIC: {result.aic}")
+print(f"BIC: {result.bic}")
 ```
 
 ### Elastic Net Regression (Python)
@@ -580,6 +650,8 @@ result = linreg_core.elastic_net_regression(
 print(f"Intercept: {result.intercept}")
 print(f"Coefficients: {result.coefficients}")
 print(f"Non-zero: {result.n_nonzero}")
+print(f"AIC: {result.aic}")
+print(f"BIC: {result.bic}")
 ```
 
 ### Lambda Path Generation (Python)
@@ -631,6 +703,16 @@ ad = linreg_core.anderson_darling_test(y, x)
 cd = linreg_core.cooks_distance_test(y, x)
 print(f"Influential points: {cd.influential_4_over_n}")
 
+# DFBETAS (influence on each coefficient)
+dfbetas = linreg_core.dfbetas_test(y, x)
+print(f"Threshold: {dfbetas.threshold}")
+print(f"Influential obs: {dfbetas.influential_observations}")
+
+# DFFITS (influence on fitted values)
+dffits = linreg_core.dffits_test(y, x)
+print(f"Threshold: {dffits.threshold}")
+print(f"Influential obs: {dffits.influential_observations}")
+
 # RESET test (model specification)
 reset = linreg_core.reset_test(y, x, [2, 3], "fitted")
 
@@ -698,7 +780,7 @@ print(f"Data rows: {result.n_rows}")
 For native Rust without WASM overhead:
 
 ```toml
-linreg-core = { version = "0.4", default-features = false }
+linreg-core = { version = "0.5", default-features = false }
 ```
 
 For Python bindings (built with maturin):

package/linreg_core.d.ts

@@ -95,6 +95,50 @@ export function breusch_pagan_test(y_json: string, x_vars_json: string): string;
  */
 export function cooks_distance_test(y_json: string, x_vars_json: string): string;
 
+/**
+ * Performs DFBETAS analysis via WASM.
+ *
+ * DFBETAS measures the influence of each observation on each regression coefficient.
+ * For each observation and each coefficient, it computes the standardized change
+ * in the coefficient when that observation is omitted.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ *
+ * # Returns
+ *
+ * JSON string containing the DFBETAS matrix, threshold, and influential observations.
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails or domain check fails.
+ */
+export function dfbetas_test(y_json: string, x_vars_json: string): string;
+
+/**
+ * Performs DFFITS analysis via WASM.
+ *
+ * DFFITS measures the influence of each observation on its own fitted value.
+ * It is the standardized change in the fitted value when that observation
+ * is omitted from the model.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ *
+ * # Returns
+ *
+ * JSON string containing the DFFITS vector, threshold, and influential observations.
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails or domain check fails.
+ */
+export function dffits_test(y_json: string, x_vars_json: string): string;
+
 /**
  * Performs the Durbin-Watson test for autocorrelation via WASM.
  *
@@ -283,6 +327,65 @@ export function jarque_bera_test(y_json: string, x_vars_json: string): string;
  */
 export function lasso_regression(y_json: string, x_vars_json: string, _variable_names: string, lambda: number, standardize: boolean, max_iter: number, tol: number): string;
 
+/**
+ * Performs LOESS regression via WASM.
+ *
+ * LOESS (Locally Estimated Scatterplot Smoothing) is a non-parametric
+ * regression method that fits multiple regressions in local subsets
+ * of data to create a smooth curve through the data points.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `span` - Fraction of data used in each local fit (0.0 to 1.0)
+ * * `degree` - Degree of local polynomial: 0 (constant), 1 (linear), or 2 (quadratic)
+ * * `robust_iterations` - Number of robustness iterations (0 for non-robust fit)
+ * * `surface` - Surface computation method: "direct" or "interpolate"
+ *
+ * # Returns
+ *
+ * JSON string containing:
+ * - `fitted` - Fitted values at each observation point
+ * - `span` - Span parameter used
+ * - `degree` - Degree of polynomial used
+ * - `robust_iterations` - Number of robustness iterations performed
+ * - `surface` - Surface computation method used
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails or domain check fails.
+ */
+export function loess_fit(y_json: string, x_vars_json: string, span: number, degree: number, robust_iterations: number, surface: string): string;
+
+/**
+ * Performs LOESS prediction at new query points via WASM.
+ *
+ * Predicts LOESS fitted values at arbitrary new points by redoing the
+ * local fitting at each query point using the original training data.
+ *
+ * # Arguments
+ *
+ * * `new_x_json` - JSON array of new predictor values (p vectors, each of length m)
+ * * `original_x_json` - JSON array of original training predictors
+ * * `original_y_json` - JSON array of original training response values
+ * * `span` - Span parameter (must match the original fit)
+ * * `degree` - Degree of polynomial (must match the original fit)
+ * * `robust_iterations` - Robustness iterations (must match the original fit)
+ * * `surface` - Surface computation method: "direct" or "interpolate"
+ *
+ * # Returns
+ *
+ * JSON string containing:
+ * - `predictions` - Vector of predicted values at query points
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters don't match
+ * the original fit, or domain check fails.
+ */
+export function loess_predict(new_x_json: string, original_x_json: string, original_y_json: string, span: number, degree: number, robust_iterations: number, surface: string): string;
+
 /**
  * Generates a lambda path for regularized regression via WASM.
  *
@@ -652,6 +755,35 @@ export function test_r_accuracy(): string;
  */
 export function test_t_critical(df: number, alpha: number): string;
 
+/**
+ * Performs Variance Inflation Factor (VIF) analysis via WASM.
+ *
+ * VIF measures how much the variance of regression coefficients is inflated
+ * due to multicollinearity among predictor variables. High VIF values indicate
+ * that a predictor is highly correlated with other predictors.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ *
+ * # Returns
+ *
+ * JSON string containing the maximum VIF, detailed VIF results for each predictor,
+ * interpretation, and guidance.
+ *
+ * # Interpretation
+ *
+ * - VIF = 1: No correlation with other predictors
+ * - VIF > 5: Moderate multicollinearity (concerning)
+ * - VIF > 10: High multicollinearity (severe)
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails or domain check fails.
+ */
+export function vif_test(y_json: string, x_vars_json: string): string;
+
 /**
  * Performs the White test for heteroscedasticity via WASM.
  *
@@ -683,12 +815,16 @@ export interface InitOutput {
     readonly breusch_godfrey_test: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly breusch_pagan_test: (a: number, b: number, c: number, d: number) => [number, number];
     readonly cooks_distance_test: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly dfbetas_test: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly dffits_test: (a: number, b: number, c: number, d: number) => [number, number];
     readonly durbin_watson_test: (a: number, b: number, c: number, d: number) => [number, number];
     readonly elastic_net_regression: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
     readonly get_version: () => [number, number];
     readonly harvey_collier_test: (a: number, b: number, c: number, d: number) => [number, number];
     readonly jarque_bera_test: (a: number, b: number, c: number, d: number) => [number, number];
     readonly lasso_regression: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly loess_fit: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
+    readonly loess_predict: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
     readonly make_lambda_path: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly ols_regression: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly parse_csv: (a: number, b: number) => [number, number];
@@ -709,6 +845,7 @@ export interface InitOutput {
     readonly test_housing_regression: () => [number, number];
     readonly test_r_accuracy: () => [number, number];
     readonly test_t_critical: (a: number, b: number) => [number, number];
+    readonly vif_test: (a: number, b: number, c: number, d: number) => [number, number];
     readonly white_test: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly get_t_cdf: (a: number, b: number) => number;
     readonly get_t_critical: (a: number, b: number) => number;

package/linreg_core.js

@@ -170,6 +170,86 @@ export function cooks_distance_test(y_json, x_vars_json) {
     }
 }
 
+/**
+ * Performs DFBETAS analysis via WASM.
+ *
+ * DFBETAS measures the influence of each observation on each regression coefficient.
+ * For each observation and each coefficient, it computes the standardized change
+ * in the coefficient when that observation is omitted.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ *
+ * # Returns
+ *
+ * JSON string containing the DFBETAS matrix, threshold, and influential observations.
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails or domain check fails.
+ * @param {string} y_json
+ * @param {string} x_vars_json
+ * @returns {string}
+ */
+export function dfbetas_test(y_json, x_vars_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(y_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(x_vars_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.dfbetas_test(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Performs DFFITS analysis via WASM.
+ *
+ * DFFITS measures the influence of each observation on its own fitted value.
+ * It is the standardized change in the fitted value when that observation
+ * is omitted from the model.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ *
+ * # Returns
+ *
+ * JSON string containing the DFFITS vector, threshold, and influential observations.
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails or domain check fails.
+ * @param {string} y_json
+ * @param {string} x_vars_json
+ * @returns {string}
+ */
+export function dffits_test(y_json, x_vars_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(y_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(x_vars_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.dffits_test(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Performs the Durbin-Watson test for autocorrelation via WASM.
  *
@@ -492,6 +572,116 @@ export function lasso_regression(y_json, x_vars_json, _variable_names, lambda, s
     }
 }
 
+/**
+ * Performs LOESS regression via WASM.
+ *
+ * LOESS (Locally Estimated Scatterplot Smoothing) is a non-parametric
+ * regression method that fits multiple regressions in local subsets
+ * of data to create a smooth curve through the data points.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `span` - Fraction of data used in each local fit (0.0 to 1.0)
+ * * `degree` - Degree of local polynomial: 0 (constant), 1 (linear), or 2 (quadratic)
+ * * `robust_iterations` - Number of robustness iterations (0 for non-robust fit)
+ * * `surface` - Surface computation method: "direct" or "interpolate"
+ *
+ * # Returns
+ *
+ * JSON string containing:
+ * - `fitted` - Fitted values at each observation point
+ * - `span` - Span parameter used
+ * - `degree` - Degree of polynomial used
+ * - `robust_iterations` - Number of robustness iterations performed
+ * - `surface` - Surface computation method used
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails or domain check fails.
+ * @param {string} y_json
+ * @param {string} x_vars_json
+ * @param {number} span
+ * @param {number} degree
+ * @param {number} robust_iterations
+ * @param {string} surface
+ * @returns {string}
+ */
+export function loess_fit(y_json, x_vars_json, span, degree, robust_iterations, surface) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(y_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(x_vars_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(surface, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.loess_fit(ptr0, len0, ptr1, len1, span, degree, robust_iterations, ptr2, len2);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Performs LOESS prediction at new query points via WASM.
+ *
+ * Predicts LOESS fitted values at arbitrary new points by redoing the
+ * local fitting at each query point using the original training data.
+ *
+ * # Arguments
+ *
+ * * `new_x_json` - JSON array of new predictor values (p vectors, each of length m)
+ * * `original_x_json` - JSON array of original training predictors
+ * * `original_y_json` - JSON array of original training response values
+ * * `span` - Span parameter (must match the original fit)
+ * * `degree` - Degree of polynomial (must match the original fit)
+ * * `robust_iterations` - Robustness iterations (must match the original fit)
+ * * `surface` - Surface computation method: "direct" or "interpolate"
+ *
+ * # Returns
+ *
+ * JSON string containing:
+ * - `predictions` - Vector of predicted values at query points
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters don't match
+ * the original fit, or domain check fails.
+ * @param {string} new_x_json
+ * @param {string} original_x_json
+ * @param {string} original_y_json
+ * @param {number} span
+ * @param {number} degree
+ * @param {number} robust_iterations
+ * @param {string} surface
+ * @returns {string}
+ */
+export function loess_predict(new_x_json, original_x_json, original_y_json, span, degree, robust_iterations, surface) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(new_x_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(original_x_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(original_y_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(surface, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.loess_predict(ptr0, len0, ptr1, len1, ptr2, len2, span, degree, robust_iterations, ptr3, len3);
+        deferred5_0 = ret[0];
+        deferred5_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+
 /**
  * Generates a lambda path for regularized regression via WASM.
  *
@@ -1200,6 +1390,53 @@ export function test_t_critical(df, alpha) {
     }
 }
 
+/**
+ * Performs Variance Inflation Factor (VIF) analysis via WASM.
+ *
+ * VIF measures how much the variance of regression coefficients is inflated
+ * due to multicollinearity among predictor variables. High VIF values indicate
+ * that a predictor is highly correlated with other predictors.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ *
+ * # Returns
+ *
+ * JSON string containing the maximum VIF, detailed VIF results for each predictor,
+ * interpretation, and guidance.
+ *
+ * # Interpretation
+ *
+ * - VIF = 1: No correlation with other predictors
+ * - VIF > 5: Moderate multicollinearity (concerning)
+ * - VIF > 10: High multicollinearity (severe)
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails or domain check fails.
+ * @param {string} y_json
+ * @param {string} x_vars_json
+ * @returns {string}
+ */
+export function vif_test(y_json, x_vars_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(y_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(x_vars_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.vif_test(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Performs the White test for heteroscedasticity via WASM.
  *

package/package.json

@@ -5,7 +5,7 @@
     "Jesse Anderson"
   ],
   "description": "Lightweight linear regression (OLS, Ridge, Lasso, Elastic Net) with diagnostic tests. Pure Rust - no external math dependencies.",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",