@pai-forge/riichi-mahjong 0.1.0 → 0.3.0

package/README.md

@@ -1,5 +1,8 @@
 # Riichi Mahjong Library
 
+[![npm version](https://img.shields.io/npm/v/@pai-forge/riichi-mahjong)](https://www.npmjs.com/package/@pai-forge/riichi-mahjong)
+
+
 リーチ麻雀のロジック（シャンテン数計算、点数計算など）を提供するTypeScriptライブラリです。
 
 > [!NOTE]

package/dist/core/tehai.d.ts

@@ -18,6 +18,8 @@ export declare function validateTehai13<T extends HaiKindId | HaiId>(tehai: Teha
  * 手牌がTehai14（有効枚数14枚）であるか検証します。
  * @throws {ShoushaiError} 枚数が不足している場合
  * @throws {TahaiError} 枚数が超過している場合
+ * @throws {InvalidHaiQuantityError} 同一種の牌が5枚以上ある場合
+ * @throws {DuplicatedHaiIdError} 物理牌モードでIDが重複している場合
  */
 export declare function validateTehai14<T extends HaiKindId | HaiId>(tehai: Tehai<T>): void;
 /**
@@ -26,6 +28,8 @@ export declare function validateTehai14<T extends HaiKindId | HaiId>(tehai: Teha
  *
  * @throws {ShoushaiError} 枚数が不足している場合 (< 13)
  * @throws {TahaiError} 枚数が超過している場合 (> 14)
+ * @throws {InvalidHaiQuantityError} 同一種の牌が5枚以上ある場合
+ * @throws {DuplicatedHaiIdError} 物理牌モードでIDが重複している場合
  */
 export declare function validateTehai<T extends HaiKindId | HaiId>(tehai: Tehai<T>): void;
 /**

package/dist/core/tehai.js

@@ -1,4 +1,4 @@
-import { ShoushaiError, TahaiError } from "../errors";
+import { DuplicatedHaiIdError, InvalidHaiQuantityError, ShoushaiError, TahaiError, } from "../errors";
 /**
  * 手牌の有効枚数を計算します。
  * 副露（槓子含む）は一律3枚として計算します。
@@ -30,11 +30,14 @@ export function validateTehai13(tehai) {
     if (count > 13) {
         throw new TahaiError();
     }
+    validateHaiConsistency(tehai);
 }
 /**
  * 手牌がTehai14（有効枚数14枚）であるか検証します。
  * @throws {ShoushaiError} 枚数が不足している場合
  * @throws {TahaiError} 枚数が超過している場合
+ * @throws {InvalidHaiQuantityError} 同一種の牌が5枚以上ある場合
+ * @throws {DuplicatedHaiIdError} 物理牌モードでIDが重複している場合
  */
 export function validateTehai14(tehai) {
     const count = calculateTehaiCount(tehai);
@@ -44,6 +47,7 @@ export function validateTehai14(tehai) {
     if (count > 14) {
         throw new TahaiError();
     }
+    validateHaiConsistency(tehai);
 }
 /**
  * 手牌がTehai13またはTehai14（有効枚数が13または14枚）であるか検証します。
@@ -51,6 +55,8 @@ export function validateTehai14(tehai) {
  *
  * @throws {ShoushaiError} 枚数が不足している場合 (< 13)
  * @throws {TahaiError} 枚数が超過している場合 (> 14)
+ * @throws {InvalidHaiQuantityError} 同一種の牌が5枚以上ある場合
+ * @throws {DuplicatedHaiIdError} 物理牌モードでIDが重複している場合
  */
 export function validateTehai(tehai) {
     const count = calculateTehaiCount(tehai);
@@ -60,6 +66,69 @@ export function validateTehai(tehai) {
     if (count > 14) {
         throw new TahaiError();
     }
+    validateHaiConsistency(tehai);
+}
+/**
+ * 手牌の整合性を検証します。
+ * - 物理的な牌ID (`HaiId`) が使われている場合、重複チェックを行います。
+ * - 牌種ID (`HaiKindId`) の場合（または変換後）、同一牌種が5枚以上ないかチェックします。
+ *
+ * @throws {DuplicatedHaiIdError}
+ * @throws {InvalidHaiQuantityError}
+ */
+function validateHaiConsistency(tehai) {
+    const allHais = [
+        ...tehai.closed,
+        ...tehai.exposed.flatMap((m) => m.hais),
+    ];
+    // 1. Check for physical HaiId usage (any id > 33)
+    // HaiKindId is 0-33. Any value > 33 implies HaiId (0-135).
+    // Note: Low HaiIds (0-33) are ambiguous, but if mix of high and low exists, it's HaiId.
+    // If only low values exist, we can't strictly distinguish, but treating as KindId is safe
+    // unless the user provided [0, 0] intending HaiId 0 and HaiId 0.
+    // However, normally HaiKindId 0 is ManZu1.
+    // Strategy: If MAX(id) > 33, treat as HaiId.
+    const isHaiIdMode = allHais.some((h) => h > 33);
+    if (isHaiIdMode) {
+        // Check for duplicate HaiIds
+        const uniqueIds = new Set(allHais);
+        if (uniqueIds.size !== allHais.length) {
+            throw new DuplicatedHaiIdError();
+        }
+    }
+    // 2. Check for Kind quantity (max 4 per kind)
+    const counts = new Map();
+    for (const hai of allHais) {
+        // If HaiId mode, convert to KindId
+        // If KindId mode, use as is
+        // import { haiIdToKindId } from "./hai"; <--- Need to import or implement logic
+        // Since we are in core/tehai, and core/hai depends on types.
+        // Let's defer strict conversion.
+        // For now, assume generic T validation behavior.
+        // But we need `haiIdToKindId`.
+        // Let's implement logic inline or use import.
+        // Circular dependency risk? core/tehai -> core/hai.
+        // core/hai imports types. core/tehai imports types. Should be fine.
+        // But I need to import it at top of file.
+        // Using inline logic to avoid circular deps if any (though likely safe)
+        // 0-35 -> 0-8, etc.
+        let kind = hai;
+        if (hai > 33) {
+            if (hai < 36)
+                kind = Math.floor(hai / 4);
+            else if (hai < 72)
+                kind = Math.floor((hai - 36) / 4) + 9;
+            else if (hai < 108)
+                kind = Math.floor((hai - 72) / 4) + 18;
+            else
+                kind = Math.floor((hai - 108) / 4) + 27;
+        }
+        const current = counts.get(kind) ?? 0;
+        if (current + 1 > 4) {
+            throw new InvalidHaiQuantityError();
+        }
+        counts.set(kind, current + 1);
+    }
 }
 /**
  * Type Guard for Tehai13

package/dist/errors.d.ts

@@ -38,3 +38,46 @@ export declare class MahjongArgumentError extends MahjongError {
      */
     constructor(message: string);
 }
+/**
+ * 牌IDが重複している場合のエラー
+ * (物理的な牌IDは一意である必要があります)
+ */
+export declare class DuplicatedHaiIdError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message?: string);
+}
+/**
+ * 牌の枚数が不正な場合のエラー
+ * (同種の牌は最大4枚までです)
+ */
+export declare class InvalidHaiQuantityError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message?: string);
+}
+/**
+ * チョンボ（錯和）の基底エラークラス
+ *
+ * 不正な和了宣言に関するエラーの基底クラス。
+ * 具体的なチョンボ種別（役なし、フリテン等）はサブクラスで定義する。
+ */
+export declare class ChomboError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message?: string);
+}
+/**
+ * 役なし和了のエラー
+ *
+ * 和了形は成立しているが、役が一つも成立していない場合にスローされます。
+ */
+export declare class NoYakuError extends ChomboError {
+    /**
+     *
+     */
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -56,3 +56,62 @@ export class MahjongArgumentError extends MahjongError {
         Object.setPrototypeOf(this, MahjongArgumentError.prototype);
     }
 }
+/**
+ * 牌IDが重複している場合のエラー
+ * (物理的な牌IDは一意である必要があります)
+ */
+export class DuplicatedHaiIdError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message = "牌IDが重複しています。") {
+        super(message);
+        this.name = "DuplicatedHaiIdError";
+        Object.setPrototypeOf(this, DuplicatedHaiIdError.prototype);
+    }
+}
+/**
+ * 牌の枚数が不正な場合のエラー
+ * (同種の牌は最大4枚までです)
+ */
+export class InvalidHaiQuantityError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message = "同種の牌が5枚以上存在します。") {
+        super(message);
+        this.name = "InvalidHaiQuantityError";
+        Object.setPrototypeOf(this, InvalidHaiQuantityError.prototype);
+    }
+}
+/**
+ * チョンボ（錯和）の基底エラークラス
+ *
+ * 不正な和了宣言に関するエラーの基底クラス。
+ * 具体的なチョンボ種別（役なし、フリテン等）はサブクラスで定義する。
+ */
+export class ChomboError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message = "不正な和了です。") {
+        super(message);
+        this.name = "ChomboError";
+        Object.setPrototypeOf(this, ChomboError.prototype);
+    }
+}
+/**
+ * 役なし和了のエラー
+ *
+ * 和了形は成立しているが、役が一つも成立していない場合にスローされます。
+ */
+export class NoYakuError extends ChomboError {
+    /**
+     *
+     */
+    constructor(message = "役が成立していません。") {
+        super(message);
+        this.name = "NoYakuError";
+        Object.setPrototypeOf(this, NoYakuError.prototype);
+    }
+}

package/dist/features/machi/index.js

@@ -1,3 +1,4 @@
+import { countHaiKind } from "../../core/tehai";
 import { calculateMentsuTeShanten } from "../shanten";
 /**
  * 手牌の受け入れ（有効牌）を計算する。
@@ -9,10 +10,20 @@ import { calculateMentsuTeShanten } from "../shanten";
 export function getUkeire(tehai) {
     const currentShanten = calculateMentsuTeShanten(tehai);
     const ukeireList = [];
+    // 手牌の全ての牌（純手牌 + 副露）をカウント
+    const allHais = [
+        ...tehai.closed,
+        ...tehai.exposed.flatMap((m) => m.hais),
+    ];
+    const haiCounts = countHaiKind(allHais);
     // 全34種の牌について、1枚加えてシャンテン数が下がるか試す
     for (let i = 0; i < 34; i++) {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const tile = i;
+        // 4枚使い切っている牌種はスキップ（山に残っていない）
+        if (haiCounts[tile] >= 4) {
+            continue;
+        }
         // 手牌のコピーを作成（副作用を防ぐため、常に新しいオブジェクトで試行）
         // Tehai13に1枚足すので、厳密にはTehai14として扱う必要があるが、
         // calculateMentsuTeShanten は Tehai<HaiKindId> を受け付けるので、

package/dist/features/points/constants.d.ts

@@ -5,17 +5,17 @@ export declare const SCORE_BASE_BAIMAN = 4000;
 export declare const SCORE_BASE_SANBAIMAN = 6000;
 export declare const SCORE_BASE_YAKUMAN = 8000;
 /**
- * 満貫以上の判定基準となる飜数
+ * 満貫以上の判定基準となる翻数
  *
- * "5飜" であれば符数に関わらず満貫以上が確定するため 5 を設定しています。
+ * "5翻" であれば符数に関わらず満貫以上が確定するため 5 を設定しています。
  *
- * Q: 4飜は満貫ではないのか？
- * A: 4飜でも符数が高ければ（40符以上など）満貫になりますが、以下のようなケースでは満貫（8000点）に届きません。
+ * Q: 4翻は満貫ではないのか？
+ * A: 4翻でも符数が高ければ（40符以上など）満貫になりますが、以下のようなケースでは満貫（8000点）に届きません。
  *    - 七対子 (25符): 6400点
  *    - 門前ツモ・愚形など (30符): 7900点 (※切り上げ満貫なしの場合)
  *    - 鳴き手・ロン (30符): 7700点 (※切り上げ満貫なしの場合)
  *
- *    そのため、4飜以下の場合は計算による基本点が基準値（2000）を超えたかどうかで判定します。
+ *    そのため、4翻以下の場合は計算による基本点が基準値（2000）を超えたかどうかで判定します。
  */
 export declare const HAN_MANGAN = 5;
 export declare const HAN_HANEMAN = 6;

package/dist/features/points/constants.js

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

package/dist/features/points/index.js

@@ -80,9 +80,9 @@ export function calculateBasicScore(yakuHansu, fuResult, dora, context) {
     let basePoints = fu * Math.pow(2, 2 + totalHan);
     let level = "Normal";
     // 満貫以上の判定
-    // 5飜以上 は満貫確定
-    // 4飜以下でも 基本点が2000を超えたら満貫 (切り上げ満貫採用なら1920->2000)
-    // ここでは厳密な計算 (2000以上) とする。※30符4飜は1920なのでNormal、60符3飜は1920、70符3飜(2240)は満貫
+    // 5翻以上 は満貫確定
+    // 4翻以下でも 基本点が2000を超えたら満貫 (切り上げ満貫採用なら1920->2000)
+    // ここでは厳密な計算 (2000以上) とする。※30符4翻は1920なのでNormal、60符3翻は1920、70符3翻(2240)は満貫
     if (totalHan >= HAN_YAKUMAN) {
         // 役満（数え役満）
         // ダブル役満等は呼び出し元でHandを判定して Han=26 とかに固定して渡してもらう想定

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

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

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 };
+        }
+    }
+}