Make the order of headers deterministic when recording HAR files (#7)

* Add tests showing the nondeterminism

I couldn't figure out how to *deterministically* reproduce the
issue, so these are stochastic. They fail 100% reliably in my
dev environment, but I have no idea whether that will be the case
elsewhere. For the record my output of `swift --version` is:

swift-driver version: 1.120.5 Apple Swift version 6.1.2 (swiftlang-6.1.2.1.2 clang-1700.0.13.5)
Target: arm64-apple-macosx15.0

* Sort headers (request & response) lexicographically before serialising

* swift format -i -r .

---------

Co-authored-by: Mattt Zmuda <mattt@me.com>

Author: tikitu

Sources/Replay/HAR.swift

@@ -880,9 +880,11 @@ extension HAR.Request {
         self.httpVersion = "HTTP/1.1"
 
         // Headers
-        self.headers = (urlRequest.allHTTPHeaderFields ?? [:]).map { key, value in
-            HAR.Header(name: key, value: value)
-        }
+        self.headers = (urlRequest.allHTTPHeaderFields ?? [:])
+            .sorted { $0.key < $1.key }
+            .map { key, value in
+                HAR.Header(name: key, value: value)
+            }
 
         // Query string
         let components = URLComponents(url: url, resolvingAgainstBaseURL: true)
@@ -945,9 +947,11 @@ extension HAR.Response {
         self.statusText = HTTPURLResponse.localizedString(forStatusCode: httpResponse.statusCode)
         self.httpVersion = "HTTP/1.1"
 
-        self.headers = httpResponse.allHeaderFields.map { key, value in
-            HAR.Header(name: String(describing: key), value: String(describing: value))
-        }
+        self.headers = httpResponse.allHeaderFields
+            .sorted { String(describing: $0.key) < String(describing: $1.key) }
+            .map { key, value in
+                HAR.Header(name: String(describing: key), value: String(describing: value))
+            }
 
         let mimeType = httpResponse.mimeType ?? "application/octet-stream"
         let utf8Text = String(data: data, encoding: .utf8)

Tests/ReplayTests/HARTests.swift

@@ -558,6 +558,42 @@ struct HARTests {
             #expect(request.queryString[0].name == "key")
             #expect(request.queryString[0].value == "")
         }
+
+        @Test("headers order is deterministic across multiple conversions")
+        func headersOrderIsDeterministic() throws {
+            // Create a URLRequest with multiple headers
+            // Using enough headers to make nondeterministic ordering likely to be observable
+            // This did reliably produce failures before adding the explicit sorting
+            var urlRequest = URLRequest(url: URL(string: "https://example.com/api")!)
+            urlRequest.setValue("application/json", forHTTPHeaderField: "Accept")
+            urlRequest.setValue("gzip, deflate", forHTTPHeaderField: "Accept-Encoding")
+            urlRequest.setValue("en-US,en;q=0.9", forHTTPHeaderField: "Accept-Language")
+            urlRequest.setValue("Bearer token123", forHTTPHeaderField: "Authorization")
+            urlRequest.setValue("keep-alive", forHTTPHeaderField: "Connection")
+            urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            urlRequest.setValue("example.com", forHTTPHeaderField: "Host")
+            urlRequest.setValue("https://example.com", forHTTPHeaderField: "Origin")
+            urlRequest.setValue("https://example.com/previous", forHTTPHeaderField: "Referer")
+            urlRequest.setValue("Mozilla/5.0", forHTTPHeaderField: "User-Agent")
+
+            // Convert to HAR.Request multiple times
+            let iterations = 10
+            var headerOrders: [[String]] = []
+
+            for _ in 0 ..< iterations {
+                let request = try HAR.Request(from: urlRequest)
+                let headerNames = request.headers.map { $0.name }
+                headerOrders.append(headerNames)
+            }
+
+            // Check if all iterations produced the same header order
+            let firstOrder = headerOrders[0]
+            let allSame = headerOrders.allSatisfy { $0 == firstOrder }
+            #expect(
+                allSame,
+                "Header order should be consistent across multiple conversions, but got varying orders: \(headerOrders)"
+            )
+        }
     }
 
     // MARK: - Response Tests
@@ -634,6 +670,51 @@ struct HARTests {
             #expect(response.bodySize == data.count)
         }
 
+        @Test("headers order is deterministic across multiple conversions")
+        func headersOrderIsDeterministic() throws {
+            // Create an HTTPURLResponse with multiple headers
+            // Using enough headers to make nondeterministic ordering likely to be observable
+            // This did reliably produce failures before adding the explicit sorting
+            let url = URL(string: "https://example.com/api")!
+            let data = "{\"test\":true}".data(using: .utf8)!
+
+            // Convert to HAR.Response multiple times
+            let iterations = 10
+            var headerOrders: [[String]] = []
+
+            for _ in 0 ..< iterations {
+                let httpResponse = HTTPURLResponse(
+                    url: url,
+                    statusCode: 200,
+                    httpVersion: "HTTP/1.1",
+                    headerFields: [
+                        "Content-Type": "application/json",
+                        "Cache-Control": "no-cache, no-store, must-revalidate",
+                        "Content-Length": "12345",
+                        "Date": "Thu, 16 Jan 2026 12:00:00 GMT",
+                        "ETag": "\"abc123\"",
+                        "Expires": "0",
+                        "Last-Modified": "Thu, 16 Jan 2026 11:00:00 GMT",
+                        "Server": "nginx/1.21.0",
+                        "Vary": "Accept-Encoding",
+                        "X-Frame-Options": "SAMEORIGIN",
+                    ]
+                )!
+
+                let response = try HAR.Response(from: httpResponse, data: data)
+                let headerNames = response.headers.map { $0.name }
+                headerOrders.append(headerNames)
+            }
+
+            // Check if all iterations produced the same header order
+            let firstOrder = headerOrders[0]
+            let allSame = headerOrders.allSatisfy { $0 == firstOrder }
+            #expect(
+                allSame,
+                "Header order should be consistent across multiple conversions, but got varying orders: \(headerOrders)"
+            )
+        }
+
         @Test("encodes binary data as base64")
         func initFromHTTPURLResponseBinary() throws {
             let url = URL(string: "https://example.com/image.png")!