taladb 0.11.2 → 0.11.3

package/dist/index.browser.mjs

@@ -838,7 +838,7 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
   function nudgedPoller(collection, fetchJson, callback, onError) {
     let active = true;
     let lastJson = "";
-    let lastGeneration = -1;
+    let lastGeneration = null;
     let generationSupported = true;
     let timer = null;
     let running = false;
@@ -903,6 +903,7 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
       await proxy.send("flush");
     },
     isPrimary: () => proxy.send("isPrimary"),
+    storageInfo: () => proxy.send("capabilities"),
     close: async () => {
       channel?.close();
       try {
@@ -915,14 +916,16 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
     listCollectionNames: async () => JSON.parse(await proxy.send("listCollections"))
   };
   if (migrations?.length) {
-    await runMigrations(
-      handle,
-      async () => proxy.send("userVersion"),
-      async (v) => {
-        await proxy.send("setUserVersion", { version: v });
-      },
-      migrations
-    );
+    await navigator.locks.request(`taladb:migrations:${dbName}`, async () => {
+      await runMigrations(
+        handle,
+        async () => proxy.send("userVersion"),
+        async (v) => {
+          await proxy.send("setUserVersion", { version: v });
+        },
+        migrations
+      );
+    });
   }
   return handle;
 }
@@ -1010,78 +1013,106 @@ async function createNativeDB(_dbName, webhook, migrations) {
     );
   }
   const native = maybeNative;
+  let nativeQueue = Promise.resolve();
+  let queued = 0;
+  let closed = false;
+  const call = (op, ...args) => {
+    if (queued >= 128) return Promise.reject(new Error("TalaDB native request queue is full"));
+    queued++;
+    const result = nativeQueue.then(async () => {
+      if (closed) throw new Error("TalaDB database is closed");
+      if (op === "close") {
+        closed = true;
+        native.close();
+        return;
+      }
+      if (op === "findNearest" && native.findNearestAsync) {
+        return native.findNearestAsync(...args);
+      }
+      if (native.callAsync) return native.callAsync(op, args);
+      if (op === "find" && native.findAsync) {
+        return native.findAsync(...args);
+      }
+      const method = native[op];
+      if (!method) throw new Error(`${op} requires a newer @taladb/react-native binary; rebuild the native module`);
+      return method(...args);
+    });
+    nativeQueue = result.catch(() => {
+    }).finally(() => {
+      queued--;
+    });
+    return result;
+  };
   function wrapCollection(name, opts) {
     const wrapped = {
-      insert: async (doc) => native.insert(name, doc),
-      insertMany: async (docs) => native.insertMany(name, docs),
-      find: async (filter) => native.find(name, filter ?? {}),
-      findOne: async (filter) => native.findOne(name, filter ?? {}),
-      updateOne: async (filter, update) => native.updateOne(name, filter, update),
-      updateMany: async (filter, update) => native.updateMany(name, filter, update),
-      deleteOne: async (filter) => native.deleteOne(name, filter),
-      deleteMany: async (filter) => native.deleteMany(name, filter),
-      count: async (filter) => native.count(name, filter ?? {}),
-      aggregate: async (pipeline) => native.aggregate(name, pipeline),
-      createIndex: async (field) => native.createIndex(name, field),
-      dropIndex: async (field) => native.dropIndex(name, field),
-      createCompoundIndex: async (fields) => native.createCompoundIndex(name, fields),
-      dropCompoundIndex: async (fields) => native.dropCompoundIndex(name, fields),
-      createFtsIndex: async (field) => native.createFtsIndex(name, field),
-      dropFtsIndex: async (field) => native.dropFtsIndex(name, field),
+      insert: async (doc) => await call("insert", name, doc),
+      insertMany: async (docs) => await call("insertMany", name, docs),
+      find: async (filter) => await call("find", name, filter ?? {}),
+      findOne: async (filter) => await call("findOne", name, filter ?? {}),
+      updateOne: async (filter, update) => await call("updateOne", name, filter, update),
+      updateMany: async (filter, update) => await call("updateMany", name, filter, update),
+      deleteOne: async (filter) => await call("deleteOne", name, filter),
+      deleteMany: async (filter) => await call("deleteMany", name, filter),
+      count: async (filter) => await call("count", name, filter ?? {}),
+      aggregate: async (pipeline) => await call("aggregate", name, pipeline),
+      createIndex: async (field) => await call("createIndex", name, field),
+      dropIndex: async (field) => await call("dropIndex", name, field),
+      createCompoundIndex: async (fields) => await call("createCompoundIndex", name, fields),
+      dropCompoundIndex: async (fields) => await call("dropCompoundIndex", name, fields),
+      createFtsIndex: async (field) => await call("createFtsIndex", name, field),
+      dropFtsIndex: async (field) => await call("dropFtsIndex", name, field),
       createVectorIndex: async (field, options) => {
         const opts2 = {};
         if (options.metric) opts2.metric = options.metric;
-        if (options.hnswM || options.hnswEfConstruction) {
-          opts2.hnsw = { m: options.hnswM, efConstruction: options.hnswEfConstruction };
+        if (options.indexType === "hnsw") {
+          opts2.hnsw = { m: options.hnswM ?? 32, ef_construction: options.hnswEfConstruction ?? 200 };
         }
-        return native.createVectorIndex(name, field, options.dimensions, opts2);
+        return await call("createVectorIndex", name, field, options.dimensions, opts2);
       },
-      dropVectorIndex: async (field) => native.dropVectorIndex(name, field),
-      upgradeVectorIndex: async (field) => native.upgradeVectorIndex(name, field),
-      // The JSI HostObject does not expose index introspection yet; return a
-      // correctly-shaped empty result rather than `{}` cast to the interface.
-      listIndexes: async () => ({ btree: [], fts: [], vector: [] }),
+      dropVectorIndex: async (field) => await call("dropVectorIndex", name, field),
+      upgradeVectorIndex: async (field) => await call("upgradeVectorIndex", name, field),
+      listIndexes: async () => call("listIndexes", name),
       findNearest: async (field, vector, topK, filter) => {
-        const raw = native.findNearest(name, field, vector, topK, filter ?? null);
+        const raw = await call("findNearest", name, field, vector, topK, filter ?? null);
         return raw;
       },
       searchText: async (field, query, topK, filter, options) => {
-        if (!native.searchText) {
+        if (!native.callAsync && !native.searchText) {
           throw new Error("searchText requires @taladb/react-native \u2265 0.10 \u2014 rebuild the native module");
         }
-        return native.searchText(name, field, query, topK, filter ?? null, options ?? null);
+        return await call("searchText", name, field, query, topK, filter ?? null, options ?? null);
       },
       hybridSearch: async (text, vector, topK, filter, options) => {
-        if (!native.hybridSearch) {
+        if (!native.callAsync && !native.hybridSearch) {
           throw new Error("hybridSearch requires @taladb/react-native \u2265 0.10 \u2014 rebuild the native module");
         }
-        return native.hybridSearch(name, text.textField, text.text, vector.vectorField, vector.vector, topK, filter ?? null, options ?? null);
+        return await call("hybridSearch", name, text.textField, text.text, vector.vectorField, vector.vector, topK, filter ?? null, options ?? null);
       },
-      subscribe: (filter, callback, onError) => makePoller(async () => native.find(name, filter ?? {}), callback, onError),
-      subscribeAggregate: (pipeline, callback, onError) => makePoller(async () => native.aggregate(name, pipeline), callback, onError)
+      subscribe: (filter, callback, onError) => makePoller(async () => await call("find", name, filter ?? {}), callback, onError),
+      subscribeAggregate: (pipeline, callback, onError) => makePoller(async () => await call("aggregate", name, pipeline), callback, onError)
     };
     return decorateCollection(wrapped, name, opts, webhook);
   }
   const handle = {
     collection: (name, opts) => wrapCollection(name, opts),
-    compact: async () => native.compact(),
-    close: async () => native.close(),
-    flush: native.flush ? async () => {
-      native.flush();
+    compact: async () => await call("compact"),
+    close: async () => await call("close"),
+    flush: native.callAsync || native.flush ? async () => {
+      await call("flush");
     } : void 0,
     // One process owns the file — there is no other tab to defer to.
     isPrimary: async () => true
   };
   if (migrations?.length) {
-    if (typeof native.userVersion !== "function" || typeof native.setUserVersion !== "function") {
+    if (!native.callAsync && (typeof native.userVersion !== "function" || typeof native.setUserVersion !== "function")) {
       throw new Error(
         "openDB({ migrations }) is not available on this @taladb/react-native binary yet (the JSI HostObject does not expose userVersion/setUserVersion). Update the native module."
       );
     }
     await runMigrations(
       handle,
-      async () => native.userVersion(),
-      async (v) => native.setUserVersion(v),
+      async () => call("userVersion"),
+      async (v) => call("setUserVersion", v),
       migrations
     );
   }

package/dist/index.d.mts

@@ -108,7 +108,7 @@ interface VectorIndexOptions {
      * Requires the `vector-hnsw` feature to be compiled in.
      */
     indexType?: 'flat' | 'hnsw';
-    /** HNSW connectivity parameter M (default 16). Higher = better recall, more memory. */
+    /** HNSW connectivity parameter M. This implementation supports only 32 (the default). */
     hnswM?: number;
     /** HNSW build-time quality parameter ef_construction (default 200). */
     hnswEfConstruction?: number;
@@ -681,33 +681,20 @@ interface TalaDB {
      */
     flush?(): Promise<void>;
     /**
-     * Whether this tab's writes land authoritatively, without being forwarded to
-     * another tab.
-     *
-     * **Browser only.** The first tab to open a database becomes the primary and
-     * owns the storage; later tabs run an in-memory copy and forward their writes
-     * to it over BroadcastChannel. Both the OPFS owner and — where OPFS is
-     * unavailable — the tab that publishes the IndexedDB snapshot report `true`.
-     *
-     * Use it for work that must not run in more than one tab at a time, or that
-     * depends on reading its own writes back immediately: a background queue
-     * drainer, a scheduled cleanup pass, an outbound sync loop. A secondary tab
-     * sees other tabs' writes up to ~500 ms late, and its own writes only once
-     * the primary has applied them.
-     *
-     * Primary status changes during a session — closing the owning tab promotes
-     * another — so re-check it rather than caching the answer.
-     *
-     * Always `true` on Node.js and React Native, where a single process owns the
-     * database. May be absent on older `@taladb/web` builds — treat absence as
-     * `true`.
-     *
-     * @example
-     * if (await db.isPrimary?.() ?? true) {
-     *   await drainOutbox();
-     * }
+     * Whether this browser tab owns the database storage. All tabs execute reads
+     * and writes through that owner and await its result. Ownership can change
+     * after the owning tab closes. Node.js and React Native return true.
      */
     isPrimary?(): Promise<boolean>;
+    /** Actual browser storage/durability capabilities, including fallback errors. */
+    storageInfo?(): Promise<{
+        storage: 'opfs' | 'indexeddb';
+        durableWrites: boolean;
+        maxSnapshotBytes: number | null;
+        storageError: string | null;
+        hnsw: boolean;
+        owner: boolean;
+    }>;
     /**
      * Change-webhook delivery counters, when the webhook is enabled. All zero
      * (and `pending: 0`) when it is not.

package/dist/index.d.ts

@@ -108,7 +108,7 @@ interface VectorIndexOptions {
      * Requires the `vector-hnsw` feature to be compiled in.
      */
     indexType?: 'flat' | 'hnsw';
-    /** HNSW connectivity parameter M (default 16). Higher = better recall, more memory. */
+    /** HNSW connectivity parameter M. This implementation supports only 32 (the default). */
     hnswM?: number;
     /** HNSW build-time quality parameter ef_construction (default 200). */
     hnswEfConstruction?: number;
@@ -681,33 +681,20 @@ interface TalaDB {
      */
     flush?(): Promise<void>;
     /**
-     * Whether this tab's writes land authoritatively, without being forwarded to
-     * another tab.
-     *
-     * **Browser only.** The first tab to open a database becomes the primary and
-     * owns the storage; later tabs run an in-memory copy and forward their writes
-     * to it over BroadcastChannel. Both the OPFS owner and — where OPFS is
-     * unavailable — the tab that publishes the IndexedDB snapshot report `true`.
-     *
-     * Use it for work that must not run in more than one tab at a time, or that
-     * depends on reading its own writes back immediately: a background queue
-     * drainer, a scheduled cleanup pass, an outbound sync loop. A secondary tab
-     * sees other tabs' writes up to ~500 ms late, and its own writes only once
-     * the primary has applied them.
-     *
-     * Primary status changes during a session — closing the owning tab promotes
-     * another — so re-check it rather than caching the answer.
-     *
-     * Always `true` on Node.js and React Native, where a single process owns the
-     * database. May be absent on older `@taladb/web` builds — treat absence as
-     * `true`.
-     *
-     * @example
-     * if (await db.isPrimary?.() ?? true) {
-     *   await drainOutbox();
-     * }
+     * Whether this browser tab owns the database storage. All tabs execute reads
+     * and writes through that owner and await its result. Ownership can change
+     * after the owning tab closes. Node.js and React Native return true.
      */
     isPrimary?(): Promise<boolean>;
+    /** Actual browser storage/durability capabilities, including fallback errors. */
+    storageInfo?(): Promise<{
+        storage: 'opfs' | 'indexeddb';
+        durableWrites: boolean;
+        maxSnapshotBytes: number | null;
+        storageError: string | null;
+        hnsw: boolean;
+        owner: boolean;
+    }>;
     /**
      * Change-webhook delivery counters, when the webhook is enabled. All zero
      * (and `pending: 0`) when it is not.

package/dist/index.js

@@ -912,7 +912,7 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
   function nudgedPoller(collection, fetchJson, callback, onError) {
     let active = true;
     let lastJson = "";
-    let lastGeneration = -1;
+    let lastGeneration = null;
     let generationSupported = true;
     let timer = null;
     let running = false;
@@ -977,6 +977,7 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
       await proxy.send("flush");
     },
     isPrimary: () => proxy.send("isPrimary"),
+    storageInfo: () => proxy.send("capabilities"),
     close: async () => {
       channel?.close();
       try {
@@ -989,14 +990,16 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
     listCollectionNames: async () => JSON.parse(await proxy.send("listCollections"))
   };
   if (migrations?.length) {
-    await runMigrations(
-      handle,
-      async () => proxy.send("userVersion"),
-      async (v) => {
-        await proxy.send("setUserVersion", { version: v });
-      },
-      migrations
-    );
+    await navigator.locks.request(`taladb:migrations:${dbName}`, async () => {
+      await runMigrations(
+        handle,
+        async () => proxy.send("userVersion"),
+        async (v) => {
+          await proxy.send("setUserVersion", { version: v });
+        },
+        migrations
+      );
+    });
   }
   return handle;
 }
@@ -1084,78 +1087,106 @@ async function createNativeDB(_dbName, webhook, migrations) {
     );
   }
   const native = maybeNative;
+  let nativeQueue = Promise.resolve();
+  let queued = 0;
+  let closed = false;
+  const call = (op, ...args) => {
+    if (queued >= 128) return Promise.reject(new Error("TalaDB native request queue is full"));
+    queued++;
+    const result = nativeQueue.then(async () => {
+      if (closed) throw new Error("TalaDB database is closed");
+      if (op === "close") {
+        closed = true;
+        native.close();
+        return;
+      }
+      if (op === "findNearest" && native.findNearestAsync) {
+        return native.findNearestAsync(...args);
+      }
+      if (native.callAsync) return native.callAsync(op, args);
+      if (op === "find" && native.findAsync) {
+        return native.findAsync(...args);
+      }
+      const method = native[op];
+      if (!method) throw new Error(`${op} requires a newer @taladb/react-native binary; rebuild the native module`);
+      return method(...args);
+    });
+    nativeQueue = result.catch(() => {
+    }).finally(() => {
+      queued--;
+    });
+    return result;
+  };
   function wrapCollection(name, opts) {
     const wrapped = {
-      insert: async (doc) => native.insert(name, doc),
-      insertMany: async (docs) => native.insertMany(name, docs),
-      find: async (filter) => native.find(name, filter ?? {}),
-      findOne: async (filter) => native.findOne(name, filter ?? {}),
-      updateOne: async (filter, update) => native.updateOne(name, filter, update),
-      updateMany: async (filter, update) => native.updateMany(name, filter, update),
-      deleteOne: async (filter) => native.deleteOne(name, filter),
-      deleteMany: async (filter) => native.deleteMany(name, filter),
-      count: async (filter) => native.count(name, filter ?? {}),
-      aggregate: async (pipeline) => native.aggregate(name, pipeline),
-      createIndex: async (field) => native.createIndex(name, field),
-      dropIndex: async (field) => native.dropIndex(name, field),
-      createCompoundIndex: async (fields) => native.createCompoundIndex(name, fields),
-      dropCompoundIndex: async (fields) => native.dropCompoundIndex(name, fields),
-      createFtsIndex: async (field) => native.createFtsIndex(name, field),
-      dropFtsIndex: async (field) => native.dropFtsIndex(name, field),
+      insert: async (doc) => await call("insert", name, doc),
+      insertMany: async (docs) => await call("insertMany", name, docs),
+      find: async (filter) => await call("find", name, filter ?? {}),
+      findOne: async (filter) => await call("findOne", name, filter ?? {}),
+      updateOne: async (filter, update) => await call("updateOne", name, filter, update),
+      updateMany: async (filter, update) => await call("updateMany", name, filter, update),
+      deleteOne: async (filter) => await call("deleteOne", name, filter),
+      deleteMany: async (filter) => await call("deleteMany", name, filter),
+      count: async (filter) => await call("count", name, filter ?? {}),
+      aggregate: async (pipeline) => await call("aggregate", name, pipeline),
+      createIndex: async (field) => await call("createIndex", name, field),
+      dropIndex: async (field) => await call("dropIndex", name, field),
+      createCompoundIndex: async (fields) => await call("createCompoundIndex", name, fields),
+      dropCompoundIndex: async (fields) => await call("dropCompoundIndex", name, fields),
+      createFtsIndex: async (field) => await call("createFtsIndex", name, field),
+      dropFtsIndex: async (field) => await call("dropFtsIndex", name, field),
       createVectorIndex: async (field, options) => {
         const opts2 = {};
         if (options.metric) opts2.metric = options.metric;
-        if (options.hnswM || options.hnswEfConstruction) {
-          opts2.hnsw = { m: options.hnswM, efConstruction: options.hnswEfConstruction };
+        if (options.indexType === "hnsw") {
+          opts2.hnsw = { m: options.hnswM ?? 32, ef_construction: options.hnswEfConstruction ?? 200 };
         }
-        return native.createVectorIndex(name, field, options.dimensions, opts2);
+        return await call("createVectorIndex", name, field, options.dimensions, opts2);
       },
-      dropVectorIndex: async (field) => native.dropVectorIndex(name, field),
-      upgradeVectorIndex: async (field) => native.upgradeVectorIndex(name, field),
-      // The JSI HostObject does not expose index introspection yet; return a
-      // correctly-shaped empty result rather than `{}` cast to the interface.
-      listIndexes: async () => ({ btree: [], fts: [], vector: [] }),
+      dropVectorIndex: async (field) => await call("dropVectorIndex", name, field),
+      upgradeVectorIndex: async (field) => await call("upgradeVectorIndex", name, field),
+      listIndexes: async () => call("listIndexes", name),
       findNearest: async (field, vector, topK, filter) => {
-        const raw = native.findNearest(name, field, vector, topK, filter ?? null);
+        const raw = await call("findNearest", name, field, vector, topK, filter ?? null);
         return raw;
       },
       searchText: async (field, query, topK, filter, options) => {
-        if (!native.searchText) {
+        if (!native.callAsync && !native.searchText) {
           throw new Error("searchText requires @taladb/react-native \u2265 0.10 \u2014 rebuild the native module");
         }
-        return native.searchText(name, field, query, topK, filter ?? null, options ?? null);
+        return await call("searchText", name, field, query, topK, filter ?? null, options ?? null);
       },
       hybridSearch: async (text, vector, topK, filter, options) => {
-        if (!native.hybridSearch) {
+        if (!native.callAsync && !native.hybridSearch) {
           throw new Error("hybridSearch requires @taladb/react-native \u2265 0.10 \u2014 rebuild the native module");
         }
-        return native.hybridSearch(name, text.textField, text.text, vector.vectorField, vector.vector, topK, filter ?? null, options ?? null);
+        return await call("hybridSearch", name, text.textField, text.text, vector.vectorField, vector.vector, topK, filter ?? null, options ?? null);
       },
-      subscribe: (filter, callback, onError) => makePoller(async () => native.find(name, filter ?? {}), callback, onError),
-      subscribeAggregate: (pipeline, callback, onError) => makePoller(async () => native.aggregate(name, pipeline), callback, onError)
+      subscribe: (filter, callback, onError) => makePoller(async () => await call("find", name, filter ?? {}), callback, onError),
+      subscribeAggregate: (pipeline, callback, onError) => makePoller(async () => await call("aggregate", name, pipeline), callback, onError)
     };
     return decorateCollection(wrapped, name, opts, webhook);
   }
   const handle = {
     collection: (name, opts) => wrapCollection(name, opts),
-    compact: async () => native.compact(),
-    close: async () => native.close(),
-    flush: native.flush ? async () => {
-      native.flush();
+    compact: async () => await call("compact"),
+    close: async () => await call("close"),
+    flush: native.callAsync || native.flush ? async () => {
+      await call("flush");
     } : void 0,
     // One process owns the file — there is no other tab to defer to.
     isPrimary: async () => true
   };
   if (migrations?.length) {
-    if (typeof native.userVersion !== "function" || typeof native.setUserVersion !== "function") {
+    if (!native.callAsync && (typeof native.userVersion !== "function" || typeof native.setUserVersion !== "function")) {
       throw new Error(
         "openDB({ migrations }) is not available on this @taladb/react-native binary yet (the JSI HostObject does not expose userVersion/setUserVersion). Update the native module."
       );
     }
     await runMigrations(
       handle,
-      async () => native.userVersion(),
-      async (v) => native.setUserVersion(v),
+      async () => call("userVersion"),
+      async (v) => call("setUserVersion", v),
       migrations
     );
   }

package/dist/index.mjs

@@ -867,7 +867,7 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
   function nudgedPoller(collection, fetchJson, callback, onError) {
     let active = true;
     let lastJson = "";
-    let lastGeneration = -1;
+    let lastGeneration = null;
     let generationSupported = true;
     let timer = null;
     let running = false;
@@ -932,6 +932,7 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
       await proxy.send("flush");
     },
     isPrimary: () => proxy.send("isPrimary"),
+    storageInfo: () => proxy.send("capabilities"),
     close: async () => {
       channel?.close();
       try {
@@ -944,14 +945,16 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
     listCollectionNames: async () => JSON.parse(await proxy.send("listCollections"))
   };
   if (migrations?.length) {
-    await runMigrations(
-      handle,
-      async () => proxy.send("userVersion"),
-      async (v) => {
-        await proxy.send("setUserVersion", { version: v });
-      },
-      migrations
-    );
+    await navigator.locks.request(`taladb:migrations:${dbName}`, async () => {
+      await runMigrations(
+        handle,
+        async () => proxy.send("userVersion"),
+        async (v) => {
+          await proxy.send("setUserVersion", { version: v });
+        },
+        migrations
+      );
+    });
   }
   return handle;
 }
@@ -1039,78 +1042,106 @@ async function createNativeDB(_dbName, webhook, migrations) {
     );
   }
   const native = maybeNative;
+  let nativeQueue = Promise.resolve();
+  let queued = 0;
+  let closed = false;
+  const call = (op, ...args) => {
+    if (queued >= 128) return Promise.reject(new Error("TalaDB native request queue is full"));
+    queued++;
+    const result = nativeQueue.then(async () => {
+      if (closed) throw new Error("TalaDB database is closed");
+      if (op === "close") {
+        closed = true;
+        native.close();
+        return;
+      }
+      if (op === "findNearest" && native.findNearestAsync) {
+        return native.findNearestAsync(...args);
+      }
+      if (native.callAsync) return native.callAsync(op, args);
+      if (op === "find" && native.findAsync) {
+        return native.findAsync(...args);
+      }
+      const method = native[op];
+      if (!method) throw new Error(`${op} requires a newer @taladb/react-native binary; rebuild the native module`);
+      return method(...args);
+    });
+    nativeQueue = result.catch(() => {
+    }).finally(() => {
+      queued--;
+    });
+    return result;
+  };
   function wrapCollection(name, opts) {
     const wrapped = {
-      insert: async (doc) => native.insert(name, doc),
-      insertMany: async (docs) => native.insertMany(name, docs),
-      find: async (filter) => native.find(name, filter ?? {}),
-      findOne: async (filter) => native.findOne(name, filter ?? {}),
-      updateOne: async (filter, update) => native.updateOne(name, filter, update),
-      updateMany: async (filter, update) => native.updateMany(name, filter, update),
-      deleteOne: async (filter) => native.deleteOne(name, filter),
-      deleteMany: async (filter) => native.deleteMany(name, filter),
-      count: async (filter) => native.count(name, filter ?? {}),
-      aggregate: async (pipeline) => native.aggregate(name, pipeline),
-      createIndex: async (field) => native.createIndex(name, field),
-      dropIndex: async (field) => native.dropIndex(name, field),
-      createCompoundIndex: async (fields) => native.createCompoundIndex(name, fields),
-      dropCompoundIndex: async (fields) => native.dropCompoundIndex(name, fields),
-      createFtsIndex: async (field) => native.createFtsIndex(name, field),
-      dropFtsIndex: async (field) => native.dropFtsIndex(name, field),
+      insert: async (doc) => await call("insert", name, doc),
+      insertMany: async (docs) => await call("insertMany", name, docs),
+      find: async (filter) => await call("find", name, filter ?? {}),
+      findOne: async (filter) => await call("findOne", name, filter ?? {}),
+      updateOne: async (filter, update) => await call("updateOne", name, filter, update),
+      updateMany: async (filter, update) => await call("updateMany", name, filter, update),
+      deleteOne: async (filter) => await call("deleteOne", name, filter),
+      deleteMany: async (filter) => await call("deleteMany", name, filter),
+      count: async (filter) => await call("count", name, filter ?? {}),
+      aggregate: async (pipeline) => await call("aggregate", name, pipeline),
+      createIndex: async (field) => await call("createIndex", name, field),
+      dropIndex: async (field) => await call("dropIndex", name, field),
+      createCompoundIndex: async (fields) => await call("createCompoundIndex", name, fields),
+      dropCompoundIndex: async (fields) => await call("dropCompoundIndex", name, fields),
+      createFtsIndex: async (field) => await call("createFtsIndex", name, field),
+      dropFtsIndex: async (field) => await call("dropFtsIndex", name, field),
       createVectorIndex: async (field, options) => {
         const opts2 = {};
         if (options.metric) opts2.metric = options.metric;
-        if (options.hnswM || options.hnswEfConstruction) {
-          opts2.hnsw = { m: options.hnswM, efConstruction: options.hnswEfConstruction };
+        if (options.indexType === "hnsw") {
+          opts2.hnsw = { m: options.hnswM ?? 32, ef_construction: options.hnswEfConstruction ?? 200 };
         }
-        return native.createVectorIndex(name, field, options.dimensions, opts2);
+        return await call("createVectorIndex", name, field, options.dimensions, opts2);
       },
-      dropVectorIndex: async (field) => native.dropVectorIndex(name, field),
-      upgradeVectorIndex: async (field) => native.upgradeVectorIndex(name, field),
-      // The JSI HostObject does not expose index introspection yet; return a
-      // correctly-shaped empty result rather than `{}` cast to the interface.
-      listIndexes: async () => ({ btree: [], fts: [], vector: [] }),
+      dropVectorIndex: async (field) => await call("dropVectorIndex", name, field),
+      upgradeVectorIndex: async (field) => await call("upgradeVectorIndex", name, field),
+      listIndexes: async () => call("listIndexes", name),
       findNearest: async (field, vector, topK, filter) => {
-        const raw = native.findNearest(name, field, vector, topK, filter ?? null);
+        const raw = await call("findNearest", name, field, vector, topK, filter ?? null);
         return raw;
       },
       searchText: async (field, query, topK, filter, options) => {
-        if (!native.searchText) {
+        if (!native.callAsync && !native.searchText) {
           throw new Error("searchText requires @taladb/react-native \u2265 0.10 \u2014 rebuild the native module");
         }
-        return native.searchText(name, field, query, topK, filter ?? null, options ?? null);
+        return await call("searchText", name, field, query, topK, filter ?? null, options ?? null);
       },
       hybridSearch: async (text, vector, topK, filter, options) => {
-        if (!native.hybridSearch) {
+        if (!native.callAsync && !native.hybridSearch) {
           throw new Error("hybridSearch requires @taladb/react-native \u2265 0.10 \u2014 rebuild the native module");
         }
-        return native.hybridSearch(name, text.textField, text.text, vector.vectorField, vector.vector, topK, filter ?? null, options ?? null);
+        return await call("hybridSearch", name, text.textField, text.text, vector.vectorField, vector.vector, topK, filter ?? null, options ?? null);
       },
-      subscribe: (filter, callback, onError) => makePoller(async () => native.find(name, filter ?? {}), callback, onError),
-      subscribeAggregate: (pipeline, callback, onError) => makePoller(async () => native.aggregate(name, pipeline), callback, onError)
+      subscribe: (filter, callback, onError) => makePoller(async () => await call("find", name, filter ?? {}), callback, onError),
+      subscribeAggregate: (pipeline, callback, onError) => makePoller(async () => await call("aggregate", name, pipeline), callback, onError)
     };
     return decorateCollection(wrapped, name, opts, webhook);
   }
   const handle = {
     collection: (name, opts) => wrapCollection(name, opts),
-    compact: async () => native.compact(),
-    close: async () => native.close(),
-    flush: native.flush ? async () => {
-      native.flush();
+    compact: async () => await call("compact"),
+    close: async () => await call("close"),
+    flush: native.callAsync || native.flush ? async () => {
+      await call("flush");
     } : void 0,
     // One process owns the file — there is no other tab to defer to.
     isPrimary: async () => true
   };
   if (migrations?.length) {
-    if (typeof native.userVersion !== "function" || typeof native.setUserVersion !== "function") {
+    if (!native.callAsync && (typeof native.userVersion !== "function" || typeof native.setUserVersion !== "function")) {
       throw new Error(
         "openDB({ migrations }) is not available on this @taladb/react-native binary yet (the JSI HostObject does not expose userVersion/setUserVersion). Update the native module."
       );
     }
     await runMigrations(
       handle,
-      async () => native.userVersion(),
-      async (v) => native.setUserVersion(v),
+      async () => call("userVersion"),
+      async (v) => call("setUserVersion", v),
       migrations
     );
   }

package/dist/index.react-native.mjs

@@ -838,7 +838,7 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
   function nudgedPoller(collection, fetchJson, callback, onError) {
     let active = true;
     let lastJson = "";
-    let lastGeneration = -1;
+    let lastGeneration = null;
     let generationSupported = true;
     let timer = null;
     let running = false;
@@ -903,6 +903,7 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
       await proxy.send("flush");
     },
     isPrimary: () => proxy.send("isPrimary"),
+    storageInfo: () => proxy.send("capabilities"),
     close: async () => {
       channel?.close();
       try {
@@ -915,14 +916,16 @@ async function createBrowserDB(dbName, webhook, config, passphrase, migrations)
     listCollectionNames: async () => JSON.parse(await proxy.send("listCollections"))
   };
   if (migrations?.length) {
-    await runMigrations(
-      handle,
-      async () => proxy.send("userVersion"),
-      async (v) => {
-        await proxy.send("setUserVersion", { version: v });
-      },
-      migrations
-    );
+    await navigator.locks.request(`taladb:migrations:${dbName}`, async () => {
+      await runMigrations(
+        handle,
+        async () => proxy.send("userVersion"),
+        async (v) => {
+          await proxy.send("setUserVersion", { version: v });
+        },
+        migrations
+      );
+    });
   }
   return handle;
 }
@@ -1010,78 +1013,106 @@ async function createNativeDB(_dbName, webhook, migrations) {
     );
   }
   const native = maybeNative;
+  let nativeQueue = Promise.resolve();
+  let queued = 0;
+  let closed = false;
+  const call = (op, ...args) => {
+    if (queued >= 128) return Promise.reject(new Error("TalaDB native request queue is full"));
+    queued++;
+    const result = nativeQueue.then(async () => {
+      if (closed) throw new Error("TalaDB database is closed");
+      if (op === "close") {
+        closed = true;
+        native.close();
+        return;
+      }
+      if (op === "findNearest" && native.findNearestAsync) {
+        return native.findNearestAsync(...args);
+      }
+      if (native.callAsync) return native.callAsync(op, args);
+      if (op === "find" && native.findAsync) {
+        return native.findAsync(...args);
+      }
+      const method = native[op];
+      if (!method) throw new Error(`${op} requires a newer @taladb/react-native binary; rebuild the native module`);
+      return method(...args);
+    });
+    nativeQueue = result.catch(() => {
+    }).finally(() => {
+      queued--;
+    });
+    return result;
+  };
   function wrapCollection(name, opts) {
     const wrapped = {
-      insert: async (doc) => native.insert(name, doc),
-      insertMany: async (docs) => native.insertMany(name, docs),
-      find: async (filter) => native.find(name, filter ?? {}),
-      findOne: async (filter) => native.findOne(name, filter ?? {}),
-      updateOne: async (filter, update) => native.updateOne(name, filter, update),
-      updateMany: async (filter, update) => native.updateMany(name, filter, update),
-      deleteOne: async (filter) => native.deleteOne(name, filter),
-      deleteMany: async (filter) => native.deleteMany(name, filter),
-      count: async (filter) => native.count(name, filter ?? {}),
-      aggregate: async (pipeline) => native.aggregate(name, pipeline),
-      createIndex: async (field) => native.createIndex(name, field),
-      dropIndex: async (field) => native.dropIndex(name, field),
-      createCompoundIndex: async (fields) => native.createCompoundIndex(name, fields),
-      dropCompoundIndex: async (fields) => native.dropCompoundIndex(name, fields),
-      createFtsIndex: async (field) => native.createFtsIndex(name, field),
-      dropFtsIndex: async (field) => native.dropFtsIndex(name, field),
+      insert: async (doc) => await call("insert", name, doc),
+      insertMany: async (docs) => await call("insertMany", name, docs),
+      find: async (filter) => await call("find", name, filter ?? {}),
+      findOne: async (filter) => await call("findOne", name, filter ?? {}),
+      updateOne: async (filter, update) => await call("updateOne", name, filter, update),
+      updateMany: async (filter, update) => await call("updateMany", name, filter, update),
+      deleteOne: async (filter) => await call("deleteOne", name, filter),
+      deleteMany: async (filter) => await call("deleteMany", name, filter),
+      count: async (filter) => await call("count", name, filter ?? {}),
+      aggregate: async (pipeline) => await call("aggregate", name, pipeline),
+      createIndex: async (field) => await call("createIndex", name, field),
+      dropIndex: async (field) => await call("dropIndex", name, field),
+      createCompoundIndex: async (fields) => await call("createCompoundIndex", name, fields),
+      dropCompoundIndex: async (fields) => await call("dropCompoundIndex", name, fields),
+      createFtsIndex: async (field) => await call("createFtsIndex", name, field),
+      dropFtsIndex: async (field) => await call("dropFtsIndex", name, field),
       createVectorIndex: async (field, options) => {
         const opts2 = {};
         if (options.metric) opts2.metric = options.metric;
-        if (options.hnswM || options.hnswEfConstruction) {
-          opts2.hnsw = { m: options.hnswM, efConstruction: options.hnswEfConstruction };
+        if (options.indexType === "hnsw") {
+          opts2.hnsw = { m: options.hnswM ?? 32, ef_construction: options.hnswEfConstruction ?? 200 };
         }
-        return native.createVectorIndex(name, field, options.dimensions, opts2);
+        return await call("createVectorIndex", name, field, options.dimensions, opts2);
       },
-      dropVectorIndex: async (field) => native.dropVectorIndex(name, field),
-      upgradeVectorIndex: async (field) => native.upgradeVectorIndex(name, field),
-      // The JSI HostObject does not expose index introspection yet; return a
-      // correctly-shaped empty result rather than `{}` cast to the interface.
-      listIndexes: async () => ({ btree: [], fts: [], vector: [] }),
+      dropVectorIndex: async (field) => await call("dropVectorIndex", name, field),
+      upgradeVectorIndex: async (field) => await call("upgradeVectorIndex", name, field),
+      listIndexes: async () => call("listIndexes", name),
       findNearest: async (field, vector, topK, filter) => {
-        const raw = native.findNearest(name, field, vector, topK, filter ?? null);
+        const raw = await call("findNearest", name, field, vector, topK, filter ?? null);
         return raw;
       },
       searchText: async (field, query, topK, filter, options) => {
-        if (!native.searchText) {
+        if (!native.callAsync && !native.searchText) {
           throw new Error("searchText requires @taladb/react-native \u2265 0.10 \u2014 rebuild the native module");
         }
-        return native.searchText(name, field, query, topK, filter ?? null, options ?? null);
+        return await call("searchText", name, field, query, topK, filter ?? null, options ?? null);
       },
       hybridSearch: async (text, vector, topK, filter, options) => {
-        if (!native.hybridSearch) {
+        if (!native.callAsync && !native.hybridSearch) {
           throw new Error("hybridSearch requires @taladb/react-native \u2265 0.10 \u2014 rebuild the native module");
         }
-        return native.hybridSearch(name, text.textField, text.text, vector.vectorField, vector.vector, topK, filter ?? null, options ?? null);
+        return await call("hybridSearch", name, text.textField, text.text, vector.vectorField, vector.vector, topK, filter ?? null, options ?? null);
       },
-      subscribe: (filter, callback, onError) => makePoller(async () => native.find(name, filter ?? {}), callback, onError),
-      subscribeAggregate: (pipeline, callback, onError) => makePoller(async () => native.aggregate(name, pipeline), callback, onError)
+      subscribe: (filter, callback, onError) => makePoller(async () => await call("find", name, filter ?? {}), callback, onError),
+      subscribeAggregate: (pipeline, callback, onError) => makePoller(async () => await call("aggregate", name, pipeline), callback, onError)
     };
     return decorateCollection(wrapped, name, opts, webhook);
   }
   const handle = {
     collection: (name, opts) => wrapCollection(name, opts),
-    compact: async () => native.compact(),
-    close: async () => native.close(),
-    flush: native.flush ? async () => {
-      native.flush();
+    compact: async () => await call("compact"),
+    close: async () => await call("close"),
+    flush: native.callAsync || native.flush ? async () => {
+      await call("flush");
     } : void 0,
     // One process owns the file — there is no other tab to defer to.
     isPrimary: async () => true
   };
   if (migrations?.length) {
-    if (typeof native.userVersion !== "function" || typeof native.setUserVersion !== "function") {
+    if (!native.callAsync && (typeof native.userVersion !== "function" || typeof native.setUserVersion !== "function")) {
       throw new Error(
         "openDB({ migrations }) is not available on this @taladb/react-native binary yet (the JSI HostObject does not expose userVersion/setUserVersion). Update the native module."
       );
     }
     await runMigrations(
       handle,
-      async () => native.userVersion(),
-      async (v) => native.setUserVersion(v),
+      async () => call("userVersion"),
+      async (v) => call("setUserVersion", v),
       migrations
     );
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taladb",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "description": "The embedded vector database for on-device AI — documents, similarity search, and offline sync for browser, React Native, and Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -62,8 +62,8 @@
     "vitest": "^3.2.0"
   },
   "peerDependencies": {
-    "@taladb/web": "0.11.2",
-    "@taladb/node": "0.11.2"
+    "@taladb/web": "0.11.3",
+    "@taladb/node": "0.11.3"
   },
   "peerDependenciesMeta": {
     "@taladb/web": {