@pai-forge/riichi-mahjong 0.1.0

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

@@ -0,0 +1,34 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const SHOUSUUSHII_YAKU = {
+    name: "Shousuushii",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const checkShousuushii = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const windTiles = [
+        HaiKind.Ton,
+        HaiKind.Nan,
+        HaiKind.Sha,
+        HaiKind.Pei,
+    ];
+    // 1. 風牌の刻子・槓子をカウント
+    let windKoutsuCount = 0;
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    for (const triplet of triplets) {
+        if (windTiles.includes(triplet.hais[0])) {
+            windKoutsuCount++;
+        }
+    }
+    // 2. 風牌の雀頭があるかチェック
+    const isWindJantou = windTiles.includes(hand.jantou.hais[0]);
+    // 小四喜の条件: 風牌の刻子が3つ かつ 風牌の雀頭が1つ
+    // (合計で4種類の風牌が揃うことになる。例: 東東東 南南南 西西西 北北)
+    return windKoutsuCount === 3 && isWindJantou;
+};
+export const shousuushiiDefinition = createYakuDefinition(SHOUSUUSHII_YAKU, checkShousuushii);

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

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

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

@@ -0,0 +1,63 @@
+const SUUANKOU_YAKU = {
+    name: "Suuankou",
+    han: {
+        open: 0, // 門前限定（構造上必然的にそうなるが、定義としても門前）
+        closed: 13, // 通常役満(13) または ダブル役満(26)
+    },
+};
+const checkSuuankou = (hand, context) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 刻子・槓子を抽出
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    let ankouCount = 0;
+    for (const triplet of triplets) {
+        // 副露している刻子は暗刻ではない
+        if (triplet.furo)
+            continue;
+        const isAgariHaiInTriplet = triplet.hais.includes(context.agariHai);
+        const isTanki = hand.jantou.hais[0] === context.agariHai;
+        if (context.isTsumo) {
+            // ツモなら、副露していなければ全て暗刻
+            ankouCount++;
+        }
+        else {
+            // ロン和了の場合
+            if (isAgariHaiInTriplet) {
+                // 和了牌を含む刻子（シャボ待ちロン）は明刻
+                // 単騎待ちロンなら暗刻
+                if (isTanki) {
+                    ankouCount++;
+                }
+            }
+            else {
+                // 和了牌を含まない刻子は暗刻
+                ankouCount++;
+            }
+        }
+    }
+    return ankouCount === 4;
+};
+// 四暗刻はダブル役満（単騎待ち）判定が必要なため、
+// createYakuDefinitionのデフォルトのgetHansuロジックをオーバーライドするか、
+// このcheck関数内で判定してフラグを渡すなどの工夫が必要。
+// しかし createYakuDefinition は boolean を返す check 関数しか受け取らない。
+// ここでは factory 側を拡張するのではなく、この定義でカスタム実装を行うか、
+// あるいは factory を通さずに直接 YakuDefinition を作る。
+// factoryの改修はスコープ外のため、ここではオブジェクトリテラルで定義を作成する。
+export const suuankouDefinition = {
+    yaku: SUUANKOU_YAKU,
+    isSatisfied: (hand, context) => checkSuuankou(hand, context),
+    getHansu: (hand, context) => {
+        if (!checkSuuankou(hand, context))
+            return 0;
+        // 四暗刻単騎の判定
+        const isTanki = hand.type === "Mentsu" && hand.jantou.hais[0] === context.agariHai;
+        // 単騎待ちならダブル役満(26)
+        if (isTanki) {
+            return 26;
+        }
+        return 13;
+    },
+};

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

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

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

@@ -0,0 +1,18 @@
+import { createYakuDefinition } from "../../factory";
+const SUUKANTSU_YAKU = {
+    name: "Suukantsu",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const checkSuukantsu = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 槓子を抽出
+    const kantsuList = hand.fourMentsu.filter((m) => m.type === "Kantsu");
+    // 2. 槓子が4つあれば成立
+    return kantsuList.length === 4;
+};
+export const suukantsuDefinition = createYakuDefinition(SUUKANTSU_YAKU, checkSuukantsu);

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

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

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

@@ -0,0 +1,23 @@
+import { isYaochu } from "../../../../core/hai";
+import { createYakuDefinition } from "../../factory";
+const TANYAO_YAKU = {
+    name: "Tanyao",
+    han: {
+        open: 1,
+        closed: 1,
+    },
+};
+const checkTanyao = (hand) => {
+    if (hand.type !== "Mentsu")
+        return false;
+    // 雀頭のチェック
+    if (isYaochu(hand.jantou.hais[0]))
+        return false;
+    // 面子のチェック
+    for (const mentsu of hand.fourMentsu) {
+        if (mentsu.hais.some(isYaochu))
+            return false;
+    }
+    return true;
+};
+export const tanyaoDefinition = createYakuDefinition(TANYAO_YAKU, checkTanyao);

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

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

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

@@ -0,0 +1,16 @@
+import { createYakuDefinition } from "../../factory";
+const TOITOI_YAKU = {
+    name: "Toitoi",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkToitoi = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 全ての面子が刻子（Koutsu）または槓子（Kantsu）であることを確認
+    return hand.fourMentsu.every((mentsu) => mentsu.type === "Koutsu" || mentsu.type === "Kantsu");
+};
+export const toitoiDefinition = createYakuDefinition(TOITOI_YAKU, checkToitoi);

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

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

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

@@ -0,0 +1,35 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const TSUUIISOU_YAKU = {
+    name: "Tsuuiisou",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const isJihai = (id) => {
+    return id >= HaiKind.Ton && id <= HaiKind.Chun;
+};
+const checkTsuuiisou = (hand) => {
+    const allHais = [];
+    if (hand.type === "Mentsu") {
+        // 面子手の場合
+        for (const mentsu of hand.fourMentsu) {
+            allHais.push(...mentsu.hais);
+        }
+        allHais.push(...hand.jantou.hais);
+    }
+    else if (hand.type === "Chiitoitsu") {
+        // 七対子の場合
+        for (const pair of hand.pairs) {
+            allHais.push(...pair.hais);
+        }
+    }
+    else {
+        // 国士無双など（国士は字一色にはなり得ないが、構造上は考慮）
+        return false;
+    }
+    // 全ての牌が字牌であれば成立
+    return allHais.every(isJihai);
+};
+export const tsuuiisouDefinition = createYakuDefinition(TSUUIISOU_YAKU, checkTsuuiisou);

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

@@ -0,0 +1,4 @@
+import type { YakuDefinition } from "../../types";
+export declare const hakuDefinition: YakuDefinition;
+export declare const hatsuDefinition: YakuDefinition;
+export declare const chunDefinition: YakuDefinition;

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

@@ -0,0 +1,21 @@
+import { HaiKind } from "../../../../types";
+import { createYakuDefinition } from "../../factory";
+function createYakuhaiDefinition(name, tile) {
+    const HAN_CONFIG = { closed: 1, open: 1 };
+    const check = (hand) => {
+        if (hand.type !== "Mentsu")
+            return false;
+        for (const mentsu of hand.fourMentsu) {
+            if (mentsu.type === "Koutsu" || mentsu.type === "Kantsu") {
+                if (mentsu.hais[0] === tile) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    return createYakuDefinition({ name, han: HAN_CONFIG }, check);
+}
+export const hakuDefinition = createYakuhaiDefinition("Haku", HaiKind.Haku);
+export const hatsuDefinition = createYakuhaiDefinition("Hatsu", HaiKind.Hatsu);
+export const chunDefinition = createYakuhaiDefinition("Chun", HaiKind.Chun);

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

@@ -0,0 +1 @@
+export * from "./definitions";

package/dist/features/yaku/lib/index.js

@@ -0,0 +1 @@
+export * from "./definitions";

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

@@ -0,0 +1,6 @@
+import type { Tehai14 } from "../../../../types";
+import type { ChiitoitsuHouraStructure } from "../../types";
+/**
+ * 手牌を七対子（7つの対子）として構造化する。
+ */
+export declare function getHouraStructuresForChiitoitsu(tehai: Tehai14): ChiitoitsuHouraStructure[];

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

@@ -0,0 +1,38 @@
+import { countHaiKind } from "../../../../core/tehai";
+/**
+ * 手牌を七対子（7つの対子）として構造化する。
+ */
+export function getHouraStructuresForChiitoitsu(tehai) {
+    // 七対子は門前のみ（定義によっては鳴きも許容する場合があるが、一般的には門前）
+    if (tehai.exposed.length > 0)
+        return [];
+    const counts = countHaiKind(tehai.closed);
+    const pairs = [];
+    for (let i = 0; i < 34; i++) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const kind = i;
+        const count = counts[kind];
+        if (count === 2) {
+            pairs.push({ type: "Toitsu", hais: [kind, kind] });
+        }
+        else if (count === 4) {
+            // 4枚使いの七対子を認めるか（ローカルルール次第だが、通常は認めない）
+            // ここでは標準的なルールに従い、4枚あっても2対子とはみなさない実装とする
+            // ※4枚使い七対子を実装する場合は pairs.push(...) を2回行う
+            return [];
+        }
+        else if (count > 0) {
+            // 2枚でない牌がある場合は七対子不成立
+            return [];
+        }
+    }
+    if (pairs.length !== 7)
+        return [];
+    return [
+        {
+            type: "Chiitoitsu",
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            pairs: pairs,
+        },
+    ];
+}

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

@@ -0,0 +1,10 @@
+import type { Tehai14 } from "../../../../types";
+import type { HouraStructure } from "../../types";
+export * from "./mentsu-te";
+export * from "./chiitoitsu";
+export * from "./kokushi";
+/**
+ * 手牌をすべての可能な和了形に構造化する。
+ * 面子手、七対子、国士無双の全ての可能性を探索する。
+ */
+export declare function getHouraStructures(tehai: Tehai14): HouraStructure[];

package/dist/features/yaku/lib/structures/index.js

@@ -0,0 +1,17 @@
+import { getHouraStructuresForMentsuTe } from "./mentsu-te";
+import { getHouraStructuresForChiitoitsu } from "./chiitoitsu";
+import { getHouraStructuresForKokushi } from "./kokushi";
+export * from "./mentsu-te";
+export * from "./chiitoitsu";
+export * from "./kokushi";
+/**
+ * 手牌をすべての可能な和了形に構造化する。
+ * 面子手、七対子、国士無双の全ての可能性を探索する。
+ */
+export function getHouraStructures(tehai) {
+    return [
+        ...getHouraStructuresForMentsuTe(tehai),
+        ...getHouraStructuresForChiitoitsu(tehai),
+        ...getHouraStructuresForKokushi(tehai),
+    ];
+}

package/dist/features/yaku/lib/structures/kokushi.d.ts

@@ -0,0 +1,6 @@
+import type { Tehai14 } from "../../../../types";
+import type { KokushiHouraStructure } from "../../types";
+/**
+ * 手牌を国士無双（13種の么九牌＋雀頭）として構造化する。
+ */
+export declare function getHouraStructuresForKokushi(tehai: Tehai14): KokushiHouraStructure[];

package/dist/features/yaku/lib/structures/kokushi.js

@@ -0,0 +1,43 @@
+import { countHaiKind } from "../../../../core/tehai";
+import { isYaochu } from "../../../../core/hai";
+/**
+ * 手牌を国士無双（13種の么九牌＋雀頭）として構造化する。
+ */
+export function getHouraStructuresForKokushi(tehai) {
+    // 国士無双は門前のみ
+    if (tehai.exposed.length > 0)
+        return [];
+    const counts = countHaiKind(tehai.closed);
+    const yaochuList = [];
+    let jantou;
+    for (let i = 0; i < 34; i++) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const kind = i;
+        const count = counts[kind];
+        if (count > 0) {
+            if (!isYaochu(kind))
+                return []; // 么九牌以外が含まれていれば不成立
+            if (count === 1) {
+                yaochuList.push(kind);
+            }
+            else if (count === 2) {
+                if (jantou !== undefined)
+                    return []; // 雀頭が既に存在すれば不成立（複数棋の雀頭候補）
+                jantou = kind;
+                yaochuList.push(kind);
+            }
+            else {
+                return []; // 3枚以上あれば不成立
+            }
+        }
+    }
+    if (yaochuList.length !== 13 || jantou === undefined)
+        return [];
+    return [
+        {
+            type: "Kokushi",
+            yaochu: yaochuList,
+            jantou,
+        },
+    ];
+}

package/dist/features/yaku/lib/structures/mentsu-te.d.ts

@@ -0,0 +1,24 @@
+import type { MentsuHouraStructure } from "../../types";
+import type { Tehai14 } from "../../../../types";
+/**
+ * 手牌を標準形（4面子1雀頭）に構造化する。
+ * 七対子や国士無双は対象外。
+ *
+ * 【役判定について】
+ * この関数は純粋に「4面子1雀頭」の形になっているかのみを検証します。
+ * 役が成立しているかどうか（和了できるかどうか）は判定しません。
+ * そのため、役なし（Yakunashi）の手牌であっても構造的に整合していれば結果を返します。
+ *
+ * 【戻り値が配列である理由について】
+ * 麻雀の手牌は、同じ牌構成であっても複数の解釈（多義性）が成立する場合があります。
+ * 例: `111222333m`
+ * - 三暗刻 (111 + 222 + 333)
+ * - 三連刻/一盃口 (123 + 123 + 123)
+ *
+ * このように成立する役が変わる可能性があるため、可能な全ての構造化パターンをリストとして返します。
+ * 利用側は、これらのパターンのうち最も高得点となるものを選択する必要があります。
+ *
+ * @param tehai 和了形の手牌
+ * @returns 可能な構造化パターンのリスト。構造化できない場合は空配列。
+ */
+export declare function getHouraStructuresForMentsuTe(tehai: Tehai14): MentsuHouraStructure[];

package/dist/features/yaku/lib/structures/mentsu-te.js

@@ -0,0 +1,127 @@
+import { validateTehai14, countHaiKind } from "../../../../core/tehai";
+import { isTuple4 } from "../../../../utils/assertions";
+/**
+ * 手牌を標準形（4面子1雀頭）に構造化する。
+ * 七対子や国士無双は対象外。
+ *
+ * 【役判定について】
+ * この関数は純粋に「4面子1雀頭」の形になっているかのみを検証します。
+ * 役が成立しているかどうか（和了できるかどうか）は判定しません。
+ * そのため、役なし（Yakunashi）の手牌であっても構造的に整合していれば結果を返します。
+ *
+ * 【戻り値が配列である理由について】
+ * 麻雀の手牌は、同じ牌構成であっても複数の解釈（多義性）が成立する場合があります。
+ * 例: `111222333m`
+ * - 三暗刻 (111 + 222 + 333)
+ * - 三連刻/一盃口 (123 + 123 + 123)
+ *
+ * このように成立する役が変わる可能性があるため、可能な全ての構造化パターンをリストとして返します。
+ * 利用側は、これらのパターンのうち最も高得点となるものを選択する必要があります。
+ *
+ * @param tehai 和了形の手牌
+ * @returns 可能な構造化パターンのリスト。構造化できない場合は空配列。
+ */
+export function getHouraStructuresForMentsuTe(tehai) {
+    validateTehai14(tehai);
+    // HaiKindDistributionはreadonlyなので、可変配列に複製する
+    const counts = [...countHaiKind(tehai.closed)];
+    const results = [];
+    // 1. 雀頭候補を探す
+    for (let i = 0; i < 34; i++) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const kind = i;
+        if ((counts[kind] ?? 0) >= 2) {
+            // 雀頭抜き出し
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            counts[kind] -= 2;
+            // 残りの牌で面子分解
+            const requiredMentsuCount = 4 - tehai.exposed.length;
+            const subResults = decomposeClosedMentsu(counts, requiredMentsuCount);
+            // subResultsには閉じた部分で見つかった面子のリストが含まれる
+            for (const closedMentsu of subResults) {
+                // 副露面子と結合して完全な構成を作成する
+                const fullMentsuList = [...closedMentsu, ...tehai.exposed];
+                // 4面子であることを確認（ロジック上は保証されているはずだが、念のため）
+                if (isTuple4(fullMentsuList)) {
+                    results.push({
+                        type: "Mentsu",
+                        fourMentsu: fullMentsuList,
+                        jantou: { type: "Toitsu", hais: [kind, kind] },
+                    });
+                }
+            }
+            // バックトラック
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            counts[kind] += 2;
+        }
+    }
+    return results;
+}
+/**
+ * 閉じた手牌の残りを面子に分解する再帰関数
+ */
+function decomposeClosedMentsu(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+counts, requiredCount) {
+    if (requiredCount === 0) {
+        // 全ての牌が使用されたか確認
+        const remaining = counts.reduce((acc, c) => acc + c, 0);
+        return remaining === 0 ? [[]] : [];
+    }
+    // 面子の重複順列を防ぎ決定論的な順序を強制するため、カウントが0より大きい最初の牌を見つける
+    let firstIndex = -1;
+    for (let i = 0; i < 34; i++) {
+        if ((counts[i] ?? 0) > 0) {
+            firstIndex = i;
+            break;
+        }
+    }
+    if (firstIndex === -1) {
+        // Should not happen if requiredCount > 0, unless invalid hand
+        return [];
+    }
+    const results = [];
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const kind = firstIndex;
+    // 刻子を試す
+    if ((counts[kind] ?? 0) >= 3) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        counts[kind] -= 3;
+        const tails = decomposeClosedMentsu(counts, requiredCount - 1);
+        const koutsu = { type: "Koutsu", hais: [kind, kind, kind] };
+        for (const tail of tails) {
+            results.push([koutsu, ...tail]);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        counts[kind] += 3; // バックトラック
+    }
+    // 順子を試す
+    // 数牌（0-26）かつ7を超えない（n, n+1, n+2を作れる）場合のみ有効
+    if (kind < 27 && kind % 9 <= 6) {
+        const k1 = kind;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const k2 = (kind + 1);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const k3 = (kind + 2);
+        if ((counts[k2] ?? 0) > 0 && (counts[k3] ?? 0) > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            counts[k1] -= 1;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            counts[k2] -= 1;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            counts[k3] -= 1;
+            const tails = decomposeClosedMentsu(counts, requiredCount - 1);
+            const shuntsu = { type: "Shuntsu", hais: [k1, k2, k3] };
+            for (const tail of tails) {
+                results.push([shuntsu, ...tail]);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            counts[k1] += 1;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            counts[k2] += 1;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            counts[k3] += 1; // バックトラック
+        }
+    }
+    return results;
+}

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

@@ -0,0 +1,121 @@
+import type { HaiKindId, Kazehai, Shuntsu, Koutsu, Kantsu, Toitsu, Mentsu, CompletedMentsu } from "../../types";
+export type { Kazehai, Shuntsu, Koutsu, Kantsu, Toitsu, Mentsu };
+/**
+ * 役牌 (Yakuhai)
+ *
+ * 構造的に成立する三元牌。
+ * ※場風・自風は状況役（Bakaze, Jikaze）として別途定義するためここには含めない。
+ */
+export type Yakuhai = "Haku" | "Hatsu" | "Chun";
+/**
+ * 手牌役 (TehaiYaku)
+ *
+ * 手牌役（手牌の構成のみで成立する役）の識別子。
+ * 偶然役（嶺上開花など）や状況役（場風、自風、立直など）は含まない。
+ */
+export type TehaiYaku = "Tanyao" | "Pinfu" | "Iipeikou" | Yakuhai | "SanshokuDoujun" | "Ikkitsuukan" | "Honchan" | "Chiitoitsu" | "Toitoi" | "Sanankou" | "Sankantsu" | "SanshokuDoukou" | "Honroutou" | "Shousangen" | "Honitsu" | "Junchan" | "Ryanpeikou" | "Chinitsu" | "KokushiMusou" | "Suuankou" | "Daisangen" | "Shousuushii" | "Daisuushii" | "Tsuuiisou" | "Chinroutou" | "Ryuuiisou" | "ChuurenPoutou" | "Suukantsu" | "MenzenTsumo";
+/**
+ * 役の飜数 (Hansu)
+ *
+ * 1, 2, 3, 5(流し満貫/清一色喰い下がり), 6(清一色), 13(役満), 26(ダブル役満)
+ */
+export type Hansu = 1 | 2 | 3 | 5 | 6 | 13 | 26;
+export interface MentsuHouraStructure {
+    readonly type: "Mentsu";
+    readonly fourMentsu: readonly [
+        CompletedMentsu,
+        CompletedMentsu,
+        CompletedMentsu,
+        CompletedMentsu
+    ];
+    readonly jantou: Toitsu;
+}
+export interface ChiitoitsuHouraStructure {
+    readonly type: "Chiitoitsu";
+    readonly pairs: readonly [
+        Toitsu,
+        Toitsu,
+        Toitsu,
+        Toitsu,
+        Toitsu,
+        Toitsu,
+        Toitsu
+    ];
+}
+export interface KokushiHouraStructure {
+    readonly type: "Kokushi";
+    /** 13種類の么九牌（重複なし） */
+    readonly yaochu: readonly HaiKindId[];
+    /** 雀頭となる牌の種類 */
+    readonly jantou: HaiKindId;
+}
+export type HouraStructure = MentsuHouraStructure | ChiitoitsuHouraStructure | KokushiHouraStructure;
+/**
+ * 役の飜数定義
+ */
+export interface YakuHanConfig {
+    /** 門前時の飜数 */
+    readonly closed: Hansu;
+    /**
+     * 鳴きあり時の飜数 (0なら不成立)
+     *
+     * @remarks
+     * この値が 0 の場合、その役は**門前限定（Menzen-only）**であることを意味します。
+     * 役判定ロジックにおいては、この値が 0 でかつ手牌が副露されている場合、
+     * 役の条件を満たしていても不成立とみなされます。
+     */
+    readonly open: Hansu | 0;
+}
+/**
+ * 役ID (YakuName)
+ *
+ * 全ての役の識別子ユニオン。
+ */
+export type YakuName = TehaiYaku;
+/**
+ * 役判定結果 (YakuResult)
+ *
+ * 成立した役と、その飜数のペアのリスト。
+ * 役が一つも成立しない場合は空配列となる。
+ */
+export type YakuResult = readonly [YakuName, Hansu][];
+export interface HouraContext {
+    /** 手牌が門前かどうか（暗槓が含まれていても門前扱い） */
+    readonly isMenzen: boolean;
+    /** 和了牌（平和判定などに必要）。省略時は判定不能な役がある */
+    readonly agariHai: HaiKindId;
+    /** 場風牌 */
+    readonly bakaze?: Kazehai | undefined;
+    /** 自風牌 */
+    readonly jikaze?: Kazehai | undefined;
+    /** ツモ和了かどうか（暗刻系役の判定などに使用） */
+    readonly isTsumo?: boolean | undefined;
+    /**
+     * ドラ表示牌 (表ドラ) のリスト
+     */
+    readonly doraMarkers: readonly HaiKindId[];
+    /**
+     * 裏ドラ表示牌のリスト (リーチ時のみ有効)
+     */
+    readonly uraDoraMarkers?: readonly HaiKindId[];
+}
+export interface Yaku {
+    readonly name: YakuName;
+    /** 飜数 (喰い下がり考慮) */
+    readonly han: {
+        readonly open: Hansu | 0;
+        readonly closed: Hansu;
+    };
+}
+/**
+ * 役の成立判定関数
+ * @param hand 分解された手牌構造
+ * @param context 判定コンテキスト
+ * @returns 成立回数 (0なら不成立、役牌などで複数成立しうる)
+ */
+export type YakuCheck = (hand: HouraStructure, context: HouraContext) => number;
+export interface YakuDefinition {
+    readonly yaku: Yaku;
+    readonly isSatisfied: (hand: HouraStructure, context: HouraContext) => boolean;
+    readonly getHansu: (hand: HouraStructure, context: HouraContext) => Hansu | 0;
+}

package/dist/features/yaku/types.js

@@ -0,0 +1 @@
+export {};