@pai-forge/riichi-mahjong 0.2.0 → 0.3.0

package/dist/features/score/constants.js

@@ -0,0 +1,30 @@
+export const SCORE_OYA_MULTIPLIER = 1.5; // 親は1.5倍
+export const SCORE_BASE_MANGAN = 2000;
+export const SCORE_BASE_HANEMAN = 3000;
+export const SCORE_BASE_BAIMAN = 4000;
+export const SCORE_BASE_SANBAIMAN = 6000;
+export const SCORE_BASE_YAKUMAN = 8000;
+/**
+ * 満貫以上の判定基準となる翻数
+ *
+ * "5翻" であれば符数に関わらず満貫以上が確定するため 5 を設定しています。
+ *
+ * Q: 4翻は満貫ではないのか？
+ * A: 4翻でも符数が高ければ（40符以上など）満貫になりますが、以下のようなケースでは満貫（8000点）に届きません。
+ *    - 七対子 (25符): 6400点
+ *    - 門前ツモ・愚形など (30符): 7900点 (※切り上げ満貫なしの場合)
+ *    - 鳴き手・ロン (30符): 7700点 (※切り上げ満貫なしの場合)
+ *
+ *    そのため、4翻以下の場合は計算による基本点が基準値（2000）を超えたかどうかで判定します。
+ */
+export const HAN_MANGAN = 5;
+export const HAN_HANEMAN = 6;
+export const HAN_BAIMAN = 8;
+export const HAN_SANBAIMAN = 11;
+export const HAN_YAKUMAN = 13;
+export const HAS_YAKUMAN = 13; // 便宜上の翻数
+export const HAS_DOUBLE_YAKUMAN = 26;
+// 切り上げ満貫の閾値 (30符4翻 = 1920 -> 2000? 60符3翻=1920)
+// 一般的には 2000点(子) / 3000点(親) が満貫の最低点（ベース）
+// 符計算による基本点が 2000 を超えたら満貫
+export const BASE_SCORE_LIMIT = 2000;

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

@@ -0,0 +1,45 @@
+import { type Tehai14, type Fu } from "../../types";
+import type { FuResult } from "./lib/fu/types";
+import { ScoreLevel, type ScoreCalculationConfig, type ScoreContext, type ScoreResult, type Payment, type Ron, type KoTsumo, type OyaTsumo } from "./types";
+export type { ScoreCalculationConfig, ScoreResult, Payment, Ron, KoTsumo, OyaTsumo, };
+export { ScoreLevel };
+/**
+ * 基本点を計算する
+ * 基本点 = 符 × 2^(2+翻)
+ *
+ * 基本点は子がツモ和了したときの他の子1人あたりの支払い点数に相当する。
+ * - 子ツモ: 子の支払い = 基本点, 親の支払い = 基本点 × 2
+ * - 子ロン: 支払い = 基本点 × 4
+ * - 親ツモ: 各子の支払い = 基本点 × 2
+ * - 親ロン: 支払い = 基本点 × 6
+ */
+export declare function calculateBasePoints(fu: Fu, han: number): number;
+/**
+ * 支払い情報から和了者が受け取る総点数を計算する
+ */
+export declare function getPaymentTotal(payment: Readonly<Payment>): number;
+/**
+ * 翻数と基本点から点数レベルを判定する
+ *
+ * @param han 翻数
+ * @param basePoints 基本点（符 × 2^(2+翻)）
+ * @returns 点数レベル
+ */
+export declare function getScoreLevel(han: number, basePoints: number): ScoreLevel;
+/**
+ * 手牌とコンテキストから点数を計算する（公開API）
+ *
+ * 手牌の構造解析を行い、最も高点となる解釈を採用して点数を返します。
+ *
+ * 注: 同一手牌で「翻数が高いが符が低い解釈」と「翻数が低いが符が高い解釈」が
+ * 両立するケースは実質的に存在しないため、翻数最大の解釈を採用しています。
+ *
+ * @param tehai 手牌 (14枚)
+ * @param config 点数計算の設定 (場風、自風、ドラなど)
+ * @returns 点数計算結果
+ */
+export declare function calculateScoreForTehai(tehai: Tehai14, config: Readonly<ScoreCalculationConfig>): ScoreResult;
+/**
+ * 基本的な点数計算ロジック (内部用・テスト用)
+ */
+export declare function calculateScoreFromHanAndFu(yakuHansu: number, fuResult: Readonly<FuResult>, dora: number, context: Readonly<ScoreContext>): ScoreResult;

package/dist/features/score/index.js

@@ -0,0 +1,207 @@
+import { HaiKind } from "../../types";
+import { NoYakuError } from "../../errors";
+import { countDora } from "../../core/dora";
+import { getHouraStructures } from "../yaku/lib/structures";
+import { detectYakuForStructure } from "../yaku";
+import { calculateFu } from "./lib/fu";
+import { isMenzen } from "../yaku/utils";
+import { BASE_SCORE_LIMIT, HAN_BAIMAN, HAN_HANEMAN, HAN_MANGAN, HAN_SANBAIMAN, HAN_YAKUMAN, SCORE_BASE_BAIMAN, SCORE_BASE_HANEMAN, SCORE_BASE_MANGAN, SCORE_BASE_SANBAIMAN, SCORE_BASE_YAKUMAN, } from "./constants";
+import { ScoreLevel, } from "./types";
+export { ScoreLevel };
+/**
+ * 100点単位で切り上げる
+ */
+function ceil100(points) {
+    return Math.ceil(points / 100) * 100;
+}
+/**
+ * 基本点を計算する
+ * 基本点 = 符 × 2^(2+翻)
+ *
+ * 基本点は子がツモ和了したときの他の子1人あたりの支払い点数に相当する。
+ * - 子ツモ: 子の支払い = 基本点, 親の支払い = 基本点 × 2
+ * - 子ロン: 支払い = 基本点 × 4
+ * - 親ツモ: 各子の支払い = 基本点 × 2
+ * - 親ロン: 支払い = 基本点 × 6
+ */
+export function calculateBasePoints(fu, han) {
+    return fu * Math.pow(2, 2 + han);
+}
+/**
+ * 支払い情報から和了者が受け取る総点数を計算する
+ */
+export function getPaymentTotal(payment) {
+    switch (payment.type) {
+        case "ron":
+            return payment.amount;
+        case "koTsumo":
+            return payment.amount[0] * 2 + payment.amount[1];
+        case "oyaTsumo":
+            return payment.amount * 3;
+    }
+}
+/**
+ * 翻数と基本点から点数レベルを判定する
+ *
+ * @param han 翻数
+ * @param basePoints 基本点（符 × 2^(2+翻)）
+ * @returns 点数レベル
+ */
+export function getScoreLevel(han, basePoints) {
+    if (han >= 26) {
+        return ScoreLevel.DoubleYakuman;
+    }
+    if (han >= HAN_YAKUMAN) {
+        return ScoreLevel.Yakuman;
+    }
+    if (han >= HAN_SANBAIMAN) {
+        return ScoreLevel.Sanbaiman;
+    }
+    if (han >= HAN_BAIMAN) {
+        return ScoreLevel.Baiman;
+    }
+    if (han >= HAN_HANEMAN) {
+        return ScoreLevel.Haneman;
+    }
+    if (han >= HAN_MANGAN || basePoints >= BASE_SCORE_LIMIT) {
+        return ScoreLevel.Mangan;
+    }
+    return ScoreLevel.Normal;
+}
+/**
+ * 点数レベルに対応する基本点を取得する
+ *
+ * @param level 点数レベル
+ * @returns 基本点（Normal の場合は null）
+ */
+function getLimitBasePoints(level) {
+    switch (level) {
+        case ScoreLevel.DoubleYakuman:
+            return SCORE_BASE_YAKUMAN * 2;
+        case ScoreLevel.Yakuman:
+            return SCORE_BASE_YAKUMAN;
+        case ScoreLevel.Sanbaiman:
+            return SCORE_BASE_SANBAIMAN;
+        case ScoreLevel.Baiman:
+            return SCORE_BASE_BAIMAN;
+        case ScoreLevel.Haneman:
+            return SCORE_BASE_HANEMAN;
+        case ScoreLevel.Mangan:
+            return SCORE_BASE_MANGAN;
+        case ScoreLevel.Normal:
+            return null;
+    }
+}
+/**
+ * 点数計算用コンテキストを作成する
+ *
+ * @param tehai 手牌 (14枚)
+ * @param config 点数計算の設定
+ * @returns 点数計算用コンテキスト
+ */
+function createScoreContext(tehai, config) {
+    return {
+        isMenzen: isMenzen(tehai),
+        agariHai: config.agariHai,
+        bakaze: config.bakaze,
+        jikaze: config.jikaze,
+        isTsumo: config.isTsumo,
+        isOya: config.jikaze === HaiKind.Ton,
+        doraMarkers: config.doraMarkers,
+        ...(config.uraDoraMarkers ? { uraDoraMarkers: config.uraDoraMarkers } : {}),
+    };
+}
+/**
+ * 手牌とコンテキストから点数を計算する（公開API）
+ *
+ * 手牌の構造解析を行い、最も高点となる解釈を採用して点数を返します。
+ *
+ * 注: 同一手牌で「翻数が高いが符が低い解釈」と「翻数が低いが符が高い解釈」が
+ * 両立するケースは実質的に存在しないため、翻数最大の解釈を採用しています。
+ *
+ * @param tehai 手牌 (14枚)
+ * @param config 点数計算の設定 (場風、自風、ドラなど)
+ * @returns 点数計算結果
+ */
+export function calculateScoreForTehai(tehai, config) {
+    const context = createScoreContext(tehai, config);
+    const structuralInterpretations = getHouraStructures(tehai);
+    let bestResult = null;
+    let maxTotalPoints = -1;
+    for (const hand of structuralInterpretations) {
+        // 1. 役の判定
+        const yakuResult = detectYakuForStructure(hand, context);
+        const yakuHansu = yakuResult.reduce((sum, [, han]) => sum + han, 0);
+        // 役がない場合はこの構造は不成立
+        if (yakuHansu === 0)
+            continue;
+        // 2. 符の計算
+        const isPinfu = yakuResult.some(([name]) => name === "Pinfu");
+        const fuResult = calculateFu(hand, context, isPinfu);
+        // 3. ドラの計算
+        const dora = countDora(tehai, context.doraMarkers);
+        // 4. 点数計算
+        const result = calculateScoreFromHanAndFu(yakuHansu, fuResult, dora, context);
+        const total = getPaymentTotal(result.payment);
+        if (total > maxTotalPoints) {
+            maxTotalPoints = total;
+            bestResult = result;
+        }
+    }
+    if (!bestResult) {
+        throw new NoYakuError();
+    }
+    return bestResult;
+}
+/**
+ * 基本的な点数計算ロジック (内部用・テスト用)
+ */
+export function calculateScoreFromHanAndFu(yakuHansu, fuResult, dora, context) {
+    const totalHan = yakuHansu + dora;
+    const fu = fuResult.total;
+    // 基本点の計算
+    const rawBasePoints = calculateBasePoints(fu, totalHan);
+    // 点数レベルの判定
+    const scoreLevel = getScoreLevel(totalHan, rawBasePoints);
+    // 満貫以上なら固定の基本点、それ以外は計算値を使用
+    const basePoints = getLimitBasePoints(scoreLevel) ?? rawBasePoints;
+    // 支払い計算
+    const payment = calculatePayment(basePoints, context);
+    return {
+        han: totalHan,
+        fu: fu,
+        scoreLevel,
+        payment,
+    };
+}
+/**
+ * 基本点から支払い情報を計算する
+ */
+function calculatePayment(basePoints, context) {
+    if (context.isTsumo) {
+        if (context.isOya) {
+            // 親ツモ: オール (基本点 * 2)
+            const allPay = ceil100(basePoints * 2);
+            return { type: "oyaTsumo", amount: allPay };
+        }
+        else {
+            // 子ツモ: 親の支払い = 基本点 * 2, 子の支払い = 基本点 * 1
+            const parentPay = ceil100(basePoints * 2);
+            const childPay = ceil100(basePoints * 1);
+            return { type: "koTsumo", amount: [childPay, parentPay] };
+        }
+    }
+    else {
+        // ロン和了
+        if (context.isOya) {
+            // 親ロン: 基本点 * 6
+            const pay = ceil100(basePoints * 6);
+            return { type: "ron", amount: pay };
+        }
+        else {
+            // 子ロン: 基本点 * 4
+            const pay = ceil100(basePoints * 4);
+            return { type: "ron", amount: pay };
+        }
+    }
+}

package/dist/features/score/lib/fu/constants.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 符計算に関する定数定義
+ */
+export declare const FU_BASE: {
+    readonly NORMAL: 20;
+    readonly CHIITOITSU: 25;
+    readonly KOKUSHI: 20;
+};
+export declare const FU_AGARI: {
+    readonly TSUMO: 2;
+    readonly MENZEN_RON: 10;
+};
+export declare const FU_JANTOU: {
+    readonly YAKUHAI: 2;
+    readonly DOUBLE_WIND_CAP: 2;
+};
+export declare const FU_MACHI: {
+    readonly KANCHAN: 2;
+    readonly PENCHAN: 2;
+    readonly TANKI: 2;
+    readonly RYANMEN: 0;
+    readonly SHANPON: 0;
+};
+export declare const FU_KOUTSU: {
+    readonly SUUPAI_OPEN: 2;
+    readonly SUUPAI_CLOSED: 4;
+    readonly YAOCHU_OPEN: 4;
+    readonly YAOCHU_CLOSED: 8;
+};
+export declare const FU_KANTSU: {
+    readonly SUUPAI_OPEN: 8;
+    readonly SUUPAI_CLOSED: 16;
+    readonly YAOCHU_OPEN: 16;
+    readonly YAOCHU_CLOSED: 32;
+};
+export declare const FU_PINFU_TSUMO = 20;
+export declare const FU_OPEN_PINFU_GLAZE = 30;

package/dist/features/score/lib/fu/constants.js

@@ -0,0 +1,45 @@
+/**
+ * 符計算に関する定数定義
+ */
+// 符底 (FuTei)
+export const FU_BASE = {
+    NORMAL: 20,
+    CHIITOITSU: 25,
+    KOKUSHI: 20, // 便宜上
+};
+// 和了符 (AgariFu)
+export const FU_AGARI = {
+    TSUMO: 2,
+    MENZEN_RON: 10,
+};
+// 雀頭符 (JantouFu)
+export const FU_JANTOU = {
+    YAKUHAI: 2,
+    // 連風牌の扱い（設定により4符または2符）
+    DOUBLE_WIND_CAP: 2,
+};
+// 待ち符 (MachiFu)
+export const FU_MACHI = {
+    KANCHAN: 2,
+    PENCHAN: 2,
+    TANKI: 2,
+    RYANMEN: 0,
+    SHANPON: 0,
+};
+// 面子符 (MentsuFu)
+// [Yaochu/Suupai]_[Open/Closed]
+export const FU_KOUTSU = {
+    SUUPAI_OPEN: 2,
+    SUUPAI_CLOSED: 4,
+    YAOCHU_OPEN: 4,
+    YAOCHU_CLOSED: 8,
+};
+export const FU_KANTSU = {
+    SUUPAI_OPEN: 8,
+    SUUPAI_CLOSED: 16,
+    YAOCHU_OPEN: 16,
+    YAOCHU_CLOSED: 32,
+};
+// 例外処理用定数
+export const FU_PINFU_TSUMO = 20;
+export const FU_OPEN_PINFU_GLAZE = 30; // 喰いタン平和形などの20符切り上げ

package/dist/features/score/lib/fu/index.d.ts

@@ -0,0 +1,11 @@
+import type { HouraStructure, HouraContext } from "../../../yaku/types";
+import type { FuResult } from "./types";
+/**
+ * 手牌の符を計算する (calculateFu)
+ *
+ * @param hand 和了形の手牌構造
+ * @param context 和了コンテキスト (場風、自風、ツモ/ロン等)
+ * @param isPinfu 平和が成立しているかどうか (平和ツモ20符例外の適用に必要)
+ * @returns 符計算結果
+ */
+export declare function calculateFu(hand: HouraStructure, context: HouraContext, isPinfu?: boolean): FuResult;

package/dist/features/score/lib/fu/index.js

@@ -0,0 +1,23 @@
+import { calculateChiitoitsuFu } from "./lib/chiitoitsu";
+import { calculateKokushiFu } from "./lib/kokushi";
+import { calculateMentsuFu } from "./lib/mentsu";
+/**
+ * 手牌の符を計算する (calculateFu)
+ *
+ * @param hand 和了形の手牌構造
+ * @param context 和了コンテキスト (場風、自風、ツモ/ロン等)
+ * @param isPinfu 平和が成立しているかどうか (平和ツモ20符例外の適用に必要)
+ * @returns 符計算結果
+ */
+export function calculateFu(hand, context, isPinfu = false) {
+    // 1. 七対子 (ChiiToitsu)
+    if (hand.type === "Chiitoitsu") {
+        return calculateChiitoitsuFu();
+    }
+    // 2. 国士無双 (Kokushi)
+    if (hand.type === "Kokushi") {
+        return calculateKokushiFu();
+    }
+    // 3. 面子手 (Mentsu)
+    return calculateMentsuFu(hand, context, isPinfu);
+}

package/dist/features/score/lib/fu/lib/chiitoitsu.d.ts

@@ -0,0 +1,5 @@
+import type { FuResult } from "../types";
+/**
+ * 七対子の符を計算する
+ */
+export declare function calculateChiitoitsuFu(): FuResult;

package/dist/features/score/lib/fu/lib/chiitoitsu.js

@@ -0,0 +1,17 @@
+import { FU_BASE } from "../constants";
+/**
+ * 七対子の符を計算する
+ */
+export function calculateChiitoitsuFu() {
+    const details = {
+        base: FU_BASE.CHIITOITSU,
+        mentsu: 0,
+        jantou: 0,
+        machi: 0,
+        agari: 0,
+    };
+    return {
+        total: FU_BASE.CHIITOITSU,
+        details,
+    };
+}

package/dist/features/score/lib/fu/lib/kokushi.d.ts

@@ -0,0 +1,6 @@
+import type { FuResult } from "../types";
+/**
+ * 国士無双の符を計算する
+ * (点数計算上は役満固定だが、便宜上符底のみを返す)
+ */
+export declare function calculateKokushiFu(): FuResult;

package/dist/features/score/lib/fu/lib/kokushi.js

@@ -0,0 +1,18 @@
+import { FU_BASE } from "../constants";
+/**
+ * 国士無双の符を計算する
+ * (点数計算上は役満固定だが、便宜上符底のみを返す)
+ */
+export function calculateKokushiFu() {
+    const details = {
+        base: FU_BASE.KOKUSHI,
+        mentsu: 0,
+        jantou: 0,
+        machi: 0,
+        agari: 0,
+    };
+    return {
+        total: FU_BASE.KOKUSHI,
+        details,
+    };
+}

package/dist/features/score/lib/fu/lib/mentsu.d.ts

@@ -0,0 +1,11 @@
+import type { FuResult } from "../types";
+import type { HouraContext } from "../../../../yaku/types";
+import type { MentsuHouraStructure } from "../../../../yaku/types";
+/**
+ * 面子手の符を計算する
+ *
+ * @param hand 面子手の構造
+ * @param context 和了コンテキスト
+ * @param isPinfu 平和成立フラグ
+ */
+export declare function calculateMentsuFu(hand: MentsuHouraStructure, context: HouraContext, isPinfu: boolean): FuResult;

package/dist/features/score/lib/fu/lib/mentsu.js

@@ -0,0 +1,136 @@
+import { isYaochu } from "../../../../../core/hai";
+import { HaiKind } from "../../../../../types";
+import { classifyMachi } from "../../../../../core/machi";
+import { FU_BASE, FU_KOUTSU, FU_KANTSU, FU_JANTOU, FU_MACHI, FU_AGARI, FU_PINFU_TSUMO, FU_OPEN_PINFU_GLAZE, } from "../constants";
+/** 有効な符の値 */
+const VALID_FU_VALUES = [
+    20, 25, 30, 40, 50, 60, 70, 80, 90, 100, 110,
+];
+/**
+ * 数値を Fu 型に変換する（無効な値の場合はエラー）
+ */
+function toFu(value) {
+    const fu = VALID_FU_VALUES.find((f) => f === value);
+    if (fu === undefined) {
+        throw new Error(`Invalid fu value: ${value}`);
+    }
+    return fu;
+}
+/**
+ * 面子手の符を計算する
+ *
+ * @param hand 面子手の構造
+ * @param context 和了コンテキスト
+ * @param isPinfu 平和成立フラグ
+ */
+export function calculateMentsuFu(hand, context, isPinfu) {
+    const details = {
+        base: FU_BASE.NORMAL,
+        mentsu: 0,
+        jantou: 0,
+        machi: 0,
+        agari: 0,
+    };
+    // 1. 面子符 (MentsuFu)
+    for (const mentsu of hand.fourMentsu) {
+        let fu = 0;
+        const isYaochuMentsu = isYaochu(mentsu.hais[0]);
+        if (mentsu.type === "Koutsu") {
+            // 刻子
+            const openFu = isYaochuMentsu
+                ? FU_KOUTSU.YAOCHU_OPEN
+                : FU_KOUTSU.SUUPAI_OPEN;
+            const closedFu = isYaochuMentsu
+                ? FU_KOUTSU.YAOCHU_CLOSED
+                : FU_KOUTSU.SUUPAI_CLOSED;
+            fu = closedFu;
+            // 明刻判定
+            let isOpen = !!mentsu.furo;
+            if (!isOpen && !context.isTsumo) {
+                // ロン和了で、かつその牌を含む刻子であれば明刻扱い
+                if (mentsu.hais.includes(context.agariHai)) {
+                    isOpen = true;
+                }
+            }
+            if (isOpen) {
+                fu = openFu;
+            }
+            details.mentsu += fu;
+        }
+        else if (mentsu.type === "Kantsu") {
+            // 槓子
+            const openFu = isYaochuMentsu
+                ? FU_KANTSU.YAOCHU_OPEN
+                : FU_KANTSU.SUUPAI_OPEN;
+            const closedFu = isYaochuMentsu
+                ? FU_KANTSU.YAOCHU_CLOSED
+                : FU_KANTSU.SUUPAI_CLOSED;
+            fu = closedFu;
+            if (mentsu.furo) {
+                fu = openFu;
+            }
+            details.mentsu += fu;
+        }
+    }
+    // 2. 雀頭符 (JantouFu)
+    const headHai = hand.jantou.hais[0];
+    let jantouFu = 0;
+    if (headHai === HaiKind.Haku ||
+        headHai === HaiKind.Hatsu ||
+        headHai === HaiKind.Chun) {
+        jantouFu += FU_JANTOU.YAKUHAI;
+    }
+    if (headHai === context.bakaze) {
+        jantouFu += FU_JANTOU.YAKUHAI;
+    }
+    if (headHai === context.jikaze) {
+        jantouFu += FU_JANTOU.YAKUHAI;
+    }
+    // 連風牌の加算上限
+    if (jantouFu > FU_JANTOU.DOUBLE_WIND_CAP) {
+        jantouFu = FU_JANTOU.DOUBLE_WIND_CAP;
+    }
+    details.jantou = jantouFu;
+    // 3. 待ち符 (MachiFu)
+    const machiType = classifyMachi(hand, context.agariHai);
+    if (machiType === "Kanchan")
+        details.machi = FU_MACHI.KANCHAN;
+    else if (machiType === "Penchan")
+        details.machi = FU_MACHI.PENCHAN;
+    else if (machiType === "Tanki")
+        details.machi = FU_MACHI.TANKI;
+    else
+        details.machi = 0; // Ryanmen, Shanpon
+    // 4. 和了符 (AgariFu)
+    if (context.isTsumo) {
+        if (!isPinfu) {
+            details.agari = FU_AGARI.TSUMO;
+        }
+    }
+    else {
+        if (context.isMenzen) {
+            details.agari = FU_AGARI.MENZEN_RON;
+        }
+    }
+    // 合計
+    let sum = details.base +
+        details.mentsu +
+        details.jantou +
+        details.machi +
+        details.agari;
+    // 平和ツモ例外
+    if (isPinfu && context.isTsumo) {
+        return { total: FU_PINFU_TSUMO, details };
+    }
+    // 切り上げ (喰いタン平和形など)
+    if (sum === 20 && !context.isTsumo && !context.isMenzen) {
+        sum = FU_OPEN_PINFU_GLAZE;
+    }
+    else {
+        sum = Math.ceil(sum / 10) * 10;
+    }
+    return {
+        total: toFu(sum),
+        details,
+    };
+}

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

@@ -0,0 +1,56 @@
+import type { Fu } from "../../../../types";
+/**
+ * 符の構成要素 (FuDetails)
+ *
+ * 符計算の内訳を保持するインターフェース。
+ */
+export interface FuDetails {
+    /**
+     * 符底 (FuTei)
+     *
+     * 一般的な和了形: 20符
+     * 七対子: 25符
+     */
+    readonly base: 20 | 25;
+    /**
+     * 面子符の合計 (MentsuFu)
+     *
+     * 刻子・槓子による加算符。順子は0符。
+     */
+    readonly mentsu: number;
+    /**
+     * 雀頭符 (JantouFu)
+     *
+     * 役牌の対子による加算符。
+     */
+    readonly jantou: number;
+    /**
+     * 待ち符 (MachiFu)
+     *
+     * 単騎・嵌張・辺張待ちによる加算符（2符）。
+     */
+    readonly machi: number;
+    /**
+     * 和了符 (AgariFu)
+     *
+     * ツモ和了: 2符
+     * 門前ロン: 10符
+     */
+    readonly agari: number;
+}
+/**
+ * 符計算結果 (FuResult)
+ */
+export interface FuResult {
+    /**
+     * 最終的な符数 (Total)
+     *
+     * 内訳の合計を10符単位で切り上げたもの。
+     * (例: 22符 -> 30符)
+     */
+    readonly total: Fu;
+    /**
+     * 計算の内訳
+     */
+    readonly details: FuDetails;
+}

package/dist/features/score/lib/fu/types.js

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