@lgriffin/esi.ts 8.0.0 → 9.0.0

package/dist/index.js

@@ -92,6 +92,7 @@ __export(index_exports, {
   fetchAllCursorPages: () => fetchAllCursorPages,
   fetchPages: () => fetchPages,
   getDefaultClient: () => getDefaultClient,
+  isCircuitOpen: () => isCircuitOpen,
   isEsiError: () => isEsiError,
   isForbidden: () => isForbidden,
   isNotFound: () => isNotFound,
@@ -308,6 +309,216 @@ var ApiClient = class {
   }
 };
 
+// src/core/logger/logger.ts
+var import_pino = __toESM(require("pino"));
+var pinoLogger = (0, import_pino.default)({ level: process.env.ESI_LOG_LEVEL || "warn" });
+var logger = {
+  info: (msg) => {
+    pinoLogger.info(msg);
+  },
+  warn: (msg) => {
+    pinoLogger.warn(msg);
+  },
+  error: (msg) => {
+    pinoLogger.error(msg);
+  },
+  debug: (msg) => {
+    pinoLogger.debug(msg);
+  }
+};
+var logger_default = logger;
+
+// src/core/logger/loggerUtil.ts
+var activeLogger = logger_default;
+var setLogger = (customLogger) => {
+  activeLogger = customLogger;
+};
+var logInfo = (message) => {
+  activeLogger.info(message);
+};
+var logError = (message) => {
+  activeLogger.error(message);
+};
+var logWarn = (message) => {
+  activeLogger.warn(message);
+};
+var logDebug = (message) => {
+  activeLogger.debug(message);
+};
+
+// src/core/circuitBreaker/CircuitBreaker.ts
+var CircuitBreaker = class {
+  circuits = /* @__PURE__ */ new Map();
+  failureThreshold;
+  resetTimeoutMs;
+  halfOpenMaxAttempts;
+  staleThresholdMs;
+  keyStrategy;
+  cleanupTimer = null;
+  constructor(config = {}) {
+    this.failureThreshold = config.failureThreshold ?? 5;
+    this.resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
+    this.halfOpenMaxAttempts = config.halfOpenMaxAttempts ?? 1;
+    this.staleThresholdMs = config.staleThresholdMs ?? 36e5;
+    this.keyStrategy = config.keyStrategy ?? "resolved";
+    const cleanupIntervalMs = config.cleanupIntervalMs;
+    if (cleanupIntervalMs !== void 0 && cleanupIntervalMs > 0) {
+      this.startCleanupTimer(cleanupIntervalMs);
+    }
+  }
+  getKey(endpoint) {
+    return endpoint.split("?")[0];
+  }
+  getOrCreate(key) {
+    let record = this.circuits.get(key);
+    if (!record) {
+      record = {
+        state: "closed",
+        failures: 0,
+        lastFailureTime: 0,
+        halfOpenAttempts: 0
+      };
+      this.circuits.set(key, record);
+    }
+    return record;
+  }
+  checkCircuit(endpoint) {
+    const key = this.getKey(endpoint);
+    const record = this.getOrCreate(key);
+    if (record.state === "closed") return;
+    if (record.state === "open") {
+      const elapsed = Date.now() - record.lastFailureTime;
+      if (elapsed >= this.resetTimeoutMs) {
+        record.state = "half-open";
+        record.halfOpenAttempts = 0;
+        logInfo(`Circuit half-open for ${key}, allowing probe request`);
+        return;
+      }
+      const remainingMs = this.resetTimeoutMs - elapsed;
+      throw new CircuitOpenError(key, record.failures, remainingMs);
+    }
+    if (record.state === "half-open") {
+      if (record.halfOpenAttempts >= this.halfOpenMaxAttempts) {
+        throw new CircuitOpenError(key, record.failures, this.resetTimeoutMs);
+      }
+      record.halfOpenAttempts++;
+    }
+  }
+  recordSuccess(endpoint) {
+    const key = this.getKey(endpoint);
+    const record = this.circuits.get(key);
+    if (!record) return;
+    if (record.state === "half-open") {
+      logInfo(`Circuit closed for ${key} after successful probe`);
+    }
+    record.state = "closed";
+    record.failures = 0;
+    record.halfOpenAttempts = 0;
+  }
+  recordFailure(endpoint, statusCode) {
+    if (statusCode !== 0 && statusCode < 500 && statusCode !== 420 && statusCode !== 429) {
+      return;
+    }
+    const key = this.getKey(endpoint);
+    const record = this.getOrCreate(key);
+    record.failures++;
+    record.lastFailureTime = Date.now();
+    if (record.state === "half-open") {
+      record.state = "open";
+      logWarn(
+        `Circuit re-opened for ${key} after failed probe (${record.failures} failures)`
+      );
+      return;
+    }
+    if (record.failures >= this.failureThreshold) {
+      record.state = "open";
+      logWarn(
+        `Circuit opened for ${key} after ${record.failures} consecutive failures`
+      );
+    }
+  }
+  getState(endpoint) {
+    const key = this.getKey(endpoint);
+    const record = this.circuits.get(key);
+    if (!record) return "closed";
+    if (record.state === "open") {
+      const elapsed = Date.now() - record.lastFailureTime;
+      if (elapsed >= this.resetTimeoutMs) {
+        return "half-open";
+      }
+    }
+    return record.state;
+  }
+  getStats() {
+    const circuits = {};
+    let openCircuits = 0;
+    for (const [key, record] of this.circuits.entries()) {
+      const state = this.getState(key);
+      circuits[key] = { state, failures: record.failures };
+      if (state === "open") openCircuits++;
+    }
+    return {
+      totalCircuits: this.circuits.size,
+      openCircuits,
+      circuits
+    };
+  }
+  reset(endpoint) {
+    if (endpoint) {
+      this.circuits.delete(this.getKey(endpoint));
+    } else {
+      this.circuits.clear();
+    }
+  }
+  cleanup() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, record] of this.circuits.entries()) {
+      if (record.state === "closed" && record.failures === 0 && record.lastFailureTime > 0 && now - record.lastFailureTime > this.staleThresholdMs) {
+        this.circuits.delete(key);
+        cleaned++;
+      }
+    }
+    if (cleaned > 0) {
+      logInfo(`Circuit breaker cleanup: removed ${cleaned} stale circuits`);
+    }
+    return cleaned;
+  }
+  getKeyStrategy() {
+    return this.keyStrategy;
+  }
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.circuits.clear();
+  }
+  shutdown() {
+    this.destroy();
+  }
+  startCleanupTimer(intervalMs) {
+    this.cleanupTimer = setInterval(() => {
+      this.cleanup();
+    }, intervalMs);
+    this.cleanupTimer.unref();
+  }
+};
+var CircuitOpenError = class extends Error {
+  endpoint;
+  failures;
+  retryAfterMs;
+  constructor(endpoint, failures, retryAfterMs) {
+    super(
+      `Circuit breaker open for ${endpoint} after ${failures} failures (retry after ${Math.ceil(retryAfterMs / 1e3)}s)`
+    );
+    this.name = "CircuitOpenError";
+    this.endpoint = endpoint;
+    this.failures = failures;
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+
 // src/core/util/error.ts
 var SENSITIVE_PARAMS = [
   "token",
@@ -402,6 +613,9 @@ function isTimeout(error) {
 function isRetryable(error) {
   return error instanceof EsiError && error.retryable;
 }
+function isCircuitOpen(error) {
+  return error instanceof CircuitOpenError;
+}
 var buildError = (message, type = "ERROR", url) => {
   const error = new Error(`[${type}] ${message}`);
   if (url) {
@@ -425,43 +639,6 @@ function isValidationError(error) {
   return error instanceof EsiValidationError;
 }
 
-// src/core/logger/logger.ts
-var import_pino = __toESM(require("pino"));
-var pinoLogger = (0, import_pino.default)({ level: process.env.ESI_LOG_LEVEL || "warn" });
-var logger = {
-  info: (msg) => {
-    pinoLogger.info(msg);
-  },
-  warn: (msg) => {
-    pinoLogger.warn(msg);
-  },
-  error: (msg) => {
-    pinoLogger.error(msg);
-  },
-  debug: (msg) => {
-    pinoLogger.debug(msg);
-  }
-};
-var logger_default = logger;
-
-// src/core/logger/loggerUtil.ts
-var activeLogger = logger_default;
-var setLogger = (customLogger) => {
-  activeLogger = customLogger;
-};
-var logInfo = (message) => {
-  activeLogger.info(message);
-};
-var logError = (message) => {
-  activeLogger.error(message);
-};
-var logWarn = (message) => {
-  activeLogger.warn(message);
-};
-var logDebug = (message) => {
-  activeLogger.debug(message);
-};
-
 // src/core/constants.ts
 var PACKAGE_NAME = "esi.ts";
 var PACKAGE_VERSION = "7.4.0";
@@ -642,238 +819,67 @@ var esiCacheTtls = {
   "GET:universe/system_kills": 3600,
   "GET:wars": 3600,
   "GET:wars/{war_id}": 3600,
-  "GET:wars/{war_id}/killmails": 3600
-};
-
-// src/core/requestPipeline/cachePolicy.ts
-function lookupSpecTtl(method, templatePath) {
-  const normalized = templatePath.replace(/\/$/, "").replace(/\{(\w+)\}/g, (_, name) => `{${camelToSnake(name)}}`);
-  const key = `${method}:${normalized}`;
-  const seconds = esiCacheTtls[key];
-  return typeof seconds === "number" ? seconds * 1e3 : void 0;
-}
-function trySpecAwareCacheHit(client, url, method, templatePath, resolveCache2) {
-  if (method !== "GET" || !templatePath) return null;
-  const specTtlMs = lookupSpecTtl(method, templatePath);
-  if (!specTtlMs) return null;
-  const cache = resolveCache2(client);
-  if (!cache) return null;
-  const entry = cache.get(url);
-  if (!entry) return null;
-  const age = Date.now() - entry.timestamp;
-  if (age < specTtlMs) {
-    logDebug(
-      `Spec-aware cache hit for ${url} (age=${Math.round(age / 1e3)}s, ttl=${Math.round(specTtlMs / 1e3)}s)`
-    );
-    return {
-      headers: entry.headers,
-      body: entry.data,
-      fromCache: true,
-      cacheHitType: "spec-ttl"
-    };
-  }
-  return null;
-}
-function tryStaleCacheResponse(client, url, parsed, resolveCache2) {
-  const cache = resolveCache2(client);
-  if (!cache) return null;
-  const cachedEntry = cache.get(url);
-  if (!cachedEntry) return null;
-  return {
-    headers: { ...cachedEntry.headers, ...parsed.raw },
-    body: cachedEntry.data,
-    fromCache: true,
-    stale: true,
-    cacheHitType: "stale-on-error"
-  };
-}
-function cacheResponse(client, url, method, endpoint, parsed, data, useETag, resolveCache2, templatePath) {
-  const cache = resolveCache2(client);
-  if (useETag && method === "GET" && cache && parsed.etag) {
-    const headerTtl = parseCacheControlTtl(parsed.raw);
-    const specTtlMs = templatePath ? lookupSpecTtl(method, templatePath) : void 0;
-    const ttl = specTtlMs ?? headerTtl;
-    cache.set(url, parsed.etag, data, parsed.raw, ttl);
-    const ttlInfo = ttl ? ` (ttl=${ttl}ms)` : "";
-    logDebug(`Cached response for ${url} with ETag ${parsed.etag}${ttlInfo}`);
-  }
-  if (method !== "GET" && cache) {
-    cache.deleteByPath(endpoint.split("?")[0]);
-  }
-}
-
-// src/core/circuitBreaker/CircuitBreaker.ts
-var CircuitBreaker = class {
-  circuits = /* @__PURE__ */ new Map();
-  failureThreshold;
-  resetTimeoutMs;
-  halfOpenMaxAttempts;
-  staleThresholdMs;
-  keyStrategy;
-  cleanupTimer = null;
-  constructor(config = {}) {
-    this.failureThreshold = config.failureThreshold ?? 5;
-    this.resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
-    this.halfOpenMaxAttempts = config.halfOpenMaxAttempts ?? 1;
-    this.staleThresholdMs = config.staleThresholdMs ?? 36e5;
-    this.keyStrategy = config.keyStrategy ?? "resolved";
-    const cleanupIntervalMs = config.cleanupIntervalMs;
-    if (cleanupIntervalMs !== void 0 && cleanupIntervalMs > 0) {
-      this.startCleanupTimer(cleanupIntervalMs);
-    }
-  }
-  getKey(endpoint) {
-    return endpoint.split("?")[0];
-  }
-  getOrCreate(key) {
-    let record = this.circuits.get(key);
-    if (!record) {
-      record = {
-        state: "closed",
-        failures: 0,
-        lastFailureTime: 0,
-        halfOpenAttempts: 0
-      };
-      this.circuits.set(key, record);
-    }
-    return record;
-  }
-  checkCircuit(endpoint) {
-    const key = this.getKey(endpoint);
-    const record = this.getOrCreate(key);
-    if (record.state === "closed") return;
-    if (record.state === "open") {
-      const elapsed = Date.now() - record.lastFailureTime;
-      if (elapsed >= this.resetTimeoutMs) {
-        record.state = "half-open";
-        record.halfOpenAttempts = 0;
-        logInfo(`Circuit half-open for ${key}, allowing probe request`);
-        return;
-      }
-      const remainingMs = this.resetTimeoutMs - elapsed;
-      throw new CircuitOpenError(key, record.failures, remainingMs);
-    }
-    if (record.state === "half-open") {
-      if (record.halfOpenAttempts >= this.halfOpenMaxAttempts) {
-        throw new CircuitOpenError(key, record.failures, this.resetTimeoutMs);
-      }
-      record.halfOpenAttempts++;
-    }
-  }
-  recordSuccess(endpoint) {
-    const key = this.getKey(endpoint);
-    const record = this.circuits.get(key);
-    if (!record) return;
-    if (record.state === "half-open") {
-      logInfo(`Circuit closed for ${key} after successful probe`);
-    }
-    record.state = "closed";
-    record.failures = 0;
-    record.halfOpenAttempts = 0;
-  }
-  recordFailure(endpoint, statusCode) {
-    if (statusCode !== 0 && statusCode < 500 && statusCode !== 420 && statusCode !== 429) {
-      return;
-    }
-    const key = this.getKey(endpoint);
-    const record = this.getOrCreate(key);
-    record.failures++;
-    record.lastFailureTime = Date.now();
-    if (record.state === "half-open") {
-      record.state = "open";
-      logWarn(
-        `Circuit re-opened for ${key} after failed probe (${record.failures} failures)`
-      );
-      return;
-    }
-    if (record.failures >= this.failureThreshold) {
-      record.state = "open";
-      logWarn(
-        `Circuit opened for ${key} after ${record.failures} consecutive failures`
-      );
-    }
-  }
-  getState(endpoint) {
-    const key = this.getKey(endpoint);
-    const record = this.circuits.get(key);
-    if (!record) return "closed";
-    if (record.state === "open") {
-      const elapsed = Date.now() - record.lastFailureTime;
-      if (elapsed >= this.resetTimeoutMs) {
-        return "half-open";
-      }
-    }
-    return record.state;
-  }
-  getStats() {
-    const circuits = {};
-    let openCircuits = 0;
-    for (const [key, record] of this.circuits.entries()) {
-      const state = this.getState(key);
-      circuits[key] = { state, failures: record.failures };
-      if (state === "open") openCircuits++;
-    }
-    return {
-      totalCircuits: this.circuits.size,
-      openCircuits,
-      circuits
-    };
-  }
-  reset(endpoint) {
-    if (endpoint) {
-      this.circuits.delete(this.getKey(endpoint));
-    } else {
-      this.circuits.clear();
-    }
-  }
-  cleanup() {
-    const now = Date.now();
-    let cleaned = 0;
-    for (const [key, record] of this.circuits.entries()) {
-      if (record.state === "closed" && record.failures === 0 && record.lastFailureTime > 0 && now - record.lastFailureTime > this.staleThresholdMs) {
-        this.circuits.delete(key);
-        cleaned++;
-      }
-    }
-    if (cleaned > 0) {
-      logInfo(`Circuit breaker cleanup: removed ${cleaned} stale circuits`);
-    }
-    return cleaned;
-  }
-  getKeyStrategy() {
-    return this.keyStrategy;
-  }
-  destroy() {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-    this.circuits.clear();
-  }
-  shutdown() {
-    this.destroy();
-  }
-  startCleanupTimer(intervalMs) {
-    this.cleanupTimer = setInterval(() => {
-      this.cleanup();
-    }, intervalMs);
-    this.cleanupTimer.unref();
-  }
+  "GET:wars/{war_id}/killmails": 3600
 };
-var CircuitOpenError = class extends Error {
-  endpoint;
-  failures;
-  retryAfterMs;
-  constructor(endpoint, failures, retryAfterMs) {
-    super(
-      `Circuit breaker open for ${endpoint} after ${failures} failures (retry after ${Math.ceil(retryAfterMs / 1e3)}s)`
+
+// src/core/requestPipeline/cachePolicy.ts
+function lookupSpecTtl(method, templatePath) {
+  const normalized = templatePath.replace(/\/$/, "").replace(/\{(\w+)\}/g, (_, name) => `{${camelToSnake(name)}}`);
+  const key = `${method}:${normalized}`;
+  const seconds = esiCacheTtls[key];
+  return typeof seconds === "number" ? seconds * 1e3 : void 0;
+}
+function trySpecAwareCacheHit(client, url, method, templatePath, resolveCache2) {
+  if (method !== "GET" || !templatePath) return null;
+  const specTtlMs = lookupSpecTtl(method, templatePath);
+  if (!specTtlMs) return null;
+  const cache = resolveCache2(client);
+  if (!cache) return null;
+  const entry = cache.get(url);
+  if (!entry) return null;
+  const age = Date.now() - entry.timestamp;
+  if (age < specTtlMs) {
+    logDebug(
+      `Spec-aware cache hit for ${url} (age=${Math.round(age / 1e3)}s, ttl=${Math.round(specTtlMs / 1e3)}s)`
     );
-    this.name = "CircuitOpenError";
-    this.endpoint = endpoint;
-    this.failures = failures;
-    this.retryAfterMs = retryAfterMs;
+    return {
+      headers: entry.headers,
+      body: entry.data,
+      status: 200,
+      fromCache: true,
+      cacheHitType: "spec-ttl"
+    };
   }
-};
+  return null;
+}
+function tryStaleCacheResponse(client, url, parsed, resolveCache2) {
+  const cache = resolveCache2(client);
+  if (!cache) return null;
+  const cachedEntry = cache.get(url);
+  if (!cachedEntry) return null;
+  return {
+    headers: { ...cachedEntry.headers, ...parsed.raw },
+    body: cachedEntry.data,
+    status: 200,
+    fromCache: true,
+    stale: true,
+    cacheHitType: "stale-on-error"
+  };
+}
+function cacheResponse(client, url, method, endpoint, parsed, data, useETag, resolveCache2, templatePath) {
+  const cache = resolveCache2(client);
+  if (useETag && method === "GET" && cache && parsed.etag) {
+    const headerTtl = parseCacheControlTtl(parsed.raw);
+    const specTtlMs = templatePath ? lookupSpecTtl(method, templatePath) : void 0;
+    const ttl = specTtlMs ?? headerTtl;
+    cache.set(url, parsed.etag, data, parsed.raw, ttl);
+    const ttlInfo = ttl ? ` (ttl=${ttl}ms)` : "";
+    logDebug(`Cached response for ${url} with ETag ${parsed.etag}${ttlInfo}`);
+  }
+  if (method !== "GET" && cache) {
+    cache.deleteByPath(endpoint.split("?")[0]);
+  }
+}
 
 // src/core/requestPipeline/statusHandling.ts
 var STATUS_MESSAGES = {
@@ -894,11 +900,11 @@ var STATUS_MESSAGES = {
 };
 function handleEarlyStatus(client, status, url, parsed, useETag, resolveCache2) {
   if (status === 201) {
-    return { headers: parsed.raw, body: void 0 };
+    return { headers: parsed.raw, body: void 0, status: 201 };
   }
   if (status === 204) {
     logInfo(`No Content for endpoint: ${url}`);
-    return { headers: parsed.raw, body: void 0 };
+    return { headers: parsed.raw, body: void 0, status: 204 };
   }
   if (status === 304) {
     const cache = resolveCache2(client);
@@ -909,6 +915,7 @@ function handleEarlyStatus(client, status, url, parsed, useETag, resolveCache2)
         return {
           headers: { ...cachedEntry.headers, ...parsed.raw },
           body: cachedEntry.data,
+          status: 304,
           fromCache: true,
           cacheHitType: "etag-304"
         };
@@ -934,7 +941,7 @@ function handleErrorResponse(client, response, url, parsed, useETag, resolveCach
     );
     if (staleResult) {
       logWarn(`${errorMessage} for ${url} \u2014 serving stale cache`);
-      return staleResult;
+      return { ...staleResult, status: response.status };
     }
   }
   if (response.status === 420 || response.status === 429) {
@@ -959,18 +966,102 @@ function wrapError(error) {
   throw buildError(String(error), "ESIJS_ERROR");
 }
 
+// src/core/util/retry.ts
+function retryDelay(attempt, baseMs, maxMs) {
+  const exponential = baseMs * Math.pow(2, attempt);
+  const jitter = exponential * (0.75 + Math.random() * 0.5);
+  return Math.min(jitter, maxMs);
+}
+
 // src/core/util/sleep.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/core/RetryStrategy.ts
+var RetryStrategy = class {
+  maxRetries;
+  baseDelayMs;
+  maxDelayMs;
+  retryMutations;
+  constructor(config) {
+    this.maxRetries = config?.maxRetries ?? 0;
+    this.baseDelayMs = config?.baseDelayMs ?? 1e3;
+    this.maxDelayMs = config?.maxDelayMs ?? 3e4;
+    this.retryMutations = config?.retryMutations ?? false;
+  }
+  async execute(operation, context) {
+    const canRetryMethod = context.method === "GET" || this.retryMutations;
+    let lastError;
+    let refreshAttempted = false;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (error instanceof CircuitOpenError) {
+          throw error;
+        }
+        if (!refreshAttempted && error instanceof EsiError && error.statusCode === 401 && context.requiresAuth && context.refreshToken) {
+          refreshAttempted = true;
+          logInfo("Received 401, attempting token refresh...");
+          try {
+            await context.refreshToken();
+          } catch (refreshError) {
+            if (refreshError instanceof EsiError || refreshError instanceof CircuitOpenError) {
+              throw refreshError;
+            }
+            const msg = refreshError instanceof Error ? refreshError.message : String(refreshError);
+            logError(`Token refresh failed: ${msg}`);
+            throw buildError(
+              `Token refresh failed: ${msg}`,
+              "TOKEN_REFRESH_FAILED"
+            );
+          }
+          logInfo("Token refreshed, retrying request");
+          attempt--;
+          continue;
+        }
+        if (error instanceof EsiError && error.retryable && canRetryMethod && attempt < this.maxRetries) {
+          const delay = retryDelay(attempt, this.baseDelayMs, this.maxDelayMs);
+          logWarn(
+            `Request to ${context.endpoint} failed (${error.statusCode}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${this.maxRetries})`
+          );
+          await sleep(delay);
+          lastError = error;
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError;
+  }
+};
+
+// src/core/requestPipeline/dependencies.ts
+function resolveCache(client) {
+  return client.getCache();
+}
+function resolveRateLimiter(client) {
+  const limiter = client.getRateLimiter();
+  if (!limiter) {
+    throw buildError(
+      "No rate limiter configured on ApiClient. Set one via apiClient.setRateLimiter(new RateLimiter()).",
+      "CONFIGURATION_ERROR"
+    );
+  }
+  return limiter;
+}
+function resolveCircuitBreaker(client) {
+  return client.getCircuitBreaker();
+}
+function resolveRetryStrategy(client) {
+  return client.getRetryStrategy() ?? new RetryStrategy(client.getRetryConfig() ?? void 0);
+}
+
 // src/core/pagination/PaginationHandler.ts
 var PaginationHandler = class {
   static DEFAULT_OPTIONS = {
     maxPages: 1e3,
-    // Reasonable limit to prevent infinite loops
-    maxRetries: 3,
-    retryDelayMs: 1e3,
     stopOnEmptyPage: true
   };
   /**
@@ -990,9 +1081,11 @@ var PaginationHandler = class {
       try {
         if (rateLimiter) await rateLimiter.checkRateLimit(templatePath, method);
         const pageData = await this.fetchPageWithRetry(
+          client,
           endpoint,
+          method,
+          requiresAuth,
           page,
-          opts,
           pageFetch
         );
         if (opts.stopOnEmptyPage && (!pageData || pageData.length === 0)) {
@@ -1016,36 +1109,35 @@ var PaginationHandler = class {
     return allData;
   }
   /**
-   * Fetch a single page with retry logic
+   * Fetch a single page with retry logic.
+   *
+   * Delegates to the configured `IRetryStrategy` (exponential backoff
+   * with jitter) instead of implementing a custom retry loop.
    */
-  static async fetchPageWithRetry(endpoint, page, options, pageFetch) {
-    let lastError = null;
-    for (let attempt = 1; attempt <= options.maxRetries; attempt++) {
-      try {
-        return await this.fetchSinglePage(endpoint, page, pageFetch);
-      } catch (error) {
-        lastError = error;
-        logWarn(
-          `Attempt ${attempt}/${options.maxRetries} failed for page ${page}: ${error instanceof Error ? error.message : String(error)}`
-        );
-        if (attempt < options.maxRetries) {
-          await sleep(options.retryDelayMs * attempt);
-        }
+  static async fetchPageWithRetry(client, endpoint, method, requiresAuth, page, pageFetch) {
+    const retryStrategy = resolveRetryStrategy(client);
+    const paginatedEndpoint = this.buildPaginatedEndpoint(endpoint, page);
+    return retryStrategy.execute(
+      () => {
+        logInfo(`Fetching page ${page} via pipeline: ${paginatedEndpoint}`);
+        return pageFetch(paginatedEndpoint);
+      },
+      {
+        endpoint: paginatedEndpoint,
+        method,
+        requiresAuth,
+        refreshToken: client.hasTokenProvider() ? () => client.refreshToken().then(() => {
+        }) : void 0
       }
-    }
-    throw lastError || new Error(
-      `Failed to fetch page ${page} after ${options.maxRetries} attempts`
     );
   }
   /**
-   * Fetch a single page.
+   * Build a paginated endpoint path.
    * Preserves any existing query params on the endpoint and appends page=N.
    */
-  static async fetchSinglePage(endpoint, page, pageFetch) {
+  static buildPaginatedEndpoint(endpoint, page) {
     const separator = endpoint.includes("?") ? "&" : "?";
-    const paginatedEndpoint = `${endpoint}${separator}page=${page}`;
-    logInfo(`Fetching page ${page} via pipeline: ${paginatedEndpoint}`);
-    return pageFetch(paginatedEndpoint);
+    return `${endpoint}${separator}page=${page}`;
   }
 };
 
@@ -1056,12 +1148,12 @@ function handleCursorPagination(parsed, data) {
     before: parsed.cursorBefore,
     after: parsed.cursorAfter
   };
-  return { headers: parsed.raw, body: data, cursors };
+  return { headers: parsed.raw, body: data, status: 200, cursors };
 }
 async function handleOffsetPagination(client, endpoint, method, requiresAuth, parsed, data, body, url, useETag, pageFetch, resolveCache2, templatePath) {
   const totalPages = parsed.xPages;
   if (totalPages <= 1) {
-    return { headers: parsed.raw, body: data };
+    return { headers: parsed.raw, body: data, status: 200 };
   }
   logInfo(
     `Found ${totalPages} pages, fetching additional pages with rate limiting...`
@@ -1078,8 +1170,7 @@ async function handleOffsetPagination(client, endpoint, method, requiresAuth, pa
       body,
       {
         maxPages: Math.min(totalPages, 1e3),
-        stopOnEmptyPage: true,
-        maxRetries: 3
+        stopOnEmptyPage: true
       },
       pageFetch,
       templatePath
@@ -1095,7 +1186,7 @@ async function handleOffsetPagination(client, endpoint, method, requiresAuth, pa
       resolveCache2,
       templatePath
     );
-    return { headers: parsed.raw, body: allData };
+    return { headers: parsed.raw, body: allData, status: 200 };
   } catch (paginationError) {
     const msg = paginationError instanceof Error ? paginationError.message : String(paginationError);
     logWarn(`Pagination failed for ${url}: ${msg}`);
@@ -1137,7 +1228,7 @@ async function applyResponseInterceptors(client, result, url, endpoint, method,
     url,
     endpoint,
     method,
-    status: 200,
+    status: result.status ?? 200,
     headers: result.headers,
     body: result.body,
     durationMs: Date.now() - startTime,
@@ -1299,93 +1390,6 @@ async function fetchOnePage(client, endpoint, method, body, requiresAuth, useETa
   return { data, parsed, url };
 }
 
-// src/core/util/retry.ts
-function retryDelay(attempt, baseMs, maxMs) {
-  const exponential = baseMs * Math.pow(2, attempt);
-  const jitter = exponential * (0.75 + Math.random() * 0.5);
-  return Math.min(jitter, maxMs);
-}
-
-// src/core/RetryStrategy.ts
-var RetryStrategy = class {
-  maxRetries;
-  baseDelayMs;
-  maxDelayMs;
-  retryMutations;
-  constructor(config) {
-    this.maxRetries = config?.maxRetries ?? 0;
-    this.baseDelayMs = config?.baseDelayMs ?? 1e3;
-    this.maxDelayMs = config?.maxDelayMs ?? 3e4;
-    this.retryMutations = config?.retryMutations ?? false;
-  }
-  async execute(operation, context) {
-    const canRetryMethod = context.method === "GET" || this.retryMutations;
-    let lastError;
-    let refreshAttempted = false;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      try {
-        return await operation();
-      } catch (error) {
-        if (error instanceof CircuitOpenError) {
-          throw error;
-        }
-        if (!refreshAttempted && error instanceof EsiError && error.statusCode === 401 && context.requiresAuth && context.refreshToken) {
-          refreshAttempted = true;
-          logInfo("Received 401, attempting token refresh...");
-          try {
-            await context.refreshToken();
-          } catch (refreshError) {
-            if (refreshError instanceof EsiError || refreshError instanceof CircuitOpenError) {
-              throw refreshError;
-            }
-            const msg = refreshError instanceof Error ? refreshError.message : String(refreshError);
-            logError(`Token refresh failed: ${msg}`);
-            throw buildError(
-              `Token refresh failed: ${msg}`,
-              "TOKEN_REFRESH_FAILED"
-            );
-          }
-          logInfo("Token refreshed, retrying request");
-          attempt--;
-          continue;
-        }
-        if (error instanceof EsiError && error.retryable && canRetryMethod && attempt < this.maxRetries) {
-          const delay = retryDelay(attempt, this.baseDelayMs, this.maxDelayMs);
-          logWarn(
-            `Request to ${context.endpoint} failed (${error.statusCode}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${this.maxRetries})`
-          );
-          await sleep(delay);
-          lastError = error;
-          continue;
-        }
-        throw error;
-      }
-    }
-    throw lastError;
-  }
-};
-
-// src/core/requestPipeline/dependencies.ts
-function resolveCache(client) {
-  return client.getCache();
-}
-function resolveRateLimiter(client) {
-  const limiter = client.getRateLimiter();
-  if (!limiter) {
-    throw buildError(
-      "No rate limiter configured on ApiClient. Set one via apiClient.setRateLimiter(new RateLimiter()).",
-      "CONFIGURATION_ERROR"
-    );
-  }
-  return limiter;
-}
-function resolveCircuitBreaker(client) {
-  return client.getCircuitBreaker();
-}
-function resolveRetryStrategy(client) {
-  return client.getRetryStrategy() ?? new RetryStrategy(client.getRetryConfig() ?? void 0);
-}
-
 // src/core/ApiRequestHandler.ts
 var executeRequest = async (client, endpoint, method, body, requiresAuth = false, useETag = true, requestTimeout, templatePath) => {
   const startTime = Date.now();
@@ -1422,7 +1426,7 @@ var executeRequest = async (client, endpoint, method, body, requiresAuth = false
       } catch {
         data2 = void 0;
       }
-      return finish({ headers: parsed.raw, body: data2 });
+      return finish({ headers: parsed.raw, body: data2, status: 201 });
     }
     const earlyResult = handleEarlyStatus(
       client,
@@ -8988,6 +8992,12 @@ function configureApiClient(client, config) {
     client.setRetryConfig(config.retryConfig);
   } else if (config?.retryAttempts !== void 0) {
     client.setRetryConfig({ maxRetries: config.retryAttempts });
+  } else {
+    client.setRetryConfig({
+      maxRetries: 3,
+      baseDelayMs: 1e3,
+      maxDelayMs: 3e4
+    });
   }
   if (config?.retryStrategy) {
     client.setRetryStrategy(config.retryStrategy);
@@ -9912,6 +9922,7 @@ __export(schemas_exports, {
   fetchAllCursorPages,
   fetchPages,
   getDefaultClient,
+  isCircuitOpen,
   isEsiError,
   isForbidden,
   isNotFound,