@stoolap/node 0.4.1 → 0.5.0-beta.1

package/lib/statement.js

@@ -1,6 +1,5 @@
 "use strict";
 
-const { processParams } = require("./ffi");
 const {
   parseRows,
   parseRaw,
@@ -8,6 +7,15 @@ const {
   makeRowFactory,
   parseRowsCached,
 } = require("./parse");
+const { RowCursor } = require("./iterator");
+
+function sameHeader(bytes, header) {
+  if (!header || bytes.length < header.length) return false;
+  for (let i = 0; i < header.length; i++) {
+    if (bytes[i] !== header[i]) return false;
+  }
+  return true;
+}
 
 /* Call stmtExecNums with direct numeric args (no array wrapping).
  * Manual unpack for 1-3 params avoids spread overhead. */
@@ -84,8 +92,9 @@ let _pbuf = Buffer.allocUnsafe(16384);
 function encodeBatch(paramsArray) {
   const rowCount = paramsArray.length;
   const ppr = paramsArray[0].length;
+  if (ppr > 65535) throw new RangeError("Too many parameters per row");
   let buf = _pbuf;
-  const estSize = 5 + rowCount * ppr * 14;
+  const estSize = 6 + rowCount * ppr * 14;
   if (estSize > buf.length) {
     buf = Buffer.allocUnsafe(estSize + 4096);
     _pbuf = buf;
@@ -93,7 +102,8 @@ function encodeBatch(paramsArray) {
   let off = 0;
   buf.writeUInt32LE(rowCount, off);
   off += 4;
-  buf[off++] = ppr;
+  buf.writeUInt16LE(ppr, off);
+  off += 2;
   for (let r = 0; r < rowCount; r++) {
     const row = paramsArray[r];
     for (let j = 0; j < ppr; j++) {
@@ -134,8 +144,44 @@ function encodeBatch(paramsArray) {
         buf[off++] = 5;
         buf.writeBigInt64LE(v, off);
         off += 8;
+      } else if (v instanceof Date) {
+        const ms = v.getTime();
+        if (ms !== ms) {
+          buf[off++] = 0;
+        } else {
+          buf[off++] = 6;
+          buf.writeBigInt64LE(BigInt(Math.trunc(ms)) * 1000000n, off);
+          off += 8;
+        }
+      } else if (v instanceof Float32Array || v instanceof Uint8Array) {
+        /* Float32Array binds as a vector; Buffer and other Uint8Array as text bytes */
+        const bytes =
+          v instanceof Float32Array
+            ? new Uint8Array(v.buffer, v.byteOffset, v.byteLength)
+            : v;
+        const need = bytes.length + 6;
+        if (off + need > buf.length) {
+          const nb = Buffer.allocUnsafe(Math.max(buf.length * 2, off + need + 4096));
+          buf.copy(nb, 0, 0, off);
+          buf = nb;
+          _pbuf = nb;
+        }
+        if (v instanceof Float32Array) {
+          buf[off++] = 7;
+          buf.writeUInt32LE(bytes.length, off);
+          off += 4;
+          buf.set(bytes, off);
+          off += bytes.length;
+        } else {
+          buf[off++] = 3;
+          buf.writeUInt32LE(bytes.length, off);
+          off += 4;
+          buf.set(bytes, off);
+          off += bytes.length;
+          buf[off++] = 0;
+        }
       } else if (typeof v === "object") {
-        const s = v instanceof Date ? v.toISOString() : JSON.stringify(v);
+        const s = JSON.stringify(v);
         const maxBytes = s.length * 3 + 6;
         if (off + maxBytes > buf.length) {
           const nb = Buffer.allocUnsafe(
@@ -158,7 +204,8 @@ function encodeBatch(paramsArray) {
 }
 
 class PreparedStatement {
-  #ptr = null;
+  #ptr = null; /* null once finalized or finalize is pending */
+  #native = null; /* the handle, until it is actually released */
   #stoolap = null;
   #q1i = null;
   #factory = null;
@@ -166,24 +213,18 @@ class PreparedStatement {
   #colCount = 0;
   #owner = null;
   #sql = "";
-  #preparedSql = "";
   #paramNames = null;
+  #header = null;
+  #pending = 0;
+  #finalizeWanted = false;
 
-  constructor(
-    ptr,
-    stoolap,
-    queryOneIntBound,
-    owner,
-    sql,
-    preparedSql,
-    paramNames,
-  ) {
+  constructor(ptr, stoolap, queryOneIntBound, owner, sql, paramNames) {
     this.#ptr = ptr;
+    this.#native = ptr;
     this.#stoolap = stoolap;
     this.#q1i = queryOneIntBound || null;
     this.#owner = owner;
     this.#sql = sql;
-    this.#preparedSql = preparedSql || sql;
     this.#paramNames = paramNames || null;
   }
 
@@ -191,48 +232,49 @@ class PreparedStatement {
     if (!this.#ptr) throw new Error("PreparedStatement is finalized");
   }
 
+  /* Parse a result buffer with the row factory cached from the first result,
+   * as long as the packed header still matches (a schema change after
+   * prepare gives the statement new columns). */
   #parseResult(abuf) {
-    if (this.#factory) {
-      return parseRowsCached(
-        abuf,
-        this.#headerOff,
-        this.#factory,
-        this.#colCount,
-      );
+    const bytes = new Uint8Array(abuf);
+    if (this.#factory && sameHeader(bytes, this.#header)) {
+      return parseRowsCached(abuf, this.#headerOff, this.#factory, this.#colCount);
     }
     const meta = parseHeader(abuf);
     this.#headerOff = meta.headerOff;
     this.#colCount = meta.colCount;
-    const f = makeRowFactory(meta.colNames);
-    if (f) {
-      this.#factory = f;
-      return parseRowsCached(abuf, meta.headerOff, f, meta.colCount);
-    }
-    return parseRows(abuf);
+    this.#header = bytes.slice(0, meta.headerOff);
+    this.#factory = makeRowFactory(meta.colNames);
+    return this.#factory
+      ? parseRowsCached(abuf, meta.headerOff, this.#factory, meta.colCount)
+      : parseRows(abuf);
   }
 
-  #normalizeParams(params) {
-    if (!params) {
-      return { sql: this.#preparedSql, values: null };
-    }
-    if (Array.isArray(params)) {
-      return {
-        sql: this.#preparedSql,
-        values: params.length === 0 ? null : params,
-      };
+  /* Run an async native call; finalize() waits for the last one to land. */
+  async #inflight(promise) {
+    this.#pending += 1;
+    try {
+      return await promise;
+    } finally {
+      this.#pending -= 1;
+      if (this.#finalizeWanted && this.#pending === 0) this.#release();
     }
-    if (this.#paramNames) {
-      const values = new Array(this.#paramNames.length);
-      for (let i = 0; i < this.#paramNames.length; i++) {
-        values[i] = params[this.#paramNames[i]];
-      }
-      return { sql: this.#preparedSql, values };
-    }
-    const rewritten = processParams(this.#sql, params);
-    return {
-      sql: rewritten.sql,
-      values: rewritten.values,
-    };
+  }
+
+  _hasPending() {
+    return this.#pending > 0;
+  }
+
+  /* Bind params positionally: an object's values are taken in the order of
+   * the :name placeholders the statement was prepared with. */
+  #positional(params) {
+    if (!params) return null;
+    if (Array.isArray(params)) return params.length === 0 ? null : params;
+    const names = this.#paramNames;
+    if (!names) return null;
+    const values = new Array(names.length);
+    for (let i = 0; i < names.length; i++) values[i] = params[names[i]];
+    return values;
   }
 
   get sql() {
@@ -244,47 +286,38 @@ class PreparedStatement {
 
   execute(params) {
     this.#checkOpen();
-    const normalized = this.#normalizeParams(params);
-    return this.#owner._stmtExecAsync(
-      this.#ptr,
-      normalized.values ? normalized.values : undefined,
-    );
+    const values = this.#positional(params);
+    return this.#inflight(this.#owner._stmtExecAsync(this.#ptr, values || undefined));
   }
 
   executeSync(params) {
     this.#checkOpen();
-    const normalized = this.#normalizeParams(params);
-    if (!normalized.values) return this.#stoolap.stmtExec(this.#ptr);
-    if (normalized.values.length <= 16 && isAllNums(normalized.values)) {
-      return callExecNums(this.#stoolap, this.#ptr, normalized.values);
+    const values = this.#positional(params);
+    if (!values) return this.#stoolap.stmtExec(this.#ptr);
+    if (values.length <= 16 && isAllNums(values)) {
+      return callExecNums(this.#stoolap, this.#ptr, values);
     }
-    return this.#stoolap.stmtExec(this.#ptr, normalized.values);
+    return this.#stoolap.stmtExec(this.#ptr, values);
   }
 
   // -- Query --
 
   async query(params) {
     this.#checkOpen();
-    const normalized = this.#normalizeParams(params);
-    const buf = await this.#owner._stmtQueryBufAsync(
-      this.#ptr,
-      normalized.values ? normalized.values : undefined,
+    const values = this.#positional(params);
+    const buf = await this.#inflight(
+      this.#owner._stmtQueryBufAsync(this.#ptr, values || undefined),
     );
     return this.#parseResult(buf);
   }
 
   querySync(params) {
     this.#checkOpen();
-    const normalized = this.#normalizeParams(params);
-    if (!normalized.values) {
-      const result = this.#stoolap.stmtQuery(this.#ptr);
-      return Array.isArray(result) ? result : this.#parseResult(result);
-    }
-    if (normalized.values.length <= 16 && isAllNums(normalized.values)) {
-      const result = callQueryNums(this.#stoolap, this.#ptr, normalized.values);
-      return Array.isArray(result) ? result : this.#parseResult(result);
-    }
-    const result = this.#stoolap.stmtQuery(this.#ptr, normalized.values);
+    const values = this.#positional(params);
+    const result =
+      values && values.length <= 16 && isAllNums(values)
+        ? callQueryNums(this.#stoolap, this.#ptr, values)
+        : this.#stoolap.stmtQueryAll(this.#ptr, values, 0);
     return Array.isArray(result) ? result : this.#parseResult(result);
   }
 
@@ -297,39 +330,47 @@ class PreparedStatement {
 
   queryOneSync(params) {
     this.#checkOpen();
-    const normalized = this.#normalizeParams(params);
-    if (!normalized.values) return this.#stoolap.stmtQueryOne(this.#ptr);
-    if (
-      normalized.values.length === 1 &&
-      typeof normalized.values[0] === "number"
-    ) {
-      return this.#q1i(normalized.values[0]);
+    const values = this.#positional(params);
+    let result;
+    if (!values) {
+      result = this.#stoolap.stmtQueryAll(this.#ptr, undefined, 1);
+    } else if (values.length === 1 && typeof values[0] === "number") {
+      result = this.#q1i(values[0]);
+    } else if (values.length <= 16 && isAllNums(values)) {
+      result = callQueryOneNums(this.#stoolap, this.#ptr, values);
+    } else {
+      result = this.#stoolap.stmtQueryAll(this.#ptr, values, 1);
     }
-    if (normalized.values.length <= 16 && isAllNums(normalized.values)) {
-      return callQueryOneNums(this.#stoolap, this.#ptr, normalized.values);
+    if (result instanceof ArrayBuffer) {
+      const rows = this.#parseResult(result);
+      return rows.length === 0 ? null : rows[0];
     }
-    return this.#stoolap.stmtQueryOne(this.#ptr, normalized.values);
+    return result;
   }
 
   // -- QueryRaw --
 
   async queryRaw(params) {
     this.#checkOpen();
-    const normalized = this.#normalizeParams(params);
-    const buf = await this.#owner._stmtQueryBufAsync(
-      this.#ptr,
-      normalized.values ? normalized.values : undefined,
+    const values = this.#positional(params);
+    const buf = await this.#inflight(
+      this.#owner._stmtQueryBufAsync(this.#ptr, values || undefined),
     );
     return parseRaw(buf);
   }
 
   queryRawSync(params) {
     this.#checkOpen();
-    const normalized = this.#normalizeParams(params);
-    if (!normalized.values) {
-      return parseRaw(this.#stoolap.stmtQueryBuf(this.#ptr));
-    }
-    return parseRaw(this.#stoolap.stmtQueryBuf(this.#ptr, normalized.values));
+    return parseRaw(this.#stoolap.stmtQueryAll(this.#ptr, this.#positional(params), 2));
+  }
+
+  // -- Iterate --
+
+  /** Open a cursor over the statement's rows; iterate with `for...of` or `for await...of`. */
+  iterate(params) {
+    this.#checkOpen();
+    const ptr = this.#stoolap.rowsOpenStmt(this.#ptr, this.#positional(params));
+    return new RowCursor(this.#stoolap, ptr, this.#owner);
   }
 
   // -- Batch --
@@ -337,34 +378,41 @@ class PreparedStatement {
   executeBatchSync(paramsArray) {
     this.#checkOpen();
     if (paramsArray.length === 0) return { changes: 0 };
-    if (paramsArray.length > 0 && Array.isArray(paramsArray[0])) {
+    if (Array.isArray(paramsArray[0])) {
       const batchBuf = encodeBatch(paramsArray);
       return this.#stoolap.stmtExecBatchBuf(this.#ptr, batchBuf);
     }
     let totalChanges = 0;
     for (const params of paramsArray) {
-      const normalized = this.#normalizeParams(params);
-      const result = normalized.values
-        ? this.#stoolap.stmtExec(this.#ptr, normalized.values)
-        : this.#stoolap.stmtExec(this.#ptr);
-      totalChanges += result.changes;
+      totalChanges += this.executeSync(params).changes;
     }
     return { changes: totalChanges };
   }
 
-  _invalidate() {
-    if (this.#ptr) {
-      this.#stoolap.stmtFinalize(this.#ptr);
-      this.#ptr = null;
+  #release() {
+    if (this.#native) {
+      this.#stoolap.stmtFinalize(this.#native);
+      this.#native = null;
     }
+    this.#ptr = null;
+    this.#finalizeWanted = false;
+    if (this.#owner) this.#owner._untrackChild(this);
+  }
+
+  /* Called by the owner when it closes; it has already waited for async work. */
+  _invalidate() {
+    if (this.#pending > 0) this.#finalizeWanted = true;
+    else this.#release();
   }
 
+  /** Release the statement. Async calls still in flight finish first. */
   finalize() {
-    if (this.#ptr) {
-      this.#stoolap.stmtFinalize(this.#ptr);
-      this.#ptr = null;
-      if (this.#owner) this.#owner._untrackChild(this);
+    if (this.#pending > 0) {
+      this.#finalizeWanted = true;
+      this.#ptr = null; /* no new calls; the handle is freed when the last one lands */
+      return;
     }
+    this.#release();
   }
 }
 

package/lib/transaction.js

@@ -1,7 +1,8 @@
 "use strict";
 
-const { processParams } = require("./ffi");
+const { processParams, splitNamed } = require("./ffi");
 const { parseRows, parseRaw } = require("./parse");
+const { RowCursor } = require("./iterator");
 
 class Transaction {
   #ptr = null;
@@ -11,6 +12,7 @@ class Transaction {
   #tail = Promise.resolve();
   #closingPromise = null;
   #owner = null;
+  #cursors = new Set(); /* WeakRef<RowCursor> */
 
   constructor(ptr, stoolap, owner, dbPtr) {
     this.#ptr = ptr;
@@ -19,8 +21,66 @@ class Transaction {
     this.#dbPtr = dbPtr || null;
   }
 
+  /* Called by the owner when it closes, after async work has settled:
+   * an open transaction is rolled back so its handle is released. */
   _invalidate() {
-    this.#ptr = null;
+    this.#closeCursors();
+    if (this.#ptr) {
+      const ptr = this.#ptr;
+      this.#ptr = null;
+      try {
+        this.#stoolap.txRollback(ptr);
+      } catch {}
+    }
+  }
+
+  _settle() {
+    return this.#closingPromise || this.#tail;
+  }
+
+  _hasPending() {
+    return this.#pendingAsync > 0 || this.#closingPromise !== null;
+  }
+
+  _trackCursor(ref) {
+    this.#cursors.add(ref);
+  }
+
+  _untrackCursor(ref) {
+    this.#cursors.delete(ref);
+  }
+
+  #closeCursors() {
+    for (const ref of this.#cursors) {
+      const cursor = ref.deref();
+      if (cursor) cursor._invalidate();
+    }
+    this.#cursors.clear();
+  }
+
+  _rowsChunk(rowsPtr, maxRows, buf) {
+    this.#checkSyncReady();
+    return this.#stoolap.rowsChunk(rowsPtr, maxRows, buf);
+  }
+
+  _rowsChunkAsync(rowsPtr, maxRows) {
+    return this.#enqueueAsync(() => this.#stoolap.rowsChunkAsync(rowsPtr, maxRows));
+  }
+
+  /**
+   * Open a cursor over the query's rows inside the transaction. Open
+   * cursors are closed by commit and rollback.
+   */
+  iterate(sql, params) {
+    this.#checkSyncReady();
+    let ptr;
+    if (params && !Array.isArray(params)) {
+      const [names, values] = splitNamed(params);
+      ptr = this.#stoolap.rowsOpenNamed(this.#dbPtr, this.#ptr, sql, names, values);
+    } else {
+      ptr = this.#stoolap.rowsOpen(this.#dbPtr, this.#ptr, sql, params);
+    }
+    return new RowCursor(this.#stoolap, ptr, this);
   }
 
   #checkOpen() {
@@ -71,19 +131,13 @@ class Transaction {
 
   executeSync(sql, params) {
     this.#checkSyncReady();
-    if (!params) return this.#stoolap.txExec(this.#ptr, sql);
-    if (Array.isArray(params)) {
-      if (params.length === 0) return this.#stoolap.txExec(this.#ptr, sql);
-      return this.#stoolap.txExec(this.#ptr, sql, params);
+    if (params && !Array.isArray(params)) {
+      const [names, values] = splitNamed(params);
+      return this.#stoolap.txExecNamed(this.#ptr, sql, names, values);
     }
-    const p = processParams(sql, params);
-    return p.values
-      ? this.#stoolap.txExec(this.#ptr, p.sql, p.values)
-      : this.#stoolap.txExec(this.#ptr, sql);
+    return this.#stoolap.txExec(this.#ptr, sql, params);
   }
 
-  // -- Query --
-
   async query(sql, params) {
     const buf = await this.#enqueueAsync((ptr) => {
       if (!params) return this.#stoolap.txQueryBufAsync(ptr, sql);
@@ -99,27 +153,21 @@ class Transaction {
     return parseRows(buf);
   }
 
+  /* One FFI call inside the transaction. mode: 0 = rows, 1 = first row, 2 = raw buffer */
+  #queryAll(sql, params, mode) {
+    if (params && !Array.isArray(params)) {
+      const [names, values] = splitNamed(params);
+      return this.#stoolap.dbQueryNamedAll(this.#dbPtr, this.#ptr, sql, names, values, mode);
+    }
+    return this.#stoolap.dbQueryAll(this.#dbPtr, this.#ptr, sql, params, mode);
+  }
+
   querySync(sql, params) {
     this.#checkSyncReady();
-    let result;
-    if (!params) {
-      result = this.#stoolap.txQuery(this.#ptr, sql);
-    } else if (Array.isArray(params)) {
-      result =
-        params.length === 0
-          ? this.#stoolap.txQuery(this.#ptr, sql)
-          : this.#stoolap.txQuery(this.#ptr, sql, params);
-    } else {
-      const p = processParams(sql, params);
-      result = p.values
-        ? this.#stoolap.txQuery(this.#ptr, p.sql, p.values)
-        : this.#stoolap.txQuery(this.#ptr, sql);
-    }
+    const result = this.#queryAll(sql, params, 0);
     return Array.isArray(result) ? result : parseRows(result);
   }
 
-  // -- QueryOne --
-
   async queryOne(sql, params) {
     const rows = await this.query(sql, params);
     return rows.length === 0 ? null : rows[0];
@@ -127,19 +175,14 @@ class Transaction {
 
   queryOneSync(sql, params) {
     this.#checkSyncReady();
-    if (!params) return this.#stoolap.txQueryOne(this.#ptr, sql);
-    if (Array.isArray(params)) {
-      if (params.length === 0) return this.#stoolap.txQueryOne(this.#ptr, sql);
-      return this.#stoolap.txQueryOne(this.#ptr, sql, params);
+    const result = this.#queryAll(sql, params, 1);
+    if (result instanceof ArrayBuffer) {
+      const rows = parseRows(result);
+      return rows.length === 0 ? null : rows[0];
     }
-    const p = processParams(sql, params);
-    return p.values
-      ? this.#stoolap.txQueryOne(this.#ptr, p.sql, p.values)
-      : this.#stoolap.txQueryOne(this.#ptr, sql);
+    return result;
   }
 
-  // -- QueryRaw --
-
   async queryRaw(sql, params) {
     const buf = await this.#enqueueAsync((ptr) => {
       if (!params) return this.#stoolap.txQueryBufAsync(ptr, sql);
@@ -157,25 +200,9 @@ class Transaction {
 
   queryRawSync(sql, params) {
     this.#checkSyncReady();
-    let buf;
-    if (!params) {
-      buf = this.#stoolap.txQueryBuf(this.#ptr, sql);
-    } else if (Array.isArray(params)) {
-      buf =
-        params.length === 0
-          ? this.#stoolap.txQueryBuf(this.#ptr, sql)
-          : this.#stoolap.txQueryBuf(this.#ptr, sql, params);
-    } else {
-      const p = processParams(sql, params);
-      buf = p.values
-        ? this.#stoolap.txQueryBuf(this.#ptr, p.sql, p.values)
-        : this.#stoolap.txQueryBuf(this.#ptr, sql);
-    }
-    return parseRaw(buf);
+    return parseRaw(this.#queryAll(sql, params, 2));
   }
 
-  // -- Batch --
-
   executeBatchSync(sql, paramsArray) {
     this.#checkSyncReady();
     if (paramsArray.length > 0 && Array.isArray(paramsArray[0])) {
@@ -188,11 +215,7 @@ class Transaction {
     }
     let totalChanges = 0;
     for (const params of paramsArray) {
-      const p = processParams(sql, params);
-      const result = p.values
-        ? this.#stoolap.txExec(this.#ptr, p.sql, p.values)
-        : this.#stoolap.txExec(this.#ptr, sql);
-      totalChanges += result.changes;
+      totalChanges += this.executeSync(sql, params).changes;
     }
     return { changes: totalChanges };
   }
@@ -205,7 +228,10 @@ class Transaction {
 
     const ptr = this.#ptr;
     this.#closingPromise = this.#tail
-      .then(() => this.#stoolap.txCommitAsync(ptr))
+      .then(() => {
+        this.#closeCursors();
+        return this.#stoolap.txCommitAsync(ptr);
+      })
       .finally(() => {
         this.#ptr = null;
         this.#closingPromise = null;
@@ -218,10 +244,11 @@ class Transaction {
 
   commitSync() {
     this.#checkSyncReady();
+    this.#closeCursors();
     const ptr = this.#ptr;
     this.#ptr = null;
-    this.#stoolap.txCommit(ptr);
     if (this.#owner) this.#owner._untrackChild(this);
+    this.#stoolap.txCommit(ptr);
   }
 
   async rollback() {
@@ -230,7 +257,10 @@ class Transaction {
 
     const ptr = this.#ptr;
     this.#closingPromise = this.#tail
-      .then(() => this.#stoolap.txRollbackAsync(ptr))
+      .then(() => {
+        this.#closeCursors();
+        return this.#stoolap.txRollbackAsync(ptr);
+      })
       .finally(() => {
         this.#ptr = null;
         this.#closingPromise = null;
@@ -243,10 +273,11 @@ class Transaction {
 
   rollbackSync() {
     this.#checkSyncReady();
+    this.#closeCursors();
     const ptr = this.#ptr;
     this.#ptr = null;
-    this.#stoolap.txRollback(ptr);
     if (this.#owner) this.#owner._untrackChild(this);
+    this.#stoolap.txRollback(ptr);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stoolap/node",
-  "version": "0.4.1",
+  "version": "0.5.0-beta.1",
   "description": "High-performance Node.js driver for Stoolap embedded SQL database",
   "main": "index.js",
   "types": "index.d.ts",
@@ -18,11 +18,11 @@
     "bench": "node benchmark.mjs"
   },
   "optionalDependencies": {
-    "@stoolap/lib-darwin-arm64": "0.4.1",
-    "@stoolap/lib-darwin-x64": "0.4.1",
-    "@stoolap/lib-linux-arm64-gnu": "0.4.1",
-    "@stoolap/lib-linux-x64-gnu": "0.4.1",
-    "@stoolap/lib-win32-x64-msvc": "0.4.1"
+    "@stoolap/lib-darwin-arm64": "0.5.0-beta.1",
+    "@stoolap/lib-darwin-x64": "0.5.0-beta.1",
+    "@stoolap/lib-linux-arm64-gnu": "0.5.0-beta.1",
+    "@stoolap/lib-linux-x64-gnu": "0.5.0-beta.1",
+    "@stoolap/lib-win32-x64-msvc": "0.5.0-beta.1"
   },
   "devDependencies": {
     "better-sqlite3": "^12.6.2",