@wiscale/velesdb-wasm 2.0.0 → 3.0.1

package/README.md

@@ -94,6 +94,7 @@ class VectorStore {
   insert(id: bigint, vector: Float32Array): void;
   insert_with_payload(id: bigint, vector: Float32Array, payload: object): void;
   insert_batch(batch: Array<[bigint, number[]]>): void;  // Bulk insert
+  insertBatchRaw(ids: BigUint64Array, vectors: Float32Array, dimension: number): void;  // Flat raw-bulk insert (since 2026-06-14)
   search(query: Float32Array, k: number): Array<[bigint, number]>;
   search_with_filter(query: Float32Array, k: number, filter: object): Array<{id, score, payload}>;
   text_search(query: string, k: number, field?: string): Array<{id, score, payload}>;

package/package.json

@@ -5,7 +5,7 @@
     "Julien Lange <contact@wiscale.fr>"
   ],
   "description": "VelesDB for WebAssembly - Vector search in the browser",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",

package/velesdb_wasm.d.ts

@@ -802,6 +802,12 @@ export class VectorStore {
      * Inserts a vector with the given ID.
      */
     insert(id: bigint, vector: Float32Array): void;
+    /**
+     * Bulk insert from a flat contiguous `Float32Array` (zero-copy layout),
+     * mirroring the VRB1 raw-bulk contract: `ids` + flat row-major `vectors`
+     * + `dimension`. No payloads (use `insert_batch` for those).
+     */
+    insertBatchRaw(ids: BigUint64Array, vectors: Float32Array, dimension: number): void;
     /**
      * Batch insert. Input: `[[id, Float32Array], ...]`.
      */
@@ -864,6 +870,20 @@ export class VectorStore {
      * k-NN search. Returns [[id, score], ...].
      */
     search(query: Float32Array, k: number): any;
+    /**
+     * Sparse k-NN search over the store's pre-built sparse index.
+     *
+     * Unlike [`sparse_search`](Self::sparse_search) — which returns an empty
+     * result set when no sparse data has been inserted — this method mirrors
+     * the core `sparse_search` contract and returns an **error** when the
+     * store has no sparse index, so callers can distinguish "index missing"
+     * from "no matches". Scoring is delegated unchanged to the
+     * recall-verified [`sparse::SparseIndex`] kernel.
+     *
+     * Returns a JSON array of `{doc_id, score}` objects sorted by score
+     * descending, truncated to `k`.
+     */
+    search_sparse(query_indices: Uint32Array, query_values: Float32Array, k: number): any;
     /**
      * Searches with metadata filtering. Returns [{id, score, payload}].
      */
@@ -993,6 +1013,15 @@ export class WasmCollectionHandle {
      * Returns an error if the vector dimension does not match the collection.
      */
     insert(id: bigint, vector: Float32Array): void;
+    /**
+     * Bulk insert from a flat row-major `vectors` buffer plus parallel `ids`
+     * (VRB1 raw-bulk contract). No payloads.
+     *
+     * # Errors
+     * Returns an error on dimension mismatch or when
+     * `vectors.len() != ids.len() * dimension`.
+     */
+    insertBatchRaw(ids: BigUint64Array, vectors: Float32Array, dimension: number): void;
     /**
      * Removes a vector by ID. Returns `true` if found.
      */
@@ -1309,6 +1338,7 @@ export interface InitOutput {
     readonly vectorstore_hybrid_search: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly vectorstore_import_from_bytes: (a: number, b: number, c: number) => void;
     readonly vectorstore_insert: (a: number, b: number, c: bigint, d: number, e: number) => void;
+    readonly vectorstore_insertBatchRaw: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly vectorstore_insert_batch: (a: number, b: number, c: number) => void;
     readonly vectorstore_insert_with_payload: (a: number, b: number, c: bigint, d: number, e: number, f: number) => void;
     readonly vectorstore_is_metadata_only: (a: number) => number;
@@ -1323,6 +1353,7 @@ export interface InitOutput {
     readonly vectorstore_reserve: (a: number, b: number) => void;
     readonly vectorstore_save: (a: number, b: number, c: number) => number;
     readonly vectorstore_search: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly vectorstore_search_sparse: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly vectorstore_search_with_filter: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly vectorstore_search_with_quality: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly vectorstore_similarity_search: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
@@ -1335,6 +1366,7 @@ export interface InitOutput {
     readonly velesql_parse: (a: number, b: number, c: number) => void;
     readonly wasmcollectionhandle_dimension: (a: number) => number;
     readonly wasmcollectionhandle_insert: (a: number, b: number, c: bigint, d: number, e: number) => void;
+    readonly wasmcollectionhandle_insertBatchRaw: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly wasmcollectionhandle_is_empty: (a: number) => number;
     readonly wasmcollectionhandle_len: (a: number) => number;
     readonly wasmcollectionhandle_remove: (a: number, b: bigint) => number;
@@ -1358,9 +1390,9 @@ export interface InitOutput {
     readonly graphnode_id: (a: number) => bigint;
     readonly vectorstore_dimension: (a: number) => number;
     readonly wasmdatabase_collection_count: (a: number) => number;
-    readonly __wasm_bindgen_func_elem_1850: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_1866: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_401: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_1267: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_1283: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_412: (a: number, b: number, c: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/velesdb_wasm.js

@@ -2002,6 +2002,31 @@ export class VectorStore {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Bulk insert from a flat contiguous `Float32Array` (zero-copy layout),
+     * mirroring the VRB1 raw-bulk contract: `ids` + flat row-major `vectors`
+     * + `dimension`. No payloads (use `insert_batch` for those).
+     * @param {BigUint64Array} ids
+     * @param {Float32Array} vectors
+     * @param {number} dimension
+     */
+    insertBatchRaw(ids, vectors, dimension) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray64ToWasm0(ids, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF32ToWasm0(vectors, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.vectorstore_insertBatchRaw(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, dimension);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Batch insert. Input: `[[id, Float32Array], ...]`.
      * @param {any} batch
@@ -2252,6 +2277,42 @@ export class VectorStore {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sparse k-NN search over the store's pre-built sparse index.
+     *
+     * Unlike [`sparse_search`](Self::sparse_search) — which returns an empty
+     * result set when no sparse data has been inserted — this method mirrors
+     * the core `sparse_search` contract and returns an **error** when the
+     * store has no sparse index, so callers can distinguish "index missing"
+     * from "no matches". Scoring is delegated unchanged to the
+     * recall-verified [`sparse::SparseIndex`] kernel.
+     *
+     * Returns a JSON array of `{doc_id, score}` objects sorted by score
+     * descending, truncated to `k`.
+     * @param {Uint32Array} query_indices
+     * @param {Float32Array} query_values
+     * @param {number} k
+     * @returns {any}
+     */
+    search_sparse(query_indices, query_values, k) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray32ToWasm0(query_indices, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF32ToWasm0(query_values, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.vectorstore_search_sparse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, k);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Searches with metadata filtering. Returns [{id, score, payload}].
      * @param {Float32Array} query
@@ -2600,6 +2661,34 @@ export class WasmCollectionHandle {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Bulk insert from a flat row-major `vectors` buffer plus parallel `ids`
+     * (VRB1 raw-bulk contract). No payloads.
+     *
+     * # Errors
+     * Returns an error on dimension mismatch or when
+     * `vectors.len() != ids.len() * dimension`.
+     * @param {BigUint64Array} ids
+     * @param {Float32Array} vectors
+     * @param {number} dimension
+     */
+    insertBatchRaw(ids, vectors, dimension) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray64ToWasm0(ids, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF32ToWasm0(vectors, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.wasmcollectionhandle_insertBatchRaw(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, dimension);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Returns `true` if the collection has no vectors.
      * @returns {boolean}
@@ -3216,7 +3305,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_1866(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_1283(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -3238,7 +3327,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_1866(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_1283(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -3371,13 +3460,13 @@ function __wbg_get_imports() {
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 330, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_1850);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 274, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_1267);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 7, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_401);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_412);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -3414,14 +3503,14 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_401(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_401(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_412(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_412(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1850(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_1267(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_1850(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_1267(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -3432,8 +3521,8 @@ function __wasm_bindgen_func_elem_1850(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_1866(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1866(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_1283(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1283(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 
@@ -3692,6 +3781,13 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArray64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getBigUint64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);