@moltendb-web/core 0.1.0-alpha.10

package/LICENSE.md

@@ -0,0 +1,35 @@
+# MoltenDB License
+
+MoltenDB is dual-licensed:
+
+1. **Free for Startups & Personal Use:** Licensed under the Business Source License (BSL) 1.1 with an Additional Use Grant (see below).
+2. **Commercial/Enterprise Use:** For companies exceeding the revenue threshold, or companies wishing to provide MoltenDB as a managed cloud service, a commercial license is required. Contact: [maximilian.both27@outlook.com]
+
+---
+
+## Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+**Licensor:** Maximilian Both.
+**Licensed Work:** The MoltenDB source code and compiled binaries.
+**Change Date:** 3 years after the publication of each specific version/release.
+**Change License:** MIT License
+
+### Additional Use Grant
+
+You may make use of the Licensed Work (including running it in production) provided that your organization (including any parent companies, subsidiaries, and affiliates) meets **ALL** of the following conditions:
+
+1. **Revenue Limit:** Your organization's total annual gross revenue does not exceed $5,000,000 USD (or equivalent).
+2. **Not a Managed Service:** You do not offer the Licensed Work to third parties as a hosted or managed service (e.g., Database-as-a-Service, Backend-as-a-Service), regardless of your company's revenue.
+
+If you meet these conditions, the Licensor grants you a non-exclusive, royalty-free, worldwide license to reproduce, use, merge, publish, distribute, and modify the Licensed Work.
+
+If your organization exceeds the Revenue Limit, or if you wish to provide the Licensed Work as a managed service, you must purchase a Commercial License from the Licensor.
+
+### BSL General Terms
+
+If your use of the Licensed Work does not comply with the Additional Use Grant, you may still use the Licensed Work strictly for non-production, internal testing, and development purposes.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly available distribution of a specific version of the Licensed Work under this License, whichever comes first, the Licensor hereby grants you rights under the terms of the Change License (MIT License), and the terms of this Business Source License will terminate for that specific version.

package/README.md

@@ -0,0 +1,261 @@
+# MoltenDB Web
+
+<div align="center">
+  <img src="./dist/assets/logo.png" alt="MoltenDB Logo" width="64"/>
+
+  ### 🌋 The Embedded Database for the Modern Web
+  **High-performance Rust engine compiled to WASM. Persistent storage via OPFS.**
+
+  [Interactive Demo](https://stackblitz.com/~/github.com/maximilian27/moltendb-wasm-demo?file=package.json) • [Core Engine](https://www.npmjs.com/package/@moltendb-web/core) • [Query Builder](https://www.npmjs.com/package/@moltendb-web/query) • [Original Repository](https://github.com/maximilian27/MoltenDB) • [License](LICENSE.md)
+
+  [![NPM Version](https://img.shields.io/npm/v/@moltendb-web/core?style=flat-square&color=orange)](https://www.npmjs.com/package/@moltendb-web/core)
+  [![License](https://img.shields.io/badge/license-BSL%201.1-blue?style=flat-square)](LICENSE.md)
+  [![WASM](https://img.shields.io/badge/wasm-optimized-magenta?style=flat-square)](https://webassembly.org/)
+
+</div>
+
+---
+
+## What is MoltenDB Web?
+
+MoltenDB is a JSON document database written in Rust that runs directly in your browser. Unlike traditional browser databases limited by `localStorage` quotas or IndexedDB's complex API, MoltenDB leverages the **Origin Private File System (OPFS)** to provide a high-performance, append-only storage engine.
+
+### 🎮 Explore the Full Functionality
+
+The best way to experience MoltenDB is through the **[Interactive Demo on StackBlitz](https://stackblitz.com/~/github.com/maximilian27/moltendb-wasm-demo?file=package.json)**. It provides a complete, live environment where you can test query builder expressions, perform mutations, and see real-time events with zero local setup.
+
+Prefer to run it in your own environment? You can **[clone the demo repository](https://github.com/maximilian27/moltendb-wasm-demo)** to inspect the source code, run the explorers locally, and experiment with your own schema.
+
+**⚠️ Note for Online IDEs:** If you are viewing this on StackBlitz or CodeSandbox, the WASM engine may be blocked by iframe security restrictions. Please click the "Open in New Window/Tab" button in the preview pane to enable the full OPFS storage engine.
+
+### Core Features
+- **Pure Rust Engine:** The same query logic used in our server binary, compiled to WebAssembly.
+- **OPFS Persistence:** Data persists across page reloads in a dedicated, high-speed sandbox.
+- **Worker-Threaded:** The database runs entirely inside a Web Worker—zero impact on your UI thread.
+- **GraphQL-style Selection:** Request only the fields you need (even deeply nested ones) to save memory and CPU.
+- **Auto-Indexing:** The engine monitors your queries and automatically creates indexes for frequently filtered fields.
+- **Conflict Resolution:** Incoming writes with `_v ≤ stored _v` are silently skipped.
+- **Inline reference embedding (`extends`):** Embed data from another collection at insert time.
+
+---
+
+## Installation
+
+MoltenDB is split into two packages: the core engine and the type-safe, chainable query builder.
+
+```bash
+# Install the core engine and WASM artifacts
+npm install @moltendb-web/core
+
+# Install the chainable query builder
+npm install @moltendb-web/query
+```
+
+---
+
+# Quick Start
+1. Initialize the Client
+
+MoltenDB handles the Web Worker and WASM instantiation for you.
+TypeScript
+```ts
+import { MoltenDB } from '@moltendb-web/core';
+import { MoltenDBClient, WorkerTransport } from '@moltendb-web/query';
+
+const workerUrl = new URL('@moltendb-web/core/worker', import.meta.url).href;
+const db = new MoltenDB('moltendb_demo', { syncEnabled: false, workerUrl });
+await db.init();
+
+// Connect the query builder to the WASM worker
+const client = new MoltenDBClient(new WorkerTransport(db.worker));
+
+// 2. Insert and Query
+
+// Use the @moltendb-web/query builder for a type-safe experience. 
+
+// Insert data
+await client.collection('laptops').set({
+  lp1: {
+    brand: "Apple",
+      model: "MacBook Pro",
+      price: 1999,
+      in_stock: true,
+      memory_id: 'mem1',
+      specs: {
+        cpu: {
+          cores: 8,
+          clock_speed: 3.5,
+        },
+        display: {
+          refresh_hz: 60,
+        }
+      }
+  },
+  lp2: {
+    brand: "Apple",
+    model: "MacBook Air",
+    price: 900,
+    in_stock: true,
+      memory_id: 'mem2',
+      specs: {
+      cpu: {
+        cores: 4,
+        clock_speed: 3.5,
+      },
+      display: {
+        refresh_hz: 60,
+      }
+    }
+  }
+}).exec();
+
+await client.collection('memory').set({
+    mem1: { 
+      capacity_gb: 16,
+      type: 'DDR4',  
+      speed_mhz: 4800,
+      upgradeable: false  
+    },
+    mem2: {
+      capacity_gb: 64,
+      type: 'DDR5',  
+      speed_mhz: 5600,
+      upgradeable: true 
+    },
+}).exec();
+
+// Query with field selection
+const results = await client.collection('laptops')
+  .get()
+  .where({ brand: { $in: ["Apple", "Dell"] }, in_stock: true }) // Using $in operator
+  .fields(['model', 'price']) // Only return these specific fields
+  .sort([{ field: 'price', order: 'desc' }])
+  .exec();
+
+console.log(results); 
+// [
+//  {
+//    "_key": "lp1",
+//    "model": "MacBook Pro",
+//    "price": 1999
+//  },
+//  {
+//    "_key": "lp2",
+//    "model": "MacBook Air",
+//    "price": 900
+//  }
+// ]
+
+// Powerful Query Capabilities
+// GraphQL-style Field Selection
+
+// Never over-fetch data again. Use dot-notation to extract deeply nested values.
+
+await client.collection('laptops')
+  .get()
+  .fields(["brand", "specs.cpu.cores", "specs.display.refresh_hz"])
+  .exec();
+
+// Inline Joins
+
+// Resolve relationships between collections at query time.
+
+await client.collection('laptops')
+  .get()
+  .joins([{ 
+    alias: 'ram', 
+    from: 'memory', 
+    on: 'memory_id', 
+    fields: ['capacity_gb', 'type'] 
+  }])
+  .exec();
+
+// Supported Query Operators
+
+MoltenDB supports a variety of operators in the `where` clause:
+
+| Operator | Aliases | Description |
+|---|---|---|
+| `$eq` | `$equals` | Exact equality |
+| `$ne` | `$notEquals` | Not equal |
+| `$gt` | `$greaterThan` | Greater than (numeric) |
+| `$gte` | | Greater than or equal |
+| `$lt` | `$lessThan` | Less than (numeric) |
+| `$lte` | | Less than or equal |
+| `$contains` | `$ct` | Substring check (string) or membership check (array) |
+| `$in` | `$oneOf` | Field value is one of a list |
+| `$nin` | `$notIn` | Field value is not in a list |
+
+// Inline reference embedding (`extends`)
+
+The `extends` key embeds data from another collection directly into the stored document at insert time — no join needed on reads.
+
+```ts
+await client.collection('laptops')
+  .set({
+    lp7: {
+      brand: "MSI",
+      model: "Titan GT77",
+      price: 3299,
+    }
+  })
+  .extends({
+    ram: "memory.mem4",
+    screen: "display.dsp3"
+  })
+  .exec();
+```
+
+**When to use `extends` vs `joins`:**
+
+| | `extends` | `joins` |
+|---|---|---|
+| Resolved at | Insert time (once) | Query time (every request) |
+| Data freshness | Snapshot — may become stale | Always live |
+| Read cost | O(1) — data already embedded | O(1) per join per document |
+| Use when | Data rarely changes, fast reads matter | Data changes frequently, freshness matters |
+
+---
+## Storage Architecture
+
+### How the Log Works
+
+MoltenDB uses an append-only JSON log. Every write is a new line, ensuring your data is safe even if the tab is closed unexpectedly.
+
+- **Compaction:** When the log exceeds 5MB or 500 entries, the engine automatically "squashes" the log, removing old versions of documents to save space.
+- **Persistence:** All data is stored in the Origin Private File System (OPFS). This is a special file system for web apps that provides much higher performance than IndexedDB.
+
+### Performance Note
+
+Because MoltenDB uses OPFS, your browser must support `SharedArrayBuffer`. Most modern browsers support this, but your server must send the following headers:
+
+```http
+Cross-Origin-Opener-Policy: same-origin
+Cross-Origin-Embedder-Policy: require-corp
+```
+
+## Project Structure
+
+This monorepo contains the following packages:
+
+- **`packages/core`:** The core WASM engine, Web Worker logic, and the MoltenDB main client.
+- **`packages/query`:** The type-safe, chainable Query Builder.
+
+## Roadmap
+
+- [ ] **Multi-Tab Sync:** Leader election for multiple tabs to share a single OPFS instance.
+- [ ] **Delta Sync:** Automatic two-way sync with the MoltenDB Rust server.
+- [ ] **Analytics functionality:** Run analytics queries straight in the browser. 
+
+## License
+
+MoltenDB is licensed under the **Business Source License 1.1**.
+
+- Free for personal use and organizations with annual revenue under $5 million USD.
+- Converts to MIT automatically 3 years after each version's release date.
+
+For commercial licensing or questions: [maximilian.both27@outlook.com](mailto:maximilian.both27@outlook.com)
+
+---
+
+Created with 🌋 by Maximilian Both. Coming to the world on the Equinox.

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+export interface MoltenDBOptions {
+  /** URL or path to moltendb-worker.js. Defaults to './moltendb-worker.js'. */
+  workerUrl?: string | URL;
+  /** Enable WebSocket sync with a MoltenDB server. Default: false. */
+  syncEnabled?: boolean;
+  /** WebSocket server URL. Default: 'wss://localhost:3000/ws'. */
+  serverUrl?: string;
+  /** Sync batch flush interval in ms. Default: 5000. */
+  syncIntervalMs?: number;
+  /** JWT token for WebSocket authentication. */
+  authToken?: string;
+}
+
+export type SyncCallback = (update: {
+  event: 'change' | 'delete' | 'drop';
+  collection: string;
+  key: string;
+  new_v: number | null;
+}) => void;
+
+export class MoltenDB {
+  readonly dbName: string;
+  readonly worker: Worker | null;
+
+  constructor(dbName?: string, options?: MoltenDBOptions);
+
+  /** Initialise the Web Worker and open the OPFS database. */
+  init(): Promise<void>;
+
+  /** Send a raw message to the worker. */
+  sendMessage(action: string, params?: Record<string, unknown>): Promise<unknown>;
+
+  /** Insert / upsert one document. */
+  set(collection: string, key: string, value: Record<string, unknown>, options?: { skipSync?: boolean }): Promise<void>;
+
+  /** Fetch a single document by key. */
+  get(collection: string, key: string): Promise<unknown>;
+
+  /** Fetch all documents in a collection. */
+  getAll(collection: string): Promise<unknown>;
+
+  /** Delete a document by key. */
+  delete(collection: string, key: string, options?: { skipSync?: boolean }): Promise<void>;
+
+  /** Compact the OPFS log file. */
+  compact(): Promise<unknown>;
+
+  /** Subscribe to real-time server push events. Returns an unsubscribe function. */
+  onSync(callback: SyncCallback): () => void;
+
+  /** Close the WebSocket connection and stop the sync timer. */
+  disconnect(): void;
+
+  /** Terminate the Web Worker (and disconnect sync). */
+  terminate(): void;
+}

package/dist/index.js

@@ -0,0 +1,176 @@
+/**
+ * MoltenDB main-thread client.
+ *
+ * Usage:
+ *   import { MoltenDB } from 'moltendb-wasm';
+ *
+ *   const db = new MoltenDB('my-db', {
+ *     // Required: URL or path to the moltendb-worker.js file.
+ *     // With a bundler:  new URL('moltendb-wasm/worker', import.meta.url)
+ *     // Plain script:    '/node_modules/moltendb-wasm/dist/moltendb-worker.js'
+ *     workerUrl: new URL('moltendb-wasm/worker', import.meta.url),
+ *   });
+ *   await db.init();
+ */
+export class MoltenDB {
+    /**
+     * @param {string} dbName - OPFS file name (unique per database).
+     * @param {object} [options]
+     * @param {string|URL} [options.workerUrl] - URL to moltendb-worker.js.
+     *   Defaults to './moltendb-worker.js' (works when served from the same directory).
+     * @param {boolean} [options.syncEnabled=false] - Enable WebSocket sync.
+     * @param {string}  [options.serverUrl='wss://localhost:3000/ws'] - WS server URL.
+     * @param {number}  [options.syncIntervalMs=5000] - Sync batch flush interval.
+     * @param {string}  [options.authToken] - JWT token for WS authentication.
+     */
+    constructor(dbName = 'moltendb', options = {}) {
+        this.dbName         = dbName;
+        this.workerUrl      = options.workerUrl ?? './moltendb-worker.js';
+        this.worker         = null;
+        this.messageId      = 0;
+        this.pendingRequests = new Map();
+
+        this.syncEnabled    = options.syncEnabled    ?? false;
+        this.serverUrl      = options.serverUrl      ?? 'wss://localhost:3000/ws';
+        this.syncIntervalMs = options.syncIntervalMs ?? 5000;
+        this.authToken      = options.authToken      ?? null;
+
+        this.ws             = null;
+        this.syncCallbacks  = new Set();
+        this.syncQueue      = [];
+        this.syncTimer      = null;
+    }
+
+    /** Initialise the Web Worker and open the OPFS database. */
+    async init() {
+        return new Promise((resolve, reject) => {
+            this.worker = new Worker(this.workerUrl, { type: 'module' });
+
+            this.worker.onmessage = (event) => {
+                const { id, result, error } = event.data;
+                const pending = this.pendingRequests.get(id);
+                if (!pending) return;
+                this.pendingRequests.delete(id);
+                if (error) pending.reject(new Error(error));
+                else       pending.resolve(result);
+            };
+
+            this.worker.onerror = (err) => {
+                console.error('[MoltenDB] Worker error:', err);
+                reject(err);
+            };
+
+            this.sendMessage('init', { dbName: this.dbName })
+                .then(() => this.syncEnabled ? this.connectSync() : undefined)
+                .then(resolve)
+                .catch(reject);
+        });
+    }
+
+    /**
+     * Send a raw message to the worker and return a Promise for the result.
+     * @param {string} action
+     * @param {object} [params]
+     */
+    sendMessage(action, params = {}) {
+        return new Promise((resolve, reject) => {
+            const id = this.messageId++;
+            this.pendingRequests.set(id, { resolve, reject });
+            this.worker.postMessage({ id, action, ...params });
+        });
+    }
+
+    // ── WebSocket sync ────────────────────────────────────────────────────────
+
+    connectSync() {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(this.serverUrl);
+
+            this.ws.onopen = () => {
+                if (this.authToken) {
+                    this.ws.send(JSON.stringify({ action: 'AUTH', token: this.authToken }));
+                }
+                if (this.syncTimer) clearInterval(this.syncTimer);
+                this.syncTimer = setInterval(() => this.flushSyncQueue(), this.syncIntervalMs);
+                resolve();
+            };
+
+            this.ws.onmessage = (event) => {
+                try { this.handleServerUpdate(JSON.parse(event.data)); }
+                catch (e) { console.error('[MoltenDB] Failed to parse server message:', e); }
+            };
+
+            this.ws.onclose = () => {
+                if (this.syncTimer) clearInterval(this.syncTimer);
+                setTimeout(() => this.connectSync(), 3000);
+            };
+
+            this.ws.onerror = (err) => reject(err);
+        });
+    }
+
+    handleServerUpdate(update) {
+        if (update.event === 'change' && update.collection && update.key) {
+            // Re-fetch the updated document from the server and apply locally.
+            // (The WS push only carries the key + new _v, not the full document.)
+        }
+        this.syncCallbacks.forEach(cb => cb(update));
+    }
+
+    /** Subscribe to real-time server push events. Returns an unsubscribe fn. */
+    onSync(callback) {
+        this.syncCallbacks.add(callback);
+        return () => this.syncCallbacks.delete(callback);
+    }
+
+    flushSyncQueue() {
+        if (!this.syncQueue.length || !this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+        const batch = this.syncQueue.splice(0);
+        this.ws.send(JSON.stringify({ action: 'set', operations: batch }));
+    }
+
+    // ── Convenience CRUD helpers ──────────────────────────────────────────────
+
+    /** Insert / upsert one document. */
+    async set(collection, key, value, options = {}) {
+        await this.sendMessage('set', { collection, data: { [key]: value } });
+        if (this.syncEnabled && !options.skipSync) {
+            this.syncQueue.push({ action: 'set', collection, data: { [key]: value } });
+        }
+    }
+
+    /** Fetch a single document by key. */
+    get(collection, key) {
+        return this.sendMessage('get', { collection, keys: key });
+    }
+
+    /** Fetch all documents in a collection. */
+    getAll(collection) {
+        return this.sendMessage('get', { collection });
+    }
+
+    /** Delete a document by key. */
+    async delete(collection, key, options = {}) {
+        await this.sendMessage('delete', { collection, keys: key });
+        if (this.syncEnabled && !options.skipSync) {
+            this.syncQueue.push({ action: 'delete', collection, keys: key });
+        }
+    }
+
+    /** Compact the OPFS log file. */
+    compact() {
+        return this.sendMessage('compact');
+    }
+
+    /** Close the WebSocket connection and stop the sync timer. */
+    disconnect() {
+        if (this.syncTimer) clearInterval(this.syncTimer);
+        if (this.ws) this.ws.close();
+    }
+
+    /** Terminate the Web Worker (and disconnect sync). */
+    terminate() {
+        this.disconnect();
+        if (this.worker) this.worker.terminate();
+    }
+}

package/dist/moltendb-worker.js

@@ -0,0 +1,30 @@
+// MoltenDB Web Worker — auto-generated by moltendb-wasm build script
+// Do not edit directly; edit moltendb-wasm/scripts/build.mjs instead.
+import init, { WorkerDb } from './moltendb.js';
+
+let db = null;
+
+self.onmessage = async (event) => {
+    const { id, action, ...params } = event.data;
+
+    try {
+        if (!db && action === 'init') {
+            await init();
+            db = await new WorkerDb(params.dbName || 'moltendb');
+            self.postMessage({ id, result: { status: 'initialized' } });
+            return;
+        }
+
+        if (!db) {
+            throw new Error('Database not initialized. Send an "init" message first.');
+        }
+
+        // Pass action + params but NOT id so the Rust validator does not see
+        // 'id' as an unknown property.
+        const result = db.handle_message({ action, ...params });
+        self.postMessage({ id, result });
+
+    } catch (error) {
+        self.postMessage({ id, error: error.toString() });
+    }
+};

package/dist/moltendb.d.ts

@@ -0,0 +1,119 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The WASM-exposed database handle used by the JavaScript Web Worker.
+ *
+ * `#[wasm_bindgen]` on the struct makes it visible to JavaScript.
+ * JavaScript creates an instance with: `const db = await new WorkerDb("mydb")`
+ *
+ * The struct wraps a `Db` — the same engine used on the server.
+ * All methods on this struct are thin adapters that:
+ *   1. Convert JavaScript values (JsValue) to Rust types.
+ *   2. Call the underlying Db methods.
+ *   3. Convert the result back to JsValue for JavaScript.
+ */
+export class WorkerDb {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Execute an analytics query and return the result as a JSON string.
+     *
+     * This is the method called by the dashboard's auto-refresh loop:
+     *   `const resultStr = db.analytics(JSON.stringify(query))`
+     *
+     * Takes a JSON string (not a JsValue) because the analytics query format
+     * is complex and easier to pass as a pre-serialized string from JavaScript.
+     *
+     * Returns a JSON string (not a JsValue) so JavaScript can parse it with
+     * `JSON.parse(resultStr)` and access `result` and `metadata`.
+     *
+     * Example input:
+     *   `'{"collection":"events","metric":{"type":"COUNT"},"where":{"event_type":"button_click"}}'`
+     *
+     * Example output:
+     *   `'{"result":42,"metadata":{"execution_time_ms":0,"rows_scanned":42}}'`
+     *
+     * `#[wasm_bindgen(js_name = analytics)]` sets the JavaScript method name to
+     * "analytics" (matching the call in analytics-worker.js).
+     */
+    analytics(query_json: string): string;
+    /**
+     * Route an incoming message from the JavaScript worker to the correct handler.
+     *
+     * Called from moltendb-worker.js as:
+     *   `db.handle_message({ action: 'get', collection: 'laptops', keys: 'lp1' })`
+     *
+     * The `data` parameter is a plain JavaScript object (not a MessageEvent wrapper).
+     * It must have an `action` field that determines which operation to perform.
+     *
+     * Supported actions — identical to the HTTP server endpoints:
+     *   - "get"      → query documents (single key, batch, full collection, WHERE, joins, sort, pagination)
+     *   - "set"      → insert or upsert documents: { collection, data: { key: doc, ... } }
+     *   - "update"   → patch/merge documents:      { collection, data: { key: patch, ... } }
+     *   - "delete"   → delete documents or drop:   { collection, keys: ... } or { drop: true }
+     *   - "compact"  → compact the OPFS log file
+     *   - "get_size" → return current OPFS file size in bytes
+     *
+     * Returns a JsValue result on success, or a JsValue error string on failure.
+     */
+    handle_message(data: any): any;
+    /**
+     * Initialize the database and open (or create) the OPFS storage file.
+     *
+     * This is the constructor — called from JavaScript as:
+     *   `const db = await new WorkerDb("click_analytics_db")`
+     *
+     * `#[wasm_bindgen(constructor)]` tells wasm-bindgen that this function
+     * is the JavaScript `new WorkerDb(...)` constructor.
+     *
+     * `async` because opening the OPFS file handle is an async browser API.
+     * Returns `Result<WorkerDb, JsValue>` — on error, the JsValue becomes a
+     * JavaScript exception that the worker's try/catch can handle.
+     *
+     * # Arguments
+     * * `db_name` — The name of the OPFS file to open (e.g. "click_analytics_db").
+     *   Each unique name is a separate database file in the browser's OPFS storage.
+     */
+    constructor(db_name: string);
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_workerdb_free: (a: number, b: number) => void;
+    readonly workerdb_analytics: (a: number, b: number, c: number, d: number) => void;
+    readonly workerdb_handle_message: (a: number, b: number, c: number) => void;
+    readonly workerdb_new: (a: number, b: number) => number;
+    readonly __wasm_bindgen_func_elem_3598: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_3677: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_3690: (a: number, b: number, c: number, d: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;