playlist-data-engine 1.5.8 → 1.6.0

package/dist/arweaveGatewayManager-BKUZ1Klm.js

@@ -0,0 +1,1415 @@
+var N = /* @__PURE__ */ ((f) => (f[f.DEBUG = 0] = "DEBUG", f[f.INFO = 1] = "INFO", f[f.WARN = 2] = "WARN", f[f.ERROR = 3] = "ERROR", f[f.NONE = 4] = "NONE", f))(N || {});
+const I = {
+  0: "DEBUG",
+  1: "INFO",
+  2: "WARN",
+  3: "ERROR",
+  4: "NONE"
+};
+let G = 1, U = !0, _ = !0, C = null, E = !1, S = !1;
+class D {
+  /**
+   * Create a logger instance with a specific context (usually the class/module name)
+   * @param context - The context name to prefix log messages (e.g., 'WeatherAPIClient')
+   */
+  constructor(e) {
+    this.context = e;
+  }
+  /**
+   * Create a named logger for a specific class or module
+   * @param context - The context name (e.g., 'WeatherAPIClient', 'EnvironmentalSensors')
+   * @returns A Logger instance configured with the given context
+   */
+  static for(e) {
+    return new D(e);
+  }
+  /**
+   * Enable diagnostic mode
+   * Sets log level to DEBUG for maximum verbosity
+   */
+  static enableDiagnosticMode() {
+    E = !0, G = 0;
+  }
+  /**
+   * Disable diagnostic mode
+   * Resets log level to INFO
+   */
+  static disableDiagnosticMode() {
+    E = !1, G = 1;
+  }
+  /**
+   * Check if diagnostic mode is enabled
+   * @returns True if diagnostic mode is active
+   */
+  static isDiagnosticMode() {
+    return E;
+  }
+  /**
+   * Enable verbose logging mode
+   * Sets log level to DEBUG for increased output verbosity
+   * This is a convenience method equivalent to Logger.setLevel(LogLevel.DEBUG)
+   * @example
+   * Logger.enableVerbose();
+   * // All debug messages will now be logged
+   */
+  static enableVerbose() {
+    S = !0, G = 0;
+  }
+  /**
+   * Disable verbose logging mode
+   * Resets log level to INFO (default)
+   * @example
+   * Logger.disableVerbose();
+   * // Only INFO and above will be logged
+   */
+  static disableVerbose() {
+    S = !1, G = 1;
+  }
+  /**
+   * Check if verbose mode is enabled
+   * @returns True if verbose mode is active
+   */
+  static isVerbose() {
+    return S;
+  }
+  /**
+   * Set verbose mode on or off
+   * @param enabled - Whether to enable verbose logging
+   * @example
+   * Logger.setVerbose(true);  // Enable verbose logging
+   * Logger.setVerbose(false); // Disable verbose logging
+   */
+  static setVerbose(e) {
+    S = e, G = e ? 0 : 1;
+  }
+  /**
+   * Set the global log level
+   * @param level - The minimum log level to display
+   */
+  static setLevel(e) {
+    G = e;
+  }
+  /**
+   * Get the current global log level
+   * @returns The current log level
+   */
+  static getLevel() {
+    return G;
+  }
+  /**
+   * Configure the logger globally
+   * @param config - Logger configuration options
+   */
+  static configure(e) {
+    e.level !== void 0 && (G = e.level), e.includeTimestamp !== void 0 && (U = e.includeTimestamp), e.includeContext !== void 0 && (_ = e.includeContext), e.customHandler !== void 0 && (C = e.customHandler);
+  }
+  /**
+   * Reset logger to default configuration
+   */
+  static reset() {
+    G = 1, U = !0, _ = !0, C = null, E = !1, S = !1;
+  }
+  /**
+   * Log a debug message (most verbose)
+   * @param message - The log message
+   * @param data - Optional data to include
+   */
+  debug(e, t) {
+    this.log(0, e, t);
+  }
+  /**
+   * Log an info message (general operational info)
+   * @param message - The log message
+   * @param data - Optional data to include
+   */
+  info(e, t) {
+    this.log(1, e, t);
+  }
+  /**
+   * Log a warning message (potential issues)
+   * @param message - The log message
+   * @param data - Optional data to include
+   */
+  warn(e, t) {
+    this.log(2, e, t);
+  }
+  /**
+   * Log an error message (errors that need attention)
+   * @param message - The log message
+   * @param data - Optional error or data to include
+   */
+  error(e, t) {
+    this.log(3, e, t);
+  }
+  /**
+   * Internal logging method
+   */
+  log(e, t, s) {
+    if (e < G)
+      return;
+    const a = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level: e,
+      context: this.context,
+      message: t,
+      data: s
+    };
+    if (C) {
+      C(a);
+      return;
+    }
+    const r = this.formatMessage(a);
+    switch (e) {
+      case 0:
+        s !== void 0 ? console.debug(r, s) : console.debug(r);
+        break;
+      case 1:
+        s !== void 0 ? console.info(r, s) : console.info(r);
+        break;
+      case 2:
+        s !== void 0 ? console.warn(r, s) : console.warn(r);
+        break;
+      case 3:
+        s !== void 0 ? console.error(r, s) : console.error(r);
+        break;
+    }
+  }
+  /**
+   * Format a log entry into a string
+   */
+  formatMessage(e) {
+    const t = [];
+    return U && t.push(this.formatTimestamp(e.timestamp)), t.push(`[${I[e.level]}]`), _ && e.context && t.push(`[${e.context}]`), t.push(e.message), t.join(" ");
+  }
+  /**
+   * Format a timestamp for log output
+   */
+  formatTimestamp(e) {
+    const t = e.getHours().toString().padStart(2, "0"), s = e.getMinutes().toString().padStart(2, "0"), a = e.getSeconds().toString().padStart(2, "0"), r = e.getMilliseconds().toString().padStart(3, "0");
+    return `${t}:${s}:${a}.${r}`;
+  }
+}
+function V(f) {
+  return D.for(f);
+}
+const O = [
+  { host: "arweave.net", protocol: "https", priority: 3 },
+  { host: "ardrive.net", protocol: "https", priority: 2 },
+  { host: "turbo-gateway.com", protocol: "https", priority: 1 }
+], M = [
+  "arweave.net",
+  "arweave.dev",
+  "www.arweave.net",
+  "ardrive.net",
+  "turbo-gateway.com",
+  "irys.xyz",
+  "ar-io.dev",
+  "ar-io.net",
+  "arweave.rocks",
+  "g8way.io"
+];
+function A(f) {
+  if (!f || typeof f != "string")
+    return !1;
+  if (f.startsWith("ar://"))
+    return !0;
+  const e = f.toLowerCase();
+  try {
+    const t = new URL(f).hostname;
+    return M.some(
+      (s) => t === s || t.endsWith("." + s)
+    );
+  } catch {
+    return M.some((t) => e.includes(t));
+  }
+}
+function T(f) {
+  if (!f || typeof f != "string" || !A(f))
+    return null;
+  let e = null, t = "";
+  if (f.startsWith("ar://")) {
+    const l = f.slice(5), i = l.indexOf("/");
+    return i !== -1 ? (e = l.slice(0, i), t = l.slice(i)) : e = l, e.length === 43 && /^[A-Za-z0-9_-]+$/.test(e) ? { txId: e, originalUrl: f, pathSuffix: t } : null;
+  }
+  let s = f;
+  try {
+    const l = new URL(f);
+    s = l.pathname + l.search;
+  } catch {
+  }
+  const a = /[A-Za-z0-9_-]{43}/g, r = s.match(a);
+  if (r && r.length > 0) {
+    e = r[0];
+    const l = f.indexOf(e);
+    if (l !== -1) {
+      const i = f.slice(l + 43), c = Math.min(
+        i.indexOf("?") === -1 ? 1 / 0 : i.indexOf("?"),
+        i.indexOf("#") === -1 ? 1 / 0 : i.indexOf("#")
+      );
+      c === 1 / 0 ? t = i : t = i.slice(0, c);
+    }
+    return { txId: e, originalUrl: f, pathSuffix: t };
+  }
+  return null;
+}
+function k(f, e, t = "") {
+  return `${e.protocol || "https"}://${e.host}/${f}${t}`;
+}
+function j(f, e = O, t = "") {
+  return e.sort((s, a) => s.priority - a.priority).map((s) => k(f, s, t));
+}
+async function $() {
+  try {
+    return await import("@ar.io/wayfinder-core");
+  } catch {
+    return null;
+  }
+}
+async function x() {
+  try {
+    return await import("@ar.io/sdk");
+  } catch {
+    return null;
+  }
+}
+const z = "https://solana-rpc.publicnode.com", B = 5e3, Y = 864e5, H = "arweave_active_gateway", L = "arweave_ranked_gateways";
+class K {
+  constructor(e) {
+    this.cache = /* @__PURE__ */ new Map(), this.logger = D.for("ArweaveGateway"), this.hitCount = 0, this.missCount = 0, this.healthData = /* @__PURE__ */ new Map(), this.originalPriorities = /* @__PURE__ */ new Map(), this.MAX_HEALTH_RECORDS = 50, this.inflightResolves = /* @__PURE__ */ new Map(), this.inflightControllers = /* @__PURE__ */ new Map(), this.wayfinder = null, this.wayfinderGatewaysProvider = null, this.rankedGatewaysCache = null, this.rankedGatewaysCacheTimestamp = 0, this.RANKED_GATEWAYS_TTL_MS = 1440 * 60 * 1e3, this.activeGateway = null, this.lastFetchTiming = 0, this.consecutiveSlowResponses = 0, this.gateways = (e?.gateways ?? O).map((s) => ({ ...s })), this.timeout = e?.timeout ?? B, this.cacheTTL = e?.cacheTTL ?? Y, this.slowResponseThreshold = e?.slowResponseThreshold ?? 8e3, this.maxSlowResponses = e?.maxSlowResponses ?? 3, this.solanaRpcUrl = e?.solanaRpcUrl ?? z, this.hasCustomSolanaRpc = typeof e?.solanaRpcUrl == "string" && e.solanaRpcUrl.length > 0, this.wayfinderSortBy = e?.wayfinderSortBy ?? "weights.compositeWeight", this.wayfinderPrimaryLimit = e?.wayfinderPrimaryLimit ?? 50, this.wayfinderFallbackLimit = e?.wayfinderFallbackLimit ?? 100, this.wayfinderStrategy = e?.wayfinderStrategy ?? "composite-ping-random", this.gateways.sort((s, a) => s.priority - a.priority), this.gateways.forEach((s) => {
+      this.originalPriorities.set(s.host, s.priority);
+    }), this.activeGateway = this.loadPersistedGateway();
+    const t = this.loadPersistedRankedGateways();
+    t && (this.rankedGatewaysCache = t), Promise.all([$(), x(), import("./index.browser-CVv08iVS.js")]).then(([s, a, r]) => {
+      if (s && a)
+        try {
+          const {
+            FastestPingRoutingStrategy: l,
+            RandomRoutingStrategy: i,
+            CompositeRoutingStrategy: c,
+            RoundRobinRoutingStrategy: n,
+            NetworkGatewaysProvider: y
+          } = s, w = a.ARIO, o = r.createSolanaRpc(this.solanaRpcUrl), g = w.init({ rpc: o }), h = this.wrapProviderWithCache(
+            new y({
+              ario: g,
+              sortBy: this.wayfinderSortBy,
+              limit: this.wayfinderPrimaryLimit
+            })
+          ), u = this.wrapProviderWithCache(
+            new y({
+              ario: g,
+              sortBy: this.wayfinderSortBy,
+              limit: this.wayfinderFallbackLimit
+            })
+          );
+          this.wayfinderGatewaysProvider = h;
+          const d = (() => {
+            switch (this.wayfinderStrategy) {
+              case "random-only":
+                return new i({ gatewaysProvider: u });
+              case "ping-only":
+                return new l({ timeoutMs: 3e3, gatewaysProvider: h });
+              case "round-robin":
+                return new n({ gateways: [], gatewaysProvider: h });
+              default:
+                return new c({
+                  strategies: [
+                    new l({ timeoutMs: 3e3, gatewaysProvider: h }),
+                    new i({ gatewaysProvider: u })
+                  ]
+                });
+            }
+          })();
+          this.wayfinder = s.createWayfinderClient({ routingStrategy: d }), this.logger.info("Wayfinder client initialized", {
+            strategy: this.wayfinderStrategy,
+            sortBy: this.wayfinderSortBy,
+            primaryLimit: this.wayfinderPrimaryLimit,
+            fallbackLimit: this.wayfinderFallbackLimit
+          });
+        } catch (l) {
+          this.logger.warn("Failed to configure Wayfinder routing strategy, using defaults", { error: l }), this.wayfinder = s.createWayfinderClient(), this.logger.info("Wayfinder client initialized with default routing");
+        }
+      else s && (this.wayfinder = s.createWayfinderClient(), this.logger.info("Wayfinder client initialized with default routing (SDK unavailable)"));
+    }).catch(() => {
+      this.logger.debug("Wayfinder client initialization failed, using static gateways");
+    }), this.logger.info("Gateway manager initialized", {
+      gateways: this.gateways.map((s) => s.host),
+      timeout: this.timeout,
+      cacheTTL: this.cacheTTL,
+      activeGateway: this.activeGateway?.host ?? null
+    });
+  }
+  /**
+   * Wrap a promise with a timeout to prevent hanging indefinitely.
+   * Useful for third-party calls (e.g., Wayfinder) that have no built-in timeout.
+   */
+  withTimeout(e, t, s) {
+    return new Promise((a, r) => {
+      const l = setTimeout(() => r(new Error(s)), t);
+      e.then(
+        (i) => {
+          clearTimeout(l), a(i);
+        },
+        (i) => {
+          clearTimeout(l), r(i);
+        }
+      );
+    });
+  }
+  /**
+   * Wrap a raw upstream gateways provider (NetworkGatewaysProvider) in a
+   * long-TTL cache. This is the single lever that keeps us off the Solana
+   * RPC (Helius): every Wayfinder routing strategy and the ranked walk in
+   * tryWayfinder() read through this wrapper, so the upstream is queried at
+   * most once per RANKED_GATEWAYS_TTL_MS regardless of how many resolves fail.
+   *
+   * Behaviour:
+   *   - Fresh cache → return immediately, no network.
+   *   - Cache miss → one upstream fetch; concurrent callers share the in-flight
+   *     promise (dedupe) so we never fire two fetches for the same refresh.
+   *   - Fetch fails → serve the stale in-memory list if present (better than
+   *     empty); otherwise let the upstream's [] fall through. This keeps a
+   *     Helius rate-limit blip from restarting the hammering.
+   *   - On success → write to both in-memory cache and localStorage so the
+   *     list survives reloads.
+   */
+  wrapProviderWithCache(e) {
+    let t = null, s = 0, a = null;
+    const r = () => t !== null && t.length > 0 && Date.now() < s, i = this.loadPersistedRankedGateways();
+    return i && i.length > 0 && (t = i, s = (this.rankedGatewaysCacheTimestamp || Date.now()) + this.RANKED_GATEWAYS_TTL_MS), {
+      getGateways: async () => r() ? t : a || (a = (async () => {
+        try {
+          const c = await e.getGateways();
+          return c && c.length > 0 && (t = c, s = Date.now() + this.RANKED_GATEWAYS_TTL_MS, this.rankedGatewaysCacheTimestamp = Date.now(), this.rankedGatewaysCache = c, this.persistRankedGateways(c, this.rankedGatewaysCacheTimestamp)), c;
+        } catch (c) {
+          if (this.logger.warn("Ranked gateway fetch failed, serving stale list", { error: c }), t && t.length > 0) return t;
+          throw c;
+        } finally {
+          a = null;
+        }
+      })(), a)
+    };
+  }
+  /**
+   * Resolve an Arweave URL to a gateway URL using the active gateway, with no network checks.
+   *
+   * This is the fast path — it returns instantly by reusing the current active gateway
+   * (or arweave.net if none is set). Use this for the hot path where latency matters.
+   * When real fetches fail, call {@link reportGatewayFailure} to trigger gateway rotation.
+   *
+   * @param url - The URL to resolve
+   * @returns A gateway URL constructed from the active gateway, or the original URL if not Arweave
+   */
+  resolveUrlSimple(e) {
+    if (!A(e)) return e;
+    const t = T(e);
+    if (!t) return e;
+    const s = this.activeGateway ?? this.gateways[0];
+    return this.logger.debug("[gateway] resolveUrlSimple", {
+      txId: t.txId,
+      gateway: s.host,
+      pathSuffix: t.pathSuffix || void 0
+    }), k(t.txId, s, t.pathSuffix);
+  }
+  /**
+   * Set a preferred gateway by host name.
+   *
+   * If the host is in the known gateways list, it becomes the active gateway
+   * and is persisted to localStorage. Returns true on success.
+   *
+   * @param host - Gateway hostname (e.g. 'ardrive.net')
+   * @returns True if the gateway was found and set, false otherwise
+   */
+  setPreferredGateway(e) {
+    const t = this.gateways.find((s) => s.host === e);
+    return t ? (this.activeGateway = t, this.lastFetchTiming = 0, this.consecutiveSlowResponses = 0, this.persistGateway(t), this.logger.info("Preferred gateway set", { host: e }), !0) : (this.logger.warn("Cannot set preferred gateway — not in gateway list", {
+      host: e,
+      available: this.gateways.map((s) => s.host)
+    }), !1);
+  }
+  /**
+   * Clear the preferred/active gateway.
+   *
+   * Removes the active gateway, clears the persisted gateway from localStorage,
+   * and clears the cache. The next resolveUrl() call will re-discover the best gateway.
+   */
+  clearPreferredGateway() {
+    this.activeGateway = null, this.lastFetchTiming = 0, this.consecutiveSlowResponses = 0, this.clearPersistedGateway(), this.cache.clear(), this.logger.info("Preferred gateway cleared, will re-discover on next resolve");
+  }
+  /**
+   * Get a diagnostic snapshot of the gateway manager's current state.
+   *
+   * Useful for debugging and console inspection.
+   *
+   * @returns Current gateway manager diagnostics
+   */
+  getDiagnostics() {
+    const e = this.gateways.map((t) => {
+      const s = this.healthData.get(t.host) ?? [], a = s.length, r = a > 0 ? Math.round(s.reduce((i, c) => i + c.responseTime, 0) / a) : 0, l = a > 0 ? s.filter((i) => i.success).length / a : 1;
+      return { host: t.host, avgMs: r, successRate: Math.round(l * 100) / 100, checks: a };
+    });
+    return {
+      activeGateway: this.activeGateway?.host ?? null,
+      activeGatewayAge: null,
+      // not tracked currently — could add timestamp later
+      availableGateways: this.gateways.map((t) => t.host),
+      lastFetchTiming: this.lastFetchTiming,
+      consecutiveSlowResponses: this.consecutiveSlowResponses,
+      healthSummary: e
+    };
+  }
+  /**
+   * Resolve an Arweave URL to a working gateway URL.
+   *
+   * Strategy: try static gateways first with real fetch checks (not HEAD),
+   * fall back to Wayfinder only if all static gateways fail.
+   *
+   * @param url - The URL to resolve
+   * @param options - Optional resolve options (signal, bypassArweaveNet, bypassWayfinder)
+   * @returns A working URL (or original URL if all gateways fail or signal is aborted)
+   */
+  async resolveUrl(e, t) {
+    const s = t?.signal;
+    if (s?.aborted)
+      return this.logger.debug("resolveUrl called with already-aborted signal, returning original URL"), e;
+    if (!A(e))
+      return e;
+    const a = T(e);
+    if (!a)
+      return this.logger.warn("Failed to parse Arweave URL, returning original", { url: e }), e;
+    const { txId: r, pathSuffix: l } = a, i = this.getCachedGateway(r);
+    if (i) {
+      this.hitCount++;
+      const o = k(r, i, l);
+      return this.logger.debug("Cache hit for txId", { txId: r, gateway: i.host, pathSuffix: l }), o;
+    }
+    const c = this.activeGateway?.host ?? "none";
+    this.consecutiveSlowResponses >= this.maxSlowResponses && (this.logger.warn("Proactive gateway rotation triggered", {
+      slowCount: this.consecutiveSlowResponses,
+      threshold: this.maxSlowResponses,
+      previousGateway: c
+    }), this.activeGateway = null, this.consecutiveSlowResponses = 0, this.clearPersistedGateway(), this.cache.clear());
+    const n = this.inflightResolves.get(r);
+    if (n)
+      return this.logger.debug("Reusing in-flight resolve for txId", { txId: r }), n;
+    const y = new AbortController();
+    s && s.addEventListener("abort", () => y.abort(), { once: !0 });
+    const w = this.resolveGatewayChain(e, r, l, y.signal, t).finally(() => {
+      this.inflightResolves.delete(r), this.inflightControllers.delete(r);
+    });
+    return this.inflightResolves.set(r, w), this.inflightControllers.set(r, y), w;
+  }
+  /**
+   * The actual gateway fallback chain. Extracted from resolveUrl() for
+   * request deduplication — concurrent callers for the same txId share
+   * one instance of this chain.
+   */
+  async resolveGatewayChain(e, t, s, a, r) {
+    const l = Date.now(), i = r?.bypassArweaveNet ?? !1;
+    let c = null, n = null;
+    if (e.startsWith("https://") || e.startsWith("http://"))
+      try {
+        const u = new URL(e), d = {
+          host: u.host,
+          // includes port if present
+          protocol: u.protocol.replace(":", ""),
+          priority: 0
+        }, m = Date.now(), p = await this.checkAndSetGateway(e, t, s, d, a), R = Date.now() - m;
+        if (p) {
+          if (this.logger.info(`[gateway] Step 0 (original): ${p.kind}`, { host: d.host, ms: R, totalMs: Date.now() - l }), p.kind === "verified") return p.url;
+          n ??= p.url;
+        } else
+          this.logger.info("[gateway] Step 0 (original): failed", { host: d.host, ms: R });
+        c = d.host;
+      } catch {
+      }
+    if (this.activeGateway && this.activeGateway.host !== c) {
+      const u = Date.now(), d = await this.checkAndSetGateway(e, t, s, this.activeGateway, a), m = Date.now() - u;
+      if (d) {
+        if (this.logger.info(`[gateway] Step 1 (persisted): ${d.kind}`, { host: this.activeGateway.host, ms: m, totalMs: Date.now() - l }), d.kind === "verified") return d.url;
+        n ??= d.url;
+      } else
+        this.logger.info("[gateway] Step 1 (persisted): failed, clearing", { ms: m }), this.activeGateway = null, this.clearPersistedGateway();
+    }
+    if (!i && c !== "arweave.net") {
+      const u = this.gateways.find((d) => d.host === "arweave.net");
+      if (u) {
+        const d = Date.now(), m = await this.checkAndSetGateway(e, t, s, u, a), p = Date.now() - d;
+        if (m) {
+          if (this.logger.info(`[gateway] Step 2 (arweave.net): ${m.kind}`, { ms: p, totalMs: Date.now() - l }), m.kind === "verified") return m.url;
+          n ??= m.url;
+        } else
+          this.logger.info("[gateway] Step 2 (arweave.net): failed", { ms: p });
+      }
+    }
+    const y = Date.now(), w = await this.tryFallbackGateways(e, t, s, a, c), o = Date.now() - y;
+    if (w) {
+      if (this.logger.info(`[gateway] Step 3 (fallbacks): ${w.kind}`, { ms: o, totalMs: Date.now() - l }), w.kind === "verified") return w.url;
+      n ??= w.url;
+    } else
+      this.logger.info("[gateway] Step 3 (fallbacks): failed", { ms: o });
+    const g = !this.hasCustomSolanaRpc, h = r?.bypassWayfinder ?? g;
+    if (this.wayfinder && !h) {
+      const u = Date.now();
+      this.logger.info("[gateway] Step 4 (wayfinder): trying");
+      const d = await this.tryWayfinder(t, s, a, c), m = Date.now() - u;
+      if (d) {
+        if (this.logger.info(`[gateway] Step 4 (wayfinder): ${d.kind}`, { ms: m, totalMs: Date.now() - l }), d.kind === "verified") return d.url;
+        n ??= d.url;
+      } else
+        this.logger.info("[gateway] Step 4 (wayfinder): failed", { ms: m });
+    }
+    return n ? (this.logger.warn("No gateway verified, returning best maybe-result", { txId: t, pathSuffix: s, maybeUrl: n }), n) : (this.logger.warn("All gateways (arweave.net + Wayfinder + fallbacks) failed, returning original URL", { txId: t, pathSuffix: s, originalUrl: e }), e);
+  }
+  /**
+   * Report that the active gateway failed a real fetch.
+   *
+   * Call this when the URL returned by resolveUrl() actually fails to load
+   * (e.g. fetch() returns a 4xx/5xx or throws). This clears the active gateway
+   * and finds a new one, persisting the result to localStorage.
+   *
+   * When reason is 'user-cancel-fast', the active gateway is preserved since
+   * the user intentionally cancelled and the gateway is likely fine.
+   *
+   * @param url - The URL that failed
+   * @param options - Optional signal for cancellation and reason to distinguish failure types
+   * @returns A new working URL (or original if all gateways fail or user cancelled quickly)
+   */
+  async reportGatewayFailure(e, t) {
+    const { signal: s, reason: a, excludeHost: r } = t ?? {};
+    if (s?.aborted)
+      return this.logger.debug("reportGatewayFailure called with already-aborted signal, returning original URL"), e;
+    if (a === "user-cancel-fast")
+      return this.logger.debug("User cancelled quickly, keeping current gateway"), e;
+    const l = T(e);
+    if (!l) return e;
+    const { txId: i, pathSuffix: c } = l;
+    this.logger.warn("Gateway failure reported, finding new gateway", {
+      failedHost: this.activeGateway?.host,
+      txId: i,
+      reason: a ?? "load-error"
+    });
+    const n = this.activeGateway?.host ?? r;
+    this.activeGateway = null, this.cache.delete(i), this.clearPersistedGateway();
+    const y = this.gateways.find((g) => g.host === "arweave.net" && g.host !== n);
+    if (y) {
+      const g = await this.checkAndSetGateway(e, i, c, y, s);
+      if (g) return g.url;
+    }
+    if (this.wayfinder) {
+      const g = await this.tryWayfinder(i, c, s);
+      if (g) return g.url;
+    }
+    const w = this.gateways;
+    n && (this.gateways = this.gateways.filter((g) => g.host !== n));
+    const o = await this.tryFallbackGateways(e, i, c, s);
+    return this.gateways = w, o ? o.url : e;
+  }
+  /**
+   * Report that a fetch succeeded with timing data.
+   *
+   * Callers invoke this after a successful fetch to feed timing data back to the manager.
+   * If the fetch was fast, the consecutive slow counter resets. If slow, it increments
+   * and may trigger proactive gateway rotation on the next resolveUrl() call.
+   *
+   * @param timingMs - The time the fetch took in milliseconds
+   */
+  reportFetchSuccess(e) {
+    this.lastFetchTiming = e, e >= this.slowResponseThreshold ? (this.consecutiveSlowResponses++, this.logger.warn("Slow fetch response recorded", {
+      timingMs: e,
+      threshold: this.slowResponseThreshold,
+      consecutiveSlow: this.consecutiveSlowResponses,
+      maxAllowed: this.maxSlowResponses,
+      gateway: this.activeGateway?.host ?? "none"
+    })) : (this.consecutiveSlowResponses > 0 && this.logger.info("Fetch timing recovered, resetting slow counter", {
+      timingMs: e,
+      previousSlowCount: this.consecutiveSlowResponses
+    }), this.consecutiveSlowResponses = 0);
+  }
+  /**
+   * Check a single gateway and set it as active if it works.
+   *
+   * Returns one of:
+   *   - `{ kind: 'verified', url }`  — HEAD returned 2xx/3xx, gateway is confirmed working
+   *   - `{ kind: 'maybe', url }`     — HEAD failed (likely CORS), no-cors GET didn't throw.
+   *                                   Server responded but we can't verify status. Caller
+   *                                   should keep looking for a 'verified' result and use
+   *                                   'maybe' only as a last resort.
+   *   - `null`                       — gateway definitively failed
+   *
+   * Previously this returned `string | null` for both 'verified' and 'maybe', which forced
+   * `resolveGatewayChain` to bail on the first 'maybe' — even when other gateways might
+   * have a verified 2xx response. For manifest-path Arweave URLs (where the txid root
+   * serves a manifest and individual paths may 404), this meant the chain stopped at the
+   * first gateway that responded at all (even with 404s hidden behind no-cors opacity)
+   * and never tried alternates. Surfacing the distinction lets the chain prefer verified
+   * results and use 'maybe' only as a fallback.
+   */
+  async checkAndSetGateway(e, t, s, a, r) {
+    if (r?.aborted) return null;
+    const l = await this.checkGateway(t, a, s, r);
+    if (l === !0) {
+      this.setActiveGateway(a, t);
+      const i = k(t, a, s);
+      return this.logger.info("Gateway resolved", {
+        txId: t,
+        gateway: a.host,
+        pathSuffix: s,
+        workingUrl: i
+      }), { kind: "verified", url: i };
+    }
+    if (l === "maybe") {
+      const i = k(t, a, s);
+      return this.logger.info("Gateway maybe resolved (no-cors)", {
+        txId: t,
+        gateway: a.host,
+        pathSuffix: s,
+        workingUrl: i
+      }), { kind: "maybe", url: i };
+    }
+    return null;
+  }
+  /**
+   * Try remaining fallback gateways (everything except arweave.net) in parallel.
+   * Returns the URL of the first gateway that responds, or null if all fail.
+   */
+  async tryFallbackGateways(e, t, s, a, r) {
+    this.missCount++;
+    const l = 0.7, i = 3, c = this.gateways.filter((h) => h.host !== "arweave.net" && h.host !== r), n = c.filter((h) => {
+      const { rate: u, totalChecks: d } = this.getFailureRate(h.host);
+      return !(d >= i && u > l);
+    }), y = n.length > 0 ? n : c;
+    if (a?.aborted || y.length === 0) return null;
+    const w = async (h) => {
+      if (a?.aborted || h.length === 0) return null;
+      const u = new AbortController(), d = () => u.abort();
+      a?.addEventListener("abort", d, { once: !0 });
+      let m = null, p = null, R = !1;
+      try {
+        const P = await Promise.allSettled(
+          h.map(async (v) => {
+            const b = await this.checkGateway(t, v, s, u.signal);
+            if (!b) throw new Error(`Gateway ${v.host} failed check`);
+            const W = k(t, v, s), F = b === !0 ? "verified" : "maybe";
+            return R || (R = !0, F === "verified" ? (this.setActiveGateway(v, t), this.logger.info("Gateway resolved via fallback", {
+              txId: t,
+              gateway: v.host,
+              pathSuffix: s,
+              workingUrl: W
+            })) : this.logger.info("Gateway maybe resolved via fallback (no-cors)", {
+              txId: t,
+              gateway: v.host,
+              pathSuffix: s,
+              workingUrl: W
+            })), { kind: F, url: W };
+          })
+        );
+        for (const v of P) {
+          if (v.status !== "fulfilled") continue;
+          const b = v.value;
+          if (b.kind === "verified" && !m ? m = { kind: "verified", url: b.url } : b.kind === "maybe" && !p && (p = { kind: "maybe", url: b.url }), m) break;
+        }
+        return m ?? p;
+      } finally {
+        a?.removeEventListener("abort", d);
+      }
+    }, o = await w(y);
+    if (o && o.kind === "verified") return o;
+    let g = o;
+    if (n.length < c.length && !a?.aborted) {
+      const h = c.filter((d) => !n.some((m) => m.host === d.host)).map((d) => d.host);
+      this.logger.debug("Healthy gateways exhausted, retrying with previously unhealthy", { excludedHosts: h });
+      const u = await w(c);
+      if (u && (u.kind === "verified" || !g))
+        return u;
+    }
+    return g;
+  }
+  /**
+   * Return the ranked gateway list. The provider itself is already wrapped in
+   * the 24h cache (see wrapProviderWithCache), so this is now a thin reader —
+   * no separate fetch, TTL, or stale logic here. Kept as an indirection point
+   * so tryWayfinder's Step B reads through a named method. Returns null if the
+   * provider is unavailable or both fetch and stale fallback fail.
+   */
+  async getRankedGatewaysCached(e) {
+    if (!this.wayfinderGatewaysProvider) return null;
+    try {
+      const t = await this.withTimeout(
+        this.wayfinderGatewaysProvider.getGateways(),
+        this.timeout + 2e3,
+        "Wayfinder provider getGateways timed out"
+      );
+      return e?.aborted ? null : t && t.length > 0 ? t : null;
+    } catch (t) {
+      return this.logger.debug("Ranked gateway list unavailable", { error: t }), null;
+    }
+  }
+  async tryWayfinder(e, t, s, a) {
+    if (!this.wayfinder) return null;
+    let r = null;
+    const l = 10, i = /* @__PURE__ */ new Set();
+    a && i.add(a);
+    const c = `https://arweave.net/${e}${t}`;
+    try {
+      this.logger.debug("Resolving via Wayfinder (first pick)", { txId: e, normalizedUrl: c });
+      const w = await this.withTimeout(
+        this.wayfinder.resolveUrl({ originalUrl: c }),
+        this.timeout + 2e3,
+        "Wayfinder resolution timed out"
+      );
+      if (s?.aborted) return null;
+      const o = w.hostname;
+      if (i.has(o))
+        this.logger.debug("Wayfinder first pick was already excluded, skipping to walk", { host: o });
+      else {
+        const g = w.protocol.replace(":", ""), h = {
+          host: o,
+          protocol: g,
+          priority: 0
+        }, u = await this.checkGateway(e, h, t, s);
+        if (u) {
+          const d = k(e, h, t), m = u === !0 ? "verified" : "maybe";
+          if (m === "verified" ? (this.setActiveGateway(h, e), this.logger.info("Gateway resolved via Wayfinder (first pick)", {
+            txId: e,
+            gateway: o,
+            pathSuffix: t,
+            workingUrl: d
+          })) : this.logger.info("Gateway maybe resolved via Wayfinder (first pick, no-cors)", {
+            txId: e,
+            gateway: o,
+            pathSuffix: t,
+            workingUrl: d
+          }), m === "verified") return { kind: m, url: d };
+          r ??= { kind: m, url: d };
+        } else
+          this.logger.debug("Wayfinder first pick failed verify, will walk ranked list", { host: o });
+        i.add(o);
+      }
+    } catch (w) {
+      this.logger.debug("Wayfinder first pick threw, will walk ranked list", { error: w });
+    }
+    if (s?.aborted) return r;
+    const n = await this.getRankedGatewaysCached(s);
+    if (!n || n.length === 0 || s?.aborted) return r;
+    const y = n.filter((w) => !i.has(w.hostname)).slice(0, l);
+    this.logger.debug("Walking Wayfinder ranked list", {
+      txId: e,
+      poolSize: n.length,
+      walkSize: y.length
+    });
+    for (const w of y) {
+      if (s?.aborted) return r;
+      const o = {
+        host: w.hostname,
+        protocol: w.protocol.replace(":", ""),
+        priority: 0
+      }, g = await this.checkGateway(e, o, t, s);
+      if (g) {
+        const h = k(e, o, t), u = g === !0 ? "verified" : "maybe";
+        if (u === "verified")
+          return this.setActiveGateway(o, e), this.logger.info("Gateway resolved via Wayfinder ranked walk", {
+            txId: e,
+            gateway: o.host,
+            pathSuffix: t,
+            workingUrl: h
+          }), { kind: u, url: h };
+        this.logger.info("Gateway maybe resolved via Wayfinder ranked walk (no-cors)", {
+          txId: e,
+          gateway: o.host,
+          pathSuffix: t,
+          workingUrl: h
+        }), r ??= { kind: u, url: h };
+      }
+      i.add(o.host);
+    }
+    return r ? this.logger.debug("Wayfinder returning best maybe-result (no verified match)", {
+      txId: e,
+      checkedHosts: Array.from(i),
+      maybeUrl: r.url
+    }) : this.logger.debug("Wayfinder ranked walk exhausted with no match", {
+      txId: e,
+      checkedHosts: Array.from(i)
+    }), r;
+  }
+  /**
+   * Set the active gateway, cache it for the txId, and persist to localStorage.
+   */
+  setActiveGateway(e, t) {
+    this.activeGateway = e, this.lastFetchTiming = 0, this.consecutiveSlowResponses = 0, this.setCache(t, e), this.persistGateway(e);
+  }
+  /**
+   * Load the persisted active gateway from localStorage.
+   */
+  loadPersistedGateway() {
+    try {
+      if (typeof localStorage > "u") return null;
+      const e = localStorage.getItem(H);
+      if (!e) return null;
+      const t = JSON.parse(e);
+      if (t && typeof t.host == "string" && typeof t.protocol == "string") {
+        if (typeof t.timestamp == "number" && Date.now() - t.timestamp > 72e5)
+          return this.logger.info("Ignoring persisted gateway — expired (older than 2 hours)", { host: t.host }), this.clearPersistedGateway(), null;
+        this.logger.info("Restored active gateway from localStorage", { host: t.host });
+        const { timestamp: a, ...r } = t;
+        return r;
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Load the persisted ranked gateway list from localStorage. Returns null if
+   * unavailable, malformed, or expired.
+   */
+  loadPersistedRankedGateways() {
+    try {
+      if (typeof localStorage > "u") return null;
+      const e = localStorage.getItem(L);
+      if (!e) return null;
+      const t = JSON.parse(e);
+      if (!t || !Array.isArray(t.gateways) || typeof t.timestamp != "number") return null;
+      const s = Date.now() - t.timestamp;
+      if (s > this.RANKED_GATEWAYS_TTL_MS)
+        return this.logger.info("Ignoring persisted ranked gateway list — expired", { ageMs: s }), this.clearPersistedRankedGateways(), null;
+      const a = [];
+      for (const r of t.gateways)
+        if (typeof r == "string")
+          try {
+            a.push(new URL(r));
+          } catch {
+          }
+      return a.length === 0 ? null : (this.rankedGatewaysCacheTimestamp = t.timestamp, this.logger.info("Restored ranked gateway list from localStorage", { size: a.length, ageMs: s }), a);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Persist the ranked gateway list to localStorage so it survives reloads.
+   */
+  persistRankedGateways(e, t) {
+    try {
+      if (typeof localStorage > "u") return;
+      const s = {
+        gateways: e.map((a) => a.toString()),
+        timestamp: t
+      };
+      localStorage.setItem(L, JSON.stringify(s));
+    } catch {
+    }
+  }
+  /**
+   * Clear the persisted ranked gateway list from localStorage.
+   */
+  clearPersistedRankedGateways() {
+    try {
+      if (typeof localStorage > "u") return;
+      localStorage.removeItem(L);
+    } catch {
+    }
+  }
+  /**
+   * Persist the active gateway to localStorage.
+   */
+  persistGateway(e) {
+    try {
+      if (typeof localStorage > "u") return;
+      const t = { ...e, timestamp: Date.now() };
+      localStorage.setItem(H, JSON.stringify(t));
+    } catch {
+    }
+  }
+  /**
+   * Clear the persisted gateway from localStorage.
+   */
+  clearPersistedGateway() {
+    try {
+      if (typeof localStorage > "u") return;
+      localStorage.removeItem(H);
+    } catch {
+    }
+  }
+  /**
+   * Check if a gateway can serve a transaction
+   *
+   * Uses a HEAD request with timeout to check if the gateway responds.
+   * Handles CORS errors gracefully (treats as failure, not exception).
+   *
+   * @param txId - The transaction ID to check
+   * @param gateway - The gateway to check
+   * @param pathSuffix - Optional path suffix to append after txId
+   * @param signal - Optional external AbortSignal to cancel the check
+   * @returns true if the gateway can serve the transaction
+   */
+  async checkGateway(e, t, s = "", a) {
+    const r = k(e, t, s), l = Date.now(), i = new AbortController(), c = setTimeout(() => i.abort(), this.timeout), n = () => i.abort();
+    a?.addEventListener("abort", n, { once: !0 });
+    try {
+      const y = await fetch(r, {
+        method: "HEAD",
+        mode: "cors",
+        signal: i.signal
+      });
+      clearTimeout(c), a?.removeEventListener("abort", n);
+      const w = Date.now() - l, o = y.ok || y.status >= 200 && y.status < 400;
+      return this.recordGatewayResponse(t.host, w, o), o;
+    } catch (y) {
+      clearTimeout(c), a?.removeEventListener("abort", n);
+      const w = Date.now() - l;
+      if (this.recordGatewayResponse(t.host, w, !1), y instanceof Error && y.name === "AbortError") {
+        const o = a?.aborted;
+        return this.logger.debug(o ? "Gateway check aborted by external signal" : "Gateway check timed out", {
+          txId: e,
+          gateway: t.host,
+          timeout: this.timeout
+        }), !1;
+      }
+      if (y instanceof TypeError) {
+        this.logger.debug("HEAD failed (likely CORS), retrying with no-cors", {
+          txId: e,
+          gateway: t.host,
+          error: y.message
+        });
+        try {
+          await fetch(r, {
+            method: "GET",
+            mode: "no-cors",
+            signal: i.signal
+          });
+          const o = Date.now() - l;
+          return this.recordGatewayResponse(t.host, o, !0), "maybe";
+        } catch {
+          const o = Date.now() - l;
+          return this.recordGatewayResponse(t.host, o, !1), !1;
+        }
+      }
+      return this.logger.debug("Gateway HEAD failed", {
+        txId: e,
+        gateway: t.host,
+        error: y instanceof Error ? y.message : String(y)
+      }), !1;
+    }
+  }
+  /**
+   * Get the cached working gateway for a transaction ID
+   *
+   * @param txId - The transaction ID to look up
+   * @returns The cached gateway config, or null if not cached or expired
+   */
+  getCachedGateway(e) {
+    const t = this.cache.get(e);
+    return t ? this.isCacheValid(t) ? t.workingGateway : (this.cache.delete(e), null) : null;
+  }
+  /**
+   * Cache a working gateway for a transaction ID
+   *
+   * @param txId - The transaction ID
+   * @param gateway - The working gateway to cache
+   */
+  setCache(e, t) {
+    const s = {
+      txId: e,
+      workingGateway: t,
+      timestamp: Date.now(),
+      ttl: this.cacheTTL
+    };
+    this.cache.set(e, s), this.logger.debug("Cached working gateway", { txId: e, gateway: t.host });
+  }
+  /**
+   * Clear all cached gateway entries
+   */
+  clearCache() {
+    const e = this.cache.size;
+    this.cache.clear(), this.hitCount = 0, this.missCount = 0, this.logger.info("Cache cleared", { entriesRemoved: e });
+  }
+  /**
+   * Invalidate the cached gateway for a specific URL's transaction ID.
+   * Also clears the active gateway and persisted gateway so that resolveUrl()
+   * runs the full fallback chain instead of short-circuiting.
+   */
+  invalidateCacheForUrl(e) {
+    if (!A(e)) return;
+    const t = T(e);
+    t && (this.cache.delete(t.txId), this.activeGateway = null, this.clearPersistedGateway());
+  }
+  /**
+   * Prefetch and cache gateways for multiple URLs in parallel
+   *
+   * This is useful for warming up the cache at app startup with known model URLs.
+   * URLs are resolved in parallel with configurable concurrency.
+   *
+   * @param urls - Array of URLs to prefetch (non-Arweave URLs are skipped)
+   * @param options - Prefetch options
+   * @returns Result summary with success/failure counts and details
+   *
+   * @example
+   * ```ts
+   * const result = await arweaveGatewayManager.prefetchUrls([
+   *     'https://arweave.net/abc123.../model.json',
+   *     'https://arweave.net/def456.../model.json',
+   * ]);
+   * console.log(`Prefetched ${result.succeeded}/${result.total} URLs`);
+   * ```
+   */
+  async prefetchUrls(e, t) {
+    const s = t?.concurrency ?? 5, a = t?.continueOnError ?? !0, r = [];
+    let l = 0, i = 0, c = 0;
+    for (let n = 0; n < e.length; n += s) {
+      const y = e.slice(n, n + s), w = await Promise.allSettled(
+        y.map(async (o) => {
+          if (!A(o))
+            return {
+              url: o,
+              txId: "",
+              success: !1,
+              error: "Not an Arweave URL"
+            };
+          const g = T(o);
+          if (!g)
+            return {
+              url: o,
+              txId: "",
+              success: !1,
+              error: "Failed to parse Arweave URL"
+            };
+          const h = this.getCachedGateway(g.txId);
+          if (h)
+            return {
+              url: o,
+              txId: g.txId,
+              success: !0,
+              gateway: h
+            };
+          await this.resolveUrl(o);
+          const u = this.getCachedGateway(g.txId);
+          return u ? {
+            url: o,
+            txId: g.txId,
+            success: !0,
+            gateway: u
+          } : {
+            url: o,
+            txId: g.txId,
+            success: !1,
+            error: "All gateways failed"
+          };
+        })
+      );
+      for (const o of w)
+        if (o.status === "fulfilled") {
+          const g = o.value;
+          r.push(g), g.error === "Not an Arweave URL" ? c++ : g.success ? l++ : i++;
+        } else
+          i++, r.push({
+            url: "unknown",
+            txId: "",
+            success: !1,
+            error: o.reason?.message ?? "Unknown error"
+          });
+      if (!a && i > 0) {
+        this.logger.warn("Prefetch stopped due to failures", { failed: i, processed: r.length });
+        break;
+      }
+    }
+    return this.logger.info("Prefetch complete", {
+      total: e.length,
+      succeeded: l,
+      failed: i,
+      skipped: c
+    }), {
+      total: e.length,
+      succeeded: l,
+      failed: i,
+      skipped: c,
+      entries: r
+    };
+  }
+  /**
+   * Get statistics about the gateway cache
+   *
+   * @returns Cache statistics including size, entries, and hit/miss counts
+   *
+   * @example
+   * ```ts
+   * const stats = arweaveGatewayManager.getCacheStats();
+   * console.log(`Cache has ${stats.size} entries, hit rate: ${stats.hitCount / (stats.hitCount + stats.missCount)}`);
+   * ```
+   */
+  getCacheStats() {
+    const e = Array.from(this.cache.entries()), t = Date.now(), s = e.filter(([, a]) => t - a.timestamp < a.ttl).map(([a]) => a);
+    return {
+      size: s.length,
+      txIds: s,
+      hitCount: this.hitCount,
+      missCount: this.missCount,
+      ttl: this.cacheTTL
+    };
+  }
+  /**
+   * Get all cached gateway entries (for debugging)
+   *
+   * @returns Array of all cache entries (including expired ones)
+   */
+  getCacheEntries() {
+    return Array.from(this.cache.values());
+  }
+  /**
+   * Check if a cache entry is still valid
+   *
+   * @param cache - The cache entry to check
+   * @returns true if the entry is still within its TTL
+   */
+  isCacheValid(e) {
+    return Date.now() - e.timestamp < e.ttl;
+  }
+  /**
+   * Get the average response time for a gateway from health data.
+   * Returns 0 if no records exist (indicates no history).
+   *
+   * @param host - Gateway hostname
+   * @returns Average response time in ms, or 0 if no data
+   */
+  /**
+   * Get the failure rate for a gateway based on health data.
+   *
+   * @param host - Gateway hostname
+   * @returns Object with failure rate (0-1) and total check count
+   */
+  getFailureRate(e) {
+    const t = this.healthData.get(e);
+    return !t || t.length === 0 ? { rate: 0, totalChecks: 0 } : { rate: t.filter((a) => !a.success).length / t.length, totalChecks: t.length };
+  }
+  getAverageResponseTime(e) {
+    const t = this.healthData.get(e);
+    return !t || t.length === 0 ? 0 : t.reduce((s, a) => s + a.responseTime, 0) / t.length;
+  }
+  /**
+   * Record a gateway response for health tracking
+   *
+   * @param host - Gateway hostname
+   * @param responseTime - Response time in milliseconds
+   * @param success - Whether the check was successful
+   */
+  recordGatewayResponse(e, t, s) {
+    this.healthData.has(e) || this.healthData.set(e, []);
+    const a = this.healthData.get(e);
+    a.push({
+      responseTime: t,
+      success: s,
+      timestamp: Date.now()
+    }), a.length > this.MAX_HEALTH_RECORDS && a.shift();
+  }
+  /**
+   * Report real fetch timing data for a gateway.
+   *
+   * Callers invoke this after an actual data-transfer fetch (not just a HEAD check)
+   * to feed real performance data into health tracking. This is separate from the
+   * HEAD-based timing recorded by checkGateway(), and gives a more accurate picture
+   * of actual download performance.
+   *
+   * @param host - Gateway hostname that served the fetch
+   * @param timingMs - Time the full fetch took in milliseconds
+   * @param success - Whether the fetch succeeded
+   */
+  reportFetchTiming(e, t, s) {
+    this.recordGatewayResponse(e, t, s), this.logger.debug("Fetch timing reported", { host: e, timingMs: t, success: s });
+  }
+  /**
+   * Get health statistics for a specific gateway
+   *
+   * @param host - Gateway hostname
+   * @returns Health statistics for the gateway, or undefined if not tracked
+   */
+  getGatewayHealth(e) {
+    const t = this.gateways.find((o) => o.host === e);
+    if (!t)
+      return;
+    const s = this.healthData.get(e) || [], a = this.originalPriorities.get(e) ?? t.priority;
+    if (s.length === 0)
+      return {
+        host: e,
+        priority: t.priority,
+        originalPriority: a,
+        successCount: 0,
+        failureCount: 0,
+        totalChecks: 0,
+        successRate: 0,
+        averageResponseTime: 0,
+        lastSuccess: null,
+        lastFailure: null,
+        isHealthy: !0
+        // Assume healthy until we have data
+      };
+    const r = s.filter((o) => o.success).length, l = s.filter((o) => !o.success).length, i = r / s.length, c = Math.round(
+      s.reduce((o, g) => o + g.responseTime, 0) / s.length
+    ), n = s.filter((o) => o.success).pop()?.timestamp ?? null, y = s.filter((o) => !o.success).pop()?.timestamp ?? null, w = i >= 0.5;
+    return {
+      host: e,
+      priority: t.priority,
+      originalPriority: a,
+      successCount: r,
+      failureCount: l,
+      totalChecks: s.length,
+      successRate: i,
+      averageResponseTime: c,
+      lastSuccess: n,
+      lastFailure: y,
+      isHealthy: w
+    };
+  }
+  /**
+   * Get health statistics for all gateways
+   *
+   * @returns Array of health statistics for each gateway
+   */
+  getAllGatewayHealth() {
+    return this.gateways.map((e) => this.getGatewayHealth(e.host));
+  }
+  /**
+   * Adjust gateway priorities based on health data
+   *
+   * This method reorders gateways based on:
+   * 1. Health status (healthy gateways first)
+   * 2. Average response time (faster gateways first among healthy)
+   * 3. Success rate (higher success rate first)
+   *
+   * @param options - Options for priority adjustment
+   * @returns The new gateway order after adjustment
+   */
+  adjustGatewayPriorities(e) {
+    const t = e?.minChecks ?? 3, s = e?.healthyThreshold ?? 0.5, r = this.getAllGatewayHealth().reduce((n, y) => n + y.totalChecks, 0);
+    if (r < t)
+      return this.logger.debug("Not enough health data to adjust priorities", {
+        totalChecks: r,
+        required: t
+      }), [...this.gateways];
+    const l = this.gateways.map((n, y) => ({ gateway: n, originalIndex: y }));
+    l.sort((n, y) => {
+      const w = this.getGatewayHealth(n.gateway.host), o = this.getGatewayHealth(y.gateway.host), g = w.successRate >= s || w.totalChecks === 0, h = o.successRate >= s || o.totalChecks === 0;
+      if (g && !h) return -1;
+      if (!g && h) return 1;
+      if (w.totalChecks > 0 && o.totalChecks > 0) {
+        const u = w.averageResponseTime - o.averageResponseTime;
+        if (Math.abs(u) > 100)
+          return u;
+      }
+      if (w.totalChecks > 0 && o.totalChecks > 0) {
+        const u = o.successRate - w.successRate;
+        if (Math.abs(u) > 0.1)
+          return u;
+      }
+      return n.originalIndex - y.originalIndex;
+    });
+    const i = l.map((n) => n.gateway), c = Math.min(...Array.from(this.originalPriorities.values()));
+    return i.forEach((n, y) => {
+      n.priority = c + y;
+    }), this.gateways = i, this.logger.info("Gateway priorities adjusted", {
+      newOrder: this.gateways.map((n) => ({
+        host: n.host,
+        priority: n.priority,
+        health: this.getGatewayHealth(n.host)
+      }))
+    }), [...this.gateways];
+  }
+  /**
+   * Run a health check on all gateways
+   *
+   * Tests each gateway by making a HEAD request to a known transaction.
+   * Optionally adjusts priorities based on results.
+   *
+   * @param options - Health check options
+   * @returns Health check results
+   *
+   * @example
+   * ```ts
+   * const result = await arweaveGatewayManager.runHealthCheck({
+   *     adjustPriorities: true,
+   * });
+   * console.log(`Fastest gateway: ${result.fastestGateway}`);
+   * console.log(`Healthy gateways: ${result.healthyGateways.join(', ')}`);
+   * ```
+   */
+  async runHealthCheck(e) {
+    const t = Date.now(), s = e?.txId ?? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijk012345", a = e?.healthyThreshold ?? 0.5;
+    e?.fastThreshold, this.logger.info("Starting gateway health check", {
+      txId: s,
+      gateways: this.gateways.map((h) => h.host)
+    });
+    const r = this.gateways.map(async (h) => {
+      const u = Date.now();
+      let d = !1, m = this.timeout;
+      try {
+        const p = k(s, h), R = new AbortController(), P = setTimeout(() => R.abort(), this.timeout), v = await fetch(p, {
+          method: "HEAD",
+          mode: "cors",
+          signal: R.signal
+        });
+        clearTimeout(P), m = Date.now() - u, d = v.ok || v.status >= 200 && v.status < 400;
+      } catch {
+        m = Date.now() - u, d = !1;
+      }
+      return this.recordGatewayResponse(h.host, m, d), {
+        host: h.host,
+        success: d,
+        responseTime: m
+      };
+    }), l = await Promise.all(r), i = this.getAllGatewayHealth(), c = [], n = [];
+    let y = null, w = 1 / 0;
+    for (const h of l) {
+      const u = i.find((d) => d.host === h.host);
+      h.success && h.responseTime < w && (w = h.responseTime, y = h.host), (u.successRate >= a || u.totalChecks === 1) && h.success ? c.push(h.host) : n.push(h.host);
+    }
+    const o = Date.now() - t;
+    e?.adjustPriorities && this.adjustGatewayPriorities({
+      minChecks: e.minChecksForAdjustment ?? 1,
+      healthyThreshold: a
+    });
+    const g = {
+      timestamp: t,
+      gateways: i,
+      healthyGateways: c,
+      unhealthyGateways: n,
+      fastestGateway: y,
+      totalTime: o
+    };
+    return this.logger.info("Health check complete", {
+      healthyGateways: c,
+      unhealthyGateways: n,
+      fastestGateway: y,
+      totalTime: o
+    }), g;
+  }
+  /**
+   * Reset gateway priorities to their original values
+   */
+  resetGatewayPriorities() {
+    this.gateways.forEach((e) => {
+      const t = this.originalPriorities.get(e.host);
+      t !== void 0 && (e.priority = t);
+    }), this.gateways.sort((e, t) => {
+      const s = this.originalPriorities.get(e.host) ?? e.priority, a = this.originalPriorities.get(t.host) ?? t.priority;
+      return s - a;
+    }), this.logger.info("Gateway priorities reset to original values", {
+      gateways: this.gateways.map((e) => ({ host: e.host, priority: e.priority }))
+    });
+  }
+  /**
+   * Clear all health tracking data
+   */
+  clearHealthData() {
+    this.healthData.clear(), this.logger.info("Health data cleared");
+  }
+}
+const X = new K();
+export {
+  K as A,
+  O as D,
+  M as K,
+  D as L,
+  X as a,
+  N as b,
+  k as c,
+  V as d,
+  j as g,
+  A as i,
+  T as p
+};