@onekeyfe/react-native-sni-connect 3.0.85 → 3.0.86

package/ios/SniConnectValidation.swift

@@ -32,6 +32,7 @@ enum SniConnectValidation {
   static let maxTotalHeaderBytes = 32 * 1024
   static let maxActiveRequests = 64
   static let maxActiveRequestsPerPair = 16
+  static let maxPendingRequests = 256
 
   /// HTTP methods the module is allowed to issue.
   private static let allowedMethods: Set<String> = [
@@ -212,6 +213,16 @@ enum SniConnectValidation {
     throw ValidationError.invalidIP(ip)
   }
 
+  static func canonicalIPKey(_ ip: String) -> String {
+    if let v4 = parseIPv4(ip) {
+      return "4:" + v4.map { String($0) }.joined(separator: ".")
+    }
+    if let v6 = parseIPv6(ip) {
+      return "6:" + v6.map { String($0) }.joined(separator: ".")
+    }
+    return ip
+  }
+
   private static func parseIPv4(_ ip: String) -> [UInt8]? {
     var addr = in_addr()
     guard ip.withCString({ inet_pton(AF_INET, $0, &addr) }) == 1 else { return nil }
@@ -301,16 +312,27 @@ enum SniConnectValidation {
   }
 }
 
-final class SniConnectRequestLimiter {
-  final class Token {
+final class SniConnectRequestLimiter: @unchecked Sendable {
+  static let shared = SniConnectRequestLimiter()
+
+  struct Snapshot {
+    let activeRequests: Int
+    let activeRequestsForPair: Int
+    let pendingRequests: Int
+    let pendingRequestsForPair: Int
+    let activeRequestIdsForPair: [String]
+    let pendingRequestIdsForPair: [String]
+  }
+
+  final class Token: @unchecked Sendable {
     private weak var limiter: SniConnectRequestLimiter?
-    private let key: String
+    private let id: UUID
     private let lock = NSLock()
     private var released = false
 
-    fileprivate init(limiter: SniConnectRequestLimiter, key: String) {
+    fileprivate init(limiter: SniConnectRequestLimiter, id: UUID) {
       self.limiter = limiter
-      self.key = key
+      self.id = id
     }
 
     func release() {
@@ -321,7 +343,7 @@ final class SniConnectRequestLimiter {
       }
       released = true
       lock.unlock()
-      limiter?.release(key: key)
+      limiter?.release(id: id)
     }
 
     deinit {
@@ -329,65 +351,216 @@ final class SniConnectRequestLimiter {
     }
   }
 
+  private final class CancellationState: @unchecked Sendable {
+    private let lock = NSLock()
+    private var cancelled = false
+
+    var isCancelled: Bool {
+      lock.lock()
+      defer { lock.unlock() }
+      return cancelled
+    }
+
+    func cancel() {
+      lock.lock()
+      cancelled = true
+      lock.unlock()
+    }
+  }
+
+  private struct PendingRequest {
+    let id: UUID
+    let key: String
+    let requestId: String?
+    let continuation: CheckedContinuation<Token, Error>
+  }
+
+  private struct ActiveRequest {
+    let key: String
+    let requestId: String?
+  }
+
   private let maxActiveRequests: Int
   private let maxActiveRequestsPerPair: Int
+  private let maxPendingRequests: Int
   private let queue = DispatchQueue(label: "com.onekey.sni.connect.request-limiter")
   private var activeRequests = 0
   private var activeRequestsByPair: [String: Int] = [:]
+  private var activeRequestsByID: [UUID: ActiveRequest] = [:]
+  private var pendingRequests: [PendingRequest] = []
 
   init(
     maxActiveRequests: Int = SniConnectValidation.maxActiveRequests,
-    maxActiveRequestsPerPair: Int = SniConnectValidation.maxActiveRequestsPerPair
+    maxActiveRequestsPerPair: Int = SniConnectValidation.maxActiveRequestsPerPair,
+    maxPendingRequests: Int = SniConnectValidation.maxPendingRequests
   ) {
     self.maxActiveRequests = maxActiveRequests
     self.maxActiveRequestsPerPair = maxActiveRequestsPerPair
+    self.maxPendingRequests = maxPendingRequests
   }
 
-  func acquire(hostname: String, ip: String) throws -> Token {
+  var pendingRequestCount: Int {
+    queue.sync {
+      pendingRequests.count
+    }
+  }
+
+  func snapshot(hostname: String, ip: String) -> Snapshot {
     let key = pairKey(hostname: hostname, ip: ip)
-    return try queue.sync {
-      if activeRequests >= maxActiveRequests {
-        SniConnectCoreDiagnostics.warn(SniConnectCoreDiagnostics.event("sni_resource_limit", [
-          ("activeCount", activeRequests),
-          ("pairCount", activeRequestsByPair[key] ?? 0),
-          ("limit", maxActiveRequests),
-          ("reason", "max_active_requests"),
-          ("hostname", hostname.lowercased()),
-          ("ipHash", SniConnectCoreDiagnostics.shortHash(ip)),
-        ]))
-        throw SniConnectValidation.ValidationError.resourceLimit("Too many active SNI requests")
+    return queue.sync {
+      let activeForPair = activeRequestsByID.values.filter { $0.key == key }
+      let pendingForPair = pendingRequests.filter { $0.key == key }
+      return Snapshot(
+        activeRequests: activeRequests,
+        activeRequestsForPair: activeForPair.count,
+        pendingRequests: pendingRequests.count,
+        pendingRequestsForPair: pendingForPair.count,
+        activeRequestIdsForPair: activeForPair.compactMap { $0.requestId }.sorted(),
+        pendingRequestIdsForPair: pendingForPair.compactMap { $0.requestId }.sorted()
+      )
+    }
+  }
+
+  func acquire(hostname: String, ip: String, requestId: String? = nil) async throws -> Token {
+    try Task.checkCancellation()
+
+    let id = UUID()
+    let key = pairKey(hostname: hostname, ip: ip)
+    let trackedRequestId = requestId.flatMap { $0.isEmpty ? nil : $0 }
+    let cancellationState = CancellationState()
+
+    let token = try await withTaskCancellationHandler {
+      try Task.checkCancellation()
+      return try await withCheckedThrowingContinuation { continuation in
+        var immediateToken: Token?
+        var immediateError: Error?
+
+        queue.sync {
+          if cancellationState.isCancelled {
+            immediateError = CancellationError()
+            return
+          }
+
+          if hasCapacity(for: key) {
+            retainSlot(id: id, key: key, requestId: trackedRequestId)
+            immediateToken = Token(limiter: self, id: id)
+            return
+          }
+
+          if pendingRequests.count >= maxPendingRequests {
+            SniConnectCoreDiagnostics.warn(SniConnectCoreDiagnostics.event("sni_resource_limit", [
+              ("activeCount", activeRequests),
+              ("pairCount", activeRequestsByPair[key] ?? 0),
+              ("pendingCount", pendingRequests.count),
+              ("limit", maxPendingRequests),
+              ("reason", "max_pending_requests"),
+              ("hostname", hostname.lowercased()),
+              ("ipHash", SniConnectCoreDiagnostics.shortHash(ip)),
+            ]))
+            immediateError = SniConnectValidation.ValidationError.resourceLimit(
+              "Too many pending SNI requests"
+            )
+            return
+          }
+
+          pendingRequests.append(PendingRequest(
+            id: id,
+            key: key,
+            requestId: trackedRequestId,
+            continuation: continuation
+          ))
+        }
+
+        if let immediateToken {
+          continuation.resume(returning: immediateToken)
+        } else if let immediateError {
+          continuation.resume(throwing: immediateError)
+        }
+      }
+    } onCancel: {
+      cancellationState.cancel()
+      self.cancelPendingRequest(id: id)
+    }
+
+    // Cancellation can race with a pending-to-active handoff. Never return a
+    // token to an already-cancelled caller without releasing its retained slot.
+    do {
+      try Task.checkCancellation()
+      return token
+    } catch {
+      token.release()
+      throw error
+    }
+  }
+
+  private func release(id: UUID) {
+    var nextRequest: PendingRequest?
+
+    queue.sync {
+      guard releaseSlot(id: id) else { return }
+
+      guard activeRequests < maxActiveRequests,
+            let index = pendingRequests.firstIndex(where: { hasCapacity(for: $0.key) }) else {
+        return
       }
-      let pairCount = activeRequestsByPair[key] ?? 0
-      if pairCount >= maxActiveRequestsPerPair {
-        SniConnectCoreDiagnostics.warn(SniConnectCoreDiagnostics.event("sni_resource_limit", [
-          ("activeCount", activeRequests),
-          ("pairCount", pairCount),
-          ("limit", maxActiveRequestsPerPair),
-          ("reason", "max_active_requests_per_pair"),
-          ("hostname", hostname.lowercased()),
-          ("ipHash", SniConnectCoreDiagnostics.shortHash(ip)),
-        ]))
-        throw SniConnectValidation.ValidationError.resourceLimit("Too many active SNI requests for destination")
+
+      nextRequest = pendingRequests.remove(at: index)
+      if let nextRequest {
+        retainSlot(
+          id: nextRequest.id,
+          key: nextRequest.key,
+          requestId: nextRequest.requestId
+        )
       }
-      activeRequests += 1
-      activeRequestsByPair[key] = pairCount + 1
-      return Token(limiter: self, key: key)
+    }
+
+    if let nextRequest {
+      nextRequest.continuation.resume(returning: Token(limiter: self, id: nextRequest.id))
     }
   }
 
-  private func release(key: String) {
+  private func cancelPendingRequest(id: UUID) {
+    var cancelledRequest: PendingRequest?
+
     queue.sync {
-      activeRequests = max(0, activeRequests - 1)
-      guard let pairCount = activeRequestsByPair[key] else { return }
-      if pairCount <= 1 {
-        activeRequestsByPair.removeValue(forKey: key)
-      } else {
-        activeRequestsByPair[key] = pairCount - 1
+      guard let index = pendingRequests.firstIndex(where: { $0.id == id }) else {
+        return
       }
+      cancelledRequest = pendingRequests.remove(at: index)
+    }
+
+    cancelledRequest?.continuation.resume(throwing: CancellationError())
+  }
+
+  private func hasCapacity(for key: String) -> Bool {
+    activeRequests < maxActiveRequests &&
+      (activeRequestsByPair[key] ?? 0) < maxActiveRequestsPerPair
+  }
+
+  private func retainSlot(id: UUID, key: String, requestId: String?) {
+    activeRequestsByID[id] = ActiveRequest(key: key, requestId: requestId)
+    activeRequests += 1
+    activeRequestsByPair[key, default: 0] += 1
+  }
+
+  private func releaseSlot(id: UUID) -> Bool {
+    guard let activeRequest = activeRequestsByID.removeValue(forKey: id) else {
+      return false
+    }
+    let key = activeRequest.key
+    activeRequests = max(0, activeRequests - 1)
+    guard let pairCount = activeRequestsByPair[key] else {
+      return true
+    }
+    if pairCount <= 1 {
+      activeRequestsByPair.removeValue(forKey: key)
+    } else {
+      activeRequestsByPair[key] = pairCount - 1
     }
+    return true
   }
 
   private func pairKey(hostname: String, ip: String) -> String {
-    return "\(hostname.lowercased())|\(ip)"
+    return "\(hostname.lowercased())|\(SniConnectValidation.canonicalIPKey(ip))"
   }
 }

package/ios/Tests/SniConnectValidationTests/SniConnectValidationTests.swift

@@ -122,12 +122,18 @@ final class SniConnectValidationTests: XCTestCase {
   }
 
   func testEnforcesRequestIdTimeoutAndBodyLimits() {
+    XCTAssertNoThrow(
+      try SniConnectValidation.validateRequestId(String(repeating: "界", count: 42))
+    )
     assertValidationFails {
       try SniConnectValidation.validateRequestId("")
     }
     assertValidationFails {
       try SniConnectValidation.validateRequestId(String(repeating: "x", count: 129))
     }
+    assertValidationFails {
+      try SniConnectValidation.validateRequestId(String(repeating: "界", count: 43))
+    }
     assertValidationFails {
       try SniConnectValidation.validateRequestId("req\n1")
     }
@@ -204,24 +210,196 @@ final class SniConnectValidationTests: XCTestCase {
     XCTAssertNoThrow(try SniConnectValidation.validateMethodBody(method: "OPTIONS", body: nil))
   }
 
-  func testRequestLimiterEnforcesGlobalAndPerDestinationLimits() throws {
+  func testTwentySamePairRequestsProduceSixteenActiveAndFourPending() async throws {
+    let limiter = SniConnectRequestLimiter()
+    var tasks: [String: Task<SniConnectRequestLimiter.Token, Error>] = [:]
+
+    for index in 0..<20 {
+      let requestId = String(format: "req-%02d", index)
+      tasks[requestId] = Task {
+        try await limiter.acquire(
+          hostname: "Example.com",
+          ip: index.isMultiple(of: 2)
+            ? "2001:4860:4860::8888"
+            : "2001:4860:4860:0:0:0:0:8888",
+          requestId: requestId
+        )
+      }
+    }
+
+    await waitForPendingRequests(4, in: limiter)
+    let saturated = limiter.snapshot(
+      hostname: "EXAMPLE.COM",
+      ip: "2001:4860:4860::8888"
+    )
+    XCTAssertEqual(saturated.activeRequests, 16)
+    XCTAssertEqual(saturated.activeRequestsForPair, 16)
+    XCTAssertEqual(saturated.pendingRequests, 4)
+    XCTAssertEqual(saturated.pendingRequestsForPair, 4)
+    XCTAssertEqual(saturated.activeRequestIdsForPair.count, 16)
+    XCTAssertEqual(saturated.pendingRequestIdsForPair.count, 4)
+
+    for requestId in saturated.pendingRequestIdsForPair {
+      tasks[requestId]?.cancel()
+    }
+    for requestId in saturated.pendingRequestIdsForPair {
+      do {
+        _ = try await tasks[requestId]!.value
+        XCTFail("Expected pending request \(requestId) to be cancelled")
+      } catch is CancellationError {
+        // Expected.
+      }
+    }
+
+    XCTAssertEqual(limiter.pendingRequestCount, 0)
+    for requestId in saturated.activeRequestIdsForPair {
+      let token = try await tasks[requestId]!.value
+      token.release()
+    }
+    let drained = limiter.snapshot(
+      hostname: "example.com",
+      ip: "2001:4860:4860:0:0:0:0:8888"
+    )
+    XCTAssertEqual(drained.activeRequests, 0)
+    XCTAssertEqual(drained.pendingRequests, 0)
+
+    let recovery = try await limiter.acquire(
+      hostname: "example.com",
+      ip: "2001:4860:4860::8888",
+      requestId: "recovery"
+    )
+    recovery.release()
+  }
+
+  func testRequestLimiterQueuesGlobalAndPerDestinationLimits() async throws {
     let limiter = SniConnectRequestLimiter(maxActiveRequests: 2, maxActiveRequestsPerPair: 1)
-    let firstToken = try limiter.acquire(hostname: "Example.com", ip: "93.184.216.34")
+    let firstToken = try await limiter.acquire(hostname: "Example.com", ip: "93.184.216.34")
 
-    assertValidationFails {
-      _ = try limiter.acquire(hostname: "example.com", ip: "93.184.216.34")
+    let sameDestinationTask = Task {
+      try await limiter.acquire(hostname: "example.com", ip: "93.184.216.34")
     }
+    await waitForPendingRequests(1, in: limiter)
 
-    let secondToken = try limiter.acquire(hostname: "example.com", ip: "93.184.216.35")
-    assertValidationFails {
-      _ = try limiter.acquire(hostname: "example.net", ip: "93.184.216.36")
+    let secondToken = try await limiter.acquire(hostname: "example.com", ip: "93.184.216.35")
+    let globallyQueuedTask = Task {
+      try await limiter.acquire(hostname: "example.net", ip: "93.184.216.36")
     }
+    await waitForPendingRequests(2, in: limiter)
 
     firstToken.release()
-    let replacementToken = try limiter.acquire(hostname: "example.com", ip: "93.184.216.34")
+    let replacementToken = try await sameDestinationTask.value
     firstToken.release()
     secondToken.release()
+    let globallyQueuedToken = try await globallyQueuedTask.value
     replacementToken.release()
+    globallyQueuedToken.release()
+  }
+
+  func testRequestLimiterSnapshotCanonicalizesTargetAndReturnsRequestIDs() async throws {
+    let limiter = SniConnectRequestLimiter(maxActiveRequests: 2, maxActiveRequestsPerPair: 1)
+    let activeTarget = try await limiter.acquire(
+      hostname: "Example.com",
+      ip: "2001:4860:4860::8888",
+      requestId: "active-target"
+    )
+    let activeOther = try await limiter.acquire(
+      hostname: "example.com",
+      ip: "93.184.216.34",
+      requestId: "active-other"
+    )
+    let pendingTargetTask = Task {
+      try await limiter.acquire(
+        hostname: "example.com",
+        ip: "2001:4860:4860:0:0:0:0:8888",
+        requestId: "pending-target"
+      )
+    }
+    let pendingWithoutIDTask = Task {
+      try await limiter.acquire(
+        hostname: "example.com",
+        ip: "2001:4860:4860::8888",
+        requestId: ""
+      )
+    }
+    await waitForPendingRequests(2, in: limiter)
+
+    let snapshot = limiter.snapshot(
+      hostname: "EXAMPLE.COM",
+      ip: "2001:4860:4860:0:0:0:0:8888"
+    )
+    XCTAssertEqual(snapshot.activeRequests, 2)
+    XCTAssertEqual(snapshot.activeRequestsForPair, 1)
+    XCTAssertEqual(snapshot.pendingRequests, 2)
+    XCTAssertEqual(snapshot.pendingRequestsForPair, 2)
+    XCTAssertEqual(snapshot.activeRequestIdsForPair, ["active-target"])
+    XCTAssertEqual(snapshot.pendingRequestIdsForPair, ["pending-target"])
+
+    pendingTargetTask.cancel()
+    pendingWithoutIDTask.cancel()
+    _ = try? await pendingTargetTask.value
+    _ = try? await pendingWithoutIDTask.value
+    activeTarget.release()
+    activeOther.release()
+  }
+
+  func testRequestLimiterRejectsTheTwoHundredFiftySeventhPendingRequest() async throws {
+    let limiter = SniConnectRequestLimiter(
+      maxActiveRequests: 1,
+      maxActiveRequestsPerPair: 1,
+      maxPendingRequests: 256
+    )
+    let activeToken = try await limiter.acquire(
+      hostname: "example.com",
+      ip: "93.184.216.34"
+    )
+    let queuedTasks = (0..<256).map { index in
+      Task {
+        try await limiter.acquire(
+          hostname: "example.com",
+          ip: "93.184.216.34",
+          requestId: "pending-\(index)"
+        )
+      }
+    }
+    await waitForPendingRequests(256, in: limiter)
+
+    do {
+      _ = try await limiter.acquire(hostname: "example.com", ip: "93.184.216.34")
+      XCTFail("Expected the bounded pending queue to reject overflow")
+    } catch SniConnectValidation.ValidationError.resourceLimit(_) {
+      // Expected.
+    }
+
+    queuedTasks.forEach { $0.cancel() }
+    for task in queuedTasks {
+      _ = try? await task.value
+    }
+    XCTAssertEqual(limiter.pendingRequestCount, 0)
+    activeToken.release()
+  }
+
+  func testWallClockDeadlineCancelsPendingLimiterWait() async throws {
+    let limiter = SniConnectRequestLimiter(maxActiveRequests: 1, maxActiveRequestsPerPair: 1)
+    let activeToken = try await limiter.acquire(
+      hostname: "example.com",
+      ip: "93.184.216.34"
+    )
+
+    do {
+      _ = try await SniConnectWallClockDeadline.run(timeoutMilliseconds: 20) {
+        try await limiter.acquire(
+          hostname: "example.com",
+          ip: "93.184.216.34",
+          requestId: "deadline-pending"
+        )
+      }
+      XCTFail("Expected queue wait to consume the wall-clock deadline")
+    } catch let error as SniConnectTimeout {
+      XCTAssertEqual(error, .deadlineExceeded)
+    }
+
+    XCTAssertEqual(limiter.pendingRequestCount, 0)
+    activeToken.release()
   }
 
   func testResolverRegistryKeepsResolverClassUntilAllSessionsReleaseIt() throws {
@@ -298,6 +476,20 @@ final class SniConnectValidationTests: XCTestCase {
     }
   }
 
+  func testWallClockDeadlineRejectsResultAfterAbsoluteDeadline() async throws {
+    let deadline = SniConnectWallClockDeadline.makeDeadline(timeoutMilliseconds: 5)
+    try await Task.sleep(nanoseconds: 20_000_000)
+
+    do {
+      _ = try await SniConnectWallClockDeadline.run(until: deadline) {
+        return "late"
+      }
+      XCTFail("Expected an operation result produced after the deadline to be rejected")
+    } catch let error as SniConnectTimeout {
+      XCTAssertEqual(error, .deadlineExceeded)
+    }
+  }
+
   func testResponseHeaderMapsPreserveRawRepeatedSetCookieHeaders() throws {
     let headerMaps = SniConnectResponseHeaders.make(rawHeaderFields: [
       (name: "Content-Type", value: "application/json"),
@@ -331,4 +523,24 @@ final class SniConnectValidationTests: XCTestCase {
   private func assertValidationFails(_ block: () throws -> Void, file: StaticString = #filePath, line: UInt = #line) {
     XCTAssertThrowsError(try block(), file: file, line: line)
   }
+
+  private func waitForPendingRequests(
+    _ expectedCount: Int,
+    in limiter: SniConnectRequestLimiter,
+    file: StaticString = #filePath,
+    line: UInt = #line
+  ) async {
+    let deadline = Date().addingTimeInterval(5)
+    while Date() < deadline {
+      if limiter.pendingRequestCount == expectedCount {
+        return
+      }
+      try? await Task.sleep(nanoseconds: 1_000_000)
+    }
+    XCTFail(
+      "Expected \(expectedCount) pending requests, got \(limiter.pendingRequestCount)",
+      file: file,
+      line: line
+    )
+  }
 }

package/lib/module/index.js

@@ -13,6 +13,9 @@ export function cancelAllRequests() {
 export function clearDNSCache() {
   return NativeSniConnect.clearDNSCache();
 }
+export function getDebugSnapshot(target) {
+  return NativeSniConnect.getDebugSnapshot(target);
+}
 export function isProxyActiveForUrl(url) {
   return NativeSniConnect.isProxyActiveForUrl(url);
 }

package/lib/typescript/src/NativeSniConnect.d.ts

@@ -39,6 +39,18 @@ export type SniConnectResponse = {
     headers: HeaderMap;
     multiValueHeaders?: MultiValueHeaderMap;
 };
+export type SniConnectDebugTarget = {
+    ip: string;
+    hostname: string;
+};
+export type SniConnectDebugSnapshot = {
+    activeRequests: Int32;
+    activeRequestsForPair: Int32;
+    pendingRequests: Int32;
+    pendingRequestsForPair: Int32;
+    activeRequestIdsForPair: string[];
+    pendingRequestIdsForPair: string[];
+};
 export interface Spec extends TurboModule {
     request(config: NativeSniConnectRequest): Promise<SniConnectResponse>;
     cancelRequest(requestId: string): Promise<{
@@ -50,6 +62,7 @@ export interface Spec extends TurboModule {
     clearDNSCache(): Promise<{
         success: boolean;
     }>;
+    getDebugSnapshot(target: SniConnectDebugTarget): Promise<SniConnectDebugSnapshot>;
     isProxyActiveForUrl(url: string): Promise<boolean>;
 }
 export type SniConnectModule = Spec;

package/lib/typescript/src/index.d.ts

@@ -1,4 +1,4 @@
-import { type SniConnectRequest, type SniConnectResponse } from './NativeSniConnect';
+import { type SniConnectDebugSnapshot, type SniConnectDebugTarget, type SniConnectRequest, type SniConnectResponse } from './NativeSniConnect';
 export declare function request(config: SniConnectRequest): Promise<SniConnectResponse>;
 export declare function cancelRequest(requestId: string): Promise<{
     success: boolean;
@@ -9,6 +9,7 @@ export declare function cancelAllRequests(): Promise<{
 export declare function clearDNSCache(): Promise<{
     success: boolean;
 }>;
+export declare function getDebugSnapshot(target: SniConnectDebugTarget): Promise<SniConnectDebugSnapshot>;
 export declare function isProxyActiveForUrl(url: string): Promise<boolean>;
-export type { SniConnectBodylessMethod, SniConnectMethod, SniConnectOptionalBodyMethod, SniConnectRequest, SniConnectRequiredBodyMethod, SniConnectResponse, } from './NativeSniConnect';
+export type { SniConnectBodylessMethod, SniConnectDebugSnapshot, SniConnectDebugTarget, SniConnectMethod, SniConnectOptionalBodyMethod, SniConnectRequest, SniConnectRequiredBodyMethod, SniConnectResponse, } from './NativeSniConnect';
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-sni-connect",
-  "version": "3.0.85",
+  "version": "3.0.86",
   "description": "A React Native library for SNI-based HTTP requests with DNS caching and request management",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/NativeSniConnect.ts

@@ -58,11 +58,28 @@ export type SniConnectResponse = {
   multiValueHeaders?: MultiValueHeaderMap;
 };
 
+export type SniConnectDebugTarget = {
+  ip: string;
+  hostname: string;
+};
+
+export type SniConnectDebugSnapshot = {
+  activeRequests: Int32;
+  activeRequestsForPair: Int32;
+  pendingRequests: Int32;
+  pendingRequestsForPair: Int32;
+  activeRequestIdsForPair: string[];
+  pendingRequestIdsForPair: string[];
+};
+
 export interface Spec extends TurboModule {
   request(config: NativeSniConnectRequest): Promise<SniConnectResponse>;
   cancelRequest(requestId: string): Promise<{ success: boolean }>;
   cancelAllRequests(): Promise<{ success: boolean }>;
   clearDNSCache(): Promise<{ success: boolean }>;
+  getDebugSnapshot(
+    target: SniConnectDebugTarget
+  ): Promise<SniConnectDebugSnapshot>;
   isProxyActiveForUrl(url: string): Promise<boolean>;
 }