@lgriffin/esi.ts 10.2.0 → 11.0.0

package/dist/chunk-KIY3XA5Q.mjs

@@ -0,0 +1,2980 @@
+import {
+  CircuitOpenError,
+  EsiConfigurationError,
+  EsiError,
+  EsiNetworkError,
+  EsiPaginationError,
+  EsiParseError,
+  EsiTokenRefreshError,
+  EsiValidationError,
+  SENSITIVE_QUERY_PATTERN,
+  TimeoutError,
+  isSensitiveQueryParam,
+  toEsiError
+} from "./chunk-JNFQXEWZ.mjs";
+
+// src/core/middleware/Middleware.ts
+var MiddlewareManager = class {
+  requestInterceptors = [];
+  responseInterceptors = [];
+  addRequestInterceptor(fn) {
+    this.requestInterceptors.push(fn);
+    return () => {
+      this.requestInterceptors = this.requestInterceptors.filter(
+        (i) => i !== fn
+      );
+    };
+  }
+  addResponseInterceptor(fn) {
+    this.responseInterceptors.push(fn);
+    return () => {
+      this.responseInterceptors = this.responseInterceptors.filter(
+        (i) => i !== fn
+      );
+    };
+  }
+  async applyRequestInterceptors(context) {
+    let ctx = context;
+    for (const interceptor of this.requestInterceptors) {
+      ctx = await interceptor(ctx);
+    }
+    return ctx;
+  }
+  async applyResponseInterceptors(context) {
+    let ctx = context;
+    for (const interceptor of this.responseInterceptors) {
+      ctx = await interceptor(ctx);
+    }
+    return ctx;
+  }
+  hasInterceptors() {
+    return this.requestInterceptors.length > 0 || this.responseInterceptors.length > 0;
+  }
+  clear() {
+    this.requestInterceptors = [];
+    this.responseInterceptors = [];
+  }
+};
+
+// src/core/util/validation.ts
+var UNSAFE_PATH_CHARS = /[/\\?#@!$&'()*+,;=<>{}|^`]/;
+function validatePathParam(paramName, value) {
+  const str = value === null || value === void 0 ? "" : `${value}`;
+  if (str === "") {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Path parameter '${paramName}' must not be empty`
+    );
+  }
+  if (UNSAFE_PATH_CHARS.test(str)) {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Path parameter '${paramName}' contains invalid characters`
+    );
+  }
+  if (str === "." || str === "..") {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Path parameter '${paramName}' must not be a dot segment`
+    );
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Path parameter '${paramName}' must be a finite number`
+    );
+  }
+  return str;
+}
+var ALLOWED_ESI_HOSTS = ["esi.evetech.net"];
+function validateBaseUrl(url, allowCustomHost) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Invalid base URL: ${url}`
+    );
+  }
+  if (parsed.protocol !== "https:") {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      "Base URL must use HTTPS protocol"
+    );
+  }
+  if (!allowCustomHost && !ALLOWED_ESI_HOSTS.includes(parsed.hostname)) {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Base URL host '${parsed.hostname}' is not in the allowlist. Allowed hosts: ${ALLOWED_ESI_HOSTS.join(", ")}. Set unsafeAllowCustomHost to bypass this check.`
+    );
+  }
+  return url.replace(/\/$/, "");
+}
+function validateQueryParam(paramName, value) {
+  if (value === null || value === void 0) {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Query parameter '${paramName}' must not be null or undefined`
+    );
+  }
+  const str = `${value}`;
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Query parameter '${paramName}' must be a finite number`
+    );
+  }
+  if (str.length > 2e3) {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `Query parameter '${paramName}' exceeds maximum length`
+    );
+  }
+  return str;
+}
+var HEADER_VALUE = /^[\t\x20-\x7e]+$/;
+function validateHeaderOption(option, value) {
+  if (!HEADER_VALUE.test(value)) {
+    throw new EsiConfigurationError(
+      "VALIDATION_ERROR",
+      `${option} must be printable ASCII with no line breaks or control characters`
+    );
+  }
+  return value;
+}
+
+// src/core/ApiClient.ts
+var ApiClient = class {
+  constructor(clientId, link, accessToken) {
+    this.clientId = clientId;
+    this.link = link;
+    this.accessToken = accessToken;
+    this.link = this.link.replace(/\/$/, "");
+  }
+  clientId;
+  link;
+  accessToken;
+  datasource;
+  tokenProvider;
+  refreshInFlight;
+  middleware = new MiddlewareManager();
+  cache = null;
+  rateLimiter = null;
+  circuitBreaker = null;
+  timeout = 3e4;
+  deduplicator = null;
+  retryConfig = null;
+  retryStrategy = null;
+  validateResponse = true;
+  validateRequest = false;
+  language;
+  tenant;
+  userAgent;
+  compatibilityDate;
+  fetchFn = null;
+  logger = null;
+  getTimeout() {
+    return this.timeout;
+  }
+  setTimeout(timeout) {
+    this.timeout = timeout;
+  }
+  getCache() {
+    return this.cache;
+  }
+  setCache(cache) {
+    this.cache = cache;
+  }
+  getRateLimiter() {
+    return this.rateLimiter;
+  }
+  setRateLimiter(limiter) {
+    this.rateLimiter = limiter;
+  }
+  getCircuitBreaker() {
+    return this.circuitBreaker;
+  }
+  setCircuitBreaker(cb) {
+    this.circuitBreaker = cb;
+  }
+  getDeduplicator() {
+    return this.deduplicator;
+  }
+  setDeduplicator(dedup) {
+    this.deduplicator = dedup;
+  }
+  getRetryConfig() {
+    return this.retryConfig;
+  }
+  setRetryConfig(config) {
+    this.retryConfig = config;
+  }
+  getRetryStrategy() {
+    return this.retryStrategy;
+  }
+  setRetryStrategy(strategy) {
+    this.retryStrategy = strategy;
+  }
+  getValidateResponse() {
+    return this.validateResponse;
+  }
+  setValidateResponse(validate) {
+    this.validateResponse = validate;
+  }
+  getValidateRequest() {
+    return this.validateRequest;
+  }
+  setValidateRequest(validate) {
+    this.validateRequest = validate;
+  }
+  getFetch() {
+    return this.fetchFn ?? globalThis.fetch;
+  }
+  setFetch(fn) {
+    this.fetchFn = fn;
+  }
+  getMiddleware() {
+    return this.middleware;
+  }
+  addRequestInterceptor(fn) {
+    return this.middleware.addRequestInterceptor(fn);
+  }
+  addResponseInterceptor(fn) {
+    return this.middleware.addResponseInterceptor(fn);
+  }
+  getAuthorizationHeader() {
+    return this.accessToken ? `Bearer ${this.accessToken}` : void 0;
+  }
+  getLink() {
+    return this.link;
+  }
+  getClientId() {
+    return this.clientId;
+  }
+  getDatasource() {
+    return this.datasource;
+  }
+  setDatasource(datasource) {
+    this.datasource = datasource;
+  }
+  getLanguage() {
+    return this.language;
+  }
+  setLanguage(language) {
+    this.language = language;
+  }
+  /** The `X-Tenant` every request names, or undefined for ESI's default. */
+  getTenant() {
+    return this.tenant;
+  }
+  /** @throws VALIDATION_ERROR when the value is not printable ASCII. */
+  setTenant(tenant) {
+    this.tenant = tenant === void 0 ? void 0 : validateHeaderOption("tenant", tenant);
+  }
+  /** The application's own user agent, sent ahead of the library's. */
+  getUserAgent() {
+    return this.userAgent;
+  }
+  /** @throws VALIDATION_ERROR when the value is not printable ASCII. */
+  setUserAgent(userAgent) {
+    this.userAgent = userAgent === void 0 ? void 0 : validateHeaderOption("userAgent", userAgent);
+  }
+  getCompatibilityDate() {
+    return this.compatibilityDate;
+  }
+  setCompatibilityDate(date) {
+    this.compatibilityDate = date;
+  }
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  setTokenProvider(provider) {
+    this.tokenProvider = provider;
+  }
+  getLogger() {
+    return this.logger;
+  }
+  setLogger(logger) {
+    this.logger = logger;
+  }
+  hasTokenProvider() {
+    return this.tokenProvider !== void 0;
+  }
+  toJSON() {
+    return {
+      link: this.link,
+      datasource: this.datasource,
+      timeout: this.timeout,
+      hasCache: this.cache !== null,
+      hasRateLimiter: this.rateLimiter !== null,
+      hasCircuitBreaker: this.circuitBreaker !== null,
+      hasDeduplicator: this.deduplicator !== null,
+      hasTokenProvider: this.tokenProvider !== void 0,
+      validateResponse: this.validateResponse,
+      validateRequest: this.validateRequest,
+      language: this.language,
+      compatibilityDate: this.compatibilityDate
+    };
+  }
+  async refreshToken() {
+    if (!this.tokenProvider) {
+      throw new Error("No token provider configured");
+    }
+    if (this.refreshInFlight) {
+      return this.refreshInFlight;
+    }
+    this.refreshInFlight = this.tokenProvider().then(
+      (token) => {
+        this.accessToken = token;
+        this.refreshInFlight = void 0;
+        return token;
+      },
+      (err) => {
+        this.refreshInFlight = void 0;
+        throw err;
+      }
+    );
+    return this.refreshInFlight;
+  }
+};
+
+// src/core/logger/DefaultLogger.ts
+import pino from "pino";
+function createDefaultLogger(level) {
+  return buildDefaultLogger(level);
+}
+function buildDefaultLogger(level) {
+  const resolved = level || process.env.ESI_LOG_LEVEL || "warn";
+  return adaptPino(pino({ level: resolved }));
+}
+function toPinoLogger(p) {
+  return adaptPino(p);
+}
+function adaptPino(p) {
+  const emit3 = (level) => (message, context) => context ? p[level](context, message) : p[level](message);
+  const logger = {
+    fatal: emit3("fatal"),
+    error: emit3("error"),
+    warn: emit3("warn"),
+    info: emit3("info"),
+    debug: emit3("debug"),
+    trace: emit3("trace")
+  };
+  const values = p.levels?.values;
+  if (values && typeof p.levelVal === "number") {
+    logger.isLevelEnabled = (level) => (values[level] ?? Infinity) >= (p.levelVal ?? -Infinity);
+  } else if (typeof p.isLevelEnabled === "function") {
+    logger.isLevelEnabled = (level) => p.isLevelEnabled?.(level) ?? true;
+  }
+  return logger;
+}
+var LEVELS = [
+  "fatal",
+  "error",
+  "warn",
+  "info",
+  "debug",
+  "trace"
+];
+function createLazyDefaultLogger() {
+  const lazy = {};
+  let built;
+  const materialise = () => {
+    if (built) return built;
+    const real = buildDefaultLogger();
+    built = real;
+    for (const level of LEVELS) lazy[level] = real[level];
+    lazy.isLevelEnabled = real.isLevelEnabled ?? (() => true);
+    return real;
+  };
+  for (const level of LEVELS) {
+    lazy[level] = (message, context) => materialise()[level](message, context);
+  }
+  lazy.isLevelEnabled = (level) => materialise().isLevelEnabled?.(level) ?? true;
+  return lazy;
+}
+var defaultLogger = createLazyDefaultLogger();
+
+// src/core/logger/redactLog.ts
+var QUERY_PAIR = /([?&])([^=&#?\s]+)=([^&#\s,;"'`<>()[\]{}]*)/g;
+var REDACTED = "%5BREDACTED%5D";
+function redactLogText(text) {
+  if (!text.includes("?") || !SENSITIVE_QUERY_PATTERN.test(text)) return text;
+  return text.replace(
+    QUERY_PAIR,
+    (pair, separator, name, value) => value !== "" && isSensitiveQueryParam(name) ? `${separator}${name}=${REDACTED}` : pair
+  );
+}
+function redactLogContext(context) {
+  if (!context) return void 0;
+  const keys = Object.keys(context);
+  if (keys.length === 0) return void 0;
+  for (const key of keys) {
+    if (mayCarrySecret(context[key])) return redactValues(context, keys);
+  }
+  return context;
+}
+function mayCarrySecret(value) {
+  return typeof value === "string" && value.includes("?") && SENSITIVE_QUERY_PATTERN.test(value);
+}
+function redactValues(context, keys) {
+  const redacted = {};
+  for (const key of keys) {
+    const value = context[key];
+    redacted[key] = mayCarrySecret(value) ? redactLogText(value) : value;
+  }
+  return redacted;
+}
+function redactingLogger(logger) {
+  const at = (level) => (message, context) => {
+    if (logger.isLevelEnabled?.(level) === false) return;
+    const safe = redactLogContext(context);
+    if (safe === void 0) logger[level](redactLogText(message));
+    else logger[level](redactLogText(message), safe);
+  };
+  return {
+    fatal: at("fatal"),
+    error: at("error"),
+    warn: at("warn"),
+    info: at("info"),
+    debug: at("debug"),
+    trace: at("trace")
+  };
+}
+
+// src/core/logger/loggerUtil.ts
+var activeLogger = defaultLogger;
+var setLogger = (customLogger) => {
+  activeLogger = customLogger;
+};
+var getLogger = () => activeLogger;
+var emit = (level) => (message, context) => {
+  if (activeLogger.isLevelEnabled?.(level) === false) return;
+  activeLogger[level](redactLogText(message), redactLogContext(context));
+};
+var logFatal = emit("fatal");
+var logError = emit("error");
+var logWarn = emit("warn");
+var logInfo = emit("info");
+var logDebug = emit("debug");
+var logTrace = emit("trace");
+
+// src/core/logger/resolveLogger.ts
+function resolveLogger(client) {
+  return client?.getLogger?.() ?? getLogger();
+}
+
+// src/core/logger/clientLog.ts
+var emit2 = (level) => (client, message, context) => {
+  const logger = resolveLogger(client);
+  if (logger.isLevelEnabled?.(level) === false) return;
+  logger[level](redactLogText(message), redactLogContext(context));
+};
+var logFatal2 = emit2("fatal");
+var logError2 = emit2("error");
+var logWarn2 = emit2("warn");
+var logInfo2 = emit2("info");
+var logDebug2 = emit2("debug");
+var logTrace2 = emit2("trace");
+
+// src/core/circuitBreaker/CircuitBreaker.ts
+var CircuitBreaker = class {
+  circuits = /* @__PURE__ */ new Map();
+  failureThreshold;
+  resetTimeoutMs;
+  halfOpenMaxAttempts;
+  staleThresholdMs;
+  keyStrategy;
+  cleanupTimer = null;
+  client = null;
+  setClient(client) {
+    this.client = client;
+  }
+  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 = 1;
+        logInfo2(
+          this.client,
+          `Circuit half-open for ${key}, allowing probe request`,
+          { key }
+        );
+        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 === "open") return;
+    if (record.state === "half-open") {
+      logInfo2(this.client, `Circuit closed for ${key} after successful probe`, {
+        key
+      });
+    }
+    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";
+      logWarn2(
+        this.client,
+        `Circuit re-opened for ${key} after failed probe (${record.failures} failures)`,
+        { key, failures: record.failures }
+      );
+      return;
+    }
+    if (record.failures >= this.failureThreshold) {
+      record.state = "open";
+      logWarn2(
+        this.client,
+        `Circuit opened for ${key} after ${record.failures} consecutive failures`,
+        { key, failures: record.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) {
+      logInfo2(
+        this.client,
+        `Circuit breaker cleanup: removed ${cleaned} stale circuits`,
+        {
+          cleaned
+        }
+      );
+    }
+    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();
+  }
+};
+
+// src/core/util/retry.ts
+function retryDelay(attempt, baseMs, maxMs) {
+  const exponential = baseMs === 0 ? 0 : 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;
+          logInfo2(context.client, "Received 401, attempting token refresh...", {
+            endpoint: context.endpoint
+          });
+          try {
+            await context.refreshToken();
+          } catch (refreshError) {
+            if (refreshError instanceof EsiError) {
+              throw refreshError;
+            }
+            const msg = refreshError instanceof Error ? refreshError.message : String(refreshError);
+            logError2(context.client, `Token refresh failed: ${msg}`, {
+              endpoint: context.endpoint
+            });
+            throw new EsiTokenRefreshError(refreshError);
+          }
+          logInfo2(context.client, "Token refreshed, retrying request", {
+            endpoint: context.endpoint
+          });
+          attempt--;
+          continue;
+        }
+        if (error instanceof EsiError && error.retryable && canRetryMethod && attempt < this.maxRetries) {
+          const delay = retryDelay(attempt, this.baseDelayMs, this.maxDelayMs);
+          logWarn2(
+            context.client,
+            `Request to ${context.endpoint} failed (${error.statusCode}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${this.maxRetries})`,
+            { method: context.method, statusCode: error.statusCode }
+          );
+          await sleep(delay);
+          lastError = error;
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError;
+  }
+};
+
+// src/core/util/callerIdentity.ts
+import { createHash } from "crypto";
+var CHARACTER_SUBJECT = /^CHARACTER:EVE:(\d+)$/;
+function characterIdOfToken(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3 || !parts[1]) return null;
+  let claims;
+  try {
+    claims = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof claims !== "object" || claims === null) return null;
+  const sub = claims.sub;
+  const match = typeof sub === "string" ? CHARACTER_SUBJECT.exec(sub) : null;
+  return match ? Number(match[1]) : null;
+}
+function hashedIdentity(authorizationHeader) {
+  return createHash("sha256").update(authorizationHeader).digest("hex").slice(0, 16);
+}
+function callerIdentity(authorizationHeader) {
+  const token = authorizationHeader.startsWith("Bearer ") ? authorizationHeader.slice("Bearer ".length) : authorizationHeader;
+  const characterId = characterIdOfToken(token);
+  if (characterId !== null) return `character:${characterId}`;
+  return hashedIdentity(authorizationHeader);
+}
+
+// src/core/cache/cacheKey.ts
+var identities = /* @__PURE__ */ new WeakMap();
+var accepted = /* @__PURE__ */ new WeakMap();
+var ACCEPTED_LIMIT = 64;
+function identityOf(client, header) {
+  const known = identities.get(client);
+  if (known && known.header === header) return known;
+  const identity = {
+    header,
+    claimed: callerIdentity(header),
+    hashed: hashedIdentity(header)
+  };
+  identities.set(client, identity);
+  return identity;
+}
+function markTokenAccepted(client, authorizationHeader) {
+  let set = accepted.get(client);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    accepted.set(client, set);
+  }
+  const hashed = hashedIdentity(authorizationHeader);
+  if (set.has(hashed)) return;
+  if (set.size >= ACCEPTED_LIMIT) {
+    set.delete(set.values().next().value);
+  }
+  set.add(hashed);
+}
+function isAccepted(client, identity) {
+  return accepted.get(client)?.has(identity.hashed) ?? false;
+}
+function scope(key, identity) {
+  return identity === null ? key : `${identity}:${key}`;
+}
+function trustedIdentity(client, requiresAuth, authorizationHeader) {
+  if (!requiresAuth) return null;
+  const header = authorizationHeader ?? client.getAuthorizationHeader();
+  if (!header) return null;
+  const identity = identityOf(client, header);
+  return isAccepted(client, identity) ? identity.claimed : identity.hashed;
+}
+function claimedIdentity(client, requiresAuth) {
+  if (!requiresAuth) return null;
+  const header = client.getAuthorizationHeader();
+  if (!header) return null;
+  return identityOf(client, header).claimed;
+}
+function buildCacheKey(url, client, requiresAuth = false, authorizationHeader) {
+  return scope(url, trustedIdentity(client, requiresAuth, authorizationHeader));
+}
+function buildConditionalCacheKey(url, client, requiresAuth = false) {
+  return scope(url, claimedIdentity(client, requiresAuth));
+}
+function buildDedupeKey(endpoint, client, requiresAuth = false) {
+  return scope(endpoint, trustedIdentity(client, requiresAuth));
+}
+
+// src/core/util/stringUtil.ts
+function camelToSnake(s) {
+  return s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+
+// src/core/endpoints/esi-cache-ttls.generated.ts
+var esiCacheTtls = {
+  "GET:alliances": 3600,
+  "GET:alliances/{alliance_id}": 3600,
+  "GET:alliances/{alliance_id}/contacts": 300,
+  "GET:alliances/{alliance_id}/contacts/labels": 300,
+  "GET:alliances/{alliance_id}/corporations": 3600,
+  "GET:characters/{character_id}": 86400,
+  "GET:characters/{character_id}/access-lists": 300,
+  "GET:characters/{character_id}/access-lists/{access_list_id}": 300,
+  "GET:characters/{character_id}/agents_research": 3600,
+  "GET:characters/{character_id}/assets": 3600,
+  "GET:characters/{character_id}/attributes": 120,
+  "GET:characters/{character_id}/blueprints": 3600,
+  "GET:characters/{character_id}/calendar": 5,
+  "GET:characters/{character_id}/calendar/{event_id}": 5,
+  "PUT:characters/{character_id}/calendar/{event_id}": 5,
+  "GET:characters/{character_id}/calendar/{event_id}/attendees": 600,
+  "GET:characters/{character_id}/clones": 120,
+  "GET:characters/{character_id}/contacts": 300,
+  "GET:characters/{character_id}/contacts/labels": 300,
+  "GET:characters/{character_id}/contracts": 300,
+  "GET:characters/{character_id}/contracts/{contract_id}/bids": 300,
+  "GET:characters/{character_id}/contracts/{contract_id}/items": 3600,
+  "GET:characters/{character_id}/corporationhistory": 86400,
+  "GET:characters/{character_id}/cosmetics/skinr": 3600,
+  "GET:characters/{character_id}/cosmetics/skinr/components": 3600,
+  "GET:characters/{character_id}/fatigue": 300,
+  "GET:characters/{character_id}/fittings": 300,
+  "GET:characters/{character_id}/fleet": 60,
+  "GET:characters/{character_id}/freelance-jobs": 60,
+  "GET:characters/{character_id}/freelance-jobs/{job_id}/participation": 60,
+  "GET:characters/{character_id}/implants": 120,
+  "GET:characters/{character_id}/industry/jobs": 300,
+  "GET:characters/{character_id}/killmails/recent": 300,
+  "GET:characters/{character_id}/location": 5,
+  "GET:characters/{character_id}/loyalty/points": 3600,
+  "GET:characters/{character_id}/mail": 30,
+  "GET:characters/{character_id}/mail/{mail_id}": 30,
+  "GET:characters/{character_id}/mail/labels": 30,
+  "GET:characters/{character_id}/mail/lists": 120,
+  "GET:characters/{character_id}/medals": 3600,
+  "GET:characters/{character_id}/mercenary-tactical-operations": 300,
+  "GET:characters/{character_id}/mercenary-tactical-operations/{operation_id}": 300,
+  "GET:characters/{character_id}/military-campaigns/objectives": 60,
+  "GET:characters/{character_id}/military-campaigns/objectives/{objective_id}": 60,
+  "GET:characters/{character_id}/mining": 600,
+  "GET:characters/{character_id}/notifications": 600,
+  "GET:characters/{character_id}/notifications/contacts": 600,
+  "GET:characters/{character_id}/online": 60,
+  "GET:characters/{character_id}/orders": 1200,
+  "GET:characters/{character_id}/orders/history": 3600,
+  "GET:characters/{character_id}/planets": 600,
+  "GET:characters/{character_id}/planets/{planet_id}": 600,
+  "GET:characters/{character_id}/roles": 3600,
+  "GET:characters/{character_id}/search": 3600,
+  "GET:characters/{character_id}/ship": 5,
+  "GET:characters/{character_id}/skillqueue": 60,
+  "GET:characters/{character_id}/skills": 60,
+  "GET:characters/{character_id}/standings": 3600,
+  "GET:characters/{character_id}/structures/mercenary-dens": 3600,
+  "GET:characters/{character_id}/structures/mercenary-dens/{mercenary_den_id}": 3600,
+  "GET:characters/{character_id}/titles": 3600,
+  "GET:characters/{character_id}/wallet": 120,
+  "GET:characters/{character_id}/wallet/journal": 3600,
+  "GET:characters/{character_id}/wallet/transactions": 3600,
+  "POST:characters/affiliation": 3600,
+  "GET:contracts/public/{region_id}": 1800,
+  "GET:contracts/public/bids/{contract_id}": 300,
+  "GET:contracts/public/items/{contract_id}": 3600,
+  "GET:corporation/{corporation_id}/mining/extractions": 1800,
+  "GET:corporation/{corporation_id}/mining/observers": 3600,
+  "GET:corporation/{corporation_id}/mining/observers/{observer_id}": 3600,
+  "GET:corporations/{corporation_id}": 3600,
+  "GET:corporations/{corporation_id}/alliancehistory": 3600,
+  "GET:corporations/{corporation_id}/assets": 3600,
+  "GET:corporations/{corporation_id}/blueprints": 3600,
+  "GET:corporations/{corporation_id}/contacts": 300,
+  "GET:corporations/{corporation_id}/contacts/labels": 300,
+  "GET:corporations/{corporation_id}/containers/logs": 600,
+  "GET:corporations/{corporation_id}/contracts": 300,
+  "GET:corporations/{corporation_id}/contracts/{contract_id}/bids": 3600,
+  "GET:corporations/{corporation_id}/contracts/{contract_id}/items": 3600,
+  "GET:corporations/{corporation_id}/customs_offices": 3600,
+  "GET:corporations/{corporation_id}/divisions": 3600,
+  "GET:corporations/{corporation_id}/facilities": 3600,
+  "GET:corporations/{corporation_id}/icons": 3600,
+  "GET:corporations/{corporation_id}/industry/jobs": 300,
+  "GET:corporations/{corporation_id}/killmails/recent": 300,
+  "GET:corporations/{corporation_id}/medals": 3600,
+  "GET:corporations/{corporation_id}/medals/issued": 3600,
+  "GET:corporations/{corporation_id}/members": 3600,
+  "GET:corporations/{corporation_id}/members/limit": 3600,
+  "GET:corporations/{corporation_id}/members/titles": 3600,
+  "GET:corporations/{corporation_id}/membertracking": 3600,
+  "GET:corporations/{corporation_id}/orders": 1200,
+  "GET:corporations/{corporation_id}/orders/history": 3600,
+  "GET:corporations/{corporation_id}/projects/{project_id}": 60,
+  "GET:corporations/{corporation_id}/projects/{project_id}/contribution/{character_id}": 60,
+  "GET:corporations/{corporation_id}/roles": 3600,
+  "GET:corporations/{corporation_id}/roles/history": 3600,
+  "GET:corporations/{corporation_id}/shareholders": 3600,
+  "GET:corporations/{corporation_id}/standings": 3600,
+  "GET:corporations/{corporation_id}/starbases": 3600,
+  "GET:corporations/{corporation_id}/starbases/{starbase_id}": 3600,
+  "GET:corporations/{corporation_id}/structures": 3600,
+  "GET:corporations/{corporation_id}/structures/skyhooks": 3600,
+  "GET:corporations/{corporation_id}/structures/skyhooks/{skyhook_id}": 3600,
+  "GET:corporations/{corporation_id}/structures/sovereignty-hubs": 3600,
+  "GET:corporations/{corporation_id}/structures/sovereignty-hubs/{sovereignty_hub_id}": 3600,
+  "GET:corporations/{corporation_id}/titles": 3600,
+  "GET:corporations/{corporation_id}/wallets": 300,
+  "GET:corporations/{corporation_id}/wallets/{division}/journal": 3600,
+  "GET:corporations/{corporation_id}/wallets/{division}/transactions": 3600,
+  "GET:cosmetics/skinr/{skinr_id}": 31536e3,
+  "GET:fleets/{fleet_id}": 5,
+  "GET:fleets/{fleet_id}/members": 5,
+  "GET:fleets/{fleet_id}/wings": 5,
+  "GET:freelance-jobs/{job_id}": 60,
+  "GET:fw/systems": 1800,
+  "GET:incursions": 300,
+  "GET:industry/facilities": 3600,
+  "GET:industry/systems": 3600,
+  "GET:insurance/prices": 3600,
+  "GET:killmails/{killmail_id}/{killmail_hash}": 2592e3,
+  "GET:markets/{region_id}/orders": 300,
+  "GET:markets/{region_id}/types": 600,
+  "GET:markets/prices": 3600,
+  "GET:markets/structures/{structure_id}": 300,
+  "GET:meta/changelog": 600,
+  "GET:meta/compatibility-dates": 600,
+  "GET:meta/name": 600,
+  "GET:military-campaigns": 60,
+  "GET:military-campaigns/{campaign_id}": 60,
+  "GET:military-campaigns/{campaign_id}/objectives": 60,
+  "GET:military-campaigns/{campaign_id}/objectives/{objective_id}": 60,
+  "GET:skyhooks/raidable": 300,
+  "GET:sovereignty/campaigns": 5,
+  "GET:sovereignty/systems": 300,
+  "GET:status": 30,
+  "GET:universe/schematics/{schematic_id}": 3600,
+  "GET:universe/structures": 3600,
+  "GET:universe/structures/{structure_id}": 3600,
+  "GET:universe/system_jumps": 3600,
+  "GET:universe/system_kills": 3600,
+  "GET:wars": 3600,
+  "GET:wars/{war_id}": 3600,
+  "GET:wars/{war_id}/killmails": 3600
+};
+
+// src/core/constants.ts
+var PACKAGE_NAME = "esi.ts";
+var PACKAGE_VERSION = "11.0.0";
+var USER_AGENT = `${PACKAGE_NAME}/${PACKAGE_VERSION}`;
+var COMPATIBILITY_DATE = "2026-08-18";
+
+// src/core/requestPipeline/headers.ts
+var parseCacheControlTtl = (headers) => {
+  const cacheControl = headers["cache-control"] ?? headers["Cache-Control"];
+  if (!cacheControl) return void 0;
+  const match = /max-age=(\d+)/.exec(cacheControl);
+  return match ? parseInt(match[1], 10) * 1e3 : void 0;
+};
+var HEADER_VALUE2 = /^[\t\x20-\x7e]+$/;
+function buildRequestHeaders(client, url, method, requiresAuth, useETag, body, resolveCache2, accept = "application/json") {
+  const userAgent = client.getUserAgent();
+  const headers = {
+    Accept: accept,
+    "Accept-Encoding": "gzip, deflate, br",
+    "User-Agent": userAgent ? `${userAgent} ${USER_AGENT}` : USER_AGENT,
+    "X-Compatibility-Date": client.getCompatibilityDate() ?? COMPATIBILITY_DATE
+  };
+  const clientId = client.getClientId();
+  if (userAgent) {
+    headers["X-User-Agent"] = userAgent;
+  } else if (HEADER_VALUE2.test(clientId)) {
+    headers["X-User-Agent"] = clientId;
+  }
+  const tenant = client.getTenant();
+  if (tenant) {
+    headers["X-Tenant"] = tenant;
+  }
+  const language = client.getLanguage();
+  if (language) {
+    headers["Accept-Language"] = language;
+  }
+  if (requiresAuth) {
+    const authHeader = client.getAuthorizationHeader();
+    if (!authHeader) {
+      throw new EsiConfigurationError(
+        "NO_AUTH_TOKEN",
+        [
+          "Authorization header is required for this endpoint but no access token is configured",
+          "Fix: set ESI_ACCESS_TOKEN in your environment (see .env.example), or call client.setAccessToken(token), or pass accessToken to the EsiClient constructor"
+        ].join(" \u2014 ")
+      );
+    }
+    headers["Authorization"] = authHeader;
+  }
+  const cache = resolveCache2(client);
+  if (useETag && method === "GET" && cache) {
+    const key = buildConditionalCacheKey(url, client, requiresAuth);
+    const cachedETag = cache.getETag(key);
+    if (cachedETag) {
+      headers["If-None-Match"] = cachedETag;
+      logDebug2(client, `Adding If-None-Match header: ${cachedETag}`, {
+        etag: cachedETag
+      });
+    }
+  }
+  if (body) {
+    headers["Content-Type"] = "application/json";
+  }
+  return headers;
+}
+
+// src/core/requestPipeline/cachePolicy.ts
+var STALE_RETENTION_MS = 60 * 60 * 1e3;
+function retentionTtl(freshnessTtlMs) {
+  return freshnessTtlMs === void 0 ? void 0 : freshnessTtlMs + STALE_RETENTION_MS;
+}
+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, requiresAuth = false) {
+  if (method !== "GET" || !templatePath) return null;
+  const specTtlMs = lookupSpecTtl(method, templatePath);
+  if (!specTtlMs) return null;
+  const cache = resolveCache2(client);
+  if (!cache) return null;
+  const key = buildCacheKey(url, client, requiresAuth);
+  const entry = cache.get(key);
+  if (!entry) return null;
+  const age = Date.now() - entry.timestamp;
+  if (age < specTtlMs) {
+    logDebug2(
+      client,
+      `Spec-aware cache hit for ${url} (age=${Math.round(age / 1e3)}s, ttl=${Math.round(specTtlMs / 1e3)}s)`,
+      { method, templatePath }
+    );
+    return {
+      headers: entry.headers,
+      body: entry.data,
+      status: 200,
+      fromCache: true,
+      cacheHitType: "spec-ttl"
+    };
+  }
+  return null;
+}
+function hasCachedEntry(client, url, resolveCache2, requiresAuth = false, authorization) {
+  const cache = resolveCache2(client);
+  return !!cache && cache.has(buildCacheKey(url, client, requiresAuth, authorization));
+}
+function tryStaleCacheResponse(client, url, parsed, resolveCache2, requiresAuth = false, authorization) {
+  const cache = resolveCache2(client);
+  if (!cache) return null;
+  const key = buildCacheKey(url, client, requiresAuth, authorization);
+  const cachedEntry = cache.get(key);
+  if (!cachedEntry) return null;
+  return {
+    headers: { ...cachedEntry.headers, ...parsed.raw },
+    body: cachedEntry.data,
+    status: 200,
+    fromCache: true,
+    stale: true,
+    cacheHitType: "stale-on-error"
+  };
+}
+var RECENT_WRITES = 64;
+var writeLogs = /* @__PURE__ */ new WeakMap();
+function writeLogFor(cache) {
+  let log = writeLogs.get(cache);
+  if (!log) {
+    log = { generation: 0, recent: [] };
+    writeLogs.set(cache, log);
+  }
+  return log;
+}
+function currentWriteGeneration(client, resolveCache2) {
+  const cache = resolveCache2(client);
+  return cache ? writeLogFor(cache).generation : 0;
+}
+function invalidatedSince(cache, generation, key) {
+  const log = writeLogFor(cache);
+  if (log.generation === generation) return false;
+  if (log.generation - generation > log.recent.length) return true;
+  return log.recent.some(
+    (write) => write.generation > generation && key.includes(write.path)
+  );
+}
+function cacheResponse(client, url, method, endpoint, parsed, data, useETag, resolveCache2, templatePath, requiresAuth = false, sentAtWriteGeneration, authorization) {
+  const cache = resolveCache2(client);
+  if (useETag && method === "GET" && cache && parsed.etag) {
+    const key = buildCacheKey(url, client, requiresAuth, authorization);
+    if (sentAtWriteGeneration !== void 0 && invalidatedSince(cache, sentAtWriteGeneration, key)) {
+      logDebug2(
+        client,
+        `Not caching ${url}: a write invalidated it while the request was in flight`,
+        { method }
+      );
+      return;
+    }
+    const headerTtl = parseCacheControlTtl(parsed.raw);
+    const specTtlMs = templatePath ? lookupSpecTtl(method, templatePath) : void 0;
+    const freshnessTtl = specTtlMs ?? headerTtl;
+    const ttl = retentionTtl(freshnessTtl);
+    cache.set(key, parsed.etag, data, parsed.raw, ttl);
+    const ttlInfo = freshnessTtl !== void 0 ? ` (ttl=${freshnessTtl}ms, kept for ${ttl}ms)` : "";
+    logDebug2(
+      client,
+      `Cached response for ${url} with ETag ${parsed.etag}${ttlInfo}`,
+      {
+        method,
+        etag: parsed.etag
+      }
+    );
+  }
+  invalidateAfterWrite(client, method, endpoint, resolveCache2);
+}
+function evictRejectedResponse(client, endpoint, requiresAuth, resolveCache2) {
+  const cache = resolveCache2(client);
+  if (!cache) return;
+  const url = `${client.getLink()}/${endpoint}`;
+  if (cache.delete(buildCacheKey(url, client, requiresAuth))) {
+    logDebug2(
+      client,
+      `Evicted cached response for ${url} after it failed validation`
+    );
+  }
+}
+function invalidateAfterWrite(client, method, endpoint, resolveCache2) {
+  if (method === "GET") return;
+  const path = endpoint.split("?")[0];
+  client.getDeduplicator()?.detachByPath?.(path);
+  const cache = resolveCache2(client);
+  if (cache) {
+    cache.deleteByPath(path);
+    const log = writeLogFor(cache);
+    log.generation += 1;
+    log.recent.push({ generation: log.generation, path });
+    if (log.recent.length > RECENT_WRITES) log.recent.shift();
+  }
+}
+
+// src/core/requestPipeline/statusHandling.ts
+var STATUS_MESSAGES = {
+  201: "Created",
+  204: "No Content",
+  304: "Not Modified",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Resource not found",
+  420: "Error Limited",
+  422: "Unprocessable Entity",
+  429: "Too many requests",
+  500: "Internal server error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  520: "Internal server error, did the request terminate too soon?"
+};
+function statusMessage(response) {
+  return STATUS_MESSAGES[response.status] || response.statusText || `HTTP ${response.status}`;
+}
+function handleEarlyStatus(client, status, url, parsed, useETag, resolveCache2, requiresAuth = false, authorization) {
+  if (status === 201) {
+    return { headers: parsed.raw, body: void 0, status: 201 };
+  }
+  if (status === 204) {
+    logInfo2(client, `No Content for endpoint: ${url}`, { status });
+    return { headers: parsed.raw, body: void 0, status: 204 };
+  }
+  if (status === 304) {
+    const cache = resolveCache2(client);
+    if (useETag && cache) {
+      const key = buildCacheKey(url, client, requiresAuth, authorization);
+      const cachedEntry = cache.get(key);
+      if (cachedEntry) {
+        logInfo2(client, `Cache hit (304) for endpoint: ${url}`, {
+          status,
+          cacheHitType: "etag-304"
+        });
+        const headers = {
+          ...cachedEntry.headers,
+          ...parsed.raw
+        };
+        if ("etag" in parsed.raw) headers["etag"] = cachedEntry.etag;
+        cache.set(
+          key,
+          cachedEntry.etag,
+          cachedEntry.data,
+          headers,
+          cachedEntry.ttl
+        );
+        return {
+          headers,
+          body: cachedEntry.data,
+          status: 304,
+          fromCache: true,
+          cacheHitType: "etag-304"
+        };
+      }
+    }
+    throw new EsiError(
+      304,
+      "Not Modified \u2014 no cached data available",
+      url,
+      parsed.requestId ?? void 0
+    );
+  }
+  return null;
+}
+var MAX_REASON_LENGTH = 200;
+async function readEsiErrorReason(response) {
+  try {
+    const parsed = JSON.parse(await response.text());
+    const reason = typeof parsed === "object" && parsed !== null ? parsed.error : void 0;
+    if (typeof reason !== "string") return void 0;
+    const trimmed = reason.trim();
+    return trimmed ? trimmed.slice(0, MAX_REASON_LENGTH) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function handleErrorResponse(client, response, url, parsed, useETag, resolveCache2, requiresAuth = false, esiReason, authorization) {
+  const text = statusMessage(response);
+  const errorMessage = esiReason ? `${text}: ${esiReason}` : text;
+  if (response.status >= 500 && useETag) {
+    const staleResult = tryStaleCacheResponse(
+      client,
+      url,
+      parsed,
+      resolveCache2,
+      requiresAuth,
+      authorization
+    );
+    if (staleResult) {
+      logWarn2(client, `${errorMessage} for ${url} \u2014 serving stale cache`, {
+        status: response.status
+      });
+      return { ...staleResult, status: response.status };
+    }
+  }
+  if (response.status === 420 || response.status === 429) {
+    logWarn2(client, `Rate limited (${response.status}) on ${url}`, {
+      status: response.status
+    });
+  }
+  let message = errorMessage;
+  if (response.status === 401) {
+    message = `${errorMessage} \u2014 the access token was missing, expired, or lacks the required ESI scope. Fix: verify ESI_ACCESS_TOKEN, or configure onTokenRefresh for automatic refresh on 401`;
+  } else if (response.status === 403) {
+    message = `${errorMessage} \u2014 your access token does not have the OAuth scopes required for this endpoint. Check the scopes on your EVE SSO application`;
+  }
+  throw new EsiError(
+    response.status,
+    message,
+    url,
+    parsed.requestId ?? void 0
+  );
+}
+function wrapError(error, client) {
+  if (error instanceof EsiError) {
+    throw error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  logError2(client, `Unexpected error: ${message}`);
+  throw toEsiError(error);
+}
+
+// src/core/requestPipeline/dependencies.ts
+function resolveCache(client) {
+  return client.getCache();
+}
+function resolveRateLimiter(client) {
+  const limiter = client.getRateLimiter();
+  if (!limiter) {
+    throw new EsiConfigurationError(
+      "CONFIGURATION_ERROR",
+      "No rate limiter configured on ApiClient. Set one via apiClient.setRateLimiter(new RateLimiter())."
+    );
+  }
+  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,
+    stopOnEmptyPage: true
+  };
+  /**
+   * Fetch remaining pages (2..totalPages) and combine with first page data.
+   * The caller has already fetched page 1 and knows the total page count.
+   */
+  static async fetchRemainingPages(client, endpoint, method, requiresAuth, firstPageData, totalPages, body, options, pageFetch, templatePath) {
+    const opts = { ...this.DEFAULT_OPTIONS, ...options };
+    const rateLimiter = client.getRateLimiter();
+    const allData = [...firstPageData];
+    const effectiveMaxPage = Math.min(totalPages, opts.maxPages);
+    if (effectiveMaxPage <= 1) {
+      return allData;
+    }
+    logInfo2(client, `Fetching pages 2-${effectiveMaxPage} for ${endpoint}...`, {
+      method,
+      totalPages
+    });
+    for (let page = 2; page <= effectiveMaxPage; page++) {
+      try {
+        if (rateLimiter) await rateLimiter.checkRateLimit(templatePath, method);
+        const pageData = await this.fetchPageWithRetry(
+          client,
+          endpoint,
+          method,
+          requiresAuth,
+          page,
+          pageFetch
+        );
+        if (opts.stopOnEmptyPage && (!pageData || pageData.length === 0)) {
+          logWarn2(client, `Page ${page} is empty. Stopping pagination.`, {
+            page
+          });
+          break;
+        }
+        allData.push(...pageData);
+        logInfo2(
+          client,
+          `Fetched page ${page}/${effectiveMaxPage} (${pageData.length} items)`,
+          { page, items: pageData.length }
+        );
+      } catch (error) {
+        logError2(
+          client,
+          `Failed to fetch page ${page}: ${error instanceof Error ? error.message : String(error)}`,
+          { page }
+        );
+        throw error instanceof Error ? error : new Error(`Failed to fetch page ${page}: ${String(error)}`);
+      }
+    }
+    logInfo2(
+      client,
+      `Pagination complete. Fetched ${allData.length} total items from up to ${effectiveMaxPage} pages.`,
+      { totalItems: allData.length }
+    );
+    return allData;
+  }
+  /**
+   * 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(client, endpoint, method, requiresAuth, page, pageFetch) {
+    const retryStrategy = resolveRetryStrategy(client);
+    const paginatedEndpoint = this.buildPaginatedEndpoint(endpoint, page);
+    return retryStrategy.execute(
+      () => {
+        logInfo2(
+          client,
+          `Fetching page ${page} via pipeline: ${paginatedEndpoint}`,
+          { page }
+        );
+        return pageFetch(paginatedEndpoint);
+      },
+      {
+        client,
+        endpoint: paginatedEndpoint,
+        method,
+        requiresAuth,
+        refreshToken: client.hasTokenProvider() ? () => client.refreshToken().then(() => {
+        }) : void 0
+      }
+    );
+  }
+  /**
+   * Build a paginated endpoint path.
+   * Preserves any existing query params on the endpoint and appends page=N.
+   */
+  static buildPaginatedEndpoint(endpoint, page) {
+    const separator = endpoint.includes("?") ? "&" : "?";
+    return `${endpoint}${separator}page=${page}`;
+  }
+};
+
+// src/core/requestPipeline/paginationOrchestration.ts
+function handleCursorPagination(parsed, data) {
+  if (!parsed.hasCursorPagination) return null;
+  const cursors = {
+    before: parsed.cursorBefore,
+    after: parsed.cursorAfter
+  };
+  return { headers: parsed.raw, body: data, status: 200, cursors };
+}
+async function handleOffsetPagination(client, endpoint, method, requiresAuth, parsed, data, body, url, useETag, pageFetch, resolveCache2, templatePath, sentAtWriteGeneration, authorization) {
+  const totalPages = parsed.xPages;
+  if (totalPages <= 1) {
+    return { headers: parsed.raw, body: data, status: 200 };
+  }
+  logInfo2(
+    client,
+    `Found ${totalPages} pages, fetching additional pages with rate limiting...`,
+    { endpoint, totalPages }
+  );
+  try {
+    const firstPageData = Array.isArray(data) ? data : [data];
+    const allData = await PaginationHandler.fetchRemainingPages(
+      client,
+      endpoint,
+      method,
+      requiresAuth,
+      firstPageData,
+      totalPages,
+      body,
+      {
+        maxPages: Math.min(totalPages, 1e3),
+        stopOnEmptyPage: true
+      },
+      pageFetch,
+      templatePath
+    );
+    cacheResponse(
+      client,
+      url,
+      method,
+      endpoint,
+      parsed,
+      allData,
+      useETag,
+      resolveCache2,
+      templatePath,
+      requiresAuth,
+      sentAtWriteGeneration,
+      authorization
+    );
+    return { headers: parsed.raw, body: allData, status: 200 };
+  } catch (paginationError) {
+    const msg = paginationError instanceof Error ? paginationError.message : String(paginationError);
+    logWarn2(client, `Pagination failed for ${url}: ${msg}`, {
+      url,
+      endpoint,
+      error: msg
+    });
+    if (paginationError instanceof EsiError) {
+      throw paginationError;
+    }
+    throw new EsiPaginationError(url, paginationError);
+  }
+}
+
+// src/core/requestPipeline/middlewareBridge.ts
+async function applyRequestMiddleware(client, url, endpoint, method, headers, body) {
+  const middleware = client.getMiddleware();
+  if (!middleware.hasInterceptors()) {
+    return { url, headers, body };
+  }
+  const reqCtx = {
+    url,
+    endpoint,
+    method,
+    headers: { ...headers },
+    body
+  };
+  const modified = await middleware.applyRequestInterceptors(reqCtx);
+  return {
+    url: modified.url,
+    headers: modified.headers,
+    body: modified.body
+  };
+}
+async function applyResponseInterceptors(client, result, url, endpoint, method, startTime) {
+  const middleware = client.getMiddleware();
+  if (!middleware.hasInterceptors()) return result;
+  const responseCtx = {
+    url,
+    endpoint,
+    method,
+    status: result.status ?? 200,
+    headers: result.headers,
+    body: result.body,
+    durationMs: Date.now() - startTime,
+    fromCache: result.fromCache ?? false
+  };
+  const modified = await middleware.applyResponseInterceptors(responseCtx);
+  return {
+    ...result,
+    headers: modified.headers,
+    body: modified.body
+  };
+}
+
+// src/core/util/headersUtil.ts
+function parseWarning(value) {
+  if (!value) return null;
+  const match = /^(\d{3}) - "([^"]+)"$/.exec(value) ?? /^(\d{3}) - ([^ ].+[^ ])$/.exec(value);
+  if (!match) return null;
+  const [, code, message] = match;
+  return { code: parseInt(code, 10), message };
+}
+function parseHeaders(fetchHeaders) {
+  const raw = {};
+  fetchHeaders.forEach((value, key) => {
+    raw[key.toLowerCase()] = value;
+  });
+  const cursorBefore = raw["x-cursor-before"] ?? null;
+  const cursorAfter = raw["x-cursor-after"] ?? null;
+  return {
+    raw,
+    xPages: parseInt(raw["x-pages"] ?? "1", 10),
+    etag: raw["etag"] ?? null,
+    cacheControl: raw["cache-control"] ?? null,
+    expires: raw["expires"] ?? null,
+    lastModified: raw["last-modified"] ?? null,
+    cursorBefore,
+    cursorAfter,
+    hasCursorPagination: "x-cursor-before" in raw || "x-cursor-after" in raw,
+    warning: parseWarning(raw["warning"]),
+    requestId: raw["x-esi-request-id"] ?? null,
+    date: raw["date"] ?? null,
+    contentLanguage: raw["content-language"] ?? null
+  };
+}
+
+// src/core/requestPipeline/fetchExecution.ts
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && err.name === "AbortError";
+}
+function networkError(err, url) {
+  const reason = err instanceof Error ? err.message : String(err);
+  return new EsiNetworkError(reason, url, err);
+}
+async function bufferBody(response) {
+  if (typeof response.text !== "function") return;
+  const text = await response.text();
+  Object.defineProperties(response, {
+    text: { value: () => Promise.resolve(text), configurable: true },
+    json: {
+      value: () => Promise.resolve(text).then((t) => JSON.parse(t)),
+      configurable: true
+    }
+  });
+}
+async function executeSingleFetch(client, endpoint, method, body, requiresAuth, useETag, resolveCache2, resolveRateLimiter2, resolveCircuitBreaker2, requestTimeout, templatePath, accept) {
+  const rawUrl = `${client.getLink()}/${endpoint}`;
+  const builtHeaders = buildRequestHeaders(
+    client,
+    rawUrl,
+    method,
+    requiresAuth,
+    useETag,
+    body,
+    resolveCache2,
+    accept
+  );
+  const req = await applyRequestMiddleware(
+    client,
+    rawUrl,
+    endpoint,
+    method,
+    builtHeaders,
+    body
+  );
+  const options = {
+    method,
+    headers: req.headers,
+    ...req.body ? { body: JSON.stringify(req.body) } : {}
+  };
+  const url = req.url;
+  logInfo2(client, `Hitting endpoint: ${url}`, { method, endpoint });
+  const cb = resolveCircuitBreaker2(client);
+  const cbKey = cb && templatePath && cb.getKeyStrategy?.() === "template" ? templatePath : endpoint;
+  if (cb) cb.checkCircuit(cbKey);
+  let cbRecorded = false;
+  try {
+    const rateLimiter = resolveRateLimiter2(client);
+    await rateLimiter.checkRateLimit(templatePath, method, req.headers);
+    const timeoutMs = requestTimeout ?? client.getTimeout();
+    const controller = new AbortController();
+    const timer = globalThis.setTimeout(() => controller.abort(), timeoutMs);
+    options.signal = controller.signal;
+    let response;
+    try {
+      response = await client.getFetch()(url, options);
+      await bufferBody(response);
+    } catch (err) {
+      clearTimeout(timer);
+      if (cb) {
+        cb.recordFailure(cbKey, 0);
+        cbRecorded = true;
+      }
+      if (err instanceof EsiError) throw err;
+      if (isAbortError(err)) {
+        throw new TimeoutError(timeoutMs, url);
+      }
+      throw networkError(err, url);
+    }
+    clearTimeout(timer);
+    const parsed = parseHeaders(response.headers);
+    if (requiresAuth && (response.ok || response.status === 304)) {
+      const sent = req.headers["Authorization"];
+      if (sent) markTokenAccepted(client, sent);
+    }
+    rateLimiter.updateFromResponse(
+      parsed.raw,
+      response.status,
+      templatePath,
+      method,
+      req.headers
+    );
+    if (cb) {
+      if (response.status >= 500 || response.status === 420 || response.status === 429) {
+        cb.recordFailure(cbKey, response.status);
+      } else {
+        cb.recordSuccess(cbKey);
+      }
+      cbRecorded = true;
+    }
+    if (parsed.warning) {
+      logWarn2(
+        client,
+        `ESI Warning ${parsed.warning.code}: ${parsed.warning.message}`,
+        {
+          url,
+          warningCode: parsed.warning.code
+        }
+      );
+    }
+    return {
+      response,
+      parsed,
+      url,
+      authorization: req.headers["Authorization"]
+    };
+  } finally {
+    if (cb && !cbRecorded) {
+      cb.recordFailure(cbKey, 0);
+    }
+  }
+}
+async function parseJsonBody(client, response, _url) {
+  try {
+    return await response.json();
+  } catch (jsonError) {
+    const msg = jsonError instanceof Error ? jsonError.message : String(jsonError);
+    logError2(client, `Failed to parse JSON response: ${msg}`, { url: _url });
+    throw new EsiParseError(`Invalid JSON response: ${msg}`, _url, jsonError);
+  }
+}
+async function fetchOnePage(client, endpoint, method, body, requiresAuth, useETag, resolveCache2, resolveRateLimiter2, resolveCircuitBreaker2, requestTimeout, templatePath) {
+  const { response, parsed, url } = await executeSingleFetch(
+    client,
+    endpoint,
+    method,
+    body,
+    requiresAuth,
+    useETag,
+    resolveCache2,
+    resolveRateLimiter2,
+    resolveCircuitBreaker2,
+    requestTimeout,
+    templatePath
+  );
+  if (!response.ok) {
+    const text = statusMessage(response);
+    const reason = await readEsiErrorReason(response);
+    throw new EsiError(
+      response.status,
+      reason ? `${text}: ${reason}` : text,
+      url,
+      parsed.requestId ?? void 0
+    );
+  }
+  const data = await parseJsonBody(client, response, url);
+  return { data, parsed, url };
+}
+
+// src/core/ApiRequestHandler.ts
+var executeRequest = async (client, endpoint, method, body, requiresAuth = false, useETag = true, requestTimeout, templatePath, textResponse, emptyWhenNoContent) => {
+  const startTime = Date.now();
+  const finish = (r) => {
+    r.responseTimeMs = Date.now() - startTime;
+    const rawUrl = `${client.getLink()}/${endpoint}`;
+    return applyResponseInterceptors(
+      client,
+      r,
+      rawUrl,
+      endpoint,
+      method,
+      startTime
+    );
+  };
+  try {
+    const writeGeneration = currentWriteGeneration(client, resolveCache);
+    const revalidating = useETag && method === "GET" && hasCachedEntry(
+      client,
+      `${client.getLink()}/${endpoint}`,
+      resolveCache,
+      requiresAuth
+    );
+    const { response, parsed, url, authorization } = await executeSingleFetch(
+      client,
+      endpoint,
+      method,
+      body,
+      requiresAuth,
+      useETag,
+      resolveCache,
+      resolveRateLimiter,
+      resolveCircuitBreaker,
+      requestTimeout,
+      templatePath,
+      textResponse?.accept
+    );
+    if (response.status === 201 || response.status === 204) {
+      invalidateAfterWrite(client, method, endpoint, resolveCache);
+    }
+    if (response.status === 201) {
+      let data2;
+      try {
+        data2 = await response.json();
+      } catch {
+        data2 = void 0;
+      }
+      return finish({ headers: parsed.raw, body: data2, status: 201 });
+    }
+    if (emptyWhenNoContent && response.status === 200 && response.headers.get("content-length") === "0") {
+      logInfo2(client, `No Content for endpoint: ${url}`, { status: 200 });
+      return finish({ headers: parsed.raw, body: void 0, status: 200 });
+    }
+    if (response.status === 304 && revalidating && !hasCachedEntry(client, url, resolveCache, requiresAuth, authorization)) {
+      return await executeRequest(
+        client,
+        endpoint,
+        method,
+        body,
+        requiresAuth,
+        useETag,
+        requestTimeout,
+        templatePath,
+        textResponse,
+        emptyWhenNoContent
+      );
+    }
+    const earlyResult = handleEarlyStatus(
+      client,
+      response.status,
+      url,
+      parsed,
+      useETag,
+      resolveCache,
+      requiresAuth,
+      authorization
+    );
+    if (earlyResult) return finish(earlyResult);
+    if (!response.ok) {
+      const staleOrThrow = handleErrorResponse(
+        client,
+        response,
+        url,
+        parsed,
+        useETag,
+        resolveCache,
+        requiresAuth,
+        await readEsiErrorReason(response),
+        authorization
+      );
+      return finish(staleOrThrow);
+    }
+    const data = textResponse ? await response.text() : await parseJsonBody(client, response, url);
+    if (parsed.xPages <= 1 || parsed.hasCursorPagination) {
+      cacheResponse(
+        client,
+        url,
+        method,
+        endpoint,
+        parsed,
+        data,
+        useETag,
+        resolveCache,
+        templatePath,
+        requiresAuth,
+        writeGeneration,
+        authorization
+      );
+    }
+    const cursorResult = handleCursorPagination(parsed, data);
+    if (cursorResult) return finish(cursorResult);
+    const pageFetch = async (paginatedEndpoint) => {
+      const result = await fetchOnePage(
+        client,
+        paginatedEndpoint,
+        method,
+        body,
+        requiresAuth,
+        false,
+        resolveCache,
+        resolveRateLimiter,
+        resolveCircuitBreaker,
+        requestTimeout,
+        templatePath
+      );
+      return Array.isArray(result.data) ? result.data : [result.data];
+    };
+    const paginatedResult = await handleOffsetPagination(
+      client,
+      endpoint,
+      method,
+      requiresAuth,
+      parsed,
+      data,
+      body,
+      url,
+      useETag,
+      pageFetch,
+      resolveCache,
+      templatePath,
+      writeGeneration,
+      authorization
+    );
+    return finish(paginatedResult);
+  } catch (error) {
+    wrapError(error, client);
+  }
+};
+var handleSinglePageRequest = async (client, endpoint, method, body, requiresAuth = false, templatePath, requestTimeout) => {
+  const doExecute = () => fetchOnePage(
+    client,
+    endpoint,
+    method,
+    body,
+    requiresAuth,
+    false,
+    resolveCache,
+    resolveRateLimiter,
+    resolveCircuitBreaker,
+    requestTimeout,
+    templatePath
+  ).then(({ data, parsed }) => ({
+    headers: parsed.raw,
+    body: data
+  }));
+  const retryStrategy = resolveRetryStrategy(client);
+  return retryStrategy.execute(doExecute, {
+    client,
+    endpoint,
+    method,
+    requiresAuth,
+    refreshToken: client.hasTokenProvider() ? () => client.refreshToken().then(() => {
+    }) : void 0
+  });
+};
+var handleRequest = async (client, endpoint, method, body, requiresAuth = false, useETag = true, templatePath, requestTimeout, textResponse, emptyWhenNoContent = false) => {
+  const rawUrl = `${client.getLink()}/${endpoint}`;
+  const startTime = Date.now();
+  const specCacheHit = () => {
+    const hit = trySpecAwareCacheHit(
+      client,
+      rawUrl,
+      method,
+      templatePath,
+      resolveCache,
+      requiresAuth
+    );
+    return hit ? applyResponseInterceptors(
+      client,
+      hit,
+      rawUrl,
+      endpoint,
+      method,
+      startTime
+    ) : null;
+  };
+  const specHit = specCacheHit();
+  if (specHit) return specHit;
+  const doExecute = () => executeRequest(
+    client,
+    endpoint,
+    method,
+    body,
+    requiresAuth,
+    useETag,
+    requestTimeout,
+    templatePath,
+    textResponse,
+    emptyWhenNoContent
+  );
+  const dedup = client.getDeduplicator();
+  const canDedup = dedup && method === "GET" && !body;
+  let attempted = false;
+  const operation = () => {
+    const retryHit = attempted ? specCacheHit() : null;
+    attempted = true;
+    if (retryHit) return retryHit;
+    return canDedup ? dedup.dedupe(
+      buildDedupeKey(endpoint, client, requiresAuth),
+      doExecute
+    ) : doExecute();
+  };
+  const retryStrategy = resolveRetryStrategy(client);
+  return retryStrategy.execute(operation, {
+    client,
+    endpoint,
+    method,
+    requiresAuth,
+    refreshToken: client.hasTokenProvider() ? () => client.refreshToken().then(() => {
+    }) : void 0
+  });
+};
+
+// src/core/pagination/AsyncPaginationIterator.ts
+function extractArray(body) {
+  if (Array.isArray(body)) return body;
+  if (body !== void 0 && body !== null) return [body];
+  return [];
+}
+function validatePageBody(body, schema, url, validate) {
+  if (!schema || !validate) return body;
+  const result = schema.safeParse(body);
+  if (!result.success) {
+    throw new EsiValidationError(url, result.error);
+  }
+  return result.data;
+}
+async function fetchAllPages(client, endpoint, method, requiresAuth = false, body, templatePath, responseSchema, concurrency = 8) {
+  const validate = client.getValidateResponse();
+  const firstResponse = await handleSinglePageRequest(
+    client,
+    endpoint,
+    method,
+    body,
+    requiresAuth,
+    templatePath
+  );
+  const firstBody = validatePageBody(
+    firstResponse.body,
+    responseSchema,
+    `${client.getLink()}/${endpoint}`,
+    validate
+  );
+  const totalPages = parseInt(firstResponse.headers["x-pages"] || "1", 10);
+  const result = extractArray(firstBody);
+  const remaining = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
+  for (let i = 0; i < remaining.length; i += concurrency) {
+    const batch = remaining.slice(i, i + concurrency);
+    const pages = await Promise.all(
+      batch.map(async (page) => {
+        const sep = endpoint.includes("?") ? "&" : "?";
+        const pagedEndpoint = `${endpoint}${sep}page=${page}`;
+        logInfo2(
+          client,
+          `Fetching page ${page}/${totalPages}: ${pagedEndpoint}`,
+          { page, totalPages }
+        );
+        const response = await handleSinglePageRequest(
+          client,
+          pagedEndpoint,
+          method,
+          body,
+          requiresAuth,
+          templatePath
+        );
+        return validatePageBody(
+          response.body,
+          responseSchema,
+          `${client.getLink()}/${pagedEndpoint}`,
+          validate
+        );
+      })
+    );
+    for (const pageBody of pages) {
+      result.push(...extractArray(pageBody));
+    }
+  }
+  return result;
+}
+async function* fetchPages(client, endpoint, method, requiresAuth = false, body, templatePath, responseSchema) {
+  const validate = client.getValidateResponse();
+  const firstResponse = await handleSinglePageRequest(
+    client,
+    endpoint,
+    method,
+    body,
+    requiresAuth,
+    templatePath
+  );
+  const firstBody = validatePageBody(
+    firstResponse.body,
+    responseSchema,
+    `${client.getLink()}/${endpoint}`,
+    validate
+  );
+  const totalPages = parseInt(firstResponse.headers["x-pages"] || "1", 10);
+  yield { data: extractArray(firstBody), page: 1, totalPages };
+  for (let page = 2; page <= totalPages; page++) {
+    const sep = endpoint.includes("?") ? "&" : "?";
+    const pagedEndpoint = `${endpoint}${sep}page=${page}`;
+    logInfo2(client, `Fetching page ${page}/${totalPages}: ${pagedEndpoint}`, {
+      page,
+      totalPages
+    });
+    const response = await handleSinglePageRequest(
+      client,
+      pagedEndpoint,
+      method,
+      body,
+      requiresAuth,
+      templatePath
+    );
+    const pageBody = validatePageBody(
+      response.body,
+      responseSchema,
+      `${client.getLink()}/${pagedEndpoint}`,
+      validate
+    );
+    const pageData = extractArray(pageBody);
+    if (pageData.length === 0) break;
+    yield { data: pageData, page, totalPages };
+  }
+}
+
+// src/core/cache/ETagCacheManager.ts
+var ETagCacheManager = class {
+  cache = /* @__PURE__ */ new Map();
+  config;
+  cleanupTimer;
+  hits = 0;
+  misses = 0;
+  client = null;
+  setClient(client) {
+    this.client = client;
+  }
+  log(level, message, context) {
+    const ctx = context && Object.keys(context).length > 0 ? context : void 0;
+    const emit3 = level === "info" ? logInfo2 : logDebug2;
+    emit3(this.client, message, ctx);
+  }
+  /**
+   * @param client - the client whose logger this cache logs to, from the
+   *   first line (the startup log) on. `setClient` can attach or change it
+   *   later; without one the cache logs to the global logger.
+   */
+  constructor(config = {}, client) {
+    this.client = client ?? null;
+    this.config = {
+      maxEntries: config.maxEntries ?? 1e3,
+      defaultTtl: config.defaultTtl ?? 5 * 60 * 1e3,
+      // 5 minutes default
+      cleanupInterval: config.cleanupInterval ?? 60 * 1e3
+      // 1 minute cleanup
+    };
+    this.startCleanupTimer();
+    this.log(
+      "info",
+      `ETag cache manager initialized with ${this.config.maxEntries} max entries`,
+      { maxEntries: this.config.maxEntries }
+    );
+  }
+  /**
+   * Get cached data if ETag matches
+   */
+  get(url) {
+    const entry = this.cache.get(url);
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+    if (this.isExpired(entry)) {
+      this.cache.delete(url);
+      this.misses++;
+      this.log("debug", `Cache entry expired for ${url}`, { url });
+      return null;
+    }
+    this.hits++;
+    this.log("debug", `Cache hit for ${url} with ETag ${entry.etag}`, { url });
+    return entry;
+  }
+  /**
+   * Get ETag for a URL (for If-None-Match header)
+   */
+  getETag(url) {
+    const entry = this.get(url);
+    return entry ? entry.etag : null;
+  }
+  /**
+   * Set cache entry
+   */
+  set(url, etag, data, headers, customTtl) {
+    if (!this.cache.has(url) && this.cache.size >= this.config.maxEntries) {
+      this.evictOldest();
+    }
+    const entry = {
+      etag,
+      data,
+      headers,
+      timestamp: Date.now(),
+      ttl: customTtl ?? this.config.defaultTtl
+    };
+    this.cache.set(url, entry);
+    this.log("debug", `Cached response for ${url} with ETag ${etag}`, { url });
+  }
+  /**
+   * Check if cached data exists and is valid
+   */
+  has(url) {
+    const entry = this.cache.get(url);
+    return entry !== void 0 && !this.isExpired(entry);
+  }
+  /**
+   * Clear specific cache entry
+   */
+  delete(url) {
+    return this.cache.delete(url);
+  }
+  /**
+   * Delete all cache entries whose URL contains the given path segment
+   */
+  deleteByPath(pathSegment) {
+    let count = 0;
+    for (const key of this.cache.keys()) {
+      if (key.includes(pathSegment)) {
+        this.cache.delete(key);
+        count++;
+      }
+    }
+    if (count > 0) {
+      this.log(
+        "debug",
+        `Invalidated ${count} cache entries matching ${pathSegment}`,
+        {
+          count
+        }
+      );
+    }
+    return count;
+  }
+  /**
+   * Clear all cache entries
+   */
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+    this.log("info", "ETag cache cleared");
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    let oldest = Infinity;
+    let newest = -Infinity;
+    for (const entry of this.cache.values()) {
+      if (entry.timestamp < oldest) oldest = entry.timestamp;
+      if (entry.timestamp > newest) newest = entry.timestamp;
+    }
+    const total = this.hits + this.misses;
+    return {
+      totalEntries: this.cache.size,
+      maxEntries: this.config.maxEntries,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0,
+      oldestEntry: this.cache.size > 0 ? oldest : null,
+      newestEntry: this.cache.size > 0 ? newest : null
+    };
+  }
+  /**
+   * Update cache configuration
+   */
+  updateConfig(newConfig) {
+    this.config = {
+      maxEntries: newConfig.maxEntries ?? this.config.maxEntries,
+      defaultTtl: newConfig.defaultTtl ?? this.config.defaultTtl,
+      cleanupInterval: newConfig.cleanupInterval ?? this.config.cleanupInterval
+    };
+    this.log("info", "ETag cache configuration updated", {
+      maxEntries: this.config.maxEntries
+    });
+  }
+  /**
+   * Cleanup expired entries
+   */
+  cleanup() {
+    const beforeSize = this.cache.size;
+    for (const [url, entry] of this.cache.entries()) {
+      if (this.isExpired(entry)) {
+        this.cache.delete(url);
+      }
+    }
+    const cleanedCount = beforeSize - this.cache.size;
+    if (cleanedCount > 0) {
+      this.log("debug", `Cleaned up ${cleanedCount} expired cache entries`, {
+        cleanedCount
+      });
+    }
+    return cleanedCount;
+  }
+  /**
+   * Shutdown cache manager
+   */
+  shutdown() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+    this.log("info", "ETag cache manager shut down");
+  }
+  isExpired(entry) {
+    if (!entry.ttl) return false;
+    return Date.now() - entry.timestamp > entry.ttl;
+  }
+  evictOldest() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.timestamp < oldestTime) {
+        oldestTime = entry.timestamp;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.cache.delete(oldestKey);
+      this.log("debug", `Evicted oldest cache entry: ${oldestKey}`, {
+        url: oldestKey
+      });
+    }
+  }
+  startCleanupTimer() {
+    this.cleanupTimer = setInterval(() => {
+      this.cleanup();
+    }, this.config.cleanupInterval);
+    this.cleanupTimer.unref();
+  }
+};
+
+// src/core/endpoints/esi-rate-limit-groups.generated.ts
+var esiRateLimitGroups = {
+  "GET:alliances/{alliance_id}/contacts": { group: "alliance-social", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:alliances/{alliance_id}/contacts/labels": { group: "alliance-social", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/access-lists": { group: "char-access", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/access-lists/{access_list_id}": { group: "char-access", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/agents_research": { group: "char-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/assets": { group: "char-asset", maxTokens: 1800, windowSizeMs: 9e5 },
+  "POST:characters/{character_id}/assets/locations": { group: "char-asset", maxTokens: 1800, windowSizeMs: 9e5 },
+  "POST:characters/{character_id}/assets/names": { group: "char-asset", maxTokens: 1800, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/attributes": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/blueprints": { group: "char-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/calendar": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/calendar/{event_id}": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "PUT:characters/{character_id}/calendar/{event_id}": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/calendar/{event_id}/attendees": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/clones": { group: "char-location", maxTokens: 1200, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/contacts": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "POST:characters/{character_id}/contacts": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "PUT:characters/{character_id}/contacts": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "DELETE:characters/{character_id}/contacts": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/contacts/labels": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/contracts": { group: "char-contract", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/contracts/{contract_id}/bids": { group: "char-contract", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/contracts/{contract_id}/items": { group: "char-contract", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/cosmetics/skinr": { group: "char-skinr", maxTokens: 30, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/cosmetics/skinr/components": { group: "char-skinr", maxTokens: 30, windowSizeMs: 9e5 },
+  "POST:characters/{character_id}/cspa": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/fatigue": { group: "char-location", maxTokens: 1200, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/fittings": { group: "fitting", maxTokens: 150, windowSizeMs: 9e5 },
+  "POST:characters/{character_id}/fittings": { group: "fitting", maxTokens: 150, windowSizeMs: 9e5 },
+  "DELETE:characters/{character_id}/fittings/{fitting_id}": { group: "fitting", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/fleet": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/freelance-jobs": { group: "char-freelance-job", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/freelance-jobs/{job_id}/participation": { group: "char-freelance-job", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/fw/stats": { group: "factional-warfare", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/implants": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/industry/jobs": { group: "char-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/killmails/recent": { group: "char-killmail", maxTokens: 30, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/location": { group: "char-location", maxTokens: 1200, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/loyalty/points": { group: "char-wallet", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/mail": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "POST:characters/{character_id}/mail": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/mail/{mail_id}": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "PUT:characters/{character_id}/mail/{mail_id}": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "DELETE:characters/{character_id}/mail/{mail_id}": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/mail/labels": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "POST:characters/{character_id}/mail/labels": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "DELETE:characters/{character_id}/mail/labels/{label_id}": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/mail/lists": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/medals": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/mercenary-tactical-operations": { group: "char-activity", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/mercenary-tactical-operations/{operation_id}": { group: "char-activity", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/military-campaigns/objectives": { group: "char-military-campaign", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/military-campaigns/objectives/{objective_id}": { group: "char-military-campaign", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/mining": { group: "char-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/notifications": { group: "char-notification", maxTokens: 15, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/notifications/contacts": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/online": { group: "char-location", maxTokens: 1200, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/paragon-hub/skinr": { group: "char-paragon-hub", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/planets": { group: "char-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/planets/{planet_id}": { group: "char-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/portrait": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/roles": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/ship": { group: "char-location", maxTokens: 1200, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/skillqueue": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/skills": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/standings": { group: "char-social", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/structures/mercenary-dens": { group: "char-structure", maxTokens: 30, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/structures/mercenary-dens/{mercenary_den_id}": { group: "char-structure", maxTokens: 30, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/titles": { group: "char-detail", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/wallet": { group: "char-wallet", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/wallet/journal": { group: "char-wallet", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:characters/{character_id}/wallet/transactions": { group: "char-wallet", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:corporation/{corporation_id}/mining/extractions": { group: "corp-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporation/{corporation_id}/mining/observers": { group: "corp-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporation/{corporation_id}/mining/observers/{observer_id}": { group: "corp-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/assets": { group: "corp-asset", maxTokens: 1800, windowSizeMs: 9e5 },
+  "POST:corporations/{corporation_id}/assets/locations": { group: "corp-asset", maxTokens: 1800, windowSizeMs: 9e5 },
+  "POST:corporations/{corporation_id}/assets/names": { group: "corp-asset", maxTokens: 1800, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/blueprints": { group: "corp-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/contacts": { group: "corp-social", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/contacts/labels": { group: "corp-social", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/containers/logs": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/contracts": { group: "corp-contract", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/contracts/{contract_id}/bids": { group: "corp-contract", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/contracts/{contract_id}/items": { group: "corp-contract", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/customs_offices": { group: "corp-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/divisions": { group: "corp-wallet", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/facilities": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/freelance-jobs": { group: "corp-freelance-job", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/freelance-jobs/{job_id}/participants": { group: "corp-freelance-job", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/fw/stats": { group: "factional-warfare", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/industry/jobs": { group: "corp-industry", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/killmails/recent": { group: "corp-killmail", maxTokens: 30, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/medals": { group: "corp-detail", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/medals/issued": { group: "corp-detail", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/members": { group: "corp-member", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/members/limit": { group: "corp-member", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/members/titles": { group: "corp-member", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/membertracking": { group: "corp-member", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/projects": { group: "corp-project", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/projects/{project_id}": { group: "corp-project", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/projects/{project_id}/contribution/{character_id}": { group: "corp-project", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/projects/{project_id}/contributors": { group: "corp-project", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/roles": { group: "corp-member", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/roles/history": { group: "corp-member", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/shareholders": { group: "corp-detail", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/standings": { group: "corp-member", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/starbases": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/starbases/{starbase_id}": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/structures": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/structures/skyhooks": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/structures/skyhooks/{skyhook_id}": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/structures/sovereignty-hubs": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/structures/sovereignty-hubs/{sovereignty_hub_id}": { group: "corp-structure", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/titles": { group: "corp-detail", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/wallets": { group: "corp-wallet", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/wallets/{division}/journal": { group: "corp-wallet", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:corporations/{corporation_id}/wallets/{division}/transactions": { group: "corp-wallet", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:cosmetics/skinr/{skinr_id}": { group: "skinr", maxTokens: 12e3, windowSizeMs: 9e5 },
+  "GET:fleets/{fleet_id}": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "PUT:fleets/{fleet_id}": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "GET:fleets/{fleet_id}/members": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "POST:fleets/{fleet_id}/members": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "PUT:fleets/{fleet_id}/members/{member_id}": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "DELETE:fleets/{fleet_id}/members/{member_id}": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "PUT:fleets/{fleet_id}/squads/{squad_id}": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "DELETE:fleets/{fleet_id}/squads/{squad_id}": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "GET:fleets/{fleet_id}/wings": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "POST:fleets/{fleet_id}/wings": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "PUT:fleets/{fleet_id}/wings/{wing_id}": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "DELETE:fleets/{fleet_id}/wings/{wing_id}": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "POST:fleets/{fleet_id}/wings/{wing_id}/squads": { group: "fleet", maxTokens: 1800, windowSizeMs: 9e5 },
+  "GET:freelance-jobs": { group: "freelance-job", maxTokens: 12e3, windowSizeMs: 9e5 },
+  "GET:freelance-jobs/{job_id}": { group: "freelance-job", maxTokens: 12e3, windowSizeMs: 9e5 },
+  "GET:fw/leaderboards": { group: "factional-warfare", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:fw/leaderboards/characters": { group: "factional-warfare", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:fw/leaderboards/corporations": { group: "factional-warfare", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:fw/stats": { group: "factional-warfare", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:fw/systems": { group: "factional-warfare", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:fw/wars": { group: "factional-warfare", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:incursions": { group: "incursion", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:industry/facilities": { group: "industry", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:industry/systems": { group: "industry", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:insurance/prices": { group: "insurance", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:killmails/{killmail_id}/{killmail_hash}": { group: "killmail", maxTokens: 3600, windowSizeMs: 9e5 },
+  "GET:markets/{region_id}/orders": { group: "market-order", maxTokens: 12e3, windowSizeMs: 9e5 },
+  "GET:meta/changelog": { group: "meta", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:meta/compatibility-dates": { group: "meta", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:meta/name": { group: "meta", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:meta/status": { group: "meta", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:military-campaigns": { group: "military-campaign", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:military-campaigns/{campaign_id}": { group: "military-campaign", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:military-campaigns/{campaign_id}/objectives": { group: "military-campaign", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:military-campaigns/{campaign_id}/objectives/{objective_id}": { group: "military-campaign", maxTokens: 300, windowSizeMs: 9e5 },
+  "GET:paragon-hub/skinr": { group: "paragon-hub", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:paragon-hub/skinr/alliances/{alliance_id}": { group: "char-paragon-hub", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:paragon-hub/skinr/characters/{character_id}": { group: "char-paragon-hub", maxTokens: 150, windowSizeMs: 9e5 },
+  "GET:paragon-hub/skinr/corporations/{corporation_id}": { group: "char-paragon-hub", maxTokens: 150, windowSizeMs: 9e5 },
+  "POST:route/{origin_system_id}/{destination_system_id}": { group: "routes", maxTokens: 3600, windowSizeMs: 9e5 },
+  "GET:skyhooks/raidable": { group: "activity", maxTokens: 30, windowSizeMs: 9e5 },
+  "GET:sovereignty/campaigns": { group: "sovereignty", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:sovereignty/systems": { group: "sovereignty", maxTokens: 600, windowSizeMs: 9e5 },
+  "GET:status": { group: "status", maxTokens: 600, windowSizeMs: 9e5 },
+  "POST:ui/autopilot/waypoint": { group: "ui", maxTokens: 900, windowSizeMs: 9e5 },
+  "POST:ui/openwindow/contract": { group: "ui", maxTokens: 900, windowSizeMs: 9e5 },
+  "POST:ui/openwindow/information": { group: "ui", maxTokens: 900, windowSizeMs: 9e5 },
+  "POST:ui/openwindow/marketdetails": { group: "ui", maxTokens: 900, windowSizeMs: 9e5 },
+  "POST:ui/openwindow/newmail": { group: "ui", maxTokens: 900, windowSizeMs: 9e5 },
+  "GET:wars": { group: "killmail", maxTokens: 3600, windowSizeMs: 9e5 },
+  "GET:wars/{war_id}": { group: "killmail", maxTokens: 3600, windowSizeMs: 9e5 },
+  "GET:wars/{war_id}/killmails": { group: "killmail", maxTokens: 3600, windowSizeMs: 9e5 }
+};
+
+// src/core/rateLimiter/RateLimiter.ts
+function getTokenCost(statusCode) {
+  if (statusCode >= 200 && statusCode < 300) return 2;
+  if (statusCode >= 300 && statusCode < 400) return 1;
+  if (statusCode >= 400 && statusCode < 500) return 5;
+  if (statusCode >= 500 && statusCode < 600) return 0;
+  return 2;
+}
+function retryAfterDeadline(value, now) {
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return now + parseInt(trimmed, 10) * 1e3;
+  if (!/[A-Za-z]/.test(trimmed)) return void 0;
+  const date = Date.parse(trimmed);
+  return Number.isNaN(date) ? void 0 : date;
+}
+var DEFAULT_WINDOW_MS = 9e5;
+var DEFAULT_ERROR_LIMIT = {
+  remain: 100,
+  reset: 0,
+  exhaustedUntil: 0
+};
+var RateLimiter = class _RateLimiter {
+  minDelayMs;
+  decelerationThreshold;
+  userKeyExtractor;
+  endpointOverrides;
+  lastRequestTime = 0;
+  minDelayChain = Promise.resolve();
+  isTestMode = false;
+  globalErrorLimit = { ...DEFAULT_ERROR_LIMIT };
+  defaultBuckets = /* @__PURE__ */ new Map();
+  userBuckets = null;
+  fallbackBucket;
+  lastCleanup = 0;
+  static CLEANUP_INTERVAL_MS = 6e4;
+  client = null;
+  /**
+   * Attach the client whose logger this limiter's warnings go to. Without
+   * one they go to the global logger (`setLogger`), then the pino default.
+   */
+  setClient(client) {
+    this.client = client;
+  }
+  constructor(config) {
+    this.minDelayMs = config?.minDelayMs ?? 50;
+    this.decelerationThreshold = config?.decelerationThreshold ?? 0.2;
+    this.userKeyExtractor = config?.userKeyExtractor;
+    this.endpointOverrides = config?.endpointOverrides ?? {};
+    if (this.userKeyExtractor) {
+      this.userBuckets = /* @__PURE__ */ new Map();
+    }
+    this.fallbackBucket = this.createFallbackBucket();
+  }
+  createFallbackBucket() {
+    return {
+      group: "__fallback__",
+      remaining: -1,
+      limit: 0,
+      used: 0,
+      windowSizeMs: DEFAULT_WINDOW_MS,
+      blockedUntil: 0,
+      lastUpdated: 0
+    };
+  }
+  createBucketFromSpec(spec) {
+    return {
+      group: spec.group,
+      remaining: spec.maxTokens,
+      limit: spec.maxTokens,
+      used: 0,
+      windowSizeMs: spec.windowSizeMs,
+      blockedUntil: 0,
+      lastUpdated: 0
+    };
+  }
+  createBucketForGroup(groupName) {
+    return {
+      group: groupName,
+      remaining: -1,
+      limit: 0,
+      used: 0,
+      windowSizeMs: DEFAULT_WINDOW_MS,
+      blockedUntil: 0,
+      lastUpdated: 0
+    };
+  }
+  lookupGroupSpec(method, templatePath) {
+    if (!templatePath || !method) return void 0;
+    const normalized = templatePath.replace(/\/$/, "").replace(/\{(\w+)\}/g, (_, name) => `{${camelToSnake(name)}}`);
+    const key = `${method}:${normalized}`;
+    const override = this.endpointOverrides[key];
+    if (override) {
+      return {
+        group: `endpoint:${key}`,
+        maxTokens: override.maxTokens,
+        windowSizeMs: override.windowSizeMs
+      };
+    }
+    return esiRateLimitGroups[key];
+  }
+  resolveUserSet(requestHeaders) {
+    if (!this.userBuckets || !this.userKeyExtractor || !requestHeaders) {
+      return null;
+    }
+    const userKey = this.userKeyExtractor(requestHeaders);
+    let userSet = this.userBuckets.get(userKey);
+    if (!userSet) {
+      userSet = {
+        groups: /* @__PURE__ */ new Map(),
+        errorLimit: { ...DEFAULT_ERROR_LIMIT },
+        lastAccessed: Date.now()
+      };
+      this.userBuckets.set(userKey, userSet);
+    }
+    userSet.lastAccessed = Date.now();
+    return userSet;
+  }
+  resolveBucketMap(requestHeaders) {
+    const userSet = this.resolveUserSet(requestHeaders);
+    return userSet ? userSet.groups : this.defaultBuckets;
+  }
+  resolveErrorLimit(requestHeaders) {
+    const userSet = this.resolveUserSet(requestHeaders);
+    return userSet ? userSet.errorLimit : this.globalErrorLimit;
+  }
+  getBucket(templatePath, method, requestHeaders, groupNameOverride) {
+    const bucketMap = this.resolveBucketMap(requestHeaders);
+    const spec = this.lookupGroupSpec(method, templatePath);
+    const groupName = groupNameOverride ?? spec?.group;
+    if (!groupName) return this.fallbackBucket;
+    let bucket = bucketMap.get(groupName);
+    if (!bucket) {
+      bucket = spec ? this.createBucketFromSpec(spec) : this.createBucketForGroup(groupName);
+      bucketMap.set(groupName, bucket);
+    }
+    return bucket;
+  }
+  cleanupStaleUsers() {
+    if (!this.userBuckets) return;
+    const now = Date.now();
+    if (now - this.lastCleanup < _RateLimiter.CLEANUP_INTERVAL_MS) return;
+    this.lastCleanup = now;
+    for (const [userKey, userSet] of this.userBuckets) {
+      if (now - userSet.lastAccessed > DEFAULT_WINDOW_MS) {
+        this.userBuckets.delete(userKey);
+      }
+    }
+  }
+  updateFromResponse(headers, statusCode, templatePath, method, requestHeaders) {
+    if (this.isTestMode) return;
+    const now = Date.now();
+    const responseGroup = headers["x-ratelimit-group"] || void 0;
+    const bucket = this.getBucket(
+      templatePath,
+      method,
+      requestHeaders,
+      responseGroup
+    );
+    if ("x-ratelimit-remaining" in headers) {
+      bucket.remaining = parseInt(headers["x-ratelimit-remaining"], 10);
+    }
+    if ("x-ratelimit-limit" in headers) {
+      bucket.limit = parseInt(headers["x-ratelimit-limit"], 10);
+    }
+    if ("x-ratelimit-used" in headers) {
+      bucket.used = parseInt(headers["x-ratelimit-used"], 10);
+    }
+    bucket.lastUpdated = now;
+    if ("retry-after" in headers) {
+      const until = retryAfterDeadline(headers["retry-after"], now);
+      if (until !== void 0) bucket.blockedUntil = until;
+    }
+    if (statusCode === 420 || statusCode === 429) {
+      if (bucket.blockedUntil <= now) {
+        bucket.blockedUntil = now + 6e4;
+      }
+    }
+    const errorLimit = this.resolveErrorLimit(requestHeaders);
+    const reportedRemain = "x-esi-error-limit-remain" in headers ? parseInt(headers["x-esi-error-limit-remain"], 10) : void 0;
+    if (reportedRemain !== void 0 && reportedRemain > 0 && errorLimit.remain <= 0 && now < errorLimit.exhaustedUntil) {
+      return;
+    }
+    if (reportedRemain !== void 0) {
+      errorLimit.remain = reportedRemain;
+    }
+    if ("x-esi-error-limit-reset" in headers) {
+      errorLimit.reset = parseInt(headers["x-esi-error-limit-reset"], 10);
+    }
+    if (reportedRemain !== void 0 && reportedRemain <= 0) {
+      errorLimit.exhaustedUntil = now + errorLimit.reset * 1e3;
+    }
+  }
+  updateRateLimitInfo(headers) {
+    this.updateFromResponse(headers, 200);
+  }
+  async checkRateLimit(templatePath, method, requestHeaders) {
+    if (this.isTestMode) return;
+    this.cleanupStaleUsers();
+    let stillBlockedBucket;
+    for (let i = 0; i < 10; i++) {
+      const bucket2 = this.getBucket(templatePath, method, requestHeaders);
+      const now = Date.now();
+      if (bucket2.blockedUntil <= now) {
+        stillBlockedBucket = void 0;
+        break;
+      }
+      stillBlockedBucket = bucket2;
+      const waitedUntil = bucket2.blockedUntil;
+      const waitTime = waitedUntil - now;
+      logWarn2(
+        this.client,
+        `[ESI Rate Limit] Group '${bucket2.group}' blocked for ${Math.ceil(waitTime / 1e3)}s (420/429 received)`,
+        { group: bucket2.group, waitMs: waitTime }
+      );
+      await sleep(waitTime);
+      if (bucket2.blockedUntil <= waitedUntil) {
+        bucket2.blockedUntil = 0;
+      }
+    }
+    if (stillBlockedBucket && stillBlockedBucket.blockedUntil > Date.now()) {
+      const waitTime = stillBlockedBucket.blockedUntil - Date.now();
+      logWarn2(
+        this.client,
+        `[ESI Rate Limit] Group '${stillBlockedBucket.group}' still blocked after retry budget exhausted; aborting request instead of sending while blocked`,
+        { group: stillBlockedBucket.group }
+      );
+      throw new EsiError(
+        429,
+        `Rate limit group '${stillBlockedBucket.group}' still blocked for ${Math.ceil(waitTime / 1e3)}s`
+      );
+    }
+    const errorLimit = this.resolveErrorLimit(requestHeaders);
+    if (errorLimit.remain <= 10 && errorLimit.remain > 0) {
+      const resetMs = errorLimit.reset * 1e3;
+      const delay = Math.min(resetMs, 5e3);
+      if (delay > 0) {
+        logWarn2(
+          this.client,
+          `[ESI Rate Limit] Legacy error limit low (${errorLimit.remain}), waiting ${delay}ms`,
+          { errorLimitRemain: errorLimit.remain }
+        );
+        await sleep(delay);
+      }
+    } else if (errorLimit.remain <= 0 && errorLimit.reset > 0) {
+      const waitTime = errorLimit.reset * 1e3;
+      logWarn2(
+        this.client,
+        `[ESI Rate Limit] Legacy error limit exhausted, waiting ${Math.ceil(waitTime / 1e3)}s`,
+        { errorLimitReset: errorLimit.reset }
+      );
+      await sleep(waitTime);
+    }
+    const bucket = this.getBucket(templatePath, method, requestHeaders);
+    if (bucket.remaining >= 0 && bucket.limit > 0) {
+      const ratio = bucket.remaining / bucket.limit;
+      if (bucket.remaining <= 0) {
+        logWarn2(
+          this.client,
+          `[ESI Rate Limit] Group '${bucket.group}' token bucket empty, waiting 1s`,
+          { group: bucket.group }
+        );
+        await sleep(1e3);
+      } else if (ratio <= this.decelerationThreshold) {
+        const extraDelay = Math.ceil(
+          (1 - ratio / this.decelerationThreshold) * 1e3
+        );
+        await sleep(extraDelay);
+      }
+    }
+    await this.enforceMinDelay();
+  }
+  /**
+   * Serializes min-delay waits so concurrent callers cannot all read the same
+   * lastRequestTime and fire together after sleeping.
+   */
+  async enforceMinDelay() {
+    if (this.isTestMode) {
+      this.lastRequestTime = Date.now();
+      return;
+    }
+    const run = async () => {
+      const now = Date.now();
+      const timeSinceLastRequest = now - this.lastRequestTime;
+      if (timeSinceLastRequest < this.minDelayMs) {
+        await sleep(this.minDelayMs - timeSinceLastRequest);
+      }
+      this.lastRequestTime = Date.now();
+    };
+    const scheduled = this.minDelayChain.then(run, run);
+    this.minDelayChain = scheduled.then(
+      () => void 0,
+      () => void 0
+    );
+    await scheduled;
+  }
+  getStatus() {
+    let worstBucket = this.fallbackBucket;
+    let worstRatio = Infinity;
+    const checkBucket = (bucket) => {
+      if (bucket.limit > 0) {
+        const ratio = bucket.remaining / bucket.limit;
+        if (ratio < worstRatio) {
+          worstRatio = ratio;
+          worstBucket = bucket;
+        }
+      }
+    };
+    for (const bucket of this.defaultBuckets.values()) {
+      checkBucket(bucket);
+    }
+    if (this.userBuckets) {
+      for (const userSet of this.userBuckets.values()) {
+        for (const bucket of userSet.groups.values()) {
+          checkBucket(bucket);
+        }
+      }
+    }
+    return {
+      remaining: worstBucket.remaining,
+      limit: worstBucket.limit,
+      used: worstBucket.used,
+      group: worstBucket.group === "__fallback__" ? null : worstBucket.group,
+      errorLimitRemain: this.globalErrorLimit.remain,
+      errorLimitReset: this.globalErrorLimit.reset,
+      retryAfter: worstBucket.blockedUntil > Date.now() ? Math.ceil((worstBucket.blockedUntil - Date.now()) / 1e3) : null,
+      blockedUntil: worstBucket.blockedUntil
+    };
+  }
+  getGroupStatus(group) {
+    const bucket = this.defaultBuckets.get(group);
+    if (!bucket) return void 0;
+    return {
+      group: bucket.group,
+      remaining: bucket.remaining,
+      limit: bucket.limit,
+      used: bucket.used,
+      windowSizeMs: bucket.windowSizeMs,
+      blockedUntil: bucket.blockedUntil
+    };
+  }
+  getAllGroupStatuses() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [name, bucket] of this.defaultBuckets) {
+      result.set(name, {
+        group: bucket.group,
+        remaining: bucket.remaining,
+        limit: bucket.limit,
+        used: bucket.used,
+        windowSizeMs: bucket.windowSizeMs,
+        blockedUntil: bucket.blockedUntil
+      });
+    }
+    return result;
+  }
+  static getTokenCost(statusCode) {
+    return getTokenCost(statusCode);
+  }
+  isBlocked(group) {
+    const now = Date.now();
+    if (group) {
+      const bucket = this.defaultBuckets.get(group);
+      return bucket ? bucket.blockedUntil > now : false;
+    }
+    if (this.fallbackBucket.blockedUntil > now) return true;
+    for (const bucket of this.defaultBuckets.values()) {
+      if (bucket.blockedUntil > now) return true;
+    }
+    return false;
+  }
+  setTestMode(enabled) {
+    this.isTestMode = enabled;
+  }
+  reset() {
+    this.defaultBuckets.clear();
+    if (this.userBuckets) this.userBuckets.clear();
+    this.fallbackBucket = this.createFallbackBucket();
+    this.globalErrorLimit = { ...DEFAULT_ERROR_LIMIT };
+    this.lastRequestTime = 0;
+    this.minDelayChain = Promise.resolve();
+    this.lastCleanup = 0;
+  }
+};
+
+// src/core/RequestDeduplicator.ts
+var RequestDeduplicator = class {
+  inflight = /* @__PURE__ */ new Map();
+  client = null;
+  setClient(client) {
+    this.client = client;
+  }
+  async dedupe(key, execute) {
+    const existing = this.inflight.get(key);
+    if (existing) {
+      if (this.client) {
+        logDebug2(this.client, `[Dedup] Coalescing request: ${key}`);
+      }
+      return existing;
+    }
+    const promise = execute().finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /**
+   * Drop the in-flight entries whose key contains `pathSegment`, so a call
+   * made after a write cannot join a request sent before it.
+   *
+   * The requests themselves keep running and whoever already joined them still
+   * gets their answer. Only the map entry goes, which is what new callers look
+   * in. Matching is `includes`, the same rule ETagCacheManager.deleteByPath
+   * uses, so one written path invalidates the cache and detaches the reads of
+   * it by the same test.
+   */
+  detachByPath(pathSegment) {
+    let count = 0;
+    for (const key of this.inflight.keys()) {
+      if (key.includes(pathSegment)) {
+        this.inflight.delete(key);
+        count += 1;
+      }
+    }
+    if (count > 0 && this.client) {
+      logDebug2(
+        this.client,
+        `[Dedup] Detached ${count} in-flight request(s) matching ${pathSegment} after a write`
+      );
+    }
+    return count;
+  }
+  get pending() {
+    return this.inflight.size;
+  }
+  clear() {
+    this.inflight.clear();
+  }
+};
+
+// src/core/configureApiClient.ts
+function configureApiClient(client, config) {
+  let deduplicator = null;
+  if (config?.logger) {
+    client.setLogger(config.logger);
+  } else if (config?.logLevel) {
+    client.setLogger(createDefaultLogger(config.logLevel));
+  }
+  if (config?.tenant !== void 0) client.setTenant(config.tenant);
+  if (config?.userAgent !== void 0) client.setUserAgent(config.userAgent);
+  const rateLimiter = new RateLimiter(config?.rateLimiterConfig);
+  rateLimiter.setClient(client);
+  client.setRateLimiter(rateLimiter);
+  if (config?.enableRequestDeduplication !== false) {
+    deduplicator = new RequestDeduplicator();
+    deduplicator.setClient(client);
+    client.setDeduplicator(deduplicator);
+  }
+  if (config?.enableETagCache !== false) {
+    const cache = new ETagCacheManager(config?.etagCacheConfig, client);
+    client.setCache(cache);
+  }
+  if (config?.enableCircuitBreaker) {
+    const cb = new CircuitBreaker(config.circuitBreakerConfig);
+    cb.setClient(client);
+    client.setCircuitBreaker(cb);
+  }
+  if (config?.retryConfig) {
+    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);
+  }
+  if (config?.requestInterceptors) {
+    for (const interceptor of config.requestInterceptors) {
+      client.addRequestInterceptor(interceptor);
+    }
+  }
+  if (config?.responseInterceptors) {
+    for (const interceptor of config.responseInterceptors) {
+      client.addResponseInterceptor(interceptor);
+    }
+  }
+  if (config?.validateResponse !== void 0) {
+    client.setValidateResponse(config.validateResponse);
+  }
+  if (config?.validateRequest !== void 0) {
+    client.setValidateRequest(config.validateRequest);
+  }
+  if (config?.timeout !== void 0) {
+    client.setTimeout(config.timeout);
+  }
+  return { deduplicator };
+}
+
+export {
+  validatePathParam,
+  validateBaseUrl,
+  validateQueryParam,
+  validateHeaderOption,
+  ApiClient,
+  characterIdOfToken,
+  redactingLogger,
+  createDefaultLogger,
+  toPinoLogger,
+  setLogger,
+  getLogger,
+  logFatal,
+  logError,
+  logWarn,
+  logInfo,
+  logDebug,
+  logTrace,
+  logWarn2,
+  logInfo2,
+  logDebug2,
+  USER_AGENT,
+  evictRejectedResponse,
+  CircuitBreaker,
+  RetryStrategy,
+  resolveCache,
+  parseWarning,
+  handleRequest,
+  fetchAllPages,
+  fetchPages,
+  ETagCacheManager,
+  RateLimiter,
+  RequestDeduplicator,
+  configureApiClient
+};
+//# sourceMappingURL=chunk-KIY3XA5Q.mjs.map