linreg-core 0.6.0 → 0.6.1

package/README.md

@@ -7,6 +7,7 @@
 [![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)
+[![Live Demo](https://img.shields.io/badge/demo-online-brightgreen)](https://jesse-anderson.net/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.
@@ -37,6 +38,8 @@ A lightweight, self-contained linear regression library written in Rust. Compile
 - **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
+- **WLS (Weighted Least Squares):** Regression with observation weights for heteroscedastic data, includes confidence intervals
+- **K-Fold Cross Validation:** Model evaluation and hyperparameter tuning for all regression types (OLS, Ridge, Lasso, Elastic Net) with customizable folds, shuffling, and seeding
 - **Lambda Path Generation:** Create regularization paths for cross-validation
 
 ### Model Statistics
@@ -64,7 +67,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-linreg-core = { version = "0.5", default-features = false }
+linreg-core = { version = "0.6", default-features = false }
 ```
 
 ### OLS Regression (Rust)
@@ -198,35 +201,199 @@ fn main() -> Result<(), linreg_core::Error> {
 ```rust
 use linreg_core::diagnostics::{
     breusch_pagan_test, durbin_watson_test, jarque_bera_test,
-    shapiro_wilk_test, RainbowMethod, rainbow_test
+    shapiro_wilk_test, rainbow_test, harvey_collier_test,
+    white_test, anderson_darling_test, breusch_godfrey_test,
+    cooks_distance_test, dfbetas_test, dffits_test, vif_test,
+    reset_test, BGTestType, RainbowMethod, ResetType, WhiteMethod
 };
 
 fn main() -> Result<(), linreg_core::Error> {
     let y = vec![/* your data */];
     let x = vec![vec![/* predictor 1 */], vec![/* predictor 2 */]];
 
-    // Heteroscedasticity
+    // Heteroscedasticity tests
     let bp = breusch_pagan_test(&y, &x)?;
     println!("Breusch-Pagan: LM={:.4}, p={:.4}", bp.statistic, bp.p_value);
 
-    // Autocorrelation
+    let white = white_test(&y, &x, WhiteMethod::R)?;
+    println!("White: statistic={:.4}, p={:.4}", white.statistic, white.p_value);
+
+    // Autocorrelation tests
     let dw = durbin_watson_test(&y, &x)?;
     println!("Durbin-Watson: {:.4}", dw.statistic);
 
-    // Normality
+    let bg = breusch_godfrey_test(&y, &x, 2, BGTestType::Chisq)?;
+    println!("Breusch-Godfrey (order 2): statistic={:.4}, p={:.4}", bg.statistic, bg.p_value);
+
+    // Normality tests
     let jb = jarque_bera_test(&y, &x)?;
     println!("Jarque-Bera: JB={:.4}, p={:.4}", jb.statistic, jb.p_value);
 
-    // Linearity
+    let sw = shapiro_wilk_test(&y, &x)?;
+    println!("Shapiro-Wilk: W={:.4}, p={:.4}", sw.statistic, sw.p_value);
+
+    let ad = anderson_darling_test(&y, &x)?;
+    println!("Anderson-Darling: A={:.4}, p={:.4}", ad.statistic, ad.p_value);
+
+    // Linearity tests
     let rainbow = rainbow_test(&y, &x, 0.5, RainbowMethod::R)?;
     println!("Rainbow: F={:.4}, p={:.4}",
         rainbow.r_result.as_ref().unwrap().statistic,
         rainbow.r_result.as_ref().unwrap().p_value);
 
+    let hc = harvey_collier_test(&y, &x)?;
+    println!("Harvey-Collier: t={:.4}, p={:.4}", hc.statistic, hc.p_value);
+
+    let reset = reset_test(&y, &x, &[2, 3], ResetType::Fitted)?;
+    println!("RESET: F={:.4}, p={:.4}", reset.f_statistic, reset.p_value);
+
+    // Influence diagnostics
+    let cd = cooks_distance_test(&y, &x)?;
+    println!("Cook's Distance: {} influential points", cd.influential_4_over_n.len());
+
+    let dfbetas = dfbetas_test(&y, &x)?;
+    println!("DFBETAS: {} influential observations", dfbetas.influential_observations.len());
+
+    let dffits = dffits_test(&y, &x)?;
+    println!("DFFITS: {} influential observations", dffits.influential_observations.len());
+
+    // Multicollinearity
+    let vif = vif_test(&y, &x)?;
+    println!("VIF: {:?}", vif.vif_values);
+
+    Ok(())
+}
+```
+
+### WLS Regression (Rust)
+
+```rust,no_run
+use linreg_core::weighted_regression::wls_regression;
+
+fn main() -> Result<(), linreg_core::Error> {
+    let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
+    let x1 = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+
+    // Equal weights = OLS
+    let weights = vec![1.0, 1.0, 1.0, 1.0, 1.0];
+
+    let fit = wls_regression(&y, &[x1], &weights)?;
+
+    println!("Intercept: {} (SE: {}, t: {}, p: {})",
+        fit.coefficients[0],
+        fit.standard_errors[0],
+        fit.t_statistics[0],
+        fit.p_values[0]
+    );
+    println!("F-statistic: {} (p: {})", fit.f_statistic, fit.f_p_value);
+    println!("R-squared: {:.4}", fit.r_squared);
+
+    // Access confidence intervals
+    for (i, (&coef, &lower, &upper)) in fit.coefficients.iter()
+        .zip(fit.conf_int_lower.iter())
+        .zip(fit.conf_int_upper.iter())
+        .enumerate()
+    {
+        println!("Coefficient {}: [{}, {}]", i, lower, upper);
+    }
+
+    Ok(())
+}
+```
+
+### LOESS Regression (Rust)
+
+```rust,no_run
+use linreg_core::loess::{loess_fit, LoessOptions};
+
+fn main() -> Result<(), linreg_core::Error> {
+    // Single predictor only
+    let x = vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
+    let y = vec![1.0, 3.5, 4.8, 6.2, 8.5, 11.0, 13.2, 14.8, 17.5, 19.0, 22.0];
+
+    // Default options: span=0.75, degree=2, robust iterations=0
+    let options = LoessOptions::default();
+
+    let result = loess_fit(&y, &[x], &options)?;
+
+    println!("Fitted values: {:?}", result.fitted_values);
+    println!("Residuals: {:?}", result.residuals);
+
     Ok(())
 }
 ```
 
+**Custom LOESS options:**
+
+```rust,no_run
+use linreg_core::loess::{loess_fit, LoessOptions, LoessSurface};
+
+let options = LoessOptions {
+    span: 0.5,              // Smoothing parameter (0-1, smaller = less smooth)
+    degree: 1,              // Polynomial degree (0=constant, 1=linear, 2=quadratic)
+    surface: LoessSurface::Direct,  // Note: only "direct" is currently supported; "interpolate" is planned
+    robust_iterations: 3,   // Number of robust fitting iterations (0 = disabled)
+};
+
+let result = loess_fit(&y, &[x], &options)?;
+```
+
+### K-Fold Cross Validation (Rust)
+
+Cross-validation is used for model evaluation and hyperparameter tuning. The library supports K-Fold CV for all regression types:
+
+```rust,no_run
+use linreg_core::cross_validation::{kfold_cv_ols, kfold_cv_ridge, kfold_cv_lasso, kfold_cv_elastic_net, KFoldOptions};
+
+fn main() -> Result<(), linreg_core::Error> {
+    let y = vec![2.5, 3.7, 4.2, 5.1, 6.3, 7.0, 7.5, 8.1];
+    let x1 = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+    let x2 = vec![2.0, 4.0, 5.0, 4.0, 3.0, 4.5, 5.5, 6.0];
+    let names = vec!["Intercept".to_string(), "X1".to_string(), "X2".to_string()];
+
+    // Configure CV options
+    let options = KFoldOptions {
+        n_folds: 5,
+        shuffle: true,
+        seed: Some(42),  // For reproducibility
+    };
+
+    // OLS cross-validation
+    let ols_cv = kfold_cv_ols(&y, &[x1.clone(), x2.clone()], &names, &options)?;
+    println!("OLS CV RMSE: {:.4} (±{:.4})", ols_cv.mean_rmse, ols_cv.std_rmse);
+    println!("OLS CV R²: {:.4} (±{:.4})", ols_cv.mean_r_squared, ols_cv.std_r_squared);
+
+    // Ridge cross-validation (for lambda selection)
+    let lambda = 1.0;
+    let ridge_cv = kfold_cv_ridge(&[x1.clone(), x2.clone()], &y, lambda, true, &options)?;
+    println!("Ridge CV RMSE: {:.4}", ridge_cv.mean_rmse);
+
+    // Lasso cross-validation
+    let lasso_cv = kfold_cv_lasso(&[x1.clone(), x2.clone()], &y, 0.1, true, &options)?;
+    println!("Lasso CV RMSE: {:.4}", lasso_cv.mean_rmse);
+
+    // Elastic Net cross-validation
+    let enet_cv = kfold_cv_elastic_net(&[x1, x2], &y, 0.1, 0.5, true, &options)?;
+    println!("Elastic Net CV RMSE: {:.4}", enet_cv.mean_rmse);
+
+    // Access per-fold results
+    for fold in &ols_cv.fold_results {
+        println!("Fold {}: train={}, test={}, R²={:.4}",
+            fold.fold_index, fold.train_size, fold.test_size, fold.r_squared);
+    }
+
+    Ok(())
+}
+```
+
+**CV Result fields:**
+- `mean_rmse`, `std_rmse` - Mean and std of RMSE across folds
+- `mean_mae`, `std_mae` - Mean and std of MAE across folds
+- `mean_r_squared`, `std_r_squared` - Mean and std of R² across folds
+- `mean_train_r_squared` - Mean training R² (for overfitting detection)
+- `fold_results` - Per-fold metrics (train/test sizes, MSE, RMSE, MAE, R²)
+- `fold_coefficients` - Coefficients from each fold (for stability analysis)
+
 ### Lambda Path Generation (Rust)
 
 ```rust,no_run
@@ -250,10 +417,34 @@ for &lambda in lambdas.iter() {
 }
 ```
 
+### Model Save/Load (Rust)
+
+All trained models can be saved to disk and loaded back later:
+
+```rust,no_run
+use linreg_core::{ModelSave, ModelLoad};
+
+// Train a model
+let result = ols_regression(&y, &[x1], &names)?;
+
+// Save to file
+result.save("my_model.json")?;
+
+// Or with a custom name
+result.save_with_name("my_model.json", Some("My Housing Model".to_string()))?;
+
+// Load back
+let loaded = linreg_core::core::RegressionOutput::load("my_model.json")?;
+```
+
+The same `save()` and `load()` methods work for all model types: `RegressionOutput`, `RidgeFit`, `LassoFit`, `ElasticNetFit`, `WlsFit`, and `LoessFit`.
+
 ---
 
 ## WebAssembly Usage
 
+**[Live Demo →](https://jesse-anderson.net/linreg-core/)**
+
 Build with wasm-pack:
 
 ```bash
@@ -360,6 +551,24 @@ console.log("Lambda sequence:", path.lambda_path);
 console.log("Lambda max:", path.lambda_max);
 ```
 
+### WLS Regression (WASM)
+
+```javascript
+const result = JSON.parse(wls_regression(
+    JSON.stringify([2, 4, 6, 8, 10]),
+    JSON.stringify([[1, 2, 3, 4, 5]]),
+    JSON.stringify([1, 1, 1, 1, 1])  // weights (equal weights = OLS)
+));
+
+console.log("Coefficients:", result.coefficients);
+console.log("Standard errors:", result.standard_errors);
+console.log("P-values:", result.p_values);
+console.log("R-squared:", result.r_squared);
+console.log("F-statistic:", result.f_statistic);
+console.log("Confidence intervals (lower):", result.conf_int_lower);
+console.log("Confidence intervals (upper):", result.conf_int_upper);
+```
+
 ### LOESS Regression (WASM)
 
 ```javascript
@@ -368,7 +577,7 @@ const result = JSON.parse(loess_fit(
     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")
+    "direct", // surface method ("direct" only; "interpolate" is planned)
     0         // robust iterations (0=disabled, >0=number of iterations)
 ));
 
@@ -376,6 +585,64 @@ console.log("Fitted values:", result.fitted_values);
 console.log("Residuals:", result.residuals);
 ```
 
+### K-Fold Cross Validation (WASM)
+
+```javascript
+// OLS cross-validation
+const ols_cv = JSON.parse(kfold_cv_ols(
+    JSON.stringify(y),
+    JSON.stringify(x),
+    JSON.stringify(["Intercept", "X1", "X2"]),
+    5,         // n_folds
+    "true",    // shuffle (JSON boolean)
+    "42"       // seed (JSON string number, or "null" for no seed)
+));
+
+console.log("OLS CV RMSE:", ols_cv.mean_rmse, "±", ols_cv.std_rmse);
+console.log("OLS CV R²:", ols_cv.mean_r_squared, "±", ols_cv.std_r_squared);
+
+// Ridge cross-validation
+const ridge_cv = JSON.parse(kfold_cv_ridge(
+    JSON.stringify(y),
+    JSON.stringify(x),
+    1.0,       // lambda
+    true,      // standardize
+    5,         // n_folds
+    "true",    // shuffle
+    "42"       // seed
+));
+
+// Lasso cross-validation
+const lasso_cv = JSON.parse(kfold_cv_lasso(
+    JSON.stringify(y),
+    JSON.stringify(x),
+    0.1,       // lambda
+    true,      // standardize
+    5,         // n_folds
+    "true",    // shuffle
+    "42"       // seed
+));
+
+// Elastic Net cross-validation
+const enet_cv = JSON.parse(kfold_cv_elastic_net(
+    JSON.stringify(y),
+    JSON.stringify(x),
+    0.1,       // lambda
+    0.5,       // alpha (0 = Ridge, 1 = Lasso)
+    true,      // standardize
+    5,         // n_folds
+    "true",    // shuffle
+    "42"       // seed
+));
+
+// Access per-fold results
+ols_cv.fold_results.forEach(fold => {
+    console.log(`Fold ${fold.fold_index}: R²=${fold.r_squared.toFixed(4)}`);
+});
+```
+
+**Note:** In WASM, boolean and seed parameters are passed as JSON strings. Use `"true"`/`"false"` for shuffle and `"42"` or `"null"` for seed.
+
 ### Diagnostic Tests (WASM)
 
 ```javascript
@@ -524,6 +791,43 @@ const version = get_version();  // e.g., "0.5.0"
 const msg = test();             // "Rust WASM is working!"
 ```
 
+### Model Serialization (WASM)
+
+```javascript
+// Train a model
+const resultJson = ols_regression(
+    JSON.stringify(y),
+    JSON.stringify(x),
+    JSON.stringify(names)
+);
+const result = JSON.parse(resultJson);
+
+// Serialize with metadata
+const serialized = serialize_model(
+    resultJson,        // model JSON
+    "OLS",             // model type: "OLS", "Ridge", "Lasso", "ElasticNet", "WLS", "LOESS"
+    "My Model"         // optional name (null to omit)
+);
+
+// Get metadata without loading full model
+const metadataJson = get_model_metadata(serialized);
+const metadata = JSON.parse(metadataJson);
+console.log("Model type:", metadata.model_type);
+console.log("Created:", metadata.created_at);
+
+// Deserialize to get model data back
+const modelJson = deserialize_model(serialized);
+const model = JSON.parse(modelJson);
+
+// Download in browser
+const blob = new Blob([serialized], { type: 'application/json' });
+const url = URL.createObjectURL(blob);
+const a = document.createElement('a');
+a.href = url;
+a.download = 'model.json';
+a.click();
+```
+
 ### Domain Security (WASM)
 
 Optional domain restriction via build-time environment variable:
@@ -654,6 +958,20 @@ print(f"AIC: {result.aic}")
 print(f"BIC: {result.bic}")
 ```
 
+### LOESS Regression (Python)
+
+```python
+result = linreg_core.loess_fit(
+    y,           # Single predictor only
+    [0.5],       # span (smoothing parameter: 0-1)
+    2,           # degree (0=constant, 1=linear, 2=quadratic)
+    "direct",    # surface ("direct" only; "interpolate" is planned)
+    0            # robust iterations (0=disabled, >0=number of iterations)
+)
+print(f"Fitted values: {result.fitted_values}")
+print(f"Residuals: {result.residuals}")
+```
+
 ### Lambda Path Generation (Python)
 
 ```python
@@ -767,6 +1085,23 @@ print(f"Numeric columns: {result.numeric_columns}")
 print(f"Data rows: {result.n_rows}")
 ```
 
+### Model Save/Load (Python)
+
+```python
+# Train a model
+result = linreg_core.ols_regression(y, x, names)
+
+# Save to file
+linreg_core.save_model(result, "my_model.json", name="My Housing Model")
+
+# Load back
+loaded = linreg_core.load_model("my_model.json")
+print(f"R²: {loaded.r_squared}")
+print(f"Coefficients: {loaded.coefficients}")
+```
+
+The `save_model()` and `load_model()` functions work with all result types: `OLSResult`, `RidgeResult`, `LassoResult`, `ElasticNetResult`, `LoessResult`, and `WlsResult`.
+
 ---
 
 ## Feature Flags
@@ -780,7 +1115,7 @@ print(f"Data rows: {result.n_rows}")
 For native Rust without WASM overhead:
 
 ```toml
-linreg-core = { version = "0.5", default-features = false }
+linreg-core = { version = "0.6", default-features = false }
 ```
 
 For Python bindings (built with maturin):
@@ -843,6 +1178,181 @@ This library is under active development and has not reached 1.0 stability. Whil
 
 ---
 
+## Benchmarks
+
+<details>
+<summary><strong>Click to expand v0.6.0 benchmark results</strong></summary>
+
+Benchmark results run on Windows with `cargo bench --no-default-features`. Times are median values.
+
+### Core Regression Benchmarks
+
+| Benchmark | Size (n × p) | Time | Throughput |
+|-----------|--------------|------|------------|
+| OLS Regression | 10 × 2 | 12.46 µs | 802.71 Kelem/s |
+| OLS Regression | 50 × 3 | 53.72 µs | 930.69 Kelem/s |
+| OLS Regression | 100 × 5 | 211.09 µs | 473.73 Kelem/s |
+| OLS Regression | 500 × 10 | 7.46 ms | 67.04 Kelem/s |
+| OLS Regression | 1000 × 20 | 47.81 ms | 20.91 Kelem/s |
+| OLS Regression | 5000 × 50 | 2.86 s | 1.75 Kelem/s |
+| Ridge Regression | 50 × 3 | 9.61 µs | 5.20 Melem/s |
+| Ridge Regression | 100 × 5 | 70.41 µs | 1.42 Melem/s |
+| Ridge Regression | 500 × 10 | 842.37 µs | 593.56 Kelem/s |
+| Ridge Regression | 1000 × 20 | 1.38 ms | 724.71 Kelem/s |
+| Ridge Regression | 5000 × 50 | 10.25 ms | 487.78 Kelem/s |
+| Lasso Regression | 50 × 3 | 258.82 µs | 193.18 Kelem/s |
+| Lasso Regression | 100 × 5 | 247.89 µs | 403.41 Kelem/s |
+| Lasso Regression | 500 × 10 | 3.58 ms | 139.86 Kelem/s |
+| Lasso Regression | 1000 × 20 | 1.54 ms | 651.28 Kelem/s |
+| Lasso Regression | 5000 × 50 | 12.52 ms | 399.50 Kelem/s |
+| Elastic Net Regression | 50 × 3 | 46.15 µs | 1.08 Melem/s |
+| Elastic Net Regression | 100 × 5 | 358.07 µs | 279.27 Kelem/s |
+| Elastic Net Regression | 500 × 10 | 1.61 ms | 310.18 Kelem/s |
+| Elastic Net Regression | 1000 × 20 | 1.60 ms | 623.66 Kelem/s |
+| Elastic Net Regression | 5000 × 50 | 12.57 ms | 397.77 Kelem/s |
+| WLS Regression | 50 × 3 | 32.92 µs | 1.52 Melem/s |
+| WLS Regression | 100 × 5 | 155.30 µs | 643.93 Kelem/s |
+| WLS Regression | 500 × 10 | 6.63 ms | 75.37 Kelem/s |
+| WLS Regression | 1000 × 20 | 42.68 ms | 23.43 Kelem/s |
+| WLS Regression | 5000 × 50 | 2.64 s | 1.89 Kelem/s |
+| LOESS Fit | 50 × 1 | 132.83 µs | 376.42 Kelem/s |
+| LOESS Fit | 100 × 1 | 1.16 ms | 86.00 Kelem/s |
+| LOESS Fit | 500 × 1 | 28.42 ms | 17.59 Kelem/s |
+| LOESS Fit | 1000 × 1 | 113.00 ms | 8.85 Kelem/s |
+| LOESS Fit | 100 × 2 | 7.10 ms | 14.09 Kelem/s |
+| LOESS Fit | 500 × 2 | 1.05 s | 476.19 elem/s |
+
+### Lambda Path & Elastic Net Path Benchmarks
+
+| Benchmark | Size (n × p) | Time | Throughput |
+|-----------|--------------|------|------------|
+| Elastic Net Path | 100 × 5 | 198.60 ms | 503.52 elem/s |
+| Elastic Net Path | 500 × 10 | 69.46 ms | 7.20 Kelem/s |
+| Elastic Net Path | 1000 × 20 | 39.08 ms | 25.59 Kelem/s |
+| Make Lambda Path | 100 × 5 | 1.09 µs | 91.58 Melem/s |
+| Make Lambda Path | 500 × 10 | 8.10 µs | 61.70 Melem/s |
+| Make Lambda Path | 1000 × 20 | 29.96 µs | 33.37 Melem/s |
+| Make Lambda Path | 5000 × 50 | 424.18 µs | 11.79 Melem/s |
+
+### Diagnostic Test Benchmarks
+
+| Benchmark | Size (n × p) | Time |
+|-----------|--------------|------|
+| Rainbow Test | 50 × 3 | 40.34 µs |
+| Rainbow Test | 100 × 5 | 187.94 µs |
+| Rainbow Test | 500 × 10 | 8.63 ms |
+| Rainbow Test | 1000 × 20 | 60.09 ms |
+| Rainbow Test | 5000 × 50 | 3.45 s |
+| Harvey-Collier Test | 50 × 1 | 15.26 µs |
+| Harvey-Collier Test | 100 × 1 | 30.32 µs |
+| Harvey-Collier Test | 500 × 1 | 138.44 µs |
+| Harvey-Collier Test | 1000 × 1 | 298.33 µs |
+| Breusch-Pagan Test | 50 × 3 | 58.07 µs |
+| Breusch-Pagan Test | 100 × 5 | 296.74 µs |
+| Breusch-Pagan Test | 500 × 10 | 13.79 ms |
+| Breusch-Pagan Test | 1000 × 20 | 96.49 ms |
+| Breusch-Pagan Test | 5000 × 50 | 5.56 s |
+| White Test | 50 × 3 | 14.31 µs |
+| White Test | 100 × 5 | 44.25 µs |
+| White Test | 500 × 10 | 669.40 µs |
+| White Test | 1000 × 20 | 4.89 ms |
+| Jarque-Bera Test | 50 × 3 | 30.13 µs |
+| Jarque-Bera Test | 100 × 5 | 149.29 µs |
+| Jarque-Bera Test | 500 × 10 | 6.64 ms |
+| Jarque-Bera Test | 1000 × 20 | 47.89 ms |
+| Jarque-Bera Test | 5000 × 50 | 2.75 s |
+| Durbin-Watson Test | 50 × 3 | 31.80 µs |
+| Durbin-Watson Test | 100 × 5 | 152.56 µs |
+| Durbin-Watson Test | 500 × 10 | 6.87 ms |
+| Durbin-Watson Test | 1000 × 20 | 48.65 ms |
+| Durbin-Watson Test | 5000 × 50 | 2.76 s |
+| Breusch-Godfrey Test | 50 × 3 | 71.73 µs |
+| Breusch-Godfrey Test | 100 × 5 | 348.94 µs |
+| Breusch-Godfrey Test | 500 × 10 | 14.77 ms |
+| Breusch-Godfrey Test | 1000 × 20 | 100.08 ms |
+| Breusch-Godfrey Test | 5000 × 50 | 5.64 s |
+| Shapiro-Wilk Test | 10 × 2 | 2.04 µs |
+| Shapiro-Wilk Test | 50 × 3 | 4.87 µs |
+| Shapiro-Wilk Test | 100 × 5 | 10.67 µs |
+| Shapiro-Wilk Test | 500 × 10 | 110.02 µs |
+| Shapiro-Wilk Test | 1000 × 20 | 635.13 µs |
+| Shapiro-Wilk Test | 5000 × 50 | 17.53 ms |
+| Anderson-Darling Test | 50 × 3 | 34.02 µs |
+| Anderson-Darling Test | 100 × 5 | 162.28 µs |
+| Anderson-Darling Test | 500 × 10 | 6.95 ms |
+| Anderson-Darling Test | 1000 × 20 | 48.15 ms |
+| Anderson-Darling Test | 5000 × 50 | 2.78 s |
+| Cook's Distance Test | 50 × 3 | 64.52 µs |
+| Cook's Distance Test | 100 × 5 | 297.69 µs |
+| Cook's Distance Test | 500 × 10 | 12.73 ms |
+| Cook's Distance Test | 1000 × 20 | 94.02 ms |
+| Cook's Distance Test | 5000 × 50 | 5.31 s |
+| DFBETAS Test | 50 × 3 | 46.34 µs |
+| DFBETAS Test | 100 × 5 | 185.52 µs |
+| DFBETAS Test | 500 × 10 | 7.04 ms |
+| DFBETAS Test | 1000 × 20 | 49.68 ms |
+| DFFITS Test | 50 × 3 | 33.56 µs |
+| DFFITS Test | 100 × 5 | 157.62 µs |
+| DFFITS Test | 500 × 10 | 6.82 ms |
+| DFFITS Test | 1000 × 20 | 48.35 ms |
+| VIF Test | 50 × 3 | 5.36 µs |
+| VIF Test | 100 × 5 | 12.68 µs |
+| VIF Test | 500 × 10 | 128.04 µs |
+| VIF Test | 1000 × 20 | 807.30 µs |
+| VIF Test | 5000 × 50 | 26.33 ms |
+| RESET Test | 50 × 3 | 77.85 µs |
+| RESET Test | 100 × 5 | 359.12 µs |
+| RESET Test | 500 × 10 | 14.40 ms |
+| RESET Test | 1000 × 20 | 100.52 ms |
+| RESET Test | 5000 × 50 | 5.67 s |
+| Full Diagnostics | 100 × 5 | 2.75 ms |
+| Full Diagnostics | 500 × 10 | 104.01 ms |
+| Full Diagnostics | 1000 × 20 | 740.52 ms |
+
+### Linear Algebra Benchmarks
+
+| Benchmark | Size | Time |
+|-----------|------|------|
+| Matrix Transpose | 10 × 10 | 209.50 ns |
+| Matrix Transpose | 50 × 50 | 3.67 µs |
+| Matrix Transpose | 100 × 100 | 14.92 µs |
+| Matrix Transpose | 500 × 500 | 924.23 µs |
+| Matrix Transpose | 1000 × 1000 | 5.56 ms |
+| Matrix Multiply (matmul) | 10 × 10 × 10 | 1.54 µs |
+| Matrix Multiply (matmul) | 50 × 50 × 50 | 144.15 µs |
+| Matrix Multiply (matmul) | 100 × 100 × 100 | 1.39 ms |
+| Matrix Multiply (matmul) | 200 × 200 × 200 | 11.90 ms |
+| Matrix Multiply (matmul) | 1000 × 100 × 100 | 13.94 ms |
+| QR Decomposition | 10 × 5 | 1.41 µs |
+| QR Decomposition | 50 × 10 | 14.81 µs |
+| QR Decomposition | 100 × 20 | 57.61 µs |
+| QR Decomposition | 500 × 50 | 2.19 ms |
+| QR Decomposition | 1000 × 100 | 19.20 ms |
+| QR Decomposition | 5000 × 100 | 1.48 s |
+| QR Decomposition | 10000 × 100 | 8.09 s |
+| QR Decomposition | 1000 × 500 | 84.48 ms |
+| SVD | 10 × 5 | 150.36 µs |
+| SVD | 50 × 10 | 505.41 µs |
+| SVD | 100 × 20 | 2.80 ms |
+| SVD | 500 × 50 | 60.00 ms |
+| SVD | 1000 × 100 | 513.35 ms |
+| Matrix Invert | 5 × 5 | 877.32 ns |
+| Matrix Invert | 10 × 10 | 2.48 µs |
+| Matrix Invert | 20 × 20 | 5.46 µs |
+| Matrix Invert | 50 × 50 | 31.94 µs |
+| Matrix Invert | 100 × 100 | 141.38 µs |
+| Matrix Invert | 200 × 200 | 647.03 µs |
+
+### Pressure Benchmarks (Large Datasets)
+
+| Benchmark | Size (n) | Time |
+|-----------|----------|------|
+| Pressure (OLS + all diagnostics) | 10000 | 11.28 s |
+
+</details>
+
+---
+
 ## License
 
 Dual-licensed under [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-APACHE).

package/linreg_core.d.ts

@@ -95,6 +95,41 @@ 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;
 
+/**
+ * Deserialize a serialized model, extracting the inner model data.
+ *
+ * This function takes a serialized model JSON (as created by serialize_model),
+ * validates the format version, and returns the inner model data as JSON.
+ *
+ * # Arguments
+ *
+ * * `json_string` - JSON string of the serialized model (with metadata wrapper)
+ *
+ * # Returns
+ *
+ * JSON string of the inner model data (coefficients, statistics, etc.),
+ * or a JSON error object if the input is invalid, the format version is
+ * incompatible, or the domain check fails.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { deserialize_model } from './linreg_core.js';
+ *
+ * // Load from file (browser-side)
+ * const response = await fetch('my_model.json');
+ * const serialized = await response.text();
+ *
+ * // Deserialize to get the model data
+ * const modelJson = deserialize_model(serialized);
+ * const model = JSON.parse(modelJson);
+ *
+ * console.log(model.coefficients);
+ * console.log(model.r_squared);
+ * ```
+ */
+export function deserialize_model(json_string: string): string;
+
 /**
  * Performs DFBETAS analysis via WASM.
  *
@@ -188,6 +223,46 @@ export function durbin_watson_test(y_json: string, x_vars_json: string): string;
  */
 export function elastic_net_regression(y_json: string, x_vars_json: string, _variable_names: string, lambda: number, alpha: number, standardize: boolean, max_iter: number, tol: number): string;
 
+/**
+ * Extract metadata from a serialized model without deserializing the full model.
+ *
+ * This function returns only the metadata portion of a serialized model,
+ * which includes information like model type, library version, creation time,
+ * and optional model name.
+ *
+ * # Arguments
+ *
+ * * `json_string` - JSON string of the serialized model
+ *
+ * # Returns
+ *
+ * JSON string containing the metadata object with fields:
+ * - `format_version` - Format version (e.g., "1.0")
+ * - `library_version` - linreg-core version used to create the model
+ * - `model_type` - Type of model ("OLS", "Ridge", etc.)
+ * - `created_at` - ISO 8601 timestamp of creation
+ * - `name` - Optional custom model name
+ *
+ * Returns a JSON error object if the input is invalid or the domain check fails.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { get_model_metadata } from './linreg_core.js';
+ *
+ * const response = await fetch('my_model.json');
+ * const serialized = await response.text();
+ *
+ * const metadataJson = get_model_metadata(serialized);
+ * const metadata = JSON.parse(metadataJson);
+ *
+ * console.log('Model type:', metadata.model_type);
+ * console.log('Created:', metadata.created_at);
+ * console.log('Name:', metadata.name || '(unnamed)');
+ * ```
+ */
+export function get_model_metadata(json_string: string): string;
+
 /**
  * Computes the inverse of the standard normal CDF (probit function).
  *
@@ -291,6 +366,110 @@ export function harvey_collier_test(y_json: string, x_vars_json: string): string
  */
 export function jarque_bera_test(y_json: string, x_vars_json: string): string;
 
+/**
+ * Performs K-Fold Cross Validation for Elastic Net regression via WASM.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `lambda` - Regularization strength (>= 0)
+ * * `alpha` - Mixing parameter (0 = Ridge, 1 = Lasso)
+ * * `standardize` - Whether to standardize predictors
+ * * `n_folds` - Number of folds (must be >= 2)
+ * * `shuffle_json` - JSON boolean: whether to shuffle data before splitting
+ * * `seed_json` - JSON string with seed number or "null" for no seed
+ *
+ * # Returns
+ *
+ * JSON string containing CV results (same structure as OLS).
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters are invalid,
+ * or domain check fails.
+ */
+export function kfold_cv_elastic_net(y_json: string, x_vars_json: string, lambda: number, alpha: number, standardize: boolean, n_folds: number, shuffle_json: string, seed_json: string): string;
+
+/**
+ * Performs K-Fold Cross Validation for Lasso regression via WASM.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `lambda` - Regularization strength (>= 0)
+ * * `standardize` - Whether to standardize predictors
+ * * `n_folds` - Number of folds (must be >= 2)
+ * * `shuffle_json` - JSON boolean: whether to shuffle data before splitting
+ * * `seed_json` - JSON string with seed number or "null" for no seed
+ *
+ * # Returns
+ *
+ * JSON string containing CV results (same structure as OLS).
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters are invalid,
+ * or domain check fails.
+ */
+export function kfold_cv_lasso(y_json: string, x_vars_json: string, lambda: number, standardize: boolean, n_folds: number, shuffle_json: string, seed_json: string): string;
+
+/**
+ * Performs K-Fold Cross Validation for OLS regression via WASM.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `variable_names_json` - JSON array of variable names
+ * * `n_folds` - Number of folds (must be >= 2)
+ * * `shuffle_json` - JSON boolean: whether to shuffle data before splitting
+ * * `seed_json` - JSON string with seed number or "null" for no seed
+ *
+ * # Returns
+ *
+ * JSON string containing CV results:
+ * - `n_folds` - Number of folds used
+ * - `n_samples` - Total number of observations
+ * - `mean_mse`, `std_mse` - Mean and std of MSE across folds
+ * - `mean_rmse`, `std_rmse` - Mean and std of RMSE across folds
+ * - `mean_mae`, `std_mae` - Mean and std of MAE across folds
+ * - `mean_r_squared`, `std_r_squared` - Mean and std of R² across folds
+ * - `fold_results` - Array of individual fold results
+ * - `fold_coefficients` - Array of coefficient arrays from each fold
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters are invalid,
+ * or domain check fails.
+ */
+export function kfold_cv_ols(y_json: string, x_vars_json: string, variable_names_json: string, n_folds: number, shuffle_json: string, seed_json: string): string;
+
+/**
+ * Performs K-Fold Cross Validation for Ridge regression via WASM.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `lambda` - Regularization strength (>= 0)
+ * * `standardize` - Whether to standardize predictors
+ * * `n_folds` - Number of folds (must be >= 2)
+ * * `shuffle_json` - JSON boolean: whether to shuffle data before splitting
+ * * `seed_json` - JSON string with seed number or "null" for no seed
+ *
+ * # Returns
+ *
+ * JSON string containing CV results (same structure as OLS).
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters are invalid,
+ * or domain check fails.
+ */
+export function kfold_cv_ridge(y_json: string, x_vars_json: string, lambda: number, standardize: boolean, n_folds: number, shuffle_json: string, seed_json: string): string;
+
 /**
  * Performs Lasso regression via WASM.
  *
@@ -592,6 +771,46 @@ export function reset_test(y_json: string, x_vars_json: string, powers_json: str
  */
 export function ridge_regression(y_json: string, x_vars_json: string, _variable_names: string, lambda: number, standardize: boolean): string;
 
+/**
+ * Serialize a model by wrapping its JSON data with metadata.
+ *
+ * This function takes a model's JSON representation (as returned by regression
+ * functions), wraps it with version and type metadata, and returns a serialized
+ * JSON string suitable for storage or download.
+ *
+ * # Arguments
+ *
+ * * `model_json` - JSON string of the model result (e.g., from ols_regression)
+ * * `model_type` - Type of model: "OLS", "Ridge", "Lasso", "ElasticNet", "WLS", or "LOESS"
+ * * `name` - Optional custom name for the model
+ *
+ * # Returns
+ *
+ * JSON string containing the serialized model with metadata, or a JSON error object
+ * if the input is invalid or the domain check fails.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { serialize_model, ols_regression } from './linreg_core.js';
+ *
+ * // Train a model
+ * const resultJson = ols_regression(yJson, xJson, namesJson);
+ *
+ * // Serialize it
+ * const serialized = serialize_model(resultJson, "OLS", "My Housing Model");
+ *
+ * // Download (browser-side)
+ * const blob = new Blob([serialized], { type: 'application/json' });
+ * const url = URL.createObjectURL(blob);
+ * const a = document.createElement('a');
+ * a.href = url;
+ * a.download = 'my_model.json';
+ * a.click();
+ * ```
+ */
+export function serialize_model(model_json: string, model_type: string, name?: string | null): string;
+
 /**
  * Performs the Shapiro-Wilk test for normality via WASM.
  *
@@ -857,13 +1076,19 @@ 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 deserialize_model: (a: number, b: 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_model_metadata: (a: number, b: 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 kfold_cv_elastic_net: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number];
+    readonly kfold_cv_lasso: (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 kfold_cv_ols: (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 kfold_cv_ridge: (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 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];
@@ -875,6 +1100,7 @@ export interface InitOutput {
     readonly rainbow_test: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly reset_test: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly ridge_regression: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly serialize_model: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly shapiro_wilk_test: (a: number, b: number, c: number, d: number) => [number, number];
     readonly stats_correlation: (a: number, b: number, c: number, d: number) => [number, number];
     readonly stats_mean: (a: number, b: number) => [number, number];

package/linreg_core.js

@@ -170,6 +170,56 @@ export function cooks_distance_test(y_json, x_vars_json) {
     }
 }
 
+/**
+ * Deserialize a serialized model, extracting the inner model data.
+ *
+ * This function takes a serialized model JSON (as created by serialize_model),
+ * validates the format version, and returns the inner model data as JSON.
+ *
+ * # Arguments
+ *
+ * * `json_string` - JSON string of the serialized model (with metadata wrapper)
+ *
+ * # Returns
+ *
+ * JSON string of the inner model data (coefficients, statistics, etc.),
+ * or a JSON error object if the input is invalid, the format version is
+ * incompatible, or the domain check fails.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { deserialize_model } from './linreg_core.js';
+ *
+ * // Load from file (browser-side)
+ * const response = await fetch('my_model.json');
+ * const serialized = await response.text();
+ *
+ * // Deserialize to get the model data
+ * const modelJson = deserialize_model(serialized);
+ * const model = JSON.parse(modelJson);
+ *
+ * console.log(model.coefficients);
+ * console.log(model.r_squared);
+ * ```
+ * @param {string} json_string
+ * @returns {string}
+ */
+export function deserialize_model(json_string) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(json_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.deserialize_model(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Performs DFBETAS analysis via WASM.
  *
@@ -343,6 +393,61 @@ export function elastic_net_regression(y_json, x_vars_json, _variable_names, lam
     }
 }
 
+/**
+ * Extract metadata from a serialized model without deserializing the full model.
+ *
+ * This function returns only the metadata portion of a serialized model,
+ * which includes information like model type, library version, creation time,
+ * and optional model name.
+ *
+ * # Arguments
+ *
+ * * `json_string` - JSON string of the serialized model
+ *
+ * # Returns
+ *
+ * JSON string containing the metadata object with fields:
+ * - `format_version` - Format version (e.g., "1.0")
+ * - `library_version` - linreg-core version used to create the model
+ * - `model_type` - Type of model ("OLS", "Ridge", etc.)
+ * - `created_at` - ISO 8601 timestamp of creation
+ * - `name` - Optional custom model name
+ *
+ * Returns a JSON error object if the input is invalid or the domain check fails.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { get_model_metadata } from './linreg_core.js';
+ *
+ * const response = await fetch('my_model.json');
+ * const serialized = await response.text();
+ *
+ * const metadataJson = get_model_metadata(serialized);
+ * const metadata = JSON.parse(metadataJson);
+ *
+ * console.log('Model type:', metadata.model_type);
+ * console.log('Created:', metadata.created_at);
+ * console.log('Name:', metadata.name || '(unnamed)');
+ * ```
+ * @param {string} json_string
+ * @returns {string}
+ */
+export function get_model_metadata(json_string) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(json_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.get_model_metadata(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Computes the inverse of the standard normal CDF (probit function).
  *
@@ -511,6 +616,220 @@ export function jarque_bera_test(y_json, x_vars_json) {
     }
 }
 
+/**
+ * Performs K-Fold Cross Validation for Elastic Net regression via WASM.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `lambda` - Regularization strength (>= 0)
+ * * `alpha` - Mixing parameter (0 = Ridge, 1 = Lasso)
+ * * `standardize` - Whether to standardize predictors
+ * * `n_folds` - Number of folds (must be >= 2)
+ * * `shuffle_json` - JSON boolean: whether to shuffle data before splitting
+ * * `seed_json` - JSON string with seed number or "null" for no seed
+ *
+ * # Returns
+ *
+ * JSON string containing CV results (same structure as OLS).
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters are invalid,
+ * or domain check fails.
+ * @param {string} y_json
+ * @param {string} x_vars_json
+ * @param {number} lambda
+ * @param {number} alpha
+ * @param {boolean} standardize
+ * @param {number} n_folds
+ * @param {string} shuffle_json
+ * @param {string} seed_json
+ * @returns {string}
+ */
+export function kfold_cv_elastic_net(y_json, x_vars_json, lambda, alpha, standardize, n_folds, shuffle_json, seed_json) {
+    let deferred5_0;
+    let deferred5_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(shuffle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(seed_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.kfold_cv_elastic_net(ptr0, len0, ptr1, len1, lambda, alpha, standardize, n_folds, ptr2, len2, 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);
+    }
+}
+
+/**
+ * Performs K-Fold Cross Validation for Lasso regression via WASM.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `lambda` - Regularization strength (>= 0)
+ * * `standardize` - Whether to standardize predictors
+ * * `n_folds` - Number of folds (must be >= 2)
+ * * `shuffle_json` - JSON boolean: whether to shuffle data before splitting
+ * * `seed_json` - JSON string with seed number or "null" for no seed
+ *
+ * # Returns
+ *
+ * JSON string containing CV results (same structure as OLS).
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters are invalid,
+ * or domain check fails.
+ * @param {string} y_json
+ * @param {string} x_vars_json
+ * @param {number} lambda
+ * @param {boolean} standardize
+ * @param {number} n_folds
+ * @param {string} shuffle_json
+ * @param {string} seed_json
+ * @returns {string}
+ */
+export function kfold_cv_lasso(y_json, x_vars_json, lambda, standardize, n_folds, shuffle_json, seed_json) {
+    let deferred5_0;
+    let deferred5_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(shuffle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(seed_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.kfold_cv_lasso(ptr0, len0, ptr1, len1, lambda, standardize, n_folds, ptr2, len2, 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);
+    }
+}
+
+/**
+ * Performs K-Fold Cross Validation for OLS regression via WASM.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `variable_names_json` - JSON array of variable names
+ * * `n_folds` - Number of folds (must be >= 2)
+ * * `shuffle_json` - JSON boolean: whether to shuffle data before splitting
+ * * `seed_json` - JSON string with seed number or "null" for no seed
+ *
+ * # Returns
+ *
+ * JSON string containing CV results:
+ * - `n_folds` - Number of folds used
+ * - `n_samples` - Total number of observations
+ * - `mean_mse`, `std_mse` - Mean and std of MSE across folds
+ * - `mean_rmse`, `std_rmse` - Mean and std of RMSE across folds
+ * - `mean_mae`, `std_mae` - Mean and std of MAE across folds
+ * - `mean_r_squared`, `std_r_squared` - Mean and std of R² across folds
+ * - `fold_results` - Array of individual fold results
+ * - `fold_coefficients` - Array of coefficient arrays from each fold
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters are invalid,
+ * or domain check fails.
+ * @param {string} y_json
+ * @param {string} x_vars_json
+ * @param {string} variable_names_json
+ * @param {number} n_folds
+ * @param {string} shuffle_json
+ * @param {string} seed_json
+ * @returns {string}
+ */
+export function kfold_cv_ols(y_json, x_vars_json, variable_names_json, n_folds, shuffle_json, seed_json) {
+    let deferred6_0;
+    let deferred6_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(variable_names_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(shuffle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(seed_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.kfold_cv_ols(ptr0, len0, ptr1, len1, ptr2, len2, n_folds, ptr3, len3, ptr4, len4);
+        deferred6_0 = ret[0];
+        deferred6_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+    }
+}
+
+/**
+ * Performs K-Fold Cross Validation for Ridge regression via WASM.
+ *
+ * # Arguments
+ *
+ * * `y_json` - JSON array of response variable values
+ * * `x_vars_json` - JSON array of predictor arrays
+ * * `lambda` - Regularization strength (>= 0)
+ * * `standardize` - Whether to standardize predictors
+ * * `n_folds` - Number of folds (must be >= 2)
+ * * `shuffle_json` - JSON boolean: whether to shuffle data before splitting
+ * * `seed_json` - JSON string with seed number or "null" for no seed
+ *
+ * # Returns
+ *
+ * JSON string containing CV results (same structure as OLS).
+ *
+ * # Errors
+ *
+ * Returns a JSON error object if parsing fails, parameters are invalid,
+ * or domain check fails.
+ * @param {string} y_json
+ * @param {string} x_vars_json
+ * @param {number} lambda
+ * @param {boolean} standardize
+ * @param {number} n_folds
+ * @param {string} shuffle_json
+ * @param {string} seed_json
+ * @returns {string}
+ */
+export function kfold_cv_ridge(y_json, x_vars_json, lambda, standardize, n_folds, shuffle_json, seed_json) {
+    let deferred5_0;
+    let deferred5_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(shuffle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(seed_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.kfold_cv_ridge(ptr0, len0, ptr1, len1, lambda, standardize, n_folds, ptr2, len2, 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);
+    }
+}
+
 /**
  * Performs Lasso regression via WASM.
  *
@@ -1049,6 +1368,67 @@ export function ridge_regression(y_json, x_vars_json, _variable_names, lambda, s
     }
 }
 
+/**
+ * Serialize a model by wrapping its JSON data with metadata.
+ *
+ * This function takes a model's JSON representation (as returned by regression
+ * functions), wraps it with version and type metadata, and returns a serialized
+ * JSON string suitable for storage or download.
+ *
+ * # Arguments
+ *
+ * * `model_json` - JSON string of the model result (e.g., from ols_regression)
+ * * `model_type` - Type of model: "OLS", "Ridge", "Lasso", "ElasticNet", "WLS", or "LOESS"
+ * * `name` - Optional custom name for the model
+ *
+ * # Returns
+ *
+ * JSON string containing the serialized model with metadata, or a JSON error object
+ * if the input is invalid or the domain check fails.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { serialize_model, ols_regression } from './linreg_core.js';
+ *
+ * // Train a model
+ * const resultJson = ols_regression(yJson, xJson, namesJson);
+ *
+ * // Serialize it
+ * const serialized = serialize_model(resultJson, "OLS", "My Housing Model");
+ *
+ * // Download (browser-side)
+ * const blob = new Blob([serialized], { type: 'application/json' });
+ * const url = URL.createObjectURL(blob);
+ * const a = document.createElement('a');
+ * a.href = url;
+ * a.download = 'my_model.json';
+ * a.click();
+ * ```
+ * @param {string} model_json
+ * @param {string} model_type
+ * @param {string | null} [name]
+ * @returns {string}
+ */
+export function serialize_model(model_json, model_type, name) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(model_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(model_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(name) ? 0 : passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.serialize_model(ptr0, len0, ptr1, len1, 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 the Shapiro-Wilk test for normality via WASM.
  *
@@ -1579,6 +1959,10 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/package.json

@@ -5,12 +5,13 @@
     "Jesse Anderson"
   ],
   "description": "Lightweight linear regression (OLS, Ridge, Lasso, Elastic Net) with diagnostic tests. Pure Rust - no external math dependencies.",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/jesse-anderson/linreg-core"
   },
+  "homepage": "https://jesse-anderson.net/linreg-core/",
   "files": [
     "linreg_core_bg.wasm",
     "linreg_core.js",