Make NetworkingClient.headers thread-safe

headers was a plain stored dictionary read on every request build (and on
retries from URLSession/Combine threads) while being rewritten on auth token
refresh from arbitrary threads. Swift Dictionary is not thread-safe, so this
raced and corrupted the CoW buffer, producing the Crashlytics crashes in
NetworkingClient.addHeaders/removeHeaders and NetworkingRequest.__ivar_destroyer
(EXC_BAD_ACCESS / EXC_BREAKPOINT / SIGABRT).

- back headers with an NSLock-protected private store; the public property
  keeps the exact same get/set surface, so existing consumers compile and
  behave unchanged
- add withHeaders(_:) for callers that need an atomic read-modify-write
  (e.g. merging auth headers) instead of racy get-modify-set
- add regression tests; the concurrent hammer test segfaults (signal 11)
  against the previous implementation and passes with the lock

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: logansease

Sources/Networking/NetworkingClient.swift

@@ -10,7 +10,40 @@ public class NetworkingClient {
      */
     public var defaultCollectionParsingKeyPath: String?
     let baseURL: String
-    public var headers = [String: String]()
+
+    // Headers are read on every request build (including retries on URLSession/Combine
+    // threads) and mutated on auth token refresh from arbitrary threads. Dictionary is
+    // not thread-safe, so all access goes through a lock. The public property keeps the
+    // same get/set surface as the previous stored `var`.
+    private let headersLock = NSLock()
+    private var _headers = [String: String]()
+    public var headers: [String: String] {
+        get {
+            headersLock.lock()
+            defer { headersLock.unlock() }
+            return _headers
+        }
+        set {
+            headersLock.lock()
+            defer { headersLock.unlock() }
+            _headers = newValue
+        }
+    }
+
+    /**
+        Atomically reads and mutates the headers dictionary under the same lock that
+        protects the `headers` property. Use this instead of get-modify-set on `headers`
+        when the modification must not race with other writers (e.g. merging auth headers).
+        Do not access `headers` or call `withHeaders` again from inside `body` — the lock
+        is not reentrant.
+    */
+    @discardableResult
+    public func withHeaders<T>(_ body: (inout [String: String]) -> T) -> T {
+        headersLock.lock()
+        defer { headersLock.unlock() }
+        return body(&_headers)
+    }
+
     public var parameterEncoding = ParameterEncoding.urlEncoded
     public var timeout: TimeInterval?
     public var sessionConfiguration = URLSessionConfiguration.default

Tests/NetworkingTests/HeadersThreadSafetyTests.swift

@@ -0,0 +1,94 @@
+//
+//  HeadersThreadSafetyTests.swift
+//
+//  Regression tests for the data race on NetworkingClient.headers that caused
+//  EXC_BAD_ACCESS / EXC_BREAKPOINT / SIGABRT crashes in production when auth
+//  header updates raced with request building on other threads.
+//
+
+import Foundation
+import XCTest
+
+@testable
+import Networking
+
+final class HeadersThreadSafetyTests: XCTestCase {
+
+    // Hammers the same access pattern that crashed in production:
+    // writers doing get-modify-set add/remove cycles (auth token refresh) while
+    // readers copy the dictionary (request building). Before headers was
+    // lock-protected this reliably corrupted the dictionary's CoW buffer.
+    func testConcurrentReadsAndWritesDoNotCrash() {
+        let network = NetworkingClient(baseURL: "https://mocked.com")
+        network.headers = ["Client-Version": "1.0.0", "Client-OS": "iOS"]
+
+        let group = DispatchGroup()
+        let queue = DispatchQueue.global(qos: .userInitiated)
+        let iterations = 2_000
+
+        // writers: replace auth headers, like setAuthHeaders on token refresh
+        for writer in 0..<4 {
+            queue.async(group: group) {
+                for i in 0..<iterations {
+                    var copy = network.headers
+                    copy.removeValue(forKey: "Authorization")
+                    network.headers = copy
+                    network.headers = network.headers.merging(
+                        ["Authorization": "Bearer token-\(writer)-\(i)"]) { _, new in new }
+                }
+            }
+        }
+
+        // readers: copy headers into a request, like NetworkingClient+Requests
+        for _ in 0..<4 {
+            queue.async(group: group) {
+                for _ in 0..<iterations {
+                    let snapshot = network.headers
+                    _ = snapshot.count
+                }
+            }
+        }
+
+        XCTAssertEqual(group.wait(timeout: .now() + 60), .success)
+        XCTAssertEqual(network.headers["Client-OS"], "iOS")
+    }
+
+    // withHeaders must be atomic: concurrent read-modify-writes through it must
+    // never lose updates, which get-modify-set on the plain property can.
+    func testWithHeadersIsAtomic() {
+        let network = NetworkingClient(baseURL: "https://mocked.com")
+        network.headers = ["counter": "0"]
+
+        let totalIncrements = 8_000
+        DispatchQueue.concurrentPerform(iterations: totalIncrements) { _ in
+            network.withHeaders { headers in
+                let current = Int(headers["counter"] ?? "0") ?? 0
+                headers["counter"] = String(current + 1)
+            }
+        }
+
+        XCTAssertEqual(network.headers["counter"], String(totalIncrements))
+    }
+
+    // The property must keep behaving like the stored `var` it replaced.
+    func testHeadersPropertyKeepsValueSemantics() {
+        let network = NetworkingClient(baseURL: "https://mocked.com")
+
+        network.headers["a"] = "1"
+        XCTAssertEqual(network.headers["a"], "1")
+
+        var snapshot = network.headers
+        snapshot["b"] = "2"
+        XCTAssertNil(network.headers["b"], "mutating a copy must not affect the client")
+
+        network.headers = [:]
+        XCTAssertTrue(network.headers.isEmpty)
+
+        let returned = network.withHeaders { headers -> Int in
+            headers["c"] = "3"
+            return headers.count
+        }
+        XCTAssertEqual(returned, 1)
+        XCTAssertEqual(network.headers["c"], "3")
+    }
+}