@wiscale/velesdb-wasm 1.3.0 → 1.4.1

package/velesdb_wasm.js

@@ -280,16 +280,16 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 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_265(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_265(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_1176(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1176(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));
+function __wasm_bindgen_func_elem_1217(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1217(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
@@ -302,14 +302,38 @@ const GraphNodeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_graphnode_free(ptr >>> 0, 1));
 
+const GraphPersistenceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_graphpersistence_free(ptr >>> 0, 1));
+
 const GraphStoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_graphstore_free(ptr >>> 0, 1));
 
+const GraphWorkerConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_graphworkerconfig_free(ptr >>> 0, 1));
+
+const ParsedQueryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_parsedquery_free(ptr >>> 0, 1));
+
+const SemanticMemoryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_semanticmemory_free(ptr >>> 0, 1));
+
+const TraversalProgressFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_traversalprogress_free(ptr >>> 0, 1));
+
 const VectorStoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_vectorstore_free(ptr >>> 0, 1));
 
+const VelesQLFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_velesql_free(ptr >>> 0, 1));
+
 /**
  * A graph edge representing a relationship between nodes.
  */
@@ -590,12 +614,111 @@ export class GraphNode {
 }
 if (Symbol.dispose) GraphNode.prototype[Symbol.dispose] = GraphNode.prototype.free;
 
+/**
+ * `IndexedDB` persistence manager for `GraphStore`.
+ */
+export class GraphPersistence {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GraphPersistenceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_graphpersistence_free(ptr, 0);
+    }
+    /**
+     * Lists all saved graph names.
+     * @returns {Promise<Array<any>>}
+     */
+    list_graphs() {
+        const ret = wasm.graphpersistence_list_graphs(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Deletes a saved graph by name.
+     *
+     * BUG-7 FIX: Also deletes all nodes and edges with the graph prefix.
+     * @param {string} graph_name
+     * @returns {Promise<void>}
+     */
+    delete_graph(graph_name) {
+        const ptr0 = passStringToWasm0(graph_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.graphpersistence_delete_graph(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Gets metadata for a saved graph.
+     * @param {string} graph_name
+     * @returns {Promise<any>}
+     */
+    get_metadata(graph_name) {
+        const ptr0 = passStringToWasm0(graph_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.graphpersistence_get_metadata(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Creates a new `GraphPersistence` instance (call `init()` to open database).
+     */
+    constructor() {
+        const ret = wasm.graphpersistence_new();
+        this.__wbg_ptr = ret >>> 0;
+        GraphPersistenceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Initializes the database connection. Must be called before save/load.
+     * @returns {Promise<void>}
+     */
+    init() {
+        const ret = wasm.graphpersistence_init(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Loads a graph from `IndexedDB` by name.
+     *
+     * BUG-6 FIX: Only loads nodes/edges with keys prefixed by `{graph_name}:`
+     * @param {string} graph_name
+     * @returns {Promise<GraphStore>}
+     */
+    load(graph_name) {
+        const ptr0 = passStringToWasm0(graph_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.graphpersistence_load(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Saves a graph to `IndexedDB` with the given name.
+     * @param {string} graph_name
+     * @param {GraphStore} store
+     * @returns {Promise<void>}
+     */
+    save(graph_name, store) {
+        const ptr0 = passStringToWasm0(graph_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(store, GraphStore);
+        const ret = wasm.graphpersistence_save(this.__wbg_ptr, ptr0, len0, store.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) GraphPersistence.prototype[Symbol.dispose] = GraphPersistence.prototype.free;
+
 /**
  * In-memory graph store for browser-based knowledge graphs.
  *
  * Stores nodes and edges with bidirectional indexing for efficient traversal.
  */
 export class GraphStore {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GraphStore.prototype);
+        obj.__wbg_ptr = ptr;
+        GraphStoreFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -884,88 +1007,591 @@ export class GraphStore {
         return this;
     }
     /**
-     * Clears all nodes and edges.
+     * 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);
+    }
+    /**
+     * 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;
+    }
+}
+if (Symbol.dispose) GraphStore.prototype[Symbol.dispose] = GraphStore.prototype.free;
+
+/**
+ * Configuration for Web Worker traversal decisions.
+ */
+export class GraphWorkerConfig {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GraphWorkerConfig.prototype);
+        obj.__wbg_ptr = ptr;
+        GraphWorkerConfigFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GraphWorkerConfigFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_graphworkerconfig_free(ptr, 0);
+    }
+    /**
+     * Creates a configuration optimized for large graphs.
+     * @returns {GraphWorkerConfig}
+     */
+    static for_large_graphs() {
+        const ret = wasm.graphworkerconfig_for_large_graphs();
+        return GraphWorkerConfig.__wrap(ret);
+    }
+    /**
+     * Creates a configuration optimized for responsive UI.
+     * @returns {GraphWorkerConfig}
+     */
+    static for_responsive_ui() {
+        const ret = wasm.graphworkerconfig_for_responsive_ui();
+        return GraphWorkerConfig.__wrap(ret);
+    }
+    /**
+     * Creates a new configuration with default values.
+     */
+    constructor() {
+        const ret = wasm.graphworkerconfig_new();
+        this.__wbg_ptr = ret >>> 0;
+        GraphWorkerConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Minimum node count to trigger worker offload.
+     * @returns {number}
+     */
+    get node_threshold() {
+        const ret = wasm.__wbg_get_graphworkerconfig_node_threshold(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Minimum node count to trigger worker offload.
+     * @param {number} arg0
+     */
+    set node_threshold(arg0) {
+        wasm.__wbg_set_graphworkerconfig_node_threshold(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Minimum depth to trigger worker offload.
+     * @returns {number}
+     */
+    get depth_threshold() {
+        const ret = wasm.__wbg_get_graphworkerconfig_depth_threshold(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Minimum depth to trigger worker offload.
+     * @param {number} arg0
+     */
+    set depth_threshold(arg0) {
+        wasm.__wbg_set_graphworkerconfig_depth_threshold(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Progress callback interval in milliseconds.
+     * @returns {number}
+     */
+    get progress_interval_ms() {
+        const ret = wasm.__wbg_get_graphworkerconfig_progress_interval_ms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Progress callback interval in milliseconds.
+     * @param {number} arg0
+     */
+    set progress_interval_ms(arg0) {
+        wasm.__wbg_set_graphworkerconfig_progress_interval_ms(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Whether to use `SharedArrayBuffer` for result transfer (if available).
+     * @returns {boolean}
+     */
+    get use_shared_buffer() {
+        const ret = wasm.__wbg_get_graphworkerconfig_use_shared_buffer(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether to use `SharedArrayBuffer` for result transfer (if available).
+     * @param {boolean} arg0
+     */
+    set use_shared_buffer(arg0) {
+        wasm.__wbg_set_graphworkerconfig_use_shared_buffer(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) GraphWorkerConfig.prototype[Symbol.dispose] = GraphWorkerConfig.prototype.free;
+
+/**
+ * A parsed `VelesQL` statement with introspection methods.
+ */
+export class ParsedQuery {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ParsedQuery.prototype);
+        obj.__wbg_ptr = ptr;
+        ParsedQueryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ParsedQueryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_parsedquery_free(ptr, 0);
+    }
+    /**
+     * Check if the query uses FUSION (hybrid search).
+     * @returns {boolean}
+     */
+    get hasFusion() {
+        const ret = wasm.parsedquery_hasFusion(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the number of JOIN clauses.
+     * @returns {number}
+     */
+    get joinCount() {
+        const ret = wasm.parsedquery_joinCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the table name from the FROM clause.
+     * @returns {string | undefined}
+     */
+    get tableName() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.parsedquery_tableName(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the LIMIT from the MATCH RETURN clause.
+     * @returns {bigint | undefined}
+     */
+    get matchLimit() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.parsedquery_matchLimit(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : BigInt.asUintN(64, r2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Check if DISTINCT modifier is present.
+     * @returns {boolean}
+     */
+    get hasDistinct() {
+        const ret = wasm.parsedquery_hasDistinct(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if the query has a GROUP BY clause.
+     * @returns {boolean}
+     */
+    get hasGroupBy() {
+        const ret = wasm.parsedquery_hasGroupBy(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if the query has an ORDER BY clause.
+     * @returns {boolean}
+     */
+    get hasOrderBy() {
+        const ret = wasm.parsedquery_hasOrderBy(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if the MATCH clause has a WHERE condition.
+     * @returns {boolean}
+     */
+    get matchHasWhere() {
+        const ret = wasm.parsedquery_matchHasWhere(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if the query has a WHERE clause.
+     * @returns {boolean}
+     */
+    get hasWhereClause() {
+        const ret = wasm.parsedquery_hasWhereClause(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the number of node patterns in the MATCH clause.
+     * @returns {number}
+     */
+    get matchNodeCount() {
+        const ret = wasm.parsedquery_matchNodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Check if the query contains vector search (NEAR clause).
+     * @returns {boolean}
+     */
+    get hasVectorSearch() {
+        const ret = wasm.parsedquery_hasVectorSearch(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get node labels from the MATCH clause as JSON array of arrays.
+     * Each inner array contains the labels for one node pattern.
+     * @returns {any}
+     */
+    get matchNodeLabels() {
+        const ret = wasm.parsedquery_matchNodeLabels(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get RETURN items from the MATCH clause as JSON array.
+     * @returns {any}
+     */
+    get matchReturnItems() {
+        const ret = wasm.parsedquery_matchReturnItems(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the number of relationship patterns in the MATCH clause.
+     * @returns {number}
+     */
+    get matchRelationshipCount() {
+        const ret = wasm.parsedquery_matchRelationshipCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get relationship types from the MATCH clause as JSON array of arrays.
+     * Each inner array contains the types for one relationship pattern.
+     * @returns {any}
+     */
+    get matchRelationshipTypes() {
+        const ret = wasm.parsedquery_matchRelationshipTypes(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the LIMIT value if present.
+     * @returns {bigint | undefined}
+     */
+    get limit() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.parsedquery_limit(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : BigInt.asUintN(64, r2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the OFFSET value if present.
+     * @returns {bigint | undefined}
+     */
+    get offset() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.parsedquery_offset(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : BigInt.asUintN(64, r2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the list of selected columns as JSON array.
+     * @returns {any}
+     */
+    get columns() {
+        const ret = wasm.parsedquery_columns(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the GROUP BY columns as JSON array.
+     * @returns {any}
+     */
+    get groupBy() {
+        const ret = wasm.parsedquery_groupBy(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Check if this is a MATCH (graph) query.
+     * @returns {boolean}
+     */
+    get isMatch() {
+        const ret = wasm.parsedquery_isMatch(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if the query is valid (always true for successfully parsed queries).
+     * @returns {boolean}
+     */
+    get isValid() {
+        const ret = wasm.parsedquery_isValid(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the ORDER BY columns and directions as JSON array.
+     * @returns {any}
+     */
+    get orderBy() {
+        const ret = wasm.parsedquery_orderBy(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Check if the query has JOINs.
+     * @returns {boolean}
+     */
+    get hasJoins() {
+        const ret = wasm.parsedquery_hasJoins(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if this is a SELECT query.
+     * @returns {boolean}
+     */
+    get isSelect() {
+        const ret = wasm.parsedquery_isSelect(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) ParsedQuery.prototype[Symbol.dispose] = ParsedQuery.prototype.free;
+
+/**
+ * Semantic Memory for AI agents in WASM.
+ *
+ * Stores knowledge facts as vectors with similarity search.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * import { SemanticMemory } from 'velesdb-wasm';
+ *
+ * const memory = new SemanticMemory(384);
+ * memory.store(1, "Paris is the capital of France", embedding);
+ * const results = memory.query(queryEmbedding, 5);
+ * ```
+ */
+export class SemanticMemory {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SemanticMemoryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_semanticmemory_free(ptr, 0);
+    }
+    /**
+     * Returns the number of stored knowledge facts.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.graphstore_node_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Creates a new `SemanticMemory` with the given embedding dimension.
+     * @param {number} dimension
+     */
+    constructor(dimension) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.semanticmemory_new(retptr, dimension);
+            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;
+            SemanticMemoryFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Clears all knowledge facts.
      */
     clear() {
-        wasm.graphstore_clear(this.__wbg_ptr);
+        wasm.semanticmemory_clear(this.__wbg_ptr);
     }
     /**
-     * Adds an edge to the graph.
+     * Queries semantic memory by similarity search.
      *
-     * Returns an error if an edge with the same ID already exists.
-     * @param {GraphEdge} edge
+     * Returns a JSON array of {id, score, content} objects.
+     * @param {Float32Array} embedding
+     * @param {number} top_k
+     * @returns {any}
      */
-    add_edge(edge) {
+    query(embedding, top_k) {
         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);
+            const ptr0 = passArrayF32ToWasm0(embedding, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.semanticmemory_query(retptr, this.__wbg_ptr, ptr0, len0, top_k);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return 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.
+     * Stores a knowledge fact with its embedding vector.
+     *
+     * # Arguments
+     *
+     * * `id` - Unique identifier for this fact
+     * * `content` - Text content of the knowledge
+     * * `embedding` - Vector representation (`Float32Array`)
      * @param {bigint} id
-     * @returns {GraphNode | undefined}
+     * @param {string} content
+     * @param {Float32Array} embedding
      */
-    get_node(id) {
-        const ret = wasm.graphstore_get_node(this.__wbg_ptr, id);
-        return ret === 0 ? undefined : GraphNode.__wrap(ret);
+    store(id, content, embedding) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF32ToWasm0(embedding, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.semanticmemory_store(retptr, this.__wbg_ptr, id, ptr0, len0, ptr1, len1);
+            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);
+        }
     }
     /**
-     * Checks if an edge exists.
+     * Removes a knowledge fact by ID.
      * @param {bigint} id
      * @returns {boolean}
      */
-    has_edge(id) {
-        const ret = wasm.graphstore_has_edge(this.__wbg_ptr, id);
+    remove(id) {
+        const ret = wasm.semanticmemory_remove(this.__wbg_ptr, id);
         return ret !== 0;
     }
     /**
-     * Checks if a node exists.
-     * @param {bigint} id
+     * Returns true if no knowledge facts are stored.
      * @returns {boolean}
      */
-    has_node(id) {
-        const ret = wasm.graphstore_has_node(this.__wbg_ptr, id);
+    is_empty() {
+        const ret = wasm.semanticmemory_is_empty(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * Gets the in-degree (number of incoming edges) of a node.
-     * @param {bigint} node_id
+     * Returns the embedding dimension.
      * @returns {number}
      */
-    in_degree(node_id) {
-        const ret = wasm.graphstore_in_degree(this.__wbg_ptr, node_id);
+    dimension() {
+        const ret = wasm.semanticmemory_dimension(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) GraphStore.prototype[Symbol.dispose] = GraphStore.prototype.free;
+if (Symbol.dispose) SemanticMemory.prototype[Symbol.dispose] = SemanticMemory.prototype.free;
 
 /**
  * Storage mode for vector quantization.
@@ -986,6 +1612,137 @@ export const StorageMode = Object.freeze({
     Binary: 2, "2": "Binary",
 });
 
+/**
+ * Progress information for long-running traversals.
+ */
+export class TraversalProgress {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TraversalProgressFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_traversalprogress_free(ptr, 0);
+    }
+    /**
+     * Returns the completion percentage (0-100).
+     * @returns {number}
+     */
+    get percentage() {
+        const ret = wasm.traversalprogress_percentage(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Creates a new progress report.
+     * @param {number} visited
+     * @param {number} estimated
+     * @param {number} depth
+     */
+    constructor(visited, estimated, depth) {
+        const ret = wasm.traversalprogress_new(visited, estimated, depth);
+        this.__wbg_ptr = ret >>> 0;
+        TraversalProgressFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Converts to JSON for postMessage.
+     * @returns {any}
+     */
+    to_json() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.traversalprogress_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);
+        }
+    }
+    /**
+     * Number of nodes visited so far.
+     * @returns {number}
+     */
+    get visited_count() {
+        const ret = wasm.__wbg_get_graphworkerconfig_node_threshold(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of nodes visited so far.
+     * @param {number} arg0
+     */
+    set visited_count(arg0) {
+        wasm.__wbg_set_graphworkerconfig_node_threshold(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Estimated total nodes to visit (heuristic).
+     * @returns {number}
+     */
+    get estimated_total() {
+        const ret = wasm.__wbg_get_graphworkerconfig_depth_threshold(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Estimated total nodes to visit (heuristic).
+     * @param {number} arg0
+     */
+    set estimated_total(arg0) {
+        wasm.__wbg_set_graphworkerconfig_depth_threshold(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Current traversal depth.
+     * @returns {number}
+     */
+    get current_depth() {
+        const ret = wasm.__wbg_get_graphworkerconfig_progress_interval_ms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Current traversal depth.
+     * @param {number} arg0
+     */
+    set current_depth(arg0) {
+        wasm.__wbg_set_graphworkerconfig_progress_interval_ms(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Whether the traversal is complete.
+     * @returns {boolean}
+     */
+    get is_complete() {
+        const ret = wasm.__wbg_get_graphworkerconfig_use_shared_buffer(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether the traversal is complete.
+     * @param {boolean} arg0
+     */
+    set is_complete(arg0) {
+        wasm.__wbg_set_graphworkerconfig_use_shared_buffer(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Whether the traversal was cancelled.
+     * @returns {boolean}
+     */
+    get is_cancelled() {
+        const ret = wasm.__wbg_get_traversalprogress_is_cancelled(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether the traversal was cancelled.
+     * @param {boolean} arg0
+     */
+    set is_cancelled(arg0) {
+        wasm.__wbg_set_traversalprogress_is_cancelled(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) TraversalProgress.prototype[Symbol.dispose] = TraversalProgress.prototype.free;
+
 /**
  * A vector store for in-memory vector search.
  *
@@ -1442,6 +2199,39 @@ export class VectorStore {
     clear() {
         wasm.vectorstore_clear(this.__wbg_ptr);
     }
+    /**
+     * VelesQL-style query returning multi-model results (EPIC-031 US-009).
+     *
+     * Returns results in `HybridResult` format with `node_id`, `vector_score`,
+     * `graph_score`, `fused_score`, `bindings`, and `column_data`.
+     *
+     * # Arguments
+     * * `query_vector` - Query vector for similarity search
+     * * `k` - Number of results to return
+     *
+     * # Returns
+     * Array of `{nodeId, vectorScore, graphScore, fusedScore, bindings, columnData}`
+     * @param {Float32Array} query_vector
+     * @param {number} k
+     * @returns {any}
+     */
+    query(query_vector, k) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF32ToWasm0(query_vector, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.vectorstore_query(retptr, this.__wbg_ptr, ptr0, len0, 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);
+        }
+    }
     /**
      * Inserts a vector with the given ID.
      * @param {bigint} id
@@ -1520,6 +2310,114 @@ export class VectorStore {
 }
 if (Symbol.dispose) VectorStore.prototype[Symbol.dispose] = VectorStore.prototype.free;
 
+/**
+ * `VelesQL` query parser for browser use.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * import { VelesQL } from 'velesdb-wasm';
+ *
+ * // Parse a query
+ * const parsed = VelesQL.parse("SELECT * FROM docs WHERE category = 'tech' LIMIT 10");
+ * console.log(parsed.tableName);  // "docs"
+ * console.log(parsed.isValid);    // true
+ *
+ * // Validate without parsing
+ * const valid = VelesQL.isValid("SELECT * FROM docs");  // true
+ * ```
+ */
+export class VelesQL {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VelesQLFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_velesql_free(ptr, 0);
+    }
+    /**
+     * Parse a `VelesQL` query string.
+     *
+     * Returns a `ParsedQuery` object with query introspection methods.
+     * Throws an error if the query has syntax errors.
+     * @param {string} query
+     * @returns {ParsedQuery}
+     */
+    static parse(query) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.velesql_parse(retptr, 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);
+            }
+            return ParsedQuery.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Validate a `VelesQL` query without full parsing.
+     *
+     * This is faster than `parse()` when you only need to check validity.
+     * @param {string} query
+     * @returns {boolean}
+     */
+    static isValid(query) {
+        const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.velesql_isValid(ptr0, len0);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) VelesQL.prototype[Symbol.dispose] = VelesQL.prototype.free;
+
+/**
+ * Estimates the number of nodes that will be visited during traversal.
+ *
+ * Uses a heuristic based on graph density and max depth.
+ * @param {number} node_count
+ * @param {number} edge_count
+ * @param {number} max_depth
+ * @returns {number}
+ */
+export function estimate_traversal_size(node_count, edge_count, max_depth) {
+    const ret = wasm.estimate_traversal_size(node_count, edge_count, max_depth);
+    return ret >>> 0;
+}
+
+/**
+ * Determines whether a traversal should be offloaded to a Web Worker.
+ *
+ * # Arguments
+ * * `node_count` - Total nodes in the graph
+ * * `max_depth` - Maximum traversal depth requested
+ * * `config` - Optional configuration (uses defaults if None)
+ *
+ * # Returns
+ * `true` if the operation should use a Web Worker
+ * @param {number} node_count
+ * @param {number} max_depth
+ * @param {GraphWorkerConfig | null} [config]
+ * @returns {boolean}
+ */
+export function should_use_worker(node_count, max_depth, config) {
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, GraphWorkerConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.should_use_worker(node_count, max_depth, ptr0);
+    return ret !== 0;
+}
+
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -1645,6 +2543,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
         getObject(arg0)._wbg_cb_unref();
     };
+    imports.wbg.__wbg_bound_dd83af44245de95e = function() { return handleError(function (arg0, arg1) {
+        const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
@@ -1661,6 +2563,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_delete_a8cf58aab29e18d2 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).delete(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
         const ret = getObject(arg0).done;
         return ret;
@@ -1669,6 +2575,14 @@ function __wbg_get_imports() {
         const ret = Object.entries(getObject(arg0));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_getAllKeys_925405ffbd671e86 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).getAllKeys();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getAll_48e288420773a079 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).getAll(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
         const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
@@ -1688,6 +2602,10 @@ function __wbg_get_imports() {
         const ret = Reflect.get(getObject(arg0), getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
+        const ret = getObject(arg0)[getObject(arg1)];
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_graphedge_new = function(arg0) {
         const ret = GraphEdge.__wrap(arg0);
         return addHeapObject(ret);
@@ -1696,6 +2614,10 @@ function __wbg_get_imports() {
         const ret = GraphNode.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_graphstore_new = function(arg0) {
+        const ret = GraphStore.__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);
@@ -1787,7 +2709,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_689(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_1217(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -1814,6 +2736,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).next();
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_now_69d776cd24f5215b = function() {
+        const ret = Date.now();
+        return ret;
+    };
     imports.wbg.__wbg_objectStoreNames_90900f9a531513ac = function(arg0) {
         const ret = getObject(arg0).objectStoreNames;
         return addHeapObject(ret);
@@ -1822,6 +2748,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_open_0d7b85f4c0a38ffe = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_open_2a2740c93beabe29 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
@@ -1829,6 +2759,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
     };
+    imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
+        const ret = getObject(arg0).push(getObject(arg1));
+        return ret;
+    };
     imports.wbg.__wbg_put_d40a68e5a8902a46 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
@@ -1891,10 +2825,22 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).then(getObject(arg1));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_transaction_257422def49a0094 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).transaction(getObject(arg1), __wbindgen_enum_IdbTransactionMode[arg2]);
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_transaction_754344c3ae25fdcf = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_transaction_790ec170b8fbc74b = function() { return handleError(function (arg0, arg1, arg2, arg3) {
         const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2), __wbindgen_enum_IdbTransactionMode[arg3]);
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_transaction_f32b8e1d5f304f61 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).transaction(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
         const ret = getObject(arg0).value;
         return addHeapObject(ret);
@@ -1913,11 +2859,6 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    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_197, __wasm_bindgen_func_elem_198);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
         // Cast intrinsic for `I64 -> Externref`.
         const ret = arg0;
@@ -1928,9 +2869,14 @@ 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);
+    imports.wbg.__wbindgen_cast_f1c9170db27db6a8 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 125, function: Function { arguments: [Externref], shim_idx: 126, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1175, __wasm_bindgen_func_elem_1176);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_fdfac116b4bf22c8 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 9, function: Function { arguments: [NamedExternref("Event")], shim_idx: 10, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_264, __wasm_bindgen_func_elem_265);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {