feat(bindings): node + rust packages, primary names unscoped

Add Node and Rust bindings alongside the Python one, and make the primary
package name the generic `sqlite-predict` everywhere -- the discoverable,
squattable name worth claiming -- with the everpure-scoped/prefixed mirrors
reserved for brand (a thin follow-up, and @Everpure is already scope-protected).

- bindings/node: `npm install sqlite-predict`, `require("sqlite-predict").load(db)`
  for better-sqlite3 and node:sqlite. Per-platform binary packages
  (`sqlite-predict-<platform>`) as optionalDependencies, the esbuild/sqlite-vec
  pattern, with a local fallback. Verified loading + forecasting via node:sqlite.
- bindings/rust: crate `sqlite-predict`. build.rs compiles the amalgamation via
  the cc crate (self-contained, no bundled binary); `register()` installs it as
  a SQLite auto-extension. Verified end-to-end (`cargo test` registers + forecasts
  through rusqlite).
- Python package renamed everpure -> unscoped `sqlite-predict` / `import
  sqlite_predict`.
- CI: a `bindings` job runs the rust cargo test and a node:sqlite load+forecast,
  so neither binding can rot. wheels.yml gains the trusted-publishing publish job.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: mstrathman

.github/workflows/ci.yml

@@ -40,6 +40,36 @@ jobs:
       - name: Generate + compile amalgamation
         run: make amalgamation-check
 
+  bindings:
+    name: bindings (node + rust)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # rust crate: compiles the amalgamation via build.rs, register + forecast
+      - name: Rust crate
+        run: make rust-src && cargo test --manifest-path bindings/rust/Cargo.toml
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+      # node binding: load the extension and run a forecast through node:sqlite
+      - name: Node binding
+        run: |
+          make loadable
+          cp dist/predict0.so bindings/node/predict0.so
+          node --experimental-sqlite -e '
+            const sp = require("./bindings/node/index.cjs");
+            const { DatabaseSync } = require("node:sqlite");
+            const db = new DatabaseSync(":memory:", { allowExtension: true });
+            sp.load(db);
+            db.exec("CREATE TABLE r(ts TEXT, value REAL)");
+            const ins = db.prepare("INSERT INTO r VALUES (?,?)");
+            for (let i = 0; i < 96; i++)
+              ins.run("2024-01-01T" + String(i % 24).padStart(2, "0") + ":00:00", 50 + 10 * Math.sin(i));
+            const n = db.prepare("SELECT count(*) c FROM forecast(\x27SELECT ts,value FROM r ORDER BY ts\x27, 6)").get().c;
+            if (n !== 6) { console.error("expected 6, got", n); process.exit(1); }
+            console.log("node binding OK");
+          '
+
   sanitizers:
     name: ASan + UBSan
     runs-on: ubuntu-latest

.github/workflows/wheels.yml

@@ -11,7 +11,7 @@ on:
 # package; cibuildwheel then compiles them per platform.
 #
 # Publishing uses PyPI Trusted Publishing (OIDC) -- no token in GitHub. ONE-TIME
-# setup on PyPI: create the `everpure-sqlite-predict` project's trusted publisher
+# setup on PyPI: create the `sqlite-predict` project's trusted publisher
 # pointing at this repo, workflow `wheels.yml`, and environment `pypi`
 # (https://docs.pypi.org/trusted-publishers/). The `publish` job only runs on a
 # v* tag; plain pushes / workflow_dispatch just build wheels.

.gitignore

@@ -37,4 +37,13 @@ bindings/python/src/
 bindings/python/build/
 bindings/python/dist/
 bindings/python/*.egg-info/
-bindings/python/everpure/sqlite_predict/predict0.*
+bindings/python/sqlite_predict/predict0.*
+
+# node binding (dev binary + deps)
+bindings/node/predict0.*
+bindings/node/node_modules/
+
+# rust binding (staged C + build)
+bindings/rust/csrc/
+bindings/rust/target/
+bindings/rust/Cargo.lock

Makefile

@@ -200,7 +200,7 @@ clean:
 format:
 	clang-format -i sqlite-predict.c predict-*.c
 
-.PHONY: loadable loadable-onnx loadable-onnx-gpu amalgamation amalgamation-check python-src \
+.PHONY: loadable loadable-onnx loadable-onnx-gpu amalgamation amalgamation-check python-src rust-src \
   debug test test-loadable test-onnx test-asan-onnx clean format
 
 # stage the amalgamation + SQLite ext headers into the python package so it can
@@ -209,3 +209,10 @@ python-src: amalgamation vendor/sqlite3ext.h
 	mkdir -p bindings/python/src
 	cp $(AMALGAMATION) bindings/python/src/sqlite-predict.c
 	cp vendor/sqlite3ext.h vendor/sqlite3.h bindings/python/src/
+
+# stage the amalgamation + SQLite ext header into the rust crate (compiled by
+# its build.rs via the cc crate) so `cargo build`/`cargo publish` is self-contained
+rust-src: amalgamation vendor/sqlite3ext.h
+	mkdir -p bindings/rust/csrc
+	cp $(AMALGAMATION) bindings/rust/csrc/sqlite-predict.c
+	cp vendor/sqlite3ext.h vendor/sqlite3.h bindings/rust/csrc/

README.md

@@ -205,12 +205,11 @@ CPU. The default build never links onnxruntime at all.
 **Python** (the fastest way to try it):
 
 ```sh
-pip install everpure-sqlite-predict
+pip install sqlite-predict          # also: npm install sqlite-predict, cargo add sqlite-predict
 ```
 
 ```python
-import sqlite3
-from everpure import sqlite_predict
+import sqlite3, sqlite_predict
 
 db = sqlite3.connect("app.db")
 sqlite_predict.load(db)

bindings/node/README.md

@@ -0,0 +1,31 @@
+# sqlite-predict
+
+Prediction as a SQL primitive for SQLite: `forecast()`, `detect_anomalies()`,
+`predict()`, with replayable receipts. Bundles the zero-dependency loadable
+extension for your platform.
+
+```js
+const Database = require("better-sqlite3");
+const sqlitePredict = require("sqlite-predict");
+
+const db = new Database(":memory:");
+sqlitePredict.load(db);
+
+for (const row of db
+  .prepare("SELECT * FROM forecast('SELECT ts, value FROM readings', 24)")
+  .all()) {
+  console.log(row);
+}
+```
+
+Also works with Node's built-in `node:sqlite`:
+
+```js
+const { DatabaseSync } = require("node:sqlite");
+const sqlitePredict = require("sqlite-predict");
+const db = new DatabaseSync(":memory:", { allowExtension: true });
+db.loadExtension(sqlitePredict.getLoadablePath());
+```
+
+See the [project README](https://github.com/PureStorage-OpenConnect/sqlite-predict)
+for the full SQL surface, models, and benchmarks.

bindings/node/index.cjs

@@ -0,0 +1,48 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+// per-platform binary packages, installed as optionalDependencies so npm pulls
+// only the one matching the host (the esbuild / sqlite-vec pattern)
+const PLATFORM_PACKAGES = {
+  "darwin-arm64": "sqlite-predict-darwin-arm64",
+  "darwin-x64": "sqlite-predict-darwin-x64",
+  "linux-x64": "sqlite-predict-linux-x64",
+  "linux-arm64": "sqlite-predict-linux-arm64",
+  "win32-x64": "sqlite-predict-windows-x64",
+};
+
+/**
+ * Absolute path to the loadable extension for this platform, without a file
+ * suffix (the form SQLite's load_extension prefers).
+ */
+function getLoadablePath() {
+  // dev / bundled fallback: a binary sitting next to this file
+  for (const ext of ["dylib", "so", "dll"]) {
+    const local = path.join(__dirname, `predict0.${ext}`);
+    if (fs.existsSync(local)) return path.join(__dirname, "predict0");
+  }
+  const key = `${process.platform}-${process.arch}`;
+  const pkg = PLATFORM_PACKAGES[key];
+  if (!pkg) {
+    throw new Error(
+      `sqlite-predict: no prebuilt binary for ${key}; build from source`
+    );
+  }
+  try {
+    return require(pkg).loadablePath;
+  } catch (_) {
+    throw new Error(
+      `sqlite-predict: the platform package ${pkg} is not installed`
+    );
+  }
+}
+
+/**
+ * Load sqlite-predict into a connection with a loadExtension method
+ * (better-sqlite3, or node:sqlite's DatabaseSync with allowExtension: true).
+ */
+function load(db) {
+  db.loadExtension(getLoadablePath());
+}
+
+module.exports = { getLoadablePath, load };

bindings/node/index.d.ts

@@ -0,0 +1,8 @@
+/** Absolute path to the bundled loadable extension for this platform. */
+export function getLoadablePath(): string;
+
+/**
+ * Load sqlite-predict into a connection exposing `loadExtension`
+ * (better-sqlite3, or node:sqlite's `DatabaseSync` with `allowExtension: true`).
+ */
+export function load(db: { loadExtension(path: string): void }): void;

bindings/node/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "sqlite-predict",
+  "version": "0.0.1-alpha.1",
+  "description": "Prediction as a SQL primitive for SQLite: forecast, detect_anomalies, predict, with replayable receipts.",
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "files": [
+    "index.cjs",
+    "index.d.ts",
+    "README.md"
+  ],
+  "keywords": [
+    "sqlite",
+    "forecasting",
+    "anomaly-detection",
+    "time-series",
+    "machine-learning",
+    "better-sqlite3"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PureStorage-OpenConnect/sqlite-predict.git",
+    "directory": "bindings/node"
+  },
+  "optionalDependencies": {
+    "sqlite-predict-darwin-arm64": "0.0.1-alpha.1",
+    "sqlite-predict-darwin-x64": "0.0.1-alpha.1",
+    "sqlite-predict-linux-x64": "0.0.1-alpha.1",
+    "sqlite-predict-linux-arm64": "0.0.1-alpha.1",
+    "sqlite-predict-windows-x64": "0.0.1-alpha.1"
+  }
+}

bindings/python/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=64"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "everpure-sqlite-predict"
+name = "sqlite-predict"
 version = "0.0.1a1"
 description = "Prediction as a SQL primitive for SQLite: forecast, detect_anomalies, predict, with replayable receipts."
 readme = "README.md"
@@ -23,9 +23,8 @@ classifiers = [
 Homepage = "https://github.com/PureStorage-OpenConnect/sqlite-predict"
 Source = "https://github.com/PureStorage-OpenConnect/sqlite-predict"
 
-[tool.setuptools.packages.find]
-namespaces = true
-include = ["everpure*"]
+[tool.setuptools]
+packages = ["sqlite_predict"]
 
 [tool.setuptools.package-data]
-"everpure.sqlite_predict" = ["predict0.*"]
+sqlite_predict = ["predict0.*"]