@magicred-1/react-native-lxmf 0.1.6 → 0.1.9

package/android/src/main/kotlin/expo/modules/lxmf/BleManager.kt

@@ -3,6 +3,7 @@ package expo.modules.lxmf
 import android.bluetooth.*
 import android.bluetooth.le.*
 import android.content.Context
+import android.os.Build
 import android.os.Handler
 import android.os.Looper
 import android.os.ParcelUuid
@@ -53,6 +54,14 @@ class BleManager(
     private var isScanning = false
     private var isAdvertising = false
 
+    // GATT server (peripheral role) — accepts inbound writes from remote centrals
+    // and pushes outbound notifications to subscribed centrals.
+    private var gattServer: BluetoothGattServer? = null
+    private var serverTxChar: BluetoothGattCharacteristic? = null
+    // Centrals that have enabled CCC notifications on our TX char, keyed by MAC.
+    // Only these are "registered as peers" with Rust (mirrors iOS subscribedCentrals).
+    private val serverSubscribers = mutableMapOf<String, BluetoothDevice>()
+
     // TX polling — every 50 ms drain the Rust TX queue and write to peers
     private val txPollRunnable = object : Runnable {
         override fun run() {
@@ -75,7 +84,10 @@ class BleManager(
             Log.w(TAG, "Bluetooth not available or not enabled")
             return
         }
-        startAdvertising()
+        // GATT server must be opened (and service added) before advertising,
+        // otherwise centrals connect and find no service. startAdvertising()
+        // is invoked from onServiceAdded once the service is registered.
+        openGattServer()
         startScanning()
         mainHandler.postDelayed(txPollRunnable, TX_POLL_INTERVAL_MS)
         Log.i(TAG, "BleManager started")
@@ -84,6 +96,7 @@ class BleManager(
     fun stop() {
         stopScanning()
         stopAdvertising()
+        closeGattServer()
         mainHandler.removeCallbacks(txPollRunnable)
         connections.values.forEach { it.disconnect(); it.close() }
         connections.clear()
@@ -127,6 +140,193 @@ class BleManager(
         }
     }
 
+    // ── GATT server (peripheral role) ────────────────────────────────────────
+
+    private fun openGattServer() {
+        val mgr = bluetoothManager ?: return
+        gattServer = mgr.openGattServer(context, gattServerCallback)
+        if (gattServer == null) {
+            Log.e(TAG, "openGattServer returned null (missing BLUETOOTH_CONNECT?)")
+            return
+        }
+
+        val service = BluetoothGattService(
+            RNS_SERVICE_UUID,
+            BluetoothGattService.SERVICE_TYPE_PRIMARY,
+        )
+
+        // RX — remote centrals write LXMF frames here. We forward to Rust.
+        val rxChar = BluetoothGattCharacteristic(
+            RNS_RX_CHAR_UUID,
+            BluetoothGattCharacteristic.PROPERTY_WRITE or
+                BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE,
+            BluetoothGattCharacteristic.PERMISSION_WRITE,
+        )
+
+        // TX — we push outbound LXMF frames to subscribed centrals via NOTIFY.
+        val txChar = BluetoothGattCharacteristic(
+            RNS_TX_CHAR_UUID,
+            BluetoothGattCharacteristic.PROPERTY_NOTIFY or
+                BluetoothGattCharacteristic.PROPERTY_READ,
+            BluetoothGattCharacteristic.PERMISSION_READ,
+        )
+        // CCCD lets the central enable/disable notifications.
+        val cccd = BluetoothGattDescriptor(
+            CCCD_UUID,
+            BluetoothGattDescriptor.PERMISSION_READ or
+                BluetoothGattDescriptor.PERMISSION_WRITE,
+        )
+        txChar.addDescriptor(cccd)
+
+        service.addCharacteristic(rxChar)
+        service.addCharacteristic(txChar)
+        serverTxChar = txChar
+
+        val ok = gattServer?.addService(service) ?: false
+        Log.i(TAG, "GATT server opened, addService=$ok")
+    }
+
+    private fun closeGattServer() {
+        // Notify Rust that all subscribed centrals are gone.
+        for ((mac, _) in serverSubscribers) {
+            module.nativeBleDisconnected(macToBytes(mac))
+        }
+        serverSubscribers.clear()
+        gattServer?.close()
+        gattServer = null
+        serverTxChar = null
+    }
+
+    /**
+     * Push outbound bytes to a subscribed central via NOTIFY.
+     * Uses the API 33+ value-bearing variant when available (more reliable on
+     * Android 13+); falls back to the deprecated set-then-notify path on older
+     * devices. Returns true if the notification was queued.
+     */
+    private fun notifyServerSubscriber(
+        device: BluetoothDevice,
+        txChar: BluetoothGattCharacteristic,
+        data: ByteArray,
+    ): Boolean {
+        val server = gattServer ?: return false
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            // BluetoothStatusCodes.SUCCESS == 0
+            server.notifyCharacteristicChanged(device, txChar, false, data) == 0
+        } else {
+            @Suppress("DEPRECATION")
+            run {
+                txChar.value = data
+                server.notifyCharacteristicChanged(device, txChar, false)
+            }
+        }
+    }
+
+    private val gattServerCallback = object : BluetoothGattServerCallback() {
+        override fun onServiceAdded(status: Int, service: BluetoothGattService?) {
+            if (status == BluetoothGatt.GATT_SUCCESS) {
+                Log.i(TAG, "GATT service added; starting advertise")
+                startAdvertising()
+            } else {
+                Log.e(TAG, "GATT addService failed: $status")
+            }
+        }
+
+        override fun onConnectionStateChange(device: BluetoothDevice, status: Int, newState: Int) {
+            val mac = device.address ?: return
+            when (newState) {
+                BluetoothProfile.STATE_CONNECTED -> {
+                    // Just an ATT connection — peer hasn't subscribed yet, so
+                    // it's not a "peer" from Rust's POV. Wait for CCC write.
+                    Log.d(TAG, "GATT server: $mac connected")
+                }
+                BluetoothProfile.STATE_DISCONNECTED -> {
+                    if (serverSubscribers.remove(mac) != null) {
+                        Log.i(TAG, "GATT server: $mac disconnected (was subscribed)")
+                        module.nativeBleDisconnected(macToBytes(mac))
+                    }
+                }
+            }
+        }
+
+        override fun onCharacteristicWriteRequest(
+            device: BluetoothDevice,
+            requestId: Int,
+            characteristic: BluetoothGattCharacteristic,
+            preparedWrite: Boolean,
+            responseNeeded: Boolean,
+            offset: Int,
+            value: ByteArray?,
+        ) {
+            if (characteristic.uuid == RNS_RX_CHAR_UUID && value != null && value.isNotEmpty()) {
+                // Inbound LXMF frame from a remote central. Push raw bytes to
+                // Rust — HDLC deframing happens there. 4KB cap enforced in FFI.
+                Log.d(TAG, "GATT server RX ${value.size}B from ${device.address}")
+                module.nativeBleReceive(macToBytes(device.address), value)
+            }
+            if (responseNeeded) {
+                gattServer?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, null)
+            }
+        }
+
+        override fun onDescriptorWriteRequest(
+            device: BluetoothDevice,
+            requestId: Int,
+            descriptor: BluetoothGattDescriptor,
+            preparedWrite: Boolean,
+            responseNeeded: Boolean,
+            offset: Int,
+            value: ByteArray?,
+        ) {
+            if (descriptor.uuid == CCCD_UUID
+                && descriptor.characteristic?.uuid == RNS_TX_CHAR_UUID
+                && value != null
+            ) {
+                val mac = device.address
+                when {
+                    value.contentEquals(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE) -> {
+                        if (serverSubscribers.put(mac, device) == null) {
+                            Log.i(TAG, "GATT server: $mac subscribed to TX")
+                            module.nativeBleConnected(macToBytes(mac))
+                        }
+                    }
+                    value.contentEquals(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE) -> {
+                        if (serverSubscribers.remove(mac) != null) {
+                            Log.i(TAG, "GATT server: $mac unsubscribed")
+                            module.nativeBleDisconnected(macToBytes(mac))
+                        }
+                    }
+                }
+            }
+            if (responseNeeded) {
+                gattServer?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, null)
+            }
+        }
+
+        override fun onCharacteristicReadRequest(
+            device: BluetoothDevice,
+            requestId: Int,
+            offset: Int,
+            characteristic: BluetoothGattCharacteristic,
+        ) {
+            // TX is read+notify; some centrals do an initial read. Return empty.
+            gattServer?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, ByteArray(0))
+        }
+
+        override fun onDescriptorReadRequest(
+            device: BluetoothDevice,
+            requestId: Int,
+            offset: Int,
+            descriptor: BluetoothGattDescriptor,
+        ) {
+            val state = if (serverSubscribers.containsKey(device.address)) {
+                BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+            } else {
+                BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE
+            }
+            gattServer?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, state)
+        }
+    }
+
     // ── Scanning (find peers) ─────────────────────────────────────────────────
 
     private fun startScanning() {
@@ -207,13 +407,17 @@ class BleManager(
                 gatt.disconnect()
                 return
             }
-            // Enable notifications on RX characteristic
-            val rxChar = service.getCharacteristic(RNS_RX_CHAR_UUID)
-            if (rxChar != null) {
-                gatt.setCharacteristicNotification(rxChar, true)
-                val cccd = rxChar.getDescriptor(CCCD_UUID)
+            // Subscribe to peer's TX char (their notify path → our inbound).
+            // Convention matches iOS BLEManager.swift: RX is write-only on the
+            // peripheral, TX is notify-only. Subscribing to RX is a no-op.
+            val peerTxChar = service.getCharacteristic(RNS_TX_CHAR_UUID)
+            if (peerTxChar != null) {
+                gatt.setCharacteristicNotification(peerTxChar, true)
+                val cccd = peerTxChar.getDescriptor(CCCD_UUID)
                 cccd?.let {
+                    @Suppress("DEPRECATION")
                     it.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+                    @Suppress("DEPRECATION")
                     gatt.writeDescriptor(it)
                 }
             }
@@ -226,7 +430,8 @@ class BleManager(
             gatt: BluetoothGatt,
             characteristic: BluetoothGattCharacteristic,
         ) {
-            if (characteristic.uuid == RNS_RX_CHAR_UUID) {
+            if (characteristic.uuid == RNS_TX_CHAR_UUID) {
+                @Suppress("DEPRECATION")
                 val data = characteristic.value ?: return
                 Log.d(TAG, "BLE RX ${data.size}B from ${gatt.device.address}")
                 module.nativeBleReceive(macToBytes(gatt.device.address), data)
@@ -255,12 +460,28 @@ class BleManager(
                 val dataB64 = obj.getString("data")
                 val data = android.util.Base64.decode(dataB64, android.util.Base64.DEFAULT)
                 val mac = hexToMacString(peerHex)             // "AA:BB:CC:DD:EE:FF"
+
+                // Peripheral (server) role: peer subscribed to our TX char →
+                // push via NOTIFY. Mirrors iOS peripheralManager.updateValue.
+                val subscriber = serverSubscribers[mac]
+                val txChar = serverTxChar
+                if (subscriber != null && txChar != null) {
+                    val ok = notifyServerSubscriber(subscriber, txChar, data)
+                    Log.d(TAG, "BLE NOTIFY ${data.size}B to $mac ok=$ok")
+                    continue
+                }
+
+                // Central (client) role: write to peer's RX characteristic.
+                // RX has WRITE properties; TX is notify-only (writes there
+                // would be rejected by the peer). Matches iOS convention.
                 val gatt = connections[mac] ?: continue
                 val service = gatt.getService(RNS_SERVICE_UUID) ?: continue
-                val txChar = service.getCharacteristic(RNS_TX_CHAR_UUID) ?: continue
-                txChar.value = data
-                txChar.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
-                val ok = gatt.writeCharacteristic(txChar)
+                val peerRxChar = service.getCharacteristic(RNS_RX_CHAR_UUID) ?: continue
+                @Suppress("DEPRECATION")
+                peerRxChar.value = data
+                peerRxChar.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+                @Suppress("DEPRECATION")
+                val ok = gatt.writeCharacteristic(peerRxChar)
                 Log.d(TAG, "BLE TX ${data.size}B to $mac ok=$ok")
             } catch (e: Exception) {
                 Log.e(TAG, "drainTxQueue parse error: ${e.message}")

package/android/src/main/kotlin/expo/modules/lxmf/LxmfModule.kt

@@ -100,6 +100,11 @@ class LxmfModule : Module() {
       nativeBroadcast(destsJson, bodyBase64).toDouble()
     }
 
+    // Identity
+    Function("getIdentityHex") {
+      nativeGetIdentityHex()
+    }
+
     // Status & State
     Function("getStatus") {
       nativeGetStatus()
@@ -197,6 +202,7 @@ class LxmfModule : Module() {
   private external fun nativePollEvents(): String?
   private external fun nativeSend(destHex: String, bodyBase64: String): Long
   private external fun nativeBroadcast(destsJson: String, bodyBase64: String): Long
+  private external fun nativeGetIdentityHex(): String?
   private external fun nativeGetStatus(): String?
   private external fun nativeGetBeacons(): String?
   private external fun nativeFetchMessages(limit: Int): String?

package/build/LxmfModule.d.ts

@@ -8,6 +8,7 @@ export type NativeModuleType = {
     isRunning(): boolean;
     send(destHex: string, bodyBase64: string): Promise<number>;
     broadcast(destsHex: string[], bodyBase64: string): Promise<number>;
+    getIdentityHex(): string | null;
     getStatus(): string | null;
     getBeacons(): string | null;
     fetchMessages(limit: number): string | null;

package/build/LxmfModule.js

@@ -24,6 +24,7 @@ const missingNativeShim = {
     isRunning: () => false,
     send: async () => throwMissingNative(),
     broadcast: async () => throwMissingNative(),
+    getIdentityHex: () => throwMissingNative(),
     getStatus: () => throwMissingNative(),
     getBeacons: () => throwMissingNative(),
     fetchMessages: () => throwMissingNative(),

package/build/index.d.ts

@@ -1,2 +1,2 @@
-export { LxmfModule, LxmfModuleNative, NativeModuleType } from './LxmfModule';
+export { LxmfModule, LxmfModuleNative, isLxmfNativeAvailable, NativeModuleType } from './LxmfModule';
 export { useLxmf, LxmfNodeMode, type UseLxmfOptions, type TcpInterface, type LxmfNodeStatus, type Beacon, type LxmfEvent } from './useLxmf';

package/build/index.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LxmfNodeMode = exports.useLxmf = exports.LxmfModuleNative = exports.LxmfModule = void 0;
+exports.LxmfNodeMode = exports.useLxmf = exports.isLxmfNativeAvailable = exports.LxmfModuleNative = exports.LxmfModule = void 0;
 var LxmfModule_1 = require("./LxmfModule");
 Object.defineProperty(exports, "LxmfModule", { enumerable: true, get: function () { return LxmfModule_1.LxmfModule; } });
 Object.defineProperty(exports, "LxmfModuleNative", { enumerable: true, get: function () { return LxmfModule_1.LxmfModuleNative; } });
+Object.defineProperty(exports, "isLxmfNativeAvailable", { enumerable: true, get: function () { return LxmfModule_1.isLxmfNativeAvailable; } });
 var useLxmf_1 = require("./useLxmf");
 Object.defineProperty(exports, "useLxmf", { enumerable: true, get: function () { return useLxmf_1.useLxmf; } });
 Object.defineProperty(exports, "LxmfNodeMode", { enumerable: true, get: function () { return useLxmf_1.LxmfNodeMode; } });

package/build/useLxmf.d.ts

@@ -74,6 +74,7 @@ export declare function useLxmf(options?: UseLxmfOptions): {
     getStatus: () => LxmfNodeStatus | null;
     getBeacons: () => Beacon[];
     fetchMessages: (limit?: number) => any[];
+    getIdentityHex: () => string | null;
     setLogLevel: (level: number) => boolean;
     startBLE: () => void;
     stopBLE: () => void;

package/build/useLxmf.js

@@ -223,6 +223,19 @@ function useLxmf(options = {}) {
     const setLogLevel = (0, react_1.useCallback)((level) => {
         return LxmfModule_1.LxmfModule.setLogLevel(level);
     }, []);
+    /**
+     * Returns the full 128-char private identity hex for persistence, or null
+     * if no node is initialized. Persist to encrypted storage (e.g. expo-secure-store)
+     * and pass back via UseLxmfOptions.identityHex on next mount to reuse the identity.
+     */
+    const getIdentityHex = (0, react_1.useCallback)(() => {
+        try {
+            return LxmfModule_1.LxmfModule.getIdentityHex();
+        }
+        catch {
+            return null;
+        }
+    }, []);
     const startBLE = (0, react_1.useCallback)(() => {
         LxmfModule_1.LxmfModule.startBLE();
     }, []);
@@ -248,6 +261,7 @@ function useLxmf(options = {}) {
         getStatus,
         getBeacons,
         fetchMessages,
+        getIdentityHex,
         setLogLevel,
         startBLE,
         stopBLE,

package/ios/BLEManager.swift

@@ -53,6 +53,12 @@ class BLEManager: NSObject {
 
     private var isRunning = false
 
+    /// Per-launch random token embedded in our advertisement's local name, so
+    /// our central role can detect and skip our own peripheral advertisement
+    /// (CoreBluetooth does not auto-filter self when running both roles).
+    private var instanceTokenHex: String = ""
+    private static let advertNamePrefix = "lxmf-mesh-"
+
     private static let bondedKey = "lxmf.ble.bondedPeripheralUUIDs"
 
     private func loadBondedPeripherals() {
@@ -76,6 +82,35 @@ class BLEManager: NSObject {
         loadBondedPeripherals()
         discoveredUnpairedRNodes.removeAll()
 
+        // Generate fresh per-launch token for self-loop detection.
+        // CoreBluetooth doesn't filter our own peripheral when scanning, so we
+        // embed a random token in the advertised local name and skip matches.
+        var tokenBytes = [UInt8](repeating: 0, count: 4)
+        guard SecRandomCopyBytes(kSecRandomDefault, tokenBytes.count, &tokenBytes) == errSecSuccess else {
+            // CSPRNG failed — fall back to UUID bytes so two failing devices
+            // don't converge to all-zero tokens (deterministic collision).
+            let fallback = UUID().uuid
+            tokenBytes = [fallback.0, fallback.1, fallback.2, fallback.3]
+            instanceTokenHex = tokenBytes.map { String(format: "%02x", $0) }.joined()
+            // TODO(sentinel): remove or downgrade to debug before production
+            NSLog("[BLE] instance token (fallback): %@", instanceTokenHex)
+            // Use restoration identifiers for background BLE
+            centralManager = CBCentralManager(
+                delegate: self,
+                queue: DispatchQueue(label: "lxmf.ble.central"),
+                options: [CBCentralManagerOptionRestoreIdentifierKey: "lxmf-central"]
+            )
+            peripheralManager = CBPeripheralManager(
+                delegate: self,
+                queue: DispatchQueue(label: "lxmf.ble.peripheral"),
+                options: [CBPeripheralManagerOptionRestoreIdentifierKey: "lxmf-peripheral"]
+            )
+            return
+        }
+        instanceTokenHex = tokenBytes.map { String(format: "%02x", $0) }.joined()
+        // TODO(sentinel): remove or downgrade to debug before production
+        NSLog("[BLE] instance token: %@", instanceTokenHex)
+
         // Use restoration identifiers for background BLE
         centralManager = CBCentralManager(
             delegate: self,
@@ -231,7 +266,7 @@ class BLEManager: NSObject {
     private func startAdvertising() {
         peripheralManager.startAdvertising([
             CBAdvertisementDataServiceUUIDsKey: [BLEManager.meshServiceUUID],
-            CBAdvertisementDataLocalNameKey: "lxmf-mesh"
+            CBAdvertisementDataLocalNameKey: BLEManager.advertNamePrefix + instanceTokenHex
         ])
     }
 
@@ -258,6 +293,14 @@ extension BLEManager: CBCentralManagerDelegate {
                         advertisementData: [String: Any], rssi RSSI: NSNumber) {
         guard connectedPeripherals[peripheral.identifier] == nil else { return }
 
+        // Self-loop filter: if the advertised local name carries our own
+        // instance token, this is our own peripheral being seen by our own
+        // central. Skip — CoreBluetooth does not auto-filter this.
+        if let advertName = advertisementData[CBAdvertisementDataLocalNameKey] as? String,
+           advertName == BLEManager.advertNamePrefix + instanceTokenHex {
+            return
+        }
+
         // Check if this is an RNode (NUS service) that we haven't paired with yet.
         // If so, don't auto-connect — the user needs to pair in iOS Settings first.
         let advertisedServices = advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] ?? []

package/ios/LxmfModule.swift

@@ -44,6 +44,12 @@ func lxmf_poll_events(
     _ outCapacity: Int
 ) -> Int32
 
+@_silgen_name("lxmf_get_identity_hex")
+func lxmf_get_identity_hex(
+    _ outBuf: UnsafeMutablePointer<UInt8>?,
+    _ outCapacity: Int
+) -> Int32
+
 @_silgen_name("lxmf_get_status")
 func lxmf_get_status(
     _ outBuf: UnsafeMutablePointer<UInt8>?,
@@ -69,22 +75,6 @@ func lxmf_set_log_level(_ level: UInt32) -> Int32
 @_silgen_name("lxmf_abi_version")
 func lxmf_abi_version() -> UInt32
 
-@_silgen_name("lxmf_hdlc_encode")
-func lxmf_hdlc_encode(
-    _ dataPtr: UnsafePointer<UInt8>?,
-    _ dataLen: Int,
-    _ outPtr: UnsafeMutablePointer<UInt8>?,
-    _ outCapacity: Int
-) -> Int32
-
-@_silgen_name("lxmf_kiss_encode")
-func lxmf_kiss_encode(
-    _ dataPtr: UnsafePointer<UInt8>?,
-    _ dataLen: Int,
-    _ outPtr: UnsafeMutablePointer<UInt8>?,
-    _ outCapacity: Int
-) -> Int32
-
 @_silgen_name("lxmf_fetch_messages")
 func lxmf_fetch_messages(
     _ limit: UInt32,
@@ -259,6 +249,19 @@ public class LxmfModule: Module {
             return Double(opId)
         }
 
+        // --- Identity ---
+
+        Function("getIdentityHex") { () -> String? in
+            // 128 hex chars (full private key) — small, dedicated buffer to avoid
+            // sharing with the larger status JSON buffer.
+            var buf = [UInt8](repeating: 0, count: 256)
+            let len = buf.withUnsafeMutableBufferPointer { ptr in
+                lxmf_get_identity_hex(ptr.baseAddress, ptr.count)
+            }
+            guard len > 0 else { return nil }
+            return String(bytes: buf[0..<Int(len)], encoding: .utf8)
+        }
+
         // --- Status & Beacons ---
 
         Function("getStatus") { () -> String? in

package/ios/RustCore/liblxmf_rn.xcframework/Info.plist

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>liblxmf_rn.a</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>liblxmf_rn.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>liblxmf_rn.a</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>liblxmf_rn.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magicred-1/react-native-lxmf",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "LXMF Reticulum mesh networking for React Native + Expo",
   "main": "build/index.js",
   "types": "build/index.d.ts",