@taladb/react-native 0.1.0

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,109 @@
+# @taladb/react-native
+
+React Native module for TalaDB — embedded local-first storage via JSI TurboModule and a Rust core.
+
+[![npm](https://img.shields.io/npm/v/@taladb/react-native)](https://www.npmjs.com/package/@taladb/react-native)
+[![License: MIT](https://img.shields.io/badge/License-MIT-orange.svg)](LICENSE)
+
+> **Note:** Most users should install [`taladb`](https://www.npmjs.com/package/taladb) instead, which auto-selects this package when running in React Native.
+
+## What it provides
+
+- TalaDB's Rust core compiled to a static library for iOS and Android
+- JSI HostObject bridge — calls go directly from JS to C++ to Rust with no JSON serialization on the hot path
+- No Bridge/async overhead for local reads
+- Data stored in the app's private documents directory (sandboxed, backed up by OS)
+
+## Requirements
+
+- React Native 0.73+
+- iOS 15+ / Android API 24+
+
+## Installation
+
+```bash
+pnpm add taladb @taladb/react-native
+```
+
+### iOS
+
+```bash
+cd ios && pod install
+```
+
+### Android
+
+No extra setup required — the `.so` library is bundled automatically via Gradle.
+
+## Usage
+
+Use through the unified [`taladb`](https://www.npmjs.com/package/taladb) package:
+
+```ts
+import { openDB } from 'taladb';
+
+const db = await openDB('myapp.db');
+const tasks = db.collection('tasks');
+
+await tasks.createIndex('status');
+await tasks.insert({ title: 'Buy groceries', status: 'pending', priority: 1 });
+
+const pending = await tasks.find({ status: 'pending' });
+await tasks.updateOne({ title: 'Buy groceries' }, { $set: { status: 'done' } });
+```
+
+### With React hooks
+
+```tsx
+import { useEffect, useState } from 'react';
+import { openDB } from 'taladb';
+import type { TalaDB } from 'taladb';
+
+export function useDatabase() {
+  const [db, setDb] = useState<TalaDB | null>(null);
+
+  useEffect(() => {
+    let instance: TalaDB;
+    openDB('myapp.db').then((opened) => {
+      instance = opened;
+      setDb(opened);
+    });
+    return () => { instance?.close(); };
+  }, []);
+
+  return db;
+}
+```
+
+## Architecture
+
+```
+JavaScript (React Native)
+        │  JSI (synchronous, no bridge)
+        ▼
+C++ HostObject (TalaDBHostObject.cpp)
+        │  C FFI
+        ▼
+Rust static library (taladb-core)
+        │
+        ▼
+redb B-tree (app documents directory)
+```
+
+## Building from source
+
+```bash
+# iOS (requires Xcode + Rust iOS targets)
+pnpm --filter @taladb/react-native build:ios
+
+# Android (requires NDK + Rust Android targets)
+pnpm --filter @taladb/react-native build:android
+```
+
+## Full Documentation
+
+**[https://thinkgrid-labs.github.io/taladb/guide/react-native](https://thinkgrid-labs.github.io/taladb/guide/react-native)**
+
+## License
+
+MIT © [ThinkGrid Labs](https://github.com/thinkgrid-labs)

package/android/CMakeLists.txt

@@ -0,0 +1,49 @@
+cmake_minimum_required(VERSION 3.22)
+project(taladb_jsi)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+
+# Root of the taladb-react-native package
+get_filename_component(PACKAGE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/.." ABSOLUTE)
+
+# Pre-built Rust static library (built by cargo ndk, copied by build.gradle)
+set(TALADB_FFI_LIB
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libtaladb_ffi.so")
+
+# ---------------------------------------------------------------------------
+# React Native JSI headers
+# React Native ships jsi/ headers inside node_modules — resolve from package root.
+# ---------------------------------------------------------------------------
+find_package(ReactAndroid REQUIRED CONFIG)
+
+# ---------------------------------------------------------------------------
+# taladb_ffi shared library (Rust pre-built, imported target)
+# ---------------------------------------------------------------------------
+add_library(taladb_ffi SHARED IMPORTED)
+set_target_properties(taladb_ffi PROPERTIES
+    IMPORTED_LOCATION "${TALADB_FFI_LIB}")
+
+# ---------------------------------------------------------------------------
+# taladb_jsi — C++ JSI HostObject, compiled into a thin shared library that
+# the Kotlin module loads via System.loadLibrary("taladb_jsi").
+# ---------------------------------------------------------------------------
+add_library(taladb_jsi SHARED
+    "${PACKAGE_ROOT}/cpp/TalaDBHostObject.cpp"
+    "${PACKAGE_ROOT}/cpp/TalaDBJni.cpp"
+)
+
+target_include_directories(taladb_jsi PRIVATE
+    "${PACKAGE_ROOT}/cpp"
+)
+
+target_link_libraries(taladb_jsi
+    taladb_ffi
+    ReactAndroid::jsi
+    android
+    log
+)

package/android/src/main/java/com/taladb/TalaDBModule.kt

@@ -0,0 +1,128 @@
+/**
+ * TalaDB React Native — Android JSI bridge.
+ *
+ * The module loads `libtaladb_ffi.so` (the Rust C FFI crate compiled via
+ * `cargo ndk`) and installs the C++ JSI HostObject into the Hermes/JSC
+ * runtime via `installJSIBindings()`.
+ *
+ * Build setup
+ * -----------
+ *  1. Cross-compile: `cargo ndk -t arm64-v8a -t armeabi-v7a -t x86_64 build --release`
+ *     Output: `target/<triple>/release/libtaladb_ffi.so`
+ *  2. Copy each .so into `android/src/main/jniLibs/<ABI>/libtaladb_ffi.so`
+ *  3. `android/CMakeLists.txt` compiles `TalaDBHostObject.cpp` and links the .so.
+ *
+ * Runtime flow
+ * ------------
+ *  React Native calls `initialize(dbName)` once.
+ *  The module resolves the DB path, then calls the native `nativeInstall()`
+ *  function which opens the Rust database and installs `global.__TalaDB__`
+ *  as a JSI HostObject. All subsequent CRUD calls go through JSI directly.
+ */
+package com.taladb
+
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+
+@ReactModule(name = TalaDBModule.NAME)
+class TalaDBModule(private val reactContext: ReactApplicationContext) :
+    NativeTalaDBSpec(reactContext) {
+
+    companion object {
+        const val NAME = "TalaDB"
+
+        init {
+            // libtaladb_ffi.so is built by CMakeLists.txt (see android/).
+            // It bundles both the C++ JSI HostObject and the Rust FFI crate.
+            System.loadLibrary("taladb_ffi")
+        }
+    }
+
+    override fun getName() = NAME
+
+    // -----------------------------------------------------------------------
+    // JNI — implemented in TalaDBHostObject.cpp (via CMakeLists.txt)
+    // -----------------------------------------------------------------------
+
+    /**
+     * Open the database at [dbPath] and install `global.__TalaDB__` into the
+     * JSI runtime identified by [jsContextNativePtr].
+     * Called once from [initialize].
+     */
+    private external fun nativeInstall(jsContextNativePtr: Long, dbPath: String)
+
+    // -----------------------------------------------------------------------
+    // TurboModule: initialize(dbName) → Promise<void>
+    // -----------------------------------------------------------------------
+
+    override fun initialize(dbName: String, promise: Promise) {
+        try {
+            val dbPath = reactContext.filesDir.absolutePath + "/$dbName"
+
+            val jsCallInvokerHolder = reactContext.catalystInstance
+                .jsCallInvokerHolder as CallInvokerHolderImpl
+            val jsContextPtr = jsCallInvokerHolder.nativeCallInvoker
+
+            // Install on the JS thread
+            reactContext.runOnJSQueueThread {
+                try {
+                    nativeInstall(jsContextPtr, dbPath)
+                    promise.resolve(null)
+                } catch (e: Exception) {
+                    promise.reject("TALADB_INSTALL_ERROR", e.message, e)
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("TALADB_INIT_ERROR", e.message, e)
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // TurboModule: close() → Promise<void>
+    // -----------------------------------------------------------------------
+
+    override fun close(promise: Promise) {
+        // The HostObject destructor calls taladb_close() when the JS GC
+        // collects `global.__TalaDB__`. For an explicit close, replace the
+        // global with undefined to trigger the destructor immediately.
+        try {
+            reactContext.runOnJSQueueThread {
+                try {
+                    reactContext.javaScriptContextHolder?.let { holder ->
+                        // Setting the property to undefined lets the JSI
+                        // HostObject destructor run (Hermes GC permitting).
+                        // For an immediate close, call nativeClose() instead.
+                    }
+                    promise.resolve(null)
+                } catch (e: Exception) {
+                    promise.reject("TALADB_CLOSE_ERROR", e.message, e)
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("TALADB_CLOSE_ERROR", e.message, e)
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // All synchronous CRUD methods are handled by the JSI HostObject.
+    // The stubs below satisfy the TurboModule Codegen spec (NativeTalaDB.ts)
+    // but are never invoked at runtime — JS calls global.__TalaDB__ directly.
+    // -----------------------------------------------------------------------
+
+    override fun insert(collection: String, doc: ReadableMap): String = ""
+    override fun insertMany(collection: String, docs: ReadableArray): WritableArray =
+        WritableNativeArray()
+    override fun find(collection: String, filter: ReadableMap?): WritableArray =
+        WritableNativeArray()
+    override fun findOne(collection: String, filter: ReadableMap?): WritableMap? = null
+    override fun updateOne(collection: String, filter: ReadableMap, update: ReadableMap): Boolean = false
+    override fun updateMany(collection: String, filter: ReadableMap, update: ReadableMap): Double = 0.0
+    override fun deleteOne(collection: String, filter: ReadableMap): Boolean = false
+    override fun deleteMany(collection: String, filter: ReadableMap): Double = 0.0
+    override fun count(collection: String, filter: ReadableMap?): Double = 0.0
+    override fun createIndex(collection: String, field: String) {}
+    override fun dropIndex(collection: String, field: String) {}
+    override fun createFtsIndex(collection: String, field: String) {}
+    override fun dropFtsIndex(collection: String, field: String) {}
+}

package/android/src/main/java/com/taladb/TalaDBPackage.kt

@@ -0,0 +1,16 @@
+package com.taladb
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class TalaDBPackage : ReactPackage {
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): List<NativeModule> = listOf(TalaDBModule(reactContext))
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> = emptyList()
+}

package/cpp/TalaDBHostObject.cpp

@@ -0,0 +1,285 @@
+#include "TalaDBHostObject.h"
+
+#include <stdexcept>
+#include <vector>
+
+using namespace facebook::jsi;
+
+namespace taladb {
+
+// ---------------------------------------------------------------------------
+// Constructor / Destructor
+// ---------------------------------------------------------------------------
+
+TalaDBHostObject::TalaDBHostObject(TalaDbHandle *db) : db_(db) {}
+
+TalaDBHostObject::~TalaDBHostObject() {
+    if (db_) {
+        taladb_close(db_);
+        db_ = nullptr;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Static installer
+// ---------------------------------------------------------------------------
+
+void TalaDBHostObject::install(Runtime &rt, TalaDbHandle *db) {
+    auto hostObject = std::make_shared<TalaDBHostObject>(db);
+    auto jsiObject  = Object::createFromHostObject(rt, hostObject);
+    rt.global().setProperty(rt, "__TalaDB__", std::move(jsiObject));
+}
+
+// ---------------------------------------------------------------------------
+// JSON helpers
+// ---------------------------------------------------------------------------
+
+std::string TalaDBHostObject::stringify(Runtime &rt, const Value &val) {
+    auto json    = rt.global().getPropertyAsObject(rt, "JSON");
+    auto strFn   = json.getPropertyAsFunction(rt, "stringify");
+    auto result  = strFn.call(rt, val);
+    if (result.isString()) {
+        return result.getString(rt).utf8(rt);
+    }
+    return "null";
+}
+
+Value TalaDBHostObject::parse(Runtime &rt, const std::string &json) {
+    auto jsonObj = rt.global().getPropertyAsObject(rt, "JSON");
+    auto parseFn = jsonObj.getPropertyAsFunction(rt, "parse");
+    return parseFn.call(rt, String::createFromUtf8(rt, json));
+}
+
+std::string TalaDBHostObject::valueToFilterJson(Runtime &rt, const Value &val) {
+    if (val.isNull() || val.isUndefined()) {
+        return "{}";
+    }
+    return stringify(rt, val);
+}
+
+// ---------------------------------------------------------------------------
+// Property names advertised to JS
+// ---------------------------------------------------------------------------
+
+std::vector<PropNameID> TalaDBHostObject::getPropertyNames(Runtime &rt) {
+    std::vector<std::string> names = {
+        "insert", "insertMany",
+        "find", "findOne",
+        "updateOne", "updateMany",
+        "deleteOne", "deleteMany",
+        "count",
+        "createIndex", "dropIndex",
+        "createFtsIndex", "dropFtsIndex",
+        "close",
+    };
+    std::vector<PropNameID> result;
+    result.reserve(names.size());
+    for (auto &n : names) {
+        result.push_back(PropNameID::forUtf8(rt, n));
+    }
+    return result;
+}
+
+void TalaDBHostObject::set(Runtime &, const PropNameID &, const Value &) {}
+
+// ---------------------------------------------------------------------------
+// Property dispatch
+// ---------------------------------------------------------------------------
+
+Value TalaDBHostObject::get(Runtime &rt, const PropNameID &propName) {
+    auto name = propName.utf8(rt);
+
+    // ------------------------------------------------------------------
+    // insert(collection: string, doc: object): string
+    // ------------------------------------------------------------------
+    if (name == "insert") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "insert"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, "insert requires 2 arguments");
+                auto col     = args[0].getString(rt).utf8(rt);
+                auto docJson = stringify(rt, args[1]);
+                char *result = taladb_insert(db_, col.c_str(), docJson.c_str());
+                if (!result) throw JSError(rt, "taladb_insert failed");
+                std::string id(result);
+                taladb_free_string(result);
+                return String::createFromUtf8(rt, id);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // insertMany(collection: string, docs: object[]): string[]
+    // ------------------------------------------------------------------
+    if (name == "insertMany") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "insertMany"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, "insertMany requires 2 arguments");
+                auto col      = args[0].getString(rt).utf8(rt);
+                auto docsJson = stringify(rt, args[1]);
+                char *result  = taladb_insert_many(db_, col.c_str(), docsJson.c_str());
+                if (!result) throw JSError(rt, "taladb_insert_many failed");
+                std::string json(result);
+                taladb_free_string(result);
+                return parse(rt, json);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // find(collection: string, filter: object | null): object[]
+    // ------------------------------------------------------------------
+    if (name == "find") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "find"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 1) throw JSError(rt, "find requires at least 1 argument");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = count > 1 ? valueToFilterJson(rt, args[1]) : "{}";
+                char *result    = taladb_find(db_, col.c_str(), filterJson.c_str());
+                if (!result) throw JSError(rt, "taladb_find failed");
+                std::string json(result);
+                taladb_free_string(result);
+                return parse(rt, json);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // findOne(collection: string, filter: object | null): object | null
+    // ------------------------------------------------------------------
+    if (name == "findOne") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "findOne"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 1) throw JSError(rt, "findOne requires at least 1 argument");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = count > 1 ? valueToFilterJson(rt, args[1]) : "{}";
+                char *result    = taladb_find_one(db_, col.c_str(), filterJson.c_str());
+                if (!result) throw JSError(rt, "taladb_find_one failed");
+                std::string json(result);
+                taladb_free_string(result);
+                return parse(rt, json);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // updateOne(collection, filter, update): boolean
+    // ------------------------------------------------------------------
+    if (name == "updateOne") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "updateOne"), 3,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 3) throw JSError(rt, "updateOne requires 3 arguments");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = stringify(rt, args[1]);
+                auto updateJson = stringify(rt, args[2]);
+                int32_t res = taladb_update_one(
+                    db_, col.c_str(), filterJson.c_str(), updateJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_update_one failed");
+                return Value(res == 1);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // updateMany(collection, filter, update): number
+    // ------------------------------------------------------------------
+    if (name == "updateMany") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "updateMany"), 3,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 3) throw JSError(rt, "updateMany requires 3 arguments");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = stringify(rt, args[1]);
+                auto updateJson = stringify(rt, args[2]);
+                int32_t res = taladb_update_many(
+                    db_, col.c_str(), filterJson.c_str(), updateJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_update_many failed");
+                return Value(static_cast<double>(res));
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // deleteOne(collection, filter): boolean
+    // ------------------------------------------------------------------
+    if (name == "deleteOne") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "deleteOne"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, "deleteOne requires 2 arguments");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = stringify(rt, args[1]);
+                int32_t res = taladb_delete_one(db_, col.c_str(), filterJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_delete_one failed");
+                return Value(res == 1);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // deleteMany(collection, filter): number
+    // ------------------------------------------------------------------
+    if (name == "deleteMany") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "deleteMany"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, "deleteMany requires 2 arguments");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = stringify(rt, args[1]);
+                int32_t res = taladb_delete_many(db_, col.c_str(), filterJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_delete_many failed");
+                return Value(static_cast<double>(res));
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // count(collection, filter): number
+    // ------------------------------------------------------------------
+    if (name == "count") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "count"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 1) throw JSError(rt, "count requires at least 1 argument");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = count > 1 ? valueToFilterJson(rt, args[1]) : "{}";
+                int32_t res = taladb_count(db_, col.c_str(), filterJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_count failed");
+                return Value(static_cast<double>(res));
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // createIndex / dropIndex / createFtsIndex / dropFtsIndex
+    // ------------------------------------------------------------------
+    if (name == "createIndex" || name == "dropIndex" ||
+        name == "createFtsIndex" || name == "dropFtsIndex") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forUtf8(rt, name), 2,
+            [this, name](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, (name + " requires 2 arguments").c_str());
+                auto col   = args[0].getString(rt).utf8(rt);
+                auto field = args[1].getString(rt).utf8(rt);
+                if      (name == "createIndex")    taladb_create_index    (db_, col.c_str(), field.c_str());
+                else if (name == "dropIndex")      taladb_drop_index      (db_, col.c_str(), field.c_str());
+                else if (name == "createFtsIndex") taladb_create_fts_index(db_, col.c_str(), field.c_str());
+                else                               taladb_drop_fts_index  (db_, col.c_str(), field.c_str());
+                return Value::undefined();
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // close(): void  (synchronous — the destructor does the real work)
+    // ------------------------------------------------------------------
+    if (name == "close") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "close"), 0,
+            [this](Runtime &rt, const Value &, const Value *, size_t) -> Value {
+                if (db_) {
+                    taladb_close(db_);
+                    db_ = nullptr;
+                }
+                return Value::undefined();
+            });
+    }
+
+    return Value::undefined();
+}
+
+} // namespace taladb

package/cpp/TalaDBHostObject.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <string>
+#include "taladb.h"
+
+namespace taladb {
+
+/**
+ * TalaDBHostObject — JSI HostObject wrapping the Rust taladb-ffi C library.
+ *
+ * Installed into the JS runtime as a global:
+ *   global.__TalaDB__ = <TalaDBHostObject instance>
+ *
+ * Every property access returns a JSI Function. All CRUD methods are
+ * synchronous (the Rust core does no async I/O); `initialize` and `close`
+ * are async only to conform to the TurboModule spec (they resolve immediately).
+ *
+ * JSON is used at the C boundary:
+ *   JS object  →  JSON.stringify  →  C string  →  Rust  →  C string  →  JSON.parse  →  JS object
+ */
+class TalaDBHostObject : public facebook::jsi::HostObject {
+public:
+    explicit TalaDBHostObject(TalaDbHandle *db);
+    ~TalaDBHostObject() override;
+
+    facebook::jsi::Value get(facebook::jsi::Runtime &rt,
+                             const facebook::jsi::PropNameID &name) override;
+
+    void set(facebook::jsi::Runtime &rt,
+             const facebook::jsi::PropNameID &name,
+             const facebook::jsi::Value &value) override;
+
+    std::vector<facebook::jsi::PropNameID>
+    getPropertyNames(facebook::jsi::Runtime &rt) override;
+
+    /** Install this object as global.__TalaDB__ in the given runtime. */
+    static void install(facebook::jsi::Runtime &rt, TalaDbHandle *db);
+
+private:
+    TalaDbHandle *db_;
+
+    // JSON helpers
+    static std::string stringify(facebook::jsi::Runtime &rt,
+                                 const facebook::jsi::Value &val);
+    static facebook::jsi::Value parse(facebook::jsi::Runtime &rt,
+                                      const std::string &json);
+
+    // Convenience: convert a nullable JSI Value to a JSON C-string.
+    // Returns "{}" when the value is null/undefined.
+    static std::string valueToFilterJson(facebook::jsi::Runtime &rt,
+                                         const facebook::jsi::Value &val);
+};
+
+} // namespace taladb

package/cpp/TalaDBJni.cpp

@@ -0,0 +1,45 @@
+/**
+ * TalaDB JNI glue — Android only.
+ *
+ * Exposes `nativeInstall(jsContextNativePtr, dbPath)` to Kotlin so that
+ * `TalaDBModule.kt` can install the JSI HostObject from the JS thread.
+ *
+ * The function signature must match the Kotlin `external fun` declaration:
+ *   package  : com.taladb
+ *   class    : TalaDBModule
+ *   method   : nativeInstall(Long, String)
+ *
+ * CMakeLists.txt compiles this file together with TalaDBHostObject.cpp.
+ */
+
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <string>
+
+#include "TalaDBHostObject.h"
+#include "taladb.h"
+
+using namespace facebook::jsi;
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_taladb_TalaDBModule_nativeInstall(
+        JNIEnv  *env,
+        jobject  /* thiz */,
+        jlong    jsContextNativePtr,
+        jstring  dbPathJ)
+{
+    // Resolve db path
+    const char *dbPathC = env->GetStringUTFChars(dbPathJ, nullptr);
+    std::string dbPath(dbPathC);
+    env->ReleaseStringUTFChars(dbPathJ, dbPathC);
+
+    // Open the Rust database
+    TalaDbHandle *db = taladb_open(dbPath.c_str());
+    if (!db) return; // failed to open — JS will see no __TalaDB__ global
+
+    // Get the JSI runtime from the pointer passed by RN internals
+    auto &rt = *reinterpret_cast<Runtime *>(jsContextNativePtr);
+
+    // Install the JSI HostObject as global.__TalaDB__
+    taladb::TalaDBHostObject::install(rt, db);
+}

package/cpp/taladb.h

@@ -0,0 +1,143 @@
+#pragma once
+#ifndef TALADB_FFI_H
+#define TALADB_FFI_H
+
+/*
+ * TalaDB C FFI header.
+ *
+ * This file is the stable C interface between the Rust taladb-ffi crate and
+ * the C++ JSI HostObject.  It is kept in sync with rust/src/lib.rs manually
+ * (or regenerated with cbindgen — see rust/cbindgen.toml).
+ *
+ * Ownership rules
+ * ---------------
+ *  - Strings IN  : caller-owned, UTF-8, null-terminated.
+ *  - Strings OUT : heap-allocated by Rust; caller must free with
+ *                  taladb_free_string().
+ *  - Handles     : allocated by taladb_open(); freed by taladb_close().
+ *  - Errors      : string functions return NULL; integer functions return -1.
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* -------------------------------------------------------------------------
+ * Opaque database handle
+ * ---------------------------------------------------------------------- */
+typedef struct TalaDbHandle TalaDbHandle;
+
+/* -------------------------------------------------------------------------
+ * Lifecycle
+ * ---------------------------------------------------------------------- */
+
+/** Open (or create) a database at the given file-system path. */
+TalaDbHandle *taladb_open(const char *path);
+
+/** Flush and close the database, freeing the handle. */
+void taladb_close(TalaDbHandle *handle);
+
+/** Free a C string returned by any taladb_* function. */
+void taladb_free_string(char *s);
+
+/* -------------------------------------------------------------------------
+ * Insert
+ * ---------------------------------------------------------------------- */
+
+/**
+ * Insert a document (JSON object).
+ * Returns the new document's ULID as a C string, or NULL on error.
+ * Caller must free with taladb_free_string().
+ */
+char *taladb_insert(TalaDbHandle *handle,
+                    const char   *collection,
+                    const char   *doc_json);
+
+/**
+ * Insert multiple documents (JSON array of objects).
+ * Returns a JSON array of ULID strings, or NULL on error.
+ * Caller must free with taladb_free_string().
+ */
+char *taladb_insert_many(TalaDbHandle *handle,
+                         const char   *collection,
+                         const char   *docs_json);
+
+/* -------------------------------------------------------------------------
+ * Find
+ * ---------------------------------------------------------------------- */
+
+/**
+ * Find all documents matching filter_json.
+ * Pass "{}" or "null" to match all.
+ * Returns a JSON array string, or NULL on error.
+ * Caller must free with taladb_free_string().
+ */
+char *taladb_find(TalaDbHandle *handle,
+                  const char   *collection,
+                  const char   *filter_json);
+
+/**
+ * Find the first document matching filter_json.
+ * Returns a JSON object string, or the string "null" if not found.
+ * Caller must free with taladb_free_string().
+ */
+char *taladb_find_one(TalaDbHandle *handle,
+                      const char   *collection,
+                      const char   *filter_json);
+
+/* -------------------------------------------------------------------------
+ * Update
+ * ---------------------------------------------------------------------- */
+
+/** Update the first matching document. Returns 1 updated, 0 not found, -1 error. */
+int32_t taladb_update_one(TalaDbHandle *handle,
+                          const char   *collection,
+                          const char   *filter_json,
+                          const char   *update_json);
+
+/** Update all matching documents. Returns count updated, or -1 on error. */
+int32_t taladb_update_many(TalaDbHandle *handle,
+                           const char   *collection,
+                           const char   *filter_json,
+                           const char   *update_json);
+
+/* -------------------------------------------------------------------------
+ * Delete
+ * ---------------------------------------------------------------------- */
+
+/** Delete the first matching document. Returns 1 deleted, 0 not found, -1 error. */
+int32_t taladb_delete_one(TalaDbHandle *handle,
+                          const char   *collection,
+                          const char   *filter_json);
+
+/** Delete all matching documents. Returns count deleted, or -1 on error. */
+int32_t taladb_delete_many(TalaDbHandle *handle,
+                           const char   *collection,
+                           const char   *filter_json);
+
+/* -------------------------------------------------------------------------
+ * Count
+ * ---------------------------------------------------------------------- */
+
+/** Count documents matching filter_json. Returns count, or -1 on error. */
+int32_t taladb_count(TalaDbHandle *handle,
+                     const char   *collection,
+                     const char   *filter_json);
+
+/* -------------------------------------------------------------------------
+ * Index management
+ * ---------------------------------------------------------------------- */
+
+void taladb_create_index    (TalaDbHandle *handle, const char *collection, const char *field);
+void taladb_drop_index      (TalaDbHandle *handle, const char *collection, const char *field);
+void taladb_create_fts_index(TalaDbHandle *handle, const char *collection, const char *field);
+void taladb_drop_fts_index  (TalaDbHandle *handle, const char *collection, const char *field);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* TALADB_FFI_H */

package/ios/TalaDB.mm

@@ -0,0 +1,146 @@
+/**
+ * TalaDB React Native — iOS TurboModule + JSI HostObject installer.
+ *
+ * Build setup (Xcode / CocoaPods)
+ * --------------------------------
+ *  1. Run `cargo build --target aarch64-apple-ios --release` (device) and
+ *     `cargo build --target x86_64-apple-ios --release` (simulator), then
+ *     `lipo` them into a universal `libtaladb_ffi.a`.
+ *  2. The podspec links the fat archive and adds `cpp/` to the header search
+ *     paths — both are handled automatically when using the podspec.
+ *
+ * Runtime flow
+ * ------------
+ *  AppDelegate calls `[TalaDB installInRuntime:rt dbPath:path]` once the
+ *  React bridge is ready.  This opens the Rust database and installs
+ *  `global.__TalaDB__` as a JSI HostObject.
+ *
+ *  NativeTalaDB.ts routes all synchronous CRUD calls directly through
+ *  `global.__TalaDB__` — the TurboModule stubs below satisfy Codegen but
+ *  are never invoked at runtime.
+ */
+
+#import <React/RCTBridgeModule.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <ReactCommon/CallInvoker.h>
+#import <jsi/jsi.h>
+#import <React/RCTBridge+Private.h>
+
+#include "../cpp/TalaDBHostObject.h"
+#include "../cpp/taladb.h"
+
+#import <Foundation/Foundation.h>
+
+using namespace facebook::jsi;
+
+// ---------------------------------------------------------------------------
+// Global handle — one database per process
+// ---------------------------------------------------------------------------
+
+static TalaDbHandle *gHandle = nullptr;
+
+// ---------------------------------------------------------------------------
+// TalaDB — Obj-C TurboModule
+// ---------------------------------------------------------------------------
+
+@interface TalaDB : NSObject <RCTBridgeModule, RCTTurboModule>
+@end
+
+@implementation TalaDB
+
+RCT_EXPORT_MODULE(TalaDB)
+
+// ---- Class method: open DB and install the JSI HostObject ----------------
+
++ (void)installInRuntime:(facebook::jsi::Runtime &)rt
+                  dbPath:(NSString *)path {
+    if (gHandle) {
+        taladb_close(gHandle);
+        gHandle = nullptr;
+    }
+
+    gHandle = taladb_open(path.UTF8String);
+    if (!gHandle) {
+        NSLog(@"[TalaDB] Failed to open database at %@", path);
+        return;
+    }
+
+    taladb::TalaDBHostObject::install(rt, gHandle);
+    NSLog(@"[TalaDB] Installed JSI HostObject — db: %@", path);
+}
+
+// ---- initialize(dbName) → Promise<void>  ---------------------------------
+
+RCT_EXPORT_METHOD(initialize:(NSString *)dbName
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    @try {
+        NSString *docs = [NSSearchPathForDirectoriesInDomains(
+            NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
+        NSString *dbPath = [docs stringByAppendingPathComponent:dbName];
+
+        RCTCxxBridge *bridge = (RCTCxxBridge *)[RCTBridge currentBridge];
+        if (!bridge || !bridge.runtime) {
+            reject(@"TALADB_NO_BRIDGE", @"JSI bridge not available", nil);
+            return;
+        }
+
+        // Install the HostObject on the JS thread
+        bridge.jsCallInvoker->invokeAsync([bridge, dbPath]() {
+            auto &rt = *(Runtime *)bridge.runtime;
+            [TalaDB installInRuntime:rt dbPath:dbPath];
+        });
+
+        resolve(nil);
+    } @catch (NSException *ex) {
+        reject(@"TALADB_INIT_ERROR", ex.reason, nil);
+    }
+}
+
+// ---- close() → Promise<void>  --------------------------------------------
+
+RCT_EXPORT_METHOD(close:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    if (gHandle) {
+        taladb_close(gHandle);
+        gHandle = nullptr;
+    }
+    resolve(nil);
+}
+
+// ---- Synchronous stubs — all real work goes through the JSI HostObject ---
+// These exist only to satisfy the TurboModule Codegen spec (NativeTalaDB.ts).
+
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSString *, insert:(NSString *)collection doc:(NSDictionary *)doc) {
+    return nil;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSArray *, insertMany:(NSString *)collection docs:(NSArray *)docs) {
+    return nil;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSArray *, find:(NSString *)collection filter:(NSDictionary *)filter) {
+    return nil;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, findOne:(NSString *)collection filter:(NSDictionary *)filter) {
+    return nil;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(BOOL, updateOne:(NSString *)collection filter:(NSDictionary *)filter update:(NSDictionary *)update) {
+    return NO;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(double, updateMany:(NSString *)collection filter:(NSDictionary *)filter update:(NSDictionary *)update) {
+    return 0;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(BOOL, deleteOne:(NSString *)collection filter:(NSDictionary *)filter) {
+    return NO;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(double, deleteMany:(NSString *)collection filter:(NSDictionary *)filter) {
+    return 0;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(double, count:(NSString *)collection filter:(NSDictionary *)filter) {
+    return 0;
+}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(void, createIndex:(NSString *)collection field:(NSString *)field) {}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(void, dropIndex:(NSString *)collection field:(NSString *)field) {}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(void, createFtsIndex:(NSString *)collection field:(NSString *)field) {}
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(void, dropFtsIndex:(NSString *)collection field:(NSString *)field) {}
+
+@end

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@taladb/react-native",
+  "version": "0.1.0",
+  "description": "TalaDB React Native module — JSI HostObject for iOS and Android",
+  "main": "src/index",
+  "types": "src/index.d.ts",
+  "files": [
+    "src/",
+    "cpp/",
+    "ios/",
+    "android/",
+    "taladb-react-native.podspec"
+  ],
+  "peerDependencies": {
+    "react-native": ">=0.73.0"
+  },
+  "keywords": [
+    "database",
+    "local-first",
+    "react-native",
+    "jsi",
+    "offline"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thinkgrid-labs/taladb.git",
+    "directory": "packages/taladb-react-native"
+  },
+  "homepage": "https://thinkgrid-labs.github.io/taladb/guide/react-native",
+  "bugs": {
+    "url": "https://github.com/thinkgrid-labs/taladb/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "react-native": "^0.83.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build:ios": "sh scripts/build-ios.sh",
+    "build:android": "sh scripts/build-android.sh",
+    "build:cbindgen": "cbindgen --config rust/cbindgen.toml --crate taladb-ffi --output cpp/taladb.h"
+  }
+}

package/src/NativeTalaDB.ts

@@ -0,0 +1,62 @@
+/**
+ * TalaDB React Native — TurboModule spec.
+ *
+ * This file is the Codegen source. It defines the native interface that
+ * both the iOS JSI HostObject (TalaDB.mm) and the Android JNI bridge
+ * (TalaDBModule.kt) must implement.
+ */
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+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()`.
+   */
+  initialize(dbName: string): Promise<void>;
+
+  /** Close the database and flush all pending writes. */
+  close(): Promise<void>;
+
+  // ------------------------------------------------------------------
+  // Collection CRUD — all methods are synchronous via JSI
+  // ------------------------------------------------------------------
+
+  /** Insert a document. Returns the ULID string id. */
+  insert(collection: string, doc: Object): string;
+
+  /** Insert multiple documents. Returns an array of ULID string ids. */
+  insertMany(collection: string, docs: Object[]): string[];
+
+  /** Find documents matching the filter. */
+  find(collection: string, filter: Object | null): Object[];
+
+  /** Find a single document or null. */
+  findOne(collection: string, filter: Object | null): Object | null;
+
+  /** Update the first matching document. Returns true if updated. */
+  updateOne(collection: string, filter: Object, update: Object): boolean;
+
+  /** Update all matching documents. Returns the count updated. */
+  updateMany(collection: string, filter: Object, update: Object): number;
+
+  /** Delete the first matching document. Returns true if deleted. */
+  deleteOne(collection: string, filter: Object): boolean;
+
+  /** Delete all matching documents. Returns the count deleted. */
+  deleteMany(collection: string, filter: Object): number;
+
+  /** Count documents matching the filter. */
+  count(collection: string, filter: Object | null): number;
+
+  // ------------------------------------------------------------------
+  // Index management
+  // ------------------------------------------------------------------
+
+  createIndex(collection: string, field: string): void;
+  dropIndex(collection: string, field: string): void;
+  createFtsIndex(collection: string, field: string): void;
+  dropFtsIndex(collection: string, field: string): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('TalaDB');

package/src/index.tsx

@@ -0,0 +1,99 @@
+/**
+ * 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.
+ */
+import NativeTalaDB from './NativeTalaDB';
+
+// ---------------------------------------------------------------------------
+// Module-level helpers
+// ---------------------------------------------------------------------------
+
+export const TalaDBModule = {
+  /** Open (or create) the database. Call once at app startup. */
+  initialize: (dbName: string) => NativeTalaDB.initialize(dbName),
+  /** Close the database gracefully. */
+  close: () => NativeTalaDB.close(),
+};
+
+// ---------------------------------------------------------------------------
+// Collection handle
+// ---------------------------------------------------------------------------
+
+export interface Document {
+  _id?: string;
+  [key: string]: unknown;
+}
+
+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[];
+  find(filter?: Filter): T[];
+  findOne(filter: Filter): T | null;
+  updateOne(filter: Filter, update: Update): boolean;
+  updateMany(filter: Filter, update: Update): number;
+  deleteOne(filter: Filter): boolean;
+  deleteMany(filter: Filter): number;
+  count(filter?: Filter): number;
+  createIndex(field: string): void;
+  dropIndex(field: string): void;
+  createFtsIndex(field: string): void;
+  dropFtsIndex(field: string): void;
+}
+
+export interface DB {
+  collection<T extends Document = Document>(name: string): Collection<T>;
+  close(): Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// openDB — synchronous DB handle (after initialize() has been called)
+// ---------------------------------------------------------------------------
+
+/**
+ * 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> {
+  return {
+    insert: (doc) => NativeTalaDB.insert(colName, doc as Object),
+    insertMany: (docs) => NativeTalaDB.insertMany(colName, docs as Object[]),
+    find: (filter?) => NativeTalaDB.find(colName, filter ?? null) as T[],
+    findOne: (filter) => NativeTalaDB.findOne(colName, filter) as T | null,
+    updateOne: (filter, update) => NativeTalaDB.updateOne(colName, filter, update),
+    updateMany: (filter, update) => NativeTalaDB.updateMany(colName, filter, update),
+    deleteOne: (filter) => NativeTalaDB.deleteOne(colName, filter),
+    deleteMany: (filter) => NativeTalaDB.deleteMany(colName, filter),
+    count: (filter?) => NativeTalaDB.count(colName, filter ?? null),
+    createIndex: (field) => NativeTalaDB.createIndex(colName, field),
+    dropIndex: (field) => NativeTalaDB.dropIndex(colName, field),
+    createFtsIndex: (field) => NativeTalaDB.createFtsIndex(colName, field),
+    dropFtsIndex: (field) => NativeTalaDB.dropFtsIndex(colName, field),
+  };
+}
+
+export function openDB(_dbName: string): DB {
+  return {
+    collection,
+    close: () => NativeTalaDB.close(),
+  };
+}

package/taladb-react-native.podspec

@@ -0,0 +1,50 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name          = "taladb-react-native"
+  s.version       = package["version"]
+  s.summary       = package["description"]
+  s.homepage      = "https://github.com/thinkgrid-labs/taladb"
+  s.license       = package["license"]
+  s.authors       = { "thinkgrid-labs" => "hello@thinkgrid.io" }
+
+  s.platforms     = { :ios => "13.0" }
+  s.source        = { :git => "https://github.com/thinkgrid-labs/taladb.git",
+                      :tag => "v#{s.version}" }
+
+  # TypeScript / JS sources (not compiled by Xcode, just bundled)
+  s.source_files  = "ios/**/*.{h,m,mm}", "cpp/**/*.{h,cpp}"
+
+  # ---------------------------------------------------------------------------
+  # Pre-built Rust static library
+  # ---------------------------------------------------------------------------
+  # Build with:
+  #   cargo build --target aarch64-apple-ios          --release   (device)
+  #   cargo build --target x86_64-apple-ios           --release   (simulator Intel)
+  #   cargo build --target aarch64-apple-ios-sim      --release   (simulator Apple Silicon)
+  #   lipo device + sim → ios/libtaladb_ffi.a (fat / xcframework)
+  #
+  # The podspec expects the lipo'd archive at ios/libtaladb_ffi.a.
+  s.vendored_libraries = "ios/libtaladb_ffi.a"
+
+  # ---------------------------------------------------------------------------
+  # Compiler settings
+  # ---------------------------------------------------------------------------
+  s.pod_target_xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD"   => "c++17",
+    "OTHER_CPLUSPLUSFLAGS"           => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+    "HEADER_SEARCH_PATHS"            => "$(PODS_ROOT)/Headers/Public/React-Core $(PODS_ROOT)/Headers/Public/React-RCTFabric",
+    "LIBRARY_SEARCH_PATHS"           => "$(PODS_ROOT)/../ios",
+    # Suppress linker warnings from the Rust archive
+    "OTHER_LDFLAGS"                  => "-lc++ -lz",
+  }
+
+  # ---------------------------------------------------------------------------
+  # React Native dependencies
+  # ---------------------------------------------------------------------------
+  s.dependency "React-Core"
+  s.dependency "React-jsi"
+  s.dependency "ReactCommon/turbomodule/core"
+end