react-native-nitro-fetch 1.0.2 → 1.1.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/README.md

@@ -0,0 +1,370 @@
+<a href="https://margelo.com">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/margelo/react-native-nitro-fetch/main/assets/banner-dark.png" />
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/margelo/react-native-nitro-fetch/main/assets/banner-light.png" />
+    <img alt="Nitro Modules" src="https://raw.githubusercontent.com/margelo/react-native-nitro-fetch/main/assets/banner-light.png" />
+  </picture>
+</a>
+
+<br />
+
+
+
+**react-native-nitro-fetch** is a general purpose network fetching library for React Native. It can be used as a drop-in replacement for the built-in `fetch(...)` method, as well as provide additional features like prefetching and workletized mappers.
+
+<p align="center">
+  <a href="https://margelo.github.io/react-native-nitro-fetch/"><b>Documentation</b></a>
+</p>
+
+## Features
+
+- 🔧 Drop-in replacement for the built-in `fetch(...)` method
+- ⚡️ Fast HTTP stack using [Cronet](https://chromium.googlesource.com/chromium/src/+/lkgr/components/cronet/README.md) on Android, and [URLSession](https://developer.apple.com/documentation/Foundation/URLSession) on iOS
+- 💪 Supports HTTP/1, HTTP/2 and [HTTP/3](https://en.wikipedia.org/wiki/HTTP/3) over [QUIC](https://www.chromium.org/quic/), [Brotli](https://github.com/google/brotli), and disk cache
+- ⏰ Prefetching on app-startup for even faster initialization
+- 🧵 Worklet support for parallel data mapping without blocking the JS Thread
+- 🔌 Optional **WebSockets** via [`react-native-nitro-websockets`](docs/websockets.md) (see [WebSockets & prewarm](#websockets--prewarm) below)
+- 🔥 Powered by [Nitro Modules](https://github.com/mrousavy/nitro)
+
+## Installation
+
+```sh
+npm i react-native-nitro-fetch react-native-nitro-modules
+```
+
+> [Nitro Modules](https://github.com/mrousavy/nitro) requires react-native 0.75+ or higher
+
+**WebSockets (optional)** — add the companion socket package plus **text decoder** (peer dependency of websockets):
+
+```sh
+npm i react-native-nitro-websockets react-native-nitro-text-decoder
+```
+
+Full setup, native hooks, prewarm, and API details: **[docs/websockets.md](docs/websockets.md)** · UI: [`example/src/screens/WebSocketScreen.tsx`](example/src/screens/WebSocketScreen.tsx) · auth + prewarm: [Token refresh](#token-refresh-cold-start) (example block).
+
+## Usage
+
+To simply fetch data, import the `fetch(...)` method from `react-native-nitro-fetch`:
+
+```ts
+import { fetch } from 'react-native-nitro-fetch'
+
+const res = await fetch('https://httpbin.org/get')
+const json = await res.json()
+```
+
+This can be used as a drop-in-replacement for the built-in `fetch(...)` method.
+
+### Prefetching in JS
+
+You can prefetch a URL in JS, which keeps the result cached for the next actual `fetch(...)` call - this can be used shortly before navigating to a new screen to have results hot & ready:
+
+```ts
+import { prefetch } from 'react-native-nitro-fetch'
+
+await prefetch('https://httpbin.org/uuid', {
+  headers: { prefetchKey: 'uuid' }
+})
+```
+
+Then, on the new screen that was navigated to:
+
+```ts
+import { fetch } from 'react-native-nitro-fetch'
+
+const res = await fetch('https://httpbin.org/uuid', {
+  headers: { prefetchKey: 'uuid' }
+})
+console.log('prefetched header:', res.headers.get('nitroPrefetched'))
+```
+
+### Prefetching for the next app launch
+
+Prefetching data on app launch (or _process start_) will make it hot & ready once your JS code actually runs. Call `prefetchOnAppStart(...)` to enqueue a prefetch for the **next** app start:
+
+```ts
+import { prefetchOnAppStart } from 'react-native-nitro-fetch'
+
+await prefetchOnAppStart('https://httpbin.org/uuid', {
+  prefetchKey: 'uuid'
+})
+```
+
+Then, once the app opens the next time, a call to `fetch(...)` might resolve faster since it will contain already cached results:
+
+```ts
+import { fetch } from 'react-native-nitro-fetch'
+
+const res = await fetch('https://httpbin.org/uuid', {
+  headers: { prefetchKey: 'uuid' }
+})
+console.log('prefetched header:', res.headers.get('nitroPrefetched'))
+```
+
+In our tests, prefetching alone yielded a **~220 ms** faster TTI (time-to-interactive) time! 🤯
+
+### Token refresh (cold start)
+
+When you use **auto-prefetch** (`prefetchOnAppStart`) and/or **WebSocket prewarm on app start** (`react-native-nitro-websockets`), native code runs **before** your JS bundle. If those requests need auth headers, you can register a **token refresh** configuration. On each cold start, native code calls your refresh URL, maps the response into HTTP headers, and merges them into auto-prefetches and/or WebSocket prewarms.
+
+**1. Register the refresh config** (persisted in encrypted native storage):
+
+```ts
+import { registerTokenRefresh } from 'react-native-nitro-fetch'
+
+registerTokenRefresh({
+  target: 'fetch', // 'websocket' | 'fetch' | 'all'
+  url: 'https://api.example.com/oauth/token',
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ grant_type: 'client_credentials' }),
+  responseType: 'json',
+  mappings: [
+    { jsonPath: 'access_token', header: 'Authorization', valueTemplate: 'Bearer {{value}}' },
+  ],
+  // If the refresh request fails:
+  // - 'useStoredHeaders' — use last successful headers from the previous run (default)
+  // - 'skip' — skip auto-prefetch / prewarm entirely when refresh fails
+  onFailure: 'useStoredHeaders',
+})
+```
+
+**Response mapping**
+
+- Default `responseType` is `'json'`. Use **`mappings`** to copy fields from the JSON body into header names (dot paths supported, e.g. `data.token`).
+- Use **`compositeHeaders`** to build a header from a template and multiple JSON paths (`{{placeholder}}` in the template).
+- For a plain-text body, set `responseType: 'text'` and use **`textHeader`** / optional **`textTemplate`** (with `{{value}}`).
+
+
+
+**Example: token refresh + WebSocket prewarm**
+
+```ts
+import { registerTokenRefresh } from 'react-native-nitro-fetch'
+import { prewarmOnAppStart, NitroWebSocket } from 'react-native-nitro-websockets'
+
+const WSS = 'wss://api.example.com/live'
+
+registerTokenRefresh({
+  target: 'websocket', // use 'all' if you also use prefetchOnAppStart with the same token flow
+  url: 'https://api.example.com/oauth/token',
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    grant_type: 'client_credentials',
+    client_id: '…',
+    client_secret: '…',
+  }),
+  mappings: [
+    { jsonPath: 'access_token', header: 'Authorization', valueTemplate: 'Bearer {{value}}' },
+  ],
+})
+
+```
+
+**3. Optional JS helpers**
+
+```ts
+import {
+  callRefreshEndpoint,
+  clearTokenRefresh,
+  getStoredTokenRefreshConfig,
+} from 'react-native-nitro-fetch'
+
+// Same mapping rules as native; uses global fetch from JS
+const headers = await callRefreshEndpoint(config)
+
+// Remove stored config and token caches (scope with 'fetch' | 'websocket' | 'all')
+clearTokenRefresh('fetch')
+
+// Read back what was registered (or null)
+const stored = getStoredTokenRefreshConfig('fetch')
+```
+
+The refresh config and header caches are stored with **platform secure storage** (Android Keystore + encrypted values in `SharedPreferences`, iOS Keychain-backed encryption in the same `UserDefaults` suite as other nitro keys).
+
+### AbortController
+
+Cancel in-flight requests using the standard `AbortController` API:
+
+```ts
+import { fetch } from 'react-native-nitro-fetch'
+
+const controller = new AbortController()
+
+// Abort after 500ms
+setTimeout(() => controller.abort(), 500)
+
+try {
+  const res = await fetch('https://httpbin.org/delay/20', {
+    signal: controller.signal,
+  })
+} catch (e) {
+  if (e.name === 'AbortError') {
+    console.log('Request was cancelled')
+  }
+}
+```
+
+Pre-aborted signals are also supported — the request will throw immediately without making a network call:
+
+```ts
+const controller = new AbortController()
+controller.abort()
+
+await fetch(url, { signal: controller.signal }) // throws AbortError
+```
+
+### FormData
+
+Upload files and form fields using `FormData`:
+
+```ts
+import { fetch } from 'react-native-nitro-fetch'
+
+const fd = new FormData()
+fd.append('username', 'nitro_user')
+fd.append('avatar', {
+  uri: 'file:///path/to/photo.jpg',
+  type: 'image/jpeg',
+  name: 'avatar.jpg',
+} as any)
+
+const res = await fetch('https://httpbin.org/post', {
+  method: 'POST',
+  body: fd,
+})
+const json = await res.json()
+```
+
+### Worklet Mapping
+
+Since Nitro Fetch is a [Nitro Module](https://nitro.margelo.com), it can be used from Worklets.
+This can be useful to parse data without blocking the main JS-Thread:
+
+```ts
+import { nitroFetchOnWorklet } from 'react-native-nitro-fetch'
+
+const data = await nitroFetchOnWorklet(
+  'https://httpbin.org/get',
+  undefined,
+  (payload) => {
+    'worklet'
+    return JSON.parse(payload.bodyString ?? '{}')
+  }
+)
+```
+Before using worklet mapping, install and configure [react-native-worklets](https://docs.swmansion.com/react-native-worklets/docs/).
+
+### Streaming with `TextDecoder` 
+
+Nitro Fetch can also expose an streaming mode that returns a `ReadableStream` body.  
+Combined with [`react-native-nitro-text-decoder`](https://github.com/margelo/react-native-nitro-fetch/tree/main/packages/react-native-nitro-text-decoder), you can incrementally decode UTF‑8 chunks:
+
+```tsx
+import { useRef, useState } from 'react'
+import { fetch as nitroFetch } from 'react-native-nitro-fetch'
+import { TextDecoder } from 'react-native-nitro-text-decoder'
+
+export function StreamingExample() {
+  const [output, setOutput] = useState('')
+  const decoder = useRef(new TextDecoder())
+
+  const append = (text: string) => {
+    setOutput(prev => prev + text)
+  }
+
+  const runStream = async () => {
+    // `stream: true` enables the streaming transport
+    const res = await nitroFetch('https://httpbin.org/stream/20', {
+      stream: true,
+    })
+
+    const reader = res.body?.getReader()
+    if (!reader) {
+      append('No readable stream!')
+      return
+    }
+
+    let chunks = 0
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      chunks++
+      const text = decoder.current.decode(value, { stream: true })
+      append(text)
+    }
+
+    append(`\n\n✅ Done — ${chunks} chunk(s) received`)
+  }
+
+  // Call `runStream()` from a button handler in your UI
+}
+```
+
+### WebSockets & prewarm
+
+Use **[react-native-nitro-websockets](docs/websockets.md)** for `NitroWebSocket` (browser-like API: `onopen`, `onmessage`, `send`, `close`, …). Install **`react-native-nitro-text-decoder`** alongside it — the socket package uses it to decode UTF-8 text frames.
+
+**Prewarm on next launch** — queue URLs from JS so native code can start the handshake before React loads:
+
+```ts
+import {
+  prewarmOnAppStart,
+  removeFromPrewarmQueue,
+  clearPrewarmQueue,
+} from 'react-native-nitro-websockets'
+
+prewarmOnAppStart('wss://echo.websocket.org')
+// optional: prewarmOnAppStart(url, ['subproto'], { Authorization: 'Bearer …' })
+
+clearPrewarmQueue()
+removeFromPrewarmQueue('wss://echo.websocket.org')
+```
+
+On **Android**, call `NitroWebSocketAutoPrewarmer.prewarmOnStart(this)` in `Application.onCreate` (see [example `MainApplication.kt`](example/android/app/src/main/java/nitrofetch/example/MainApplication.kt)). **iOS** picks up the queue via the linked pod.
+
+Authenticated prewarms: use **`registerTokenRefresh`** with `target: 'websocket'` or `'all'` — see [Token refresh (cold start)](#token-refresh-cold-start) for a **small `registerTokenRefresh` + `prewarmOnAppStart` + `NitroWebSocket` example**.
+
+More detail: **[docs/websockets.md](docs/websockets.md)** · UI sample: **[example/src/screens/WebSocketScreen.tsx](example/src/screens/WebSocketScreen.tsx)**.
+
+## Limitations & Alternatives
+
+- **WebSockets** are not part of `react-native-nitro-fetch` itself; use the companion package **[react-native-nitro-websockets](docs/websockets.md)** (with **react-native-nitro-text-decoder**). For other stacks, [react-native-fast-io](https://github.com/callstackincubator/react-native-fast-io) is another option.
+
+## Documentation
+
+- [Getting Started](docs/getting-started.md)
+- [API Reference](docs/api.md)
+- [Android Details](docs/android.md)
+- [iOS Details](docs/ios.md)
+- [Prefetch & Auto-Prefetch](docs/prefetch.md)
+- [WebSockets & prewarm](docs/websockets.md)
+- [Worklets](docs/worklets.md)
+- [Troubleshooting](docs/troubleshooting.md)
+- [Cronet (Android) notes](docs/cronet-android.md)
+- [Cronet (iOS) notes](docs/cronet-ios.md)
+
+## Margelo
+
+Nitro Fetch is built with ❤️ by Margelo.
+We build fast and beautiful apps. Contact us at [margelo.com](https://margelo.com) for high-end consultancy services.
+
+## Contributing
+
+- Development workflow: `CONTRIBUTING.md#development-workflow`
+- Sending a pull request: `CONTRIBUTING.md#sending-a-pull-request`
+- Code of conduct: `CODE_OF_CONDUCT.md`
+
+## Authors
+
+- [Szymon Kapala](https://github.com/Szymon20000)
+- [Alex Shumihin](https://github.com/pioner92)
+- [Ronald Goedeke](https://github.com/ronickg)
+- [Marc Rousavy](https://github.com/mrousavy)
+- [Ritesh Shukla](https://github.com/riteshshukla04)
+
+## License
+
+MIT
+

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

@@ -0,0 +1,132 @@
+package com.margelo.nitro.nitrofetch
+
+/**
+ * Thin facade over React Native's [com.facebook.react.modules.network.InspectorNetworkReporter].
+ * All methods are no-ops when the modern CDP debugger is not attached (guarded by
+ * `isDebuggingEnabled()` inside RN), so they are safe to call in release builds.
+ *
+ * The underlying reporter is marked `internal` in RN but is the officially documented
+ * Kotlin entry point for third-party networking libraries to surface requests in the
+ * Fusebox / RN DevTools Network tab. We intentionally bypass the visibility modifier
+ * rather than duplicating the JNI bindings, matching the pattern used by other
+ * community HTTP clients. If the class isn't present (RN < 0.76 or a trimmed
+ * distribution), every call becomes a no-op.
+ */
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+internal object DevToolsReporter {
+  private val available: Boolean = try {
+    Class.forName("com.facebook.react.modules.network.InspectorNetworkReporter")
+    true
+  } catch (_: Throwable) {
+    false
+  }
+
+  fun isDebuggingEnabled(): Boolean {
+    if (!available) return false
+    return try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.isDebuggingEnabled()
+    } catch (_: Throwable) {
+      false
+    }
+  }
+
+  fun reportRequestStart(
+    requestId: String,
+    url: String,
+    method: String,
+    headers: Map<String, String>,
+    body: String,
+    encodedDataLength: Long
+  ) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestStart(
+        requestId, url, method, headers, body, encodedDataLength
+      )
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportConnectionTiming(requestId, headers)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun reportResponseStart(
+    requestId: String,
+    url: String,
+    statusCode: Int,
+    headers: Map<String, String>,
+    expectedDataLength: Long
+  ) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseStart(
+        requestId, url, statusCode, headers, expectedDataLength
+      )
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun reportDataReceived(requestId: String, length: Int) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportDataReceivedImpl(requestId, length)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun reportResponseEnd(requestId: String, encodedDataLength: Long) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseEnd(requestId, encodedDataLength)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun reportRequestFailed(requestId: String, cancelled: Boolean) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestFailed(requestId, cancelled)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun storeResponseBody(requestId: String, body: String, base64Encoded: Boolean) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBody(
+        requestId, body, base64Encoded
+      )
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun storeResponseBodyIncremental(requestId: String, data: String) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBodyIncremental(requestId, data)
+    } catch (_: Throwable) {
+    }
+  }
+
+  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/NitroFetchClient.kt

@@ -80,10 +80,14 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       if (BuildConfig.NITRO_FETCH_TRACING) {
         Trace.beginAsyncSection(traceLabel, traceCookie)
       }
+      val devToolsRequestId = req.requestId ?: UUID.randomUUID().toString()
+      val devToolsEnabled = DevToolsReporter.isDebuggingEnabled()
       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 +117,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 +139,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 +154,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 +193,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 +203,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 +238,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,14 @@ class NitroUrlRequestBuilder(
 
   private val builder: CronetUrlRequest.Builder
   private val byteBuffer: ByteBuffer
+  private val devToolsRequestId: String = UUID.randomUUID().toString()
+  private val devToolsEnabled: Boolean = DevToolsReporter.isDebuggingEnabled()
+  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 +58,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 +82,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 +104,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 +118,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 +132,9 @@ class NitroUrlRequestBuilder(
         request: CronetUrlRequest,
         info: CronetUrlResponseInfo?
       ) {
+        if (devToolsEnabled) {
+          DevToolsReporter.reportRequestFailed(devToolsRequestId, true)
+        }
         onCanceledCallback?.let { callback ->
           val nitroInfo = info?.toNitro()
           callback(nitroInfo)
@@ -104,11 +146,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 +163,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 +224,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,7 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
 
   private var urlRequest: URLRequest
   private var priority: Float = 0.5
+  private let devToolsRequestId: String = UUID().uuidString
 
   init(
     url: String,
@@ -89,7 +90,8 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
       onFailed: onFailedCallback,
       onCanceled: onCanceledCallback,
       executor: executor,
-      hybridRequest: nil
+      hybridRequest: nil,
+      devToolsRequestId: devToolsRequestId
     )
 
     let config = URLSessionConfiguration.default
@@ -107,6 +109,10 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
     task.priority = priority
     delegate.task = task
 
+    if NitroDevToolsReporter.isDebuggingEnabled() {
+      NitroDevToolsReporter.reportRequestStart(withRequest: devToolsRequestId, request: urlRequest)
+    }
+
     let request = HybridUrlRequest(task: task, delegate: delegate)
     delegate.hybridRequest = request
 
@@ -129,6 +135,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 +147,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 +158,7 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
     self.onCanceled = onCanceled
     self.executor = executor
     self.hybridRequest = hybridRequest
+    self.devToolsRequestId = devToolsRequestId
     super.init()
   }
 
@@ -181,11 +192,17 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
       if let error = error {
         let nsError = error as NSError
         if nsError.code == NSURLErrorCancelled {
+          if NitroDevToolsReporter.isDebuggingEnabled() {
+            NitroDevToolsReporter.reportRequestFailed(self.devToolsRequestId, cancelled: true)
+          }
           if let callback = self.onCanceled {
             let nitroInfo = self.response?.toNitro()
             callback(nitroInfo)
           }
         } else {
+          if NitroDevToolsReporter.isDebuggingEnabled() {
+            NitroDevToolsReporter.reportRequestFailed(self.devToolsRequestId, cancelled: false)
+          }
           if let callback = self.onFailed {
             let nitroError = error.toNitro()
             let nitroInfo = self.response?.toNitro()
@@ -193,6 +210,9 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
           }
         }
       } else if let response = self.response {
+        if NitroDevToolsReporter.isDebuggingEnabled() {
+          NitroDevToolsReporter.reportResponseEnd(self.devToolsRequestId, encodedDataLength: self.devToolsBytes)
+        }
         if let callback = self.onSucceeded {
           let info = response.toNitro()
           callback(info)
@@ -216,6 +236,20 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
 
     executor.sync { [weak self] in
       guard let self = self else { return }
+      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)
+      }
       if let callback = self.onResponseStarted {
         let info = httpResponse.toNitro()
         callback(info)
@@ -234,6 +268,14 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
       executor.sync { [weak self] in
         guard let self = self, let response = self.response else { return }
 
+        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)
+          }
+        }
+
         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,129 @@
+#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
+
+// The Objective-C wrapper does not expose -isDebuggingEnabled publicly,
+// but the underlying C++ NetworkReporter does. We avoid depending on the
+// C++ header and instead rely on RN guarding every report call internally.
+// For our own body-capture short-circuit we assume enabled when the class
+// exists; the underlying calls are still no-ops when no debugger attached.
+
+@implementation NitroDevToolsReporter
+
++ (BOOL)isDebuggingEnabled {
+#if NITRO_HAS_NETWORK_REPORTER
+  return YES;
+#else
+  return NO;
+#endif
+}
+
++ (void)reportRequestStartWithRequest:(NSString *)requestId
+                              request:(NSURLRequest *)request {
+#if NITRO_HAS_NETWORK_REPORTER
+  if (request == nil) return;
+  int encoded = (int)(request.HTTPBody.length);
+  [RCTInspectorNetworkReporter reportRequestStart:requestId request:request encodedDataLength:encoded];
+  [RCTInspectorNetworkReporter 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
+  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;
+  [RCTInspectorNetworkReporter reportRequestStart:requestId request:req encodedDataLength:(int)encoded];
+  [RCTInspectorNetworkReporter 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
+  NSURL *u = [NSURL URLWithString:url];
+  if (u == nil) return;
+  NSHTTPURLResponse *resp = [[NSHTTPURLResponse alloc] initWithURL:u
+                                                         statusCode:statusCode
+                                                        HTTPVersion:@"HTTP/1.1"
+                                                       headerFields:headers];
+  [RCTInspectorNetworkReporter 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;
+  // 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];
+  [RCTInspectorNetworkReporter reportDataReceived:requestId data:sized];
+#endif
+}
+
++ (void)reportResponseEnd:(NSString *)requestId encodedDataLength:(NSInteger)length {
+#if NITRO_HAS_NETWORK_REPORTER
+  [RCTInspectorNetworkReporter reportResponseEnd:requestId encodedDataLength:(int)length];
+#endif
+}
+
++ (void)reportRequestFailed:(NSString *)requestId cancelled:(BOOL)cancelled {
+#if NITRO_HAS_NETWORK_REPORTER
+  [RCTInspectorNetworkReporter reportRequestFailed:requestId cancelled:cancelled];
+#endif
+}
+
++ (void)storeResponseBody:(NSString *)requestId
+                     data:(NSData *)data
+            base64Encoded:(BOOL)base64Encoded {
+#if NITRO_HAS_NETWORK_REPORTER
+  [RCTInspectorNetworkReporter maybeStoreResponseBody:requestId data:data base64Encoded:base64Encoded];
+#endif
+}
+
++ (void)storeResponseBodyIncremental:(NSString *)requestId text:(NSString *)text {
+#if NITRO_HAS_NETWORK_REPORTER
+  [RCTInspectorNetworkReporter 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,26 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
                 "%{public}s %{public}s", traceMethod, tracePath)
     #endif
 
-    let (data, response) = try await session.data(for: urlRequest, delegate: delegate)
+    let devToolsId = req.requestId ?? UUID().uuidString
+    if NitroDevToolsReporter.isDebuggingEnabled() {
+      NitroDevToolsReporter.reportRequestStart(withRequest: devToolsId, request: urlRequest)
+    }
+
+    let data: Data
+    let response: URLResponse
+    do {
+      (data, response) = try await session.data(for: urlRequest, delegate: delegate)
+    } catch {
+      if NitroDevToolsReporter.isDebuggingEnabled() {
+        let cancelled = (error as NSError).code == NSURLErrorCancelled
+        NitroDevToolsReporter.reportRequestFailed(devToolsId, cancelled: cancelled)
+      }
+      throw error
+    }
     guard let http = response as? HTTPURLResponse else {
+      if NitroDevToolsReporter.isDebuggingEnabled() {
+        NitroDevToolsReporter.reportRequestFailed(devToolsId, cancelled: false)
+      }
       throw NSError(domain: "NitroFetch", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])
     }
 
@@ -180,6 +198,26 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
       return NitroHeader(key: key, value: String(describing: v))
     }
 
+    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)
+    }
+
     // 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.2",
+  "version": "1.1.0",
   "description": "Awesome Fetch :)",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
@@ -47,7 +47,9 @@
     "prepare": "bob build",
     "build:plugin": "cd expo/plugins && npx tsc",
     "nitrogen": "nitrogen",
-    "release": "npm run build:plugin && release-it --only-version"
+    "release": "npm run build:plugin && release-it --only-version",
+    "prepack": "cp ../../README.md ./README.md",
+    "postpack": "rm -f ./README.md"
   },
   "keywords": [
     "react-native",