@taladb/react-native 0.10.1 → 0.11.0

package/ios/TalaDBFfi.xcframework/ios-arm64_x86_64-simulator/Headers/TalaDBHostObject.cpp

@@ -38,7 +38,6 @@ TalaDBHostObject::TalaDBHostObject(TalaDbHandle *db) : db_(db) {}
 
 TalaDBHostObject::~TalaDBHostObject() {
     if (db_) {
-        taladb_sync_flush(db_, 5000);
         taladb_close(db_);
         db_ = nullptr;
     }
@@ -241,14 +240,12 @@ Value TalaDBHostObject::awaitJobAsPromise(Runtime &rt, TalaDbJob *job, bool pars
 std::vector<PropNameID> TalaDBHostObject::getPropertyNames(Runtime &rt) {
     std::vector<std::string> names = {
         "insert", "insertMany",
-        "replaceManyWithIds", "deleteManyWithIds",
         "find", "findOne",
         "updateOne", "updateMany",
         "deleteOne", "deleteMany",
         "count",
         "aggregate",
-        "exportChanges", "importChanges", "listCollectionNames",
-        "importChangesValidated", "quarantined",
+        "listCollectionNames",
         "userVersion", "setUserVersion",
         "flush",
         "createIndex", "dropIndex",
@@ -259,7 +256,6 @@ std::vector<PropNameID> TalaDBHostObject::getPropertyNames(Runtime &rt) {
         "searchText", "hybridSearch",
         "findAsync",
         "compact",
-        "syncStatus", "flushSync",
         "close",
     };
     std::vector<PropNameID> result;
@@ -315,46 +311,6 @@ Value TalaDBHostObject::get(Runtime &rt, const PropNameID &propName) {
             });
     }
 
-    // ------------------------------------------------------------------
-    // replaceManyWithIds(collection: string, docs: object[], origin: string): string[]
-    // ------------------------------------------------------------------
-    if (name == "replaceManyWithIds") {
-        return Function::createFromHostFunction(
-            rt, PropNameID::forAscii(rt, "replaceManyWithIds"), 3,
-            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-                if (count < 3) throw JSError(rt, "replaceManyWithIds requires 3 arguments");
-                auto col      = args[0].getString(rt).utf8(rt);
-                auto docsJson = stringify(rt, args[1]);
-                auto origin   = args[2].getString(rt).utf8(rt);
-                char *result  = taladb_replace_many_with_ids(
-                    db_, col.c_str(), docsJson.c_str(), origin.c_str());
-                if (!result) throw ffiError(rt, "taladb_replace_many_with_ids failed");
-                std::string json(result);
-                taladb_free_string(result);
-                return parse(rt, json);
-            });
-    }
-
-    // ------------------------------------------------------------------
-    // deleteManyWithIds(collection: string, ids: string[], origin: string): number
-    // ------------------------------------------------------------------
-    if (name == "deleteManyWithIds") {
-        return Function::createFromHostFunction(
-            rt, PropNameID::forAscii(rt, "deleteManyWithIds"), 3,
-            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-                if (count < 3) throw JSError(rt, "deleteManyWithIds requires 3 arguments");
-                auto col     = args[0].getString(rt).utf8(rt);
-                auto idsJson = stringify(rt, args[1]);
-                auto origin  = args[2].getString(rt).utf8(rt);
-                char *result = taladb_delete_many_with_ids(
-                    db_, col.c_str(), idsJson.c_str(), origin.c_str());
-                if (!result) throw ffiError(rt, "taladb_delete_many_with_ids failed");
-                std::string json(result);
-                taladb_free_string(result);
-                return parse(rt, json);
-            });
-    }
-
     // ------------------------------------------------------------------
     // find(collection: string, filter: object | null): object[]
     // ------------------------------------------------------------------
@@ -494,38 +450,8 @@ Value TalaDBHostObject::get(Runtime &rt, const PropNameID &propName) {
     }
 
     // ------------------------------------------------------------------
-    // Bidirectional sync — exportChanges / importChanges / listCollectionNames
-    // (back JS db.sync(); the runtime-agnostic loop lives in taladb/src/sync.ts)
+    // Collection metadata
     // ------------------------------------------------------------------
-    if (name == "exportChanges") {
-        return Function::createFromHostFunction(
-            rt, PropNameID::forAscii(rt, "exportChanges"), 2,
-            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-                if (count < 2) throw JSError(rt, "exportChanges requires 2 arguments");
-                auto collectionsJson = stringify(rt, args[0]);   // string[] → JSON array
-                double sinceMs       = args[1].getNumber();
-                char *result = taladb_export_changes(db_, collectionsJson.c_str(), sinceMs);
-                if (!result) throw JSError(rt, "taladb_export_changes failed");
-                std::string json(result);
-                taladb_free_string(result);
-                // Return the changeset as an opaque string (not parsed) — the
-                // JS sync adapter passes it straight to the transport.
-                return String::createFromUtf8(rt, json);
-            });
-    }
-
-    if (name == "importChanges") {
-        return Function::createFromHostFunction(
-            rt, PropNameID::forAscii(rt, "importChanges"), 1,
-            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-                if (count < 1) throw JSError(rt, "importChanges requires 1 argument");
-                auto changeset = args[0].getString(rt).utf8(rt);
-                int32_t n = taladb_import_changes(db_, changeset.c_str());
-                if (n < 0) throw JSError(rt, "taladb_import_changes failed");
-                return Value(static_cast<double>(n));
-            });
-    }
-
     if (name == "listCollectionNames") {
         return Function::createFromHostFunction(
             rt, PropNameID::forAscii(rt, "listCollectionNames"), 0,
@@ -538,38 +464,6 @@ Value TalaDBHostObject::get(Runtime &rt, const PropNameID &propName) {
             });
     }
 
-    // ------------------------------------------------------------------
-    // Validate-on-import — importChangesValidated / quarantined
-    // ------------------------------------------------------------------
-    if (name == "importChangesValidated") {
-        return Function::createFromHostFunction(
-            rt, PropNameID::forAscii(rt, "importChangesValidated"), 2,
-            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-                if (count < 2) throw JSError(rt, "importChangesValidated requires 2 arguments");
-                auto changeset = args[0].getString(rt).utf8(rt);
-                auto schemas   = args[1].getString(rt).utf8(rt);
-                char *result = taladb_import_changes_validated(db_, changeset.c_str(), schemas.c_str());
-                if (!result) throw JSError(rt, "taladb_import_changes_validated failed");
-                std::string json(result);
-                taladb_free_string(result);
-                return parse(rt, json);  // { applied, skipped, quarantined }
-            });
-    }
-
-    if (name == "quarantined") {
-        return Function::createFromHostFunction(
-            rt, PropNameID::forAscii(rt, "quarantined"), 1,
-            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-                if (count < 1) throw JSError(rt, "quarantined requires 1 argument");
-                auto col = args[0].getString(rt).utf8(rt);
-                char *result = taladb_quarantined(db_, col.c_str());
-                if (!result) throw JSError(rt, "taladb_quarantined failed");
-                std::string json(result);
-                taladb_free_string(result);
-                return parse(rt, json);  // [{ document, reason, changedAt }]
-            });
-    }
-
     // ------------------------------------------------------------------
     // Application migrations — userVersion / setUserVersion
     // ------------------------------------------------------------------
@@ -866,26 +760,6 @@ Value TalaDBHostObject::get(Runtime &rt, const PropNameID &propName) {
             });
     }
 
-    if (name == "syncStatus") {
-        return Function::createFromHostFunction(
-            rt, PropNameID::forAscii(rt, "syncStatus"), 0,
-            [this](Runtime &rt, const Value &, const Value *, size_t) -> Value {
-                char *raw = taladb_sync_status(db_);
-                if (!raw) throw ffiError(rt, "taladb_sync_status failed");
-                std::string json(raw); taladb_free_string(raw);
-                return parse(rt, json);
-            });
-    }
-
-    if (name == "flushSync") {
-        return Function::createFromHostFunction(
-            rt, PropNameID::forAscii(rt, "flushSync"), 1,
-            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-                uint64_t timeout = count && args[0].isNumber() ? (uint64_t)args[0].getNumber() : 5000;
-                return Value(taladb_sync_flush(db_, timeout) == 1);
-            });
-    }
-
     // ------------------------------------------------------------------
     // close(): void  (synchronous — the destructor does the real work)
     // ------------------------------------------------------------------
@@ -894,7 +768,6 @@ Value TalaDBHostObject::get(Runtime &rt, const PropNameID &propName) {
             rt, PropNameID::forAscii(rt, "close"), 0,
             [this](Runtime &rt, const Value &, const Value *, size_t) -> Value {
                 if (db_) {
-                    taladb_sync_flush(db_, 5000);
                     taladb_close(db_);
                     db_ = nullptr;
                 }

package/ios/TalaDBFfi.xcframework/ios-arm64_x86_64-simulator/Headers/taladb.h

@@ -38,9 +38,9 @@ typedef struct TalaDbHandle TalaDbHandle;
 TalaDbHandle *taladb_open(const char *path);
 
 /**
- * Open (or create) a database with HTTP push sync configuration.
+ * Open (or create) a database with durability/encryption configuration.
  *
- * config_json — JSON-serialised TalaDbConfig, or NULL to open without sync.
+ * config_json — JSON-serialised TalaDbConfig, or NULL for defaults.
  * Returns an opaque handle (same semantics as taladb_open), or NULL on failure.
  */
 TalaDbHandle *taladb_open_with_config(const char *path, const char *config_json);
@@ -79,39 +79,6 @@ char *taladb_insert_many(TalaDbHandle *handle,
                          const char   *collection,
                          const char   *docs_json);
 
-/* -------------------------------------------------------------------------
- * Replication writes — id-addressed upsert / delete
- * ---------------------------------------------------------------------- */
-
-/**
- * Upsert many documents by caller-supplied `_id`, in one commit.
- *
- * Unlike taladb_insert_many(), which discards `_id` and mints a fresh ULID, this
- * honours the id on each document — which is what makes a replication upsert
- * idempotent across repeated fetches of the same remote row.
- *
- * `origin` is "remote" (authoritative rows replicated in from an origin) or
- * "local" (ordinary user writes). Remote rows are marked so they never replicate
- * back out.
- *
- * Returns a JSON array of ULID strings, or NULL on error.
- * Caller must free with taladb_free_string().
- */
-char *taladb_replace_many_with_ids(TalaDbHandle *handle,
-                                   const char   *collection,
-                                   const char   *docs_json,
-                                   const char   *origin);
-
-/**
- * Delete many documents by id, in one commit.
- * Returns a JSON number (the count removed), or NULL on error.
- * Caller must free with taladb_free_string().
- */
-char *taladb_delete_many_with_ids(TalaDbHandle *handle,
-                                  const char   *collection,
-                                  const char   *ids_json,
-                                  const char   *origin);
-
 /* -------------------------------------------------------------------------
  * Find
  * ---------------------------------------------------------------------- */
@@ -187,49 +154,12 @@ char *taladb_aggregate(TalaDbHandle *handle,
                        const char   *collection,
                        const char   *pipeline_json);
 
-/* -------------------------------------------------------------------------
- * Bidirectional sync — changeset export / import (backs JS db.sync())
- * ---------------------------------------------------------------------- */
-
-/**
- * Export a changeset for the collections in collections_json (a JSON array of
- * names) with changed_at > since_ms. Returns a JSON string, or NULL on error.
- * Caller must free with taladb_free_string().
- */
-char *taladb_export_changes(TalaDbHandle *handle,
-                            const char   *collections_json,
-                            double        since_ms);
-
-/**
- * Merge a JSON changeset (from a remote peer) via Last-Write-Wins.
- * Returns the number of documents changed, or -1 on error.
- */
-int32_t taladb_import_changes(TalaDbHandle *handle,
-                              const char   *changeset_json);
-
 /**
  * User collection names (reserved names excluded) as a JSON array string.
  * Returns NULL on error. Caller must free with taladb_free_string().
  */
 char *taladb_list_collection_names(TalaDbHandle *handle);
 
-/**
- * Merge a JSON changeset through a tolerant structural validator built from
- * schemas_json ({ "<collection>": { version, required, types, defaults,
- * renames } }). Returns a JSON "{ applied, skipped, quarantined }" string, or
- * NULL on error. Caller must free with taladb_free_string().
- */
-char *taladb_import_changes_validated(TalaDbHandle *handle,
-                                      const char   *changeset_json,
-                                      const char   *schemas_json);
-
-/**
- * Documents set aside in a collection's quarantine table by a validated import,
- * as a JSON array of { document, reason, changedAt }. NULL on error. Caller
- * must free with taladb_free_string().
- */
-char *taladb_quarantined(TalaDbHandle *handle, const char *collection);
-
 /**
  * Read / write the application migration version (backs openDB({ migrations })).
  * taladb_user_version returns the version (0 if unset) or -1 on error;
@@ -320,9 +250,6 @@ char *taladb_hybrid_search(TalaDbHandle *handle,
                            const char   *filter_json,
                            const char   *options_json);
 
-char *taladb_sync_status(TalaDbHandle *handle);
-int32_t taladb_sync_flush(TalaDbHandle *handle, uint64_t timeout_ms);
-
 /* -------------------------------------------------------------------------
  * Async job API — run heavy queries on a background thread.
  *

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@taladb/react-native",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "TalaDB React Native module — document and vector database via JSI HostObject",
   "main": "src/index",
   "types": "src/index.tsx",
   "files": [
+    "LICENSE-APACHE",
+    "LICENSE-MIT",
     "src/",
     "cpp/",
     "ios/",
@@ -33,7 +35,7 @@
   "engines": {
     "node": ">=18"
   },
-  "license": "Apache-2.0",
+  "license": "MIT OR Apache-2.0",
   "codegenConfig": {
     "name": "TalaDB",
     "type": "modules",
@@ -46,6 +48,9 @@
     "typescript": "^5.9.3",
     "react-native": "^0.83.0"
   },
+  "dependencies": {
+    "taladb": "0.11.0"
+  },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build:ios": "sh scripts/build-ios.sh",

package/src/NativeTalaDB.ts

@@ -13,8 +13,7 @@ export interface Spec extends TurboModule {
    * Open (or create) a TalaDB database file at the platform default path.
    * Must be called once at app startup before using `collection()`.
    *
-   * @param configJson  Optional JSON-serialised `TalaDbConfig`. Pass to enable
-   *                    HTTP push sync. When omitted, sync is disabled.
+   * @param configJson Optional JSON-serialised durability/encryption config.
    */
   initialize(dbName: string, configJson?: string): Promise<void>;
 
@@ -25,35 +24,12 @@ export interface Spec extends TurboModule {
   // Collection CRUD — all methods are synchronous via JSI
   // ------------------------------------------------------------------
 
-  /** Insert a document. Returns the ULID string id. */
+  /** Insert a document. Honours a supplied `_id`, otherwise creates a ULID. */
   insert(collection: string, doc: Object): string;
 
-  /** Insert multiple documents. Returns an array of ULID string ids. */
+  /** Insert multiple documents, honouring any supplied `_id` values. */
   insertMany(collection: string, docs: Object[]): string[];
 
-  /**
-   * Upsert many documents **by caller-supplied `_id`**, in one commit.
-   *
-   * Unlike `insertMany`, which discards `_id` and mints a fresh ULID, this honours
-   * the id on each document — which is what makes a replication upsert idempotent
-   * across repeated fetches of the same remote row.
-   *
-   * `origin` is `'remote'` for authoritative rows replicated in from an origin, or
-   * `'local'` for ordinary user writes.
-   */
-  replaceManyWithIds(
-    collection: string,
-    docs: Object[],
-    origin: 'local' | 'remote',
-  ): string[];
-
-  /** Delete many documents by id, in one commit. Returns the number removed. */
-  deleteManyWithIds(
-    collection: string,
-    ids: string[],
-    origin: 'local' | 'remote',
-  ): number;
-
   /** Find documents matching the filter. */
   find(collection: string, filter: Object | null): Object[];
 

package/src/index.tsx

@@ -1,71 +1,32 @@
-/**
- * TalaDB React Native — public JS API.
- *
- * Usage:
- * ```ts
- * import { TalaDBModule, openDB } from '@taladb/react-native';
- *
- * // In App.tsx / index.js (once, at startup)
- * await TalaDBModule.initialize('myapp.db');
- *
- * // Anywhere in the app — same API as browser
- * const db = openDB('myapp.db');
- * const users = db.collection<User>('users');
- * const id = users.insert({ name: 'Alice', age: 30 });
- * ```
- *
- * All operations are **synchronous** via JSI — no async/await needed
- * after initialization.
- */
+/** TalaDB React Native public API. CRUD is synchronous through the JSI host. */
+import {
+  createWebhookDispatcher,
+  type WebhookConfig,
+  type WebhookDispatcher,
+  type WebhookEvent,
+  type WebhookStats,
+} from 'taladb';
 import NativeTalaDB from './NativeTalaDB';
 
-// ---------------------------------------------------------------------------
-// Module-level helpers
-// ---------------------------------------------------------------------------
-
 export const TalaDBModule = {
-  /**
-   * Open (or create) the database. Call once at app startup.
-   *
-   * @param configJson  Optional JSON-serialised `TalaDbConfig` for HTTP push
-   *                    sync. Example: `JSON.stringify({ sync: { enabled: true,
-   *                    endpoint: 'https://api.example.com/events' } })`.
-   */
+  /** Open the native database. The config controls durability/encryption only. */
   initialize: (dbName: string, configJson?: string) =>
     NativeTalaDB.initialize(dbName, configJson),
-  /** Close the database gracefully. */
   close: () => NativeTalaDB.close(),
-  /** HTTP push events dropped by backpressure or failed after retries. */
-  syncStatus: () => native().syncStatus(),
-  /** Wait for HTTP push work accepted before this call. */
-  flushSync: (timeoutMs = 5000) => native().flushSync(timeoutMs),
 };
 
-// ---------------------------------------------------------------------------
-// Collection handle
-// ---------------------------------------------------------------------------
-
 export interface Document {
   _id?: string;
   [key: string]: unknown;
 }
 
+export type InsertDocument<T extends Document> = Omit<T, '_id'> & { _id?: string };
 export type Filter = Record<string, unknown>;
 export type Update = Record<string, unknown>;
 
 export interface Collection<T extends Document = Document> {
-  insert(doc: Omit<T, '_id'>): string;
-  insertMany(docs: Omit<T, '_id'>[]): string[];
-  /**
-   * Upsert many documents **by `_id`**, in one commit. Requires an `_id` on every
-   * document — for replicated rows that comes from `deriveDocId(collection, key)`.
-   *
-   * `origin: 'remote'` marks rows as replicated in from an authoritative origin so
-   * they are never replicated back out; it defaults to `'local'`.
-   */
-  replaceManyWithIds(docs: T[], origin?: 'local' | 'remote'): string[];
-  /** Delete many documents by id, in one commit. Returns the number removed. */
-  deleteManyWithIds(ids: string[], origin?: 'local' | 'remote'): number;
+  insert(doc: InsertDocument<T>): string;
+  insertMany(docs: InsertDocument<T>[]): string[];
   find(filter?: Filter): T[];
   findOne(filter: Filter): T | null;
   updateOne(filter: Filter, update: Update): boolean;
@@ -79,26 +40,21 @@ export interface Collection<T extends Document = Document> {
   dropFtsIndex(field: string): void;
 }
 
+export interface OpenDBOptions {
+  /** Runtime-agnostic outbound change webhook, delivered with global `fetch`. */
+  webhook?: WebhookConfig;
+}
+
 export interface DB {
   collection<T extends Document = Document>(name: string): Collection<T>;
-  syncStatus(): { dropped: number; failed: number };
-  flushSync(timeoutMs?: number): boolean;
+  webhookStats(): WebhookStats;
+  flushWebhook(timeoutMs?: number): Promise<boolean>;
   close(): Promise<void>;
 }
 
 interface JsiTalaDB {
   insert(collection: string, doc: Object): string;
   insertMany(collection: string, docs: Object[]): string[];
-  replaceManyWithIds(
-    collection: string,
-    docs: Object[],
-    origin: 'local' | 'remote',
-  ): string[];
-  deleteManyWithIds(
-    collection: string,
-    ids: string[],
-    origin: 'local' | 'remote',
-  ): number;
   find(collection: string, filter: Object | null): Object[];
   findOne(collection: string, filter: Object | null): Object | null;
   updateOne(collection: string, filter: Object, update: Object): boolean;
@@ -110,8 +66,6 @@ interface JsiTalaDB {
   dropIndex(collection: string, field: string): void;
   createFtsIndex(collection: string, field: string): void;
   dropFtsIndex(collection: string, field: string): void;
-  syncStatus(): { dropped: number; failed: number };
-  flushSync(timeoutMs?: number): boolean;
 }
 
 function native(): JsiTalaDB {
@@ -120,31 +74,102 @@ function native(): JsiTalaDB {
   return host;
 }
 
-// ---------------------------------------------------------------------------
-// openDB — synchronous DB handle (after initialize() has been called)
-// ---------------------------------------------------------------------------
+const EMPTY_STATS: WebhookStats = { pending: 0, delivered: 0, failed: 0, dropped: 0 };
+
+function emitPostImages<T extends Document>(
+  webhook: WebhookDispatcher | null,
+  collection: string,
+  ids: string[],
+  op: 'insert' | 'update',
+  committedAt: number,
+): void {
+  if (!webhook?.reports(collection) || ids.length === 0) return;
+  const docs = native().find(collection, { _id: { $in: ids } }) as T[];
+  const byId = new Map(docs.map((doc) => [doc._id, doc]));
+  for (const id of ids) {
+    const document = byId.get(id);
+    if (document) webhook.emit({ op, collection, id, document, committedAt } as WebhookEvent);
+  }
+}
+
+function emitDeletes<T extends Document>(
+  webhook: WebhookDispatcher | null,
+  collection: string,
+  docs: T[],
+  committedAt: number,
+): void {
+  if (!webhook?.reports(collection)) return;
+  for (const document of docs) {
+    if (typeof document._id !== 'string') continue;
+    // DELETE carries the pre-image: after commit there is no post-image to read.
+    webhook.emit({
+      op: 'delete',
+      collection,
+      id: document._id,
+      document,
+      committedAt,
+    } as WebhookEvent);
+  }
+}
 
-/**
- * Get a synchronous DB handle for the given database name.
- *
- * `TalaDBModule.initialize(dbName)` **must** have been awaited before calling
- * this function.
- */
-function collection<T extends Document>(colName: string): Collection<T> {
+function collection<T extends Document>(
+  colName: string,
+  webhook: WebhookDispatcher | null,
+): Collection<T> {
   return {
-    insert: (doc) => native().insert(colName, doc as Object),
-    insertMany: (docs) => native().insertMany(colName, docs as Object[]),
-    replaceManyWithIds: (docs, origin = 'local') =>
-      native().replaceManyWithIds(colName, docs as Object[], origin),
-    deleteManyWithIds: (ids, origin = 'local') =>
-      native().deleteManyWithIds(colName, ids, origin),
-    find: (filter?) => native().find(colName, filter ?? null) as T[],
+    insert(doc) {
+      const id = native().insert(colName, doc as Object);
+      const committedAt = Date.now();
+      emitPostImages<T>(webhook, colName, [id], 'insert', committedAt);
+      return id;
+    },
+    insertMany(docs) {
+      const ids = native().insertMany(colName, docs as Object[]);
+      const committedAt = Date.now();
+      emitPostImages<T>(webhook, colName, ids, 'insert', committedAt);
+      return ids;
+    },
+    find: (filter) => native().find(colName, filter ?? null) as T[],
     findOne: (filter) => native().findOne(colName, filter) as T | null,
-    updateOne: (filter, update) => native().updateOne(colName, filter, update),
-    updateMany: (filter, update) => native().updateMany(colName, filter, update),
-    deleteOne: (filter) => native().deleteOne(colName, filter),
-    deleteMany: (filter) => native().deleteMany(colName, filter),
-    count: (filter?) => native().count(colName, filter ?? null),
+    updateOne(filter, update) {
+      const before = native().findOne(colName, filter) as T | null;
+      const changed = native().updateOne(colName, filter, update);
+      const committedAt = Date.now();
+      if (changed && typeof before?._id === 'string') {
+        emitPostImages<T>(webhook, colName, [before._id], 'update', committedAt);
+      }
+      return changed;
+    },
+    updateMany(filter, update) {
+      const before = native().find(colName, filter) as T[];
+      const changed = native().updateMany(colName, filter, update);
+      const committedAt = Date.now();
+      if (changed > 0) {
+        emitPostImages<T>(
+          webhook,
+          colName,
+          before.map((doc) => doc._id).filter((id): id is string => typeof id === 'string'),
+          'update',
+          committedAt,
+        );
+      }
+      return changed;
+    },
+    deleteOne(filter) {
+      const before = native().findOne(colName, filter) as T | null;
+      const deleted = native().deleteOne(colName, filter);
+      const committedAt = Date.now();
+      if (deleted && before) emitDeletes(webhook, colName, [before], committedAt);
+      return deleted;
+    },
+    deleteMany(filter) {
+      const before = native().find(colName, filter) as T[];
+      const deleted = native().deleteMany(colName, filter);
+      const committedAt = Date.now();
+      if (deleted > 0) emitDeletes(webhook, colName, before, committedAt);
+      return deleted;
+    },
+    count: (filter) => native().count(colName, filter ?? null),
     createIndex: (field) => native().createIndex(colName, field),
     dropIndex: (field) => native().dropIndex(colName, field),
     createFtsIndex: (field) => native().createFtsIndex(colName, field),
@@ -152,11 +177,16 @@ function collection<T extends Document>(colName: string): Collection<T> {
   };
 }
 
-export function openDB(_dbName: string): DB {
+/** Get a synchronous DB handle after `TalaDBModule.initialize(dbName)`. */
+export function openDB(_dbName: string, options?: OpenDBOptions): DB {
+  const webhook = createWebhookDispatcher(options?.webhook);
   return {
-    collection,
-    syncStatus: () => native().syncStatus(),
-    flushSync: (timeoutMs = 5000) => native().flushSync(timeoutMs),
-    close: () => NativeTalaDB.close(),
+    collection: <T extends Document>(name: string) => collection<T>(name, webhook),
+    webhookStats: () => webhook?.stats() ?? { ...EMPTY_STATS },
+    flushWebhook: (timeoutMs) => webhook?.flush(timeoutMs) ?? Promise.resolve(true),
+    close: async () => {
+      await webhook?.flush();
+      await NativeTalaDB.close();
+    },
   };
 }