dsh-metaphysics 0.61.2 → 0.62.1

package/engine/bazi-words.js

@@ -145,6 +145,9 @@ export function frameToneOf(level, favorRoles) {
 const RELATION_RULES = [
   [/自刑/, '自刑：自己跟自己较劲，多半是内耗而不是外来的事'],
   [/三会|三合/, '三合三会：几股力并成一股，做同类的事更容易成势'],
+  // 半合/拱合、半会/拱会都只到两支：先各自给一句，别让它们落到泛泛的「合」
+  [/半会|拱会/, '半会拱会：两支有会意但没凑成三会，像有默契还没结盟，可借势、不宜当定局'],
+  [/半合|拱合/, '合（半合/拱合）：三合只到两支，成势的苗头有了，还差最后一支'],
   [/六合|合/, '合：人事上容易谈拢，也容易被关系绑住、脱不开身'],
   [/相冲|冲/, '冲：桩子会晃，变动与拉扯偏多，宜先稳住再动'],
   [/相刑|刑/, '刑：规矩与情绪上的摩擦，事情不大但磨人'],

package/engine/bazi.js

@@ -6,7 +6,7 @@ import {
 } from './calendar.js';
 import { resolveAddress } from './geo.js';
 import { computeBaziShensha } from './shensha.js';
-import { assertCivil, daysInMonth } from './validate.js';
+import { assertCivil, assertShifted, daysInMonth } from './validate.js';
 import { applyDst } from './dst.js';
 import { nayinOf } from './nayin.js';
 import { SANHE } from './sanhe.js';
@@ -375,6 +375,8 @@ export function buildBazi(input) {
   const jdnBase = Math.floor(jd + 0.5);
   const hourOfDay = jdToParts(jd).hour;
   const jdn = lateZi && hourOfDay >= 23 ? jdnBase + 1 : jdnBase;
+  // 晚子时换日后若跨出 1600–2400，直接拒绝：直填 2401 已被 E_RANGE 拦下，换日不能例外
+  if (lateZi && hourOfDay >= 23) assertShifted(jdToParts(jd + 1), '八字');
   const dayIdx = dayGanzhiIndex(jdn);
   const dayStem = STEMS[dayIdx % 10];
 
@@ -439,14 +441,18 @@ export function buildBazi(input) {
     dayunWindows.push({ step: i, ganzhi: g.name, fromJd, toJd });
   }
 
-  // 流年（默认从「今年」起排 10 年；传 input.nowYear 可钉死基准年，用于复现历史结论）
+  // 流年（默认从「今年」起排 10 年；传 input.nowYear 可钉死基准年，用于复现历史结论；
+  // input.liunianTo 可把窗口延到指定年，生时校正要拿几十年前的事件逐年对账）
   const thisYear = Number(input.nowYear) || new Date().getFullYear();
+  const liunianTo = Math.max(thisYear, Number(input.liunianTo) || thisYear + 9);
   const liunian = [];
-  for (let y = thisYear; y < thisYear + 10; y++) {
+  for (let y = thisYear; y <= liunianTo; y++) {
     const idx = (((y - 4) % 60) + 60) % 60;
     liunian.push({
       year: y,
-      age: y - solarYear + 1,
+      // 虚岁按公历年算，与 trend.js 的 birthYear 同口径；solarYear 是立春年，
+      // 拿它算会让立春前出生的人整体多一岁，且与趋势页对不上
+      age: y - year + 1,
       ganzhi: ganzhiName(idx).name,
       stemTenGod: tenGod(dayStem, ganzhiName(idx).stem),
     });
@@ -779,21 +785,32 @@ export function buildBazi(input) {
       for (const k of Object.keys(w)) w[k] = Math.round(Math.max(0, w[k]) * 10) / 10;
       out.wuxing = w;
     }
-    // 神煞：时柱那一列清空；只落在时柱上的条目整条去掉（不能留个空壳说「时柱有X」）
+    // 神煞：时柱那一列清空；命中里带时柱的条目要把时柱摘掉再留，
+    // 只有时柱命中的条目整条去掉（不能留个空壳说「时柱有X」，也不能让复合条目继续算时柱）
     if (out.shensha && out.shensha.detail) {
       out.shensha.detail.hour = [];
       if (Array.isArray(out.shensha.groups)) {
-        out.shensha.groups = out.shensha.groups
-          .map((g) => ({ ...g, items: (g.items || []).filter((i) => (i.pillars || []).some((k) => k !== 'hour')) }))
-          .filter((g) => g.items.length);
-        out.shensha.count = out.shensha.groups.reduce((n, g) => n + g.items.length, 0);
+        const kept = [];
+        for (const g of out.shensha.groups) {
+          const items = [];
+          for (const it of g.items || []) {
+            const pillars = (it.pillars || []).filter((k) => k !== 'hour');
+            if (!pillars.length) continue;
+            const via = String(it.via || '').split('、').filter((v) => v && !v.includes('时')).join('、');
+            items.push({ ...it, pillars, via });
+          }
+          if (items.length) kept.push({ ...g, items });
+        }
+        out.shensha.groups = kept;
+        out.shensha.count = kept.reduce((n, g) => n + g.items.reduce((m, i) => m + i.pillars.length, 0), 0);
       }
     }
-    // 旺衰与格局：算法没变，但基准是正午——标出来，别让人以为是定时辰算的
+    // 旺衰与格局：内部仍按正午时柱跑（否则没有可比的基准），但必须说清这是占位值，
+    // 不能写成「时柱不参与任何判定」——那与 strength/frame 实际用了时柱相矛盾
     out.strength.precision = 'three-pillars';
     out.notes = [
-      '时柱暂缺：未提供出生时刻，时柱不参与任何判定',
-      '旺衰、格局、用神按年/月/日三柱估算，补上时柱后可能改变',
+      '时柱暂缺：未提供出生时刻，时柱不对外给出，也不计入神煞与干支关系',
+      '旺衰、格局、用神、调候暂以正午时柱估算，补上出生时刻后可能改变',
     ];
   }
   return out;

package/engine/calendar.js

@@ -110,8 +110,29 @@ export function sunLongitude(jd) {
   return ((theta % 360) + 360) % 360;
 }
 
-/** ΔT（TT - UT，秒）。分段线性近似，误差 < 2s，对分钟级排盘足够 */
+/** ΔT（TT - UT，秒）。1900 年后分段线性（误差约 2s）；1600–1900 用 Meeus 多项式，
+ *  端点 1600 约 120s。以前整段取 1900 的常数，1600 年误差达 123s，与函数注释自相矛盾。 */
 export function deltaTSeconds(year) {
+  if (year < 1900) {
+    const y = year;
+    if (y < 1600) return 120;
+    if (y < 1700) {
+      const t = y - 1600;
+      return 120 - 0.9808 * t - 0.01532 * t * t + (t * t * t) / 7129;
+    }
+    if (y < 1800) {
+      const t = y - 1700;
+      return 8.83 + 0.1603 * t - 0.0059285 * t * t + 0.00013336 * t * t * t - (t ** 4) / 1174000;
+    }
+    if (y < 1860) {
+      const t = y - 1800;
+      return 13.72 - 0.332447 * t + 0.0068612 * t * t + 0.0041116 * t ** 3
+        - 0.00037436 * t ** 4 + 0.0000121272 * t ** 5 - 0.0000001699 * t ** 6 + 0.000000000875 * t ** 7;
+    }
+    const t = y - 1860;
+    return 7.62 + 0.5737 * t - 0.251754 * t * t + 0.01680668 * t ** 3
+      - 0.0004473624 * t ** 4 + t ** 5 / 233174;
+  }
   const knots = [
     [1900, -2.8], [1920, 21.2], [1940, 24.3], [1950, 29.1], [1960, 33.2],
     [1970, 40.2], [1980, 50.5], [1990, 56.9], [2000, 63.8], [2010, 66.1],

package/engine/chenggu.js

@@ -1,9 +1,10 @@
 // 袁天罡称骨：按农历年/月/日/时辰四柱骨重求和，查通行本《称骨歌》原文，附白话释义。
 // 骨重表与歌诀均为通行本口径（各版本有异文，此处照录通行本）；释义是白话自撰，不是原文。
 import { solarToLunar } from './lunar.js';
-import { ganzhiName, toJDN, dayGanzhiIndex } from './calendar.js';
-import { assertCivil } from './validate.js';
+import { ganzhiName, toJDN, fromJDN, dayGanzhiIndex } from './calendar.js';
+import { assertCivil, assertShifted } from './validate.js';
 import { hourToBranch } from './almanac.js';
+import { fail } from './fail.js';
 
 /** 六十甲子年骨重（单位：钱；索引 = (农历年 - 4) mod 60，0 = 甲子）。 */
 export const YEAR_WEIGHT = [
@@ -142,9 +143,22 @@ export function buildChenggu(input) {
   const { year, month, day, hour } = input;
   const minute = input.minute || 0;
   if (!Number.isInteger(hour) || hour < 0 || hour > 23) {
-    throw new Error('称骨必须给时辰：hour 为 0–23 的整数（缺时辰四柱不齐，骨重无法求和）');
+    throw fail('E_INPUT', '称骨必须给时辰：hour 为 0–23 的整数（缺时辰四柱不齐，骨重无法求和）');
   }
-  const lunar = solarToLunar(year, month, day);
+  // 晚子时换日与八字/六壬/奇门同口径：23:00–23:59 按次日取农历日与日柱，
+  // 否则同一子时的前后两个钟点会差一天的日重
+  const lateZi = input.lateZi !== false;
+  let sy = year;
+  let sm = month;
+  let sd = day;
+  if (lateZi && hour >= 23) {
+    const next = assertShifted(fromJDN(toJDN(year, month, day) + 1), '称骨');
+    sy = next.year;
+    sm = next.month;
+    sd = next.day;
+  }
+  const shifted = sy !== year || sm !== month || sd !== day;
+  const lunar = solarToLunar(sy, sm, sd);
   const lunarYear = lunar.lunarYear;
   const lunarMonth = lunar.month;
   const lunarDay = lunar.day;
@@ -161,11 +175,11 @@ export function buildChenggu(input) {
   const total = wYear + wMonth + wDay + wHour;
   const verdict = bandVerdict(total);
   const song = songOf(total);
-  const jdn = toJDN(year, month, day);
+  const jdn = toJDN(sy, sm, sd);
 
   return {
     system: 'chenggu',
-    input: { solar: `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`, hour, minute },
+    input: { solar: `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`, hour, minute, lateZi, lunarDateShifted: shifted },
     lunar: {
       text: `农历${yearGz.name}年${lunarMonthText(lunarMonth, lunar.isLeap)}${lunarDayText(lunarDay)} ${hourBranch}时`,
       year: lunarYear,

package/engine/convert.js

@@ -5,12 +5,13 @@
 //   · 农历 → 公历：按目标农历年的「月首」序列反查（每月 29/30 天，闰月单独一轮），
 //     逐月定位后再加日偏移；不做「节气月」换算，农历就是朔望月口径。
 //
-// 诚实边界：只处理 1900–2100 的本地历法覆盖范围（与 lunar.js 一致）；闰月必须显式给出，
+// 诚实边界：只处理 1600–2400 的本地历法覆盖范围（与 lunar.js、assertCivil 一致）；闰月必须显式给出，
 // 不猜「第一个同名月」；农历日期越界（如小月三十）如实报错，不静默回退。
 import { solarToLunar } from './lunar.js';
 import { fromJDN, toJDN } from './calendar.js';
 import { buildAlmanac } from './almanac.js';
-import { assertCivil, daysInMonth } from './validate.js';
+import { assertCivil, assertObject, daysInMonth } from './validate.js';
+import { fail } from './fail.js';
 
 const WEEK = ['日', '一', '二', '三', '四', '五', '六'];
 const MONTH_TEXT = ['正', '二', '三', '四', '五', '六', '七', '八', '九', '十', '冬', '腊'];
@@ -69,6 +70,7 @@ function lunarMonths(lunarYear) {
  *   lunarYear?:number, lunarMonth?:number, lunarDay?:number, isLeapMonth?:boolean}} input
  */
 export function buildConvert(input) {
+  assertObject(input, '公农历互转的参数', '{ mode?, year, month, day } 或 { mode: "lunar2solar", lunarYear, lunarMonth, lunarDay }');
   const mode = input.mode === 'lunar2solar' ? 'lunar2solar' : 'solar2lunar';
   let solar;
   let lunar;
@@ -77,26 +79,33 @@ export function buildConvert(input) {
     solar = { year: input.year, month: input.month, day: input.day };
     assertCivil(solar, '公农历转换');
     if (solar.day > daysInMonth(solar.year, solar.month)) {
-      throw new Error(`非法日期：${solar.year} 年 ${solar.month} 月没有 ${solar.day} 日`);
+      throw fail('E_INPUT', `非法日期：${solar.year} 年 ${solar.month} 月没有 ${solar.day} 日`);
     }
     lunar = solarToLunar(solar.year, solar.month, solar.day);
   } else {
     const y = Number(input.lunarYear);
     const m = Number(input.lunarMonth);
     const d = Number(input.lunarDay);
-    if (![y, m, d].every(Number.isInteger)) throw new Error('农历转换需要 lunarYear / lunarMonth / lunarDay');
-    if (m < 1 || m > 12) throw new Error('农历月份须在 1–12');
+    if (![y, m, d].every(Number.isInteger)) throw fail('E_INPUT', '农历转换需要 lunarYear / lunarMonth / lunarDay（整数）');
+    if (y < 1600 || y > 2400) throw fail('E_INPUT', `农历年份 ${y} 超出可计算范围（1600–2400）`);
+    if (m < 1 || m > 12) throw fail('E_INPUT', '农历月份须在 1–12');
     const months = lunarMonths(y);
-    if (!months.length) throw new Error(`农历 ${y} 年超出本地历法覆盖范围（1900–2100）`);
+    if (!months.length) throw fail('E_INPUT', `农历 ${y} 年无法定位正月，请核对年份（1600–2400）`);
     const isLeap = input.isLeapMonth === true;
     const hit = months.find((x) => x.month === m && x.isLeap === isLeap);
     if (!hit) {
       const leapMonths = months.filter((x) => x.isLeap).map((x) => `闰${MONTH_TEXT[x.month - 1]}月`);
-      throw new Error(`农历 ${y} 年没有${leapMonths.length ? `该月（该年闰月为 ${leapMonths.join('、')}）` : '闰月'}：${isLeap ? '请确认闰月标记' : '请确认月份'}`);
+      throw fail('E_INPUT', `农历 ${y} 年没有${leapMonths.length ? `该月（该年闰月为 ${leapMonths.join('、')}）` : '闰月'}：${isLeap ? '请确认闰月标记' : '请确认月份'}`);
     }
-    if (d < 1 || d > hit.length) throw new Error(`农历 ${y} 年${isLeap ? '闰' : ''}${MONTH_TEXT[m - 1]}月只有 ${hit.length} 天，没有 ${d} 日`);
+    if (d < 1 || d > hit.length) throw fail('E_INPUT', `农历 ${y} 年${isLeap ? '闰' : ''}${MONTH_TEXT[m - 1]}月只有 ${hit.length} 天，没有 ${d} 日`);
     const p = fromJDN(hit.startJdn + d - 1);
     solar = { year: p.year, month: p.month, day: p.day };
+    // 农历 2400 年末几天会换到公历 2401：这属于「目标日期越界」，不是黄历的错；
+    // 以前一路走到 buildAlmanac 才抛「黄历的 year 超出支持范围」，代码还是 E_INPUT，用户看不懂。
+    if (solar.year < 1600 || solar.year > 2400) {
+      const solarText = `${solar.year}-${String(solar.month).padStart(2, '0')}-${String(solar.day).padStart(2, '0')}`;
+      throw fail('E_RANGE', `农历 ${y} 年${isLeap ? '闰' : ''}${MONTH_TEXT[m - 1]}月${d}日换算得到的公历日期 ${solarText} 超出可计算范围（1600–2400）`);
+    }
     const check = solarToLunar(p.year, p.month, p.day);
     if (check.month !== m || check.day !== d || check.isLeap !== isLeap) {
       note = '反查结果与目标农历日不完全一致，已按本地历法实际月首回推';
@@ -114,7 +123,7 @@ export function buildConvert(input) {
       solarDate: solarText,
       weekday: `星期${WEEK[(jdn + 1) % 7]}`,
       ...(note ? { note } : {}),
-      scope: '公农历互转按本地定朔历（1900–2100）；农历闰月须显式指定，不自动猜同名月',
+      scope: '公农历互转按本地定朔历（1600–2400）；农历闰月须显式指定，不自动猜同名月',
     },
     solar: { year: solar.year, month: solar.month, day: solar.day, text: solarText },
     lunar: {

package/engine/daliuren.js

@@ -1,8 +1,8 @@
 // 大六壬：天地盘、四课、九宗门三传。
 // 算法移植自本地 MIT 授权插件 @dhicoc/dsh-chinese-traditional-wisdom-skill 的
 // daliurenEngine.ts（仅取 classic 流派：贵人顺逆以天盘临方判定）。
-import { toJDN, dayGanzhiIndex, ganzhiName, termWindow, formatJd, xunKongOf } from './calendar.js';
-import { assertCivil } from './validate.js';
+import { toJDN, dayGanzhiIndex, ganzhiName, termWindow, formatJd, jdToParts, xunKongOf } from './calendar.js';
+import { assertCivil, assertShifted } from './validate.js';
 import { SANHE_ELEMENT } from './sanhe.js';
 
 const GAN = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
@@ -95,6 +95,8 @@ export function calcShensha(dayGz) {
 const JIA_ZI_60 = Array.from({ length: 60 }, (_, i) => GAN[i % 10] + ZHI[i % 12]);
 
 const ZHI_CHONG = { 子: '午', 午: '子', 丑: '未', 未: '丑', 寅: '申', 申: '寅', 卯: '酉', 酉: '卯', 辰: '戌', 戌: '辰', 巳: '亥', 亥: '巳' };
+// 十二支相刑：子卯互刑；寅→巳→申→寅；丑→戌→未→丑；辰午酉亥自刑。
+const ZHI_XING = { 子: '卯', 卯: '子', 寅: '巳', 巳: '申', 申: '寅', 丑: '戌', 戌: '未', 未: '丑', 辰: '辰', 午: '午', 酉: '酉', 亥: '亥' };
 const YI_MA = { 寅: '申', 午: '申', 戌: '申', 申: '寅', 子: '寅', 辰: '寅', 巳: '亥', 酉: '亥', 丑: '亥', 亥: '巳', 卯: '巳', 未: '巳' };
 
 const BA_ZHUAN_DAYS = ['壬子', '甲寅', '乙卯', '丁巳', '己未', '庚申', '辛酉', '癸亥'];
@@ -213,14 +215,77 @@ function multipleZeiKe(ke, dayGan, target) {
   return { zhi: ranked[0].k.shang, geJu: '涉害', detail: tied ? '察微' : '见机' };
 }
 
-function noZeiKe(ke, tdp, dayGan) {
+function noZeiKe(ke, tdp, dayGan, dayZhi) {
   const dw = GAN_WUXING[dayGan] ?? '土';
+  // 遥克：先整趟找「克我」的蒿矢，没有再找「我克」的弹射。
+  // 原先逐课先到先得，前面一课是弹射就会把后面的蒿矢挡掉。
   for (const k of ke) {
-    const rel = wuxingRelation(ZHI_WUXING[k.shang] ?? '土', dw);
-    if (rel === '克') return { zhi: k.shang, geJu: '遥克', detail: '蒿矢' };
-    if (rel === '被克') return { zhi: k.shang, geJu: '遥克', detail: '弹射' };
+    if (wuxingRelation(ZHI_WUXING[k.shang] ?? '土', dw) === '克') return { zhi: k.shang, geJu: '遥克', detail: '蒿矢' };
   }
-  return { zhi: tdp.diToTian['酉'], geJu: '昴星', detail: yinYang(dayGan) === '阳' ? '虎视' : '冬蛇掩目' };
+  for (const k of ke) {
+    if (wuxingRelation(ZHI_WUXING[k.shang] ?? '土', dw) === '被克') return { zhi: k.shang, geJu: '遥克', detail: '弹射' };
+  }
+  return { ...maoXing(tdp, dayGan, dayZhi) };
+}
+
+/** 昴星课：阳日虎视取地盘酉上神，阴日冬蛇掩目取天盘酉下神；
+ *  中/末传按阴阳日分别取支上、干上（阴日互换），不再走通用递推。 */
+function maoXing(tdp, dayGan, dayZhi) {
+  const ganShang = tdp.diToTian[GAN_JI_GONG[dayGan]];
+  const zhiShang = tdp.diToTian[dayZhi];
+  const yy = yinYang(dayGan);
+  if (yy === '阳') {
+    return { zhi: tdp.diToTian['酉'], zhong: zhiShang, mo: ganShang, geJu: '昴星', detail: '虎视' };
+  }
+  let tianYouDi = null;
+  for (const d of ZHI) if (tdp.diToTian[d] === '酉') { tianYouDi = d; break; }
+  return { zhi: tianYouDi, zhong: ganShang, mo: zhiShang, geJu: '昴星', detail: '冬蛇掩目' };
+}
+
+/** 八专课：干支同位且无克，阳日从干上神顺数三神、阴日从支上神逆数三神；
+ *  中/末同昴星（阳日支上→干上，阴日干上→支上）。 */
+function baZhuan(tdp, dayGan, dayZhi) {
+  const ganShang = tdp.diToTian[GAN_JI_GONG[dayGan]];
+  const zhiShang = tdp.diToTian[dayZhi];
+  const yy = yinYang(dayGan);
+  const start = yy === '阳' ? ganShang : zhiShang;
+  const i = ZHI.indexOf(start);
+  const zhi = ZHI[(i + (yy === '阳' ? 2 : -2) + 12) % 12];
+  return { zhi, zhong: yy === '阳' ? zhiShang : ganShang, mo: yy === '阳' ? ganShang : zhiShang };
+}
+
+/** 伏吟三传：有克依贼克法取初传，无克阳日取干上、阴日取支上；
+ *  中传取初传之刑，末传取中传之刑。初传自刑时中传换到与初传不同的那一节上神，仍自刑则取冲。 */
+function fuYinSanChuan(ke, tdp, dayGan, dayZhi) {
+  const xz = ke.filter((k) => k.relation === '下贼上');
+  const sk = ke.filter((k) => k.relation === '上克下');
+  const yy = yinYang(dayGan);
+  let chu;
+  let detail;
+  if (xz.length || sk.length) {
+    const r = xz.length
+      ? (xz.length === 1 && !sk.length ? { zhi: xz[0].shang } : multipleZeiKe(ke, dayGan, '下贼上'))
+      : (sk.length === 1 ? { zhi: sk[0].shang } : multipleZeiKe(ke, dayGan, '上克下'));
+    chu = r.zhi;
+    detail = '有克';
+  } else {
+    chu = yy === '阳' ? GAN_JI_GONG[dayGan] : dayZhi;
+    detail = yy === '阳' ? '自任' : '杜传';
+  }
+  const ganShang = tdp.diToTian[GAN_JI_GONG[dayGan]];
+  const zhiShang = tdp.diToTian[dayZhi];
+  let zhong;
+  if (ZHI_XING[chu] === chu) {
+    // 兜底要换到「另一个」上神：有克伏吟的初传常常就是第 1 课上神，
+    // 固定取支上（阳日）时它可能正等于初传，中传==初传的盘以前有 34%。
+    const alt = yy === '阳' ? [zhiShang, ganShang] : [ganShang, zhiShang];
+    zhong = alt.find((x) => x && x !== chu) || chu;
+  } else {
+    zhong = ZHI_XING[chu];
+  }
+  let mo = ZHI_XING[zhong];
+  if (mo === zhong) mo = ZHI_CHONG[zhong];
+  return { chu, zhong, mo, detail };
 }
 
 function fanYin(ke, dayGan, dayZhi, stats, isFB) {
@@ -254,6 +319,8 @@ export function buildDaliuren(input) {
 
   // 月将：取出生时刻之前最近的节气（中气换将）
   const jd = jdnBase - 0.5 + (hour * 60 + minute) / 1440;
+  // 晚子时换日后若跨出 1600–2400：与八字/称骨/梅花/小六壬同一把尺，直接拒绝
+  if (lateZi && hour >= 23) assertShifted(jdToParts(jd + 1), '大六壬');
   const terms = termWindow(year).filter((t) => t.jd <= jd);
   const last = terms.length ? terms[terms.length - 1] : null;
   const jieqiName = last ? last.name : '冬至';
@@ -269,17 +336,22 @@ export function buildDaliuren(input) {
   const isFanYinBaZhuan = isSamePos && stats.xiaZeiShang === 4;
 
   let chu;
+  let zhong;
+  let mo;
   let geJu;
   let detail;
   if (isFanYin || isFanYinBaZhuan) {
     const r = fanYin(ke, dayGan, dayZhi, stats, isFanYinBaZhuan);
     chu = r.zhi; geJu = '返吟'; detail = r.detail;
+    zhong = ZHI_CHONG[chu];
+    mo = ZHI_CHONG[zhong];
   } else if (isFuYin) {
-    chu = yinYang(dayGan) === '阳' ? GAN_JI_GONG[dayGan] : dayZhi;
-    geJu = '伏吟'; detail = yinYang(dayGan) === '阳' ? '自任' : '杜传';
+    const r = fuYinSanChuan(ke, tdp, dayGan, dayZhi);
+    chu = r.chu; zhong = r.zhong; mo = r.mo;
+    geJu = '伏吟'; detail = r.detail;
   } else if (isBaZhuan && stats.shangKeXia === 0 && stats.xiaZeiShang === 0) {
-    const i = ZHI.indexOf(dayZhi);
-    chu = ZHI[(i + (yinYang(dayGan) === '阳' ? 2 : -2) + 12) % 12];
+    const r = baZhuan(tdp, dayGan, dayZhi);
+    chu = r.zhi; zhong = r.zhong; mo = r.mo;
     geJu = '八专'; detail = '帷簿';
   } else if (stats.xiaZeiShang === 1 && stats.shangKeXia === 0) {
     chu = ke.find((k) => k.relation === '下贼上').shang; geJu = '贼克'; detail = '重审';
@@ -292,18 +364,15 @@ export function buildDaliuren(input) {
     const r = multipleZeiKe(ke, dayGan, '上克下');
     chu = r.zhi; geJu = r.geJu; detail = r.detail;
   } else if (stats.shangKeXia === 0 && stats.xiaZeiShang === 0) {
-    const r = noZeiKe(ke, tdp, dayGan);
+    const r = noZeiKe(ke, tdp, dayGan, dayZhi);
     chu = r.zhi; geJu = r.geJu; detail = r.detail;
+    if (r.zhong !== undefined) { zhong = r.zhong; mo = r.mo; }
   } else {
     chu = ke[0].shang; geJu = '贼克'; detail = '元首';
   }
 
-  let zhong;
-  let mo;
-  if (isFanYin) {
-    zhong = ZHI_CHONG[chu];
-    mo = ZHI_CHONG[zhong];
-  } else {
+  // 其余格局（贼克 / 遥克）中末传仍是「初传上神 → 中传上神」的通用递推
+  if (zhong === undefined) {
     zhong = tdp.diToTian[chu];
     mo = tdp.diToTian[zhong];
   }

package/engine/datetime.js

@@ -0,0 +1,73 @@
+// 共享的日期时间解析：各体系与工具层必须用同一把尺，避免某条分支绕过校验。
+import { fail } from './fail.js';
+import { MIN_YEAR, MAX_YEAR } from './validate.js';
+
+export function daysInMonth(year, month) {
+  if (month === 2) {
+    const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    return leap ? 29 : 28;
+  }
+  return [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+}
+
+/** 严格解析公历日期 YYYY-MM-DD。
+ *  格式不对 / 日子不存在（2 月 30 日）→ 返回 null，由调用方给自己的文案；
+ *  格式对但年份超出 1600–2400 → 抛 E_RANGE。
+ *
+ *  年份闸门不能省：这里以前只查月/日，于是 0000-01-01、2500-06-01、9999-12-31 都能静默出盘——
+ *  农历、节气、干支表都不覆盖这些年份，算出来的仍是「看着正常」的盘面，没人知道自己拿到了外推值。
+ *  走 parseDateTime 的体系同一道闸早已生效，只收日期的体系（择日、小六壬）不该绕过。
+ *  @param {string} raw
+ *  @param {string} [who] 报错时说是谁的日期。择日必须传（startDate / 候选日）：
+ *    否则越界会一路走到 buildAlmanac，由它抛出「黄历 的 year 超出支持范围」，锅甩给了一个用户没填的东西。
+ */
+export function parseYmd(raw, who = '') {
+  const s = String(raw == null ? '' : raw).trim();
+  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(s);
+  if (!m) return null;
+  const year = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) return null;
+  if (year < MIN_YEAR || year > MAX_YEAR) {
+    const p = who ? `${who} ` : '';
+    throw fail('E_RANGE', `${p}「${m[0]}」的年份超出可计算范围（${MIN_YEAR}–${MAX_YEAR}，收到 ${year} 年）；`
+      + '农历与节气表不覆盖之外的年份');
+  }
+  return { year, month, day };
+}
+
+/** 解析 'YYYY-MM-DDTHH:mm' / 'YYYY-MM-DD HH:mm' / 'YYYY-MM-DD'
+ *  可以带秒（用户常直接粘 ISO 串），但引擎的民用时间口径到分钟：秒只校验、不参与换算。 */
+export function parseDateTime(text) {
+  if (typeof text !== 'string' || !text.trim()) {
+    throw fail('E_INPUT', '缺少 datetime（公历日期时间），例如 1990-05-12T14:30');
+  }
+  const m = text.trim().match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:[T\s](\d{1,2}):(\d{1,2})(?::(\d{1,2}))?)?$/);
+  if (!m) throw fail('E_INPUT', `无法解析 datetime：「${text}」，请用 1990-05-12T14:30 这种格式`);
+  // 秒位以前只捕获不校验：\d{1,2} 放过 0–99，于是「T03:04:99」被静默折成 03:04。
+  // 与 1990-02-30 同一类问题——非法输入悄悄变成一个合法时刻，盘面照样排出，没人知道。
+  if (m[6] !== undefined && Number(m[6]) > 59) throw fail('E_INPUT', `秒超出范围：${m[6]}`);
+  const out = {
+    year: Number(m[1]), month: Number(m[2]), day: Number(m[3]),
+    hour: Number(m[4] ?? 0), minute: Number(m[5] ?? 0),
+  };
+  if (out.month < 1 || out.month > 12) throw fail('E_INPUT', `月份超出范围：${out.month}`);
+  // 只校验 1..31 会让 1990-02-30、2026-04-31 这类日期静默滚到下个月，整盘错位且无人察觉
+  const maxDay = daysInMonth(out.year, out.month);
+  if (out.day < 1 || out.day > maxDay) {
+    throw fail('E_INPUT', `日期不存在：${out.year}-${out.month}-${out.day}（${out.year} 年 ${out.month} 月只有 ${maxDay} 天）`);
+  }
+  if (out.hour > 23 || out.minute > 59) throw fail('E_INPUT', `时间超出范围：${out.hour}:${out.minute}`);
+  // ΔT（地球自转改正）表只覆盖 1900–2100，超出后按端点值外推，精度不可保证
+  if (out.year < MIN_YEAR || out.year > MAX_YEAR) {
+    throw fail('E_RANGE', `年份 ${out.year} 超出可计算范围（${MIN_YEAR}–${MAX_YEAR}）`);
+  }
+  if (out.year < 1900 || out.year > 2100) {
+    out.precision = {
+      level: 'approx',
+      note: `ΔT 模型仅覆盖 1900–2100，${out.year} 年按端点值外推，节气与朔望时刻可能有分钟级偏差，月柱在交节前后需复核`,
+    };
+  }
+  return out;
+}

package/engine/diff.js

@@ -322,7 +322,7 @@ export const CALIBER_SWITCHES = {
       off: '不排', single: '单星', double: '正副双星', zhanyan: '占验派',
     }),
     ziweiSchoolSwitch('kuiyueSchool', '魁钺：qs1 / qs2', '魁钺', 'qs1', 'qs2', {
-      qs1: 'qs1', qs2: 'qs2', 'zhong-yiming': '中一鸣', network: '网络',
+      qs1: 'qs1', qs2: 'qs2', 'zhong-yiming': '中一鸣',
     }),
     ziweiSchoolSwitch('tianshiTianshang', '天伤天使：常规 / 中州互换', '天伤天使', 'normal', 'zhongzhou', {
       normal: '常规', zhongzhou: '中州（阴男阳女互换）',

package/engine/dst.js

@@ -86,10 +86,3 @@ export function applyDst(t) {
           : ''),
   };
 }
-
-/** 把夏令时说明折进 notes 数组（不改动其它口径）。 */
-export function withDstNote(notes, dst) {
-  const out = Array.isArray(notes) ? notes.slice() : [];
-  if (dst && dst.applied && dst.note) out.push(dst.note);
-  return out;
-}

package/engine/fengshui.js

@@ -141,7 +141,9 @@ function zibaiChart(center, forward = true) {
   const palaces = [];
   for (const palace of PALACE_ORDER) {
     const k = PALACE_ORDER.indexOf(palace) + 1;
-    const num = norm9(k - 5 + center);
+    // 顺飞沿 1→2→…→9 递增，逆飞沿同一条轨迹递减；之前忽略 forward，
+    // 阴遁盘标着「逆飞」却按顺飞排，日/时两盘会整盘错位
+    const num = norm9((forward ? 1 : -1) * (k - 5) + center);
     const s = NINE_STARS[num];
     palaces.push({ palace, direction: palace === '中' ? '中宫' : PALACE_DIRECTION[palace], num, name: s.name, star: s.star, element: s.element, lucky: s.lucky });
   }
@@ -461,8 +463,22 @@ const DISCLAIMER = '八宅与飞星为传统通行口径的本地计算，属民
  *  xuankong：要坐山或向山；运由 period（1–9）或 fortuneYear 定，缺省按九运并注明。
  */
 export function buildFengshui(input) {
-  if (input.action === 'advise') return buildAdvise(input);
-  if (input.action === 'xuankong') return buildXuankong(input);
+  if (!input || typeof input !== 'object') {
+    throw fail('E_INPUT', '风水参数不能为空：命卦要生日与性别，布局要坐向（sitting / facing）');
+  }
+  // fortuneYear 以前只在 Number.isInteger 时才用，2026.5 会被静默当成「没给」而不排飞星。
+  // 数字串可以整形，非整数直接报错，别让「给了却没用」从结果里看不出来。
+  if (input.fortuneYear !== undefined && input.fortuneYear !== null && input.fortuneYear !== '') {
+    const fy = Number(input.fortuneYear);
+    if (!Number.isInteger(fy)) throw fail('E_INPUT', `fortuneYear 必须是整数年份，收到「${input.fortuneYear}」`);
+    input = { ...input, fortuneYear: fy };
+  }
+  const action = input.action;
+  if (action !== undefined && action !== null && action !== 'natal' && action !== 'advise' && action !== 'xuankong') {
+    throw fail('E_INPUT', `风水 action 只能是 natal / advise / xuankong，收到「${String(action).slice(0, 24)}」`);
+  }
+  if (action === 'advise') return buildAdvise(input);
+  if (action === 'xuankong') return buildXuankong(input);
   const gender = input.gender;
   if (gender !== 'male' && gender !== 'female') {
     throw fail('E_INPUT', '风水命卦需要性别：男女命卦算法不同，不可缺省');

package/engine/fingerprint.js

@@ -22,7 +22,8 @@ function sortValue(value) {
   if (t === 'boolean') return value;
   if (Array.isArray(value)) return value.map(sortValue);
   if (t === 'object') {
-    const out = {};
+    // 普通对象上给 __proto__ 赋值走的是 setter，会把键吞掉；用无原型对象承接。
+    const out = Object.create(null);
     for (const key of Object.keys(value).sort()) {
       const item = value[key];
       if (item === undefined || typeof item === 'function' || typeof item === 'symbol') continue;

package/engine/followup.js

@@ -78,6 +78,16 @@ function baziAnswer(r, q) {
         evidence: (dim.evidence || []).slice(0, 4), confidence: dim.confidence || '中',
       };
     }
+    // 方向识别到了、但这一盘没带解析层：不能说「没识别到」，只能交盘面结构并说明缺什么
+    const groups = (r.frame && r.frame.godStats && r.frame.godStats.groups) || {};
+    if (Object.keys(groups).length) {
+      const facts = ['比劫', '食伤', '财', '官杀', '印'].map((k) => `${k} ${Number(groups[k] || 0)}`);
+      return {
+        ok: true, year: null, topic,
+        answer: `「${topic.label}」这条线，这一盘只带了盘面结构：${facts.join('、')}。具体吉凶与建议需要解析层（排盘时加 withInterpret），追问这里不自行推演。`,
+        evidence: facts.slice(0, 3), confidence: '弱',
+      };
+    }
   }
   return {
     ok: false, year: null, topic,
@@ -147,11 +157,31 @@ function genericAnswer(r, q) {
     return { ok: true, year: null, topic, answer: hit.text, evidence: [`引用分节：${hit.label}`], confidence: '中' };
   }
   const first = sections[0];
+  if (first) {
+    return {
+      ok: false, year: null, topic,
+      answer: `这一盘的追问需要落到具体方面（事业 / 财富 / 感情 / 健康 / 学业 / 出行）。先看「${first.label}」这一节，或把问题说得更具体一点。`,
+      evidence: [], confidence: '弱',
+    };
+  }
+  // 没有解析层时，用盘面摘要直接答——这 12 个体系本来就不产 interpret.sections，
+  // 一律回「没有可追问的分节」等于让追问功能对它们失效
+  const summary = String((r && r.summary) || '').trim();
+  if (summary) {
+    const lines = summary.split('\n').map((s) => s.trim()).filter(Boolean);
+    const hits = topic ? lines.filter((l) => topic.words.some((w) => l.includes(w))) : [];
+    return {
+      ok: true, year: null, topic,
+      answer: hits.length
+        ? `${topic.label}相关的盘面字段：${hits.slice(0, 3).join('；')}。这一盘没带解析层，只列盘面事实，不在这里补吉凶结论。`
+        : `这一盘没有解析层，只能按盘面字段回答；可问的方向：${TOPICS.map((t) => t.label).join(' / ')}。下面任取摘要是盘面原文，未作推演。`,
+      evidence: (hits.length ? hits : lines).slice(0, 4),
+      confidence: '弱',
+    };
+  }
   return {
     ok: false, year: null, topic,
-    answer: first
-      ? `这一盘的追问需要落到具体方面（事业 / 财富 / 感情 / 健康 / 学业 / 出行）。先看「${first.label}」这一节，或把问题说得更具体一点。`
-      : '这一盘暂时没有可追问的分节；先看完整解析，再问具体方面。',
+    answer: '这一盘暂时没有可追问的分节，也没有摘要字段；先重新排一次盘，再问具体方面。',
     evidence: [], confidence: '弱',
   };
 }