@pai-forge/riichi-mahjong 0.2.0 → 0.3.0

package/dist/features/score/types.d.ts

@@ -0,0 +1,78 @@
+import type { Fu, HaiKindId, Kazehai } from "../../types";
+import type { HouraContext } from "../yaku/types";
+/**
+ * 点数計算用コンテキスト (ScoreContext)
+ *
+ * HouraContext を拡張し、点数計算に必要な追加情報を持つ。
+ *
+ * HouraContext は役判定に特化しており、isOya は役の成立・翻数に影響しない。
+ * isOya は支払い計算（親ロン/子ロン、親ツモ/子ツモの倍率差）にのみ必要なため、
+ * 点数計算用のコンテキストとして分離している。
+ */
+export interface ScoreContext extends HouraContext {
+    /** 和了者が親かどうか */
+    readonly isOya: boolean;
+}
+export interface ScoreCalculationConfig {
+    /** 和了牌 */
+    agariHai: HaiKindId;
+    /** ツモ和了かどうか (必須) */
+    isTsumo: boolean;
+    /** 自風 (必須) */
+    jikaze: Kazehai;
+    /** 場風 (必須) */
+    bakaze: Kazehai;
+    /** ドラ表示牌 (必須、なければ空配列) */
+    doraMarkers: readonly HaiKindId[];
+    /** 裏ドラ表示牌 (任意) */
+    uraDoraMarkers?: readonly HaiKindId[];
+}
+/** ロン和了時の支払い */
+export interface Ron {
+    type: "ron";
+    /** 振り込んだプレイヤーが支払う点数 */
+    amount: number;
+}
+/** 子のツモ和了時の支払い */
+export interface KoTsumo {
+    type: "koTsumo";
+    /** [子の支払い, 親の支払い] */
+    readonly amount: readonly [number, number];
+}
+/** 親のツモ和了時の支払い */
+export interface OyaTsumo {
+    type: "oyaTsumo";
+    /** 子全員が支払う点数（オール） */
+    amount: number;
+}
+/** 支払い情報 */
+export type Payment = Ron | KoTsumo | OyaTsumo;
+/**
+ * 点数レベル (ScoreLevel)
+ *
+ * 翻数と基本点から決まる点数の区分。
+ * 満貫以上では符に関係なく固定の基本点が適用される。
+ */
+export declare const ScoreLevel: {
+    /** 満貫未満（通常計算） */
+    readonly Normal: "Normal";
+    /** 満貫（5翻、または基本点2000以上） */
+    readonly Mangan: "Mangan";
+    /** 跳満（6-7翻） */
+    readonly Haneman: "Haneman";
+    /** 倍満（8-10翻） */
+    readonly Baiman: "Baiman";
+    /** 三倍満（11-12翻） */
+    readonly Sanbaiman: "Sanbaiman";
+    /** 役満（13翻以上） */
+    readonly Yakuman: "Yakuman";
+    /** ダブル役満（26翻以上、または役満複合） */
+    readonly DoubleYakuman: "DoubleYakuman";
+};
+export type ScoreLevel = (typeof ScoreLevel)[keyof typeof ScoreLevel];
+export interface ScoreResult {
+    han: number;
+    fu: Fu;
+    scoreLevel: ScoreLevel;
+    payment: Payment;
+}

package/dist/features/score/types.js

@@ -0,0 +1,22 @@
+/**
+ * 点数レベル (ScoreLevel)
+ *
+ * 翻数と基本点から決まる点数の区分。
+ * 満貫以上では符に関係なく固定の基本点が適用される。
+ */
+export const ScoreLevel = {
+    /** 満貫未満（通常計算） */
+    Normal: "Normal",
+    /** 満貫（5翻、または基本点2000以上） */
+    Mangan: "Mangan",
+    /** 跳満（6-7翻） */
+    Haneman: "Haneman",
+    /** 倍満（8-10翻） */
+    Baiman: "Baiman",
+    /** 三倍満（11-12翻） */
+    Sanbaiman: "Sanbaiman",
+    /** 役満（13翻以上） */
+    Yakuman: "Yakuman",
+    /** ダブル役満（26翻以上、または役満複合） */
+    DoubleYakuman: "DoubleYakuman",
+};

package/dist/features/shanten/index.d.ts

@@ -0,0 +1,16 @@
+import type { Tehai13 } from "../../types";
+import { calculateChiitoitsuShanten } from "./logic/chiitoitsu";
+import { calculateKokushiShanten } from "./logic/kokushi";
+import { calculateMentsuTeShanten } from "./logic/mentsu-te";
+export { calculateChiitoitsuShanten, calculateKokushiShanten, calculateMentsuTeShanten, };
+/**
+ * シャンテン数を計算します。
+ * 面子手、七対子、国士無双のシャンテン数のうち最小値を返します。
+ *
+ * NOTE: 入力は必ず牌種ID (`HaiKindId`) である必要があります。
+ * 物理牌ID (`HaiId`) を持っている場合は、事前に `haiIdToKindId` で変換してください。
+ *
+ * @param tehai 手牌
+ * @returns シャンテン数
+ */
+export declare function calculateShanten(tehai: Tehai13, useChiitoitsu?: boolean, useKokushi?: boolean): number;

package/dist/features/shanten/index.js

@@ -0,0 +1,25 @@
+import { validateTehai13 } from "../../core/tehai";
+import { calculateChiitoitsuShanten } from "./logic/chiitoitsu";
+import { calculateKokushiShanten } from "./logic/kokushi";
+import { calculateMentsuTeShanten } from "./logic/mentsu-te";
+export { calculateChiitoitsuShanten, calculateKokushiShanten, calculateMentsuTeShanten, };
+/**
+ * シャンテン数を計算します。
+ * 面子手、七対子、国士無双のシャンテン数のうち最小値を返します。
+ *
+ * NOTE: 入力は必ず牌種ID (`HaiKindId`) である必要があります。
+ * 物理牌ID (`HaiId`) を持っている場合は、事前に `haiIdToKindId` で変換してください。
+ *
+ * @param tehai 手牌
+ * @returns シャンテン数
+ */
+export function calculateShanten(tehai, useChiitoitsu = true, useKokushi = true) {
+    // Facadeパターン: 公開APIのエントリーポイントで入力を保証する
+    validateTehai13(tehai);
+    const chiitoitsuShanten = useChiitoitsu
+        ? calculateChiitoitsuShanten(tehai)
+        : Infinity;
+    const kokushiShanten = useKokushi ? calculateKokushiShanten(tehai) : Infinity;
+    const mentsuShanten = calculateMentsuTeShanten(tehai);
+    return Math.min(chiitoitsuShanten, kokushiShanten, mentsuShanten);
+}

package/dist/features/shanten/logic/chiitoitsu.d.ts

@@ -0,0 +1,8 @@
+import type { Tehai13 } from "../../../types";
+/**
+ * 七対子のシャンテン数を計算する
+ *
+ * @param tehai 手牌 (13枚)
+ * @returns シャンテン数 (0: 聴牌, -1: 和了 - 理論上)
+ */
+export declare function calculateChiitoitsuShanten(tehai: Tehai13): number;

package/dist/features/shanten/logic/chiitoitsu.js

@@ -0,0 +1,36 @@
+import { countHaiKind, validateTehai13 } from "../../../core/tehai";
+/**
+ * 七対子のシャンテン数を計算する
+ *
+ * @param tehai 手牌 (13枚)
+ * @returns シャンテン数 (0: 聴牌, -1: 和了 - 理論上)
+ */
+export function calculateChiitoitsuShanten(tehai) {
+    // 防御的プログラミング (Defensive Programming):
+    // 公開API（calculateShanten）側でもバリデーションが行われる想定だが（Facadeパターン）、
+    // 内部整合性を保つため、ここでも独立してバリデーションを実施する。
+    validateTehai13(tehai);
+    // シャンテン数を計算する前にバリデーションを実行する
+    // 七対子は門前のみ
+    if (tehai.exposed.length > 0) {
+        return Infinity;
+    }
+    // HaiId/HaiKindId の正規化は廃止。呼び出し元で HaiKindId を保証する。
+    const haiCounts = countHaiKind(tehai.closed);
+    let pairs = 0;
+    let kinds = 0;
+    for (const count of haiCounts) {
+        if (count > 0) {
+            kinds++;
+        }
+        if (count >= 2) {
+            pairs++;
+        }
+    }
+    let shanten = 6 - pairs;
+    // 種類不足ペナルティ
+    if (kinds < 7) {
+        shanten += 7 - kinds;
+    }
+    return shanten;
+}

package/dist/features/shanten/logic/kokushi.d.ts

@@ -0,0 +1,16 @@
+import type { Tehai13 } from "../../../types";
+/**
+ * 国士無双のシャンテン数を計算します。
+ *
+ * ルール:
+ * - 13種類の么九牌（1,9,字牌）を各1枚ずつ揃える。
+ * - そのうちのどれか1種類が対子（2枚）になっている必要がある。
+ * - 門前限定。
+ *
+ * 計算式:
+ * シャンテン数 = 13 - (么九牌の種類数) - (么九牌の対子があるか ? 1 : 0)
+ *
+ * @param tehai 手牌
+ * @returns シャンテン数 (0: 聴牌, -1: 和了(理論上))。副露している場合は Infinity。
+ */
+export declare function calculateKokushiShanten(tehai: Tehai13): number;

package/dist/features/shanten/logic/kokushi.js

@@ -0,0 +1,48 @@
+import { isYaochu } from "../../../core/hai";
+import { countHaiKind, validateTehai13 } from "../../../core/tehai";
+import { asHaiKindId } from "../../../utils/assertions";
+/**
+ * 国士無双のシャンテン数を計算します。
+ *
+ * ルール:
+ * - 13種類の么九牌（1,9,字牌）を各1枚ずつ揃える。
+ * - そのうちのどれか1種類が対子（2枚）になっている必要がある。
+ * - 門前限定。
+ *
+ * 計算式:
+ * シャンテン数 = 13 - (么九牌の種類数) - (么九牌の対子があるか ? 1 : 0)
+ *
+ * @param tehai 手牌
+ * @returns シャンテン数 (0: 聴牌, -1: 和了(理論上))。副露している場合は Infinity。
+ */
+export function calculateKokushiShanten(tehai) {
+    // 防御的プログラミング (Defensive Programming):
+    // 公開API（calculateShanten）側でもバリデーションが行われる想定だが（Facadeパターン）、
+    // 内部整合性を保つため、ここでも独立してバリデーションを実施する。
+    validateTehai13(tehai);
+    // 国士無双は門前のみ
+    if (tehai.exposed.length > 0) {
+        return Infinity;
+    }
+    const dist = countHaiKind(tehai.closed);
+    // 么九牌の種類数をカウント
+    // 同時に、么九牌の対子が存在するかもチェック
+    let uniqueYaochuCount = 0;
+    let hasYaochuPair = false;
+    for (let i = 0; i < dist.length; i++) {
+        const kind = asHaiKindId(i);
+        if (!isYaochu(kind)) {
+            continue;
+        }
+        const count = dist[i];
+        if (count !== undefined && count > 0) {
+            uniqueYaochuCount++;
+            if (count >= 2) {
+                hasYaochuPair = true;
+            }
+        }
+    }
+    const pairBonus = hasYaochuPair ? 1 : 0;
+    // シャンテン数 = 13 - (種類の数) - (対子ボーナス)
+    return 13 - uniqueYaochuCount - pairBonus;
+}

package/dist/features/shanten/logic/mentsu-te.d.ts

@@ -0,0 +1,8 @@
+import type { Tehai } from "../../../types";
+/**
+ * 面子手（4面子1雀頭）のシャンテン数を計算する
+ *
+ * @param tehai 手牌 (13枚 or 14枚)
+ * @returns シャンテン数
+ */
+export declare function calculateMentsuTeShanten(tehai: Tehai): number;

package/dist/features/shanten/logic/mentsu-te.js

@@ -0,0 +1,129 @@
+import { countHaiKind, validateTehai } from "../../../core/tehai";
+/**
+ * 面子手（4面子1雀頭）のシャンテン数を計算する
+ *
+ * @param tehai 手牌 (13枚 or 14枚)
+ * @returns シャンテン数
+ */
+export function calculateMentsuTeShanten(tehai) {
+    // 防御的プログラミング
+    validateTehai(tehai);
+    const counts = countHaiKind(tehai.closed);
+    // Mutation is required for the algorithm, so we convert to a mutable number array
+    const mutableCounts = Array.from(counts);
+    const exposedCount = tehai.exposed.length;
+    // 基本シャンテン数 (8 - 2 * 面子数)
+    let minShanten = 8 - 2 * exposedCount;
+    // 1. 雀頭がある場合
+    for (let i = 0; i < 34; i++) {
+        if ((mutableCounts[i] ?? 0) >= 2) {
+            mutableCounts[i] = (mutableCounts[i] ?? 0) - 2;
+            const { m, t } = searchMentsu(mutableCounts);
+            const currentMentsu = exposedCount + m;
+            const effectiveTaatsu = Math.min(4 - currentMentsu, t);
+            const shanten = 8 - 2 * currentMentsu - effectiveTaatsu - 1;
+            minShanten = Math.min(minShanten, shanten);
+            mutableCounts[i] = (mutableCounts[i] ?? 0) + 2;
+        }
+    }
+    // 2. 雀頭がない場合
+    {
+        const { m, t } = searchMentsu(mutableCounts);
+        const currentMentsu = exposedCount + m;
+        const effectiveTaatsu = Math.min(4 - currentMentsu, t);
+        const shanten = 8 - 2 * currentMentsu - effectiveTaatsu;
+        minShanten = Math.min(minShanten, shanten);
+    }
+    return minShanten;
+}
+/**
+ * 面子と塔子の最大数を探索する
+ */
+function searchMentsu(counts) {
+    let maxScore = -1;
+    let bestResult = { m: 0, t: 0 };
+    // copies needed because we mutate counts
+    const w = [...counts];
+    const search = (index, m) => {
+        // 34種類すべて見終わったら塔子を数える
+        if (index >= 34) {
+            const t = countTaatsu(w);
+            const score = 2 * m + t;
+            if (score > maxScore) {
+                maxScore = score;
+                bestResult = { m, t };
+            }
+            return;
+        }
+        // 牌がない場合は次に進む
+        if ((w[index] ?? 0) === 0) {
+            search(index + 1, m);
+            return;
+        }
+        // A. 刻子 (3枚) の場合
+        if ((w[index] ?? 0) >= 3) {
+            w[index] = (w[index] ?? 0) - 3;
+            search(index, m + 1);
+            w[index] = (w[index] ?? 0) + 3;
+        }
+        // B. 順子 (3枚) の場合
+        if (index < 27) {
+            const mod = index % 9;
+            if (mod < 7) {
+                if ((w[index] ?? 0) > 0 &&
+                    (w[index + 1] ?? 0) > 0 &&
+                    (w[index + 2] ?? 0) > 0) {
+                    w[index] = (w[index] ?? 0) - 1;
+                    w[index + 1] = (w[index + 1] ?? 0) - 1;
+                    w[index + 2] = (w[index + 2] ?? 0) - 1;
+                    search(index, m + 1);
+                    w[index] = (w[index] ?? 0) + 1;
+                    w[index + 1] = (w[index + 1] ?? 0) + 1;
+                    w[index + 2] = (w[index + 2] ?? 0) + 1;
+                }
+            }
+        }
+        // C. 面子として使わない場合
+        search(index + 1, m);
+    };
+    search(0, 0);
+    return bestResult;
+}
+/**
+ * 残った牌から塔子（対子、両面、嵌張、辺張）の数を数える
+ */
+function countTaatsu(counts) {
+    let taatsu = 0;
+    // countsのコピーを作成
+    const w = [...counts];
+    for (let i = 0; i < 34; i++) {
+        if ((w[i] ?? 0) === 0)
+            continue;
+        // 順子系の塔子 (1枚 + 1枚)
+        if (i < 27) {
+            const mod = i % 9;
+            // 辺張・両面 (i, i+1)
+            if (mod < 8) {
+                if ((w[i] ?? 0) > 0 && (w[i + 1] ?? 0) > 0) {
+                    w[i] = (w[i] ?? 0) - 1;
+                    w[i + 1] = (w[i + 1] ?? 0) - 1;
+                    taatsu++;
+                }
+            }
+            // 嵌張 (i, i+2)
+            if (mod < 7) {
+                if ((w[i] ?? 0) > 0 && (w[i + 2] ?? 0) > 0) {
+                    w[i] = (w[i] ?? 0) - 1;
+                    w[i + 2] = (w[i + 2] ?? 0) - 1;
+                    taatsu++;
+                }
+            }
+        }
+        // 対子 (2枚)
+        if ((w[i] ?? 0) >= 2) {
+            w[i] = (w[i] ?? 0) - 2;
+            taatsu++;
+        }
+    }
+    return taatsu;
+}

package/dist/features/yaku/factory.d.ts

@@ -0,0 +1,13 @@
+import type { YakuHanConfig, YakuName, HouraStructure } from "./types";
+import { YakuDefinition, HouraContext } from "./types";
+/**
+ * 役定義を作成するファクトリ関数
+ *
+ * @param yaku 役の設定情報（名前、翻数など）
+ * @param check 役の成立条件を判定する関数 (真偽値を返す)
+ * @returns YakuDefinition (isSatisfied, getHansu を持つ)
+ */
+export declare function createYakuDefinition(yaku: Readonly<{
+    name: YakuName;
+    han: YakuHanConfig;
+}>, check: (hand: HouraStructure, context: HouraContext) => boolean): YakuDefinition;

package/dist/features/yaku/factory.js

@@ -0,0 +1,19 @@
+/**
+ * 役定義を作成するファクトリ関数
+ *
+ * @param yaku 役の設定情報（名前、翻数など）
+ * @param check 役の成立条件を判定する関数 (真偽値を返す)
+ * @returns YakuDefinition (isSatisfied, getHansu を持つ)
+ */
+export function createYakuDefinition(yaku, check) {
+    return {
+        yaku,
+        isSatisfied: check,
+        getHansu: (hand, context) => {
+            if (!check(hand, context)) {
+                return 0;
+            }
+            return context.isMenzen ? yaku.han.closed : yaku.han.open;
+        },
+    };
+}

package/dist/features/yaku/index.d.ts

@@ -0,0 +1,21 @@
+import type { Tehai14, HaiKindId } from "../../types";
+import type { YakuResult, HouraStructure } from "./types";
+import type { HouraContext } from "./types";
+export type { HouraStructure, YakuResult, YakuName, Hansu, TehaiYaku, YakuHanConfig, Yakuhai, } from "./types";
+export * from "./lib";
+/**
+ * 単一の和了構造に対して役を判定する
+ *
+ * @param hand 和了構造（面子手、七対子、国士無双のいずれか）
+ * @param context 和了コンテキスト
+ * @returns 成立した役と翻数のリスト
+ */
+export declare function detectYakuForStructure(hand: HouraStructure, context: HouraContext): YakuResult;
+/**
+ * 手牌の構造役を検出する
+ *
+ * @param tehai 判定対象の手牌
+ * @param agariHai 和了牌
+ * @returns 成立した役と翻数のリスト（最も高得点となる解釈の結果）
+ */
+export declare function detectYaku(tehai: Tehai14, agariHai: HaiKindId, bakaze?: HaiKindId, jikaze?: HaiKindId, doraMarkers?: readonly HaiKindId[], uraDoraMarkers?: readonly HaiKindId[], isTsumo?: boolean): YakuResult;

package/dist/features/yaku/index.js

@@ -0,0 +1,59 @@
+import { getHouraStructures } from "./lib/structures";
+import { isMenzen, isKazehai } from "./utils";
+import { ALL_YAKU_DEFINITIONS } from "./lib/definitions";
+export * from "./lib";
+/**
+ * 単一の和了構造に対して役を判定する
+ *
+ * @param hand 和了構造（面子手、七対子、国士無双のいずれか）
+ * @param context 和了コンテキスト
+ * @returns 成立した役と翻数のリスト
+ */
+export function detectYakuForStructure(hand, context) {
+    const result = [];
+    for (const definition of ALL_YAKU_DEFINITIONS) {
+        if (definition.isSatisfied(hand, context)) {
+            const hansu = definition.getHansu(hand, context);
+            if (hansu === 0)
+                continue;
+            result.push([definition.yaku.name, hansu]);
+        }
+    }
+    return result;
+}
+/**
+ * YakuResult から総翻数を計算する
+ */
+function getTotalHan(yakuResult) {
+    return yakuResult.reduce((sum, [, han]) => sum + han, 0);
+}
+/**
+ * 手牌の構造役を検出する
+ *
+ * @param tehai 判定対象の手牌
+ * @param agariHai 和了牌
+ * @returns 成立した役と翻数のリスト（最も高得点となる解釈の結果）
+ */
+export function detectYaku(tehai, agariHai, bakaze, jikaze, doraMarkers, uraDoraMarkers, isTsumo) {
+    const context = {
+        isMenzen: isMenzen(tehai),
+        agariHai,
+        bakaze: bakaze !== undefined && isKazehai(bakaze) ? bakaze : undefined,
+        jikaze: jikaze !== undefined && isKazehai(jikaze) ? jikaze : undefined,
+        doraMarkers: doraMarkers ?? [],
+        uraDoraMarkers: uraDoraMarkers ?? [],
+        isTsumo,
+    };
+    const structuralInterpretations = getHouraStructures(tehai);
+    let bestResult = [];
+    let maxHan = -1;
+    for (const hand of structuralInterpretations) {
+        const currentResult = detectYakuForStructure(hand, context);
+        const currentHan = getTotalHan(currentResult);
+        if (currentHan > maxHan) {
+            maxHan = currentHan;
+            bestResult = currentResult;
+        }
+    }
+    return bestResult;
+}

package/dist/features/yaku/lib/definitions/chiitoitsu.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const chiitoitsuDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/chiitoitsu.js

@@ -0,0 +1,12 @@
+import { createYakuDefinition } from "../../factory";
+const CHIITOITSU_YAKU = {
+    name: "Chiitoitsu",
+    han: {
+        open: 0, // 門前限定
+        closed: 2,
+    },
+};
+const checkChiitoitsu = (hand) => {
+    return hand.type === "Chiitoitsu";
+};
+export const chiitoitsuDefinition = createYakuDefinition(CHIITOITSU_YAKU, checkChiitoitsu);

package/dist/features/yaku/lib/definitions/chinitsu.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const chinitsuDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/chinitsu.js

@@ -0,0 +1,40 @@
+import { isSuupai, kindIdToHaiType } from "../../../../core/hai";
+import { HaiType } from "../../../../types";
+import { createYakuDefinition } from "../../factory";
+const CHINITSU_YAKU = {
+    name: "Chinitsu",
+    han: {
+        open: 5,
+        closed: 6,
+    },
+};
+const checkChinitsu = (hand) => {
+    let blocks;
+    if (hand.type === "Mentsu") {
+        blocks = [hand.jantou, ...hand.fourMentsu];
+    }
+    else if (hand.type === "Chiitoitsu") {
+        blocks = hand.pairs;
+    }
+    else {
+        return false;
+    }
+    // ブロック内の全ての牌をフラットな配列にする
+    const allHais = blocks.flatMap((b) => b.hais);
+    // 1. 字牌が含まれていないこと
+    const hasJihai = allHais.some((k) => kindIdToHaiType(k) === HaiType.Jihai);
+    if (hasJihai)
+        return false;
+    // 2. 数牌が全て同じ種類であること
+    const suupais = allHais.filter((k) => isSuupai(k));
+    // 数牌が含まれていない（字一色想定だが上記でJihaiチェック済みなので事実上ありえない）場合は不成立
+    if (suupais.length === 0)
+        return false;
+    const firstSuupai = suupais[0];
+    if (firstSuupai === undefined)
+        return false;
+    const firstSuupaiType = kindIdToHaiType(firstSuupai);
+    const isAllSameType = suupais.every((k) => kindIdToHaiType(k) === firstSuupaiType);
+    return isAllSameType;
+};
+export const chinitsuDefinition = createYakuDefinition(CHINITSU_YAKU, checkChinitsu);

package/dist/features/yaku/lib/definitions/chinroutou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const chinroutouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/chinroutou.js

@@ -0,0 +1,21 @@
+import { isSuupai, isYaochu } from "../../../../core/hai";
+import { createYakuDefinition } from "../../factory";
+const CHINROUTOU_YAKU = {
+    name: "Chinroutou",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const checkChinroutou = (hand) => {
+    // 老頭牌は6種類(1m,9m,1p,9p,1s,9s)しかないため、七対子(7種)は成立しない
+    if (hand.type !== "Mentsu")
+        return false;
+    const allBlocks = [hand.jantou, ...hand.fourMentsu];
+    // 全てが老頭牌（字牌以外の么九牌）で構成されていること
+    const allRoutou = allBlocks.every((block) => block.hais.every((k) => isYaochu(k) && isSuupai(k)));
+    if (!allRoutou)
+        return false;
+    return true;
+};
+export const chinroutouDefinition = createYakuDefinition(CHINROUTOU_YAKU, checkChinroutou);

package/dist/features/yaku/lib/definitions/chuuren-poutou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const chuurenPoutouDefinition: YakuDefinition;