react-native-nitro-fetch 1.3.1 → 1.3.2

package/src/fetch.js

@@ -1,5 +1,8 @@
 import 'web-streams-polyfill/polyfill';
-import { NitroFetch as NitroFetchSingleton, NitroCronetSingleton, } from './NitroInstances';
+import {
+  NitroFetch as NitroFetchSingleton,
+  NitroCronetSingleton,
+} from './NitroInstances';
 import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
 import { NitroHeaders } from './Headers';
 import { NitroResponse } from './Response';
@@ -7,765 +10,777 @@ import { NitroRequest as NitroRequestClass } from './Request';
 import { NetworkInspector } from './NetworkInspector';
 // No base64: pass strings/ArrayBuffers directly
 function headersToPairs(headers) {
-    'worklet';
-    if (!headers)
-        return undefined;
-    const pairs = [];
-    if (headers instanceof Headers) {
-        headers.forEach((v, k) => pairs.push({ key: k, value: v }));
-        return pairs;
-    }
-    if (Array.isArray(headers)) {
-        // Convert tuple pairs to objects if needed
-        for (const entry of headers) {
-            if (Array.isArray(entry) && entry.length >= 2) {
-                pairs.push({ key: String(entry[0]), value: String(entry[1]) });
-            }
-            else if (entry &&
-                typeof entry === 'object' &&
-                'key' in entry &&
-                'value' in entry) {
-                pairs.push(entry);
-            }
-        }
-        return pairs;
+  'worklet';
+  if (!headers) return undefined;
+  const pairs = [];
+  if (headers instanceof Headers) {
+    headers.forEach((v, k) => pairs.push({ key: k, value: v }));
+    return pairs;
+  }
+  if (Array.isArray(headers)) {
+    // Convert tuple pairs to objects if needed
+    for (const entry of headers) {
+      if (Array.isArray(entry) && entry.length >= 2) {
+        pairs.push({ key: String(entry[0]), value: String(entry[1]) });
+      } else if (
+        entry &&
+        typeof entry === 'object' &&
+        'key' in entry &&
+        'value' in entry
+      ) {
+        pairs.push(entry);
+      }
     }
-    // Check if it's a plain object (Record<string, string>) first
-    // Plain objects don't have forEach, so check for its absence
-    if (typeof headers === 'object' && headers !== null) {
-        // Check if it's a Headers instance by checking for forEach method
-        const hasForEach = typeof headers.forEach === 'function';
-        if (hasForEach) {
-            // Headers-like object (duck typing)
-            headers.forEach((v, k) => pairs.push({ key: k, value: v }));
-            return pairs;
-        }
-        else {
-            // Plain object (Record<string, string>)
-            // Use Object.keys to iterate since Object.entries might not work in worklets
-            const keys = Object.keys(headers);
-            for (let i = 0; i < keys.length; i++) {
-                const k = keys[i];
-                const v = headers[k];
-                if (v !== undefined) {
-                    pairs.push({ key: k, value: String(v) });
-                }
-            }
-            return pairs;
+    return pairs;
+  }
+  // Check if it's a plain object (Record<string, string>) first
+  // Plain objects don't have forEach, so check for its absence
+  if (typeof headers === 'object' && headers !== null) {
+    // Check if it's a Headers instance by checking for forEach method
+    const hasForEach = typeof headers.forEach === 'function';
+    if (hasForEach) {
+      // Headers-like object (duck typing)
+      headers.forEach((v, k) => pairs.push({ key: k, value: v }));
+      return pairs;
+    } else {
+      // Plain object (Record<string, string>)
+      // Use Object.keys to iterate since Object.entries might not work in worklets
+      const keys = Object.keys(headers);
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        const v = headers[k];
+        if (v !== undefined) {
+          pairs.push({ key: k, value: String(v) });
         }
+      }
+      return pairs;
     }
-    return pairs;
+  }
+  return pairs;
 }
 function serializeFormData(fd) {
-    const parts = [];
-    if (typeof fd.getParts === 'function') {
-        const rnParts = fd.getParts();
-        for (const part of rnParts) {
-            if (part.string !== undefined) {
-                parts.push({ name: part.fieldName, value: String(part.string) });
-            }
-            else if (part.uri) {
-                parts.push({
-                    name: part.fieldName,
-                    fileUri: part.uri,
-                    fileName: part.fileName ?? part.name ?? 'file',
-                    mimeType: part.type ?? 'application/octet-stream',
-                });
-            }
-        }
-        return parts;
+  const parts = [];
+  if (typeof fd.getParts === 'function') {
+    const rnParts = fd.getParts();
+    for (const part of rnParts) {
+      if (part.string !== undefined) {
+        parts.push({ name: part.fieldName, value: String(part.string) });
+      } else if (part.uri) {
+        parts.push({
+          name: part.fieldName,
+          fileUri: part.uri,
+          fileName: part.fileName ?? part.name ?? 'file',
+          mimeType: part.type ?? 'application/octet-stream',
+        });
+      }
     }
-    fd.forEach((value, key) => {
-        if (typeof value === 'string') {
-            parts.push({ name: key, value });
-        }
-        else if (value && typeof value === 'object') {
-            parts.push({
-                name: key,
-                fileUri: value.uri ?? value.fileUri,
-                fileName: value.name ?? value.fileName ?? 'file',
-                mimeType: value.type ?? value.mimeType ?? 'application/octet-stream',
-            });
-        }
-    });
     return parts;
+  }
+  fd.forEach((value, key) => {
+    if (typeof value === 'string') {
+      parts.push({ name: key, value });
+    } else if (value && typeof value === 'object') {
+      parts.push({
+        name: key,
+        fileUri: value.uri ?? value.fileUri,
+        fileName: value.name ?? value.fileName ?? 'file',
+        mimeType: value.type ?? value.mimeType ?? 'application/octet-stream',
+      });
+    }
+  });
+  return parts;
 }
 function isFormData(body) {
-    if (typeof FormData !== 'undefined' && body instanceof FormData)
-        return true;
-    if (body &&
-        typeof body === 'object' &&
-        typeof body.append === 'function' &&
-        typeof body.getParts === 'function') {
-        return true;
-    }
-    return false;
+  if (typeof FormData !== 'undefined' && body instanceof FormData) return true;
+  if (
+    body &&
+    typeof body === 'object' &&
+    typeof body.append === 'function' &&
+    typeof body.getParts === 'function'
+  ) {
+    return true;
+  }
+  return false;
 }
 function normalizeBody(body) {
-    'worklet';
-    if (body == null)
-        return undefined;
-    if (typeof body === 'string')
-        return { bodyString: body };
-    if (isFormData(body)) {
-        return { bodyFormData: serializeFormData(body) };
-    }
-    if (body instanceof URLSearchParams)
-        return { bodyString: body.toString() };
-    if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer)
-        return { bodyBytes: body };
-    if (ArrayBuffer.isView(body)) {
-        const view = body;
-        return {
-            //@ts-ignore
-            bodyBytes: view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength),
-        };
-    }
-    throw new Error('Unsupported body type for nitro fetch');
+  'worklet';
+  if (body == null) return undefined;
+  if (typeof body === 'string') return { bodyString: body };
+  if (isFormData(body)) {
+    return { bodyFormData: serializeFormData(body) };
+  }
+  if (body instanceof URLSearchParams) return { bodyString: body.toString() };
+  if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer)
+    return { bodyBytes: body };
+  if (ArrayBuffer.isView(body)) {
+    const view = body;
+    return {
+      //@ts-ignore
+      bodyBytes: view.buffer.slice(
+        view.byteOffset,
+        view.byteOffset + view.byteLength
+      ),
+    };
+  }
+  throw new Error('Unsupported body type for nitro fetch');
 }
 const NitroFetchHybrid = NitroFetchSingleton;
 let client;
 function ensureClient() {
-    if (client)
-        return client;
-    try {
-        client = NitroFetchHybrid.createClient();
-    }
-    catch (err) {
-        console.error('Failed to create NitroFetch client', err);
-        // native not ready; keep undefined
-    }
-    return client;
+  if (client) return client;
+  try {
+    client = NitroFetchHybrid.createClient();
+  } catch (err) {
+    console.error('Failed to create NitroFetch client', err);
+    // native not ready; keep undefined
+  }
+  return client;
 }
 function buildNitroRequest(input, init) {
-    'worklet';
-    let url;
-    let method;
-    let headersInit;
-    let body;
-    let redirectOption = init?.redirect ?? 'follow';
-    let cacheOption = init?.cache;
-    if (input instanceof NitroRequestClass) {
-        url = input.url;
-        method = init?.method ?? input.method;
-        headersInit = init?.headers ?? input.headers;
-        body = init?.body ?? input.body ?? null;
-        if (!init?.redirect)
-            redirectOption = input.redirect;
-        if (!init?.cache)
-            cacheOption = input.cache;
-    }
-    else if (typeof input === 'string' || input instanceof URL) {
-        url = String(input);
-        method = init?.method;
-        headersInit = init?.headers;
-        body = init?.body ?? null;
-    }
-    else {
-        // Standard Request object
-        url = input.url;
-        method = input.method;
-        headersInit = input.headers;
-        body = init?.body ?? null;
-    }
-    const headers = headersToPairs(headersInit) ?? [];
-    const normalized = normalizeBody(body);
-    // Inject cache-control headers based on cache option
-    if (cacheOption === 'no-store') {
-        headers.push({ key: 'Cache-Control', value: 'no-store' });
-    }
-    else if (cacheOption === 'no-cache') {
-        headers.push({ key: 'Cache-Control', value: 'no-cache' });
-    }
-    else if (cacheOption === 'reload') {
-        headers.push({ key: 'Cache-Control', value: 'no-cache' });
-        headers.push({ key: 'Pragma', value: 'no-cache' });
-    }
-    // Determine followRedirects based on redirect option
-    const followRedirects = redirectOption === 'follow';
-    const prefetchCacheTtlMs = typeof init?.prefetchCacheTtlMs === 'number'
-        ? init.prefetchCacheTtlMs
-        : undefined;
-    return {
-        url,
-        method: method?.toUpperCase() ?? 'GET',
-        headers: headers.length > 0 ? headers : undefined,
-        bodyString: normalized?.bodyString,
-        bodyBytes: undefined,
-        bodyFormData: normalized?.bodyFormData,
-        followRedirects,
-        prefetchCacheTtlMs,
-    };
+  'worklet';
+  let url;
+  let method;
+  let headersInit;
+  let body;
+  let redirectOption = init?.redirect ?? 'follow';
+  let cacheOption = init?.cache;
+  if (input instanceof NitroRequestClass) {
+    url = input.url;
+    method = init?.method ?? input.method;
+    headersInit = init?.headers ?? input.headers;
+    body = init?.body ?? input.body ?? null;
+    if (!init?.redirect) redirectOption = input.redirect;
+    if (!init?.cache) cacheOption = input.cache;
+  } else if (typeof input === 'string' || input instanceof URL) {
+    url = String(input);
+    method = init?.method;
+    headersInit = init?.headers;
+    body = init?.body ?? null;
+  } else {
+    // Standard Request object
+    url = input.url;
+    method = input.method;
+    headersInit = input.headers;
+    body = init?.body ?? null;
+  }
+  const headers = headersToPairs(headersInit) ?? [];
+  const normalized = normalizeBody(body);
+  // Inject cache-control headers based on cache option
+  if (cacheOption === 'no-store') {
+    headers.push({ key: 'Cache-Control', value: 'no-store' });
+  } else if (cacheOption === 'no-cache') {
+    headers.push({ key: 'Cache-Control', value: 'no-cache' });
+  } else if (cacheOption === 'reload') {
+    headers.push({ key: 'Cache-Control', value: 'no-cache' });
+    headers.push({ key: 'Pragma', value: 'no-cache' });
+  }
+  // Determine followRedirects based on redirect option
+  const followRedirects = redirectOption === 'follow';
+  const prefetchCacheTtlMs =
+    typeof init?.prefetchCacheTtlMs === 'number'
+      ? init.prefetchCacheTtlMs
+      : undefined;
+  return {
+    url,
+    method: method?.toUpperCase() ?? 'GET',
+    headers: headers.length > 0 ? headers : undefined,
+    bodyString: normalized?.bodyString,
+    bodyBytes: undefined,
+    bodyFormData: normalized?.bodyFormData,
+    followRedirects,
+    prefetchCacheTtlMs,
+  };
 }
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets. TODO: Merge this to use Same logic for Worklets and normal Fetch
 function headersToPairsPure(headers) {
-    'worklet';
-    if (!headers)
-        return undefined;
-    const pairs = [];
-    if (Array.isArray(headers)) {
-        // Convert tuple pairs to objects if needed
-        for (const entry of headers) {
-            if (Array.isArray(entry) && entry.length >= 2) {
-                pairs.push({ key: String(entry[0]), value: String(entry[1]) });
-            }
-            else if (entry &&
-                typeof entry === 'object' &&
-                'key' in entry &&
-                'value' in entry) {
-                pairs.push(entry);
-            }
-        }
-        return pairs;
+  'worklet';
+  if (!headers) return undefined;
+  const pairs = [];
+  if (Array.isArray(headers)) {
+    // Convert tuple pairs to objects if needed
+    for (const entry of headers) {
+      if (Array.isArray(entry) && entry.length >= 2) {
+        pairs.push({ key: String(entry[0]), value: String(entry[1]) });
+      } else if (
+        entry &&
+        typeof entry === 'object' &&
+        'key' in entry &&
+        'value' in entry
+      ) {
+        pairs.push(entry);
+      }
     }
-    // Check if it's a plain object (Record<string, string>) first
-    // Plain objects don't have forEach, so check for its absence
-    if (typeof headers === 'object' && headers !== null) {
-        // Check if it's a Headers instance by checking for forEach method
-        const hasForEach = typeof headers.forEach === 'function';
-        if (hasForEach) {
-            // Headers-like object (duck typing)
-            headers.forEach((v, k) => pairs.push({ key: k, value: v }));
-            return pairs;
-        }
-        else {
-            // Plain object (Record<string, string>)
-            // Use Object.keys to iterate since Object.entries might not work in worklets
-            const keys = Object.keys(headers);
-            for (let i = 0; i < keys.length; i++) {
-                const k = keys[i];
-                const v = headers[k];
-                if (v !== undefined) {
-                    pairs.push({ key: k, value: String(v) });
-                }
-            }
-            return pairs;
+    return pairs;
+  }
+  // Check if it's a plain object (Record<string, string>) first
+  // Plain objects don't have forEach, so check for its absence
+  if (typeof headers === 'object' && headers !== null) {
+    // Check if it's a Headers instance by checking for forEach method
+    const hasForEach = typeof headers.forEach === 'function';
+    if (hasForEach) {
+      // Headers-like object (duck typing)
+      headers.forEach((v, k) => pairs.push({ key: k, value: v }));
+      return pairs;
+    } else {
+      // Plain object (Record<string, string>)
+      // Use Object.keys to iterate since Object.entries might not work in worklets
+      const keys = Object.keys(headers);
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        const v = headers[k];
+        if (v !== undefined) {
+          pairs.push({ key: k, value: String(v) });
         }
+      }
+      return pairs;
     }
-    return pairs;
+  }
+  return pairs;
 }
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets
 function normalizeBodyPure(body) {
-    'worklet';
-    if (body == null)
-        return undefined;
-    if (typeof body === 'string')
-        return { bodyString: body };
-    // Check for URLSearchParams (duck typing)
-    // It should be an object, have a toString method, and typically append/delete methods
-    // But mainly we care about toString() returning the query string
-    if (typeof body === 'object' &&
-        body !== null &&
-        typeof body.toString === 'function' &&
-        Object.prototype.toString.call(body) === '[object URLSearchParams]') {
-        return { bodyString: body.toString() };
-    }
-    // Check for ArrayBuffer (using toString tag to avoid instanceof)
-    if (typeof ArrayBuffer !== 'undefined' &&
-        Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
-        return { bodyBytes: body };
-    }
-    if (ArrayBuffer.isView(body)) {
-        const view = body;
-        return {
-            //@ts-ignore
-            bodyBytes: view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength),
-        };
-    }
-    throw new Error('Unsupported body type for nitro fetch worklet (FormData is not available in worklets)');
+  'worklet';
+  if (body == null) return undefined;
+  if (typeof body === 'string') return { bodyString: body };
+  // Check for URLSearchParams (duck typing)
+  // It should be an object, have a toString method, and typically append/delete methods
+  // But mainly we care about toString() returning the query string
+  if (
+    typeof body === 'object' &&
+    body !== null &&
+    typeof body.toString === 'function' &&
+    Object.prototype.toString.call(body) === '[object URLSearchParams]'
+  ) {
+    return { bodyString: body.toString() };
+  }
+  // Check for ArrayBuffer (using toString tag to avoid instanceof)
+  if (
+    typeof ArrayBuffer !== 'undefined' &&
+    Object.prototype.toString.call(body) === '[object ArrayBuffer]'
+  ) {
+    return { bodyBytes: body };
+  }
+  if (ArrayBuffer.isView(body)) {
+    const view = body;
+    return {
+      //@ts-ignore
+      bodyBytes: view.buffer.slice(
+        view.byteOffset,
+        view.byteOffset + view.byteLength
+      ),
+    };
+  }
+  throw new Error(
+    'Unsupported body type for nitro fetch worklet (FormData is not available in worklets)'
+  );
 }
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets
 export function buildNitroRequestPure(input, init) {
-    'worklet';
-    let url;
-    let method;
-    let headersInit;
-    let body;
-    // Check if input is URL-like without instanceof
-    const isUrlObject = typeof input === 'object' &&
-        input !== null &&
-        Object.prototype.toString.call(input) === '[object URL]';
-    if (typeof input === 'string' || isUrlObject) {
-        url = String(input);
-        method = init?.method;
-        headersInit = init?.headers;
-        body = init?.body ?? null;
-    }
-    else {
-        // Request object
-        const req = input;
-        url = req.url;
-        method = req.method;
-        headersInit = req.headers;
-        // Clone body if needed – Request objects in RN typically allow direct access
-        body = init?.body ?? null;
-    }
-    const headers = headersToPairsPure(headersInit);
-    const normalized = normalizeBodyPure(body);
-    const prefetchCacheTtlMs = typeof init?.prefetchCacheTtlMs === 'number'
-        ? init.prefetchCacheTtlMs
-        : undefined;
-    return {
-        url,
-        method: method?.toUpperCase() ?? 'GET',
-        headers,
-        bodyString: normalized?.bodyString,
-        // Only include bodyBytes when provided to avoid signaling upload data unintentionally
-        bodyBytes: undefined,
-        followRedirects: true,
-        prefetchCacheTtlMs,
-    };
+  'worklet';
+  let url;
+  let method;
+  let headersInit;
+  let body;
+  // Check if input is URL-like without instanceof
+  const isUrlObject =
+    typeof input === 'object' &&
+    input !== null &&
+    Object.prototype.toString.call(input) === '[object URL]';
+  if (typeof input === 'string' || isUrlObject) {
+    url = String(input);
+    method = init?.method;
+    headersInit = init?.headers;
+    body = init?.body ?? null;
+  } else {
+    // Request object
+    const req = input;
+    url = req.url;
+    method = req.method;
+    headersInit = req.headers;
+    // Clone body if needed – Request objects in RN typically allow direct access
+    body = init?.body ?? null;
+  }
+  const headers = headersToPairsPure(headersInit);
+  const normalized = normalizeBodyPure(body);
+  const prefetchCacheTtlMs =
+    typeof init?.prefetchCacheTtlMs === 'number'
+      ? init.prefetchCacheTtlMs
+      : undefined;
+  return {
+    url,
+    method: method?.toUpperCase() ?? 'GET',
+    headers,
+    bodyString: normalized?.bodyString,
+    // Only include bodyBytes when provided to avoid signaling upload data unintentionally
+    bodyBytes: undefined,
+    followRedirects: true,
+    prefetchCacheTtlMs,
+  };
 }
 function createAbortError() {
-    const err = new Error('The operation was aborted.');
-    err.name = 'AbortError';
-    return err;
+  const err = new Error('The operation was aborted.');
+  err.name = 'AbortError';
+  return err;
 }
 async function resolveRequestBody(input, init) {
-    if (typeof input === 'string' || input instanceof URL)
-        return init;
-    if (input instanceof NitroRequestClass)
-        return init;
-    if (init?.body != null)
-        return init;
-    const req = input;
-    if (typeof req.clone !== 'function')
-        return init;
-    const method = (init?.method ?? req.method ?? 'GET').toUpperCase();
-    if (method === 'GET' || method === 'HEAD')
-        return init;
-    try {
-        const text = await req.clone().text();
-        if (text.length === 0)
-            return init;
-        return { ...(init ?? {}), body: text };
-    }
-    catch {
-        return init;
-    }
+  if (typeof input === 'string' || input instanceof URL) return init;
+  if (input instanceof NitroRequestClass) return init;
+  if (init?.body != null) return init;
+  const req = input;
+  if (typeof req.clone !== 'function') return init;
+  const method = (init?.method ?? req.method ?? 'GET').toUpperCase();
+  if (method === 'GET' || method === 'HEAD') return init;
+  try {
+    const text = await req.clone().text();
+    if (text.length === 0) return init;
+    return { ...(init ?? {}), body: text };
+  } catch {
+    return init;
+  }
 }
 async function resolveBlobBody(init) {
-    if (!init?.body)
-        return init;
-    if (typeof Blob !== 'undefined' && init.body instanceof Blob) {
-        const blob = init.body;
-        const text = await new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onload = () => resolve(reader.result);
-            reader.onerror = () => reject(reader.error);
-            reader.readAsText(blob);
-        });
-        // Auto-set Content-Type from Blob.type if not already provided
-        let headers = init.headers;
-        if (blob.type) {
-            const pairs = headersToPairs(headers) ?? [];
-            const hasContentType = pairs.some((h) => h.key.toLowerCase() === 'content-type');
-            if (!hasContentType) {
-                pairs.push({ key: 'Content-Type', value: blob.type });
-                headers = pairs.map((h) => [h.key, h.value]);
-            }
-        }
-        return { ...init, body: text, headers };
-    }
-    return init;
+  if (!init?.body) return init;
+  if (typeof Blob !== 'undefined' && init.body instanceof Blob) {
+    const blob = init.body;
+    const text = await new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = () => reject(reader.error);
+      reader.readAsText(blob);
+    });
+    // Auto-set Content-Type from Blob.type if not already provided
+    let headers = init.headers;
+    if (blob.type) {
+      const pairs = headersToPairs(headers) ?? [];
+      const hasContentType = pairs.some(
+        (h) => h.key.toLowerCase() === 'content-type'
+      );
+      if (!hasContentType) {
+        pairs.push({ key: 'Content-Type', value: blob.type });
+        headers = pairs.map((h) => [h.key, h.value]);
+      }
+    }
+    return { ...init, body: text, headers };
+  }
+  return init;
 }
 async function nitroFetchRaw(input, init) {
-    const signal = init?.signal;
-    // Fast-abort: reject synchronously before any bridge work.
+  const signal = init?.signal;
+  // Fast-abort: reject synchronously before any bridge work.
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+  // Extract body from standard Request when init.body is absent (ky/undici pattern)
+  init = await resolveRequestBody(input, init);
+  // Resolve Blob body to string before passing to sync buildNitroRequest
+  init = await resolveBlobBody(init);
+  const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
+  if (!hasNative) {
+    // Fallback path not supported for raw; use global fetch and synthesize minimal shape
+    // @ts-ignore: global fetch exists in RN
+    const res = await fetch(input, init);
+    const url = res.url ?? String(input);
+    const bytes = await res.arrayBuffer();
+    const headers = [];
+    res.headers.forEach((v, k) => headers.push({ key: k, value: v }));
+    return {
+      url,
+      status: res.status,
+      statusText: res.statusText,
+      ok: res.ok,
+      redirected: res.redirected ?? false,
+      headers,
+      bodyBytes: bytes,
+      bodyString: undefined,
+    }; // bleee
+  }
+  const req = buildNitroRequest(input, init);
+  // Inspector: record start (zero cost when disabled — single boolean check)
+  let inspectorId;
+  if (NetworkInspector.isEnabled()) {
+    inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
+    NetworkInspector._recordStart(
+      inspectorId,
+      req.url,
+      req.method ?? 'GET',
+      req.headers ?? [],
+      req.bodyString
+    );
+  }
+  // Only allocate a requestId when a signal is present — zero overhead otherwise.
+  const requestId = signal ? String(Math.random()) : undefined;
+  if (requestId) req.requestId = requestId;
+  ensureClient();
+  if (!client || typeof client.request !== 'function')
+    throw new Error('NitroFetch client not available');
+  // Wire up the abort listener with { once: true } so it auto-removes
+  // after firing, avoiding a dangling reference to the client closure.
+  let abortListener;
+  if (signal && requestId) {
+    abortListener = () => {
+      try {
+        client.cancelRequest(requestId);
+      } catch {
+        // Client may already be torn down — swallow.
+      }
+    };
+    signal.addEventListener('abort', abortListener, { once: true });
+  }
+  try {
+    const res = await client.request(req);
+    if (inspectorId) {
+      NetworkInspector._recordEnd(
+        inspectorId,
+        res.status,
+        res.statusText,
+        res.headers ?? [],
+        res.bodyString?.length ?? 0,
+        undefined,
+        res.bodyString ?? undefined
+      );
+    }
+    return res;
+  } catch (e) {
+    if (inspectorId) {
+      NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, String(e));
+    }
+    // If the signal was aborted (either before or during the request),
+    // surface a spec-compliant AbortError regardless of what native threw.
     if (signal?.aborted) {
-        throw createAbortError();
+      throw createAbortError();
     }
-    // Extract body from standard Request when init.body is absent (ky/undici pattern)
-    init = await resolveRequestBody(input, init);
-    // Resolve Blob body to string before passing to sync buildNitroRequest
-    init = await resolveBlobBody(init);
-    const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
-    if (!hasNative) {
-        // Fallback path not supported for raw; use global fetch and synthesize minimal shape
-        // @ts-ignore: global fetch exists in RN
-        const res = await fetch(input, init);
-        const url = res.url ?? String(input);
-        const bytes = await res.arrayBuffer();
-        const headers = [];
-        res.headers.forEach((v, k) => headers.push({ key: k, value: v }));
-        return {
-            url,
-            status: res.status,
-            statusText: res.statusText,
-            ok: res.ok,
-            redirected: res.redirected ?? false,
-            headers,
-            bodyBytes: bytes,
-            bodyString: undefined,
-        }; // bleee
-    }
-    const req = buildNitroRequest(input, init);
-    // Inspector: record start (zero cost when disabled — single boolean check)
-    let inspectorId;
-    if (NetworkInspector.isEnabled()) {
-        inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
-        NetworkInspector._recordStart(inspectorId, req.url, req.method ?? 'GET', req.headers ?? [], req.bodyString);
-    }
-    // Only allocate a requestId when a signal is present — zero overhead otherwise.
-    const requestId = signal ? String(Math.random()) : undefined;
-    if (requestId)
-        req.requestId = requestId;
-    ensureClient();
-    if (!client || typeof client.request !== 'function')
-        throw new Error('NitroFetch client not available');
-    // Wire up the abort listener with { once: true } so it auto-removes
-    // after firing, avoiding a dangling reference to the client closure.
-    let abortListener;
-    if (signal && requestId) {
-        abortListener = () => {
-            try {
-                client.cancelRequest(requestId);
-            }
-            catch {
-                // Client may already be torn down — swallow.
-            }
-        };
-        signal.addEventListener('abort', abortListener, { once: true });
-    }
-    try {
-        const res = await client.request(req);
-        if (inspectorId) {
-            NetworkInspector._recordEnd(inspectorId, res.status, res.statusText, res.headers ?? [], res.bodyString?.length ?? 0, undefined, res.bodyString ?? undefined);
-        }
-        return res;
-    }
-    catch (e) {
-        if (inspectorId) {
-            NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, String(e));
-        }
-        // If the signal was aborted (either before or during the request),
-        // surface a spec-compliant AbortError regardless of what native threw.
-        if (signal?.aborted) {
-            throw createAbortError();
-        }
-        throw e;
-    }
-    finally {
-        // Idempotent cleanup — removeEventListener is a no-op if the listener
-        // already fired (thanks to { once: true }) or was never added.
-        if (signal && abortListener) {
-            signal.removeEventListener('abort', abortListener);
-        }
+    throw e;
+  } finally {
+    // Idempotent cleanup — removeEventListener is a no-op if the listener
+    // already fired (thanks to { once: true }) or was never added.
+    if (signal && abortListener) {
+      signal.removeEventListener('abort', abortListener);
     }
+  }
 }
 // NitroHeaders is now imported from './Headers'
 async function nitroStreamFetch(input, init) {
-    const url = typeof input === 'string' ? input : String(input);
-    const method = init?.method?.toUpperCase() ?? 'GET';
-    const headers = headersToPairs(init?.headers);
-    // Inspector: record start
-    let inspectorId;
-    if (NetworkInspector.isEnabled()) {
-        inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
-        NetworkInspector._recordStart(inspectorId, url, method, headers ?? [], typeof init?.body === 'string' ? init.body : undefined);
-    }
-    const builder = NitroCronetSingleton.newUrlRequestBuilder(url);
-    builder.setHttpMethod(method);
-    headers?.forEach((h) => builder.addHeader(h.key, h.value));
-    const body = init?.body;
-    if (body != null) {
-        if (typeof body === 'string')
-            builder.setUploadBody(body);
-        else if (body instanceof ArrayBuffer)
-            builder.setUploadBody(body);
-    }
-    return new Promise((resolveResponse, rejectResponse) => {
-        let streamController;
-        const stream = new ReadableStream({
-            start(controller) {
-                streamController = controller;
-            },
-        });
-        let responseResolved = false;
-        let streamBytesReceived = 0;
-        builder.onResponseStarted((info) => {
-            if (responseResolved)
-                return;
-            responseResolved = true;
-            const status = info.httpStatusCode;
-            const responseHeaders = new NitroHeaders(Object.entries(info.allHeaders).map(([key, value]) => ({ key, value })));
-            const response = new NitroResponse({
-                url: info.url,
-                ok: status >= 200 && status < 300,
-                status,
-                statusText: info.httpStatusText,
-                headers: responseHeaders,
-                redirected: false,
-                body: stream,
-            });
-            resolveResponse(response);
-            // Android/Cronet: kick off the first buffer read.
-            // iOS/URLSession handles reading automatically so this is a no-op there.
-            request.read();
-        });
-        builder.onReadCompleted((_info, byteBuffer, bytesRead) => {
-            const chunk = new Uint8Array(byteBuffer, 0, bytesRead).slice();
-            streamBytesReceived += bytesRead;
-            streamController.enqueue(chunk);
-            if (!request.isDone()) {
-                request.read();
-            }
-        });
-        builder.onSucceeded((_info) => {
-            streamController.close();
-            if (inspectorId) {
-                const info = _info;
-                const status = info?.httpStatusCode ?? 0;
-                const hdrs = info?.allHeadersAsList ?? [];
-                NetworkInspector._recordEnd(inspectorId, status, info?.httpStatusText ?? '', hdrs, streamBytesReceived);
-            }
-        });
-        builder.onFailed((_info, error) => {
-            const err = new Error(error.message);
-            if (inspectorId) {
-                NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, error.message);
-            }
-            if (!responseResolved) {
-                responseResolved = true;
-                rejectResponse(err);
-            }
-            else {
-                streamController.error(err);
-            }
-        });
-        builder.onCanceled(() => {
-            const err = createAbortError();
-            if (inspectorId) {
-                NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, 'Request canceled');
-            }
-            if (!responseResolved) {
-                responseResolved = true;
-                rejectResponse(err);
-            }
-            else {
-                streamController.error(err);
-            }
-        });
-        const request = builder.build();
-        request.start();
+  const url = typeof input === 'string' ? input : String(input);
+  const method = init?.method?.toUpperCase() ?? 'GET';
+  const headers = headersToPairs(init?.headers);
+  // Inspector: record start
+  let inspectorId;
+  if (NetworkInspector.isEnabled()) {
+    inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
+    NetworkInspector._recordStart(
+      inspectorId,
+      url,
+      method,
+      headers ?? [],
+      typeof init?.body === 'string' ? init.body : undefined
+    );
+  }
+  const builder = NitroCronetSingleton.newUrlRequestBuilder(url);
+  builder.setHttpMethod(method);
+  headers?.forEach((h) => builder.addHeader(h.key, h.value));
+  const body = init?.body;
+  if (body != null) {
+    if (typeof body === 'string') builder.setUploadBody(body);
+    else if (body instanceof ArrayBuffer) builder.setUploadBody(body);
+  }
+  return new Promise((resolveResponse, rejectResponse) => {
+    let streamController;
+    const stream = new ReadableStream({
+      start(controller) {
+        streamController = controller;
+      },
+    });
+    let responseResolved = false;
+    let streamBytesReceived = 0;
+    builder.onResponseStarted((info) => {
+      if (responseResolved) return;
+      responseResolved = true;
+      const status = info.httpStatusCode;
+      const responseHeaders = new NitroHeaders(
+        Object.entries(info.allHeaders).map(([key, value]) => ({ key, value }))
+      );
+      const response = new NitroResponse({
+        url: info.url,
+        ok: status >= 200 && status < 300,
+        status,
+        statusText: info.httpStatusText,
+        headers: responseHeaders,
+        redirected: false,
+        body: stream,
+      });
+      resolveResponse(response);
+      // Android/Cronet: kick off the first buffer read.
+      // iOS/URLSession handles reading automatically so this is a no-op there.
+      request.read();
+    });
+    builder.onReadCompleted((_info, byteBuffer, bytesRead) => {
+      const chunk = new Uint8Array(byteBuffer, 0, bytesRead).slice();
+      streamBytesReceived += bytesRead;
+      streamController.enqueue(chunk);
+      if (!request.isDone()) {
+        request.read();
+      }
+    });
+    builder.onSucceeded((_info) => {
+      streamController.close();
+      if (inspectorId) {
+        const info = _info;
+        const status = info?.httpStatusCode ?? 0;
+        const hdrs = info?.allHeadersAsList ?? [];
+        NetworkInspector._recordEnd(
+          inspectorId,
+          status,
+          info?.httpStatusText ?? '',
+          hdrs,
+          streamBytesReceived
+        );
+      }
+    });
+    builder.onFailed((_info, error) => {
+      const err = new Error(error.message);
+      if (inspectorId) {
+        NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, error.message);
+      }
+      if (!responseResolved) {
+        responseResolved = true;
+        rejectResponse(err);
+      } else {
+        streamController.error(err);
+      }
+    });
+    builder.onCanceled(() => {
+      const err = createAbortError();
+      if (inspectorId) {
+        NetworkInspector._recordEnd(
+          inspectorId,
+          0,
+          '',
+          [],
+          0,
+          'Request canceled'
+        );
+      }
+      if (!responseResolved) {
+        responseResolved = true;
+        rejectResponse(err);
+      } else {
+        streamController.error(err);
+      }
     });
+    const request = builder.build();
+    request.start();
+  });
 }
 export async function nitroFetch(input, init) {
-    // Merge defaults from NitroRequestClass if input is one
-    if (input instanceof NitroRequestClass) {
-        init = {
-            ...init,
-            signal: init?.signal ?? input.signal,
-            redirect: init?.redirect ?? input.redirect,
-            cache: init?.cache ?? input.cache,
-        };
-    }
-    if (init?.stream === true) {
-        return nitroStreamFetch(input, init);
-    }
-    const redirectOption = init?.redirect ?? 'follow';
-    const res = await nitroFetchRaw(input, init);
-    // Handle redirect: "error" — if we got a 3xx back (followRedirects was false), throw
-    if (redirectOption === 'error' && res.status >= 300 && res.status < 400) {
-        throw new TypeError(`redirect mode is "error": redirected request to "${res.url}"`);
-    }
-    const response = new NitroResponse({
-        url: res.url,
-        status: res.status,
-        statusText: res.statusText,
-        ok: res.ok,
-        redirected: res.redirected,
-        headers: res.headers,
-        bodyBytes: res.bodyBytes,
-        bodyString: res.bodyString,
-    });
-    return response;
+  // Merge defaults from NitroRequestClass if input is one
+  if (input instanceof NitroRequestClass) {
+    init = {
+      ...init,
+      signal: init?.signal ?? input.signal,
+      redirect: init?.redirect ?? input.redirect,
+      cache: init?.cache ?? input.cache,
+    };
+  }
+  if (init?.stream === true) {
+    return nitroStreamFetch(input, init);
+  }
+  const redirectOption = init?.redirect ?? 'follow';
+  const res = await nitroFetchRaw(input, init);
+  // Handle redirect: "error" — if we got a 3xx back (followRedirects was false), throw
+  if (redirectOption === 'error' && res.status >= 300 && res.status < 400) {
+    throw new TypeError(
+      `redirect mode is "error": redirected request to "${res.url}"`
+    );
+  }
+  const response = new NitroResponse({
+    url: res.url,
+    status: res.status,
+    statusText: res.statusText,
+    ok: res.ok,
+    redirected: res.redirected,
+    headers: res.headers,
+    bodyBytes: res.bodyBytes,
+    bodyString: res.bodyString,
+  });
+  return response;
 }
 // Start a native prefetch. Requires a `prefetchKey` header on the request.
 export async function prefetch(input, init) {
-    // If native implementation is not present yet, do nothing
-    const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
-    if (!hasNative)
-        return;
-    // Build NitroRequest and ensure prefetchKey header exists
-    const req = buildNitroRequest(input, init);
-    const hasKey = req.headers?.some((h) => h.key.toLowerCase() === 'prefetchkey') ?? false;
-    // Also support passing prefetchKey via non-standard field on init
-    const fromInit = init?.prefetchKey;
-    if (!hasKey && fromInit) {
-        req.headers = (req.headers ?? []).concat([
-            { key: 'prefetchKey', value: fromInit },
-        ]);
-    }
-    const finalHasKey = req.headers?.some((h) => h.key.toLowerCase() === 'prefetchkey');
-    if (!finalHasKey) {
-        throw new Error('prefetch requires a "prefetchKey" header');
-    }
-    // Ensure client and call native prefetch
-    ensureClient();
-    if (!client || typeof client.prefetch !== 'function')
-        return;
-    await client.prefetch(req);
+  // If native implementation is not present yet, do nothing
+  const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
+  if (!hasNative) return;
+  // Build NitroRequest and ensure prefetchKey header exists
+  const req = buildNitroRequest(input, init);
+  const hasKey =
+    req.headers?.some((h) => h.key.toLowerCase() === 'prefetchkey') ?? false;
+  // Also support passing prefetchKey via non-standard field on init
+  const fromInit = init?.prefetchKey;
+  if (!hasKey && fromInit) {
+    req.headers = (req.headers ?? []).concat([
+      { key: 'prefetchKey', value: fromInit },
+    ]);
+  }
+  const finalHasKey = req.headers?.some(
+    (h) => h.key.toLowerCase() === 'prefetchkey'
+  );
+  if (!finalHasKey) {
+    throw new Error('prefetch requires a "prefetchKey" header');
+  }
+  // Ensure client and call native prefetch
+  ensureClient();
+  if (!client || typeof client.prefetch !== 'function') return;
+  await client.prefetch(req);
 }
+const AUTOPREFETCH_QUEUE_KEY = 'nitrofetch_autoprefetch_queue';
 // Persist a request to storage so native can prefetch it on app start.
 export async function prefetchOnAppStart(input, init) {
-    // Resolve request and prefetchKey
-    const req = buildNitroRequest(input, init);
-    const fromHeader = req.headers?.find((h) => h.key.toLowerCase() === 'prefetchkey')?.value;
-    const fromInit = init?.prefetchKey;
-    const prefetchKey = fromHeader ?? fromInit;
-    if (!prefetchKey) {
-        throw new Error('prefetchOnAppStart requires a "prefetchKey" (header or init.prefetchKey)');
-    }
-    // Convert headers to a plain object for storage
-    const headersObj = (req.headers ?? []).reduce((acc, { key, value }) => {
-        acc[String(key)] = String(value);
-        return acc;
-    }, {});
-    const entry = {
-        url: req.url,
-        prefetchKey,
-        headers: headersObj,
-    };
-    if (req.method && req.method !== 'GET')
-        entry.method = req.method;
-    if (req.bodyString !== undefined)
-        entry.bodyString = req.bodyString;
-    if (typeof req.bodyBytes === 'string' && req.bodyBytes.length > 0)
-        entry.bodyBytes = req.bodyBytes;
-    if (req.bodyFormData && req.bodyFormData.length > 0)
-        entry.bodyFormData = req.bodyFormData;
-    if (typeof req.timeoutMs === 'number')
-        entry.timeoutMs = req.timeoutMs;
-    if (req.followRedirects === false)
-        entry.followRedirects = false;
-    if (typeof req.prefetchCacheTtlMs === 'number')
-        entry.prefetchCacheTtlMs = req.prefetchCacheTtlMs;
-    // Write or append to storage queue
+  // Resolve request and prefetchKey
+  const req = buildNitroRequest(input, init);
+  const fromHeader = req.headers?.find(
+    (h) => h.key.toLowerCase() === 'prefetchkey'
+  )?.value;
+  const fromInit = init?.prefetchKey;
+  const prefetchKey = fromHeader ?? fromInit;
+  if (!prefetchKey) {
+    throw new Error(
+      'prefetchOnAppStart requires a "prefetchKey" (header or init.prefetchKey)'
+    );
+  }
+  // Convert headers to a plain object for storage
+  const headersObj = (req.headers ?? []).reduce((acc, { key, value }) => {
+    acc[String(key)] = String(value);
+    return acc;
+  }, {});
+  const entry = {
+    url: req.url,
+    prefetchKey,
+    headers: headersObj,
+  };
+  if (req.method && req.method !== 'GET') entry.method = req.method;
+  if (req.bodyString !== undefined) entry.bodyString = req.bodyString;
+  if (typeof req.bodyBytes === 'string' && req.bodyBytes.length > 0)
+    entry.bodyBytes = req.bodyBytes;
+  if (req.bodyFormData && req.bodyFormData.length > 0)
+    entry.bodyFormData = req.bodyFormData;
+  if (typeof req.timeoutMs === 'number') entry.timeoutMs = req.timeoutMs;
+  if (req.followRedirects === false) entry.followRedirects = false;
+  if (typeof req.prefetchCacheTtlMs === 'number')
+    entry.prefetchCacheTtlMs = req.prefetchCacheTtlMs;
+  // Write or append to storage queue
+  try {
+    let arr = [];
     try {
-        const KEY = 'nitrofetch_autoprefetch_queue';
-        let arr = [];
-        try {
-            const raw = NativeStorageSingleton.getString('nitrofetch_autoprefetch_queue');
-            if (raw)
-                arr = JSON.parse(raw);
-            if (!Array.isArray(arr))
-                arr = [];
-        }
-        catch {
-            arr = [];
-        }
-        if (arr.some((e) => e && e.prefetchKey === prefetchKey)) {
-            arr = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
-        }
-        arr.push(entry);
-        NativeStorageSingleton.setString(KEY, JSON.stringify(arr));
-    }
-    catch (e) {
-        console.warn('Failed to persist prefetch queue', e);
-    }
+      const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
+      if (raw) arr = JSON.parse(raw);
+      if (!Array.isArray(arr)) arr = [];
+    } catch {
+      arr = [];
+    }
+    if (arr.some((e) => e && e.prefetchKey === prefetchKey)) {
+      arr = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
+    }
+    arr.push(entry);
+    NativeStorageSingleton.setString(
+      AUTOPREFETCH_QUEUE_KEY,
+      JSON.stringify(arr)
+    );
+  } catch (e) {
+    console.warn('Failed to persist prefetch queue', e);
+  }
 }
 // Remove one entry (by prefetchKey) from the auto-prefetch queue.
 export async function removeFromAutoPrefetch(prefetchKey) {
+  try {
+    let arr = [];
     try {
-        const KEY = 'nitrofetch_autoprefetch_queue';
-        let arr = [];
-        try {
-            const raw = NativeStorageSingleton.getString('nitrofetch_autoprefetch_queue');
-            if (raw)
-                arr = JSON.parse(raw);
-            if (!Array.isArray(arr))
-                arr = [];
-        }
-        catch {
-            arr = [];
-        }
-        const next = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
-        if (next.length === 0) {
-            NativeStorageSingleton.removeString(KEY);
-        }
-        else if (next.length !== arr.length) {
-            NativeStorageSingleton.setString(KEY, JSON.stringify(next));
-        }
-    }
-    catch (e) {
-        console.warn('Failed to remove from prefetch queue', e);
-    }
+      const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
+      if (raw) arr = JSON.parse(raw);
+      if (!Array.isArray(arr)) arr = [];
+    } catch {
+      arr = [];
+    }
+    const next = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
+    if (next.length === 0) {
+      NativeStorageSingleton.removeString(AUTOPREFETCH_QUEUE_KEY);
+    } else if (next.length !== arr.length) {
+      NativeStorageSingleton.setString(
+        AUTOPREFETCH_QUEUE_KEY,
+        JSON.stringify(next)
+      );
+    }
+  } catch (e) {
+    console.warn('Failed to remove from prefetch queue', e);
+  }
 }
 // Remove all entries from the auto-prefetch queue.
 export async function removeAllFromAutoprefetch() {
-    const KEY = 'nitrofetch_autoprefetch_queue';
-    NativeStorageSingleton.setString(KEY, JSON.stringify([]));
+  NativeStorageSingleton.setString(AUTOPREFETCH_QUEUE_KEY, JSON.stringify([]));
 }
 export function __readAutoPrefetchQueue() {
-    try {
-        const raw = NativeStorageSingleton.getString('nitrofetch_autoprefetch_queue');
-        if (!raw)
-            return [];
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
+  try {
+    const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
 }
 let nitroRuntime;
 function ensureWorkletRuntime(name = 'nitro-fetch') {
-    try {
-        const { createWorkletRuntime } = require('react-native-worklets');
-        nitroRuntime = nitroRuntime ?? createWorkletRuntime(name);
-        return nitroRuntime;
-    }
-    catch {
-        console.warn('react-native-worklets not available');
-        return undefined;
-    }
+  try {
+    const { createWorkletRuntime } = require('react-native-worklets');
+    nitroRuntime = nitroRuntime ?? createWorkletRuntime(name);
+    return nitroRuntime;
+  } catch {
+    console.warn('react-native-worklets not available');
+    return undefined;
+  }
 }
 export async function nitroFetchOnWorklet(input, init, mapWorklet, options) {
-    const preferBytes = options?.preferBytes === true; // default true
-    let runOnRuntimeAsync;
-    let rt;
-    try {
-        rt = ensureWorkletRuntime(options?.runtimeName);
-        const worklets = require('react-native-worklets');
-        runOnRuntimeAsync = worklets.runOnRuntimeAsync;
-    }
-    catch {
-        // Module not available
-    }
-    // Fallback: if runtime is not available, do the work on JS
-    if (!runOnRuntimeAsync || !rt) {
-        console.warn('nitroFetchOnWorklet: no runtime, mapping on JS thread');
-        const res = await nitroFetchRaw(input, init);
-        const payload = {
-            url: res.url,
-            status: res.status,
-            statusText: res.statusText,
-            ok: res.ok,
-            redirected: res.redirected,
-            headers: res.headers,
-            bodyBytes: preferBytes ? res.bodyBytes : undefined,
-            bodyString: preferBytes ? undefined : res.bodyString,
-        };
-        return mapWorklet(payload);
-    }
-    return await runOnRuntimeAsync(rt, () => {
-        'worklet';
-        const nitroFetchClient = NitroFetchHybrid.createClient();
-        const request = buildNitroRequestPure(input, init);
-        const res = nitroFetchClient.requestSync(request);
-        const payload = {
-            url: res.url,
-            status: res.status,
-            statusText: res.statusText,
-            ok: res.ok,
-            redirected: res.redirected,
-            headers: res.headers,
-            bodyBytes: preferBytes ? res.bodyBytes : undefined,
-            bodyString: preferBytes ? undefined : res.bodyString,
-        };
-        return mapWorklet(payload);
-    });
+  const preferBytes = options?.preferBytes === true; // default true
+  let runOnRuntimeAsync;
+  let rt;
+  try {
+    rt = ensureWorkletRuntime(options?.runtimeName);
+    const worklets = require('react-native-worklets');
+    runOnRuntimeAsync = worklets.runOnRuntimeAsync;
+  } catch {
+    // Module not available
+  }
+  // Fallback: if runtime is not available, do the work on JS
+  if (!runOnRuntimeAsync || !rt) {
+    console.warn('nitroFetchOnWorklet: no runtime, mapping on JS thread');
+    const res = await nitroFetchRaw(input, init);
+    const payload = {
+      url: res.url,
+      status: res.status,
+      statusText: res.statusText,
+      ok: res.ok,
+      redirected: res.redirected,
+      headers: res.headers,
+      bodyBytes: preferBytes ? res.bodyBytes : undefined,
+      bodyString: preferBytes ? undefined : res.bodyString,
+    };
+    return mapWorklet(payload);
+  }
+  return await runOnRuntimeAsync(rt, () => {
+    'worklet';
+    const nitroFetchClient = NitroFetchHybrid.createClient();
+    const request = buildNitroRequestPure(input, init);
+    const res = nitroFetchClient.requestSync(request);
+    const payload = {
+      url: res.url,
+      status: res.status,
+      statusText: res.statusText,
+      ok: res.ok,
+      redirected: res.redirected,
+      headers: res.headers,
+      bodyBytes: preferBytes ? res.bodyBytes : undefined,
+      bodyString: preferBytes ? undefined : res.bodyString,
+    };
+    return mapWorklet(payload);
+  });
 }
 export { NitroHeaders } from './Headers';
 export { NitroResponse } from './Response';