linreg-core 0.3.0 → 0.4.0

package/README.md

@@ -5,25 +5,27 @@
 [![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)
 [![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/)
 
-## Installation
+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.
 
-```bash
-# npm
-npm install linreg-core
-
-# yarn
-yarn add linreg-core
-
-# pnpm
-pnpm add linreg-core
-```
+**Key design principle:** All linear algebra and statistical distribution functions are implemented from scratch — no external math libraries required. This keeps binary sizes small and makes the crate highly portable.
 
 ---
 
-A lightweight, self-contained linear regression library written in Rust. Compiles to WebAssembly for browser use or runs as a native Rust crate.
+## Table of Contents
 
-**Key design principle:** All linear algebra and statistical distribution functions are implemented from scratch — no external math libraries required. This keeps binary sizes small and makes the crate highly portable.
+| Section | Description |
+|---------|-------------|
+| [Features](#features) | Regression methods, model statistics, diagnostic tests |
+| [Rust Usage](#rust-usage) | Native Rust crate usage |
+| [WebAssembly Usage](#webassembly-usage) | Browser/JavaScript usage |
+| [Python Usage](#python-usage) | Python bindings via PyO3 |
+| [Feature Flags](#feature-flags) | Build configuration options |
+| [Validation](#validation) | Testing and verification |
+| [Implementation Notes](#implementation-notes) | Technical details |
+
+---
 
 ## Features
 
@@ -49,22 +51,18 @@ A lightweight, self-contained linear regression library written in Rust. Compile
 | **Autocorrelation** | Durbin-Watson, Breusch-Godfrey (higher-order) |
 | **Influence** | Cook's Distance |
 
-### Dual Target
-- Browser (WASM) and server (native Rust)
-- Optional domain restriction for WASM builds
-
-## Quick Start
+---
 
-### Native Rust
+## Rust Usage
 
 Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-linreg-core = { version = "0.3", default-features = false }
+linreg-core = { version = "0.4", default-features = false }
 ```
 
-#### OLS Regression
+### OLS Regression (Rust)
 
 ```rust
 use linreg_core::core::ols_regression;
@@ -84,7 +82,7 @@ fn main() -> Result<(), linreg_core::Error> {
 }
 ```
 
-#### Ridge Regression
+### Ridge Regression (Rust)
 
 ```rust,no_run
 use linreg_core::regularized::{ridge_fit, RidgeFitOptions};
@@ -92,7 +90,6 @@ use linreg_core::linalg::Matrix;
 
 fn main() -> Result<(), linreg_core::Error> {
     let y = vec![2.5, 3.7, 4.2, 5.1, 6.3];
-    // Matrix: 5 rows × 2 cols (intercept + 1 predictor), row-major order
     let x = Matrix::new(5, 2, vec![
         1.0, 1.0,  // row 0: intercept, x1
         1.0, 2.0,  // row 1
@@ -108,7 +105,6 @@ fn main() -> Result<(), linreg_core::Error> {
     };
 
     let result = ridge_fit(&x, &y, &options)?;
-
     println!("Intercept: {}", result.intercept);
     println!("Coefficients: {:?}", result.coefficients);
 
@@ -116,7 +112,7 @@ fn main() -> Result<(), linreg_core::Error> {
 }
 ```
 
-#### Lasso Regression
+### Lasso Regression (Rust)
 
 ```rust,no_run
 use linreg_core::regularized::{lasso_fit, LassoFitOptions};
@@ -124,24 +120,22 @@ use linreg_core::linalg::Matrix;
 
 fn main() -> Result<(), linreg_core::Error> {
     let y = vec![2.5, 3.7, 4.2, 5.1, 6.3];
-    // Matrix: 5 rows × 3 cols (intercept + 2 predictors), row-major order
     let x = Matrix::new(5, 3, vec![
-        1.0, 1.0, 0.5,  // row 0: intercept, x1, x2
-        1.0, 2.0, 1.0,  // row 1
-        1.0, 3.0, 1.5,  // row 2
-        1.0, 4.0, 2.0,  // row 3
-        1.0, 5.0, 2.5,  // row 4
+        1.0, 1.0, 0.5,
+        1.0, 2.0, 1.0,
+        1.0, 3.0, 1.5,
+        1.0, 4.0, 2.0,
+        1.0, 5.0, 2.5,
     ]);
 
     let options = LassoFitOptions {
         lambda: 0.1,
         standardize: true,
         intercept: true,
-        ..Default::default()  // uses default max_iter=1000, tol=1e-7
+        ..Default::default()
     };
 
     let result = lasso_fit(&x, &y, &options)?;
-
     println!("Intercept: {}", result.intercept);
     println!("Coefficients: {:?}", result.coefficients);
     println!("Non-zero coefficients: {}", result.n_nonzero);
@@ -150,7 +144,7 @@ fn main() -> Result<(), linreg_core::Error> {
 }
 ```
 
-#### Elastic Net Regression
+### Elastic Net Regression (Rust)
 
 ```rust,no_run
 use linreg_core::regularized::{elastic_net_fit, ElasticNetOptions};
@@ -158,13 +152,12 @@ use linreg_core::linalg::Matrix;
 
 fn main() -> Result<(), linreg_core::Error> {
     let y = vec![2.5, 3.7, 4.2, 5.1, 6.3];
-    // Matrix: 5 rows × 3 cols (intercept + 2 predictors), row-major order
     let x = Matrix::new(5, 3, vec![
-        1.0, 1.0, 0.5,  // row 0: intercept, x1, x2
-        1.0, 2.0, 1.0,  // row 1
-        1.0, 3.0, 1.5,  // row 2
-        1.0, 4.0, 2.0,  // row 3
-        1.0, 5.0, 2.5,  // row 4
+        1.0, 1.0, 0.5,
+        1.0, 2.0, 1.0,
+        1.0, 3.0, 1.5,
+        1.0, 4.0, 2.0,
+        1.0, 5.0, 2.5,
     ]);
 
     let options = ElasticNetOptions {
@@ -176,7 +169,6 @@ fn main() -> Result<(), linreg_core::Error> {
     };
 
     let result = elastic_net_fit(&x, &y, &options)?;
-
     println!("Intercept: {}", result.intercept);
     println!("Coefficients: {:?}", result.coefficients);
     println!("Non-zero coefficients: {}", result.n_nonzero);
@@ -185,7 +177,66 @@ fn main() -> Result<(), linreg_core::Error> {
 }
 ```
 
-### WebAssembly (Browser)
+### Diagnostic Tests (Rust)
+
+```rust
+use linreg_core::diagnostics::{
+    breusch_pagan_test, durbin_watson_test, jarque_bera_test,
+    shapiro_wilk_test, RainbowMethod, rainbow_test
+};
+
+fn main() -> Result<(), linreg_core::Error> {
+    let y = vec![/* your data */];
+    let x = vec![vec![/* predictor 1 */], vec![/* predictor 2 */]];
+
+    // Heteroscedasticity
+    let bp = breusch_pagan_test(&y, &x)?;
+    println!("Breusch-Pagan: LM={:.4}, p={:.4}", bp.statistic, bp.p_value);
+
+    // Autocorrelation
+    let dw = durbin_watson_test(&y, &x)?;
+    println!("Durbin-Watson: {:.4}", dw.statistic);
+
+    // Normality
+    let jb = jarque_bera_test(&y, &x)?;
+    println!("Jarque-Bera: JB={:.4}, p={:.4}", jb.statistic, jb.p_value);
+
+    // Linearity
+    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);
+
+    Ok(())
+}
+```
+
+### Lambda Path Generation (Rust)
+
+```rust,no_run
+use linreg_core::regularized::{make_lambda_path, LambdaPathOptions};
+use linreg_core::linalg::Matrix;
+
+let x = Matrix::new(100, 5, vec![0.0; 500]);
+let y = vec![0.0; 100];
+
+let options = LambdaPathOptions {
+    nlambda: 100,
+    lambda_min_ratio: Some(0.01),
+    alpha: 1.0,  // Lasso
+    ..Default::default()
+};
+
+let lambdas = make_lambda_path(&x, &y, &options, None, Some(0));
+
+for &lambda in lambdas.iter() {
+    // Fit model with this lambda
+}
+```
+
+---
+
+## WebAssembly Usage
 
 Build with wasm-pack:
 
@@ -193,10 +244,10 @@ Build with wasm-pack:
 wasm-pack build --release --target web
 ```
 
-#### OLS in JavaScript
+### OLS Regression (WASM)
 
 ```javascript
-import init, { ols_regression } from 'linreg-core';
+import init, { ols_regression } from './pkg/linreg_core.js';
 
 async function run() {
     await init();
@@ -219,7 +270,7 @@ async function run() {
 run();
 ```
 
-#### Ridge Regression in JavaScript
+### Ridge Regression (WASM)
 
 ```javascript
 const result = JSON.parse(ridge_regression(
@@ -233,7 +284,7 @@ const result = JSON.parse(ridge_regression(
 console.log("Coefficients:", result.coefficients);
 ```
 
-#### Lasso Regression in JavaScript
+### Lasso Regression (WASM)
 
 ```javascript
 const result = JSON.parse(lasso_regression(
@@ -250,7 +301,7 @@ console.log("Coefficients:", result.coefficients);
 console.log("Non-zero coefficients:", result.n_nonzero);
 ```
 
-#### Elastic Net Regression
+### Elastic Net Regression (WASM)
 
 ```javascript
 const result = JSON.parse(elastic_net_regression(
@@ -268,7 +319,7 @@ console.log("Coefficients:", result.coefficients);
 console.log("Non-zero coefficients:", result.n_nonzero);
 ```
 
-#### Lambda Path Generation
+### Lambda Path Generation (WASM)
 
 ```javascript
 const path = JSON.parse(make_lambda_path(
@@ -282,45 +333,7 @@ console.log("Lambda sequence:", path.lambda_path);
 console.log("Lambda max:", path.lambda_max);
 ```
 
-## Diagnostic Tests
-
-### Native Rust
-
-```rust
-use linreg_core::diagnostics::{
-    breusch_pagan_test, durbin_watson_test, jarque_bera_test,
-    shapiro_wilk_test, RainbowMethod, rainbow_test
-};
-
-fn main() -> Result<(), linreg_core::Error> {
-    let y = vec![/* your data */];
-    let x = vec![vec![/* predictor 1 */], vec![/* predictor 2 */]];
-
-    // Heteroscedasticity
-    let bp = breusch_pagan_test(&y, &x)?;
-    println!("Breusch-Pagan: LM={:.4}, p={:.4}", bp.statistic, bp.p_value);
-
-    // Autocorrelation
-    let dw = durbin_watson_test(&y, &x)?;
-    println!("Durbin-Watson: {:.4}", dw.statistic);
-
-    // Normality
-    let jb = jarque_bera_test(&y, &x)?;
-    println!("Jarque-Bera: JB={:.4}, p={:.4}", jb.statistic, jb.p_value);
-
-    // Linearity
-    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);
-
-    Ok(())
-}
-```
-
-### WebAssembly
-
-All diagnostic tests are available in WASM:
+### Diagnostic Tests (WASM)
 
 ```javascript
 // Rainbow test
@@ -347,16 +360,16 @@ const bp = JSON.parse(breusch_pagan_test(
 const white = JSON.parse(white_test(
     JSON.stringify(y),
     JSON.stringify(x),
-    "r"       // method: "r", "python", or "both"
+    "r"
 ));
 
-// White test - R-specific method (no method parameter)
+// White test - R-specific method
 const whiteR = JSON.parse(r_white_test(
     JSON.stringify(y),
     JSON.stringify(x)
 ));
 
-// White test - Python-specific method (no method parameter)
+// White test - Python-specific method
 const whitePy = JSON.parse(python_white_test(
     JSON.stringify(y),
     JSON.stringify(x)
@@ -396,7 +409,7 @@ const cd = JSON.parse(cooks_distance_test(
 const reset = JSON.parse(reset_test(
     JSON.stringify(y),
     JSON.stringify(x),
-    JSON.stringify([2, 3]),  // powers (array of powers to test)
+    JSON.stringify([2, 3]),  // powers
     "fitted"                  // type: "fitted", "regressor", or "princomp"
 ));
 
@@ -404,12 +417,12 @@ const reset = JSON.parse(reset_test(
 const bg = JSON.parse(breusch_godfrey_test(
     JSON.stringify(y),
     JSON.stringify(x),
-    1,        // order (1 = first-order autocorrelation)
+    1,        // order
     "chisq"   // test_type: "chisq" or "f"
 ));
 ```
 
-## Statistical Utilities (WASM)
+### Statistical Utilities (WASM)
 
 ```javascript
 // Student's t CDF: P(T <= t)
@@ -436,7 +449,6 @@ const correlation = JSON.parse(stats_correlation(
 ### CSV Parsing (WASM)
 
 ```javascript
-// Parse CSV content - returns headers, data rows, and numeric column names
 const csv = parse_csv(csvContent);
 const parsed = JSON.parse(csv);
 console.log("Headers:", parsed.headers);
@@ -446,63 +458,256 @@ console.log("Numeric columns:", parsed.numeric_columns);
 ### Helper Functions (WASM)
 
 ```javascript
-// Get library version
-const version = get_version();  // e.g., "0.3.0"
+const version = get_version();  // e.g., "0.4.0"
+const msg = test();             // "Rust WASM is working!"
+```
+
+### Domain Security (WASM)
+
+Optional domain restriction via build-time environment variable:
 
-// Verify WASM is working
-const msg = test();  // "Rust WASM is working!"
+```bash
+LINREG_DOMAIN_RESTRICT=example.com,mysite.com wasm-pack build --release --target web
 ```
 
-## Feature Flags
+When NOT set (default), all domains are allowed.
 
-| Feature | Default | Description |
-|---------|---------|-------------|
-| `wasm` | Yes | Enables WASM bindings and browser support |
-| `validation` | No | Includes test data for validation tests |
+---
 
-For native Rust without WASM overhead:
+## Python Usage
 
-```toml
-linreg-core = { version = "0.3", default-features = false }
+Install from PyPI:
+
+```bash
+pip install linreg-core
 ```
 
-## Regularization Path
+### Quick Start (Python)
 
-Generate a sequence of lambda values for regularization path analysis:
+The recommended way to use `linreg-core` in Python is with native types (lists or numpy arrays):
 
-```rust,no_run
-use linreg_core::regularized::{make_lambda_path, LambdaPathOptions};
-use linreg_core::linalg::Matrix;
+```python
+import linreg_core
 
-// Assume x is your standardized design matrix and y is centered
-let x = Matrix::new(100, 5, vec![0.0; 500]);
-let y = vec![0.0; 100];
+# Works with Python lists
+y = [1, 2, 3, 4, 5]
+x = [[1, 2, 3, 4, 5]]
+names = ["Intercept", "X1"]
 
-let options = LambdaPathOptions {
-    nlambda: 100,
-    lambda_min_ratio: Some(0.01),
-    alpha: 1.0,  // Lasso
-    ..Default::default()
-};
+result = linreg_core.ols_regression(y, x, names)
 
-let lambdas = make_lambda_path(&x, &y, &options, None, Some(0));
+# Access attributes directly
+print(f"R²: {result.r_squared}")
+print(f"Coefficients: {result.coefficients}")
+print(f"F-statistic: {result.f_statistic}")
 
-// Use each lambda for cross-validation or plotting regularization paths
-for &lambda in lambdas.iter() {
-    // Fit model with this lambda
-    // ...
-}
+# Get a formatted summary
+print(result.summary())
 ```
 
-## Domain Security (WASM)
+**With NumPy arrays:**
 
-Optional domain restriction via build-time environment variable:
+```python
+import numpy as np
+import linreg_core
+
+y = np.array([1, 2, 3, 4, 5])
+x = np.array([[1, 2, 3, 4, 5]])
+
+result = linreg_core.ols_regression(y, x, ["Intercept", "X1"])
+print(result.summary())
+```
+
+**Result objects** provide:
+- Direct attribute access (`result.r_squared`, `result.coefficients`)
+- `summary()` method for formatted output
+- `to_dict()` method for JSON serialization
+
+### OLS Regression (Python)
+
+```python
+import linreg_core
+
+y = [1, 2, 3, 4, 5]
+x = [[1, 2, 3, 4, 5]]
+names = ["Intercept", "X1"]
+
+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}")
+```
+
+### Ridge Regression (Python)
+
+```python
+result = linreg_core.ridge_regression(
+    y, x, ["Intercept", "X1"],
+    1.0,      # lambda
+    True      # standardize
+)
+print(f"Intercept: {result.intercept}")
+print(f"Coefficients: {result.coefficients}")
+```
+
+### Lasso Regression (Python)
+
+```python
+result = linreg_core.lasso_regression(
+    y, x, ["Intercept", "X1"],
+    0.1,      # lambda
+    True,     # standardize
+    100000,   # max_iter
+    1e-7      # tol
+)
+print(f"Intercept: {result.intercept}")
+print(f"Coefficients: {result.coefficients}")
+print(f"Non-zero: {result.n_nonzero}")
+print(f"Converged: {result.converged}")
+```
+
+### Elastic Net Regression (Python)
+
+```python
+result = linreg_core.elastic_net_regression(
+    y, x, ["Intercept", "X1"],
+    0.1,      # lambda
+    0.5,      # alpha (0 = Ridge, 1 = Lasso, 0.5 = balanced)
+    True,     # standardize
+    100000,   # max_iter
+    1e-7      # tol
+)
+print(f"Intercept: {result.intercept}")
+print(f"Coefficients: {result.coefficients}")
+print(f"Non-zero: {result.n_nonzero}")
+```
+
+### Lambda Path Generation (Python)
+
+```python
+path = linreg_core.make_lambda_path(
+    y, x,
+    100,              # n_lambda
+    0.01              # lambda_min_ratio
+)
+print(f"Lambda max: {path.lambda_max}")
+print(f"Lambda min: {path.lambda_min}")
+print(f"Number: {path.n_lambda}")
+```
+
+### Diagnostic Tests (Python)
+
+```python
+# Breusch-Pagan test (heteroscedasticity)
+bp = linreg_core.breusch_pagan_test(y, x)
+print(f"Statistic: {bp.statistic}, p-value: {bp.p_value}")
+
+# Harvey-Collier test (linearity)
+hc = linreg_core.harvey_collier_test(y, x)
+
+# Rainbow test (linearity) - supports "r", "python", or "both" methods
+rainbow = linreg_core.rainbow_test(y, x, 0.5, "r")
+
+# White test - choose method: "r", "python", or "both"
+white = linreg_core.white_test(y, x, "r")
+# Or use specific method functions
+white_r = linreg_core.r_white_test(y, x)
+white_py = linreg_core.python_white_test(y, x)
+
+# Jarque-Bera test (normality)
+jb = linreg_core.jarque_bera_test(y, x)
+
+# Durbin-Watson test (autocorrelation)
+dw = linreg_core.durbin_watson_test(y, x)
+print(f"DW statistic: {dw.statistic}")
+
+# Shapiro-Wilk test (normality)
+sw = linreg_core.shapiro_wilk_test(y, x)
+
+# Anderson-Darling test (normality)
+ad = linreg_core.anderson_darling_test(y, x)
+
+# Cook's Distance (influential observations)
+cd = linreg_core.cooks_distance_test(y, x)
+print(f"Influential points: {cd.influential_4_over_n}")
+
+# RESET test (model specification)
+reset = linreg_core.reset_test(y, x, [2, 3], "fitted")
+
+# Breusch-Godfrey test (higher-order autocorrelation)
+bg = linreg_core.breusch_godfrey_test(y, x, 1, "chisq")
+```
+
+### Statistical Utilities (Python)
+
+```python
+# Student's t CDF
+t_cdf = linreg_core.get_t_cdf(1.96, 20)
+
+# Critical t-value (two-tailed)
+t_crit = linreg_core.get_t_critical(0.05, 20)
+
+# Normal inverse CDF (probit)
+z_score = linreg_core.get_normal_inverse(0.975)
+
+# Library version
+version = linreg_core.get_version()
+```
+
+### Descriptive Statistics (Python)
+
+```python
+import numpy as np
+
+# All return float directly (no parsing needed)
+mean = linreg_core.stats_mean([1, 2, 3, 4, 5])
+variance = linreg_core.stats_variance([1, 2, 3, 4, 5])
+stddev = linreg_core.stats_stddev([1, 2, 3, 4, 5])
+median = linreg_core.stats_median([1, 2, 3, 4, 5])
+quantile = linreg_core.stats_quantile([1, 2, 3, 4, 5], 0.5)
+correlation = linreg_core.stats_correlation([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])
+
+# Works with numpy arrays too
+mean = linreg_core.stats_mean(np.array([1, 2, 3, 4, 5]))
+```
+
+### CSV Parsing (Python)
+
+```python
+csv_content = '''name,value,category
+Alice,42.5,A
+Bob,17.3,B
+Charlie,99.9,A'''
+
+result = linreg_core.parse_csv(csv_content)
+print(f"Headers: {result.headers}")
+print(f"Numeric columns: {result.numeric_columns}")
+print(f"Data rows: {result.n_rows}")
+```
+
+---
+
+## Feature Flags
+
+| Feature | Default | Description |
+|---------|---------|-------------|
+| `wasm` | Yes | Enables WASM bindings and browser support |
+| `python` | No | Enables Python bindings via PyO3 |
+| `validation` | No | Includes test data for validation tests |
+
+For native Rust without WASM overhead:
+
+```toml
+linreg-core = { version = "0.4", default-features = false }
+```
+
+For Python bindings (built with maturin):
 
 ```bash
-LINREG_DOMAIN_RESTRICT=example.com,mysite.com wasm-pack build --release --target web
+pip install linreg-core
 ```
 
-When NOT set (default), all domains are allowed. When set, only the specified domains can use the WASM module.
+---
 
 ## Validation
 
@@ -521,6 +726,8 @@ wasm-pack test --node
 cargo test --all-features
 ```
 
+---
+
 ## Implementation Notes
 
 ### Regularization
@@ -546,10 +753,14 @@ minimize (1/(2n)) * Σ(yᵢ - β₀ - xᵢᵀβ)² + λ * [(1 - α) * ||β||₂
 - Shapiro-Wilk limited to n <= 5000 (matching R's limitation)
 - White test may differ from R on collinear datasets due to numerical precision in near-singular matrices
 
+---
+
 ## Disclaimer
 
 This library is under active development and has not reached 1.0 stability. While outputs are validated against R and Python implementations, **do not use this library for critical applications** (medical, financial, safety-critical systems) without independent verification. See the [LICENSE](LICENSE-MIT) for full terms. The software is provided "as is" without warranty of any kind.
 
+---
+
 ## License
 
 Dual-licensed under [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-APACHE).

package/package.json

@@ -1,34 +1,34 @@
-{
-  "name": "linreg-core",
-  "type": "module",
-  "collaborators": [
-    "Jesse Anderson"
-  ],
-  "description": "Lightweight linear regression (OLS, Ridge, Lasso, Elastic Net) with diagnostic tests. Pure Rust - no external math dependencies.",
-  "version": "0.3.0",
-  "license": "MIT OR Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jesse-anderson/linreg-core.git"
-  },
-  "files": [
-    "linreg_core_bg.wasm",
-    "linreg_core.js",
-    "linreg_core.d.ts",
-    "LICENSE-APACHE",
-    "LICENSE-MIT"
-  ],
-  "main": "linreg_core.js",
-  "homepage": "https://github.com/jesse-anderson/linreg-core#readme",
-  "types": "linreg_core.d.ts",
-  "sideEffects": [
-    "./snippets/*"
-  ],
-  "keywords": [
-    "regression",
-    "statistics",
-    "linear-regression",
-    "ridge",
-    "lasso"
-  ]
-}
+{
+  "name": "linreg-core",
+  "type": "module",
+  "collaborators": [
+    "Jesse Anderson"
+  ],
+  "description": "Lightweight linear regression (OLS, Ridge, Lasso, Elastic Net) with diagnostic tests. Pure Rust - no external math dependencies.",
+  "version": "0.4.0",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jesse-anderson/linreg-core"
+  },
+  "files": [
+    "linreg_core_bg.wasm",
+    "linreg_core.js",
+    "linreg_core.d.ts",
+    "LICENSE-APACHE",
+    "LICENSE-MIT"
+  ],
+  "main": "linreg_core.js",
+  "homepage": "https://jesse-anderson.net",
+  "types": "linreg_core.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ],
+  "keywords": [
+    "regression",
+    "statistics",
+    "linear-regression",
+    "ridge",
+    "lasso"
+  ]
+}