@wlearn/libsvm 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## 0.1.0 (unreleased)
+
+- Initial release
+- LIBSVM v3.37 compiled to WASM via Emscripten
+- Unified sklearn-style API: `create()`, `fit()`, `predict()`, `score()`, `save()`, `dispose()`
+- Kernel SVM: C-SVC, nu-SVC, one-class SVM, epsilon-SVR, nu-SVR
+- Kernels: linear, polynomial, RBF, sigmoid
+- Buffer-based model I/O (no filesystem dependency)
+- Accepts both typed matrices and number[][] with configurable coercion
+- `predictProba()` for probability estimates
+- `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 LIBSVM)

package/LICENSE

@@ -0,0 +1,29 @@
+Copyright (c) 2000-2025 Chih-Chung Chang and Chih-Jen Lin
+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,167 @@
+# @wlearn/libsvm
+
+LIBSVM v3.37 compiled to WebAssembly. Kernel SVM classification, regression, and novelty detection in browsers and Node.js.
+
+Based on [LIBSVM v3.37](https://www.csie.ntu.edu.tw/~cjlin/libsvm/) (BSD-3-Clause). Zero dependencies. ESM.
+
+## Install
+
+```bash
+npm install @wlearn/libsvm
+```
+
+## Quick start
+
+```js
+import { SVMModel } from '@wlearn/libsvm'
+
+const model = await SVMModel.create({
+  svmType: 'C_SVC',
+  kernel: 'RBF',
+  C: 1.0,
+  gamma: 0.5
+})
+
+// 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
+
+// Score
+const accuracy = model.score([[2, 3], [6, 7]], [0, 1])
+
+// Save / load
+const buf = model.save()  // Uint8Array
+const model2 = await SVMModel.load(buf)
+
+// Clean up -- required, WASM memory is not garbage collected
+model.dispose()
+model2.dispose()
+```
+
+## Typed matrix input (fast path)
+
+```js
+const X = {
+  data: new Float64Array([1, 2, 3, 4, 5, 6, 7, 8]),
+  rows: 4,
+  cols: 2
+}
+model.fit(X, new Float64Array([0, 0, 1, 1]))
+```
+
+## Input coercion policy
+
+```js
+const model = await SVMModel.create({ coerce: 'auto' })   // convert silently (default)
+const model = await SVMModel.create({ coerce: 'warn' })    // warn once per instance
+const model = await SVMModel.create({ coerce: 'error' })   // throw on non-typed input
+```
+
+## API
+
+### `SVMModel.create(params?)`
+
+Async factory. Loads WASM module, returns ready-to-use model.
+
+Parameters:
+- `svmType` -- `'C_SVC'` | `'NU_SVC'` | `'ONE_CLASS'` | `'EPSILON_SVR'` | `'NU_SVR'` (default: `'C_SVC'`)
+- `kernel` -- `'LINEAR'` | `'POLY'` | `'RBF'` | `'SIGMOID'` (default: `'RBF'`)
+- `C` -- regularization (default: `1.0`)
+- `gamma` -- kernel coefficient, <= 0 means 1/n_features (default: `0`)
+- `degree` -- polynomial degree (default: `3`)
+- `coef0` -- independent term in kernel (default: `0`)
+- `nu` -- for NU_SVC/NU_SVR/ONE_CLASS (default: `0.5`)
+- `eps` -- stopping tolerance (default: `0.001`)
+- `p` -- epsilon in SVR loss (default: `0.1`)
+- `shrinking` -- use shrinking heuristic (default: `1`)
+- `probability` -- enable probability estimates (default: `0`)
+- `cacheSize` -- kernel cache in MB (default: `100`)
+- `coerce` -- `'auto'` | `'warn'` | `'error'` (default: `'auto'`)
+
+### `model.fit(X, y)`
+
+Train on data. Returns `this`.
+
+### `model.predict(X)`
+
+Returns `Float64Array` of predicted labels.
+
+### `model.predictProba(X)`
+
+Returns `Float64Array` of shape `nrow * nclass` (row-major probabilities).
+Requires `probability: 1` in constructor params.
+
+### `model.decisionFunction(X)`
+
+Returns `Float64Array` of decision values.
+- Binary classification: `nrow` values
+- Multi-class: `nrow * nr_class*(nr_class-1)/2` pairwise margins
+
+### `model.score(X, y)`
+
+Returns accuracy (classification) or R-squared (regression).
+
+### `model.save()` / `SVMModel.load(buffer)`
+
+Save to / load from `Uint8Array` (native LIBSVM format).
+
+### `model.dispose()`
+
+Free WASM memory. Required. Idempotent.
+
+### `model.getParams()` / `model.setParams(p)`
+
+Get/set hyperparameters.
+
+### `SVMModel.defaultSearchSpace()`
+
+Returns default hyperparameter search space for AutoML.
+
+## SVM types
+
+| Name | Code | Task |
+|------|------|------|
+| C_SVC | 0 | C-support vector classification |
+| NU_SVC | 1 | nu-support vector classification |
+| ONE_CLASS | 2 | One-class SVM (novelty detection) |
+| EPSILON_SVR | 3 | epsilon-support vector regression |
+| NU_SVR | 4 | nu-support vector regression |
+
+## Kernels
+
+| Name | Code | Formula |
+|------|------|---------|
+| LINEAR | 0 | u'*v |
+| POLY | 1 | (gamma*u'*v + coef0)^degree |
+| RBF | 2 | exp(-gamma*\|u-v\|^2) |
+| SIGMOID | 3 | tanh(gamma*u'*v + coef0) |
+
+## Resource management
+
+WASM heap memory is not garbage collected. Call `.dispose()` on every model when done.
+
+## Build from source
+
+Requires [Emscripten](https://emscripten.org/) (emsdk) activated.
+
+```bash
+git clone --recurse-submodules https://github.com/wlearn-org/libsvm-wasm
+cd libsvm-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 LIBSVM)

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@wlearn/libsvm",
+  "version": "0.1.0",
+  "description": "LIBSVM v3.37 compiled to WebAssembly -- SVM classification, regression, and novelty detection 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"
+  },
+  "keywords": [
+    "libsvm",
+    "svm",
+    "kernel",
+    "machine-learning",
+    "wasm",
+    "webassembly",
+    "wlearn"
+  ],
+  "author": "Anton Zemlyansky",
+  "license": "BSD-3-Clause",
+  "dependencies": {
+    "@wlearn/types": "0.1.0",
+    "@wlearn/core": "0.1.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,17 @@
+export { loadSVM, getWasm } from './wasm.js'
+export { SVMModel, SVMType, Kernel } from './model.js'
+
+// Convenience: create, fit, return fitted model
+export async function train(params, X, y) {
+  const model = await (await import('./model.js')).SVMModel.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 (await import('./model.js')).SVMModel.load(bundleBytes)
+  const result = model.predict(X)
+  model.dispose()
+  return result
+}

package/src/model.js

@@ -0,0 +1,481 @@
+import { getWasm, loadSVM } 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/libsvm: Model was not disposed -- calling free() automatically. This is a bug in your code.')
+      freeFn(ptr[0])
+    }
+  })
+  : null
+
+// --- SVM type and kernel constants ---
+
+export const SVMType = {
+  C_SVC: 0,
+  NU_SVC: 1,
+  ONE_CLASS: 2,
+  EPSILON_SVR: 3,
+  NU_SVR: 4
+}
+
+export const Kernel = {
+  LINEAR: 0,
+  POLY: 1,
+  RBF: 2,
+  SIGMOID: 3
+}
+
+const SVR_TYPES = new Set([SVMType.EPSILON_SVR, SVMType.NU_SVR])
+
+// --- Input resolution ---
+
+function resolveSVMType(s) {
+  if (typeof s === 'number') return s
+  if (typeof s === 'string' && s in SVMType) return SVMType[s]
+  return SVMType.C_SVC
+}
+
+function resolveKernel(k) {
+  if (typeof k === 'number') return k
+  if (typeof k === 'string' && k in Kernel) return Kernel[k]
+  return Kernel.RBF
+}
+
+function getLastError() {
+  const wasm = getWasm()
+  return wasm.ccall('wl_svm_get_last_error', 'string', [], [])
+}
+
+// --- Internal sentinel for load path ---
+const LOAD_SENTINEL = Symbol('load')
+
+// --- SVMModel ---
+
+export class SVMModel {
+  #handle = null
+  #freed = false
+  #ptrRef = null
+  #params = {}
+  #coerce = 'auto'
+  #warned = false
+  #fitted = false
+  #ncol = 0  // track feature count for gamma default
+
+  constructor(handle, params, coerce) {
+    if (handle === LOAD_SENTINEL) {
+      this.#handle = params
+      this.#params = coerce || {}
+      this.#coerce = this.#params.coerce || 'auto'
+      this.#fitted = true
+    } else {
+      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_svm_free_model(h)
+        }, this)
+      }
+    }
+  }
+
+  static async create(params = {}) {
+    await loadSVM()
+    return new SVMModel(params)
+  }
+
+  // --- Estimator interface ---
+
+  fit(X, y) {
+    this.#ensureFitted(false)
+    const wasm = getWasm()
+
+    // Dispose previous model if refitting
+    if (this.#handle) {
+      wasm._wl_svm_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)
+    this.#ncol = cols
+
+    if (yData.length !== rows) {
+      throw new Error(`y length (${yData.length}) does not match X rows (${rows})`)
+    }
+
+    // Allocate on WASM heap
+    const xPtr = wasm._malloc(xData.length * 8)
+    wasm.HEAPF64.set(xData, xPtr / 8)
+
+    const yPtr = wasm._malloc(yData.length * 8)
+    wasm.HEAPF64.set(yData, yPtr / 8)
+
+    const svmType = resolveSVMType(this.#params.svmType)
+    const kernel = resolveKernel(this.#params.kernel)
+    const degree = this.#params.degree ?? 3
+    const gamma = this.#params.gamma ?? 0  // 0 means 1/n_features in C wrapper
+    const coef0 = this.#params.coef0 ?? 0
+    const C = this.#params.C ?? 1.0
+    const nu = this.#params.nu ?? 0.5
+    const eps = this.#params.eps ?? 0.001
+    const p = this.#params.p ?? 0.1
+    const shrinking = this.#params.shrinking ?? 1
+    const probability = this.#params.probability ?? 0
+    const cacheSize = this.#params.cacheSize ?? 100
+
+    const modelPtr = wasm._wl_svm_train(
+      xPtr, rows, cols, yPtr,
+      svmType, kernel, degree, gamma, coef0,
+      C, nu, eps, p,
+      shrinking, probability, cacheSize
+    )
+
+    wasm._free(xPtr)
+    wasm._free(yPtr)
+
+    if (!modelPtr) {
+      throw new Error(`Training failed: ${getLastError()}`)
+    }
+
+    this.#handle = modelPtr
+    this.#fitted = true
+
+    this.#ptrRef = [this.#handle]
+    if (leakRegistry) {
+      leakRegistry.register(this, {
+        ptr: this.#ptrRef,
+        freeFn: (h) => getWasm()._wl_svm_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_svm_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_svm_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 xPtr = wasm._malloc(xData.length * 8)
+    wasm.HEAPF64.set(xData, xPtr / 8)
+
+    const dimPtr = wasm._malloc(4)
+    const nrClass = this.nrClass
+    const maxDim = nrClass * (nrClass - 1) / 2 || 1
+    const outPtr = wasm._malloc(rows * maxDim * 8)
+
+    const ret = wasm._wl_svm_predict_values(
+      this.#handle, xPtr, rows, cols, outPtr, dimPtr
+    )
+
+    if (ret !== 0) {
+      wasm._free(xPtr)
+      wasm._free(outPtr)
+      wasm._free(dimPtr)
+      throw new Error(`decisionFunction failed: ${getLastError()}`)
+    }
+
+    const dim = wasm.getValue(dimPtr, 'i32')
+    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)
+    wasm._free(dimPtr)
+    return result
+  }
+
+  score(X, y) {
+    const preds = this.predict(X)
+    const yArr = normalizeY(y)
+
+    if (this.#isRegressor()) {
+      // R-squared
+      let ssRes = 0, ssTot = 0, 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 svmType = resolveSVMType(this.#params.svmType)
+    const typeId = SVR_TYPES.has(svmType)
+      ? 'wlearn.libsvm.regressor@1'
+      : 'wlearn.libsvm.classifier@1'
+    return encodeBundle(
+      { typeId, params: this.getParams() },
+      [{ id: 'model', data: rawBytes }]
+    )
+  }
+
+  static async load(bytes) {
+    const { manifest, toc, blobs } = decodeBundle(bytes)
+    return SVMModel._fromBundle(manifest, toc, blobs)
+  }
+
+  static async _fromBundle(manifest, toc, blobs) {
+    await loadSVM()
+    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_svm_load_model(bufPtr, raw.length)
+    wasm._free(bufPtr)
+
+    if (!modelPtr) {
+      throw new Error(`load failed: ${getLastError()}`)
+    }
+
+    return new SVMModel(LOAD_SENTINEL, modelPtr, manifest.params || {})
+  }
+
+  dispose() {
+    if (this.#freed) return
+    this.#freed = true
+
+    if (this.#handle) {
+      const wasm = getWasm()
+      wasm._wl_svm_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 {
+      svmType: { type: 'categorical', values: ['C_SVC', 'NU_SVC'] },
+      kernel: { type: 'categorical', values: ['RBF', 'LINEAR', 'POLY'] },
+      C: { type: 'log_uniform', low: 1e-3, high: 1e3 },
+      gamma: { type: 'log_uniform', low: 1e-5, high: 1e1 },
+      degree: { type: 'int_uniform', low: 2, high: 5, condition: { kernel: 'POLY' } },
+      nu: { type: 'uniform', low: 0.01, high: 0.99, condition: { svmType: 'NU_SVC' } }
+    }
+  }
+
+  // --- Inspection ---
+
+  get nrClass() {
+    this.#ensureFitted()
+    return getWasm()._wl_svm_get_nr_class(this.#handle)
+  }
+
+  get svCount() {
+    this.#ensureFitted()
+    return getWasm()._wl_svm_get_sv_count(this.#handle)
+  }
+
+  get classes() {
+    this.#ensureFitted()
+    const wasm = getWasm()
+    const n = this.nrClass
+    const outPtr = wasm._malloc(n * 4)
+    wasm._wl_svm_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 svmType = resolveSVMType(this.#params.svmType)
+    const isRegressor = SVR_TYPES.has(svmType)
+    const probability = this.#params.probability ?? 0
+    return {
+      classifier: !isRegressor,
+      regressor: isRegressor,
+      predictProba: !isRegressor && probability === 1,
+      decisionFunction: true,
+      oneClass: svmType === SVMType.ONE_CLASS,
+      sampleWeight: false,
+      csr: false,
+      earlyStopping: false
+    }
+  }
+
+  get probaDim() {
+    return this.isFitted ? this.nrClass : 0
+  }
+
+  get decisionDim() {
+    if (!this.isFitted) return 0
+    const svmType = resolveSVMType(this.#params.svmType)
+    if (svmType === SVMType.ONE_CLASS || SVR_TYPES.has(svmType)) return 1
+    const n = this.nrClass
+    return n === 2 ? 1 : n * (n - 1) / 2
+  }
+
+  // --- Private helpers ---
+
+  #saveRaw() {
+    const wasm = getWasm()
+
+    const outBufPtr = wasm._malloc(4)
+    const outLenPtr = wasm._malloc(4)
+
+    const ret = wasm._wl_svm_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_svm_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('SVMModel has been disposed.')
+    if (requireFit && !this.#fitted) throw new NotFittedError('SVMModel is not fitted. Call fit() first.')
+  }
+
+  #isRegressor() {
+    const svmType = resolveSVMType(this.#params.svmType)
+    return SVR_TYPES.has(svmType)
+  }
+}
+
+// --- Register loaders with @wlearn/core ---
+
+register('wlearn.libsvm.classifier@1', (m, t, b) => SVMModel._fromBundle(m, t, b))
+register('wlearn.libsvm.regressor@1', (m, t, b) => SVMModel._fromBundle(m, t, b))

package/src/wasm.js

@@ -0,0 +1,27 @@
+// WASM loader -- loads the LIBSVM WASM module (singleton, lazy init)
+
+import { createRequire } from 'module'
+
+let wasmModule = null
+let loading = null
+
+export async function loadSVM(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 createSVM = require('../wasm/svm.cjs')
+    wasmModule = await createSVM(options)
+    return wasmModule
+  })()
+
+  return loading
+}
+
+export function getWasm() {
+  if (!wasmModule) throw new Error('WASM not loaded -- call loadSVM() first')
+  return wasmModule
+}

package/wasm/BUILD_INFO

@@ -0,0 +1,6 @@
+upstream: libsvm v3.37
+upstream_commit: 6b907139084abf2da4d6d3cb10dc3b7eaffa2fbb
+build_date: 2026-02-27T13:03:12Z
+emscripten: emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 5.0.2 (dc80f645ee70178c11666de0c3860d9e064d50e4)
+build_flags: -O2 SINGLE_FILE=1
+wasm_embedded: true