@wiscale/velesdb-wasm 1.1.2 → 1.3.0

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)) {
@@ -187,87 +216,756 @@ function passStringToWasm0(arg, malloc, realloc) {
         WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+function __wasm_bindgen_func_elem_198(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_198(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_640(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_640(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_689(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_689(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;
+    }
+    /**
+     * Gets the degree (number of outgoing edges) of a node.
+     * @param {bigint} node_id
+     * @returns {number}
+     */
+    out_degree(node_id) {
+        const ret = wasm.graphstore_out_degree(this.__wbg_ptr, node_id);
+        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);
+        }
+    }
+    /**
+     * Performs DFS 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 (depth-first order).
+     * @param {bigint} source_id
+     * @param {number} max_depth
+     * @param {number} limit
+     * @returns {any}
+     */
+    dfs_traverse(source_id, max_depth, limit) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphstore_dfs_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 all edge IDs in the graph.
+     * @returns {BigUint64Array}
+     */
+    get_all_edge_ids() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphstore_get_all_edge_ids(retptr, this.__wbg_ptr);
+            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 all node IDs in the graph.
+     * @returns {BigUint64Array}
+     */
+    get_all_node_ids() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphstore_get_all_node_ids(retptr, this.__wbg_ptr);
+            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 all edges with a specific label.
+     *
+     * # Arguments
+     *
+     * * `label` - The relationship type to filter by
+     *
+     * # Returns
+     *
+     * Array of edges matching the label.
+     * @param {string} label
+     * @returns {GraphEdge[]}
+     */
+    get_edges_by_label(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_edges_by_label(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * Gets all nodes with a specific label.
+     *
+     * # Arguments
+     *
+     * * `label` - The label to filter by
+     *
+     * # Returns
+     *
+     * Array of nodes matching the label.
+     * @param {string} label
+     * @returns {GraphNode[]}
+     */
+    get_nodes_by_label(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_nodes_by_label(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * 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);
     }
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
+    /**
+     * 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);
         }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
+    /**
+     * 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);
     }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
+    /**
+     * 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);
+    }
+    /**
+     * Checks if an edge exists.
+     * @param {bigint} id
+     * @returns {boolean}
+     */
+    has_edge(id) {
+        const ret = wasm.graphstore_has_edge(this.__wbg_ptr, id);
+        return ret !== 0;
+    }
+    /**
+     * Checks if a node exists.
+     * @param {bigint} id
+     * @returns {boolean}
+     */
+    has_node(id) {
+        const ret = wasm.graphstore_has_node(this.__wbg_ptr, id);
+        return ret !== 0;
+    }
+    /**
+     * Gets the in-degree (number of incoming edges) of a node.
+     * @param {bigint} node_id
+     * @returns {number}
+     */
+    in_degree(node_id) {
+        const ret = wasm.graphstore_in_degree(this.__wbg_ptr, node_id);
+        return ret >>> 0;
     }
 }
-
-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_528(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_528(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));
-}
-
-const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
-
-const VectorStoreFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_vectorstore_free(ptr >>> 0, 1));
+if (Symbol.dispose) GraphStore.prototype[Symbol.dispose] = GraphStore.prototype.free;
 
 /**
  * Storage mode for vector quantization.
@@ -322,20 +1020,7 @@ export class VectorStore {
         wasm.__wbg_vectorstore_free(ptr, 0);
     }
     /**
-     * Performs text search on payload fields.
-     *
-     * This is a simple substring-based search on payload text fields.
-     * For full BM25 text search, use the REST API backend.
-     *
-     * # Arguments
-     *
-     * * `query` - Text query to search for
-     * * `k` - Number of results
-     * * `field` - Optional field name to search in (default: searches all string fields)
-     *
-     * # Returns
-     *
-     * Array of results with matching payloads.
+     * Text search on payload fields (substring matching).
      * @param {string} query
      * @param {number} k
      * @param {string | null} [field]
@@ -361,17 +1046,7 @@ export class VectorStore {
         }
     }
     /**
-     * Batch search for multiple vectors in parallel.
-     *
-     * # Arguments
-     *
-     * * `vectors` - Flat array of query vectors (concatenated)
-     * * `num_vectors` - Number of vectors
-     * * `k` - Results per query
-     *
-     * # Returns
-     *
-     * Array of arrays of (id, score) tuples.
+     * Batch search for multiple vectors. Returns [[[id, score], ...], ...].
      * @param {Float32Array} vectors
      * @param {number} num_vectors
      * @param {number} k
@@ -395,18 +1070,7 @@ export class VectorStore {
         }
     }
     /**
-     * Inserts multiple vectors in a single batch operation.
-     *
-     * This is significantly faster than calling `insert()` multiple times
-     * because it pre-allocates memory and reduces per-call overhead.
-     *
-     * # Arguments
-     *
-     * * `batch` - JavaScript array of `[id, Float32Array]` pairs
-     *
-     * # Errors
-     *
-     * Returns an error if any vector dimension doesn't match store dimension.
+     * Batch insert. Input: `[[id, Float32Array], ...]`.
      * @param {any} batch
      */
     insert_batch(batch) {
@@ -451,20 +1115,7 @@ export class VectorStore {
         }
     }
     /**
-     * Performs hybrid search combining vector similarity and text search.
-     *
-     * Uses a simple weighted fusion of vector search and text search results.
-     *
-     * # Arguments
-     *
-     * * `query_vector` - Query vector for similarity search
-     * * `text_query` - Text query for payload search
-     * * `k` - Number of results to return
-     * * `vector_weight` - Weight for vector results (0.0-1.0, default 0.5)
-     *
-     * # Returns
-     *
-     * Array of fused results with id, score, and payload.
+     * Hybrid search (vector + text). `vector_weight` 0-1 (default 0.5).
      * @param {Float32Array} query_vector
      * @param {string} text_query
      * @param {number} k
@@ -491,23 +1142,7 @@ export class VectorStore {
         }
     }
     /**
-     * Creates a new vector store with specified storage mode for memory optimization.
-     *
-     * # Arguments
-     *
-     * * `dimension` - Vector dimension
-     * * `metric` - Distance metric
-     * * `mode` - Storage mode: "full", "sq8", or "binary"
-     *
-     * # Storage Modes
-     *
-     * - `full`: Best recall, 4 bytes/dimension
-     * - `sq8`: 4x compression, ~1% recall loss
-     * - `binary`: 32x compression, ~5-10% recall loss
-     *
-     * # Errors
-     *
-     * Returns an error if the metric or storage mode is unknown.
+     * Creates store with mode: full (4B/dim), sq8 (4x compression), binary (32x).
      * @param {number} dimension
      * @param {string} metric
      * @param {string} mode
@@ -533,20 +1168,7 @@ export class VectorStore {
         }
     }
     /**
-     * Creates a new vector store with pre-allocated capacity.
-     *
-     * This is more efficient when you know the approximate number of vectors
-     * you'll be inserting, as it avoids repeated memory allocations.
-     *
-     * # Arguments
-     *
-     * * `dimension` - Vector dimension
-     * * `metric` - Distance metric: "cosine", "euclidean", or "dot"
-     * * `capacity` - Number of vectors to pre-allocate space for
-     *
-     * # Errors
-     *
-     * Returns an error if the metric is not recognized.
+     * Creates store with pre-allocated capacity.
      * @param {number} dimension
      * @param {string} metric
      * @param {number} capacity
@@ -570,17 +1192,7 @@ export class VectorStore {
         }
     }
     /**
-     * Deletes the `IndexedDB` database.
-     *
-     * Use this to clear all persisted data.
-     *
-     * # Arguments
-     *
-     * * `db_name` - Name of the `IndexedDB` database to delete
-     *
-     * # Errors
-     *
-     * Returns an error if the deletion fails.
+     * Deletes `IndexedDB` database.
      * @param {string} db_name
      * @returns {Promise<void>}
      */
@@ -591,23 +1203,7 @@ export class VectorStore {
         return takeObject(ret);
     }
     /**
-     * Exports the vector store to a binary format.
-     *
-     * The binary format contains:
-     * - Header: dimension (u32), metric (u8), count (u64)
-     * - For each vector: id (u64), data (f32 array)
-     *
-     * Use this to persist data to `IndexedDB` or `localStorage`.
-     *
-     * # Errors
-     *
-     * This function currently does not return errors but uses `Result`
-     * for future extensibility.
-     *
-     * # Performance
-     *
-     * Perf: Pre-allocates exact buffer size to avoid reallocations.
-     * Throughput: ~1600 MB/s on 10k vectors (768D)
+     * Exports to binary format for IndexedDB/localStorage.
      * @returns {Uint8Array}
      */
     export_to_bytes() {
@@ -637,17 +1233,7 @@ export class VectorStore {
         return ret !== 0;
     }
     /**
-     * Imports a vector store from binary format.
-     *
-     * Use this to restore data from `IndexedDB` or `localStorage`.
-     *
-     * # Errors
-     *
-     * Returns an error if:
-     * - The data is too short or corrupted
-     * - The magic number is invalid
-     * - The version is unsupported
-     * - The metric byte is invalid
+     * Imports from binary format.
      * @param {Uint8Array} bytes
      * @returns {VectorStore}
      */
@@ -670,8 +1256,6 @@ export class VectorStore {
     }
     /**
      * Creates a metadata-only store (no vectors, only payloads).
-     *
-     * Useful for storing auxiliary data without vector embeddings.
      * @returns {VectorStore}
      */
     static new_metadata_only() {
@@ -679,22 +1263,34 @@ export class VectorStore {
         return VectorStore.__wrap(ret);
     }
     /**
-     * Performs multi-query search with result fusion.
-     *
-     * Executes searches for multiple query vectors and fuses results
-     * using the specified strategy.
-     *
-     * # Arguments
-     *
-     * * `vectors` - Array of query vectors (as flat array with dimension stride)
-     * * `num_vectors` - Number of vectors in the array
-     * * `k` - Number of results to return
-     * * `strategy` - Fusion strategy: "average", "maximum", "rrf"
-     * * `rrf_k` - RRF k parameter (only used when strategy = "rrf", default 60)
-     *
-     * # Returns
-     *
-     * Array of fused results with id and score.
+     * Similarity search with threshold. Operators: >, >=, <, <=, =, !=.
+     * @param {Float32Array} query
+     * @param {number} threshold
+     * @param {string} operator
+     * @param {number} k
+     * @returns {any}
+     */
+    similarity_search(query, threshold, operator, k) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF32ToWasm0(query, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(operator, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.vectorstore_similarity_search(retptr, this.__wbg_ptr, ptr0, len0, threshold, 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);
+        }
+    }
+    /**
+     * Multi-query search with fusion. Strategies: average, maximum, rrf.
      * @param {Float32Array} vectors
      * @param {number} num_vectors
      * @param {number} k
@@ -722,17 +1318,7 @@ export class VectorStore {
         }
     }
     /**
-     * Searches with metadata filtering.
-     *
-     * # Arguments
-     *
-     * * `query` - Query vector
-     * * `k` - Number of results
-     * * `filter` - JSON filter object (e.g., `{"condition": {"type": "eq", "field": "category", "value": "tech"}}`)
-     *
-     * # Returns
-     *
-     * Array of `[id, score, payload]` tuples sorted by relevance.
+     * Searches with metadata filtering. Returns [{id, score, payload}].
      * @param {Float32Array} query
      * @param {number} k
      * @param {any} filter
@@ -756,17 +1342,7 @@ export class VectorStore {
         }
     }
     /**
-     * Inserts a vector with the given ID and optional JSON payload.
-     *
-     * # Arguments
-     *
-     * * `id` - Unique identifier for the vector
-     * * `vector` - `Float32Array` of the vector data
-     * * `payload` - Optional JSON payload (metadata)
-     *
-     * # Errors
-     *
-     * Returns an error if vector dimension doesn't match store dimension.
+     * Inserts a vector with ID and optional JSON payload.
      * @param {bigint} id
      * @param {Float32Array} vector
      * @param {any} payload
@@ -787,15 +1363,7 @@ export class VectorStore {
         }
     }
     /**
-     * Gets a vector by ID.
-     *
-     * # Arguments
-     *
-     * * `id` - The vector ID to retrieve
-     *
-     * # Returns
-     *
-     * An object with `id`, `vector`, and `payload` fields, or null if not found.
+     * Gets a vector by ID. Returns {id, vector, payload} or null.
      * @param {bigint} id
      * @returns {any}
      */
@@ -823,16 +1391,7 @@ export class VectorStore {
         return ret >>> 0;
     }
     /**
-     * Creates a new vector store with the specified dimension and distance metric.
-     *
-     * # Arguments
-     *
-     * * `dimension` - Vector dimension (e.g., 768 for BERT, 1536 for GPT)
-     * * `metric` - Distance metric: "cosine", "euclidean", or "dot"
-     *
-     * # Errors
-     *
-     * Returns an error if the metric is not recognized.
+     * Creates a new vector store. Metrics: cosine, euclidean, dot, hamming, jaccard.
      * @param {number} dimension
      * @param {string} metric
      */
@@ -856,24 +1415,7 @@ export class VectorStore {
         }
     }
     /**
-     * Loads a vector store from `IndexedDB`.
-     *
-     * This method restores all vectors from the browser's `IndexedDB`.
-     *
-     * # Arguments
-     *
-     * * `db_name` - Name of the `IndexedDB` database
-     *
-     * # Errors
-     *
-     * Returns an error if the database doesn't exist or is corrupted.
-     *
-     * # Example
-     *
-     * ```javascript
-     * const store = await VectorStore.load("my-vectors");
-     * console.log(store.len); // Number of restored vectors
-     * ```
+     * Loads from `IndexedDB`.
      * @param {string} db_name
      * @returns {Promise<VectorStore>}
      */
@@ -884,26 +1426,7 @@ export class VectorStore {
         return takeObject(ret);
     }
     /**
-     * Saves the vector store to `IndexedDB`.
-     *
-     * This method persists all vectors to the browser's `IndexedDB`,
-     * enabling offline-first applications.
-     *
-     * # Arguments
-     *
-     * * `db_name` - Name of the `IndexedDB` database
-     *
-     * # Errors
-     *
-     * Returns an error if `IndexedDB` is not available or the save fails.
-     *
-     * # Example
-     *
-     * ```javascript
-     * const store = new VectorStore(768, "cosine");
-     * store.insert(1n, vector1);
-     * await store.save("my-vectors");
-     * ```
+     * Saves to `IndexedDB`.
      * @param {string} db_name
      * @returns {Promise<void>}
      */
@@ -921,15 +1444,6 @@ export class VectorStore {
     }
     /**
      * Inserts a vector with the given ID.
-     *
-     * # Arguments
-     *
-     * * `id` - Unique identifier for the vector
-     * * `vector` - `Float32Array` of the vector data
-     *
-     * # Errors
-     *
-     * Returns an error if vector dimension doesn't match store dimension.
      * @param {bigint} id
      * @param {Float32Array} vector
      */
@@ -958,20 +1472,7 @@ export class VectorStore {
         return ret !== 0;
     }
     /**
-     * Searches for the k nearest neighbors to the query vector.
-     *
-     * # Arguments
-     *
-     * * `query` - Query vector as `Float32Array`
-     * * `k` - Number of results to return
-     *
-     * # Returns
-     *
-     * Array of [id, score] pairs sorted by relevance.
-     *
-     * # Errors
-     *
-     * Returns an error if query dimension doesn't match store dimension.
+     * k-NN search. Returns [[id, score], ...].
      * @param {Float32Array} query
      * @param {number} k
      * @returns {any}
@@ -994,13 +1495,7 @@ export class VectorStore {
         }
     }
     /**
-     * Pre-allocates memory for the specified number of additional vectors.
-     *
-     * Call this before bulk insertions to avoid repeated allocations.
-     *
-     * # Arguments
-     *
-     * * `additional` - Number of additional vectors to reserve space for
+     * Pre-allocates memory for additional vectors.
      * @param {number} additional
      */
     reserve(additional) {
@@ -1193,6 +1688,14 @@ 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_graphnode_new = function(arg0) {
+        const ret = GraphNode.__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 +1787,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_689(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -1405,11 +1908,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 +1915,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_197, __wasm_bindgen_func_elem_198);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
@@ -1430,6 +1928,11 @@ function __wbg_get_imports() {
         const ret = arg0;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_eecb66c58f878696 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 67, function: Function { arguments: [Externref], shim_idx: 68, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_639, __wasm_bindgen_func_elem_640);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
         const ret = getObject(arg0);
         return addHeapObject(ret);
@@ -1444,6 +1947,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;