react-native-fetch-client 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2849 @@
+// src/errors.ts
+function buildOptions(partial) {
+  const opts = {};
+  if (partial.config !== void 0) opts.config = partial.config;
+  if (partial.cause !== void 0) opts.cause = partial.cause;
+  return opts;
+}
+var FetchNativeError = class extends Error {
+  /** Discriminant code identifying the specific error type. */
+  code;
+  /**
+   * The resolved request configuration at the time of the error.
+   * Authorization header values are redacted to '[REDACTED]'.
+   */
+  config;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "FetchNativeError";
+    this.code = code;
+    if (options?.config !== void 0) {
+      this.config = options.config;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var HttpError = class extends FetchNativeError {
+  /** HTTP status code (e.g. 404, 500). */
+  status;
+  /** HTTP status text (e.g. 'Not Found', 'Internal Server Error'). */
+  statusText;
+  /**
+   * Parsed response body, if available and parseable.
+   * May be a string, object, or null depending on the response content.
+   */
+  data;
+  /** Response headers from the server. Keys are normalized to lowercase. */
+  headers;
+  /**
+   * The original Fetch Response object.
+   * Do not log this directly — it may contain sensitive header values.
+   */
+  response;
+  constructor(message, options) {
+    super(message, "HTTP_ERROR", buildOptions({ config: options.config }));
+    this.name = "HttpError";
+    this.status = options.status;
+    this.statusText = options.statusText;
+    this.data = options.data;
+    this.headers = options.headers;
+    this.response = options.response;
+  }
+};
+var NetworkError = class extends FetchNativeError {
+  constructor(message, options) {
+    super(message, "NETWORK_ERROR", options !== void 0 ? buildOptions(options) : void 0);
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends FetchNativeError {
+  /** The timeout that was exceeded, in milliseconds. */
+  timeoutMs;
+  constructor(timeoutMs, options) {
+    super(
+      `Request timed out after ${timeoutMs}ms`,
+      "TIMEOUT",
+      options !== void 0 ? buildOptions(options) : void 0
+    );
+    this.name = "TimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var CancelError = class extends FetchNativeError {
+  constructor(options) {
+    super(
+      "Request was cancelled",
+      "CANCELLED",
+      options !== void 0 ? buildOptions(options) : void 0
+    );
+    this.name = "CancelError";
+  }
+};
+var ParseError = class extends FetchNativeError {
+  /** HTTP status code of the response whose body could not be parsed. */
+  status;
+  /** The raw response body text that failed to parse, if retrievable. */
+  rawBody;
+  constructor(message, options) {
+    super(message, "PARSE_ERROR", buildOptions({ config: options.config, cause: options.cause }));
+    this.name = "ParseError";
+    this.status = options.status;
+    this.rawBody = options.rawBody;
+  }
+};
+var ConfigError = class extends FetchNativeError {
+  constructor(message, options) {
+    super(
+      message,
+      "CONFIG_ERROR",
+      options?.cause !== void 0 ? { cause: options.cause } : void 0
+    );
+    this.name = "ConfigError";
+  }
+};
+var RetryExhaustedError = class extends FetchNativeError {
+  /** The total number of attempts made (initial + retries). */
+  attempts;
+  /** The error from the last failed attempt. */
+  lastError;
+  constructor(attempts, lastError, options) {
+    const cause = lastError instanceof Error ? lastError : void 0;
+    super(
+      `Request failed after ${attempts} attempt${attempts === 1 ? "" : "s"}`,
+      "RETRY_EXHAUSTED",
+      buildOptions({ config: options?.config, cause })
+    );
+    this.name = "RetryExhaustedError";
+    this.attempts = attempts;
+    this.lastError = lastError;
+  }
+};
+var ValidationError = class extends FetchNativeError {
+  /** The raw unvalidated data returned by the server. */
+  data;
+  /** Detailed validation issue objects or messages if provided by the validator. */
+  issues;
+  constructor(message, options) {
+    super(message, "VALIDATION_ERROR", options !== void 0 ? buildOptions(options) : void 0);
+    this.name = "ValidationError";
+    this.data = options?.data;
+    if (options?.issues !== void 0) {
+      this.issues = options.issues;
+    }
+  }
+};
+var CircuitBreakerError = class extends FetchNativeError {
+  /** Current state of the circuit breaker at the moment of the rejection ('OPEN' | 'HALF_OPEN'). */
+  state;
+  /** Configured cooldown period before canary trial in milliseconds. */
+  resetTimeoutMs;
+  constructor(message, options) {
+    super(message, "CIRCUIT_OPEN", buildOptions(options));
+    this.name = "CircuitBreakerError";
+    this.state = options.state;
+    this.resetTimeoutMs = options.resetTimeoutMs;
+  }
+};
+function isFetchNativeError(err) {
+  return err instanceof FetchNativeError;
+}
+function isHttpError(err) {
+  return err instanceof HttpError;
+}
+function isNetworkError(err) {
+  return err instanceof NetworkError;
+}
+function isTimeoutError(err) {
+  return err instanceof TimeoutError;
+}
+function isCancelError(err) {
+  return err instanceof CancelError;
+}
+function isRetryExhaustedError(err) {
+  return err instanceof RetryExhaustedError;
+}
+function isValidationError(err) {
+  return err instanceof ValidationError;
+}
+function isCircuitBreakerError(err) {
+  return err instanceof CircuitBreakerError;
+}
+
+// src/url.ts
+function interpolatePath(url, pathParams) {
+  if (!pathParams || Object.keys(pathParams).length === 0) {
+    return url;
+  }
+  let result = url;
+  for (const [key, val] of Object.entries(pathParams)) {
+    if (val !== void 0 && val !== null) {
+      const encoded = encodeURIComponent(String(val));
+      const colonPattern = new RegExp(`:${key}(?=[/?#]|$)`, "g");
+      result = result.replace(colonPattern, encoded);
+      const bracePattern = new RegExp(`\\{${key}\\}`, "g");
+      result = result.replace(bracePattern, encoded);
+    }
+  }
+  return result;
+}
+function buildUrl(url = "", baseURL, params, pathParams) {
+  let resolvedUrl = interpolatePath(url, pathParams);
+  if (baseURL && !/^([a-z][a-z0-9+\-.]*:)?\/\//i.test(resolvedUrl)) {
+    const cleanBase = baseURL.replace(/\/+$/, "");
+    const cleanPath = resolvedUrl.replace(/^\/+/, "");
+    resolvedUrl = cleanPath ? `${cleanBase}/${cleanPath}` : cleanBase;
+  }
+  if (params) {
+    const searchParams = new URLSearchParams();
+    const [base, search] = resolvedUrl.split("?");
+    if (search) {
+      const existing = new URLSearchParams(search);
+      existing.forEach((val, key) => searchParams.append(key, val));
+    }
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== null && value !== void 0) {
+        searchParams.append(key, String(value));
+      }
+    }
+    const qs = searchParams.toString();
+    return qs ? `${base}?${qs}` : base || "";
+  }
+  return resolvedUrl;
+}
+
+// src/headers.ts
+function mergeHeaders(...headersList) {
+  const merged = {};
+  for (const headers of headersList) {
+    if (!headers) continue;
+    const h = new Headers(headers);
+    h.forEach((value, key) => {
+      merged[key.toLowerCase()] = value;
+    });
+  }
+  return merged;
+}
+
+// src/serialize.ts
+function serializeBody(body, headers, formUrlEncoded) {
+  if (body === null || body === void 0) {
+    return { body: null };
+  }
+  if (typeof body === "string") {
+    return { body, contentType: "text/plain" };
+  }
+  if (typeof FormData !== "undefined" && body instanceof FormData || typeof Blob !== "undefined" && body instanceof Blob || typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {
+    return { body };
+  }
+  const requestedContentType = headers ? headers["content-type"] ?? headers["Content-Type"] : void 0;
+  const isFormUrlEncoded = formUrlEncoded === true || typeof requestedContentType === "string" && requestedContentType.toLowerCase().includes("application/x-www-form-urlencoded");
+  if (isFormUrlEncoded && typeof body === "object") {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      if (value !== void 0 && value !== null) {
+        let strVal;
+        if (typeof value === "string") {
+          strVal = value;
+        } else if (typeof value === "number" || typeof value === "boolean") {
+          strVal = value.toString();
+        } else {
+          strVal = JSON.stringify(value);
+        }
+        params.append(key, strVal);
+      }
+    }
+    return {
+      body: params.toString(),
+      contentType: "application/x-www-form-urlencoded;charset=UTF-8"
+    };
+  }
+  return { body: JSON.stringify(body), contentType: "application/json" };
+}
+
+// src/parse.ts
+async function readBodyWithProgress(response, onProgress) {
+  const body = response.body;
+  if (!body || typeof body.getReader !== "function") {
+    const ab = await response.arrayBuffer();
+    const u8 = new Uint8Array(ab);
+    if (onProgress) {
+      onProgress({
+        loaded: u8.length,
+        total: u8.length,
+        progress: 1,
+        bytes: u8.length
+      });
+    }
+    return u8;
+  }
+  const contentLengthHeader = response.headers.get("content-length");
+  const total = contentLengthHeader ? parseInt(contentLengthHeader, 10) : void 0;
+  const isTotalValid = total !== void 0 && !isNaN(total) && total >= 0;
+  const reader = body.getReader();
+  const chunks = [];
+  let loaded = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      chunks.push(value);
+      loaded += value.length;
+      if (onProgress) {
+        const event = {
+          loaded,
+          bytes: value.length
+        };
+        if (isTotalValid) {
+          event.total = total;
+          event.progress = loaded / total;
+        }
+        onProgress(event);
+      }
+    }
+  }
+  const combined = new Uint8Array(loaded);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return combined;
+}
+async function parseResponse(response, responseType, config, onDownloadProgress) {
+  if (responseType === "none" || response.status === 204) {
+    await response.text().catch(() => {
+    });
+    return null;
+  }
+  if (responseType === "stream") {
+    return response.body;
+  }
+  let bodyBytes;
+  if (onDownloadProgress) {
+    bodyBytes = await readBodyWithProgress(response, onDownloadProgress);
+  }
+  if (responseType === "json") {
+    let text;
+    if (bodyBytes) {
+      text = new TextDecoder().decode(bodyBytes);
+    } else {
+      text = await response.text();
+    }
+    if (!text) return null;
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      throw new ParseError("Failed to parse JSON response", {
+        status: response.status,
+        rawBody: text,
+        config,
+        cause: err
+      });
+    }
+  }
+  if (responseType === "text") {
+    if (bodyBytes) return new TextDecoder().decode(bodyBytes);
+    return response.text();
+  }
+  if (responseType === "blob") {
+    if (bodyBytes) {
+      const mime = response.headers.get("content-type") ?? "";
+      return new Blob([bodyBytes.buffer], { type: mime });
+    }
+    return response.blob();
+  }
+  if (responseType === "arrayBuffer") {
+    if (bodyBytes) return bodyBytes.buffer;
+    return response.arrayBuffer();
+  }
+  if (bodyBytes) return new TextDecoder().decode(bodyBytes);
+  return response.text();
+}
+
+// src/retry.ts
+var DEFAULT_RETRY_POLICY = {
+  attempts: 0,
+  backoff: "exponential",
+  delay: 1e3,
+  maxDelay: 3e4,
+  jitter: true,
+  retryOn: [429, 500, 502, 503, 504],
+  safeMethods: ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"],
+  respectRetryAfter: true
+};
+function resolveRetryPolicy(clientRetry, requestRetry) {
+  if (requestRetry === false) {
+    return { ...DEFAULT_RETRY_POLICY, attempts: 0 };
+  }
+  const base = clientRetry === false ? { ...DEFAULT_RETRY_POLICY, attempts: 0 } : { ...DEFAULT_RETRY_POLICY, ...clientRetry };
+  const merged = { ...base, ...requestRetry };
+  const resolved = {
+    attempts: Math.max(0, merged.attempts ?? 0),
+    backoff: merged.backoff ?? "exponential",
+    delay: Math.max(0, merged.delay ?? 1e3),
+    maxDelay: Math.max(0, merged.maxDelay ?? 3e4),
+    jitter: merged.jitter ?? true,
+    retryOn: merged.retryOn ?? [429, 500, 502, 503, 504],
+    safeMethods: merged.safeMethods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"],
+    respectRetryAfter: merged.respectRetryAfter ?? true
+  };
+  if (merged.retryCondition !== void 0) {
+    resolved.retryCondition = merged.retryCondition;
+  }
+  return resolved;
+}
+function parseRetryAfter(headerValue) {
+  if (!headerValue || typeof headerValue !== "string") {
+    return null;
+  }
+  const trimmed = headerValue.trim();
+  if (/^\d+$/.test(trimmed)) {
+    const seconds = parseInt(trimmed, 10);
+    if (!isNaN(seconds) && seconds >= 0) {
+      return seconds * 1e3;
+    }
+    return null;
+  }
+  const dateMs = Date.parse(trimmed);
+  if (!isNaN(dateMs)) {
+    const diff = dateMs - Date.now();
+    return Math.max(0, diff);
+  }
+  return null;
+}
+function calculateRetryDelay(attempt, policy, error, randomFn = Math.random) {
+  if (policy.respectRetryAfter && error instanceof HttpError) {
+    const retryAfterHeader = error.headers["retry-after"];
+    const parsed = parseRetryAfter(retryAfterHeader);
+    if (parsed !== null) {
+      return Math.min(parsed, policy.maxDelay);
+    }
+  }
+  const normalizedAttempt = Math.max(1, attempt);
+  let delay;
+  if (policy.backoff === "linear") {
+    delay = policy.delay * normalizedAttempt;
+  } else {
+    delay = policy.delay * Math.pow(2, normalizedAttempt - 1);
+  }
+  delay = Math.min(delay, policy.maxDelay);
+  if (policy.jitter) {
+    delay = Math.floor(randomFn() * delay);
+  }
+  return Math.max(0, delay);
+}
+function shouldRetry(error, attempt, config) {
+  if (attempt > config.retry.attempts) {
+    return false;
+  }
+  if (!config.retry.safeMethods.includes(config.method)) {
+    return false;
+  }
+  if (error instanceof CancelError) {
+    return false;
+  }
+  if (error instanceof ConfigError) {
+    return false;
+  }
+  if (error instanceof ParseError) {
+    return false;
+  }
+  if (error instanceof TimeoutError) {
+    return false;
+  }
+  if (typeof config.retry.retryCondition === "function") {
+    return config.retry.retryCondition(error, attempt);
+  }
+  if (typeof config.retry.retryOn === "function") {
+    return config.retry.retryOn(error, attempt);
+  }
+  if (error instanceof HttpError) {
+    if (Array.isArray(config.retry.retryOn)) {
+      return config.retry.retryOn.includes(error.status);
+    }
+    return false;
+  }
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  return false;
+}
+function sleep(ms, signal) {
+  if (signal?.aborted) {
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+      return Promise.reject(reason);
+    }
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  if (ms <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    function onAbort() {
+      clearTimeout(timerId);
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      const reason = signal?.reason;
+      if (reason instanceof Error) {
+        reject(reason);
+      } else {
+        reject(new DOMException("Aborted", "AbortError"));
+      }
+    }
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timerId = setTimeout(() => {
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve();
+    }, ms);
+  });
+}
+
+// src/dedup.ts
+function generateDedupKey(method, url, headers = {}, credentials, body) {
+  const m = method.toUpperCase();
+  let normalizedUrl = url;
+  try {
+    const parsed = new URL(url, "http://localhost");
+    parsed.searchParams.sort();
+    normalizedUrl = parsed.pathname + parsed.search;
+  } catch {
+  }
+  const relevantKeys = ["accept", "content-type", "authorization", "accept-language"];
+  const headerPairs = [];
+  for (const k of Object.keys(headers).sort()) {
+    const lk = k.toLowerCase();
+    if (relevantKeys.includes(lk) && headers[k]) {
+      headerPairs.push(`${lk}=${headers[k]}`);
+    }
+  }
+  const creds = credentials || "same-origin";
+  let bodyStr = "";
+  if (body !== void 0 && body !== null) {
+    if (typeof body === "string") {
+      bodyStr = body;
+    } else {
+      try {
+        bodyStr = JSON.stringify(body) ?? "";
+      } catch {
+        bodyStr = "[unserializable-body]";
+      }
+    }
+  }
+  return `${m}|${normalizedUrl}|${creds}|${headerPairs.join("&")}|${bodyStr}`;
+}
+function isDedupEligible(method, requestDedup, clientDedup) {
+  if (requestDedup === false) {
+    return false;
+  }
+  let enabled = false;
+  if (requestDedup === true) {
+    enabled = true;
+  } else if (typeof requestDedup === "object" && requestDedup.enabled !== void 0) {
+    enabled = requestDedup.enabled;
+  } else if (clientDedup?.enabled) {
+    enabled = clientDedup.enabled;
+  }
+  if (!enabled) {
+    return false;
+  }
+  const allowedMethods = typeof requestDedup === "object" && requestDedup.methods || clientDedup?.methods || ["GET", "HEAD"];
+  return allowedMethods.includes(method);
+}
+var DedupManager = class {
+  inFlight = /* @__PURE__ */ new Map();
+  /**
+   * Executes or joins an in-flight request for the given deduplication key.
+   * If a matching request is already in flight, the caller subscribes to it.
+   * If an individual caller cancels their AbortSignal, that caller immediately rejects,
+   * but the underlying request continues for other subscribers.
+   * The underlying request is only aborted if all subscribers have cancelled.
+   */
+  execute(key, factory, callerSignal) {
+    if (callerSignal?.aborted) {
+      const reason = callerSignal.reason;
+      if (reason instanceof CancelError) {
+        return Promise.reject(reason);
+      }
+      return Promise.reject(
+        new CancelError({ cause: reason ?? new DOMException("Aborted", "AbortError") })
+      );
+    }
+    let entry = this.inFlight.get(key);
+    const isPrimary = !entry;
+    if (!entry) {
+      const underlyingAbortController = new AbortController();
+      const subscribers = /* @__PURE__ */ new Set();
+      const inFlightPromise = factory(underlyingAbortController.signal);
+      entry = {
+        key,
+        underlyingAbortController,
+        subscribers,
+        promise: inFlightPromise
+      };
+      this.inFlight.set(key, entry);
+      inFlightPromise.then((response) => {
+        this.inFlight.delete(key);
+        for (const sub of subscribers) {
+          sub.cleanup();
+          sub.resolve(response);
+        }
+      }).catch((error) => {
+        this.inFlight.delete(key);
+        for (const sub of subscribers) {
+          sub.cleanup();
+          sub.reject(error);
+        }
+      });
+    }
+    const currentEntry = entry;
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        cleanup();
+        const reason = callerSignal?.reason;
+        const cancelErr = reason instanceof CancelError ? reason : new CancelError({ cause: reason ?? new DOMException("Aborted", "AbortError") });
+        reject(cancelErr);
+        if (currentEntry.subscribers.size === 0) {
+          this.inFlight.delete(key);
+          currentEntry.underlyingAbortController.abort(
+            new DOMException("All subscribers aborted", "AbortError")
+          );
+        }
+      };
+      const cleanup = () => {
+        if (callerSignal) {
+          callerSignal.removeEventListener("abort", onAbort);
+        }
+        currentEntry.subscribers.delete(subscriber);
+      };
+      const subscriber = {
+        resolve: (res) => {
+          cleanup();
+          resolve(isPrimary ? { ...res, fromDedup: false } : { ...res, fromDedup: true });
+        },
+        reject: (err) => {
+          cleanup();
+          const errObj = err instanceof Error ? err : new Error(typeof err === "string" ? err : "Unknown error");
+          reject(errObj);
+        },
+        cleanup
+      };
+      if (callerSignal) {
+        callerSignal.addEventListener("abort", onAbort, { once: true });
+      }
+      currentEntry.subscribers.add(subscriber);
+    });
+  }
+  /** Returns the current number of active in-flight deduplicated requests. */
+  getActiveCount() {
+    return this.inFlight.size;
+  }
+  /** Clears all in-flight entries. */
+  clear() {
+    this.inFlight.clear();
+  }
+};
+
+// src/cache.ts
+var DEFAULT_TTL_MS = 6e4;
+var DEFAULT_MAX_SIZE = 100;
+var SAFE_CACHE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+function cloneData(data) {
+  if (data === null || typeof data !== "object") {
+    return data;
+  }
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(data);
+    } catch {
+    }
+  }
+  try {
+    return JSON.parse(JSON.stringify(data));
+  } catch {
+    return data;
+  }
+}
+function generateCacheKey(method, url, headers, allowAuthenticated = false) {
+  const normMethod = method.toUpperCase();
+  const urlObj = new URL(url, "http://localhost");
+  urlObj.searchParams.sort();
+  const sortedUrl = urlObj.pathname + (urlObj.search ? urlObj.search : "");
+  let authPart = "";
+  if (allowAuthenticated && headers) {
+    const authHeader = headers["authorization"] ?? headers["Authorization"];
+    if (authHeader) {
+      authPart = `|auth:${authHeader}`;
+    }
+  }
+  return `${normMethod}:${sortedUrl}${authPart}`;
+}
+function isCacheEligible(method, headers, requestCache, clientCache) {
+  const normMethod = method.toUpperCase();
+  if (!SAFE_CACHE_METHODS.has(normMethod)) {
+    return false;
+  }
+  if (requestCache === false) {
+    return false;
+  }
+  if (typeof requestCache === "object" && requestCache.skip === true) {
+    return false;
+  }
+  const enabled = typeof requestCache === "object" && !requestCache.skip || requestCache === true || (clientCache?.enabled ?? false);
+  if (!enabled) {
+    return false;
+  }
+  const allowedMethods = clientCache?.methods ?? ["GET", "HEAD"];
+  if (!allowedMethods.includes(normMethod)) {
+    return false;
+  }
+  const authHeader = headers ? headers["authorization"] ?? headers["Authorization"] : void 0;
+  if (authHeader && !(clientCache?.allowAuthenticated ?? false)) {
+    return false;
+  }
+  return true;
+}
+var CacheManager = class {
+  store = /* @__PURE__ */ new Map();
+  defaultTtl;
+  maxSize;
+  storage;
+  storageKey;
+  defaultStrategy;
+  constructor(config) {
+    this.defaultTtl = config?.defaultTtl ?? config?.ttl ?? DEFAULT_TTL_MS;
+    this.maxSize = config?.maxSize ?? DEFAULT_MAX_SIZE;
+    if (config?.storage !== void 0) {
+      this.storage = config.storage;
+    }
+    this.storageKey = config?.storageKey ?? "rnfc_http_cache";
+    this.defaultStrategy = config?.strategy ?? config?.defaultStrategy ?? "cache-first";
+    if (this.storage) {
+      void this.hydrate();
+    }
+  }
+  /**
+   * Hydrates cached entries from persistent storage into memory.
+   */
+  async hydrate() {
+    if (!this.storage) return;
+    try {
+      const raw = await this.storage.getItem(this.storageKey);
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      const now = Date.now();
+      if (Array.isArray(parsed)) {
+        for (const [key, entry] of parsed) {
+          if (entry && typeof entry === "object" && entry.expiresAt > now) {
+            this.store.set(key, entry);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Persists active (non-expired) cache entries to storage adapter.
+   */
+  async persist() {
+    if (!this.storage) return;
+    try {
+      const now = Date.now();
+      const entries = [];
+      for (const [key, entry] of this.store.entries()) {
+        if (entry.expiresAt > now) {
+          entries.push([key, entry]);
+        }
+      }
+      await this.storage.setItem(this.storageKey, JSON.stringify(entries));
+    } catch {
+    }
+  }
+  /**
+   * Retrieves a cached response by key.
+   * If expired and allowStale is false, evicts the entry and returns undefined.
+   */
+  get(key, options) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    const isExpired = Date.now() > entry.expiresAt;
+    if (isExpired && !options?.allowStale) {
+      this.store.delete(key);
+      if (this.storage) void this.persist();
+      return void 0;
+    }
+    this.store.delete(key);
+    this.store.set(key, entry);
+    const res = {
+      ...entry.response,
+      data: cloneData(entry.response.data),
+      cached: true
+    };
+    if (isExpired) {
+      res.stale = true;
+    }
+    return res;
+  }
+  /**
+   * Checks if an entry exists and is expired (stale).
+   */
+  isStale(key) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    return Date.now() > entry.expiresAt;
+  }
+  /**
+   * Retrieves the raw cache entry (including expired entries) for conditional revalidation.
+   */
+  getEntry(key) {
+    return this.store.get(key);
+  }
+  /**
+   * Revalidates an existing cache entry on receiving an HTTP 304 Not Modified response.
+   * Updates headers, extends TTL, and returns the response with fresh cached data.
+   */
+  updateFrom304(key, newHeaders, ttlMs) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    const ttl = ttlMs !== void 0 && ttlMs >= 0 ? ttlMs : this.defaultTtl;
+    entry.expiresAt = Date.now() + ttl;
+    const mergedHeaders = { ...entry.response.headers, ...newHeaders };
+    entry.response = {
+      ...entry.response,
+      headers: mergedHeaders
+    };
+    if (newHeaders["etag"] !== void 0) {
+      entry.etag = newHeaders["etag"];
+    }
+    if (newHeaders["last-modified"] !== void 0) {
+      entry.lastModified = newHeaders["last-modified"];
+    }
+    this.store.delete(key);
+    this.store.set(key, entry);
+    if (this.storage) void this.persist();
+    return {
+      ...entry.response,
+      data: cloneData(entry.response.data),
+      cached: true,
+      stale: false
+    };
+  }
+  set(key, response, ttlMs) {
+    const ttl = ttlMs !== void 0 && ttlMs >= 0 ? ttlMs : this.defaultTtl;
+    const expiresAt = Date.now() + ttl;
+    const etag = response.headers["etag"];
+    const lastModified = response.headers["last-modified"];
+    const entry = {
+      response: {
+        ...response,
+        data: cloneData(response.data),
+        cached: true
+      },
+      expiresAt
+    };
+    if (etag !== void 0) {
+      entry.etag = etag;
+    }
+    if (lastModified !== void 0) {
+      entry.lastModified = lastModified;
+    }
+    if (this.store.has(key)) {
+      this.store.delete(key);
+    } else if (this.store.size >= this.maxSize) {
+      const oldestKey = this.store.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.store.delete(oldestKey);
+      }
+    }
+    this.store.set(key, entry);
+    if (this.storage) void this.persist();
+  }
+  has(key) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      if (this.storage) void this.persist();
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    const deleted = this.store.delete(key);
+    if (deleted && this.storage) void this.persist();
+    return deleted;
+  }
+  deletePattern(pattern) {
+    let deletedCount = 0;
+    const keysToDelete = [];
+    for (const key of this.store.keys()) {
+      if (typeof pattern === "string") {
+        if (key.includes(pattern)) {
+          keysToDelete.push(key);
+        }
+      } else if (pattern.test(key)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      if (this.store.delete(key)) {
+        deletedCount++;
+      }
+    }
+    if (deletedCount > 0 && this.storage) void this.persist();
+    return deletedCount;
+  }
+  clear() {
+    this.store.clear();
+    if (this.storage) void this.storage.removeItem(this.storageKey);
+  }
+  get size() {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (now > entry.expiresAt) {
+        this.store.delete(key);
+      }
+    }
+    return this.store.size;
+  }
+};
+
+// src/validator.ts
+function buildValidationOptions(data, config, issues, cause) {
+  const opts = { data };
+  if (config !== void 0) opts.config = config;
+  if (issues !== void 0) opts.issues = issues;
+  if (cause !== void 0) opts.cause = cause;
+  return opts;
+}
+async function validateData(schema, data, config) {
+  if (!schema) {
+    return data;
+  }
+  if (typeof schema === "object" && schema !== null && "~standard" in schema && typeof schema["~standard"]?.validate === "function") {
+    try {
+      const standard = schema["~standard"];
+      const result = await standard.validate(data);
+      if ("issues" in result && result.issues && result.issues.length > 0) {
+        const firstIssue = result.issues[0];
+        const message = firstIssue?.message ? `Schema validation failed: ${firstIssue.message}` : "Schema validation failed";
+        throw new ValidationError(message, buildValidationOptions(data, config, result.issues));
+      }
+      if ("value" in result) {
+        return result.value;
+      }
+    } catch (err) {
+      if (err instanceof ValidationError) throw err;
+      const msg = err instanceof Error ? err.message : "Schema validation failed";
+      throw new ValidationError(msg, buildValidationOptions(data, config, void 0, err));
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "safeParse" in schema && typeof schema.safeParse === "function") {
+    try {
+      const res = schema.safeParse(data);
+      if (!res.success) {
+        const issues = res.error && "issues" in res.error ? res.error.issues : void 0;
+        throw new ValidationError(
+          res.error?.message ?? "Schema validation failed",
+          buildValidationOptions(data, config, issues, res.error)
+        );
+      }
+      return res.data;
+    } catch (err) {
+      if (err instanceof ValidationError) throw err;
+      const msg = err instanceof Error ? err.message : "Schema validation failed";
+      throw new ValidationError(msg, buildValidationOptions(data, config, void 0, err));
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "parse" in schema && typeof schema.parse === "function") {
+    try {
+      return schema.parse(data);
+    } catch (err) {
+      const issues = err !== null && typeof err === "object" && "issues" in err ? err.issues : void 0;
+      const msg = err instanceof Error ? err.message : "Schema validation failed";
+      throw new ValidationError(msg, buildValidationOptions(data, config, issues, err));
+    }
+  }
+  if (typeof schema === "function") {
+    try {
+      return await schema(data);
+    } catch (err) {
+      if (err instanceof ValidationError) throw err;
+      const msg = err instanceof Error ? err.message : "Schema validation failed";
+      throw new ValidationError(msg, buildValidationOptions(data, config, void 0, err));
+    }
+  }
+  return data;
+}
+
+// src/circuit-breaker.ts
+var DEFAULT_FAILURE_THRESHOLD = 5;
+var DEFAULT_RESET_TIMEOUT_MS = 3e4;
+function defaultIsFailure(err) {
+  if (isNetworkError(err) || isTimeoutError(err)) {
+    return true;
+  }
+  if (isHttpError(err) && err.status >= 500) {
+    return true;
+  }
+  return false;
+}
+var CircuitBreaker = class {
+  constructor(config) {
+    this.config = config;
+    this.failureThreshold = config.failureThreshold ?? DEFAULT_FAILURE_THRESHOLD;
+    this.resetTimeoutMs = config.resetTimeoutMs ?? DEFAULT_RESET_TIMEOUT_MS;
+    this.isFailureFn = config.isFailure ?? defaultIsFailure;
+  }
+  config;
+  state = "CLOSED";
+  failureCount = 0;
+  nextAttemptTime = 0;
+  failureThreshold;
+  resetTimeoutMs;
+  isFailureFn;
+  /**
+   * Current lifecycle state of the circuit breaker.
+   */
+  getState() {
+    if (this.state === "OPEN" && Date.now() >= this.nextAttemptTime) {
+      this.state = "HALF_OPEN";
+    }
+    return this.state;
+  }
+  /**
+   * Current consecutive failure count.
+   */
+  getFailures() {
+    return this.failureCount;
+  }
+  /**
+   * Resets the circuit breaker state to CLOSED and clears failure counts.
+   */
+  reset() {
+    this.state = "CLOSED";
+    this.failureCount = 0;
+    this.nextAttemptTime = 0;
+  }
+  /**
+   * Checks if a request is allowed to execute.
+   * Throws `CircuitBreakerError` if the circuit is currently OPEN.
+   */
+  beforeExecution() {
+    const currentState = this.getState();
+    if (currentState === "OPEN") {
+      const remainingMs = Math.max(0, this.nextAttemptTime - Date.now());
+      throw new CircuitBreakerError(
+        `Circuit breaker is OPEN. Service is temporarily unavailable (retry in ${Math.round(remainingMs / 1e3)}s)`,
+        {
+          state: "OPEN",
+          resetTimeoutMs: this.resetTimeoutMs
+        }
+      );
+    }
+  }
+  /**
+   * Records a successful execution. If the circuit was in HALF_OPEN state,
+   * it transitions back to CLOSED.
+   */
+  recordSuccess() {
+    this.failureCount = 0;
+    this.state = "CLOSED";
+  }
+  /**
+   * Records an execution error. Evaluates the failure predicate and
+   * updates the circuit state accordingly.
+   */
+  recordFailure(error) {
+    if (!this.isFailureFn(error)) {
+      return;
+    }
+    const currentState = this.getState();
+    if (currentState === "HALF_OPEN") {
+      this.state = "OPEN";
+      this.nextAttemptTime = Date.now() + this.resetTimeoutMs;
+      return;
+    }
+    this.failureCount++;
+    if (this.failureCount >= this.failureThreshold) {
+      this.state = "OPEN";
+      this.nextAttemptTime = Date.now() + this.resetTimeoutMs;
+    }
+  }
+  /**
+   * Executes a task wrapped in the circuit breaker lifecycle.
+   *
+   * @template T Return type of the task.
+   * @param task Function returning a Promise to execute.
+   * @returns Result of the task.
+   * @throws {CircuitBreakerError} If the circuit is OPEN.
+   */
+  async execute(task) {
+    this.beforeExecution();
+    try {
+      const result = await task();
+      this.recordSuccess();
+      return result;
+    } catch (err) {
+      this.recordFailure(err);
+      throw err;
+    }
+  }
+};
+
+// src/executor.ts
+var AuthRefreshError = class extends Error {
+  constructor(originalError) {
+    super("Auth refresh failed");
+    this.originalError = originalError;
+    this.name = "AuthRefreshError";
+  }
+  originalError;
+};
+async function dispatchFetch(url, method, headers, body, credentials, redirect, dispatcher, responseType, resolvedConfig, fetchImpl, signal, onDownloadProgress) {
+  const reqInit = {
+    method,
+    headers
+  };
+  if (body !== null && body !== void 0) {
+    reqInit.body = body;
+  }
+  if (credentials !== void 0) {
+    reqInit.credentials = credentials;
+  }
+  if (redirect !== void 0) {
+    reqInit.redirect = redirect;
+  }
+  if (dispatcher !== void 0) {
+    reqInit.dispatcher = dispatcher;
+  }
+  reqInit.signal = signal;
+  let requestObj;
+  try {
+    requestObj = new Request(url, reqInit);
+  } catch {
+    const fallbackUrl = /^https?:\/\//i.test(url) ? url : `http://localhost${url.startsWith("/") ? "" : "/"}${url}`;
+    requestObj = new Request(fallbackUrl, reqInit);
+  }
+  const getAbortError = () => {
+    const reason = signal.reason;
+    if (reason instanceof Error) return reason;
+    return new DOMException("Aborted", "AbortError");
+  };
+  let abortListener;
+  const abortPromise = new Promise((_, reject) => {
+    if (signal.aborted) {
+      reject(getAbortError());
+      return;
+    }
+    abortListener = () => {
+      reject(getAbortError());
+    };
+    signal.addEventListener("abort", abortListener, { once: true });
+  });
+  let response;
+  try {
+    response = await Promise.race([fetchImpl(requestObj, reqInit), abortPromise]);
+  } catch (err) {
+    if (err instanceof TimeoutError) throw err;
+    if (err instanceof CancelError) throw err;
+    if (err instanceof Error && err.name === "AbortError" || signal.aborted) {
+      const reason = signal.reason;
+      if (reason instanceof TimeoutError) throw reason;
+      if (reason instanceof CancelError) throw reason;
+      throw new CancelError({ config: resolvedConfig, cause: reason ?? err });
+    }
+    const msg = err instanceof Error ? err.message : "Network request failed";
+    throw new NetworkError(msg, { config: resolvedConfig, cause: err });
+  } finally {
+    if (abortListener) {
+      signal.removeEventListener("abort", abortListener);
+    }
+  }
+  const resHeaders = {};
+  response.headers.forEach((val, key) => {
+    resHeaders[key.toLowerCase()] = val;
+  });
+  if (response.status === 304) {
+    return {
+      data: null,
+      status: 304,
+      statusText: response.statusText,
+      headers: resHeaders,
+      config: resolvedConfig,
+      cached: true,
+      fromDedup: false,
+      request: requestObj
+    };
+  }
+  if (!response.ok) {
+    const clonedResponse = response.clone();
+    const errorData = await parseResponse(response, responseType, resolvedConfig).catch(() => null);
+    throw new HttpError(`HTTP Error ${response.status} ${response.statusText}`, {
+      status: response.status,
+      statusText: response.statusText,
+      data: errorData,
+      headers: resHeaders,
+      response: clonedResponse,
+      config: resolvedConfig
+    });
+  }
+  const data = await parseResponse(
+    response,
+    responseType,
+    resolvedConfig,
+    onDownloadProgress
+  );
+  return {
+    data,
+    status: response.status,
+    statusText: response.statusText,
+    headers: resHeaders,
+    config: resolvedConfig,
+    cached: false,
+    fromDedup: false,
+    request: requestObj
+  };
+}
+async function executeRequest(config, clientConfig = {}, authManager, dedupManager, cacheManager, circuitBreaker, concurrencyLimiter) {
+  if (concurrencyLimiter && !config._isFromConcurrency) {
+    return concurrencyLimiter.run(
+      () => executeRequest(
+        { ...config, _isFromConcurrency: true },
+        clientConfig,
+        authManager,
+        dedupManager,
+        cacheManager,
+        circuitBreaker,
+        concurrencyLimiter
+      ),
+      config.signal
+    );
+  }
+  const startTime = Date.now();
+  const urlStr = config.url ?? "";
+  const method = config.method ?? "GET";
+  const baseURL = config.baseURL ?? clientConfig.baseURL;
+  const params = { ...clientConfig.params, ...config.params };
+  const pathParams = config.pathParams;
+  const resolvedUrl = buildUrl(
+    urlStr,
+    baseURL,
+    params,
+    pathParams && Object.keys(pathParams).length > 0 ? pathParams : void 0
+  );
+  if (!resolvedUrl) {
+    throw new ConfigError("URL is required");
+  }
+  const baseHeaders = mergeHeaders(clientConfig.headers, config.headers);
+  const bearerSource = config.bearerToken ?? clientConfig.bearerToken;
+  if (bearerSource && !baseHeaders["authorization"] && !baseHeaders["Authorization"]) {
+    const tokenVal = typeof bearerSource === "function" ? await bearerSource() : bearerSource;
+    if (tokenVal) {
+      baseHeaders["authorization"] = `Bearer ${tokenVal}`;
+    }
+  }
+  if (authManager) {
+    await authManager.attachToken(baseHeaders, resolvedUrl, config.auth);
+  }
+  const activeBreaker = config.circuitBreaker === false ? void 0 : typeof config.circuitBreaker === "object" ? new CircuitBreaker(config.circuitBreaker) : circuitBreaker;
+  if (activeBreaker) {
+    activeBreaker.beforeExecution();
+  }
+  const cacheEligible = cacheManager !== void 0 && isCacheEligible(method, baseHeaders, config.cache, clientConfig.cache);
+  const cacheKey = cacheEligible ? generateCacheKey(method, resolvedUrl, baseHeaders, clientConfig.cache?.allowAuthenticated) : "";
+  if (cacheEligible && cacheManager) {
+    const cachedEntry = cacheManager.getEntry(cacheKey);
+    const etagEnabled = typeof config.cache === "object" && config.cache.etag !== void 0 ? config.cache.etag : clientConfig.cache?.etag ?? true;
+    if (cachedEntry) {
+      const isFresh = Date.now() <= cachedEntry.expiresAt;
+      const forceRevalidate = typeof config.cache === "object" && config.cache.etag === true;
+      const strategy = typeof config.cache === "object" && config.cache.strategy || clientConfig.cache?.strategy || clientConfig.cache?.defaultStrategy || "cache-first";
+      if (isFresh && !forceRevalidate) {
+        const cachedResponse = cacheManager.get(cacheKey);
+        if (cachedResponse !== void 0) {
+          return cachedResponse;
+        }
+      }
+      if (strategy === "stale-while-revalidate" && !config._isRevalidating) {
+        const staleResponse = cacheManager.get(cacheKey, { allowStale: true });
+        if (staleResponse !== void 0) {
+          const revalidateConfig = {
+            ...config,
+            _isRevalidating: true
+          };
+          void executeRequest(
+            revalidateConfig,
+            clientConfig,
+            authManager,
+            dedupManager,
+            cacheManager,
+            circuitBreaker,
+            concurrencyLimiter
+          ).then((freshRes) => {
+            const onRevalidated = typeof config.cache === "object" && config.cache?.onRevalidated || config.onRevalidated;
+            if (onRevalidated) {
+              onRevalidated(freshRes);
+            }
+          }).catch(() => {
+          });
+          return staleResponse;
+        }
+      }
+      if (etagEnabled) {
+        if (cachedEntry.etag && !baseHeaders["if-none-match"]) {
+          baseHeaders["if-none-match"] = cachedEntry.etag;
+        }
+        if (cachedEntry.lastModified && !baseHeaders["if-modified-since"]) {
+          baseHeaders["if-modified-since"] = cachedEntry.lastModified;
+        }
+      }
+    }
+  }
+  if (dedupManager && !config._isFromDedup && isDedupEligible(method, config.dedup, clientConfig.dedup)) {
+    const credentials2 = config.credentials ?? clientConfig.credentials;
+    const dedupKey = generateDedupKey(method, resolvedUrl, baseHeaders, credentials2, config.body);
+    return dedupManager.execute(
+      dedupKey,
+      (sharedSignal) => {
+        return executeRequest(
+          { ...config, signal: sharedSignal, _isFromDedup: true },
+          clientConfig,
+          authManager,
+          dedupManager,
+          cacheManager,
+          circuitBreaker,
+          concurrencyLimiter
+        );
+      },
+      config.signal
+    );
+  }
+  const formUrlEncoded = config.formUrlEncoded ?? clientConfig.formUrlEncoded;
+  const { body, contentType } = serializeBody(config.body, baseHeaders, formUrlEncoded);
+  if (contentType && !baseHeaders["content-type"]) {
+    baseHeaders["content-type"] = contentType;
+  }
+  if (typeof FormData !== "undefined" && config.body instanceof FormData) {
+    delete baseHeaders["content-type"];
+  }
+  const timeout = config.timeout ?? clientConfig.timeout ?? 0;
+  const responseType = config.responseType ?? clientConfig.responseType ?? "json";
+  const credentials = config.credentials ?? clientConfig.credentials;
+  const redirect = config.redirect ?? clientConfig.redirect;
+  const dispatcher = config.dispatcher ?? clientConfig.dispatcher;
+  const onDownloadProgress = config.onDownloadProgress ?? clientConfig.onDownloadProgress;
+  const onUploadProgress = config.onUploadProgress ?? clientConfig.onUploadProgress;
+  const fetchImpl = config.fetchImpl ?? clientConfig.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new ConfigError(
+      "globalThis.fetch is not available in this environment. react-native-fetch-client requires Node.js >= 18.0.0, a modern browser, or React Native. If you are running on Node.js 14 or 16, please upgrade to Node.js >= 18 or provide a fetch polyfill via the `fetchImpl` option (e.g. `createClient({ fetchImpl: nodeFetch })`)."
+    );
+  }
+  const resolvedRetry = resolveRetryPolicy(clientConfig.retry, config.retry);
+  const resolvedConfig = {
+    url: resolvedUrl,
+    method,
+    headers: { ...baseHeaders },
+    timeout,
+    responseType,
+    retry: resolvedRetry
+  };
+  if (Object.keys(params).length > 0) {
+    resolvedConfig.params = params;
+  }
+  if (pathParams && Object.keys(pathParams).length > 0) {
+    resolvedConfig.pathParams = pathParams;
+  }
+  if (credentials !== void 0) {
+    resolvedConfig.credentials = credentials;
+  }
+  const authHeaderKey = authManager ? authManager.getHeaderName() : "authorization";
+  if (resolvedConfig.headers[authHeaderKey]) {
+    resolvedConfig.headers[authHeaderKey] = "[REDACTED]";
+  }
+  if (resolvedConfig.headers["authorization"]) {
+    resolvedConfig.headers["authorization"] = "[REDACTED]";
+  }
+  let totalTimerId;
+  let onCallerAbort;
+  const totalController = new AbortController();
+  if (timeout > 0) {
+    totalTimerId = setTimeout(() => {
+      totalController.abort(new TimeoutError(timeout, { config: resolvedConfig }));
+    }, timeout);
+  }
+  if (config.signal) {
+    if (config.signal.aborted) {
+      const reason = config.signal.reason;
+      if (reason instanceof CancelError) throw reason;
+      throw new CancelError({ config: resolvedConfig, cause: reason });
+    }
+    onCallerAbort = () => {
+      const reason = config.signal?.reason;
+      totalController.abort(
+        reason instanceof Error ? reason : new CancelError({ config: resolvedConfig, cause: reason })
+      );
+    };
+    config.signal.addEventListener("abort", onCallerAbort);
+  }
+  const cleanup = () => {
+    if (totalTimerId !== void 0) {
+      clearTimeout(totalTimerId);
+    }
+    if (onCallerAbort && config.signal) {
+      config.signal.removeEventListener("abort", onCallerAbort);
+    }
+  };
+  if (onUploadProgress && body !== null && body !== void 0) {
+    let size = 0;
+    if (typeof body === "string") {
+      size = new TextEncoder().encode(body).length;
+    } else if (typeof Blob !== "undefined" && body instanceof Blob) {
+      size = body.size;
+    } else if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) {
+      size = body.byteLength;
+    } else if (typeof FormData !== "undefined" && body instanceof FormData) {
+      size = 1;
+      try {
+        let count = 0;
+        body.forEach((val) => {
+          if (typeof val === "string") {
+            count += val.length;
+          } else if (val && typeof val.size === "number") {
+            count += val.size;
+          }
+        });
+        if (count > 0) size = count;
+      } catch {
+      }
+    }
+    if (size > 0) {
+      onUploadProgress({
+        loaded: size,
+        total: size,
+        progress: 1,
+        bytes: size
+      });
+    }
+  }
+  const debugOpt = config.debug ?? clientConfig.debug;
+  const logSuccess = (res) => {
+    if (!debugOpt) return;
+    const durationMs = Date.now() - startTime;
+    const entry = {
+      method,
+      url: resolvedUrl,
+      status: res.status,
+      durationMs,
+      headers: resolvedConfig.headers,
+      cached: res.cached,
+      fromDedup: res.fromDedup
+    };
+    if (typeof debugOpt === "function") {
+      debugOpt(entry);
+    } else {
+      const tags = (res.cached ? " [CACHED]" : "") + (res.fromDedup ? " [DEDUP]" : "");
+      console.log(
+        `[react-native-fetch-client] ${method} ${resolvedUrl} -> ${res.status} ${res.statusText} (${durationMs}ms)${tags}`
+      );
+    }
+  };
+  const logError = (err) => {
+    if (!debugOpt) return;
+    const durationMs = Date.now() - startTime;
+    const entry = {
+      method,
+      url: resolvedUrl,
+      durationMs,
+      headers: resolvedConfig.headers,
+      error: err
+    };
+    if (typeof debugOpt === "function") {
+      debugOpt(entry);
+    } else {
+      console.warn(
+        `[react-native-fetch-client] ${method} ${resolvedUrl} -> ERROR (${durationMs}ms):`,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  };
+  let attempt = 0;
+  let lastError;
+  try {
+    while (true) {
+      attempt++;
+      try {
+        let response = await dispatchFetch(
+          resolvedUrl,
+          method,
+          baseHeaders,
+          body,
+          credentials,
+          redirect,
+          dispatcher,
+          responseType,
+          resolvedConfig,
+          fetchImpl,
+          totalController.signal,
+          onDownloadProgress
+        );
+        cleanup();
+        if (response.status === 304 && cacheManager && cacheKey) {
+          const reqTtl = typeof config.cache === "object" && config.cache.ttl !== void 0 ? config.cache.ttl : void 0;
+          const updated = cacheManager.updateFrom304(cacheKey, response.headers, reqTtl);
+          if (updated) {
+            response = updated;
+          }
+        } else if (cacheEligible && cacheManager) {
+          const reqTtl = typeof config.cache === "object" && config.cache.ttl !== void 0 ? config.cache.ttl : void 0;
+          cacheManager.set(cacheKey, response, reqTtl);
+        }
+        if (cacheManager && ["POST", "PUT", "PATCH", "DELETE"].includes(method.toUpperCase())) {
+          const urlObj = new URL(resolvedUrl, "http://localhost");
+          cacheManager.deletePattern(urlObj.pathname);
+        }
+        if (config.schema) {
+          const validatedData = await validateData(
+            config.schema,
+            response.data,
+            resolvedConfig
+          );
+          response = {
+            ...response,
+            data: validatedData
+          };
+        }
+        activeBreaker?.recordSuccess();
+        logSuccess(response);
+        return response;
+      } catch (err) {
+        lastError = err;
+        if (authManager && authManager.isEligibleForRefresh(err, resolvedUrl, config._isRefreshed, config.auth)) {
+          cleanup();
+          try {
+            await authManager.waitForRefresh(totalController.signal);
+            const retriedConfig = {
+              ...config,
+              _isRefreshed: true
+            };
+            return await executeRequest(
+              retriedConfig,
+              clientConfig,
+              authManager,
+              dedupManager,
+              cacheManager,
+              circuitBreaker,
+              concurrencyLimiter
+            );
+          } catch (refreshErr) {
+            if (totalController.signal.aborted) {
+              const reason = totalController.signal.reason;
+              if (reason instanceof TimeoutError) throw reason;
+              if (reason instanceof CancelError) throw reason;
+              throw new CancelError({ config: resolvedConfig, cause: reason });
+            }
+            throw new AuthRefreshError(refreshErr);
+          }
+        }
+        if (shouldRetry(err, attempt, resolvedConfig)) {
+          const delayMs = calculateRetryDelay(attempt, resolvedConfig.retry, err);
+          try {
+            await sleep(delayMs, totalController.signal);
+            continue;
+          } catch (sleepErr) {
+            if (totalController.signal.aborted) {
+              const reason = totalController.signal.reason;
+              if (reason instanceof TimeoutError) throw reason;
+              if (reason instanceof CancelError) throw reason;
+              throw new CancelError({ config: resolvedConfig, cause: reason });
+            }
+            throw sleepErr;
+          }
+        }
+        if (attempt > 1) {
+          throw new RetryExhaustedError(attempt, lastError, { config: resolvedConfig });
+        }
+        throw lastError;
+      }
+    }
+  } catch (err) {
+    cleanup();
+    activeBreaker?.recordFailure(err);
+    logError(err);
+    if (err instanceof AuthRefreshError) throw err.originalError;
+    if (err instanceof TimeoutError) throw err;
+    if (err instanceof CancelError) throw err;
+    if (err instanceof RetryExhaustedError) throw err;
+    if (err instanceof HttpError) throw err;
+    if (err instanceof ConfigError) throw err;
+    if (err instanceof ParseError) throw err;
+    if (err instanceof ValidationError) throw err;
+    if (err instanceof CircuitBreakerError) throw err;
+    if (err instanceof NetworkError) throw err;
+    if (err instanceof Error && err.name === "AbortError" || totalController.signal.aborted) {
+      const reason = totalController.signal.reason;
+      if (reason instanceof TimeoutError) throw reason;
+      if (reason instanceof CancelError) throw reason;
+      throw new CancelError({ config: resolvedConfig, cause: reason ?? err });
+    }
+    const msg = err instanceof Error ? err.message : "Network request failed";
+    throw new NetworkError(msg, { config: resolvedConfig, cause: err });
+  }
+}
+
+// src/auth.ts
+var AuthManager = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  activeRefreshPromise = null;
+  /** Returns the configured header name in lowercase, defaulting to 'authorization'. */
+  getHeaderName() {
+    return (this.config?.headerName || "Authorization").toLowerCase();
+  }
+  /**
+   * Attaches the access token retrieved from `getToken()` to request headers.
+   * Does not overwrite an existing explicit header of the same name.
+   */
+  async attachToken(headers, _url, requestAuth) {
+    if (!this.config?.getToken) {
+      return;
+    }
+    if (requestAuth === false || typeof requestAuth === "object" && requestAuth.skip) {
+      return;
+    }
+    const token = await this.config.getToken();
+    if (!token) {
+      return;
+    }
+    const headerKey = this.getHeaderName();
+    if (!headers[headerKey]) {
+      const prefix = this.config.tokenPrefix !== void 0 ? this.config.tokenPrefix : "Bearer ";
+      headers[headerKey] = `${prefix}${token}`;
+    }
+  }
+  /**
+   * Checks whether an error from a request URL is eligible for a token refresh attempt.
+   */
+  isEligibleForRefresh(error, url, isRefreshed, requestAuth) {
+    if (!this.config?.refreshToken) {
+      return false;
+    }
+    if (isRefreshed) {
+      return false;
+    }
+    if (requestAuth === false || typeof requestAuth === "object" && requestAuth.skip) {
+      return false;
+    }
+    if (!(error instanceof HttpError)) {
+      return false;
+    }
+    const refreshStatuses = this.config.refreshOn ?? [401];
+    if (!refreshStatuses.includes(error.status)) {
+      return false;
+    }
+    if (this.isExcludedUrl(url)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Initiates or shares an in-flight single-flight token refresh operation.
+   * Concurrent 401s await the same Promise. Cleared on completion or error.
+   */
+  refresh() {
+    const refreshTokenFn = this.config?.refreshToken;
+    if (!refreshTokenFn) {
+      return Promise.reject(new Error("refreshToken callback is not configured"));
+    }
+    if (this.activeRefreshPromise) {
+      return this.activeRefreshPromise;
+    }
+    this.activeRefreshPromise = Promise.resolve().then(() => refreshTokenFn()).finally(() => {
+      this.activeRefreshPromise = null;
+    });
+    return this.activeRefreshPromise;
+  }
+  /**
+   * Waits for token refresh while respecting the caller's request cancellation signal.
+   */
+  waitForRefresh(signal) {
+    if (signal?.aborted) {
+      const reason = signal.reason;
+      if (reason instanceof Error) {
+        return Promise.reject(reason);
+      }
+      return Promise.reject(new DOMException("Aborted", "AbortError"));
+    }
+    const refreshPromise = this.refresh();
+    if (!signal) {
+      return refreshPromise;
+    }
+    let abortHandler;
+    const abortPromise = new Promise((_, reject) => {
+      abortHandler = () => {
+        const reason = signal.reason;
+        if (reason instanceof Error) {
+          reject(reason);
+        } else {
+          reject(new DOMException("Aborted", "AbortError"));
+        }
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+    });
+    return Promise.race([refreshPromise, abortPromise]).finally(() => {
+      if (abortHandler) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+    });
+  }
+  isExcludedUrl(url) {
+    if (!this.config?.refreshExcludeUrls || this.config.refreshExcludeUrls.length === 0) {
+      return false;
+    }
+    return this.config.refreshExcludeUrls.some((entry) => {
+      if (typeof entry === "string") {
+        return url === entry || url.includes(entry);
+      }
+      return entry.test(url);
+    });
+  }
+};
+
+// src/concurrency.ts
+var ConcurrencyLimiter = class {
+  /**
+   * @param maxConcurrent Maximum number of concurrent tasks allowed to run simultaneously.
+   * If less than or equal to 0, concurrency is unlimited.
+   */
+  constructor(maxConcurrent) {
+    this.maxConcurrent = maxConcurrent;
+  }
+  maxConcurrent;
+  activeCount = 0;
+  queue = [];
+  /**
+   * Acquires a concurrency slot. Resolves immediately if active count < limit,
+   * otherwise blocks until a preceding task releases a slot.
+   */
+  async acquire(signal) {
+    if (this.maxConcurrent <= 0 || this.activeCount < this.maxConcurrent) {
+      this.activeCount++;
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const toError = (e, fallback) => {
+        if (e instanceof Error) return e;
+        return new Error(typeof e === "string" ? e : fallback);
+      };
+      let onAbort;
+      const item = {
+        resolve: () => {
+          if (signal && onAbort) {
+            signal.removeEventListener("abort", onAbort);
+          }
+          this.activeCount++;
+          resolve();
+        },
+        reject: (err) => {
+          if (signal && onAbort) {
+            signal.removeEventListener("abort", onAbort);
+          }
+          reject(toError(err, "Concurrency task failed"));
+        }
+      };
+      if (signal) {
+        if (signal.aborted) {
+          reject(toError(signal.reason, "Request was aborted while queued"));
+          return;
+        }
+        onAbort = () => {
+          const idx = this.queue.indexOf(item);
+          if (idx !== -1) {
+            this.queue.splice(idx, 1);
+          }
+          reject(toError(signal.reason, "Request was aborted while queued"));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      this.queue.push(item);
+    });
+  }
+  /**
+   * Releases an active concurrency slot and unblocks the next queued task in FIFO order.
+   */
+  release() {
+    this.activeCount--;
+    if (this.queue.length > 0 && this.activeCount < this.maxConcurrent) {
+      const next = this.queue.shift();
+      if (next) {
+        next.resolve();
+      }
+    }
+  }
+  /**
+   * Schedules an asynchronous function through the concurrency limiter.
+   *
+   * @template T The return type of the function.
+   * @param task Function returning a Promise to execute once a slot is available.
+   * @param signal Optional AbortSignal to cancel waiting in the queue.
+   * @returns The resolved value of the task.
+   */
+  async run(task, signal) {
+    if (this.maxConcurrent <= 0) {
+      return task();
+    }
+    await this.acquire(signal);
+    try {
+      return await task();
+    } finally {
+      this.release();
+    }
+  }
+  /**
+   * Current number of actively executing requests.
+   */
+  get active() {
+    return this.activeCount;
+  }
+  /**
+   * Current number of requests queued waiting for an available slot.
+   */
+  get pending() {
+    return this.queue.length;
+  }
+  /**
+   * Clears all queued pending requests and rejects them with the provided error.
+   */
+  clear(error = new Error("Concurrency queue was cancelled")) {
+    while (this.queue.length > 0) {
+      const item = this.queue.shift();
+      item?.reject(error);
+    }
+  }
+};
+
+// src/stream.ts
+async function* parseSseStream(stream, options) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent;
+  let currentData = [];
+  let currentId;
+  let currentRetry;
+  const rawLines = options?.rawLines ?? false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r\n|\r|\n/);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (rawLines) {
+          if (line.trim().length > 0) {
+            yield { data: line };
+          }
+          continue;
+        }
+        if (line.trim() === "") {
+          if (currentData.length > 0 || currentEvent !== void 0 || currentId !== void 0) {
+            const eventPayload = {
+              data: currentData.join("\n")
+            };
+            if (currentEvent !== void 0) {
+              eventPayload.event = currentEvent;
+            }
+            if (currentId !== void 0) {
+              eventPayload.id = currentId;
+            }
+            if (currentRetry !== void 0) {
+              eventPayload.retry = currentRetry;
+            }
+            yield eventPayload;
+            currentEvent = void 0;
+            currentData = [];
+            currentId = void 0;
+            currentRetry = void 0;
+          }
+          continue;
+        }
+        if (line.startsWith(":")) {
+          continue;
+        }
+        let field = line;
+        let valueStr = "";
+        const colonIdx = line.indexOf(":");
+        if (colonIdx !== -1) {
+          field = line.substring(0, colonIdx);
+          valueStr = line.substring(colonIdx + 1);
+          if (valueStr.startsWith(" ")) {
+            valueStr = valueStr.substring(1);
+          }
+        }
+        switch (field) {
+          case "event":
+            currentEvent = valueStr;
+            break;
+          case "data":
+            currentData.push(valueStr);
+            break;
+          case "id":
+            currentId = valueStr;
+            break;
+          case "retry": {
+            const parsed = parseInt(valueStr, 10);
+            if (!Number.isNaN(parsed)) {
+              currentRetry = parsed;
+            }
+            break;
+          }
+        }
+      }
+    }
+    if (buffer.trim().length > 0) {
+      const line = buffer;
+      if (rawLines) {
+        yield { data: line };
+      } else if (!line.startsWith(":")) {
+        let field = line;
+        let valueStr = "";
+        const colonIdx = line.indexOf(":");
+        if (colonIdx !== -1) {
+          field = line.substring(0, colonIdx);
+          valueStr = line.substring(colonIdx + 1);
+          if (valueStr.startsWith(" ")) {
+            valueStr = valueStr.substring(1);
+          }
+        }
+        if (field === "data") {
+          currentData.push(valueStr);
+        } else if (field === "event") {
+          currentEvent = valueStr;
+        } else if (field === "id") {
+          currentId = valueStr;
+        }
+      }
+    }
+    if (!rawLines && (currentData.length > 0 || currentEvent !== void 0)) {
+      const finalPayload = {
+        data: currentData.join("\n")
+      };
+      if (currentEvent !== void 0) {
+        finalPayload.event = currentEvent;
+      }
+      if (currentId !== void 0) {
+        finalPayload.id = currentId;
+      }
+      if (currentRetry !== void 0) {
+        finalPayload.retry = currentRetry;
+      }
+      yield finalPayload;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/interceptor.ts
+var DefaultInterceptorManager = class {
+  handlers = [];
+  nextId = 0;
+  /**
+   * Register a new interceptor.
+   * @returns Numeric registration ID used to eject.
+   */
+  use(fulfilled, rejected) {
+    const id = this.nextId++;
+    const entry = {
+      id,
+      interceptor: {
+        fulfilled
+      }
+    };
+    if (rejected !== void 0) {
+      entry.interceptor.rejected = rejected;
+    }
+    this.handlers.push(entry);
+    return id;
+  }
+  /**
+   * Remove a registered interceptor by ID.
+   */
+  eject(id) {
+    const index = this.handlers.findIndex((h) => h !== null && h.id === id);
+    if (index !== -1) {
+      this.handlers[index] = null;
+    }
+  }
+  /**
+   * Remove all registered interceptors.
+   */
+  clear() {
+    this.handlers = [];
+  }
+  /**
+   * Returns active interceptors in registration order.
+   */
+  getInterceptors() {
+    const active = [];
+    for (const h of this.handlers) {
+      if (h !== null) {
+        active.push(h.interceptor);
+      }
+    }
+    return active;
+  }
+};
+
+// src/paginate.ts
+function parseNextLinkHeader(header) {
+  if (!header) return null;
+  const parts = header.split(",");
+  for (const part of parts) {
+    const section = part.split(";");
+    if (section.length >= 2) {
+      const urlMatch = section[0]?.trim().match(/^<([^>]+)>/);
+      const relMatch = section[1]?.trim().match(/rel=["']?([^"']+)["']?/i);
+      if (urlMatch && relMatch && relMatch[1]?.toLowerCase() === "next") {
+        return urlMatch[1] ?? null;
+      }
+    }
+  }
+  return null;
+}
+function defaultExtractItems(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data && typeof data === "object") {
+    const obj = data;
+    for (const key of ["items", "data", "results", "records", "rows", "elements"]) {
+      if (Array.isArray(obj[key])) {
+        return obj[key];
+      }
+    }
+    for (const val of Object.values(obj)) {
+      if (Array.isArray(val)) {
+        return val;
+      }
+    }
+  }
+  return [];
+}
+function createPaginateHelper(client) {
+  async function* pagesGenerator(initialUrl, options) {
+    const cfg = options?.pagination ?? {};
+    const strategy = cfg.type ?? "page";
+    const pageParam = cfg.pageParam ?? cfg.param ?? "page";
+    const pageSizeParam = cfg.pageSizeParam ?? cfg.limitParam ?? "limit";
+    const pageSize = cfg.pageSize ?? cfg.limit;
+    const offsetParam = cfg.offsetParam ?? "offset";
+    const cursorParam = cfg.cursorParam ?? "cursor";
+    const maxPages = cfg.maxPages ?? cfg.totalPages ?? 50;
+    let currentPage = cfg.initialPage ?? 1;
+    let currentOffset = cfg.initialOffset ?? 0;
+    let currentCursor = cfg.initialCursor;
+    let currentUrl = initialUrl;
+    let pageCount = 0;
+    while (currentUrl && pageCount < maxPages) {
+      pageCount++;
+      const pageParams = {
+        ...options?.params ?? {}
+      };
+      if (strategy === "page") {
+        pageParams[pageParam] = currentPage;
+        if (pageSize !== void 0) {
+          pageParams[pageSizeParam] = pageSize;
+        }
+      } else if (strategy === "offset") {
+        pageParams[offsetParam] = currentOffset;
+        if (pageSize !== void 0) {
+          pageParams[pageSizeParam] = pageSize;
+        }
+      } else if (strategy === "cursor") {
+        if (currentCursor !== void 0 && currentCursor !== null) {
+          pageParams[cursorParam] = currentCursor;
+        }
+        if (cfg.pageSize !== void 0) {
+          pageParams[pageSizeParam] = cfg.pageSize;
+        }
+      }
+      const res = await client.get(currentUrl, {
+        ...options,
+        params: pageParams
+      });
+      yield res;
+      if (cfg.getNextUrl) {
+        currentUrl = cfg.getNextUrl(res) ?? null;
+      } else if (strategy === "linkHeader" || res.headers["link"]) {
+        currentUrl = parseNextLinkHeader(res.headers["link"]);
+      } else if (strategy === "cursor") {
+        if (cfg.getNextCursor) {
+          currentCursor = cfg.getNextCursor(res);
+        } else if (res.data && typeof res.data === "object") {
+          const obj = res.data;
+          currentCursor = obj["nextCursor"] ?? obj["next_cursor"] ?? obj["cursor"];
+        } else {
+          currentCursor = null;
+        }
+        if (!currentCursor) {
+          currentUrl = null;
+        }
+      } else if (strategy === "offset") {
+        const pageSize2 = cfg.pageSize ?? 10;
+        currentOffset += pageSize2;
+        const items = cfg.getItems ? cfg.getItems(res.data) : defaultExtractItems(res.data);
+        if (items.length === 0 || cfg.pageSize !== void 0 && items.length < cfg.pageSize) {
+          currentUrl = null;
+        }
+      } else {
+        currentPage++;
+        const items = cfg.getItems ? cfg.getItems(res.data) : defaultExtractItems(res.data);
+        if (items.length === 0 || cfg.pageSize !== void 0 && items.length < cfg.pageSize) {
+          currentUrl = null;
+        }
+      }
+    }
+  }
+  async function* itemsGenerator(url, options) {
+    const cfg = options?.pagination;
+    const customGetItems = cfg?.getItems;
+    const extractFn = customGetItems ? (d) => customGetItems(d) : (d) => defaultExtractItems(d);
+    for await (const page of pagesGenerator(url, options)) {
+      const items = extractFn(page.data);
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+  async function all(url, options) {
+    const results = [];
+    for await (const item of itemsGenerator(url, options)) {
+      results.push(item);
+    }
+    return results;
+  }
+  const helper = itemsGenerator;
+  helper.pages = pagesGenerator;
+  helper.all = all;
+  return helper;
+}
+
+// src/client.ts
+function createClient(config = {}) {
+  const clientConfig = { ...config };
+  const authManager = new AuthManager(config.auth);
+  const dedupManager = new DedupManager();
+  const cacheManager = new CacheManager(config.cache);
+  const circuitBreaker = config.circuitBreaker?.enabled ? new CircuitBreaker(config.circuitBreaker) : void 0;
+  const concurrencyLimiter = config.maxConcurrentRequests !== void 0 && config.maxConcurrentRequests > 0 ? new ConcurrencyLimiter(config.maxConcurrentRequests) : void 0;
+  const requestInterceptors = new DefaultInterceptorManager();
+  const responseInterceptors = new DefaultInterceptorManager();
+  const request = async (reqConfig) => {
+    let currentConfig = { ...reqConfig };
+    for (const interceptor of requestInterceptors.getInterceptors()) {
+      try {
+        currentConfig = await interceptor.fulfilled(currentConfig);
+      } catch (err) {
+        if (interceptor.rejected) {
+          currentConfig = await interceptor.rejected(err);
+        } else {
+          throw err;
+        }
+      }
+    }
+    let response;
+    try {
+      response = await executeRequest(
+        currentConfig,
+        clientConfig,
+        authManager,
+        dedupManager,
+        cacheManager,
+        circuitBreaker,
+        concurrencyLimiter
+      );
+    } catch (err) {
+      let currentError = err;
+      for (const interceptor of responseInterceptors.getInterceptors()) {
+        if (interceptor.rejected) {
+          try {
+            const recovered = await interceptor.rejected(currentError);
+            return recovered;
+          } catch (rejectedErr) {
+            currentError = rejectedErr;
+          }
+        }
+      }
+      throw currentError;
+    }
+    let currentResponse = response;
+    for (const interceptor of responseInterceptors.getInterceptors()) {
+      try {
+        currentResponse = await interceptor.fulfilled(currentResponse);
+      } catch (err) {
+        if (interceptor.rejected) {
+          currentResponse = await interceptor.rejected(err);
+        } else {
+          throw err;
+        }
+      }
+    }
+    const shouldUnwrap = currentConfig.unwrap ?? clientConfig.unwrap ?? false;
+    if (shouldUnwrap) {
+      return currentResponse.data;
+    }
+    return currentResponse;
+  };
+  const safeRequest = async (reqConfig) => {
+    try {
+      const res = await request({ ...reqConfig, unwrap: false });
+      return [res.data, null];
+    } catch (err) {
+      const fncError = isFetchNativeError(err) ? err : new NetworkError(err instanceof Error ? err.message : String(err), { cause: err });
+      return [null, fncError];
+    }
+  };
+  const safe = {
+    get: (url, reqConfig) => safeRequest({ ...reqConfig, url, method: "GET" }),
+    post: (url, body, reqConfig) => {
+      const merged = {
+        ...reqConfig,
+        url,
+        method: "POST"
+      };
+      if (body !== void 0) merged.body = body;
+      return safeRequest(merged);
+    },
+    put: (url, body, reqConfig) => {
+      const merged = {
+        ...reqConfig,
+        url,
+        method: "PUT"
+      };
+      if (body !== void 0) merged.body = body;
+      return safeRequest(merged);
+    },
+    patch: (url, body, reqConfig) => {
+      const merged = {
+        ...reqConfig,
+        url,
+        method: "PATCH"
+      };
+      if (body !== void 0) merged.body = body;
+      return safeRequest(merged);
+    },
+    delete: (url, reqConfig) => safeRequest({ ...reqConfig, url, method: "DELETE" }),
+    request: (reqConfig) => safeRequest(reqConfig)
+  };
+  async function* stream(url, options) {
+    const reqConfig = {
+      ...options,
+      url,
+      method: options?.method ?? "GET",
+      responseType: "stream",
+      unwrap: false
+    };
+    const response = await request(reqConfig);
+    if (!response.data || typeof response.data.getReader !== "function") {
+      return;
+    }
+    yield* parseSseStream(response.data, options);
+  }
+  const upload = async (url, file, options) => {
+    let formData;
+    const fieldName = options?.fieldName ?? "file";
+    if (typeof FormData !== "undefined" && file instanceof FormData) {
+      formData = file;
+      if (options?.extraFields) {
+        for (const [k, v] of Object.entries(options.extraFields)) {
+          formData.append(k, String(v));
+        }
+      }
+    } else if (typeof FormData !== "undefined") {
+      formData = new FormData();
+      if (typeof Blob !== "undefined" && file instanceof Blob) {
+        if (options?.fileName) {
+          formData.append(fieldName, file, options.fileName);
+        } else {
+          formData.append(fieldName, file);
+        }
+      } else if (file instanceof ArrayBuffer || file instanceof Uint8Array) {
+        const buffer = file instanceof Uint8Array ? file.buffer : file;
+        const blob = new Blob([buffer]);
+        if (options?.fileName) {
+          formData.append(fieldName, blob, options.fileName);
+        } else {
+          formData.append(fieldName, blob);
+        }
+      } else if (typeof file === "object" && file !== null) {
+        for (const [k, v] of Object.entries(file)) {
+          if (typeof Blob !== "undefined" && v instanceof Blob) {
+            formData.append(k, v);
+          } else if (v !== void 0 && v !== null) {
+            formData.append(k, String(v));
+          }
+        }
+      }
+      if (options?.extraFields) {
+        for (const [k, v] of Object.entries(options.extraFields)) {
+          formData.append(k, String(v));
+        }
+      }
+    } else {
+      throw new ConfigError("FormData is not available in this environment");
+    }
+    const mergedConfig = {
+      ...options,
+      url,
+      method: options?.method ?? "POST",
+      body: formData
+    };
+    return request(mergedConfig);
+  };
+  const client = {
+    request,
+    get: (url, reqConfig) => request({ ...reqConfig, url, method: "GET" }),
+    post: (url, body, reqConfig) => {
+      const merged = {
+        ...reqConfig,
+        url,
+        method: "POST"
+      };
+      if (body !== void 0) merged.body = body;
+      return request(merged);
+    },
+    put: (url, body, reqConfig) => {
+      const merged = {
+        ...reqConfig,
+        url,
+        method: "PUT"
+      };
+      if (body !== void 0) merged.body = body;
+      return request(merged);
+    },
+    patch: (url, body, reqConfig) => {
+      const merged = {
+        ...reqConfig,
+        url,
+        method: "PATCH"
+      };
+      if (body !== void 0) merged.body = body;
+      return request(merged);
+    },
+    delete: (url, reqConfig) => request({ ...reqConfig, url, method: "DELETE" }),
+    safe,
+    stream,
+    upload,
+    paginate: null,
+    cache: cacheManager,
+    interceptors: {
+      request: requestInterceptors,
+      response: responseInterceptors
+    }
+  };
+  client.paginate = createPaginateHelper(client);
+  return client;
+}
+
+// src/mock.ts
+function createMockAdapter(client, options) {
+  const handlers = [];
+  const history = {
+    get: [],
+    post: [],
+    put: [],
+    patch: [],
+    delete: [],
+    head: [],
+    options: [],
+    all: []
+  };
+  function matchesUrl(pattern, targetUrl) {
+    if (pattern instanceof RegExp) {
+      return pattern.test(targetUrl);
+    }
+    if (targetUrl === pattern) {
+      return true;
+    }
+    try {
+      const parsed = new URL(targetUrl, "http://localhost");
+      return parsed.pathname === pattern || parsed.pathname + parsed.search === pattern || targetUrl.includes(pattern);
+    } catch {
+      return targetUrl.includes(pattern);
+    }
+  }
+  function registerHandler(method, url = "") {
+    const handler = {
+      method,
+      url,
+      action: "reply",
+      status: 200,
+      reply(statusOrCallback, data, headers) {
+        if (typeof statusOrCallback === "function") {
+          handler.action = "reply";
+          handler.callback = statusOrCallback;
+        } else {
+          handler.action = "reply";
+          handler.status = statusOrCallback;
+          handler.data = data;
+          if (headers !== void 0) {
+            handler.headers = headers;
+          }
+        }
+      },
+      replyWithTimeout() {
+        handler.action = "timeout";
+      },
+      replyWithNetworkError(message) {
+        handler.action = "networkError";
+        handler.errorMessage = message ?? "Network request failed";
+      }
+    };
+    handlers.push(handler);
+    return handler;
+  }
+  const mockFetch = async (input, init) => {
+    if (options?.delayMs && options.delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, options.delayMs));
+    }
+    let urlString;
+    let method = init?.method?.toUpperCase() ?? "GET";
+    if (typeof input === "string") {
+      urlString = input;
+    } else if (input instanceof URL) {
+      urlString = input.toString();
+    } else {
+      urlString = input.url;
+      method = input.method.toUpperCase() ?? method;
+    }
+    const historyItem = {
+      url: urlString,
+      method
+    };
+    if (init?.headers) {
+      const hdrs = {};
+      if (typeof Headers !== "undefined" && init.headers instanceof Headers) {
+        init.headers.forEach((v, k) => {
+          hdrs[k] = v;
+        });
+      } else if (Array.isArray(init.headers)) {
+        for (const [k, v] of init.headers) {
+          hdrs[k] = v;
+        }
+      } else {
+        Object.assign(hdrs, init.headers);
+      }
+      historyItem.headers = hdrs;
+    }
+    if (init?.body) {
+      historyItem.body = init.body;
+    }
+    const lowerMethod = method.toLowerCase();
+    if (history[lowerMethod]) {
+      history[lowerMethod].push(historyItem);
+    }
+    history.all.push(historyItem);
+    let matched;
+    for (let i = handlers.length - 1; i >= 0; i--) {
+      const h = handlers[i];
+      if (!h) continue;
+      if (h.method === "ANY" || h.method === method) {
+        if (!h.url || matchesUrl(h.url, urlString)) {
+          matched = h;
+          break;
+        }
+      }
+    }
+    if (!matched) {
+      if (options?.passthrough && typeof globalThis.fetch === "function") {
+        return globalThis.fetch(input, init);
+      }
+      return new Response(
+        JSON.stringify({
+          error: `[react-native-fetch-client-mock] No mock handler registered for ${method} ${urlString}`
+        }),
+        {
+          status: 404,
+          statusText: "Not Found",
+          headers: { "content-type": "application/json" }
+        }
+      );
+    }
+    if (matched.action === "timeout") {
+      throw new TimeoutError(0);
+    }
+    if (matched.action === "networkError") {
+      throw new TypeError(matched.errorMessage ?? "Network request failed");
+    }
+    let status = matched.status ?? 200;
+    let data = matched.data;
+    let headers = matched.headers ?? {};
+    if (matched.callback) {
+      const reqConfig = {
+        url: urlString,
+        method
+      };
+      if (init?.body !== void 0) {
+        reqConfig.body = init.body;
+      }
+      const cbResult = await matched.callback(reqConfig);
+      status = cbResult[0];
+      if (cbResult[1] !== void 0) data = cbResult[1];
+      if (cbResult[2] !== void 0) headers = cbResult[2];
+    }
+    let bodyText = "";
+    if (typeof data === "string") {
+      bodyText = data;
+    } else if (data !== void 0 && data !== null) {
+      bodyText = JSON.stringify(data);
+    }
+    const resHeaders = {
+      "content-type": "application/json",
+      ...headers
+    };
+    return new Response(bodyText, {
+      status,
+      statusText: status === 200 ? "OK" : "Mock Response",
+      headers: resHeaders
+    });
+  };
+  const interceptorId = client.interceptors.request.use((config) => {
+    config.fetchImpl = mockFetch;
+    return config;
+  });
+  return {
+    onGet: (url = "") => registerHandler("GET", url),
+    onPost: (url = "") => registerHandler("POST", url),
+    onPut: (url = "") => registerHandler("PUT", url),
+    onPatch: (url = "") => registerHandler("PATCH", url),
+    onDelete: (url = "") => registerHandler("DELETE", url),
+    onAny: (url = "") => registerHandler("ANY", url),
+    reset() {
+      handlers.length = 0;
+      this.resetHistory();
+    },
+    resetHandlers() {
+      handlers.length = 0;
+    },
+    resetHistory() {
+      for (const key of Object.keys(history)) {
+        history[key].length = 0;
+      }
+    },
+    restore() {
+      client.interceptors.request.eject(interceptorId);
+      this.reset();
+    },
+    history
+  };
+}
+
+// src/offline/storage.ts
+var MemoryStorageAdapter = class {
+  store = /* @__PURE__ */ new Map();
+  getItem(key) {
+    return this.store.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.store.set(key, value);
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+};
+
+// src/offline/queue.ts
+var DEFAULT_STORAGE_KEY = "fnc_offline_queue";
+var DEFAULT_MAX_QUEUE_SIZE = 100;
+var DEFAULT_MAX_ATTEMPTS = 5;
+var DEFAULT_MAX_AGE_MS = 864e5;
+var DEFAULT_IDEMPOTENCY_HEADER = "Idempotency-Key";
+var DEFAULT_DISALLOWED_PATTERNS = [
+  /\/pay(\/|$)/i,
+  /\/payment(\/|$)/i,
+  /\/checkout(\/|$)/i,
+  /\/orders?(\/|$)/i,
+  /\/charge(\/|$)/i,
+  /\/billing(\/|$)/i,
+  /\/subscribe(\/|$)/i,
+  /\/refund(\/|$)/i
+];
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "req_" + Math.random().toString(36).substring(2, 15) + Date.now().toString(36);
+}
+function isDisallowed(url, customPatterns) {
+  for (const pattern of DEFAULT_DISALLOWED_PATTERNS) {
+    if (pattern.test(url)) return true;
+  }
+  if (customPatterns) {
+    for (const pattern of customPatterns) {
+      if (typeof pattern === "string") {
+        if (url.includes(pattern)) return true;
+      } else if (pattern.test(url)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function serializeBody2(body) {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") return body;
+  if (typeof FormData !== "undefined" && body instanceof FormData) {
+    throw new ConfigError("FormData bodies cannot be serialized to persistent offline storage");
+  }
+  if (typeof Blob !== "undefined" && body instanceof Blob) {
+    throw new ConfigError("Blob bodies cannot be serialized to persistent offline storage");
+  }
+  if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) {
+    throw new ConfigError("ArrayBuffer bodies cannot be serialized to persistent offline storage");
+  }
+  try {
+    return JSON.stringify(body);
+  } catch {
+    throw new ConfigError("Request body cannot be serialized for offline queue");
+  }
+}
+function createOfflineQueue(config) {
+  const storage = config.storage ?? new MemoryStorageAdapter();
+  const storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
+  const maxQueueSize = config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+  const maxAttempts = config.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  const maxAgeMs = config.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const idempotencyHeader = config.idempotencyHeader ?? DEFAULT_IDEMPOTENCY_HEADER;
+  let initialized = false;
+  let processing = false;
+  let inMemoryQueue = [];
+  const persist = async () => {
+    const raw = JSON.stringify(inMemoryQueue);
+    await storage.setItem(storageKey, raw);
+  };
+  const initialize = async () => {
+    if (initialized) return;
+    try {
+      const stored = await storage.getItem(storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        const now = Date.now();
+        inMemoryQueue = parsed.filter((item) => now - item.enqueuedAt < maxAgeMs);
+      }
+    } catch {
+      inMemoryQueue = [];
+    }
+    initialized = true;
+    await persist();
+  };
+  const enqueue = async (reqConfig) => {
+    await initialize();
+    const url = reqConfig.url ?? "";
+    if (!url) {
+      throw new ConfigError("Cannot enqueue request without a URL");
+    }
+    if (isDisallowed(url, config.disallowedUrls)) {
+      throw new ConfigError(
+        `Offline queuing is prohibited for critical/payment URL: "${url}". Please retry with network connectivity.`
+      );
+    }
+    if (config.shouldQueue && !config.shouldQueue(reqConfig)) {
+      return { enqueued: false, id: "" };
+    }
+    if (inMemoryQueue.length >= maxQueueSize) {
+      throw new ConfigError(
+        `Offline queue capacity limit of ${maxQueueSize} entries reached. Cannot enqueue request.`
+      );
+    }
+    const method = reqConfig.method ?? "GET";
+    const serializedBody = serializeBody2(reqConfig.body);
+    const id = generateId();
+    let assignedIdempotencyKey = "";
+    const normHeaders = {};
+    if (reqConfig.headers) {
+      if (typeof reqConfig.headers.forEach === "function") {
+        reqConfig.headers.forEach((v, k) => {
+          normHeaders[k.toLowerCase()] = v;
+        });
+      } else if (Array.isArray(reqConfig.headers)) {
+        for (const [k, v] of reqConfig.headers) {
+          normHeaders[k.toLowerCase()] = v;
+        }
+      } else {
+        for (const [k, v] of Object.entries(reqConfig.headers)) {
+          if (typeof v === "string") {
+            normHeaders[k.toLowerCase()] = v;
+          }
+        }
+      }
+      assignedIdempotencyKey = normHeaders[idempotencyHeader.toLowerCase()] ?? normHeaders["idempotency-key"] ?? normHeaders["x-idempotency-key"] ?? "";
+    }
+    if (!assignedIdempotencyKey) {
+      assignedIdempotencyKey = id;
+      normHeaders[idempotencyHeader.toLowerCase()] = assignedIdempotencyKey;
+    }
+    const queuedItem = {
+      id,
+      url,
+      method,
+      headers: normHeaders,
+      enqueuedAt: Date.now(),
+      attemptCount: 0,
+      maxAttempts,
+      idempotencyKey: assignedIdempotencyKey
+    };
+    if (reqConfig.params) {
+      queuedItem.params = { ...reqConfig.params };
+    }
+    if (serializedBody !== void 0) {
+      queuedItem.body = serializedBody;
+    }
+    inMemoryQueue.push(queuedItem);
+    await persist();
+    return { enqueued: true, id };
+  };
+  const process = async () => {
+    await initialize();
+    if (processing) {
+      return {
+        processed: 0,
+        succeeded: 0,
+        failedPermanent: 0,
+        failedTransient: 0,
+        remaining: inMemoryQueue.length
+      };
+    }
+    processing = true;
+    let succeeded = 0;
+    let failedPermanent = 0;
+    let failedTransient = 0;
+    let processed = 0;
+    try {
+      while (inMemoryQueue.length > 0) {
+        const current = inMemoryQueue[0];
+        if (!current) break;
+        if (Date.now() - current.enqueuedAt > maxAgeMs) {
+          inMemoryQueue.shift();
+          failedPermanent++;
+          processed++;
+          config.onPermanentFailure?.(
+            current,
+            new ConfigError(`Queued request expired after ${maxAgeMs}ms`)
+          );
+          await persist();
+          continue;
+        }
+        current.attemptCount++;
+        processed++;
+        let parsedBody = current.body;
+        if (current.body && (current.body.startsWith("{") || current.body.startsWith("["))) {
+          try {
+            parsedBody = JSON.parse(current.body);
+          } catch {
+            parsedBody = current.body;
+          }
+        }
+        const requestConfig = {
+          url: current.url,
+          method: current.method
+        };
+        if (current.headers) {
+          requestConfig.headers = current.headers;
+        }
+        if (current.params) {
+          requestConfig.params = current.params;
+        }
+        if (parsedBody !== void 0 && parsedBody !== null) {
+          requestConfig.body = parsedBody;
+        }
+        try {
+          const response = await config.client.request(requestConfig);
+          inMemoryQueue.shift();
+          succeeded++;
+          await persist();
+          config.onReplaySuccess?.(current, response);
+        } catch (err) {
+          const is4xx = isHttpError(err) && err.status >= 400 && err.status < 500 && err.status !== 429;
+          const isExhausted = current.attemptCount >= current.maxAttempts;
+          if (is4xx || isExhausted) {
+            inMemoryQueue.shift();
+            failedPermanent++;
+            await persist();
+            config.onPermanentFailure?.(current, err);
+          } else if (isNetworkError(err) || isTimeoutError(err)) {
+            failedTransient++;
+            await persist();
+            break;
+          } else {
+            failedTransient++;
+            await persist();
+            break;
+          }
+        }
+      }
+    } finally {
+      processing = false;
+    }
+    return {
+      processed,
+      succeeded,
+      failedPermanent,
+      failedTransient,
+      remaining: inMemoryQueue.length
+    };
+  };
+  const getItems = async () => {
+    await initialize();
+    return [...inMemoryQueue];
+  };
+  const size = async () => {
+    await initialize();
+    return inMemoryQueue.length;
+  };
+  const clear = async () => {
+    inMemoryQueue = [];
+    initialized = true;
+    await storage.removeItem(storageKey);
+  };
+  let onlineListener;
+  if (config.autoSyncOnOnline && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    onlineListener = () => {
+      process().catch(() => {
+      });
+    };
+    window.addEventListener("online", onlineListener);
+  }
+  const destroy = () => {
+    if (onlineListener && typeof window !== "undefined" && typeof window.removeEventListener === "function") {
+      window.removeEventListener("online", onlineListener);
+      onlineListener = void 0;
+    }
+  };
+  const isProcessing = () => processing;
+  return {
+    enqueue,
+    process,
+    isProcessing,
+    getItems,
+    size,
+    clear,
+    initialize,
+    destroy
+  };
+}
+
+export { AuthManager, CacheManager, CancelError, CircuitBreaker, CircuitBreakerError, ConcurrencyLimiter, ConfigError, DedupManager, DefaultInterceptorManager, FetchNativeError, HttpError, MemoryStorageAdapter, NetworkError, ParseError, RetryExhaustedError, TimeoutError, ValidationError, buildUrl, cloneData, createClient, createMockAdapter, createOfflineQueue, createPaginateHelper, generateCacheKey, generateDedupKey, interpolatePath, isCacheEligible, isCancelError, isCircuitBreakerError, isFetchNativeError, isHttpError, isNetworkError, isRetryExhaustedError, isTimeoutError, isValidationError, parseNextLinkHeader, parseSseStream, validateData };