@moltendb-web/core 1.7.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,23 +94,25 @@ 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', {
-  hotThreshold: 25000,          // Keep 25k docs in RAM per collection
   encryptionKey: 'my-secret',    // Enable transparent at-rest encryption
   writeMode: 'sync'             // Ensure every write is flushed to OPFS
 });
@@ -103,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,
@@ -145,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",
@@ -180,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.
 
@@ -243,23 +269,24 @@ 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.
 
 ```ts
 const db = new MoltenDb('my-app', {
-  hotThreshold: 25000,           // Page to disk after 25k docs
   encryptionKey: 'user-secret',  // Secure at-rest storage in OPFS
   writeMode: 'sync'              // Ensure durability on every write
 });
@@ -268,25 +295,24 @@ await db.init();
 
 ### Options Reference
 
-| Property | Type | Default | Description                                                                                                                                                                                                                                                      |
-| :--- | :--- | :--- |:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `hotThreshold` | `number` | `50000` | **Hybrid Bitcask Limit:** Maximum documents per collection to keep in RAM. When exceeded, the oldest documents are paged out to OPFS to save memory.                                                                                                             |
-| `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
 
@@ -326,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
   }
@@ -336,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 */ });
+```
 
 ---
 
@@ -356,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**:
@@ -368,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.**
 
@@ -397,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
 
@@ -418,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

@@ -1,12 +1,10 @@
 export interface MoltenDbOptions {
     /** URL or path to moltendb-worker.js. */
     workerUrl?: string | URL;
-    /** Maximum documents per collection to keep in RAM. Default: 50,000. */
-    hotThreshold?: number;
     /** 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. */
@@ -23,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;
@@ -34,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);
     /**
@@ -49,16 +47,28 @@ 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>;
     getAll(collection: string): Promise<unknown[]>;
     delete(collection: string, key: string): Promise<void>;
     compact(): Promise<unknown>;
+    /**
+     * 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.
+     */
+    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,6 +72,134 @@ export class MoltenDb {
         });
         return this.initPromise;
     }
+    // ───────────────────────────────────────────────────────────────────────────
+    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 (this.initPromise) {
+                await this.initPromise;
+            }
+            else {
+                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
+            ? crypto.randomUUID()
+            : Math.random().toString(36).substring(2, 9);
+        return new Promise((resolve, reject) => {
+            const successHandler = (res) => resolve(mapToObj(res));
+            // 3. We are now GUARANTEED that isLeader, worker, and bc are accurately set
+            if (this.isLeader && this.worker) {
+                this.pendingRequests.set(id, { resolve: successHandler, reject });
+                this.worker.postMessage({ id, action, ...payload });
+            }
+            else {
+                // Follower routing via BroadcastChannel
+                const timer = setTimeout(() => {
+                    if (this.pendingRequests.has(id)) {
+                        this.pendingRequests.delete(id);
+                        reject(new Error(`[MoltenDb] Request "${action}" timed out after 10s.`));
+                    }
+                }, 10000);
+                this.pendingRequests.set(id, {
+                    resolve: (res) => {
+                        clearTimeout(timer);
+                        successHandler(res);
+                    },
+                    reject: (e) => {
+                        clearTimeout(timer);
+                        reject(e);
+                    },
+                });
+                this.bc.postMessage({ type: "query", id, action, payload });
+            }
+        });
+    } // ── Convenience CRUD helpers ───────────────────────────────────────────────
+    async set(collection, key, value) {
+        await this.sendMessage("set", { collection, data: { [key]: value } });
+    }
+    async get(collection, key) {
+        try {
+            return await this.sendMessage("get", { collection, keys: key });
+        }
+        catch (err) {
+            try {
+                const errorData = JSON.parse(err.message);
+                if (errorData.statusCode === 404)
+                    return null;
+            }
+            catch { }
+            throw err;
+        }
+    }
+    async getAll(collection) {
+        try {
+            const result = await this.sendMessage("get", { collection });
+            return result || [];
+        }
+        catch (err) {
+            try {
+                const errorData = JSON.parse(err.message);
+                if (errorData.statusCode === 404)
+                    return [];
+            }
+            catch { }
+            throw err;
+        }
+    }
+    async delete(collection, key) {
+        await this.sendMessage("delete", { collection, keys: key });
+    }
+    compact() {
+        return this.sendMessage("compact");
+    }
+    /**
+     * 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.
+     */
+    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) {
@@ -91,18 +207,21 @@ export class MoltenDb {
                 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+).');
+                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` });
+        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') {
+            if (data.type === "event") {
                 this.dispatchEvent(data); // ⬅️ Trigger new dispatcher
                 this.bc.postMessage(data);
                 return;
@@ -117,10 +236,9 @@ export class MoltenDb {
             }
         };
         // Wait for worker to boot
-        await this.sendMessage('init', {
+        await this.sendMessage("init", {
             dbName: this.dbName,
             encryptionKey: this.options.encryptionKey,
-            hotThreshold: this.options.hotThreshold,
             inMemory: this.options.inMemory,
             maxBodySize: this.options.maxBodySize,
             maxKeysPerRequest: this.options.maxKeysPerRequest,
@@ -128,25 +246,41 @@ export class MoltenDb {
         });
         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') {
+            if (msg.type === "clear_all") {
                 try {
-                    await this.sendMessage('clear', {});
-                    this.bc.postMessage({ type: 'cleared' });
-                    console.log('[MoltenDb] In-memory store wiped (tab unloaded).');
+                    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);
+                    console.warn("[MoltenDb] Failed to clear in-memory store:", err);
                 }
                 return;
             }
-            if (msg.type === 'query' && msg.action) {
+            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 });
+                    this.bc.postMessage({ type: "response", id: msg.id, result });
                 }
                 catch (err) {
-                    this.bc.postMessage({ type: 'response', id: msg.id, error: err.message });
+                    this.bc.postMessage({
+                        type: "response",
+                        id: msg.id,
+                        error: err.message,
+                    });
                 }
             }
         };
@@ -159,20 +293,32 @@ export class MoltenDb {
         }
         this.bc.onmessage = (e) => {
             const data = e.data;
-            if (data.type === 'event') {
+            // --- 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.');
+            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.'));
+                    req.reject(new Error("[MoltenDb] In-memory store was cleared by a tab reload."));
                     this.pendingRequests.delete(id);
                 }
                 return;
             }
-            if (data.type === 'response') {
+            if (data.type === "response") {
                 const req = this.pendingRequests.get(data.id);
                 if (req) {
                     if (data.error)
@@ -184,91 +330,4 @@ export class MoltenDb {
             }
         };
     }
-    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 (this.initPromise) {
-                await this.initPromise;
-            }
-            else {
-                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)
-            ? crypto.randomUUID()
-            : Math.random().toString(36).substring(2, 9);
-        return new Promise((resolve, reject) => {
-            const successHandler = (res) => resolve(mapToObj(res));
-            // 3. We are now GUARANTEED that isLeader, worker, and bc are accurately set
-            if (this.isLeader && this.worker) {
-                this.pendingRequests.set(id, { resolve: successHandler, reject });
-                this.worker.postMessage({ id, action, ...payload });
-            }
-            else {
-                // Follower routing via BroadcastChannel
-                const timer = setTimeout(() => {
-                    if (this.pendingRequests.has(id)) {
-                        this.pendingRequests.delete(id);
-                        reject(new Error(`[MoltenDb] Request "${action}" timed out after 10s.`));
-                    }
-                }, 10000);
-                this.pendingRequests.set(id, {
-                    resolve: (res) => { clearTimeout(timer); successHandler(res); },
-                    reject: (e) => { clearTimeout(timer); reject(e); }
-                });
-                this.bc.postMessage({ type: 'query', id, action, payload });
-            }
-        });
-    } // ── Convenience CRUD helpers ───────────────────────────────────────────────
-    async set(collection, key, value) {
-        await this.sendMessage('set', { collection, data: { [key]: value } });
-    }
-    async get(collection, key) {
-        try {
-            return await this.sendMessage('get', { collection, keys: key });
-        }
-        catch (err) {
-            try {
-                const errorData = JSON.parse(err.message);
-                if (errorData.statusCode === 404)
-                    return null;
-            }
-            catch { }
-            throw err;
-        }
-    }
-    async getAll(collection) {
-        try {
-            const result = await this.sendMessage('get', { collection });
-            return result || [];
-        }
-        catch (err) {
-            try {
-                const errorData = JSON.parse(err.message);
-                if (errorData.statusCode === 404)
-                    return [];
-            }
-            catch { }
-            throw err;
-        }
-    }
-    async delete(collection, key) {
-        await this.sendMessage('delete', { collection, keys: key });
-    }
-    compact() {
-        return this.sendMessage('compact');
-    }
-    disconnect() {
-        if (this.bc)
-            this.bc.close();
-    }
-    terminate() {
-        this.disconnect();
-        if (this.worker) {
-            this.worker.terminate();
-            this.worker = null;
-        }
-    }
 }

package/dist/moltendb-worker.js

@@ -1,23 +1,23 @@
-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();
                 // Pass all config flags to Rust
-                const instance = await WorkerDb.create(payload.dbName, payload.hotThreshold, payload.encryptionKey, payload.writeMode, payload.maxBodySize, payload.maxKeysPerRequest, payload.inMemory);
+                const instance = await WorkerDb.create(payload.dbName, payload.encryptionKey, payload.writeMode, payload.maxBodySize, payload.maxKeysPerRequest, payload.inMemory);
                 // Listen to Rust and broadcast events
                 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

@@ -17,28 +17,6 @@ export class WorkerDb {
     private constructor();
     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;
     /**
      * Initialize the database and open (or create) the OPFS storage file.
      *
@@ -56,7 +34,6 @@ export class WorkerDb {
      * # 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.
-     * * `hot_threshold` — Optional maximum documents per collection to keep in RAM (default: 50,000).
      * * `encryption_key` — Optional password for at-rest encryption.
      * * `write_mode` — Optional write mode: "async" (default) or "sync".
      * * `max_body_size` — Optional maximum request body size in bytes (default: 10MB).
@@ -65,7 +42,7 @@ export class WorkerDb {
      *   When `true`, all data is lost when the worker is terminated — useful for ephemeral
      *   session caches or testing without touching OPFS storage.
      */
-    static create(db_name: string, hot_threshold?: number | null, encryption_key?: string | null, write_mode?: string | null, max_body_size?: number | null, max_keys_per_request?: number | null, in_memory?: boolean | null): Promise<WorkerDb>;
+    static create(db_name: string, encryption_key?: string | null, write_mode?: string | null, max_body_size?: number | null, max_keys_per_request?: number | null, in_memory?: boolean | null): Promise<WorkerDb>;
     /**
      * Route an incoming message from the JavaScript worker to the correct handler.
      *
@@ -81,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.
@@ -100,12 +76,11 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 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_create: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
+    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_4220: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_4230: (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

@@ -30,47 +30,6 @@ export class WorkerDb {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_workerdb_free(ptr, 0);
     }
-    /**
-     * 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).
-     * @param {string} query_json
-     * @returns {string}
-     */
-    analytics(query_json) {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.workerdb_analytics(retptr, this.__wbg_ptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
-        }
-    }
     /**
      * Initialize the database and open (or create) the OPFS storage file.
      *
@@ -88,7 +47,6 @@ export class WorkerDb {
      * # 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.
-     * * `hot_threshold` — Optional maximum documents per collection to keep in RAM (default: 50,000).
      * * `encryption_key` — Optional password for at-rest encryption.
      * * `write_mode` — Optional write mode: "async" (default) or "sync".
      * * `max_body_size` — Optional maximum request body size in bytes (default: 10MB).
@@ -97,7 +55,6 @@ export class WorkerDb {
      *   When `true`, all data is lost when the worker is terminated — useful for ephemeral
      *   session caches or testing without touching OPFS storage.
      * @param {string} db_name
-     * @param {number | null} [hot_threshold]
      * @param {string | null} [encryption_key]
      * @param {string | null} [write_mode]
      * @param {number | null} [max_body_size]
@@ -105,14 +62,14 @@ export class WorkerDb {
      * @param {boolean | null} [in_memory]
      * @returns {Promise<WorkerDb>}
      */
-    static create(db_name, hot_threshold, encryption_key, write_mode, max_body_size, max_keys_per_request, in_memory) {
+    static create(db_name, encryption_key, write_mode, max_body_size, max_keys_per_request, in_memory) {
         const ptr0 = passStringToWasm0(db_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         var ptr1 = isLikeNone(encryption_key) ? 0 : passStringToWasm0(encryption_key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         var len1 = WASM_VECTOR_LEN;
         var ptr2 = isLikeNone(write_mode) ? 0 : passStringToWasm0(write_mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.workerdb_create(ptr0, len0, isLikeNone(hot_threshold) ? 0x100000001 : (hot_threshold) >>> 0, ptr1, len1, ptr2, len2, isLikeNone(max_body_size) ? 0x100000001 : (max_body_size) >>> 0, isLikeNone(max_keys_per_request) ? 0x100000001 : (max_keys_per_request) >>> 0, isLikeNone(in_memory) ? 0xFFFFFF : in_memory ? 1 : 0);
+        const ret = wasm.workerdb_create(ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(max_body_size) ? 0x100000001 : (max_body_size) >>> 0, isLikeNone(max_keys_per_request) ? 0x100000001 : (max_keys_per_request) >>> 0, isLikeNone(in_memory) ? 0xFFFFFF : in_memory ? 1 : 0);
         return takeObject(ret);
     }
     /**
@@ -130,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.
@@ -275,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;
@@ -420,7 +373,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_4230(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_4178(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -455,14 +408,6 @@ function __wbg_get_imports() {
             const ret = Date.now();
             return ret;
         },
-        __wbg_now_e7c6795a7f81e10f: function(arg0) {
-            const ret = getObject(arg0).now();
-            return ret;
-        },
-        __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
-            const ret = getObject(arg0).performance;
-            return addHeapObject(ret);
-        },
         __wbg_process_44c7a14e11e9f69e: function(arg0) {
             const ret = getObject(arg0).process;
             return addHeapObject(ret);
@@ -567,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: 774, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_4220);
+            // 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) {
@@ -610,10 +555,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_4220(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_4220(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) {
@@ -624,8 +569,8 @@ function __wasm_bindgen_func_elem_4220(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_4230(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_4230(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

@@ -2,12 +2,11 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_workerdb_free: (a: number, b: number) => void;
-export const workerdb_analytics: (a: number, b: number, c: number, d: number) => void;
-export const workerdb_create: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
+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_4220: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_4230: (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.7.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",