@wlearn/liblinear 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 0.1.0 (unreleased)
+
+- Initial release
+- LIBLINEAR v2.50 compiled to WASM via Emscripten
+- Unified sklearn-style API: `create()`, `fit()`, `predict()`, `score()`, `save()`, `dispose()`
+- Linear classifiers (logistic regression, SVC) and regressors (SVR)
+- Buffer-based model I/O (no filesystem dependency)
+- Accepts both typed matrices and number[][] with configurable coercion
+- `predictProba()` for logistic regression solvers
+- `decisionFunction()` for decision values
+- `getParams()`/`setParams()` for AutoML integration
+- `defaultSearchSpace()` for hyperparameter search
+- `FinalizationRegistry` safety net for leak detection
+- BSD-3-Clause license (same as upstream LIBLINEAR)

package/LICENSE

@@ -0,0 +1,29 @@
+Copyright (c) 2007-2025 The LIBLINEAR Project.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither name of copyright holders nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,176 @@
+# @wlearn/liblinear
+
+LIBLINEAR v2.50 compiled to WebAssembly. Linear classification and regression in browsers and Node.js.
+
+Based on [LIBLINEAR v2.50](https://www.csie.ntu.edu.tw/~cjlin/liblinear/) (BSD-3-Clause). Zero dependencies. ESM.
+
+## Install
+
+```bash
+npm install @wlearn/liblinear
+```
+
+## Quick start
+
+```js
+import { LinearModel } from '@wlearn/liblinear'
+
+const model = await LinearModel.create({
+  solver: 'L2R_LR',
+  C: 1.0
+})
+
+// Train -- accepts number[][] or { data: Float64Array, rows, cols }
+model.fit(
+  [[1, 2], [3, 4], [5, 6], [7, 8]],
+  [0, 0, 1, 1]
+)
+
+// Predict
+const preds = model.predict([[2, 3], [6, 7]])  // Float64Array
+
+// Probabilities (logistic regression solvers only)
+const probs = model.predictProba([[2, 3], [6, 7]])  // Float64Array (nrow * nclass)
+
+// Score
+const accuracy = model.score([[2, 3], [6, 7]], [0, 1])
+
+// Save / load
+const buf = model.save()  // Uint8Array
+const model2 = await LinearModel.load(buf)
+
+// Clean up -- required, WASM memory is not garbage collected
+model.dispose()
+model2.dispose()
+```
+
+## Typed matrix input (fast path)
+
+For performance-critical code and AutoML integration, pass typed matrices directly:
+
+```js
+const X = {
+  data: new Float64Array([1, 2, 3, 4, 5, 6, 7, 8]),
+  rows: 4,
+  cols: 2
+}
+const y = new Float64Array([0, 0, 1, 1])
+
+model.fit(X, y)
+```
+
+This avoids the conversion cost of nested arrays.
+
+## Input coercion policy
+
+Control how non-typed inputs are handled:
+
+```js
+// Default: convert silently
+const model = await LinearModel.create({ coerce: 'auto' })
+
+// Warn once per instance when conversion happens
+const model = await LinearModel.create({ coerce: 'warn' })
+
+// Throw if input is not already a typed matrix
+const model = await LinearModel.create({ coerce: 'error' })
+```
+
+## API
+
+### `LinearModel.create(params?)`
+
+Async factory. Loads WASM module, returns a ready-to-use model.
+
+Parameters:
+- `solver` -- solver type string or number (default: `'L2R_LR'`)
+- `C` -- regularization parameter (default: `1.0`)
+- `eps` -- stopping tolerance (default: `0.01`)
+- `bias` -- bias term, < 0 disables (default: `-1`)
+- `p` -- epsilon in SVR loss (default: `0.1`)
+- `coerce` -- input coercion: `'auto'` | `'warn'` | `'error'` (default: `'auto'`)
+
+### `model.fit(X, y)`
+
+Train on data. Returns `this` for chaining.
+- `X` -- `number[][]` or `{ data: Float64Array, rows, cols }`
+- `y` -- `number[]` or `Float64Array`
+
+### `model.predict(X)`
+
+Returns `Float64Array` of predicted labels.
+
+### `model.predictProba(X)`
+
+Returns `Float64Array` of shape `nrow * nclass` (row-major probabilities).
+Only available for logistic regression solvers (L2R_LR, L1R_LR, L2R_LR_DUAL).
+
+### `model.decisionFunction(X)`
+
+Returns `Float64Array` of decision values.
+
+### `model.score(X, y)`
+
+Returns accuracy (classification) or R-squared (regression).
+
+### `model.save()`
+
+Returns `Uint8Array` (native LIBLINEAR model format).
+
+### `LinearModel.load(buffer)`
+
+Loads from `Uint8Array`. Returns `Promise<LinearModel>`.
+
+### `model.dispose()`
+
+Free WASM memory. Required. Idempotent.
+
+### `model.getParams()` / `model.setParams(p)`
+
+Get/set hyperparameters. Enables AutoML grid search and cloning.
+
+### `LinearModel.defaultSearchSpace()`
+
+Returns default hyperparameter search space for AutoML.
+
+## Solver types
+
+| Name | Code | Task |
+|------|------|------|
+| L2R_LR | 0 | L2-regularized logistic regression |
+| L2R_L2LOSS_SVC_DUAL | 1 | L2-loss SVM (dual) |
+| L2R_L2LOSS_SVC | 2 | L2-loss SVM (primal) |
+| L2R_L1LOSS_SVC_DUAL | 3 | L1-loss SVM (dual) |
+| MCSVM_CS | 4 | Multi-class SVM (Crammer-Singer) |
+| L1R_L2LOSS_SVC | 5 | L1-regularized L2-loss SVM |
+| L1R_LR | 6 | L1-regularized logistic regression |
+| L2R_LR_DUAL | 7 | L2-regularized logistic regression (dual) |
+| L2R_L2LOSS_SVR | 11 | L2-loss SVR (primal) |
+| L2R_L2LOSS_SVR_DUAL | 12 | L2-loss SVR (dual) |
+| L2R_L1LOSS_SVR_DUAL | 13 | L1-loss SVR (dual) |
+
+## Resource management
+
+WASM heap memory is not garbage collected. Call `.dispose()` on every model when done.
+A `FinalizationRegistry` safety net warns if you forget, but do not rely on it.
+
+## Build from source
+
+Requires [Emscripten](https://emscripten.org/) (emsdk) activated.
+
+```bash
+git clone --recurse-submodules https://github.com/wlearn-org/liblinear-wasm
+cd liblinear-wasm
+npm run build
+npm test
+```
+
+If you already cloned without `--recurse-submodules`:
+
+```bash
+git submodule update --init
+```
+
+## License
+
+BSD-3-Clause (same as upstream LIBLINEAR)

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@wlearn/liblinear",
+  "version": "0.1.0",
+  "description": "LIBLINEAR v2.50 compiled to WebAssembly -- linear classification and regression in browsers and Node.js",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src/",
+    "wasm/",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --experimental-vm-modules test/test.js",
+    "build": "bash scripts/build-wasm.sh",
+    "verify": "bash scripts/verify-exports.sh"
+  },
+  "dependencies": {
+    "@wlearn/types": "0.1.0",
+    "@wlearn/core": "0.1.0"
+  },
+  "keywords": [
+    "liblinear",
+    "svm",
+    "logistic-regression",
+    "machine-learning",
+    "wasm",
+    "webassembly",
+    "wlearn"
+  ],
+  "author": "Anton Zemlyansky",
+  "license": "BSD-3-Clause"
+}

package/src/index.js

@@ -0,0 +1,17 @@
+export { loadLinear, getWasm } from './wasm.js'
+export { LinearModel, Solver } from './model.js'
+
+// Convenience: create, fit, return fitted model
+export async function train(params, X, y) {
+  const model = await LinearModel.create(params)
+  model.fit(X, y)
+  return model
+}
+
+// Convenience: load WLRN bundle and predict, auto-disposes model
+export async function predict(bundleBytes, X) {
+  const model = await LinearModel.load(bundleBytes)
+  const result = model.predict(X)
+  model.dispose()
+  return result
+}

package/src/model.js

@@ -0,0 +1,475 @@
+import { getWasm, loadLinear } from './wasm.js'
+import {
+  normalizeX, normalizeY,
+  encodeBundle, decodeBundle,
+  register,
+  DisposedError, NotFittedError
+} from '@wlearn/core'
+
+// FinalizationRegistry safety net -- warns if dispose() was never called
+const leakRegistry = typeof FinalizationRegistry !== 'undefined'
+  ? new FinalizationRegistry(({ ptr, freeFn }) => {
+    if (ptr[0]) {
+      console.warn('@wlearn/liblinear: Model was not disposed -- calling free() automatically. This is a bug in your code.')
+      freeFn(ptr[0])
+    }
+  })
+  : null
+
+// --- Solver constants ---
+
+export const Solver = {
+  L2R_LR: 0,
+  L2R_L2LOSS_SVC_DUAL: 1,
+  L2R_L2LOSS_SVC: 2,
+  L2R_L1LOSS_SVC_DUAL: 3,
+  MCSVM_CS: 4,
+  L1R_L2LOSS_SVC: 5,
+  L1R_LR: 6,
+  L2R_LR_DUAL: 7,
+  L2R_L2LOSS_SVR: 11,
+  L2R_L2LOSS_SVR_DUAL: 12,
+  L2R_L1LOSS_SVR_DUAL: 13
+}
+
+const SOLVER_NAMES = Object.fromEntries(
+  Object.entries(Solver).map(([k, v]) => [v, k])
+)
+
+const LR_SOLVERS = new Set([Solver.L2R_LR, Solver.L1R_LR, Solver.L2R_LR_DUAL])
+const SVR_SOLVERS = new Set([Solver.L2R_L2LOSS_SVR, Solver.L2R_L2LOSS_SVR_DUAL, Solver.L2R_L1LOSS_SVR_DUAL])
+
+function resolveSolver(s) {
+  if (typeof s === 'number') return s
+  if (typeof s === 'string' && s in Solver) return Solver[s]
+  return Solver.L2R_LR
+}
+
+// --- Helper: write C string to WASM heap ---
+
+function withCString(wasm, str, fn) {
+  const bytes = new TextEncoder().encode(str + '\0')
+  const ptr = wasm._malloc(bytes.length)
+  wasm.HEAPU8.set(bytes, ptr)
+  try {
+    return fn(ptr)
+  } finally {
+    wasm._free(ptr)
+  }
+}
+
+function getLastError() {
+  const wasm = getWasm()
+  return wasm.ccall('wl_linear_get_last_error', 'string', [], [])
+}
+
+// --- Internal sentinel for load path ---
+const LOAD_SENTINEL = Symbol('load')
+
+// --- LinearModel ---
+
+export class LinearModel {
+  #handle = null
+  #freed = false
+  #ptrRef = null
+  #params = {}
+  #coerce = 'auto'
+  #warned = false
+  #fitted = false
+
+  constructor(handle, params, coerce) {
+    if (handle === LOAD_SENTINEL) {
+      // Internal: created by load()
+      this.#handle = params // params holds the handle in this path
+      this.#params = coerce || {} // coerce holds params in this path
+      this.#coerce = this.#params.coerce || 'auto'
+      this.#fitted = true
+    } else {
+      // Normal construction (from create())
+      this.#handle = null
+      this.#params = handle || {}
+      this.#coerce = this.#params.coerce || 'auto'
+    }
+
+    this.#freed = false
+    if (this.#handle) {
+      this.#ptrRef = [this.#handle]
+      if (leakRegistry) {
+        leakRegistry.register(this, {
+          ptr: this.#ptrRef,
+          freeFn: (h) => getWasm()._wl_linear_free_model(h)
+        }, this)
+      }
+    }
+  }
+
+  static async create(params = {}) {
+    await loadLinear()
+    return new LinearModel(params)
+  }
+
+  // --- Estimator interface ---
+
+  fit(X, y) {
+    this.#ensureFitted(false)
+    const wasm = getWasm()
+
+    // Dispose previous model if refitting
+    if (this.#handle) {
+      wasm._wl_linear_free_model(this.#handle)
+      this.#handle = null
+      if (this.#ptrRef) this.#ptrRef[0] = null
+      if (leakRegistry) leakRegistry.unregister(this)
+    }
+
+    const { data: xData, rows, cols } = this.#normalizeX(X)
+    const yNorm = normalizeY(y)
+    // WASM boundary requires Float64Array
+    const yData = yNorm instanceof Float64Array ? yNorm : new Float64Array(yNorm)
+
+    if (yData.length !== rows) {
+      throw new Error(`y length (${yData.length}) does not match X rows (${rows})`)
+    }
+
+    // Allocate X on WASM heap (float64)
+    const xBytes = xData.length * 8
+    const xPtr = wasm._malloc(xBytes)
+    wasm.HEAPF64.set(xData, xPtr / 8)
+
+    // Allocate y on WASM heap
+    const yBytes = yData.length * 8
+    const yPtr = wasm._malloc(yBytes)
+    wasm.HEAPF64.set(yData, yPtr / 8)
+
+    const solver = resolveSolver(this.#params.solver)
+    const C = this.#params.C ?? 1.0
+    const eps = this.#params.eps ?? 0.01
+    const bias = this.#params.bias ?? -1
+    const p = this.#params.p ?? 0.1
+
+    const modelPtr = wasm._wl_linear_train(
+      xPtr, rows, cols,
+      yPtr,
+      solver, C, eps, bias, p,
+      0, 0, 0  // nr_weight, weight_label, weight (none)
+    )
+
+    wasm._free(xPtr)
+    wasm._free(yPtr)
+
+    if (!modelPtr) {
+      throw new Error(`Training failed: ${getLastError()}`)
+    }
+
+    this.#handle = modelPtr
+    this.#fitted = true
+
+    // Register for leak detection
+    this.#ptrRef = [this.#handle]
+    if (leakRegistry) {
+      leakRegistry.register(this, {
+        ptr: this.#ptrRef,
+        freeFn: (h) => getWasm()._wl_linear_free_model(h)
+      }, this)
+    }
+
+    return this
+  }
+
+  predict(X) {
+    this.#ensureFitted()
+    const wasm = getWasm()
+    const { data: xData, rows, cols } = this.#normalizeX(X)
+
+    const xPtr = wasm._malloc(xData.length * 8)
+    wasm.HEAPF64.set(xData, xPtr / 8)
+
+    const outPtr = wasm._malloc(rows * 8)
+
+    const ret = wasm._wl_linear_predict(this.#handle, xPtr, rows, cols, outPtr)
+
+    if (ret !== 0) {
+      wasm._free(xPtr)
+      wasm._free(outPtr)
+      throw new Error(`Predict failed: ${getLastError()}`)
+    }
+
+    const result = new Float64Array(rows)
+    for (let i = 0; i < rows; i++) {
+      result[i] = wasm.HEAPF64[outPtr / 8 + i]
+    }
+
+    wasm._free(xPtr)
+    wasm._free(outPtr)
+    return result
+  }
+
+  predictProba(X) {
+    this.#ensureFitted()
+    const wasm = getWasm()
+    const { data: xData, rows, cols } = this.#normalizeX(X)
+    const nrClass = this.nrClass
+
+    const xPtr = wasm._malloc(xData.length * 8)
+    wasm.HEAPF64.set(xData, xPtr / 8)
+
+    const outPtr = wasm._malloc(rows * nrClass * 8)
+
+    const ret = wasm._wl_linear_predict_probability(this.#handle, xPtr, rows, cols, outPtr)
+
+    if (ret !== 0) {
+      wasm._free(xPtr)
+      wasm._free(outPtr)
+      throw new Error(`predictProba failed: ${getLastError()}`)
+    }
+
+    const total = rows * nrClass
+    const result = new Float64Array(total)
+    for (let i = 0; i < total; i++) {
+      result[i] = wasm.HEAPF64[outPtr / 8 + i]
+    }
+
+    wasm._free(xPtr)
+    wasm._free(outPtr)
+    return result
+  }
+
+  decisionFunction(X) {
+    this.#ensureFitted()
+    const wasm = getWasm()
+    const { data: xData, rows, cols } = this.#normalizeX(X)
+    const dim = this.decisionDim
+
+    const xPtr = wasm._malloc(xData.length * 8)
+    wasm.HEAPF64.set(xData, xPtr / 8)
+
+    const outPtr = wasm._malloc(rows * dim * 8)
+
+    const ret = wasm._wl_linear_predict_values(this.#handle, xPtr, rows, cols, outPtr)
+
+    if (ret !== 0) {
+      wasm._free(xPtr)
+      wasm._free(outPtr)
+      throw new Error(`decisionFunction failed: ${getLastError()}`)
+    }
+
+    const total = rows * dim
+    const result = new Float64Array(total)
+    for (let i = 0; i < total; i++) {
+      result[i] = wasm.HEAPF64[outPtr / 8 + i]
+    }
+
+    wasm._free(xPtr)
+    wasm._free(outPtr)
+    return result
+  }
+
+  score(X, y) {
+    const preds = this.predict(X)
+    const yArr = normalizeY(y)
+
+    if (this.#isRegressor()) {
+      // R-squared
+      let ssRes = 0, ssTot = 0
+      let yMean = 0
+      for (let i = 0; i < yArr.length; i++) yMean += yArr[i]
+      yMean /= yArr.length
+      for (let i = 0; i < yArr.length; i++) {
+        ssRes += (yArr[i] - preds[i]) ** 2
+        ssTot += (yArr[i] - yMean) ** 2
+      }
+      return ssTot === 0 ? 0 : 1 - ssRes / ssTot
+    } else {
+      // Accuracy
+      let correct = 0
+      for (let i = 0; i < preds.length; i++) {
+        if (preds[i] === yArr[i]) correct++
+      }
+      return correct / preds.length
+    }
+  }
+
+  // --- Model I/O ---
+
+  save() {
+    this.#ensureFitted()
+    const rawBytes = this.#saveRaw()
+    const solver = resolveSolver(this.#params.solver)
+    const typeId = SVR_SOLVERS.has(solver)
+      ? 'wlearn.liblinear.regressor@1'
+      : 'wlearn.liblinear.classifier@1'
+    return encodeBundle(
+      { typeId, params: this.getParams() },
+      [{ id: 'model', data: rawBytes }]
+    )
+  }
+
+  static async load(bytes) {
+    const { manifest, toc, blobs } = decodeBundle(bytes)
+    return LinearModel._fromBundle(manifest, toc, blobs)
+  }
+
+  static async _fromBundle(manifest, toc, blobs) {
+    await loadLinear()
+    const wasm = getWasm()
+
+    const entry = toc.find(e => e.id === 'model')
+    if (!entry) throw new Error('Bundle missing "model" artifact')
+    const raw = blobs.subarray(entry.offset, entry.offset + entry.length)
+
+    const bufPtr = wasm._malloc(raw.length)
+    wasm.HEAPU8.set(raw, bufPtr)
+    const modelPtr = wasm._wl_linear_load_model(bufPtr, raw.length)
+    wasm._free(bufPtr)
+
+    if (!modelPtr) {
+      throw new Error(`load failed: ${getLastError()}`)
+    }
+
+    return new LinearModel(LOAD_SENTINEL, modelPtr, manifest.params || {})
+  }
+
+  dispose() {
+    if (this.#freed) return
+    this.#freed = true
+
+    if (this.#handle) {
+      const wasm = getWasm()
+      wasm._wl_linear_free_model(this.#handle)
+    }
+
+    if (this.#ptrRef) this.#ptrRef[0] = null
+    if (leakRegistry) leakRegistry.unregister(this)
+
+    this.#handle = null
+    this.#fitted = false
+  }
+
+  // --- Params ---
+
+  getParams() {
+    return { ...this.#params }
+  }
+
+  setParams(p) {
+    Object.assign(this.#params, p)
+    if ('coerce' in p) this.#coerce = p.coerce
+    return this
+  }
+
+  static defaultSearchSpace() {
+    return {
+      solver: { type: 'categorical', values: ['L2R_LR', 'L2R_L2LOSS_SVC_DUAL', 'L1R_LR'] },
+      C: { type: 'log_uniform', low: 1e-4, high: 1e4 },
+      eps: { type: 'log_uniform', low: 1e-5, high: 1e-1 }
+    }
+  }
+
+  // --- Inspection ---
+
+  get nrClass() {
+    this.#ensureFitted()
+    return getWasm()._wl_linear_get_nr_class(this.#handle)
+  }
+
+  get nrFeature() {
+    this.#ensureFitted()
+    return getWasm()._wl_linear_get_nr_feature(this.#handle)
+  }
+
+  get classes() {
+    this.#ensureFitted()
+    const wasm = getWasm()
+    const n = this.nrClass
+    const outPtr = wasm._malloc(n * 4)
+    wasm._wl_linear_get_labels(this.#handle, outPtr)
+    const result = new Int32Array(n)
+    for (let i = 0; i < n; i++) {
+      result[i] = wasm.getValue(outPtr + i * 4, 'i32')
+    }
+    wasm._free(outPtr)
+    return result
+  }
+
+  get isFitted() {
+    return this.#fitted && !this.#freed
+  }
+
+  get capabilities() {
+    const solver = resolveSolver(this.#params.solver)
+    const isRegressor = SVR_SOLVERS.has(solver)
+    const hasProba = LR_SOLVERS.has(solver)
+    return {
+      classifier: !isRegressor,
+      regressor: isRegressor,
+      predictProba: hasProba,
+      decisionFunction: true,
+      sampleWeight: false,
+      csr: false,
+      earlyStopping: false
+    }
+  }
+
+  get probaDim() {
+    return this.isFitted ? this.nrClass : 0
+  }
+
+  get decisionDim() {
+    if (!this.isFitted) return 0
+    const n = this.nrClass
+    return n === 2 ? 1 : n
+  }
+
+  // --- Private helpers ---
+
+  #saveRaw() {
+    const wasm = getWasm()
+
+    const outBufPtr = wasm._malloc(4)  // char** (pointer to buffer)
+    const outLenPtr = wasm._malloc(4)  // int*
+
+    const ret = wasm._wl_linear_save_model(this.#handle, outBufPtr, outLenPtr)
+
+    if (ret !== 0) {
+      wasm._free(outBufPtr)
+      wasm._free(outLenPtr)
+      throw new Error(`save failed: ${getLastError()}`)
+    }
+
+    const bufPtr = wasm.getValue(outBufPtr, 'i32')
+    const bufLen = wasm.getValue(outLenPtr, 'i32')
+
+    const result = new Uint8Array(bufLen)
+    result.set(wasm.HEAPU8.subarray(bufPtr, bufPtr + bufLen))
+
+    wasm._wl_linear_free_buffer(bufPtr)
+    wasm._free(outBufPtr)
+    wasm._free(outLenPtr)
+
+    return result
+  }
+
+  #normalizeX(X) {
+    const coerce = this.#warned ? 'auto' : this.#coerce
+    const result = normalizeX(X, coerce)
+    if (this.#coerce === 'warn' && !this.#warned && Array.isArray(X)) {
+      this.#warned = true
+    }
+    return result
+  }
+
+  #ensureFitted(requireFit = true) {
+    if (this.#freed) throw new DisposedError('LinearModel has been disposed.')
+    if (requireFit && !this.#fitted) throw new NotFittedError('LinearModel is not fitted. Call fit() first.')
+  }
+
+  #isRegressor() {
+    const solver = resolveSolver(this.#params.solver)
+    return SVR_SOLVERS.has(solver)
+  }
+}
+
+// --- Register loaders with @wlearn/core ---
+
+register('wlearn.liblinear.classifier@1', (m, t, b) => LinearModel._fromBundle(m, t, b))
+register('wlearn.liblinear.regressor@1', (m, t, b) => LinearModel._fromBundle(m, t, b))

package/src/wasm.js

@@ -0,0 +1,27 @@
+// WASM loader -- loads the LIBLINEAR WASM module (singleton, lazy init)
+
+import { createRequire } from 'module'
+
+let wasmModule = null
+let loading = null
+
+export async function loadLinear(options = {}) {
+  if (wasmModule) return wasmModule
+  if (loading) return loading
+
+  loading = (async () => {
+    // SINGLE_FILE=1: .wasm is embedded in the .js file, no locateFile needed
+    // Emscripten output is CJS, use createRequire for ESM compatibility
+    const require = createRequire(import.meta.url)
+    const createLinear = require('../wasm/linear.cjs')
+    wasmModule = await createLinear(options)
+    return wasmModule
+  })()
+
+  return loading
+}
+
+export function getWasm() {
+  if (!wasmModule) throw new Error('WASM not loaded -- call loadLinear() first')
+  return wasmModule
+}

package/wasm/BUILD_INFO

@@ -0,0 +1,6 @@
+upstream: liblinear v2.50
+upstream_commit: 491c9f1188b97ba70847c70a68be363d186ddf9d
+build_date: 2026-02-27T13:01:37Z
+emscripten: emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 5.0.2 (dc80f645ee70178c11666de0c3860d9e064d50e4)
+build_flags: -O2 SINGLE_FILE=1
+wasm_embedded: true