@boy-offi9-inc/reqkit 0.3.0 → 0.6.0

package/dist/reqkit.mjs

@@ -0,0 +1,2507 @@
+/*! @boy-offi9-inc/reqkit v0.6.0 — ESM bundle (generated by scripts/build-esm.js, do not edit) */
+const __defs = {
+"./HTTPError": function (module, exports, require) {
+class HTTPError extends Error {
+  constructor(response, request) {
+    const statusText = response.statusText ? ` ${response.statusText}` : "";
+    super(`Request failed with status ${response.status}${statusText}: ${request.method} ${request.url}`);
+    this.name = "HTTPError";
+    this.status = response.status;
+    this.statusText = response.statusText || "";
+    this.response = response;
+    this.url = request.url;
+    this.method = request.method;
+  }
+}
+
+module.exports = { HTTPError };
+
+},
+"./_cache": function (module, exports, require) {
+// Helpers for createFetch's response cache.
+
+const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+
+function cacheKey(method, url, headers) {
+  // Every request header is part of the key, so responses fetched with one
+  // user's Authorization header can never be served to another.
+  return `${method} ${url} ${JSON.stringify([...headers.entries()].sort())}`;
+}
+
+/**
+ * Reads a response (via a clone — the original stays usable) into a plain,
+ * storable entry. Returns null when the response must not be cached.
+ */
+async function snapshotResponse(response, maxBodyBytes = DEFAULT_MAX_BODY_BYTES) {
+  if (response.status !== 200) return null;
+
+  const cacheControl = (response.headers.get("cache-control") || "").toLowerCase();
+  if (/\bno-store\b/.test(cacheControl)) return null;
+  if ((response.headers.get("vary") || "").trim() === "*") return null;
+
+  const declared = Number(response.headers.get("content-length"));
+  if (response.headers.has("content-length") && declared > maxBodyBytes) return null;
+
+  const copy = response.clone();
+  const buffer = await copy.arrayBuffer();
+  if (buffer.byteLength > maxBodyBytes) return null;
+
+  const headers = [];
+  response.headers.forEach((value, key) => {
+    // The body we stored is already decoded; replaying these would corrupt it.
+    if (key === "content-encoding" || key === "content-length" || key === "transfer-encoding") return;
+    headers.push([key, value]);
+  });
+
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+    body: new Uint8Array(buffer),
+    storedAt: Date.now(),
+    etag: response.headers.get("etag"),
+    lastModified: response.headers.get("last-modified"),
+  };
+}
+
+function entryToResponse(entry) {
+  return new Response(entry.body.slice(), {
+    status: entry.status,
+    statusText: entry.statusText,
+    headers: entry.headers,
+  });
+}
+
+module.exports = { cacheKey, snapshotResponse, entryToResponse, DEFAULT_MAX_BODY_BYTES };
+
+},
+"./_http": function (module, exports, require) {
+/**
+ * Parses a Retry-After header value into milliseconds. Per HTTP spec it's
+ * either an integer number of seconds, or an HTTP-date.
+ */
+function parseRetryAfter(headerValue) {
+  if (headerValue === null || headerValue === undefined) return null;
+  const value = String(headerValue).trim();
+  if (!value) return null;
+
+  // delta-seconds (spec says integer; tolerate "1.5" from sloppy servers)
+  if (/^\d+(\.\d+)?$/.test(value)) {
+    return Number(value) * 1000;
+  }
+
+  const dateMs = Date.parse(value);
+  if (!Number.isNaN(dateMs)) {
+    return Math.max(0, dateMs - Date.now());
+  }
+
+  return null;
+}
+
+// Reset headers come in two flavors: a delta in seconds ("30", the IETF
+// RateLimit-Reset draft, Discord's *-Reset-After) or an absolute epoch
+// (GitHub/Twitter style, seconds or ms). Anything under ~31 years in seconds
+// can't be a real epoch, so treat it as a delta.
+function parseResetMs(value) {
+  if (value === null || value === undefined || String(value).trim() === "") return null;
+  const n = Number(value);
+  if (Number.isNaN(n) || n < 0) return null;
+  if (n < 1e9) return n * 1000;
+  const epochMs = n > 4102444800 ? n : n * 1000;
+  return Math.max(0, epochMs - Date.now());
+}
+
+function readHeader(headers, ...names) {
+  for (const name of names) {
+    const v = headers.get(name);
+    if (v !== null && v !== undefined && v !== "") return v;
+  }
+  return null;
+}
+
+/**
+ * Reads a wait time from common rate-limit headers, trying Retry-After first,
+ * then falling back to X-RateLimit-Reset(-After) if present.
+ */
+function getWaitMsFromHeaders(headers) {
+  if (!headers || typeof headers.get !== "function") return null;
+
+  const retryAfter = parseRetryAfter(headers.get("retry-after"));
+  if (retryAfter !== null) return retryAfter;
+
+  return parseResetMs(
+    readHeader(headers, "x-ratelimit-reset-after", "x-ratelimit-reset", "x-rate-limit-reset", "ratelimit-reset")
+  );
+}
+
+/**
+ * Everything useful a response says about rate limits:
+ *   { remaining: number|null, resetMs: number|null, retryAfterMs: number|null }
+ * Understands X-RateLimit-*, X-Rate-Limit-*, RateLimit-* and Retry-After.
+ */
+function getRateLimitInfo(headers) {
+  const info = { remaining: null, resetMs: null, retryAfterMs: null };
+  if (!headers || typeof headers.get !== "function") return info;
+
+  const remaining = readHeader(headers, "x-ratelimit-remaining", "x-rate-limit-remaining", "ratelimit-remaining");
+  if (remaining !== null && !Number.isNaN(Number(remaining))) info.remaining = Number(remaining);
+
+  info.resetMs = parseResetMs(
+    readHeader(headers, "x-ratelimit-reset-after", "x-ratelimit-reset", "x-rate-limit-reset", "ratelimit-reset")
+  );
+  info.retryAfterMs = parseRetryAfter(headers.get("retry-after"));
+  return info;
+}
+
+async function discardBody(response) {
+  // An unread body keeps the underlying connection busy; cancel it before
+  // we sit through a backoff and fire the next request.
+  try {
+    if (response.body && typeof response.body.cancel === "function" && !response.bodyUsed) {
+      await response.body.cancel();
+    }
+  } catch {
+    // locked / already consumed / not a web stream — safe to ignore
+  }
+}
+
+module.exports = { parseRetryAfter, parseResetMs, getWaitMsFromHeaders, getRateLimitInfo, discardBody };
+
+},
+"./_sleep": function (module, exports, require) {
+class RetryAbortedError extends Error {
+  constructor(cause) {
+    super("Retry loop was aborted");
+    this.name = "RetryAbortedError";
+    if (cause !== undefined) this.cause = cause;
+  }
+}
+
+/**
+ * Abortable sleep shared by withRetry and retryAfterAware. Rejects with
+ * RetryAbortedError (carrying `cause`, usually the last failure) if the
+ * signal aborts before or during the wait.
+ */
+function sleep(ms, signal, cause) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new RetryAbortedError(cause));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new RetryAbortedError(cause));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+/** Like sleep(), but rejects with the signal's own reason (an AbortError by default). */
+function abortableSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+module.exports = { RetryAbortedError, sleep, abortableSleep };
+
+},
+"./buildQuery": function (module, exports, require) {
+function toParam(key, value) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new TypeError(`buildQuery: value for "${key}" is an invalid Date`);
+    }
+    return value.toISOString();
+  }
+  if (typeof value === "object" || typeof value === "function" || typeof value === "symbol") {
+    throw new TypeError(
+      `buildQuery: value for "${key}" is not a primitive, Date or array of those — flatten it or JSON.stringify it first`
+    );
+  }
+  return String(value);
+}
+
+/**
+ * Builds a query string from a params object. Skips null/undefined values,
+ * repeats the key for arrays (`?tag=a&tag=b`), serializes Dates as ISO 8601,
+ * and encodes everything. Nested objects throw a TypeError instead of
+ * silently becoming "[object Object]".
+ *
+ * Deliberately minimal — for full query-string parsing/nested-object support,
+ * reach for `query-string` (sindresorhus) instead. This just covers the
+ * common "build a query string from a flat params object" case with zero deps.
+ *
+ * @param {Record<string, unknown>} params
+ */
+function buildQuery(params) {
+  if (!params) return "";
+
+  const pairs = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === undefined) continue;
+
+    const values = Array.isArray(value) ? value : [value];
+    for (const v of values) {
+      if (v === null || v === undefined) continue;
+      pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(toParam(key, v))}`);
+    }
+  }
+
+  return pairs.join("&");
+}
+
+module.exports = { buildQuery };
+
+},
+"./createCircuitBreaker": function (module, exports, require) {
+class CircuitOpenError extends Error {
+  constructor(retryAfterMs) {
+    super("Circuit is open — failing fast instead of calling a service that keeps failing");
+    this.name = "CircuitOpenError";
+    // Deliberately not an E-code: this is *not* a network error and must not be retried as one.
+    this.code = "CIRCUIT_OPEN";
+    this.retryAfterMs = retryAfterMs;
+  }
+}
+
+function defaultIsFailure(valueOrError, isError) {
+  if (isError) return !(valueOrError && valueOrError.name === "AbortError");
+  return Boolean(valueOrError) && typeof valueOrError.status === "number" && valueOrError.status >= 500;
+}
+
+/**
+ * Circuit breaker: after `failureThreshold` consecutive failures it "opens"
+ * and fails fast with CircuitOpenError for `resetTimeoutMs`, so a dying
+ * service isn't hammered (and your callers don't wait on it). Then it goes
+ * "half-open" and lets `halfOpenMax` probe through: success closes the
+ * circuit, failure re-opens it.
+ *
+ * By default a thrown error (except AbortError) or a result with status >= 500
+ * counts as a failure; override with `isFailure(valueOrError, isError)`.
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.failureThreshold=5]
+ * @param {number} [opts.resetTimeoutMs=30000]
+ * @param {number} [opts.halfOpenMax=1]
+ * @param {(valueOrError: any, isError: boolean) => boolean} [opts.isFailure]
+ * @param {(state: string, prev: string) => void} [opts.onStateChange]
+ */
+function createCircuitBreaker(opts = {}) {
+  const {
+    failureThreshold = 5,
+    resetTimeoutMs = 30000,
+    halfOpenMax = 1,
+    isFailure = defaultIsFailure,
+    onStateChange,
+  } = opts;
+
+  let state = "closed";
+  let failures = 0;
+  let openedAt = 0;
+  let probes = 0;
+
+  function setState(next) {
+    if (next === state) return;
+    const prev = state;
+    state = next;
+    if (onStateChange) onStateChange(next, prev);
+  }
+
+  function open() {
+    openedAt = Date.now();
+    setState("open");
+  }
+
+  function current() {
+    if (state === "open" && Date.now() - openedAt >= resetTimeoutMs) {
+      probes = 0;
+      setState("half-open");
+    }
+    return state;
+  }
+
+  function recordFailure() {
+    if (state === "half-open") {
+      open();
+      return;
+    }
+    failures++;
+    if (failures >= failureThreshold) open();
+  }
+
+  function recordSuccess() {
+    failures = 0;
+    if (state === "half-open") setState("closed");
+  }
+
+  async function run(fn) {
+    const s = current();
+    if (s === "open") {
+      throw new CircuitOpenError(Math.max(0, resetTimeoutMs - (Date.now() - openedAt)));
+    }
+    let probing = false;
+    if (s === "half-open") {
+      if (probes >= halfOpenMax) throw new CircuitOpenError(0);
+      probes++;
+      probing = true;
+    }
+
+    let result;
+    try {
+      result = await fn();
+    } catch (err) {
+      if (isFailure(err, true)) recordFailure();
+      else if (probing) probes--; // e.g. an abort — free the probe slot
+      throw err;
+    }
+
+    if (isFailure(result, false)) recordFailure();
+    else recordSuccess();
+    return result;
+  }
+
+  return {
+    run,
+    get state() {
+      return current();
+    },
+    get failures() {
+      return failures;
+    },
+    /** Force the circuit closed and forget the failure count. */
+    reset() {
+      failures = 0;
+      probes = 0;
+      setState("closed");
+    },
+  };
+}
+
+module.exports = { createCircuitBreaker, CircuitOpenError };
+
+},
+"./createFetch": function (module, exports, require) {
+const { withRetry, RetryAbortedError } = require("./withRetry");
+const { withTimeout } = require("./withTimeout");
+const { withDedupe } = require("./withDedupe");
+const { buildQuery } = require("./buildQuery");
+const { parseJsonSafe } = require("./parseJsonSafe");
+const { normalizeError } = require("./normalizeError");
+const { HTTPError } = require("./HTTPError");
+const { createRateLimiter } = require("./createRateLimiter");
+const { createCircuitBreaker } = require("./createCircuitBreaker");
+const { createMemoryCache } = require("./createMemoryCache");
+const { cacheKey, snapshotResponse, entryToResponse } = require("./_cache");
+const { discardBody } = require("./_http");
+
+const DEFAULT_RETRY_STATUS_CODES = [408, 425, 429, 500, 502, 503, 504];
+// Safe to repeat without side effects. POST/PATCH are deliberately absent.
+const DEFAULT_RETRY_METHODS = ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"];
+
+function isAbsoluteUrl(url) {
+  return /^[a-z][a-z0-9+.-]*:/i.test(url);
+}
+
+function joinUrl(baseUrl, url, query) {
+  let full = String(url);
+  if (baseUrl && !isAbsoluteUrl(full)) {
+    full = `${String(baseUrl).replace(/\/+$/, "")}/${full.replace(/^\/+/, "")}`;
+  }
+  const qs = query ? buildQuery(query) : "";
+  if (qs) full += (full.includes("?") ? "&" : "?") + qs;
+  return full;
+}
+
+async function resolveHeaders(source) {
+  const value = typeof source === "function" ? await source() : source;
+  return new Headers(value || undefined);
+}
+
+function mergeHeaders(...headerSets) {
+  const out = new Headers();
+  for (const set of headerSets) {
+    set.forEach((value, key) => out.set(key, value));
+  }
+  return out;
+}
+
+function isStreamBody(body) {
+  return Boolean(body) && typeof body === "object" && typeof body.getReader === "function";
+}
+
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return url;
+  }
+}
+
+function mergeDefaults(base, extra) {
+  const merged = { ...base, ...extra };
+
+  if (base.headers || extra.headers) {
+    merged.headers = async () => {
+      const a = await resolveHeaders(base.headers);
+      const b = await resolveHeaders(extra.headers);
+      return mergeHeaders(a, b);
+    };
+  }
+  if (base.retry !== false && extra.retry !== false && (base.retry || extra.retry)) {
+    merged.retry = { ...base.retry, ...extra.retry };
+  }
+  return merged;
+}
+
+/**
+ * Builds a fetch-like function from the other reqkit pieces — only if you
+ * want that. It's still plain `fetch` underneath: you get a standard
+ * `Response` back, and `fetch` itself stays swappable.
+ *
+ * What you get on top of fetch:
+ *  - `baseUrl`, `query` (via buildQuery), `json` request bodies
+ *  - default headers (an object, or a function for tokens that change)
+ *  - per-attempt `timeout` (withTimeout) and external `signal`
+ *  - retries (withRetry) on network errors/timeouts and retryable statuses,
+ *    honoring Retry-After; only for idempotent methods unless you opt in
+ *  - `rateLimit`: stay under a budget and obey X-RateLimit-* / Retry-After
+ *    *before* the server has to say 429
+ *  - `circuitBreaker`: fail fast against a service that keeps failing
+ *  - `cache`: in-memory GET cache with TTL, stale-while-revalidate and
+ *    ETag / Last-Modified revalidation (304s)
+ *  - concurrent GET de-duplication (withDedupe)
+ *  - `HTTPError` on non-2xx (turn off with `throwHttpErrors: false`)
+ *  - `onRequest` / `onResponse` hooks
+ *
+ * @param {object} [defaults]
+ * @param {string} [defaults.baseUrl]
+ * @param {HeadersInit | (() => HeadersInit | Promise<HeadersInit>)} [defaults.headers]
+ * @param {number | false} [defaults.timeout=30000] - per attempt, ms
+ * @param {false | object} [defaults.retry] - false disables. Options:
+ *   `retries`(2), `statusCodes`, `methods`, `baseDelayMs`, `maxDelayMs`,
+ *   `factor`, `jitter`, `maxRetryTime`, `onRetry`, `calculateDelay`
+ * @param {boolean | object} [defaults.rateLimit] - `true` just learns from
+ *   response headers; `{ requests, perMs }` also enforces a budget; or pass a
+ *   createRateLimiter() instance to share one budget
+ * @param {boolean | object | Function} [defaults.circuitBreaker] - options for
+ *   a per-origin breaker, a createCircuitBreaker() instance, or `(url) => breaker`
+ * @param {boolean | object} [defaults.cache] - `{ ttl, staleWhileRevalidate,
+ *   maxEntries, maxBodyBytes, store, onEvent }`; `true` = 60s TTL
+ * @param {boolean} [defaults.dedupe=false] - merge identical concurrent GET/HEAD calls
+ * @param {boolean} [defaults.throwHttpErrors=true]
+ * @param {typeof fetch} [defaults.fetch=globalThis.fetch]
+ * @param {(ctx: {url: string, init: object}) => void | Promise<void>} [defaults.onRequest] -
+ *   runs once per call; may mutate ctx.url / ctx.init (e.g. add a header)
+ * @param {(ctx: {url: string, init: object, response: Response}) => void | Promise<void>} [defaults.onResponse]
+ */
+function createFetch(defaults = {}) {
+  const {
+    baseUrl,
+    headers: defaultHeaders,
+    timeout: defaultTimeout = 30000,
+    retry: defaultRetry = {},
+    rateLimit,
+    circuitBreaker,
+    cache,
+    dedupe = false,
+    throwHttpErrors: defaultThrow = true,
+    fetch: customFetch,
+    onRequest,
+    onResponse,
+  } = defaults;
+
+  const doFetch = (...args) => (customFetch || globalThis.fetch)(...args);
+
+  // --- stateful pieces, built once so `extend()` children share them -------
+  const limiter = !rateLimit
+    ? null
+    : typeof rateLimit.acquire === "function"
+      ? rateLimit
+      : createRateLimiter(rateLimit === true ? {} : rateLimit);
+
+  const breakerRegistry = new Map();
+  const breakerFor = !circuitBreaker
+    ? null
+    : typeof circuitBreaker === "function"
+      ? circuitBreaker
+      : typeof circuitBreaker.run === "function"
+        ? () => circuitBreaker
+        : (url) => {
+            const origin = originOf(url);
+            if (!breakerRegistry.has(origin)) {
+              breakerRegistry.set(origin, createCircuitBreaker(circuitBreaker === true ? {} : circuitBreaker));
+            }
+            return breakerRegistry.get(origin);
+          };
+
+  const cacheCfg = !cache
+    ? null
+    : {
+        ttl: 60000,
+        staleWhileRevalidate: 0,
+        maxEntries: 100,
+        maxBodyBytes: undefined,
+        ...(cache === true ? {} : cache),
+      };
+  if (cacheCfg && !cacheCfg.store) cacheCfg.store = createMemoryCache({ maxEntries: cacheCfg.maxEntries });
+  // In-flight bookkeeping lives on the (shared) cache config so `extend()`
+  // children see the parent's pending writes and revalidations.
+  if (cacheCfg) {
+    cacheCfg.pending = cacheCfg.pending || new Map();
+    cacheCfg.revalidating = cacheCfg.revalidating || new Set();
+  }
+  const pendingStores = cacheCfg ? cacheCfg.pending : null;
+  const revalidating = cacheCfg ? cacheCfg.revalidating : null;
+  const emit = (type, url) => cacheCfg && cacheCfg.onEvent && cacheCfg.onEvent({ type, url });
+
+  // Shared in-flight GETs. Every caller gets its own clone of the response so
+  // body reads don't fight each other.
+  const sharedFetch = withDedupe((key, url, init) => doFetch(url, init), { keyFn: (key) => key });
+
+  function scheduleStore(key, response, url) {
+    const p = snapshotResponse(response, cacheCfg.maxBodyBytes)
+      .then(async (entry) => {
+        if (entry) {
+          await cacheCfg.store.set(key, entry);
+          emit("store", url);
+        }
+      })
+      .catch(() => {})
+      .finally(() => {
+        if (pendingStores.get(key) === p) pendingStores.delete(key);
+      });
+    pendingStores.set(key, p);
+  }
+
+  async function request(input, init = {}) {
+    const {
+      query,
+      json,
+      timeout = defaultTimeout,
+      retry: retryOpt,
+      throwHttpErrors = defaultThrow,
+      signal,
+      headers: initHeaders,
+      cache: cacheMode,
+      ...fetchInit
+    } = init;
+
+    const method = String(fetchInit.method || "GET").toUpperCase();
+    const headers = mergeHeaders(await resolveHeaders(defaultHeaders), new Headers(initHeaders || undefined));
+
+    let body = fetchInit.body;
+    if (json !== undefined) {
+      body = JSON.stringify(json);
+      if (!headers.has("content-type")) headers.set("content-type", "application/json");
+    }
+
+    const ctx = { url: joinUrl(baseUrl, input, query), init: { ...fetchInit, method, headers, body } };
+    if (onRequest) await onRequest(ctx);
+    const finalHeaders = ctx.init.headers instanceof Headers ? ctx.init.headers : new Headers(ctx.init.headers);
+    const finalMethod = String(ctx.init.method || method).toUpperCase();
+
+    // --- retry policy ------------------------------------------------------
+    const retryCfg = retryOpt === false || defaultRetry === false ? false : { ...defaultRetry, ...retryOpt };
+    const methods = (retryCfg && retryCfg.methods) || DEFAULT_RETRY_METHODS;
+    const hasIdempotencyKey = finalHeaders.has("idempotency-key");
+    const canRetry =
+      retryCfg !== false &&
+      !isStreamBody(ctx.init.body) && // a consumed stream can't be replayed
+      (methods.map((m) => m.toUpperCase()).includes(finalMethod) || hasIdempotencyKey);
+    const { statusCodes, methods: _methods, retries = 2, shouldRetry: customShouldRetry, ...retryRest } = retryCfg || {};
+
+    // One trip to the network: rate limit → circuit breaker → per-attempt
+    // timeout → fetch, retried per the policy above. `netHeaders` and
+    // `netSignal` are parameters so background revalidation can reuse this.
+    function network(netHeaders, netSignal) {
+      const attemptOnce = () => {
+        const attempt = async () => {
+          if (limiter) await limiter.acquire({ signal: netSignal });
+          const res = await withTimeout(
+            (attemptSignal) => {
+              const attemptInit = { ...ctx.init, method: finalMethod, headers: netHeaders, signal: attemptSignal };
+              const useDedupe =
+                dedupe && !netSignal && !ctx.init.body && (finalMethod === "GET" || finalMethod === "HEAD");
+              if (!useDedupe) return doFetch(ctx.url, attemptInit);
+              // No per-attempt signal on a shared request: aborting one caller
+              // must never cancel everyone else's. It still gets its own
+              // timeout so a hung server can't leak the request.
+              const sharedInit = {
+                ...attemptInit,
+                signal: timeout === false ? undefined : AbortSignal.timeout(timeout),
+              };
+              const key = `${finalMethod} ${ctx.url} ${JSON.stringify([...netHeaders.entries()].sort())}`;
+              return sharedFetch(key, ctx.url, sharedInit).then((res) => res.clone());
+            },
+            timeout === false ? Infinity : timeout,
+            { signal: netSignal }
+          );
+          if (limiter) limiter.update(res);
+          return res;
+        };
+        const breaker = breakerFor && breakerFor(ctx.url);
+        return breaker ? breaker.run(attempt) : attempt();
+      };
+
+      return canRetry
+        ? withRetry(attemptOnce, {
+            ...retryRest,
+            retries,
+            retryStatusCodes: statusCodes || DEFAULT_RETRY_STATUS_CODES,
+            shouldRetry:
+              customShouldRetry ||
+              ((err) => {
+                const n = normalizeError(err);
+                return n.isNetworkError || n.isTimeout;
+              }),
+            signal: netSignal,
+          })
+        : attemptOnce();
+    }
+
+    function conditionalHeaders(entry) {
+      const h = new Headers(finalHeaders);
+      if (entry) {
+        if (entry.etag && !h.has("if-none-match")) h.set("if-none-match", entry.etag);
+        if (entry.lastModified && !h.has("if-modified-since")) h.set("if-modified-since", entry.lastModified);
+      }
+      return h;
+    }
+
+    // --- cache lookup --------------------------------------------------------
+    const useCache =
+      Boolean(cacheCfg) &&
+      finalMethod === "GET" &&
+      !ctx.init.body &&
+      cacheMode !== false &&
+      cacheMode !== "no-store";
+    const key = useCache ? cacheKey(finalMethod, ctx.url, finalHeaders) : null;
+    let entry = null;
+
+    const finish = async (response) => {
+      if (onResponse) await onResponse({ url: ctx.url, init: ctx.init, response });
+      if (throwHttpErrors && !response.ok) {
+        throw new HTTPError(response, { method: finalMethod, url: ctx.url });
+      }
+      return response;
+    };
+
+    if (useCache && cacheMode !== "reload") {
+      if (pendingStores.has(key)) await pendingStores.get(key);
+      entry = (await cacheCfg.store.get(key)) || null;
+      if (entry) {
+        const age = Date.now() - entry.storedAt;
+        if (age < cacheCfg.ttl) {
+          emit("hit", ctx.url);
+          return finish(entryToResponse(entry));
+        }
+        if (age < cacheCfg.ttl + cacheCfg.staleWhileRevalidate) {
+          emit("stale", ctx.url);
+          if (!revalidating.has(key)) {
+            revalidating.add(key);
+            const staleEntry = entry;
+            (async () => {
+              try {
+                const res = await network(conditionalHeaders(staleEntry), undefined);
+                if (res.status === 304) {
+                  staleEntry.storedAt = Date.now();
+                  await cacheCfg.store.set(key, staleEntry);
+                  emit("revalidated", ctx.url);
+                  await discardBody(res);
+                } else if (res.status === 200) {
+                  scheduleStore(key, res, ctx.url);
+                  await pendingStores.get(key);
+                } else {
+                  await discardBody(res);
+                }
+              } catch {
+                // keep serving the stale copy; try again next time
+              } finally {
+                revalidating.delete(key);
+              }
+            })();
+          }
+          return finish(entryToResponse(entry));
+        }
+      }
+    }
+
+    // --- network -------------------------------------------------------------
+    let response;
+    try {
+      response = await network(useCache ? conditionalHeaders(entry) : finalHeaders, signal);
+    } catch (err) {
+      // Present a user abort as the plain AbortError they caused, not as retry internals.
+      if (err instanceof RetryAbortedError && signal && signal.aborted) throw signal.reason ?? err;
+      throw err;
+    }
+
+    if (useCache) {
+      if (response.status === 304 && entry) {
+        entry.storedAt = Date.now();
+        await cacheCfg.store.set(key, entry);
+        emit("revalidated", ctx.url);
+        await discardBody(response);
+        response = entryToResponse(entry);
+      } else {
+        emit("miss", ctx.url);
+        if (response.status === 200) scheduleStore(key, response, ctx.url);
+      }
+    }
+
+    return finish(response);
+  }
+
+  /** Like `request`, but resolves to the parsed JSON body (null for an empty body). */
+  request.json = async (input, init) => {
+    const response = await request(input, init);
+    const { data, error } = await parseJsonSafe(response);
+    if (error) throw error;
+    return data;
+  };
+
+  /** A new fetch with these defaults merged over the current ones (headers and retry are merged, the rest replaced). */
+  request.extend = (overrides = {}) =>
+    createFetch(
+      mergeDefaults(
+        {
+          ...defaults,
+          // children share the parent's budget, breakers and cache unless they bring their own
+          rateLimit: limiter || undefined,
+          circuitBreaker: breakerFor || undefined,
+          cache: cacheCfg || undefined,
+        },
+        overrides
+      )
+    );
+
+  return request;
+}
+
+module.exports = { createFetch, HTTPError };
+
+},
+"./createLimiter": function (module, exports, require) {
+/**
+ * Creates a concurrency limiter: at most `concurrency` calls run at once,
+ * the rest wait in a FIFO queue. Handy for "download these 200 files, 4 at a
+ * time" without pulling in a queue library. (Same idea as p-limit.)
+ *
+ * ```js
+ * const limit = createLimiter(4);
+ * const bytes = await Promise.all(urls.map((u) => limit(() => download(u))));
+ * // or: await limit.map(urls, (u) => download(u));
+ * ```
+ *
+ * @param {number} [concurrency=Infinity] - integer >= 1, or Infinity
+ */
+function createLimiter(concurrency = Infinity) {
+  if (concurrency !== Infinity && !(Number.isInteger(concurrency) && concurrency >= 1)) {
+    throw new TypeError("createLimiter: `concurrency` must be an integer >= 1 (or Infinity)");
+  }
+
+  const queue = [];
+  let active = 0;
+
+  function next() {
+    while (active < concurrency && queue.length > 0) {
+      active++;
+      queue.shift()();
+    }
+  }
+
+  function limit(fn, ...args) {
+    return new Promise((resolve, reject) => {
+      queue.push(() => {
+        Promise.resolve()
+          .then(() => fn(...args))
+          .then(resolve, reject)
+          .finally(() => {
+            active--;
+            next();
+          });
+      });
+      next();
+    });
+  }
+
+  Object.defineProperties(limit, {
+    activeCount: { get: () => active },
+    pendingCount: { get: () => queue.length },
+  });
+
+  /** Runs `fn(item, index)` for every item through the limiter. Results keep input order. */
+  limit.map = (items, fn) => Promise.all(Array.from(items, (item, i) => limit(fn, item, i)));
+
+  return limit;
+}
+
+module.exports = { createLimiter };
+
+},
+"./createMemoryCache": function (module, exports, require) {
+/**
+ * A small in-memory LRU store for createFetch's `cache` option. Anything with
+ * async-or-sync `get(key)`, `set(key, value)` and `delete(key)` can be used
+ * instead (Redis, IndexedDB, a Map...).
+ *
+ * @param {{ maxEntries?: number }} [opts]
+ */
+function createMemoryCache(opts = {}) {
+  const { maxEntries = 100 } = opts;
+  if (!(Number.isInteger(maxEntries) && maxEntries >= 1)) {
+    throw new TypeError("createMemoryCache: `maxEntries` must be an integer >= 1");
+  }
+  const map = new Map();
+
+  return {
+    get(key) {
+      if (!map.has(key)) return undefined;
+      const value = map.get(key);
+      map.delete(key); // re-insert so it counts as most recently used
+      map.set(key, value);
+      return value;
+    },
+    set(key, value) {
+      map.delete(key);
+      map.set(key, value);
+      while (map.size > maxEntries) map.delete(map.keys().next().value);
+    },
+    delete(key) {
+      return map.delete(key);
+    },
+    clear() {
+      map.clear();
+    },
+    get size() {
+      return map.size;
+    },
+  };
+}
+
+module.exports = { createMemoryCache };
+
+},
+"./createMockFetch": function (module, exports, require) {
+const { abortableSleep } = require("./_sleep");
+
+const BODYLESS = new Set([101, 204, 205, 304]);
+
+function toBody(body, headers) {
+  if (body === null || body === undefined) return null;
+  if (typeof body === "string") return body;
+  if (
+    body instanceof ArrayBuffer ||
+    ArrayBuffer.isView(body) ||
+    (typeof Blob !== "undefined" && body instanceof Blob) ||
+    (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) ||
+    body instanceof URLSearchParams
+  ) {
+    return body;
+  }
+  if (!headers.has("content-type")) headers.set("content-type", "application/json");
+  return JSON.stringify(body);
+}
+
+function buildResponse(status, body, extraHeaders) {
+  const headers = new Headers(extraHeaders || undefined);
+  const payload = BODYLESS.has(status) ? null : toBody(body, headers);
+  return new Response(payload, { status, headers });
+}
+
+function matchesUrl(matcher, url) {
+  if (typeof matcher === "function") return Boolean(matcher(url));
+  if (matcher instanceof RegExp) return matcher.test(url);
+  if (matcher === "*" || matcher === undefined) return true;
+  if (url === matcher) return true;
+  try {
+    const u = new URL(url);
+    if (matcher === u.pathname + u.search) return true;
+    if (!String(matcher).includes("?") && matcher === u.pathname) return true;
+  } catch {
+    // relative/odd URL — exact match only
+  }
+  return false;
+}
+
+/**
+ * A scriptable, fetch-compatible test double — for testing code that uses
+ * retries, timeouts, rate limits and so on without a network.
+ *
+ * ```js
+ * const mock = createMockFetch();
+ * mock.on("GET", "/users/1")
+ *   .replyOnce(503, "busy", { headers: { "retry-after": "0" } })
+ *   .reply(200, { id: 1 });
+ * mock.on("POST", /\/orders/).fail(mock.networkError());
+ *
+ * const api = createFetch({ fetch: mock.fetch, baseUrl: "https://api.test" });
+ * await api.json("/users/1");          // → { id: 1 } after one retry
+ * mock.calls.length;                   // 2
+ * ```
+ *
+ * String matchers match the full URL, `pathname + search`, or the bare
+ * `pathname`; you can also pass a RegExp or a `(url) => boolean`. `"*"` as the
+ * method matches any method. Unmatched requests reject with a clear error.
+ */
+function createMockFetch() {
+  let routes = [];
+  const calls = [];
+
+  function on(method, matcher) {
+    const route = { method: String(method).toUpperCase(), matcher, once: [], fallback: null };
+    routes.push(route);
+
+    const chain = {
+      /** Always answer like this (once any `…Once` replies are used up). */
+      reply(status = 200, body, opts) {
+        route.fallback = replyHandler(status, body, opts);
+        return chain;
+      },
+      replyOnce(status = 200, body, opts) {
+        route.once.push(replyHandler(status, body, opts));
+        return chain;
+      },
+      /** `fn(call)` returns a Response, `{ status, body, headers }`, or throws/rejects. */
+      replyWith(fn) {
+        route.fallback = customHandler(fn);
+        return chain;
+      },
+      replyWithOnce(fn) {
+        route.once.push(customHandler(fn));
+        return chain;
+      },
+      /** Reject like fetch does on a network failure. */
+      fail(err = networkError()) {
+        route.fallback = async () => {
+          throw err;
+        };
+        return chain;
+      },
+      failOnce(err = networkError()) {
+        route.once.push(async () => {
+          throw err;
+        });
+        return chain;
+      },
+    };
+    return chain;
+  }
+
+  function replyHandler(status, body, opts = {}) {
+    return async (call) => {
+      if (opts.delayMs) await abortableSleep(opts.delayMs, call.signal);
+      return buildResponse(status, body, opts.headers);
+    };
+  }
+
+  function customHandler(fn) {
+    return async (call) => {
+      const out = await fn(call);
+      if (out instanceof Response) return out;
+      return buildResponse(out.status ?? 200, out.body, out.headers);
+    };
+  }
+
+  function networkError(code = "ECONNREFUSED") {
+    const err = new TypeError("fetch failed");
+    err.cause = Object.assign(new Error(`connect ${code}`), { code });
+    return err;
+  }
+
+  async function mockFetch(input, init = {}) {
+    const url = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
+    const method = String(init.method || (typeof input === "object" && input.method) || "GET").toUpperCase();
+    const signal = init.signal || (typeof input === "object" ? input.signal : undefined);
+    signal?.throwIfAborted?.();
+
+    const headers = {};
+    new Headers(init.headers || (typeof input === "object" ? input.headers : undefined)).forEach((v, k) => {
+      headers[k] = v;
+    });
+
+    const call = {
+      url,
+      method,
+      headers,
+      body: init.body,
+      signal,
+      get json() {
+        try {
+          return typeof this.body === "string" ? JSON.parse(this.body) : undefined;
+        } catch {
+          return undefined;
+        }
+      },
+    };
+    calls.push(call);
+
+    const route = routes.find(
+      (r) => (r.method === "*" || r.method === method) && matchesUrl(r.matcher, url) && (r.once.length > 0 || r.fallback)
+    );
+    if (!route) {
+      throw new Error(`createMockFetch: no mock registered for ${method} ${url}`);
+    }
+    const handler = route.once.length > 0 ? route.once.shift() : route.fallback;
+    return handler(call);
+  }
+
+  return {
+    fetch: mockFetch,
+    on,
+    get: (m) => on("GET", m),
+    post: (m) => on("POST", m),
+    put: (m) => on("PUT", m),
+    patch: (m) => on("PATCH", m),
+    delete: (m) => on("DELETE", m),
+    /** A TypeError("fetch failed") with `cause.code`, like Node's fetch throws. */
+    networkError,
+    /** Every request made so far, in order. */
+    calls,
+    /** Remove all routes and forget recorded calls. */
+    reset() {
+      routes = [];
+      calls.length = 0;
+    },
+  };
+}
+
+module.exports = { createMockFetch };
+
+},
+"./createRateLimiter": function (module, exports, require) {
+const { abortableSleep } = require("./_sleep");
+const { getRateLimitInfo } = require("./_http");
+
+function abortable(promise, signal) {
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (v) => (signal.removeEventListener("abort", onAbort), resolve(v)),
+      (e) => (signal.removeEventListener("abort", onAbort), reject(e))
+    );
+  });
+}
+
+/**
+ * A *proactive* rate limiter: slows you down before the server has to say
+ * 429. Two things feed it:
+ *  1. your own budget — `requests` per `perMs` (sliding window), and
+ *  2. what the server tells you — `update(response)` reads X-RateLimit-* /
+ *     RateLimit-* / Retry-After and pauses everything once `remaining` hits 0
+ *     (or the server sent Retry-After), until the reset time.
+ *
+ * Callers are served FIFO.
+ *
+ * ```js
+ * const rl = createRateLimiter({ requests: 10, perMs: 1000 });
+ * const res = await rl.run(() => fetch(url)); // acquire → call → learn from headers
+ * ```
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.requests=Infinity] - max requests per window
+ * @param {number} [opts.perMs=1000] - window length
+ */
+function createRateLimiter(opts = {}) {
+  const { requests = Infinity, perMs = 1000 } = opts;
+  if (requests !== Infinity && !(Number.isInteger(requests) && requests >= 1)) {
+    throw new TypeError("createRateLimiter: `requests` must be an integer >= 1 (or Infinity)");
+  }
+  if (!(typeof perMs === "number" && perMs > 0 && Number.isFinite(perMs))) {
+    throw new TypeError("createRateLimiter: `perMs` must be a positive number");
+  }
+
+  const stamps = [];
+  let blockedUntil = 0;
+  let tail = Promise.resolve();
+
+  async function take(signal) {
+    for (;;) {
+      signal?.throwIfAborted?.();
+      const now = Date.now();
+      while (stamps.length > 0 && stamps[0] <= now - perMs) stamps.shift();
+
+      let waitMs = 0;
+      if (blockedUntil > now) waitMs = blockedUntil - now;
+      else if (stamps.length >= requests) waitMs = stamps[0] + perMs - now;
+
+      if (waitMs <= 0) {
+        stamps.push(now);
+        return;
+      }
+      await abortableSleep(waitMs, signal);
+    }
+  }
+
+  /** Resolves when it's your turn. Rejects with the signal's reason if aborted while waiting. */
+  function acquire({ signal } = {}) {
+    const turn = tail.then(() => take(signal));
+    tail = turn.catch(() => {});
+    return abortable(turn, signal);
+  }
+
+  /** Feed a response (anything with `.headers`/`.status`) so the limiter learns the server's limits. */
+  function update(response) {
+    if (!response || !response.headers) return;
+    const { remaining, resetMs, retryAfterMs } = getRateLimitInfo(response.headers);
+    let blockMs = null;
+    if (retryAfterMs !== null && (response.status === 429 || response.status === 503)) blockMs = retryAfterMs;
+    else if (remaining === 0 && resetMs !== null) blockMs = resetMs;
+    if (blockMs !== null) blockedUntil = Math.max(blockedUntil, Date.now() + blockMs);
+  }
+
+  /** acquire → fn() → update(result). Errors thrown by fn propagate (the slot stays spent). */
+  async function run(fn, { signal } = {}) {
+    await acquire({ signal });
+    const result = await fn();
+    update(result);
+    return result;
+  }
+
+  return {
+    acquire,
+    update,
+    run,
+    /** Ms until the server-imposed pause ends (0 if none). */
+    get blockedForMs() {
+      return Math.max(0, blockedUntil - Date.now());
+    },
+    /** Forget all history and server hints. */
+    reset() {
+      stamps.length = 0;
+      blockedUntil = 0;
+    },
+  };
+}
+
+module.exports = { createRateLimiter };
+
+},
+"./downloadResumable": function (module, exports, require) {
+const { HTTPError } = require("./HTTPError");
+const { BodyTooLargeError } = require("./withProgress");
+const { normalizeError } = require("./normalizeError");
+const { getWaitMsFromHeaders } = require("./_http");
+const { abortableSleep } = require("./_sleep");
+
+const RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
+
+function parseContentRange(header) {
+  // "bytes 100-199/1000" (total may be "*")
+  const m = /^bytes\s+(\d+)-(\d+)\/(\d+|\*)$/i.exec(String(header || "").trim());
+  if (!m) return null;
+  return { start: Number(m[1]), end: Number(m[2]), total: m[3] === "*" ? null : Number(m[3]) };
+}
+
+function isRetryable(err) {
+  if (err instanceof BodyTooLargeError) return false;
+  if (err instanceof HTTPError) return RETRYABLE_STATUS.has(err.status);
+  const n = normalizeError(err);
+  if (n.isAborted) return false;
+  return n.isNetworkError || n.isTimeout;
+}
+
+/**
+ * Downloads a URL into memory and, if the connection drops mid-body, resumes
+ * from where it stopped with an HTTP `Range` request instead of starting
+ * over. Uses `If-Range` with the first response's strong ETag (or
+ * Last-Modified) so a file that changed on the server is restarted rather
+ * than stitched together wrongly. If the server ignores Range, it simply
+ * restarts from zero.
+ *
+ * `retries` counts consecutive attempts *without progress* — a flaky link
+ * that keeps making headway keeps going. Honors Retry-After on 429/503.
+ *
+ * ```js
+ * const bytes = await downloadResumable(url, {
+ *   onProgress: ({ percent }) => console.log(percent),
+ *   maxBytes: 200 * 1024 * 1024,
+ * });
+ * ```
+ *
+ * @param {string} url
+ * @param {object} [opts]
+ * @param {typeof fetch} [opts.fetch=globalThis.fetch] - e.g. `createFetch(...)` or a mock
+ * @param {HeadersInit} [opts.headers]
+ * @param {number} [opts.retries=5]
+ * @param {number} [opts.baseDelayMs=500]
+ * @param {number} [opts.maxDelayMs=10000]
+ * @param {(p: {loaded: number, total: number | null, percent: number | null}) => void} [opts.onProgress]
+ * @param {number} [opts.maxBytes] - throws BodyTooLargeError past this
+ * @param {AbortSignal} [opts.signal]
+ * @param {(err: any, attempt: number, delayMs: number, info: {resumeFrom: number}) => void} [opts.onRetry]
+ * @returns {Promise<Uint8Array>}
+ */
+async function downloadResumable(url, opts = {}) {
+  const {
+    fetch: fetchFn = globalThis.fetch,
+    headers,
+    retries = 5,
+    baseDelayMs = 500,
+    maxDelayMs = 10000,
+    onProgress,
+    maxBytes,
+    signal,
+    onRetry,
+  } = opts;
+
+  const chunks = [];
+  let loaded = 0;
+  let total = null;
+  let validator = null;
+  let attempt = 0; // consecutive attempts without progress
+
+  const report = () => {
+    if (onProgress) {
+      onProgress({ loaded, total, percent: total ? Math.min(100, Math.round((loaded / total) * 100)) : null });
+    }
+  };
+
+  for (;;) {
+    signal?.throwIfAborted?.();
+    const loadedBefore = loaded;
+
+    try {
+      const reqHeaders = new Headers(headers || undefined);
+      // Range offsets count encoded bytes, so ask for an uncompressed body.
+      if (!reqHeaders.has("accept-encoding")) reqHeaders.set("accept-encoding", "identity");
+      if (loaded > 0) {
+        reqHeaders.set("range", `bytes=${loaded}-`);
+        if (validator) reqHeaders.set("if-range", validator);
+      }
+
+      const res = await fetchFn(url, { headers: reqHeaders, signal });
+
+      if (res.status === 416 && loaded > 0) {
+        // Our offset no longer fits the file — start over, without burning a retry.
+        await res.body?.cancel?.().catch(() => {});
+        chunks.length = 0;
+        loaded = 0;
+        continue;
+      }
+      if (!res.ok) {
+        await res.body?.cancel?.().catch(() => {});
+        throw new HTTPError(res, { method: "GET", url });
+      }
+
+      const encoding = res.headers.get("content-encoding");
+      const encoded = Boolean(encoding) && encoding.trim().toLowerCase() !== "identity";
+
+      if (loaded > 0) {
+        const range = res.status === 206 ? parseContentRange(res.headers.get("content-range")) : null;
+        if (!range || range.start !== loaded || encoded) {
+          // Server ignored Range, the file changed (If-Range failed), or the
+          // bytes don't line up: discard and restart from the beginning.
+          chunks.length = 0;
+          loaded = 0;
+        }
+      }
+
+      if (loaded === 0) {
+        const range = res.status === 206 ? parseContentRange(res.headers.get("content-range")) : null;
+        const length = Number(res.headers.get("content-length"));
+        total = encoded ? null : range ? range.total : Number.isFinite(length) && res.headers.has("content-length") ? length : null;
+        const etag = res.headers.get("etag");
+        validator = etag && !etag.startsWith("W/") ? etag : res.headers.get("last-modified");
+      }
+
+      if (maxBytes !== undefined && total !== null && total > maxBytes) {
+        await res.body?.cancel?.().catch(() => {});
+        throw new BodyTooLargeError(maxBytes);
+      }
+
+      if (!res.body || typeof res.body.getReader !== "function") {
+        const buf = new Uint8Array(await res.arrayBuffer());
+        if (maxBytes !== undefined && buf.byteLength > maxBytes) throw new BodyTooLargeError(maxBytes);
+        chunks.push(buf);
+        loaded += buf.byteLength;
+        total = total ?? loaded;
+        report();
+      } else {
+        const reader = res.body.getReader();
+        const onAbort = () => reader.cancel(signal.reason).catch(() => {});
+        signal?.addEventListener("abort", onAbort, { once: true });
+        let finished = false;
+        try {
+          for (;;) {
+            const { done, value } = await reader.read();
+            signal?.throwIfAborted?.();
+            if (done) break;
+            chunks.push(value);
+            loaded += value.byteLength;
+            if (maxBytes !== undefined && loaded > maxBytes) throw new BodyTooLargeError(maxBytes);
+            report();
+          }
+          finished = true;
+        } finally {
+          signal?.removeEventListener("abort", onAbort);
+          if (!finished) reader.cancel().catch(() => {});
+        }
+      }
+
+      if (total !== null && loaded < total) {
+        // Stream ended early without an error (some servers just close the socket).
+        throw Object.assign(new Error(`Incomplete download: got ${loaded} of ${total} bytes`), { code: "ECONNRESET" });
+      }
+
+      const out = new Uint8Array(loaded);
+      let offset = 0;
+      for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      return out;
+    } catch (err) {
+      if (signal?.aborted) throw signal.reason ?? err;
+      if (!isRetryable(err)) throw err;
+
+      if (loaded > loadedBefore) attempt = 0; // it made progress — doesn't count against the budget
+      if (attempt >= retries) throw err;
+
+      let delayMs = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+      if (err instanceof HTTPError) {
+        const headerMs = getWaitMsFromHeaders(err.response && err.response.headers);
+        if (headerMs !== null) delayMs = Math.min(headerMs, 60000);
+      }
+      attempt++;
+      if (onRetry) onRetry(err, attempt, delayMs, { resumeFrom: loaded });
+      await abortableSleep(delayMs, signal);
+    }
+  }
+}
+
+module.exports = { downloadResumable };
+
+},
+"./index": function (module, exports, require) {
+const { withRetry, RetryAbortedError, StopRetry } = require("./withRetry");
+const { withTimeout, TimeoutError } = require("./withTimeout");
+const { normalizeError } = require("./normalizeError");
+const { parseJsonSafe } = require("./parseJsonSafe");
+const { buildQuery } = require("./buildQuery");
+const { retryAfterAware, parseRetryAfter, getWaitMsFromHeaders } = require("./retryAfterAware");
+const { withProgress, BodyTooLargeError } = require("./withProgress");
+const { withDedupe } = require("./withDedupe");
+const { createLimiter } = require("./createLimiter");
+const { createFetch, HTTPError } = require("./createFetch");
+const { createRateLimiter } = require("./createRateLimiter");
+const { createCircuitBreaker, CircuitOpenError } = require("./createCircuitBreaker");
+const { createMemoryCache } = require("./createMemoryCache");
+const { createMockFetch } = require("./createMockFetch");
+const { downloadResumable } = require("./downloadResumable");
+const { readLines, readNDJSON, readSSE } = require("./streams");
+const { streamSSE } = require("./streamSSE");
+
+module.exports = {
+  withRetry,
+  RetryAbortedError,
+  StopRetry,
+  withTimeout,
+  TimeoutError,
+  normalizeError,
+  parseJsonSafe,
+  buildQuery,
+  retryAfterAware,
+  parseRetryAfter,
+  getWaitMsFromHeaders,
+  withProgress,
+  BodyTooLargeError,
+  withDedupe,
+  createLimiter,
+  createFetch,
+  HTTPError,
+  createRateLimiter,
+  createCircuitBreaker,
+  CircuitOpenError,
+  createMemoryCache,
+  createMockFetch,
+  downloadResumable,
+  readLines,
+  readNDJSON,
+  readSSE,
+  streamSSE,
+};
+
+},
+"./normalizeError": function (module, exports, require) {
+/**
+ * Normalizes errors from fetch, axios, node's http/https, undici and generic
+ * Error objects into one consistent shape:
+ *   { message, status, code, isNetworkError, isTimeout, isAborted, cause }
+ *
+ * Every field is always present (null/false when not applicable) so callers
+ * can destructure without existence checks.
+ *
+ * - `isTimeout` is true only for real timeouts (reqkit's TimeoutError,
+ *   AbortSignal.timeout(), ETIMEDOUT, undici timeouts) — not for a plain
+ *   user-initiated abort.
+ * - `isAborted` is true when the request was cancelled on purpose
+ *   (AbortController.abort(), axios cancel).
+ */
+
+function shape(err, overrides) {
+  return {
+    message: "Unknown error",
+    status: null,
+    code: null,
+    isNetworkError: false,
+    isTimeout: false,
+    isAborted: false,
+    cause: err,
+    ...overrides,
+  };
+}
+
+// Node's fetch (undici) throws `TypeError: fetch failed` and puts the real
+// reason (ECONNREFUSED, ENOTFOUND, UND_ERR_*...) on `err.cause`, sometimes
+// inside an AggregateError. Walk the chain to find the first string code.
+function findCode(err) {
+  const seen = new Set();
+  const queue = [err];
+  while (queue.length && seen.size < 10) {
+    const cur = queue.shift();
+    if (!cur || typeof cur !== "object" || seen.has(cur)) continue;
+    seen.add(cur);
+    if (typeof cur.code === "string") return cur.code;
+    queue.push(cur.cause);
+    if (Array.isArray(cur.errors)) queue.push(...cur.errors);
+  }
+  return null;
+}
+
+function isTimeoutCode(code) {
+  return code === "ETIMEDOUT" || code === "ESOCKETTIMEDOUT" || /^UND_ERR_.*TIMEOUT$/.test(code || "");
+}
+
+function isNetworkCode(code) {
+  if (!code) return false;
+  return /^E[A-Z0-9]+$/.test(code) || code === "EAI_AGAIN" || code === "EAI_FAIL" || code.startsWith("UND_ERR_");
+}
+
+// Browsers and Node throw a bare TypeError for network-level fetch failures.
+const FETCH_NETWORK_MESSAGE =
+  /fetch failed|failed to fetch|network ?request failed|load failed|networkerror when attempting to fetch|^terminated$|^network error$/i;
+
+function isFetchNetworkTypeError(err) {
+  return err.name === "TypeError" && FETCH_NETWORK_MESSAGE.test(err.message || "");
+}
+
+function normalizeError(err) {
+  if (!err) return shape(err);
+
+  // axios error shape: err.response.{status,data}, err.request, err.code
+  if (err.isAxiosError || (err.response && typeof err.response.status === "number" && err.config)) {
+    return shape(err, {
+      message: err.response?.data?.message || err.message || "Request failed",
+      status: err.response?.status ?? null,
+      code: err.code ?? null,
+      isNetworkError: !err.response && Boolean(err.request),
+      isTimeout: err.code === "ECONNABORTED" || err.code === "ETIMEDOUT" || /timeout/i.test(err.message || ""),
+      isAborted: err.code === "ERR_CANCELED" || err.name === "CanceledError",
+    });
+  }
+
+  // fetch Response passed in directly (not thrown, but common enough to handle)
+  if (typeof err.status === "number" && typeof err.ok === "boolean") {
+    return shape(err, {
+      message: err.statusText || `Request failed with status ${err.status}`,
+      status: err.status,
+    });
+  }
+
+  const chainCode = findCode(err);
+
+  // reqkit's TimeoutError, AbortSignal.timeout() (DOMException TimeoutError),
+  // node ETIMEDOUT, undici connect/headers/body timeouts
+  if (err.name === "TimeoutError" || isTimeoutCode(chainCode)) {
+    return shape(err, {
+      message: err.message || "Request timed out",
+      code: chainCode || "ETIMEDOUT",
+      isTimeout: true,
+    });
+  }
+
+  // Deliberate cancellation via AbortController — not a timeout.
+  if (err.name === "AbortError") {
+    return shape(err, {
+      message: err.message || "Request aborted",
+      code: "ABORT_ERR",
+      isAborted: true,
+    });
+  }
+
+  // node http/https / undici network-level failures, including
+  // `TypeError: fetch failed` with the real code on err.cause
+  if (isNetworkCode(chainCode) || isFetchNetworkTypeError(err)) {
+    return shape(err, {
+      message: err.message || `Network error (${chainCode})`,
+      code: chainCode,
+      isNetworkError: true,
+    });
+  }
+
+  return shape(err, {
+    message: err.message || String(err),
+    status: err.status ?? err.statusCode ?? err.response?.status ?? err.response?.statusCode ?? null,
+    code: err.code ?? null,
+  });
+}
+
+module.exports = { normalizeError };
+
+},
+"./parseJsonSafe": function (module, exports, require) {
+/**
+ * Parses a fetch Response (or raw string) as JSON without throwing.
+ * Returns { data, error } — exactly one is non-null.
+ *
+ * @param {Response | string} input
+ */
+async function parseJsonSafe(input) {
+  let text;
+  try {
+    text = typeof input === "string" ? input : await input.text();
+  } catch (err) {
+    return { data: null, error: err };
+  }
+
+  if (!text) {
+    return { data: null, error: null };
+  }
+
+  try {
+    return { data: JSON.parse(text), error: null };
+  } catch (err) {
+    return { data: null, error: err };
+  }
+}
+
+module.exports = { parseJsonSafe };
+
+},
+"./retryAfterAware": function (module, exports, require) {
+const { withRetry } = require("./withRetry");
+const { normalizeError } = require("./normalizeError");
+const { parseRetryAfter, getWaitMsFromHeaders } = require("./_http");
+
+function defaultShouldRetryError(err) {
+  const normalized = normalizeError(err);
+  return normalized.isNetworkError || normalized.isTimeout;
+}
+
+/**
+ * Retries a fetch-like call, honoring Retry-After / X-RateLimit-Reset
+ * headers on 429/503 responses instead of blind exponential backoff — most
+ * generic retry libraries treat rate-limit responses like any other failure
+ * and ignore the header the server is explicitly giving you.
+ *
+ * This is a thin preset over `withRetry` (retryStatusCodes + Retry-After,
+ * no jitter, network errors/timeouts only for thrown errors). Reach for
+ * `withRetry` directly when you need jitter, `maxRetryTime`, `StopRetry`,
+ * `calculateDelay`, ...
+ *
+ * Also retries thrown network errors / timeouts (see `shouldRetryError`),
+ * and the whole loop — including any backoff wait — can be cancelled with
+ * `signal`. The body of each response that gets retried is cancelled so the
+ * connection is released.
+ *
+ * `fn` should return a fetch Response (or anything with `.status` and
+ * `.headers.get()`).
+ *
+ * @param {(attempt: number) => Promise<Response>} fn
+ * @param {object} [opts]
+ * @param {number} [opts.retries=3]
+ * @param {number[]} [opts.retryStatusCodes=[429, 503]]
+ * @param {number} [opts.fallbackDelayMs=1000] - used when no usable header is present
+ * @param {number} [opts.maxDelayMs=60000]
+ * @param {(status: number, waitMs: number, attempt: number) => void} [opts.onRetry]
+ * @param {(err: any, attempt: number) => boolean} [opts.shouldRetryError] -
+ *   decides whether a thrown error is retried. Default: network errors and
+ *   timeouts only.
+ * @param {(err: any, waitMs: number, attempt: number) => void} [opts.onRetryError]
+ * @param {AbortSignal} [opts.signal] - cancels the retry loop, throwing
+ *   RetryAbortedError
+ */
+function retryAfterAware(fn, opts = {}) {
+  const {
+    retries = 3,
+    retryStatusCodes = [429, 503],
+    fallbackDelayMs = 1000,
+    maxDelayMs = 60000,
+    onRetry,
+    shouldRetryError = defaultShouldRetryError,
+    onRetryError,
+    signal,
+  } = opts;
+
+  return withRetry(fn, {
+    retries,
+    retryStatusCodes,
+    baseDelayMs: fallbackDelayMs,
+    maxDelayMs,
+    maxRetryAfterMs: maxDelayMs,
+    factor: 2,
+    jitter: 0,
+    shouldRetry: shouldRetryError,
+    onRetry: (err, attempt, waitMs, ctx) => {
+      if (ctx.reason === "result") {
+        if (onRetry) onRetry(ctx.status, waitMs, attempt);
+      } else if (onRetryError) {
+        onRetryError(err, waitMs, attempt);
+      }
+    },
+    signal,
+  });
+}
+
+module.exports = { retryAfterAware, parseRetryAfter, getWaitMsFromHeaders };
+
+},
+"./streamSSE": function (module, exports, require) {
+const { readSSE } = require("./streams");
+const { HTTPError } = require("./HTTPError");
+const { normalizeError } = require("./normalizeError");
+const { getWaitMsFromHeaders, discardBody } = require("./_http");
+const { abortableSleep } = require("./_sleep");
+
+function isRetryableStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+
+function isRetryableError(err) {
+  const n = normalizeError(err);
+  return !n.isAborted && (n.isNetworkError || n.isTimeout);
+}
+
+async function resolveHeaders(source) {
+  const value = typeof source === "function" ? await source() : source;
+  return new Headers(value || undefined);
+}
+
+/**
+ * Connects to a Server-Sent Events endpoint and yields its events — and when
+ * the connection drops (or the server closes it), reconnects by itself,
+ * sending `Last-Event-ID` so the server can resume where you left off. This is
+ * what the browser's `EventSource` does, but with `fetch`: custom headers,
+ * POST bodies, AbortSignal, your own retry/backoff rules.
+ *
+ * ```js
+ * for await (const { data } of streamSSE("https://api.example.com/events", { signal })) {
+ *   console.log(data);
+ * }
+ * ```
+ *
+ * Reconnect behavior:
+ *  - `Last-Event-ID` is sent on every reconnect (the last `id:` seen).
+ *  - A server `retry: <ms>` field sets the base reconnect delay, like EventSource.
+ *  - Waits back off exponentially (capped at `maxDelayMs`) while connecting keeps
+ *    failing; 429/503 `Retry-After` is honored. A connection that delivered at
+ *    least one event resets the failure count (only no-progress attempts count
+ *    toward `retries`).
+ *  - HTTP 204 means "stop reconnecting" (iteration ends). A non-retryable
+ *    status (e.g. 401/404) or a wrong content-type throws immediately.
+ *  - Only GET reconnects by default. For other methods (e.g. a POST that starts
+ *    an LLM stream) re-sending the request could repeat side effects, so
+ *    nothing is retried unless you pass `reconnect: true`.
+ *  - Breaking out of the loop, or aborting `signal`, closes the connection.
+ *
+ * @param {string} url
+ * @param {object} [opts]
+ * @param {typeof fetch} [opts.fetch=globalThis.fetch] - e.g. a createFetch() instance
+ * @param {string} [opts.method="GET"]
+ * @param {HeadersInit | (() => HeadersInit | Promise<HeadersInit>)} [opts.headers] -
+ *   a function is called before every (re)connect — handy for refreshing a token
+ * @param {BodyInit} [opts.body]
+ * @param {AbortSignal} [opts.signal]
+ * @param {string} [opts.lastEventId] - resume from here on the very first connect
+ * @param {boolean} [opts.reconnect] - default: true for GET/HEAD, false otherwise
+ * @param {number} [opts.retries=10] - consecutive failed connections before giving up (Infinity = never)
+ * @param {number} [opts.reconnectDelayMs=1000] - base delay (the server's `retry:` overrides it)
+ * @param {number} [opts.maxDelayMs=30000]
+ * @param {(event: object) => boolean} [opts.stopWhen] - end the stream (no reconnect) after this event, e.g. `e => e.data === "[DONE]"`
+ * @param {(info: {connections: number, lastEventId: string}) => void} [opts.onOpen]
+ * @param {(info: {reason: "error"|"end"|"status", error?: any, status?: number, attempt: number, delayMs: number, lastEventId: string}) => void} [opts.onReconnect]
+ * @returns {AsyncGenerator<{event: string, data: string, id: string, retry: number|undefined}>}
+ */
+async function* streamSSE(url, opts = {}) {
+  const {
+    fetch: fetchFn = globalThis.fetch,
+    method = "GET",
+    headers,
+    body,
+    signal,
+    reconnect = method === "GET" || method === "HEAD",
+    retries = 10,
+    reconnectDelayMs = 1000,
+    maxDelayMs = 30000,
+    stopWhen,
+    onOpen,
+    onReconnect,
+  } = opts;
+
+  let lastId = opts.lastEventId || "";
+  let baseDelay = reconnectDelayMs;
+  let failures = 0; // consecutive connections that delivered nothing
+  let connections = 0;
+
+  for (;;) {
+    signal?.throwIfAborted?.();
+    let failure = null; // { reason, error?, status?, response? }
+    let res = null;
+
+    // ---- connect -----------------------------------------------------------
+    try {
+      const h = await resolveHeaders(headers);
+      if (!h.has("accept")) h.set("accept", "text/event-stream");
+      if (!h.has("cache-control")) h.set("cache-control", "no-cache");
+      if (lastId) h.set("last-event-id", lastId);
+      res = await fetchFn(url, { method, headers: h, body, signal });
+    } catch (err) {
+      if (signal?.aborted) throw signal.reason ?? err;
+      if (err instanceof HTTPError) {
+        if (!isRetryableStatus(err.status)) throw err;
+        failure = { reason: "status", status: err.status, response: err.response, error: err };
+      } else if (isRetryableError(err)) {
+        failure = { reason: "error", error: err };
+      } else {
+        throw err;
+      }
+    }
+
+    // ---- inspect the response ---------------------------------------------
+    if (!failure) {
+      if (res.status === 204) {
+        await discardBody(res);
+        return; // the server's way of saying "don't reconnect"
+      }
+      if (!res.ok) {
+        if (!isRetryableStatus(res.status)) {
+          await discardBody(res);
+          throw new HTTPError(res, { method, url });
+        }
+        failure = { reason: "status", status: res.status, response: res };
+      } else {
+        const type = res.headers.get("content-type") || "";
+        if (!/text\/event-stream/i.test(type)) {
+          await discardBody(res);
+          throw Object.assign(new Error(`streamSSE: expected "text/event-stream" but the server sent "${type || "no content-type"}"`), {
+            code: "SSE_BAD_CONTENT_TYPE",
+          });
+        }
+      }
+    }
+
+    // ---- stream ------------------------------------------------------------
+    let gotEvent = false;
+    if (!failure) {
+      connections++;
+      if (onOpen) onOpen({ connections, lastEventId: lastId });
+      try {
+        for await (const event of readSSE(res, { signal })) {
+          gotEvent = true;
+          lastId = event.id;
+          if (event.retry !== undefined) baseDelay = event.retry;
+          yield event;
+          if (stopWhen && stopWhen(event)) return;
+        }
+        failure = { reason: "end" };
+      } catch (err) {
+        if (signal?.aborted) throw signal.reason ?? err;
+        if (!isRetryableError(err)) throw err;
+        failure = { reason: "error", error: err };
+      }
+    }
+
+    // ---- decide whether and when to reconnect ------------------------------
+    if (!reconnect) {
+      if (failure.reason === "end") return;
+      if (failure.reason === "status") {
+        throw failure.error || new HTTPError(failure.response, { method, url });
+      }
+      throw failure.error;
+    }
+
+    // A connection that delivered events made progress: reconnect promptly and
+    // start the failure count over. Only no-progress attempts count toward `retries`.
+    failures = gotEvent ? 0 : failures + 1;
+    if (failures > retries) {
+      if (failure.reason === "status") throw failure.error || new HTTPError(failure.response, { method, url });
+      if (failure.reason === "error") throw failure.error;
+      throw Object.assign(new Error(`streamSSE: the server keeps closing the stream without sending events — gave up after ${retries} retries`), {
+        code: "SSE_GAVE_UP",
+      });
+    }
+
+    let delayMs = Math.min(baseDelay * 2 ** Math.max(failures - 1, 0), maxDelayMs);
+    if (failure.reason === "status" && failure.response) {
+      const headerMs = getWaitMsFromHeaders(failure.response.headers);
+      if (headerMs !== null) delayMs = Math.min(headerMs, 60000);
+      await discardBody(failure.response);
+    }
+    delayMs += Math.random() * delayMs * 0.1; // a little jitter so clients don't reconnect in lockstep
+
+    if (onReconnect) {
+      onReconnect({
+        reason: failure.reason,
+        error: failure.error,
+        status: failure.status,
+        attempt: Math.max(failures, 1),
+        delayMs,
+        lastEventId: lastId,
+      });
+    }
+    await abortableSleep(delayMs, signal);
+  }
+}
+
+module.exports = { streamSSE };
+
+},
+"./streams": function (module, exports, require) {
+const encoder = new TextEncoder();
+
+// Yields Uint8Array chunks from a fetch Response, a web ReadableStream, or any
+// async iterable (e.g. a Node Readable). Cancels the underlying stream when
+// the consumer stops early or the signal aborts, so the connection is freed.
+async function* chunks(source, signal) {
+  let body = source;
+  if (body && typeof body.getReader !== "function" && "body" in body) body = body.body; // a Response
+  if (body === null || body === undefined) return;
+  signal?.throwIfAborted?.();
+
+  if (typeof body.getReader === "function") {
+    const reader = body.getReader();
+    const onAbort = () => reader.cancel(signal.reason).catch(() => {});
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      for (;;) {
+        const { done, value } = await reader.read();
+        signal?.throwIfAborted?.(); // cancel() makes read() resolve as done — don't mistake that for the end
+        if (done) return;
+        yield value;
+      }
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      reader.cancel().catch(() => {});
+    }
+  } else if (typeof body[Symbol.asyncIterator] === "function") {
+    for await (const chunk of body) {
+      signal?.throwIfAborted?.();
+      yield typeof chunk === "string" ? encoder.encode(chunk) : chunk;
+    }
+  } else {
+    throw new TypeError("reqkit streams: expected a Response, a ReadableStream or an async iterable");
+  }
+}
+
+/**
+ * Async-iterates the text lines of a streamed body. Handles \n, \r\n and \r,
+ * multi-byte characters split across chunks, and a leading BOM.
+ *
+ * ```js
+ * for await (const line of readLines(response)) console.log(line);
+ * ```
+ *
+ * @param {Response | ReadableStream | AsyncIterable<Uint8Array>} source
+ * @param {{ signal?: AbortSignal }} [opts]
+ * @returns {AsyncGenerator<string>}
+ */
+async function* readLines(source, opts = {}) {
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let first = true;
+
+  for await (const chunk of chunks(source, opts.signal)) {
+    buffer += decoder.decode(chunk, { stream: true });
+    if (first && buffer.length > 0) {
+      buffer = buffer.replace(/^\uFEFF/, "");
+      first = false;
+    }
+
+    let pos = 0;
+    for (;;) {
+      const rest = buffer.slice(pos);
+      const i = rest.search(/\r\n|\n|\r/);
+      if (i === -1) break;
+      // A trailing "\r" might be the first half of "\r\n" — wait for more data.
+      if (rest[i] === "\r" && i === rest.length - 1) break;
+      yield rest.slice(0, i);
+      pos += i + (rest.startsWith("\r\n", i) ? 2 : 1);
+    }
+    buffer = buffer.slice(pos);
+  }
+
+  buffer += decoder.decode();
+  if (buffer.endsWith("\r")) buffer = buffer.slice(0, -1);
+  if (buffer.length > 0) yield buffer;
+}
+
+/**
+ * Async-iterates parsed JSON values from a newline-delimited JSON stream
+ * (NDJSON / JSON Lines). Blank lines are skipped. A malformed line throws a
+ * SyntaxError naming the line, unless `skipInvalid` is true.
+ *
+ * @param {Response | ReadableStream | AsyncIterable<Uint8Array>} source
+ * @param {{ signal?: AbortSignal, skipInvalid?: boolean }} [opts]
+ */
+async function* readNDJSON(source, opts = {}) {
+  let lineNo = 0;
+  for await (const line of readLines(source, opts)) {
+    lineNo++;
+    if (line.trim() === "") continue;
+    try {
+      yield JSON.parse(line);
+    } catch (err) {
+      if (opts.skipInvalid) continue;
+      throw new SyntaxError(`readNDJSON: invalid JSON on line ${lineNo}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Async-iterates Server-Sent Events (text/event-stream) as
+ * `{ event, data, id, retry }`, following the spec: multi-line `data:` is
+ * joined with "\n", comments (`:`) are ignored, `event` defaults to
+ * "message", `id` carries over between events, and an event cut off by the end
+ * of the stream is discarded. Great for LLM token streams.
+ *
+ * ```js
+ * for await (const { data } of readSSE(response)) {
+ *   if (data === "[DONE]") break;
+ *   console.log(JSON.parse(data));
+ * }
+ * ```
+ *
+ * @param {Response | ReadableStream | AsyncIterable<Uint8Array>} source
+ * @param {{ signal?: AbortSignal }} [opts]
+ */
+async function* readSSE(source, opts = {}) {
+  let event = "";
+  let data = [];
+  let retry;
+  let lastId = "";
+
+  for await (const line of readLines(source, opts)) {
+    if (line === "") {
+      if (data.length > 0) yield { event: event || "message", data: data.join("\n"), id: lastId, retry };
+      event = "";
+      data = [];
+      retry = undefined;
+      continue;
+    }
+    if (line.startsWith(":")) continue;
+
+    const idx = line.indexOf(":");
+    const field = idx === -1 ? line : line.slice(0, idx);
+    let value = idx === -1 ? "" : line.slice(idx + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+
+    if (field === "event") event = value;
+    else if (field === "data") data.push(value);
+    else if (field === "id") {
+      if (!value.includes("\0")) lastId = value;
+    } else if (field === "retry") {
+      if (/^\d+$/.test(value)) retry = Number(value);
+    }
+  }
+}
+
+module.exports = { readLines, readNDJSON, readSSE };
+
+},
+"./withDedupe": function (module, exports, require) {
+// Non-plain objects (AbortSignal, Response, class instances, functions...)
+// can't be meaningfully JSON-serialized — JSON.stringify turns every
+// AbortSignal into "{}", which would make unrelated calls share one request.
+// Give them a stable identity-based id instead.
+const identityIds = new WeakMap();
+let nextIdentityId = 1;
+
+function identityOf(value) {
+  let id = identityIds.get(value);
+  if (id === undefined) {
+    id = nextIdentityId++;
+    identityIds.set(value, id);
+  }
+  return id;
+}
+
+function isPlainObject(value) {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function keyReplacer(_key, value) {
+  if (typeof value === "bigint") return { $bigint: String(value) };
+  if (typeof value === "function") return { $ref: identityOf(value) };
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value;
+  if (!isPlainObject(value)) return { $ref: identityOf(value) };
+
+  // Sort plain-object keys so {a:1,b:2} and {b:2,a:1} dedupe together.
+  const sorted = {};
+  for (const k of Object.keys(value).sort()) sorted[k] = value[k];
+  return sorted;
+}
+
+function defaultKeyFn(...args) {
+  try {
+    return JSON.stringify(args, keyReplacer);
+  } catch {
+    // Circular structures etc. Fall back to identity for objects.
+    return args
+      .map((a) => ((a && typeof a === "object") || typeof a === "function" ? `#${identityOf(a)}` : String(a)))
+      .join("|");
+  }
+}
+
+/**
+ * Wraps an async function so that concurrent calls with the same key share
+ * a single in-flight promise instead of firing duplicate requests. Common
+ * use case: several parts of a UI ask for the same resource at once (e.g. a
+ * user profile) — only one network request actually goes out, and every
+ * caller resolves with the same result.
+ *
+ * The in-flight entry is cleared as soon as the call settles (success or
+ * failure), so the next call — even with the same key — always starts a
+ * fresh request. This is deduplication of concurrent calls, not a cache.
+ *
+ * @param {(...args: any[]) => Promise<any>} fn
+ * @param {object} [opts]
+ * @param {(...args: any[]) => string} [opts.keyFn] - derives a dedupe key
+ *   from the call arguments. By default plain data is compared by value
+ *   (object key order doesn't matter) and anything else — AbortSignals,
+ *   Responses, class instances, functions — by identity, so two calls with
+ *   different AbortSignals are never merged.
+ * @returns {(...args: any[]) => Promise<any>}
+ */
+function withDedupe(fn, opts = {}) {
+  const { keyFn = defaultKeyFn } = opts;
+  const inFlight = new Map();
+
+  return function deduped(...args) {
+    const key = keyFn(...args);
+
+    if (inFlight.has(key)) {
+      return inFlight.get(key);
+    }
+
+    const promise = Promise.resolve()
+      .then(() => fn(...args))
+      .finally(() => {
+        inFlight.delete(key);
+      });
+
+    inFlight.set(key, promise);
+    return promise;
+  };
+}
+
+module.exports = { withDedupe };
+
+},
+"./withProgress": function (module, exports, require) {
+class BodyTooLargeError extends Error {
+  constructor(maxBytes) {
+    super(`Response body exceeded the ${maxBytes}-byte limit`);
+    this.name = "BodyTooLargeError";
+    this.code = "EBODYTOOLARGE";
+    this.maxBytes = maxBytes;
+  }
+}
+
+function cancelQuietly(reader) {
+  try {
+    const p = reader.cancel();
+    if (p && typeof p.catch === "function") p.catch(() => {});
+  } catch {
+    // already closed / released — nothing to do
+  }
+}
+
+/**
+ * Reads a fetch Response body while reporting progress, and returns the
+ * fully collected bytes as a Uint8Array. Works for any streamed response,
+ * not just file downloads — same shape whether it's a media file, a large
+ * JSON payload, or anything else worth showing progress for.
+ *
+ * `total` is null (and `percent` with it) when the size isn't trustworthy:
+ * no Content-Length, or a Content-Encoding is applied (Content-Length is then
+ * the *compressed* size while fetch hands you *decompressed* bytes, so
+ * loaded could exceed total). `percent` is always clamped to 0–100.
+ *
+ * @param {Response} response
+ * @param {(progress: { loaded: number, total: number | null, percent: number | null }) => void} [onProgress]
+ * @param {object} [opts]
+ * @param {number} [opts.maxBytes] - abort with BodyTooLargeError once more
+ *   than this many bytes have been received
+ * @param {AbortSignal} [opts.signal] - cancels the read; rejects with the
+ *   signal's reason (an AbortError by default)
+ * @returns {Promise<Uint8Array>}
+ */
+async function withProgress(response, onProgress, opts = {}) {
+  const { maxBytes, signal } = opts;
+  signal?.throwIfAborted?.();
+
+  if (!response.body || typeof response.body.getReader !== "function") {
+    // No streaming support available — fall back to a single-shot read,
+    // still reporting one final progress event so callers don't need a branch.
+    const buf = new Uint8Array(await response.arrayBuffer());
+    signal?.throwIfAborted?.();
+    if (maxBytes !== undefined && buf.byteLength > maxBytes) {
+      throw new BodyTooLargeError(maxBytes);
+    }
+    if (onProgress) {
+      onProgress({ loaded: buf.byteLength, total: buf.byteLength, percent: 100 });
+    }
+    return buf;
+  }
+
+  const encoding = response.headers?.get?.("content-encoding");
+  const encoded = Boolean(encoding) && encoding.trim().toLowerCase() !== "identity";
+  const contentLength = response.headers?.get?.("content-length");
+  const parsed = contentLength ? Number(contentLength) : NaN;
+  const total = !encoded && Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+
+  const reader = response.body.getReader();
+
+  // Fail fast when the declared size already exceeds the cap.
+  if (maxBytes !== undefined && total !== null && total > maxBytes) {
+    cancelQuietly(reader);
+    throw new BodyTooLargeError(maxBytes);
+  }
+
+  const onAbort = () => cancelQuietly(reader);
+  signal?.addEventListener("abort", onAbort, { once: true });
+
+  const chunks = [];
+  let loaded = 0;
+  let finished = false;
+
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      // reader.cancel() on abort makes read() resolve as done — check the
+      // signal first so an aborted read never looks like a complete one.
+      signal?.throwIfAborted?.();
+      if (done) break;
+
+      chunks.push(value);
+      loaded += value.byteLength;
+
+      if (maxBytes !== undefined && loaded > maxBytes) {
+        throw new BodyTooLargeError(maxBytes);
+      }
+
+      if (onProgress) {
+        onProgress({
+          loaded,
+          total,
+          percent: total ? Math.min(100, Math.round((loaded / total) * 100)) : null,
+        });
+      }
+    }
+    finished = true;
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    if (!finished) cancelQuietly(reader);
+  }
+
+  const result = new Uint8Array(loaded);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+
+module.exports = { withProgress, BodyTooLargeError };
+
+},
+"./withRetry": function (module, exports, require) {
+const { RetryAbortedError, sleep } = require("./_sleep");
+const { getWaitMsFromHeaders, discardBody } = require("./_http");
+
+function defaultShouldRetry(err) {
+  // Retry thrown errors except deliberate aborts. Narrow it with `shouldRetry`
+  // (e.g. network errors only). HTTP *statuses* aren't errors with fetch, so
+  // opt in with `retryStatusCodes` / `shouldRetryResult`.
+  return Boolean(err) && err.name !== "AbortError";
+}
+
+/**
+ * Throw this from inside `fn` to stop retrying immediately. If you pass an
+ * Error, that exact error is what withRetry rethrows; with a string, the
+ * StopRetry itself is thrown. (Same idea as p-retry's AbortError.)
+ */
+class StopRetry extends Error {
+  constructor(reasonOrMessage) {
+    const isError = reasonOrMessage instanceof Error;
+    super(isError ? reasonOrMessage.message : String(reasonOrMessage ?? "Retrying was stopped"));
+    this.name = "StopRetry";
+    this.original = isError ? reasonOrMessage : null;
+  }
+}
+
+/**
+ * Retries an async function with exponential backoff + jitter. Retries on
+ * thrown errors, and — opt-in — on *results* too (HTTP status codes, or any
+ * predicate), honoring Retry-After / X-RateLimit-Reset when the result has
+ * headers.
+ *
+ * @param {(attempt: number) => Promise<any>} fn
+ * @param {object} [opts]
+ * @param {number} [opts.retries=3] - max retry attempts after the first try (Infinity is fine with maxRetryTime)
+ * @param {number} [opts.baseDelayMs=300] - initial delay
+ * @param {number} [opts.maxDelayMs=10000] - backoff ceiling
+ * @param {number} [opts.factor=2] - backoff multiplier
+ * @param {number|"full"} [opts.jitter=0.2] - fraction of extra random delay
+ *   added on top (0 disables); "full" picks uniformly in [0, delay] — the
+ *   AWS "full jitter" strategy, best when many clients retry at once
+ * @param {number} [opts.maxRetryTime=Infinity] - total time budget in ms
+ *   across all attempts and waits; once the next wait would blow it, stop
+ *   and surface the last error/result
+ * @param {(err: any, attempt: number) => boolean} [opts.shouldRetry] - for thrown errors
+ * @param {number[]} [opts.retryStatusCodes=[]] - retry when the result's `.status` is in this list
+ * @param {(result: any, attempt: number) => boolean} [opts.shouldRetryResult] - retry on any result predicate
+ * @param {boolean} [opts.respectRetryAfter=true] - use Retry-After/X-RateLimit-Reset from `result.headers`
+ * @param {number} [opts.maxRetryAfterMs=60000] - cap on a header-provided wait
+ * @param {(info: {attempt: number, error: any, result: any, delayMs: number}) => number|false} [opts.calculateDelay]
+ *   - override the wait; return a number of ms, or false to stop retrying
+ * @param {(err: any, attempt: number, delayMs: number, ctx: {reason: "error"|"result", result?: any, status?: number}) => void} [opts.onRetry]
+ *   - `err` is undefined when the retry was triggered by a result
+ * @param {AbortSignal} [opts.signal] - cancels the whole retry loop,
+ *   including any pending backoff wait, throwing RetryAbortedError (with the
+ *   last failure as `cause`). Separate from a per-call signal you pass into
+ *   `fn` yourself — this one governs whether *another attempt starts at all*.
+ */
+async function withRetry(fn, opts = {}) {
+  const {
+    retries = 3,
+    baseDelayMs = 300,
+    maxDelayMs = 10000,
+    factor = 2,
+    jitter = 0.2,
+    maxRetryTime = Infinity,
+    shouldRetry = defaultShouldRetry,
+    retryStatusCodes = [],
+    shouldRetryResult,
+    respectRetryAfter = true,
+    maxRetryAfterMs = 60000,
+    calculateDelay,
+    onRetry,
+    signal,
+  } = opts;
+
+  const startedAt = Date.now();
+
+  function backoff(attempt) {
+    const exponential = Math.min(baseDelayMs * factor ** attempt, maxDelayMs);
+    if (jitter === "full") return Math.round(Math.random() * exponential);
+    const extra = Math.random() * exponential * (Number(jitter) || 0);
+    return Math.round(exponential + extra);
+  }
+
+  // Returns the wait in ms, or null if retrying should stop (custom
+  // calculateDelay said so, or the time budget would be exceeded).
+  function planWait(defaultMs, attempt, error, result) {
+    let waitMs = defaultMs;
+    if (calculateDelay) {
+      const custom = calculateDelay({ attempt, error, result, delayMs: defaultMs });
+      if (custom === false || custom === null || custom === undefined) return null;
+      waitMs = Math.max(0, Number(custom) || 0);
+    }
+    if (Date.now() - startedAt + waitMs > maxRetryTime) return null;
+    return waitMs;
+  }
+
+  function wantsResultRetry(result, attempt) {
+    if (
+      retryStatusCodes.length > 0 &&
+      result &&
+      typeof result.status === "number" &&
+      retryStatusCodes.includes(result.status)
+    ) {
+      return true;
+    }
+    return shouldRetryResult ? Boolean(shouldRetryResult(result, attempt)) : false;
+  }
+
+  let lastErr;
+  for (let attempt = 0; ; attempt++) {
+    if (signal?.aborted) {
+      throw new RetryAbortedError(lastErr);
+    }
+
+    let result;
+    try {
+      result = await fn(attempt);
+    } catch (err) {
+      if (err instanceof StopRetry) throw err.original ?? err;
+      lastErr = err;
+      if (attempt >= retries || !shouldRetry(err, attempt)) throw err;
+
+      const waitMs = planWait(backoff(attempt), attempt, err, undefined);
+      if (waitMs === null) throw err;
+
+      if (onRetry) onRetry(err, attempt, waitMs, { reason: "error" });
+      await sleep(waitMs, signal, err);
+      continue;
+    }
+
+    if (attempt >= retries || !wantsResultRetry(result, attempt)) return result;
+
+    let defaultMs = backoff(attempt);
+    if (respectRetryAfter) {
+      const headerMs = getWaitMsFromHeaders(result && result.headers);
+      if (headerMs !== null) defaultMs = Math.min(headerMs, maxRetryAfterMs);
+    }
+    const waitMs = planWait(defaultMs, attempt, undefined, result);
+    if (waitMs === null) return result;
+
+    await discardBody(result);
+    if (onRetry) onRetry(undefined, attempt, waitMs, { reason: "result", result, status: result && result.status });
+    await sleep(waitMs, signal);
+  }
+}
+
+module.exports = { withRetry, RetryAbortedError, StopRetry };
+
+},
+"./withTimeout": function (module, exports, require) {
+class TimeoutError extends Error {
+  constructor(ms) {
+    super(`Timed out after ${ms}ms`);
+    this.name = "TimeoutError";
+    this.code = "ETIMEDOUT";
+  }
+}
+
+/**
+ * Races an async function against a timeout. `fn` is handed an AbortSignal
+ * so the underlying request can actually be cancelled (not just abandoned) —
+ * e.g. `withTimeout(signal => fetch(url, { signal }), 5000)`.
+ *
+ * Pass your own `signal` to also cancel from the outside (user navigated
+ * away, shutdown...). That signal is linked into the one `fn` receives, and
+ * aborting it rejects with its reason even if `fn` ignores the signal.
+ * `ms: Infinity` disables the timer (handy to only link a signal).
+ *
+ * @param {(signal: AbortSignal) => Promise<any>} fn
+ * @param {number} ms
+ * @param {object} [opts]
+ * @param {AbortSignal} [opts.signal] - external cancellation
+ */
+async function withTimeout(fn, ms, opts = {}) {
+  const { signal } = opts;
+
+  if (typeof ms !== "number" || Number.isNaN(ms) || ms < 0) {
+    throw new TypeError("withTimeout: `ms` must be a non-negative number (or Infinity)");
+  }
+  signal?.throwIfAborted?.();
+
+  const controller = new AbortController();
+  let timedOut = false;
+
+  const timer =
+    ms === Infinity
+      ? null
+      : setTimeout(() => {
+          timedOut = true;
+          controller.abort(new TimeoutError(ms));
+        }, ms);
+
+  const onExternalAbort = () => controller.abort(signal.reason);
+  signal?.addEventListener("abort", onExternalAbort, { once: true });
+
+  const guard = new Promise((_, reject) => {
+    controller.signal.addEventListener(
+      "abort",
+      () => reject(timedOut ? new TimeoutError(ms) : controller.signal.reason),
+      { once: true }
+    );
+  });
+
+  try {
+    return await Promise.race([fn(controller.signal), guard]);
+  } catch (err) {
+    // If our timeout is what triggered the abort, always surface TimeoutError —
+    // regardless of whether fn's own rejection or our guard "won" the race
+    // (that's a listener-registration-order detail callers shouldn't have to
+    // think about).
+    if (timedOut) throw new TimeoutError(ms);
+    throw err;
+  } finally {
+    if (timer) clearTimeout(timer);
+    signal?.removeEventListener("abort", onExternalAbort);
+  }
+}
+
+module.exports = { withTimeout, TimeoutError };
+
+},
+};
+const __cache = {};
+function __require(id) {
+  const key = id.replace(/\.js$/, "");
+  if (!(key in __defs)) throw new Error(`reqkit bundle: cannot resolve ${id}`);
+  if (__cache[key]) return __cache[key].exports;
+  const module = (__cache[key] = { exports: {} });
+  __defs[key].call(module.exports, module, module.exports, __require);
+  return module.exports;
+}
+const __reqkit = __require("./index");
+export const {
+  BodyTooLargeError,
+  CircuitOpenError,
+  HTTPError,
+  RetryAbortedError,
+  StopRetry,
+  TimeoutError,
+  buildQuery,
+  createCircuitBreaker,
+  createFetch,
+  createLimiter,
+  createMemoryCache,
+  createMockFetch,
+  createRateLimiter,
+  downloadResumable,
+  getWaitMsFromHeaders,
+  normalizeError,
+  parseJsonSafe,
+  parseRetryAfter,
+  readLines,
+  readNDJSON,
+  readSSE,
+  retryAfterAware,
+  streamSSE,
+  withDedupe,
+  withProgress,
+  withRetry,
+  withTimeout,
+} = __reqkit;
+export default __reqkit;