@wiscale/velesdb-wasm 1.1.2 → 1.2.0

package/package.json

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

package/velesdb_wasm.d.ts

@@ -1,6 +1,173 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class GraphEdge {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Sets a numeric property on the edge.
+   */
+  set_number_property(key: string, value: number): void;
+  /**
+   * Sets a string property on the edge.
+   */
+  set_string_property(key: string, value: string): void;
+  /**
+   * Creates a new graph edge.
+   *
+   * # Arguments
+   *
+   * * `id` - Unique identifier for the edge
+   * * `source` - Source node ID
+   * * `target` - Target node ID
+   * * `label` - Relationship type (e.g., "KNOWS", "WROTE")
+   */
+  constructor(id: bigint, source: bigint, target: bigint, label: string);
+  /**
+   * Converts to JSON for JavaScript interop.
+   */
+  to_json(): any;
+  /**
+   * Returns the edge ID.
+   */
+  readonly id: bigint;
+  /**
+   * Returns the edge label (relationship type).
+   */
+  readonly label: string;
+  /**
+   * Returns the source node ID.
+   */
+  readonly source: bigint;
+  /**
+   * Returns the target node ID.
+   */
+  readonly target: bigint;
+}
+
+export class GraphNode {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns true if this node has a vector embedding.
+   */
+  has_vector(): boolean;
+  /**
+   * Sets a vector embedding on the node.
+   */
+  set_vector(vector: Float32Array): void;
+  /**
+   * Sets a boolean property on the node.
+   */
+  set_bool_property(key: string, value: boolean): void;
+  /**
+   * Sets a numeric property on the node.
+   */
+  set_number_property(key: string, value: number): void;
+  /**
+   * Sets a string property on the node.
+   */
+  set_string_property(key: string, value: string): void;
+  /**
+   * Creates a new graph node.
+   *
+   * # Arguments
+   *
+   * * `id` - Unique identifier for the node
+   * * `label` - Node type/label (e.g., "Person", "Document")
+   */
+  constructor(id: bigint, label: string);
+  /**
+   * Converts to JSON for JavaScript interop.
+   */
+  to_json(): any;
+  /**
+   * Returns the node ID.
+   */
+  readonly id: bigint;
+  /**
+   * Returns the node label.
+   */
+  readonly label: string;
+}
+
+export class GraphStore {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Removes an edge by ID.
+   */
+  remove_edge(edge_id: bigint): void;
+  /**
+   * Removes a node and all connected edges.
+   */
+  remove_node(node_id: bigint): void;
+  /**
+   * Performs BFS traversal from a source node.
+   *
+   * # Arguments
+   *
+   * * `source_id` - Starting node ID
+   * * `max_depth` - Maximum traversal depth
+   * * `limit` - Maximum number of results
+   *
+   * # Returns
+   *
+   * Array of reachable node IDs with their depths.
+   */
+  bfs_traverse(source_id: bigint, max_depth: number, limit: number): any;
+  /**
+   * Gets incoming edges to a node.
+   */
+  get_incoming(node_id: bigint): GraphEdge[];
+  /**
+   * Gets outgoing edges from a node.
+   */
+  get_outgoing(node_id: bigint): GraphEdge[];
+  /**
+   * Gets neighbors reachable from a node (1-hop).
+   */
+  get_neighbors(node_id: bigint): BigUint64Array;
+  /**
+   * Gets outgoing edges filtered by label.
+   */
+  get_outgoing_by_label(node_id: bigint, label: string): GraphEdge[];
+  /**
+   * Creates a new empty graph store.
+   */
+  constructor();
+  /**
+   * Clears all nodes and edges.
+   */
+  clear(): void;
+  /**
+   * Adds an edge to the graph.
+   *
+   * Returns an error if an edge with the same ID already exists.
+   */
+  add_edge(edge: GraphEdge): void;
+  /**
+   * Adds a node to the graph.
+   */
+  add_node(node: GraphNode): void;
+  /**
+   * Gets an edge by ID.
+   */
+  get_edge(id: bigint): GraphEdge | undefined;
+  /**
+   * Gets a node by ID.
+   */
+  get_node(id: bigint): GraphNode | undefined;
+  /**
+   * Returns the number of edges.
+   */
+  readonly edge_count: number;
+  /**
+   * Returns the number of nodes.
+   */
+  readonly node_count: number;
+}
+
 /**
  * Storage mode for vector quantization.
  */
@@ -370,7 +537,41 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_graphedge_free: (a: number, b: number) => void;
+  readonly __wbg_graphnode_free: (a: number, b: number) => void;
+  readonly __wbg_graphstore_free: (a: number, b: number) => void;
   readonly __wbg_vectorstore_free: (a: number, b: number) => void;
+  readonly graphedge_id: (a: number) => bigint;
+  readonly graphedge_label: (a: number, b: number) => void;
+  readonly graphedge_new: (a: number, b: bigint, c: bigint, d: bigint, e: number, f: number) => void;
+  readonly graphedge_set_number_property: (a: number, b: number, c: number, d: number) => void;
+  readonly graphedge_set_string_property: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly graphedge_source: (a: number) => bigint;
+  readonly graphedge_target: (a: number) => bigint;
+  readonly graphedge_to_json: (a: number, b: number) => void;
+  readonly graphnode_has_vector: (a: number) => number;
+  readonly graphnode_label: (a: number, b: number) => void;
+  readonly graphnode_new: (a: bigint, b: number, c: number) => number;
+  readonly graphnode_set_bool_property: (a: number, b: number, c: number, d: number) => void;
+  readonly graphnode_set_number_property: (a: number, b: number, c: number, d: number) => void;
+  readonly graphnode_set_string_property: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly graphnode_set_vector: (a: number, b: number, c: number) => void;
+  readonly graphnode_to_json: (a: number, b: number) => void;
+  readonly graphstore_add_edge: (a: number, b: number, c: number) => void;
+  readonly graphstore_add_node: (a: number, b: number) => void;
+  readonly graphstore_bfs_traverse: (a: number, b: number, c: bigint, d: number, e: number) => void;
+  readonly graphstore_clear: (a: number) => void;
+  readonly graphstore_edge_count: (a: number) => number;
+  readonly graphstore_get_edge: (a: number, b: bigint) => number;
+  readonly graphstore_get_incoming: (a: number, b: number, c: bigint) => void;
+  readonly graphstore_get_neighbors: (a: number, b: number, c: bigint) => void;
+  readonly graphstore_get_node: (a: number, b: bigint) => number;
+  readonly graphstore_get_outgoing: (a: number, b: number, c: bigint) => void;
+  readonly graphstore_get_outgoing_by_label: (a: number, b: number, c: bigint, d: number, e: number) => void;
+  readonly graphstore_new: () => number;
+  readonly graphstore_node_count: (a: number) => number;
+  readonly graphstore_remove_edge: (a: number, b: bigint) => void;
+  readonly graphstore_remove_node: (a: number, b: bigint) => void;
   readonly vectorstore_batch_search: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly vectorstore_clear: (a: number) => void;
   readonly vectorstore_delete_database: (a: number, b: number) => number;
@@ -399,11 +600,12 @@ export interface InitOutput {
   readonly vectorstore_storage_mode: (a: number, b: number) => void;
   readonly vectorstore_text_search: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly vectorstore_with_capacity: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly __wasm_bindgen_func_elem_148: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_147: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_528: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_527: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_577: (a: number, b: number, c: number, d: number) => void;
+  readonly graphnode_id: (a: number) => bigint;
+  readonly __wasm_bindgen_func_elem_612: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_611: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_184: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_183: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_661: (a: number, b: number, c: number, d: 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

@@ -9,6 +9,12 @@ function addHeapObject(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => state.dtor(state.a, state.b));
@@ -84,11 +90,34 @@ function dropObject(idx) {
     heap_next = idx;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
+function getArrayU64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -251,24 +280,535 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_148(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_148(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_612(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_612(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_528(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_528(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_184(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_184(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_577(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_577(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_661(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_661(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
 
+const GraphEdgeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_graphedge_free(ptr >>> 0, 1));
+
+const GraphNodeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_graphnode_free(ptr >>> 0, 1));
+
+const GraphStoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_graphstore_free(ptr >>> 0, 1));
+
 const VectorStoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_vectorstore_free(ptr >>> 0, 1));
 
+/**
+ * A graph edge representing a relationship between nodes.
+ */
+export class GraphEdge {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GraphEdge.prototype);
+        obj.__wbg_ptr = ptr;
+        GraphEdgeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GraphEdgeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_graphedge_free(ptr, 0);
+    }
+    /**
+     * Sets a numeric property on the edge.
+     * @param {string} key
+     * @param {number} value
+     */
+    set_number_property(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.graphedge_set_number_property(this.__wbg_ptr, ptr0, len0, value);
+    }
+    /**
+     * Sets a string property on the edge.
+     * @param {string} key
+     * @param {string} value
+     */
+    set_string_property(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.graphedge_set_string_property(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * Returns the edge ID.
+     * @returns {bigint}
+     */
+    get id() {
+        const ret = wasm.graphedge_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Creates a new graph edge.
+     *
+     * # Arguments
+     *
+     * * `id` - Unique identifier for the edge
+     * * `source` - Source node ID
+     * * `target` - Target node ID
+     * * `label` - Relationship type (e.g., "KNOWS", "WROTE")
+     * @param {bigint} id
+     * @param {bigint} source
+     * @param {bigint} target
+     * @param {string} label
+     */
+    constructor(id, source, target, label) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.graphedge_new(retptr, id, source, target, ptr0, len0);
+            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);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            GraphEdgeFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the edge label (relationship type).
+     * @returns {string}
+     */
+    get label() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphedge_label(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Returns the source node ID.
+     * @returns {bigint}
+     */
+    get source() {
+        const ret = wasm.graphedge_source(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Returns the target node ID.
+     * @returns {bigint}
+     */
+    get target() {
+        const ret = wasm.graphedge_target(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Converts to JSON for JavaScript interop.
+     * @returns {any}
+     */
+    to_json() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphedge_to_json(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+}
+if (Symbol.dispose) GraphEdge.prototype[Symbol.dispose] = GraphEdge.prototype.free;
+
+/**
+ * A graph node for knowledge graph construction.
+ */
+export class GraphNode {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GraphNode.prototype);
+        obj.__wbg_ptr = ptr;
+        GraphNodeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GraphNodeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_graphnode_free(ptr, 0);
+    }
+    /**
+     * Returns true if this node has a vector embedding.
+     * @returns {boolean}
+     */
+    has_vector() {
+        const ret = wasm.graphnode_has_vector(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Sets a vector embedding on the node.
+     * @param {Float32Array} vector
+     */
+    set_vector(vector) {
+        const ptr0 = passArrayF32ToWasm0(vector, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.graphnode_set_vector(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Sets a boolean property on the node.
+     * @param {string} key
+     * @param {boolean} value
+     */
+    set_bool_property(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.graphnode_set_bool_property(this.__wbg_ptr, ptr0, len0, value);
+    }
+    /**
+     * Sets a numeric property on the node.
+     * @param {string} key
+     * @param {number} value
+     */
+    set_number_property(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.graphnode_set_number_property(this.__wbg_ptr, ptr0, len0, value);
+    }
+    /**
+     * Sets a string property on the node.
+     * @param {string} key
+     * @param {string} value
+     */
+    set_string_property(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.graphnode_set_string_property(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * Returns the node ID.
+     * @returns {bigint}
+     */
+    get id() {
+        const ret = wasm.graphedge_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Creates a new graph node.
+     *
+     * # Arguments
+     *
+     * * `id` - Unique identifier for the node
+     * * `label` - Node type/label (e.g., "Person", "Document")
+     * @param {bigint} id
+     * @param {string} label
+     */
+    constructor(id, label) {
+        const ptr0 = passStringToWasm0(label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.graphnode_new(id, ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        GraphNodeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the node label.
+     * @returns {string}
+     */
+    get label() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphnode_label(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Converts to JSON for JavaScript interop.
+     * @returns {any}
+     */
+    to_json() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphnode_to_json(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+}
+if (Symbol.dispose) GraphNode.prototype[Symbol.dispose] = GraphNode.prototype.free;
+
+/**
+ * In-memory graph store for browser-based knowledge graphs.
+ *
+ * Stores nodes and edges with bidirectional indexing for efficient traversal.
+ */
+export class GraphStore {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GraphStoreFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_graphstore_free(ptr, 0);
+    }
+    /**
+     * Returns the number of edges.
+     * @returns {number}
+     */
+    get edge_count() {
+        const ret = wasm.graphstore_edge_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the number of nodes.
+     * @returns {number}
+     */
+    get node_count() {
+        const ret = wasm.graphstore_node_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Removes an edge by ID.
+     * @param {bigint} edge_id
+     */
+    remove_edge(edge_id) {
+        wasm.graphstore_remove_edge(this.__wbg_ptr, edge_id);
+    }
+    /**
+     * Removes a node and all connected edges.
+     * @param {bigint} node_id
+     */
+    remove_node(node_id) {
+        wasm.graphstore_remove_node(this.__wbg_ptr, node_id);
+    }
+    /**
+     * Performs BFS traversal from a source node.
+     *
+     * # Arguments
+     *
+     * * `source_id` - Starting node ID
+     * * `max_depth` - Maximum traversal depth
+     * * `limit` - Maximum number of results
+     *
+     * # Returns
+     *
+     * Array of reachable node IDs with their depths.
+     * @param {bigint} source_id
+     * @param {number} max_depth
+     * @param {number} limit
+     * @returns {any}
+     */
+    bfs_traverse(source_id, max_depth, limit) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphstore_bfs_traverse(retptr, this.__wbg_ptr, source_id, max_depth, limit);
+            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);
+        }
+    }
+    /**
+     * Gets incoming edges to a node.
+     * @param {bigint} node_id
+     * @returns {GraphEdge[]}
+     */
+    get_incoming(node_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphstore_get_incoming(retptr, this.__wbg_ptr, node_id);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Gets outgoing edges from a node.
+     * @param {bigint} node_id
+     * @returns {GraphEdge[]}
+     */
+    get_outgoing(node_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphstore_get_outgoing(retptr, this.__wbg_ptr, node_id);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Gets neighbors reachable from a node (1-hop).
+     * @param {bigint} node_id
+     * @returns {BigUint64Array}
+     */
+    get_neighbors(node_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphstore_get_neighbors(retptr, this.__wbg_ptr, node_id);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Gets outgoing edges filtered by label.
+     * @param {bigint} node_id
+     * @param {string} label
+     * @returns {GraphEdge[]}
+     */
+    get_outgoing_by_label(node_id, label) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.graphstore_get_outgoing_by_label(retptr, this.__wbg_ptr, node_id, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Creates a new empty graph store.
+     */
+    constructor() {
+        const ret = wasm.graphstore_new();
+        this.__wbg_ptr = ret >>> 0;
+        GraphStoreFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Clears all nodes and edges.
+     */
+    clear() {
+        wasm.graphstore_clear(this.__wbg_ptr);
+    }
+    /**
+     * Adds an edge to the graph.
+     *
+     * Returns an error if an edge with the same ID already exists.
+     * @param {GraphEdge} edge
+     */
+    add_edge(edge) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(edge, GraphEdge);
+            var ptr0 = edge.__destroy_into_raw();
+            wasm.graphstore_add_edge(retptr, this.__wbg_ptr, ptr0);
+            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);
+        }
+    }
+    /**
+     * Adds a node to the graph.
+     * @param {GraphNode} node
+     */
+    add_node(node) {
+        _assertClass(node, GraphNode);
+        var ptr0 = node.__destroy_into_raw();
+        wasm.graphstore_add_node(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Gets an edge by ID.
+     * @param {bigint} id
+     * @returns {GraphEdge | undefined}
+     */
+    get_edge(id) {
+        const ret = wasm.graphstore_get_edge(this.__wbg_ptr, id);
+        return ret === 0 ? undefined : GraphEdge.__wrap(ret);
+    }
+    /**
+     * Gets a node by ID.
+     * @param {bigint} id
+     * @returns {GraphNode | undefined}
+     */
+    get_node(id) {
+        const ret = wasm.graphstore_get_node(this.__wbg_ptr, id);
+        return ret === 0 ? undefined : GraphNode.__wrap(ret);
+    }
+}
+if (Symbol.dispose) GraphStore.prototype[Symbol.dispose] = GraphStore.prototype.free;
+
 /**
  * Storage mode for vector quantization.
  * @enum {0 | 1 | 2}
@@ -1193,6 +1733,10 @@ function __wbg_get_imports() {
         const ret = Reflect.get(getObject(arg0), getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_graphedge_new = function(arg0) {
+        const ret = GraphEdge.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_indexedDB_23c232e00a1e28ad = function() { return handleError(function (arg0) {
         const ret = getObject(arg0).indexedDB;
         return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -1284,7 +1828,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_577(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_661(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -1405,11 +1949,6 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_257c51b8abf9285e = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 57, function: Function { arguments: [Externref], shim_idx: 58, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_527, __wasm_bindgen_func_elem_528);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
@@ -1417,7 +1956,7 @@ function __wbg_get_imports() {
     };
     imports.wbg.__wbindgen_cast_59e89726c7c5a9af = function(arg0, arg1) {
         // Cast intrinsic for `Closure(Closure { dtor_idx: 8, function: Function { arguments: [NamedExternref("Event")], shim_idx: 9, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_147, __wasm_bindgen_func_elem_148);
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_183, __wasm_bindgen_func_elem_184);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
@@ -1425,6 +1964,11 @@ function __wbg_get_imports() {
         const ret = arg0;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_c060e19e7a983f38 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 55, function: Function { arguments: [Externref], shim_idx: 56, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_611, __wasm_bindgen_func_elem_612);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;
@@ -1444,6 +1988,7 @@ function __wbg_get_imports() {
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
+    cachedBigUint64ArrayMemory0 = null;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;