// 成套报价 AI 选型替换确定性引擎 v2（2026-09-25 重写：规格全解析+系列字典全维度匹配，匹配不上不替换）
// 与 SKILL.md《塑壳断路器规格完全解析知识库》同源实现：
//   附件码逐位语义：第1位极数(2/3/4) 第2位脱扣(2电磁/3热磁) 第3位附件十位(0-7) 第4位附件个位(0/8)
//   第5位用途代号(空=配电/2=电动机保护，仅此两种→32008 必非法)；字母码系列整串比对。
// 用法：
//   node xuanxing.js <品牌关键词> <系列关键词> --dry            # 预览（默认，不改库）
//   node xuanxing.js <品牌关键词> <系列关键词> --exec           # 真实替换（一次 /api/replacebatch，失败项回落逐行 /api/replace）
//   node xuanxing.js 德力西 CDM3S --dry --only "CDM3S-250F/3300200A"
//   node xuanxing.js 德力西 CDM3S --dry --fix 修正.json         # {"旧规格":"纠错后规格",...} 阶段① LLM 纠错结果喂进来
// 数据链：主程序18790清单 → dqb搜索系列/系列树(品名) → 直连拉 spe_prop/spe_opt/spe_price
//   → 系列选项字典全维度展开 → 知识库逐位解析旧规格 → 全维度匹配 → 无兜底(匹配不上即跳过)
var http = require("http");
var fs = require("fs");
var path = require("path");
var os = require("os");

var args = process.argv.slice(2);
var DRY = args.indexOf("--exec") < 0;              // ★默认 dry 预览，必须显式 --exec 才改库
var ONLY = "";
var oi = args.indexOf("--only");
if (oi >= 0 && args[oi + 1]) { ONLY = args[oi + 1]; args.splice(oi, 2); }
var FIX = "";
oi = args.indexOf("--fix");
if (oi >= 0 && args[oi + 1]) { FIX = args[oi + 1]; args.splice(oi, 2); }
var BRAND = args[0] || "";
var SERIES = args[1] || "";
if ((!BRAND || !SERIES) && args.indexOf("--selftest") < 0) {
  console.error("用法: node xuanxing.js <品牌关键词> <系列关键词> [--dry|--exec] [--only 旧规格] [--fix 修正.json]");
  process.exit(1);
}

// ================= dqb 签名（内联自 dqb_sign.js，与页面同源） =================
function dqShift(t, e) {
  for (var s = 0; s < e.length - 2; s += 3) {
    var r = e.charAt(s + 2);
    r = r >= "a" ? r.charCodeAt(0) - 87 : Number(r);
    r = "+" === e.charAt(s + 1) ? t >>> r : t << r;
    t = "+" === e.charAt(s) ? (t + r) & 4294967295 : t ^ r;
  }
  return t;
}
function dqSign(t, e) {
  if (e.length > 30) e = "" + e.substr(0, 10) + e.substr(Math.floor(e.length / 2) - 5, 10) + e.substr(-10, 10);
  var u = t, h = u.split("."), m = Number(h[0]) || 0, f = Number(h[1]) || 0;
  var v = [], g = 0;
  for (var A = 0; A < e.length; A++) {
    var y = e.charCodeAt(A);
    if (y < 128) v[g++] = y;
    else if (y < 2048) { v[g++] = y >> 6 | 192; v[g++] = y >> 6 & 63 | 128; }
    else {
      if ((y & 64512) === 55296 && A + 1 < e.length && (e.charCodeAt(A + 1) & 64512) === 56320) {
        y = 65536 + ((y & 1023) << 10) + (e.charCodeAt(++A) & 1023);
        v[g++] = y >> 18 | 240; v[g++] = y >> 12 & 63 | 128;
      } else { v[g++] = y >> 12 | 224; v[g++] = y >> 6 & 63 | 128; }
      v[g++] = y & 63 | 128;
    }
  }
  var b = m, C = "+-a^+6", S = "+-3^+b+-f";
  for (var w = 0; w < v.length; w++) { b += v[w]; b = dqShift(b, C); }
  b = dqShift(b, S); b ^= f;
  if (b < 0) b = 2147483648 + (b & 2147483647);
  b %= 1e6;
  return b.toString() + "." + (b ^ m);
}
function dqSParam(sid) {
  var d = "0123456789";
  function r6() { var r = ""; for (var i = 0; i < 6; i++) r += d.charAt(Math.floor(Math.random() * d.length)); return r; }
  var ab = r6() + "." + r6();
  return sid + "." + ab + "." + dqSign(ab, String(sid));
}

// ================= dqb 解码（内联自 dqb_decode.js） =================
function dqDeStr(t, off, mul) {
  var e = [];
  for (var s = 0; s + 1 < t.length; s += 2)
    e.push(mul * (t[s].charCodeAt() - off) + (t[s + 1].charCodeAt() - off));
  return e;
}
function dqDe(t) {
  var e, s, r, a, n = [], i = "", o = 256;
  for (e = 0; e < 256; e += 1) n[e] = String.fromCharCode(e);
  for (s = String.fromCharCode(t[0]), r = s, e = 1; e < t.length; e += 1) {
    a = t[e];
    if (n[a]) i = n[a];
    else { if (a !== o) return null; i = s + s.charAt(0); }
    r += i; n[o++] = s + i.charAt(0); s = i;
  }
  return r;
}

// ================= HTTP 小工具 =================
function get(url) {
  return new Promise(function (res, rej) {
    http.get(url, function (r) {
      var b = ""; r.setEncoding("utf-8");
      r.on("data", function (c) { b += c; });
      r.on("end", function () { res(b); });
    }).on("error", rej);
  });
}
function postForm(host, p, form) {
  return new Promise(function (res, rej) {
    var req = http.request({ hostname: host, port: 8080, path: p, method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" } }, function (r) {
      var b = ""; r.setEncoding("utf-8");
      r.on("data", function (c) { b += c; });
      r.on("end", function () { res(b); });
    });
    req.on("error", rej); req.end(form);
  });
}
function postJson(url, obj) {
  return new Promise(function (res, rej) {
    var body = JSON.stringify(obj);
    var u = new URL(url);
    var req = http.request({ hostname: u.hostname, port: u.port, path: u.pathname + u.search, method: "POST", headers: { "Content-Type": "application/json; charset=utf-8" } }, function (r) {
      var b = ""; r.setEncoding("utf-8");
      r.on("data", function (c) { b += c; });
      r.on("end", function () { res(b); });
    });
    req.on("error", rej); req.end(body);
  });
}

function readToken() {
  try {
    var t = fs.readFileSync(path.join(os.homedir(), ".zcode", "chengtao", "token.txt"), "utf-8").trim();
    if (t) return t;
  } catch (e) { }
  console.error("读不到令牌（~/.zcode/chengtao/token.txt；由成套报价软件主程序启动时自动生成）");
  process.exit(1);
}
async function findAppPort(token) {
  for (var p = 18790; p < 18800; p++) {
    try {
      await get("http://127.0.0.1:" + p + "/api/xuanxing?token=" + encodeURIComponent(token));
      return p;
    } catch (e) { }
  }
  console.error("找不到主程序接口（127.0.0.1:18790 起），请确认成套报价软件已运行");
  process.exit(1);
}

// ================= 知识库：附件码语法域 =================
var 电流档位 = { 6: 1, 10: 1, 16: 1, 20: 1, 25: 1, 32: 1, 40: 1, 50: 1, 60: 1, 63: 1, 80: 1, 100: 1, 125: 1, 140: 1, 150: 1, 160: 1, 180: 1, 200: 1, 225: 1, 250: 1, 315: 1, 350: 1, 400: 1, 500: 1, 630: 1, 700: 1, 800: 1, 1000: 1, 1250: 1, 1600: 1, 2000: 1, 2500: 1 };
var 字母码白名单 = { AX: 1, AL: 1, AXL: 1, SHT: 1, SHTA: 1, SHTB: 1, UVT: 1, UVTD: 1, ASUVT: 1, MO: 1, OF: 1, CC: 1, KL: 1 };
var 壳架档 = [6300, 5000, 4000, 3200, 2500, 2000, 1600, 1250, 800, 630, 400, 250, 160, 125, 100, 63, 32, 20, 16];

/// 校验一个附件码串：返回 {ok:bool, why:错误原因, js:极数("3P"), tk:脱扣数字, yt:用途位}
function 拆附件码(code) {
  var out = { ok: false, why: "", js: "", tk: "", yt: "", letter: "" };
  if (!code) { out.why = "空码"; return out; }
  if (/^[A-Z]+$/.test(code)) {                       // 字母码系列：整串白名单比对
    if (字母码白名单[code]) { out.ok = true; out.letter = code; }
    else out.why = "字母码" + code + "不在已知码表(AX/AL/SHT/UVT/MO等)";
    return out;
  }
  if (/^[0-7][0-8]?Y$/.test(code)) { out.ok = true; out.why = "预付费变体"; return out; }   // 10Y/48Y
  if (!/^\d+$/.test(code)) { out.why = "码\"" + code + "\"不是纯数字/纯字母，无法按码位解读"; return out; }
  var yt = "";
  var c4 = code;
  if (code.length === 5) {
    yt = code.charAt(4);
    if (yt !== "2") { out.why = "第5位用途代号=\"\"(配电保护)或\"2\"(电动机保护)，\"" + yt + "\"不存在→型号" + code + "不存在"; return out; }
    c4 = code.substr(0, 4);
  }
  if (c4.length === 4) {
    var d1 = c4.charAt(0), d2 = c4.charAt(1), d3 = c4.charAt(2), d4 = c4.charAt(3);
    if ("234".indexOf(d1) < 0) { out.why = "第1位极数须为2/3/4，是\"" + d1 + "\""; return out; }
    if ("23".indexOf(d2) < 0) { out.why = "第2位脱扣器须为2(电磁)/3(热磁)，是\"" + d2 + "\""; return out; }
    if ("01234567".indexOf(d3) < 0) { out.why = "第3位附件十位须为0-7，是\"" + d3 + "\""; return out; }
    if ("08".indexOf(d4) < 0) { out.why = "第4位附件个位须为0/8，是\"" + d4 + "\""; return out; }
    out.ok = true; out.js = d1 + "P"; out.tk = d2; out.yt = yt;
    return out;
  }
  if (code.length === 3) {                            // NM2 制：300/308/320/328 = 极数+附件十位+个位
    if (["300", "308", "320", "328"].indexOf(code) >= 0) { out.ok = true; out.js = code.charAt(0) + "P"; out.yt = ""; return out; }
    out.why = "3位码仅 NM2 系列使用(300/308/320/328)，\"" + code + "\"不存在"; return out;
  }
  if (code.length === 2) {
    var e1 = code.charAt(0), e2 = code.charAt(1);
    if ("01234567".indexOf(e1) < 0) { out.why = "2位码十位须为0-7，是\"" + e1 + "\""; return out; }
    if ("08".indexOf(e2) < 0) { out.why = "2位码个位须为0/8，是\"" + e2 + "\""; return out; }
    out.ok = true; return out;                        // 纯附件码制，极数另看规格
  }
  if (code.length === 1) { if ("012345678".indexOf(code) >= 0) { out.ok = true; return out; } out.why = "1位码须为0-8"; return out; }
  out.why = "码\"" + code + "\"位数(" + code.length + ")超过5位，不是合法附件码";
  return out;
}

/// 码位解读成中文（方案表展示用）
function 码解读(code, c) {
  if (!code) return "无码";
  if (c.letter) return code + "(字母码整串)";
  var s = code + "=";
  if (c.js) s += c.js;
  if (c.tk) s += (c.tk === "2" ? "电磁式" : "热磁");
  if (code.length >= 4) {
    var d3 = code.charAt(code.length - (code.length === 5 ? 2 : 1)), d4 = code.length >= 4 ? code.charAt(code.length - (code.length === 5 ? 1 : 0)) : "";
    var 十位 = { 0: "无附件", 1: "分励", 2: "辅助", 3: "欠压", 4: "分励+辅助", 5: "分励+欠压", 6: "二组辅助", 7: "辅助+欠压" };
    if (十位[d3] !== undefined) s += "+" + 十位[d3];
    if (d4 === "8") s += "+报警触头";
  }
  if (c.yt === "2") s += "+电动机保护";
  else if (code.length === 5) s += "+配电保护";
  return s;
}

// ================= 知识库：旧规格全解析（枚举粘连切分） =================
/// 电流提取：先剥结尾的漏电标识(30mA/100mA/300mA)再匹配，防 C16+30mA 粘连吞成 1630；
/// C/D 兜底前先剥电流单位 A(防 'C40A' 的 A 触发负向断言)，并取最后一组（D747/CDM 等前缀数字不是电流）。
function 取电流(str) {
  var t = String(str).replace(/(30|100|300)MA$/, "").replace(/(\d+(?:\.\d+)?)A(?!M)/g, "$1 ");
  var m = t.match(/(\d+(?:\.\d+)?)A/); if (m) return parseFloat(m[1]);
  var ms = t.match(/([BCD])(\d+(?:\.\d+)?)(?![\dAM])/g);
  if (ms && ms.length) return parseFloat(ms[ms.length - 1].replace(/^[CD]/, ""));
  return 0;
}
/// v3 微型要素：从整串提取 极数(含+N)/脱扣曲线(C·D)/漏电 mA（无附件码的微型规格解析）。
/// 漏电先按标准档位字面剥出(30/100/300mA——防 C16+30 粘连吞成 1630)，再在余串上提曲线/电流。
function 解析微型(str, cand) {
  var s = String(str || "");
  var mm = s.match(/(30|100|300)MA/);
  if (mm) {
    if (!cand.ma) cand.ma = parseInt(mm[1], 10);
    s = s.replace(mm[1] + "MA", "");
  }
  s = s.replace(/(\d+(?:\.\d+)?)A(?!M)/g, "$1 ");   // 剥电流单位 A(防 'C16A'/'C16AE' 触发负向断言,保留 mA)
  var m = s.match(/([1-4])P(＋|\+)?N/);
  if (m) { cand.poles = m[1] + "P+N"; s = s.replace(m[0], " "); }
  else { m = s.match(/([1-4])P/); if (m) { cand.poles = m[1] + "P"; s = s.replace(m[0], " "); } }
  if (!cand.poles) {
    // "-1N（N极直通）"式：DZ47sLE-1N = 1P+N（N 极直通/可开闭都归 N 极组）
    m = s.match(/-?([1-4])N(?![0-9A-Z])/);
    if (m) { cand.poles = m[1] + "P+N"; s = s.replace(m[0], " "); }
  }
  cand.js = cand.js || (cand.poles ? cand.poles.replace("+N", "") : "");
  // (剥极数后再扫曲线,防 'B161P' 里 1P 与电流粘连吞错)
  // 曲线+电流：取最后一组（型号尾部才是 曲线+电流；D747/CDM 前缀误扫由"取末组"防；
  //   允许 'C型16' 的"型"字间隔；B 曲线=施耐德/ABB 微型保护特性曲线）
  var ms = s.match(/([BCD])型?(\d+(?:\.\d+)?)(?![\dAM])/g);
  if (ms && ms.length) {
    var m2 = ms[ms.length - 1].match(/^([BCD])型?(\d+(?:\.\d+)?)/);
    if (m2) { cand.curve = m2[1]; if (!cand.dl) cand.dl = parseFloat(m2[2]); }
  }
}
/// 返回 {cands:[合法候选解], invalid:[{code,why}] , base:{kj,fenhe,jiexian}}
/// cand = {code, codeC(拆附件码结果), js, dl, kj, fenhe, jiexian}
function parseSpecAll(spec) {
  var s = String(spec || "").toUpperCase().replace(/\s+/g, "");
  var base = { kj: 0, fenhe: "", jiexian: "" };
  var cands = [], invalid = [];
  // 接线后缀
  if (s.indexOf("板后接线") >= 0) { base.jiexian = "板后接线"; s = s.replace(/板后接线/g, ""); }
  else if (s.indexOf("插入式") >= 0) { base.jiexian = "插入式"; s = s.replace(/插入式/g, ""); }
  // 壳架（长到短防吞位）+ 分断字母（紧贴壳架数字后、/ 前）
  var m = s.match(/-(6300|5000|4000|3200|2500|2000|1600|1250|1000|800|630|400|250|160|125|100|63|32|20|16)/);
  if (!m) m = s.match(/^([A-Z]+)(6300|5000|4000|3200|2500|2000|1600|1250|1000|800|630|400|250|160|125|100|63|32|20|16)/);
  if (m) base.kj = parseInt(m[m.length - 1], 10);
  if (!base.kj) {
    // ★v3 通用兜底：串中首个"独立成词"的标准壳架数——国际命名式无横杠/前缀式套不住的
    //   XT4N250(250)、NSX100F(100)、Tmax XT2N160(160) 等都靠这条；先剥电流(带A)防误取
    var noA = s.replace(/(\d+(?:\.\d+)?)A(?!M)/g, " ");
    var fm = noA.match(/(?:^|[^0-9.])(6300|5000|4000|3200|2500|2000|1600|1250|1000|800|630|400|250|160|125|100|63|32|20|16)(?=[^0-9.]|$)/);
    if (fm) base.kj = parseInt(fm[1], 10);
  }
  var mf = s.match(/-(\d+)([A-Z])\//);          // -250F/ 型
  if (mf) base.fenhe = mf[2];
  else { mf = s.match(/-(\d+)([A-Z])$/); if (mf) base.fenhe = mf[2]; }
  // "/"后的码段：先按纯数字段匹配（电流A留在rest），不是数字再按字母码整串
  var msl = s.match(/\/(\d+)(.*)$/);
  var isLetter = false;
  if (!msl) { msl = s.match(/\/([A-Z]+)(.*)$/); isLetter = true; }
  var restAll = s;
  if (msl) {
    var run = msl[1], rest = msl[2];
    restAll = s.substr(0, s.indexOf("/" + run));   // 去掉 "/码段" 的前段（极数/电流兜底用）
    if (isLetter) {                                 // 字母码整串比对
      var lc = 拆附件码(run);
      if (lc.ok) cands.push(mkCand(run, lc, rest, 0));
      else { invalid.push({ code: run, why: lc.why }); 无码兜底候选(s); }
    } else if (run.length === 1 && rest.charAt(0) === "P") {
      // "/1P""/2P" 是极数写法，不是 1 位附件码——不当码，走无码分支逻辑
      var cp = { code: "", codeC: { ok: true }, js: run + "P", dl: 取电流(rest + " " + restAll), kj: base.kj, fenhe: base.fenhe, jiexian: base.jiexian };
      if (!cp.dl) cp.dl = 取电流(restAll);
      解析微型(s, cp);
      if (cp.js || cp.dl) cands.push(cp);
    } else {
      // 数字串：尾部紧粘 A（码+电流粘连）→ 枚举全部切分；否则整段是码
      var glued = rest.charAt(0) === "A";
      if (glued) {
        var seen = {};
        for (var cl = 1; cl < run.length; cl++) {
          var code = run.substr(0, cl), curStr = run.substr(cl);
          var cur = parseInt(curStr, 10);
          if (isNaN(cur) || cur <= 0 || !电流档位[cur]) continue;
          if (base.kj && cur > base.kj) continue;           // 电流必须 ≤ 壳架
          var c2 = 拆附件码(code);
          if (c2.ok) {
            var key = code + "|" + cur;
            if (!seen[key]) { seen[key] = 1; cands.push(mkCand(code, c2, "", cur)); }
          } else {
            invalid.push({ code: code, why: c2.why });
          }
        }
      } else {
        var c3 = 拆附件码(run);
        if (c3.ok) cands.push(mkCand(run, c3, rest, 0));
        else { invalid.push({ code: run, why: c3.why }); 无码兜底候选(s); }
      }
    }
  }
  function mkCand(code, c, rest, dlGiven) {
    var cand = { code: code, codeC: c, js: c.js || "", dl: dlGiven || 0, kj: base.kj, fenhe: base.fenhe, jiexian: base.jiexian };
    if (!cand.js) { var mj = (restAll + rest).match(/([1-4])P/); if (mj) cand.js = mj[1] + "P"; }
    if (!cand.dl) cand.dl = 取电流(rest + " " + restAll);
    解析微型(rest + " " + restAll, cand);
    return cand;
  }
  /// v3 无码兜底候选："/"后的段当码解析非法时（OCR 噪声斜杠如 C16/A e30mA），
  ///   用完整串按微型要素再出一个无码候选，让微型全维度匹配兜住
  function 无码兜底候选(text) {
    var c = { code: "", codeC: { ok: true }, js: "", dl: 0, kj: base.kj, fenhe: base.fenhe, jiexian: base.jiexian };
    var mj = text.match(/([1-4])P/); if (mj) c.js = mj[1] + "P";
    c.dl = 取电流(text);
    解析微型(text, c);
    if (c.js || c.dl || c.curve || c.ma) cands.push(c);
  }
  // 无"/"码段的规格（微型等）：极数/曲线/漏电/电流解析
  if (!msl) {
    var cand = { code: "", codeC: { ok: true }, js: "", dl: 0, kj: base.kj, fenhe: base.fenhe, jiexian: base.jiexian };
    var mj2 = s.match(/([1-4])P/); if (mj2) cand.js = mj2[1] + "P";
    cand.dl = 取电流(s);
    解析微型(s, cand);
    if (cand.js || cand.dl) cands.push(cand);
  }
  return { cands: cands, invalid: invalid, base: base };
}

// ================= 系列选项字典（全维度） =================
function 维度角色(propName) {
  var n = String(propName || "");
  if (n.indexOf("壳架") >= 0) return "kj";
  if (n.indexOf("极数") >= 0) return "js";
  // ★"额定剩余动作电流"含"额定电流"子串——必须先判剩余/漏电（否则 30mA 被当电流维）
  if (n.indexOf("剩余") >= 0 || n.indexOf("漏电") >= 0 || n.indexOf("动作电流") >= 0) return "ma";
  if (n.indexOf("额定电流") >= 0) return "dl";
  if (n.indexOf("分断") >= 0) return "fenhe";
  if (n.indexOf("脱扣") >= 0) return "tk";
  if (n.indexOf("附件") >= 0) return "acc";
  if (n.indexOf("用途") >= 0) return "yt";
  if (n.indexOf("操作") >= 0) return "oper";
  if (n.indexOf("接线") >= 0) return "jx";
  return "other";
}
function 选项打印码(optName) {                     // "3【热磁式】"→"3"；"3P"→"3"；"1P＋N（…）"/"S 35kA"→""
  var t = String(optName || "").trim();
  var m = t.match(/^([0-9]+)【/); if (m) return m[1];
  m = t.match(/^([1-4])P(?:$|[^N＋+])/); if (m && t.indexOf("【") < 0) return m[1];   // 塑壳纯 '3P'
  return "";
}
function 选项分断字母(optName) {
  var m = String(optName || "").trim().match(/^([A-Z])\b/); return m ? m[1] : "";
}
function numFromOpt(name) {
  var m = String(name || "").toUpperCase().match(/(\d+(?:\.\d+)?)/);
  return m ? parseFloat(m[1]) : 0;
}
function jsFromOpt(name) {
  var u = String(name || "").toUpperCase();
  if (u.indexOf("1P") >= 0) return "1P";
  if (u.indexOf("2P") >= 0) return "2P";
  if (u.indexOf("4P") >= 0) return "4P";
  if (u.indexOf("3P") >= 0) return "3P";
  var m = u.match(/^([1-4])(P|极)/);
  return m ? m[1] + "P" : "";
}
function normJx(label) {
  var t = String(label || "");
  if (t.indexOf("板后") >= 0) return "板后接线";
  if (t.indexOf("插入") >= 0) return "插入式";
  return "板前";                                    // 板前/空=默认
}

/// 把 spe_prop/spe_opt/spe_price 组装成全维度价格行；返回 {rows, dict:{codeStrSet}, propsByRole}
/// v3：微型断路器支持——每行额外提取 poles(极数含+N)/curve(C·D 曲线)/ma(漏电 mA)，
///     并收集各选项的 nameStr/nameSort（元件库页面规范型号串=系列短名+nameStr 按 nameSort 拼接）。
function 展开价格行(props, opts, prices) {
  var propRole = {}, propName = {};
  (props || []).forEach(function (p) {
    propRole[p.propId] = 维度角色(p.propName);
    propName[p.propId] = String(p.propName || "");
  });
  var optName = {}, optNameStr = {}, optNameSort = {};
  (opts || []).forEach(function (o) {
    var k = o.propId + "-" + o.optId;
    optName[k] = String(o.optName || "");
    optNameStr[k] = String(o.nameStr || "");
    optNameSort[k] = Number(o.nameSort || o.orderSort || 9999);
  });
  var accProps = [];                                 // 附件维度按 propId 升序拼码
  Object.keys(propRole).forEach(function (pid) { if (propRole[pid] === "acc") accProps.push(Number(pid)); });
  accProps.sort(function (a, b) { return a - b; });
  // ★码拼装只对塑壳式系列（存在 脱扣/附件/用途 任一维度）——微型系列(极数/曲线/电流/漏电)恒无码
  var hasCodeDims = Object.keys(propRole).some(function (pid) {
    return propRole[pid] === "tk" || propRole[pid] === "acc" || propRole[pid] === "yt";
  });
  var rows = [];
  (prices || []).forEach(function (pr) {
    if (!pr || pr.compPrice === undefined || pr.compPrice === null) return;
    var price = parseFloat(pr.compPrice);
    if (isNaN(price)) return;
    var row = { kj: 0, js: "", dl: 0, fenhe: "", code: "", oper: "", jx: "", other: 0,
      poles: "", curve: "", ma: 0, nameParts: [], unnamed: [],
      price: price, optStr: pr.optStr };
    var codeJs = "", codeTk = "", codeAcc = "", codeYt = "";
    String(pr.optStr || "").split("-").forEach(function (id) {
      var pid = null, name = "", key = "";
      for (var k in propRole) { if (optName[k + "-" + id] !== undefined) { pid = Number(k); name = optName[k + "-" + id]; key = k + "-" + id; break; } }
      if (pid === null) return;
      var role = propRole[pid];
      // nameStr 拼装素材(页面规范型号串的组成段,按 nameSort 排)
      if (optNameStr[key]) row.nameParts.push({ sort: optNameSort[key], str: optNameStr[key] });
      if (role === "kj") { row.kj = numFromOpt(name); return; }
      if (role === "js") {
        row.js = jsFromOpt(name); codeJs = 选项打印码(name);
        row.poles = 归一极数(name);
        var mc = name.toUpperCase().match(/([BCD])\s*型/); if (mc) row.curve = mc[1];
        return;
      }
      if (role === "dl") {
        row.dl = numFromOpt(name);
        var md = name.toUpperCase().match(/(\d+)\s*MA\b/); if (md) row.ma = parseInt(md[1], 10);
        var mcc = name.toUpperCase().match(/^([CD])\s*型?\s*\d/); if (mcc) row.curve = mcc[1];
        return;
      }
      if (role === "ma") {                              // 额定剩余动作电流(漏电档)
        var mma2 = name.toUpperCase().match(/(\d+)\s*MA/);
        if (mma2) row.ma = parseInt(mma2[1], 10);
        else if (/无|不带/.test(name)) row.ma = 0;
        row.unnamed.push(String(name || ""));           // 漏电档也进未识别维度(消歧用"不带")
        return;
      }
      if (role === "fenhe") { row.fenhe = 选项分断字母(name); return; }
      if (role === "tk") {
        codeTk = 选项打印码(name);
        // ★曲线提取：'B型'/'C型'/'D型'(纯曲线维) 或 'C16A'(曲线+电流合一)——数字可选
        var mtk = name.toUpperCase().match(/^([BCD])\s*型?\s*(\d+(?:\.\d+)?)?/);
        if (mtk && mtk[1]) {
          if (!row.curve) row.curve = mtk[1];
          if (mtk[2] && !row.dl) row.dl = parseFloat(mtk[2]);
        }
        return;
      }
      if (role === "acc") { codeAcc += 选项打印码(name); return; }
      if (role === "yt") { codeYt = 选项打印码(name); return; }   // 配电保护打印空
      if (role === "oper") { row.oper = String(name || ""); return; }
      if (role === "jx") { row.jx = normJx(name); return; }
      // 兜底维度（曲线类型/漏电等独立维）：尽力提取曲线与 mA；文本存入 unnamed(歧义消解用)
      var mcx = name.toUpperCase().match(/^([CD])\s*型/); if (mcx && !row.curve) row.curve = mcx[1];
      var mma = name.toUpperCase().match(/(\d+)\s*MA\b/); if (mma && !row.ma) row.ma = parseInt(mma[1], 10);
      if (role === "other" || role === "acc" || role === "tk" || role === "yt") row.unnamed.push(String(name || ""));
      row.other++;
    });
    if (!row.poles && row.js) row.poles = row.js;
    row.nameParts.sort(function (a, b) { return a.sort - b.sort; });
    row.code = hasCodeDims ? ((codeJs + codeTk + codeAcc + codeYt) || "") : "";
    // ★v3"极数即码"修正：微型系列(如 DZ47s)的 2P/3P/4P 极数选项是 '3【3P】' 带码形式，极数数字
    //   被拼进 code——若 code 仅由极数位构成(无脱扣/附件/用途位)且等于极数数字，视为微型式行，清码
    if (row.code && codeJs && !codeTk && !codeAcc && !codeYt
      && row.js && codeJs === row.js.replace("P", "")) row.code = "";
    rows.push(row);
  });
  // ★v3 系列固定维度回填：某维度从未被任何价格组合选中且只有唯一选项（如 DZ47PLE 的
  //   极数固定 1P+N、漏电固定 30mA——不进价格组合，行侧恒空导致全维度误判失配）——
  //   把唯一选项按角色提取后回填进所有行。
  try {
    var 已选optId = {};
    (prices || []).forEach(function (pr) {
      String(pr.optStr || "").split("-").forEach(function (id) { 已选optId[id] = 1; });
    });
    (props || []).forEach(function (p) {
      var 本维选项 = (opts || []).filter(function (o) { return Number(o.propId) === Number(p.propId); });
      if (本维选项.length !== 1) return;
      var o = 本维选项[0];
      if (已选optId[String(o.optId)]) return;                    // 被选中过=非固定维度
      var name = String(o.optName || "");
      var role = propRole[p.propId];
      var mm;
      rows.forEach(function (r) {
        if (role === "ma") { mm = name.toUpperCase().match(/(\d+)\s*MA/); if (mm && !r.ma) r.ma = parseInt(mm[1], 10); }
        else if (role === "js") { if (!r.poles) r.poles = 归一极数(name) || r.poles; if (!r.js) r.js = jsFromOpt(name); }
        else if (role === "tk") { mm = name.toUpperCase().match(/^([CD])/); if (mm && !r.curve) r.curve = mm[1]; }
        else if (role === "kj") { if (!r.kj) r.kj = numFromOpt(name); }
        else if (role === "dl") { if (!r.dl) r.dl = numFromOpt(name); }
      });
    });
  } catch (eFix) { }
  return { rows: rows, propRole: propRole, propName: propName };
}

/// 极数原文归一：'1P＋N（N极可开闭）'/'1P+N'→'1P+N'；'2P'→'2P'；'1N（N极直通）'→'1P+N'
/// （保留 N 极信息，微型匹配关键维度）
function 归一极数(name) {
  var u = String(name || "").toUpperCase().replace(/\s+/g, "");
  var m = u.match(/^([1-4])P/);
  if (m) {
    var 带N = /^([1-4])P(?:＋|\+)?N/.test(u) || /N极/.test(String(name || ""));
    return m[1] + "P" + (带N ? "+N" : "");
  }
  m = u.match(/^([1-4])N/);                       // '1N（N极直通）'式
  if (m) return m[1] + "P+N";
  return "";
}

// ================= 全维度匹配（无兜底） =================
/// 返回 null=命中；否则=失配维度名。
/// 塑壳模式(cand/row 带 code)：原全维度比对。
/// 微型模式(双方都无 code，v3 新增)：极数(含+N)/脱扣曲线(C·D)/漏电 mA/电流 全等才命中。
function 全维度匹配(cand, row) {
  if (row.kj && cand.kj && row.kj !== cand.kj) return "壳架(" + cand.kj + "≠" + row.kj + ")";
  if (row.js && cand.js && row.js !== cand.js) return "极数(" + cand.js + "≠" + row.js + ")";
  if (row.dl && cand.dl && row.dl !== cand.dl) return "电流(" + cand.dl + "≠" + row.dl + ")";
  if (row.code && cand.code && row.code !== cand.code) return "附件码(" + cand.code + "≠" + row.code + ")";
  if (row.code && !cand.code) return "附件码(旧规格无码,系列型号带码" + row.code + ")";
  if (!row.code && cand.code) return "附件码(系列型号不带码,旧规格码" + cand.code + ")";
  if (row.fenhe && cand.fenhe && row.fenhe !== cand.fenhe) return "分断(" + cand.fenhe + "≠" + row.fenhe + ")";
  if (normJx(cand.jiexian) !== (row.jx || "板前")) return "接线(" + (cand.jiexian || "板前") + "≠" + (row.jx || "板前") + ")";
  if (!row.code && !cand.code) {
    // 微型维度(极数N/曲线/漏电)：双方都有→必须相等；cand 有 row 无→行不完整失配；
    //   cand 无 row 有(如旧规格未标漏电档/未标曲线)→放行，交由价格消歧(缺省/无附件档在歧义分支选)
    if (row.poles && cand.poles && row.poles !== cand.poles)
      return "极数N(" + cand.poles + "≠" + row.poles + ")";
    if (!row.poles && cand.poles) return "极数N(系列组合未含极数)";
    if (row.curve && cand.curve && row.curve !== cand.curve)
      return "曲线(" + cand.curve + "≠" + row.curve + ")";
    if (!row.curve && cand.curve) return "曲线(系列组合未含曲线)";
    if (row.ma && cand.ma && row.ma !== cand.ma)
      return "漏电(" + cand.ma + "mA≠" + row.ma + "mA)";
    if (!row.ma && cand.ma) return "漏电(系列该组合不带)";
  }
  return null;
}

/// 匹配诊断：码在该系列是否存在、差在哪个维度（跳过原因用）
function 匹配诊断(cand, rows) {
  var 同码 = rows.filter(function (r) { return !r.code || r.code === cand.code; });
  if (cand.code && 同码.length === 0) return "附件码" + cand.code + "不在系列选项表(该系列无此型号)";
  var whyCount = {};
  同码.forEach(function (r) { var w = 全维度匹配(cand, r); if (w) { var k = w.split("(")[0]; whyCount[k] = (whyCount[k] || 0) + 1; } });
  var ks = Object.keys(whyCount);
  if (!ks.length) return "无组合(价格表缺行)";
  return ks.map(function (k) { return k + "不匹配"; }).join("+");
}

// ================= 主流程 =================
async function main() {
  var token = readToken();
  var port = await findAppPort(token);

  var list = JSON.parse(await get("http://127.0.0.1:" + port + "/api/xuanxing?token=" + encodeURIComponent(token)));
  if (!list.ok) { console.error("读选型页失败: " + (list.error || "")); process.exit(1); }
  var fixMap = {};
  if (FIX) {
    try { fixMap = JSON.parse(fs.readFileSync(FIX, "utf-8")); console.log("已载入修正文件 " + FIX + "（" + Object.keys(fixMap).length + " 条）"); }
    catch (e) { console.error("修正文件读取失败: " + e.message); process.exit(1); }
  }
  var targets = (list.rows || []).filter(function (r) {
    if (r.fenlei !== "塑壳" && r.fenlei !== "微型") {
      // v3：fenlei=null 的疑似断路器行（OCR 乱码 D747s/0747s 等）——能解析出断路器要素即纳入(推断行)；
      //     明确其他类型(隔离开关等)坚决跳过
      if (r.fenlei) return false;
      var P0 = parseSpecAll(r.guige);
      var c0 = P0.cands[0];
      if (!P0.cands.length || (!c0.code && !c0.curve && !c0.ma && !c0.js)) return false;
      r.tuiDuan = true;
    }
    if (ONLY && r.guige !== ONLY) return false;
    return true;
  });
  var 推断数 = 0;
  targets.forEach(function (t) { if (t.tuiDuan) 推断数++; });
  console.log("选型页共 " + list.rows.length + " 行，可替换目标 " + targets.length + " 行"
    + (推断数 ? "（含 " + 推断数 + " 行 fenlei=null 推断行——解析出断路器要素，方案表已标注 ⚠️推断）" : "")
    + (ONLY ? "（限定 " + ONLY + "）" : ""));
  if (!targets.length) { console.log("无可替换行，结束。"); return; }

  // 目标系列：搜索候选里系列名最贴切的第一个有价系列（品牌+系列关键词都过滤）
  var search = JSON.parse(await postForm("127.0.0.1", "/api8k/get_data_search2", "inputstr=" + encodeURIComponent(SERIES)));
  var cands0 = [];
  (search.data || []).forEach(function (f) {
    if (BRAND && (String(f.factoryname || "").indexOf(BRAND) < 0) && (String(f.fsortname || "").indexOf(BRAND) < 0)) return;
    (f.data || []).forEach(function (ser) {
      var nm = String(ser.seriesname || "");
      if (nm.toUpperCase().indexOf(SERIES.toUpperCase()) < 0) return;
      cands0.push({ id: ser.SeriesId, name: nm, factory: f.factoryname, rank: (nm.toUpperCase().indexOf(SERIES.toUpperCase()) === 0 ? 0 : 1) });
    });
  });
  cands0.sort(function (a, b) { return a.rank - b.rank; });
  if (!cands0.length) { console.error("元件库里没找到 [" + BRAND + " " + SERIES + "] 系列（搜索只认系列名）"); process.exit(1); }

  var hit = null, speData = null, tried = [];
  for (var ci = 0; ci < Math.min(cands0.length, 5); ci++) {
    var c0 = cands0[ci];
    var raw0 = await get("http://127.0.0.1:8080/api8k/get_spedata_all?s=" + dqSParam(c0.id));
    var j0 = JSON.parse(dqDe(dqDeStr(raw0.trim(), 903, 500)) || "{}");
    var d0 = (j0 && j0.data) || {};
    var pr0 = d0.spe_price || [];
    tried.push(c0.name + (pr0.length ? "(有价" + pr0.length + "组合)" : "(未定价)"));
    if (pr0.length) { hit = c0; speData = d0; break; }
  }
  if (!hit) { console.error("候选系列均未定价：" + tried.join("、")); process.exit(1); }
  console.log("目标系列: " + hit.name + " (SeriesId=" + hit.id + ", " + hit.factory + ")");
  if (tried.length > 1) console.log("  候选: " + tried.join("、"));

  // ★全维度字典：拉全部 spe_prop + spe_opt（不只壳架/极数/电流三个）
  var 展 = 展开价格行(speData.spe_prop || [], speData.spe_opt || [], speData.spe_price || []);
  var rows = 展.rows;
  var 角色表 = 展.propRole;
  var 维度清单 = [];
  Object.keys(角色表).forEach(function (pid) { 维度清单.push(展.propName[pid] + "#" + 角色表[pid]); });
  console.log("系列组合价格 " + rows.length + " 条；维度: " + 维度清单.join("、"));
  var 有码维度 = rows.some(function (r) { return r.code; });
  var 有操作维度 = rows.some(function (r) { return r.oper; });

  // 品名：系列树拿 DustryName（与元件库"替换"按钮同源）
  var dustry = "";
  try {
    for (var fi = 1; fi <= 2 && !dustry; fi++) {
      var treeRaw = await get("http://127.0.0.1:8080/api8k/get_seriesdata?factId=" + fi);
      var tree = JSON.parse(treeRaw);
      (function walk(nodes) {
        (nodes || []).forEach(function (n) {
          if (Number(n.SeriesId) === Number(hit.id)) { dustry = String(n.DustryName || ""); hit.treeName = String(n.SeriesName || n.seriesname || hit.name); }
          if (n.child) walk(n.child);
        });
      })(tree.data || tree);
    }
  } catch (e) { }
  if (!dustry) console.log("  (系列树未取到 DustryName，xin_pinming 将省略由软件按系列名补)");

  // ★折扣现读（元件库页面 localStorage；读不到按 100→系数1）
  var bt = 100;
  try {
    var pr = JSON.parse(await postJson("http://127.0.0.1:" + port + "/api/page?token=" + encodeURIComponent(token), {
      js: "(function(){var o={};for(var i=0;i<localStorage.length;i++){var k=localStorage.key(i);if(k&&k.indexOf('__dqb折扣@')===0){try{o[k.slice(8)]=JSON.parse(localStorage.getItem(k))}catch(e){}}}return JSON.stringify(o)})()"
    }));
    if (pr && pr.ok && pr.result) {
      var map = JSON.parse(JSON.parse(pr.result));
      var key = Object.keys(map).filter(function (k) { return k === hit.name || k === hit.treeName; })[0];
      if (key && map[key] && map[key].bt) bt = parseFloat(map[key].bt);
    }
  } catch (e) { }
  var xishu = bt / 100;
  console.log("采购系数=" + xishu + "（系列折扣bt=" + bt + "%，页面 localStorage 现读" + (bt === 100 ? "，无存档按100" : "") + "）");

  // ===== 逐行解析+全维度匹配（无兜底：匹配不上即跳过） =====
  var done = [], skip = [];
  for (var i = 0; i < targets.length; i++) {
    var t = targets[i];
    var guige = t.guige;
    var fixedNote = "";
    if (fixMap[guige]) { fixedNote = " [已按修正文件: " + fixMap[guige] + "]"; guige = fixMap[guige]; }
    var P = parseSpecAll(guige);
    if (!P.cands.length) {
      var why = P.invalid.length ? P.invalid.map(function (x) { return "附件码" + x.code + "非法:" + x.why; }).join(";") : "解析不出壳架/极数/电流";
      skip.push({ guige: t.guige, fenlei: t.fenlei, why: why + fixedNote });
      continue;
    }
    // 逐候选解试全维度匹配
    var 方案 = [];
    P.cands.forEach(function (cand) {
      var hits = rows.filter(function (r) { return !全维度匹配(cand, r); });
      // 操作方式默认=手柄直接操作（旧规格不带操作附件信息时，取手柄直操行；系列无手柄行则保留全部）
      if (hits.length && 有操作维度) {
        var 手柄 = hits.filter(function (r) { return String(r.oper).indexOf("手柄") >= 0 || String(r.oper).indexOf("直接") >= 0; });
        if (手柄.length) hits = 手柄;
      }
      if (!hits.length) return;
      // 价格唯一性：同维度命中行价格不一致 → 先按"默认配置"消歧，仍不唯一才跳过
      var prices = {};
      hits.forEach(function (r) { prices[r.price] = 1; });
      var pk = Object.keys(prices);
      if (pk.length > 1) {
        // v3 默认配置偏好：多价歧义常见于 过压保护/远程附件/选用说明 等未识别维度——
        //   优先取"未识别维度全为 无/不带/标准"的行，过滤后价格唯一即采纳(方案表标注)；仍多价才跳过
        var 默认行 = hits.filter(function (r) {
          return r.unnamed.every(function (t) { return /无|不带|标准|普通|缺省|—/.test(t); });
        });
        var dp = {};
        默认行.forEach(function (r) { dp[r.price] = 1; });
        if (Object.keys(dp).length === 1) {
          方案.push({ cand: cand, row: 默认行[0], hits: 默认行.length, 默认注: "按标准/无附件配置(过压保护等附加项取无)" });
          return;
        }
        方案.push({ cand: cand, 歧义: pk.join("/") });
        return;
      }
      方案.push({ cand: cand, row: hits[0], hits: hits.length });
    });
    var 歧义方案 = 方案.filter(function (x) { return x.歧义; });
    var 实方案 = 方案.filter(function (x) { return x.row; });
    if (!实方案.length) {
      var why2;
      if (歧义方案.length) why2 = "多价歧义(" + 歧义方案[0].歧义 + ")，需人工确认";
      else {
        var best = P.cands[0];
        why2 = "系列内无全维度匹配：" + 匹配诊断(best, rows) + (P.cands.length > 1 ? "（候选解" + P.cands.length + "个均未命中）" : "") + (有码维度 ? "" : "（该系列型号不带附件码）") + fixedNote;
      }
      skip.push({ guige: t.guige, fenlei: t.fenlei, why: why2 });
      continue;
    }
    // 多个候选解都命中且新规格不同 → 歧义跳过
    var specs = {};
    实方案.forEach(function (x) { specs[组装新规格(x.cand, x.row)] = 1; });
    if (Object.keys(specs).length > 1) {
      skip.push({ guige: t.guige, fenlei: t.fenlei, why: "粘连多解均命中(" + Object.keys(specs).join(" / ") + ")，需人工确认" + fixedNote });
      continue;
    }
    var x = 实方案[0];
    done.push({
      old: t.guige, cand: x.cand, row: x.row, neu: 组装新规格(x.cand, x.row),
      price: x.row.price, hits: x.hits,
      note: (x.cand.code ? 码解读(x.cand.code, x.cand.codeC) : 微型解读(x.cand))
        + (x.默认注 ? " [" + x.默认注 + "]" : "")
        + (t.tuiDuan ? " ⚠️推断(fenlei=null,解析认定)" : "")
        + (fixedNote || "")
    });
  }

  /// v3 微型要素解读（方案表展示用）
  function 微型解读(c) {
    var s = [];
    if (c.poles) s.push(c.poles);
    if (c.curve) s.push(c.curve + "型");
    if (c.dl) s.push(c.dl + "A");
    if (c.ma) s.push(c.ma + "mA");
    return s.length ? "微型 " + s.join(" ") : "微型";
  }

  function 组装新规格(cand, row) {
    var shortName = hit.name.replace(/系列.*/, "");
    // v3 微型：规范型号串=系列短名 + 各选项 nameStr 按 nameSort 顺序拼接（与元件库页面拼装同源，
    //   2026-09-26 从页面 chunk 逆向确认；nameStr 自带前后空格，直接连接后压空白）
    if (!row.code && row.nameParts.length) {
      return (shortName + row.nameParts.map(function (p) { return p.str; }).join("")).replace(/\s+/g, " ").trim();
    }
    var kjShow = row.kj || cand.kj;
    var parts = shortName + (kjShow ? "-" + kjShow : "") + (row.fenhe || "");
    if (row.code) parts += "/" + row.code;
    parts += (row.dl || cand.dl) ? " " + (row.dl || cand.dl) + "A" : "";
    if (cand.js && !row.code) parts += " " + cand.js;
    var jx = normJx(cand.jiexian);
    if (jx !== "板前") parts += " " + jx;
    return parts.replace(/\s+/g, " ").trim();
  }

  // ===== 输出 / 提交 =====
  console.log("");
  console.log(DRY ? "=== 方案表（dry 预览，未改库；确认后 --exec 执行）===" : "=== 执行替换 ===");
  if (DRY) {
    done.forEach(function (d) {
      console.log("| " + d.old + " | " + d.note + " | " + d.neu + " | 表价" + d.price.toFixed(2) + " | 系数" + xishu + " | 命中" + d.hits + "行组合 |");
    });
    if (skip.length) {
      console.log("=== 跳过 " + skip.length + " 行（匹配不上就不替换）===");
      skip.forEach(function (k) { console.log("| " + k.guige + " | " + (k.fenlei || "?") + " | " + k.why + " |"); });
    }
    console.log("");
    console.log("共 " + done.length + " 行可替换 / " + skip.length + " 行跳过。");
    return;
  }

  // --exec：一次 /api/replacebatch；失败项回落逐行 /api/replace
  var items = done.map(function (d) {
    return {
      jiu_mingcheng: d.ming || "", jiu_guige: d.old,
      xin_pinming: dustry, xin_guige: d.neu, xin_biaojia: d.price, xin_xishu: xishu,
      xin_pinpai: hit.factory, xin_xilie: hit.treeName || hit.name
    };
  });
  var 批 = { items: [] };
  var resp = null;
  if (items.length) {
    try {
      resp = JSON.parse(await postJson("http://127.0.0.1:" + port + "/api/replacebatch?token=" + encodeURIComponent(token), { items: items }));
    } catch (e) { console.error("replacebatch 请求失败: " + e.message); }
  }
  var okSet = {};
  if (resp && resp.ok) {
    (resp.results || []).forEach(function (r, idx) {
      if (r && !r.error && r.rows > 0) okSet[idx] = 1;
    });
  }
  // 失败项回落逐行（同款协议）
  for (var di = 0; di < done.length; di++) {
    if (okSet[di]) {
      var rr = (resp.results || [])[di] || {};
      console.log("| " + done[di].old + " | " + done[di].neu + " | 表价" + done[di].price.toFixed(2) + " | 影响" + rr.rows + "行 | 批量命中 |");
      continue;
    }
    var it = items[di];
    var r2 = null;
    try { r2 = JSON.parse(await postJson("http://127.0.0.1:" + port + "/api/replace?token=" + encodeURIComponent(token), {
      jiu_mingcheng: it.jiu_mingcheng, jiu_guige: it.jiu_guige,
      xin_pinming: it.xin_pinming, xin_guige: it.xin_guige, xin_biaojia: it.xin_biaojia,
      xin_xishu: it.xin_xishu, xin_pinpai: it.xin_pinpai, xin_xilie: it.xin_xilie
    })); } catch (e) { }
    if (r2 && r2.ok && r2.rows > 0) console.log("| " + done[di].old + " | " + done[di].neu + " | 表价" + done[di].price.toFixed(2) + " | 影响" + r2.rows + "行 | 回落单条 |");
    else skip.push({ guige: done[di].old, fenlei: "", why: "接口拒绝: " + ((r2 && r2.error) || (resp && resp.error) || "未知") });
  }
  if (skip.length) {
    console.log("=== 跳过/失败 " + skip.length + " 行 ===");
    skip.forEach(function (k) { console.log("| " + k.guige + " | " + (k.fenlei || "?") + " | " + k.why + " |"); });
  }
  console.log("");
  console.log("完成：执行 " + done.length + " 项，跳过/失败 " + skip.length + " 项。");
}

// ================= 离线自测（node xuanxing.js --selftest） =================
function selftest() {
  var fail = 0;
  function eq(name, got, want) {
    var ok = JSON.stringify(got) === JSON.stringify(want);
    if (!ok) { fail++; console.log("✗ " + name + ": got " + JSON.stringify(got) + " want " + JSON.stringify(want)); }
    else console.log("✓ " + name);
  }
  eq("码33002合法", (function () { var c = 拆附件码("33002"); return [c.ok, c.js, c.tk, c.yt]; })(), [true, "3P", "3", "2"]);
  eq("码32008非法(用途位)", 拆附件码("32008").ok, false);
  eq("码32008原因含'用途'", 拆附件码("32008").why.indexOf("用途") >= 0, true);
  eq("码3300合法", (function () { var c = 拆附件码("3300"); return [c.ok, c.js, c.tk]; })(), [true, "3P", "3"]);
  eq("码3200合法(电磁)", 拆附件码("3200").tk, "2");
  eq("码3320合法", 拆附件码("3320").ok, true);
  eq("码3308合法", 拆附件码("3308").ok, true);
  eq("码3400非法(个位4)", 拆附件码("3400").ok, false);
  eq("码3900非法(脱扣9)", 拆附件码("3900").ok, false);
  eq("码320/328合法(NM2)", [拆附件码("320").ok, 拆附件码("328").ok], [true, true]);
  eq("码330/338非法(NM2无此码)", [拆附件码("330").ok, 拆附件码("338").ok], [false, false]);
  eq("码AX/SHT合法(字母)", [拆附件码("AX").ok, 拆附件码("SHT").ok], [true, true]);
  eq("码AB非法(字母白名单)", 拆附件码("AB").ok, false);
  eq("码10Y合法(预付费)", 拆附件码("10Y").ok, true);
  eq("码3300200非法(超5位)", 拆附件码("3300200").ok, false);
  var p1 = parseSpecAll("CDM3S-250F/3300200A");
  eq("3300200A唯一解=3300+200", p1.cands.map(function (c) { return c.code + "|" + c.dl; }), ["3300|200"]);
  eq("3300200A壳架250分断F", [p1.base.kj, p1.base.fenhe], [250, "F"]);
  var p2 = parseSpecAll("CDM3-63C/3200863A");
  eq("3200863A无合法候选(码32008非法)", p2.cands.length, 0);
  var x1 = parseSpecAll("XT4N250/3340 200A");
  eq("ABB XT4N250 壳架=250", x1.base.kj, 250);
  eq("XT /3340 码合法", x1.cands.map(function (c) { return c.code; }), ["3340"]);
  var x2 = parseSpecAll("NSX100F TMD 100A 3P3D");
  eq("施耐德 NSX100F 壳架=100(通用兜底)", x2.base.kj, 100);
  eq("NSX 电流/极数(无码→fix 由 LLM 翻译)", [x2.cands[0].dl, x2.cands[0].js, x2.cands[0].code], [100, "3P", ""]);
  eq("XT2N160 壳架=160", parseSpecAll("XT2N160 TMA 160 3p").base.kj, 160);
  eq("壳架1000 支持", parseSpecAll("NM8-1000/3300 800A").base.kj, 1000);
  eq("B曲线识别(施耐德微型)", (function () { var c = parseSpecAll("iC65N B16 1P").cands[0]; return [c.curve, c.dl]; })(), ["B", 16]);
  eq("3200863A记录非法码", p2.invalid.map(function (x) { return x.code; }), ["32008"]);
  var p3 = parseSpecAll("NXM-63S/33002 63A 板后接线");
  eq("标准串33002+板后", p3.cands.map(function (c) { return c.code + "|" + c.dl + "|" + c.js; }), ["33002|63|3P"]);
  eq("标准串接线后缀", p3.base.jiexian, "板后接线");
  eq("标准串壳架", p3.base.kj, 63);
  var p4 = parseSpecAll("CDM3S-160S/3300140A");
  eq("3300140A=3300+140(140∈档位)", p4.cands.map(function (c) { return c.code + "|" + c.dl; }), ["3300|140"]);
  var p5 = parseSpecAll("NXM-630S/33002500A");
  eq("33002500A=33002+500(2500超壳架)", p5.cands.map(function (c) { return c.code + "|" + c.dl; }), ["33002|500"]);
  var p6 = parseSpecAll("DZ47sLE 1P+N C16 30mA");
  eq("微型无码串仍可解析", [p6.cands.length, p6.cands[0] && p6.cands[0].js, p6.cands[0] && p6.cands[0].dl], [1, "1P", 16]);
  // 合成系列字典全维度匹配测试：33002 行不得被 3300 串命中
  var props = [
    { propId: 1, propName: "壳架电流" }, { propId: 2, propName: "分断能力" }, { propId: 3, propName: "操作方式" },
    { propId: 4, propName: "极数" }, { propId: 5, propName: "脱扣器" }, { propId: 6, propName: "附件代号1" },
    { propId: 7, propName: "附件代号2" }, { propId: 8, propName: "用途" }, { propId: 9, propName: "额定电流" }, { propId: 10, propName: "接线方式" }
  ];
  var opts = [
    { propId: 1, optId: 56, optName: "63A" }, { propId: 2, optId: 24, optName: "S 25kA" }, { propId: 3, optId: 22, optName: "手柄直接操作" },
    { propId: 4, optId: 15, optName: "3【3P】" }, { propId: 5, optId: 17, optName: "3【热磁式】" },
    { propId: 6, optId: 18, optName: "0【无附件】" }, { propId: 7, optId: 19, optName: "0【无附件】" },
    { propId: 8, optId: 74, optName: "【配电保护】" }, { propId: 8, optId: 75, optName: "2【电动机保护】" },
    { propId: 9, optId: 33, optName: "63A" }, { propId: 10, optId: 27, optName: "板前接线" }
  ];
  var prices = [
    { optStr: "56-24-22-15-17-18-19-74-33-27", compPrice: "322" },
    { optStr: "56-24-22-15-17-18-19-75-33-27", compPrice: "322" }
  ];
  var E = 展开价格行(props, opts, prices);
  eq("合成行码=3300/33002", E.rows.map(function (r) { return r.code; }), ["3300", "33002"]);
  var c3300 = parseSpecAll("NXM-63S/3300 63A").cands[0];
  var c33002 = parseSpecAll("NXM-63S/33002 63A").cands[0];
  eq("3300串命中3300行", E.rows.filter(function (r) { return !全维度匹配(c3300, r); }).map(function (r) { return r.code; }), ["3300"]);
  eq("33002串命中33002行(不被3300行吞)", E.rows.filter(function (r) { return !全维度匹配(c33002, r); }).map(function (r) { return r.code; }), ["33002"]);
  var c板后 = parseSpecAll("NXM-63S/3300 63A 板后接线").cands[0];
  eq("接线不匹配被拒", E.rows.filter(function (r) { return !全维度匹配(c板后, r); }).length, 0);
  // ===== v3 微型断路器：合成系列（极数含+N/曲线/电流/漏电，无码维度） =====
  var mprops = [
    { propId: 1, propName: "极数" }, { propId: 2, propName: "曲线类型" },
    { propId: 3, propName: "额定电流" }, { propId: 4, propName: "剩余动作电流" }
  ];
  var mopts = [
    { propId: 1, optId: 1, optName: "1P＋N（N极可开闭）", nameStr: " 1P+N（N极可开闭）", nameSort: 2 },
    { propId: 1, optId: 2, optName: "2P", nameStr: " 2P", nameSort: 2 },
    { propId: 2, optId: 3, optName: "C型", nameStr: " C", nameSort: 3 },
    { propId: 2, optId: 4, optName: "D型", nameStr: " D", nameSort: 3 },
    { propId: 3, optId: 5, optName: "16A", nameStr: " C16", nameSort: 4 },
    { propId: 4, optId: 6, optName: "30mA", nameStr: "", nameSort: 5 },
    { propId: 4, optId: 7, optName: "300mA", nameStr: "", nameSort: 5 }
  ];
  var mprices = [
    { optStr: "1-3-5-6", compPrice: "76.09" },
    { optStr: "1-4-5-6", compPrice: "76.84" },
    { optStr: "1-3-5-7", compPrice: "90" },
    { optStr: "2-3-5-6", compPrice: "60" }
  ];
  var M = 展开价格行(mprops, mopts, mprices);
  eq("微型行无码", M.rows.every(function (r) { return !r.code; }), true);
  eq("微型行要素提取(极数N/曲线/mA)", [M.rows[0].poles, M.rows[0].curve, M.rows[0].ma, M.rows[0].dl], ["1P+N", "C", 30, 16]);
  var m1 = parseSpecAll("DZ47PLE 1P+N C16 30mA").cands[0];
  eq("微型解析(1P+N/C/30mA)", [m1.poles, m1.curve, m1.ma, m1.dl], ["1P+N", "C", 30, 16]);
  var 乱码 = parseSpecAll("D747sLE 1P+N C16 300mA").cands[0];
  eq("乱码行解析(300mA)", [乱码.poles, 乱码.curve, 乱码.ma], ["1P+N", "C", 300]);
  eq("微型C16/30mA 命中76.09", M.rows.filter(function (r) { return !全维度匹配(m1, r); }).map(function (r) { return r.price; }), [76.09]);
  var m2 = parseSpecAll("DZ47sLE 1P＋N D16 30mA").cands[0];
  eq("微型D型区分(命中76.84不串C型)", M.rows.filter(function (r) { return !全维度匹配(m2, r); }).map(function (r) { return r.price; }), [76.84]);
  eq("微型300mA区分", M.rows.filter(function (r) { return !全维度匹配(乱码, r); }).map(function (r) { return r.price; }), [90]);
  var m3 = parseSpecAll("DZ47 2P C16 30mA").cands[0];
  eq("微型2P区分(不带N)", M.rows.filter(function (r) { return !全维度匹配(m3, r); }).map(function (r) { return r.price; }), [60]);
  var m4 = parseSpecAll("DZ47 1P+N C16").cands[0];
  eq("cand缺漏电档→匹配层放行(30/300mA行都过,交价格消歧)", M.rows.filter(function (r) { return !全维度匹配(m4, r); }).length, 2);
  console.log(fail ? "\n自测失败 " + fail + " 项" : "\n自测全部通过");
  process.exit(fail ? 1 : 0);
}
if (args.indexOf("--selftest") >= 0) selftest();
else main().catch(function (e) { console.error("脚本异常: " + (e && e.message || e)); process.exit(1); });