@boy-offi9-inc/reqkit 0.7.0 → 0.8.0

package/dist/reqkit.mjs

@@ -1,6 +1,6 @@
-/*! @boy-offi9-inc/reqkit v0.7.0 — ESM bundle (generated by scripts/build-esm.js, do not edit) */
+/*! @boy-offi9-inc/reqkit v0.8.0 — ESM bundle (generated by scripts/build-esm.js, do not edit) */
 const __defs = {
-"./HTTPError": function (module, exports, require) {
+"errors/HTTPError": function (module, exports, require) {
 class HTTPError extends Error {
   constructor(response, request) {
     const statusText = response.statusText ? ` ${response.statusText}` : "";
@@ -17,7 +17,182 @@ class HTTPError extends Error {
 module.exports = { HTTPError };
 
 },
-"./_cache": function (module, exports, require) {
+"errors/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 };
+
+},
+"http/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 };
+
+},
+"http/cache/entry": function (module, exports, require) {
 // Helpers for createFetch's response cache.
 
 const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
@@ -75,521 +250,288 @@ function entryToResponse(entry) {
 module.exports = { cacheKey, snapshotResponse, entryToResponse, DEFAULT_MAX_BODY_BYTES };
 
 },
-"./_http": function (module, exports, require) {
+"http/cache/memoryCache": 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.
+ * 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 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());
+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 null;
+  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;
+    },
+  };
 }
 
-// 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());
-}
+module.exports = { createMemoryCache };
 
-function readHeader(headers, ...names) {
-  for (const name of names) {
-    const v = headers.get(name);
-    if (v !== null && v !== undefined && v !== "") return v;
-  }
-  return null;
-}
+},
+"http/createFetch": function (module, exports, require) {
+const { withRetry, RetryAbortedError } = require("../resilience/retry");
+const { withTimeout } = require("../resilience/timeout");
+const { withDedupe } = require("../resilience/dedupe");
+const { buildQuery } = require("./buildQuery");
+const { parseJsonSafe } = require("./parseJsonSafe");
+const { normalizeError } = require("../errors/normalizeError");
+const { HTTPError } = require("../errors/HTTPError");
+const { createRateLimiter } = require("../resilience/rateLimiter");
+const { createCircuitBreaker } = require("../resilience/circuitBreaker");
+const { createMemoryCache } = require("./cache/memoryCache");
+const { cacheKey, snapshotResponse, entryToResponse } = require("./cache/entry");
+const { discardBody, getOrigin } = require("../internal/http");
 
-/**
- * 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 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"];
+// Default headers that carry credentials. They're only sent to trusted origins.
+const SENSITIVE_HEADERS = ["authorization", "proxy-authorization", "cookie", "x-api-key", "x-auth-token"];
 
-  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")
-  );
+function isAbsoluteUrl(url) {
+  return /^[a-z][a-z0-9+.-]*:/i.test(url);
 }
 
-/**
- * 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);
+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;
+}
 
-  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 resolveHeaders(source) {
+  const value = typeof source === "function" ? await source() : source;
+  return new Headers(value || undefined);
 }
 
-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
+function mergeHeaders(...headerSets) {
+  const out = new Headers();
+  for (const set of headerSets) {
+    set.forEach((value, key) => out.set(key, value));
   }
+  return out;
 }
 
-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;
-  }
+function isStreamBody(body) {
+  return Boolean(body) && typeof body === "object" && typeof body.getReader === "function";
 }
 
-/**
- * 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 });
-  });
+function originOf(url) {
+  return getOrigin(url) || url;
 }
 
-/** 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 });
-  });
+// One in-flight token refresh per `auth` config object, so concurrent 401s —
+// even across extend() children — trigger exactly one refresh.
+const refreshStates = new WeakMap();
+function refreshStateFor(auth) {
+  let state = refreshStates.get(auth);
+  if (!state) {
+    state = { inflight: null };
+    refreshStates.set(auth, state);
+  }
+  return state;
 }
 
-module.exports = { RetryAbortedError, sleep, abortableSleep };
+function mergeDefaults(base, extra) {
+  const merged = { ...base, ...extra };
 
-},
-"./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 (base.headers || extra.headers) {
+    merged.headers = async () => {
+      const a = await resolveHeaders(base.headers);
+      const b = await resolveHeaders(extra.headers);
+      return mergeHeaders(a, b);
+    };
   }
-  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`
-    );
+  if (base.retry !== false && extra.retry !== false && (base.retry || extra.retry)) {
+    merged.retry = { ...base.retry, ...extra.retry };
   }
-  return String(value);
+  return merged;
 }
 
 /**
- * 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]".
+ * 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.
  *
- * 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.
+ * 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,
+ *    stale-if-error and ETag / Last-Modified revalidation (304s)
+ *  - `onEvent`: one callback for everything that happens (request, attempt,
+ *    retry, response, error, cache, rate-limit waits, circuit changes, token
+ *    refreshes) — plug it into your logger or metrics
+ *  - concurrent GET de-duplication (withDedupe)
+ *  - `auth`: attach a token, and on a 401 refresh it ONCE (shared by all
+ *    concurrent requests) and replay the request
+ *  - credential safety: default credentials (`auth`, and default headers like
+ *    Authorization/Cookie/X-API-Key) are only sent to `baseUrl`'s origin and
+ *    `trustedOrigins` — pass an absolute URL to another host and they stay home
+ *  - `HTTPError` on non-2xx (turn off with `throwHttpErrors: false`)
+ *  - `onRequest` / `onResponse` hooks
  *
- * @param {Record<string, unknown>} params
+ * @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, staleIfError,
+ *   maxEntries, maxBodyBytes, store, onEvent }`; `true` = 60s TTL. `staleIfError` (ms) lets a
+ *   cached copy be served for that long past its TTL when the network fails or the server answers 5xx.
+ * @param {object} [defaults.auth] - `{ getToken, refresh, header?, scheme?, shouldRefresh? }`.
+ *   `getToken()` supplies the current token (sync or async); on a 401 (or
+ *   whatever `shouldRefresh(response)` says) `refresh({ token, response })` is
+ *   called once for all concurrent callers and the request is replayed with the
+ *   new token. `header` defaults to "authorization", `scheme` to "Bearer" ("" for none).
+ * @param {string[]} [defaults.trustedOrigins] - extra origins ("https://cdn.example.com") that may
+ *   receive the default credentials, besides `baseUrl`'s. With neither `baseUrl` nor
+ *   `trustedOrigins` set there is nothing to compare against and credentials go everywhere.
+ * @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]
+ * @param {(event: object) => void | Promise<void>} [defaults.onEvent] - receives `{ type, ... }` events:
+ *   "request", "attempt", "retry", "response", "error", "cache", "ratelimit", "circuit", "auth".
+ *   Errors thrown by the handler are swallowed — logging must never break a request.
  */
-function buildQuery(params) {
-  if (!params) return "";
+function createFetch(defaults = {}) {
+  const {
+    baseUrl,
+    headers: defaultHeaders,
+    timeout: defaultTimeout = 30000,
+    retry: defaultRetry = {},
+    rateLimit,
+    circuitBreaker,
+    cache,
+    auth,
+    trustedOrigins,
+    dedupe = false,
+    throwHttpErrors: defaultThrow = true,
+    fetch: customFetch,
+    onRequest,
+    onResponse,
+    onEvent,
+  } = defaults;
 
-  const pairs = [];
-  for (const [key, value] of Object.entries(params)) {
-    if (value === null || value === undefined) continue;
+  const doFetch = (...args) => (customFetch || globalThis.fetch)(...args);
 
-    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))}`);
+  // A throwing (or rejecting) handler must never break a request.
+  const emitEvent = (event) => {
+    if (!onEvent) return;
+    try {
+      const result = onEvent(event);
+      if (result && typeof result.catch === "function") result.catch(() => {});
+    } catch {
+      // ignore
     }
+  };
+
+  // Origins allowed to receive default credentials. Empty = no baseUrl to compare against = unrestricted.
+  const trusted = new Set();
+  for (const o of [baseUrl, ...(trustedOrigins || [])]) {
+    const origin = o && getOrigin(o);
+    if (origin) trusted.add(origin);
   }
+  const isTrustedTarget = (url) => {
+    if (trusted.size === 0 || !isAbsoluteUrl(url)) return true; // relative URLs resolve against our own base
+    const origin = getOrigin(url);
+    return origin !== null && trusted.has(origin);
+  };
 
-  return pairs.join("&");
-}
+  // --- stateful pieces, built once so `extend()` children share them -------
+  const limiter = !rateLimit
+    ? null
+    : typeof rateLimit.acquire === "function"
+      ? rateLimit
+      : createRateLimiter(rateLimit === true ? {} : rateLimit);
 
-module.exports = { buildQuery };
+  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)) {
+              const options = circuitBreaker === true ? {} : { ...circuitBreaker };
+              const userOnStateChange = options.onStateChange;
+              options.onStateChange = (state, previous) => {
+                if (userOnStateChange) userOnStateChange(state, previous);
+                emitEvent({ type: "circuit", origin, state, previous });
+              };
+              breakerRegistry.set(origin, createCircuitBreaker(options));
+            }
+            return breakerRegistry.get(origin);
+          };
 
-},
-"./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;
-  }
-}
-
-// One in-flight token refresh per `auth` config object, so concurrent 401s —
-// even across extend() children — trigger exactly one refresh.
-const refreshStates = new WeakMap();
-function refreshStateFor(auth) {
-  let state = refreshStates.get(auth);
-  if (!state) {
-    state = { inflight: null };
-    refreshStates.set(auth, state);
-  }
-  return state;
-}
-
-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)
- *  - `auth`: attach a token, and on a 401 refresh it ONCE (shared by all
- *    concurrent requests) and replay the request
- *  - `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 {object} [defaults.auth] - `{ getToken, refresh, header?, scheme?, shouldRefresh? }`.
- *   `getToken()` supplies the current token (sync or async); on a 401 (or
- *   whatever `shouldRefresh(response)` says) `refresh({ token, response })` is
- *   called once for all concurrent callers and the request is replayed with the
- *   new token. `header` defaults to "authorization", `scheme` to "Bearer" ("" for none).
- * @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,
-    auth,
-    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 cacheCfg = !cache
+    ? null
+    : {
+        ttl: 60000,
+        staleWhileRevalidate: 0,
+        staleIfError: 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 });
+  const emit = (type, url) => {
+    if (cacheCfg && cacheCfg.onEvent) cacheCfg.onEvent({ type, url });
+    emitEvent({ type: "cache", url, method: "GET", event: type });
+  };
 
   // Shared in-flight GETs. Every caller gets its own clone of the response so
   // body reads don't fight each other.
@@ -613,9 +555,12 @@ function createFetch(defaults = {}) {
   // Returns a token newer than `usedToken`, refreshing at most once no matter
   // how many requests were rejected at the same time. If someone else already
   // refreshed (the current token isn't the one we used), just use that.
-  async function obtainFreshToken(authCfg, tokenUsed, response) {
+  async function obtainFreshToken(authCfg, tokenUsed, response, info) {
     const current = await authCfg.getToken();
-    if (current && current !== tokenUsed) return current;
+    if (current && current !== tokenUsed) {
+      emitEvent({ type: "auth", ...info, outcome: "reused" });
+      return current;
+    }
 
     const state = refreshStateFor(authCfg);
     if (!state.inflight) {
@@ -628,10 +573,21 @@ function createFetch(defaults = {}) {
         }
       })();
     }
-    return state.inflight;
+    try {
+      const token = await state.inflight;
+      emitEvent({ type: "auth", ...info, outcome: "refreshed" });
+      return token;
+    } catch (error) {
+      emitEvent({ type: "auth", ...info, outcome: "failed", error });
+      throw error;
+    }
   }
 
-  async function request(input, init = {}) {
+  // May a cached copy be served because the origin is failing?
+  const withinStaleIfError = (entry) =>
+    cacheCfg && cacheCfg.staleIfError > 0 && Date.now() - entry.storedAt < cacheCfg.ttl + cacheCfg.staleIfError;
+
+  async function execute(input, init, state) {
     const {
       query,
       json,
@@ -645,7 +601,20 @@ function createFetch(defaults = {}) {
     } = init;
 
     const method = String(fetchInit.method || "GET").toUpperCase();
-    const headers = mergeHeaders(await resolveHeaders(defaultHeaders), new Headers(initHeaders || undefined));
+    const url = joinUrl(baseUrl, input, query);
+    state.url = url;
+    state.method = method;
+    const credentialsAllowed = isTrustedTarget(url);
+
+    const defaultHeaderSet = await resolveHeaders(defaultHeaders);
+    if (!credentialsAllowed) {
+      // An absolute URL to some other host: don't hand it our default credentials.
+      for (const name of [...SENSITIVE_HEADERS, ...(auth && auth.header ? [String(auth.header).toLowerCase()] : [])]) {
+        defaultHeaderSet.delete(name);
+      }
+    }
+    // Headers the caller passes for *this* call are deliberate, so they always go through.
+    const headers = mergeHeaders(defaultHeaderSet, new Headers(initHeaders || undefined));
 
     let body = fetchInit.body;
     if (json !== undefined) {
@@ -653,16 +622,19 @@ function createFetch(defaults = {}) {
       if (!headers.has("content-type")) headers.set("content-type", "application/json");
     }
 
-    const ctx = { url: joinUrl(baseUrl, input, query), init: { ...fetchInit, method, headers, body } };
+    const ctx = { url, 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();
+    state.url = ctx.url;
+    state.method = finalMethod;
+    emitEvent({ type: "request", url: ctx.url, method: finalMethod });
 
     // --- auth: attach the current token (unless the caller set the header) ----
     const authHeader = auth ? String(auth.header || "authorization").toLowerCase() : null;
     const formatToken = (token) => (auth.scheme === "" ? String(token) : `${auth.scheme === undefined ? "Bearer" : auth.scheme} ${token}`);
     let usedToken = null;
-    if (auth && !finalHeaders.has(authHeader)) {
+    if (auth && credentialsAllowed && !finalHeaders.has(authHeader)) {
       usedToken = (await auth.getToken()) || null;
       if (usedToken) finalHeaders.set(authHeader, formatToken(usedToken));
     }
@@ -682,8 +654,13 @@ function createFetch(defaults = {}) {
     // `netSignal` are parameters so background revalidation can reuse this.
     function network(netHeaders, netSignal) {
       const attemptOnce = () => {
+        state.attempts++;
+        emitEvent({ type: "attempt", url: ctx.url, method: finalMethod, attempt: state.attempts });
         const attempt = async () => {
-          if (limiter) await limiter.acquire({ signal: netSignal });
+          if (limiter) {
+            const waitedMs = await limiter.acquire({ signal: netSignal });
+            if (waitedMs > 0) emitEvent({ type: "ratelimit", url: ctx.url, method: finalMethod, waitedMs });
+          }
           const res = await withTimeout(
             (attemptSignal) => {
               const attemptInit = { ...ctx.init, method: finalMethod, headers: netHeaders, signal: attemptSignal };
@@ -715,6 +692,19 @@ function createFetch(defaults = {}) {
             ...retryRest,
             retries,
             retryStatusCodes: statusCodes || DEFAULT_RETRY_STATUS_CODES,
+            onRetry: (err, attempt, delayMs, rctx) => {
+              if (retryRest.onRetry) retryRest.onRetry(err, attempt, delayMs, rctx);
+              emitEvent({
+                type: "retry",
+                url: ctx.url,
+                method: finalMethod,
+                attempt: attempt + 1,
+                delayMs,
+                reason: rctx.reason === "result" ? "status" : "error",
+                status: rctx.status,
+                error: err,
+              });
+            },
             shouldRetry:
               customShouldRetry ||
               ((err) => {
@@ -746,6 +736,17 @@ function createFetch(defaults = {}) {
     let entry = null;
 
     const finish = async (response) => {
+      state.responded = true;
+      emitEvent({
+        type: "response",
+        url: ctx.url,
+        method: finalMethod,
+        status: response.status,
+        ok: response.ok,
+        durationMs: Date.now() - state.startedAt,
+        attempts: state.attempts,
+        cache: state.cache,
+      });
       if (onResponse) await onResponse({ url: ctx.url, init: ctx.init, response });
       if (throwHttpErrors && !response.ok) {
         throw new HTTPError(response, { method: finalMethod, url: ctx.url });
@@ -760,10 +761,12 @@ function createFetch(defaults = {}) {
         const age = Date.now() - entry.storedAt;
         if (age < cacheCfg.ttl) {
           emit("hit", ctx.url);
+          state.cache = "hit";
           return finish(entryToResponse(entry));
         }
         if (age < cacheCfg.ttl + cacheCfg.staleWhileRevalidate) {
           emit("stale", ctx.url);
+          state.cache = "stale";
           if (!revalidating.has(key)) {
             revalidating.add(key);
             const staleEntry = entry;
@@ -800,13 +803,19 @@ function createFetch(defaults = {}) {
     } 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;
+      // The network failed but we still hold a usable copy: serve it (never for a deliberate abort).
+      if (entry && withinStaleIfError(entry) && !(signal && signal.aborted) && !(err && err.name === "AbortError")) {
+        emit("stale-if-error", ctx.url);
+        state.cache = "stale-if-error";
+        return finish(entryToResponse(entry));
+      }
       throw err;
     }
 
     // --- auth: a rejected token is refreshed once, then the request replays ----
     const needsRefresh = auth && (auth.shouldRefresh ? auth.shouldRefresh(response) : response.status === 401);
     if (usedToken && needsRefresh && !isStreamBody(ctx.init.body)) {
-      const fresh = await obtainFreshToken(auth, usedToken, response);
+      const fresh = await obtainFreshToken(auth, usedToken, response, { url: ctx.url, method: finalMethod });
       if (fresh) {
         await discardBody(response);
         finalHeaders.set(authHeader, formatToken(fresh));
@@ -821,15 +830,25 @@ function createFetch(defaults = {}) {
       }
     }
 
+    // The server answered, but with an error, and we still hold a usable copy.
+    if (useCache && entry && response.status >= 500 && withinStaleIfError(entry)) {
+      await discardBody(response);
+      emit("stale-if-error", ctx.url);
+      state.cache = "stale-if-error";
+      return finish(entryToResponse(entry));
+    }
+
     if (useCache) {
       if (response.status === 304 && entry) {
         entry.storedAt = Date.now();
         await cacheCfg.store.set(key, entry);
         emit("revalidated", ctx.url);
+        state.cache = "revalidated";
         await discardBody(response);
         response = entryToResponse(entry);
       } else {
         emit("miss", ctx.url);
+        state.cache = "miss";
         if (response.status === 200) scheduleStore(key, response, ctx.url);
       }
     }
@@ -837,6 +856,22 @@ function createFetch(defaults = {}) {
     return finish(response);
   }
 
+  async function request(input, init = {}) {
+    const state = { startedAt: Date.now(), attempts: 0, responded: false, cache: undefined, url: undefined, method: undefined };
+    try {
+      return await execute(input, init, state);
+    } catch (error) {
+      // A non-2xx HTTPError was already reported as a "response" event.
+      if (!state.responded) {
+        emitEvent({ type: "error", url: state.url, method: state.method, error, durationMs: Date.now() - state.startedAt, attempts: state.attempts });
+      }
+      throw error;
+    }
+  }
+
+  /** The `baseUrl` this instance was created with (paginateLinks uses it to stay on-origin). */
+  request.baseUrl = baseUrl;
+
   /** 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);
@@ -866,988 +901,992 @@ function createFetch(defaults = {}) {
 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) {
+"http/parseJsonSafe": 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...).
+ * Parses a fetch Response (or raw string) as JSON without throwing.
+ * Returns { data, error } — exactly one is non-null.
  *
- * @param {{ maxEntries?: number }} [opts]
+ * @param {Response | string} input
  */
-function createMemoryCache(opts = {}) {
-  const { maxEntries = 100 } = opts;
-  if (!(Number.isInteger(maxEntries) && maxEntries >= 1)) {
-    throw new TypeError("createMemoryCache: `maxEntries` must be an integer >= 1");
+async function parseJsonSafe(input) {
+  let text;
+  try {
+    text = typeof input === "string" ? input : await input.text();
+  } catch (err) {
+    return { data: null, error: err };
   }
-  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 (!text) {
+    return { data: null, error: null };
   }
-  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 { data: JSON.parse(text), error: null };
+  } catch (err) {
+    return { data: null, error: err };
   }
-  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);
+module.exports = { parseJsonSafe };
 
-    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;
-  }
+},
+"index": function (module, exports, require) {
+const { withRetry, RetryAbortedError, StopRetry } = require("./resilience/retry");
+const { withTimeout, TimeoutError } = require("./resilience/timeout");
+const { normalizeError } = require("./errors/normalizeError");
+const { parseJsonSafe } = require("./http/parseJsonSafe");
+const { buildQuery } = require("./http/buildQuery");
+const { retryAfterAware, parseRetryAfter, getWaitMsFromHeaders } = require("./resilience/retryAfterAware");
+const { withProgress, BodyTooLargeError } = require("./streams/progress");
+const { withDedupe } = require("./resilience/dedupe");
+const { createLimiter } = require("./resilience/limiter");
+const { createFetch, HTTPError } = require("./http/createFetch");
+const { createRateLimiter } = require("./resilience/rateLimiter");
+const { createCircuitBreaker, CircuitOpenError } = require("./resilience/circuitBreaker");
+const { createMemoryCache } = require("./http/cache/memoryCache");
+const { createMockFetch } = require("./testing/createMockFetch");
+const { downloadResumable } = require("./streams/download");
+const { readLines, readNDJSON, readSSE } = require("./streams/readers");
+const { streamSSE } = require("./streams/streamSSE");
+const { paginate, paginatePages, paginateLinks, parseLinkHeader } = require("./pagination/paginate");
 
-  function replyHandler(status, body, opts = {}) {
-    return async (call) => {
-      if (opts.delayMs) await abortableSleep(opts.delayMs, call.signal);
-      return buildResponse(status, body, opts.headers);
-    };
-  }
+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,
+  paginate,
+  paginatePages,
+  paginateLinks,
+  parseLinkHeader,
+};
 
-  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);
-    };
-  }
+},
+"internal/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;
 
-  function networkError(code = "ECONNREFUSED") {
-    const err = new TypeError("fetch failed");
-    err.cause = Object.assign(new Error(`connect ${code}`), { code });
-    return err;
+  // delta-seconds (spec says integer; tolerate "1.5" from sloppy servers)
+  if (/^\d+(\.\d+)?$/.test(value)) {
+    return Number(value) * 1000;
   }
 
-  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 dateMs = Date.parse(value);
+  if (!Number.isNaN(dateMs)) {
+    return Math.max(0, dateMs - Date.now());
+  }
 
-    const headers = {};
-    new Headers(init.headers || (typeof input === "object" ? input.headers : undefined)).forEach((v, k) => {
-      headers[k] = v;
-    });
+  return null;
+}
 
-    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);
+// 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());
+}
 
-    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);
+function readHeader(headers, ...names) {
+  for (const name of names) {
+    const v = headers.get(name);
+    if (v !== null && v !== undefined && v !== "") return v;
   }
-
-  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;
-    },
-  };
+  return null;
 }
 
-module.exports = { createMockFetch };
+/**
+ * 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;
 
-},
-"./createRateLimiter": function (module, exports, require) {
-const { abortableSleep } = require("./_sleep");
-const { getRateLimitInfo } = require("./_http");
+  const retryAfter = parseRetryAfter(headers.get("retry-after"));
+  if (retryAfter !== null) return retryAfter;
 
-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))
-    );
-  });
+  return parseResetMs(
+    readHeader(headers, "x-ratelimit-reset-after", "x-ratelimit-reset", "x-rate-limit-reset", "ratelimit-reset")
+  );
 }
 
 /**
- * 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
+ * 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 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();
+function getRateLimitInfo(headers) {
+  const info = { remaining: null, resetMs: null, retryAfterMs: null };
+  if (!headers || typeof headers.get !== "function") return info;
 
-  async function take(signal) {
-    for (;;) {
-      signal?.throwIfAborted?.();
-      const now = Date.now();
-      while (stamps.length > 0 && stamps[0] <= now - perMs) stamps.shift();
+  const remaining = readHeader(headers, "x-ratelimit-remaining", "x-rate-limit-remaining", "ratelimit-remaining");
+  if (remaining !== null && !Number.isNaN(Number(remaining))) info.remaining = Number(remaining);
 
-      let waitMs = 0;
-      if (blockedUntil > now) waitMs = blockedUntil - now;
-      else if (stamps.length >= requests) waitMs = stamps[0] + perMs - now;
+  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;
+}
 
-      if (waitMs <= 0) {
-        stamps.push(now);
-        return;
-      }
-      await abortableSleep(waitMs, signal);
+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
   }
+}
 
-  /** 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);
+/** The origin ("https://host:port") of an absolute URL, or null if `url` is relative/invalid. */
+function getOrigin(url) {
+  try {
+    const { origin } = new URL(String(url));
+    return origin === "null" ? null : origin;
+  } catch {
+    return null;
   }
+}
 
-  /** 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);
-  }
+module.exports = { parseRetryAfter, parseResetMs, getWaitMsFromHeaders, getRateLimitInfo, discardBody, getOrigin };
 
-  /** 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;
+},
+"internal/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;
   }
+}
 
-  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;
-    },
-  };
+/**
+ * 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 = { createRateLimiter };
+module.exports = { RetryAbortedError, sleep, abortableSleep };
 
 },
-"./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");
+"pagination/paginate": function (module, exports, require) {
+const { HTTPError } = require("../errors/HTTPError");
+const { getOrigin } = require("../internal/http");
 
-const RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
+const MAX_LINK_HEADER_LENGTH = 64 * 1024;
 
-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]) };
+/**
+ * Parses an RFC 8288 `Link` header (GitHub, GitLab, WordPress... use it for
+ * pagination) into `{ rel: url }`. Pass `base` to resolve relative URLs.
+ *
+ * ```js
+ * parseLinkHeader('<https://api.x/items?page=2>; rel="next", <https://api.x/items?page=9>; rel="last"');
+ * // { next: "https://api.x/items?page=2", last: "https://api.x/items?page=9" }
+ * ```
+ *
+ * A link with several rels (`rel="next last"`) is listed under each; the first
+ * link wins when a rel appears twice. Commas inside `<...>` are handled. Input
+ * is treated as untrusted: headers over 64 KB are ignored and parsing is linear-time.
+ *
+ * @param {string | null | undefined} header
+ * @param {string} [base]
+ * @returns {Record<string, string>}
+ */
+function parseLinkHeader(header, base) {
+  const links = {};
+  // Link headers are server-controlled; real ones are a few hundred bytes (HTTP stacks cap headers at ~16 KB).
+  if (!header || header.length > MAX_LINK_HEADER_LENGTH) return links;
+
+  // <url> followed by any number of `; name` / `; name=token` / `; name="quoted, value"` params
+  const linkRe = /<([^<>]*)>((?:\s*;\s*[^=;,<\s]+(?:\s*=\s*(?:"[^"]*"|[^;,<\s]*))?)*)/g;
+  let match;
+  while ((match = linkRe.exec(header)) !== null) {
+    const rel = /;\s*rel\s*=\s*(?:"([^"]*)"|([^\s;,]+))/i.exec(match[2]);
+    if (!rel) continue;
+
+    let url = match[1].trim();
+    if (base) {
+      try {
+        url = new URL(url, base).href;
+      } catch {
+        // leave it as written
+      }
+    }
+    for (const name of (rel[1] ?? rel[2]).toLowerCase().split(/\s+/).filter(Boolean)) {
+      if (!(name in links)) links[name] = url;
+    }
+  }
+  return links;
 }
 
-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;
+function stuckError(message) {
+  return Object.assign(new Error(message), { code: "PAGINATE_STUCK" });
 }
 
 /**
- * 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.
+ * Walks a paginated API page by page. You write `fetchPage(cursor, ctx)` —
+ * it returns `{ items, next }`, where `next` is whatever identifies the next
+ * page (a cursor token, an offset, a URL...) or `undefined`/`null` on the
+ * last page — and you get an async iterator of pages.
  *
  * ```js
- * const bytes = await downloadResumable(url, {
- *   onProgress: ({ percent }) => console.log(percent),
- *   maxBytes: 200 * 1024 * 1024,
- * });
+ * for await (const { items, index } of paginatePages(async (cursor) => {
+ *   const r = await api.json("/users", { query: { cursor, limit: 100 } });
+ *   return { items: r.data, next: r.next_cursor };
+ * })) { ... }
  * ```
  *
- * @param {string} url
+ * A `next` that equals the cursor just used throws `code: "PAGINATE_STUCK"`
+ * instead of looping forever.
+ *
+ * @template T
+ * @param {(cursor: any, ctx: { index: number, signal?: AbortSignal }) => Promise<{ items: T[], next?: any }>} fetchPage
  * @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 {any} [opts.start] - the cursor for the first page (default undefined)
+ * @param {number} [opts.maxPages=Infinity]
  * @param {AbortSignal} [opts.signal]
- * @param {(err: any, attempt: number, delayMs: number, info: {resumeFrom: number}) => void} [opts.onRetry]
- * @returns {Promise<Uint8Array>}
+ * @returns {AsyncGenerator<{ items: T[], index: number, cursor: any }>}
  */
-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 });
-    }
-  };
+async function* paginatePages(fetchPage, opts = {}) {
+  const { start, maxPages = Infinity, signal } = opts;
+  let cursor = start;
+  let index = 0;
 
   for (;;) {
+    if (index >= maxPages) return;
     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");
-      }
+    const result = await fetchPage(cursor, { index, signal });
+    if (!result || !Array.isArray(result.items)) {
+      throw new TypeError("paginate: fetchPage must return { items: array, next?: cursor }");
+    }
+    yield { items: result.items, index, cursor };
 
-      if (maxBytes !== undefined && total !== null && total > maxBytes) {
-        await res.body?.cancel?.().catch(() => {});
-        throw new BodyTooLargeError(maxBytes);
-      }
+    const next = result.next;
+    if (next === undefined || next === null) return;
+    if (next === cursor) {
+      throw stuckError("paginate: `next` equals the cursor just used, so the page didn't advance — stopping to avoid an infinite loop");
+    }
+    cursor = next;
+    index++;
+  }
+}
 
-      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(() => {});
-        }
-      }
+/**
+ * Like `paginatePages`, but yields the items one by one. `maxItems` stops
+ * early (mid-page) — and since nothing is fetched until you ask for it,
+ * `break`-ing out of the loop never fetches a page you didn't need.
+ *
+ * ```js
+ * for await (const user of paginate(fetchUsersPage, { maxItems: 250 })) { ... }
+ * ```
+ *
+ * @template T
+ * @param {(cursor: any, ctx: { index: number, signal?: AbortSignal }) => Promise<{ items: T[], next?: any }>} fetchPage
+ * @param {object} [opts] - same as paginatePages, plus `maxItems`
+ * @param {number} [opts.maxItems=Infinity]
+ * @returns {AsyncGenerator<T>}
+ */
+async function* paginate(fetchPage, opts = {}) {
+  const { maxItems = Infinity } = opts;
+  if (maxItems <= 0) return;
 
-      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" });
-      }
+  let count = 0;
+  for await (const page of paginatePages(fetchPage, opts)) {
+    for (const item of page.items) {
+      yield item;
+      if (++count >= maxItems) return;
+    }
+  }
+}
 
-      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;
+function defaultGetItems(data) {
+  if (Array.isArray(data)) return data;
+  for (const key of ["items", "data", "results", "records"]) {
+    if (data && Array.isArray(data[key])) return data[key];
+  }
+  throw new TypeError("paginateLinks: couldn't find the items array in the response — pass `getItems(data)`");
+}
 
-      if (loaded > loadedBefore) attempt = 0; // it made progress — doesn't count against the budget
-      if (attempt >= retries) throw err;
+/**
+ * Follows `Link: <...>; rel="next"` headers (GitHub-style) and yields the
+ * items of every page. `request` is anything fetch-like — a `createFetch`
+ * instance or plain `fetch` (a non-2xx response throws `HTTPError`).
+ *
+ * ```js
+ * for await (const repo of paginateLinks(api, "/orgs/acme/repos?per_page=100")) { ... }
+ * ```
+ *
+ * @param {(url: string, init?: object) => Promise<Response>} request
+ * @param {string} url - the first page
+ * @param {object} [opts]
+ * @param {(data: any, response: Response) => any[]} [opts.getItems] - default: the body if it's an array, else its `items` / `data` / `results` / `records`
+ * @param {number} [opts.maxPages=Infinity]
+ * @param {number} [opts.maxItems=Infinity]
+ * @param {AbortSignal} [opts.signal]
+ * @param {object} [opts.init] - extra options passed to every `request`
+ * @param {string[]} [opts.origins] - origins a `Link` may point to. Default: the origin of `url`
+ *   (or of the `createFetch` instance's `baseUrl`). A `Link` to anywhere else throws
+ *   `code: "PAGINATE_CROSS_ORIGIN"` — a server could otherwise steer your requests (and any
+ *   credentials in `init`) to a third party. The check is skipped only when no origin can be determined.
+ */
+async function* paginateLinks(request, url, opts = {}) {
+  const { getItems = defaultGetItems, init = {}, signal } = opts;
 
-      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);
+  const allowed = new Set();
+  if (opts.origins) {
+    for (const o of opts.origins) {
+      const origin = getOrigin(o);
+      if (origin) allowed.add(origin);
+    }
+  } else {
+    const origin = getOrigin(url) || getOrigin(request && request.baseUrl) || getOrigin(globalThis.location && globalThis.location.href);
+    if (origin) allowed.add(origin);
+  }
+
+  async function fetchPage(pageUrl) {
+    const res = await request(pageUrl, { ...init, signal });
+    if (!res.ok) throw new HTTPError(res, { method: init.method || "GET", url: pageUrl });
+    const items = getItems(await res.json(), res);
+    const next = parseLinkHeader(res.headers.get("link"), pageUrl).next;
+    if (next && allowed.size > 0) {
+      const nextOrigin = getOrigin(next);
+      if (nextOrigin !== null && !allowed.has(nextOrigin)) {
+        throw Object.assign(
+          new Error(`paginateLinks: refusing to follow a Link to another origin (${nextOrigin}). Pass { origins: [...] } if that's intended.`),
+          { code: "PAGINATE_CROSS_ORIGIN" }
+        );
       }
-      attempt++;
-      if (onRetry) onRetry(err, attempt, delayMs, { resumeFrom: loaded });
-      await abortableSleep(delayMs, signal);
     }
+    return { items, next };
   }
+
+  yield* paginate(fetchPage, { ...opts, start: url });
 }
 
-module.exports = { downloadResumable };
+module.exports = { paginate, paginatePages, paginateLinks, parseLinkHeader };
 
 },
-"./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");
-const { paginate, paginatePages, paginateLinks, parseLinkHeader } = require("./paginate");
+"resilience/circuitBreaker": 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;
+  }
+}
 
-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,
-  paginate,
-  paginatePages,
-  paginateLinks,
-  parseLinkHeader,
-};
+function defaultIsFailure(valueOrError, isError) {
+  if (isError) return !(valueOrError && valueOrError.name === "AbortError");
+  return Boolean(valueOrError) && typeof valueOrError.status === "number" && valueOrError.status >= 500;
+}
 
-},
-"./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 }
+ * 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.
  *
- * Every field is always present (null/false when not applicable) so callers
- * can destructure without existence checks.
+ * By default a thrown error (except AbortError) or a result with status >= 500
+ * counts as a failure; override with `isFailure(valueOrError, isError)`.
  *
- * - `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).
+ * @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;
+  }
 
-function shape(err, overrides) {
   return {
-    message: "Unknown error",
-    status: null,
-    code: null,
-    isNetworkError: false,
-    isTimeout: false,
-    isAborted: false,
-    cause: err,
-    ...overrides,
+    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");
+    },
   };
 }
 
-// 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);
+module.exports = { createCircuitBreaker, CircuitOpenError };
+
+},
+"resilience/dedupe": 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 null;
-}
-
-function isTimeoutCode(code) {
-  return code === "ETIMEDOUT" || code === "ESOCKETTIMEDOUT" || /^UND_ERR_.*TIMEOUT$/.test(code || "");
+  return id;
 }
 
-function isNetworkCode(code) {
-  if (!code) return false;
-  return /^E[A-Z0-9]+$/.test(code) || code === "EAI_AGAIN" || code === "EAI_FAIL" || code.startsWith("UND_ERR_");
+function isPlainObject(value) {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
 }
 
-// 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 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) };
 
-function isFetchNetworkTypeError(err) {
-  return err.name === "TypeError" && FETCH_NETWORK_MESSAGE.test(err.message || "");
+  // 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 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,
-    });
+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("|");
   }
+}
 
-  const chainCode = findCode(err);
+/**
+ * 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();
 
-  // 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,
-    });
-  }
+  return function deduped(...args) {
+    const key = keyFn(...args);
 
-  // Deliberate cancellation via AbortController — not a timeout.
-  if (err.name === "AbortError") {
-    return shape(err, {
-      message: err.message || "Request aborted",
-      code: "ABORT_ERR",
-      isAborted: true,
-    });
-  }
+    if (inFlight.has(key)) {
+      return inFlight.get(key);
+    }
 
-  // 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,
-    });
-  }
+    const promise = Promise.resolve()
+      .then(() => fn(...args))
+      .finally(() => {
+        inFlight.delete(key);
+      });
 
-  return shape(err, {
-    message: err.message || String(err),
-    status: err.status ?? err.statusCode ?? err.response?.status ?? err.response?.statusCode ?? null,
-    code: err.code ?? null,
-  });
+    inFlight.set(key, promise);
+    return promise;
+  };
 }
 
-module.exports = { normalizeError };
+module.exports = { withDedupe };
 
 },
-"./paginate": function (module, exports, require) {
-const { HTTPError } = require("./HTTPError");
-
+"resilience/limiter": function (module, exports, require) {
 /**
- * Parses an RFC 8288 `Link` header (GitHub, GitLab, WordPress... use it for
- * pagination) into `{ rel: url }`. Pass `base` to resolve relative URLs.
+ * 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
- * parseLinkHeader('<https://api.x/items?page=2>; rel="next", <https://api.x/items?page=9>; rel="last"');
- * // { next: "https://api.x/items?page=2", last: "https://api.x/items?page=9" }
+ * const limit = createLimiter(4);
+ * const bytes = await Promise.all(urls.map((u) => limit(() => download(u))));
+ * // or: await limit.map(urls, (u) => download(u));
  * ```
  *
- * A link with several rels (`rel="next last"`) is listed under each; the first
- * link wins when a rel appears twice. Commas inside `<...>` are handled.
- *
- * @param {string | null | undefined} header
- * @param {string} [base]
- * @returns {Record<string, string>}
+ * @param {number} [concurrency=Infinity] - integer >= 1, or Infinity
  */
-function parseLinkHeader(header, base) {
-  const links = {};
-  if (!header) return links;
+function createLimiter(concurrency = Infinity) {
+  if (concurrency !== Infinity && !(Number.isInteger(concurrency) && concurrency >= 1)) {
+    throw new TypeError("createLimiter: `concurrency` must be an integer >= 1 (or Infinity)");
+  }
 
-  // <url> followed by any number of `; name` / `; name=token` / `; name="quoted, value"` params
-  const linkRe = /<([^>]*)>((?:\s*;\s*[^=;,<\s]+(?:\s*=\s*(?:"[^"]*"|[^;,<\s]*))?)*)/g;
-  let match;
-  while ((match = linkRe.exec(header)) !== null) {
-    const rel = /;\s*rel\s*=\s*(?:"([^"]*)"|([^\s;,]+))/i.exec(match[2]);
-    if (!rel) continue;
+  const queue = [];
+  let active = 0;
 
-    let url = match[1].trim();
-    if (base) {
-      try {
-        url = new URL(url, base).href;
-      } catch {
-        // leave it as written
-      }
-    }
-    for (const name of (rel[1] ?? rel[2]).toLowerCase().split(/\s+/).filter(Boolean)) {
-      if (!(name in links)) links[name] = url;
+  function next() {
+    while (active < concurrency && queue.length > 0) {
+      active++;
+      queue.shift()();
     }
   }
-  return links;
-}
 
-function stuckError(message) {
-  return Object.assign(new Error(message), { code: "PAGINATE_STUCK" });
-}
+  function limit(fn, ...args) {
+    return new Promise((resolve, reject) => {
+      queue.push(() => {
+        Promise.resolve()
+          .then(() => fn(...args))
+          .then(resolve, reject)
+          .finally(() => {
+            active--;
+            next();
+          });
+      });
+      next();
+    });
+  }
 
-/**
- * Walks a paginated API page by page. You write `fetchPage(cursor, ctx)` —
- * it returns `{ items, next }`, where `next` is whatever identifies the next
- * page (a cursor token, an offset, a URL...) or `undefined`/`null` on the
- * last page — and you get an async iterator of pages.
- *
- * ```js
- * for await (const { items, index } of paginatePages(async (cursor) => {
- *   const r = await api.json("/users", { query: { cursor, limit: 100 } });
- *   return { items: r.data, next: r.next_cursor };
- * })) { ... }
- * ```
- *
- * A `next` that equals the cursor just used throws `code: "PAGINATE_STUCK"`
- * instead of looping forever.
- *
- * @template T
- * @param {(cursor: any, ctx: { index: number, signal?: AbortSignal }) => Promise<{ items: T[], next?: any }>} fetchPage
- * @param {object} [opts]
- * @param {any} [opts.start] - the cursor for the first page (default undefined)
- * @param {number} [opts.maxPages=Infinity]
- * @param {AbortSignal} [opts.signal]
- * @returns {AsyncGenerator<{ items: T[], index: number, cursor: any }>}
- */
-async function* paginatePages(fetchPage, opts = {}) {
-  const { start, maxPages = Infinity, signal } = opts;
-  let cursor = start;
-  let index = 0;
+  Object.defineProperties(limit, {
+    activeCount: { get: () => active },
+    pendingCount: { get: () => queue.length },
+  });
 
-  for (;;) {
-    if (index >= maxPages) return;
-    signal?.throwIfAborted?.();
+  /** 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)));
 
-    const result = await fetchPage(cursor, { index, signal });
-    if (!result || !Array.isArray(result.items)) {
-      throw new TypeError("paginate: fetchPage must return { items: array, next?: cursor }");
-    }
-    yield { items: result.items, index, cursor };
+  return limit;
+}
 
-    const next = result.next;
-    if (next === undefined || next === null) return;
-    if (next === cursor) {
-      throw stuckError("paginate: `next` equals the cursor just used, so the page didn't advance — stopping to avoid an infinite loop");
+module.exports = { createLimiter };
+
+},
+"resilience/rateLimiter": function (module, exports, require) {
+const { abortableSleep } = require("../internal/sleep");
+const { getRateLimitInfo } = require("../internal/http");
+
+function abortable(promise, signal) {
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
     }
-    cursor = next;
-    index++;
-  }
+    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))
+    );
+  });
 }
 
 /**
- * Like `paginatePages`, but yields the items one by one. `maxItems` stops
- * early (mid-page) — and since nothing is fetched until you ask for it,
- * `break`-ing out of the loop never fetches a page you didn't need.
+ * 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
- * for await (const user of paginate(fetchUsersPage, { maxItems: 250 })) { ... }
+ * const rl = createRateLimiter({ requests: 10, perMs: 1000 });
+ * const res = await rl.run(() => fetch(url)); // acquire → call → learn from headers
  * ```
  *
- * @template T
- * @param {(cursor: any, ctx: { index: number, signal?: AbortSignal }) => Promise<{ items: T[], next?: any }>} fetchPage
- * @param {object} [opts] - same as paginatePages, plus `maxItems`
- * @param {number} [opts.maxItems=Infinity]
- * @returns {AsyncGenerator<T>}
+ * @param {object} [opts]
+ * @param {number} [opts.requests=Infinity] - max requests per window
+ * @param {number} [opts.perMs=1000] - window length
  */
-async function* paginate(fetchPage, opts = {}) {
-  const { maxItems = Infinity } = opts;
-  if (maxItems <= 0) return;
+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");
+  }
 
-  let count = 0;
-  for await (const page of paginatePages(fetchPage, opts)) {
-    for (const item of page.items) {
-      yield item;
-      if (++count >= maxItems) return;
+  const stamps = [];
+  let blockedUntil = 0;
+  let tail = Promise.resolve();
+
+  async function take(signal) {
+    let waitedMs = 0;
+    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 waitedMs;
+      }
+      const waitStartedAt = Date.now();
+      await abortableSleep(waitMs, signal);
+      waitedMs += Date.now() - waitStartedAt;
     }
   }
-}
 
-function defaultGetItems(data) {
-  if (Array.isArray(data)) return data;
-  for (const key of ["items", "data", "results", "records"]) {
-    if (data && Array.isArray(data[key])) return data[key];
+  /** Resolves with the time spent waiting. Rejects if aborted while waiting. */
+  function acquire({ signal } = {}) {
+    const turn = tail.then(() => take(signal));
+    tail = turn.catch(() => {});
+    return abortable(turn, signal);
   }
-  throw new TypeError("paginateLinks: couldn't find the items array in the response — pass `getItems(data)`");
-}
 
-/**
- * Follows `Link: <...>; rel="next"` headers (GitHub-style) and yields the
- * items of every page. `request` is anything fetch-like — a `createFetch`
- * instance or plain `fetch` (a non-2xx response throws `HTTPError`).
- *
- * ```js
- * for await (const repo of paginateLinks(api, "/orgs/acme/repos?per_page=100")) { ... }
- * ```
- *
- * @param {(url: string, init?: object) => Promise<Response>} request
- * @param {string} url - the first page
- * @param {object} [opts]
- * @param {(data: any, response: Response) => any[]} [opts.getItems] - default: the body if it's an array, else its `items` / `data` / `results` / `records`
- * @param {number} [opts.maxPages=Infinity]
- * @param {number} [opts.maxItems=Infinity]
- * @param {AbortSignal} [opts.signal]
- * @param {object} [opts.init] - extra options passed to every `request`
- */
-async function* paginateLinks(request, url, opts = {}) {
-  const { getItems = defaultGetItems, init = {}, signal } = opts;
+  /** 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);
+  }
 
-  async function fetchPage(pageUrl) {
-    const res = await request(pageUrl, { ...init, signal });
-    if (!res.ok) throw new HTTPError(res, { method: init.method || "GET", url: pageUrl });
-    const items = getItems(await res.json(), res);
-    const next = parseLinkHeader(res.headers.get("link"), pageUrl).next;
-    return { items, next };
+  /** 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;
   }
 
-  yield* paginate(fetchPage, { ...opts, start: url });
+  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 = { paginate, paginatePages, paginateLinks, parseLinkHeader };
+module.exports = { createRateLimiter };
 
 },
-"./parseJsonSafe": function (module, exports, require) {
+"resilience/retry": function (module, exports, require) {
+const { RetryAbortedError, sleep } = require("../internal/sleep");
+const { getWaitMsFromHeaders, discardBody } = require("../internal/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";
+}
+
 /**
- * Parses a fetch Response (or raw string) as JSON without throwing.
- * Returns { data, error } — exactly one is non-null.
+ * 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 {Response | string} input
+ * @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 parseJsonSafe(input) {
-  let text;
-  try {
-    text = typeof input === "string" ? input : await input.text();
-  } catch (err) {
-    return { data: null, error: err };
+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;
   }
 
-  if (!text) {
-    return { data: null, error: null };
-  }
+  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;
 
-  try {
-    return { data: JSON.parse(text), error: null };
-  } catch (err) {
-    return { data: null, error: err };
+    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 = { parseJsonSafe };
+module.exports = { withRetry, RetryAbortedError, StopRetry };
 
 },
-"./retryAfterAware": function (module, exports, require) {
-const { withRetry } = require("./withRetry");
-const { normalizeError } = require("./normalizeError");
-const { parseRetryAfter, getWaitMsFromHeaders } = require("./_http");
+"resilience/retryAfterAware": function (module, exports, require) {
+const { withRetry } = require("./retry");
+const { normalizeError } = require("../errors/normalizeError");
+const { parseRetryAfter, getWaitMsFromHeaders } = require("../internal/http");
 
 function defaultShouldRetryError(err) {
   const normalized = normalizeError(err);
@@ -1919,210 +1958,397 @@ function retryAfterAware(fn, opts = {}) {
   });
 }
 
-module.exports = { retryAfterAware, parseRetryAfter, getWaitMsFromHeaders };
+module.exports = { retryAfterAware, parseRetryAfter, getWaitMsFromHeaders };
+
+},
+"resilience/timeout": 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 };
+
+},
+"streams/download": function (module, exports, require) {
+const { HTTPError } = require("../errors/HTTPError");
+const { BodyTooLargeError } = require("./progress");
+const { normalizeError } = require("../errors/normalizeError");
+const { getWaitMsFromHeaders } = require("../internal/http");
+const { abortableSleep } = require("../internal/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;
 
-},
-"./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");
+      if (loaded > loadedBefore) attempt = 0; // it made progress — doesn't count against the budget
+      if (attempt >= retries) throw err;
 
-function isRetryableStatus(status) {
-  return status === 408 || status === 425 || status === 429 || status >= 500;
+      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);
+    }
+  }
 }
 
-function isRetryableError(err) {
-  const n = normalizeError(err);
-  return !n.isAborted && (n.isNetworkError || n.isTimeout);
+module.exports = { downloadResumable };
+
+},
+"streams/progress": 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;
+  }
 }
 
-async function resolveHeaders(source) {
-  const value = typeof source === "function" ? await source() : source;
-  return new Headers(value || undefined);
+function cancelQuietly(reader) {
+  try {
+    const p = reader.cancel();
+    if (p && typeof p.catch === "function") p.catch(() => {});
+  } catch {
+    // already closed / released — nothing to do
+  }
 }
 
 /**
- * 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);
- * }
- * ```
+ * 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.
  *
- * 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.
+ * `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 {string} url
+ * @param {Response} response
+ * @param {(progress: { loaded: number, total: number | null, percent: number | null }) => void} [onProgress]
  * @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}>}
+ * @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* 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;
+async function withProgress(response, onProgress, opts = {}) {
+  const { maxBytes, signal } = opts;
+  signal?.throwIfAborted?.();
 
-  for (;;) {
+  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?.();
-    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;
-      }
+    if (maxBytes !== undefined && buf.byteLength > maxBytes) {
+      throw new BodyTooLargeError(maxBytes);
     }
-
-    // ---- 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",
-          });
-        }
-      }
+    if (onProgress) {
+      onProgress({ loaded: buf.byteLength, total: buf.byteLength, percent: 100 });
     }
+    return buf;
+  }
 
-    // ---- 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 };
-      }
-    }
+  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;
 
-    // ---- 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;
-    }
+  const reader = response.body.getReader();
 
-    // 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",
-      });
-    }
+  // Fail fast when the declared size already exceeds the cap.
+  if (maxBytes !== undefined && total !== null && total > maxBytes) {
+    cancelQuietly(reader);
+    throw new BodyTooLargeError(maxBytes);
+  }
 
-    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
+  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 (onReconnect) {
-      onReconnect({
-        reason: failure.reason,
-        error: failure.error,
-        status: failure.status,
-        attempt: Math.max(failures, 1),
-        delayMs,
-        lastEventId: lastId,
-      });
+      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,
+        });
+      }
     }
-    await abortableSleep(delayMs, signal);
+    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 = { streamSSE };
+module.exports = { withProgress, BodyTooLargeError };
 
 },
-"./streams": function (module, exports, require) {
+"streams/readers": function (module, exports, require) {
 const encoder = new TextEncoder();
 
 // Yields Uint8Array chunks from a fetch Response, a web ReadableStream, or any
@@ -2159,46 +2385,83 @@ async function* chunks(source, signal) {
   }
 }
 
+const DEFAULT_MAX_LINE_LENGTH = 16 * 1024 * 1024;
+
+function lineTooLong(limit) {
+  return Object.assign(
+    new Error(`reqkit streams: a line exceeded ${limit} characters without a line break (raise \`maxLineLength\` if that's expected)`),
+    { code: "LINE_TOO_LONG" }
+  );
+}
+
 /**
  * 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.
  *
+ * Runs in linear time and bounded memory: only newly arrived text is scanned,
+ * and a "line" longer than `maxLineLength` characters (default 16 Mi — a
+ * server that never sends a newline) throws `code: "LINE_TOO_LONG"` instead
+ * of buffering forever.
+ *
  * ```js
  * for await (const line of readLines(response)) console.log(line);
  * ```
  *
  * @param {Response | ReadableStream | AsyncIterable<Uint8Array>} source
- * @param {{ signal?: AbortSignal }} [opts]
+ * @param {{ signal?: AbortSignal, maxLineLength?: number }} [opts]
  * @returns {AsyncGenerator<string>}
  */
 async function* readLines(source, opts = {}) {
+  const { maxLineLength = DEFAULT_MAX_LINE_LENGTH } = opts;
   const decoder = new TextDecoder("utf-8");
-  let buffer = "";
+  const terminator = /[\r\n]/g;
+
+  let parts = []; // pieces of the line being assembled (no terminators in them)
+  let partsLength = 0;
+  let skipLF = false; // the previous line ended with "\r", so a leading "\n" belongs to it
   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/, "");
+    let text = decoder.decode(chunk, { stream: true });
+    if (first && text.length > 0) {
+      text = text.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);
+    let start = 0;
+    terminator.lastIndex = 0;
+    let match;
+    while ((match = terminator.exec(text)) !== null) {
+      const ch = match[0];
+      if (ch === "\n" && skipLF && match.index === start) {
+        skipLF = false; // the "\n" of a "\r\n" pair — swallow it
+        start = match.index + 1;
+        continue;
+      }
+      skipLF = false;
+
+      const piece = text.slice(start, match.index);
+      if (partsLength + piece.length > maxLineLength) throw lineTooLong(maxLineLength);
+      const line = parts.length > 0 ? parts.join("") + piece : piece;
+      parts = [];
+      partsLength = 0;
+      yield line;
+
+      start = match.index + 1;
+      skipLF = ch === "\r";
+    }
+
+    if (start < text.length) {
+      const rest = text.slice(start);
+      partsLength += rest.length;
+      if (partsLength > maxLineLength) throw lineTooLong(maxLineLength);
+      parts.push(rest);
+      skipLF = false;
     }
-    buffer = buffer.slice(pos);
   }
 
-  buffer += decoder.decode();
-  if (buffer.endsWith("\r")) buffer = buffer.slice(0, -1);
-  if (buffer.length > 0) yield buffer;
+  const tail = parts.join("") + decoder.decode();
+  if (tail.length > 0) yield tail;
 }
 
 /**
@@ -2238,11 +2501,13 @@ async function* readNDJSON(source, opts = {}) {
  * ```
  *
  * @param {Response | ReadableStream | AsyncIterable<Uint8Array>} source
- * @param {{ signal?: AbortSignal }} [opts]
+ * @param {{ signal?: AbortSignal, maxLineLength?: number }} [opts] - `maxLineLength` also caps the data of a single event
  */
 async function* readSSE(source, opts = {}) {
+  const maxEventLength = opts.maxLineLength ?? DEFAULT_MAX_LINE_LENGTH;
   let event = "";
   let data = [];
+  let dataLength = 0;
   let retry;
   let lastId = "";
 
@@ -2251,6 +2516,7 @@ async function* readSSE(source, opts = {}) {
       if (data.length > 0) yield { event: event || "message", data: data.join("\n"), id: lastId, retry };
       event = "";
       data = [];
+      dataLength = 0;
       retry = undefined;
       continue;
     }
@@ -2261,462 +2527,432 @@ async function* readSSE(source, opts = {}) {
     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;
+    if (field === "event") event = value;
+    else if (field === "data") {
+      dataLength += value.length + 1;
+      if (dataLength > maxEventLength) throw lineTooLong(maxEventLength);
+      data.push(value);
+    }
+    else if (field === "id") {
+      if (!value.includes("\0")) lastId = value;
+    } else if (field === "retry") {
+      if (/^\d+$/.test(value)) retry = Number(value);
+    }
   }
-  return result;
 }
 
-module.exports = { withProgress, BodyTooLargeError };
+module.exports = { readLines, readNDJSON, readSSE };
 
 },
-"./withRetry": function (module, exports, require) {
-const { RetryAbortedError, sleep } = require("./_sleep");
-const { getWaitMsFromHeaders, discardBody } = require("./_http");
+"streams/streamSSE": function (module, exports, require) {
+const { readSSE } = require("./readers");
+const { HTTPError } = require("../errors/HTTPError");
+const { normalizeError } = require("../errors/normalizeError");
+const { getWaitMsFromHeaders, discardBody } = require("../internal/http");
+const { abortableSleep } = require("../internal/sleep");
 
-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";
+function isRetryableStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500;
 }
 
-/**
- * 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;
-  }
+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);
 }
 
 /**
- * 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.
+ * 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.
  *
- * @param {(attempt: number) => Promise<any>} fn
+ * ```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 {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*.
+ * @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 withRetry(fn, opts = {}) {
+async function* streamSSE(url, 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,
+    fetch: fetchFn = globalThis.fetch,
+    method = "GET",
+    headers,
+    body,
     signal,
+    reconnect = method === "GET" || method === "HEAD",
+    retries = 10,
+    reconnectDelayMs = 1000,
+    maxDelayMs = 30000,
+    stopWhen,
+    onOpen,
+    onReconnect,
   } = opts;
 
-  const startedAt = Date.now();
+  let lastId = opts.lastEventId || "";
+  let baseDelay = reconnectDelayMs;
+  let failures = 0; // consecutive connections that delivered nothing
+  let connections = 0;
 
-  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);
-  }
+  for (;;) {
+    signal?.throwIfAborted?.();
+    let failure = null; // { reason, error?, status?, response? }
+    let res = null;
 
-  // 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);
+    // ---- 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;
+      }
     }
-    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;
+    // ---- 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",
+          });
+        }
+      }
     }
-    return shouldRetryResult ? Boolean(shouldRetryResult(result, attempt)) : false;
-  }
 
-  let lastErr;
-  for (let attempt = 0; ; attempt++) {
-    if (signal?.aborted) {
-      throw new RetryAbortedError(lastErr);
+    // ---- 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 };
+      }
     }
 
-    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;
+    // ---- 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",
+      });
+    }
 
-      const waitMs = planWait(backoff(attempt), attempt, err, undefined);
-      if (waitMs === null) throw err;
+    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 (onRetry) onRetry(err, attempt, waitMs, { reason: "error" });
-      await sleep(waitMs, signal, err);
-      continue;
+    if (onReconnect) {
+      onReconnect({
+        reason: failure.reason,
+        error: failure.error,
+        status: failure.status,
+        attempt: Math.max(failures, 1),
+        delayMs,
+        lastEventId: lastId,
+      });
     }
+    await abortableSleep(delayMs, signal);
+  }
+}
 
-    if (attempt >= retries || !wantsResultRetry(result, attempt)) return result;
+module.exports = { streamSSE };
 
-    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;
+},
+"testing/createMockFetch": function (module, exports, require) {
+const { abortableSleep } = require("../internal/sleep");
 
-    await discardBody(result);
-    if (onRetry) onRetry(undefined, attempt, waitMs, { reason: "result", result, status: result && result.status });
-    await sleep(waitMs, signal);
+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);
 }
 
-module.exports = { withRetry, RetryAbortedError, StopRetry };
+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 });
+}
 
-},
-"./withTimeout": function (module, exports, require) {
-class TimeoutError extends Error {
-  constructor(ms) {
-    super(`Timed out after ${ms}ms`);
-    this.name = "TimeoutError";
-    this.code = "ETIMEDOUT";
+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;
 }
 
 /**
- * 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)`.
+ * A scriptable, fetch-compatible test double — for testing code that uses
+ * retries, timeouts, rate limits and so on without a network.
  *
- * 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).
+ * ```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());
  *
- * @param {(signal: AbortSignal) => Promise<any>} fn
- * @param {number} ms
- * @param {object} [opts]
- * @param {AbortSignal} [opts.signal] - external cancellation
+ * 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.
  */
-async function withTimeout(fn, ms, opts = {}) {
-  const { signal } = opts;
+function createMockFetch() {
+  let routes = [];
+  const calls = [];
 
-  if (typeof ms !== "number" || Number.isNaN(ms) || ms < 0) {
-    throw new TypeError("withTimeout: `ms` must be a non-negative number (or Infinity)");
+  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;
   }
-  signal?.throwIfAborted?.();
 
-  const controller = new AbortController();
-  let timedOut = false;
+  function replyHandler(status, body, opts = {}) {
+    return async (call) => {
+      if (opts.delayMs) await abortableSleep(opts.delayMs, call.signal);
+      return buildResponse(status, body, opts.headers);
+    };
+  }
 
-  const timer =
-    ms === Infinity
-      ? null
-      : setTimeout(() => {
-          timedOut = true;
-          controller.abort(new TimeoutError(ms));
-        }, ms);
+  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);
+    };
+  }
 
-  const onExternalAbort = () => controller.abort(signal.reason);
-  signal?.addEventListener("abort", onExternalAbort, { once: true });
+  function networkError(code = "ECONNREFUSED") {
+    const err = new TypeError("fetch failed");
+    err.cause = Object.assign(new Error(`connect ${code}`), { code });
+    return err;
+  }
 
-  const guard = new Promise((_, reject) => {
-    controller.signal.addEventListener(
-      "abort",
-      () => reject(timedOut ? new TimeoutError(ms) : controller.signal.reason),
-      { once: true }
-    );
-  });
+  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?.();
 
-  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);
+    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 = { withTimeout, TimeoutError };
+module.exports = { createMockFetch };
 
 },
 };
 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);
+// Resolve a relative request the way node would, against the requiring module's id.
+function __resolve(fromId, request) {
+  const parts = fromId.split("/").slice(0, -1);
+  for (const seg of request.replace(/\.js$/, "").split("/")) {
+    if (seg === "..") parts.pop();
+    else if (seg !== "." && seg !== "") parts.push(seg);
+  }
+  const id = parts.join("/");
+  if (id in __defs) return id;
+  if (`${id}/index` in __defs) return `${id}/index`;
+  if (id === "" && "index" in __defs) return "index";
+  throw new Error(`reqkit bundle: cannot resolve ${request} from ${fromId}`);
+}
+function __load(id) {
+  if (__cache[id]) return __cache[id].exports;
+  const module = (__cache[id] = { exports: {} });
+  __defs[id].call(module.exports, module, module.exports, (request) => __load(__resolve(id, request)));
   return module.exports;
 }
-const __reqkit = __require("./index");
+const __reqkit = __load("index");
 export const {
   BodyTooLargeError,
   CircuitOpenError,