texas-poker-core 1.4.31 → 1.4.32

package/README.md

@@ -182,7 +182,7 @@ async function drainAndConsumePendingFlow(
 | `RolesAssigned`          | `setPlayerRoles`                                                                   |
 | `HoleCardsDealt`         | `dealCards`                                                                        |
 | `HandStarted`            | `start` / `startPreflopWithJoiningBigBlinds`                                       |
-| `PostedJoiningBigBlinds` | 入座大盲汇总（`startPreflopWithJoiningBigBlinds` 恒一条；`PostBigBlind` 每次一条） |
+| `PostedJoiningBigBlinds` | 入座大盲汇总（`startPreflopWithJoiningBigBlinds` 至少一人入账时；`PostBigBlind` 每次一条） |
 | `BlindsPosted`           | 桌 SB/BB 贴盲后                                                                    |
 | `PlayerActed`            | 自愿行动 / 超时行动（盲注路径不发）                                                |
 | `PotUpdated`             | 每次入池后（紧跟对应 `PlayerActed` 或盲注行）                                      |
@@ -724,4 +724,6 @@ reject modulo bias
 同步 README 接入文档
 
 ## 1.4.31
-增加跑马摊牌事件
+增加跑马摊牌事件
+## 1.4.32
+增加 RunoutHandsRevealed 跑马亮底牌事件；无人须贴入座大盲时不发 PostedJoiningBigBlinds 空事件

package/dist/Controller/index.js

@@ -497,7 +497,7 @@ var Controller = /*#__PURE__*/function () {
     /**
      * 与 {@link start} 同属一手开局原子路径：先进入翻前帧并 `HandStarted`，再对 `joiningBigBlindUserIds`
      * 依次入账（跳过 SB/BB、环上不存在 id 忽略），其间每条入池后各一条 `PotUpdated`；
-     * 最后 **恒** 缓冲一条 {@link PostedJoiningBigBlinds}，`posts` 为本次所有入座大盲（无人须贴时为空数组）；
+     * 若至少一人入账则缓冲一条 {@link PostedJoiningBigBlinds}（`posts` 非空）；无人须贴则**不发**（与 {@link start} 事件序列一致）。
      * 再贴桌盲并 `transferControlTo(BB.getNext())`。
      * 业务应仅此入口处理「待贴入座大盲」，勿在 `start()` 后再穿插 `PostBigBlind`。
      */
@@ -523,12 +523,14 @@ var Controller = /*#__PURE__*/function () {
       } finally {
         _iterator.f();
       }
-      _classPrivateFieldGet(_handEvents, this).push({
-        type: 'PostedJoiningBigBlinds',
-        payload: _objectSpread(_objectSpread({}, _assertClassBrand(_Controller_brand, this, _eventMeta).call(this)), {}, {
-          posts: joiningPosts
-        })
-      });
+      if (joiningPosts.length > 0) {
+        _classPrivateFieldGet(_handEvents, this).push({
+          type: 'PostedJoiningBigBlinds',
+          payload: _objectSpread(_objectSpread({}, _assertClassBrand(_Controller_brand, this, _eventMeta).call(this)), {}, {
+            posts: joiningPosts
+          })
+        });
+      }
       _assertClassBrand(_Controller_brand, this, _postTableBlindsAndFirstPreflopActor).call(this);
     }
   }, {

package/dist/Texas/index.js

@@ -253,7 +253,7 @@ var Texas = /*#__PURE__*/function () {
 
     /**
      * 开始本手（含「入座大盲」）：与 {@link start} 相同前置条件；由 Core 原子完成
-     * `HandStarted` → 对 `joiningBigBlindUserIds` 贴入座大盲（跳过 SB/BB、未知 id 忽略）→ **恒** 一条 `PostedJoiningBigBlinds`（`posts` 汇总，无人须贴时为空数组）→ 桌盲 → `transferControlTo(BB.getNext())`。
+     * `HandStarted` → 对 `joiningBigBlindUserIds` 贴入座大盲（跳过 SB/BB、未知 id 忽略）→ 有人入账则 `PostedJoiningBigBlinds` → 桌盲 → `transferControlTo(BB.getNext())`。
      * 业务应消费本批领域事件并驱动 `pendingFlowOps`；勿再于 `start()` 后自行 `dispatchCommand(PostBigBlind)`。
      */
   }, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "texas-poker-core",
-  "version": "1.4.31",
+  "version": "1.4.32",
   "description": "德州扑克核心功能",
   "main": "dist/index.js",
   "types": "types/index.d.ts",

package/types/Controller/HandSettlement.d.ts

@@ -1,28 +0,0 @@
-import { Player } from '../Player';
-import { Poke, RankCategory, RankSignature } from '../Deck/constant';
-export type RankSettlementSnapshot = {
-    rankCategory?: RankCategory;
-    pokes: Poke[][];
-    rankStrength: number;
-    /** 与 `pokes[0]` 一致的最强牌签名（多人平分牌型时各赢家 bestFive 的签名相同）。 */
-    rankSignature?: RankSignature;
-};
-/** 单座摊牌评估（唯一数据源；`Player` 经 `Controller.getShowdownEvalForPlayer` 只读） */
-export type ShowdownPlayerEval = {
-    bestFiveCards: Poke[];
-    rankSignature: RankSignature;
-    rankStrength: number;
-    rankCategory: RankCategory;
-};
-/**
- * 摊牌结算：按 userId 存评估表，并汇总桌上最强牌型。
- * 与阶段机、控制权移交无关。
- */
-export declare class HandSettlement {
-    #private;
-    get snapshot(): RankSettlementSnapshot;
-    getPlayerEval(userId: number): ShowdownPlayerEval | undefined;
-    setPlayerEval(userId: number, evalData: ShowdownPlayerEval): void;
-    reset(): void;
-    settleFromCommonBoard(allSeatedPlayers: Player[], playersStillInShowdown: Player[], commonPokes: Poke[]): void;
-}

package/types/Controller/constants.d.ts

@@ -1,2 +0,0 @@
-import { StageEnum } from '.';
-export declare const stageMap: Map<StageEnum, string>;

package/types/Controller/index.d.ts

@@ -1,146 +0,0 @@
-/**
- * 控制本手阶段、奖池结算与领域事件缓冲。
- * 进街与下一位思考权不立即生效：写入 {@link Controller.#pendingFlowOps}，由业务调用
- * {@link applyPendingStageAdvance} / {@link flushPendingTurnHandoff}（或 {@link drainPendingFlowOpsSync}）消费。
- */
-import type { Role } from '../Player/constant';
-import type { ShowdownPlayerEval } from './HandSettlement';
-import type { PlayerHandSession } from '../playerSessionPorts';
-import type { HandDomainEvent, TurnEndedReason } from '../domain/handDomainEvents';
-import type { GameComponent, HandLifecycle, TexasErrorCallback } from '../gameContracts';
-import Pool from '../Pool';
-import Dealer from '../Dealer';
-import { Poke } from '../Deck/constant';
-import { Player } from '../Player';
-import { StageEnum, type Stage } from './stage';
-export { StageEnum, type Stage } from './stage';
-export type { HandLifecycle };
-/**
- * 流程队列项（FIFO）。
- * - `stage_advance`：一轮下注已结束，须再执行一条进街（含 `betting_round_complete` 或跑马路 `runout_reveal`）。
- * - `turn_handoff`：记录待交权目标；消费时才设置 `activePlayer` 并缓冲 `TurnOffered`。
- */
-export type PendingFlowOp = {
-    kind: 'stage_advance';
-} | {
-    kind: 'turn_handoff';
-    toUserId: number;
-};
-export type PendingFlowOpKind = PendingFlowOp['kind'];
-declare class Controller implements GameComponent, PlayerHandSession<Player> {
-    #private;
-    fail: TexasErrorCallback;
-    constructor(dealer: Dealer, pool: Pool, fail?: TexasErrorCallback);
-    /** 当前本手 id；未经过 `prepareHandTape` 时为 `null` */
-    get currentHandId(): string | null;
-    /**
-     * 为本手分配 `handId`、重置本手 `seq` 与事件缓冲；同一物理手上再次调用（如仅 `rearrange`）时为 no-op。
-     * 由 {@link Texas#setPlayerRoles} / {@link Texas#dealCards} 在写磁带前调用。
-     */
-    prepareHandTape(): void;
-    recordRolesAssigned(players: ReadonlyArray<{
-        userId: number;
-        name: string;
-        role: Role;
-        actionIndex: number;
-    }>): void;
-    recordHoleCardsDealt(byUserId: Record<number, Poke[]>): void;
-    /** 自上次 drain 以来本手产生的事件（取出后清空本手缓冲） */
-    drainHandEvents(): HandDomainEvent[];
-    get status(): HandLifecycle;
-    get defaultBets(): {
-        userId: number;
-        balance: number;
-        amount: number;
-    }[];
-    get stage(): StageEnum;
-    getShowdownEvalForPlayer(player: Player): ShowdownPlayerEval | undefined;
-    setShowdownEvalForPlayer(player: Player, evalData: ShowdownPlayerEval): void;
-    get activePlayer(): Player | null;
-    recordPlayerAction(player: Player, options: {
-        emitPot: boolean;
-    }): void;
-    recordPotUpdated(): void;
-    recordTurnOffered(player: Player): void;
-    recordTurnEnded(userId: number, reason: TurnEndedReason): void;
-    setPendingTurnEndedReason(reason: TurnEndedReason): void;
-    consumePendingTurnEndedReason(): TurnEndedReason | null;
-    recordPotAwarded(potTotal: number, allocations: Array<{
-        userId: number;
-        amount: number;
-    }>): void;
-    /**
-     * ② 结束条件（没人还能操作）：
-     * - 场上只剩 out / allIn（无 eligible）=> 直接结束（可能发生在任意街：多人全下）
-     * - 河牌圈且所有仍可行动玩家都不可 actionable（即便 status 仍为 eligible）=> 结束
-     */
-    shouldShowDown(): boolean;
-    /**
-     * 仅入队 `turn_handoff`，**不**设置 `activePlayer`、不调用 `getControl()`。
-     * 下一家的 `TurnOffered` 在 {@link flushPendingTurnHandoff} 消费队头时进入缓冲。
-     */
-    transferControlTo(player: Player | null): undefined;
-    clearActivePlayerAfterAction(player: Player): void;
-    /**
-     * 循环：队头为 `stage_advance` 则 {@link applyPendingStageAdvance}，否则 {@link flushPendingTurnHandoff}，直至队列为空。
-     * 单测 / 模拟器「零节拍」跑通一手时使用；生产环境通常由业务在 sleep 之间逐步消费。
-     */
-    drainPendingFlowOpsSync(): void;
-    /** 返回队列快照，不修改队列。 */
-    getPendingFlowOps(): PendingFlowOp[];
-    /**
-     * 当且仅当：全员本轮不可再行动 **且** 当前街仍可进到下一街（未到河牌）。
-     * 为 true 时 {@link Player.transferControl} 会 {@link requestDeferredStageAdvance} 而非同步进街。
-     */
-    canDeferBettingRoundStageAdvance(): boolean;
-    /** 将「待进街」入队；实际推进由 {@link applyPendingStageAdvance} 执行。 */
-    requestDeferredStageAdvance(): void;
-    /**
-     * 消费队头 `stage_advance`（否则抛 `CTRL_FLOW_PENDING_MISMATCH`）。
-     * - 非跑马路：`#performBettingRoundStageAdvance` → `StageAdvanced(betting_round_complete)` → 再入队首位行动者的 `turn_handoff`。
-     * - `#runoutMode`：`#applyOneRunoutRevealStep` → `StageAdvanced(runout_reveal)`；到河牌时顺带 settle、`HandEnded(showdown)`。
-     */
-    applyPendingStageAdvance(): void;
-    /**
-     * 队头为 `turn_handoff` 时 shift，并在此刻真正设置 `activePlayer` 与发出 `TurnOffered`。
-     * 队头类型不符、或目标玩家缺失时 **静默 return**（不抛错）。
-     */
-    flushPendingTurnHandoff(): void;
-    /**
-     * 尝试收局。返回 `true` 表示本方法已处理终局逻辑（或已入队跑马路，不再向下传递控制权）。
-     * - 独赢弃牌：同步 settle + `HandEnded(fold_win)`。
-     * - 摊牌且 **非河牌**：`#runoutMode`、多条 `stage_advance` 入队、`resetActivePlayer`，**无**当场 `HandEnded`。
-     * - 摊牌且 **已在河牌**：同步 settle + `HandEnded(showdown)`。
-     */
-    tryToEndGame(): boolean;
-    getCommonPokes(currentStage: Stage, endStage: Stage): Poke[];
-    /** 当前手牌阶段下已发出的公牌（翻前 → `#hand.stage`）。 */
-    getRevealedPokes(): Poke[];
-    /**
-     * 中途入座贴大盲：翻前、非当前 `activePlayer`、本街 `currentStageTotalAmount === 0`、且玩家仍为 `eligible`。
-     * 入池额 `min(桌大盲, 余额)`，与开局盲注路径一致；**不**调用 `completeBettingTurn`、不改变当前思考权。
-     */
-    postBigBlindForJoiningPlayer(player: Player): void;
-    takeActionInPreFlop(): void;
-    /**
-     * 进入本手街道阶段：须在 {@link prepareHandTape} 之后调用；不清空已缓冲的 `RolesAssigned` / `HoleCardsDealt`。
-     * 写入 `HandStarted`、贴盲与 **`pendingFlowOps` / 跑马路状态**，再 `transferControlTo`（首人思考权先入队，待业务 flush）。
-     */
-    start(): void;
-    /**
-     * 与 {@link start} 同属一手开局原子路径：先进入翻前帧并 `HandStarted`，再对 `joiningBigBlindUserIds`
-     * 依次入账（跳过 SB/BB、环上不存在 id 忽略），其间每条入池后各一条 `PotUpdated`；
-     * 最后 **恒** 缓冲一条 {@link PostedJoiningBigBlinds}，`posts` 为本次所有入座大盲（无人须贴时为空数组）；
-     * 再贴桌盲并 `transferControlTo(BB.getNext())`。
-     * 业务应仅此入口处理「待贴入座大盲」，勿在 `start()` 后再穿插 `PostBigBlind`。
-     */
-    startPreflopWithJoiningBigBlinds(joiningBigBlindUserIds: ReadonlyArray<number>): void;
-    continue(): undefined;
-    settleRankingsThroughStage(throughStage: Stage): void;
-    end(): undefined;
-    resetActivePlayer(): void;
-    reset(): void;
-    pause(): void;
-}
-export type { ShowdownPlayerEval } from './HandSettlement';
-export default Controller;

package/types/Controller/index.test.d.ts

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

package/types/Controller/stage.d.ts

@@ -1,9 +0,0 @@
-/** 公共牌推进阶段；独立文件避免 Player ↔ Controller 循环依赖 */
-export declare enum StageEnum {
-    PRE_FLOP = "pre_flop",
-    FLOP = "flop",
-    TURN = "turn",
-    RIVER = "river"
-}
-export type Stage = StageEnum;
-export declare const STAGE_ORDER: Stage[];

package/types/Dealer/DealerService.d.ts

@@ -1,47 +0,0 @@
-import type { Table } from './Table';
-import type { Poke } from '../Deck/constant';
-import type { TableStakes } from '../TableStakes';
-import type { GameComponent, TexasErrorCallback } from '../gameContracts';
-import Deck from '../Deck';
-import { Player } from '../Player';
-/**
- * 荷官侧流程：牌堆、角色分配、发牌、行动历史、桌面日志；依赖 {@link Table} 提供座位环与遍历。
- */
-export declare class DealerService implements GameComponent {
-    #private;
-    fail: TexasErrorCallback;
-    constructor(table: Table, deck: Deck, stakes: TableStakes, fail?: TexasErrorCallback, options?: {
-        maxTablePlayers?: number;
-    });
-    get actionHistory(): Player[];
-    get deck(): Deck;
-    /** 当前已发手牌与公牌快照（与牌堆对象分离） */
-    getPokes(): import("../Deck/DealtBoard").DealSnapshot;
-    get stakes(): TableStakes;
-    get lowestBetAmount(): number;
-    dealCards(): undefined;
-    /**
-     * 手牌唯一数据源为 {@link DealtBoard}；下标与发牌顺序一致（从庄家下家起绕桌一圈）。
-     */
-    getHoleCardsForPlayer(player: Player): Poke[];
-    setHoleCardsForPlayer(player: Player, pokes: readonly Poke[]): void;
-    addAction(player: Player): void;
-    initialRoles(buttonPlayer?: Player): undefined;
-    reArrangeRoles(): undefined;
-    rotateRolesForNewHand(): void;
-    /** @deprecated 请使用 {@link DealerService.initialRoles} */
-    setRoles(): void;
-    log(): void;
-    getPlayersStillInGame(): Player[];
-    changeButtonToNextPlayer(): undefined;
-    setButton(player: Player): void;
-    setOthers(): undefined;
-    /** 从庄家下家起绕桌一圈的玩家顺序（与行动序一致） */
-    getPlayersByActionSequence(): Player[];
-    resetCurrentStageTotalAmount(): void;
-    resetActionsOfPlayers(): void;
-    resetActionsHistory(): void;
-    reset(): void;
-    getTheFirstPlayerToAct(): Player | null;
-    getPlayersCanAct(): Player[];
-}

package/types/Dealer/Table.d.ts

@@ -1,38 +0,0 @@
-import type { TexasErrorCallback } from '../gameContracts';
-import { Player } from '../Player';
-/**
- * 环形座位：入座/离座、head/last、庄家位标记（仅引用，不负责 BTN/SB/BB 语义分配）。
- * 非法入座/离座通过 `fail` 抛出 {@link TexasError}，与 Room / Dealer 层 fail-fast 一致。
- */
-export declare class Table {
-    #private;
-    constructor(fail: TexasErrorCallback);
-    get count(): number;
-    get button(): Player | null;
-    /**
-     * 设置庄家位标记（仅引用，不写角色枚举）。
-     * 清空请用 {@link clearButtonSeat}，避免 `setButtonSeat(null)` 语义含糊。
-     */
-    setButtonSeat(player: Player): void;
-    /** 清空庄家位标记（例如桌上已无玩家） */
-    clearButtonSeat(): void;
-    get players(): Player[];
-    join(player: Player): void;
-    /**
-     * 将 `player` 顺时针插在 `predecessor` 与其原 `next` 之间（用于新玩家插在 **大盲下家** 一侧，与 post BB 叙事一致）。
-     * `predecessor` 须在环上且已有合法 `next`（至少两人环）。
-     */
-    joinAfter(predecessor: Player, player: Player): void;
-    remove(player: Player): void;
-    has(player: Player): boolean;
-    hasById(userId: number): boolean;
-    get(player: Player): Player | null;
-    getById(userId: number): Player | null;
-    forEach(callback: (p: Player, i: number) => void): void;
-    map<T>(callback: (p: Player, i: number) => T): T[];
-    every(callback: (p: Player, i: number) => boolean): boolean;
-    findReverse(callback: (p: Player) => boolean, from: Player | null): Player | null;
-    filter(callback: (p: Player, i: number) => boolean): Player[];
-    find(callback: (p: Player) => boolean): Player | null;
-    loop(callback: (p: Player, i: number) => void, startFrom?: Player | null | undefined): void;
-}

package/types/Dealer/index.d.ts

@@ -1,74 +0,0 @@
-import type { Poke } from '../Deck/constant';
-import type { PlayerDealerRing } from '../playerSessionPorts';
-import type { GameComponent, TexasErrorCallback } from '../gameContracts';
-import Deck from '../Deck';
-import { Table } from './Table';
-import { Player } from '../Player';
-import { TableStakes } from '../TableStakes';
-import { DealerService } from './DealerService';
-export { Table } from './Table';
-export { DealerService } from './DealerService';
-/**
- * 对外门面：组合 {@link Table}（座位环）与 {@link DealerService}（发牌与角色流程），保持原有 API。
- * 需要单独扩展座位逻辑或荷官逻辑时，可访问 `table` / `service`。
- */
-declare class Dealer implements GameComponent, PlayerDealerRing<Player> {
-    #private;
-    fail: TexasErrorCallback;
-    constructor(stakes: TableStakes | number, fail?: TexasErrorCallback, options?: {
-        maxTablePlayers?: number;
-    });
-    /** 环形座位与遍历；不含发牌与角色业务规则 */
-    get table(): Table;
-    /** 牌堆、角色、发牌、行动历史等 */
-    get service(): DealerService;
-    get actionHistory(): Player[];
-    get count(): number;
-    get button(): Player | null;
-    get deck(): Deck;
-    /** 已发手牌与公牌（由 DealerService 内 DealtBoard 持有，与 52 张牌堆分离） */
-    getPokes(): import("..").DealSnapshot;
-    /** 该玩家在 {@link DealtBoard} 中对应座位的手牌（Player 不再私有缓存） */
-    getHoleCardsForPlayer(player: Player): ("hj" | "h2" | "h3" | "h4" | "h5" | "h6" | "h7" | "h8" | "h9" | "ht" | "hq" | "hk" | "ha" | "s2" | "s3" | "s4" | "s5" | "s6" | "s7" | "s8" | "s9" | "st" | "sj" | "sq" | "sk" | "sa" | "d2" | "d3" | "d4" | "d5" | "d6" | "d7" | "d8" | "d9" | "dt" | "dj" | "dq" | "dk" | "da" | "c2" | "c3" | "c4" | "c5" | "c6" | "c7" | "c8" | "c9" | "ct" | "cj" | "cq" | "ck" | "ca")[];
-    setHoleCardsForPlayer(player: Player, pokes: readonly Poke[]): void;
-    get players(): Player[];
-    get stakes(): TableStakes;
-    /** 大盲注额；与 `stakes.bigBlind` 同义 */
-    get lowestBetAmount(): number;
-    dealCards(): void;
-    addAction(player: Player): void;
-    initialRoles(buttonPlayer?: Player): void;
-    reArrangeRoles(): void;
-    rotateRolesForNewHand(): void;
-    remove(player: Player): void;
-    /**
-     * @param options.insertAfter 若给定，则新座位插在**该玩家顺时针下家**一侧（房规：插在 **BB 之后** 时传大盲位玩家）。
-     */
-    join(player: Player, options?: {
-        insertAfter: Player;
-    }): void;
-    has(player: Player): boolean;
-    hasById(userId: number): boolean;
-    get(player: Player): Player | null;
-    getById(userId: number): Player | null;
-    log(): void;
-    getPlayersStillInGame(): Player[];
-    changeButtonToNextPlayer(): void;
-    setButton(player: Player): void;
-    setOthers(): void;
-    getPlayersByActionSequence(): Player[];
-    forEach(callback: (p: Player, i: number) => void): void;
-    map<T>(callback: (p: Player, i: number) => T): T[];
-    every(callback: (p: Player, i: number) => boolean): boolean;
-    resetCurrentStageTotalAmount(): void;
-    resetActionsOfPlayers(): void;
-    resetActionsHistory(): void;
-    reset(): void;
-    findReverse(callback: (p: Player) => boolean, from: Player | null): Player | null;
-    filter(callback: (p: Player, i: number) => boolean): Player[];
-    find(callback: (p: Player) => boolean): Player | null;
-    loop(callback: (p: Player, i: number) => void, startFrom?: Player | null): void;
-    getTheFirstPlayerToAct(): Player | null;
-    getPlayersCanAct(): Player[];
-}
-export default Dealer;

package/types/Dealer/index.test.d.ts

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

package/types/Deck/DealtBoard.d.ts

@@ -1,15 +0,0 @@
-import type { Poke } from './constant';
-export type DealSnapshot = {
-    handPokes: Poke[][];
-    commonPokes: Poke[];
-};
-/**
- * 上一手发牌结果（手牌矩阵 + 公牌），与 52 张牌堆 {@link Deck} 解耦。
- */
-export declare class DealtBoard {
-    #private;
-    capture(snapshot: DealSnapshot): void;
-    reset(): void;
-    getPokes(): DealSnapshot;
-    setHoleCardsAt(index: number, pokes: readonly Poke[]): void;
-}

package/types/Deck/constant.d.ts

@@ -1,30 +0,0 @@
-export declare const suits: readonly ["h", "s", "d", "c"];
-export declare const ranks: readonly ["2", "3", "4", "5", "6", "7", "8", "9", "t", "j", "q", "k", "a"];
-/**
- * h: 红心
- * s: 黑桃
- * d: 方块
- * c: 梅花
- */
-export type Suit = (typeof suits)[number];
-export type Rank = (typeof ranks)[number];
-/**
- * 扑克牌的存储 比如h2, h8
- */
-export type Poke = `${Suit}${Rank}`;
-/**
- * 2张手牌
- */
-export type HandPoke = Poke[];
-/** 牌型枚举（五张牌型的类型：高牌/一对/顺子…） */
-export type RankCategory = 'z' | 'y' | 'x' | 'w' | 'v' | 'u' | 't' | 's' | 'r' | 'q';
-/**
- * 牌力签名：首字符为牌型 (RankCategory)，后接可选数字段，如 "z" | "q14+13+12+11+9" | "w13+r7"
- */
-export type RankSignature = `${RankCategory}${string}`;
-/**
- * 花色format map
- */
-export declare const suitsMap: Map<"h" | "s" | "d" | "c", string>;
-export declare const rankCategoryMap: Map<RankCategory, string>;
-export declare const rankMap: (input: Rank) => number;

package/types/Deck/core.d.ts

@@ -1,9 +0,0 @@
-/**
- * 牌力相关入口：按职责拆分为 `format` / `handEvaluation` / `handCompare` / `handCombinations`，本文件保持向后兼容的聚合导出。
- */
-export { createStandardDeckPokes } from './standardDeck';
-export { formatterPoke } from './format';
-export { isStraight, getFiveCardCombinationIndices, allFiveCardHandsFromPool, getFiveCardsRankSignature } from './handEvaluation';
-export { compareFn, compareRankSignature, getStrengthFromRankSignature, getFiveCardsStrength, rankSignatureToRanks, rankSignatureToDisplayGroups } from './handCompare';
-export type { RankSignatureDisplayGroup } from './handCompare';
-export { getBestFiveCards, getBestPokesRankSignature } from './handCombinations';

package/types/Deck/core.test.d.ts

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

package/types/Deck/format.d.ts

@@ -1,5 +0,0 @@
-import { Poke } from './constant';
-/**
- * 展示用：将 Poke 格式化为可读字符串（与牌力计算无关）。
- */
-export declare const formatterPoke: (input: Poke[]) => string;

package/types/Deck/handCombinations.d.ts

@@ -1,6 +0,0 @@
-import { Poke } from './constant';
-/**
- * 手牌 + 公牌 → 最优五张、多人比较、最佳牌型信息（依赖 evaluation + compare）。
- */
-export declare function getBestFiveCards(handPokes: Poke[], commonPokes: Poke[]): Poke[];
-export declare function getBestPokesRankSignature(handPokes: Poke[][], commonPokes: Poke[]): `s${string}` | `t${string}` | `q${string}` | `z${string}` | `y${string}` | `x${string}` | `w${string}` | `v${string}` | `u${string}` | `r${string}`;

package/types/Deck/handCompare.d.ts

@@ -1,21 +0,0 @@
-import { Poke, Rank, RankSignature } from './constant';
-/**
- * 将 `RankSignature` 展开为五张牌的点数（`Rank`），与 `getFiveCardsRankSignature` 编码对称。
- * 顺子 wheel（`u5`/`y5`）为 5→A 展示顺序，A 在末位；Broadway 仍为 A→T。
- * `x`（四条）当前签名仅含四条点数，踢脚未编码，第五位为 `null`。
- */
-export declare function rankSignatureToRanks(rankSignature: RankSignature): (Rank | null)[];
-/** 供 UI 分组渲染：每组 `ranks` 为从左到右、已合并同点的连续张（与 `rankSignatureToRanks` 顺序一致）。 */
-export type RankSignatureDisplayGroup = {
-    ranks: Rank[];
-};
-/**
- * 将牌力签名映射为展示用分组（间距与样式由应用层决定）。
- * - `q`/`v`/`u`/`y`/`z`：每张一组；顺子 wheel 时 A 已在末位（见 `straightRanksFromMax`）。
- * - `r`/`s`/`t`/`w`/`x`：连续同点合并为一组。
- */
-export declare function rankSignatureToDisplayGroups(rankSignature: RankSignature): RankSignatureDisplayGroup[];
-export declare const compareFn: (a: Poke[], b: Poke[]) => number;
-export declare const compareRankSignature: (p1: string, p2: string) => number;
-export declare function getStrengthFromRankSignature(rankSignature: RankSignature): number;
-export declare function getFiveCardsStrength(input: Poke[]): number;

package/types/Deck/handEvaluation.d.ts

@@ -1,11 +0,0 @@
-import { Poke, Rank, RankSignature } from './constant';
-/**
- * 单副牌组合、顺子判定、五张牌型签名生成（不含两副牌之间的 compare）。
- */
-export declare const isStraight: (values: Rank[]) => {
-    result: boolean;
-    max: number;
-};
-export declare function getFiveCardCombinationIndices(n: number, k?: number): number[][];
-export declare function allFiveCardHandsFromPool(cards: Poke[]): Poke[][];
-export declare function getFiveCardsRankSignature(input: Poke[]): RankSignature;

package/types/Deck/index.d.ts

@@ -1,20 +0,0 @@
-import { type Poke } from './constant';
-/**
- * 52 张牌堆：生成、洗牌、按德州规则发手牌与公牌（含烧牌）。
- * 发牌结果由调用方写入 {@link DealtBoard}，本类不缓存手牌/公牌。
- */
-declare class Deck {
-    #private;
-    constructor();
-    shuffle(): void;
-    /**
-     * @description 给玩家发牌
-     * @param count 玩家数量
-     */
-    dealCards(count: number): {
-        handPokes: Poke[][];
-        commonPokes: Poke[];
-    };
-    getCards(): ("hj" | "h2" | "h3" | "h4" | "h5" | "h6" | "h7" | "h8" | "h9" | "ht" | "hq" | "hk" | "ha" | "s2" | "s3" | "s4" | "s5" | "s6" | "s7" | "s8" | "s9" | "st" | "sj" | "sq" | "sk" | "sa" | "d2" | "d3" | "d4" | "d5" | "d6" | "d7" | "d8" | "d9" | "dt" | "dj" | "dq" | "dk" | "da" | "c2" | "c3" | "c4" | "c5" | "c6" | "c7" | "c8" | "c9" | "ct" | "cj" | "cq" | "ck" | "ca")[];
-}
-export default Deck;

package/types/Deck/index.test.d.ts

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

package/types/Deck/standardDeck.d.ts

@@ -1,6 +0,0 @@
-import { type Poke } from './constant';
-/**
- * 生成标准 52 张牌（无洗牌）。
- * 顺序与 `Deck` 内部建牌一致：按 `suits` 顺序，每种花色内 `ranks` 从 2 到 a（如 `h2`…`ha`，再 `s2`…）。
- */
-export declare function createStandardDeckPokes(): Poke[];

package/types/Deck/standardDeck.test.d.ts

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

package/types/Hand/CurrentHand.d.ts

@@ -1,28 +0,0 @@
-import type { Player } from '../Player';
-import type { HandLifecycle } from '../gameContracts';
-import { type Stage } from '../Controller/stage';
-import { HandSettlement } from '../Controller/HandSettlement';
-/**
- * 单桌「当前一手」的聚合状态：生命周期、街、控制权、盲注记录、摊牌评估。
- * 公牌进度与下注圈一致，由 {@link Controller} 维护的 `stage` 表示。
- * {@link Controller} 负责编排流程；本类只持有数据与 `HandSettlement`。
- */
-export declare class CurrentHand {
-    /** 一手在控制器中的生命周期 */
-    status: HandLifecycle;
-    /** 当前下注圈（与已发公牌条数一致） */
-    stage: Stage;
-    /** 当前轮到行动的玩家 */
-    activePlayer: Player | null;
-    /** 翻牌前自动下的盲注记录（展示/回放） */
-    defaultBets: Array<{
-        userId: number;
-        balance: number;
-        amount: number;
-    }>;
-    /** 本手摊牌评估（按 userId） */
-    readonly settlement: HandSettlement;
-    constructor();
-    /** 局间清理：与 `Controller.reset` 中对手牌的期望一致 */
-    reset(): void;
-}

package/types/Player/allowedActions.d.ts

@@ -1,28 +0,0 @@
-import { ActionTypeEnum } from './constant';
-import TexasError, { type TexasErrorCode } from '../TexasError';
-/**
- * 纯函数：根据桌面公开状态推导当前玩家允许的行动列表（与倒计时、回调无关）。
- * 输入可由 {@link Player#getAllowedActionsContext} 构造，便于单测与机器人与 `Player` 解耦。
- */
-export type AllowedActionsContext = {
-    /** 仍在底池争胜且可参与下注轮（思考权以 `Controller.activePlayer` 为准，不由状态位表达） */
-    selfStatus: 'allIn' | 'eligible' | 'out';
-    selfBalance: number;
-    selfCurrentStageTotal: number;
-    dealerActionHistory: readonly {
-        getAction(): {
-            type: ActionTypeEnum;
-        } | undefined;
-        getStatus(): string;
-        readonly currentStageTotalAmount: number;
-    }[];
-    maxOthersStageBet: number;
-    isBigBlindPreFlopOption: boolean;
-    isJoiningBlindPreFlopOption: boolean;
-};
-export declare function resolveAllowedActions(ctx: AllowedActionsContext): ActionTypeEnum[];
-/**
- * 自愿动作是否被当前允许列表接纳（纯函数）。
- * 返回 `TexasError` 供调用方 `player.fail(err)`；通过则返回 `null`。
- */
-export declare function voluntaryActionDisallowError(allowed: readonly ActionTypeEnum[], required: ActionTypeEnum, disallowCode: TexasErrorCode): TexasError | null;

package/types/Player/allowedActions.test.d.ts

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