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

package/ios/SniConnectValidation.swift

@@ -32,7 +32,6 @@ 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> = [
@@ -213,16 +212,6 @@ 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 }
@@ -312,27 +301,16 @@ enum SniConnectValidation {
   }
 }
 
-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 {
+final class SniConnectRequestLimiter {
+  final class Token {
     private weak var limiter: SniConnectRequestLimiter?
-    private let id: UUID
+    private let key: String
     private let lock = NSLock()
     private var released = false
 
-    fileprivate init(limiter: SniConnectRequestLimiter, id: UUID) {
+    fileprivate init(limiter: SniConnectRequestLimiter, key: String) {
       self.limiter = limiter
-      self.id = id
+      self.key = key
     }
 
     func release() {
@@ -343,7 +321,7 @@ final class SniConnectRequestLimiter: @unchecked Sendable {
       }
       released = true
       lock.unlock()
-      limiter?.release(id: id)
+      limiter?.release(key: key)
     }
 
     deinit {
@@ -351,216 +329,65 @@ final class SniConnectRequestLimiter: @unchecked Sendable {
     }
   }
 
-  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,
-    maxPendingRequests: Int = SniConnectValidation.maxPendingRequests
+    maxActiveRequestsPerPair: Int = SniConnectValidation.maxActiveRequestsPerPair
   ) {
     self.maxActiveRequests = maxActiveRequests
     self.maxActiveRequestsPerPair = maxActiveRequestsPerPair
-    self.maxPendingRequests = maxPendingRequests
   }
 
-  var pendingRequestCount: Int {
-    queue.sync {
-      pendingRequests.count
-    }
-  }
-
-  func snapshot(hostname: String, ip: String) -> Snapshot {
+  func acquire(hostname: String, ip: String) throws -> Token {
     let key = pairKey(hostname: hostname, ip: ip)
-    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
+    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")
       }
-
-      nextRequest = pendingRequests.remove(at: index)
-      if let nextRequest {
-        retainSlot(
-          id: nextRequest.id,
-          key: nextRequest.key,
-          requestId: nextRequest.requestId
-        )
+      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")
       }
-    }
-
-    if let nextRequest {
-      nextRequest.continuation.resume(returning: Token(limiter: self, id: nextRequest.id))
+      activeRequests += 1
+      activeRequestsByPair[key] = pairCount + 1
+      return Token(limiter: self, key: key)
     }
   }
 
-  private func cancelPendingRequest(id: UUID) {
-    var cancelledRequest: PendingRequest?
-
+  private func release(key: String) {
     queue.sync {
-      guard let index = pendingRequests.firstIndex(where: { $0.id == id }) else {
-        return
+      activeRequests = max(0, activeRequests - 1)
+      guard let pairCount = activeRequestsByPair[key] else { return }
+      if pairCount <= 1 {
+        activeRequestsByPair.removeValue(forKey: key)
+      } else {
+        activeRequestsByPair[key] = pairCount - 1
       }
-      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())|\(SniConnectValidation.canonicalIPKey(ip))"
+    return "\(hostname.lowercased())|\(ip)"
   }
 }

package/ios/Tests/SniConnectValidationTests/SniConnectValidationTests.swift

@@ -3,6 +3,15 @@ import XCTest
 
 final class SniConnectValidationTests: XCTestCase {
 
+  func testSessionWithoutForwardingDataDelegateAllowsResponse() {
+    switch SniConnectSessionDelegatePolicy.responseDispositionWithoutForwardingDelegate {
+    case .allow:
+      break
+    default:
+      XCTFail("A session without a forwarding data delegate must allow its response")
+    }
+  }
+
   func testAcceptsValidRequestBoundaryValues() throws {
     XCTAssertNoThrow(try SniConnectValidation.validateRequestId("req-1"))
     XCTAssertNoThrow(try SniConnectValidation.validateTimeout(120_000))
@@ -113,18 +122,12 @@ 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")
     }
@@ -201,196 +204,24 @@ final class SniConnectValidationTests: XCTestCase {
     XCTAssertNoThrow(try SniConnectValidation.validateMethodBody(method: "OPTIONS", body: nil))
   }
 
-  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 {
+  func testRequestLimiterEnforcesGlobalAndPerDestinationLimits() throws {
     let limiter = SniConnectRequestLimiter(maxActiveRequests: 2, maxActiveRequestsPerPair: 1)
-    let firstToken = try await limiter.acquire(hostname: "Example.com", ip: "93.184.216.34")
+    let firstToken = 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")
+    assertValidationFails {
+      _ = try limiter.acquire(hostname: "example.com", ip: "93.184.216.34")
     }
-    await waitForPendingRequests(1, in: limiter)
 
-    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")
+    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")
     }
-    await waitForPendingRequests(2, in: limiter)
 
     firstToken.release()
-    let replacementToken = try await sameDestinationTask.value
+    let replacementToken = try limiter.acquire(hostname: "example.com", ip: "93.184.216.34")
     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 {
@@ -500,24 +331,4 @@ 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,9 +13,6 @@ 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,18 +39,6 @@ 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<{
@@ -62,7 +50,6 @@ 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 SniConnectDebugSnapshot, type SniConnectDebugTarget, type SniConnectRequest, type SniConnectResponse } from './NativeSniConnect';
+import { type SniConnectRequest, type SniConnectResponse } from './NativeSniConnect';
 export declare function request(config: SniConnectRequest): Promise<SniConnectResponse>;
 export declare function cancelRequest(requestId: string): Promise<{
     success: boolean;
@@ -9,7 +9,6 @@ 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, SniConnectDebugSnapshot, SniConnectDebugTarget, SniConnectMethod, SniConnectOptionalBodyMethod, SniConnectRequest, SniConnectRequiredBodyMethod, SniConnectResponse, } from './NativeSniConnect';
+export type { SniConnectBodylessMethod, 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.81",
+  "version": "3.0.85",
   "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,28 +58,11 @@ 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>;
 }