@moltendb-web/core 1.8.0 → 2.0.0

package/README.md

@@ -3,15 +3,16 @@
 <div align="center">
   <img src="../../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.**
+### 🌋 The Embedded Database for the Modern Web
 
-  [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)
+**High-performance Rust engine compiled to WASM. Persistent storage via OPFS.**
 
-  [![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-MIT-green?style=flat-square)](LICENSE.md)
-  [![WASM](https://img.shields.io/badge/wasm-optimized-magenta?style=flat-square)](https://webassembly.org/)
-  [![Status](https://img.shields.io/badge/status-stable-brightgreen?style=flat-square)]()
+[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-MIT-green?style=flat-square)](LICENSE.md)
+[![WASM](https://img.shields.io/badge/wasm-optimized-magenta?style=flat-square)](https://webassembly.org/)
+[![Status](https://img.shields.io/badge/status-stable-brightgreen?style=flat-square)]()
 
 </div>
 
@@ -34,20 +35,33 @@ Prefer to run it in your own environment? You can **[clone the demo repository](
 **⚠️ 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
-- **Hybrid Bitcask Storage:** The same query logic used in our server binary, compiled to WebAssembly. Data is paged between RAM and OPFS to handle datasets larger than memory.
+
 - **At-Rest Encryption:** Transparently secure your data in the browser using XChaCha20-Poly1305 (Argon2id key derivation).
 - **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.
-- **Multi-Tab Sync (stabilised):** Leader election via the Web Locks API ensures only one tab owns the OPFS handle. All other tabs proxy reads and writes through a `BroadcastChannel`. Seamless leader promotion when the active tab closes.
-- **Automatic Compaction:** The engine automatically compacts the append-only log when it exceeds **500 entries or 5 MB**, keeping storage lean without any manual intervention.
+- **Multi-Tab Sync:** Leader election via the Web Locks API ensures only one tab owns the OPFS handle. All other tabs proxy reads and writes through a `BroadcastChannel`. Seamless leader promotion when the active tab closes.
 - **Real-Time Pub/Sub:** Every write and delete emits a typed `DbEvent` to all open tabs instantly. The `subscribe()` pattern supports multiple independent listeners per tab — perfect for modern UI frameworks like React and Angular.
 - **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.
 
 ---
 
+## What's New in v2.0.0
+
+### Query Builder
+
+- **Bulk Delete with `.where()`** — delete documents matching a filter clause without listing individual keys (see [`@moltendb-web/query`](../query/README.md)).
+- **Capped Collections (`.maxSize()`)** — cap a collection to a maximum number of documents; oldest entries are evicted automatically when the limit is reached.
+- **TTL Collections (`.ttl()`)** — set a time-to-live (in seconds) on a collection; documents are removed automatically after expiry.
+
+### Core Engine Performance
+
+- **`Arc<str>` collection-key interning** — the outer `DashMap` key was changed from `String` to `Arc<str>`. During bulk insert and WAL replay all documents in the same collection share a single pointer instead of allocating a new `String` per document. Saves ~30 B per doc (~30 MB at 1 M docs) and reduces allocator pressure during startup.
+- **MessagePack in-memory storage** — the hot document map was switched from `serde_json::Value` to `Box<[u8]>` (MessagePack bytes). Reduces steady-state RSS for 1 M docs from ~4 GB to ~500 MB (~8× lower). Decoding to `Value` happens lazily on read; write paths encode via `rmp_serde`.
+
+---
+
 ## Installation
 
 MoltenDb is split into two packages: the core engine and the type-safe, chainable query builder.
@@ -59,6 +73,7 @@ npm install @moltendb-web/core
 # Install the chainable query builder
 npm install @moltendb-web/query
 ```
+
 📦 **Bundler Setup**
 
 MoltenDb handles its own Web Workers and WASM loading automatically. However, depending on your build tool, you may need a tiny config tweak to ensure it serves the static files correctly.
@@ -67,9 +82,9 @@ MoltenDb handles its own Web Workers and WASM loading automatically. However, de
 Exclude the core package from pre-bundling in your vite.config.js:
 
 ```js
-// vite.config.js`
+// vite.config.js
 export default defineConfig({
-  optimizeDeps: { exclude: ['@moltendb-web/core'] }
+  optimizeDeps: {exclude: ['@moltendb-web/core']}
 });
 ```
 
@@ -79,20 +94,23 @@ Ensure Webpack treats the `.wasm` binary as a static resource in `webpack.config
 ```js
 module.exports = {
   module: {
-    rules: [{ test: /\.wasm$/, type: 'asset/resource' }]
+    rules: [{test: /\.wasm$/, type: 'asset/resource'}]
   }
 };
 ```
+
 ---
 
 # 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';
+import {MoltenDb} from '@moltendb-web/core';
+import {MoltenDbClient, WorkerTransport} from '@moltendb-web/query';
 
 const db = new MoltenDb('moltendb_demo', {
   encryptionKey: 'my-secret',    // Enable transparent at-rest encryption
@@ -102,36 +120,38 @@ await db.init();
 
 // Connect the query builder to the WASM worker
 const client = new MoltenDbClient(db);
+```
 
-// 2. Insert and Query
+2. Insert and Query
 
-// Use the @moltendb-web/query builder for a type-safe experience. 
+Use the `@moltendb-web/query` builder for a type-safe experience.
 
+```ts
 // 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,
-        }
+    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: {
+    memory_id: 'mem2',
+    specs: {
       cpu: {
         cores: 4,
         clock_speed: 3.5,
@@ -144,29 +164,29 @@ await client.collection('laptops').set({
 }).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 
-    },
+  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();
+    .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); 
+console.log(results);
 // [
 //  {
 //    "_key": "lp1",
@@ -179,50 +199,57 @@ console.log(results);
 //    "price": 900
 //  }
 // ]
+```
 
-// Powerful Query Capabilities
-// GraphQL-style Field Selection
+Powerful Query Capabilities
+GraphQL-style Field Selection
 
-// Never over-fetch data again. Use dot-notation to extract deeply nested values.
+Never over-fetch data again. Use dot-notation to extract deeply nested values.
 
+```ts
 await client.collection('laptops')
-  .get()
-  .fields(["brand", "specs.cpu.cores", "specs.display.refresh_hz"])
-  .exec();
+    .get()
+    .fields(["brand", "specs.cpu.cores", "specs.display.refresh_hz"])
+    .exec();
+```
 
-// Inline Joins
+Inline Joins
 
-// Resolve relationships between collections at query time.
+Resolve relationships between collections at query time.
 
+```ts
 await client.collection('laptops')
-  .get()
-  .joins([{ 
-    alias: 'ram', 
-    from: 'memory', 
-    on: 'memory_id', 
-    fields: ['capacity_gb', 'type'] 
-  }])
-  .exec();
+    .get()
+    .joins([{
+      alias: 'ram',
+      from: 'memory',
+      on: 'memory_id',
+      fields: ['capacity_gb', 'type']
+    }])
+    .exec();
+```
+
+---
 
-// Supported Query Operators
+## 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 |
-| `$or` | | At least one of the sub-conditions must match (array of where-style objects) |
-| `$and` | | All sub-conditions must match (array of where-style objects) |
-
-// Inline reference embedding (`extends`)
+| 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                                |
+| `$or`       |               | At least one of the sub-conditions must match (array of where-style objects) |
+| `$and`      |               | All sub-conditions must match (array of where-style objects) |
+
+## 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.
 
@@ -242,16 +269,18 @@ await client.collection('laptops')
   .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 |
+|                | `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 |
 
 ---
+
 ## Configuration
 
 You can customise the database behavior by passing an options object to the `MoltenDb` constructor.
@@ -266,24 +295,24 @@ await db.init();
 
 ### Options Reference
 
-| Property | Type | Default | Description                                                                                                                                                                                                                                                      |
-| :--- | :--- | :--- |:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `encryptionKey` | `string` | `undefined` | **At-Rest Encryption:** If provided, all data written to OPFS is encrypted using XChaCha20-Poly1305. If omitted, data is stored as plain JSON.                                                                                                                   |
-| `writeMode` | `'async' \| 'sync'` | `'async'` | **Durability vs Speed:** `'async'` is blazing fast (high throughput), while `'sync'` ensures every write is flushed to disk before returning (safer but slower). **Note:** `async` is recommended for most web apps to avoid blocking during heavy write bursts. |
-| `workerUrl` | `string \| URL` | `undefined` | Custom path to the Web Worker script.                                                                                                                                                                                                                            |
-| `maxBodySize` | `number` | `10485760` | **Payload Limit:** Max body size in bytes. Prevents memory spikes from large messages.                                                                                                                                                                           |
-| `maxKeysPerRequest` | `number` | `1000` | **Batch Limit:** Maximum number of keys allowed per JSON request.                                                                                                                                                                                                |
-| `inMemory` | `boolean` | `false` | **Ephemeral Mode:** Run entirely in RAM — no OPFS writes, no WAL. All data is lost when **any** tab refreshes or closes. Ideal for CI environments and ephemeral caches.                                                                                         |
+| Property            | Type                | Default     | Description                                                                                                                                                                                                                                                      |
+| :------------------ | :------------------ | :---------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `encryptionKey`     | `string`            | `undefined` | **At-Rest Encryption:** If provided, all data written to OPFS is encrypted using XChaCha20-Poly1305. If omitted, data is stored as plain JSON.                                                                                                                   |
+| `writeMode`         | `'async' \| 'sync'` | `'async'`   | **Durability vs Speed:** `'async'` is blazing fast (high throughput), while `'sync'` ensures every write is flushed to disk before returning (safer but slower). **Note:** `async` is recommended for most web apps to avoid blocking during heavy write bursts. |
+| `workerUrl`         | `string \| URL`     | `undefined` | Custom path to the Web Worker script.                                                                                                                                                                                                                            |
+| `maxBodySize`       | `number`            | `10485760`  | **Payload Limit:** Max body size in bytes. Prevents memory spikes from large messages.                                                                                                                                                                           |
+| `maxKeysPerRequest` | `number`            | `1000`      | **Batch Limit:** Maximum number of keys allowed per JSON request.                                                                                                                                                                                                |
+| `inMemory`          | `boolean`           | `false`     | **Ephemeral Mode:** Run entirely in RAM — no OPFS writes, no WAL. All data is lost when **any** tab refreshes or closes. Ideal for CI environments and ephemeral caches.                                                                                         |
 
 ---
+
 ## 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.
 
-- **Automatic Compaction:** When the log exceeds **500 entries or 5 MB**, the engine automatically "squashes" the log, removing superseded document versions to reclaim space. No manual `compact()` calls are needed in normal operation.
-- **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.
+- **Persistence:** Unlese inMemory option is selected 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.
 
 ### Multi-Tab Sync
 
@@ -323,7 +352,7 @@ unsubscribe();
 The event fires on the **leader tab** (directly from the WASM engine) and is automatically broadcast over the `BroadcastChannel` so every **follower tab** receives it too. This makes it trivial to keep your UI in sync across tabs without any extra infrastructure:
 
 ```ts
-db.subscribe(({ event, collection, key }) => {
+db.subscribe(({event, collection, key}) => {
   if (collection === 'laptops') {
     refreshLaptopList(); // re-query and re-render
   }
@@ -333,12 +362,13 @@ db.subscribe(({ event, collection, key }) => {
 The `DbEvent` type is exported from the package for full TypeScript support:
 
 ```ts
-import { MoltenDb, DbEvent } from '@moltendb-web/core';
+import {MoltenDb, DbEvent} from '@moltendb-web/core';
 
 const db = new MoltenDb('my-app');
 await db.init();
 
-db.subscribe((e: DbEvent) => { /* fully typed */ });```
+db.subscribe((e: DbEvent) => { /* fully typed */ });
+```
 
 ---
 
@@ -353,6 +383,22 @@ Cross-Origin-Embedder-Policy: require-corp
 
 ---
 
+## Management Methods
+
+### `clearOpfs()`
+
+Truncate and close the OPFS file handle, then remove the OPFS directory.
+
+Works from any tab — followers automatically route the `clear_opfs` message through the leader via BroadcastChannel, so the leader worker (which holds the exclusive FileSystemSyncAccessHandle) is the one that actually closes the file before the directory is removed.
+
+After this resolves, call the `terminate` method and `location.reload()` if needed or re-initialize the database.
+
+### `terminate()`
+
+Terminates the MoltenDb worker. Call after clearing OPFS storage.
+
+---
+
 ## Testing
 
 The core package ships with a comprehensive test suite built on **Vitest**:
@@ -365,20 +411,20 @@ npm run test:coverage # with coverage report
 
 ### What's covered
 
-| Suite | Tests | What it verifies |
-|---|---|---|
-| `init()` | 5 | Leader election, idempotency, worker error propagation |
-| CRUD — leader | 9 | set/get/delete/getAll round-trips, collection isolation |
-| CRUD — follower | 3 | BroadcastChannel proxy path for all mutations |
-| Worker error handling | 3 | Transient errors, unknown actions, request isolation |
-| Leader promotion | 2 | Follower takes over when leader tab closes |
-| `Pub/Sub (subscribe)`  | 2 | Multi-subscriber event delivery across tabs |
-| Follower timeout | 1 | Pending requests reject after 10 s if leader disappears |
-| `terminate` / `disconnect` | 3 | Worker cleanup, timer teardown |
-| Stress — rapid writes | 3 | 100 sequential, 50 concurrent, interleaved set/delete |
-| BC name isolation | 2 | Two databases on the same origin don't bleed data |
-| Bulk insert stress | 3 | 1 000 concurrent sets, 500 mixed ops, compact under pressure |
-| Multi-tab parallel stress | 4 | 3 tabs × 100 writes, ID collision safety, follower reads after burst, promotion under load |
+| Suite                      | Tests | What it verifies                                                                           |
+| :------------------------- | :---- | :----------------------------------------------------------------------------------------- |
+| `init()`                   | 5     | Leader election, idempotency, worker error propagation                                     |
+| CRUD — leader              | 9     | set/get/delete/getAll round-trips, collection isolation                                    |
+| CRUD — follower            | 3     | BroadcastChannel proxy path for all mutations                                              |
+| Worker error handling      | 3     | Transient errors, unknown actions, request isolation                                       |
+| Leader promotion           | 2     | Follower takes over when leader tab closes                                                 |
+| `Pub/Sub (subscribe)`      | 2     | Multi-subscriber event delivery across tabs                                                |
+| Follower timeout           | 1     | Pending requests reject after 10 s if leader disappears                                    |
+| `terminate` / `disconnect` | 3     | Worker cleanup, timer teardown                                                             |
+| Stress — rapid writes      | 3     | 100 sequential, 50 concurrent, interleaved set/delete                                      |
+| BC name isolation          | 2     | Two databases on the same origin don't bleed data                                          |
+| Bulk insert stress         | 3     | 1 000 concurrent sets, 500 mixed ops, compact under pressure                               |
+| Multi-tab parallel stress  | 4     | 3 tabs × 100 writes, ID collision safety, follower reads after burst, promotion under load |
 
 **Total: 50 tests — all green.**
 
@@ -394,16 +440,13 @@ This monorepo contains the following packages:
 ## Roadmap
 
 - [x] **Multi-Tab Sync:** Leader election for multiple tabs to share a single OPFS instance.
-- [x] **Automatic Compaction:** Log compacts automatically at 500 entries or 5 MB.
 - [x] **Rich Test Suite:** 50 unit, integration, and stress tests via Vitest.
-- [ ] **React Adapter:** Official `@moltendb-web/react` package with `useQuery` hooks and real-time context providers.
+- [x] **React Adapter:** Official `@moltendb-web/react` package with `useQuery` hooks and real-time context providers.
 - [x] **Angular Adapter:** Official `@moltendb-web/angular` package featuring Signal-based data fetching.
 - [ ] **Delta Sync:** Automatic two-way sync with the MoltenDb Rust server.
 - [x] **Data Encryption:** Transparent encryption-at-rest using hardware-backed keys (Argon2id + XChaCha20).
-- [x] **Hybrid Bitcask:** Seamlessly handle datasets larger than RAM by paging docs to OPFS.
 - [ ] **Analytics Functionality:** Run complex analytics queries straight in the browser without blocking the UI.
-- [x] **Configurable Limits:** User-defined RAM thresholds and request body sizes for edge and browser environments.
-
+- [x] **Configurable Limits:** User-defined request body sizes for edge and browser environments.
 
 ## Contributing & Feedback
 
@@ -415,6 +458,4 @@ Found a bug or have a feature request? Please open an issue on the [GitHub issue
 
 The MoltenDb Web packages (`@moltendb-web/core` and `@moltendb-web/query`) are licensed under the MIT License.
 
-The **MoltenDb Server** (Rust backend) remains under the Business Source License 1.1 (Free for organizations under $5M revenue, requires a license for managed services).
-
-For commercial licensing or questions: [maximilian.both27@outlook.com](mailto:maximilian.both27@outlook.com)
+The **MoltenDb Server** (Rust backend) remains under the Business Source License 1.1 (Free for organizations under $5M revenue, requires a license for managed services).

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export interface MoltenDbOptions {
     /** Password for at-rest encryption. If not provided, data is stored as plain JSON. */
     encryptionKey?: string;
     /** Storage write mode: 'async' (default, high throughput) or 'sync' (durable). */
-    writeMode?: 'async' | 'sync';
+    writeMode?: "async" | "sync";
     /**  Maximum request body size in bytes. */
     maxBodySize?: number;
     /** Maximum number of keys allowed per JSON request. Default: 1000. */
@@ -21,8 +21,8 @@ export interface MoltenDbOptions {
     inMemory?: boolean;
 }
 export interface DbEvent {
-    type: 'event';
-    event: 'change' | 'delete' | 'drop';
+    type: "event";
+    event: "change" | "delete" | "drop" | "kill" | "ttl_expiry";
     collection: string;
     key: string;
     new_v: number | null;
@@ -32,12 +32,12 @@ export declare class MoltenDb {
     readonly workerUrl?: string | URL;
     readonly options: MoltenDbOptions;
     worker: Worker | null;
-    private initPromise;
-    private pendingRequests;
     isLeader: boolean;
-    private bc;
     /** Legacy global hook. Use `subscribe()` for multi-component listeners. */
     onEvent?: (event: DbEvent) => void;
+    private initPromise;
+    private pendingRequests;
+    private bc;
     private eventListeners;
     constructor(dbName?: string, options?: MoltenDbOptions);
     /**
@@ -47,10 +47,7 @@ export declare class MoltenDb {
     subscribe(listener: (event: DbEvent) => void): () => void;
     /** Manually remove a specific listener */
     unsubscribe(listener: (event: DbEvent) => void): void;
-    private dispatchEvent;
     init(): Promise<void>;
-    private startAsLeader;
-    private startAsFollower;
     sendMessage(action: string, payload?: Record<string, unknown>): Promise<any>;
     set(collection: string, key: string, value: any): Promise<void>;
     get(collection: string, key: string): Promise<unknown>;
@@ -58,19 +55,20 @@ export declare class MoltenDb {
     delete(collection: string, key: string): Promise<void>;
     compact(): Promise<unknown>;
     /**
-     * Truncate and close the OPFS file so the directory can be removed.
+     * Truncate and close the OPFS file handle, then remove the OPFS directory.
      *
-     * Works from any tab — followers automatically route this through the leader
-     * via BroadcastChannel, so the leader worker (which holds the exclusive
-     * FileSystemSyncAccessHandle) is the one that actually closes the file.
+     * Works from any tab — followers automatically route the `clear_opfs` message
+     * through the leader via BroadcastChannel, so the leader worker (which holds
+     * the exclusive FileSystemSyncAccessHandle) is the one that actually closes
+     * the file before the directory is removed.
      *
-     * After this resolves, call:
-     *   `const root = await navigator.storage.getDirectory();`
-     *   `const root = await navigator.storage.getDirectory();`
-     *   `await root.removeEntry(dbName, { recursive: true });`
-     * then reload the page.
+     * After this resolves, call the `terminate` method and `location.reload()` if needed or re-initialize the database.
      */
-    clearOpfs(): Promise<unknown>;
+    clearOpfs(): Promise<void>;
     disconnect(): void;
+    /** Terminates the MoltenDb worker. Call after clearing OPFS storage. */
     terminate(): void;
+    private dispatchEvent;
+    private startAsLeader;
+    private startAsFollower;
 }

package/dist/index.js

@@ -4,16 +4,16 @@ export class MoltenDb {
     workerUrl;
     options;
     worker = null;
-    initPromise = null;
-    pendingRequests = new Map();
     // Multi-tab Sync State
     isLeader = false;
-    bc;
     /** Legacy global hook. Use `subscribe()` for multi-component listeners. */
     onEvent;
+    initPromise = null;
+    pendingRequests = new Map();
+    bc;
     // ── Multi-Subscriber Event System ──────────────────────────────────────────
     eventListeners = new Set();
-    constructor(dbName = 'moltendb', options = {}) {
+    constructor(dbName = "moltendb", options = {}) {
         this.dbName = dbName;
         this.workerUrl = options.workerUrl;
         this.options = options;
@@ -30,18 +30,6 @@ export class MoltenDb {
     unsubscribe(listener) {
         this.eventListeners.delete(listener);
     }
-    dispatchEvent(event) {
-        // Fire all subscribed component handlers
-        for (const listener of this.eventListeners) {
-            try {
-                listener(event);
-            }
-            catch (err) {
-                console.error('[MoltenDb] Error in subscribed listener', err);
-            }
-        }
-    }
-    // ───────────────────────────────────────────────────────────────────────────
     init() {
         // 1. If initialization has already started or finished, return the existing promise
         if (this.initPromise)
@@ -49,9 +37,9 @@ export class MoltenDb {
         // 2. When running in-memory, any tab refresh should wipe the shared RAM store.
         //    Broadcast a clear_all signal on beforeunload so the leader can wipe the Rust DashMap.
         if (this.options.inMemory) {
-            window.addEventListener('beforeunload', () => {
+            window.addEventListener("beforeunload", () => {
                 try {
-                    this.bc?.postMessage({ type: 'clear_all' });
+                    this.bc?.postMessage({ type: "clear_all" });
                 }
                 catch { }
             });
@@ -84,118 +72,20 @@ export class MoltenDb {
         });
         return this.initPromise;
     }
-    async startAsLeader() {
-        // Guard: OPFS is required
-        if (!this.options.inMemory) {
-            try {
-                await navigator.storage.getDirectory();
-            }
-            catch {
-                throw new Error('[MoltenDb] Origin Private File System (OPFS) is not available in this browser context. ' +
-                    'Try a non-private window or a browser that supports OPFS (Chrome 102+, Firefox 111+, Safari 15.2+).');
-            }
-        }
-        this.isLeader = true;
-        if (this.worker)
-            this.worker.terminate();
-        const url = this.workerUrl || new URL('./moltendb-worker.js', import.meta.url);
-        this.worker = new Worker(url, { type: 'module', name: `moltendb-${this.dbName}-leader` });
-        this.worker.onmessage = (e) => {
-            const data = e.data;
-            if (data.type === 'event') {
-                this.dispatchEvent(data); // ⬅️ Trigger new dispatcher
-                this.bc.postMessage(data);
-                return;
-            }
-            const req = this.pendingRequests.get(data.id);
-            if (req) {
-                if (data.error)
-                    req.reject(new Error(data.error));
-                else
-                    req.resolve(data.result);
-                this.pendingRequests.delete(data.id);
-            }
-        };
-        // Wait for worker to boot
-        await this.sendMessage('init', {
-            dbName: this.dbName,
-            encryptionKey: this.options.encryptionKey,
-            inMemory: this.options.inMemory,
-            maxBodySize: this.options.maxBodySize,
-            maxKeysPerRequest: this.options.maxKeysPerRequest,
-            writeMode: this.options.writeMode,
-        });
-        this.bc.onmessage = async (e) => {
-            const msg = e.data;
-            // Any tab unloading in in-memory mode broadcasts this — wipe the shared RAM store.
-            if (msg.type === 'clear_all') {
-                try {
-                    await this.sendMessage('clear', {});
-                    this.bc.postMessage({ type: 'cleared' });
-                    console.log('[MoltenDb] In-memory store wiped (tab unloaded).');
-                }
-                catch (err) {
-                    console.warn('[MoltenDb] Failed to clear in-memory store:', err);
-                }
-                return;
-            }
-            if (msg.type === 'query' && msg.action) {
-                try {
-                    const result = await this.sendMessage(msg.action, msg.payload);
-                    this.bc.postMessage({ type: 'response', id: msg.id, result });
-                }
-                catch (err) {
-                    this.bc.postMessage({ type: 'response', id: msg.id, error: err.message });
-                }
-            }
-        };
-    }
-    startAsFollower() {
-        this.isLeader = false;
-        if (this.worker) {
-            this.worker.terminate();
-            this.worker = null;
-        }
-        this.bc.onmessage = (e) => {
-            const data = e.data;
-            if (data.type === 'event') {
-                this.dispatchEvent(data); // ⬅️ Trigger new dispatcher
-                return;
-            }
-            // In-memory wipe notification from leader — reject all in-flight requests.
-            if (data.type === 'cleared') {
-                console.log('[MoltenDb] In-memory store was wiped by another tab.');
-                for (const [id, req] of this.pendingRequests) {
-                    req.reject(new Error('[MoltenDb] In-memory store was cleared by a tab reload.'));
-                    this.pendingRequests.delete(id);
-                }
-                return;
-            }
-            if (data.type === 'response') {
-                const req = this.pendingRequests.get(data.id);
-                if (req) {
-                    if (data.error)
-                        req.reject(new Error(data.error));
-                    else
-                        req.resolve(data.result);
-                    this.pendingRequests.delete(data.id);
-                }
-            }
-        };
-    }
+    // ───────────────────────────────────────────────────────────────────────────
     async sendMessage(action, payload) {
         //  Wait for the engine to boot before routing the message.
         // If the DB is already initialized, this resolves instantly.
-        if (action !== 'init') {
+        if (action !== "init") {
             if (this.initPromise) {
                 await this.initPromise;
             }
             else {
-                throw new Error('[MoltenDb] You must call db.init() before querying the database.');
+                throw new Error("[MoltenDb] You must call db.init() before querying the database.");
             }
         }
         // 2. Generate a unique ID
-        const id = (typeof crypto !== 'undefined' && crypto.randomUUID)
+        const id = typeof crypto !== "undefined" && crypto.randomUUID
             ? crypto.randomUUID()
             : Math.random().toString(36).substring(2, 9);
         return new Promise((resolve, reject) => {
@@ -214,19 +104,25 @@ export class MoltenDb {
                     }
                 }, 10000);
                 this.pendingRequests.set(id, {
-                    resolve: (res) => { clearTimeout(timer); successHandler(res); },
-                    reject: (e) => { clearTimeout(timer); reject(e); }
+                    resolve: (res) => {
+                        clearTimeout(timer);
+                        successHandler(res);
+                    },
+                    reject: (e) => {
+                        clearTimeout(timer);
+                        reject(e);
+                    },
                 });
-                this.bc.postMessage({ type: 'query', id, action, payload });
+                this.bc.postMessage({ type: "query", id, action, payload });
             }
         });
     } // ── Convenience CRUD helpers ───────────────────────────────────────────────
     async set(collection, key, value) {
-        await this.sendMessage('set', { collection, data: { [key]: value } });
+        await this.sendMessage("set", { collection, data: { [key]: value } });
     }
     async get(collection, key) {
         try {
-            return await this.sendMessage('get', { collection, keys: key });
+            return await this.sendMessage("get", { collection, keys: key });
         }
         catch (err) {
             try {
@@ -240,7 +136,7 @@ export class MoltenDb {
     }
     async getAll(collection) {
         try {
-            const result = await this.sendMessage('get', { collection });
+            const result = await this.sendMessage("get", { collection });
             return result || [];
         }
         catch (err) {
@@ -254,36 +150,184 @@ export class MoltenDb {
         }
     }
     async delete(collection, key) {
-        await this.sendMessage('delete', { collection, keys: key });
+        await this.sendMessage("delete", { collection, keys: key });
     }
     compact() {
-        return this.sendMessage('compact');
+        return this.sendMessage("compact");
     }
     /**
-     * Truncate and close the OPFS file so the directory can be removed.
+     * Truncate and close the OPFS file handle, then remove the OPFS directory.
      *
-     * Works from any tab — followers automatically route this through the leader
-     * via BroadcastChannel, so the leader worker (which holds the exclusive
-     * FileSystemSyncAccessHandle) is the one that actually closes the file.
+     * Works from any tab — followers automatically route the `clear_opfs` message
+     * through the leader via BroadcastChannel, so the leader worker (which holds
+     * the exclusive FileSystemSyncAccessHandle) is the one that actually closes
+     * the file before the directory is removed.
      *
-     * After this resolves, call:
-     *   `const root = await navigator.storage.getDirectory();`
-     *   `const root = await navigator.storage.getDirectory();`
-     *   `await root.removeEntry(dbName, { recursive: true });`
-     * then reload the page.
+     * After this resolves, call the `terminate` method and `location.reload()` if needed or re-initialize the database.
      */
-    clearOpfs() {
-        return this.sendMessage('clear_opfs');
+    async clearOpfs() {
+        // 1. Tell Rust to flush, truncate, and CLOSE the FileSystemSyncAccessHandle.
+        //    Without this, removeEntry() throws "No modification allowed".
+        await this.sendMessage("clear_opfs");
+        // 2. Remove the OPFS directory — the handle is now closed, so this succeeds.
+        const root = await navigator.storage.getDirectory();
+        await root.removeEntry(this.dbName, { recursive: true });
+        // 3. Hit the Kill Switch for all other tabs
+        this.bc?.postMessage({ type: "kill_signal" });
     }
     disconnect() {
         if (this.bc)
             this.bc.close();
     }
+    /** Terminates the MoltenDb worker. Call after clearing OPFS storage. */
     terminate() {
         this.disconnect();
         if (this.worker) {
             this.worker.terminate();
             this.worker = null;
         }
+        this.initPromise = null;
+        this.isLeader = false;
+    }
+    dispatchEvent(event) {
+        // Fire all subscribed component handlers
+        for (const listener of this.eventListeners) {
+            try {
+                listener(event);
+            }
+            catch (err) {
+                console.error("[MoltenDb] Error in subscribed listener", err);
+            }
+        }
+    }
+    async startAsLeader() {
+        // Guard: OPFS is required
+        if (!this.options.inMemory) {
+            try {
+                await navigator.storage.getDirectory();
+            }
+            catch {
+                throw new Error("[MoltenDb] Origin Private File System (OPFS) is not available in this browser context. " +
+                    "Try a non-private window or a browser that supports OPFS (Chrome 102+, Firefox 111+, Safari 15.2+).");
+            }
+        }
+        this.isLeader = true;
+        if (this.worker)
+            this.worker.terminate();
+        const url = this.workerUrl || new URL("./moltendb-worker.js", import.meta.url);
+        this.worker = new Worker(url, {
+            type: "module",
+            name: `moltendb-${this.dbName}-leader`,
+        });
+        this.worker.onmessage = (e) => {
+            const data = e.data;
+            if (data.type === "event") {
+                this.dispatchEvent(data); // ⬅️ Trigger new dispatcher
+                this.bc.postMessage(data);
+                return;
+            }
+            const req = this.pendingRequests.get(data.id);
+            if (req) {
+                if (data.error)
+                    req.reject(new Error(data.error));
+                else
+                    req.resolve(data.result);
+                this.pendingRequests.delete(data.id);
+            }
+        };
+        // Wait for worker to boot
+        await this.sendMessage("init", {
+            dbName: this.dbName,
+            encryptionKey: this.options.encryptionKey,
+            inMemory: this.options.inMemory,
+            maxBodySize: this.options.maxBodySize,
+            maxKeysPerRequest: this.options.maxKeysPerRequest,
+            writeMode: this.options.writeMode,
+        });
+        this.bc.onmessage = async (e) => {
+            const msg = e.data;
+            // --- THE KILL SWITCH ---
+            if (msg.type === "kill_signal") {
+                this.terminate(); // Kills zombie worker instantly
+                this.dispatchEvent({
+                    type: "event",
+                    event: "kill",
+                    collection: "*",
+                    key: "*",
+                    new_v: null,
+                });
+                return;
+            }
+            // Any tab unloading in in-memory mode broadcasts this — wipe the shared RAM store.
+            if (msg.type === "clear_all") {
+                try {
+                    await this.sendMessage("clear", {});
+                    this.bc.postMessage({ type: "cleared" });
+                    console.log("[MoltenDb] In-memory store wiped (tab unloaded).");
+                }
+                catch (err) {
+                    console.warn("[MoltenDb] Failed to clear in-memory store:", err);
+                }
+                return;
+            }
+            if (msg.type === "query" && msg.action) {
+                try {
+                    const result = await this.sendMessage(msg.action, msg.payload);
+                    this.bc.postMessage({ type: "response", id: msg.id, result });
+                }
+                catch (err) {
+                    this.bc.postMessage({
+                        type: "response",
+                        id: msg.id,
+                        error: err.message,
+                    });
+                }
+            }
+        };
+    }
+    startAsFollower() {
+        this.isLeader = false;
+        if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+        }
+        this.bc.onmessage = (e) => {
+            const data = e.data;
+            // --- THE KILKILL SWITCH ---
+            if (data.type === "kill_signal") {
+                this.terminate(); // Kills zombie worker instantly
+                this.dispatchEvent({
+                    type: "event",
+                    event: "kill",
+                    collection: "*",
+                    key: "*",
+                    new_v: null,
+                });
+                return;
+            }
+            if (data.type === "event") {
+                this.dispatchEvent(data); // ⬅️ Trigger new dispatcher
+                return;
+            }
+            // In-memory wipe notification from leader — reject all in-flight requests.
+            if (data.type === "cleared") {
+                console.log("[MoltenDb] In-memory store was wiped by another tab.");
+                for (const [id, req] of this.pendingRequests) {
+                    req.reject(new Error("[MoltenDb] In-memory store was cleared by a tab reload."));
+                    this.pendingRequests.delete(id);
+                }
+                return;
+            }
+            if (data.type === "response") {
+                const req = this.pendingRequests.get(data.id);
+                if (req) {
+                    if (data.error)
+                        req.reject(new Error(data.error));
+                    else
+                        req.resolve(data.result);
+                    this.pendingRequests.delete(data.id);
+                }
+            }
+        };
     }
 }

package/dist/moltendb-worker.js

@@ -1,10 +1,10 @@
-import init, { WorkerDb } from './wasm/moltendb_core.js';
+import init, { WorkerDb } from "./wasm/moltendb_core.js";
 let db = null;
 let initPromise = null;
 self.onmessage = async (e) => {
     const { id, action, ...payload } = e.data;
     // --- 1. Initialization Phase ---
-    if (action === 'init') {
+    if (action === "init") {
         if (!initPromise) {
             initPromise = (async () => {
                 await init();
@@ -14,10 +14,10 @@ self.onmessage = async (e) => {
                 instance.subscribe((eventStr) => {
                     try {
                         const eventData = JSON.parse(eventStr);
-                        self.postMessage({ type: 'event', ...eventData });
+                        self.postMessage({ type: "event", ...eventData });
                     }
                     catch (err) {
-                        console.error('[MoltenDb Worker] Event parse error', err);
+                        console.error("[MoltenDb Worker] Event parse error", err);
                     }
                 });
                 db = instance;
@@ -26,11 +26,11 @@ self.onmessage = async (e) => {
         }
         try {
             await initPromise;
-            self.postMessage({ id, result: { status: 'ok' } });
+            self.postMessage({ id, result: { status: "ok" } });
         }
         catch (error) {
             // FIX: Handle Map-based errors from Rust correctly
-            const errorMsg = (error instanceof Map)
+            const errorMsg = error instanceof Map
                 ? JSON.stringify(Object.fromEntries(error))
                 : String(error);
             self.postMessage({ id, error: errorMsg });
@@ -47,7 +47,7 @@ self.onmessage = async (e) => {
     }
     catch (error) {
         // FIX: Handle Map-based errors here too
-        const errorMsg = (error instanceof Map)
+        const errorMsg = error instanceof Map
             ? JSON.stringify(Object.fromEntries(error))
             : String(error);
         self.postMessage({ id, error: errorMsg });

package/dist/wasm/moltendb_core.d.ts

@@ -58,7 +58,6 @@ export class WorkerDb {
      *   - "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
      *   - "clear"    → wipe all in-memory state (in-memory mode only)
      *
      * Returns a JsValue result on success, or a JsValue error string on failure.
@@ -80,8 +79,8 @@ export interface InitOutput {
     readonly workerdb_create: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
     readonly workerdb_handle_message: (a: number, b: number, c: number) => void;
     readonly workerdb_subscribe: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_3769: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_3781: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_4166: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_4178: (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;

package/dist/wasm/moltendb_core.js

@@ -87,7 +87,6 @@ export class WorkerDb {
      *   - "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
      *   - "clear"    → wipe all in-memory state (in-memory mode only)
      *
      * Returns a JsValue result on success, or a JsValue error string on failure.
@@ -232,9 +231,6 @@ function __wbg_get_imports() {
             const ret = Object.entries(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_error_2001591ad2463697: function(arg0) {
-            console.error(getObject(arg0));
-        },
         __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
@@ -377,7 +373,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_3781(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_4178(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -516,8 +512,8 @@ function __wbg_get_imports() {
             return ret;
         }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 724, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_3769);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 735, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_4166);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -559,10 +555,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_3769(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_4166(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_3769(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_4166(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -573,8 +569,8 @@ function __wasm_bindgen_func_elem_3769(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_3781(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_3781(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_4178(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_4178(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const WorkerDbFinalization = (typeof FinalizationRegistry === 'undefined')

package/dist/wasm/moltendb_core_bg.wasm.d.ts

@@ -5,8 +5,8 @@ export const __wbg_workerdb_free: (a: number, b: number) => void;
 export const workerdb_create: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
 export const workerdb_handle_message: (a: number, b: number, c: number) => void;
 export const workerdb_subscribe: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_3769: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_3781: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_4166: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_4178: (a: number, b: number, c: number, d: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@moltendb-web/core",
-  "version": "1.8.0",
+  "version": "2.0.0",
   "description": "MoltenDb WASM runtime — the database engine, Web Worker, and main-thread client in one package.",
   "type": "module",
-  "author": "Maximilian Both <maximilian.both27@outlook.com>",
+  "author": "Maximilian Both <admin@moltendb.dev",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -43,6 +43,7 @@
   "devDependencies": {
     "@playwright/test": "^1.58.2",
     "@vitest/coverage-v8": "^4.1.1",
+    "@vitest/utils": "^4.1.5",
     "copyfiles": "^2.4.1",
     "happy-dom": "^20.8.7",
     "typescript": "^6.0.2",