dsh-metaphysics 0.21.0 → 0.34.0

package/engine/name.js

@@ -116,6 +116,115 @@ export const CHAR_LIB = [
   ['月', '木', '明月', 'f'], ['言', '木', '言语，信', 'n'],
   ['和', '水', '和顺', 'n'], ['安', '土', '安宁', 'n'],
   ['宁', '火', '安宁', 'f'],
+  // ── 扩充：木 ──
+  ['林', '木', '林木成片，茂盛有荫', 'n'], ['森', '木', '众木成林，森然', 'n'],
+  ['枝', '木', '枝条，生发', 'n'], ['果', '木', '果实，有成', 'n'],
+  ['禾', '木', '禾苗，五谷初生', 'n'], ['秀', '木', '禾吐穗，秀美出众', 'n'],
+  ['穗', '木', '谷穗，丰实', 'n'], ['稼', '木', '庄稼，耕作有成', 'm'],
+  ['颖', '木', '禾颖，聪颖', 'n'], ['苗', '木', '苗裔，初生有生机', 'n'],
+  ['菁', '木', '菁华，草木茂盛', 'f'], ['菡', '木', '荷花含苞', 'f'],
+  ['蕴', '木', '蕴积，含而不露', 'f'], ['蕾', '木', '花蕾，待放', 'f'],
+  ['薇', '木', '蔷薇，细而韧', 'f'], ['薏', '木', '薏苡，清润', 'f'],
+  ['菀', '木', '草木茂盛', 'f'], ['荷', '木', '荷花，出淤泥', 'f'],
+  ['莲', '木', '莲花，清直', 'f'], ['菱', '木', '菱角，水生', 'f'],
+  ['苇', '木', '芦苇，柔韧', 'n'], ['荻', '木', '荻草，秋声', 'n'],
+  ['筠', '木', '竹皮，竹之青', 'n'], ['笛', '木', '竹笛，清音', 'n'],
+  ['杉', '木', '杉木，挺拔', 'n'], ['柠', '木', '柠檬，清新', 'f'],
+  ['桢', '木', '桢干，栋梁材', 'm'], ['樾', '木', '树荫，庇下', 'm'],
+  ['柘', '木', '柘木，坚韧', 'n'], ['权', '木', '权衡，执中', 'm'],
+  ['材', '木', '木材，成材', 'm'], ['杭', '木', '苏杭，舟行', 'n'],
+  ['枚', '木', '衔枚，静而进', 'n'], ['梧', '木', '梧桐，栖凤', 'n'],
+  ['竹', '木', '竹，有节而虚心', 'n'], ['简', '木', '简朴，简静', 'n'],
+  ['策', '木', '策谋，鞭策', 'm'], ['筹', '木', '筹算，谋划', 'm'],
+  ['芬', '木', '芬芳', 'f'], ['芳', '木', '芳华', 'f'],
+  ['花', '木', '花，明媚', 'f'], ['菊', '木', '菊花，晚节', 'f'],
+  ['兰', '木', '兰花，幽香', 'f'], ['芝', '木', '芝兰，瑞草', 'f'],
+  ['芹', '木', '芹献，谦诚', 'f'], ['荃', '木', '荃草，香草', 'f'],
+  ['萃', '木', '荟萃，聚合', 'n'], ['蓁', '木', '蓁蓁，草木盛', 'n'],
+  ['荞', '木', '荞麦，实而不华', 'f'], ['莞', '木', '莞尔，浅笑', 'f'],
+  ['萦', '木', '萦绕，绵长', 'f'], ['蔚', '木', '蔚然，文采盛', 'n'],
+  ['芃', '木', '芃芃，草木茂', 'n'], ['芩', '木', '黄芩，草本', 'f'],
+  ['苡', '木', '薏苡，清润', 'f'], ['莱', '木', '莱草，野而秀', 'n'],
+  ['萌', '木', '萌芽，生机', 'n'], ['葆', '木', '永葆，守而不失', 'n'],
+  ['萧', '木', '萧然，清疏', 'n'], ['樟', '木', '樟木，香而久', 'n'],
+  ['樱', '木', '樱花，明丽', 'f'], ['栎', '木', '栎树，坚实', 'n'],
+  ['棹', '木', '舟棹，行水', 'n'], ['楸', '木', '楸树，高直', 'n'],
+  ['槐', '木', '槐树，三公之位', 'n'], ['橙', '木', '橙，明暖', 'n'],
+  ['檀', '木', '檀香，沉静', 'n'],
+  // ── 扩充：火 ──
+  ['丰', '火', '丰盛、丰盈（繁体豐从豆，归火）', 'n'], ['日', '火', '太阳，光明', 'm'],
+  ['阳', '火', '阳光，向阳而生', 'm'], ['光', '火', '光明', 'n'],
+  ['亮', '火', '明亮，爽朗', 'm'], ['明', '火', '光明、明理', 'n'],
+  ['晶', '火', '晶莹，三光', 'f'], ['晴', '火', '晴朗，天开', 'f'],
+  ['夏', '火', '夏天，盛大', 'n'], ['智', '火', '智慧，明达', 'm'],
+  ['卓', '火', '卓越，卓立', 'm'], ['乐', '火', '和乐', 'n'],
+  ['恺', '火', '恺悌，和乐', 'm'], ['恬', '火', '恬静', 'f'],
+  ['甜', '火', '甜美', 'f'], ['亭', '火', '亭亭，端立', 'f'],
+  ['俊', '火', '俊朗，才俊', 'm'], ['丙', '火', '天干丙，阳火', 'm'],
+  ['丁', '火', '天干丁，阴火', 'n'], ['鼎', '火', '鼎立，厚重', 'm'],
+  ['陶', '火', '陶然，自得', 'n'], ['熹', '火', '熹微，晨光', 'n'],
+  ['炀', '火', '火旺，炽盛', 'm'], ['烜', '火', '烜赫，显明', 'm'],
+  ['暻', '火', '日光', 'n'], ['晖', '火', '日晖，光彩', 'n'],
+  ['晔', '火', '光晔，明盛', 'n'], ['旻', '火', '秋天，天高', 'm'],
+  ['晏', '火', '晏然，安和', 'n'], ['晓', '火', '拂晓，天将明', 'f'],
+  ['暄', '火', '温暖，日暖', 'f'], ['昆', '火', '昆山，同也', 'm'],
+  ['伶', '火', '伶俐，聪敏', 'f'],
+  // ── 扩充：土 ──
+  ['山', '土', '山，稳重', 'm'], ['岸', '土', '岸然，独立', 'm'],
+  ['岑', '土', '小山，高而静', 'n'], ['巍', '土', '巍峨，高大', 'm'],
+  ['嵩', '土', '嵩山，高峻', 'm'], ['岭', '土', '山岭，绵延', 'n'],
+  ['奥', '土', '深奥，蕴藉', 'm'], ['宜', '土', '宜然，合度', 'n'],
+  ['容', '土', '包容，容仪', 'n'], ['意', '土', '心意，诚意', 'f'],
+  ['依', '土', '依倚，亲近', 'f'], ['悠', '土', '悠然，从容', 'f'],
+  ['维', '土', '维系，纲维', 'n'], ['纬', '土', '经纬，有条', 'n'],
+  ['永', '土', '永恒，久长', 'n'], ['远', '土', '高远', 'm'],
+  ['辰', '土', '星辰、辰时', 'm'], ['壁', '土', '壁立，端正', 'm'],
+  ['田', '土', '田野，耕获', 'm'], ['由', '土', '由来，自得', 'n'],
+  ['画', '土', '图画，文采', 'f'], ['延', '土', '延展，绵长', 'm'],
+  ['建', '土', '建立，树也', 'm'], ['音', '土', '音声，和鸣', 'f'],
+  ['韵', '土', '韵致，余响', 'f'], ['玮', '土', '美玉，珍奇', 'm'],
+  ['雍', '土', '雍容，和穆', 'm'], ['懿', '土', '懿德，美善', 'f'],
+  // ── 扩充：金 ──
+  ['金', '金', '金，坚而贵', 'm'], ['秋', '金', '秋收、成熟（秋属金，肃而收）', 'n'],
+  ['书', '金', '书卷，文墨', 'n'], ['舒', '金', '舒展，从容', 'n'],
+  ['善', '金', '善良，善成', 'n'], ['信', '金', '诚信，符信', 'm'],
+  ['修', '金', '修远，修身', 'm'], ['素', '金', '素雅，本色', 'f'],
+  ['静', '金', '安静，沉静', 'f'], ['心', '金', '心志，中藏', 'f'],
+  ['新', '金', '新意，日新', 'n'], ['正', '金', '正直，端正', 'm'],
+  ['世', '金', '世代，绵延', 'm'], ['少', '金', '少年，少壮', 'm'],
+  ['西', '金', '西方，金位', 'n'], ['白', '金', '洁白，素净', 'n'],
+  ['辛', '金', '天干辛，阴金', 'n'], ['成', '金', '成器，成事', 'm'],
+  ['利', '金', '利落，锋利', 'm'], ['剑', '金', '剑，刚锐', 'm'],
+  ['刚', '金', '刚强，不屈', 'm'], ['则', '金', '法则，有度', 'm'],
+  ['初', '金', '初心，开端', 'n'], ['硕', '金', '硕大，学殖', 'm'],
+  ['尚', '金', '崇尚，尚贤', 'n'], ['臣', '金', '臣，佐事', 'm'],
+  ['川', '金', '川流，通达', 'n'], ['舟', '金', '舟行，济渡', 'n'],
+  ['州', '金', '州，聚落', 'n'], ['祖', '金', '祖德，源远', 'm'],
+  ['祥', '金', '吉祥，祥瑞', 'n'], ['禄', '金', '福禄，俸给', 'm'],
+  ['禧', '金', '禧庆，福', 'n'], ['珍', '金', '珍宝，珍重', 'f'],
+  ['宣', '金', '宣明，布达', 'n'], ['序', '金', '秩序，庠序', 'n'],
+  ['谦', '金', '谦逊，有终', 'm'], ['赞', '金', '赞美，佐成', 'm'],
+  ['超', '金', '超越，越过', 'm'], ['锴', '金', '精铁，坚刚', 'm'],
+  // ── 扩充：水 ──
+  ['水', '水', '水，润下', 'n'], ['冰', '水', '冰清，澄澈', 'f'],
+  ['洁', '水', '洁净，洁身', 'f'], ['浩', '水', '浩大，广远', 'm'],
+  ['瀚', '水', '浩瀚，无涯', 'm'], ['渊', '水', '渊深，有本', 'm'],
+  ['澜', '水', '波澜，壮阔', 'n'], ['潮', '水', '潮涌，有信', 'n'],
+  ['溪', '水', '溪流，清浅', 'f'], ['湘', '水', '湘水，清深', 'f'],
+  ['渝', '水', '渝水，守而不变', 'n'], ['深', '水', '深厚，深藏', 'm'],
+  ['湛', '水', '湛然，清深', 'm'], ['汇', '水', '汇聚，会归', 'n'],
+  ['洲', '水', '洲渚，水中地', 'n'], ['湾', '水', '水湾，曲处', 'f'],
+  ['云', '水', '云行，舒卷', 'n'], ['风', '水', '风雅，流动', 'n'],
+  ['北', '水', '北方，水位', 'n'], ['冬', '水', '冬藏，静敛', 'f'],
+  ['玄', '水', '玄远，幽深', 'n'], ['子', '水', '子，初生', 'm'],
+  ['平', '水', '平和，坦易', 'n'], ['方', '水', '方正，有隅', 'n'],
+  ['帆', '水', '风帆，顺行', 'n'], ['航', '水', '航行，济远', 'm'],
+  ['敏', '水', '敏思，捷悟', 'f'], ['慧', '水', '慧心，明彻', 'f'],
+  ['惠', '水', '惠泽，施与', 'f'], ['霈', '水', '霈雨，丰沛', 'm'],
+  ['灏', '水', '灏气，广大', 'm'], ['湄', '水', '水湄，岸边', 'f'],
+  ['滨', '水', '水滨，近水', 'n'], ['洛', '水', '洛水，清流', 'n'],
+  ['津', '水', '津渡，要处', 'n'], ['泊', '水', '淡泊，自守', 'm'],
+  ['沧', '水', '沧海，苍茫', 'm'], ['浦', '水', '浦，水滨', 'n'],
 ];
 
 const EL_INDEX = new Map();
@@ -123,6 +232,24 @@ for (const c of CHAR_LIB) {
   if (!EL_INDEX.has(c[0])) EL_INDEX.set(c[0], { c: c[0], el: c[1], meaning: c[2], g: c[3], order: EL_INDEX.size });
 }
 
+/** 用户可自带某字的五行（字库未收时用，按你信的那派算；传了就算「用户指定」）。 */
+function userElement(input, ch) {
+  const map = input && input.charElements;
+  if (!map || typeof map !== 'object') return null;
+  const v = map[ch];
+  return ALL.includes(v) ? v : null;
+}
+
+/** 喜用五行里挑几个可替换的常用字（同性别倾向优先），给未收录字一个落点。 */
+function suggestFor(element, genderPref, exclude, count = 3) {
+  const pool = CHAR_LIB.filter((c) => c[1] === element && !exclude.has(c[0]));
+  pool.sort((a, b) => {
+    const fit = (x) => (x[3] === genderPref || x[3] === 'n' ? 1 : 0);
+    return fit(b) - fit(a);
+  });
+  return pool.slice(0, count).map((c) => ({ char: c[0], element: c[1], meaning: c[2] }));
+}
+
 const KIND_LABEL = { m: '男', f: '女', n: '中' };
 
 /** 喜用五行（简化判定：旺衰 + 生克泄耗）。 */
@@ -178,23 +305,44 @@ export function assessName(input) {
     baziNote = { dayMaster: r.dayMaster, solarNote: r.solarTime ? r.solarTime.note : '' };
   }
 
+  const genderPref = input.gender === 'female' ? 'f' : 'm';
+  const taken = new Set([surname, ...given]);
+  const favPool = favorable.list.length ? favorable.list : ALL.slice();
   const chars = [...given].map((ch) => {
     const info = charInfo(ch);
-    const inFav = info ? favorable.list.includes(info.el) : null;
+    const given = userElement(input, ch);
+    if (info) {
+      return {
+        char: ch, element: info.el, meaning: info.meaning,
+        genderHint: KIND_LABEL[info.g], favorable: hasBirth ? favorable.list.includes(info.el) : null,
+        source: 'lib', note: null,
+      };
+    }
+    if (given) {
+      return {
+        char: ch, element: given, meaning: '字库未收录；五行按你指定的「' + given + '」计',
+        genderHint: null, favorable: hasBirth ? favorable.list.includes(given) : null,
+        source: 'user', note: '此字五行由调用方指定，不是字库推断',
+      };
+    }
     return {
-      char: ch,
-      element: info ? info.el : '未收录',
-      meaning: info ? info.meaning : '字库未收录，未推断五行',
-      genderHint: info ? KIND_LABEL[info.g] : null,
-      favorable: inFav,
+      char: ch, element: '未收录', meaning: '字库未收录，未推断五行（不猜）',
+      genderHint: null, favorable: null, source: 'none',
+      note: hasBirth ? '若想贴合命局，可换用下面的同喜用字' : '字库未收录：给出生辰后可以看同喜用的替换字',
+      suggest: hasBirth
+        ? favPool.flatMap((el) => suggestFor(el, genderPref, taken, 2))
+        : [],
     };
   });
-  const known = chars.filter((c) => c.element !== '未收录').length;
+  const known = chars.filter((c) => c.source === 'lib').length;
+  const unknown = chars.filter((c) => c.source === 'none').length;
   const favCount = chars.filter((c) => c.favorable === true).length;
+  const judged = chars.length - unknown;
   let verdict;
   if (!hasBirth) verdict = '只做了字义与五行归类；给出生年月日才能判断用字是否合喜用。';
-  else if (favCount === chars.length && chars.length > 0) verdict = `用字都落在喜用（${favorable.list.join('、')}）上，与命局方向一致。`;
-  else if (favCount > 0) verdict = `部分用字合喜用（${favCount}/${chars.length}），其余可再斟酌；喜用为 ${favorable.list.join('、')}。`;
+  else if (unknown === chars.length) verdict = `两字都不在字库里，没法判断合不合喜用（喜用为 ${favorable.list.join('、')}）。下面给了可替换的常用字，或把你自己认定的五行传进来。`;
+  else if (favCount === judged && judged > 0) verdict = `用字都落在喜用（${favorable.list.join('、')}）上，与命局方向一致。`;
+  else if (favCount > 0) verdict = `部分用字合喜用（${favCount}/${judged}），其余可再斟酌；喜用为 ${favorable.list.join('、')}。`;
   else verdict = `用字未落在喜用（${favorable.list.join('、')}）上；不必然是坏名，但若想贴合命局可换字再看。`;
 
   return {
@@ -212,10 +360,10 @@ export function assessName(input) {
       },
     } : {}),
     chars,
-    stats: { chars: chars.length, known, favorableCount: favCount },
+    stats: { chars: chars.length, known, unknown, favorableCount: favCount, libSize: CHAR_LIB.length },
     verdict,
     notes: [
-      '字之五行按通行字义/偏旁归类，自建字库有限：未收录的字不猜五行，如实标注。',
+      `字之五行按通行字义/偏旁归类，自建字库共 ${CHAR_LIB.length} 字（常用名用字为主）；未收录的字不猜五行，如实标注，「用户指定」是你传入的归类。`,
       '不做五格剖象（需康熙字典笔画），也不做音韵格律判断——谐音、拗口请自己读三遍或用方言读一遍。',
       '起名只做用字参考，不替父母做决定。',
     ],
@@ -267,19 +415,41 @@ export function generateNames(input) {
         elements: [a[1], b[1]],
         allFavorable: fav.list.includes(a[1]) && fav.list.includes(b[1]),
         genderScore: gScore,
-        order: i * 1000 + j,
+        order: (i * 7 + j * 13) % 9973, // 打散字库顺序，避免候选清一色都是前几个字
       });
     }
   }
-  scored.sort((x, y) => (y.allFavorable - x.allFavorable) || (y.genderScore - x.genderScore) || (x.order - y.order));
+  const mixed = (c) => (c.elements[0] !== c.elements[1] ? 1 : 0); // 两字异行，比同气堆叠更有层次
+  scored.sort((x, y) => (y.allFavorable - x.allFavorable) || (mixed(y) - mixed(x)) || (y.genderScore - x.genderScore) || (x.order - y.order));
+  // 去重 + 用字轮换：先收「两个字都没出现过」的候选，再放宽——避免 20 个候选里 13 个都用同一个「梓」
   const out = [];
-  const used = new Set();
-  for (const cand of scored) {
-    if (out.length >= limit) break;
+  const usedNames = new Set();
+  const usedChars = new Set([surname]);
+  const usedPairs = new Set();
+  const take = (cand, strict, freshPair) => {
     const key = [...cand.name].sort().join('');
-    if (used.has(key)) continue;
-    used.add(key);
+    if (usedNames.has(key)) return false;
+    if (strict && cand.chars.some((x) => usedChars.has(x.char))) return false;
+    const pair = cand.elements.join('');
+    if (freshPair && usedPairs.has(pair)) return false;
+    usedNames.add(key);
+    usedPairs.add(pair);
+    cand.chars.forEach((x) => usedChars.add(x.char));
     out.push({ rank: out.length + 1, name: surname + cand.name, given: cand.name, chars: cand.chars });
+    return true;
+  };
+  // 三轮：①新字 + 新五行组合 ②新字 ③放开——先保证候选之间不撞字、不撞组合
+  for (const cand of scored) {
+    if (out.length >= limit) break;
+    take(cand, true, true);
+  }
+  for (const cand of scored) {
+    if (out.length >= limit) break;
+    take(cand, true, false);
+  }
+  for (const cand of scored) {
+    if (out.length >= limit) break;
+    take(cand, false, false);
   }
   return {
     system: 'name',
@@ -289,7 +459,7 @@ export function generateNames(input) {
     bazi: { dayMaster: r.dayMaster, strength, favorable: fav.list, basis: fav.basis },
     candidates: out,
     notes: [
-      `字库共 ${CHAR_LIB.length} 字，只在喜用五行（${fav.list.join('、')}）里选字；未覆盖的生僻好字可手工评估。`,
+      `字库共 ${CHAR_LIB.length} 字，只在喜用五行（${fav.list.join('、')}）里选字；未覆盖的生僻好字可用 charElements 指定五行后评估。`,
       '候选按合喜用与性别倾向确定性排序，不是「吉名」判定；音韵与方言谐音请自行读念检查。',
       '不做五格剖象（需康熙字典笔画）。',
     ],

package/engine/qimen-interpret.js

@@ -33,6 +33,19 @@ const YONG_SHEN = {
   travel: { label: '出行', primary: ['九天'], secondary: ['驿马'], note: '出行以九天为主，兼看驿马' },
 };
 
+/** 天盘干与宫的落宫关系统计：干克宫 3 宫（辛）… */
+function stemRelationLine(r) {
+  const groups = new Map();
+  for (const p of r.palaces || []) {
+    const rel = p.stemRelation || null;
+    if (!rel || rel.type === 'unknown' || !p.tianPan) continue;
+    if (!groups.has(rel.type)) groups.set(rel.type, []);
+    groups.get(rel.type).push(`${p.palace}宫${p.tianPan}`);
+  }
+  const order = ['干克宫', '宫克干', '干生宫', '宫生干', '比和'];
+  return order.filter((k) => groups.has(k)).map((k) => `${k} ${groups.get(k).join('、')}`).join('；') || '—';
+}
+
 const REL_TEXT = {
   生: '主体力量流向环境或趋势',
   克: '主体对环境或趋势构成压力、有改造意图',
@@ -128,15 +141,37 @@ export function interpretQimen(r, opts = {}) {
     else if (rel.type === '宫制门') controlled.push(`${p.palace}宫（宫${rel.palace}克${p.gate}${rel.gate}）`);
   }
   const kongCells = r.palaces.filter((p) => p.kong).map((p) => `${p.palace}宫`);
+  const jiXing = (r.conditions && r.conditions.jiXing) || [];
+  const ruMu = (r.conditions && r.conditions.ruMu) || [];
   sections.push({
     key: 'conditions',
     label: '宫位条件',
     text: `门迫（同宫内门克宫）：${forced.length ? forced.join('、') : '本盘无'}；`
       + `宫制门（宫克门，属「制」不为迫）：${controlled.length ? controlled.join('、') : '无'}。`
+      + `击刑（天盘六仪落刑宫）：${jiXing.length ? jiXing.map((x) => `${x.palace}宫${x.stem}（${x.basis}）`).join('、') : '本盘无'}；`
+      + `入墓（天盘三奇落墓宫）：${ruMu.length ? ruMu.map((x) => `${x.palace}宫${x.stem}（${x.basis}）`).join('、') : '本盘无'}。`
       + (kongCells.length ? `空亡：${kongCells.join('、')}——落空之宫事多不实。` : '无落空之宫。')
-      + `门迫只作宫位条件，不自动等同于用神受制。`,
+      + `这三项都只作宫位条件：门迫、击刑、入墓不自动等同于用神受制，取象时看它们落在哪个符号上。`,
   });
 
+  // ⑤b 月令旺衰：门、星、天盘干按月支五行判五态（与门迫这类宫位关系分开）
+  const mo = r.month || null;
+  const st = r.states || null;
+  if (mo && st) {
+    const order = ['旺', '相', '休', '囚', '死'];
+    const line = (g) => order.filter((k) => g && Array.isArray(g[k]) && g[k].length)
+      .map((k) => `${k} ${g[k].join('、')}`).join('；') || '—';
+    sections.push({
+      key: 'states',
+      label: '月令旺衰',
+      text: `月令 ${mo.branch}（${mo.element}）：`
+        + `门 ${line(st.gate)}。星 ${line(st.star)}。天盘干 ${line(st.stem)}。`
+        + `旺为同月令之气，相为月令所生，休为生月令，囚为克月令，死为月令所克。`
+        + `干宫的落宫关系另算：${stemRelationLine(r)}。`
+        + `这一层只说明门、星、干自身力量强弱，不合吉凶：门旺而宫克门，仍受宫制；星旺而落宫死地，也难全其用。`,
+    });
+  }
+
   // ⑥ 条件式倾向
   if (unresolved.length) {
     sections.push({
@@ -151,7 +186,7 @@ export function interpretQimen(r, opts = {}) {
       key: 'tendency',
       label: '最终倾向',
       text: `在当前输入、规则集与所问之事下：若以「${primary.key}」为用神，用神宫对值符宫为「${rel}」，整体${tone}；`
-        + `若${ys.label}实际取另一个候选，或时间范围不同，解读边界随之变化。未决项：月令旺衰未纳入本规则集。`,
+        + `若${ys.label}实际取另一个候选，或时间范围不同，解读边界随之变化。未决项：天盘干与地盘的十干克应（100 组）未纳入本规则集，干宫生克只作落宫条件。`,
     });
   }
 

package/engine/qimen.js

@@ -1,4 +1,4 @@
-// 时家奇门（转盘，拆补法定局）。
+// 时家奇门（转盘，拆补法定局）。
 // 算法移植自 MIT 许可的 qimendunjia-standalone@0.1.0（作者：见其 LICENSE），
 // 保留其定局/排盘口径（符头定三元、值符值使推演、天盘随值符旋转、中五宫寄坤二），
 // 只把历法层换成本插件自己的 calendar/lunar 模块——节气、干支、农历都走同一套已验证的源码。
@@ -179,6 +179,108 @@ export function gatePalaceRelation(gate, palace) {
   if (SHENG[pe] === ge) return { type: '宫生门', gate: ge, palace: pe, note: `${pe}生${ge}` };
   return { type: '比和', gate: ge, palace: pe, note: `${ge}与${pe}比和` };
 }
+
+// ── 天盘干：五行、与所落宫的生克 ─────────────────────────────
+// 天盘干（三奇六仪，甲隐于六仪，盘面上不出现甲）与所落宫五行的生克，
+// 是与门宫关系并列的一层「干—宫」关系，只作落宫条件，不折吉凶。
+const STEM_ELEMENT = {
+  甲: '木', 乙: '木', 丙: '火', 丁: '火', 戊: '土',
+  己: '土', 庚: '金', 辛: '金', 壬: '水', 癸: '水',
+};
+
+/** 天盘干与其所落宫的关系：干克宫 / 宫克干 / 干生宫 / 宫生干 / 比和 */
+export function stemPalaceRelation(stem, palace) {
+  const se = STEM_ELEMENT[stem];
+  const pe = PALACE_ELEMENT[palace];
+  if (!se || !pe) return { type: 'unknown', stem: se || null, palace: pe || null, note: '缺少干或宫的五行，无法判断' };
+  if (KE[se] === pe) return { type: '干克宫', stem: se, palace: pe, note: `${se}克${pe}，天盘干克宫` };
+  if (KE[pe] === se) return { type: '宫克干', stem: se, palace: pe, note: `${pe}克${se}，宫克天盘干` };
+  if (SHENG[se] === pe) return { type: '干生宫', stem: se, palace: pe, note: `${se}生${pe}，干泄气于宫` };
+  if (SHENG[pe] === se) return { type: '宫生干', stem: se, palace: pe, note: `${pe}生${se}，宫来生干` };
+  return { type: '比和', stem: se, palace: pe, note: `${se}与${pe}比和` };
+}
+
+// ── 六仪击刑 / 三奇入墓 ─────────────────────────────────────
+// 两者都是「天盘干落到某个宫就成立」的硬条件，与门迫一样只作宫位条件，不下吉凶。
+// 六仪击刑按地支相刑推：子刑卯、戌刑未、申刑寅、午自刑、辰自刑、寅刑巳；
+// 三奇入墓按五行墓库推：乙木墓未（未在坤二宫）、丙丁火墓戌（戌在乾六宫）。
+const JI_XING = {
+  戊: { palace: '3', zhi: '卯', basis: '甲子戊，子刑卯' },
+  己: { palace: '2', zhi: '未', basis: '甲戌己，戌刑未' },
+  庚: { palace: '8', zhi: '寅', basis: '甲申庚，申刑寅' },
+  辛: { palace: '9', zhi: '午', basis: '甲午辛，午自刑' },
+  壬: { palace: '4', zhi: '辰', basis: '甲辰壬，辰自刑' },
+  癸: { palace: '4', zhi: '巳', basis: '甲寅癸，寅刑巳' },
+};
+const RU_MU = {
+  乙: { palace: '2', zhi: '未', basis: '乙木墓于未，未在坤二宫' },
+  丙: { palace: '6', zhi: '戌', basis: '丙火墓于戌，戌在乾六宫' },
+  丁: { palace: '6', zhi: '戌', basis: '丁火墓于戌，戌在乾六宫' },
+};
+
+/** 天盘六仪落刑宫 → [{palace, stem, zhi, basis}] */
+export function jiXingOf(palaces) {
+  const out = [];
+  for (const p of palaces || []) {
+    const hit = JI_XING[p.tianPan];
+    if (hit && hit.palace === String(p.palace)) out.push({ palace: p.palace, stem: p.tianPan, zhi: hit.zhi, basis: hit.basis });
+  }
+  return out;
+}
+
+/** 天盘三奇入墓 → [{palace, stem, zhi, basis}] */
+export function ruMuOf(palaces) {
+  const out = [];
+  for (const p of palaces || []) {
+    const hit = RU_MU[p.tianPan];
+    if (hit && hit.palace === String(p.palace)) out.push({ palace: p.palace, stem: p.tianPan, zhi: hit.zhi, basis: hit.basis });
+  }
+  return out;
+}
+
+/** 供测试与文档引用：两张表的只读视图 */
+export const QIMEN_CONDITION_TABLES = Object.freeze({
+  jiXing: Object.freeze(Object.fromEntries(Object.entries(JI_XING).map(([k, v]) => [k, { ...v }]))),
+  ruMu: Object.freeze(Object.fromEntries(Object.entries(RU_MU).map(([k, v]) => [k, { ...v }]))),
+});
+
+// ── 月令旺衰：门与星对月令的五态 ─────────────────────────────
+// 五行在月令的旺相休囚死：与月令同气为旺，月令生之为相，生月令为休，
+// 克月令为囚，被月令克为死。只作「力量强弱」的事实，不折成吉凶。
+const BRANCH_ELEMENT = {
+  子: '水', 丑: '土', 寅: '木', 卯: '木', 辰: '土', 巳: '火',
+  午: '火', 未: '土', 申: '金', 酉: '金', 戌: '土', 亥: '水',
+};
+/** 旺相休囚死：element 在 monthElement 月令中的状态 */
+export function monthState(element, monthElement) {
+  if (!element || !monthElement) return 'unknown';
+  if (element === monthElement) return '旺';
+  if (SHENG[monthElement] === element) return '相';
+  if (SHENG[element] === monthElement) return '休';
+  if (KE[element] === monthElement) return '囚';
+  if (KE[monthElement] === element) return '死';
+  return 'unknown';
+}
+/** 月支 → 月令五行 */
+export function monthElementOf(branch) {
+  return BRANCH_ELEMENT[branch] || null;
+}
+/** 把一组 {name, element} 按状态归堆 → {旺:[…],相:[…],休:[…],囚:[…],死:[…]} */
+export function groupByState(items, monthElement) {
+  const out = { 旺: [], 相: [], 休: [], 囚: [], 死: [] };
+  for (const it of items || []) {
+    const st = monthState(it.element, monthElement);
+    if (out[st]) out[st].push(it.name);
+  }
+  return out;
+}
+/** 供测试与文档引用：门/星五行与月支五行的只读视图 */
+export const QIMEN_STATE_TABLES = Object.freeze({
+  gate: Object.freeze({ ...GATE_ELEMENT }),
+  star: Object.freeze({ ...STAR_ELEMENT }),
+  branch: Object.freeze({ ...BRANCH_ELEMENT }),
+  stem: Object.freeze({ ...STEM_ELEMENT }),
+});
 function getDiPan(type, num) {
   const result = {};
   let gong = num;
@@ -360,6 +462,10 @@ export function buildQimen(input) {
   const maZhi = maMap[hourGz[1]] || '';
   const maGong = ZHI_TO_GONG[maZhi] || '';
 
+  // 月令：门与星的力量强弱都按月支五行判，与局数、宫位分开记
+  const monthBranch = (snapshot.monthGanZhi || '')[1] || '';
+  const monthElement = BRANCH_ELEMENT[monthBranch] || null;
+
   // 中五宫单列（天禽寄坤二，门神为空），与参照实现的九宫结构对齐
   const centerPalace = {
     palace: '5',
@@ -372,7 +478,11 @@ export function buildQimen(input) {
     palaceElement: PALACE_ELEMENT['5'],
     gateElement: null,
     starElement: STAR_ELEMENT['天禽'],
+    stemElement: STEM_ELEMENT[tianPan['5']] || null,
     gateRelation: { type: 'unknown', note: '中宫无门，不参与门宫关系' },
+    stemRelation: stemPalaceRelation(tianPan['5'], '5'),
+    starState: monthState(STAR_ELEMENT['天禽'], monthElement),
+    stemState: monthState(STEM_ELEMENT[tianPan['5']], monthElement),
     kong: false,
     ma: false,
     center: true,
@@ -389,7 +499,12 @@ export function buildQimen(input) {
     palaceElement: PALACE_ELEMENT[gong],
     gateElement: GATE_ELEMENT[bm.baMen[gong]] || null,
     starElement: STAR_ELEMENT[jx.jiuXing[gong]] || null,
+    stemElement: STEM_ELEMENT[tianPan[gong]] || null,
     gateRelation: gatePalaceRelation(bm.baMen[gong], gong),
+    stemRelation: stemPalaceRelation(tianPan[gong], gong),
+    gateState: monthState(GATE_ELEMENT[bm.baMen[gong]], monthElement),
+    starState: monthState(STAR_ELEMENT[jx.jiuXing[gong]], monthElement),
+    stemState: monthState(STEM_ELEMENT[tianPan[gong]], monthElement),
     kong: kongGong.includes(gong),
     ma: maGong === gong,
   }));
@@ -418,6 +533,18 @@ export function buildQimen(input) {
     zhiShi: { gate: bm.zhiShiMen, gong: bm.zhiShiGong },
     kongWang: kongZhi,
     ma: { zhi: maZhi, gong: maGong },
+    // 宫位硬条件（天盘干定宫）：六仪击刑、三奇入墓。只列成立项，不排序、不打分
+    conditions: {
+      jiXing: jiXingOf(palaces),
+      ruMu: ruMuOf(palaces),
+    },
+    // 月令与门/星旺衰：按月支五行判旺相休囚死，只报强弱、不折吉凶
+    month: { branch: monthBranch, element: monthElement },
+    states: {
+      gate: groupByState(palaces.filter((p) => p.gate).map((p) => ({ name: p.gate, element: p.gateElement })), monthElement),
+      star: groupByState(palaces.map((p) => ({ name: p.star, element: p.starElement })), monthElement),
+      stem: groupByState(palaces.filter((p) => p.tianPan).map((p) => ({ name: p.tianPan, element: p.stemElement })), monthElement),
+    },
     palaces,
     centerPalace,
     rules: [

package/engine/ziwei.js

@@ -524,6 +524,8 @@ export function buildZiwei(input) {
 
   chart.patterns = detectPatterns(chart);
   chart.daxianList = daxianList(chart);
+  chart.fly = flyStars(chart);
+  chart.flyChains = flyChains(chart, { from: '命宫' });
   enrichLiunian(chart);
   // 流月/流日/流时：默认按本机当前时刻，可用 asOf 指定（如 "2026-10-22T16:00"）
   chart.flow = flowOf(chart, input.asOf);
@@ -716,6 +718,83 @@ export function daxianList(chart) {
     .sort((a, b) => a.ages[0] - b.ages[0]);
 }
 
+// ── 四化飞星：宫干四化飞向哪一宫，以及「串连」────────────────────
+// 生年四化看「这颗星先天带着什么」，飞星四化看「这一宫自己会去找谁」：
+// 宫干定出四个化星，星曜落在哪一宫，就是这一宫的禄/权/科/忌飞向哪里。
+// 串连（忌转忌、科转科…）是同一支化一路跟下去：命宫化忌入 A 宫，A 宫的宫干再化忌入 B 宫……
+// 走到回到已访问过的宫就成环（传统讲的「忌出」「自化」都在这一步显现）。
+
+export const FLY_TYPES = ['禄', '权', '科', '忌'];
+
+// 某天干下某一化的星曜；表里没有就返回 null（不会凭印象补）
+export function flyStarOf(stem, type) {
+  const map = MUTAGEN[stem];
+  if (!map) return null;
+  for (const [star, t] of Object.entries(map)) if (t === type) return star;
+  return null;
+}
+
+// 12 宫各自的四化落点（一次算全，供面板与解读共用）
+export function flyStars(chart) {
+  const palaces = chart.palaces || [];
+  return palaces.map((p) => ({
+    palace: p.palace,
+    branch: p.branch,
+    stem: p.stem,
+    flies: FLY_TYPES.map((type) => {
+      const star = flyStarOf(p.stem, type);
+      const b = star ? starBranchOf(chart, star) : -1;
+      const target = b >= 0 ? palaces.find((x) => x.branch === BRANCHES[b]) : null;
+      return {
+        type,
+        star,
+        to: target ? target.palace : null,
+        toBranch: target ? target.branch : null,
+        // 落回本宫即自化：这一宫自己化出去又回到自己
+        self: !!(target && target.palace === p.palace),
+      };
+    }),
+  }));
+}
+
+// 从某一宫出发，跟着同一支化逐跳；ended 说明为什么停：
+// cycle=回到走过的宫（成环）、no-star=该干这一化无星、off-chart=星未上盘、max=走满上限
+export function flyChain(chart, { from = '命宫', type = '忌', maxSteps = 12 } = {}) {
+  const palaces = chart.palaces || [];
+  const start = palaces.find((p) => p.palace === from) || palaces[0];
+  if (!start) return null;
+  const steps = [];
+  const seen = new Set([start.palace]);
+  let cur = start;
+  let ended = 'max';
+  for (let i = 0; i < Math.max(1, maxSteps); i++) {
+    const star = flyStarOf(cur.stem, type);
+    if (!star) { ended = 'no-star'; break; }
+    const b = starBranchOf(chart, star);
+    if (b < 0) { ended = 'off-chart'; break; }
+    const to = palaces.find((x) => x.branch === BRANCHES[b]);
+    steps.push({ from: cur.palace, fromBranch: cur.branch, fromStem: cur.stem, star, type, to: to.palace, toBranch: to.branch });
+    if (seen.has(to.palace)) { ended = 'cycle'; break; }
+    seen.add(to.palace);
+    cur = to;
+  }
+  return {
+    from: start.palace,
+    type,
+    steps,
+    path: [start.palace, ...steps.map((s) => s.to)],
+    ended,
+    closed: ended === 'cycle',
+  };
+}
+
+// 某一宫的四支化各串一条（默认命宫）
+export function flyChains(chart, { from = '命宫', maxSteps = 12 } = {}) {
+  const out = {};
+  for (const type of FLY_TYPES) out[type] = flyChain(chart, { from, type, maxSteps });
+  return out;
+}
+
 // ── 流年四化落宫 ────────────────────────────────────────────
 
 export function enrichLiunian(chart) {