@trainstar/synchro-react-native 0.4.0-rc.3 → 0.4.0-rc.4

package/ios/SynchroOwnership.swift

@@ -0,0 +1,173 @@
+import Foundation
+import os
+import React
+
+/// Values that can cross wrapper execution boundaries without carrying Foundation containers.
+enum BridgeValue: Sendable {
+    case null
+    case bool(Bool)
+    case integer(Int64)
+    case double(Double)
+    case string(String)
+    case array([BridgeValue])
+    case object([String: BridgeValue])
+
+    func foundationValue() -> Any {
+        switch self {
+        case .null:
+            return NSNull()
+        case .bool(let value):
+            return NSNumber(value: value)
+        case .integer(let value):
+            return NSNumber(value: value)
+        case .double(let value):
+            return NSNumber(value: value)
+        case .string(let value):
+            return value
+        case .array(let values):
+            return values.map { $0.foundationValue() }
+        case .object(let values):
+            return values.mapValues { $0.foundationValue() }
+        }
+    }
+}
+
+enum BridgePromiseValue: Sendable {
+    case void
+    case value(BridgeValue)
+}
+
+/// Owns the imported React promise blocks and settles them exactly once.
+///
+/// React Native copies these blocks for an escaping module invocation. Its TurboModule
+/// implementation protects its shared resolve/reject state with a mutex and schedules
+/// JavaScript through `AsyncCallback`. React Native also permits native callbacks from
+/// any queue. Swift cannot express those Objective-C runtime guarantees as `Sendable`.
+final class ReactPromiseSettlement: @unchecked Sendable {
+    private let lock = NSLock()
+    private var resolveBlock: RCTPromiseResolveBlock?
+    private var rejectBlock: RCTPromiseRejectBlock?
+
+    init(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        resolveBlock = resolve
+        rejectBlock = reject
+    }
+
+    @discardableResult
+    func resolve(_ value: BridgePromiseValue) -> Bool {
+        lock.lock()
+        guard let resolveBlock else {
+            lock.unlock()
+            return false
+        }
+        self.resolveBlock = nil
+        rejectBlock = nil
+        lock.unlock()
+
+        switch value {
+        case .void:
+            resolveBlock(nil)
+        case .value(let value):
+            resolveBlock(value.foundationValue())
+        }
+        return true
+    }
+
+    @discardableResult
+    func reject(_ code: String?, _ message: String?, _ error: Error?) -> Bool {
+        lock.lock()
+        guard let rejectBlock else {
+            lock.unlock()
+            return false
+        }
+        resolveBlock = nil
+        self.rejectBlock = nil
+        lock.unlock()
+
+        rejectBlock(code, message, error)
+        return true
+    }
+}
+
+/// Owns the Objective-C event target without creating an implementation cycle.
+///
+/// The delegate is installed by Objective-C++, can be released outside Swift, and is
+/// invoked only on main. The lock protects the weak reference, not callback execution.
+final class ReactEventTarget: @unchecked Sendable {
+    private let lock = NSLock()
+    private weak var delegate: SynchroEventEmitting?
+
+    var currentDelegate: SynchroEventEmitting? {
+        lock.lock()
+        defer { lock.unlock() }
+        return delegate
+    }
+
+    func setDelegate(_ delegate: SynchroEventEmitting?) {
+        lock.lock()
+        self.delegate = delegate
+        lock.unlock()
+    }
+
+    func emit(_ name: String, body: BridgeValue) {
+        DispatchQueue.main.async { [self, name, body] in
+            lock.lock()
+            let delegate = self.delegate
+            lock.unlock()
+            guard let payload = body.foundationValue() as? NSDictionary else {
+                preconditionFailure("Event payload must be an object")
+            }
+            delegate?.emitEvent(name, body: payload)
+        }
+    }
+}
+
+final class AuthRequestStore: Sendable {
+    private struct State: Sendable {
+        var acceptsRequests = false
+        var continuations: [String: CheckedContinuation<String, Error>] = [:]
+    }
+
+    private let state = OSAllocatedUnfairLock(initialState: State())
+
+    func activate() {
+        state.withLock { $0.acceptsRequests = true }
+    }
+
+    func insert(_ continuation: CheckedContinuation<String, Error>, for requestID: String) -> Bool {
+        state.withLock { state in
+            guard state.acceptsRequests else { return false }
+            state.continuations[requestID] = continuation
+            return true
+        }
+    }
+
+    func resolve(_ requestID: String, token: String) {
+        let continuation = state.withLock { $0.continuations.removeValue(forKey: requestID) }
+        continuation?.resume(returning: token)
+    }
+
+    func reject(_ requestID: String, error: Error) {
+        let continuation = state.withLock { $0.continuations.removeValue(forKey: requestID) }
+        continuation?.resume(throwing: error)
+    }
+
+    func cancelAll() {
+        let continuations = state.withLock { state in
+            state.acceptsRequests = false
+            let continuations = Array(state.continuations.values)
+            state.continuations.removeAll()
+            return continuations
+        }
+        let error = NSError(
+            domain: "SynchroModule",
+            code: 0,
+            userInfo: [NSLocalizedDescriptionKey: "client closed"]
+        )
+        continuations.forEach { $0.resume(throwing: error) }
+    }
+
+    var count: Int {
+        state.withLock { $0.continuations.count }
+    }
+}

package/ios-test-host/{main.m → AppDelegate.m}

@@ -39,10 +39,3 @@
 }
 
 @end
-
-int main(int argc, char *argv[])
-{
-    @autoreleasepool {
-        return UIApplicationMain(argc, argv, nil, NSStringFromClass([SynchroTestHostAppDelegate class]));
-    }
-}

package/ios-test-host/main.swift

@@ -0,0 +1,12 @@
+import Darwin
+import UIKit
+
+let status = autoreleasepool {
+    UIApplicationMain(
+        CommandLine.argc,
+        CommandLine.unsafeArgv,
+        nil,
+        "SynchroTestHostAppDelegate"
+    )
+}
+exit(status)

package/ios-tests/SynchroModuleTransactionTests.swift

@@ -244,6 +244,7 @@ final class SynchroModuleTransactionTests: XCTestCase {
     private var events: EventRecorder!
     private var cleanup: CleanupState!
     private var databasePath: String!
+    private var externalConnections: [ExternalConnection] = []
 
     override func setUpWithError() throws {
         try super.setUpWithError()
@@ -257,32 +258,51 @@ final class SynchroModuleTransactionTests: XCTestCase {
         self.events = events
         self.cleanup = cleanup
         self.databasePath = databasePath
-        // Teardown blocks run in reverse order. This block is first, so every gate a test
-        // registers later is released before close joins the registered transactions.
-        addTeardownBlock {
-            withExtendedLifetime(events) {
-                let close = PromiseRecorder("teardown close")
-                module.close(close.resolve, reject: close.reject)
-                let settled = XCTWaiter().wait(for: [close.firstSettlement], timeout: settlementTimeout) == .completed
-                guard settled, close.resolutions.count == 1, close.rejections.isEmpty else {
-                    XCTFail("teardown close did not resolve once (settled: \(settled), resolutions: \(close.resolutions.count), rejections: \(close.rejections)). Kept \(databasePath).")
-                    return
-                }
-                guard !cleanup.hasFailure else {
-                    XCTFail("a test-owned resource did not close. Kept \(databasePath).")
-                    return
-                }
-                for suffix in ["", "-wal", "-shm"] {
-                    let path = databasePath + suffix
-                    guard FileManager.default.fileExists(atPath: path) else { continue }
-                    do {
-                        try FileManager.default.removeItem(atPath: path)
-                    } catch {
-                        XCTFail("remove \(path): \(error)")
-                    }
+    }
+
+    override func tearDownWithError() throws {
+        let teardownDatabasePath = databasePath ?? "unknown database path"
+        var moduleClosed = false
+        for connection in externalConnections.reversed() {
+            do {
+                try connection.close()
+            } catch {
+                cleanup.recordFailure()
+                XCTFail("close external connection: \(error)")
+            }
+        }
+        externalConnections.removeAll()
+
+        if let module {
+            let close = PromiseRecorder("teardown close")
+            module.close(close.resolve, reject: close.reject)
+            let settled = XCTWaiter().wait(for: [close.firstSettlement], timeout: settlementTimeout) == .completed
+            moduleClosed = settled && close.resolutions.count == 1 && close.rejections.isEmpty
+            if !moduleClosed {
+                XCTFail("teardown close did not resolve once (settled: \(settled), resolutions: \(close.resolutions.count), rejections: \(close.rejections)). Kept \(teardownDatabasePath).")
+            }
+            module.eventDelegate = nil
+        }
+        withExtendedLifetime(events) {}
+
+        if cleanup.hasFailure {
+            XCTFail("a test-owned resource did not close. Kept \(teardownDatabasePath).")
+        } else if moduleClosed {
+            for suffix in ["", "-wal", "-shm"] {
+                let path = teardownDatabasePath + suffix
+                guard FileManager.default.fileExists(atPath: path) else { continue }
+                do {
+                    try FileManager.default.removeItem(atPath: path)
+                } catch {
+                    XCTFail("remove \(path): \(error)")
                 }
             }
         }
+        module = nil
+        events = nil
+        cleanup = nil
+        databasePath = nil
+        try super.tearDownWithError()
     }
 
     func testAcquisitionFailureRejectsBeginOnce() throws {
@@ -392,21 +412,15 @@ final class SynchroModuleTransactionTests: XCTestCase {
         let held = try holdReadTransactions(count: 5)
         let ordinary = PromiseRecorder("ordinary query with five readers")
         let commits = held.ids.indices.map { PromiseRecorder("commit reader \($0)") }
-        let invocationReturned = XCTestExpectation(description: "ordinary query invocation returns")
-        let methodQueue = DispatchQueue(label: "test.react-native.query-dispatch")
         let module = try XCTUnwrap(self.module)
 
-        methodQueue.async {
-            module.query("SELECT 1", params: [], resolve: ordinary.resolve, reject: ordinary.reject)
-            invocationReturned.fulfill()
-        }
-        methodQueue.async {
-            for (index, txID) in held.ids.enumerated() {
-                module.commitTransaction(txID, resolve: commits[index].resolve, reject: commits[index].reject)
-            }
+        let invocationStarted = Date()
+        module.query("SELECT 1", params: [], resolve: ordinary.resolve, reject: ordinary.reject)
+        XCTAssertLessThan(Date().timeIntervalSince(invocationStarted), promptDispatchTimeout)
+        for (index, txID) in held.ids.enumerated() {
+            module.commitTransaction(txID, resolve: commits[index].resolve, reject: commits[index].reject)
         }
 
-        XCTAssertEqual(XCTWaiter().wait(for: [invocationReturned], timeout: promptDispatchTimeout), .completed)
         waitForSettlements([ordinary] + commits, timeout: promptDispatchTimeout)
         XCTAssertEqual((try resolvedValue(ordinary) as? [[String: Any]])?.count, 1)
         let close = try closeModule()
@@ -420,21 +434,15 @@ final class SynchroModuleTransactionTests: XCTestCase {
         let held = try holdReadTransactions(count: 5)
         let ordinary = PromiseRecorder("ordinary query one with five readers")
         let rollbacks = held.ids.indices.map { PromiseRecorder("rollback reader \($0)") }
-        let invocationReturned = XCTestExpectation(description: "ordinary query one invocation returns")
-        let methodQueue = DispatchQueue(label: "test.react-native.query-one-dispatch")
         let module = try XCTUnwrap(self.module)
 
-        methodQueue.async {
-            module.queryOne("SELECT 1", params: [], resolve: ordinary.resolve, reject: ordinary.reject)
-            invocationReturned.fulfill()
-        }
-        methodQueue.async {
-            for (index, txID) in held.ids.enumerated() {
-                module.rollbackTransaction(txID, resolve: rollbacks[index].resolve, reject: rollbacks[index].reject)
-            }
+        let invocationStarted = Date()
+        module.queryOne("SELECT 1", params: [], resolve: ordinary.resolve, reject: ordinary.reject)
+        XCTAssertLessThan(Date().timeIntervalSince(invocationStarted), promptDispatchTimeout)
+        for (index, txID) in held.ids.enumerated() {
+            module.rollbackTransaction(txID, resolve: rollbacks[index].resolve, reject: rollbacks[index].reject)
         }
 
-        XCTAssertEqual(XCTWaiter().wait(for: [invocationReturned], timeout: promptDispatchTimeout), .completed)
         waitForSettlements([ordinary] + rollbacks, timeout: promptDispatchTimeout)
         XCTAssertEqual((try resolvedValue(ordinary) as? [String: Any])?.count, 1)
         let close = try closeModule()
@@ -446,7 +454,6 @@ final class SynchroModuleTransactionTests: XCTestCase {
     func testOrdinaryWriterSurfacesDoNotBlockWriteTransactionCommands() throws {
         try initializeModule()
         let module = try XCTUnwrap(self.module)
-        let methodQueue = DispatchQueue(label: "test.react-native.writer-dispatch")
         let ordinaryCalls: [(String, (PromiseRecorder) -> Void)] = [
             ("execute", { recorder in
                 module.execute("SELECT 1", params: [], resolve: recorder.resolve, reject: recorder.reject)
@@ -482,21 +489,11 @@ final class SynchroModuleTransactionTests: XCTestCase {
             }
             let ordinary = PromiseRecorder(name)
             let commit = PromiseRecorder("commit after \(name)")
-            let invocationReturned = XCTestExpectation(description: "\(name) invocation returns")
-
-            methodQueue.async {
-                call(ordinary)
-                invocationReturned.fulfill()
-            }
-            methodQueue.async {
-                module.commitTransaction(txID, resolve: commit.resolve, reject: commit.reject)
-            }
+            let invocationStarted = Date()
+            call(ordinary)
+            XCTAssertLessThan(Date().timeIntervalSince(invocationStarted), promptDispatchTimeout, name)
+            module.commitTransaction(txID, resolve: commit.resolve, reject: commit.reject)
 
-            XCTAssertEqual(
-                XCTWaiter().wait(for: [invocationReturned], timeout: promptDispatchTimeout),
-                .completed,
-                name
-            )
             waitForSettlements([ordinary, commit])
             recorders += [begin, probe, ordinary, commit]
         }
@@ -673,6 +670,40 @@ final class SynchroModuleTransactionTests: XCTestCase {
         XCTAssertEqual(events.names, [])
     }
 
+    func testUnsupportedCyclicSQLParametersRejectPromptlyAndSettleOnce() throws {
+        try initializeModule()
+        let cyclicArray = NSMutableArray()
+        cyclicArray.add(cyclicArray)
+        let cyclicDictionary = NSMutableDictionary()
+        cyclicDictionary["type"] = "bytes"
+        cyclicDictionary["base64"] = cyclicDictionary
+        let inputs: [(String, Any)] = [
+            ("cyclic array", cyclicArray),
+            ("cyclic dictionary", cyclicDictionary),
+        ]
+        var rejections: [PromiseRecorder] = []
+
+        for (name, value) in inputs {
+            let recorder = PromiseRecorder(name)
+            let invocationStarted = Date()
+            module.query("SELECT ?", params: [value], resolve: recorder.resolve, reject: recorder.reject)
+            XCTAssertLessThan(Date().timeIntervalSince(invocationStarted), promptDispatchTimeout, name)
+            waitForSettlements([recorder], timeout: promptDispatchTimeout)
+            rejections.append(recorder)
+        }
+
+        cyclicArray.removeAllObjects()
+        cyclicDictionary.removeAllObjects()
+        let close = try closeModule()
+        for recorder in rejections {
+            XCTAssertEqual(recorder.resolutions.count, 0, recorder.name)
+            XCTAssertEqual(recorder.rejections, ["UNKNOWN"], recorder.name)
+            XCTAssertEqual(recorder.settlementCount, 1, recorder.name)
+        }
+        requireSettledOnce([close])
+        XCTAssertEqual(events.names, [])
+    }
+
     // MARK: - Inspection snapshot
 
     func testClientStateSnapshotReadsRequestedRowsInsideReadOnlySnapshot() throws {
@@ -874,15 +905,7 @@ final class SynchroModuleTransactionTests: XCTestCase {
     private func openExternalConnection() throws -> ExternalConnection {
         let getPath = settle("get path") { module.getPath($0.resolve, reject: $0.reject) }
         let connection = try ExternalConnection(path: try XCTUnwrap(try resolvedValue(getPath) as? String))
-        let cleanup = self.cleanup!
-        addTeardownBlock {
-            do {
-                try connection.close()
-            } catch {
-                cleanup.recordFailure()
-                XCTFail("close external connection: \(error)")
-            }
-        }
+        externalConnections.append(connection)
         return connection
     }
 
@@ -909,9 +932,7 @@ final class SynchroModuleTransactionTests: XCTestCase {
 
     private func registrySnapshot() throws -> [String] {
         let module = try XCTUnwrap(self.module)
-        module.sessionsLock.lock()
-        defer { module.sessionsLock.unlock() }
-        return Array(module.sessions.keys)
+        return module.activeTransactionIDs
     }
 
     /// Close removes every registered session under the registry lock before it waits for them.

package/ios-tests/TransactionSessionTests.swift

@@ -1,4 +1,5 @@
 @testable import SynchroReactNative
+import os
 import XCTest
 
 private struct SessionError: Error, Equatable {
@@ -6,21 +7,95 @@ private struct SessionError: Error, Equatable {
 }
 
 /// Records the begin completions that the actual session delivers.
-private final class BeginRecorder {
-    private(set) var results: [Result<String, Error>] = []
-
-    func record(_ result: Result<String, Error>) {
-        results.append(result)
+private final class BeginRecorder: Sendable {
+    private struct State: Sendable {
+        var successes: [String] = []
+        var failures: [SessionError?] = []
     }
 
+    private let state = OSAllocatedUnfairLock(initialState: State())
+
     var successes: [String] {
-        results.compactMap { try? $0.get() }
+        state.withLock { $0.successes }
     }
 
     var failures: [SessionError?] {
-        results.compactMap { result in
-            guard case .failure(let error) = result else { return nil }
-            return .some(error as? SessionError)
+        state.withLock { $0.failures }
+    }
+
+    func settlement() -> ReactPromiseSettlement {
+        ReactPromiseSettlement(
+            resolve: { [self] value in
+                let stringValue = value as? String
+                state.withLock { state in
+                    if let stringValue {
+                        state.successes.append(stringValue)
+                    }
+                }
+            },
+            reject: { [self] _, _, error in
+                state.withLock { $0.failures.append(error as? SessionError) }
+            }
+        )
+    }
+}
+
+private final class SettlementCounter: Sendable {
+    private let countState = OSAllocatedUnfairLock(initialState: 0)
+
+    var count: Int {
+        countState.withLock { $0 }
+    }
+
+    func increment() {
+        countState.withLock { $0 += 1 }
+    }
+}
+
+private final class EventRecorder: NSObject, SynchroEventEmitting {
+    private struct State {
+        var name: String?
+        var body: NSDictionary?
+        var deliveredOnMain = false
+    }
+
+    private let state = NSLock()
+    private var value = State()
+    let expectation: XCTestExpectation
+
+    init(expectation: XCTestExpectation) {
+        self.expectation = expectation
+    }
+
+    func emitEvent(_ name: String, body: NSDictionary) {
+        state.lock()
+        value.name = name
+        value.body = body
+        value.deliveredOnMain = Thread.isMainThread
+        state.unlock()
+        expectation.fulfill()
+    }
+
+    func snapshot() -> (String?, NSDictionary?, Bool) {
+        state.lock()
+        defer { state.unlock() }
+        return (value.name, value.body, value.deliveredOnMain)
+    }
+}
+
+private struct AuthStoreTimeout: Error {}
+
+private func pendingAuthRequest(
+    _ store: AuthRequestStore,
+    id: String,
+    insertion: CheckedContinuation<Bool, Never>
+) async throws -> String {
+    try await withCheckedThrowingContinuation { continuation in
+        let inserted = store.insert(continuation, for: id)
+        insertion.resume(returning: inserted)
+        guard inserted else {
+            continuation.resume(throwing: AuthStoreTimeout())
+            return
         }
     }
 }
@@ -29,7 +104,7 @@ private final class BeginRecorder {
 final class TransactionSessionTests: XCTestCase {
     func testFailureBeforeCallbackRejectsStoredBeginOnce() {
         let begin = BeginRecorder()
-        let session = TransactionSession(isWrite: true, beginCompletion: begin.record)
+        let session = TransactionSession(isWrite: true, beginSettlement: begin.settlement())
 
         session.rejectBegin(SessionError(name: "acquisition"))
         session.rejectBegin(SessionError(name: "later failure"))
@@ -40,7 +115,7 @@ final class TransactionSessionTests: XCTestCase {
 
     func testAbortBeforeBeginAcceptanceRejectsBeginAndUnwindsCallback() {
         let begin = BeginRecorder()
-        let session = TransactionSession(isWrite: true, beginCompletion: begin.record)
+        let session = TransactionSession(isWrite: true, beginSettlement: begin.settlement())
 
         session.abort(SessionError(name: "close"))
         XCTAssertThrowsError(try session.acceptBegin("abort-before-begin")) { error in
@@ -54,7 +129,7 @@ final class TransactionSessionTests: XCTestCase {
 
     func testAcceptedBeginIsNotSettledAgainByLaterFailure() throws {
         let begin = BeginRecorder()
-        let session = TransactionSession(isWrite: true, beginCompletion: begin.record)
+        let session = TransactionSession(isWrite: true, beginSettlement: begin.settlement())
 
         try session.acceptBegin("accepted")
         session.abort(SessionError(name: "close"))
@@ -63,4 +138,84 @@ final class TransactionSessionTests: XCTestCase {
         XCTAssertEqual(begin.successes, ["accepted"])
         XCTAssertEqual(begin.failures, [])
     }
+
+    func testPromiseSettlementRaceInvokesOneBlock() {
+        let counter = SettlementCounter()
+        let settlement = ReactPromiseSettlement(
+            resolve: { _ in counter.increment() },
+            reject: { _, _, _ in counter.increment() }
+        )
+
+        DispatchQueue.concurrentPerform(iterations: 100) { index in
+            if index.isMultiple(of: 2) {
+                settlement.resolve(.void)
+            } else {
+                settlement.reject("TEST", "test", nil)
+            }
+        }
+
+        XCTAssertEqual(counter.count, 1)
+    }
+
+    func testPromiseSettlementUnlocksBeforeReentrantInvocation() {
+        let counter = SettlementCounter()
+        let holder = OSAllocatedUnfairLock<ReactPromiseSettlement?>(initialState: nil)
+        let settlement = ReactPromiseSettlement(
+            resolve: { _ in
+                counter.increment()
+                holder.withLock { $0 }?.reject("REENTRANT", "reentrant", nil)
+            },
+            reject: { _, _, _ in counter.increment() }
+        )
+        holder.withLock { $0 = settlement }
+
+        settlement.resolve(.void)
+
+        XCTAssertEqual(counter.count, 1)
+    }
+
+    func testEventTargetIsWeakAndDeliversOnMain() {
+        let event = expectation(description: "event")
+        let target = ReactEventTarget()
+        var recorder: EventRecorder? = EventRecorder(expectation: event)
+        target.setDelegate(recorder)
+
+        target.emit("onTest", body: .object(["value": .string("ok")]))
+        wait(for: [event], timeout: 1)
+
+        let snapshot = recorder?.snapshot()
+        XCTAssertEqual(snapshot?.0, "onTest")
+        XCTAssertEqual(snapshot?.1?["value"] as? String, "ok")
+        XCTAssertEqual(snapshot?.2, true)
+
+        weak let weakRecorder = recorder
+        recorder = nil
+        XCTAssertNil(weakRecorder)
+        XCTAssertNil(target.currentDelegate)
+    }
+
+    func testAuthStoreCloseRejectsPendingAndIgnoresLateCompletion() async throws {
+        let store = AuthRequestStore()
+        store.activate()
+        var pendingTask: Task<String, Error>?
+        let inserted = await withCheckedContinuation { insertion in
+            pendingTask = Task {
+                try await pendingAuthRequest(store, id: "request", insertion: insertion)
+            }
+        }
+        XCTAssertTrue(inserted)
+        XCTAssertEqual(store.count, 1)
+        let task = try XCTUnwrap(pendingTask)
+
+        store.cancelAll()
+        store.resolve("request", token: "late")
+
+        do {
+            _ = try await task.value
+            XCTFail("Expected close to reject the request")
+        } catch {
+            XCTAssertEqual((error as NSError).domain, "SynchroModule")
+        }
+        XCTAssertEqual(store.count, 0)
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainstar/synchro-react-native",
-  "version": "0.4.0-rc.3",
+  "version": "0.4.0-rc.4",
   "description": "React Native bridge for Synchro sync SDK",
   "source": "./src/index.ts",
   "main": "./lib/module/index.js",
@@ -20,6 +20,8 @@
     "./tooling-patches/cli-config-android-20.2.0.patch": "./tooling-patches/cli-config-android-20.2.0.patch",
     "./tooling-patches/cli-clean-20.2.0.patch": "./tooling-patches/cli-clean-20.2.0.patch",
     "./tooling-patches/react-native-builder-bob-0.40.18.patch": "./tooling-patches/react-native-builder-bob-0.40.18.patch",
+    "./tooling-patches/react-native-gradle-plugin-0.82.1-kotlin-2.4.21.patch": "./tooling-patches/react-native-gradle-plugin-0.82.1-kotlin-2.4.21.patch",
+    "./tooling-patches/react-native-gradle-plugin-0.88.0-kotlin-2.4.21.patch": "./tooling-patches/react-native-gradle-plugin-0.88.0-kotlin-2.4.21.patch",
     "./tooling-patches/stream-json-1.9.1.patch": "./tooling-patches/stream-json-1.9.1.patch",
     "./package.json": "./package.json"
   },
@@ -103,6 +105,7 @@
   "resolutions": {
     "@react-native-community/cli-config-android@npm:20.2.0": "patch:@react-native-community/cli-config-android@npm%3A20.2.0#./tooling-patches/cli-config-android-20.2.0.patch",
     "@react-native-community/cli-clean@npm:20.2.0": "patch:@react-native-community/cli-clean@npm%3A20.2.0#./tooling-patches/cli-clean-20.2.0.patch",
+    "@react-native/gradle-plugin@npm:0.88.0": "patch:@react-native/gradle-plugin@npm%3A0.88.0#./tooling-patches/react-native-gradle-plugin-0.88.0-kotlin-2.4.21.patch",
     "react-native-builder-bob@npm:^0.40.18": "patch:react-native-builder-bob@npm%3A0.40.18#./tooling-patches/react-native-builder-bob-0.40.18.patch",
     "stream-json@npm:^1.7.4": "patch:stream-json@npm%3A1.9.1#./tooling-patches/stream-json-1.9.1.patch",
     "stream-json@npm:^1.7.5": "patch:stream-json@npm%3A1.9.1#./tooling-patches/stream-json-1.9.1.patch"