taladb 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 thinkgrid-labs
+
+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

@@ -0,0 +1,150 @@
+# taladb
+
+Local-first document database for React, React Native, and Node.js — powered by a Rust/WASM core with zero GC pauses.
+
+[![npm](https://img.shields.io/npm/v/taladb)](https://www.npmjs.com/package/taladb)
+[![License: MIT](https://img.shields.io/badge/License-MIT-orange.svg)](LICENSE)
+
+## What is TalaDB?
+
+TalaDB gives you a MongoDB-style document API that runs entirely on-device — in the browser via WASM + OPFS, in React Native via JSI, and in Node.js via a native module. No cloud, no sync server, no garbage-collection pauses.
+
+```ts
+import { openDB } from 'taladb';
+
+const db = await openDB('myapp.db');
+const users = db.collection('users');
+
+await users.createIndex('email');
+
+const id = await users.insert({ name: 'Alice', email: 'alice@example.com', age: 30 });
+
+const alice  = await users.findOne({ email: 'alice@example.com' });
+const adults = await users.find({ age: { $gte: 18 } });
+
+await users.updateOne({ email: 'alice@example.com' }, { $inc: { age: 1 } });
+await users.deleteOne({ email: 'alice@example.com' });
+
+await db.close();
+```
+
+## Installation
+
+```bash
+# npm
+npm install taladb
+
+# pnpm
+pnpm add taladb
+
+# yarn
+yarn add taladb
+```
+
+The package automatically loads the right backend for your platform:
+
+| Platform | Backend |
+|----------|---------|
+| Browser  | `@taladb/web` (WASM + OPFS) |
+| Node.js  | `@taladb/node` (napi-rs native module) |
+| React Native | `@taladb/react-native` (JSI TurboModule) |
+
+Install the appropriate platform package as well:
+
+```bash
+# Browser
+pnpm add taladb @taladb/web
+
+# Node.js
+pnpm add taladb @taladb/node
+
+# React Native
+pnpm add taladb @taladb/react-native
+```
+
+## API
+
+### Database
+
+```ts
+const db = await openDB(name?: string): Promise<TalaDB>
+
+db.collection<T>(name: string): Collection<T>
+db.close(): Promise<void>
+```
+
+### Collection
+
+```ts
+// Write
+col.insert(doc): Promise<string>                          // returns ULID id
+col.insertMany(docs): Promise<string[]>
+col.updateOne(filter, update): Promise<boolean>
+col.updateMany(filter, update): Promise<number>
+col.deleteOne(filter): Promise<boolean>
+col.deleteMany(filter): Promise<number>
+
+// Read
+col.find(filter?): Promise<T[]>
+col.findOne(filter): Promise<T | null>
+col.count(filter?): Promise<number>
+
+// Indexes
+col.createIndex(field): Promise<void>                     // idempotent
+col.dropIndex(field): Promise<void>
+```
+
+### Filters
+
+```ts
+{ field: value }                                // equality
+{ field: { $eq, $ne, $gt, $gte, $lt, $lte } }  // comparisons
+{ field: { $in: [...], $nin: [...] } }          // set membership
+{ field: { $exists: true | false } }            // field presence
+{ $and: [...filters] }
+{ $or: [...filters] }
+{ $not: filter }
+```
+
+### Updates
+
+```ts
+{ $set:   { field: value } }      // set or replace
+{ $unset: { field: true } }       // remove field
+{ $inc:   { field: number } }     // increment / decrement
+{ $push:  { field: value } }      // append to array
+{ $pull:  { field: value } }      // remove from array
+```
+
+## Migrations
+
+Run schema migrations at open time — each migration runs exactly once, in version order:
+
+```ts
+import { runMigrations } from 'taladb';
+
+await runMigrations(db, [
+  {
+    fromVersion: 0,
+    toVersion: 1,
+    description: 'add default role',
+    async up(col) {
+      await col('users').updateMany({}, { $set: { role: 'viewer' } });
+    },
+  },
+]);
+```
+
+## Full Documentation
+
+**[https://thinkgrid-labs.github.io/taladb](https://thinkgrid-labs.github.io/taladb)**
+
+- [Introduction](https://thinkgrid-labs.github.io/taladb/introduction)
+- [Web (Browser / WASM) Guide](https://thinkgrid-labs.github.io/taladb/guide/web)
+- [Node.js Guide](https://thinkgrid-labs.github.io/taladb/guide/node)
+- [React Native Guide](https://thinkgrid-labs.github.io/taladb/guide/react-native)
+- [API Reference](https://thinkgrid-labs.github.io/taladb/api/collection)
+
+## License
+
+MIT © [ThinkGrid Labs](https://github.com/thinkgrid-labs)

package/dist/index.d.mts

@@ -0,0 +1,91 @@
+type Value = null | boolean | number | string | Uint8Array | Value[] | {
+    [key: string]: Value;
+};
+type Document = {
+    _id?: string;
+    [key: string]: Value | undefined;
+};
+type FieldOps<T> = T extends null | undefined ? {
+    $exists?: boolean;
+} : {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $exists?: boolean;
+    /** Full-text search: matches documents where this string field contains the given token. */
+    $contains?: string;
+};
+type Filter<T extends Document = Document> = {
+    [K in keyof T]?: T[K] | FieldOps<T[K]>;
+} & {
+    $and?: Filter<T>[];
+    $or?: Filter<T>[];
+    $not?: Filter<T>;
+};
+type Update<T extends Document = Document> = {
+    $set?: Partial<T>;
+    $unset?: {
+        [K in keyof T]?: true;
+    };
+    $inc?: {
+        [K in keyof T]?: number;
+    };
+    $push?: {
+        [K in keyof T]?: Value;
+    };
+    $pull?: {
+        [K in keyof T]?: Value;
+    };
+};
+interface Collection<T extends Document = Document> {
+    insert(doc: Omit<T, '_id'>): Promise<string>;
+    insertMany(docs: Omit<T, '_id'>[]): Promise<string[]>;
+    find(filter?: Filter<T>): Promise<T[]>;
+    findOne(filter: Filter<T>): Promise<T | null>;
+    updateOne(filter: Filter<T>, update: Update<T>): Promise<boolean>;
+    updateMany(filter: Filter<T>, update: Update<T>): Promise<number>;
+    deleteOne(filter: Filter<T>): Promise<boolean>;
+    deleteMany(filter: Filter<T>): Promise<number>;
+    count(filter?: Filter<T>): Promise<number>;
+    createIndex(field: keyof Omit<T, '_id'> & string): Promise<void>;
+    dropIndex(field: keyof Omit<T, '_id'> & string): Promise<void>;
+    /**
+     * Subscribe to live query results. The callback receives a full snapshot of
+     * matching documents immediately and again after every write that could
+     * affect the result set.
+     *
+     * @returns An unsubscribe function. Call it to stop receiving updates.
+     *
+     * @example
+     * const unsub = users.subscribe({ active: true }, (docs) => {
+     *   console.log('active users:', docs);
+     * });
+     * // later…
+     * unsub();
+     */
+    subscribe(filter: Filter<T>, callback: (docs: T[]) => void): () => void;
+}
+interface TalaDB {
+    collection<T extends Document = Document>(name: string): Collection<T>;
+    close(): Promise<void>;
+}
+
+/**
+ * Open a TalaDB database.
+ *
+ * @param dbName  Name of the database file (used for OPFS and native file paths).
+ *                Ignored for in-memory databases.
+ *
+ * @example
+ * const db = await openDB('myapp.db');
+ * const users = db.collection<User>('users');
+ * const id = await users.insert({ name: 'Alice', age: 30 });
+ */
+declare function openDB(dbName?: string): Promise<TalaDB>;
+
+export { type Collection, type Document, type Filter, type TalaDB, type Update, type Value, openDB };

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+type Value = null | boolean | number | string | Uint8Array | Value[] | {
+    [key: string]: Value;
+};
+type Document = {
+    _id?: string;
+    [key: string]: Value | undefined;
+};
+type FieldOps<T> = T extends null | undefined ? {
+    $exists?: boolean;
+} : {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $exists?: boolean;
+    /** Full-text search: matches documents where this string field contains the given token. */
+    $contains?: string;
+};
+type Filter<T extends Document = Document> = {
+    [K in keyof T]?: T[K] | FieldOps<T[K]>;
+} & {
+    $and?: Filter<T>[];
+    $or?: Filter<T>[];
+    $not?: Filter<T>;
+};
+type Update<T extends Document = Document> = {
+    $set?: Partial<T>;
+    $unset?: {
+        [K in keyof T]?: true;
+    };
+    $inc?: {
+        [K in keyof T]?: number;
+    };
+    $push?: {
+        [K in keyof T]?: Value;
+    };
+    $pull?: {
+        [K in keyof T]?: Value;
+    };
+};
+interface Collection<T extends Document = Document> {
+    insert(doc: Omit<T, '_id'>): Promise<string>;
+    insertMany(docs: Omit<T, '_id'>[]): Promise<string[]>;
+    find(filter?: Filter<T>): Promise<T[]>;
+    findOne(filter: Filter<T>): Promise<T | null>;
+    updateOne(filter: Filter<T>, update: Update<T>): Promise<boolean>;
+    updateMany(filter: Filter<T>, update: Update<T>): Promise<number>;
+    deleteOne(filter: Filter<T>): Promise<boolean>;
+    deleteMany(filter: Filter<T>): Promise<number>;
+    count(filter?: Filter<T>): Promise<number>;
+    createIndex(field: keyof Omit<T, '_id'> & string): Promise<void>;
+    dropIndex(field: keyof Omit<T, '_id'> & string): Promise<void>;
+    /**
+     * Subscribe to live query results. The callback receives a full snapshot of
+     * matching documents immediately and again after every write that could
+     * affect the result set.
+     *
+     * @returns An unsubscribe function. Call it to stop receiving updates.
+     *
+     * @example
+     * const unsub = users.subscribe({ active: true }, (docs) => {
+     *   console.log('active users:', docs);
+     * });
+     * // later…
+     * unsub();
+     */
+    subscribe(filter: Filter<T>, callback: (docs: T[]) => void): () => void;
+}
+interface TalaDB {
+    collection<T extends Document = Document>(name: string): Collection<T>;
+    close(): Promise<void>;
+}
+
+/**
+ * Open a TalaDB database.
+ *
+ * @param dbName  Name of the database file (used for OPFS and native file paths).
+ *                Ignored for in-memory databases.
+ *
+ * @example
+ * const db = await openDB('myapp.db');
+ * const users = db.collection<User>('users');
+ * const id = await users.insert({ name: 'Alice', age: 30 });
+ */
+declare function openDB(dbName?: string): Promise<TalaDB>;
+
+export { type Collection, type Document, type Filter, type TalaDB, type Update, type Value, openDB };

package/dist/index.js

@@ -0,0 +1,312 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  openDB: () => openDB
+});
+module.exports = __toCommonJS(index_exports);
+var import_meta = {};
+function detectPlatform() {
+  if (globalThis.nativeCallSyncHook !== void 0) {
+    return "react-native";
+  }
+  if (globalThis.window !== void 0 && typeof navigator !== "undefined") {
+    return "browser";
+  }
+  return "node";
+}
+var WorkerProxy = class {
+  constructor(port) {
+    this.pending = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.port = port;
+    this.port.onmessage = (e) => {
+      const { id, result, error } = e.data;
+      const p = this.pending.get(id);
+      if (p) {
+        this.pending.delete(id);
+        if (error === void 0) p.resolve(result);
+        else p.reject(new Error(error));
+      }
+    };
+    this.port.start();
+  }
+  send(op, args = {}) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      this.pending.set(id, { resolve, reject });
+      this.port.postMessage({ id, op, ...args });
+    });
+  }
+};
+async function createInMemoryBrowserDB(_dbName) {
+  const wasmUrl = new URL("@taladb/web/pkg/taladb_wasm.js", import_meta.url);
+  const wasm = await import(
+    /* @vite-ignore */
+    wasmUrl.href
+  );
+  await wasm.default();
+  const db = wasm.TalaDBWasm.openInMemory();
+  function wrapCollection(name) {
+    const col = db.collection(name);
+    return {
+      insert: async (doc) => col.insert(doc),
+      insertMany: async (docs) => col.insertMany(docs),
+      find: async (filter) => col.find(filter ?? null),
+      findOne: async (filter) => col.findOne(filter) ?? null,
+      updateOne: async (filter, update) => col.updateOne(filter, update),
+      updateMany: async (filter, update) => col.updateMany(filter, update),
+      deleteOne: async (filter) => col.deleteOne(filter),
+      deleteMany: async (filter) => col.deleteMany(filter),
+      count: async (filter) => col.count(filter ?? null),
+      createIndex: async (field) => col.createIndex(field),
+      dropIndex: async (field) => col.dropIndex(field),
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "";
+        const poll = async () => {
+          if (!active) return;
+          try {
+            const docs = await col.find(filter ?? null);
+            const json = JSON.stringify(docs);
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(docs);
+            }
+          } catch {
+          }
+          if (active) setTimeout(poll, 300);
+        };
+        poll();
+        return () => {
+          active = false;
+        };
+      }
+    };
+  }
+  return {
+    collection: (name) => wrapCollection(name),
+    close: async () => {
+    }
+  };
+}
+async function createBrowserDB(dbName) {
+  if (typeof SharedWorker === "undefined") {
+    return createInMemoryBrowserDB(dbName);
+  }
+  const workerUrl = new URL("@taladb/web/worker/taladb.worker.js", import_meta.url);
+  const worker = new SharedWorker(workerUrl, { type: "module", name: "taladb" });
+  const proxy = new WorkerProxy(worker.port);
+  await proxy.send("init", { dbName });
+  function wrapCollection(name) {
+    const s = JSON.stringify;
+    return {
+      insert: (doc) => proxy.send("insert", { collection: name, docJson: s(doc) }),
+      insertMany: async (docs) => {
+        const json = await proxy.send("insertMany", {
+          collection: name,
+          docsJson: s(docs)
+        });
+        return JSON.parse(json);
+      },
+      find: async (filter) => {
+        const json = await proxy.send("find", {
+          collection: name,
+          filterJson: filter ? s(filter) : "null"
+        });
+        return JSON.parse(json);
+      },
+      findOne: async (filter) => {
+        const json = await proxy.send("findOne", {
+          collection: name,
+          filterJson: filter ? s(filter) : "null"
+        });
+        return JSON.parse(json);
+      },
+      updateOne: (filter, update) => proxy.send("updateOne", {
+        collection: name,
+        filterJson: s(filter),
+        updateJson: s(update)
+      }),
+      updateMany: (filter, update) => proxy.send("updateMany", {
+        collection: name,
+        filterJson: s(filter),
+        updateJson: s(update)
+      }),
+      deleteOne: (filter) => proxy.send("deleteOne", { collection: name, filterJson: s(filter) }),
+      deleteMany: (filter) => proxy.send("deleteMany", { collection: name, filterJson: s(filter) }),
+      count: (filter) => proxy.send("count", {
+        collection: name,
+        filterJson: filter ? s(filter) : "null"
+      }),
+      createIndex: (field) => proxy.send("createIndex", { collection: name, field }),
+      dropIndex: (field) => proxy.send("dropIndex", { collection: name, field }),
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "";
+        const poll = async () => {
+          if (!active) return;
+          try {
+            const json = await proxy.send("find", {
+              collection: name,
+              filterJson: filter ? s(filter) : "null"
+            });
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(JSON.parse(json));
+            }
+          } catch {
+          }
+          if (active) setTimeout(poll, 300);
+        };
+        poll();
+        return () => {
+          active = false;
+        };
+      }
+    };
+  }
+  return {
+    collection: (name) => wrapCollection(name),
+    close: () => proxy.send("close")
+  };
+}
+async function createNodeDB(dbName) {
+  const { TalaDBNode } = await import("@taladb/node");
+  const db = TalaDBNode.open(dbName);
+  function wrapCollection(name) {
+    const col = db.collection(name);
+    return {
+      insert: async (doc) => col.insert(doc),
+      insertMany: async (docs) => col.insertMany(docs),
+      find: async (filter) => col.find(filter ?? null),
+      findOne: async (filter) => col.findOne(filter) ?? null,
+      updateOne: async (filter, update) => col.updateOne(filter, update),
+      updateMany: async (filter, update) => col.updateMany(filter, update),
+      deleteOne: async (filter) => col.deleteOne(filter),
+      deleteMany: async (filter) => col.deleteMany(filter),
+      count: async (filter) => col.count(filter ?? null),
+      createIndex: async (field) => col.createIndex(field),
+      dropIndex: async (field) => col.dropIndex(field),
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "";
+        const poll = async () => {
+          if (!active) return;
+          try {
+            const docs = await col.find(filter ?? null);
+            const json = JSON.stringify(docs);
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(docs);
+            }
+          } catch {
+          }
+          if (active) setTimeout(poll, 300);
+        };
+        poll();
+        return () => {
+          active = false;
+        };
+      }
+    };
+  }
+  return {
+    collection: (name) => wrapCollection(name),
+    close: async () => {
+    }
+  };
+}
+async function createNativeDB(_dbName) {
+  const maybeNative = globalThis.__TalaDB__;
+  if (!maybeNative) {
+    throw new Error(
+      "@taladb/react-native JSI HostObject not found. Did you call TalaDBModule.initialize() in your app entry point?"
+    );
+  }
+  const native = maybeNative;
+  function wrapCollection(name) {
+    const col = native.collection(name);
+    return {
+      insert: async (doc) => col.insert(doc),
+      insertMany: async (docs) => col.insertMany(docs),
+      find: async (filter) => col.find(filter ?? {}),
+      findOne: async (filter) => col.findOne(filter ?? {}),
+      updateOne: async (filter, update) => col.updateOne(filter, update),
+      updateMany: async (filter, update) => col.updateMany(filter, update),
+      deleteOne: async (filter) => col.deleteOne(filter),
+      deleteMany: async (filter) => col.deleteMany(filter),
+      count: async (filter) => col.count(filter ?? {}),
+      createIndex: async (field) => col.createIndex(field),
+      dropIndex: async (field) => col.dropIndex(field),
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "";
+        const poll = () => {
+          if (!active) return;
+          try {
+            const docs = col.find(filter ?? {});
+            const json = JSON.stringify(docs);
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(docs);
+            }
+          } catch {
+          }
+          if (active) setTimeout(poll, 300);
+        };
+        poll();
+        return () => {
+          active = false;
+        };
+      }
+    };
+  }
+  return {
+    collection: (name) => wrapCollection(name),
+    close: async () => native.close()
+  };
+}
+async function openDB(dbName = "taladb.db") {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "browser":
+      return createBrowserDB(dbName);
+    case "react-native":
+      return createNativeDB(dbName);
+    case "node":
+      return createNodeDB(dbName);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDB
+});

package/dist/index.mjs

@@ -0,0 +1,276 @@
+// src/index.ts
+function detectPlatform() {
+  if (globalThis.nativeCallSyncHook !== void 0) {
+    return "react-native";
+  }
+  if (globalThis.window !== void 0 && typeof navigator !== "undefined") {
+    return "browser";
+  }
+  return "node";
+}
+var WorkerProxy = class {
+  constructor(port) {
+    this.pending = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.port = port;
+    this.port.onmessage = (e) => {
+      const { id, result, error } = e.data;
+      const p = this.pending.get(id);
+      if (p) {
+        this.pending.delete(id);
+        if (error === void 0) p.resolve(result);
+        else p.reject(new Error(error));
+      }
+    };
+    this.port.start();
+  }
+  send(op, args = {}) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      this.pending.set(id, { resolve, reject });
+      this.port.postMessage({ id, op, ...args });
+    });
+  }
+};
+async function createInMemoryBrowserDB(_dbName) {
+  const wasmUrl = new URL("@taladb/web/pkg/taladb_wasm.js", import.meta.url);
+  const wasm = await import(
+    /* @vite-ignore */
+    wasmUrl.href
+  );
+  await wasm.default();
+  const db = wasm.TalaDBWasm.openInMemory();
+  function wrapCollection(name) {
+    const col = db.collection(name);
+    return {
+      insert: async (doc) => col.insert(doc),
+      insertMany: async (docs) => col.insertMany(docs),
+      find: async (filter) => col.find(filter ?? null),
+      findOne: async (filter) => col.findOne(filter) ?? null,
+      updateOne: async (filter, update) => col.updateOne(filter, update),
+      updateMany: async (filter, update) => col.updateMany(filter, update),
+      deleteOne: async (filter) => col.deleteOne(filter),
+      deleteMany: async (filter) => col.deleteMany(filter),
+      count: async (filter) => col.count(filter ?? null),
+      createIndex: async (field) => col.createIndex(field),
+      dropIndex: async (field) => col.dropIndex(field),
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "";
+        const poll = async () => {
+          if (!active) return;
+          try {
+            const docs = await col.find(filter ?? null);
+            const json = JSON.stringify(docs);
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(docs);
+            }
+          } catch {
+          }
+          if (active) setTimeout(poll, 300);
+        };
+        poll();
+        return () => {
+          active = false;
+        };
+      }
+    };
+  }
+  return {
+    collection: (name) => wrapCollection(name),
+    close: async () => {
+    }
+  };
+}
+async function createBrowserDB(dbName) {
+  if (typeof SharedWorker === "undefined") {
+    return createInMemoryBrowserDB(dbName);
+  }
+  const workerUrl = new URL("@taladb/web/worker/taladb.worker.js", import.meta.url);
+  const worker = new SharedWorker(workerUrl, { type: "module", name: "taladb" });
+  const proxy = new WorkerProxy(worker.port);
+  await proxy.send("init", { dbName });
+  function wrapCollection(name) {
+    const s = JSON.stringify;
+    return {
+      insert: (doc) => proxy.send("insert", { collection: name, docJson: s(doc) }),
+      insertMany: async (docs) => {
+        const json = await proxy.send("insertMany", {
+          collection: name,
+          docsJson: s(docs)
+        });
+        return JSON.parse(json);
+      },
+      find: async (filter) => {
+        const json = await proxy.send("find", {
+          collection: name,
+          filterJson: filter ? s(filter) : "null"
+        });
+        return JSON.parse(json);
+      },
+      findOne: async (filter) => {
+        const json = await proxy.send("findOne", {
+          collection: name,
+          filterJson: filter ? s(filter) : "null"
+        });
+        return JSON.parse(json);
+      },
+      updateOne: (filter, update) => proxy.send("updateOne", {
+        collection: name,
+        filterJson: s(filter),
+        updateJson: s(update)
+      }),
+      updateMany: (filter, update) => proxy.send("updateMany", {
+        collection: name,
+        filterJson: s(filter),
+        updateJson: s(update)
+      }),
+      deleteOne: (filter) => proxy.send("deleteOne", { collection: name, filterJson: s(filter) }),
+      deleteMany: (filter) => proxy.send("deleteMany", { collection: name, filterJson: s(filter) }),
+      count: (filter) => proxy.send("count", {
+        collection: name,
+        filterJson: filter ? s(filter) : "null"
+      }),
+      createIndex: (field) => proxy.send("createIndex", { collection: name, field }),
+      dropIndex: (field) => proxy.send("dropIndex", { collection: name, field }),
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "";
+        const poll = async () => {
+          if (!active) return;
+          try {
+            const json = await proxy.send("find", {
+              collection: name,
+              filterJson: filter ? s(filter) : "null"
+            });
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(JSON.parse(json));
+            }
+          } catch {
+          }
+          if (active) setTimeout(poll, 300);
+        };
+        poll();
+        return () => {
+          active = false;
+        };
+      }
+    };
+  }
+  return {
+    collection: (name) => wrapCollection(name),
+    close: () => proxy.send("close")
+  };
+}
+async function createNodeDB(dbName) {
+  const { TalaDBNode } = await import("@taladb/node");
+  const db = TalaDBNode.open(dbName);
+  function wrapCollection(name) {
+    const col = db.collection(name);
+    return {
+      insert: async (doc) => col.insert(doc),
+      insertMany: async (docs) => col.insertMany(docs),
+      find: async (filter) => col.find(filter ?? null),
+      findOne: async (filter) => col.findOne(filter) ?? null,
+      updateOne: async (filter, update) => col.updateOne(filter, update),
+      updateMany: async (filter, update) => col.updateMany(filter, update),
+      deleteOne: async (filter) => col.deleteOne(filter),
+      deleteMany: async (filter) => col.deleteMany(filter),
+      count: async (filter) => col.count(filter ?? null),
+      createIndex: async (field) => col.createIndex(field),
+      dropIndex: async (field) => col.dropIndex(field),
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "";
+        const poll = async () => {
+          if (!active) return;
+          try {
+            const docs = await col.find(filter ?? null);
+            const json = JSON.stringify(docs);
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(docs);
+            }
+          } catch {
+          }
+          if (active) setTimeout(poll, 300);
+        };
+        poll();
+        return () => {
+          active = false;
+        };
+      }
+    };
+  }
+  return {
+    collection: (name) => wrapCollection(name),
+    close: async () => {
+    }
+  };
+}
+async function createNativeDB(_dbName) {
+  const maybeNative = globalThis.__TalaDB__;
+  if (!maybeNative) {
+    throw new Error(
+      "@taladb/react-native JSI HostObject not found. Did you call TalaDBModule.initialize() in your app entry point?"
+    );
+  }
+  const native = maybeNative;
+  function wrapCollection(name) {
+    const col = native.collection(name);
+    return {
+      insert: async (doc) => col.insert(doc),
+      insertMany: async (docs) => col.insertMany(docs),
+      find: async (filter) => col.find(filter ?? {}),
+      findOne: async (filter) => col.findOne(filter ?? {}),
+      updateOne: async (filter, update) => col.updateOne(filter, update),
+      updateMany: async (filter, update) => col.updateMany(filter, update),
+      deleteOne: async (filter) => col.deleteOne(filter),
+      deleteMany: async (filter) => col.deleteMany(filter),
+      count: async (filter) => col.count(filter ?? {}),
+      createIndex: async (field) => col.createIndex(field),
+      dropIndex: async (field) => col.dropIndex(field),
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "";
+        const poll = () => {
+          if (!active) return;
+          try {
+            const docs = col.find(filter ?? {});
+            const json = JSON.stringify(docs);
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(docs);
+            }
+          } catch {
+          }
+          if (active) setTimeout(poll, 300);
+        };
+        poll();
+        return () => {
+          active = false;
+        };
+      }
+    };
+  }
+  return {
+    collection: (name) => wrapCollection(name),
+    close: async () => native.close()
+  };
+}
+async function openDB(dbName = "taladb.db") {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "browser":
+      return createBrowserDB(dbName);
+    case "react-native":
+      return createNativeDB(dbName);
+    case "node":
+      return createNodeDB(dbName);
+  }
+}
+export {
+  openDB
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "taladb",
+  "version": "0.1.1",
+  "description": "Local-first document database for React, React Native, and Node.js",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "database",
+    "local-first",
+    "offline",
+    "wasm",
+    "react-native"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thinkgrid-labs/taladb.git",
+    "directory": "packages/taladb"
+  },
+  "homepage": "https://thinkgrid-labs.github.io/taladb/",
+  "bugs": {
+    "url": "https://github.com/thinkgrid-labs/taladb/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.0"
+  },
+  "optionalDependencies": {
+    "@taladb/web": "0.1.1",
+    "@taladb/node": "0.1.1"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --out-dir dist --external @taladb/web --external @taladb/node --external @taladb/react-native",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}