react-native-nitro-fetch 1.0.3 → 1.1.1-alpha.0

package/NitroFetch.podspec

@@ -22,6 +22,10 @@ Pod::Spec.new do |s|
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
+  s.dependency 'React-RCTNetwork'
+
+  # Expose the DevTools reporter Obj-C facade to Swift via the pod's umbrella module.
+  s.public_header_files = ["ios/NitroDevToolsReporter.h"]
 
   load 'nitrogen/generated/ios/NitroFetch+autolinking.rb'
   add_nitrogen_files(s)

package/android/src/main/java/com/margelo/nitro/nitrofetch/DevToolsReporter.kt

@@ -0,0 +1,127 @@
+package com.margelo.nitro.nitrofetch
+
+/**
+ * Thin facade over React Native's `com.facebook.react.modules.network.InspectorNetworkReporter`.
+ *
+ * The reporter is `internal` in RN and may be missing entirely on older versions or stripped
+ * distributions. To stay both safe (no [NoClassDefFoundError]) and fast (no per-call reflection
+ * once the class is known to exist), we use the **isolation-class pattern**:
+ *
+ *  - This facade has *no* compile-time reference to `InspectorNetworkReporter`. It can always
+ *    be loaded and verified by ART, even when the reporter is absent.
+ *  - All direct calls live in [DevToolsReporterImpl], which is loaded reflectively *once* via
+ *    `Class.forName`. If verification fails (missing class), we catch and stay in no-op mode.
+ *  - On success, we hold an [Impl] interface reference and dispatch through it on every call —
+ *    a single null check + a virtual call (likely devirtualized by the JIT). No reflection,
+ *    no boxing, no method-handle lookups on the hot path.
+ */
+internal object DevToolsReporter {
+
+  /** Stable interface in *our* package — Impl implements it; no foreign types here. */
+  internal interface Impl {
+    fun isDebuggingEnabled(): Boolean
+    fun reportRequestStart(
+      requestId: String, url: String, method: String,
+      headers: Map<String, String>, body: String, encodedDataLength: Long
+    )
+    fun reportResponseStart(
+      requestId: String, url: String, statusCode: Int,
+      headers: Map<String, String>, expectedDataLength: Long
+    )
+    fun reportDataReceived(requestId: String, length: Int)
+    fun reportResponseEnd(requestId: String, encodedDataLength: Long)
+    fun reportRequestFailed(requestId: String, cancelled: Boolean)
+    fun storeResponseBody(requestId: String, body: String, base64Encoded: Boolean)
+    fun storeResponseBodyIncremental(requestId: String, data: String)
+  }
+
+  @Volatile private var impl: Impl? = null
+  // We deliberately do NOT latch failure: cold-start prefetch can run before
+  // RN classes are realized, and we want a later request to recover. The
+  // probe is cheap (Class.forName has its own internal cache).
+  private fun resolve(): Impl? {
+    val cached = impl
+    if (cached != null) return cached
+
+    if (!isSoLoaderInitialized()) return null
+    return try {
+      val cls = Class.forName("com.margelo.nitro.nitrofetch.DevToolsReporterImpl")
+  
+      val created = cls.getDeclaredConstructor().newInstance() as Impl
+      impl = created
+      created
+    } catch (_: Throwable) {
+      null
+    }
+  }
+
+  private fun isSoLoaderInitialized(): Boolean = try {
+    com.facebook.soloader.SoLoader.isInitialized()
+  } catch (_: Throwable) {
+    false
+  }
+
+  // --- Hot path: one null check + interface call. JIT will devirtualize. ---
+
+  fun isDebuggingEnabled(): Boolean = resolve()?.isDebuggingEnabled() ?: false
+
+  fun reportRequestStart(
+    requestId: String, url: String, method: String,
+    headers: Map<String, String>, body: String, encodedDataLength: Long
+  ) {
+    impl?.reportRequestStart(requestId, url, method, headers, body, encodedDataLength)
+  }
+
+  fun reportResponseStart(
+    requestId: String, url: String, statusCode: Int,
+    headers: Map<String, String>, expectedDataLength: Long
+  ) {
+    impl?.reportResponseStart(requestId, url, statusCode, headers, expectedDataLength)
+  }
+
+  fun reportDataReceived(requestId: String, length: Int) {
+    impl?.reportDataReceived(requestId, length)
+  }
+
+  fun reportResponseEnd(requestId: String, encodedDataLength: Long) {
+    impl?.reportResponseEnd(requestId, encodedDataLength)
+  }
+
+  fun reportRequestFailed(requestId: String, cancelled: Boolean) {
+    impl?.reportRequestFailed(requestId, cancelled)
+  }
+
+  fun storeResponseBody(requestId: String, body: String, base64Encoded: Boolean) {
+    impl?.storeResponseBody(requestId, body, base64Encoded)
+  }
+
+  fun storeResponseBodyIncremental(requestId: String, data: String) {
+    impl?.storeResponseBodyIncremental(requestId, data)
+  }
+
+  // --- Pure helpers, no reporter dependency. ---
+
+  fun isTextualContentType(contentType: String?): Boolean {
+    if (contentType == null) return false
+    val ct = contentType.lowercase()
+    return ct.startsWith("text/") ||
+      ct.contains("application/json") ||
+      ct.contains("application/xml") ||
+      ct.contains("application/javascript") ||
+      ct.contains("+json") ||
+      ct.contains("+xml")
+  }
+
+  fun headersArrayToMap(headers: Array<NitroHeader>?): Map<String, String> {
+    if (headers == null) return emptyMap()
+    val map = LinkedHashMap<String, String>(headers.size)
+    for (h in headers) map[h.key] = h.value
+    return map
+  }
+
+  fun headersListToMap(entries: List<Map.Entry<String, String>>): Map<String, String> {
+    val map = LinkedHashMap<String, String>(entries.size)
+    for (e in entries) map[e.key] = e.value
+    return map
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/DevToolsReporterImpl.kt

@@ -0,0 +1,67 @@
+package com.margelo.nitro.nitrofetch
+
+/**
+ * Direct-dispatch backend for [DevToolsReporter]. Loaded reflectively from the facade
+ * via `Class.forName`, so a missing `InspectorNetworkReporter` only prevents *this* class
+ * from loading — the facade itself stays intact and degrades to a no-op.
+ *
+ * Once loaded, every call here is a plain JVM static invoke. No reflection, no boxing,
+ * no method-handle lookups. The `@Suppress` annotations bypass RN's `internal` visibility
+ * (RN has no public surface here) — this is the documented integration point.
+ */
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+internal class DevToolsReporterImpl : DevToolsReporter.Impl {
+  override fun isDebuggingEnabled(): Boolean =
+    com.facebook.react.modules.network.InspectorNetworkReporter.isDebuggingEnabled()
+
+  override fun reportRequestStart(
+    requestId: String, url: String, method: String,
+    headers: Map<String, String>, body: String, encodedDataLength: Long
+  ) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestStart(
+      requestId, url, method, headers, body, encodedDataLength
+    )
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportConnectionTiming(
+      requestId, headers
+    )
+  }
+
+  override fun reportResponseStart(
+    requestId: String, url: String, statusCode: Int,
+    headers: Map<String, String>, expectedDataLength: Long
+  ) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseStart(
+      requestId, url, statusCode, headers, expectedDataLength
+    )
+  }
+
+  override fun reportDataReceived(requestId: String, length: Int) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportDataReceivedImpl(
+      requestId, length
+    )
+  }
+
+  override fun reportResponseEnd(requestId: String, encodedDataLength: Long) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseEnd(
+      requestId, encodedDataLength
+    )
+  }
+
+  override fun reportRequestFailed(requestId: String, cancelled: Boolean) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestFailed(
+      requestId, cancelled
+    )
+  }
+
+  override fun storeResponseBody(requestId: String, body: String, base64Encoded: Boolean) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBody(
+      requestId, body, base64Encoded
+    )
+  }
+
+  override fun storeResponseBodyIncremental(requestId: String, data: String) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBodyIncremental(
+      requestId, data
+    )
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroFetchClient.kt

@@ -80,10 +80,18 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       if (BuildConfig.NITRO_FETCH_TRACING) {
         Trace.beginAsyncSection(traceLabel, traceCookie)
       }
+      // BuildConfig.DEBUG short-circuits in release: R8 constant-folds the
+      // && so every `if (devToolsEnabled)` block below becomes dead code and
+      // the DevToolsReporter classes drop out of the release APK entirely.
+      // The UUID generation is gated too so SecureRandom isn't touched in release.
+      val devToolsEnabled = BuildConfig.DEBUG && DevToolsReporter.isDebuggingEnabled()
+      val devToolsRequestId = if (devToolsEnabled) (req.requestId ?: UUID.randomUUID().toString()) else ""
       val callback = object : UrlRequest.Callback() {
         private val buffer = ByteBuffer.allocateDirect(16 * 1024)
         private val out = java.io.ByteArrayOutputStream()
         private var redirectStopped = false
+        private var devToolsBytes = 0
+        private var devToolsTextual = false
 
         override fun onRedirectReceived(request: UrlRequest, info: UrlResponseInfo, newLocationUrl: String) {
           if (shouldFollowRedirects) {
@@ -113,6 +121,19 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
         }
 
         override fun onResponseStarted(request: UrlRequest, info: UrlResponseInfo) {
+          if (devToolsEnabled) {
+            val headersMap = LinkedHashMap<String, String>()
+            info.allHeadersAsList.forEach { headersMap[it.key] = it.value }
+            val contentType = headersMap["Content-Type"] ?: headersMap["content-type"]
+            devToolsTextual = DevToolsReporter.isTextualContentType(contentType)
+            DevToolsReporter.reportResponseStart(
+              devToolsRequestId,
+              info.url,
+              info.httpStatusCode,
+              headersMap,
+              -1L
+            )
+          }
           buffer.clear()
           request.read(buffer)
         }
@@ -122,6 +143,13 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           val bytes = ByteArray(byteBuffer.remaining())
           byteBuffer.get(bytes)
           out.write(bytes)
+          if (devToolsEnabled) {
+            devToolsBytes += bytes.size
+            DevToolsReporter.reportDataReceived(devToolsRequestId, bytes.size)
+            if (devToolsTextual) {
+              DevToolsReporter.storeResponseBodyIncremental(devToolsRequestId, String(bytes, Charsets.UTF_8))
+            }
+          }
           byteBuffer.clear()
           request.read(byteBuffer)
         }
@@ -130,6 +158,9 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           if (BuildConfig.NITRO_FETCH_TRACING) {
             Trace.endAsyncSection(traceLabel, traceCookie)
           }
+          if (devToolsEnabled) {
+            DevToolsReporter.reportResponseEnd(devToolsRequestId, devToolsBytes.toLong())
+          }
           try {
             val headersArr: Array<NitroHeader> =
               info.allHeadersAsList.map { NitroHeader(it.key, it.value) }.toTypedArray()
@@ -166,6 +197,9 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           if (BuildConfig.NITRO_FETCH_TRACING) {
             Trace.endAsyncSection(traceLabel, traceCookie)
           }
+          if (devToolsEnabled) {
+            DevToolsReporter.reportRequestFailed(devToolsRequestId, false)
+          }
           onFail(RuntimeException("Cronet failed: ${error.message}", error))
         }
 
@@ -173,6 +207,9 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           if (BuildConfig.NITRO_FETCH_TRACING) {
             Trace.endAsyncSection(traceLabel, traceCookie)
           }
+          if (devToolsEnabled) {
+            DevToolsReporter.reportRequestFailed(devToolsRequestId, true)
+          }
           if (!redirectStopped) {
             onFail(RuntimeException("Cronet canceled"))
           }
@@ -205,6 +242,19 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       }
 
       val request = builder.build()
+      if (devToolsEnabled) {
+        val headersMap = DevToolsReporter.headersArrayToMap(req.headers)
+        val body = req.bodyString ?: ""
+        val encoded = body.toByteArray(Charsets.UTF_8).size.toLong()
+        DevToolsReporter.reportRequestStart(
+          devToolsRequestId,
+          url,
+          method,
+          headersMap,
+          body,
+          encoded
+        )
+      }
       request.start()
       return request
     }

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroUrlRequestBuilder.kt

@@ -7,6 +7,7 @@ import org.chromium.net.UrlRequest as CronetUrlRequest
 import org.chromium.net.UrlResponseInfo as CronetUrlResponseInfo
 import org.chromium.net.CronetException as CronetNativeException
 import java.nio.ByteBuffer
+import java.util.UUID
 import java.util.concurrent.Executor as JavaExecutor
 
 @DoNotStrip
@@ -26,6 +27,16 @@ class NitroUrlRequestBuilder(
 
   private val builder: CronetUrlRequest.Builder
   private val byteBuffer: ByteBuffer
+  // BuildConfig.DEBUG short-circuits in release so R8 strips DevTools paths.
+  // UUID generation is gated too so SecureRandom isn't touched in release.
+  private val devToolsEnabled: Boolean = BuildConfig.DEBUG && DevToolsReporter.isDebuggingEnabled()
+  private val devToolsRequestId: String = if (devToolsEnabled) UUID.randomUUID().toString() else ""
+  private var devToolsBytes: Int = 0
+  private var devToolsTextual: Boolean = false
+  private var httpMethod: String = "GET"
+  private val requestHeaders: LinkedHashMap<String, String> = LinkedHashMap()
+  private var uploadBodyString: String = ""
+  private var uploadBodyLength: Long = 0L
 
   init {
     // Allocate ONE reusable owning buffer for all reads (64KB)
@@ -49,6 +60,19 @@ class NitroUrlRequestBuilder(
         request: CronetUrlRequest,
         info: CronetUrlResponseInfo
       ) {
+        if (devToolsEnabled) {
+          val headersMap = LinkedHashMap<String, String>()
+          info.allHeadersAsList.forEach { headersMap[it.key] = it.value }
+          val ct = headersMap["Content-Type"] ?: headersMap["content-type"]
+          devToolsTextual = DevToolsReporter.isTextualContentType(ct)
+          DevToolsReporter.reportResponseStart(
+            devToolsRequestId,
+            info.url,
+            info.httpStatusCode,
+            headersMap,
+            -1L
+          )
+        }
         onResponseStartedCallback?.let { callback ->
           val nitroInfo = info.toNitro()
           callback(nitroInfo)
@@ -60,8 +84,19 @@ class NitroUrlRequestBuilder(
         info: CronetUrlResponseInfo,
         receivedBuffer: ByteBuffer
       ) {
+        val bytesRead = receivedBuffer.position()
+        if (devToolsEnabled && bytesRead > 0) {
+          devToolsBytes += bytesRead
+          DevToolsReporter.reportDataReceived(devToolsRequestId, bytesRead)
+          if (devToolsTextual) {
+            val dup = receivedBuffer.duplicate()
+            dup.flip()
+            val arr = ByteArray(dup.remaining())
+            dup.get(arr)
+            DevToolsReporter.storeResponseBodyIncremental(devToolsRequestId, String(arr, Charsets.UTF_8))
+          }
+        }
         onReadCompletedCallback?.let { callback ->
-          val bytesRead = receivedBuffer.position()
           val nitroInfo = info.toNitro()
           callback(nitroInfo, reusableBuffer, bytesRead.toDouble())
         }
@@ -71,6 +106,9 @@ class NitroUrlRequestBuilder(
         request: CronetUrlRequest,
         info: CronetUrlResponseInfo
       ) {
+        if (devToolsEnabled) {
+          DevToolsReporter.reportResponseEnd(devToolsRequestId, devToolsBytes.toLong())
+        }
         onSucceededCallback?.let { callback ->
           val nitroInfo = info.toNitro()
           callback(nitroInfo)
@@ -82,6 +120,9 @@ class NitroUrlRequestBuilder(
         info: CronetUrlResponseInfo?,
         error: CronetNativeException
       ) {
+        if (devToolsEnabled) {
+          DevToolsReporter.reportRequestFailed(devToolsRequestId, false)
+        }
         onFailedCallback?.let { callback ->
           val nitroInfo = info?.toNitro()
           val nitroError = error.toNitro()
@@ -93,6 +134,9 @@ class NitroUrlRequestBuilder(
         request: CronetUrlRequest,
         info: CronetUrlResponseInfo?
       ) {
+        if (devToolsEnabled) {
+          DevToolsReporter.reportRequestFailed(devToolsRequestId, true)
+        }
         onCanceledCallback?.let { callback ->
           val nitroInfo = info?.toNitro()
           callback(nitroInfo)
@@ -104,11 +148,13 @@ class NitroUrlRequestBuilder(
   }
 
   override fun setHttpMethod(httpMethod: String) {
+    this.httpMethod = httpMethod
     builder.setHttpMethod(httpMethod)
   }
 
   override fun addHeader(name: String, value: String) {
-    builder.addHeader(name, value)  
+    requestHeaders[name] = value
+    builder.addHeader(name, value)
   }
 
   override fun setUploadBody(body: Variant_ArrayBuffer_String) {
@@ -119,8 +165,12 @@ class NitroUrlRequestBuilder(
         buffer.get(bytes)
         bytes
       }
-      is Variant_ArrayBuffer_String.Second -> body.value.toByteArray(Charsets.UTF_8)
+      is Variant_ArrayBuffer_String.Second -> {
+        uploadBodyString = body.value
+        body.value.toByteArray(Charsets.UTF_8)
+      }
     }
+    uploadBodyLength = bodyBytes.size.toLong()
 
     val provider = object : org.chromium.net.UploadDataProvider() {
       private var position = 0
@@ -176,6 +226,16 @@ class NitroUrlRequestBuilder(
 
   override fun build(): HybridUrlRequestSpec {
     val cronetRequest = builder.build()
+    if (devToolsEnabled) {
+      DevToolsReporter.reportRequestStart(
+        devToolsRequestId,
+        url,
+        httpMethod,
+        requestHeaders,
+        uploadBodyString,
+        uploadBodyLength
+      )
+    }
     return NitroUrlRequest(cronetRequest, byteBuffer)
   }
 }

package/ios/HybridUrlRequestBuilder.swift

@@ -16,6 +16,13 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
 
   private var urlRequest: URLRequest
   private var priority: Float = 0.5
+  private let devToolsRequestId: String = {
+    #if DEBUG
+    return UUID().uuidString
+    #else
+    return ""
+    #endif
+  }()
 
   init(
     url: String,
@@ -89,7 +96,8 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
       onFailed: onFailedCallback,
       onCanceled: onCanceledCallback,
       executor: executor,
-      hybridRequest: nil
+      hybridRequest: nil,
+      devToolsRequestId: devToolsRequestId
     )
 
     let config = URLSessionConfiguration.default
@@ -107,6 +115,12 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
     task.priority = priority
     delegate.task = task
 
+    #if DEBUG
+    if NitroDevToolsReporter.isDebuggingEnabled() {
+      NitroDevToolsReporter.reportRequestStart(withRequest: devToolsRequestId, request: urlRequest)
+    }
+    #endif
+
     let request = HybridUrlRequest(task: task, delegate: delegate)
     delegate.hybridRequest = request
 
@@ -129,6 +143,9 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
   weak var hybridRequest: HybridUrlRequest?
 
   private var response: HTTPURLResponse?
+  private let devToolsRequestId: String
+  private var devToolsBytes: Int = 0
+  private var devToolsTextual: Bool = false
 
   init(
     onRedirectReceived: ((_ info: UrlResponseInfo, _ newLocationUrl: String) -> Void)?,
@@ -138,7 +155,8 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
     onFailed: ((_ info: UrlResponseInfo?, _ error: RequestException) -> Void)?,
     onCanceled: ((_ info: UrlResponseInfo?) -> Void)?,
     executor: DispatchQueue,
-    hybridRequest: HybridUrlRequest?
+    hybridRequest: HybridUrlRequest?,
+    devToolsRequestId: String
   ) {
     self.onRedirectReceived = onRedirectReceived
     self.onResponseStarted = onResponseStarted
@@ -148,6 +166,7 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
     self.onCanceled = onCanceled
     self.executor = executor
     self.hybridRequest = hybridRequest
+    self.devToolsRequestId = devToolsRequestId
     super.init()
   }
 
@@ -181,11 +200,21 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
       if let error = error {
         let nsError = error as NSError
         if nsError.code == NSURLErrorCancelled {
+          #if DEBUG
+          if NitroDevToolsReporter.isDebuggingEnabled() {
+            NitroDevToolsReporter.reportRequestFailed(self.devToolsRequestId, cancelled: true)
+          }
+          #endif
           if let callback = self.onCanceled {
             let nitroInfo = self.response?.toNitro()
             callback(nitroInfo)
           }
         } else {
+          #if DEBUG
+          if NitroDevToolsReporter.isDebuggingEnabled() {
+            NitroDevToolsReporter.reportRequestFailed(self.devToolsRequestId, cancelled: false)
+          }
+          #endif
           if let callback = self.onFailed {
             let nitroError = error.toNitro()
             let nitroInfo = self.response?.toNitro()
@@ -193,6 +222,11 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
           }
         }
       } else if let response = self.response {
+        #if DEBUG
+        if NitroDevToolsReporter.isDebuggingEnabled() {
+          NitroDevToolsReporter.reportResponseEnd(self.devToolsRequestId, encodedDataLength: self.devToolsBytes)
+        }
+        #endif
         if let callback = self.onSucceeded {
           let info = response.toNitro()
           callback(info)
@@ -216,6 +250,22 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
 
     executor.sync { [weak self] in
       guard let self = self else { return }
+      #if DEBUG
+      if NitroDevToolsReporter.isDebuggingEnabled() {
+        var headerDict: [String: String] = [:]
+        httpResponse.allHeaderFields.forEach { k, v in
+          if let key = k as? String { headerDict[key] = String(describing: v) }
+        }
+        NitroDevToolsReporter.reportResponseStart(
+          self.devToolsRequestId,
+          url: httpResponse.url?.absoluteString ?? "",
+          statusCode: httpResponse.statusCode,
+          headers: headerDict
+        )
+        let ct = headerDict["Content-Type"] ?? headerDict["content-type"]
+        self.devToolsTextual = NitroDevToolsReporter.isTextualContentType(ct)
+      }
+      #endif
       if let callback = self.onResponseStarted {
         let info = httpResponse.toNitro()
         callback(info)
@@ -234,6 +284,16 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
       executor.sync { [weak self] in
         guard let self = self, let response = self.response else { return }
 
+        #if DEBUG
+        if NitroDevToolsReporter.isDebuggingEnabled() {
+          self.devToolsBytes += data.count
+          NitroDevToolsReporter.reportDataReceived(self.devToolsRequestId, length: data.count)
+          if self.devToolsTextual, let text = String(data: data, encoding: .utf8) {
+            NitroDevToolsReporter.storeResponseBodyIncremental(self.devToolsRequestId, text: text)
+          }
+        }
+        #endif
+
         let arrayBuffer: ArrayBuffer
         do {
           arrayBuffer = try ArrayBuffer.copy(data: data)

package/ios/NitroDevToolsReporter.h

@@ -0,0 +1,42 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Swift-friendly facade over RCTInspectorNetworkReporter.
+/// All methods are no-ops when the modern CDP debugger is not attached
+/// (checked via -isDebuggingEnabled). Safe to call in release builds.
+@interface NitroDevToolsReporter : NSObject
+
++ (BOOL)isDebuggingEnabled;
+
++ (void)reportRequestStartWithRequest:(NSString *)requestId
+                              request:(NSURLRequest *)request;
+
++ (void)reportRequestStart:(NSString *)requestId
+                       url:(NSString *)url
+                    method:(NSString *)method
+                   headers:(NSDictionary<NSString *, NSString *> *)headers
+                bodyString:(nullable NSString *)bodyString;
+
++ (void)reportResponseStart:(NSString *)requestId
+                        url:(NSString *)url
+                 statusCode:(NSInteger)statusCode
+                    headers:(NSDictionary<NSString *, NSString *> *)headers;
+
++ (void)reportDataReceived:(NSString *)requestId length:(NSInteger)length;
+
++ (void)reportResponseEnd:(NSString *)requestId encodedDataLength:(NSInteger)length;
+
++ (void)reportRequestFailed:(NSString *)requestId cancelled:(BOOL)cancelled;
+
++ (void)storeResponseBody:(NSString *)requestId
+                     data:(NSData *)data
+            base64Encoded:(BOOL)base64Encoded;
+
++ (void)storeResponseBodyIncremental:(NSString *)requestId text:(NSString *)text;
+
++ (BOOL)isTextualContentType:(nullable NSString *)contentType;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NitroDevToolsReporter.mm

@@ -0,0 +1,153 @@
+#import "NitroDevToolsReporter.h"
+
+// RCTInspectorNetworkReporter is bundled in React-RCTNetwork. In RN < 0.76
+// or when the header isn't visible (release-optimized module maps, OSS forks),
+// we compile to a no-op so the module still builds.
+#if __has_include(<React/RCTInspectorNetworkReporter.h>)
+#import <React/RCTInspectorNetworkReporter.h>
+#define NITRO_HAS_NETWORK_REPORTER 1
+#else
+#define NITRO_HAS_NETWORK_REPORTER 0
+#endif
+
+// During cold-start prefetch, RN's RCTInspectorNetworkReporter class may not
+// be realized yet (its underlying C++ NetworkReporter singleton is brought up
+// when the bridge initializes). Every entry point goes through +reporterClass,
+// which uses NSClassFromString so a missing class becomes a clean no-op
+// instead of crashing on a not-yet-initialized C++ singleton.
+
+@implementation NitroDevToolsReporter
+
++ (Class _Nullable)reporterClass {
+#if NITRO_HAS_NETWORK_REPORTER
+  static Class cached = Nil;
+  if (cached == Nil) {
+    cached = NSClassFromString(@"RCTInspectorNetworkReporter");
+  }
+  return cached;
+#else
+  return Nil;
+#endif
+}
+
++ (BOOL)isDebuggingEnabled {
+  return [self reporterClass] != Nil;
+}
+
++ (void)reportRequestStartWithRequest:(NSString *)requestId
+                              request:(NSURLRequest *)request {
+#if NITRO_HAS_NETWORK_REPORTER
+  if (request == nil) return;
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  int encoded = (int)(request.HTTPBody.length);
+  [cls reportRequestStart:requestId request:request encodedDataLength:encoded];
+  [cls reportConnectionTiming:requestId request:request];
+#endif
+}
+
++ (void)reportRequestStart:(NSString *)requestId
+                       url:(NSString *)url
+                    method:(NSString *)method
+                   headers:(NSDictionary<NSString *, NSString *> *)headers
+                bodyString:(NSString *)bodyString {
+#if NITRO_HAS_NETWORK_REPORTER
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  NSURL *u = [NSURL URLWithString:url];
+  if (u == nil) return;
+  NSMutableURLRequest *req = [NSMutableURLRequest requestWithURL:u];
+  req.HTTPMethod = method ?: @"GET";
+  for (NSString *k in headers) {
+    [req setValue:headers[k] forHTTPHeaderField:k];
+  }
+  if (bodyString.length > 0) {
+    req.HTTPBody = [bodyString dataUsingEncoding:NSUTF8StringEncoding];
+  }
+  NSInteger encoded = bodyString ? (NSInteger)[bodyString lengthOfBytesUsingEncoding:NSUTF8StringEncoding] : 0;
+  [cls reportRequestStart:requestId request:req encodedDataLength:(int)encoded];
+  [cls reportConnectionTiming:requestId request:req];
+#endif
+}
+
++ (void)reportResponseStart:(NSString *)requestId
+                        url:(NSString *)url
+                 statusCode:(NSInteger)statusCode
+                    headers:(NSDictionary<NSString *, NSString *> *)headers {
+#if NITRO_HAS_NETWORK_REPORTER
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  NSURL *u = [NSURL URLWithString:url];
+  if (u == nil) return;
+  NSHTTPURLResponse *resp = [[NSHTTPURLResponse alloc] initWithURL:u
+                                                         statusCode:statusCode
+                                                        HTTPVersion:@"HTTP/1.1"
+                                                       headerFields:headers];
+  [cls reportResponseStart:requestId
+                  response:resp
+                statusCode:(int)statusCode
+                   headers:headers];
+#endif
+}
+
++ (void)reportDataReceived:(NSString *)requestId length:(NSInteger)length {
+#if NITRO_HAS_NETWORK_REPORTER
+  if (length <= 0) return;
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  // Only data.length is read by the underlying reporter. Avoid allocating a
+  // zero-filled buffer by handing NSData a non-owned byte pointer and the
+  // intended length.
+  static uint8_t sentinel;
+  NSData *sized = [NSData dataWithBytesNoCopy:&sentinel length:(NSUInteger)length freeWhenDone:NO];
+  [cls reportDataReceived:requestId data:sized];
+#endif
+}
+
++ (void)reportResponseEnd:(NSString *)requestId encodedDataLength:(NSInteger)length {
+#if NITRO_HAS_NETWORK_REPORTER
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  [cls reportResponseEnd:requestId encodedDataLength:(int)length];
+#endif
+}
+
++ (void)reportRequestFailed:(NSString *)requestId cancelled:(BOOL)cancelled {
+#if NITRO_HAS_NETWORK_REPORTER
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  [cls reportRequestFailed:requestId cancelled:cancelled];
+#endif
+}
+
++ (void)storeResponseBody:(NSString *)requestId
+                     data:(NSData *)data
+            base64Encoded:(BOOL)base64Encoded {
+#if NITRO_HAS_NETWORK_REPORTER
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  [cls maybeStoreResponseBody:requestId data:data base64Encoded:base64Encoded];
+#endif
+}
+
++ (void)storeResponseBodyIncremental:(NSString *)requestId text:(NSString *)text {
+#if NITRO_HAS_NETWORK_REPORTER
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  [cls maybeStoreResponseBodyIncremental:requestId data:text];
+#endif
+}
+
++ (BOOL)isTextualContentType:(NSString *)contentType {
+  if (contentType == nil) return NO;
+  NSString *ct = [contentType lowercaseString];
+  if ([ct hasPrefix:@"text/"]) return YES;
+  if ([ct containsString:@"application/json"]) return YES;
+  if ([ct containsString:@"application/xml"]) return YES;
+  if ([ct containsString:@"application/javascript"]) return YES;
+  if ([ct containsString:@"+json"]) return YES;
+  if ([ct containsString:@"+xml"]) return YES;
+  return NO;
+}
+
+@end

package/ios/NitroFetchClient.swift

@@ -170,8 +170,34 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
                 "%{public}s %{public}s", traceMethod, tracePath)
     #endif
 
-    let (data, response) = try await session.data(for: urlRequest, delegate: delegate)
+    // DevTools/CDP reporting is gated on `#if DEBUG` so the entire block is
+    // compiled out of release builds — no runtime cost, no symbol references.
+    #if DEBUG
+    let devToolsId = req.requestId ?? UUID().uuidString
+    if NitroDevToolsReporter.isDebuggingEnabled() {
+      NitroDevToolsReporter.reportRequestStart(withRequest: devToolsId, request: urlRequest)
+    }
+    #endif
+
+    let data: Data
+    let response: URLResponse
+    do {
+      (data, response) = try await session.data(for: urlRequest, delegate: delegate)
+    } catch {
+      #if DEBUG
+      if NitroDevToolsReporter.isDebuggingEnabled() {
+        let cancelled = (error as NSError).code == NSURLErrorCancelled
+        NitroDevToolsReporter.reportRequestFailed(devToolsId, cancelled: cancelled)
+      }
+      #endif
+      throw error
+    }
     guard let http = response as? HTTPURLResponse else {
+      #if DEBUG
+      if NitroDevToolsReporter.isDebuggingEnabled() {
+        NitroDevToolsReporter.reportRequestFailed(devToolsId, cancelled: false)
+      }
+      #endif
       throw NSError(domain: "NitroFetch", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])
     }
 
@@ -180,6 +206,28 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
       return NitroHeader(key: key, value: String(describing: v))
     }
 
+    #if DEBUG
+    if NitroDevToolsReporter.isDebuggingEnabled() {
+      var headerDict: [String: String] = [:]
+      for h in headersPairs { headerDict[h.key] = h.value }
+      NitroDevToolsReporter.reportResponseStart(
+        devToolsId,
+        url: finalURL?.absoluteString ?? http.url?.absoluteString ?? req.url,
+        statusCode: http.statusCode,
+        headers: headerDict
+      )
+      NitroDevToolsReporter.reportDataReceived(devToolsId, length: data.count)
+      if NitroDevToolsReporter.isTextualContentType(headerDict["Content-Type"] ?? headerDict["content-type"]) {
+        if let text = String(data: data, encoding: .utf8) {
+          NitroDevToolsReporter.storeResponseBody(devToolsId, data: Data(text.utf8), base64Encoded: false)
+        }
+      } else if data.count > 0 && data.count <= 5 * 1024 * 1024 {
+        NitroDevToolsReporter.storeResponseBody(devToolsId, data: data, base64Encoded: true)
+      }
+      NitroDevToolsReporter.reportResponseEnd(devToolsId, encodedDataLength: data.count)
+    }
+    #endif
+
     // Choose bodyString by default (matching Android’s first pass)
     let charset = NitroFetchClient.detectCharset(from: http) ?? String.Encoding.utf8
     let bodyStr = String(data: data, encoding: charset) ?? String(data: data, encoding: .utf8)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-fetch",
-  "version": "1.0.3",
+  "version": "1.1.1-alpha.0",
   "description": "Awesome Fetch :)",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",