@moltendb-web/core 0.1.0-beta.2 → 1.0.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:** 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.
@@ -244,9 +250,66 @@ 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.
+
+You can attach multiple independent listeners using the subscribe() method, making it trivial to keep different UI components (like React hooks or Angular signals) in sync without memory leaks:
+
+```ts
+const db = new MoltenDB('my-app');
+await db.init();
+
+// Attach a listener (Returns an unsubscribe function)
+const unsubscribe = db.subscribe((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
+});
+
+// Later, when the UI component unmounts:
+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 }) => {
+  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.subscribe((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:
@@ -256,6 +319,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 |
+| `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.**
+
+---
+
 ## Project Structure
 
 This monorepo contains the following packages:
@@ -265,17 +361,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

@@ -1,55 +1,43 @@
 export interface MoltenDBOptions {
     /** URL or path to moltendb-worker.js. */
     workerUrl?: string | URL;
-    /** Enable WebSocket sync with a MoltenDB server. Default: false. */
-    syncEnabled?: boolean;
-    /** WebSocket server URL. Default: 'wss://localhost:1538/ws'. */
-    serverUrl?: string;
-    /** Sync batch flush interval in ms. Default: 5000. */
-    syncIntervalMs?: number;
-    /** JWT token for WebSocket authentication. */
-    authToken?: string;
 }
-export type SyncCallback = (update: {
+export interface DBEvent {
+    type: 'event';
     event: 'change' | 'delete' | 'drop';
     collection: string;
     key: string;
     new_v: number | null;
-}) => void;
+}
 export declare class MoltenDB {
     readonly dbName: string;
     readonly workerUrl?: string | URL;
     worker: Worker | null;
-    private messageId;
     private pendingRequests;
     isLeader: boolean;
     private bc;
-    private syncEnabled;
-    private serverUrl;
-    private syncIntervalMs;
-    private authToken?;
-    private ws;
-    private syncCallbacks;
-    private syncQueue;
-    private syncTimer;
-    /** ⚡ Hook to listen to native real-time DB mutations (works on all tabs) */
-    onEvent?: (event: any) => void;
+    /** Legacy global hook. Use `subscribe()` for multi-component listeners. */
+    onEvent?: (event: DBEvent) => void;
+    private eventListeners;
     constructor(dbName?: string, options?: MoltenDBOptions);
+    /**
+     * ⚡ Subscribe to real-time DB mutations.
+     * @returns An unsubscribe function to prevent memory leaks in UI frameworks.
+     */
+    subscribe(listener: (event: DBEvent) => void): () => void;
+    /** Manually remove a specific listener */
+    unsubscribe(listener: (event: DBEvent) => void): void;
+    private dispatchEvent;
+    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?: {
-        skipSync?: boolean;
-    }): Promise<void>;
+    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, options?: {
-        skipSync?: boolean;
-    }): Promise<void>;
+    getAll(collection: string): Promise<unknown[]>;
+    delete(collection: string, key: string): Promise<void>;
     compact(): Promise<unknown>;
-    private startSync;
-    onSyncEvent(callback: SyncCallback): void;
     disconnect(): void;
     terminate(): void;
 }

package/dist/index.js

@@ -2,49 +2,65 @@ export class MoltenDB {
     dbName;
     workerUrl;
     worker = null;
-    messageId = 0;
     pendingRequests = new Map();
     // Multi-tab Sync State
     isLeader = false;
     bc;
-    // Server Sync State
-    syncEnabled;
-    serverUrl;
-    syncIntervalMs;
-    authToken;
-    ws = null;
-    syncCallbacks = [];
-    syncQueue = [];
-    syncTimer = null;
-    /** ⚡ Hook to listen to native real-time DB mutations (works on all tabs) */
+    /** Legacy global hook. Use `subscribe()` for multi-component listeners. */
     onEvent;
+    // ── Multi-Subscriber Event System ──────────────────────────────────────────
+    eventListeners = new Set();
     constructor(dbName = 'moltendb', options = {}) {
         this.dbName = dbName;
         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;
     }
+    /**
+     * ⚡ Subscribe to real-time DB mutations.
+     * @returns An unsubscribe function to prevent memory leaks in UI frameworks.
+     */
+    subscribe(listener) {
+        this.eventListeners.add(listener);
+        return () => this.eventListeners.delete(listener);
+    }
+    /** Manually remove a specific listener */
+    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);
+            }
+        }
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    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
                     });
@@ -53,28 +69,26 @@ export class MoltenDB {
         });
     }
     async startAsLeader() {
-        this.isLeader = true;
-        if (this.worker)
-            this.worker.terminate(); // Clean slate if promoted
-        // We must inline `new URL` directly inside `new Worker` so bundlers catch it!
-        if (this.workerUrl) {
-            this.worker = new Worker(this.workerUrl, { type: 'module', name: `moltendb-${this.dbName}-leader` });
+        // Guard: OPFS is required
+        try {
+            await navigator.storage.getDirectory();
         }
-        else {
-            this.worker = new Worker(new URL('./moltendb-worker.js', import.meta.url), { type: 'module', name: `moltendb-${this.dbName}-leader` });
+        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+).');
         }
-        // Handle messages strictly from our local Worker
+        this.isLeader = true;
+        if (this.worker)
+            this.worker.terminate();
+        const url = this.workerUrl || new URL('./moltendb-worker.js', import.meta.url);
+        this.worker = new Worker(url, { type: 'module', name: `moltendb-${this.dbName}-leader` });
         this.worker.onmessage = (e) => {
             const data = e.data;
             if (data.type === 'event') {
-                // Trigger local UI hook
-                if (this.onEvent)
-                    this.onEvent(data);
-                // Broadcast the native event to all Follower tabs
+                this.dispatchEvent(data); // ⬅️ Trigger new dispatcher
                 this.bc.postMessage(data);
                 return;
             }
-            // Resolve pending local promises
             const req = this.pendingRequests.get(data.id);
             if (req) {
                 if (data.error)
@@ -84,13 +98,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 });
-        });
-        // 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) {
@@ -103,29 +112,20 @@ export class MoltenDB {
                 }
             }
         };
-        // If backend sync is enabled, only the Leader manages the WebSocket
-        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);
+                this.dispatchEvent(data); // ⬅️ Trigger new dispatcher
                 return;
             }
             if (data.type === 'response') {
-                // Resolve our proxied promises
                 const req = this.pendingRequests.get(data.id);
                 if (req) {
                     if (data.error)
@@ -138,82 +138,75 @@ export class MoltenDB {
         };
     }
     async sendMessage(action, payload) {
-        const id = this.messageId++;
+        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 ──────────────────────────────────────────────
-    async set(collection, key, value, options = {}) {
+    // ── Convenience CRUD helpers ───────────────────────────────────────────────
+    async set(collection, key, value) {
         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 = {}) {
+    async delete(collection, key) {
         await this.sendMessage('delete', { collection, keys: key });
-        if (this.syncEnabled && !options.skipSync && this.isLeader) {
-            this.syncQueue.push({ action: 'delete', collection, keys: key });
-        }
     }
     compact() {
         return this.sendMessage('compact');
     }
-    // ── Server Sync Implementation (Leader Only) ──────────────────────────────
-    startSync() {
-        this.ws = new WebSocket(this.serverUrl);
-        this.ws.onopen = () => {
-            if (this.authToken) {
-                this.ws?.send(JSON.stringify({ type: 'auth', token: this.authToken }));
-            }
-        };
-        this.ws.onmessage = (e) => {
-            try {
-                const msg = JSON.parse(e.data);
-                if (msg.event) {
-                    for (const cb of this.syncCallbacks)
-                        cb(msg);
-                }
-            }
-            catch (err) { }
-        };
-        this.syncTimer = setInterval(async () => {
-            if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
-                return;
-            if (this.syncQueue.length === 0)
-                return;
-            const batch = this.syncQueue.splice(0, this.syncQueue.length);
-            this.ws.send(JSON.stringify({ type: 'batch', operations: batch }));
-        }, this.syncIntervalMs);
-    }
-    onSyncEvent(callback) {
-        this.syncCallbacks.push(callback);
-    }
     disconnect() {
-        if (this.syncTimer)
-            clearInterval(this.syncTimer);
-        if (this.ws)
-            this.ws.close();
         if (this.bc)
             this.bc.close();
     }
     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/dist/moltendb.d.ts

@@ -93,9 +93,9 @@ export interface InitOutput {
     readonly workerdb_handle_message: (a: number, b: number, c: number) => void;
     readonly workerdb_new: (a: number, b: number) => number;
     readonly workerdb_subscribe: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_3624: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_3703: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_3716: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_3613: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_3697: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_3702: (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/moltendb.js

@@ -251,6 +251,9 @@ function __wbg_get_imports() {
             const ret = Object.entries(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_error_8d9a8e04cd1d3588: function(arg0) {
+            console.error(getObject(arg0));
+        },
         __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
@@ -386,7 +389,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_3716(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_3702(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -506,8 +509,8 @@ function __wbg_get_imports() {
             return ret;
         }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 663, function: Function { arguments: [Externref], shim_idx: 674, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3624, __wasm_bindgen_func_elem_3703);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 664, function: Function { arguments: [Externref], shim_idx: 677, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3613, __wasm_bindgen_func_elem_3697);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -544,10 +547,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_3703(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_3697(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_3703(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_3697(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -558,8 +561,8 @@ function __wasm_bindgen_func_elem_3703(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_3716(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_3716(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_3702(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_3702(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const WorkerDbFinalization = (typeof FinalizationRegistry === 'undefined')

package/dist/moltendb_bg.wasm.d.ts

@@ -6,9 +6,9 @@ export const workerdb_analytics: (a: number, b: number, c: number, d: number) =>
 export const workerdb_handle_message: (a: number, b: number, c: number) => void;
 export const workerdb_new: (a: number, b: number) => number;
 export const workerdb_subscribe: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_3624: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_3703: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_3716: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_3613: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_3697: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_3702: (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,10 +1,10 @@
 {
   "name": "@moltendb-web/core",
-  "version": "0.1.0-beta.2",
+  "version": "1.0.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.2"
+    "@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"
   ]
-}
+}