@swmansion/argent 0.29.1-next.20 → 0.29.1-next.21

package/dist/tool-server.cjs

@@ -11384,11 +11384,11 @@ var init_nl = __esm({
           case "too_small": {
             const adj = issue2.inclusive ? ">=" : ">";
             const sizing = getSizing(issue2.origin);
-            const shortName = issue2.origin === "date" ? "vroeg" : issue2.origin === "string" ? "kort" : "klein";
+            const shortName2 = issue2.origin === "date" ? "vroeg" : issue2.origin === "string" ? "kort" : "klein";
             if (sizing) {
-              return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
+              return `Te ${shortName2}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
             }
-            return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`;
+            return `Te ${shortName2}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`;
           }
           case "invalid_format": {
             const _issue = issue2;
@@ -100666,7 +100666,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = (0, import_node_crypto3.randomUUID)();
 function readCliVersion() {
   if (true) {
-    return "0.29.1-next.20";
+    return "0.29.1-next.21";
   }
   return "0.0.0";
 }
@@ -111742,10 +111742,10 @@ var PublishError = class _PublishError {
   requestId;
   errorCode;
   reasonPhrase;
-  constructor({ requestId, errorCode, reasonPhrase }) {
+  constructor({ requestId, errorCode, reasonPhrase: reasonPhrase2 }) {
     this.requestId = requestId;
     this.errorCode = errorCode;
-    this.reasonPhrase = reasonPhrase;
+    this.reasonPhrase = reasonPhrase2;
   }
   async #encode(w) {
     await w.u62(this.requestId);
@@ -111761,8 +111761,8 @@ var PublishError = class _PublishError {
   static async #decode(r) {
     const requestId = await r.u62();
     const errorCode = Number(await r.u62());
-    const reasonPhrase = await r.string();
-    return new _PublishError({ requestId, errorCode, reasonPhrase });
+    const reasonPhrase2 = await r.string();
+    return new _PublishError({ requestId, errorCode, reasonPhrase: reasonPhrase2 });
   }
 };
 var PublishDone = class _PublishDone {
@@ -111770,10 +111770,10 @@ var PublishDone = class _PublishDone {
   requestId;
   statusCode;
   reasonPhrase;
-  constructor({ requestId, statusCode, reasonPhrase }) {
+  constructor({ requestId, statusCode, reasonPhrase: reasonPhrase2 }) {
     this.requestId = requestId;
     this.statusCode = statusCode;
-    this.reasonPhrase = reasonPhrase;
+    this.reasonPhrase = reasonPhrase2;
   }
   async #encode(w, version3) {
     if (version3 === Version.DRAFT_14 || version3 === Version.DRAFT_15 || version3 === Version.DRAFT_16) {
@@ -111795,8 +111795,8 @@ var PublishDone = class _PublishDone {
     const requestId = version3 === Version.DRAFT_14 || version3 === Version.DRAFT_15 || version3 === Version.DRAFT_16 ? await r.u62() : void 0;
     const statusCode = Number(await r.u62());
     await r.u62();
-    const reasonPhrase = await r.string();
-    return new _PublishDone({ requestId, statusCode, reasonPhrase });
+    const reasonPhrase2 = await r.string();
+    return new _PublishDone({ requestId, statusCode, reasonPhrase: reasonPhrase2 });
   }
 };
 
@@ -111876,10 +111876,10 @@ var PublishNamespaceError = class _PublishNamespaceError {
   requestId;
   errorCode;
   reasonPhrase;
-  constructor({ requestId, errorCode, reasonPhrase }) {
+  constructor({ requestId, errorCode, reasonPhrase: reasonPhrase2 }) {
     this.requestId = requestId;
     this.errorCode = errorCode;
-    this.reasonPhrase = reasonPhrase;
+    this.reasonPhrase = reasonPhrase2;
   }
   async #encode(w) {
     await w.u62(this.requestId);
@@ -111895,8 +111895,8 @@ var PublishNamespaceError = class _PublishNamespaceError {
   static async #decode(r) {
     const requestId = await r.u62();
     const errorCode = Number(await r.u62());
-    const reasonPhrase = await r.string();
-    return new _PublishNamespaceError({ requestId, errorCode, reasonPhrase });
+    const reasonPhrase2 = await r.string();
+    return new _PublishNamespaceError({ requestId, errorCode, reasonPhrase: reasonPhrase2 });
   }
 };
 var PublishNamespaceDone = class _PublishNamespaceDone {
@@ -112249,10 +112249,10 @@ var RequestError = class _RequestError {
   errorCode;
   reasonPhrase;
   retryInterval;
-  constructor({ requestId, errorCode, reasonPhrase, retryInterval = 0n }) {
+  constructor({ requestId, errorCode, reasonPhrase: reasonPhrase2, retryInterval = 0n }) {
     this.requestId = requestId;
     this.errorCode = errorCode;
-    this.reasonPhrase = reasonPhrase;
+    this.reasonPhrase = reasonPhrase2;
     this.retryInterval = retryInterval;
   }
   async #encode(w, version3) {
@@ -112274,8 +112274,8 @@ var RequestError = class _RequestError {
     const requestId = version3 === Version.DRAFT_14 || version3 === Version.DRAFT_15 || version3 === Version.DRAFT_16 ? await r.u62() : void 0;
     const errorCode = Number(await r.u62());
     const retryInterval = version3 === Version.DRAFT_14 || version3 === Version.DRAFT_15 ? 0n : await r.u62();
-    const reasonPhrase = await r.string();
-    return new _RequestError({ requestId, errorCode, reasonPhrase, retryInterval });
+    const reasonPhrase2 = await r.string();
+    return new _RequestError({ requestId, errorCode, reasonPhrase: reasonPhrase2, retryInterval });
   }
   static async decode(r, version3) {
     return decode7(r, (rd) => _RequestError.#decode(rd, version3));
@@ -112488,10 +112488,10 @@ var SubscribeError = class _SubscribeError {
   requestId;
   errorCode;
   reasonPhrase;
-  constructor({ requestId, errorCode, reasonPhrase }) {
+  constructor({ requestId, errorCode, reasonPhrase: reasonPhrase2 }) {
     this.requestId = requestId;
     this.errorCode = errorCode;
-    this.reasonPhrase = reasonPhrase;
+    this.reasonPhrase = reasonPhrase2;
   }
   async #encode(w) {
     await w.u62(this.requestId);
@@ -112507,8 +112507,8 @@ var SubscribeError = class _SubscribeError {
   static async #decode(r) {
     const requestId = await r.u62();
     const errorCode = Number(await r.u62());
-    const reasonPhrase = await r.string();
-    return new _SubscribeError({ requestId, errorCode, reasonPhrase });
+    const reasonPhrase2 = await r.string();
+    return new _SubscribeError({ requestId, errorCode, reasonPhrase: reasonPhrase2 });
   }
 };
 var SubscribeUpdate = class _SubscribeUpdate {
@@ -114177,16 +114177,16 @@ var Subscriber2 = class {
     console.debug(`subscribe written: id=${requestId} broadcast=${broadcast} track=${request3.name}`);
     const respTypeId = await state3.stream.reader.u53();
     if (respTypeId !== SubscribeOk.id) {
-      let reasonPhrase = "unknown error";
+      let reasonPhrase2 = "unknown error";
       try {
         if (respTypeId === RequestError.id) {
           const err = version3 === Version.DRAFT_14 ? await SubscribeError.decode(state3.stream.reader, version3) : await RequestError.decode(state3.stream.reader, version3);
-          reasonPhrase = `code=${err.errorCode} reason=${err.reasonPhrase}`;
+          reasonPhrase2 = `code=${err.errorCode} reason=${err.reasonPhrase}`;
         }
       } catch {
       }
       state3.rejected = true;
-      throw new Error(`SUBSCRIBE error: ${reasonPhrase}`);
+      throw new Error(`SUBSCRIBE error: ${reasonPhrase2}`);
     }
     const ok = await SubscribeOk.decode(state3.stream.reader, version3);
     try {
@@ -133157,8 +133157,8 @@ var nativeNetworkLogsTool = {
   },
   capability: { apple: { simulator: true }, appleRemote: { simulator: true } },
   description: `Retrieve network requests captured at the native NSURLProtocol level. 
-Unlike the JS-level network inspector (view-network-logs), this captures ALL network traffic from the app including native modules, Swift/Objective-C networking, and background transfers that bypass JS fetch. 
-Use when you need to inspect native-level HTTP traffic that is invisible to JS fetch interception. 
+Unlike the JS-level network inspector (view-network-logs), this captures ALL network traffic from the app including native modules, Swift/Objective-C networking, and background transfers that never pass through JS XMLHttpRequest or fetch. 
+Use when you need to inspect native-level HTTP traffic that is invisible to the JS-level capture. 
 Returns { status, count, events } where each event contains URL, method, status code, headers, and timing.
 If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help. Restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting. Do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised. Follow the message (re-boot the simulator) rather than retrying this tool.
 A not-running app comes back as one of those statuses rather than a failure. An app that is not connected does too, except on a device whose devtools agent argent attached to rather than armed itself: there it fails with \`NATIVE_DEVTOOLS_NOT_CONNECTED\`, since no restart of ours can complete a handshake we do not own. Failures are separate: an Apple system app is rejected outright (terminal: never retry it), while a missing host dependency or a udid that is not an Apple device is not.`,
@@ -134237,116 +134237,1038 @@ init_src2();
 
 // ../tool-server/src/utils/debugger/scripts/network-interceptor.ts
 var NETWORK_INTERCEPTOR_SCRIPT = `(function() {
-  if (globalThis.__argent_network_installed) return JSON.stringify({ installed: false, reason: 'already installed' });
-  globalThis.__argent_network_installed = true;
+  var g = globalThis;
+  if (g.__argent_network_v2) return JSON.stringify({ installed: false, reason: 'already installed' });
+  g.__argent_network_v2 = true;
+  // The previous fetch-only script, injected by an older tool-server before an upgrade, stays
+  // installed until the app reloads. Its fetch wrapper keeps the buffers below in a closure, so
+  // empty them and stop them from growing: it then still reads each response, but keeps nothing.
+  if (g.__argent_network_installed && Array.isArray(g.__argent_network_log)) {
+    var oldLog = g.__argent_network_log;
+    oldLog.length = 0;
+    oldLog.push = function() { return 0; };
+    var oldById = g.__argent_network_by_id;
+    if (oldById && typeof oldById === 'object') {
+      for (var oldKey in oldById) delete oldById[oldKey];
+      Object.freeze(oldById);
+    }
+  }
+  // The previous fetch-only script checks this flag; setting it stops an older tool-server
+  // from replacing the buffer below with its own.
+  g.__argent_network_installed = true;
+
+  var MAX_ENTRIES = 2000;
+  var BODY_CAP = 1048576;
+  var BUFFER_CAP = 52428800;
+  var hasOwn = Object.prototype.hasOwnProperty;
 
   var log = [];
-  globalThis.__argent_network_log = log;
   var byId = {};
-  globalThis.__argent_network_by_id = byId;
-  var nextReqId = 1;
-  var MAX_ENTRIES = 2000;
-  function genId() { return 'rn-net-' + (nextReqId++); }
-  function ts() { return Date.now() / 1000; }
+  g.__argent_network_log = log;
+  g.__argent_network_by_id = byId;
+  var nextId = 1;
+  var bufferedChars = 0;
+  // Above zero while an XHR is sent: the request React Native's network module gets then is the
+  // XHR's, which has its record.
+  var xhrSending = 0;
 
-  function getOrCreate(reqId) {
-    if (byId[reqId]) return byId[reqId];
-    var entry = {
-      id: log.length,
-      requestId: reqId,
-      state: 'pending'
+  function bodyChars(entry) {
+    return (entry.responseBody ? entry.responseBody.length : 0) +
+      (entry.request.postData ? entry.request.postData.length : 0) +
+      (entry.bodyBytes ? entry.bodyBytes.byteLength : 0) + (entry.postBytes ? entry.postBytes.byteLength : 0) +
+      (entry.bodyBase64 ? entry.bodyBase64.length : 0);
+  }
+
+  function evict() {
+    while (log.length > MAX_ENTRIES || (bufferedChars > BUFFER_CAP && log.length > 0)) {
+      var removed = log.shift();
+      bufferedChars -= bodyChars(removed);
+      delete byId[removed.requestId];
+    }
+  }
+
+  // Runs on the app's JS thread for every text response. The loop costs about 200 ms per MiB in
+  // Hermes with a debugger attached, so the native checks go first.
+  function utf8Length(text) {
+    try {
+      if (/^[\\x00-\\x7f]*$/.test(text)) return text.length;
+      if (typeof TextEncoder === 'function') return new TextEncoder().encode(text).length;
+    } catch (e) {}
+    var n = 0;
+    for (var i = 0; i < text.length; i++) {
+      var c = text.charCodeAt(i);
+      if (c < 0x80) n += 1;
+      else if (c < 0x800) n += 2;
+      else if (c >= 0xd800 && c <= 0xdbff && i + 1 < text.length &&
+        text.charCodeAt(i + 1) >= 0xdc00 && text.charCodeAt(i + 1) <= 0xdfff) { n += 4; i++; }
+      else n += 3;
+    }
+    return n;
+  }
+
+  // The UTF-8 size of a text body the interceptor keeps whole. A longer body is cut, and its size
+  // is recorded in characters (bodyLength) instead: counting its bytes would take the app's JS
+  // thread a time that grows with the body.
+  function textSize(text) {
+    return text.length > BODY_CAP ? undefined : utf8Length(text);
+  }
+
+  // A body of one of these types is not text: its size is recorded and it is not read as text.
+  var BINARY_TYPES = /^(image\\/(?!svg)|audio\\/|video\\/|font\\/|application\\/(octet-stream|pdf|zip|gzip|wasm|x-protobuf)$)/;
+  function isBinaryType(mime) {
+    return typeof mime === 'string' && BINARY_TYPES.test(mime.toLowerCase());
+  }
+
+  function mimeTypeOf(headers) {
+    return hasOwn.call(headers, 'content-type') ? String(headers['content-type']).split(';')[0].trim() : '';
+  }
+
+  // The headers of every HeadersInit form: [name, value] pairs (an array or another iterable), a
+  // Headers or Map, or a plain object. A name given twice keeps both values.
+  function headersObject(source) {
+    var out = {};
+    if (!source || typeof source !== 'object') return out;
+    var add = function(name, value) {
+      name = String(name);
+      out[name] = hasOwn.call(out, name) ? out[name] + ', ' + String(value) : String(value);
     };
+    try {
+      // A Headers and a Map iterate as pairs too.
+      if (Array.isArray(source) || (typeof Symbol === 'function' && typeof source[Symbol.iterator] === 'function')) {
+        var pairs = Array.from(source);
+        for (var i = 0; i < pairs.length; i++) {
+          if (pairs[i] && typeof pairs[i] === 'object' && pairs[i].length === 2) add(pairs[i][0], pairs[i][1]);
+        }
+      } else if (typeof source.forEach === 'function') {
+        source.forEach(function(value, name) { add(name, value); });
+      } else {
+        for (var k in source) if (hasOwn.call(source, k)) add(k, source[k]);
+      }
+    } catch (e) {}
+    return out;
+  }
+
+  function parseHeaders(raw) {
+    var out = {};
+    if (typeof raw !== 'string') return out;
+    var lines = raw.split(/\\r?\\n/);
+    for (var i = 0; i < lines.length; i++) {
+      var at = lines[i].indexOf(':');
+      if (at <= 0) continue;
+      var name = lines[i].slice(0, at).trim().toLowerCase();
+      var value = lines[i].slice(at + 1).trim();
+      out[name] = hasOwn.call(out, name) ? out[name] + ', ' + value : value;
+    }
+    return out;
+  }
+
+  function describeFormData(form) {
+    var parts = [];
+    function file(value) {
+      return '<file' + (value && value.name ? ' ' + value.name : '') + (value && value.type ? ' ' + value.type : '') + '>';
+    }
+    // React Native's FormData lists its parts through getParts().
+    var list = form.getParts();
+    for (var i = 0; i < list.length; i++) {
+      parts.push(list[i].fieldName + '=' + (typeof list[i].string === 'string' ? list[i].string : file(list[i])));
+    }
+    return '[FormData] ' + parts.join('; ');
+  }
+
+  // The text of UTF-8 bytes, cut at BODY_CAP on a character boundary; undefined when they are not
+  // UTF-8 or no decoder exists (React Native has none; Expo installs one).
+  function utf8Text(bytes) {
+    if (typeof TextDecoder !== 'function') return undefined;
+    var end = Math.min(bytes.byteLength, BODY_CAP);
+    if (end < bytes.byteLength) while (end > 0 && (bytes[end] & 0xc0) === 0x80) end--;
+    try { return new TextDecoder('utf-8', { fatal: true }).decode(bytes.subarray(0, end)); } catch (e) { return undefined; }
+  }
+
+  // Bodies of bytes are kept as bytes, 3 past the cap to let utf8Text step back to a character
+  // boundary, and decoded only when the agent reads the record: Expo SDK 54 and 55 install a
+  // TextDecoder written in JS, which would stop the app's JS thread for each request.
+  // A copy even of a subclass whose slice() returns a view (the Buffer of the buffer package).
+  function keepBytes(bytes) {
+    return Uint8Array.prototype.slice.call(bytes, 0, BODY_CAP + 3);
+  }
+
+  // The bytes of base64 text, which a response of React Native's network module can come as.
+  var base64Values = null;
+  function base64Bytes(text) {
+    if (!base64Values) {
+      base64Values = {};
+      var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+      for (var d = 0; d < 64; d++) base64Values[digits.charAt(d)] = d;
+    }
+    var out = new Uint8Array(Math.floor(text.length * 3 / 4));
+    var n = 0, bits = 0, acc = 0;
+    for (var i = 0; i < text.length; i++) {
+      var v = base64Values[text.charAt(i)];
+      if (v === undefined) continue;
+      acc = (acc << 6) | v;
+      bits += 6;
+      if (bits >= 8) {
+        bits -= 8;
+        out[n++] = (acc >> bits) & 0xff;
+        acc &= (1 << bits) - 1;
+      }
+    }
+    return out.subarray(0, n);
+  }
+
+  function decodeBodies(entry) {
+    if (!entry.postBytes && !entry.bodyBytes && entry.bodyBase64 === undefined) return;
+    var before = bodyChars(entry);
+    if (entry.bodyBase64 !== undefined) {
+      entry.bodyBytes = base64Bytes(entry.bodyBase64);
+      delete entry.bodyBase64;
+    }
+    if (entry.postBytes) {
+      // Expo hands its native request the body as bytes: they show as text when they are UTF-8.
+      var post = utf8Text(entry.postBytes);
+      entry.request.postData = post === undefined ? '[binary ' + entry.postSize + ' bytes]' : post;
+      if (post !== undefined && entry.postSize > BODY_CAP) entry.request.postDataTruncated = true;
+      delete entry.postBytes;
+      delete entry.postSize;
+    }
+    if (entry.bodyBytes) {
+      var body = utf8Text(entry.bodyBytes);
+      if (body !== undefined) {
+        entry.responseBody = body;
+        if (entry.encodedDataLength > BODY_CAP) entry.bodyTruncated = true;
+      } else if (typeof TextDecoder === 'function') {
+        // Bytes that are not UTF-8.
+        entry.bodyOmitted = true;
+      }
+      delete entry.bodyBytes;
+    }
+    bufferedChars += bodyChars(entry) - before;
+    evict();
+  }
+  g.__argent_network_decode = decodeBodies;
+
+  // What a request body shows, and whether that is only its start.
+  function describeBody(body) {
+    var text;
+    try {
+      if (body == null) return undefined;
+      if (typeof body === 'string') text = body;
+      else if (typeof FormData === 'function' && body instanceof FormData) text = describeFormData(body);
+      else if (typeof Blob === 'function' && body instanceof Blob) text = '[Blob ' + body.size + ' bytes]';
+      else if (typeof Uint8Array === 'function' && body instanceof Uint8Array) return { bytes: keepBytes(body), size: body.byteLength };
+      else if (typeof ArrayBuffer === 'function' && (body instanceof ArrayBuffer || ArrayBuffer.isView(body))) {
+        text = '[binary ' + body.byteLength + ' bytes]';
+      }
+    } catch (e) {}
+    if (text === undefined) return undefined;
+    return text.length > BODY_CAP ? { text: text.slice(0, BODY_CAP), cut: true } : { text: text, cut: false };
+  }
+
+  function createRecord(resourceType, method, url, headers, body, startedAt) {
+    var id = nextId++;
+    var entry = {
+      id: id,
+      requestId: 'rn-net-' + id,
+      state: 'pending',
+      resourceType: resourceType,
+      request: { url: url, method: method, headers: headers },
+      timestamp: startedAt / 1000
+    };
+    var postData = describeBody(body);
+    if (postData && postData.bytes) {
+      entry.postBytes = postData.bytes;
+      entry.postSize = postData.size;
+    } else if (postData) {
+      entry.request.postData = postData.text;
+      if (postData.cut) entry.request.postDataTruncated = true;
+    }
     log.push(entry);
-    byId[reqId] = entry;
-    if (log.length > MAX_ENTRIES) {
-      var removed = log.splice(0, log.length - MAX_ENTRIES);
-      for (var i = 0; i < removed.length; i++) {
-        delete byId[removed[i].requestId];
-      }
-    }
-    return entry;
-  }
-
-  // \u2500\u2500 Patch fetch \u2500\u2500
-  var origFetch = globalThis.fetch;
-  if (origFetch) {
-    globalThis.fetch = function(input, init) {
-      var reqId = genId();
-      var method = (init && init.method) ? init.method.toUpperCase() : 'GET';
-      var url = typeof input === 'string' ? input : (input && input.url ? input.url : String(input));
-      var headers = {};
-      if (init && init.headers) {
-        if (typeof init.headers.forEach === 'function') {
-          init.headers.forEach(function(v, k) { headers[k] = v; });
-        } else if (typeof init.headers === 'object') {
-          var ks = Object.keys(init.headers);
-          for (var i = 0; i < ks.length; i++) { headers[ks[i]] = String(init.headers[ks[i]]); }
-        }
-      }
-      var postData = (init && init.body && typeof init.body === 'string') ? init.body : undefined;
-      var t = ts();
-
-      var entry = getOrCreate(reqId);
-      entry.request = { url: url, method: method, headers: headers, postData: postData };
-      entry.timestamp = t;
-      entry.wallTime = t;
-      entry.resourceType = 'Fetch';
-
-      return origFetch.apply(globalThis, arguments).then(function(response) {
-        var respHeaders = {};
-        if (response.headers && typeof response.headers.forEach === 'function') {
-          response.headers.forEach(function(v, k) { respHeaders[k] = v; });
-        }
-        var contentType = respHeaders['content-type'] || '';
-        var mimeType = contentType.split(';')[0].trim();
-
-        entry.response = {
-          url: response.url || url,
-          status: response.status,
-          statusText: response.statusText || '',
-          headers: respHeaders,
-          mimeType: mimeType
+    byId[entry.requestId] = entry;
+    bufferedChars += bodyChars(entry);
+    evict();
+    return { entry: entry, startedAt: startedAt };
+  }
+
+  function setResponse(rec, url, status, statusText, headers) {
+    var e = rec.entry;
+    e.response = { url: url || e.request.url, status: status, statusText: statusText || '', headers: headers, mimeType: mimeTypeOf(headers) };
+  }
+
+  // A response header, by its name in lower case.
+  function headerValue(response, wanted) {
+    var headers = response && response.headers;
+    if (!headers) return undefined;
+    for (var name in headers) {
+      if (hasOwn.call(headers, name) && name.toLowerCase() === wanted) return String(headers[name]);
+    }
+    return undefined;
+  }
+
+  // The Content-Length of a response, when it gives the size of the body the app gets. With a
+  // Content-Encoding (gzip, br) it is the compressed size, which iOS keeps on the decoded response.
+  function contentLength(response) {
+    var encoding = headerValue(response, 'content-encoding');
+    if (encoding !== undefined && encoding.trim().toLowerCase() !== 'identity' && encoding.trim() !== '') return undefined;
+    var value = headerValue(response, 'content-length');
+    var n = Number(value);
+    return value !== undefined && value !== '' && n >= 0 && Math.floor(n) === n ? n : undefined;
+  }
+
+  function isBinaryResponse(rec) {
+    return !!rec.entry.response && isBinaryType(rec.entry.response.mimeType);
+  }
+
+  // The size of a text body, unless the body is binary: its text is then not stored (see storeBody).
+  function textSizeOf(rec, text) {
+    return isBinaryResponse(rec) ? undefined : textSize(text);
+  }
+
+  // Records a body that is not kept, once: the details show its size instead.
+  function omitBody(rec, byteLength) {
+    var e = rec.entry;
+    if (e.responseBody !== undefined || e.encodedDataLength !== undefined || e.bodyOmitted) return;
+    e.bodyOmitted = true;
+    if (typeof byteLength === 'number') e.encodedDataLength = byteLength;
+  }
+
+  // Stores the body of a response, once: text, or bytes that keepBytes cut.
+  function storeBody(rec, body, byteLength, truncated) {
+    var e = rec.entry;
+    if (e.responseBody !== undefined || e.encodedDataLength !== undefined || e.bodyOmitted) return;
+    if (typeof body === 'string' && isBinaryResponse(rec)) {
+      // A binary body read as text (an XHR's default responseType, Expo's text()) is not that text.
+      // Its size is the one the server gave, else the length of the text, close to it: a byte that is
+      // not UTF-8 reads as one character.
+      var declared = e.state === 'failed' ? undefined : contentLength(e.response);
+      omitBody(rec, declared);
+      if (declared === undefined) e.bodyLength = body.length;
+      return;
+    }
+    if (body instanceof Uint8Array && isBinaryResponse(rec)) return omitBody(rec, byteLength);
+    if (typeof byteLength === 'number') e.encodedDataLength = byteLength;
+    if (body instanceof Uint8Array) {
+      e.bodyBytes = body;
+      if (byId[e.requestId] === e) { bufferedChars += body.byteLength; evict(); }
+    } else if (typeof body === 'string') {
+      if (body.length > BODY_CAP) {
+        // A cut body is not counted (see textSize): its size is the one the server gave, if any.
+        e.bodyLength = body.length;
+        if (e.encodedDataLength === undefined) e.encodedDataLength = contentLength(e.response);
+        body = body.slice(0, BODY_CAP);
+        truncated = true;
+      }
+      e.responseBody = body;
+      if (truncated) e.bodyTruncated = true;
+      if (byId[e.requestId] === e) { bufferedChars += body.length; evict(); }
+    }
+  }
+
+  // Ends a request that got a response and stores its body. A request that failed meanwhile (the
+  // app aborted it while its body was read) stays failed.
+  function complete(rec, body, byteLength, truncated) {
+    if (rec.entry.state === 'failed') return;
+    storeBody(rec, body, byteLength, truncated);
+    rec.entry.state = 'finished';
+  }
+
+  function fail(rec, errorText) {
+    var e = rec.entry;
+    e.state = 'failed';
+    e.errorText = errorText;
+    e.durationMs = Date.now() - rec.startedAt;
+  }
+
+  // \u2500\u2500 XMLHttpRequest \u2500\u2500
+  var XHR = g.XMLHttpRequest;
+  if (typeof XHR === 'function') {
+    var slots = new WeakMap();
+    // The record and the end handler of each XHR's live request.
+    var live = new WeakMap();
+    var proto = XHR.prototype;
+    var origOpen = proto.open;
+    var origSetRequestHeader = proto.setRequestHeader;
+    var origSend = proto.send;
+    var origAbort = proto.abort;
+
+    var onHeaders = function(xhr, rec) {
+      var raw;
+      try { raw = xhr.getAllResponseHeaders(); } catch (e) {}
+      setResponse(rec, xhr.responseURL, xhr.status, xhr.statusText, parseHeaders(raw));
+    };
+
+    // React Native's fetch is whatwg-fetch over XHR. Each call builds a Request of whatwg-fetch, whose
+    // constructor ends with _initBody, and then, in the same synchronous run, opens its XHR with that
+    // Request's method and URL. Its Request class is the global one, so wrapping _initBody marks the
+    // Request of each call, also of a fetch the app captured before the install, and the next open
+    // that matches it, before the run ends, is the call's XHR. Any other XHR is the app's own, even
+    // one that reads its response as a blob.
+    var fetchRequest = null;
+    var knowsFetch = false;
+    try {
+      var requestProto = typeof g.Request === 'function' && g.Request.prototype;
+      if (requestProto && hasOwn.call(requestProto, '_initBody') && typeof requestProto._initBody === 'function' &&
+        typeof Promise === 'function') {
+        var origInitBody = requestProto._initBody;
+        var markFetch = function() {
+          fetchRequest = this;
+          var marked = this;
+          Promise.resolve().then(function() { if (fetchRequest === marked) fetchRequest = null; });
+          return origInitBody.apply(this, arguments);
         };
+        requestProto._initBody = markFetch;
+        knowsFetch = requestProto._initBody === markFetch;
+      }
+    } catch (e) {}
+    // Without that Request class, an XHR shaped as React Native's fetch sends it: it reads every
+    // response as a blob (as an arraybuffer where Blob is unavailable) and sets these handlers.
+    // axios sets onloadend, not onload.
+    var isFetchXhr = function(xhr, slot) {
+      if (knowsFetch) return slot.fetch;
+      return (xhr.responseType === 'blob' || xhr.responseType === 'arraybuffer') && typeof xhr.onload === 'function' &&
+        typeof xhr.onabort === 'function' && typeof xhr.ontimeout === 'function';
+    };
+
+    var isBinaryBlob = function(rec, blob) {
+      var mime = rec.entry.response && rec.entry.response.mimeType;
+      try { if (!mime) mime = blob.type; } catch (e) {}
+      return isBinaryType(mime);
+    };
+
+    // iOS resolves readAsText with null when the cut splits a UTF-8 character, so step back a
+    // byte at a time, at most 3 times.
+    // The size is read up front: RN's Blob throws on every access once the app closes it.
+    // cutOf(end), when given, makes the start of the blob that is read instead of a slice.
+    var readBlob = function(rec, blob, size, end, cutOf) {
+      if (end === Math.min(size, BODY_CAP) && isBinaryBlob(rec, blob)) {
+        omitBody(rec, size);
+        return complete(rec, undefined, size, false);
+      }
+      var part = end < size ? (cutOf ? cutOf(end) : blob.slice(0, end)) : blob;
+      // A slice holds its own reference to the native blob: release it, so the app's close() frees it.
+      var release = function() { if (part !== blob && !cutOf) part.close(); };
+      var reader = new FileReader();
+      reader.onload = function() {
+        release();
+        if (typeof reader.result === 'string' || part === blob || end <= BODY_CAP - 3) {
+          return complete(rec, reader.result, size, part !== blob);
+        }
+        // The app may have closed the blob since the first read.
+        try { readBlob(rec, blob, size, end - 1, cutOf); } catch (e) { complete(rec, undefined, size, false); }
+      };
+      reader.onerror = function() {
+        release();
+        complete(rec, undefined, size, false);
+      };
+      reader.readAsText(part);
+    };
+
+    var readBody = function(rec, xhr) {
+      var type = xhr.responseType || '';
+      if (type === '' || type === 'text') {
+        var text = xhr.responseText;
+        if (typeof text === 'string') return complete(rec, text, textSizeOf(rec, text), false);
+      } else if (type === 'json') {
+        // React Native keeps the text it received, which spares a serialization of the whole object.
+        var raw = xhr._response;
+        if (typeof raw === 'string') return complete(rec, raw, textSize(raw), false);
+        var json = xhr.response == null ? undefined : JSON.stringify(xhr.response);
+        // Re-serialized, so its length is not the size received: record no size.
+        if (typeof json === 'string') return complete(rec, json, undefined, false);
+      } else if (type === 'arraybuffer') {
+        // Kept as bytes like Expo's bodies, and decoded when the agent reads the record.
+        var buffer = xhr.response;
+        if (buffer && typeof buffer.byteLength === 'number') return complete(rec, keepBytes(new Uint8Array(buffer)), buffer.byteLength);
+      } else if (type === 'blob') {
+        var blob = xhr.response;
+        if (blob) return readBlob(rec, blob, blob.size, Math.min(blob.size, BODY_CAP));
+      }
+      complete(rec, undefined, undefined, false);
+    };
+
+    // Listeners belong to one request and are removed when it ends.
+    var listen = function(xhr, rec) {
+      var handlers = {
+        readystatechange: function() { if (xhr.readyState === 2) onHeaders(xhr, rec); },
+        load: function() { end('load'); },
+        error: function() { end('error'); },
+        timeout: function() { end('timeout'); },
+        abort: function() { end('abort'); }
+      };
+      var end = function(outcome, force) {
+        // An end event that finds the XHR no longer DONE belongs to a request the app has already
+        // replaced, and the abort patch below recorded how that request ended.
+        if (!force && xhr.readyState !== 4) return;
+        for (var type in handlers) xhr.removeEventListener(type, handlers[type]);
+        if (live.has(xhr) && live.get(xhr).end === end) live.delete(xhr);
+        if (outcome === 'abort') return fail(rec, 'aborted');
+        if (outcome === 'timeout') return fail(rec, 'timeout');
+        if (outcome === 'error') {
+          var text = '';
+          try { if (xhr.responseType === '' || xhr.responseType === 'text') text = xhr.responseText; } catch (e) {}
+          return fail(rec, text ? String(text) : 'Network error');
+        }
+        // RN sets responseURL only after it announces HEADERS_RECEIVED: this is the final URL.
+        if (rec.entry.response && xhr.responseURL) rec.entry.response.url = xhr.responseURL;
+        rec.entry.durationMs = Date.now() - rec.startedAt;
+        try { readBody(rec, xhr); } catch (e) { complete(rec, undefined, undefined, false); }
+      };
+      live.set(xhr, { rec: rec, end: end });
+      // RN switches an XHR to incremental response updates once it has a readystatechange
+      // listener. Restore the flag so these listeners do not change how the app gets data.
+      var incremental = xhr._incrementalEvents;
+      for (var type in handlers) xhr.addEventListener(type, handlers[type]);
+      if (typeof incremental === 'boolean') xhr._incrementalEvents = incremental;
+    };
+
+    proto.open = function(method, url) {
+      var orphan = live.get(this);
+      var previous = slots.get(this);
+      var request = fetchRequest;
+      fetchRequest = null;
+      var slot = { method: String(method || 'GET').toUpperCase(), url: String(url), headers: {}, fetch: false };
+      // whatwg-fetch opens '' as the page's URL, which React Native does not have.
+      slot.fetch = !!request && String(request.method).toUpperCase() === slot.method && (String(request.url) === slot.url || request.url === '');
+      // Set before the original open, which dispatches readystatechange: a handler may send from there.
+      slots.set(this, slot);
+      var result;
+      try {
+        result = origOpen.apply(this, arguments);
+      } catch (e) {
+        if (previous) slots.set(this, previous);
+        else slots.delete(this);
+        throw e;
+      }
+      // Open succeeds only on a reset XHR, so a request still listening here can never end: RN reset
+      // it without an end event reaching these listeners (a re-send from inside an abort's own
+      // handlers, or an app listener that stopped the event). Drop it before it takes a response.
+      if (orphan) orphan.end('abort', true);
+      return result;
+    };
 
-        // Read the cloned response as a Blob to preserve the decoded entity's
-        // byte length across text charsets and binary responses. Content-Length
-        // cannot be used here: HEAD/304 responses may advertise a body that was
-        // not sent, and compression headers describe a different measurement.
-        var sizeClone = response.clone();
-        var bodyClone = response.clone();
-        var sizePromise = typeof sizeClone.blob === 'function'
-          ? sizeClone.blob().then(function(blob) {
-              return blob && typeof blob.size === 'number' ? blob.size : undefined;
-            }).catch(function() { return undefined; })
-          : Promise.resolve(undefined);
-        var bodyPromise = bodyClone.text().catch(function() { return undefined; });
-
-        Promise.all([sizePromise, bodyPromise]).then(function(values) {
-          var byteLength = values[0];
-          var body = values[1];
-          entry.state = 'finished';
-          if (typeof byteLength === 'number') entry.encodedDataLength = byteLength;
-          entry.durationMs = Math.round((ts() - t) * 1000);
-          if (typeof body === 'string') entry.responseBody = body;
-        }).catch(function() {
-          entry.state = 'finished';
-          entry.durationMs = Math.round((ts() - t) * 1000);
-        });
+    proto.setRequestHeader = function(name, value) {
+      var result = origSetRequestHeader.apply(this, arguments);
+      var slot = slots.get(this);
+      // React Native sends one value per lowercased name, the last one set. RN still accepts a
+      // header after send, but it never reaches the wire, so it is not recorded.
+      if (slot && slot.headers) {
+        name = String(name).toLowerCase();
+        value = String(value);
+        // whatwg-fetch sets headers given as [name, value] pairs as if they were an object: each pair
+        // as '0': 'name,value' and so on, then 'length', then each pair again under its own name. The
+        // pair is recorded under its own name, so a redacted header stays redacted.
+        var comma = value.indexOf(',');
+        if (/^\\d+$/.test(name) && comma > 0) {
+          slot.pairs = true;
+          name = value.slice(0, comma).trim().toLowerCase();
+          value = value.slice(comma + 1);
+        } else if (name === 'length' && slot.pairs) {
+          return result;
+        }
+        slot.headers[name] = value;
+      }
+      return result;
+    };
 
-        return response;
-      }).catch(function(err) {
-        entry.state = 'failed';
-        entry.errorText = err ? (err.message || String(err)) : 'Network error';
-        entry.durationMs = Math.round((ts() - t) * 1000);
-        throw err;
+    proto.send = function(body) {
+      var slot = slots.get(this);
+      var startedAt = Date.now();
+      var result;
+      xhrSending++;
+      try {
+        result = origSend.apply(this, arguments);
+      } finally {
+        xhrSending--;
+      }
+      if (!slot || !slot.headers) return result;
+      var rec = createRecord(isFetchXhr(this, slot) ? 'Fetch' : 'XHR', slot.method, slot.url, slot.headers, body, startedAt);
+      slot.headers = null;
+      listen(this, rec);
+      return result;
+    };
+
+    // To reuse an XHR from its own handler, the app aborts it first, and RN runs that handler
+    // before these listeners. Record a request that has already ended before abort resets the XHR.
+    // RN keeps _aborted set until the next open, so an abort called from a handler of an abort
+    // still counts as one. An app can also abort from its own handler of HEADERS_RECEIVED, which
+    // runs before the listener that records the headers: keep them.
+    // RN clears the response before it announces the abort, so the text an XHR has received while it
+    // streams (react-native-sse aborts to close) is taken first. The request stays failed: the body
+    // is only the part that arrived.
+    proto.abort = function() {
+      var request = live.get(this);
+      if (request && this.readyState >= 2 && !request.rec.entry.response) onHeaders(this, request.rec);
+      if (request && this.readyState === 4) {
+        request.end(this._aborted ? 'abort' : this._hasError ? (this._timedOut ? 'timeout' : 'error') : 'load');
+      }
+      var partial;
+      if (request && this.readyState === 3) {
+        try { if (this.responseType === '' || this.responseType === 'text') partial = this.responseText; } catch (e) {}
+      }
+      var result = origAbort.apply(this, arguments);
+      if (typeof partial === 'string' && partial && request.rec.entry.state === 'failed') {
+        storeBody(request.rec, partial, textSizeOf(request.rec, partial), false);
+      }
+      return result;
+    };
+  }
+
+  // \u2500\u2500 Expo's native fetch \u2500\u2500
+  // expo/fetch builds each request as new NativeRequest(response) and sends it with start(url, init,
+  // body), whether the app calls it as the global fetch or imports it. The app gets that response
+  // once start resolves.
+  var expoFetch;
+  try { expoFetch = g.expo && g.expo.modules && g.expo.modules.ExpoFetchModule; } catch (e) {}
+  // Takes the whole body of a response from native, for the app to get at its first read. It stays
+  // null when Expo's module cannot hand a body back (see below).
+  var takeBody = null;
+
+  // Hands each result of an object's method to tap as well. track(1) runs when a call starts and
+  // track(-1) once its promise settles. The caller gets a promise that settles like the original, so
+  // a rejection it never handles is still reported as unhandled.
+  function tapMethod(target, name, tap, track) {
+    var method = target[name];
+    if (typeof method !== 'function') return;
+    target[name] = function() {
+      var result = method.apply(this, arguments);
+      if (!result || typeof result.then !== 'function') return result;
+      track(1);
+      return result.then(function(value) {
+        try { tap(value); } catch (e) {}
+        track(-1);
+        return value;
+      }, function(error) {
+        track(-1);
+        throw error;
       });
     };
   }
 
-  // Note: XHR is intentionally NOT patched. In React Native, fetch() is built
-  // on top of XMLHttpRequest internally, so patching both would double-count
-  // every request. Since virtually all RN code uses fetch(), patching only
-  // fetch captures all meaningful traffic without duplicates.
+  // Native Expo hands a body out once, so reading it here while the request runs, or through a clone,
+  // would take it from the app or make it wait. The body is taken as the app reads it: its text() or
+  // arrayBuffer() (json(), blob() and bytes() go through them), or the chunks of its body stream. A
+  // 2xx body the app never reads is not recorded. The native side announces the end of every request with
+  // readyForJSFinalization, a failed one too, and that event can come before start rejects: the
+  // record ends only once start resolved. The body can be complete before JS gets that event: a
+  // whole body the app reads, or didComplete after the chunks it streams, ends the record too. So an
+  // app that aborts once it has the body (urql, graphql-sse) does not make the request fail. A read
+  // of the app still in flight holds the record: on iOS, when the connection drops in the middle of
+  // the body, the event can say nothing of the drop, and the read then never settles. The record
+  // stays pending, as the app's read does.
+  // Apps often do not read the body of an error response (if (!response.ok) throw ...), and that
+  // body is what the agent needs. Once the request has ended, and the app has not started to read
+  // the body in the turn after, such a body is taken from native. The app gets it at its first read.
+  function observeExpoResponse(rec, response, started) {
+    var chunks = [];
+    var kept = 0;
+    var streamed = 0;
+    var endedAt = 0;
+    var responded = false;
+    var reading = 0;
+    var read = false;
+    var finalized = false;
+    var stalled = false;
+    var completed = false;
+    // Keeps as many bytes of the chunks as keepBytes keeps of a whole body.
+    var take = function(data) {
+      if (!data || typeof data.byteLength !== 'number') return;
+      var view = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
+      streamed += view.byteLength;
+      if (kept >= BODY_CAP + 3) return;
+      chunks.push(new Uint8Array(view.buffer.slice(view.byteOffset, view.byteOffset + Math.min(view.byteLength, BODY_CAP + 3 - kept))));
+      kept += chunks[chunks.length - 1].byteLength;
+    };
+    // A whole body, which can come after the request ended.
+    var takeWhole = function(data) {
+      if (!data || typeof data.byteLength !== 'number' || rec.entry.state === 'failed') return;
+      var bytes = ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
+      storeBody(rec, keepBytes(bytes), bytes.byteLength);
+    };
+    var onData = function(data) { take(data); };
+    var onFail = function(error) { if (rec.entry.state === 'pending') fail(rec, String(error)); };
+    // Returns whether it holds the record for a take of the body.
+    var tried = false;
+    var takeUnread = function() {
+      if (tried) return false;
+      tried = true;
+      var status = rec.entry.response.status;
+      if (rec.entry.request.method === 'HEAD' || status === 204 || status === 205 || status === 304 ||
+        rec.entry.response.headers['content-length'] === '0') {
+        storeBody(rec, '', 0, false);
+        return false;
+      }
+      if ((status >= 200 && status < 300) || !takeBody) return false;
+      var release = function() {
+        reading--;
+        finish();
+      };
+      // The app gets a turn to start its own read: on iOS, SDK 55 resolves fetch only once the request
+      // ended.
+      reading++;
+      setTimeout(function() {
+        var body = read ? undefined : takeBody(response);
+        if (!body) return release();
+        body.then(function(data) {
+          if (data != null) takeWhole(data);
+          release();
+        }, release);
+      }, 0);
+      return true;
+    };
+    var finish = function() {
+      if (!endedAt || !responded || reading || stalled || rec.entry.state !== 'pending') return;
+      if (!read && !streamed && takeUnread()) return;
+      rec.entry.durationMs = endedAt - rec.startedAt;
+      if (!streamed) return complete(rec, undefined, undefined, false);
+      var bytes = new Uint8Array(kept);
+      for (var i = 0, at = 0; i < chunks.length; at += chunks[i].byteLength, i++) bytes.set(chunks[i], at);
+      complete(rec, bytes, streamed);
+    };
+    var bodyEnded = function() {
+      if (!endedAt) endedAt = Date.now();
+    };
+    var ended = function() {
+      bodyEnded();
+      finish();
+    };
+    var track = function(step) {
+      read = true;
+      // A read that starts once the record ended without a body can hang too, and holds it again.
+      if (step > 0 && rec.entry.state === 'finished' && rec.entry.encodedDataLength === undefined) rec.entry.state = 'pending';
+      reading += step;
+      finish();
+    };
+    var onEnd = function() {
+      try { response.removeListener('readyForJSFinalization', onEnd); } catch (e) {}
+      finalized = true;
+      ended();
+    };
+    // Expo drops the stream listeners itself when the request ends.
+    response.addListener('didReceiveResponseData', onData);
+    response.addListener('didComplete', function() {
+      completed = true;
+      ended();
+    });
+    response.addListener('didFailWithError', onFail);
+    response.addListener('readyForJSFinalization', onEnd);
+    // startStreaming returns the whole body when it completed before the app opened its stream (on
+    // iOS, SDK 55 resolves fetch only then), else null and the chunks follow as events.
+    tapMethod(response, 'startStreaming', function(data) {
+      // Once the request ended, native answers null only when the body did not complete: the app's
+      // stream then never ends, and the record stays pending. On Android, SDK 55 can deliver the null
+      // of a stream it started after the stream's didComplete and the end: that stream is whole.
+      if (data == null) {
+        if (finalized && !completed) stalled = true;
+        return;
+      }
+      takeWhole(data);
+      bodyEnded();
+    }, track);
+    tapMethod(response, 'arrayBuffer', function(data) {
+      takeWhole(data);
+      bodyEnded();
+    }, track);
+    tapMethod(response, 'text', function(text) {
+      if (typeof text === 'string' && rec.entry.state !== 'failed') storeBody(rec, text, textSizeOf(rec, text), false);
+      bodyEnded();
+    }, track);
+    started.then(function() {
+      if (rec.entry.state === 'failed') return;
+      setResponse(rec, response.url, response.status, response.statusText, headersObject(response.headers));
+      responded = true;
+      finish();
+    }, function(err) {
+      if (rec.entry.state === 'pending') fail(rec, err ? String(err.message || err) : 'Network error');
+    });
+  }
+
+  if (expoFetch && typeof expoFetch.NativeRequest === 'function' && typeof expoFetch.NativeRequest.prototype.start === 'function' &&
+    typeof Proxy === 'function' && typeof Reflect === 'object') {
+    var NativeRequest = expoFetch.NativeRequest;
+    var nativeProto = NativeRequest.prototype;
+    var origStart = nativeProto.start;
+    var origCancel = nativeProto.cancel;
+    // The response each request fills, and the record of each request sent.
+    var responses = new WeakMap();
+    var nativeRecords = new WeakMap();
+    try {
+      expoFetch.NativeRequest = new Proxy(NativeRequest, {
+        construct: function(target, args, newTarget) {
+          var request = Reflect.construct(target, args, newTarget);
+          if (args[0] && typeof args[0] === 'object') responses.set(request, args[0]);
+          return request;
+        }
+      });
+    } catch (e) {}
+    if (expoFetch.NativeRequest !== NativeRequest) {
+      nativeProto.start = function(url, init, body) {
+        var startedAt = Date.now();
+        var promise = origStart.apply(this, arguments);
+        var response = responses.get(this);
+        if (!response || !promise || typeof promise.then !== 'function') return promise;
+        try {
+          var rec = createRecord('Fetch', String((init && init.method) || 'GET').toUpperCase(), String(url),
+            lowerCaseHeaders(init && init.headers), body, startedAt);
+          nativeRecords.set(this, rec);
+          observeExpoResponse(rec, response, promise);
+        } catch (e) {}
+        return promise;
+      };
+      // expo/fetch cancels the request when the app aborts it, also while the app reads the body.
+      if (typeof origCancel === 'function') {
+        nativeProto.cancel = function() {
+          var rec = nativeRecords.get(this);
+          if (rec && rec.entry.state === 'pending') fail(rec, 'aborted');
+          return origCancel.apply(this, arguments);
+        };
+      }
+      // Native hands a body out once. A body taken for the record goes to the first read of the app
+      // instead, through the native methods that expo/fetch reads with. Expo's own response, its
+      // listeners and its body stream stay as they are.
+      var responseProto = expoFetch.NativeResponse && expoFetch.NativeResponse.prototype;
+      if (responseProto && typeof responseProto.arrayBuffer === 'function' && typeof responseProto.text === 'function' &&
+        typeof responseProto.startStreaming === 'function' && typeof TextDecoder === 'function') {
+        var takenBodies = new WeakMap();
+        var origStartStreaming = responseProto.startStreaming;
+        var handBack = function(name, convert) {
+          var original = responseProto[name];
+          var patched = function() {
+            var body = takenBodies.get(this);
+            if (!body) return original.apply(this, arguments);
+            takenBodies.delete(this);
+            var self = this, args = arguments;
+            // Nothing taken (the body did not complete): native answers as it would have.
+            return body.then(function(data) { return data == null ? original.apply(self, args) : convert(data); });
+          };
+          try { responseProto[name] = patched; } catch (e) {}
+          return responseProto[name] === patched;
+        };
+        var handed = [
+          handBack('arrayBuffer', function(data) {
+            return data.byteOffset === 0 && data.byteLength === data.buffer.byteLength ? data.buffer :
+              data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+          }),
+          handBack('startStreaming', function(data) { return data; }),
+          // As native text(): a byte order mark stays, and bytes that are not UTF-8 become U+FFFD. This
+          // decode runs on the app's JS thread, only for an error body the app reads a turn or more
+          // after the request ended.
+          handBack('text', function(data) { return new TextDecoder('utf-8', { ignoreBOM: true }).decode(data); })
+        ];
+        if (handed[0] && handed[1] && handed[2]) {
+          // Once the request ended, native startStreaming returns the whole body, or null when the body
+          // did not complete, and does not wait.
+          takeBody = function(response) {
+            var body = origStartStreaming.call(response);
+            if (!body || typeof body.then !== 'function') return undefined;
+            takenBodies.set(response, body);
+            return body;
+          };
+        }
+      }
+    }
+  }
+
+  // \u2500\u2500 React Native's network module \u2500\u2500
+  // A fetch library can send through React Native's network module (RCTNetworking) itself, not
+  // through an XHR: react-native-fetch-api, which react-native-polyfill-globals installs as the global
+  // fetch. Each request such a library sends there is recorded, so it has one record whatever the
+  // app's wrappers do, and whenever the library was installed. The module is not global: it is found
+  // in the module list of Metro's development build (__r.getModules()). A request that an XHR sends
+  // (xhrSending) has its record from the XHR.
+  // The native module answers by request id, with events of the module: the response, its data
+  // (text, base64 text or a native blob, as the sender asked) or the parts of a text it streams, and
+  // the end of the request. An aborted request gets no end event on iOS.
+  var NETWORKING_PATH = /(^|[\\\\/])Libraries[\\\\/]Network[\\\\/]RCTNetworking(\\.[a-z]+)?\\.js$/;
+  function findNetworking() {
+    var modules;
+    try { modules = typeof g.__r === 'function' && typeof g.__r.getModules === 'function' ? g.__r.getModules() : null; } catch (e) {}
+    if (!modules || typeof modules !== 'object') return null;
+    var matches = [];
+    var check = function(mod, id) {
+      if (mod && typeof mod.verboseName === 'string' && NETWORKING_PATH.test(mod.verboseName)) matches.push({ mod: mod, id: Number(id) });
+    };
+    if (typeof modules.forEach === 'function') modules.forEach(check);
+    else for (var key in modules) if (hasOwn.call(modules, key)) check(modules[key], key);
+    // A module the app has not loaded yet is loaded here, as its first request would.
+    matches.sort(function(a, b) { return (b.mod.isInitialized ? 1 : 0) - (a.mod.isInitialized ? 1 : 0); });
+    for (var i = 0; i < matches.length; i++) {
+      var exports;
+      try {
+        exports = matches[i].mod.isInitialized ? matches[i].mod.publicModule && matches[i].mod.publicModule.exports : g.__r(matches[i].id);
+      } catch (e) {}
+      var api = exports && typeof exports === 'object' && exports.default ? exports.default : exports;
+      if (api && typeof api.sendRequest === 'function' && typeof api.abortRequest === 'function' &&
+        typeof api.addListener === 'function') return api;
+    }
+    return null;
+  }
+
+  function lowerCaseHeaders(source) {
+    var headers = headersObject(source);
+    var out = {};
+    for (var name in headers) {
+      if (!hasOwn.call(headers, name)) continue;
+      var lower = name.toLowerCase();
+      out[lower] = hasOwn.call(out, lower) ? out[lower] + ', ' + headers[name] : headers[name];
+    }
+    return out;
+  }
+
+  // A Blob of the native blob a response came as, for FileReader only: it does not count as a
+  // reference to the native blob, so the app's own Blob of it still frees it, and nothing here closes it.
+  function blobOf(data, size) {
+    var copy = {};
+    for (var key in data) if (hasOwn.call(data, key)) copy[key] = data[key];
+    copy.size = size;
+    var blob = Object.create(Blob.prototype);
+    blob.data = copy;
+    return blob;
+  }
+
+  // Records one request sent through the module. Returns the request's watcher, which gets the
+  // request id once the module hands it back.
+  function watchRequest(networking, method, url, headers, data, responseType) {
+    var rec = createRecord('Fetch', String(method || 'GET').toUpperCase(), String(url), lowerCaseHeaders(headers), data, Date.now());
+    var requestId;
+    var subscriptions = [];
+    var received;
+    // The text received so far of a response streamed in parts, up to one character past the cut.
+    var streamed = '';
+    var streamedChars = 0;
+    var streamedBytes = 0;
+    var stop = function() {
+      for (var i = 0; i < subscriptions.length; i++) {
+        try { subscriptions[i].remove(); } catch (e) {}
+      }
+      subscriptions = [];
+      if (requestId !== undefined && watched[requestId] === watcher) delete watched[requestId];
+    };
+    var storeStreamed = function() {
+      if (!streamedChars) return;
+      var cut = streamedChars > BODY_CAP;
+      storeBody(rec, streamed, cut ? undefined : streamedBytes, false);
+      if (cut) rec.entry.bodyLength = streamedChars;
+    };
+    var handlers = {
+      didReceiveNetworkResponse: function(args) {
+        setResponse(rec, args[3], args[1], '', lowerCaseHeaders(args[2]));
+      },
+      didReceiveNetworkData: function(args) { received = args[1]; },
+      didReceiveNetworkIncrementalData: function(args) {
+        var text = args[1];
+        if (typeof text !== 'string' || !text) return;
+        streamedChars += text.length;
+        if (streamedChars <= BODY_CAP) streamedBytes += utf8Length(text);
+        if (streamed.length <= BODY_CAP) streamed += text.slice(0, BODY_CAP + 1 - streamed.length);
+      },
+      didCompleteNetworkResponse: function(args) {
+        stop();
+        if (rec.entry.state !== 'pending') return;
+        if (args[2]) return fail(rec, 'timeout');
+        if (args[1]) {
+          storeStreamed();
+          return fail(rec, String(args[1]));
+        }
+        rec.entry.durationMs = Date.now() - rec.startedAt;
+        if (typeof received === 'string') {
+          if (responseType !== 'base64') return complete(rec, received, textSizeOf(rec, received), false);
+          var n = received.length;
+          var padding = received.charAt(n - 1) === '=' ? (received.charAt(n - 2) === '=' ? 2 : 1) : 0;
+          var size = Math.max(0, Math.floor(n * 3 / 4) - padding);
+          // A binary body keeps no bytes (see storeBody).
+          if (isBinaryResponse(rec)) {
+            omitBody(rec, size);
+            return complete(rec, undefined, size, false);
+          }
+          // Decoded when the agent reads the record, as bytes are.
+          rec.entry.bodyBase64 = received.slice(0, Math.ceil((BODY_CAP + 3) / 3) * 4);
+          if (byId[rec.entry.requestId] === rec.entry) { bufferedChars += rec.entry.bodyBase64.length; evict(); }
+          return complete(rec, undefined, size, false);
+        }
+        if (received && typeof received === 'object' && typeof received.blobId === 'string') {
+          var blobSize = Number(received.size) || 0;
+          if (typeof Blob === 'function' && typeof FileReader === 'function' && typeof readBlob === 'function') {
+            try {
+              return readBlob(rec, blobOf(received, blobSize), blobSize, Math.min(blobSize, BODY_CAP), function(end) { return blobOf(received, end); });
+            } catch (e) {}
+          }
+          if (isBinaryResponse(rec)) omitBody(rec, blobSize);
+          return complete(rec, undefined, blobSize, false);
+        }
+        storeStreamed();
+        complete(rec, undefined, undefined, false);
+      }
+    };
+    var watcher = {
+      sent: function(id) {
+        requestId = id;
+        watched[id] = watcher;
+      },
+      // The app aborted the request: what it streamed so far stays with the failed record.
+      abort: function() {
+        stop();
+        if (rec.entry.state !== 'pending') return;
+        storeStreamed();
+        fail(rec, 'aborted');
+      },
+      // The module did not take the request: its send threw before it handed back an id.
+      drop: function() {
+        if (requestId !== undefined) return;
+        stop();
+        var at = log.lastIndexOf(rec.entry);
+        if (at === -1) return;
+        log.splice(at, 1);
+        delete byId[rec.entry.requestId];
+        bufferedChars -= bodyChars(rec.entry);
+      }
+    };
+    // Each event carries the request id, which the module hands back only after the request starts.
+    try {
+      for (var event in handlers) {
+        (function(handler) {
+          subscriptions.push(networking.addListener(event, function(args) {
+            if (requestId === undefined || !args || args[0] !== requestId) return;
+            try { handler(args); } catch (e) {}
+          }));
+        })(handlers[event]);
+      }
+    } catch (e) {
+      watcher.drop();
+      return null;
+    }
+    return watcher;
+  }
+
+  // The watcher of each request in flight, by request id.
+  var watched = {};
+  var networking = findNetworking();
+  if (networking) {
+    var origSendRequest = networking.sendRequest;
+    var origAbortRequest = networking.abortRequest;
+    networking.sendRequest = function(method, trackingName, url, headers, data, responseType, incrementalUpdates, timeout, callback) {
+      if (xhrSending || typeof callback !== 'function') return origSendRequest.apply(this, arguments);
+      var watcher = null;
+      try { watcher = watchRequest(networking, method, url, headers, data, responseType); } catch (e) {}
+      if (!watcher) return origSendRequest.apply(this, arguments);
+      var args = Array.prototype.slice.call(arguments);
+      args[8] = function(requestId) {
+        try { if (typeof requestId === 'number' || typeof requestId === 'string') watcher.sent(requestId); } catch (e) {}
+        return callback.apply(this, arguments);
+      };
+      try {
+        return origSendRequest.apply(this, args);
+      } catch (e) {
+        watcher.drop();
+        throw e;
+      }
+    };
+    networking.abortRequest = function(requestId) {
+      var watcher = hasOwn.call(watched, requestId) ? watched[requestId] : null;
+      if (watcher) {
+        try { watcher.abort(); } catch (e) {}
+      }
+      return origAbortRequest.apply(this, arguments);
+    };
+  }
 
   return JSON.stringify({ installed: true });
 })()`;
@@ -134382,9 +135304,10 @@ function makeNetworkLogReadScript(start2, limit, metroPort2) {
       requestId: s.requestId,
       state: s.state,
       request: s.request ? { url: s.request.url, method: s.request.method } : undefined,
-      response: s.response ? { status: s.response.status, statusText: s.response.statusText, mimeType: s.response.mimeType } : undefined,
+      response: s.response ? { url: s.response.url, status: s.response.status, statusText: s.response.statusText, mimeType: s.response.mimeType } : undefined,
       resourceType: s.resourceType,
       encodedDataLength: s.encodedDataLength,
+      bodyLength: s.bodyLength,
       timestamp: s.timestamp,
       durationMs: s.durationMs,
       errorText: s.errorText
@@ -134400,6 +135323,7 @@ function makeNetworkDetailReadScript(requestId) {
   if (!byId) return JSON.stringify({ error: 'Network interceptor not installed' });
   var entry = byId[${JSON.stringify(requestId)}];
   if (!entry) return JSON.stringify({ error: 'Request not found' });
+  if (typeof globalThis.__argent_network_decode === 'function') globalThis.__argent_network_decode(entry);
 
   return JSON.stringify({
     id: entry.id,
@@ -134410,11 +135334,12 @@ function makeNetworkDetailReadScript(requestId) {
     resourceType: entry.resourceType,
     encodedDataLength: entry.encodedDataLength,
     timestamp: entry.timestamp,
-    wallTime: entry.wallTime,
     durationMs: entry.durationMs,
     errorText: entry.errorText,
-    initiator: entry.initiator,
-    responseBody: entry.responseBody
+    responseBody: entry.responseBody,
+    bodyTruncated: entry.bodyTruncated,
+    bodyLength: entry.bodyLength,
+    bodyOmitted: entry.bodyOmitted
   });
 })()`;
 }
@@ -149700,35 +150625,83 @@ When the debugger cannot be reached, this tool does not fail: it returns { statu
 }
 
 // ../tool-server/src/tools/network/network-logs.ts
+var import_node_http4 = require("node:http");
 init_zod();
 var import_bytes3 = __toESM(require_bytes());
 init_device_info();
 var ITEMS_PER_PAGE = 50;
+function notInstalled(installError) {
+  return installError ? `Network interceptor could not be installed in the app's JS runtime: ${installError}` : "Network interceptor not installed: the app's JS runtime reloaded, which clears captured requests. Call view-network-logs again to reinstall it, then repeat the action that sends the requests.";
+}
 function formatBytes2(bytes) {
   return (0, import_bytes3.default)(bytes, { decimalPlaces: 1, unitSeparator: " " }) ?? `${bytes} B`;
 }
-function formatEntry(entry) {
-  const method = entry.request?.method ?? "???";
-  const url2 = entry.request?.url ?? "unknown";
-  let name;
+function reasonPhrase(status) {
+  return import_node_http4.STATUS_CODES[status] ?? "";
+}
+function comparableUrl(url2) {
+  let text = url2;
   try {
     const parsed = new URL(url2);
-    name = parsed.pathname === "/" ? parsed.hostname : parsed.pathname;
+    parsed.hash = "";
+    text = parsed.search ? parsed.href : parsed.href.replace(/\?$/, "");
+  } catch {
+  }
+  text = text.replace(/\+/g, " ");
+  for (let i = 0; i < 4; i++) {
+    let decoded;
+    try {
+      decoded = decodeURI(text);
+    } catch {
+      break;
+    }
+    if (decoded === text) break;
+    text = decoded;
+  }
+  return text.replace(/%[0-9a-f]{2}/gi, (escape2) => escape2.toUpperCase());
+}
+function isRedirect(requestUrl, finalUrl) {
+  if (!finalUrl || requestUrl === void 0 || finalUrl === requestUrl) return false;
+  return comparableUrl(finalUrl) !== comparableUrl(requestUrl);
+}
+function shortName(url2, from2) {
+  try {
+    const parsed = new URL(url2);
+    const path53 = parsed.pathname === "/" ? "" : parsed.pathname;
+    let sameHost = true;
+    try {
+      sameHost = from2 === void 0 || new URL(from2).host === parsed.host;
+    } catch {
+      sameHost = false;
+    }
+    if (sameHost) return path53 || parsed.hostname;
+    return parsed.host + path53;
   } catch {
-    name = url2;
+    return url2;
   }
+}
+function formatEntry(entry) {
+  const method = entry.request?.method ?? "???";
+  const url2 = entry.request?.url ?? "unknown";
+  const name = shortName(url2);
+  const finalUrl = entry.response?.url;
+  const redirect = finalUrl && isRedirect(url2, finalUrl) ? `\u2192 ${shortName(finalUrl, url2)}` : "";
   let status;
   if (entry.state === "failed") {
     status = entry.errorText ?? "failed";
   } else if (entry.response) {
-    status = `${entry.response.status} ${entry.response.statusText}`;
+    status = [
+      entry.response.status,
+      entry.response.statusText,
+      entry.state === "pending" ? "(pending)" : ""
+    ].filter((part) => part !== "").join(" ");
   } else {
     status = "pending";
   }
   const type = entry.resourceType ?? "";
-  const size = entry.encodedDataLength != null ? formatBytes2(entry.encodedDataLength) : "";
+  const size = entry.encodedDataLength != null ? formatBytes2(entry.encodedDataLength) : entry.bodyLength != null ? `~${formatBytes2(entry.bodyLength)}` : "";
   const duration3 = entry.durationMs != null ? `${entry.durationMs} ms` : "";
-  return `{id: ${entry.requestId}} "${method} ${name}" ${status} ${type} ${size} ${duration3}`.trim();
+  return [`{id: ${entry.requestId}}`, `"${method} ${name}"`, status, type, size, duration3, redirect].filter(Boolean).join(" ");
 }
 function recordToLogEntry(r, id) {
   return {
@@ -149746,7 +150719,7 @@ function recordToLogEntry(r, id) {
 function renderChromiumPage(records, pageIndexParam) {
   const total = records.length;
   if (total === 0) {
-    return "No network traffic captured. Recording is active on the active tab \u2014 navigate or reload the page to populate it (requests made before the device was attached are not captured).";
+    return "No network traffic captured. Recording is active on the active tab. Navigate or reload the page to populate it (requests made before the device was attached are not captured).";
   }
   const pageCount = Math.ceil(total / ITEMS_PER_PAGE);
   const pageIndex = pageIndexParam === "latest" ? pageCount - 1 : pageIndexParam;
@@ -149777,8 +150750,9 @@ var networkLogsTool = {
   },
   description: `Retrieve captured network (HTTP) requests from the running app.
 Returns a paginated list of requests with method, URL, status, resource type, size, and duration.
+A size with "~" is estimated from the body's length in characters; on React Native, "\u2192 <url>" is the final URL after a redirect.
 Each entry includes a requestId that can be passed to view-network-request-details for full details.
-On React Native (iOS / Android / Vega) interception is injected into the JS runtime: it captures fetch() calls. On Chromium it reads the browser's native CDP Network domain (the active tab; all request types).
+On React Native (iOS / Android / Vega) interception is injected into the JS runtime: it records each request once: XMLHttpRequest (axios included), React Native's fetch, Expo's fetch, and a fetch library that sends through React Native's network module itself, such as react-native-fetch-api (found in a Metro development build). Capture starts at the first network-tool call; a reload clears it. On Chromium it reads the browser's native CDP Network domain (the active tab; all request types).
 Use when inspecting outbound HTTP traffic or debugging API calls in the running app.
 Fails if the app is not connected (RN) or the device is not reachable (Chromium).`,
   zodSchema: zodSchema38,
@@ -149798,12 +150772,15 @@ Fails if the app is not connected (RN) or the device is not reachable (Chromium)
       return renderChromiumPage(chromium.server.network.requests(), params.pageIndex);
     }
     const api = services.inspector;
-    await api.cdp.evaluate(NETWORK_INTERCEPTOR_SCRIPT).catch(() => {
-    });
+    const installError = await api.cdp.evaluate(NETWORK_INTERCEPTOR_SCRIPT).then(
+      () => void 0,
+      (err) => err instanceof Error ? err.message : String(err)
+    );
     const countRaw = await api.cdp.evaluate(makeNetworkLogReadScript(0, 0, api.port));
-    const { total } = JSON.parse(countRaw);
+    const { total, interceptorInstalled } = JSON.parse(countRaw);
+    if (!interceptorInstalled) return notInstalled(installError);
     if (total === 0) {
-      return "No network traffic captured. Make sure the app is running and making HTTP requests. Network interception is active \u2014 it captures fetch() calls.";
+      return "No network traffic captured. Make sure the app is running and making HTTP requests. Network interception is active: it records XMLHttpRequest (axios included), React Native's fetch, Expo's fetch, and a fetch library that sends through React Native's network module, but not requests sent before capture started (at the first network-tool call).";
     }
     const pageCount = Math.ceil(total / ITEMS_PER_PAGE);
     const pageIndex = params.pageIndex === "latest" ? pageCount - 1 : params.pageIndex;
@@ -149814,10 +150791,15 @@ Fails if the app is not connected (RN) or the device is not reachable (Chromium)
     const readScript = makeNetworkLogReadScript(start2, ITEMS_PER_PAGE, api.port);
     const raw = await api.cdp.evaluate(readScript);
     const data = JSON.parse(raw);
-    if (!data.interceptorInstalled) {
-      return "Network interceptor not installed. Try reconnecting with network-inspector-connect.";
-    }
-    const lines = data.entries.map(formatEntry);
+    if (!data.interceptorInstalled) return notInstalled(installError);
+    const lines = data.entries.map(
+      (entry) => formatEntry(
+        entry.response ? {
+          ...entry,
+          response: { ...entry.response, statusText: reasonPhrase(entry.response.status) }
+        } : entry
+      )
+    );
     return `=== NETWORK LOGS (page ${pageIndex + 1}/${pageCount}, ${data.total} total) ===
 
 ${lines.join("\n")}`;
@@ -149840,19 +150822,37 @@ var SENSITIVE_HEADER_PATTERNS = [
   "apikey",
   "x-api-key"
 ];
-function isSensitiveHeader(name) {
+function isSensitiveHeader(name, value) {
   const lower = name.toLowerCase();
-  return SENSITIVE_HEADER_PATTERNS.some((p) => lower.includes(p));
+  if (SENSITIVE_HEADER_PATTERNS.some((p) => lower.includes(p))) return true;
+  return /^\d+$/.test(name) && value != null && isSensitiveHeader(String(value).split(",")[0].trim());
 }
 function redactHeaders(headers) {
   if (!headers) return {};
   const result = {};
   for (const [key2, value] of Object.entries(headers)) {
-    result[key2] = isSensitiveHeader(key2) ? "[REDACTED]" : value;
+    result[key2] = isSensitiveHeader(key2, value) ? "[REDACTED]" : value;
   }
   return result;
 }
 var MAX_BODY_SIZE = 1e3;
+function cutMarker(fullSize, mimeType) {
+  const mime = mimeType !== void 0 ? `, MIME: ${mimeType}` : "";
+  return `[TRUNCATED: first ${MAX_BODY_SIZE} chars shown, full size: ${fullSize}${mime}]`;
+}
+function utf8Text(bytes) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return bytes;
+  }
+}
+function truncatePostData(postData, truncated) {
+  if (postData == null || postData.length <= MAX_BODY_SIZE) return postData;
+  const fullSize = truncated ? `more than ${postData.length} chars` : `${postData.length} chars`;
+  return `${cutMarker(fullSize)}
+${postData.slice(0, MAX_BODY_SIZE)}...`;
+}
 var zodSchema39 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
@@ -149869,9 +150869,9 @@ var networkRequestTool = {
     failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to read network request ${params.requestId}: ${failureSignal2.error_code}`
   },
   description: `Get full details of a specific network request by its requestId (from view-network-logs).
-Returns request/response headers (sensitive headers redacted), status, timing, and optionally the response body.
-Large response bodies are truncated. Use when you need headers, body, or timing for a specific request after listing logs.
-Returns an error message string if the requestId is not found; use view-network-logs to get valid requestId values.`,
+Returns request/response headers (sensitive headers redacted), status, timing, the request body, and optionally the response body.
+Request and response bodies over 1000 chars are cut to 1000 under a "[TRUNCATED: ...]" line that gives the full size; a binary response body is replaced by "[body omitted: binary <mime>, N bytes]". Use when you need headers, body, or timing for a specific request after listing logs.
+Returns an error message string if the requestId is not found: use view-network-logs to get valid requestId values.`,
   zodSchema: zodSchema39,
   capability: DEBUGGER_TOOL_CAPABILITY,
   services: (params) => {
@@ -149904,7 +150904,7 @@ Returns an error message string if the requestId is not found; use view-network-
           url: rec.url,
           method: rec.method,
           headers: redactHeaders(rec.requestHeaders),
-          postData: rec.postData
+          postData: truncatePostData(rec.postData)
         };
       }
       if (rec.status != null) {
@@ -149920,9 +150920,13 @@ Returns an error message string if the requestId is not found; use view-network-
               requestId: rec.requestId
             });
             if (out.body != null) {
-              const body = out.base64Encoded ? Buffer.from(out.body, "base64").toString("utf8") : out.body;
-              resp.body = body.length > MAX_BODY_SIZE ? `[TRUNCATED \u2014 original size: ${body.length} chars, MIME: ${resp.mimeType}]
+              const body = out.base64Encoded ? utf8Text(Buffer.from(out.body, "base64")) : out.body;
+              if (typeof body !== "string") {
+                resp.body = `[body omitted: binary ${resp.mimeType || "data"}, ${body.length} bytes]`;
+              } else {
+                resp.body = body.length > MAX_BODY_SIZE ? `${cutMarker(`${body.length} chars`, resp.mimeType)}
 ${body.slice(0, MAX_BODY_SIZE)}...` : body;
+              }
             }
           } catch {
           }
@@ -149947,28 +150951,34 @@ ${body.slice(0, MAX_BODY_SIZE)}...` : body;
       resourceType: entry.resourceType,
       durationMs: entry.durationMs,
       encodedDataLength: entry.encodedDataLength,
-      errorText: entry.errorText,
-      initiator: entry.initiator
+      errorText: entry.errorText
     };
     if (entry.request) {
       details.request = {
         url: entry.request.url,
         method: entry.request.method,
         headers: redactHeaders(entry.request.headers),
-        postData: entry.request.postData
+        postData: truncatePostData(entry.request.postData, entry.request.postDataTruncated)
       };
     }
     if (entry.response) {
       const resp = {
         status: entry.response.status,
-        statusText: entry.response.statusText,
+        statusText: reasonPhrase(entry.response.status),
         headers: redactHeaders(entry.response.headers),
         mimeType: entry.response.mimeType
       };
-      if (params.includeBody && entry.responseBody != null) {
+      if (isRedirect(entry.request?.url, entry.response.url)) {
+        resp.redirectedTo = entry.response.url;
+      }
+      if (params.includeBody && entry.bodyOmitted) {
+        const size = entry.encodedDataLength != null ? `, ${entry.encodedDataLength} bytes` : entry.bodyLength != null ? `, ~${entry.bodyLength} bytes` : "";
+        resp.body = `[body omitted: binary ${entry.response.mimeType || "data"}${size}]`;
+      } else if (params.includeBody && entry.responseBody != null) {
         const body = entry.responseBody;
         if (body.length > MAX_BODY_SIZE) {
-          resp.body = `[TRUNCATED \u2014 original size: ${body.length} chars, MIME: ${entry.response.mimeType}]
+          const fullSize = !entry.bodyTruncated ? `${body.length} chars` : entry.encodedDataLength != null ? `${entry.encodedDataLength} bytes` : entry.bodyLength != null ? `${entry.bodyLength} chars` : `more than ${body.length} chars`;
+          resp.body = `${cutMarker(fullSize, entry.response.mimeType)}
 ${body.slice(0, MAX_BODY_SIZE)}...`;
         } else {
           resp.body = body;