@moltendb-web/core 0.1.0-beta.1 → 0.1.0-rc.1

package/LICENSE.md

@@ -1,35 +1,21 @@
-# MoltenDB License
-
-MoltenDB is dual-licensed:
-
-1. **Free for Startups & Personal Use:** Licensed under the Business Source License (BSL) 1.1 with an Additional Use Grant (see below).
-2. **Commercial/Enterprise Use:** For companies exceeding the revenue threshold, or companies wishing to provide MoltenDB as a managed cloud service, a commercial license is required. Contact: [maximilian.both27@outlook.com]
-
----
-
-## Business Source License 1.1
-
-License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
-"Business Source License" is a trademark of MariaDB Corporation Ab.
-
-**Licensor:** Maximilian Both.
-**Licensed Work:** The MoltenDB source code and compiled binaries.
-**Change Date:** 3 years after the publication of each specific version/release.
-**Change License:** MIT License
-
-### Additional Use Grant
-
-You may make use of the Licensed Work (including running it in production) provided that your organization (including any parent companies, subsidiaries, and affiliates) meets **ALL** of the following conditions:
-
-1. **Revenue Limit:** Your organization's total annual gross revenue does not exceed $5,000,000 USD (or equivalent).
-2. **Not a Managed Service:** You do not offer the Licensed Work to third parties as a hosted or managed service (e.g., Database-as-a-Service, Backend-as-a-Service), regardless of your company's revenue.
-
-If you meet these conditions, the Licensor grants you a non-exclusive, royalty-free, worldwide license to reproduce, use, merge, publish, distribute, and modify the Licensed Work.
-
-If your organization exceeds the Revenue Limit, or if you wish to provide the Licensed Work as a managed service, you must purchase a Commercial License from the Licensor.
-
-### BSL General Terms
-
-If your use of the Licensed Work does not comply with the Additional Use Grant, you may still use the Licensed Work strictly for non-production, internal testing, and development purposes.
-
-Effective on the Change Date, or the fourth anniversary of the first publicly available distribution of a specific version of the Licensed Work under this License, whichever comes first, the Licensor hereby grants you rights under the terms of the Change License (MIT License), and the terms of this Business Source License will terminate for that specific version.
+MIT License
+
+Copyright (c) 2026 Maximilian Both
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -9,8 +9,9 @@
   [Interactive Demo](https://stackblitz.com/~/github.com/maximilian27/moltendb-wasm-demo?file=package.json) • [Core Engine](https://www.npmjs.com/package/@moltendb-web/core) • [Query Builder](https://www.npmjs.com/package/@moltendb-web/query) • [Original Repository](https://github.com/maximilian27/MoltenDB) • [License](LICENSE.md)
 
   [![NPM Version](https://img.shields.io/npm/v/@moltendb-web/core?style=flat-square&color=orange)](https://www.npmjs.com/package/@moltendb-web/core)
-  [![License](https://img.shields.io/badge/license-BSL%201.1-blue?style=flat-square)](LICENSE.md)
+  [![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-release%20candidate-brightgreen?style=flat-square)]()
 
 </div>
 
@@ -20,6 +21,8 @@
 
 MoltenDB is a JSON document database written in Rust that runs directly in your browser. Unlike traditional browser databases limited by `localStorage` quotas or IndexedDB's complex API, MoltenDB leverages the **Origin Private File System (OPFS)** to provide a high-performance, append-only storage engine.
 
+> **🚀 Release Candidate** — The core engine, multi-tab sync, and storage layer are feature-complete and stabilised for v1. Server sync, encryption and analytics are planned for a future release.
+
 ### 🎮 Explore the Full Functionality
 
 The best way to experience MoltenDB is through the **[Interactive Demo on StackBlitz](https://stackblitz.com/~/github.com/maximilian27/moltendb-wasm-demo?file=package.json)**. It provides a complete, live environment where you can test query builder expressions, perform mutations, and see real-time events with zero local setup.
@@ -32,6 +35,9 @@ Prefer to run it in your own environment? You can **[clone the demo repository](
 - **Pure Rust Engine:** The same query logic used in our server binary, compiled to WebAssembly.
 - **OPFS Persistence:** Data persists across page reloads in a dedicated, high-speed sandbox.
 - **Worker-Threaded:** The database runs entirely inside a Web Worker—zero impact on your UI thread.
+- **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.
+- **Real-Time Pub/Sub (`onEvent`):** Every write and delete emits a typed `DBEvent` to all open tabs instantly — no polling, no extra infrastructure.
 - **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.
@@ -50,7 +56,30 @@ 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.
 
+**For Vite:**
+Exclude the core package from pre-bundling in your vite.config.js:
+
+```js
+// vite.config.js`
+export default defineConfig({
+  optimizeDeps: { exclude: ['@moltendb-web/core'] }
+});
+```
+
+**For Webpack 5 (Next.js, Create React App):**
+Ensure Webpack treats the `.wasm` binary as a static resource in `webpack.config.js`:
+
+```js
+module.exports = {
+  module: {
+    rules: [{ test: /\.wasm$/, type: 'asset/resource' }]
+  }
+};
+```
 ---
 
 # Quick Start
@@ -62,12 +91,11 @@ TypeScript
 import { MoltenDB } from '@moltendb-web/core';
 import { MoltenDBClient, WorkerTransport } from '@moltendb-web/query';
 
-const workerUrl = new URL('@moltendb-web/core/worker', import.meta.url).href;
-const db = new MoltenDB('moltendb_demo', { syncEnabled: false, workerUrl });
+const db = new MoltenDB('moltendb_demo');
 await db.init();
 
 // Connect the query builder to the WASM worker
-const client = new MoltenDBClient(new WorkerTransport(db.worker));
+const client = new MoltenDBClient(db);
 
 // 2. Insert and Query
 
@@ -222,9 +250,63 @@ await client.collection('laptops')
 
 MoltenDB uses an append-only JSON log. Every write is a new line, ensuring your data is safe even if the tab is closed unexpectedly.
 
-- **Compaction:** When the log exceeds 5MB or 500 entries, the engine automatically "squashes" the log, removing old versions of documents to save space.
+- **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.
 
+### Multi-Tab Sync
+
+MoltenDB uses the **Web Locks API** for leader election. The first tab to acquire the lock becomes the *leader* and owns the OPFS file handle directly. Every subsequent tab becomes a *follower* and proxies all reads and writes through a `BroadcastChannel` to the leader.
+
+When the leader tab is closed, the next queued follower automatically acquires the lock and promotes itself to leader — no data loss, no manual reconnection required.
+
+```
+Tab 1 (Leader) ──owns──▶ Web Worker ──▶ WASM Engine ──▶ OPFS
+     │
+     └── BroadcastChannel ──▶ Tab 2 (Follower)
+                          ──▶ Tab 3 (Follower)
+```
+
+### Real-Time Events (Pub/Sub)
+
+MoltenDB has a built-in pub/sub system that automatically notifies **all open tabs** whenever a document is created, updated, or deleted — no polling required.
+
+Assign a callback to `onEvent` after calling `init()`:
+
+```ts
+const db = new MoltenDB('my-app');
+await db.init();
+
+db.onEvent = (event) => {
+  console.log(event.event);      // 'change' | 'delete' | 'drop'
+  console.log(event.collection); // e.g. 'laptops'
+  console.log(event.key);        // e.g. 'lp1'
+  console.log(event.new_v);      // new version number, or null on delete
+};
+```
+
+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.onEvent = ({ event, collection, key }) => {
+  if (collection === 'laptops') {
+    refreshLaptopList(); // re-query and re-render
+  }
+};
+```
+
+The `DBEvent` type is exported from the package for full TypeScript support:
+
+```ts
+import { MoltenDB, DBEvent } from '@moltendb-web/core';
+
+const db = new MoltenDB('my-app');
+await db.init();
+
+db.onEvent = (e: DBEvent) => { /* fully typed */ };
+```
+
+---
+
 ### Performance Note
 
 Because MoltenDB uses OPFS, your browser must support `SharedArrayBuffer`. Most modern browsers support this, but your server must send the following headers:
@@ -234,6 +316,39 @@ Cross-Origin-Opener-Policy: same-origin
 Cross-Origin-Embedder-Policy: require-corp
 ```
 
+---
+
+## Testing
+
+The core package ships with a comprehensive test suite built on **Vitest**:
+
+```bash
+cd packages/core
+npm test              # run all unit & integration tests
+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 |
+| `onEvent` hook | 2 | Real-time event delivery to leader and followers |
+| 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.**
+
+---
+
 ## Project Structure
 
 This monorepo contains the following packages:
@@ -243,17 +358,26 @@ This monorepo contains the following packages:
 
 ## Roadmap
 
-- [ ] ~~**Multi-Tab Sync:** Leader election for multiple tabs to share a single OPFS instance.~~ ✅
+- [x] **Multi-Tab Sync:** Leader election for multiple tabs to share a single OPFS instance — **stabilised in RC1**.
+- [x] **Automatic Compaction:** Log compacts automatically at 500 entries or 5 MB — **stabilised in RC1**.
+- [x] **Rich Test Suite:** 50 unit, integration, and stress tests via Vitest — **stabilised in RC1**.
+- [ ] **React Adapter:** Official `@moltendb-web/react` package with `useQuery` hooks and real-time context providers.
+- [ ] **Angular Adapter:** Official `@moltendb-web/angular` package featuring RxJS observables and Signal-based data fetching.
 - [ ] **Delta Sync:** Automatic two-way sync with the MoltenDB Rust server.
-- [ ] **Analytics functionality:** Run analytics queries straight in the browser. 
+- [ ] **Data Encryption:** Transparent encryption-at-rest using hardware-backed keys (Web Crypto API).
+- [ ] **Analytics Functionality:** Run complex analytics queries straight in the browser without blocking the UI.
 
-## License
 
-MoltenDB is licensed under the **Business Source License 1.1**.
+## Contributing & Feedback
 
-- Free for personal use and organizations with annual revenue under $5 million USD.
-- Converts to MIT automatically 3 years after each version's release date.
+Found a bug or have a feature request? Please open an issue on the [GitHub issue tracker](https://github.com/maximilian27/moltendb-web/issues).
 
-For commercial licensing or questions: [maximilian.both27@outlook.com](mailto:maximilian.both27@outlook.com)
+---
+
+## License
+
+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)

package/dist/index.d.ts

@@ -9,6 +9,8 @@ export interface MoltenDBOptions {
     syncIntervalMs?: number;
     /** JWT token for WebSocket authentication. */
     authToken?: string;
+    /** Called whenever a DB mutation event is broadcast (all tabs). */
+    onEvent?: (event: DBEvent) => void;
 }
 export type SyncCallback = (update: {
     event: 'change' | 'delete' | 'drop';
@@ -16,11 +18,17 @@ export type SyncCallback = (update: {
     key: string;
     new_v: number | null;
 }) => void;
+export interface DBEvent {
+    type: 'event';
+    event: 'change' | 'delete' | 'drop';
+    collection: string;
+    key: string;
+    new_v: number | null;
+}
 export declare class MoltenDB {
     readonly dbName: string;
-    readonly workerUrl: string | URL;
+    readonly workerUrl?: string | URL;
     worker: Worker | null;
-    private messageId;
     private pendingRequests;
     isLeader: boolean;
     private bc;
@@ -33,17 +41,18 @@ export declare class MoltenDB {
     private syncQueue;
     private syncTimer;
     /** ⚡ Hook to listen to native real-time DB mutations (works on all tabs) */
-    onEvent?: (event: any) => void;
+    onEvent?: (event: DBEvent) => void;
     constructor(dbName?: string, options?: MoltenDBOptions);
+    private initialized;
     init(): Promise<void>;
     private startAsLeader;
     private startAsFollower;
     sendMessage(action: string, payload?: Record<string, unknown>): Promise<any>;
-    set(collection: string, key: string, value: Record<string, unknown>, options?: {
+    set(collection: string, key: string, value: any, options?: {
         skipSync?: boolean;
     }): Promise<void>;
     get(collection: string, key: string): Promise<unknown>;
-    getAll(collection: string): Promise<unknown>;
+    getAll(collection: string): Promise<unknown[]>;
     delete(collection: string, key: string, options?: {
         skipSync?: boolean;
     }): Promise<void>;

package/dist/index.js

@@ -2,7 +2,6 @@ export class MoltenDB {
     dbName;
     workerUrl;
     worker = null;
-    messageId = 0;
     pendingRequests = new Map();
     // Multi-tab Sync State
     isLeader = false;
@@ -20,32 +19,37 @@ export class MoltenDB {
     onEvent;
     constructor(dbName = 'moltendb', options = {}) {
         this.dbName = dbName;
-        // Zero-config default worker resolution
-        this.workerUrl = options.workerUrl ?? new URL('./moltendb-worker.js', import.meta.url).href;
+        this.workerUrl = options.workerUrl;
         this.syncEnabled = options.syncEnabled ?? false;
         this.serverUrl = options.serverUrl ?? 'wss://localhost:3000/ws';
         this.syncIntervalMs = options.syncIntervalMs ?? 5000;
         this.authToken = options.authToken;
+        if (options.onEvent)
+            this.onEvent = options.onEvent;
     }
+    initialized = false;
     async init() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
         this.bc = new BroadcastChannel(`moltendb_channel_${this.dbName}`);
-        return new Promise((resolveInit) => {
-            // 1. Try to grab the lock immediately (Leader Election)
+        return new Promise((resolveInit, rejectInit) => {
             navigator.locks.request(`moltendb_lock_${this.dbName}`, { ifAvailable: true }, async (lock) => {
                 if (lock) {
-                    // We got the lock! We are the active DB host.
-                    await this.startAsLeader();
-                    resolveInit();
-                    // Return a promise that never resolves to hold the lock until the tab closes
-                    return new Promise(() => { });
+                    try {
+                        await this.startAsLeader();
+                        resolveInit();
+                    }
+                    catch (err) {
+                        rejectInit(err);
+                    }
+                    return new Promise(() => { }); // Hold lock
                 }
                 else {
-                    // Lock is taken. We are a proxy follower.
                     this.startAsFollower();
                     resolveInit();
-                    // 2. Queue up in the background. If the Leader tab closes, this lock resolves!
-                    navigator.locks.request(`moltendb_lock_${this.dbName}`, async (fallbackLock) => {
-                        console.log(`[MoltenDB] Previous leader disconnected. Promoting this tab to Leader.`);
+                    navigator.locks.request(`moltendb_lock_${this.dbName}`, async () => {
+                        console.log(`[MoltenDB] Promoting this tab to Leader.`);
                         await this.startAsLeader();
                         return new Promise(() => { }); // Hold lock
                     });
@@ -54,22 +58,27 @@ export class MoltenDB {
         });
     }
     async startAsLeader() {
+        // Guard: OPFS is required
+        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(); // Clean slate if promoted
-        this.worker = new Worker(this.workerUrl, { type: 'module', name: `moltendb-${this.dbName}-leader` });
-        // Handle messages strictly from our local 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') {
-                // Trigger local UI hook
                 if (this.onEvent)
                     this.onEvent(data);
-                // Broadcast the native event to all Follower tabs
                 this.bc.postMessage(data);
                 return;
             }
-            // Resolve pending local promises
             const req = this.pendingRequests.get(data.id);
             if (req) {
                 if (data.error)
@@ -79,13 +88,8 @@ export class MoltenDB {
                 this.pendingRequests.delete(data.id);
             }
         };
-        // Initialize the WASM Engine
-        await new Promise((resolve, reject) => {
-            const id = this.messageId++;
-            this.pendingRequests.set(id, { resolve, reject });
-            this.worker.postMessage({ id, action: 'init', dbName: this.dbName, workerUrl: this.workerUrl });
-        });
-        // Listen to the BroadcastChannel for queries coming from Follower tabs
+        // Wait for worker to boot
+        await this.sendMessage('init', { dbName: this.dbName });
         this.bc.onmessage = async (e) => {
             const msg = e.data;
             if (msg.type === 'query' && msg.action) {
@@ -98,29 +102,23 @@ export class MoltenDB {
                 }
             }
         };
-        // If backend sync is enabled, only the Leader manages the WebSocket
-        if (this.syncEnabled) {
+        if (this.syncEnabled)
             this.startSync();
-        }
     }
     startAsFollower() {
         this.isLeader = false;
-        // We don't need a worker, we rely on the Leader.
         if (this.worker) {
             this.worker.terminate();
             this.worker = null;
         }
-        // Listen to the BroadcastChannel for answers from the Leader
         this.bc.onmessage = (e) => {
             const data = e.data;
             if (data.type === 'event') {
-                // Trigger local UI hook as if it happened in this tab
                 if (this.onEvent)
                     this.onEvent(data);
                 return;
             }
             if (data.type === 'response') {
-                // Resolve our proxied promises
                 const req = this.pendingRequests.get(data.id);
                 if (req) {
                     if (data.error)
@@ -133,31 +131,63 @@ export class MoltenDB {
         };
     }
     async sendMessage(action, payload) {
-        const id = this.messageId++;
+        // FIX: Use random UUIDs so tabs don't collide on message IDs
+        const id = crypto.randomUUID();
         return new Promise((resolve, reject) => {
-            this.pendingRequests.set(id, { resolve, reject });
             if (this.isLeader && this.worker) {
-                // Direct execution on the local Worker
+                this.pendingRequests.set(id, { resolve, reject });
                 this.worker.postMessage({ id, action, ...payload });
             }
             else {
-                // Proxy the request to the Leader tab
+                const timer = setTimeout(() => {
+                    if (this.pendingRequests.has(id)) {
+                        this.pendingRequests.delete(id);
+                        reject(new Error(`[MoltenDB] Request "${action}" timed out.`));
+                    }
+                }, 10000);
+                this.pendingRequests.set(id, {
+                    resolve: (v) => { clearTimeout(timer); resolve(v); },
+                    reject: (e) => { clearTimeout(timer); reject(e); }
+                });
                 this.bc.postMessage({ type: 'query', id, action, payload });
             }
         });
     }
-    // ── Convenience CRUD helpers ──────────────────────────────────────────────
+    // ── Convenience CRUD helpers (CLEANED - NO DUPLICATES) ─────────────────────
     async set(collection, key, value, options = {}) {
         await this.sendMessage('set', { collection, data: { [key]: value } });
         if (this.syncEnabled && !options.skipSync && this.isLeader) {
             this.syncQueue.push({ action: 'set', collection, data: { [key]: value } });
         }
     }
-    get(collection, key) {
-        return this.sendMessage('get', { collection, keys: key });
+    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;
+        }
     }
-    getAll(collection) {
-        return this.sendMessage('get', { collection });
+    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, options = {}) {
         await this.sendMessage('delete', { collection, keys: key });
@@ -184,7 +214,8 @@ export class MoltenDB {
                         cb(msg);
                 }
             }
-            catch (err) { }
+            catch (err) {
+            }
         };
         this.syncTimer = setInterval(async () => {
             if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
@@ -208,7 +239,9 @@ export class MoltenDB {
     }
     terminate() {
         this.disconnect();
-        if (this.worker)
+        if (this.worker) {
             this.worker.terminate();
+            this.worker = null;
+        }
     }
 }

package/dist/moltendb-worker.js

@@ -1,36 +1,55 @@
 import init, { WorkerDb } from './moltendb.js';
-let db;
+let db = null;
+let initPromise = null;
 self.onmessage = async (e) => {
     const { id, action, ...payload } = e.data;
-    // --- Initialization Phase ---
+    // --- 1. Initialization Phase ---
     if (action === 'init') {
+        if (!initPromise) {
+            initPromise = (async () => {
+                await init();
+                // FIX: You must await the async constructor
+                const instance = await new WorkerDb(payload.dbName);
+                // Listen to Rust and broadcast events
+                instance.subscribe((eventStr) => {
+                    try {
+                        const eventData = JSON.parse(eventStr);
+                        self.postMessage({ type: 'event', ...eventData });
+                    }
+                    catch (err) {
+                        console.error('[MoltenDB Worker] Event parse error', err);
+                    }
+                });
+                db = instance;
+                return instance;
+            })();
+        }
         try {
-            await init();
-            db = await new WorkerDb(payload.dbName);
-            // THE NATIVE FEED: Listen to Rust and broadcast to the main thread
-            db.subscribe((eventStr) => {
-                try {
-                    const eventData = JSON.parse(eventStr);
-                    // Use type: 'event' so the transport knows it's an unsolicited broadcast
-                    self.postMessage({ type: 'event', ...eventData });
-                }
-                catch (err) {
-                    console.error('[MoltenDB Worker] Failed to parse event', err);
-                }
-            });
+            await initPromise;
             self.postMessage({ id, result: { status: 'ok' } });
         }
         catch (error) {
-            self.postMessage({ id, error: String(error) });
+            // FIX: Handle Map-based errors from Rust correctly
+            const errorMsg = (error instanceof Map)
+                ? JSON.stringify(Object.fromEntries(error))
+                : String(error);
+            self.postMessage({ id, error: errorMsg });
         }
         return;
     }
-    // --- Standard Request/Response Phase ---
+    // --- 2. Standard Request/Response Phase ---
     try {
-        const result = db.handle_message({ action, ...payload });
+        if (!initPromise)
+            throw new Error("Worker not initialized");
+        const currentDb = await initPromise;
+        const result = currentDb.handle_message({ action, ...payload });
         self.postMessage({ id, result });
     }
     catch (error) {
-        self.postMessage({ id, error: String(error) });
+        // FIX: Handle Map-based errors here too
+        const errorMsg = (error instanceof Map)
+            ? JSON.stringify(Object.fromEntries(error))
+            : String(error);
+        self.postMessage({ id, error: errorMsg });
     }
 };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@moltendb-web/core",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-rc.1",
   "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>",
-  "license": "LICENSE.md",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/maximilian27/moltendb-web/tree/master/packages/core"
@@ -19,7 +19,10 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./worker": "./dist/moltendb-worker.js",
+    "./worker": {
+      "import": "./dist/moltendb-worker.js",
+      "types": "./dist/moltendb-worker.d.ts"
+    },
     "./wasm": "./dist/moltendb.js",
     "./wasm-bg": "./dist/moltendb_bg.wasm"
   },
@@ -28,10 +31,20 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build",
+    "test:e2e": "playwright test"
   },
   "devDependencies": {
-    "typescript": "^6.0.1-rc"
+    "@playwright/test": "^1.58.2",
+    "@vitest/coverage-v8": "^4.1.1",
+    "happy-dom": "^20.8.7",
+    "typescript": "^6.0.2",
+    "vite": "^8.0.2",
+    "vitest": "^4.1.1"
   },
   "keywords": [
     "database",
@@ -43,4 +56,4 @@
     "indexeddb",
     "embedded"
   ]
-}
+}