@apex-inc/capacitor-plugin 0.3.6 → 0.3.7

package/ios/Sources/ApexCapacitorPlugin/BatchSender.swift

@@ -67,6 +67,12 @@ public final class NativeBatchSender {
     /// Drains the queue, one batch at a time, with exponential backoff
     /// on retryable failures. Safe to call concurrently — only one
     /// flush actually runs at a time; concurrent callers no-op.
+    ///
+    /// Accumulator is passed by value through the recursion (no inout).
+    /// The previous inout-based design tripped Swift's exclusivity
+    /// runtime check at line 85 because the same `totalFlushed` local
+    /// was both captured by the `done` closure and passed inout — a
+    /// classic simultaneous-access violation that traps in debug builds.
     public func flush(queue: NativeOfflineQueue, completion: @escaping (Int, Int) -> Void) {
         serial.async { [weak self] in
             guard let self = self else { completion(0, 0); return }
@@ -77,54 +83,56 @@ public final class NativeBatchSender {
                 return
             }
             self.inFlight = true
-
-            var totalFlushed = 0
-            self.drainLoop(queue: queue, flushed: &totalFlushed) { [weak self] in
-                self?.inFlight = false
-                let remaining = (try? queue.size()) ?? 0
-                completion(totalFlushed, remaining)
+            self.drainLoop(queue: queue, accumulated: 0) { [weak self] flushed in
+                self?.serial.async {
+                    self?.inFlight = false
+                    let remaining = (try? queue.size()) ?? 0
+                    completion(flushed, remaining)
+                }
             }
         }
     }
 
+    /// Recursive drain. `accumulated` is the running total of successfully
+    /// flushed events; `done` is invoked exactly once with the final count.
     private func drainLoop(
         queue: NativeOfflineQueue,
-        flushed: inout Int,
-        done: @escaping () -> Void
+        accumulated: Int,
+        done: @escaping (Int) -> Void
     ) {
         let batch: [NativeQueuedEvent]
         do {
             batch = try queue.peek(batchSize: batchSize)
         } catch {
             if debug { print("[apex-capacitor] peek failed: \(error)") }
-            done()
+            done(accumulated)
             return
         }
         if batch.isEmpty {
-            done()
+            done(accumulated)
             return
         }
 
-        let localFlushed = flushed
         sendBatchWithRetry(batch, attempt: 0) { [weak self] outcome in
-            guard let self = self else { done(); return }
+            guard let self = self else { done(accumulated); return }
             self.serial.async {
                 let ids = batch.map { $0.id }
                 switch outcome {
                 case .success:
                     try? queue.markSent(ids: ids)
                     if self.debug { print("[apex-capacitor] flushed batch of \(batch.count)") }
-                    var nextFlushed = localFlushed + batch.count
-                    self.drainLoop(queue: queue, flushed: &nextFlushed, done: done)
-                    // After the recursive call returns the outer flushed
-                    // is no longer relevant — drain handles its own.
+                    self.drainLoop(
+                        queue: queue,
+                        accumulated: accumulated + batch.count,
+                        done: done
+                    )
                 case .nonRetryable(let status):
                     if self.debug { print("[apex-capacitor] non-retryable HTTP \(status); leaving events queued") }
-                    done()
+                    done(accumulated)
                 case .retryableExhausted(let err):
                     try? queue.markFailed(ids: ids)
                     if self.debug { print("[apex-capacitor] retries exhausted: \(err)") }
-                    done()
+                    done(accumulated)
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apex-inc/capacitor-plugin",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "Apex Capacitor plugin — iOS/Android attribution, events, deep linking, SKAN, and offline-tolerant tracking for Capacitor apps.",
   "main": "dist/index.js",
   "module": "dist/esm/index.js",