@dikolab/kbdb 0.2.2 → 0.3.1

package/dist/src/shared/worker-daemon/functions/dispatch-request.function.d.ts

@@ -0,0 +1,35 @@
+import type { DaemonConfig } from '../typings/daemon-config.interface.ts';
+import type { HandlerContext } from '../typings/handler-context.interface.ts';
+import type { WriteLockState } from '../typings/write-lock.interface.ts';
+/** Daemon status information returned by `status` and `idle_at`. */
+interface DaemonStatus {
+    /** Whether the daemon is currently serving connections. */
+    readonly status: 'busy' | 'idle';
+    /** Whether the startup integrity check passed. */
+    readonly integrityOk: boolean;
+    /** Integrity errors found at startup, if any. */
+    readonly integrityErrors: string[];
+    /** Unix timestamp (seconds) of the last completed request. */
+    readonly idleAt: number;
+}
+/**
+ * Dispatches an IPC method to its handler.
+ *
+ * Routes daemon-state methods inline and delegates WASM read/write
+ * operations to their respective handler functions. Write operations
+ * are serialised through the single-writer lock.
+ *
+ * @param method - IPC method name
+ * @param params - request parameters
+ * @param ctx - handler context (WASM modules, config, targetDir)
+ * @param daemonStatus - live daemon state read by the `status` method
+ * @param writeLock - shared write-lock state
+ */
+export declare function dispatchRequest(method: string, params: Record<string, unknown>, ctx: HandlerContext, daemonStatus: DaemonStatus, writeLock: WriteLockState): Promise<unknown>;
+/**
+ * Re-export `DaemonConfig` so callers can pass strongly-typed
+ * config without an extra import.
+ *
+ * @internal
+ */
+export type { DaemonConfig };

package/dist/src/shared/worker-daemon/functions/handle-check-version.function.d.ts

@@ -0,0 +1,23 @@
+/** Payload returned by the `checkVersion` IPC method. */
+interface VersionCheckResult {
+    /** Compatibility status string. */
+    readonly status: string;
+    /** Format version stored in the catalog. */
+    readonly currentVersion: number;
+    /** Format version required by the current engine. */
+    readonly requiredVersion: number;
+}
+/**
+ * Handles the `checkVersion` IPC method.
+ *
+ * Reads `catalog.toml` at `targetPath` and compares its format
+ * version to `DB_FORMAT_VERSION`. Returns a result object without
+ * making any modifications.
+ *
+ * @param targetPath - absolute path to the `.kbdb` directory to
+ *   inspect; falls back to `defaultDir` when not provided in params
+ * @param defaultDir - fallback directory when `params.targetPath`
+ *   is absent
+ */
+export declare function handleCheckVersion(params: Record<string, unknown>, defaultDir: string): VersionCheckResult;
+export {};

package/dist/src/shared/worker-daemon/functions/handle-config-method.function.d.ts

@@ -0,0 +1,11 @@
+import type { DaemonConfig } from '../typings/daemon-config.interface.ts';
+/**
+ * Handles `config_{key}` IPC methods by returning the corresponding
+ * `DaemonConfig` field value.
+ *
+ * @param method - the full method name, e.g. `config_timeout_ms`
+ * @param config - parsed daemon configuration
+ * @throws {IpcError} with code `-32601` when the key suffix is not
+ *   in `CONFIG_KEY_MAP`
+ */
+export declare function handleConfigMethod(method: string, config: DaemonConfig): unknown;

package/dist/src/shared/worker-daemon/functions/handle-read-ops.function.d.ts

@@ -0,0 +1,52 @@
+import type { HandlerContext } from '../typings/handler-context.interface.ts';
+/**
+ * Handles `search` and `query` IPC methods.
+ *
+ * Encodes parameters, invokes the `worker_search` token pipeline,
+ * waits synchronously for the result, and decodes the paged result.
+ */
+export declare function handleSearch(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `get_result_status` IPC method.
+ */
+export declare function handleResultStatus(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `get_result` IPC method.
+ */
+export declare function handleGetResult(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `readSections` IPC method.
+ */
+export declare function handleReadSections(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `retrieveDocument` IPC method.
+ */
+export declare function handleRetrieveDoc(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `content` and `compose` IPC methods.
+ */
+export declare function handleCompose(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `integrityCheck` IPC method.
+ */
+export declare function handleIntegrityCheck(ctx: HandlerContext): unknown;
+/**
+ * Handles the `dbStatus` IPC method.
+ */
+export declare function handleDbStatus(ctx: HandlerContext): unknown;
+/**
+ * Handles the `listByType` IPC method.
+ */
+export declare function handleListByType(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `listDocumentsByType` IPC method.
+ */
+export declare function handleListDocsByType(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `recall` IPC method.
+ */
+export declare function handleRecall(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `export` and `exportDb` IPC methods.
+ */
+export declare function handleExport(ctx: HandlerContext, params: Record<string, unknown>): unknown;

package/dist/src/shared/worker-daemon/functions/handle-write-ops.function.d.ts

@@ -0,0 +1,44 @@
+import type { HandlerContext } from '../typings/handler-context.interface.ts';
+/**
+ * Handles the `addSection` IPC method.
+ *
+ * Encodes the section input, delegates to `worker_add_section`, and
+ * runs a near-duplicate scan when the WASM result reports none.
+ */
+export declare function handleAddSection(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `updateSection` IPC method.
+ */
+export declare function handleUpdateSection(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `removeSection` IPC method.
+ */
+export declare function handleRemoveSection(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `groupSections` IPC method.
+ */
+export declare function handleGroupSections(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `removeGrouping` IPC method.
+ */
+export declare function handleRemoveGrouping(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `initDirectory` IPC method.
+ */
+export declare function handleInitDirectory(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `invalidate` IPC method.
+ */
+export declare function handleInvalidate(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `invalidateAll` IPC method.
+ */
+export declare function handleInvalidateAll(ctx: HandlerContext): unknown;
+/**
+ * Handles the `gc` IPC method.
+ */
+export declare function handleGc(ctx: HandlerContext): unknown;
+/**
+ * Handles the `rebuildIndexes` IPC method.
+ */
+export declare function handleRebuild(ctx: HandlerContext): unknown;

package/dist/src/shared/worker-daemon/functions/parse-auto-capture-section.function.d.ts

@@ -0,0 +1,14 @@
+import type { AutoCaptureConfig } from '../../auto-capture/typings/auto-capture-config.interface.ts';
+/**
+ * Parses key-value pairs from an `[auto_capture]` TOML section
+ * into an `AutoCaptureConfig`.
+ *
+ * Recognised keys: `enabled`, `trigger_after_tool_calls`,
+ * `min_interval_ms`, `max_captures_per_session`, `dry_run`.
+ * Unknown keys are silently ignored. Falls back to
+ * `AUTO_CAPTURE_DEFAULTS` for any absent key.
+ *
+ * @param entries - key-value pairs from inside the
+ *   `[auto_capture]` section
+ */
+export declare function parseAutoCaptureSection(entries: ReadonlyMap<string, string>): AutoCaptureConfig;

package/dist/src/shared/worker-daemon/functions/parse-catalog-version.function.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parses the `version` field from a minimal TOML string.
+ *
+ * Supports only `version = <integer>` syntax. Comment lines are
+ * skipped. Returns `null` when no `version` field is present.
+ *
+ * @param text - raw TOML text from `catalog.toml`
+ * @returns the integer version, or `null` if absent
+ */
+export declare function parseCatalogVersion(text: string): number | null;

package/dist/src/shared/worker-daemon/functions/parse-embedding-section.function.d.ts

@@ -0,0 +1,13 @@
+import type { EmbeddingConfig } from '../../embedding/typings/embedding-config.interface.ts';
+/**
+ * Parses key-value pairs from a `[embedding]` TOML section into an
+ * `EmbeddingConfig`.
+ *
+ * Recognises: `provider`, `model`, `endpoint`, `dimensions`.
+ * Unknown keys are silently ignored. Returns `undefined` when the
+ * `provider` key is absent from the supplied entries.
+ *
+ * @param entries - key-value pairs from inside the `[embedding]`
+ *   section
+ */
+export declare function parseEmbeddingSection(entries: ReadonlyMap<string, string>): EmbeddingConfig | undefined;

package/dist/src/shared/worker-daemon/functions/parse-worker-toml.function.d.ts

@@ -0,0 +1,11 @@
+import type { DaemonConfig } from '../typings/daemon-config.interface.ts';
+/**
+ * Parses a `worker.toml` file body into a partial `DaemonConfig`.
+ *
+ * Handles `[embedding]` sub-sections and root key-value pairs.
+ * Unknown keys are silently ignored.
+ *
+ * @param text - raw content of `worker.toml`
+ * @param contextPath - daemon context directory path
+ */
+export declare function parseWorkerToml(text: string, contextPath: string): DaemonConfig;

package/dist/src/shared/worker-daemon/functions/run-startup-integrity-check.function.d.ts

@@ -0,0 +1,18 @@
+import type { WasmModules } from '../typings/wasm-modules.interface.ts';
+/** Result of a startup integrity check. */
+export interface StartupIntegrityResult {
+    /** Whether the check passed without errors. */
+    readonly integrityOk: boolean;
+    /** Integrity error descriptions found at startup. */
+    readonly integrityErrors: string[];
+}
+/**
+ * Runs `worker_check_integrity` immediately after WASM context
+ * initialisation and returns the result.
+ *
+ * Logs a warning to stderr when issues are found. Never throws --
+ * failures are captured and returned as part of the result.
+ *
+ * @param modules - loaded WASM module instances
+ */
+export declare function runStartupIntegrityCheck(modules: WasmModules): StartupIntegrityResult;

package/dist/src/shared/worker-daemon/functions/scan-near-duplicates.function.d.ts

@@ -0,0 +1,21 @@
+/** A near-duplicate match found during add-section scanning. */
+export interface NearDuplicateMatch {
+    /** Knowledge-base identifier of the near-duplicate section. */
+    readonly kbid: string;
+    /** Jaccard similarity score, rounded to 2 decimal places (0–1). */
+    readonly similarity: number;
+}
+/**
+ * Scans existing section files for near-duplicates of `content`.
+ *
+ * Uses Jaccard similarity on a set of lowercased tokens (3+ chars)
+ * extracted from the section body. Sections with a similarity of
+ * 0.85 or above are included in the result. The `newKbid` section
+ * is excluded from comparison.
+ *
+ * @param targetDir - absolute path to the `.kbdb` directory
+ * @param content - raw text content of the newly added section
+ * @param newKbid - identifier of the just-added section to exclude
+ * @returns near-duplicate matches sorted by insertion order
+ */
+export declare function scanNearDuplicates(targetDir: string, content: string, newKbid: string): NearDuplicateMatch[];

package/dist/src/shared/worker-daemon/functions/wasm-bridge.function.d.ts

@@ -0,0 +1,51 @@
+import type { WasmModules } from '../typings/wasm-modules.interface.ts';
+import type { WasmFn } from '../typings/wasm-fn.type.ts';
+/**
+ * Retrieves a named export from the kb-worker WASM instance.
+ *
+ * @throws {Error} if WASM modules are not yet loaded
+ * @throws {Error} if the named export does not exist or is not a
+ *   function
+ */
+export declare function getWasmExport(modules: WasmModules, name: string): WasmFn;
+/**
+ * Allocates `size` bytes in WASM linear memory.
+ *
+ * Returns `0` when `size` is zero or the allocator export is
+ * absent.
+ */
+export declare function wasmAlloc(modules: WasmModules, size: number): number;
+/**
+ * Frees a previously allocated WASM memory region.
+ *
+ * No-ops when `ptr` or `size` is zero, or when the free export
+ * is absent.
+ */
+export declare function wasmFree(modules: WasmModules, ptr: number, size: number): void;
+/**
+ * Writes `data` into WASM linear memory at `ptr`.
+ *
+ * @throws {Error} if the write would exceed memory bounds
+ */
+export declare function wasmWrite(modules: WasmModules, ptr: number, data: Uint8Array): void;
+/**
+ * Reads the WASM return slot, frees the underlying buffer, and
+ * returns its contents as a `Uint8Array`.
+ *
+ * Returns an empty array when the slot is unset or memory is
+ * unavailable.
+ */
+export declare function readReturnSlot(modules: WasmModules): Uint8Array;
+/**
+ * Calls a WASM export with binary-encoded input via the
+ * alloc/write/call/read/free protocol.
+ *
+ * @throws {IpcError} when the export returns `-1` (error sentinel)
+ */
+export declare function callWasmSync(modules: WasmModules, exportName: string, input: Uint8Array): Uint8Array;
+/**
+ * Calls a zero-argument WASM export and checks its return code.
+ *
+ * @throws {IpcError} when the export returns `-1` (error sentinel)
+ */
+export declare function callWasmZeroArg(modules: WasmModules, exportName: string): void;

package/dist/src/shared/worker-daemon/functions/wasm-memory-helpers.function.d.ts

@@ -0,0 +1,22 @@
+import type { MemoryRef } from '../typings/memory-ref.interface.ts';
+/**
+ * Returns the current `ArrayBuffer` backing WASM linear memory.
+ *
+ * Must be called after WASM module instantiation. The buffer
+ * reference may change after WASM memory growth, so callers
+ * should call this function each time they need a fresh view.
+ *
+ * @param memoryRef - deferred reference to WASM linear memory
+ * @throws {Error} when memory is not yet initialised
+ */
+export declare function getWasmBuffer(memoryRef: MemoryRef): ArrayBuffer;
+/**
+ * Decodes a UTF-8 path from WASM linear memory and resolves it
+ * relative to `contextPath` when the path is not absolute.
+ *
+ * @param memoryRef - deferred reference to WASM linear memory
+ * @param contextPath - base directory for relative paths
+ * @param ptr - byte offset of the path string in WASM memory
+ * @param len - byte length of the path string
+ */
+export declare function readWasmPathArg(memoryRef: MemoryRef, contextPath: string, ptr: number, len: number): string;

package/dist/src/shared/worker-daemon/functions/write-lock.function.d.ts

@@ -0,0 +1,32 @@
+import type { WriteLockState } from '../typings/write-lock.interface.ts';
+/**
+ * Acquires the single-writer lock.
+ *
+ * Enforces the single-writer guarantee: at most one write
+ * operation runs at a time inside the daemon. Concurrent writes
+ * are serialized through an in-memory FIFO queue -- each caller
+ * awaits this function and proceeds only when it is at the head
+ * of the queue. Read operations bypass this lock entirely and
+ * may proceed concurrently with writes and with each other.
+ *
+ * Crash recovery: the lock is purely in-memory. If the daemon
+ * process crashes mid-write, the OS reclaims process memory,
+ * releasing the lock automatically. The WASM engine is
+ * responsible for leaving on-disk state consistent (it uses
+ * atomic rename: write to a `.tmp` file, then `host_rename` to
+ * the final path).
+ *
+ * @param state - shared write-lock state
+ */
+export declare function acquireWriteLock(state: WriteLockState): Promise<void>;
+/**
+ * Releases the single-writer lock.
+ *
+ * Grants the lock to the next queued waiter if one exists;
+ * otherwise marks the lock as free. Must always be called in a
+ * `finally` block after `acquireWriteLock` to prevent permanent
+ * lock starvation.
+ *
+ * @param state - shared write-lock state
+ */
+export declare function releaseWriteLock(state: WriteLockState): void;

package/dist/src/shared/worker-daemon/typings/allocator-ref.interface.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A mutable reference to the WASM allocator function.
+ *
+ * The `alloc` field starts as `null` and is wired up after the
+ * `kb-worker` WASM module is instantiated. Host import functions
+ * that must allocate memory in WASM linear memory check this
+ * reference before proceeding and return `-1` when it is null.
+ */
+export interface AllocatorRef {
+    /**
+     * Allocates `size` bytes in WASM linear memory and returns the
+     * byte offset of the allocated region, or `null` when the
+     * allocator is not yet available.
+     */
+    alloc: ((size: number) => number) | null;
+}

package/dist/src/shared/worker-daemon/typings/daemon-config.interface.d.ts

@@ -1,3 +1,5 @@
+import type { EmbeddingConfig } from '../../embedding/typings/embedding-config.interface.ts';
+import type { AutoCaptureConfig } from '../../auto-capture/typings/auto-capture-config.interface.ts';
 /** Configuration for the worker daemon process. */
 export interface DaemonConfig {
     /** Absolute path to the knowledge-base context directory. */
@@ -10,4 +12,8 @@ export interface DaemonConfig {
     readonly timeoutMs: number;
     /** Time-to-live in milliseconds for each cached item. */
     readonly itemTtlMs: number;
+    /** Embedding provider configuration. */
+    readonly embedding?: EmbeddingConfig;
+    /** Auto-capture behaviour configuration. */
+    readonly autoCapture?: AutoCaptureConfig;
 }

package/dist/src/shared/worker-daemon/typings/fs-adapter.interface.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Minimal filesystem operations required by the WASM host imports.
+ *
+ * The default implementation delegates to `node:fs` synchronous
+ * APIs. Tests inject a stub to avoid touching the real filesystem.
+ */
+export interface FsAdapter {
+    /** Read entire file as a Buffer. */
+    readFileSync(path: string): Buffer;
+    /** Write data buffer to file. */
+    writeFileSync(path: string, data: Uint8Array): void;
+    /** Rename `oldPath` to `newPath`. */
+    renameSync(oldPath: string, newPath: string): void;
+    /** Delete a file. */
+    unlinkSync(path: string): void;
+    /** List directory entries as strings. */
+    readdirSync(path: string): string[];
+    /** Create a directory (and parents) recursively. */
+    mkdirSync(path: string): void;
+    /** Return true if the path exists. */
+    existsSync(path: string): boolean;
+}

package/dist/src/shared/worker-daemon/typings/handler-context.interface.d.ts

@@ -0,0 +1,18 @@
+import type { DaemonConfig } from './daemon-config.interface.ts';
+import type { WasmModules } from './wasm-modules.interface.ts';
+/**
+ * Runtime context passed to all IPC request handler functions.
+ *
+ * Groups the minimal shared state needed by every request handler
+ * so that handler functions can be standalone (not methods on a
+ * class) while still accessing WASM modules, configuration, and
+ * the database directory path.
+ */
+export interface HandlerContext {
+    /** Absolute path to the `.kbdb` directory. */
+    readonly targetDir: string;
+    /** Parsed daemon configuration from `worker.toml`. */
+    readonly config: DaemonConfig;
+    /** Loaded WASM module instances. */
+    readonly modules: WasmModules;
+}

package/dist/src/shared/worker-daemon/typings/memory-ref.interface.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A mutable reference to the WASM linear memory.
+ *
+ * The `memory` field starts as `null` and is wired up after the
+ * `kb-worker` WASM module is instantiated (the module exports its
+ * own memory rather than importing one). Host import functions
+ * read `memory` at call time, not at creation time, so the ref
+ * can be populated after the import record is built.
+ */
+export interface MemoryRef {
+    /** WASM linear memory; `null` until the module is instantiated. */
+    memory: WebAssembly.Memory | null;
+}

package/dist/src/shared/worker-daemon/typings/wasm-fn.type.d.ts

@@ -0,0 +1,2 @@
+/** Callable WASM export function signature. */
+export type WasmFn = (...args: unknown[]) => unknown;

package/dist/src/shared/worker-daemon/typings/write-lock.interface.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Mutable state for the single-writer lock used by WorkerDaemon.
+ *
+ * Holds the current lock flag and the queue of pending waiters.
+ * Both fields are mutated by `acquireWriteLock` and
+ * `releaseWriteLock`.
+ */
+export interface WriteLockState {
+    /** Whether the write lock is currently held. */
+    locked: boolean;
+    /** Queue of resolve callbacks for pending lock waiters. */
+    queue: {
+        resolve: () => void;
+    }[];
+}

package/dist/wasm/fs-database/kbdb_fs_database.d.ts

@@ -5,7 +5,10 @@ declare namespace wasm_bindgen {
     /**
      * Adds a section. `ptr`/`len` point to an encoded `AddSectionParams`.
      *
-     * On success: writes encoded kbid string to return slot, returns 0.
+     * On success: writes an encoded `AddSectionResult` to the return slot and
+     * returns 0.  When `params.replace` is true and a section with the same
+     * `source_key` exists, the superseded section's index entries are removed
+     * and the returned `AddSectionResult.superseded` is set to its kbid.
      * On error: writes error message to return slot, returns -1.
      */
     export function db_add_section(ptr: number, len: number): number;
@@ -42,6 +45,23 @@ declare namespace wasm_bindgen {
      */
     export function db_check_version(ptr: number, len: number): number;
 
+    /**
+     * Exports the database to a target directory.
+     *
+     * `ptr`/`len` point to a UTF-8 string containing the target path.
+     *
+     * Copies `sections/`, `documents/`, and `catalog.toml` to the target.
+     * Indexes are not copied because they can be rebuilt from the data.
+     *
+     * The target path may be absolute or relative. It is an external output
+     * destination, not a database-internal path, so no path validation is
+     * applied to it.
+     *
+     * On success a summary string is placed in the return slot:
+     * `path={target}\nsections_exported={N}\ndocuments_exported={M}`
+     */
+    export function db_export(ptr: number, len: number): number;
+
     /**
      * Runs garbage collection. Returns 0 on success.
      * On success a summary string is placed in the return slot.
@@ -200,6 +220,7 @@ declare interface InitOutput {
     readonly db_add_to_index: (a: number, b: number) => number;
     readonly db_check_integrity: (a: number, b: number) => number;
     readonly db_check_version: (a: number, b: number) => number;
+    readonly db_export: (a: number, b: number) => number;
     readonly db_gc: (a: number, b: number) => number;
     readonly db_get_back_refs: (a: number, b: number) => number;
     readonly db_get_forward_refs: (a: number, b: number) => number;

package/dist/wasm/fs-database/kbdb_fs_database.js

@@ -7,7 +7,10 @@ let wasm_bindgen = (function(exports) {
     /**
      * Adds a section. `ptr`/`len` point to an encoded `AddSectionParams`.
      *
-     * On success: writes encoded kbid string to return slot, returns 0.
+     * On success: writes an encoded `AddSectionResult` to the return slot and
+     * returns 0.  When `params.replace` is true and a section with the same
+     * `source_key` exists, the superseded section's index entries are removed
+     * and the returned `AddSectionResult.superseded` is set to its kbid.
      * On error: writes error message to return slot, returns -1.
      * @param {number} ptr
      * @param {number} len
@@ -72,6 +75,30 @@ let wasm_bindgen = (function(exports) {
     }
     exports.db_check_version = db_check_version;
 
+    /**
+     * Exports the database to a target directory.
+     *
+     * `ptr`/`len` point to a UTF-8 string containing the target path.
+     *
+     * Copies `sections/`, `documents/`, and `catalog.toml` to the target.
+     * Indexes are not copied because they can be rebuilt from the data.
+     *
+     * The target path may be absolute or relative. It is an external output
+     * destination, not a database-internal path, so no path validation is
+     * applied to it.
+     *
+     * On success a summary string is placed in the return slot:
+     * `path={target}\nsections_exported={N}\ndocuments_exported={M}`
+     * @param {number} ptr
+     * @param {number} len
+     * @returns {number}
+     */
+    function db_export(ptr, len) {
+        const ret = wasm.db_export(ptr, len);
+        return ret;
+    }
+    exports.db_export = db_export;
+
     /**
      * Runs garbage collection. Returns 0 on success.
      * On success a summary string is placed in the return slot.

package/dist/wasm/fs-database/kbdb_fs_database_bg.wasm.d.ts

@@ -7,6 +7,7 @@ export const db_add_section: (a: number, b: number) => number;
 export const db_add_to_index: (a: number, b: number) => number;
 export const db_check_integrity: (a: number, b: number) => number;
 export const db_check_version: (a: number, b: number) => number;
+export const db_export: (a: number, b: number) => number;
 export const db_gc: (a: number, b: number) => number;
 export const db_get_back_refs: (a: number, b: number) => number;
 export const db_get_forward_refs: (a: number, b: number) => number;