@dikolab/kbdb 0.1.2 → 0.1.3

package/dist/wasm/kb-worker/kbdb_worker.js

@@ -0,0 +1,1066 @@
+let wasm_bindgen = (function(exports) {
+    let script_src;
+    if (typeof document !== 'undefined' && document.currentScript !== null) {
+        script_src = new URL(document.currentScript.src, location.href).toString();
+    }
+
+    /**
+     * Adds a section. `ptr`/`len` point to an encoded `AddSectionParams`.
+     *
+     * On success: writes encoded kbid string to return slot, returns 0.
+     * On error: writes error message to return slot, returns -1.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_add_section(ptr, len) {
+        const ret = wasm.db_add_section(ptr, len);
+        return ret;
+    }
+    exports.db_add_section = db_add_section;
+
+    /**
+     * Adds a section's terms to the inverted and positional indexes.
+     * `ptr`/`len` point to encoded
+     * (kbid_str, term_count, [(term_str, pos_count, [positions], heading_tf, body_tf, code_tf)]).
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_add_to_index(ptr, len) {
+        const ret = wasm.db_add_to_index(ptr, len);
+        return ret;
+    }
+    exports.db_add_to_index = db_add_to_index;
+
+    /**
+     * Checks database integrity. Returns 0 on success.
+     * On success a summary string is placed in the return slot.
+     * @param {number} _ptr
+     * @param {number} _len
+     * @returns {number}
+     */
+    function db_check_integrity(_ptr, _len) {
+        const ret = wasm.db_check_integrity(_ptr, _len);
+        return ret;
+    }
+    exports.db_check_integrity = db_check_integrity;
+
+    /**
+     * Reads `catalog.toml` from the path at `ptr`/`len` and returns the version
+     * status without modifying state.
+     *
+     * On success, the return slot contains 8 bytes:
+     * - bytes 0-3: `catalog_version` as little-endian u32
+     * - bytes 4-7: `required_version` (DB_FORMAT_VERSION) as little-endian u32
+     *
+     * Return value:
+     * - 0: compatible (versions match)
+     * - 1: needs migration (catalog version < required)
+     * - 2: too new (catalog version > required)
+     * - -1: I/O or parse error (message in return slot)
+     *
+     * Note: this export accepts a path directly and does NOT require `db_init`
+     * to have been called first.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_check_version(ptr, len) {
+        const ret = wasm.db_check_version(ptr, len);
+        return ret;
+    }
+    exports.db_check_version = db_check_version;
+
+    /**
+     * Runs garbage collection. Returns 0 on success.
+     * On success a summary string is placed in the return slot.
+     * @param {number} _ptr
+     * @param {number} _len
+     * @returns {number}
+     */
+    function db_gc(_ptr, _len) {
+        const ret = wasm.db_gc(_ptr, _len);
+        return ret;
+    }
+    exports.db_gc = db_gc;
+
+    /**
+     * Initialises the database context path.
+     *
+     * The JS host must call this before any other function.
+     * `ptr`/`len` point to a UTF-8 context path string in WASM memory.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_init(ptr, len) {
+        const ret = wasm.db_init(ptr, len);
+        return ret;
+    }
+    exports.db_init = db_init;
+
+    /**
+     * Initialises a new empty catalog at the current context path.
+     * Writes the default catalog to disk and returns 0 on success.
+     * @param {number} _ptr
+     * @param {number} _len
+     * @returns {number}
+     */
+    function db_init_catalog(_ptr, _len) {
+        const ret = wasm.db_init_catalog(_ptr, _len);
+        return ret;
+    }
+    exports.db_init_catalog = db_init_catalog;
+
+    /**
+     * Creates the full directory scaffold for a new database at `ptr`/`len` path.
+     *
+     * Creates directories, seeds `catalog.toml` (stamped with `DB_FORMAT_VERSION`),
+     * empty index files, `worker.toml`, and `.gitignore`.
+     *
+     * Returns 0 on success. Returns -1 with an error message in the return slot
+     * if the directory already exists or any I/O fails.
+     *
+     * Note: this export accepts a path directly and does NOT require `db_init`
+     * to have been called first.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_init_directory(ptr, len) {
+        const ret = wasm.db_init_directory(ptr, len);
+        return ret;
+    }
+    exports.db_init_directory = db_init_directory;
+
+    /**
+     * Lists all document manifests. No input parameters (`ptr`/`len` are ignored).
+     *
+     * On success encodes a `u32 count` followed by each `DocumentManifest` into
+     * the return slot and returns 0. On error writes an error message and returns -1.
+     * @param {number} _ptr
+     * @param {number} _len
+     * @returns {number}
+     */
+    function db_list_documents(_ptr, _len) {
+        const ret = wasm.db_list_documents(_ptr, _len);
+        return ret;
+    }
+    exports.db_list_documents = db_list_documents;
+
+    /**
+     * Lists all section records. No input parameters (`ptr`/`len` are ignored).
+     *
+     * On success encodes a `u32 count` followed by each `SectionRecord` into the
+     * return slot and returns 0. On error writes an error message and returns -1.
+     * @param {number} _ptr
+     * @param {number} _len
+     * @returns {number}
+     */
+    function db_list_sections(_ptr, _len) {
+        const ret = wasm.db_list_sections(_ptr, _len);
+        return ret;
+    }
+    exports.db_list_sections = db_list_sections;
+
+    /**
+     * Executes a query plan against the loaded indexes.
+     * `ptr`/`len` point to an encoded `QueryPlan`.
+     * On success writes encoded `Vec<RawMatch>` to the return slot.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_query(ptr, len) {
+        const ret = wasm.db_query(ptr, len);
+        return ret;
+    }
+    exports.db_query = db_query;
+
+    /**
+     * Reads the catalog. Returns 0 on success.
+     * On success the serialised catalog TOML text is in the return slot.
+     * @param {number} _ptr
+     * @param {number} _len
+     * @returns {number}
+     */
+    function db_read_catalog(_ptr, _len) {
+        const ret = wasm.db_read_catalog(_ptr, _len);
+        return ret;
+    }
+    exports.db_read_catalog = db_read_catalog;
+
+    /**
+     * Reads corpus statistics from `<ctx>/corpus.bin`.
+     * On success places encoded `CorpusStats` bytes in the return slot.
+     * @param {number} _ptr
+     * @param {number} _len
+     * @returns {number}
+     */
+    function db_read_corpus_stats(_ptr, _len) {
+        const ret = wasm.db_read_corpus_stats(_ptr, _len);
+        return ret;
+    }
+    exports.db_read_corpus_stats = db_read_corpus_stats;
+
+    /**
+     * Reads a document manifest. `ptr`/`len` point to a UTF-8 docid string.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_read_document(ptr, len) {
+        const ret = wasm.db_read_document(ptr, len);
+        return ret;
+    }
+    exports.db_read_document = db_read_document;
+
+    /**
+     * Reads a section by kbid. `ptr`/`len` point to a UTF-8 kbid string.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_read_section(ptr, len) {
+        const ret = wasm.db_read_section(ptr, len);
+        return ret;
+    }
+    exports.db_read_section = db_read_section;
+
+    /**
+     * Reads multiple sections. `ptr`/`len` point to encoded `Vec<KbId>` (count + kbids).
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_read_sections(ptr, len) {
+        const ret = wasm.db_read_sections(ptr, len);
+        return ret;
+    }
+    exports.db_read_sections = db_read_sections;
+
+    /**
+     * Rebuilds indexes from scratch.
+     *
+     * Clears the existing inverted and positional indexes, then drives the
+     * section-scan rebuild loop. Full per-field tokenization is handled by
+     * `kb-worker.wasm` orchestration; this function provides the read-pass
+     * scaffolding and the final index write.
+     * @param {number} _ptr
+     * @param {number} _len
+     * @returns {number}
+     */
+    function db_rebuild_index(_ptr, _len) {
+        const ret = wasm.db_rebuild_index(_ptr, _len);
+        return ret;
+    }
+    exports.db_rebuild_index = db_rebuild_index;
+
+    /**
+     * Removes a document manifest. `ptr`/`len` point to a UTF-8 docid string.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_remove_document(ptr, len) {
+        const ret = wasm.db_remove_document(ptr, len);
+        return ret;
+    }
+    exports.db_remove_document = db_remove_document;
+
+    /**
+     * Removes a section's entries from the indexes.
+     * `ptr`/`len` point to a UTF-8 kbid string.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_remove_from_index(ptr, len) {
+        const ret = wasm.db_remove_from_index(ptr, len);
+        return ret;
+    }
+    exports.db_remove_from_index = db_remove_from_index;
+
+    /**
+     * Removes a section by kbid. `ptr`/`len` point to a UTF-8 kbid string.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_remove_section(ptr, len) {
+        const ret = wasm.db_remove_section(ptr, len);
+        return ret;
+    }
+    exports.db_remove_section = db_remove_section;
+
+    /**
+     * Updates a section. `ptr`/`len` point to encoded (old_kbid_str, AddSectionParams).
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_update_section(ptr, len) {
+        const ret = wasm.db_update_section(ptr, len);
+        return ret;
+    }
+    exports.db_update_section = db_update_section;
+
+    /**
+     * Writes/updates the catalog. `ptr`/`len` point to encoded catalog TOML text.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_write_catalog(ptr, len) {
+        const ret = wasm.db_write_catalog(ptr, len);
+        return ret;
+    }
+    exports.db_write_catalog = db_write_catalog;
+
+    /**
+     * Writes corpus statistics to `<ctx>/corpus.bin`.
+     * `ptr`/`len` point to 12 bytes of encoded `CorpusStats`.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_write_corpus_stats(ptr, len) {
+        const ret = wasm.db_write_corpus_stats(ptr, len);
+        return ret;
+    }
+    exports.db_write_corpus_stats = db_write_corpus_stats;
+
+    /**
+     * Writes a document manifest. `ptr`/`len` point to an encoded `DocumentManifest`.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_write_document(ptr, len) {
+        const ret = wasm.db_write_document(ptr, len);
+        return ret;
+    }
+    exports.db_write_document = db_write_document;
+
+    /**
+     * Clear all entries from the query cache. Returns 1 always.
+     * @returns {number}
+     */
+    function qp_cache_clear() {
+        const ret = wasm.qp_cache_clear();
+        return ret >>> 0;
+    }
+    exports.qp_cache_clear = qp_cache_clear;
+
+    /**
+     * Retrieve the bytes cached under the UTF-8 key at `(ptr, len)`.
+     *
+     * On hit: writes the bytes via `set_return` and returns 1.
+     * On miss: calls `set_return(null, 0)` and returns 0.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_cache_get(ptr, len) {
+        const ret = wasm.qp_cache_get(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_cache_get = qp_cache_get;
+
+    /**
+     * Cache the bytes at `(val_ptr, val_len)` under the UTF-8 key at
+     * `(key_ptr, key_len)`.  Returns 1 always.
+     * @param {number} key_ptr
+     * @param {number} key_len
+     * @param {number} val_ptr
+     * @param {number} val_len
+     * @returns {number}
+     */
+    function qp_cache_insert(key_ptr, key_len, val_ptr, val_len) {
+        const ret = wasm.qp_cache_insert(key_ptr, key_len, val_ptr, val_len);
+        return ret >>> 0;
+    }
+    exports.qp_cache_insert = qp_cache_insert;
+
+    /**
+     * Compute per-field TF values from raw field occurrence and token counts.
+     *
+     * The buffer at `(ptr, len)` contains:
+     * - u32 heading_count, u32 body_count, u32 code_count
+     * - u32 heading_tokens, u32 body_tokens, u32 code_tokens
+     *
+     * The result is 3 × f32 (heading_tf, body_tf, code_tf) written via
+     * `set_return`. Returns 1 on success, 0 if buffer is too short.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_compute_field_tf(ptr, len) {
+        const ret = wasm.qp_compute_field_tf(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_compute_field_tf = qp_compute_field_tf;
+
+    /**
+     * Compute TF-IDF for a term.
+     *
+     * The buffer at `(ptr, len)` contains:
+     * - u32 term_count   (occurrences in document)
+     * - u32 total_terms  (all terms in document)
+     * - u32 doc_freq     (documents containing the term)
+     * - u32 total_docs   (documents in corpus)
+     *
+     * The result is a single f32 TF-IDF score written via `set_return`.
+     * Returns 1 on success, 0 if the buffer is too short.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_compute_tfidf(ptr, len) {
+        const ret = wasm.qp_compute_tfidf(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_compute_tfidf = qp_compute_tfidf;
+
+    /**
+     * Extract keyphrases from the UTF-8 text at `(ptr, len)`.
+     *
+     * `n_top` — maximum number of keyphrases to return.
+     *
+     * Encodes result as:
+     * - u32 count
+     * - for each keyphrase: String phrase, f32 score
+     *
+     * Returns 1 on success, 0 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @param {number} n_top
+     * @returns {number}
+     */
+    function qp_extract_keyphrases(ptr, len, n_top) {
+        const ret = wasm.qp_extract_keyphrases(ptr, len, n_top);
+        return ret >>> 0;
+    }
+    exports.qp_extract_keyphrases = qp_extract_keyphrases;
+
+    /**
+     * Extract bigrams and trigrams from the token stream of the text at
+     * `(ptr, len)`.
+     *
+     * Encodes the result as:
+     * - u32 bigram count, then each bigram as a String
+     * - u32 trigram count, then each trigram as a String
+     *
+     * Returns 1 on success.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_extract_ngrams(ptr, len) {
+        const ret = wasm.qp_extract_ngrams(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_extract_ngrams = qp_extract_ngrams;
+
+    /**
+     * Parse the UTF-8 query string at `(ptr, len)` into a `QueryPlan`.
+     *
+     * The result is encoded using `QueryPlan`'s `Encode` implementation.
+     * Returns 1 on success, 0 on parse error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_parse_query(ptr, len) {
+        const ret = wasm.qp_parse_query(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_parse_query = qp_parse_query;
+
+    /**
+     * Compute BM25F score for all matched terms in a `RawMatch`.
+     *
+     * The buffer at `(ptr, len)` contains an encoded `RawMatch` followed
+     * immediately by an encoded `CorpusStats`. Default BM25F parameters are
+     * used (k1=1.2, b=0.75, heading=2.0, body=1.0, code=1.5).
+     *
+     * The result is a single f32 written via `set_return`.
+     * Returns 1 on success, 0 if the buffer cannot be decoded.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_score_bm25f(ptr, len) {
+        const ret = wasm.qp_score_bm25f(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_score_bm25f = qp_score_bm25f;
+
+    /**
+     * Compute BM25F score for a single term/field using explicit document frequency.
+     *
+     * Parameters are passed as a packed binary buffer at `(ptr, len)`:
+     * - f32 tf, u32 df, u32 total_docs, f32 avg_dl, f32 dl, f32 k1, f32 b
+     *
+     * The result is a single f32 written via `set_return`.
+     * Returns 1 on success, 0 if the buffer is too short.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_score_bm25f_field(ptr, len) {
+        const ret = wasm.qp_score_bm25f_field(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_score_bm25f_field = qp_score_bm25f_field;
+
+    /**
+     * Compute freshness weight.
+     *
+     * The buffer at `(ptr, len)` contains:
+     * - u64 created_at (ms)
+     * - u64 now (ms)
+     * - u64 half_life_ms
+     *
+     * Returns 1 on success, 0 if buffer is too short.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_score_freshness(ptr, len) {
+        const ret = wasm.qp_score_freshness(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_score_freshness = qp_score_freshness;
+
+    /**
+     * Compute a proximity score.
+     *
+     * The buffer at `(ptr, len)` contains:
+     * - u32 count of pairs
+     * - count × (u32 pos_a, u32 pos_b)
+     *
+     * Returns 1 on success, 0 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_score_proximity(ptr, len) {
+        const ret = wasm.qp_score_proximity(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_score_proximity = qp_score_proximity;
+
+    /**
+     * Apply zone weighting.
+     *
+     * The buffer at `(ptr, len)` contains:
+     * - u8 is_heading (0/1)
+     * - u8 is_first_para (0/1)
+     * - f32 base_score
+     *
+     * Returns 1 on success, 0 if buffer is too short.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_score_zone(ptr, len) {
+        const ret = wasm.qp_score_zone(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_score_zone = qp_score_zone;
+
+    /**
+     * Tokenise the UTF-8 text at `(ptr, len)`.
+     *
+     * Encodes the result as a length-prefixed list of `(original, stemmed,
+     * position)` records using the shared binary encoding:
+     * - u32 count
+     * - for each token: String original, String stemmed, u32 position
+     *
+     * Returns 1 on success, 0 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function qp_tokenize(ptr, len) {
+        const ret = wasm.qp_tokenize(ptr, len);
+        return ret >>> 0;
+    }
+    exports.qp_tokenize = qp_tokenize;
+
+    /**
+     * Return the crate version string.
+     * @returns {string}
+     */
+    function version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.version(retptr);
+            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_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    exports.version = version;
+
+    /**
+     * Adds a section. Returns 0 on success, -1 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_add_section(ptr, len) {
+        const ret = wasm.worker_add_section(ptr, len);
+        return ret;
+    }
+    exports.worker_add_section = worker_add_section;
+
+    /**
+     * Runs a database integrity check.
+     * @returns {number}
+     */
+    function worker_check_integrity() {
+        const ret = wasm.worker_check_integrity();
+        return ret;
+    }
+    exports.worker_check_integrity = worker_check_integrity;
+
+    /**
+     * Composes a Markdown document from an ordered list of identifiers.
+     *
+     * The identifier list is encoded as `u32 count + String` entries in shared
+     * memory at `(ptr, len)`. Each identifier is tried first as a kbid (section),
+     * then as a docid (document). Missing identifiers are silently skipped.
+     *
+     * On success the composed markdown and total character count are encoded into
+     * the return slot (String markdown + u64 total_chars), and 0 is returned.
+     * On error -1 is returned and an error message is in the return slot.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_compose(ptr, len) {
+        const ret = wasm.worker_compose(ptr, len);
+        return ret;
+    }
+    exports.worker_compose = worker_compose;
+
+    /**
+     * Runs garbage collection and invalidates all cache entries.
+     *
+     * After GC the set of valid sections may have changed; the whole cache is
+     * invalidated to prevent stale reads.
+     * @returns {number}
+     */
+    function worker_garbage_collect() {
+        const ret = wasm.worker_garbage_collect();
+        return ret;
+    }
+    exports.worker_garbage_collect = worker_garbage_collect;
+
+    /**
+     * Retrieves and removes the result for `token`.
+     *
+     * Result bytes are written to the return slot. Returns 0 on success, -1 if
+     * the token is not found or has an error.
+     * @param {number} token
+     * @returns {number}
+     */
+    function worker_get_result(token) {
+        const ret = wasm.worker_get_result(token);
+        return ret;
+    }
+    exports.worker_get_result = worker_get_result;
+
+    /**
+     * Creates a document grouping. Returns 0 on success, -1 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_group_sections(ptr, len) {
+        const ret = wasm.worker_group_sections(ptr, len);
+        return ret;
+    }
+    exports.worker_group_sections = worker_group_sections;
+
+    /**
+     * Initialises the worker context from an encoded config in shared memory.
+     *
+     * Format: UTF-8 context path string (the rest of the config uses defaults).
+     *
+     * Returns 0 on success, -1 on error (error message in return slot).
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_init(ptr, len) {
+        const ret = wasm.worker_init(ptr, len);
+        return ret;
+    }
+    exports.worker_init = worker_init;
+
+    /**
+     * Creates the full directory scaffold for a new database at `ptr`/`len` path.
+     *
+     * Delegates to `db_init_directory` in `kbdb-fs-database`. Does not require
+     * `worker_init` to have been called first.
+     *
+     * Returns 0 on success, -1 on error (message in return slot).
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_init_directory(ptr, len) {
+        const ret = wasm.worker_init_directory(ptr, len);
+        return ret;
+    }
+    exports.worker_init_directory = worker_init_directory;
+
+    /**
+     * Invalidates the cache entry for the kbid at `(ptr, len)`.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_invalidate(ptr, len) {
+        const ret = wasm.worker_invalidate(ptr, len);
+        return ret;
+    }
+    exports.worker_invalidate = worker_invalidate;
+
+    /**
+     * Clears all cache entries.
+     * @returns {number}
+     */
+    function worker_invalidate_all() {
+        const ret = wasm.worker_invalidate_all();
+        return ret;
+    }
+    exports.worker_invalidate_all = worker_invalidate_all;
+
+    /**
+     * Lists all sections whose `type_name` matches the UTF-8 string at `(ptr, len)`.
+     *
+     * On success encodes `u32 count + SectionRecord[]` into the return slot and
+     * returns 0. On error writes an error message and returns -1.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_list_by_type(ptr, len) {
+        const ret = wasm.worker_list_by_type(ptr, len);
+        return ret;
+    }
+    exports.worker_list_by_type = worker_list_by_type;
+
+    /**
+     * Lists all document manifests whose `doc_type` matches the UTF-8 string at
+     * `(ptr, len)`.
+     *
+     * On success encodes `u32 count + DocumentManifest[]` into the return slot and
+     * returns 0. On error writes an error message and returns -1.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_list_docs_by_type(ptr, len) {
+        const ret = wasm.worker_list_docs_by_type(ptr, len);
+        return ret;
+    }
+    exports.worker_list_docs_by_type = worker_list_docs_by_type;
+
+    /**
+     * Async query returning a token. The result can be polled via `worker_result_status`.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_query(ptr, len) {
+        const ret = wasm.worker_query(ptr, len);
+        return ret >>> 0;
+    }
+    exports.worker_query = worker_query;
+
+    /**
+     * Reads sections by kbid list. Returns 0 on success, -1 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_read_sections(ptr, len) {
+        const ret = wasm.worker_read_sections(ptr, len);
+        return ret;
+    }
+    exports.worker_read_sections = worker_read_sections;
+
+    /**
+     * Rebuilds all database indexes.
+     * @returns {number}
+     */
+    function worker_rebuild_indexes() {
+        const ret = wasm.worker_rebuild_indexes();
+        return ret;
+    }
+    exports.worker_rebuild_indexes = worker_rebuild_indexes;
+
+    /**
+     * Removes a document grouping. Returns 0 on success, -1 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_remove_grouping(ptr, len) {
+        const ret = wasm.worker_remove_grouping(ptr, len);
+        return ret;
+    }
+    exports.worker_remove_grouping = worker_remove_grouping;
+
+    /**
+     * Removes a section. Returns 0 on success, -1 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_remove_section(ptr, len) {
+        const ret = wasm.worker_remove_section(ptr, len);
+        return ret;
+    }
+    exports.worker_remove_section = worker_remove_section;
+
+    /**
+     * Returns a numeric status code for a token:
+     * - 0 = unknown token
+     * - 1 = pending
+     * - 2 = ready
+     * - 3 = error
+     * @param {number} token
+     * @returns {number}
+     */
+    function worker_result_status(token) {
+        const ret = wasm.worker_result_status(token);
+        return ret >>> 0;
+    }
+    exports.worker_result_status = worker_result_status;
+
+    /**
+     * Reads a document manifest. Returns 0 on success, -1 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_retrieve_doc(ptr, len) {
+        const ret = wasm.worker_retrieve_doc(ptr, len);
+        return ret;
+    }
+    exports.worker_retrieve_doc = worker_retrieve_doc;
+
+    /**
+     * Performs a search, returning an async result token.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_search(ptr, len) {
+        const ret = wasm.worker_search(ptr, len);
+        return ret >>> 0;
+    }
+    exports.worker_search = worker_search;
+
+    /**
+     * Returns worker status. Always returns 0.
+     *
+     * As a side effect, evicts any expired cache entries using the
+     * configured TTL. The status string is written to the return slot.
+     * @returns {number}
+     */
+    function worker_status() {
+        const ret = wasm.worker_status();
+        return ret;
+    }
+    exports.worker_status = worker_status;
+
+    /**
+     * Updates a section. Returns 0 on success, -1 on error.
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function worker_update_section(ptr, len) {
+        const ret = wasm.worker_update_section(ptr, len);
+        return ret;
+    }
+    exports.worker_update_section = worker_update_section;
+
+    /**
+     * Crate version.
+     * @returns {string}
+     */
+    function worker_version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.worker_version(retptr);
+            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_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    exports.worker_version = worker_version;
+    const import1 = require("env");
+    const import2 = require("env");
+    const import3 = require("env");
+    const import4 = require("env");
+    const import5 = require("env");
+    const import6 = require("env");
+
+    function __wbg_get_imports() {
+        const import0 = {
+            __proto__: null,
+        };
+        return {
+            __proto__: null,
+            "./kbdb_worker_bg.js": import0,
+            "env": import1,
+            "env": import2,
+            "env": import3,
+            "env": import4,
+            "env": import5,
+            "env": import6,
+        };
+    }
+
+    let cachedDataViewMemory0 = null;
+    function getDataViewMemory0() {
+        if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+            cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+        }
+        return cachedDataViewMemory0;
+    }
+
+    function getStringFromWasm0(ptr, len) {
+        return decodeText(ptr >>> 0, len);
+    }
+
+    let cachedUint8ArrayMemory0 = null;
+    function getUint8ArrayMemory0() {
+        if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+            cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+        }
+        return cachedUint8ArrayMemory0;
+    }
+
+    let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    function decodeText(ptr, len) {
+        return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    }
+
+    let wasmModule, wasmInstance, wasm;
+    function __wbg_finalize_init(instance, module) {
+        wasmInstance = instance;
+        wasm = instance.exports;
+        wasmModule = module;
+        cachedDataViewMemory0 = null;
+        cachedUint8ArrayMemory0 = null;
+        return wasm;
+    }
+
+    async function __wbg_load(module, imports) {
+        if (typeof Response === 'function' && module instanceof Response) {
+            if (typeof WebAssembly.instantiateStreaming === 'function') {
+                try {
+                    return await WebAssembly.instantiateStreaming(module, imports);
+                } catch (e) {
+                    const validResponse = module.ok && expectedResponseType(module.type);
+
+                    if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                        console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                    } else { throw e; }
+                }
+            }
+
+            const bytes = await module.arrayBuffer();
+            return await WebAssembly.instantiate(bytes, imports);
+        } else {
+            const instance = await WebAssembly.instantiate(module, imports);
+
+            if (instance instanceof WebAssembly.Instance) {
+                return { instance, module };
+            } else {
+                return instance;
+            }
+        }
+
+        function expectedResponseType(type) {
+            switch (type) {
+                case 'basic': case 'cors': case 'default': return true;
+            }
+            return false;
+        }
+    }
+
+    function initSync(module) {
+        if (wasm !== undefined) return wasm;
+
+
+        if (module !== undefined) {
+            if (Object.getPrototypeOf(module) === Object.prototype) {
+                ({module} = module)
+            } else {
+                console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+            }
+        }
+
+        const imports = __wbg_get_imports();
+        if (!(module instanceof WebAssembly.Module)) {
+            module = new WebAssembly.Module(module);
+        }
+        const instance = new WebAssembly.Instance(module, imports);
+        return __wbg_finalize_init(instance, module);
+    }
+
+    async function __wbg_init(module_or_path) {
+        if (wasm !== undefined) return wasm;
+
+
+        if (module_or_path !== undefined) {
+            if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+                ({module_or_path} = module_or_path)
+            } else {
+                console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+            }
+        }
+
+        if (module_or_path === undefined && script_src !== undefined) {
+            module_or_path = script_src.replace(/\.js$/, "_bg.wasm");
+        }
+        const imports = __wbg_get_imports();
+
+        if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+            module_or_path = fetch(module_or_path);
+        }
+
+        const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+        return __wbg_finalize_init(instance, module);
+    }
+
+    return Object.assign(__wbg_init, { initSync }, exports);
+})({ __proto__: null });