mslxdff 0.1.244 → 0.1.246

package/src/v6pool/detect.js

@@ -1,130 +0,0 @@
-// v6pool · 自动判断本机有没有可用的 IPv6 池（纯解析 + 可注入 IO，便于单测）。
-//
-// 四关，任一不过就诚实跳过（并给出「下一步该跑什么」）：
-//   ① 平台：只有 Linux 能读 /proc 并用 ip 命令（与 wireproxy 预编译平台限制同口径）；
-//   ② 地址：/proc/net/if_inet6 里必须有 scope=global 的地址；
-//   ③ 前缀：该地址的前缀主机位 ≥ minHostBits（/128 只有 1 个地址，不构成池）；
-//   ④ 认领：ip_nonlocal_bind=1（直接 bind，零改动）或 root（能 ip addr add）。
-//
-// ⚠ 本模块**不假装知道**「整段有没有真路由到本机」——那只能靠 probe.js 从池里的地址实测。
-// 内核接受地址（bind 成功）≠ 机房把回包送回来；两者混为一谈正是「池看起来就绪、请求全黑洞」的根因。
-import { readFileSync } from "node:fs";
-import { formatV6, hostBitsOf, networkOf, parsePrefix, parseV6 } from "./prefix.js";
-
-/** /proc/net/if_inet6 的 scope 列：00=global、10=host、20=link、40=site（都是 hex）。 */
-export const SCOPE_GLOBAL = 0;
-
-/** 解析 /proc/net/if_inet6：`<32 位 hex 地址> <ifindex> <prefixlen> <scope> <flags> <网卡>`。 */
-export function parseIfInet6(raw) {
-  const out = [];
-  for (const line of String(raw ?? "").split("\n")) {
-    const f = line.trim().split(/\s+/);
-    if (f.length < 6 || !/^[0-9a-f]{32}$/i.test(f[0])) continue;
-    const addr = parseV6(f[0].toLowerCase().match(/.{4}/g).join(":"));
-    if (addr === null) continue;
-    out.push({
-      addr,
-      text: formatV6(addr),
-      ifindex: parseInt(f[1], 16),
-      bits: parseInt(f[2], 16),
-      scope: parseInt(f[3], 16),
-      iface: f[5],
-    });
-  }
-  return out;
-}
-
-function skip(reason, hint) {
-  return { ok: false, reason, hint };
-}
-
-/**
- * 四关判定：把「本机事实」变成「可用池 或 具体跳过原因」。
- * 全部依赖注入（测试不用真读 /proc、不用真 root）。
- */
-export function pickPool({
-  entries = [],
-  nonlocalBind = 0,
-  uid = -1,
-  platform = process.platform,
-  explicitPrefix = "",
-  explicitIface = "",
-  minHostBits = 8,
-  claim = "auto",
-} = {}) {
-  if (platform !== "linux") {
-    return skip(`本平台（${platform}）不支持：需要 Linux 的 /proc 与 ip 命令`, "非 Linux 机器不需要本功能（WARP 池同样只在 Linux 可用）");
-  }
-  const globals = entries.filter((e) => e.scope === SCOPE_GLOBAL);
-  let addr;
-  let bits;
-  let iface;
-  let source;
-  if (explicitPrefix) {
-    const p = parsePrefix(explicitPrefix);
-    if (!p) return skip(`MSLXDFF_V6_PREFIX 解析失败：${explicitPrefix}`, "格式形如 2001:db8:1:2::/64");
-    addr = p.addr;
-    bits = p.bits;
-    source = "env";
-    iface = explicitIface || globals[0]?.iface || "";
-  } else {
-    if (!globals.length) {
-      return skip("本机没有任何全局 IPv6 地址（只有 link-local / loopback）", "确认网卡上启用了 IPv6，且运营商或机房确实给了 IPv6");
-    }
-    const picked = (explicitIface && globals.find((e) => e.iface === explicitIface)) || globals[0];
-    addr = picked.addr;
-    bits = picked.bits;
-    iface = explicitIface || picked.iface;
-    source = "proc";
-  }
-  const hostBits = hostBitsOf(bits);
-  if (hostBits < minHostBits) {
-    return skip(
-      `前缀 /${bits} 只有 ${hostBits} 位主机位（< ${minHostBits}），不构成池`,
-      `该地址是 /${bits}：整段没路由到本机时换不了 IP。若确认整段可用，用 MSLXDFF_V6_PREFIX=<段>/<位数> 显式指定`,
-    );
-  }
-  const mode = claim === "auto" ? (nonlocalBind === 1 ? "bind" : uid === 0 ? "add" : "none") : claim;
-  if (mode === "bind" && nonlocalBind !== 1) {
-    return skip("MSLXDFF_V6_CLAIM=bind 但 net.ipv6.ip_nonlocal_bind≠1", "sysctl -w net.ipv6.ip_nonlocal_bind=1，或改用 MSLXDFF_V6_CLAIM=add");
-  }
-  if (mode === "add" && uid !== 0) {
-    return skip(`MSLXDFF_V6_CLAIM=add 需要 root（当前 uid=${uid}）`, "以 root 跑 daemon，或 sysctl -w net.ipv6.ip_nonlocal_bind=1 后设 MSLXDFF_V6_CLAIM=bind");
-  }
-  if (mode === "none") {
-    return skip("既没有 ip_nonlocal_bind=1，也不是 root ⇒ 内核会拒绝 bind 池里的地址（EADDRNOTAVAIL）", "二选一：sysctl -w net.ipv6.ip_nonlocal_bind=1，或以 root 跑（可 ip addr add）");
-  }
-  return {
-    ok: true,
-    addr,
-    bits,
-    iface,
-    hostBits,
-    mode,
-    source,
-    prefix: `${formatV6(networkOf(addr, bits))}/${bits}`,
-    /** 本机自己的全局地址：造池时避开它们（别把机器正在用的地址当池里的"新"地址） */
-    mine: globals.map((e) => e.text),
-  };
-}
-
-/** 真机路径：读 /proc 与 /proc/sys（可整体注入，测试零 IO）。 */
-export function detectPool({ cfg = {}, entries, nonlocalBind, uid, platform = process.platform, readFile = (p) => readFileSync(p, "utf8") } = {}) {
-  const read = (p, dflt) => {
-    try {
-      return readFile(p);
-    } catch {
-      return dflt;
-    }
-  };
-  return pickPool({
-    entries: entries ?? parseIfInet6(read("/proc/net/if_inet6", "")),
-    nonlocalBind: nonlocalBind ?? (Number(String(read("/proc/sys/net/ipv6/ip_nonlocal_bind", "0")).trim()) || 0),
-    uid: uid ?? (typeof process.getuid === "function" ? process.getuid() : -1),
-    platform,
-    explicitPrefix: cfg.prefix || "",
-    explicitIface: cfg.iface || "",
-    minHostBits: cfg.minHostBits || 8,
-    claim: cfg.claim || "auto",
-  });
-}

package/src/v6pool/index.js

@@ -1,157 +0,0 @@
-// v6pool · 装配入口（MODULES.md §0/§1）。
-//
-// 定位：**自动判断**本机有没有可用的 IPv6 池；有就启用（出口 = 池里的源地址），
-// 没有就诚实跳过一行日志（行为与今天完全一致）。缺省开，MSLXDFF_V6_POOL=0 关。
-//
-// 与 WARP 池的关系：v6 池可用 ⇒ 不建 WARP 池（v6 严格更优：地址无限、零子进程、换址成本≈0）；
-// 检测通过但探活全失败 ⇒ 池为空 ⇒ dispatcher 走直连兜底，日志点名 MSLXDFF_V6_POOL=0 可恢复 WARP。
-import { getUndici } from "../compat.js";
-import { resolveV6Config } from "./config.js";
-import { detectPool } from "./detect.js";
-import { createClaimer } from "./claim.js";
-import { createV6Dispatcher } from "./rotate.js";
-import { probeFrom } from "./probe.js";
-import { randomAddress } from "./prefix.js";
-import { fmtClose, fmtConfig, fmtDetect, fmtDisabled, fmtPool, fmtPoolEmpty, fmtProbe, fmtReadyFail, fmtSkip } from "./report.js";
-import { createWarpDispatcher } from "../warp-pool/index.js";
-import { createMultiIpDispatcher } from "../multi-ip-pool/index.js";
-
-/** 每槽 Agent 的连接池参数。注入 dispatcher 后 transport 不建自带池（transport/index.js L28），所以必须自带。 */
-export const AGENT_OPTIONS = { connections: 4, pipelining: 1, keepAliveTimeout: 30_000, keepAliveMaxTimeout: 60_000 };
-
-/** 初始地址集的去重重试上限（前缀足够大时一次就成）。 */
-export const DISTINCT_TRIES = 16;
-
-/**
- * 建池。检测不过 / 平台不支持 / 无权限 / undici 缺失 ⇒ 返回 null（调用方据此不注入、退回原行为）。
- * @returns {null | { dispatcher: object, ready: Promise<void>, config: object, detect: object,
- *                    close: () => Promise<void>, stats: () => object }}
- */
-export function createV6Pool({ env = process.env, baseUrl = "https://opencode.ai", log = (m) => console.error(m), deps = {} } = {}) {
-  const cfg = resolveV6Config(env);
-  if (!cfg.enabled) {
-    log(fmtDisabled());
-    return null;
-  }
-  log(fmtConfig(cfg));
-
-  const d = deps.detect ? deps.detect(cfg) : detectPool({ cfg, env });
-  if (!d.ok) {
-    log(fmtSkip(d));
-    return null;
-  }
-  log(fmtDetect(d));
-
-  const { Agent } = getUndici();
-  if (typeof Agent !== "function") {
-    log(fmtReadyFail({ error: "undici Agent 不可用（未安装 undici 且 Node <18）" }));
-    return null;
-  }
-
-  const prefix = { addr: d.addr, bits: d.bits };
-  const mine = new Set(d.mine || []);
-  const agentFactory = deps.agentFactory || ((addr) => new Agent({ connect: { localAddress: addr }, ...AGENT_OPTIONS }));
-  const claimer = deps.claimer ? deps.claimer(d) : createClaimer({ iface: d.iface, mode: d.mode, dir: cfg.dir, log });
-  const probe = deps.probe || probeFrom;
-
-  /** 挑一个池内地址：避开本机自己的全局地址（别把机器正在用的地址当"新"地址）。 */
-  function pickAddress() {
-    for (let i = 0; i < DISTINCT_TRIES; i++) {
-      const a = randomAddress(prefix);
-      if (!mine.has(a)) return a;
-    }
-    return randomAddress(prefix);
-  }
-
-  const dispatcher = createV6Dispatcher({
-    addrs: [],
-    strategy: cfg.strategy,
-    retireMs: cfg.retireMs,
-    rotate: cfg.rotate,
-    debug: cfg.debug,
-    log,
-    claimer,
-    pickAddress,
-    agentFactory,
-  });
-
-  let closed = false;
-  const ready = (async () => {
-    try {
-      await claimer.sweepStale();
-      const addrs = [];
-      const taken = new Set();
-      for (let i = 0; i < cfg.count; i++) {
-        if (closed) return;
-        let a = pickAddress();
-        for (let k = 0; k < DISTINCT_TRIES && taken.has(a); k++) a = pickAddress();
-        await claimer.ensure(a);
-        taken.add(a);
-        addrs.push(a);
-      }
-      // 逐个实证探活：内核接受了地址 ≠ 机房把整段路由到本机。探不通的当场释放，绝不进池。
-      const passed = [];
-      for (let i = 0; i < addrs.length; i++) {
-        if (closed) return;
-        const r = await probe({ addr: addrs[i], baseUrl, path: cfg.probePath, agentFactory });
-        log(fmtProbe({ addr: addrs[i], i: i + 1, n: addrs.length, ...r }));
-        if (r.ok) passed.push(addrs[i]);
-        else await claimer.release(addrs[i]);
-      }
-      if (!passed.length) {
-        log(fmtPoolEmpty({ tried: addrs.length }));
-        return;
-      }
-      dispatcher.setAddresses(passed);
-      log(fmtPool({ prefix: d.prefix, addrs: passed, claimed: addrs.length, mode: d.mode }));
-    } catch (e) {
-      log(fmtReadyFail({ error: String(e?.message || e) }));
-    }
-  })();
-
-  // 退出钩子：`process.on("exit")` 里只能跑同步代码，但地址必须清——加进网卡的地址会改变内核的
-  // 默认源地址选择，影响同机其它服务（本轮手工实测踩过）。清不掉就交给下次启动的 sweepStale。
-  if (deps.exitHook !== false) {
-    process.once("exit", () => {
-      try {
-        claimer.releaseAllSync?.();
-      } catch {
-        /* 清残留兜底见 claim.js 的 sweepStale */
-      }
-    });
-  }
-
-  return {
-    dispatcher,
-    ready,
-    config: cfg,
-    detect: d,
-    async close() {
-      if (closed) return;
-      closed = true;
-      await dispatcher.close();
-      const released = await claimer.releaseAll();
-      log(fmtClose({ released }));
-    },
-    stats() {
-      return { enabled: true, mode: d.mode, prefix: d.prefix, iface: d.iface, claimed: claimer.claimed(), ...dispatcher.stats() };
-    },
-  };
-}
-
-/**
- * 出口池三选一（唯一接线点用）：v6 池 → 多出口池 → WARP 池。
- * 三者都只产出一个 dispatcher 对象，注入点与契约完全一致（见 MODULES.md §1）。
- * 放在这里而不是 providers-setup：那里是 10KB 硬门下的文件，多一行都是风险。
- */
-export function createPreferredDispatcher({ baseUrl = "https://opencode.ai", env = process.env, log, deps = {} } = {}) {
-  const pool = createV6Pool({ env, baseUrl, log, deps });
-  if (pool) return pool.dispatcher;
-  // 次选：多出口池（VPNGate 免费 OpenVPN 节点当出口，只组长/单机建）——它给的是**另一批真实出口 IP**，
-  // 而 v6 只是本机自带的那段地址，所以 v6 优先、它次之。任一不可用都安静跳过（各自打自己的日志）。
-  const multi = createMultiIpDispatcher({ env, baseUrl, log, deps: deps.multiIp });
-  if (multi) return multi;
-  // 单向依赖：warp-pool 不 import v6pool（见 MODULES.md §2「已知耦合」）。
-  return createWarpDispatcher({ baseUrl, env, log });
-}
-

package/src/v6pool/prefix.js

@@ -1,140 +0,0 @@
-// v6pool · IPv6 前缀算术（纯函数，零 IO）：解析 / 规范化 / 取网络号 / 随机主机号。
-//
-// 为什么自己写：Node 没有内建 IPv6 前缀算术（`net.isIPv6` 只判形状），
-// 而本功能的核心动作就是「在给定前缀里造一个合法、不与现有地址撞车的主机号」。
-// 卫生规则（跳过 0/1/全 1、扰动 EUI-64 的 ff:fe 标记）照抄 v6pool 的 sanitizeHost——
-// 那几条是为了让出口地址看起来不像 SLAAC 自生成的地址（v6pool 的「unlinkable exits」）。
-const M16 = 0xffffn;
-
-/** 解析 IPv6 字面量 → BigInt(128bit)。非法返回 null。支持 `::` 压缩、`[..]` 包裹、`%zone`、v4 尾巴。 */
-export function parseV6(raw) {
-  let s = String(raw ?? "").trim().toLowerCase();
-  if (!s) return null;
-  if (s.startsWith("[") && s.endsWith("]")) s = s.slice(1, -1);
-  const zone = s.indexOf("%");
-  if (zone >= 0) s = s.slice(0, zone);
-  if (s.includes(".")) {
-    const at = s.lastIndexOf(":");
-    if (at < 0) return null;
-    const v4 = s.slice(at + 1).split(".");
-    if (v4.length !== 4 || !v4.every((x) => /^\d{1,3}$/.test(x) && Number(x) <= 255)) return null;
-    const n = v4.reduce((a, x) => ((a << 8) | Number(x)) >>> 0, 0) >>> 0;
-    s = `${s.slice(0, at)}:${(n >>> 16).toString(16)}:${(n & 0xffff).toString(16)}`;
-  }
-  const halves = s.split("::");
-  if (halves.length > 2) return null;
-  const head = halves[0] ? halves[0].split(":") : [];
-  const tail = halves.length === 2 ? (halves[1] ? halves[1].split(":") : []) : [];
-  if (halves.length === 1 && head.length !== 8) return null;
-  if (head.length + tail.length > 8) return null;
-  const fill = 8 - head.length - tail.length;
-  const groups = [...head, ...Array(halves.length === 2 ? fill : 0).fill("0"), ...tail];
-  if (groups.length !== 8) return null;
-  let out = 0n;
-  for (const g of groups) {
-    if (!/^[0-9a-f]{1,4}$/.test(g)) return null;
-    out = (out << 16n) | BigInt(`0x${g}`);
-  }
-  return out;
-}
-
-/** BigInt → 规范化 IPv6 文本（小写；最长零段压缩成 `::`，RFC 5952 只压 ≥2 段）。 */
-export function formatV6(big) {
-  const groups = [];
-  for (let i = 7; i >= 0; i--) groups.push(Number((big >> BigInt(i * 16)) & M16));
-  let bestAt = -1;
-  let bestLen = 0;
-  let curAt = -1;
-  let curLen = 0;
-  for (let i = 0; i < 8; i++) {
-    if (groups[i] === 0) {
-      if (curAt < 0) curAt = i;
-      curLen += 1;
-      if (curLen > bestLen) {
-        bestLen = curLen;
-        bestAt = curAt;
-      }
-    } else {
-      curAt = -1;
-      curLen = 0;
-    }
-  }
-  const hex = groups.map((g) => g.toString(16));
-  if (bestLen < 2) return hex.join(":");
-  return `${hex.slice(0, bestAt).join(":")}::${hex.slice(bestAt + bestLen).join(":")}`;
-}
-
-/** `"2001:db8::/64"` → `{ addr: BigInt, bits: 64, text: "2001:db8::" }`；非法返回 null。 */
-export function parsePrefix(raw) {
-  const s = String(raw ?? "").trim();
-  const slash = s.lastIndexOf("/");
-  if (slash < 0) return null;
-  const bits = Number(s.slice(slash + 1));
-  if (!Number.isInteger(bits) || bits < 0 || bits > 128) return null;
-  const addr = parseV6(s.slice(0, slash));
-  if (addr === null) return null;
-  return { addr, bits, text: formatV6(networkOf(addr, bits)) };
-}
-
-/** /bits 前缀里有几位主机位（= 可用地址的指数）。 */
-export function hostBitsOf(bits) {
-  return 128 - Number(bits);
-}
-
-/** 该地址在 /bits 下的网络号（主机位清零）。 */
-export function networkOf(addr, bits) {
-  if (bits <= 0) return 0n;
-  if (bits >= 128) return addr;
-  return addr & ~((1n << BigInt(128 - bits)) - 1n);
-}
-
-/** 随机主机号（m 位）。用 rnd() 拼 32bit 块，避免一次 Math.random 只有 53 位精度。 */
-export function randomHost(m, rnd = Math.random) {
-  let v = 0n;
-  let got = 0;
-  while (got < m) {
-    const take = Math.min(32, m - got);
-    const r = Math.floor(rnd() * 0x100000000) >>> 0;
-    v = (v << BigInt(take)) | (BigInt(r) & ((1n << BigInt(take)) - 1n));
-    got += take;
-  }
-  return v;
-}
-
-/** 该 64 位 IID 是否带 EUI-64 的 ff:fe 标记（RFC 4291 附录 A：MAC 派生的 SLAAC 地址）。 */
-export function isEui64(iid) {
-  return ((iid >> 24n) & M16) === 0xfffen;
-}
-
-/**
- * 主机号卫生：m>2 时跳过 0/1/全 1；m>=40 时扰动 ff:fe 标记。循环有界（8 次）且确定。
- */
-export function sanitizeHost(v, m) {
-  const mask = m >= 128 ? (1n << 128n) - 1n : (1n << BigInt(m)) - 1n;
-  let x = v & mask;
-  for (let i = 0; i < 8; i++) {
-    if (m >= 40 && isEui64(x)) {
-      x = (x ^ 0x0000000200000000n) & mask;
-      continue;
-    }
-    if (m > 2 && (x === 0n || x === 1n || x === mask)) {
-      x = (x + 1n) & mask;
-      continue;
-    }
-    return x;
-  }
-  return x;
-}
-
-/** 在前缀里造一个随机地址（主机号随机 + 卫生规则）。m<=0（/128）时只能返回前缀自身。 */
-export function randomAddress(prefix, rnd = Math.random) {
-  const m = hostBitsOf(prefix.bits);
-  if (m <= 0) return formatV6(prefix.addr);
-  const host = sanitizeHost(randomHost(m, rnd), m);
-  return formatV6(networkOf(prefix.addr, prefix.bits) | host);
-}
-
-/** 地址是否落在该前缀里。 */
-export function inPrefix(addr, prefix) {
-  return networkOf(addr, prefix.bits) === networkOf(prefix.addr, prefix.bits);
-}

package/src/v6pool/probe.js

@@ -1,40 +0,0 @@
-// v6pool · 起池前的实证探活：**用池里的源地址**打一次上游。
-//
-// 为什么必须有（这是本功能唯一不能省的实测）：内核接受地址（bind 成功）≠ 机房真把整段路由到本机。
-// 只路由单个 /128 的机器上，从段内随机地址发出的包全部黑洞——那种池进了池就是「请求挂到超时」，
-// 比直连更糟。判据只有一条：**从该地址真的能拿到上游响应**。
-import { compatFetch, getUndici, timeoutSignal } from "../compat.js";
-import { opencodeUa } from "../opencode-identity.js";
-
-/**
- * @param {{ addr: string, baseUrl?: string, path?: string, agentFactory: Function, fetchImpl?: Function, timeoutMs?: number }} opts
- * @returns {Promise<{ ok: boolean, status: number, ms: number, error?: string }>}
- */
-export async function probeFrom({ addr, baseUrl = "https://opencode.ai", path = "/zen/v1/models", agentFactory, fetchImpl, timeoutMs = 8000 } = {}) {
-  const agent = agentFactory(addr);
-  const url = `${String(baseUrl).replace(/\/+$/, "")}${path}`;
-  const t0 = Date.now();
-  try {
-    const f = fetchImpl || getUndici().fetch || compatFetch;
-    const res = await f(url, {
-      method: "GET",
-      headers: { "User-Agent": opencodeUa() },
-      dispatcher: agent,
-      signal: timeoutSignal(timeoutMs),
-    });
-    try {
-      await res.text();
-    } catch {
-      /* 读不完不影响判活：拿到状态码就算数 */
-    }
-    return { ok: !!res.ok, status: res.status, ms: Date.now() - t0 };
-  } catch (e) {
-    return { ok: false, status: 0, ms: Date.now() - t0, error: String(e?.message || e) };
-  } finally {
-    try {
-      await agent?.close?.();
-    } catch {
-      /* 探活用的 Agent 是一次性的，关不掉也不影响后续 */
-    }
-  }
-}

package/src/v6pool/report.js

@@ -1,104 +0,0 @@
-// v6pool · 日志文案（纯函数，零 IO）。
-//
-// 判据（ADR-0059）：**看完日志还需要的下一个命令，就是日志没写好的地方**。
-// 所以每一行都必须自带定位信息：哪个源地址、哪个前缀、第几次换、旧地址当时打了多少发什么状态。
-// 行首标记沿用 warp-pool/report.js 的 MARK（▸步骤 / ✓正常 / ✗失败 / ⚠警告）。
-export const MARK = { step: "▸", ok: "✓", fail: "✗", warn: "⚠" };
-const TAG = "[v6pool]";
-
-/** `{200: 3, 429: 1}` → `200×3 429×1`（按次数降序；空则"无响应"）。 */
-export function fmtCounts(counts = {}) {
-  const parts = Object.entries(counts)
-    .filter(([, n]) => Number(n) > 0)
-    .sort((a, b) => Number(b[1]) - Number(a[1]))
-    .map(([s, n]) => `${s}×${n}`);
-  return parts.length ? parts.join(" ") : "无响应";
-}
-
-export function fmtConfig(cfg = {}) {
-  return `${TAG} ${MARK.step} 配置 开关=${cfg.enabled ? "开" : "关"} 槽位=${cfg.count} 策略=${cfg.strategy} 换址=${cfg.rotate ? "开" : "关"} 认领=${cfg.claim} 冷却=${Math.round((cfg.cooldownMs || 0) / 1000)}s 退休=${Math.round((cfg.retireMs || 0) / 1000)}s 前缀=${cfg.prefix || "(自动判断)"}`;
-}
-
-export function fmtDisabled() {
-  return `${TAG} ${MARK.step} 出口池关着（MSLXDFF_V6_POOL=0）⇒ 请求走直连或 WARP 池`;
-}
-
-export function fmtDetect(d = {}) {
-  return `${TAG} ${MARK.step} 自检 网卡=${d.iface || "?"} 前缀=${d.prefix} 主机位=${d.hostBits}（可用地址 2^${d.hostBits}） 认领=${d.mode === "bind" ? "bind（ip_nonlocal_bind=1，不碰网卡）" : "add（root，ip addr add）"} 来源=${d.source}`;
-}
-
-export function fmtSkip({ reason = "", hint = "" } = {}) {
-  return `${TAG} ${MARK.fail} 出口池本次不启用（请求走直连）：${reason}｜下一步：${hint}`;
-}
-
-export function fmtClaim({ addr, iface }) {
-  return `${TAG} ${MARK.step} 认领源地址 ${addr}/128 dev ${iface} nodad（记进认领账，收摊时释放）`;
-}
-
-export function fmtClaimFail({ addr, iface, error }) {
-  return `${TAG} ${MARK.fail} 认领源地址失败 ${addr} dev ${iface}：${error}`;
-}
-
-export function fmtSweep({ iface, removed = [], failed = [] } = {}) {
-  const r = removed.length ? `删掉 ${removed.length} 个：${removed.slice(0, 4).join(" ")}${removed.length > 4 ? " …" : ""}` : "无";
-  const f = failed.length ? `｜失败 ${failed.length} 个：${failed.map((x) => `${x.addr}（${x.error}）`).join(" ")}` : "";
-  return `${TAG} ${MARK.step} 清上一代残留地址（dev ${iface}）：${r}${f}`;
-}
-
-export function fmtProbe({ addr, i, n, ok, status, ms, error }) {
-  return ok
-    ? `${TAG} ${MARK.step} 探活 ${i}/${n} 源=${addr} → HTTP ${status} ${ms}ms`
-    : `${TAG} ${MARK.warn} 探活 ${i}/${n} 源=${addr} → 失败 ${ms}ms ${error || `HTTP ${status}`}`;
-}
-
-export function fmtPool({ prefix, addrs = [], claimed, mode }) {
-  return `${TAG} ${MARK.ok} 出口池就绪：前缀 ${prefix}｜源地址 ${addrs.length} 个：${addrs.join(" ")}｜认领方式 ${mode}｜配额信号即换新地址（不重注册、不握手，成本≈0）`;
-}
-
-export function fmtPoolEmpty({ tried = 0 } = {}) {
-  return `${TAG} ${MARK.fail} 池里 ${tried} 个源地址**全部**探活失败（内核接受了地址，但整段没真路由到本机）⇒ 本次走直连。下一步：① 确认机房把整段路由到本机；② 或设 MSLXDFF_V6_POOL=0 恢复 WARP 池；③ 或 MSLXDFF_V6_PREFIX=<真正路由过来的段>/<位数>`;
-}
-
-export function fmtReadyFail({ error }) {
-  return `${TAG} ${MARK.fail} 建池过程出错，本次走直连：${error}`;
-}
-
-export function fmtSwap({ from, to, status, kind, forced, swaps, prevCounts }) {
-  return `${TAG} ${MARK.warn} 源 ${from} 上游 ${status} 判为「${kind}」⇒ 换源地址 ${to}（本槽第 ${swaps} 次${forced ? "，强制跳过冷却" : ""}；旧地址计数 ${fmtCounts(prevCounts)}）`;
-}
-
-export function fmtSwapFail({ addr, error }) {
-  return `${TAG} ${MARK.fail} 源 ${addr} 换址失败（该槽保持原地址，继续用）：${error}`;
-}
-
-export function fmtFirstOk({ addr, swaps, counts }) {
-  return swaps > 0
-    ? `${TAG} ${MARK.ok} 源 ${addr} 首个响应 200 ⇒ **换址后立刻恢复**（第 ${swaps} 次换址有效；新地址计数 ${fmtCounts(counts)}）`
-    : `${TAG} ${MARK.ok} 源 ${addr} 首个响应 200（池内地址工作正常）`;
-}
-
-export function fmtNoRotate({ addr, status, kind }) {
-  return `${TAG} ${MARK.warn} 源 ${addr} 上游 ${status}（${kind}）—— 换址开关关着（MSLXDFF_V6_ROTATE=0），不换源地址`;
-}
-
-export function fmtVerdictNo({ addr, status, kind, why }) {
-  return `${TAG} ${MARK.step} 源 ${addr} 上游 ${status} 判为「${kind}」⇒ 不换源地址：${why}`;
-}
-
-export function fmtRetire({ addr }) {
-  return `${TAG} ${MARK.step} 退休旧出口 ${addr}（关 Agent + 释放地址；留到最后是为让在飞请求走完）`;
-}
-
-export function fmtClose({ released = [] } = {}) {
-  return released.length
-    ? `${TAG} ${MARK.step} 收摊：释放源地址 ${released.length} 个：${released.join(" ")}`
-    : `${TAG} ${MARK.step} 收摊：没有需要释放的源地址（bind 模式不碰网卡）`;
-}
-
-export function fmtDispatch({ addr, session }) {
-  return `${TAG} · 源=${addr} 会话=${session}`;
-}
-
-export function fmtDirect({ reason }) {
-  return `${TAG} ${MARK.warn} 本次走直连：${reason}`;
-}