playlist-data-engine 1.5.9 → 1.7.0

package/dist/arweaveGatewayManager-DDSO5sLJ.js

@@ -0,0 +1,1458 @@
+var x = /* @__PURE__ */ ((y) => (y[y.DEBUG = 0] = "DEBUG", y[y.INFO = 1] = "INFO", y[y.WARN = 2] = "WARN", y[y.ERROR = 3] = "ERROR", y[y.NONE = 4] = "NONE", y))(x || {});
+const $ = {
+  0: "DEBUG",
+  1: "INFO",
+  2: "WARN",
+  3: "ERROR",
+  4: "NONE"
+};
+let k = 1, W = !0, _ = !0, E = null, D = !1, T = !1;
+class P {
+  /**
+   * 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 P(e);
+  }
+  /**
+   * Enable diagnostic mode
+   * Sets log level to DEBUG for maximum verbosity
+   */
+  static enableDiagnosticMode() {
+    D = !0, k = 0;
+  }
+  /**
+   * Disable diagnostic mode
+   * Resets log level to INFO
+   */
+  static disableDiagnosticMode() {
+    D = !1, k = 1;
+  }
+  /**
+   * Check if diagnostic mode is enabled
+   * @returns True if diagnostic mode is active
+   */
+  static isDiagnosticMode() {
+    return D;
+  }
+  /**
+   * 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() {
+    T = !0, k = 0;
+  }
+  /**
+   * Disable verbose logging mode
+   * Resets log level to INFO (default)
+   * @example
+   * Logger.disableVerbose();
+   * // Only INFO and above will be logged
+   */
+  static disableVerbose() {
+    T = !1, k = 1;
+  }
+  /**
+   * Check if verbose mode is enabled
+   * @returns True if verbose mode is active
+   */
+  static isVerbose() {
+    return T;
+  }
+  /**
+   * 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) {
+    T = e, k = e ? 0 : 1;
+  }
+  /**
+   * Set the global log level
+   * @param level - The minimum log level to display
+   */
+  static setLevel(e) {
+    k = e;
+  }
+  /**
+   * Get the current global log level
+   * @returns The current log level
+   */
+  static getLevel() {
+    return k;
+  }
+  /**
+   * Configure the logger globally
+   * @param config - Logger configuration options
+   */
+  static configure(e) {
+    e.level !== void 0 && (k = e.level), e.includeTimestamp !== void 0 && (W = e.includeTimestamp), e.includeContext !== void 0 && (_ = e.includeContext), e.customHandler !== void 0 && (E = e.customHandler);
+  }
+  /**
+   * Reset logger to default configuration
+   */
+  static reset() {
+    k = 1, W = !0, _ = !0, E = null, D = !1, T = !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 < k)
+      return;
+    const a = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level: e,
+      context: this.context,
+      message: t,
+      data: s
+    };
+    if (E) {
+      E(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 W && t.push(this.formatTimestamp(e.timestamp)), t.push(`[${$[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 q(y) {
+  return P.for(y);
+}
+const I = [
+  { host: "arweave.net", protocol: "https", priority: 3 },
+  { host: "ardrive.net", protocol: "https", priority: 2 },
+  { host: "turbo-gateway.com", protocol: "https", priority: 1 }
+], F = [
+  "arweave.net",
+  "arweave.dev",
+  "www.arweave.net",
+  "ardrive.net",
+  "turbo-gateway.com",
+  "irys.xyz",
+  "ar-io.dev",
+  "ar-io.net",
+  "arweave.rocks",
+  "g8way.io"
+], z = [
+  "irys.xyz"
+];
+function Y(y) {
+  if (!y) return !1;
+  const e = y.toLowerCase();
+  return z.some((t) => e === t || e.endsWith("." + t));
+}
+const M = /^ar:\/\//i;
+function C(y) {
+  if (!y || typeof y != "string")
+    return !1;
+  if (M.test(y))
+    return !0;
+  const e = y.toLowerCase();
+  try {
+    const t = new URL(y).hostname;
+    return F.some(
+      (s) => t === s || t.endsWith("." + s)
+    );
+  } catch {
+    return F.some((t) => e.includes(t));
+  }
+}
+function A(y) {
+  if (!y || typeof y != "string" || !C(y))
+    return null;
+  let e = null, t = "";
+  if (M.test(y)) {
+    const l = y.replace(M, ""), o = l.search(/[/?#]/);
+    return o !== -1 ? (e = l.slice(0, o), t = l.slice(o)) : e = l, e.length === 43 && /^[A-Za-z0-9_-]+$/.test(e) ? { txId: e, originalUrl: y, pathSuffix: t } : null;
+  }
+  let s = y;
+  try {
+    const l = new URL(y);
+    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 = y.indexOf(e);
+    if (l !== -1) {
+      const o = y.slice(l + 43), c = Math.min(
+        o.indexOf("?") === -1 ? 1 / 0 : o.indexOf("?"),
+        o.indexOf("#") === -1 ? 1 / 0 : o.indexOf("#")
+      );
+      c === 1 / 0 ? t = o : t = o.slice(0, c);
+    }
+    return { txId: e, originalUrl: y, pathSuffix: t };
+  }
+  return null;
+}
+function R(y, e, t = "") {
+  return `${e.protocol || "https"}://${e.host}/${y}${t}`;
+}
+function Z(y, e = I, t = "") {
+  return e.sort((s, a) => s.priority - a.priority).map((s) => R(y, s, t));
+}
+function B(y) {
+  if (!y.startsWith("www.")) return y;
+  const e = y.slice(4);
+  return F.includes(e) ? e : y;
+}
+async function K() {
+  try {
+    return await import("@ar.io/wayfinder-core");
+  } catch {
+    return null;
+  }
+}
+async function V() {
+  try {
+    return await import("@ar.io/sdk");
+  } catch {
+    return null;
+  }
+}
+const N = "https://solana-rpc.publicnode.com", j = 5e3, X = 864e5, H = "arweave_active_gateway", L = "arweave_ranked_gateways";
+class J {
+  constructor(e) {
+    this.cache = /* @__PURE__ */ new Map(), this.logger = P.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 ?? I).map((s) => ({ ...s })), this.timeout = e?.timeout ?? j, this.cacheTTL = e?.cacheTTL ?? X, this.slowResponseThreshold = e?.slowResponseThreshold ?? 8e3, this.maxSlowResponses = e?.maxSlowResponses ?? 3, this.solanaRpcUrl = e?.solanaRpcUrl ?? N, 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), this.initWayfinder(), this.logger.info("Gateway manager initialized", {
+      gateways: this.gateways.map((s) => s.host),
+      timeout: this.timeout,
+      cacheTTL: this.cacheTTL,
+      activeGateway: this.activeGateway?.host ?? null
+    });
+  }
+  /**
+   * Build the Wayfinder client + ARIO providers on `this.solanaRpcUrl`.
+   * Runs async/fire-and-forget — `this.wayfinder` is null until it lands,
+   * and resolves fall back to the static gateway list meanwhile. Called
+   * from the constructor and again by `setSolanaRpcUrl()` after a RPC swap.
+   */
+  initWayfinder() {
+    Promise.all([K(), V(), import("./index.browser-CVv08iVS.js")]).then(([e, t, s]) => {
+      if (e && t)
+        try {
+          const {
+            FastestPingRoutingStrategy: a,
+            RandomRoutingStrategy: r,
+            CompositeRoutingStrategy: l,
+            RoundRobinRoutingStrategy: o,
+            NetworkGatewaysProvider: c
+          } = e, n = t.ARIO, h = s.createSolanaRpc(this.solanaRpcUrl), w = n.init({ rpc: h }), i = this.wrapProviderWithCache(
+            new c({
+              ario: w,
+              sortBy: this.wayfinderSortBy,
+              limit: this.wayfinderPrimaryLimit
+            })
+          ), u = this.wrapProviderWithCache(
+            new c({
+              ario: w,
+              sortBy: this.wayfinderSortBy,
+              limit: this.wayfinderFallbackLimit
+            })
+          );
+          this.wayfinderGatewaysProvider = i;
+          const d = (() => {
+            switch (this.wayfinderStrategy) {
+              case "random-only":
+                return new r({ gatewaysProvider: u });
+              case "ping-only":
+                return new a({ timeoutMs: 3e3, gatewaysProvider: i });
+              case "round-robin":
+                return new o({ gateways: [], gatewaysProvider: i });
+              default:
+                return new l({
+                  strategies: [
+                    new a({ timeoutMs: 3e3, gatewaysProvider: i }),
+                    new r({ gatewaysProvider: u })
+                  ]
+                });
+            }
+          })();
+          this.wayfinder = e.createWayfinderClient({ routingStrategy: d }), this.logger.info("Wayfinder client initialized", {
+            strategy: this.wayfinderStrategy,
+            sortBy: this.wayfinderSortBy,
+            primaryLimit: this.wayfinderPrimaryLimit,
+            fallbackLimit: this.wayfinderFallbackLimit
+          });
+        } catch (a) {
+          this.logger.warn("Failed to configure Wayfinder routing strategy, using defaults", { error: a }), this.wayfinder = e.createWayfinderClient(), this.logger.info("Wayfinder client initialized with default routing");
+        }
+      else e && (this.wayfinder = e.createWayfinderClient(), this.logger.info("Wayfinder client initialized with default routing (SDK unavailable)"));
+    }).catch(() => {
+      this.logger.debug("Wayfinder client initialization failed, using static gateways");
+    });
+  }
+  /**
+   * Swap the Solana RPC the ARIO gateway registry is read from. Invalidates
+   * the ranked-gateway caches (memory + localStorage — a fresh 24h list
+   * would otherwise keep serving rankings fetched via the old RPC) and
+   * rebuilds the Wayfinder client on the new RPC. Resolves already in
+   * flight finish on the old providers.
+   */
+  setSolanaRpcUrl(e) {
+    const t = (e ?? "").trim();
+    this.solanaRpcUrl = t || N, this.hasCustomSolanaRpc = t.length > 0, this.rankedGatewaysCache = null, this.rankedGatewaysCacheTimestamp = 0, this.clearPersistedRankedGateways();
+    try {
+      this.logger.info("Solana RPC updated", { host: new URL(this.solanaRpcUrl).host });
+    } catch {
+    }
+    this.initWayfinder();
+  }
+  /**
+   * 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(
+        (o) => {
+          clearTimeout(l), a(o);
+        },
+        (o) => {
+          clearTimeout(l), r(o);
+        }
+      );
+    });
+  }
+  /**
+   * 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, o = this.loadPersistedRankedGateways();
+    return o && o.length > 0 && (t = o, 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 (!C(e)) return e;
+    const t = A(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
+    }), R(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((o, c) => o + c.responseTime, 0) / a) : 0, l = a > 0 ? s.filter((o) => o.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 (!C(e))
+      return e;
+    const a = A(e);
+    if (!a)
+      return this.logger.warn("Failed to parse Arweave URL, returning original", { url: e }), e;
+    const { txId: r, pathSuffix: l } = a, o = this.getCachedGateway(r);
+    if (o) {
+      this.hitCount++;
+      const i = R(r, o, l);
+      return this.logger.debug("Cache hit for txId", { txId: r, gateway: o.host, pathSuffix: l }), i;
+    }
+    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 h = new AbortController();
+    s && s.addEventListener("abort", () => h.abort(), { once: !0 });
+    const w = this.resolveGatewayChain(e, r, l, h.signal, t).finally(() => {
+      this.inflightResolves.delete(r), this.inflightControllers.delete(r);
+    });
+    return this.inflightResolves.set(r, w), this.inflightControllers.set(r, h), 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(), o = r?.bypassArweaveNet ?? !1;
+    let c = null, n = null;
+    if (e.startsWith("https://") || e.startsWith("http://"))
+      try {
+        const g = new URL(e), f = B(g.host);
+        if (Y(f))
+          this.logger.info("[gateway] Step 0 (original): skipping legacy redirect host, re-resolving via chain", { host: g.host }), c = f;
+        else {
+          const m = {
+            host: f,
+            // includes port if present; strips www. for known gateways
+            protocol: g.protocol.replace(":", ""),
+            priority: 0
+          }, v = Date.now(), G = await this.checkAndSetGateway(e, t, s, m, a), S = Date.now() - v;
+          if (G) {
+            if (this.logger.info(`[gateway] Step 0 (original): ${G.kind}`, { host: m.host, ms: S, totalMs: Date.now() - l }), G.kind === "verified") return G.url;
+            n ??= G.url;
+          } else
+            this.logger.info("[gateway] Step 0 (original): failed", { host: m.host, ms: S });
+          c = m.host;
+        }
+      } catch {
+      }
+    if (this.activeGateway && this.activeGateway.host !== c) {
+      const g = Date.now(), f = await this.checkAndSetGateway(e, t, s, this.activeGateway, a), m = Date.now() - g;
+      if (f) {
+        if (this.logger.info(`[gateway] Step 1 (persisted): ${f.kind}`, { host: this.activeGateway.host, ms: m, totalMs: Date.now() - l }), f.kind === "verified") return f.url;
+        n ??= f.url;
+      } else
+        this.logger.info("[gateway] Step 1 (persisted): failed, clearing", { ms: m }), this.activeGateway = null, this.clearPersistedGateway();
+    }
+    if (!o && c !== "arweave.net") {
+      const g = this.gateways.find((f) => f.host === "arweave.net");
+      if (g) {
+        const f = Date.now(), m = await this.checkAndSetGateway(e, t, s, g, a), v = Date.now() - f;
+        if (m) {
+          if (this.logger.info(`[gateway] Step 2 (arweave.net): ${m.kind}`, { ms: v, totalMs: Date.now() - l }), m.kind === "verified") return m.url;
+          n ??= m.url;
+        } else
+          this.logger.info("[gateway] Step 2 (arweave.net): failed", { ms: v });
+      }
+    }
+    const h = Date.now(), w = await this.tryFallbackGateways(e, t, s, a, c), i = Date.now() - h;
+    if (w) {
+      if (this.logger.info(`[gateway] Step 3 (fallbacks): ${w.kind}`, { ms: i, totalMs: Date.now() - l }), w.kind === "verified") return w.url;
+      n ??= w.url;
+    } else
+      this.logger.info("[gateway] Step 3 (fallbacks): failed", { ms: i });
+    const u = !this.hasCustomSolanaRpc, d = r?.bypassWayfinder ?? u;
+    if (this.wayfinder && !d) {
+      const g = Date.now();
+      this.logger.info("[gateway] Step 4 (wayfinder): trying");
+      const f = await this.tryWayfinder(t, s, a, c), m = Date.now() - g;
+      if (f) {
+        if (this.logger.info(`[gateway] Step 4 (wayfinder): ${f.kind}`, { ms: m, totalMs: Date.now() - l }), f.kind === "verified") return f.url;
+        n ??= f.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 = A(e);
+    if (!l) return e;
+    const { txId: o, pathSuffix: c } = l;
+    this.logger.warn("Gateway failure reported, finding new gateway", {
+      failedHost: this.activeGateway?.host,
+      txId: o,
+      reason: a ?? "load-error"
+    });
+    const n = this.activeGateway?.host ?? r;
+    this.activeGateway = null, this.cache.delete(o), this.clearPersistedGateway();
+    const h = this.gateways.find((u) => u.host === "arweave.net" && u.host !== n);
+    if (h) {
+      const u = await this.checkAndSetGateway(e, o, c, h, s);
+      if (u) return u.url;
+    }
+    if (this.wayfinder) {
+      const u = await this.tryWayfinder(o, c, s);
+      if (u) return u.url;
+    }
+    const w = this.gateways;
+    n && (this.gateways = this.gateways.filter((u) => u.host !== n));
+    const i = await this.tryFallbackGateways(e, o, c, s);
+    return this.gateways = w, i ? i.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 o = R(t, a, s);
+      return this.logger.info("Gateway resolved", {
+        txId: t,
+        gateway: a.host,
+        pathSuffix: s,
+        workingUrl: o
+      }), { kind: "verified", url: o };
+    }
+    if (l === "maybe") {
+      const o = R(t, a, s);
+      return this.logger.info("Gateway maybe resolved (no-cors)", {
+        txId: t,
+        gateway: a.host,
+        pathSuffix: s,
+        workingUrl: o
+      }), { kind: "maybe", url: o };
+    }
+    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, o = 3, c = this.gateways.filter((d) => d.host !== "arweave.net" && d.host !== r), n = c.filter((d) => {
+      const { rate: g, totalChecks: f } = this.getFailureRate(d.host);
+      return !(f >= o && g > l);
+    }), h = n.length > 0 ? n : c;
+    if (a?.aborted || h.length === 0) return null;
+    const w = async (d) => {
+      if (a?.aborted || d.length === 0) return null;
+      const g = new AbortController(), f = () => g.abort();
+      a?.addEventListener("abort", f, { once: !0 });
+      let m = null, v = null, G = !1;
+      try {
+        const S = await Promise.allSettled(
+          d.map(async (p) => {
+            const b = await this.checkGateway(t, p, s, g.signal);
+            if (!b) throw new Error(`Gateway ${p.host} failed check`);
+            const U = R(t, p, s), O = b === !0 ? "verified" : "maybe";
+            return G || (G = !0, O === "verified" ? (this.setActiveGateway(p, t), this.logger.info("Gateway resolved via fallback", {
+              txId: t,
+              gateway: p.host,
+              pathSuffix: s,
+              workingUrl: U
+            })) : this.logger.info("Gateway maybe resolved via fallback (no-cors)", {
+              txId: t,
+              gateway: p.host,
+              pathSuffix: s,
+              workingUrl: U
+            })), { kind: O, url: U };
+          })
+        );
+        for (const p of S) {
+          if (p.status !== "fulfilled") continue;
+          const b = p.value;
+          if (b.kind === "verified" && !m ? m = { kind: "verified", url: b.url } : b.kind === "maybe" && !v && (v = { kind: "maybe", url: b.url }), m) break;
+        }
+        return m ?? v;
+      } finally {
+        a?.removeEventListener("abort", f);
+      }
+    }, i = await w(h);
+    if (i && i.kind === "verified") return i;
+    let u = i;
+    if (n.length < c.length && !a?.aborted) {
+      const d = c.filter((f) => !n.some((m) => m.host === f.host)).map((f) => f.host);
+      this.logger.debug("Healthy gateways exhausted, retrying with previously unhealthy", { excludedHosts: d });
+      const g = await w(c);
+      if (g && (g.kind === "verified" || !u))
+        return g;
+    }
+    return u;
+  }
+  /**
+   * 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, o = /* @__PURE__ */ new Set();
+    a && o.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 i = w.hostname;
+      if (o.has(i))
+        this.logger.debug("Wayfinder first pick was already excluded, skipping to walk", { host: i });
+      else {
+        const u = w.protocol.replace(":", ""), d = {
+          host: i,
+          protocol: u,
+          priority: 0
+        }, g = await this.checkGateway(e, d, t, s);
+        if (g) {
+          const f = R(e, d, t), m = g === !0 ? "verified" : "maybe";
+          if (m === "verified" ? (this.setActiveGateway(d, e), this.logger.info("Gateway resolved via Wayfinder (first pick)", {
+            txId: e,
+            gateway: i,
+            pathSuffix: t,
+            workingUrl: f
+          })) : this.logger.info("Gateway maybe resolved via Wayfinder (first pick, no-cors)", {
+            txId: e,
+            gateway: i,
+            pathSuffix: t,
+            workingUrl: f
+          }), m === "verified") return { kind: m, url: f };
+          r ??= { kind: m, url: f };
+        } else
+          this.logger.debug("Wayfinder first pick failed verify, will walk ranked list", { host: i });
+        o.add(i);
+      }
+    } 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 h = n.filter((w) => !o.has(w.hostname)).slice(0, l);
+    this.logger.debug("Walking Wayfinder ranked list", {
+      txId: e,
+      poolSize: n.length,
+      walkSize: h.length
+    });
+    for (const w of h) {
+      if (s?.aborted) return r;
+      const i = {
+        host: w.hostname,
+        protocol: w.protocol.replace(":", ""),
+        priority: 0
+      }, u = await this.checkGateway(e, i, t, s);
+      if (u) {
+        const d = R(e, i, t), g = u === !0 ? "verified" : "maybe";
+        if (g === "verified")
+          return this.setActiveGateway(i, e), this.logger.info("Gateway resolved via Wayfinder ranked walk", {
+            txId: e,
+            gateway: i.host,
+            pathSuffix: t,
+            workingUrl: d
+          }), { kind: g, url: d };
+        this.logger.info("Gateway maybe resolved via Wayfinder ranked walk (no-cors)", {
+          txId: e,
+          gateway: i.host,
+          pathSuffix: t,
+          workingUrl: d
+        }), r ??= { kind: g, url: d };
+      }
+      o.add(i.host);
+    }
+    return r ? this.logger.debug("Wayfinder returning best maybe-result (no verified match)", {
+      txId: e,
+      checkedHosts: Array.from(o),
+      maybeUrl: r.url
+    }) : this.logger.debug("Wayfinder ranked walk exhausted with no match", {
+      txId: e,
+      checkedHosts: Array.from(o)
+    }), 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 = R(e, t, s), l = Date.now(), o = new AbortController(), c = setTimeout(() => o.abort(), this.timeout), n = () => o.abort();
+    a?.addEventListener("abort", n, { once: !0 });
+    try {
+      const h = await fetch(r, {
+        method: "HEAD",
+        mode: "cors",
+        signal: o.signal
+      });
+      clearTimeout(c), a?.removeEventListener("abort", n);
+      const w = Date.now() - l, i = h.ok || h.status >= 200 && h.status < 400;
+      return this.recordGatewayResponse(t.host, w, i), i;
+    } catch (h) {
+      clearTimeout(c), a?.removeEventListener("abort", n);
+      const w = Date.now() - l;
+      if (this.recordGatewayResponse(t.host, w, !1), h instanceof Error && h.name === "AbortError") {
+        const i = a?.aborted;
+        return this.logger.debug(i ? "Gateway check aborted by external signal" : "Gateway check timed out", {
+          txId: e,
+          gateway: t.host,
+          timeout: this.timeout
+        }), !1;
+      }
+      if (h instanceof TypeError) {
+        this.logger.debug("HEAD failed (likely CORS), retrying with no-cors", {
+          txId: e,
+          gateway: t.host,
+          error: h.message
+        });
+        try {
+          await fetch(r, {
+            method: "GET",
+            mode: "no-cors",
+            signal: o.signal
+          });
+          const i = Date.now() - l;
+          return this.recordGatewayResponse(t.host, i, !0), "maybe";
+        } catch {
+          const i = Date.now() - l;
+          return this.recordGatewayResponse(t.host, i, !1), !1;
+        }
+      }
+      return this.logger.debug("Gateway HEAD failed", {
+        txId: e,
+        gateway: t.host,
+        error: h instanceof Error ? h.message : String(h)
+      }), !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 (!C(e)) return;
+    const t = A(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, o = 0, c = 0;
+    for (let n = 0; n < e.length; n += s) {
+      const h = e.slice(n, n + s), w = await Promise.allSettled(
+        h.map(async (i) => {
+          if (!C(i))
+            return {
+              url: i,
+              txId: "",
+              success: !1,
+              error: "Not an Arweave URL"
+            };
+          const u = A(i);
+          if (!u)
+            return {
+              url: i,
+              txId: "",
+              success: !1,
+              error: "Failed to parse Arweave URL"
+            };
+          const d = this.getCachedGateway(u.txId);
+          if (d)
+            return {
+              url: i,
+              txId: u.txId,
+              success: !0,
+              gateway: d
+            };
+          await this.resolveUrl(i);
+          const g = this.getCachedGateway(u.txId);
+          return g ? {
+            url: i,
+            txId: u.txId,
+            success: !0,
+            gateway: g
+          } : {
+            url: i,
+            txId: u.txId,
+            success: !1,
+            error: "All gateways failed"
+          };
+        })
+      );
+      for (const i of w)
+        if (i.status === "fulfilled") {
+          const u = i.value;
+          r.push(u), u.error === "Not an Arweave URL" ? c++ : u.success ? l++ : o++;
+        } else
+          o++, r.push({
+            url: "unknown",
+            txId: "",
+            success: !1,
+            error: i.reason?.message ?? "Unknown error"
+          });
+      if (!a && o > 0) {
+        this.logger.warn("Prefetch stopped due to failures", { failed: o, processed: r.length });
+        break;
+      }
+    }
+    return this.logger.info("Prefetch complete", {
+      total: e.length,
+      succeeded: l,
+      failed: o,
+      skipped: c
+    }), {
+      total: e.length,
+      succeeded: l,
+      failed: o,
+      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((i) => i.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((i) => i.success).length, l = s.filter((i) => !i.success).length, o = r / s.length, c = Math.round(
+      s.reduce((i, u) => i + u.responseTime, 0) / s.length
+    ), n = s.filter((i) => i.success).pop()?.timestamp ?? null, h = s.filter((i) => !i.success).pop()?.timestamp ?? null, w = o >= 0.5;
+    return {
+      host: e,
+      priority: t.priority,
+      originalPriority: a,
+      successCount: r,
+      failureCount: l,
+      totalChecks: s.length,
+      successRate: o,
+      averageResponseTime: c,
+      lastSuccess: n,
+      lastFailure: h,
+      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, h) => n + h.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, h) => ({ gateway: n, originalIndex: h }));
+    l.sort((n, h) => {
+      const w = this.getGatewayHealth(n.gateway.host), i = this.getGatewayHealth(h.gateway.host), u = w.successRate >= s || w.totalChecks === 0, d = i.successRate >= s || i.totalChecks === 0;
+      if (u && !d) return -1;
+      if (!u && d) return 1;
+      if (w.totalChecks > 0 && i.totalChecks > 0) {
+        const g = w.averageResponseTime - i.averageResponseTime;
+        if (Math.abs(g) > 100)
+          return g;
+      }
+      if (w.totalChecks > 0 && i.totalChecks > 0) {
+        const g = i.successRate - w.successRate;
+        if (Math.abs(g) > 0.1)
+          return g;
+      }
+      return n.originalIndex - h.originalIndex;
+    });
+    const o = l.map((n) => n.gateway), c = Math.min(...Array.from(this.originalPriorities.values()));
+    return o.forEach((n, h) => {
+      n.priority = c + h;
+    }), this.gateways = o, 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((d) => d.host)
+    });
+    const r = this.gateways.map(async (d) => {
+      const g = Date.now();
+      let f = !1, m = this.timeout;
+      try {
+        const v = R(s, d), G = new AbortController(), S = setTimeout(() => G.abort(), this.timeout), p = await fetch(v, {
+          method: "HEAD",
+          mode: "cors",
+          signal: G.signal
+        });
+        clearTimeout(S), m = Date.now() - g, f = p.ok || p.status >= 200 && p.status < 400;
+      } catch {
+        m = Date.now() - g, f = !1;
+      }
+      return this.recordGatewayResponse(d.host, m, f), {
+        host: d.host,
+        success: f,
+        responseTime: m
+      };
+    }), l = await Promise.all(r), o = this.getAllGatewayHealth(), c = [], n = [];
+    let h = null, w = 1 / 0;
+    for (const d of l) {
+      const g = o.find((f) => f.host === d.host);
+      d.success && d.responseTime < w && (w = d.responseTime, h = d.host), (g.successRate >= a || g.totalChecks === 1) && d.success ? c.push(d.host) : n.push(d.host);
+    }
+    const i = Date.now() - t;
+    e?.adjustPriorities && this.adjustGatewayPriorities({
+      minChecks: e.minChecksForAdjustment ?? 1,
+      healthyThreshold: a
+    });
+    const u = {
+      timestamp: t,
+      gateways: o,
+      healthyGateways: c,
+      unhealthyGateways: n,
+      fastestGateway: h,
+      totalTime: i
+    };
+    return this.logger.info("Health check complete", {
+      healthyGateways: c,
+      unhealthyGateways: n,
+      fastestGateway: h,
+      totalTime: i
+    }), u;
+  }
+  /**
+   * 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 Q = new J();
+export {
+  J as A,
+  I as D,
+  F as K,
+  P as L,
+  Q as a,
+  x as b,
+  R as c,
+  q as d,
+  Z as g,
+  C as i,
+  A as p
+};