react-native-nitro-fetch 1.3.0 → 1.3.2

package/src/fetch.js

@@ -0,0 +1,787 @@
+import 'web-streams-polyfill/polyfill';
+import {
+  NitroFetch as NitroFetchSingleton,
+  NitroCronetSingleton,
+} from './NitroInstances';
+import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
+import { NitroHeaders } from './Headers';
+import { NitroResponse } from './Response';
+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;
+  }
+  // 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;
+}
+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;
+  }
+  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;
+}
+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');
+}
+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;
+}
+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,
+  };
+}
+// 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;
+  }
+  // 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;
+}
+// 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)'
+  );
+}
+// 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,
+  };
+}
+function createAbortError() {
+  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;
+  }
+}
+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;
+}
+async function nitroFetchRaw(input, init) {
+  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 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();
+  });
+}
+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;
+}
+// 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);
+}
+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
+  try {
+    let arr = [];
+    try {
+      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 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() {
+  NativeStorageSingleton.setString(AUTOPREFETCH_QUEUE_KEY, JSON.stringify([]));
+}
+export function __readAutoPrefetchQueue() {
+  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;
+  }
+}
+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);
+  });
+}
+export { NitroHeaders } from './Headers';
+export { NitroResponse } from './Response';
+export { NitroRequest as NitroRequestClass } from './Request';