dsh-metaphysics 0.14.3 → 0.15.0

package/engine/diff.js

@@ -0,0 +1,197 @@
+// 口径差异：同一组参数在不同流派口径下排出的盘，逐字段比对
+//
+// 用途：口径（晚子时换日、真太阳时、拆补/超神接气/置闰、闰月归月）是命理圈争执最多的地方。
+// 多数工具切换后只给新结果，用户不知道「哪里变了」。这里把变化摊开：
+//   变化字段路径 + 旧值 → 新值 + 一句话总结。
+//
+// 只做结构化比对，不改动任何引擎的输出。
+
+/** 比对时忽略的字段：文案、时间戳、口径回显、内部儒略日数字 */
+const IGNORE_KEYS = new Set([
+  'summary', 'interpret', 'castAt', 'asOf', 'precision', 'disclaimer', 'note',
+  'trueSolarText', 'civilText', 'offsetMinutes',
+  'input', // 只是把调用参数回显出来，不是盘面变化
+  'jd',    // 内部儒略日，人类不可读；对外展示用 time 等格式化字段
+]);
+
+const isObject = (v) => v !== null && typeof v === 'object';
+
+/**
+ * 结构化差异
+ * @returns {{path:string, from:any, to:any}[]}
+ */
+export function diffObjects(a, b, path = '', out = []) {
+  if (a === b) return out;
+  if (!isObject(a) || !isObject(b)) {
+    out.push({ path: path || '(root)', from: a, to: b });
+    return out;
+  }
+  const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const k of keys) {
+    if (IGNORE_KEYS.has(k)) continue;
+    const p = path ? `${path}.${k}` : k;
+    const va = a[k];
+    const vb = b[k];
+    if (isObject(va) && isObject(vb)) {
+      diffObjects(va, vb, p, out);
+    } else if (JSON.stringify(va) !== JSON.stringify(vb)) {
+      out.push({ path: p, from: va, to: vb });
+    }
+  }
+  return out;
+}
+
+/** 路径 → 盘面栏位名；未命中细分规则时退回所属大类 */
+const LABELS = [
+  [/^pillars\.year\.ganzhi$/, '年柱'],
+  [/^pillars\.month\.ganzhi$/, '月柱'],
+  [/^pillars\.day\.ganzhi$/, '日柱'],
+  [/^pillars\.hour\.ganzhi$/, '时柱'],
+  [/^pillars\.\w+\.hidden/, '藏干'],
+  [/^pillars\.\w+\.stemTenGod$/, '十神'],
+  [/^pillars\.\w+\.kongwang/, '空亡'],
+  [/^pillars\.\w+\.dishi$|^pillars\.\w+\.zizuo$/, '十二长生'],
+  [/^pillars\.\w+\.nayin$/, '纳音'],
+  [/^dayMaster\./, '日主'],
+  [/^palaces\./, '命身宫'],
+  [/^dayun\.list\.(\d+)\.ganzhi$/, '大运干支'],
+  [/^dayun\.startAge\./, '起运时间'],
+  [/^dayun\./, '大运评分'],
+  [/^liunian\./, '流年'],
+  [/^jieqi\./, '节气边界'],
+  [/^solarTime\./, '真太阳时'],
+  [/^dayGanZhi$/, '日辰'],
+  [/^hourZhi$/, '时支'],
+  [/^yueJiang\./, '月将'],
+  [/^ju(Num|Name)?$/, '局数'],
+  [/^xunKong$/, '旬空'],
+  [/^lines\.(\d+)\./, '爻'],
+  [/^shensha\./, '神煞'],
+  [/^frame\./, '格局用神'],
+  [/^strength\./, '旺衰'],
+  [/^wuxing\./, '五行计数'],
+  [/^relations\./, '干支关系'],
+  [/^input\./, '输入回显'],
+];
+
+/** 大类：用于把几百处连带变化归成几句话 */
+const CATEGORY = [
+  [/^pillars\./, '四柱'],
+  [/^shensha\./, '神煞'],
+  [/^dayun\./, '大运'],
+  [/^liunian\./, '流年'],
+  [/^frame\./, '格局用神'],
+  [/^strength\./, '旺衰'],
+  [/^wuxing\./, '五行计数'],
+  [/^dayMaster\./, '日主'],
+  [/^relations\./, '干支关系'],
+  [/^palaces\./, '命身宫'],
+  [/^jieqi\./, '节气'],
+  [/^solarTime\./, '真太阳时'],
+  [/^input\./, '输入回显'],
+  [/^lines\./, '爻'],
+];
+
+/**
+ * 根因字段：真正被口径直接改动的干支/局数/爻。
+ * 其余几百处都是从这里派生出去的——把这层关系讲清楚，才是「口径对照」的价值。
+ */
+const ROOT = [
+  [/^pillars\.(year|month|day|hour)\.ganzhi$/, '柱'],
+  [/^dayGanZhi$/, '日辰'],
+  [/^hourZhi$/, '时支'],
+  [/^ju(Num|Name)?$/, '局数'],
+  [/^lines\.\d+\.(ganzhi|yinYang|name)$/, '爻'],
+  [/^yueJiang\.(name|zhi)$/, '月将'],
+];
+
+export function labelOf(path) {
+  for (const [re, label] of LABELS) {
+    if (re.test(path)) return label;
+  }
+  return categoryOf(path) || path;
+}
+
+export function categoryOf(path) {
+  for (const [re, cat] of CATEGORY) {
+    if (re.test(path)) return cat;
+  }
+  return '';
+}
+
+export function rootOf(path) {
+  for (const [re, label] of ROOT) {
+    if (re.test(path)) return label;
+  }
+  return '';
+}
+
+/** 自然排序：行运类按序号，其余按字符串 */
+export function sortDiffs(diffs) {
+  return [...diffs].sort((x, y) => x.path.localeCompare(y.path, 'zh-Hans-CN', { numeric: true }));
+}
+
+/**
+ * 把一组变化归纳成因果式一句话：
+ * 「根因：日柱 丙子 → 乙亥；连带影响 四柱、神煞、大运、流年 等 6 类（共 407 处）」
+ */
+export function summarize(diffs) {
+  if (!diffs.length) return '本盘不受此口径影响：所有字段一致。';
+  const roots = diffs.filter((d) => rootOf(d.path));
+  const cats = [...new Set(diffs.map((d) => categoryOf(d.path)).filter(Boolean))];
+  const head = roots.length
+    ? `根因 ${roots.length} 处：` + roots.slice(0, 4)
+      .map((d) => `${labelOf(d.path)} ${fmt(d.from)}→${fmt(d.to)}`).join('、')
+      + (roots.length > 4 ? ' 等' : '')
+    : '无单一根因';
+  const tail = cats.length
+    ? `；连带影响 ${cats.slice(0, 6).join('、')}${cats.length > 6 ? ' 等' : ''} ${cats.length} 类，共 ${diffs.length} 处`
+    : `；共 ${diffs.length} 处`;
+  return head + tail + '。';
+}
+
+const fmt = (v) => {
+  if (v === undefined) return '—';
+  if (v === null) return 'null';
+  if (typeof v === 'string') return v;
+  if (Array.isArray(v)) return v.join('') || '[]';
+  if (typeof v === 'object') return JSON.stringify(v);
+  return String(v);
+};
+
+/**
+ * 文本版对照：先列根因，再列连带变化（默认最多 12 处，其余按类归并）
+ */
+export function renderDiff(diffs, { title = '', limit = 12 } = {}) {
+  const lines = [];
+  if (title) lines.push(`【${title}】`);
+  lines.push(summarize(diffs));
+  if (!diffs.length) return lines.join('\n');
+
+  const roots = sortDiffs(diffs.filter((d) => rootOf(d.path)));
+  const rest = sortDiffs(diffs.filter((d) => !rootOf(d.path)));
+
+  if (roots.length) {
+    lines.push('');
+    lines.push('  根因（口径直接改动）：');
+    for (const d of roots) {
+      lines.push(`    ${labelOf(d.path).padEnd(6)} ${fmt(d.from)} → ${fmt(d.to)}`);
+    }
+  }
+  if (rest.length) {
+    lines.push('');
+    lines.push(`  连带变化（${rest.length} 处，展示前 ${Math.min(limit, rest.length)} 处）：`);
+    for (const d of rest.slice(0, limit)) {
+      lines.push(`    ${labelOf(d.path).padEnd(6)} ${fmt(d.from)} → ${fmt(d.to)}`);
+    }
+    if (rest.length > limit) {
+      const byCat = {};
+      for (const d of rest.slice(limit)) {
+        const c = categoryOf(d.path) || '其他';
+        byCat[c] = (byCat[c] || 0) + 1;
+      }
+      lines.push('    其余：' + Object.entries(byCat).map(([c, n]) => `${c} ${n} 处`).join('、'));
+    }
+  }
+  return lines.join('\n');
+}

package/engine/fail.js

@@ -0,0 +1,13 @@
+// 统一错误工厂：带错误码的 Error，工具层据此把「参数错误」转成可执行提示，
+// 而不是把内部堆栈直出给模型。引擎各模块都从这里取 fail，避免各自造一个。
+
+/**
+ * @param {string} code 错误码：E_INPUT / E_RANGE / E_LINES / E_COUNT / E_ASOF / E_PARTNER / E_SYSTEM
+ * @param {string} message 面向调用方的中文说明（含修复提示）
+ * @returns {Error & { code: string }}
+ */
+export const fail = (code, message) => {
+  const e = new Error(message);
+  e.code = code;
+  return e;
+};

package/engine/geo.js

@@ -143,7 +143,7 @@ const DETAIL = /(区|县|镇|乡|村|小区|街道|路|号|巷|弄|组|队)/;
 
 /** OpenStreetMap Nominatim：免密钥、支持中文。失败返回 null。
  *  UA 按 OSM 使用政策要求写明应用与联系方式（改版本时同步这里）。 */
-const USER_AGENT = 'dsh-metaphysics/0.14.3 (+https://github.com/xuanfu-web/dsh-metaphysics)';
+const USER_AGENT = 'dsh-metaphysics/0.15.0 (+https://github.com/xuanfu-web/dsh-metaphysics)';
 
 async function onlineLookup(text, { timeoutMs = 2500 } = {}) {
   if (typeof fetch !== 'function') return null;

package/engine/hepan.js

@@ -1,144 +1,147 @@
-// 合盘（合婚）：日主关系 + 夫妻宫关系 + 五行互补。
-// 口径：日主取五行生克（双向平均），夫妻宫取日支的六合/三合/冲/害/刑/破，
-// 五行互补看「一方喜用是否正是另一方所旺」。各派取法不同，这里只给通用版结论。
-import { buildBazi } from './bazi.js';
-import { STEMS, BRANCHES } from './calendar.js';
-
-const WX_GAN = { 甲: '木', 乙: '木', 丙: '火', 丁: '火', 戊: '土', 己: '土', 庚: '金', 辛: '金', 壬: '水', 癸: '水' };
-const WX_ZHI = { 子: '水', 丑: '土', 寅: '木', 卯: '木', 辰: '土', 巳: '火', 午: '火', 未: '土', 申: '金', 酉: '金', 戌: '土', 亥: '水' };
-const SHENG = { 木: '火', 火: '土', 土: '金', 金: '水', 水: '木' };
-const KE = { 木: '土', 土: '水', 水: '火', 火: '金', 金: '木' };
-
-// 地支两两关系（只取合、冲、害、刑、破；三合按半合算）
-const LIU_HE = [['子', '丑'], ['寅', '亥'], ['卯', '戌'], ['辰', '酉'], ['巳', '申'], ['午', '未']];
-const CHONG = [['子', '午'], ['丑', '未'], ['寅', '申'], ['卯', '酉'], ['辰', '戌'], ['巳', '亥']];
-const HAI = [['子', '未'], ['丑', '午'], ['寅', '巳'], ['卯', '辰'], ['申', '亥'], ['酉', '戌']];
-const PO = [['子', '酉'], ['卯', '午'], ['辰', '丑'], ['未', '戌'], ['寅', '亥'], ['巳', '申']];
-const SAN_HE = [['申', '子', '辰'], ['寅', '午', '戌'], ['巳', '酉', '丑'], ['亥', '卯', '未']];
-const XING = [['寅', '巳', '申'], ['丑', '戌', '未'], ['子', '卯']];
-
-const pairIn = (list, a, b) => list.some((g) => g.includes(a) && g.includes(b) && a !== b);
-
-function zhiRelation(a, b) {
-  if (a === b) return { name: '同支', score: 0, text: '日支相同，性情相近，容易互相理解，也容易同时卡在同一处' };
-  if (pairIn(LIU_HE, a, b)) return { name: '六合', score: 20, text: '日支六合，相处自然、彼此补位' };
-  for (const g of SAN_HE) {
-    if (g.includes(a) && g.includes(b)) return { name: '半合', score: 14, text: '日支同属三合局，易有共同语言' };
-  }
-  if (pairIn(CHONG, a, b)) return { name: '相冲', score: -15, text: '日支相冲，节奏与需求容易错位，需要刻意协调' };
-  if (pairIn(XING, a, b)) {
-    for (const g of XING) {
-      if (g.includes(a) && g.includes(b)) return { name: '相刑', score: -10, text: '日支相刑，摩擦多起于细节，宜少用指责' };
-    }
-  }
-  if (pairIn(HAI, a, b)) return { name: '相害', score: -9, text: '日支相害，容易因第三方或误解生嫌隙' };
-  if (pairIn(PO, a, b)) return { name: '相破', score: -5, text: '日支相破，小事易起波澜' };
-  return { name: '无直接关系', score: 4, text: '日支之间没有直接刑冲合害，关系好坏主要看经营' };
-}
-
-/** 两个五行之间：对方对我 */
-function wxToMe(other, me) {
-  if (other === me) return { name: '比和', score: 13, text: '两人日主同五行，气味相投，也容易一起犯同样的毛病' };
-  if (SHENG[other] === me) return { name: '生我', score: 20, text: '对方五行生我，容易得到照顾与助力' };
-  if (SHENG[me] === other) return { name: '我生', score: 10, text: '我生对方，多为付出的一方，久了要留意消耗' };
-  if (KE[me] === other) return { name: '我克', score: 5, text: '我克对方，主导感较强，需留意对方的空间' };
-  return { name: '克我', score: -12, text: '对方克我，压力感偏重，宜把话说开' };
-}
-
-/** 合盘主函数 */
-export function buildHepan(input) {
-  const A = buildBazi({ ...input.a, gender: input.a.gender });
-  const B = buildBazi({ ...input.b, gender: input.b.gender });
-
-  const aStem = A.pillars.day.stem;
-  const bStem = B.pillars.day.stem;
-  const aWx = WX_GAN[aStem];
-  const bWx = WX_GAN[bStem];
-  const aZhi = A.pillars.day.branch;
-  const bZhi = B.pillars.day.branch;
-
-  // ① 日主
-  const aToB = wxToMe(bWx, aWx); // 以 A 为主体看 B
-  const bToA = wxToMe(aWx, bWx);
-  const stemScore = (aToB.score + bToA.score) / 2;
-
-  // ② 夫妻宫（日支）
-  const gong = zhiRelation(aZhi, bZhi);
-
-  // ③ 五行互补：一方喜用是否正是另一方所旺
-  const favorA = (A.frame && A.frame.yongshen ? A.frame.yongshen.favor : []).slice();
-  const favorB = (B.frame && B.frame.yongshen ? B.frame.yongshen.favor : []).slice();
-  const wxCount = (r) => {
-    const m = {};
-    for (const k of ['year', 'month', 'day', 'hour']) {
-      m[WX_GAN[r.pillars[k].stem]] = (m[WX_GAN[r.pillars[k].stem]] || 0) + 1;
-      m[WX_ZHI[r.pillars[k].branch]] = (m[WX_ZHI[r.pillars[k].branch]] || 0) + 1;
-    }
-    return m;
-  };
-  const wxA = wxCount(A);
-  const wxB = wxCount(B);
-  const strongOf = (m) => Object.entries(m).sort((x, y) => y[1] - x[1])[0] || ['', 0];
-  const [strongA] = strongOf(wxA);
-  const [strongB] = strongOf(wxB);
-  const bFeedsA = favorA.includes(strongB);
-  const aFeedsB = favorB.includes(strongA);
-  let compScore = 0;
-  const compNotes = [];
-  if (bFeedsA) { compScore += 12; compNotes.push(`对方的旺行 ${strongB} 正是你的喜用`); }
-  if (aFeedsB) { compScore += 12; compNotes.push(`你的旺行 ${strongA} 正是对方的喜用`); }
-  if (!bFeedsA && !aFeedsB) { compScore += 3; compNotes.push('双方的旺行都不是对方的喜用，互补性一般，靠沟通补'); }
-  // 一方缺的五行正好是对方所旺，也算补
-  const missingA = ['木', '火', '土', '金', '水'].filter((w) => !wxA[w]);
-  const missingB = ['木', '火', '土', '金', '水'].filter((w) => !wxB[w]);
-  if (missingA.includes(strongB)) { compScore += 4; compNotes.push(`你命局缺 ${strongB}，对方正好偏旺`); }
-  if (missingB.includes(strongA)) { compScore += 4; compNotes.push(`对方命局缺 ${strongA}，你正好偏旺`); }
-
-  // ④ 综合
-  const raw = stemScore + gong.score + compScore; // 理论区间约 -27 ~ 56
-  const pct = Math.max(0, Math.min(100, Math.round(((raw + 27) / 83) * 100)));
-  const level = pct >= 75 ? '契合度较高' : pct >= 55 ? '中等偏顺' : pct >= 40 ? '需要磨合' : '差异较大';
-
-  const dim = (key, label, score, text, extra) => ({ key, label, score: Math.round(score), text, ...(extra || {}) });
-
-  return {
-    system: 'hepan',
-    a: {
-      gender: A.input.gender,
-      pillars: ['year', 'month', 'day', 'hour'].map((k) => A.pillars[k].ganzhi),
-      dayMaster: `${aStem}${aWx}`,
-      dayBranch: aZhi,
-      strength: A.strength ? A.strength.level : null,
-      favor: favorA.join(''),
-      wuxing: wxA,
-      // 真太阳时口径要能被看到：合盘与单盘用同一套修正，否则同一个人会出现两套四柱
-      longitude: A.input.longitude ?? null,
-      trueSolar: A.input.trueSolar !== false,
-      solarNote: A.solarTime ? A.solarTime.note : '',
-      summary: A.summary,
-    },
-    b: {
-      gender: B.input.gender,
-      pillars: ['year', 'month', 'day', 'hour'].map((k) => B.pillars[k].ganzhi),
-      dayMaster: `${bStem}${bWx}`,
-      dayBranch: bZhi,
-      strength: B.strength ? B.strength.level : null,
-      favor: favorB.join(''),
-      wuxing: wxB,
-      longitude: B.input.longitude ?? null,
-      trueSolar: B.input.trueSolar !== false,
-      solarNote: B.solarTime ? B.solarTime.note : '',
-      summary: B.summary,
-    },
-    score: { total: pct, level },
-    dimensions: [
-      dim('stem', '日主关系', stemScore, `你的日主 ${aStem}${aWx}，对方 ${bStem}${bWx}。${aToB.text}；${bToA.text}。`),
-      dim('gong', '夫妻宫（日支）', gong.score, `${gong.name}：${gong.text}。你日支 ${aZhi}，对方日支 ${bZhi}。`),
-      dim('wuxing', '五行互补', compScore, compNotes.join('；') + '。'),
-    ],
-    notes: [
-      '合盘看的是相处方式与互补点，不决定关系成败；现实里的沟通与选择分量更重。',
-      `口径：日主取五行生克双向平均，夫妻宫取日支关系，五行互补看「一方喜用是否为另一方所旺」。`,
-    ],
-  };
-}
+// 合盘（合婚）：日主关系 + 夫妻宫关系 + 五行互补。
+// 口径：日主取五行生克（双向平均），夫妻宫取日支的六合/三合/冲/害/刑/破，
+// 五行互补看「一方喜用是否正是另一方所旺」。各派取法不同，这里只给通用版结论。
+import { buildBazi } from './bazi.js';
+import { STEMS, BRANCHES } from './calendar.js';
+import { assertCivil } from './validate.js';
+import { SANHE_GROUPS } from './sanhe.js';
+
+const WX_GAN = { 甲: '木', 乙: '木', 丙: '火', 丁: '火', 戊: '土', 己: '土', 庚: '金', 辛: '金', 壬: '水', 癸: '水' };
+const WX_ZHI = { 子: '水', 丑: '土', 寅: '木', 卯: '木', 辰: '土', 巳: '火', 午: '火', 未: '土', 申: '金', 酉: '金', 戌: '土', 亥: '水' };
+const SHENG = { 木: '火', 火: '土', 土: '金', 金: '水', 水: '木' };
+const KE = { 木: '土', 土: '水', 水: '火', 火: '金', 金: '木' };
+
+// 地支两两关系（只取合、冲、害、刑、破；三合按半合算）
+const LIU_HE = [['子', '丑'], ['寅', '亥'], ['卯', '戌'], ['辰', '酉'], ['巳', '申'], ['午', '未']];
+const CHONG = [['子', '午'], ['丑', '未'], ['寅', '申'], ['卯', '酉'], ['辰', '戌'], ['巳', '亥']];
+const HAI = [['子', '未'], ['丑', '午'], ['寅', '巳'], ['卯', '辰'], ['申', '亥'], ['酉', '戌']];
+const PO = [['子', '酉'], ['卯', '午'], ['辰', '丑'], ['未', '戌'], ['寅', '亥'], ['巳', '申']];
+const XING = [['寅', '巳', '申'], ['丑', '戌', '未'], ['子', '卯']];
+
+const pairIn = (list, a, b) => list.some((g) => g.includes(a) && g.includes(b) && a !== b);
+
+function zhiRelation(a, b) {
+  if (a === b) return { name: '同支', score: 0, text: '日支相同，性情相近，容易互相理解，也容易同时卡在同一处' };
+  if (pairIn(LIU_HE, a, b)) return { name: '六合', score: 20, text: '日支六合，相处自然、彼此补位' };
+  if (SANHE_GROUPS.some((g) => g.branches.includes(a) && g.branches.includes(b))) {
+    return { name: '半合', score: 14, text: '日支同属三合局，易有共同语言' };
+  }
+  if (pairIn(CHONG, a, b)) return { name: '相冲', score: -15, text: '日支相冲，节奏与需求容易错位，需要刻意协调' };
+  if (pairIn(XING, a, b)) {
+    for (const g of XING) {
+      if (g.includes(a) && g.includes(b)) return { name: '相刑', score: -10, text: '日支相刑，摩擦多起于细节，宜少用指责' };
+    }
+  }
+  if (pairIn(HAI, a, b)) return { name: '相害', score: -9, text: '日支相害，容易因第三方或误解生嫌隙' };
+  if (pairIn(PO, a, b)) return { name: '相破', score: -5, text: '日支相破，小事易起波澜' };
+  return { name: '无直接关系', score: 4, text: '日支之间没有直接刑冲合害，关系好坏主要看经营' };
+}
+
+/** 两个五行之间：对方对我 */
+function wxToMe(other, me) {
+  if (other === me) return { name: '比和', score: 13, text: '两人日主同五行，气味相投，也容易一起犯同样的毛病' };
+  if (SHENG[other] === me) return { name: '生我', score: 20, text: '对方五行生我，容易得到照顾与助力' };
+  if (SHENG[me] === other) return { name: '我生', score: 10, text: '我生对方，多为付出的一方，久了要留意消耗' };
+  if (KE[me] === other) return { name: '我克', score: 5, text: '我克对方，主导感较强，需留意对方的空间' };
+  return { name: '克我', score: -12, text: '对方克我，压力感偏重，宜把话说开' };
+}
+
+/** 合盘主函数 */
+export function buildHepan(input) {
+  assertCivil(input && input.a, 'a');
+  assertCivil(input && input.b, 'b');
+  const A = buildBazi({ ...input.a, gender: input.a.gender });
+  const B = buildBazi({ ...input.b, gender: input.b.gender });
+
+  const aStem = A.pillars.day.stem;
+  const bStem = B.pillars.day.stem;
+  const aWx = WX_GAN[aStem];
+  const bWx = WX_GAN[bStem];
+  const aZhi = A.pillars.day.branch;
+  const bZhi = B.pillars.day.branch;
+
+  // ① 日主
+  const aToB = wxToMe(bWx, aWx); // 以 A 为主体看 B
+  const bToA = wxToMe(aWx, bWx);
+  const stemScore = (aToB.score + bToA.score) / 2;
+
+  // ② 夫妻宫（日支）
+  const gong = zhiRelation(aZhi, bZhi);
+
+  // ③ 五行互补：一方喜用是否正是另一方所旺
+  const favorA = (A.frame && A.frame.yongshen ? A.frame.yongshen.favor : []).slice();
+  const favorB = (B.frame && B.frame.yongshen ? B.frame.yongshen.favor : []).slice();
+  const wxCount = (r) => {
+    const m = {};
+    for (const k of ['year', 'month', 'day', 'hour']) {
+      m[WX_GAN[r.pillars[k].stem]] = (m[WX_GAN[r.pillars[k].stem]] || 0) + 1;
+      m[WX_ZHI[r.pillars[k].branch]] = (m[WX_ZHI[r.pillars[k].branch]] || 0) + 1;
+    }
+    return m;
+  };
+  const wxA = wxCount(A);
+  const wxB = wxCount(B);
+  const strongOf = (m) => Object.entries(m).sort((x, y) => y[1] - x[1])[0] || ['', 0];
+  const [strongA] = strongOf(wxA);
+  const [strongB] = strongOf(wxB);
+  const bFeedsA = favorA.includes(strongB);
+  const aFeedsB = favorB.includes(strongA);
+  let compScore = 0;
+  const compNotes = [];
+  if (bFeedsA) { compScore += 12; compNotes.push(`对方的旺行 ${strongB} 正是你的喜用`); }
+  if (aFeedsB) { compScore += 12; compNotes.push(`你的旺行 ${strongA} 正是对方的喜用`); }
+  if (!bFeedsA && !aFeedsB) { compScore += 3; compNotes.push('双方的旺行都不是对方的喜用，互补性一般，靠沟通补'); }
+  // 一方缺的五行正好是对方所旺，也算补
+  const missingA = ['木', '火', '土', '金', '水'].filter((w) => !wxA[w]);
+  const missingB = ['木', '火', '土', '金', '水'].filter((w) => !wxB[w]);
+  if (missingA.includes(strongB)) { compScore += 4; compNotes.push(`你命局缺 ${strongB}，对方正好偏旺`); }
+  if (missingB.includes(strongA)) { compScore += 4; compNotes.push(`对方命局缺 ${strongA}，你正好偏旺`); }
+
+  // ④ 综合
+  const raw = stemScore + gong.score + compScore; // 理论区间约 -27 ~ 56
+  const pct = Math.max(0, Math.min(100, Math.round(((raw + 27) / 83) * 100)));
+  const level = pct >= 75 ? '契合度较高' : pct >= 55 ? '中等偏顺' : pct >= 40 ? '需要磨合' : '差异较大';
+
+  const dim = (key, label, score, text, extra) => ({ key, label, score: Math.round(score), text, ...(extra || {}) });
+
+  return {
+    system: 'hepan',
+    a: {
+      gender: A.input.gender,
+      pillars: ['year', 'month', 'day', 'hour'].map((k) => A.pillars[k].ganzhi),
+      dayMaster: `${aStem}${aWx}`,
+      dayBranch: aZhi,
+      strength: A.strength ? A.strength.level : null,
+      favor: favorA.join(''),
+      wuxing: wxA,
+      // 真太阳时口径要能被看到：合盘与单盘用同一套修正，否则同一个人会出现两套四柱
+      longitude: A.input.longitude ?? null,
+      trueSolar: A.input.trueSolar !== false,
+      solarNote: A.solarTime ? A.solarTime.note : '',
+      summary: A.summary,
+    },
+    b: {
+      gender: B.input.gender,
+      pillars: ['year', 'month', 'day', 'hour'].map((k) => B.pillars[k].ganzhi),
+      dayMaster: `${bStem}${bWx}`,
+      dayBranch: bZhi,
+      strength: B.strength ? B.strength.level : null,
+      favor: favorB.join(''),
+      wuxing: wxB,
+      longitude: B.input.longitude ?? null,
+      trueSolar: B.input.trueSolar !== false,
+      solarNote: B.solarTime ? B.solarTime.note : '',
+      summary: B.summary,
+    },
+    score: { total: pct, level },
+    dimensions: [
+      dim('stem', '日主关系', stemScore, `你的日主 ${aStem}${aWx}，对方 ${bStem}${bWx}。${aToB.text}；${bToA.text}。`),
+      dim('gong', '夫妻宫（日支）', gong.score, `${gong.name}：${gong.text}。你日支 ${aZhi}，对方日支 ${bZhi}。`),
+      dim('wuxing', '五行互补', compScore, compNotes.join('；') + '。'),
+    ],
+    notes: [
+      '合盘看的是相处方式与互补点，不决定关系成败；现实里的沟通与选择分量更重。',
+      `口径：日主取五行生克双向平均，夫妻宫取日支关系，五行互补看「一方喜用是否为另一方所旺」。`,
+    ],
+  };
+}