mslxdff 0.1.244 → 0.1.246

package/src/multi-ip-pool/dial.js

@@ -1,179 +0,0 @@
-// multi-ip-pool · 拨号与体检：候选队列 → 起一条隧道 → **打一个 hi 到上游要它 200** → 才算可用出口。
-//
-// 为什么"要 200"而不是"能连上就行"（用户 2026-10-25 定）：
-//   这条池的唯一目的是**换新额度**。隧道起来了但那个 IP 已经没额度（429/403），拿它换出口等于白换——
-//   所以判据必须是"这个出口现在真能出活"，即免费层 chat 打 `hi` 回 **200**。
-//   请求形状复用 `v6pool/selftest.js`（`stream:true` + 五核心工具名 + 身份四件套）：缺任何一项上游回
-//   **403 FreeTierError 而不是 429**，那测的是形状、不是额度（真机 2026-10-19 踩过）。
-// 拆成独立模块的原因：装配（index）、拨号（本文件）、备选池（standby）三件事各自都要单测，混一起必超 10KB 门。
-import { getUndici } from "../compat.js";
-import { DEFAULT_PROBE_MODEL, probeUpstreamFrom } from "../v6pool/selftest.js";
-import { loadNodeCache, materializeNode, sampleCandidates } from "./nodes.js";
-import { fetchNodes, probeExitIp } from "./nodes-fetch.js";
-import { bringUpTunnel, tearDownTunnel } from "./tunnel.js";
-import { AGENT_OPTIONS } from "./dispatch.js";
-import { fmtExitIpFail, fmtHi, fmtNodePick, fmtNodes } from "./report.js";
-
-/**
- * @param {{ cfg: object, baseUrl?: string, log?: Function, deps?: {
- *            bringUpTunnel?, tearDownTunnel?, materializeNode?, fetchNodes?, loadNodeCache?, probeExitIp?,
- *            probeHi?, agentFactory?, fetchImpl?, runCmdFn?, spawnFn?, wait?, authFile?, probeSession? } }} opts
- */
-export function createDialer({ cfg, baseUrl = "https://opencode.ai", log = () => {}, deps = {} } = {}) {
-  const startSlot = deps.bringUpTunnel || bringUpTunnel;
-  const stopSlot = deps.tearDownTunnel || tearDownTunnel;
-  const materialize = deps.materializeNode || materializeNode;
-  const probeExit = deps.probeExitIp || probeExitIp;
-  const probeHi = deps.probeHi || probeUpstreamFrom;
-  const { Agent } = getUndici();
-  const agentFactory = deps.agentFactory || ((addr) => new Agent({ connect: { localAddress: addr }, ...AGENT_OPTIONS }));
-
-  /** 本拨号器起过的所有隧道（含备用的）：退出钩子与 close 都从这儿收，一条都不许漏。 */
-  const tunnels = new Set();
-  const used = new Set(); // 已试过的节点（含正在用的）：绝不重复拨同一台
-  let pending = [];
-  let source = "(未取表)";
-  let authFile = deps.authFile || "";
-
-  function setAuthFile(f) {
-    authFile = f || "";
-  }
-
-  /** 探额度用的免费模型（上游不同模型额度池可能独立，需要时可换）。 */
-  function probeModel() {
-    return cfg.probeModel || DEFAULT_PROBE_MODEL;
-  }
-
-  /**
-   * 「打一个 hi，要 200」：一发请求同时拿两个读数——**有没有额度**（status）与**真实出口 IP**（取证）。
-   * @returns {Promise<{ok: boolean, status: number, kind: string, ms: number, ip: string, error: string}>}
-   */
-  async function hiProbe(entry) {
-    const r = await probeHi({
-      addr: entry.tunIp,
-      model: probeModel(),
-      baseUrl,
-      agentFactory,
-      fetchImpl: deps.fetchImpl,
-      session: deps.probeSession,
-    });
-    let ip = entry.exitIp || "";
-    if (!ip) {
-      const agent = agentFactory(entry.tunIp);
-      try {
-        const e = await probeExit({ agent, timeoutMs: cfg.probeTimeoutMs, fetchImpl: deps.fetchImpl });
-        ip = e.ip || "";
-      } finally {
-        try {
-          await agent.close?.();
-        } catch {
-          /* 一次性 Agent */
-        }
-      }
-    }
-    return { ok: Boolean(r.ok), status: Number(r.status) || 0, kind: r.kind || "", ms: Number(r.ms) || 0, ip, error: r.error || "" };
-  }
-
-  /** 取节点表 → 候选队列（Score 降序 + **按簇轮转**，剔除已用过的）；`force` = 绕过缓存重取（每小时刷新备选池用）。 */
-  async function ensureCandidates({ force = false } = {}) {
-    if (!force && pending.length) return pending.length;
-    let rows = [];
-    if (!force) {
-      const cache = (deps.loadNodeCache || loadNodeCache)({ dir: cfg.dir, ttlMs: cfg.nodesTtlMs });
-      if (cache?.rows?.length) {
-        rows = cache.rows;
-        source = cache.source || "(本地缓存)";
-      }
-    }
-    if (!rows.length) {
-      const got = await (deps.fetchNodes || fetchNodes)({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, log });
-      rows = got.rows;
-      source = got.source;
-    }
-    // 按簇轮转（见 nodes.js sampleCandidates）：免费表前列常被同一个机房霸榜，纯 Score 序会让「那一片连不上」
-    // 变成「池永远起不来」（真机 2026-10-25：三个候选同属 219.100.37.x）。轮转不丢节点，只是把各机房摊开。
-    pending = sampleCandidates({ rows, countries: cfg.countries, minScore: cfg.minScore, skip: used, limit: cfg.scan * (cfg.count + cfg.standby + 1) });
-    log(fmtNodes({ source, total: rows.length, countries: cfg.countries, minScore: cfg.minScore }));
-    return pending.length;
-  }
-
-  /** 拆一条隧道并忘掉它（先撤策略路由再收子进程，见 tunnel.js）。 */
-  async function drop(entry, why = "") {
-    if (!entry) return;
-    tunnels.delete(entry);
-    try {
-      await stopSlot({ slot: entry, runCmdFn: deps.runCmdFn, log });
-    } catch (e) {
-      log(`[multi-ip-pool] ${entry.dev} 拆隧道没拆干净：${String(e?.message || e)}${why ? `（${why}）` : ""}`);
-    }
-  }
-
-  /**
-   * 开一个出口：按序试候选，每个都走「起隧道 → hi 要 200」，**不 200 当场拆掉换下一个**。
-   * 为什么这道闸门必须有：隧道进程活着但转不动流量、或那个 IP 早已没额度时，把它塞进池等于
-   * 把请求挂到超时或继续 429——比直连更糟（与 WARP 池 probeGate 同一纪律）。
-   * @returns {Promise<null | { dev, table, priority, tunIp, pid, stop, node, exitIp }>}
-   */
-  async function openSlot(slotIndex, { dev = "", gate = true } = {}) {
-    for (let attempt = 1; attempt <= cfg.scan; attempt++) {
-      if (!pending.length) {
-        try {
-          await ensureCandidates();
-        } catch (e) {
-          log(`[multi-ip-pool] 取节点表失败：${String(e?.message || e)}`);
-          return null;
-        }
-        if (!pending.length) return null;
-      }
-      const row = pending.shift();
-      if (!row || used.has(row.hostName)) continue;
-      used.add(row.hostName);
-      log(fmtNodePick({ i: attempt, n: cfg.scan, row, dev }));
-      let slot = null;
-      try {
-        let node = row;
-        if (!node.conf) {
-          node = materialize({ dir: cfg.dir, row });
-          if (!node) throw new Error("节点配置解不开（base64 或 remote 缺失）");
-        }
-        slot = await startSlot({
-          cfg,
-          slotIndex,
-          node,
-          deps: { authFile, runCmdFn: deps.runCmdFn, spawnFn: deps.spawnFn, wait: deps.wait, log, onExit: () => tunnels.delete(slot) },
-        });
-        tunnels.add(slot);
-        const p = await hiProbe(slot);
-        log(fmtHi({ dev: slot.dev, model: probeModel(), ip: p.ip, ...p }));
-        if (!p.ip) log(fmtExitIpFail({ dev: slot.dev, error: p.error || "出口取证无响应" }));
-        if (gate && p.status !== 200) {
-          await drop(slot, "hi 未回 200");
-          continue;
-        }
-        return { ...slot, node, exitIp: p.ip || "" };
-      } catch (e) {
-        await drop(slot);
-        log(`[multi-ip-pool] ${slot?.dev || `${cfg.devPrefix}${slotIndex}`} 起隧道失败：${String(e?.message || e)}`);
-      }
-    }
-    return null;
-  }
-
-  return {
-    tunnels,
-    agentFactory,
-    used,
-    setAuthFile,
-    probeModel,
-    hiProbe,
-    ensureCandidates,
-    openSlot,
-    drop,
-    get sourceLabel() {
-      return source;
-    },
-    get pendingCount() {
-      return pending.length;
-    },
-  };
-}

package/src/multi-ip-pool/dispatch.js

@@ -1,244 +0,0 @@
-// multi-ip-pool · 槽位 dispatcher：每槽一条隧道 + 一个把源地址绑到 tun 地址的 undici Agent。
-//
-// 契约与 v6pool/warp-pool 的 dispatcher 完全一致：`dispatch(opts, handler)` + `close()`，
-// 注入点同为 transport 的 extDispatcher（legacy 与 SDK 两条路共用同一个对象）。
-// 与 v6 池的差别只在「换出口」这一步里干了什么：
-//   v6  ：换个源地址（≈0 成本）
-//   这里：拆掉旧隧道 + 用下一个 VPNGate 节点起新隧道（秒级；所以**绝不用于请求内换址**）
-//
-// 判决表复用 warp-pool/verdict.js（403 FreeTierError 与 429 FreeUsageLimitError 同判、强制换，
-// BlackUsageLimitError 绝不换）——与生产同源，不自造一套。
-import { getUndici } from "../compat.js";
-import { headerValue, tapHandler } from "../warp-pool/rotate.js";
-import { createSelector } from "../warp-pool/strategy.js";
-import { SIGNAL_STATUSES, classifyWarpSignal } from "../warp-pool/verdict.js";
-import { fmtDirect, fmtExitIp, fmtExitIpFail, fmtFirstOk, fmtNoRotate, fmtSwap, fmtSwapFail, fmtVerdictNo } from "./report.js";
-
-const SESSION_HEADER = "x-opencode-session";
-
-/** 每槽 Agent 的连接池参数（与 v6pool 同口径：注入 dispatcher 后 transport 不自带池）。 */
-export const AGENT_OPTIONS = { connections: 4, pipelining: 1, keepAliveTimeout: 30_000, keepAliveMaxTimeout: 60_000 };
-
-/** 误关旧 Agent 不影响新出口，但也不该静默吞掉（只在 debug 里报）。 */
-function closeQuietly(agent, log) {
-  try {
-    Promise.resolve(agent?.close?.()).catch((e) => log(`[multi-ip-pool] 关旧出口 Agent 失败：${String(e?.message || e)}`));
-  } catch (e) {
-    log(`[multi-ip-pool] 关旧出口 Agent 抛错：${String(e?.message || e)}`);
-  }
-}
-
-/**
- * @param {{ slots?: object[], strategy?: "session"|"request", cooldownMs?: number, rotate?: boolean,
- *           now?: () => number, log?: (s: string) => void,
- *           agentFactory?: (addr: string) => object, fallbackAgent?: object, agentOptions?: object,
- *           selector?: object, rebuild?: (index: number, prev: object) => Promise<object>,
- *           verifyExit?: (t: object) => Promise<{ ok: boolean, ip?: string, ms?: number, error?: string }> }} [opts]
- */
-export function createMultiIpDispatcher({
-  slots = [],
-  strategy = "session",
-  cooldownMs = 600_000,
-  rotate = true,
-  now = Date.now,
-  log = () => {},
-  agentFactory,
-  fallbackAgent,
-  agentOptions = AGENT_OPTIONS,
-  selector = createSelector({ strategy }),
-  rebuild = null,
-  verifyExit = null,
-} = {}) {
-  const { Agent } = getUndici();
-  if (typeof agentFactory !== "function") {
-    if (typeof Agent !== "function") throw new Error("undici Agent 不可用：无法建立多出口池");
-    agentFactory = (addr) => new Agent({ connect: { localAddress: addr }, ...agentOptions });
-  }
-  // 空池兜底 = 直连：池还没建好（或全槽不可用）时行为与未启用完全一致。
-  const fallback = fallbackAgent !== undefined ? fallbackAgent : typeof Agent === "function" ? new Agent(agentOptions) : null;
-
-  let list = [];
-  const history = [];
-  let directWarned = false;
-
-  function buildSlot(index, t) {
-    return {
-      index,
-      node: t.node || null,
-      dev: t.dev,
-      tunIp: t.tunIp || "",
-      table: t.table,
-      priority: t.priority,
-      stop: t.stop,
-      exitIp: t.exitIp || "",
-      agent: t.tunIp ? agentFactory(t.tunIp) : null,
-      cooldownUntil: 0,
-      swapping: false,
-      swaps: 0,
-      counts: {},
-      firstOkAt: 0,
-    };
-  }
-
-  /** 装上初始槽（bootstrap 探活通过后调用；空数组 = 池为空 ⇒ 直连兜底）。 */
-  async function setSlots(next = []) {
-    const old = list;
-    list = (next || []).map((t, i) => buildSlot(i, t));
-    for (const e of old) closeQuietly(e.agent, log);
-    return list.length;
-  }
-
-  function availableIndexes() {
-    const t = now();
-    return list.filter((e) => e.agent && e.cooldownUntil <= t && !e.swapping).map((e) => e.index);
-  }
-
-  function markFailure(index) {
-    const e = list[index];
-    if (!e) return;
-    e.cooldownUntil = now() + cooldownMs;
-  }
-
-  function markOk(index) {
-    const e = list[index];
-    if (e) e.cooldownUntil = 0;
-  }
-
-  /**
-   * 换该槽的出口：挑下一个候选节点起新隧道（rebuild 由 index.js 提供，含拆旧/起新/探活）。
-   * 失败时**绝不假装成功**：把该槽标记为无出口（tunIp 置空 ⇒ 不再被选中），并如实报错。
-   * @returns {Promise<{ok?: boolean, skipped?: boolean, from?: string, to?: string, reason?: string}>}
-   */
-  async function swap(index, verdict = {}) {
-    const e = list[index];
-    if (!e) return { skipped: true, reason: "槽不存在" };
-    if (e.swapping) return { skipped: true, reason: "该槽已在换出口中" };
-    if (!rebuild) return { skipped: true, reason: "没有配置换出口实现（rebuild）" };
-    e.swapping = true;
-    const prev = { dev: e.dev, tunIp: e.tunIp, node: e.node, agent: e.agent, stop: e.stop, exitIp: e.exitIp, counts: { ...e.counts }, swaps: e.swaps };
-    try {
-      const t = await rebuild(index, prev);
-      if (!t || !t.tunIp) throw new Error("换出口没拿到可用的新隧道");
-      const exit = verifyExit ? await verifyExit(t) : null;
-      e.node = t.node || null;
-      e.dev = t.dev || e.dev;
-      e.tunIp = t.tunIp;
-      e.table = t.table ?? e.table;
-      e.priority = t.priority ?? e.priority;
-      e.stop = t.stop || null;
-      e.exitIp = exit?.ip || t.exitIp || e.exitIp;
-      e.agent = agentFactory(t.tunIp);
-      e.cooldownUntil = 0;
-      e.swaps = prev.swaps + 1;
-      e.counts = {};
-      e.firstOkAt = 0;
-      closeQuietly(prev.agent, log);
-      log(fmtSwap({ dev: e.dev, from: prev.tunIp, to: e.tunIp, status: verdict.status, kind: verdict.kind, forced: verdict.forced, swaps: e.swaps }));
-      if (exit && !exit.ok) log(fmtExitIpFail({ dev: e.dev, error: exit.error }));
-      else if (exit) log(fmtExitIp({ dev: e.dev, ip: exit.ip, ms: exit.ms, prev: prev.exitIp }));
-      history.push({ dev: e.dev, tunIp: e.tunIp, swaps: e.swaps, counts: { ...prev.counts }, exitIp: e.exitIp });
-      if (history.length > 32) history.shift();
-      return { ok: true, from: prev.tunIp, to: e.tunIp, node: e.node };
-    } catch (err) {
-      // 旧隧道可能已经被拆掉了 ⇒ 这槽当前没有出口，必须置空（否则会被选中并挂到超时）
-      e.agent = null;
-      e.tunIp = "";
-      e.cooldownUntil = now() + cooldownMs;
-      log(fmtSwapFail({ dev: prev.dev, error: String(err?.message || err) }));
-      return { skipped: false, error: String(err?.message || err) };
-    } finally {
-      e.swapping = false;
-    }
-  }
-
-  /** 上游响应旁听：记账 → 换出口后首个 200 的取证行 → 配额信号才换出口。 */
-  function onTap(signal, e) {
-    const status = Number(signal?.status);
-    e.counts[status] = (e.counts[status] || 0) + 1;
-    if (status === 200 && !e.firstOkAt) {
-      e.firstOkAt = now();
-      log(fmtFirstOk({ dev: e.dev, ip: e.exitIp || e.tunIp, swaps: e.swaps, counts: e.counts }));
-    }
-    if (!SIGNAL_STATUSES.includes(status)) return;
-    const v = classifyWarpSignal(signal);
-    if (!rotate) {
-      log(fmtNoRotate({ dev: e.dev, status, kind: v.kind }));
-      return;
-    }
-    if (!v.rotate) {
-      log(fmtVerdictNo({ dev: e.dev, status, kind: v.kind, why: v.why }));
-      return;
-    }
-    const dev = e.dev;
-    void swap(e.index, { ...v, status }).catch((err) => log(fmtSwapFail({ dev, error: String(err?.message || err) })));
-  }
-
-  return {
-    /** 每次请求调一次 = 选槽粒度（session 策略下同会话粘同一出口）。 */
-    dispatch(opts, handler) {
-      const avail = availableIndexes();
-      if (!avail.length) {
-        // 空池/全槽不可用 ⇒ 直连兜底（行为与未启用一致），绝不硬派给已知不可用的槽。
-        if (!list.length || !list.some((e) => e.agent)) {
-          if (fallback) return fallback.dispatch(opts, handler);
-          throw new Error("multi-ip-pool：出口池为空且无直连兜底");
-        }
-        if (!directWarned) {
-          directWarned = true;
-          log(fmtDirect({ reason: `全部 ${list.length} 条隧道都在冷却/换出口中（下一条恢复后自动回到池内）` }));
-        }
-        return (fallback || list[0].agent).dispatch(opts, handler);
-      }
-      directWarned = false;
-      const sessionKey = strategy === "session" ? headerValue(opts?.headers, SESSION_HEADER) : "";
-      const e = list[selector.pick(avail, sessionKey)];
-      return e.agent.dispatch(opts, tapHandler(handler, (sig) => onTap(sig, e)));
-    },
-
-    setSlots,
-
-    /** 手动换某槽出口（供运维/测试；正常路径由配额信号触发）。 */
-    swap,
-
-    /** 只读快照（换出口后首个 200 是否出现 = 「换 IP 有没有换来新额度」的证据）。 */
-    stats() {
-      const t = now();
-      return {
-        slots: list.map((e) => ({
-          dev: e.dev,
-          tunIp: e.tunIp,
-          exitIp: e.exitIp,
-          node: e.node?.hostName || "",
-          cooling: e.cooldownUntil > t,
-          swapping: e.swapping,
-          swaps: e.swaps,
-          counts: { ...e.counts },
-          firstOk: !!e.firstOkAt,
-        })),
-        history: history.map((h) => ({ ...h, counts: { ...h.counts } })),
-      };
-    },
-
-    entries() {
-      return list.map((e) => ({ index: e.index, dev: e.dev, tunIp: e.tunIp, cooldownUntil: e.cooldownUntil, swaps: e.swaps }));
-    },
-
-    async close() {
-      const old = list;
-      list = [];
-      for (const e of old) closeQuietly(e.agent, log);
-      if (fallback) closeQuietly(fallback, log);
-    },
-
-    async destroy() {
-      return this.close();
-    },
-
-    markFailure,
-    markOk,
-
-    get size() {
-      return list.length;
-    },
-  };
-}

package/src/multi-ip-pool/index.js

@@ -1,174 +0,0 @@
-// multi-ip-pool · 装配入口（MODULES.md §0/§2）：只做「门 + 接线 + 生命周期」，
-// 拨号与体检在 dial.js、备选池在 standby.js、选槽与换槽在 dispatch.js（每件事各自可单测）。
-//
-// 定位：**只有组长启用的第三.种出口源**——用 VPNGate 免费 OpenVPN 节点换出口 IP，专供 opencode 免费层。
-// 用户 2026-10-25 的四条裁决（本文件的形状就是这四条）：
-//   ① 只有组长建池（组员与没带组的单机都不建，强开需显式 MODE=leader）；
-//   ② 只有 Linux（tun 设备 + ip rule）；
-//   ③ 定时预拨**不多于 5** 条备选 IP（缺省每小时重拨一批），429 一到立即启用备胎，不现场拨号；
-//   ④ 启用备用 IP 时**打一个 hi 到 opencode.ai，要它 200** —— 没 200 的出口不算可用，也不配当备用。
-//
-// 门（任一不过 ⇒ 返回 null，调用方据此不注入，行为与未启用完全一致）：
-//   开关 → 角色 → 平台 → root → openvpn 可执行（最后一条在 bootstrap 里判，绝不阻塞启动）。
-import { resolveMultiIpConfig, resolveRole } from "./config.js";
-import { createDialer } from "./dial.js";
-import { createStandby } from "./standby.js";
-import { createMultiIpDispatcher as createDispatcher } from "./dispatch.js";
-import { writeAuthFile } from "./nodes.js";
-import { checkOpenvpn, isRoot, isSupportedPlatform } from "./tunnel.js";
-import { fmtClose, fmtConfig, fmtDisabled, fmtNoOpenvpn, fmtNoRoot, fmtPlatformSkip, fmtPool, fmtPoolEmpty, fmtRoleOk, fmtRoleSkip } from "./report.js";
-import { loadGroupsJoined } from "../state.js";
-
-/**
- * @param {{ env?: object, baseUrl?: string, log?: (s: string) => void,
- *           deps?: { joined?, platform?, supported?, isRoot?, checkOpenvpn?, authFile?, schedule?, cancel?,
- *                    bringUpTunnel?, tearDownTunnel?, materializeNode?, fetchNodes?, loadNodeCache?,
- *                    probeExitIp?, probeHi?, agentFactory?, fetchImpl?, runCmdFn?, spawnFn?, wait?, exitHook? } }} [opts]
- * @returns {null | { dispatcher, standby, ready, config, role, close, stats }}
- */
-export function createMultiIpPool({ env = process.env, baseUrl = "https://opencode.ai", log = (m) => console.error(m), deps = {} } = {}) {
-  const cfg = resolveMultiIpConfig(env);
-  if (!cfg.enabled) {
-    log(fmtDisabled());
-    return null;
-  }
-  // ① 角色门：只有组长（裁决 2026-10-25，从"组长或单机"收紧为"只有组长"）
-  const role = resolveRole({ mode: cfg.mode, joined: deps.joined ?? loadGroupsJoined() });
-  if (!role.active) {
-    log(fmtRoleSkip(role));
-    return null;
-  }
-  // ② 平台门：只有 Linux
-  const platform = deps.platform || process.platform;
-  if (!(deps.supported ?? isSupportedPlatform(platform))) {
-    log(fmtPlatformSkip({ platform, why: "本功能只在 Linux 上可用" }));
-    return null;
-  }
-  // ③ 权限门
-  if (!(deps.isRoot ?? isRoot)()) {
-    log(fmtNoRoot());
-    return null;
-  }
-  log(fmtConfig(cfg));
-  log(fmtRoleOk(role));
-
-  const dialer = createDialer({ cfg, baseUrl, log, deps });
-  const standby = createStandby({ cfg, log, dialer, schedule: deps.schedule, cancel: deps.cancel, now: deps.now });
-  let closed = false;
-
-  const dispatcher = createDispatcher({
-    slots: [],
-    strategy: cfg.strategy,
-    cooldownMs: cfg.cooldownMs,
-    rotate: cfg.rotate,
-    log,
-    agentFactory: dialer.agentFactory,
-    /**
-     * 换出口（429 路径）：**先用备选池里已验通的备胎**（裁决③的"立即启用"），
-     * 备胎为空才现场拨一条新的（拨号内部同样要过 hi 200 闸门）。
-     * 旧隧道在拿到新出口**之后**才拆：换出口全程都有一条能用的出口，不把池打空。
-     */
-    rebuild: async (index, prev) => {
-      const spare = cfg.standby ? await standby.take() : null;
-      const opened = spare || (await dialer.openSlot(index, { dev: prev?.dev || "" }));
-      if (!opened) throw new Error("备选池为空且候选节点都没通过 hi 验，本槽暂时没有出口");
-      if (prev) await dialer.drop(prev, "换出口后拆旧隧道");
-      return opened;
-    },
-  });
-
-  async function bootstrap() {
-    if (closed) return;
-    const openvpn = await (deps.checkOpenvpn || checkOpenvpn)(cfg.openvpnBin, { runCmdFn: deps.runCmdFn });
-    if (!openvpn.ok) {
-      log(fmtNoOpenvpn({ bin: cfg.openvpnBin, why: openvpn.why }));
-      return;
-    }
-    dialer.setAuthFile(deps.authFile || writeAuthFile({ dir: cfg.dir, user: cfg.authUser, pass: cfg.authPass }));
-
-    try {
-      await dialer.ensureCandidates();
-    } catch (e) {
-      log(fmtPoolEmpty({ tried: 0, why: `节点表取不到：${String(e?.message || e)}` }));
-      return;
-    }
-
-    const slots = [];
-    for (let i = 0; i < cfg.count; i++) {
-      if (closed) return;
-      const opened = await dialer.openSlot(i);
-      if (!opened) break;
-      slots.push(opened);
-    }
-    if (slots.length) {
-      await dispatcher.setSlots(slots);
-      log(fmtPool({ pooled: slots.length, tried: dialer.used.size, exits: slots.map((s) => s.exitIp || "(未取证)") }));
-    } else {
-      log(fmtPoolEmpty({ tried: dialer.used.size, why: "候选节点都没起通、或起来后 hi 拿不到 200（可能被墙 / 节点已下线 / 额度被同出口的其他人吃光）" }));
-    }
-
-    // ③ 备选池：正式槽成没成都要起（备胎本身就是"下一次 429 的出口"），并按小时刷新
-    if (cfg.standby) {
-      standby.start();
-      void standby.refill({ force: true }).catch((e) => log(`[multi-ip-pool] 备选池首轮补位失败：${String(e?.message || e)}`));
-    }
-  }
-
-  // 退出兜底：daemon 被强杀时 `exit` 钩子仍会跑；这里只能做同步事——把每条隧道的子进程都收掉
-  // （openvpn 子进程留着 = 白占 tun 设备与策略路由表，下次启动还得人工清）。
-  if (deps.exitHook !== false) {
-    process.once("exit", () => {
-      closed = true;
-      for (const t of dialer.tunnels) {
-        try {
-          t.stop?.();
-        } catch {
-          /* 已经退了 */
-        }
-      }
-    });
-  }
-
-  const ready = bootstrap().catch((e) => log(`[multi-ip-pool] bootstrap 失败：${String(e?.message || e)}`));
-
-  return {
-    dispatcher,
-    standby,
-    ready,
-    config: cfg,
-    role,
-    async close() {
-      if (closed) return;
-      closed = true;
-      await standby.stop().catch(() => {}); // 先停定时器，免得收摊路上又补出一批
-      let failed = 0;
-      const all = [...dialer.tunnels];
-      for (const t of all) {
-        try {
-          await dialer.drop(t, "收摊");
-        } catch {
-          failed += 1;
-        }
-      }
-      await dispatcher.close();
-      log(fmtClose({ closed: all.length - failed, failed }));
-    },
-    stats() {
-      return {
-        enabled: true,
-        role: role.role,
-        count: cfg.count,
-        standbyWant: cfg.standby,
-        tunnels: dialer.tunnels.size,
-        dir: cfg.dir,
-        standby: standby.stats(),
-        ...dispatcher.stats(),
-      };
-    },
-  };
-}
-
-/** 只取 dispatcher 的便捷入口；未启用时返回 undefined（调用方直接透传即"关闭态"）。 */
-export function createMultiIpDispatcher(opts) {
-  return createMultiIpPool(opts)?.dispatcher;
-}