hx-cdn-forge 2.0.0

package/dist/index.js

@@ -0,0 +1,1405 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/core/cdnNodes.ts
+var buildJsDelivrUrl = (baseUrl) => (ctx, filePath) => {
+  const path = filePath.startsWith("/") ? filePath : `/${filePath}`;
+  return `${baseUrl}/${ctx.user}/${ctx.repo}@${ctx.ref}${path}`;
+};
+var buildGithubRawUrl = (ctx, filePath) => {
+  const path = filePath.startsWith("/") ? filePath : `/${filePath}`;
+  return `https://raw.githubusercontent.com/${ctx.user}/${ctx.repo}/${ctx.ref}${path}`;
+};
+var buildCfWorkerUrl = (domain) => (ctx, filePath) => {
+  const rawUrl = buildGithubRawUrl(ctx, filePath);
+  return `https://${domain}/${rawUrl}`;
+};
+var CDN_NODE_PRESETS = {
+  jsdelivr_main: {
+    id: "jsdelivr-main",
+    name: "jsDelivr (Main)",
+    baseUrl: "https://cdn.jsdelivr.net/gh",
+    region: "global",
+    buildUrl: buildJsDelivrUrl("https://cdn.jsdelivr.net/gh"),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: "jsDelivr \u4E3B\u8282\u70B9\uFF0C\u5168\u7403 CDN"
+  },
+  jsdelivr_fastly: {
+    id: "jsdelivr-fastly",
+    name: "jsDelivr (Fastly)",
+    baseUrl: "https://fastly.jsdelivr.net/gh",
+    region: "global",
+    buildUrl: buildJsDelivrUrl("https://fastly.jsdelivr.net/gh"),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: "jsDelivr Fastly \u8282\u70B9"
+  },
+  jsdelivr_testing: {
+    id: "jsdelivr-testing",
+    name: "jsDelivr (Testing)",
+    baseUrl: "https://testing.jsdelivr.net/gh",
+    region: "global",
+    buildUrl: buildJsDelivrUrl("https://testing.jsdelivr.net/gh"),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: "jsDelivr \u6D4B\u8BD5\u8282\u70B9"
+  },
+  jsd_mirror: {
+    id: "jsd-mirror",
+    name: "JSD Mirror",
+    baseUrl: "https://cdn.jsdmirror.com/gh",
+    region: "china",
+    buildUrl: buildJsDelivrUrl("https://cdn.jsdmirror.com/gh"),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: "jsDelivr \u56FD\u5185\u955C\u50CF\uFF0C\u817E\u8BAF\u4E91 EdgeOne \u52A0\u901F"
+  },
+  zstatic: {
+    id: "zstatic",
+    name: "Zstatic",
+    baseUrl: "https://jsd.zstatic.net/gh",
+    region: "china",
+    buildUrl: buildJsDelivrUrl("https://jsd.zstatic.net/gh"),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: "Zstatic CDN \u955C\u50CF"
+  },
+  github_raw: {
+    id: "github-raw",
+    name: "GitHub Raw",
+    baseUrl: "https://raw.githubusercontent.com",
+    region: "global",
+    buildUrl: buildGithubRawUrl,
+    maxFileSize: 100 * 1024 * 1024,
+    supportsRange: true,
+    description: "GitHub \u539F\u59CB\u6587\u4EF6\u670D\u52A1"
+  }
+};
+var DEFAULT_GITHUB_CDN_NODES = [
+  CDN_NODE_PRESETS.jsdelivr_main,
+  CDN_NODE_PRESETS.jsdelivr_fastly,
+  CDN_NODE_PRESETS.jsdelivr_testing,
+  CDN_NODE_PRESETS.jsd_mirror,
+  CDN_NODE_PRESETS.zstatic,
+  CDN_NODE_PRESETS.github_raw
+];
+function createWorkerNode(domain) {
+  return {
+    id: `cf-worker-${domain.replace(/\./g, "-")}`,
+    name: `CF Worker (${domain})`,
+    baseUrl: `https://${domain}`,
+    region: "global",
+    buildUrl: buildCfWorkerUrl(domain),
+    maxFileSize: -1,
+    supportsRange: true,
+    description: `Cloudflare Worker \u4EE3\u7406 (${domain})`
+  };
+}
+var CDNTester = class {
+  constructor(timeout = 5e3, retryCount = 2) {
+    this.timeout = timeout;
+    this.retryCount = retryCount;
+  }
+  /** 测试单节点延迟 */
+  async testNode(node, testUrl) {
+    const url = testUrl ?? node.baseUrl;
+    for (let attempt = 0; attempt <= this.retryCount; attempt++) {
+      try {
+        const start = performance.now();
+        const ctrl = new AbortController();
+        const tid = setTimeout(() => ctrl.abort(), this.timeout);
+        await fetch(url, {
+          method: "HEAD",
+          mode: "no-cors",
+          cache: "no-cache",
+          signal: ctrl.signal
+        });
+        clearTimeout(tid);
+        return {
+          nodeId: node.id,
+          latency: Math.round((performance.now() - start) * 100) / 100,
+          success: true,
+          timestamp: Date.now()
+        };
+      } catch (err) {
+        if (attempt === this.retryCount) {
+          return {
+            nodeId: node.id,
+            latency: -1,
+            success: false,
+            timestamp: Date.now(),
+            error: err instanceof Error ? err.message : "Unknown error"
+          };
+        }
+        await delay(200 * (attempt + 1));
+      }
+    }
+    return { nodeId: node.id, latency: -1, success: false, timestamp: Date.now() };
+  }
+  /** 并发测试所有启用节点 */
+  async testAll(nodes) {
+    const enabled = nodes.filter((n) => n.enabled !== false);
+    return Promise.all(enabled.map((n) => this.testNode(n)));
+  }
+  /** 流式测试: 每完成一个就回调 */
+  async testAllStreaming(nodes, onResult) {
+    const enabled = nodes.filter((n) => n.enabled !== false);
+    const results = [];
+    const promises = enabled.map(async (node) => {
+      const r = await this.testNode(node);
+      results.push(r);
+      onResult(r);
+      return r;
+    });
+    await Promise.all(promises);
+    return results;
+  }
+  /** 找延迟最低的节点 ID */
+  getBestNodeId(results) {
+    const sorted = results.filter((r) => r.success && r.latency >= 0).sort((a, b) => a.latency - b.latency);
+    return sorted.length > 0 ? sorted[0].nodeId : null;
+  }
+  setTimeout(ms) {
+    this.timeout = ms;
+  }
+  setRetryCount(n) {
+    this.retryCount = n;
+  }
+};
+function getSortedNodesWithLatency(nodes, results) {
+  return nodes.filter((n) => n.enabled !== false).map((node) => {
+    const r = results.get(node.id);
+    return {
+      ...node,
+      latency: r?.success ? r.latency : r ? -1 : void 0,
+      latencyStatus: r ? r.success ? "success" : "failed" : "idle"
+    };
+  }).sort((a, b) => {
+    if (a.latency === void 0 && b.latency === void 0) return 0;
+    if (a.latency === void 0) return 1;
+    if (b.latency === void 0) return -1;
+    if (a.latency < 0 && b.latency < 0) return 0;
+    if (a.latency < 0) return 1;
+    if (b.latency < 0) return -1;
+    return a.latency - b.latency;
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/config.ts
+var DEFAULTS = {
+  splitThreshold: 20 * 1024 * 1024,
+  // 20MB
+  chunkSizeForSplit: 19 * 1024 * 1024,
+  // 切片时使用 19MB (留余量)
+  testTimeout: 5e3,
+  testRetries: 2,
+  maxConcurrency: 6,
+  chunkTimeout: 3e4,
+  maxRetries: 3,
+  enableWorkStealing: true,
+  turboMode: false,
+  turboConcurrentCDNs: 3,
+  storageKey: "hx-cdn-forge-node",
+  autoTest: true
+};
+function normalizeConfig(config) {
+  return {
+    github: config.github,
+    nodes: config.nodes ?? DEFAULT_GITHUB_CDN_NODES,
+    defaultNodeId: config.defaultNodeId ?? "",
+    autoTest: config.autoTest ?? DEFAULTS.autoTest,
+    testTimeout: config.testTimeout ?? DEFAULTS.testTimeout,
+    testRetries: config.testRetries ?? DEFAULTS.testRetries,
+    splitThreshold: config.splitThreshold ?? DEFAULTS.splitThreshold,
+    mappingPrefix: config.mappingPrefix ?? "",
+    splitStoragePath: config.splitStoragePath ?? "",
+    storageKey: config.storageKey ?? DEFAULTS.storageKey,
+    maxConcurrency: config.maxConcurrency ?? DEFAULTS.maxConcurrency,
+    chunkTimeout: config.chunkTimeout ?? DEFAULTS.chunkTimeout,
+    maxRetries: config.maxRetries ?? DEFAULTS.maxRetries,
+    enableWorkStealing: config.enableWorkStealing ?? DEFAULTS.enableWorkStealing,
+    turboMode: config.turboMode ?? DEFAULTS.turboMode,
+    turboConcurrentCDNs: config.turboConcurrentCDNs ?? DEFAULTS.turboConcurrentCDNs
+  };
+}
+function createForgeConfig(github, options) {
+  return {
+    github,
+    ...options
+  };
+}
+
+// src/core/manifest.ts
+function parseInfoYaml(text) {
+  const lines = text.split("\n").map((l) => l.trimEnd());
+  let originalName = "";
+  let totalSize = 0;
+  let mimeType = "application/octet-stream";
+  let chunkSize = 0;
+  let createdAt = "";
+  const chunks = [];
+  let inChunks = false;
+  let currentChunk = null;
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (!inChunks) {
+      if (trimmed.startsWith("originalName:")) {
+        originalName = extractValue(trimmed);
+      } else if (trimmed.startsWith("totalSize:")) {
+        totalSize = parseInt(extractValue(trimmed), 10);
+      } else if (trimmed.startsWith("mimeType:")) {
+        mimeType = extractValue(trimmed);
+      } else if (trimmed.startsWith("chunkSize:")) {
+        chunkSize = parseInt(extractValue(trimmed), 10);
+      } else if (trimmed.startsWith("createdAt:")) {
+        createdAt = extractValue(trimmed);
+      } else if (trimmed.startsWith("chunks:")) {
+        inChunks = true;
+      }
+      continue;
+    }
+    if (trimmed.startsWith("- fileName:") || trimmed === "- fileName:") {
+      if (currentChunk && currentChunk.fileName) {
+        chunks.push(currentChunk);
+      }
+      currentChunk = { fileName: extractValue(trimmed.replace(/^-\s*/, "")) };
+    } else if (currentChunk) {
+      if (trimmed.startsWith("index:")) {
+        currentChunk.index = parseInt(extractValue(trimmed), 10);
+      } else if (trimmed.startsWith("size:")) {
+        currentChunk.size = parseInt(extractValue(trimmed), 10);
+      } else if (trimmed.startsWith("sha256:")) {
+        currentChunk.sha256 = extractValue(trimmed);
+      }
+    }
+  }
+  if (currentChunk && currentChunk.fileName) {
+    chunks.push(currentChunk);
+  }
+  return { originalName, totalSize, mimeType, chunkSize, createdAt, chunks };
+}
+function serializeInfoYaml(info) {
+  const lines = [
+    `originalName: ${info.originalName}`,
+    `totalSize: ${info.totalSize}`,
+    `mimeType: ${info.mimeType}`,
+    `chunkSize: ${info.chunkSize}`,
+    `createdAt: "${info.createdAt}"`,
+    "chunks:"
+  ];
+  for (const chunk of info.chunks) {
+    lines.push(`  - fileName: ${chunk.fileName}`);
+    lines.push(`    index: ${chunk.index}`);
+    lines.push(`    size: ${chunk.size}`);
+    lines.push(`    sha256: ${chunk.sha256}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function parseCacheYaml(text) {
+  const lines = text.split("\n");
+  let sourcePath = "";
+  let sourceHash = "";
+  let sourceSize = 0;
+  let generatedAt = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("sourcePath:")) sourcePath = extractValue(trimmed);
+    else if (trimmed.startsWith("sourceHash:")) sourceHash = extractValue(trimmed);
+    else if (trimmed.startsWith("sourceSize:")) sourceSize = parseInt(extractValue(trimmed), 10);
+    else if (trimmed.startsWith("generatedAt:")) generatedAt = extractValue(trimmed);
+  }
+  return { sourcePath, sourceHash, sourceSize, generatedAt };
+}
+function serializeCacheYaml(cache) {
+  return [
+    `sourcePath: ${cache.sourcePath}`,
+    `sourceHash: ${cache.sourceHash}`,
+    `sourceSize: ${cache.sourceSize}`,
+    `generatedAt: "${cache.generatedAt}"`,
+    ""
+  ].join("\n");
+}
+function extractValue(line) {
+  const idx = line.indexOf(":");
+  if (idx < 0) return "";
+  let val = line.slice(idx + 1).trim();
+  if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+    val = val.slice(1, -1);
+  }
+  return val;
+}
+
+// src/core/chunkedFetcher.ts
+var LoadBalancer = class {
+  constructor(nodeIds, alpha = 0.3) {
+    this.stats = /* @__PURE__ */ new Map();
+    this.alpha = alpha;
+    for (const id of nodeIds) {
+      this.stats.set(id, {
+        nodeId: id,
+        totalBytes: 0,
+        totalTime: 0,
+        speedBps: 0,
+        completedChunks: 0,
+        consecutiveFailures: 0,
+        available: true
+      });
+    }
+  }
+  initFromLatency(results) {
+    for (const [nodeId, r] of results) {
+      const s = this.stats.get(nodeId);
+      if (s && r.success) {
+        s.speedBps = 1024 * 1024 / Math.max(r.latency, 10);
+      }
+    }
+  }
+  report(nodeId, bytes, timeMs, success) {
+    const s = this.stats.get(nodeId);
+    if (!s) return;
+    if (success) {
+      s.totalBytes += bytes;
+      s.totalTime += timeMs;
+      s.completedChunks++;
+      s.consecutiveFailures = 0;
+      const instant = bytes / Math.max(timeMs, 1);
+      s.speedBps = s.speedBps > 0 ? s.speedBps * (1 - this.alpha) + instant * this.alpha : instant;
+    } else {
+      s.consecutiveFailures++;
+      if (s.consecutiveFailures >= 3) s.available = false;
+    }
+  }
+  selectBest(pendingPerNode) {
+    let best = null;
+    let bestETA = Infinity;
+    for (const [nodeId, s] of this.stats) {
+      if (!s.available) continue;
+      const pending = pendingPerNode.get(nodeId) ?? 0;
+      const eta = s.speedBps > 0 ? pending / s.speedBps : Infinity;
+      if (eta < bestETA) {
+        bestETA = eta;
+        best = nodeId;
+      }
+    }
+    return best;
+  }
+  findStealable(tasks) {
+    const avail = [...this.stats.values()].filter((s) => s.available);
+    if (avail.length < 2) return null;
+    const sorted = avail.sort((a, b) => b.speedBps - a.speedBps);
+    const fastest = sorted[0];
+    const slowest = sorted[sorted.length - 1];
+    if (fastest.speedBps < slowest.speedBps * 2) return null;
+    for (let i = tasks.length - 1; i >= 0; i--) {
+      const t = tasks[i];
+      if (t.assignedNodeId === slowest.nodeId && t.status === "pending") {
+        return { from: slowest.nodeId, taskIndex: i };
+      }
+    }
+    return null;
+  }
+  getAvailableNodes() {
+    return [...this.stats.entries()].filter(([, s]) => s.available).map(([id]) => id);
+  }
+  getStats() {
+    return new Map(this.stats);
+  }
+};
+var ChunkedFetcher = class {
+  constructor(opts = {}) {
+    this.opts = {
+      maxConcurrency: opts.maxConcurrency ?? 6,
+      chunkTimeout: opts.chunkTimeout ?? 3e4,
+      maxRetries: opts.maxRetries ?? 3,
+      enableWorkStealing: opts.enableWorkStealing ?? true,
+      turboMode: opts.turboMode ?? false,
+      turboConcurrentCDNs: opts.turboConcurrentCDNs ?? 3
+    };
+  }
+  /**
+   * 并行下载多个分片文件，然后拼接
+   *
+   * @param chunkUrls - 每个分片的 URL 列表 (外层=分片索引, 内层=各CDN节点的URL)
+   * @param chunkSizes - 各分片的预期大小
+   * @param totalSize - 总大小
+   * @param contentType - MIME 类型
+   * @param nodes - 可用节点列表 (用于负载均衡)
+   * @param latencyResults - 延迟数据
+   * @param onProgress - 进度回调
+   */
+  async downloadChunks(chunkUrls, chunkSizes, totalSize, contentType, nodes, latencyResults, onProgress) {
+    const startTime = performance.now();
+    const numChunks = chunkUrls.length;
+    if (numChunks === 0) {
+      throw new Error("No chunks to download");
+    }
+    if (this.opts.turboMode && chunkUrls[0].length > 1) {
+      return this.downloadTurbo(
+        chunkUrls,
+        chunkSizes,
+        totalSize,
+        contentType,
+        nodes,
+        startTime,
+        onProgress
+      );
+    }
+    return this.downloadStandard(
+      chunkUrls,
+      chunkSizes,
+      totalSize,
+      contentType,
+      nodes,
+      latencyResults,
+      startTime,
+      onProgress
+    );
+  }
+  // ============================================================
+  // 标准模式
+  // ============================================================
+  async downloadStandard(chunkUrls, chunkSizes, totalSize, contentType, nodes, latencyResults, startTime, onProgress) {
+    const nodeIds = nodes.filter((n) => n.enabled !== false).map((n) => n.id);
+    const balancer = new LoadBalancer(nodeIds);
+    if (latencyResults) balancer.initFromLatency(latencyResults);
+    const tasks = chunkUrls.map((urls, i) => ({
+      chunk: { index: i, start: 0, end: chunkSizes[i] - 1, size: chunkSizes[i] },
+      status: "pending",
+      assignedNodeId: nodeIds[i % nodeIds.length],
+      retries: 0
+    }));
+    const concurrency = Math.min(this.opts.maxConcurrency, tasks.length);
+    let completedBytes = 0;
+    const emitProgress = () => {
+      if (!onProgress) return;
+      const elapsed = (performance.now() - startTime) / 1e3;
+      const speed = completedBytes / Math.max(elapsed, 1e-3);
+      const remaining = totalSize - completedBytes;
+      onProgress({
+        loaded: completedBytes,
+        total: totalSize,
+        percentage: Math.round(completedBytes / totalSize * 1e4) / 100,
+        speed,
+        eta: speed > 0 ? remaining / speed : Infinity,
+        completedChunks: tasks.filter((t) => t.status === "completed").length,
+        totalChunks: tasks.length
+      });
+    };
+    const workerFn = async () => {
+      while (true) {
+        const idx = tasks.findIndex((t) => t.status === "pending");
+        if (idx === -1) break;
+        const task = tasks[idx];
+        task.status = "downloading";
+        const nodeIndex = nodeIds.indexOf(task.assignedNodeId);
+        const urlIndex = nodeIndex >= 0 && nodeIndex < chunkUrls[task.chunk.index].length ? nodeIndex : 0;
+        const url = chunkUrls[task.chunk.index][urlIndex];
+        try {
+          const t0 = performance.now();
+          const data = await this.fetchChunk(url);
+          const dt = performance.now() - t0;
+          task.data = data;
+          task.status = "completed";
+          completedBytes += data.byteLength;
+          balancer.report(task.assignedNodeId, data.byteLength, dt, true);
+          emitProgress();
+          if (this.opts.enableWorkStealing) {
+            const steal = balancer.findStealable(tasks);
+            if (steal) {
+              const stolen = tasks[steal.taskIndex];
+              const fastNodes = balancer.getAvailableNodes();
+              if (fastNodes.length > 0) {
+                stolen.assignedNodeId = fastNodes[0];
+                stolen.status = "pending";
+              }
+            }
+          }
+        } catch (err) {
+          task.retries++;
+          balancer.report(task.assignedNodeId, 0, 0, false);
+          if (task.retries < this.opts.maxRetries) {
+            const pendingMap = getPendingCount(tasks);
+            const newNode = balancer.selectBest(pendingMap);
+            if (newNode) task.assignedNodeId = newNode;
+            task.status = "pending";
+          } else {
+            task.status = "failed";
+            task.error = err instanceof Error ? err.message : "Unknown error";
+          }
+        }
+      }
+    };
+    const workers = Array.from({ length: concurrency }, () => workerFn());
+    await Promise.all(workers);
+    const failed = tasks.filter((t) => t.status === "failed");
+    if (failed.length > 0) {
+      throw new Error(
+        `Failed to download ${failed.length} chunks: ${failed.map((t) => `#${t.chunk.index}: ${t.error}`).join("; ")}`
+      );
+    }
+    return this.buildResult(tasks, contentType, startTime, balancer, true);
+  }
+  // ============================================================
+  // 极速模式: 同一分片多 CDN 竞速
+  // ============================================================
+  async downloadTurbo(chunkUrls, chunkSizes, totalSize, contentType, nodes, startTime, onProgress) {
+    const turboCDNs = Math.min(this.opts.turboConcurrentCDNs, chunkUrls[0].length);
+    const results = new Array(chunkUrls.length);
+    const nodeContrib = /* @__PURE__ */ new Map();
+    let completedBytes = 0;
+    const emitProgress = () => {
+      if (!onProgress) return;
+      const elapsed = (performance.now() - startTime) / 1e3;
+      const speed = completedBytes / Math.max(elapsed, 1e-3);
+      onProgress({
+        loaded: completedBytes,
+        total: totalSize,
+        percentage: Math.round(completedBytes / totalSize * 1e4) / 100,
+        speed,
+        eta: speed > 0 ? (totalSize - completedBytes) / speed : Infinity,
+        completedChunks: results.filter(Boolean).length,
+        totalChunks: chunkUrls.length
+      });
+    };
+    const concurrency = Math.min(this.opts.maxConcurrency, chunkUrls.length);
+    let nextChunkIndex = 0;
+    const worker = async () => {
+      while (true) {
+        const ci = nextChunkIndex++;
+        if (ci >= chunkUrls.length) break;
+        const urls = chunkUrls[ci].slice(0, turboCDNs);
+        const data = await this.raceDownload(urls, nodes, turboCDNs);
+        results[ci] = data.buffer;
+        completedBytes += data.buffer.byteLength;
+        const existing = nodeContrib.get(data.winnerId) ?? { bytes: 0, chunks: 0 };
+        existing.bytes += data.buffer.byteLength;
+        existing.chunks++;
+        nodeContrib.set(data.winnerId, existing);
+        emitProgress();
+      }
+    };
+    const workers = Array.from({ length: concurrency }, () => worker());
+    await Promise.all(workers);
+    const parts = results.filter(Boolean);
+    if (parts.length !== chunkUrls.length) {
+      throw new Error(`Only downloaded ${parts.length}/${chunkUrls.length} chunks`);
+    }
+    const blob = new Blob(results, { type: contentType });
+    const contributions = /* @__PURE__ */ new Map();
+    for (const [id, c] of nodeContrib) {
+      contributions.set(id, { ...c, avgSpeed: 0 });
+    }
+    return {
+      blob,
+      totalSize,
+      totalTime: performance.now() - startTime,
+      nodeContributions: contributions,
+      usedParallelMode: true,
+      contentType
+    };
+  }
+  /** 多 CDN 竞速下载同一个 URL */
+  async raceDownload(urls, nodes, _count) {
+    const controllers = [];
+    const promises = urls.map(async (url, i) => {
+      const ctrl = new AbortController();
+      controllers.push(ctrl);
+      const tid = setTimeout(() => ctrl.abort(), this.opts.chunkTimeout);
+      try {
+        const resp = await fetch(url, { mode: "cors", signal: ctrl.signal });
+        clearTimeout(tid);
+        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+        const buffer = await resp.arrayBuffer();
+        return {
+          buffer,
+          winnerId: i < nodes.length ? nodes[i].id : `cdn-${i}`
+        };
+      } catch (err) {
+        clearTimeout(tid);
+        throw err;
+      }
+    });
+    try {
+      const result = await Promise.any(promises);
+      for (const ctrl of controllers) {
+        try {
+          ctrl.abort();
+        } catch {
+        }
+      }
+      return result;
+    } catch {
+      throw new Error("All CDN nodes failed for this chunk");
+    }
+  }
+  // ============================================================
+  // 辅助
+  // ============================================================
+  async fetchChunk(url) {
+    const ctrl = new AbortController();
+    const tid = setTimeout(() => ctrl.abort(), this.opts.chunkTimeout);
+    try {
+      const resp = await fetch(url, { mode: "cors", signal: ctrl.signal });
+      clearTimeout(tid);
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+      return await resp.arrayBuffer();
+    } catch (err) {
+      clearTimeout(tid);
+      throw err;
+    }
+  }
+  buildResult(tasks, contentType, startTime, balancer, parallel) {
+    const sorted = [...tasks].filter((t) => t.status === "completed" && t.data).sort((a, b) => a.chunk.index - b.chunk.index);
+    const blob = new Blob(sorted.map((t) => t.data), { type: contentType });
+    const contributions = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      if (task.status !== "completed") continue;
+      const existing = contributions.get(task.assignedNodeId) ?? { bytes: 0, chunks: 0, avgSpeed: 0 };
+      existing.bytes += task.data?.byteLength ?? 0;
+      existing.chunks++;
+      contributions.set(task.assignedNodeId, existing);
+    }
+    for (const [nodeId, stats] of contributions) {
+      const ws = balancer.getStats().get(nodeId);
+      if (ws && ws.totalTime > 0) {
+        stats.avgSpeed = ws.totalBytes / ws.totalTime * 1e3;
+      }
+    }
+    return {
+      blob,
+      totalSize: blob.size,
+      totalTime: performance.now() - startTime,
+      nodeContributions: contributions,
+      usedParallelMode: parallel,
+      contentType
+    };
+  }
+};
+function getPendingCount(tasks) {
+  const m = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    if (t.status === "pending" || t.status === "downloading") {
+      m.set(t.assignedNodeId, (m.get(t.assignedNodeId) ?? 0) + 1);
+    }
+  }
+  return m;
+}
+
+// src/core/fetcher.ts
+var ForgeEngine = class {
+  constructor(config) {
+    this.currentNodeId = null;
+    this.latencyResults = /* @__PURE__ */ new Map();
+    this.initialized = false;
+    /**
+     * "就绪" Promise — 第一个成功测速结果回来就 resolve
+     * reqByCDN 等方法 await 这个而不是等全部测完
+     */
+    this.readyResolve = null;
+    // info.yaml 缓存: filePath → SplitInfo | null
+    this.splitInfoCache = /* @__PURE__ */ new Map();
+    this.config = normalizeConfig(config);
+    this.tester = new CDNTester(this.config.testTimeout, this.config.testRetries);
+    this.fetcher = new ChunkedFetcher({
+      maxConcurrency: this.config.maxConcurrency,
+      chunkTimeout: this.config.chunkTimeout,
+      maxRetries: this.config.maxRetries,
+      enableWorkStealing: this.config.enableWorkStealing,
+      turboMode: this.config.turboMode,
+      turboConcurrentCDNs: this.config.turboConcurrentCDNs
+    });
+    this.readyPromise = new Promise((resolve) => {
+      this.readyResolve = resolve;
+    });
+    this.loadSelectedNode();
+    if (!this.currentNodeId && this.config.defaultNodeId) {
+      this.currentNodeId = this.config.defaultNodeId;
+    }
+    if (!this.currentNodeId) {
+      const first = this.getNodes().find((n) => n.enabled !== false);
+      if (first) this.currentNodeId = first.id;
+    }
+  }
+  // ---- 初始化 ----
+  /** 标记引擎已就绪 (第一个成功结果/不需要测速时) */
+  markReady() {
+    if (!this.initialized) {
+      this.initialized = true;
+      this.readyResolve?.();
+      this.readyResolve = null;
+    }
+  }
+  /**
+   * 等待引擎就绪 — 不等全部测完，只等第一个成功结果
+   * reqByCDN / buildUrl 内部使用
+   */
+  waitReady() {
+    return this.readyPromise;
+  }
+  async initialize() {
+    if (this.initialized) return;
+    if (this.config.autoTest) {
+      await this.testAndSelectBest();
+    }
+    this.markReady();
+  }
+  /**
+   * 流式初始化 — 每完成一个节点测速就回调
+   * 第一个**成功**结果到达时立刻标记 initialized，不等超时节点
+   * 剩余节点在后台继续测速
+   *
+   * @param onResult 每完成一个节点的回调
+   * @param onReady  第一个成功结果到达时触发（可选）
+   */
+  async initializeStreaming(onResult, onReady) {
+    if (this.initialized) return;
+    if (this.config.autoTest) {
+      await this.testAndSelectBest((r) => {
+        onResult(r);
+        if (r.success && !this.initialized) {
+          this.markReady();
+          onReady?.();
+        }
+      });
+    }
+    this.markReady();
+  }
+  // ---- 节点管理 ----
+  getNodes() {
+    return this.config.nodes;
+  }
+  getCurrentNode() {
+    return this.config.nodes.find((n) => n.id === this.currentNodeId) ?? null;
+  }
+  selectNode(nodeId) {
+    const node = this.config.nodes.find((n) => n.id === nodeId);
+    if (node) {
+      this.currentNodeId = nodeId;
+      this.saveSelectedNode(nodeId);
+      return node;
+    }
+    return null;
+  }
+  getSortedNodes() {
+    return getSortedNodesWithLatency(this.config.nodes, this.latencyResults);
+  }
+  getLatencyResults() {
+    return new Map(this.latencyResults);
+  }
+  // ---- 测速 ----
+  async testAndSelectBest(onResult) {
+    const results = onResult ? await this.testAllNodesStreaming((r) => {
+      const bestId2 = this.tester.getBestNodeId([...this.latencyResults.values()]);
+      if (bestId2) this.selectNode(bestId2);
+      onResult(r);
+    }) : await this.testAllNodes();
+    const bestId = this.tester.getBestNodeId(results);
+    if (bestId) this.selectNode(bestId);
+    return results;
+  }
+  async testAllNodes() {
+    const results = await this.tester.testAll(this.config.nodes);
+    this.latencyResults.clear();
+    for (const r of results) this.latencyResults.set(r.nodeId, r);
+    return results;
+  }
+  async testAllNodesStreaming(onResult) {
+    this.latencyResults.clear();
+    return this.tester.testAllStreaming(this.config.nodes, (r) => {
+      this.latencyResults.set(r.nodeId, r);
+      onResult(r);
+    });
+  }
+  // ---- URL 构建 ----
+  buildUrl(filePath) {
+    const node = this.getCurrentNode();
+    if (!node) throw new Error("No CDN node selected");
+    return node.buildUrl(this.config.github, filePath);
+  }
+  // ---- 核心: reqByCDN ----
+  /**
+   * 统一请求接口 — 对使用者完全透明
+   *
+   * @param filePath - GitHub 仓库中相对于根目录的文件路径
+   * @param onProgress - 进度回调
+   *
+   * 内部会自动判断:
+   * - 是否有切片版本 (在 splitStoragePath 下查找 info.yaml)
+   * - 如果有 → 并行下载分片 → 拼接
+   * - 如果没有 → 直接下载
+   */
+  async reqByCDN(filePath, onProgress) {
+    const startTime = performance.now();
+    if (!this.initialized) await this.waitReady();
+    const splitInfo = await this.tryGetSplitInfo(filePath);
+    if (splitInfo) {
+      return this.downloadSplit(filePath, splitInfo, startTime, onProgress);
+    }
+    return this.downloadDirect(filePath, startTime, onProgress);
+  }
+  // ============================================================
+  // 私有: 分片下载
+  // ============================================================
+  /** 尝试获取文件的切片信息 */
+  async tryGetSplitInfo(filePath) {
+    const { splitStoragePath, mappingPrefix } = this.config;
+    if (!splitStoragePath) return null;
+    if (this.splitInfoCache.has(filePath)) {
+      return this.splitInfoCache.get(filePath);
+    }
+    const mappedPath = this.mapFilePath(filePath, mappingPrefix);
+    const infoPath = `${splitStoragePath}/${mappedPath}/info.yaml`;
+    try {
+      const node = this.getCurrentNode() ?? this.getNodes()[0];
+      if (!node) return null;
+      const url = node.buildUrl(this.config.github, infoPath);
+      const ctrl = new AbortController();
+      const tid = setTimeout(() => ctrl.abort(), 1e4);
+      const resp = await fetch(url, { mode: "cors", signal: ctrl.signal });
+      clearTimeout(tid);
+      if (!resp.ok) {
+        this.splitInfoCache.set(filePath, null);
+        return null;
+      }
+      const text = await resp.text();
+      const info = parseInfoYaml(text);
+      this.splitInfoCache.set(filePath, info);
+      return info;
+    } catch {
+      this.splitInfoCache.set(filePath, null);
+      return null;
+    }
+  }
+  /** 下载切片并拼接 */
+  async downloadSplit(filePath, splitInfo, startTime, onProgress) {
+    const { splitStoragePath, mappingPrefix } = this.config;
+    const mappedPath = this.mapFilePath(filePath, mappingPrefix);
+    const enabledNodes = this.config.nodes.filter((n) => n.enabled !== false);
+    if (enabledNodes.length === 0) throw new Error("No CDN nodes available");
+    const chunkUrls = splitInfo.chunks.map((chunk) => {
+      const chunkPath = `${splitStoragePath}/${mappedPath}/${chunk.fileName}`;
+      return enabledNodes.map(
+        (node) => node.buildUrl(this.config.github, chunkPath)
+      );
+    });
+    const chunkSizes = splitInfo.chunks.map((c) => c.size);
+    const result = await this.fetcher.downloadChunks(
+      chunkUrls,
+      chunkSizes,
+      splitInfo.totalSize,
+      splitInfo.mimeType,
+      enabledNodes,
+      this.latencyResults,
+      onProgress
+    );
+    const blob = result.blob;
+    return {
+      blob,
+      arrayBuffer: () => blob.arrayBuffer(),
+      totalSize: result.totalSize,
+      totalTime: performance.now() - startTime,
+      contentType: result.contentType,
+      usedSplitMode: true,
+      usedParallelMode: result.usedParallelMode,
+      nodeContributions: result.nodeContributions
+    };
+  }
+  /** 直接下载 (无切片) */
+  async downloadDirect(filePath, startTime, onProgress) {
+    const node = this.getCurrentNode();
+    if (!node) throw new Error("No CDN node selected");
+    const url = node.buildUrl(this.config.github, filePath);
+    const ctrl = new AbortController();
+    const tid = setTimeout(() => ctrl.abort(), this.config.chunkTimeout * 3);
+    try {
+      const resp = await fetch(url, { mode: "cors", signal: ctrl.signal });
+      clearTimeout(tid);
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+      const contentLength = parseInt(resp.headers.get("Content-Length") ?? "0", 10);
+      const contentType = resp.headers.get("Content-Type") ?? "application/octet-stream";
+      let blob;
+      if (contentLength > 0 && resp.body && onProgress) {
+        blob = await this.readStreamWithProgress(
+          resp.body,
+          contentLength,
+          contentType,
+          startTime,
+          onProgress
+        );
+      } else {
+        blob = await resp.blob();
+        onProgress?.({
+          loaded: blob.size,
+          total: blob.size,
+          percentage: 100,
+          speed: 0,
+          eta: 0,
+          completedChunks: 1,
+          totalChunks: 1
+        });
+      }
+      return {
+        blob,
+        arrayBuffer: () => blob.arrayBuffer(),
+        totalSize: blob.size,
+        totalTime: performance.now() - startTime,
+        contentType,
+        usedSplitMode: false,
+        usedParallelMode: false,
+        nodeContributions: /* @__PURE__ */ new Map([[node.id, { bytes: blob.size, chunks: 1, avgSpeed: 0 }]])
+      };
+    } catch (err) {
+      clearTimeout(tid);
+      throw err;
+    }
+  }
+  /** 流式读取并报告进度 */
+  async readStreamWithProgress(body, total, contentType, startTime, onProgress) {
+    const reader = body.getReader();
+    const chunks = [];
+    let loaded = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      loaded += value.byteLength;
+      const elapsed = (performance.now() - startTime) / 1e3;
+      const speed = loaded / Math.max(elapsed, 1e-3);
+      onProgress({
+        loaded,
+        total,
+        percentage: Math.round(loaded / total * 1e4) / 100,
+        speed,
+        eta: speed > 0 ? (total - loaded) / speed : Infinity,
+        completedChunks: loaded >= total ? 1 : 0,
+        totalChunks: 1
+      });
+    }
+    return new Blob(chunks, { type: contentType });
+  }
+  // ============================================================
+  // 私有: 路径映射
+  // ============================================================
+  /**
+   * 映射文件路径
+   * 例: filePath="static/ass/loli.ass", prefix="static"
+   *   → "ass/loli.ass"
+   */
+  mapFilePath(filePath, prefix) {
+    let p = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+    if (prefix && p.startsWith(prefix)) {
+      p = p.slice(prefix.length);
+      if (p.startsWith("/")) p = p.slice(1);
+    }
+    return p;
+  }
+  // ============================================================
+  // 私有: 持久化
+  // ============================================================
+  loadSelectedNode() {
+    if (typeof window === "undefined") return;
+    try {
+      const id = localStorage.getItem(this.config.storageKey);
+      if (id) {
+        const node = this.config.nodes.find((n) => n.id === id);
+        if (node) this.currentNodeId = id;
+      }
+    } catch {
+    }
+  }
+  saveSelectedNode(nodeId) {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(this.config.storageKey, nodeId);
+    } catch {
+    }
+  }
+  // ============================================================
+  // 公开: 配置
+  // ============================================================
+  getConfig() {
+    return this.config;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  /** 清除 info.yaml 缓存 */
+  clearSplitInfoCache() {
+    this.splitInfoCache.clear();
+  }
+};
+var CDNCtx = react.createContext(null);
+function CDNProvider({
+  config,
+  children,
+  onInitialized,
+  onNodeChange
+}) {
+  const engineRef = react.useRef(null);
+  if (!engineRef.current) {
+    engineRef.current = new ForgeEngine(config);
+  }
+  const [currentNode, setCurrentNode] = react.useState(
+    () => engineRef.current?.getCurrentNode() ?? null
+  );
+  const [nodes, setNodes] = react.useState([]);
+  const [isTesting, setIsTesting] = react.useState(false);
+  const [latencyResults, setLatencyResults] = react.useState(/* @__PURE__ */ new Map());
+  const [isInitialized, setIsInitialized] = react.useState(false);
+  const isInitializedRef = react.useRef(false);
+  react.useEffect(() => {
+    isInitializedRef.current = isInitialized;
+  }, [isInitialized]);
+  react.useEffect(() => {
+    const engine = engineRef.current;
+    if (!engine) return;
+    let cancelled = false;
+    setNodes(engine.getSortedNodes());
+    setCurrentNode(engine.getCurrentNode());
+    const init = async () => {
+      setIsTesting(true);
+      setNodes(
+        (prev) => prev.map((n) => ({ ...n, latencyStatus: "testing", latency: void 0 }))
+      );
+      try {
+        await engine.initializeStreaming(
+          (result) => {
+            if (cancelled) return;
+            setLatencyResults(engine.getLatencyResults());
+            setNodes(engine.getSortedNodes().map((n) => {
+              const hasResult = engine.getLatencyResults().has(n.id);
+              if (!hasResult) return { ...n, latencyStatus: "testing", latency: void 0 };
+              return n;
+            }));
+            if (!cancelled) {
+              setCurrentNode(engine.getCurrentNode());
+            }
+          },
+          () => {
+            if (cancelled) return;
+            setCurrentNode(engine.getCurrentNode());
+            setIsInitialized(true);
+            onInitialized?.(engine.getCurrentNode());
+          }
+        );
+      } finally {
+        if (!cancelled) {
+          setCurrentNode(engine.getCurrentNode());
+          setNodes(engine.getSortedNodes());
+          setLatencyResults(engine.getLatencyResults());
+          setIsTesting(false);
+          if (!isInitializedRef.current) {
+            setIsInitialized(true);
+            onInitialized?.(engine.getCurrentNode());
+          }
+        }
+      }
+    };
+    init();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const selectNode = react.useCallback(
+    (nodeId) => {
+      const engine = engineRef.current;
+      if (!engine) return;
+      const node = engine.selectNode(nodeId);
+      if (node) {
+        setCurrentNode(node);
+        setNodes(engine.getSortedNodes());
+        onNodeChange?.(node);
+      }
+    },
+    [onNodeChange]
+  );
+  const testAllNodes = react.useCallback(async () => {
+    const engine = engineRef.current;
+    if (!engine) return [];
+    setIsTesting(true);
+    setNodes(
+      (prev) => prev.map((n) => ({ ...n, latencyStatus: "testing", latency: void 0 }))
+    );
+    try {
+      const results = await engine.testAllNodesStreaming((result) => {
+        setLatencyResults(engine.getLatencyResults());
+        setNodes(engine.getSortedNodes().map((n) => {
+          const hasResult = engine.getLatencyResults().has(n.id);
+          if (!hasResult) return { ...n, latencyStatus: "testing", latency: void 0 };
+          return n;
+        }));
+      });
+      setLatencyResults(engine.getLatencyResults());
+      setNodes(engine.getSortedNodes());
+      return results;
+    } finally {
+      setIsTesting(false);
+    }
+  }, []);
+  const reqByCDN = react.useCallback(
+    async (filePath, onProgress) => {
+      const engine = engineRef.current;
+      if (!engine) throw new Error("ForgeEngine not initialized");
+      return engine.reqByCDN(filePath, onProgress);
+    },
+    []
+  );
+  const buildUrl = react.useCallback((filePath) => {
+    const engine = engineRef.current;
+    if (!engine) return "";
+    try {
+      return engine.buildUrl(filePath);
+    } catch {
+      return "";
+    }
+  }, []);
+  const getSortedNodes = react.useCallback(() => {
+    const engine = engineRef.current;
+    if (!engine) return [];
+    return engine.getSortedNodes();
+  }, []);
+  const value = react.useMemo(
+    () => ({
+      config,
+      currentNode,
+      nodes,
+      isTesting,
+      isInitialized,
+      latencyResults,
+      selectNode,
+      testAllNodes,
+      reqByCDN,
+      buildUrl,
+      getSortedNodes
+    }),
+    [
+      config,
+      currentNode,
+      nodes,
+      isTesting,
+      isInitialized,
+      latencyResults,
+      selectNode,
+      testAllNodes,
+      reqByCDN,
+      buildUrl,
+      getSortedNodes
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(CDNCtx.Provider, { value, children });
+}
+function useCDN() {
+  const ctx = react.useContext(CDNCtx);
+  if (!ctx) throw new Error("useCDN() must be used within a <CDNProvider>");
+  return ctx;
+}
+function useCDNUrl(relativePath) {
+  const { buildUrl } = useCDN();
+  return buildUrl(relativePath);
+}
+function useCurrentCDNNode() {
+  const { currentNode } = useCDN();
+  return currentNode;
+}
+function useCDNStatus() {
+  return useCDN();
+}
+function useReqByCDN() {
+  const { reqByCDN } = useCDN();
+  return reqByCDN;
+}
+var ChevronDownIcon = () => /* @__PURE__ */ jsxRuntime.jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 20 20", fill: "currentColor", children: /* @__PURE__ */ jsxRuntime.jsx("path", { fillRule: "evenodd", d: "M5.22 8.22a.75.75 0 0 1 1.06 0L10 11.94l3.72-3.72a.75.75 0 1 1 1.06 1.06l-4.25 4.25a.75.75 0 0 1-1.06 0L5.22 9.28a.75.75 0 0 1 0-1.06Z", clipRule: "evenodd" }) });
+var RefreshIcon = () => /* @__PURE__ */ jsxRuntime.jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 20 20", fill: "currentColor", children: /* @__PURE__ */ jsxRuntime.jsx("path", { fillRule: "evenodd", d: "M15.312 11.424a5.5 5.5 0 0 1-9.201 2.466l-.312-.311h2.433a.75.75 0 0 0 0-1.5H4.598a.75.75 0 0 0-.75.75v3.634a.75.75 0 0 0 1.5 0v-2.033l.312.311a7 7 0 0 0 11.712-3.138.75.75 0 0 0-1.449-.39Zm-10.624-2.85a5.5 5.5 0 0 1 9.201-2.465l.312.31H11.77a.75.75 0 0 0 0 1.5h3.634a.75.75 0 0 0 .75-.75V3.536a.75.75 0 0 0-1.5 0v2.033l-.312-.31A7 7 0 0 0 2.63 8.384a.75.75 0 0 0 1.449.39l.609.8Z", clipRule: "evenodd" }) });
+var REGION_LABELS = {
+  china: "\u4E2D\u56FD\u5927\u9646",
+  asia: "\u4E9A\u592A",
+  global: "\u5168\u7403"
+};
+function getLatencyText(node) {
+  if (node.latencyStatus === "testing") return "\u6D4B\u901F\u4E2D";
+  if (node.latencyStatus === "failed" || node.latency !== void 0 && node.latency < 0) return "\u5931\u8D25";
+  if (node.latencyStatus === "idle" || node.latency === void 0) return "--";
+  return `${Math.round(node.latency)}ms`;
+}
+function getLatencyClassName(node) {
+  if (node.latencyStatus === "testing") return "latency-testing";
+  if (node.latencyStatus === "failed" || node.latency !== void 0 && node.latency < 0) return "latency-failed";
+  if (node.latencyStatus === "idle" || node.latency === void 0) return "latency-idle";
+  if (node.latency < 100) return "latency-excellent";
+  if (node.latency < 200) return "latency-good";
+  if (node.latency < 500) return "latency-normal";
+  return "latency-slow";
+}
+function CDNNodeSelector({
+  className = "",
+  style,
+  showLatency = true,
+  showRegion = true,
+  title,
+  showRefreshButton = true,
+  disabled = false,
+  compact = false,
+  onChange,
+  onTestComplete,
+  renderTrigger,
+  renderNode,
+  renderEmpty,
+  renderLoading
+}) {
+  const { currentNode, nodes, isTesting, isInitialized, selectNode, testAllNodes } = useCDN();
+  const isAutoSelecting = isTesting && !isInitialized;
+  const [isOpen, setIsOpen] = react.useState(false);
+  const containerRef = react.useRef(null);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    const handleClickOutside = (e) => {
+      if (containerRef.current && !containerRef.current.contains(e.target)) {
+        setIsOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, [isOpen]);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape") setIsOpen(false);
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [isOpen]);
+  const handleSelect = react.useCallback(
+    (nodeId) => {
+      if (disabled) return;
+      selectNode(nodeId);
+      const node = nodes.find((n) => n.id === nodeId);
+      if (node) onChange?.(node);
+      setIsOpen(false);
+    },
+    [disabled, selectNode, nodes, onChange]
+  );
+  const handleRefresh = react.useCallback(async () => {
+    if (disabled || isTesting) return;
+    const results = await testAllNodes();
+    onTestComplete?.(results);
+  }, [disabled, isTesting, testAllNodes, onTestComplete]);
+  const toggleOpen = react.useCallback(() => {
+    if (!disabled) setIsOpen((prev) => !prev);
+  }, [disabled]);
+  const currentNodeWithLatency = currentNode ? nodes.find((n) => n.id === currentNode.id) ?? { ...currentNode, latencyStatus: "idle" } : null;
+  const rootClassName = [
+    "cdn-node-selector",
+    compact ? "cdn-compact" : "",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: rootClassName, style, ref: containerRef, children: [
+    title && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cdn-selector-title", children: title }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "cdn-selector-container", children: [
+      renderTrigger ? /* @__PURE__ */ jsxRuntime.jsx("div", { onClick: toggleOpen, style: { flex: 1, cursor: disabled ? "not-allowed" : "pointer" }, children: renderTrigger({ currentNode, isOpen, isTesting }) }) : /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          className: `cdn-current-node${isAutoSelecting ? " cdn-auto-selecting" : ""}`,
+          onClick: toggleOpen,
+          disabled,
+          type: "button",
+          "aria-haspopup": "listbox",
+          "aria-expanded": isOpen,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cdn-node-info", children: isAutoSelecting ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "cdn-node-name cdn-auto-selecting-text", children: "\u81EA\u52A8\u9009\u62E9\u4E2D\u2026" }),
+              /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "cdn-node-region", style: { fontSize: "11px" }, children: [
+                "\u6B63\u5728\u6D4B\u901F\uFF0C\u4F7F\u7528\u4E34\u65F6\u8282\u70B9: ",
+                currentNode?.name ?? "\u2014"
+              ] })
+            ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "cdn-node-name", children: currentNode?.name ?? "\u672A\u9009\u62E9\u8282\u70B9" }),
+              showRegion && currentNode?.region && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "cdn-node-region", children: REGION_LABELS[currentNode.region] ?? currentNode.region })
+            ] }) }),
+            !isAutoSelecting && showLatency && currentNodeWithLatency && /* @__PURE__ */ jsxRuntime.jsx("span", { className: `cdn-latency ${getLatencyClassName(currentNodeWithLatency)}`, children: getLatencyText(currentNodeWithLatency) }),
+            isAutoSelecting && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "cdn-latency latency-testing", children: "\u6D4B\u901F\u4E2D" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: `cdn-selector-arrow ${isOpen ? "cdn-arrow-open" : ""}`, children: /* @__PURE__ */ jsxRuntime.jsx(ChevronDownIcon, {}) })
+          ]
+        }
+      ),
+      showRefreshButton && /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          className: `cdn-refresh-button ${isTesting ? "cdn-refreshing" : ""}`,
+          onClick: handleRefresh,
+          disabled: disabled || isTesting,
+          type: "button",
+          title: "\u5237\u65B0\u6D4B\u901F",
+          "aria-label": "\u5237\u65B0\u6D4B\u901F",
+          children: /* @__PURE__ */ jsxRuntime.jsx(RefreshIcon, {})
+        }
+      ),
+      isOpen && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cdn-node-list", role: "listbox", children: nodes.length === 0 ? renderEmpty ? renderEmpty() : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cdn-no-nodes", children: "\u6682\u65E0\u53EF\u7528\u8282\u70B9" }) : isTesting && renderLoading ? renderLoading() : nodes.map((node) => {
+        const isSelected = currentNode?.id === node.id;
+        const isDisabled = disabled || node.enabled === false;
+        const latencyText = getLatencyText(node);
+        const latencyClass = getLatencyClassName(node);
+        if (renderNode) {
+          return /* @__PURE__ */ jsxRuntime.jsx("div", { role: "option", "aria-selected": isSelected, children: renderNode({
+            node,
+            isSelected,
+            isDisabled,
+            latencyText,
+            latencyClassName: latencyClass,
+            onSelect: () => handleSelect(node.id)
+          }) }, node.id);
+        }
+        return /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            className: `cdn-node-option ${isSelected ? "cdn-node-selected" : ""} cdn-region-${node.region}`,
+            onClick: () => handleSelect(node.id),
+            disabled: isDisabled,
+            type: "button",
+            role: "option",
+            "aria-selected": isSelected,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "cdn-node-info", children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "cdn-node-name", children: node.name }),
+                showRegion && node.region && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "cdn-node-region", children: REGION_LABELS[node.region] ?? node.region }),
+                node.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "cdn-node-desc", children: node.description })
+              ] }),
+              showLatency && /* @__PURE__ */ jsxRuntime.jsx("span", { className: `cdn-latency ${latencyClass}`, children: latencyText })
+            ]
+          },
+          node.id
+        );
+      }) })
+    ] })
+  ] });
+}
+
+exports.CDNNodeSelector = CDNNodeSelector;
+exports.CDNProvider = CDNProvider;
+exports.CDNTester = CDNTester;
+exports.CDN_NODE_PRESETS = CDN_NODE_PRESETS;
+exports.ChunkedFetcher = ChunkedFetcher;
+exports.DEFAULTS = DEFAULTS;
+exports.DEFAULT_GITHUB_CDN_NODES = DEFAULT_GITHUB_CDN_NODES;
+exports.ForgeEngine = ForgeEngine;
+exports.REGION_LABELS = REGION_LABELS;
+exports.createForgeConfig = createForgeConfig;
+exports.createWorkerNode = createWorkerNode;
+exports.getLatencyClassName = getLatencyClassName;
+exports.getLatencyText = getLatencyText;
+exports.getSortedNodesWithLatency = getSortedNodesWithLatency;
+exports.normalizeConfig = normalizeConfig;
+exports.parseCacheYaml = parseCacheYaml;
+exports.parseInfoYaml = parseInfoYaml;
+exports.serializeCacheYaml = serializeCacheYaml;
+exports.serializeInfoYaml = serializeInfoYaml;
+exports.useCDN = useCDN;
+exports.useCDNStatus = useCDNStatus;
+exports.useCDNUrl = useCDNUrl;
+exports.useCurrentCDNNode = useCurrentCDNNode;
+exports.useReqByCDN = useReqByCDN;