@konoui/mjimage 0.8.0 → 0.10.0

package/dist/index.d.cts

@@ -17,6 +17,19 @@ import { StateValue } from 'xstate';
 import { StrictObjectSchema } from 'valibot';
 import { StringSchema } from 'valibot';
 
+export declare class ActionLogic {
+    static doWin(hand: Hand, env: BoardContext, t: Tile, riverDiscarded: readonly {
+        t: Tile;
+    }[]): false | WinResult;
+    static doChi(hand: Hand, iam: Wind, discardedBy: Wind, t: Tile): false | readonly BlockChi[];
+    static doPon(hand: Hand, iam: Wind, discardedBy: Wind, t: Tile): false | readonly BlockPon[];
+    static doReach(hand: Hand): false | readonly TileAnalysis[];
+    static doDiscard(hand: Hand, called?: BlockChi | BlockPon): readonly Tile[];
+    static doDaiKan(hand: Hand, iam: Wind, discardedBy: Wind, t: Tile): false | BlockDaiKan;
+    static doAnkan(hand: Hand): false | BlockAnKan[];
+    static doShoKan(hand: Hand): false | BlockShoKan[];
+}
+
 export declare class ActorHand extends Hand {
     isBackHand(): boolean;
     clone(): ActorHand;
@@ -36,16 +49,12 @@ export declare abstract class BaseActor {
     river: IRiver;
     placeManager: PlaceManager;
     scoreManager: ScoreManager;
-    hands: {
-        "1z": ActorHand;
-        "2z": ActorHand;
-        "3z": ActorHand;
-        "4z": ActorHand;
-    };
+    hands: WindMap<ActorHand>;
     counter: Counter;
-    doraIndicators: Tile[];
+    private _doraIndicators;
     eventHandler: EventHandler;
     constructor(id: string, eventHandler: EventHandler);
+    get doraIndicators(): readonly Tile[];
     hand(w: Wind): ActorHand;
     protected abstract setHands(e: DistributeEvent): void;
     handleEvent(e: PlayerEvent): void;
@@ -90,8 +99,8 @@ export declare abstract class Block {
     private readonly _tiles;
     private readonly _type;
     constructor(tiles: readonly Tile[], type: BlockType);
-    static from(tiles: string): BlockHand | BlockOther | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockThree | BlockRun | BlockIsolated | BlockPair;
-    static deserialize(v: SerializedBlock): Block | BlockHand | BlockOther | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockThree | BlockRun | BlockIsolated | BlockPair;
+    static from(tiles: string): Block;
+    static deserialize(v: SerializedBlock): Block | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockPair | BlockRun | BlockThree | BlockHand | BlockIsolated | BlockOther;
     serialize(): {
         tiles: string;
         type: BlockType;
@@ -110,7 +119,7 @@ export declare abstract class Block {
             idx: number;
             tile: Tile;
         };
-    }): Block | BlockHand | BlockOther | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockThree | BlockRun | BlockIsolated | BlockPair;
+    }): Block | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockPair | BlockRun | BlockThree | BlockHand | BlockIsolated | BlockOther;
 }
 
 export declare class BlockAnKan extends Block {
@@ -124,13 +133,13 @@ export declare class BlockAnKan extends Block {
 export declare class BlockCalculator {
     hand: Hand;
     constructor(hand: Hand);
-    calc(lastTile: Tile): readonly Block[][];
-    markedHands(hands: readonly Block[][], lastTile: Tile): readonly Block[][];
-    markedHand(hand: readonly Block[], lastTile: Tile): readonly Block[][];
-    sevenPairs(): readonly Block[][];
-    thirteenOrphans(): readonly Block[][];
-    nineGates(): readonly Block[][];
-    standardType(): readonly Block[][];
+    calc(lastTile: Tile): readonly (readonly Block[])[];
+    markedHands(hands: readonly (readonly Block[])[], lastTile: Tile): readonly (readonly Block[])[];
+    markedHand(hand: readonly Block[], lastTile: Tile): readonly (readonly Block[])[];
+    sevenPairs(): readonly (readonly Block[])[];
+    thirteenOrphans(): readonly (readonly Block[])[];
+    nineGates(): readonly (readonly Block[])[];
+    standardType(): readonly (readonly Block[])[];
     private calcAllBlockCombinations;
     private handleBack;
     private handleZ;
@@ -211,7 +220,7 @@ export declare interface BoardContext {
         readonly reach: number;
         readonly dead: number;
     };
-    reached?: 1 | 2;
+    doubleReached?: boolean;
     replacementWin?: boolean;
     quadWin?: boolean;
     finalWallWin?: boolean;
@@ -238,7 +247,7 @@ export declare interface ChoiceAfterCalled {
     id: string;
     type: Extract<Event_2, "CHOICE_AFTER_CALLED">;
     wind: Wind;
-    choices: Pick<DrawnChoice, "DISCARD">;
+    choices: Pick<DrawChoice, "DISCARD">;
 }
 
 export declare interface ChoiceAfterDiscardedEvent {
@@ -246,10 +255,10 @@ export declare interface ChoiceAfterDiscardedEvent {
     type: Extract<Event_2, "CHOICE_AFTER_DISCARDED">;
     wind: Wind;
     discarterInfo: {
-        wind: Wind;
-        tile: string;
+        readonly wind: Wind;
+        readonly tile: string;
     };
-    choices: DiscardedChoice;
+    choices: DiscardChoice;
 }
 
 export declare interface ChoiceAfterDrawnEvent {
@@ -257,23 +266,23 @@ export declare interface ChoiceAfterDrawnEvent {
     type: Extract<Event_2, "CHOICE_AFTER_DRAWN">;
     wind: Wind;
     drawerInfo: {
-        wind: Wind;
-        tile: string;
+        readonly wind: Wind;
+        readonly tile: string;
     };
-    choices: DrawnChoice;
+    choices: DrawChoice;
 }
 
-declare type ChoiceEvent = "PON" | "CHI" | "RON" | "DISCARD" | "TSUMO" | "REACH" | "AN_KAN" | "SHO_KAN" | "DAI_KAN" | "DRAWN_GAME_BY_NINE_ORPHANS";
+declare type ChoiceEvent = "PON" | "CHI" | "RON" | "DISCARD" | "TSUMO" | "REACH" | "AN_KAN" | "SHO_KAN" | "DAI_KAN" | "DRAWN_GAME_BY_NINE_TERMINALS";
 
 export declare interface ChoiceForChanKan {
     id: string;
     type: Extract<Event_2, "CHOICE_FOR_CHAN_KAN">;
     wind: Wind;
     callerInfo: {
-        wind: Wind;
-        tile: string;
+        readonly wind: Wind;
+        readonly tile: string;
     };
-    choices: Pick<DiscardedChoice, "RON">;
+    choices: Pick<DiscardChoice, "RON">;
 }
 
 export declare interface ChoiceForReachAcceptance {
@@ -281,12 +290,14 @@ export declare interface ChoiceForReachAcceptance {
     type: Extract<Event_2, "CHOICE_FOR_REACH_ACCEPTANCE">;
     wind: Wind;
     reacherInfo: {
-        wind: Wind;
-        tile: string;
+        readonly wind: Wind;
+        readonly tile: string;
     };
-    choices: Pick<DiscardedChoice, "RON">;
+    choices: Pick<DiscardChoice, "RON">;
 }
 
+export declare const compareCalledTiles: (arr: readonly Tile[]) => Tile[];
+
 export declare const compareTiles: (i: Tile, j: Tile) => number;
 
 export declare class Controller {
@@ -294,8 +305,8 @@ export declare class Controller {
     playerIDs: string[];
     actor: Actor<StateMachine<    {
     currentWind: Wind;
-    oneShotMap: { [key in Wind]: boolean; };
-    missingMap: { [key in Wind]: boolean; };
+    oneShotMap: { [w in Wind]: boolean; };
+    missingMap: { [w in Wind]: boolean; };
     controller: Controller;
     genEventID: ReturnType<incrementalIDGenerator>;
     }, {
@@ -351,7 +362,7 @@ export declare class Controller {
     block: BlockDaiKan;
     iam: Wind;
     } | {
-    type: "DRAWN_GAME_BY_NINE_ORPHANS";
+    type: "DRAWN_GAME_BY_NINE_TERMINALS";
     iam: Wind;
     }, Record<string, AnyActorRef>, ProvidedActor, ParameterizedObject, ParameterizedObject, never, StateValue, string, unknown, NonReducibleUnknown, EventObject, MetaObject, any>>;
     observer: Observer;
@@ -361,13 +372,21 @@ export declare class Controller {
     mailBox: {
         [id: string]: PlayerEvent[];
     };
-    histories: GameHistory[];
+    histories: RoundHistory[];
     debugMode: boolean;
-    constructor(players: PlayerSession[], params?: {
+    constructor(players: readonly PlayerSession[], params?: {
         debug?: boolean;
         shuffle?: boolean;
     });
-    boardParams(w: Wind): BoardContext;
+    getBaseBoardParams(w: Wind): {
+        doraIndicators: readonly Tile[];
+        round: Round;
+        myWind: Wind;
+        sticks: {
+            readonly reach: number;
+            readonly dead: number;
+        };
+    };
     hand(w: Wind): ActorHand;
     get placeManager(): PlaceManager;
     get scoreManager(): ScoreManager;
@@ -375,9 +394,9 @@ export declare class Controller {
     next(force?: boolean): void;
     emit(e: PlayerEvent): void;
     enqueue(event: PlayerEvent): void;
-    pollReplies(eventID: string, wind: Wind[]): void;
-    export(): GameHistory[];
-    static load(h: GameHistory): Controller;
+    pollReplies(eventID: string, wind: readonly Wind[]): void;
+    export(): RoundHistory[];
+    static load(h: RoundHistory): Controller;
     start(): void;
     startGame(): void;
     finalResult(ret: WinResult, iam: Wind): WinResult;
@@ -388,31 +407,29 @@ export declare class Controller {
         missingRon?: boolean;
         discardedBy?: Wind;
     }): WinResult | false;
-    doPon(w: Wind, discardedBy: Wind, t?: Tile): BlockPon[] | false;
-    doChi(w: Wind, discardedBy: Wind, t?: Tile): BlockChi[] | false;
-    redPattern(blocks: BlockChi[]): BlockChi[];
-    doReach(w: Wind): TileAnalysis[] | false;
-    doDiscard(w: Wind, called?: BlockChi | BlockPon): Tile[];
-    cannotDiscardTile(b: BlockChi): Tile[];
-    doAnKan(w: Wind): BlockAnKan[] | false;
-    doShoKan(w: Wind): BlockShoKan[] | false;
+    doPon(w: Wind, discardedBy: Wind, t?: Tile): readonly BlockPon[] | false;
+    doChi(w: Wind, discardedBy: Wind, t?: Tile): readonly BlockChi[] | false;
+    doReach(w: Wind): readonly TileAnalysis[] | false;
+    doDiscard(w: Wind, called?: BlockChi | BlockPon): readonly Tile[];
+    doAnKan(w: Wind): readonly BlockAnKan[] | false;
+    doShoKan(w: Wind): readonly BlockShoKan[] | false;
     doDaiKan(w: Wind, discardedBy: Wind, t: Tile): BlockDaiKan | false;
-    canDrawnGame(w: Wind): boolean;
+    canDeclareNineTerminalsAbort(w: Wind): boolean;
     initialHands(): {
-        "1z": string;
-        "2z": string;
-        "3z": string;
-        "4z": string;
+        readonly "1z": string;
+        readonly "2z": string;
+        readonly "3z": string;
+        readonly "4z": string;
     };
 }
 
 declare type ControllerContext = {
     currentWind: Wind;
     oneShotMap: {
-        [key in Wind]: boolean;
+        [w in Wind]: boolean;
     };
     missingMap: {
-        [key in Wind]: boolean;
+        [w in Wind]: boolean;
     };
     controller: Controller;
     genEventID: ReturnType<typeof incrementalIDGenerator>;
@@ -427,23 +444,10 @@ export declare const convertInput: (i: TableInput) => {
 export declare class Counter {
     disabled: boolean;
     private c;
-    safeTileMap: {
-        "1z": {
-            [name: string]: boolean;
-        };
-        "2z": {
-            [name: string]: boolean;
-        };
-        "3z": {
-            [name: string]: boolean;
-        };
-        "4z": {
-            [name: string]: boolean;
-        };
-    };
+    private safeTileMap;
     constructor(disabled?: boolean);
     get(t: Tile): number;
-    dec(...tiles: Tile[]): void;
+    dec(...tiles: readonly Tile[]): void;
     addTileToSafeMap(t: Tile, targetUser: Wind): void;
     isSafeTile(k: Type, n: number, targetUser: Wind): boolean;
     private key;
@@ -451,7 +455,7 @@ export declare class Counter {
     private initial;
 }
 
-export declare const createBlockHand: (helper: ImageHelper, blocks: Block[], options?: DrawOptions) => MySVGElement;
+export declare const createBlockHand: (helper: ImageHelper, blocks: readonly Block[], options?: DrawOptions) => MySVGElement;
 
 export declare const createControllerMachine: (c: Controller) => StateMachine<ControllerContext, {
 type: "";
@@ -506,7 +510,7 @@ type: "DAI_KAN";
 block: BlockDaiKan;
 iam: Wind;
 } | {
-type: "DRAWN_GAME_BY_NINE_ORPHANS";
+type: "DRAWN_GAME_BY_NINE_TERMINALS";
 iam: Wind;
 }, Record<string, AnyActorRef>, ProvidedActor, ParameterizedObject, ParameterizedObject, never, StateValue, string, unknown, NonReducibleUnknown, EventObject, MetaObject, any>;
 
@@ -536,22 +540,23 @@ export declare const createLocalGame: (params?: {
 
 export declare const createTable: (helper: ImageHelper, fontCtx: FontContext, handsProps: HandsInput, discardsProps: DiscardsInput, scoreBoardProps: ScoreBoardInput) => MySVGElement;
 
-export declare function createWindMap<T>(initial: T, clone?: boolean): {
-    "1z": T;
-    "2z": T;
-    "3z": T;
-    "4z": T;
-};
+export declare function createWindMap<T>(factory: () => T): WindMap<T>;
 
 export declare const deserializeWinResult: (ret: SerializedWinResult) => WinResult;
 
-declare interface DiscardedChoice {
+declare interface DiscardChoice {
     RON: false | SerializedWinResult;
-    PON: false | SerializedBlock[];
-    CHI: false | SerializedBlock[];
+    PON: false | readonly SerializedBlock[];
+    CHI: false | readonly SerializedBlock[];
     DAI_KAN: false | SerializedBlock;
 }
 
+declare type DiscardEntry = {
+    w: Wind;
+    t: Tile;
+    callMarker?: boolean;
+};
+
 export declare interface DiscardEvent {
     id: string;
     type: Extract<ChoiceEvent, "DISCARD">;
@@ -571,28 +576,37 @@ export declare interface DistributeEvent {
     id: string;
     type: Extract<Event_2, "DISTRIBUTE">;
     hands: {
-        [key in Wind]: string;
+        readonly [w in Wind]: string;
     };
     wind: Wind;
     doraIndicator: string;
-    players: string[];
+    players: readonly string[];
     places: {
-        [key: string]: Wind;
+        readonly [id: string]: Wind;
     };
     sticks: {
-        reach: number;
-        dead: number;
+        readonly reach: number;
+        readonly dead: number;
     };
     round: Round;
     scores: {
-        [key: string]: number;
+        readonly [key: string]: number;
     };
 }
 
-export declare const drawBlocks: (svg: Svg, blocks: Block[], config?: ImageHelperConfig, options?: {
+export declare const drawBlocks: (svg: Svg, blocks: readonly Block[], config?: ImageHelperConfig, options?: {
     responsive?: boolean;
 } & DrawOptions) => void;
 
+declare interface DrawChoice {
+    TSUMO: false | SerializedWinResult;
+    REACH: false | readonly SerializedTileAnalysis[];
+    AN_KAN: false | readonly SerializedBlock[];
+    SHO_KAN: false | readonly SerializedBlock[];
+    DISCARD: false | readonly string[];
+    DRAWN_GAME_BY_NINE_TERMINALS: boolean;
+}
+
 export declare interface DrawEvent {
     id: string;
     type: Extract<Event_2, "DRAW">;
@@ -602,15 +616,6 @@ export declare interface DrawEvent {
     tile: string;
 }
 
-declare interface DrawnChoice {
-    TSUMO: false | SerializedWinResult;
-    REACH: false | SerializedTileAnalysis[];
-    AN_KAN: false | SerializedBlock[];
-    SHO_KAN: false | SerializedBlock[];
-    DISCARD: false | string[];
-    DRAWN_GAME_BY_NINE_ORPHANS: boolean;
-}
-
 export declare interface DrawOptions {
     enableDoraText?: boolean;
     enableTsumoText?: boolean;
@@ -621,13 +626,13 @@ export declare const drawTable: (svg: Svg, tableInput: string, config: ImageHelp
 }) => void;
 
 export declare class Efficiency {
-    static calcEffectiveTiles(hand: Hand, choices: Tile[], options?: {
+    static calcEffectiveTiles(hand: Hand, choices: readonly Tile[], options?: {
         arrangeRed?: boolean;
         standardTypeOnly?: boolean;
-    }): TileAnalysis[];
+    }): readonly TileAnalysis[];
     static getEffectiveTiles(hand: Hand, options?: {
         standardTypeOnly?: boolean;
-        typeFilter?: Type[];
+        typeFilter?: readonly Type[];
     }): {
         shanten: number;
         effectiveTiles: Tile[];
@@ -637,20 +642,20 @@ export declare class Efficiency {
 export declare interface EndEvent {
     id: string;
     type: Extract<Event_2, "END_GAME">;
-    subType: "WIN_GAME" | "DRAWN_GAME" | "FOUR_KAN" | "FOUR_WIND" | "NINE_TILES";
+    subType: "WIN_GAME" | "DRAWN_GAME" | "FOUR_KANS" | "FOUR_WINDS" | "NINE_TERMINALS";
     wind: Wind;
     scores: {
-        [key: string]: number;
+        readonly [key: string]: number;
     };
     sticks: {
-        reach: number;
-        dead: number;
+        readonly reach: number;
+        readonly dead: number;
     };
     deltas: {
-        [key in Wind]: number;
+        readonly [w in Wind]: number;
     };
     hands: {
-        [key in Wind]: string;
+        readonly [w in Wind]: string;
     };
     shouldContinue: boolean;
 }
@@ -679,8 +684,8 @@ export declare interface FontContext {
 
 export declare function forHand(options?: {
     skipBack?: boolean;
-    filterBy?: Type[];
-}): Generator<readonly ["m" | "p" | "s" | "z" | "_", number], void, unknown>;
+    filterBy?: readonly Type[];
+}): Generator<readonly [Type, number], void, unknown>;
 
 export declare class G extends Mark {
     children: Mark[];
@@ -695,24 +700,6 @@ export declare class G extends Mark {
     each(block: (idx: number, children: Mark[]) => void, deep: boolean): void;
 }
 
-export declare interface GameHistory {
-    round: Round;
-    scores: {
-        [wind in string]: number;
-    };
-    players: {
-        [id in string]: Wind;
-    };
-    sticks: {
-        reach: number;
-        dead: number;
-    };
-    wall: WallProps;
-    choiceEvents: {
-        [id: string]: PlayerEvent[];
-    };
-}
-
 export declare const getCallBlockIndex: (caller: Wind, discardedBy: Wind, type: typeof BLOCK.PON | typeof BLOCK.DAI_KAN) => 0 | 1 | 3 | 2;
 
 export declare function getPointDescription(params: {
@@ -727,7 +714,7 @@ export declare function getPointDescription(params: {
 
 export declare class Hand {
     protected data: HandData;
-    constructor(input: string | Block[], allowBackBlock?: boolean);
+    constructor(input: string | readonly Block[], allowBackBlock?: boolean);
     private init;
     get hands(): Tile[];
     toString(): string;
@@ -759,10 +746,10 @@ export declare interface HandData {
 }
 
 export declare interface HandsInput {
-    front: Block[];
-    right: Block[];
-    opposite: Block[];
-    left: Block[];
+    front: readonly Block[];
+    right: readonly Block[];
+    opposite: readonly Block[];
+    left: readonly Block[];
 }
 
 declare class Image_2 extends Mark {
@@ -803,18 +790,11 @@ export declare const INPUT_SEPARATOR = ",";
 
 export declare interface IRiver {
     discard(t: Tile, w: Wind): void;
-    discards(w?: Wind): {
-        w: Wind;
-        t: Tile;
-        callMarker?: boolean;
-    }[];
-    lastTile: {
-        w: Wind;
-        t: Tile;
-        callMarker?: boolean;
-    };
+    discards(w?: Wind): readonly DiscardEntry[];
+    lastTile: DiscardEntry;
     markCalled(): void;
-    cannotContinue(): boolean;
+    isFourWindsAbort(): boolean;
+    reset(): void;
 }
 
 export declare function is5Tile(t: Tile): boolean;
@@ -829,10 +809,10 @@ export declare interface IWall {
     canDraw: boolean;
     export(): WallProps;
     initialHands(): {
-        [WIND.E]: string;
-        [WIND.S]: string;
-        [WIND.W]: string;
-        [WIND.N]: string;
+        readonly [WIND.E]: string;
+        readonly [WIND.S]: string;
+        readonly [WIND.W]: string;
+        readonly [WIND.N]: string;
     };
 }
 
@@ -931,10 +911,14 @@ export declare const parse: (s: string) => {
 
 export declare class Parser {
     readonly input: string;
-    readonly enableImplicitTsumoBlock: boolean;
+    readonly options: {
+        enableImplicitTsumoBlock?: boolean;
+    };
     readonly maxInputLength = 600;
-    constructor(input: string, enableImplicitTsumoBlock?: boolean);
-    parse(): (BlockHand | BlockOther | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockThree | BlockRun | BlockIsolated | BlockPair)[];
+    constructor(input: string, options?: {
+        enableImplicitTsumoBlock?: boolean;
+    });
+    parse(): readonly Block[];
     tiles(): readonly Tile[];
     tileSeparators(): readonly (Tile | Separator)[];
     private reconstruct;
@@ -977,20 +961,22 @@ export declare const parseTableInput: (s: string) => {
 export declare class PlaceManager {
     private playerToWind;
     private windToPlayer;
-    round: Round;
-    sticks: {
-        reach: number;
-        dead: number;
-    };
+    private _round;
+    private _sticks;
     constructor(initial: {
-        [key: string]: Wind;
+        readonly [key: string]: Wind;
     }, params?: {
-        round: Round;
-        sticks: {
-            reach: number;
-            dead: number;
+        readonly round: Round;
+        readonly sticks: {
+            readonly reach: number;
+            readonly dead: number;
         };
     });
+    get sticks(): {
+        readonly reach: number;
+        readonly dead: number;
+    };
+    get round(): Round;
     private update;
     incrementDeadStick(): void;
     incrementReachStick(): void;
@@ -1001,7 +987,7 @@ export declare class PlaceManager {
     wind(id: string): Wind;
     playerID(w: Wind): string;
     get playerMap(): {
-        [id: string]: Wind;
+        readonly [id: string]: Wind;
     };
 }
 
@@ -1016,8 +1002,8 @@ export declare class Player extends BaseActor {
 }
 
 export declare class PlayerEfficiency {
-    static analyzePlayerEfficiency(counter: Counter, analyses: TileAnalysis[]): PlayerTileAnalysis[];
-    static selectMinPriority(c: Counter, playerAnalyses: PlayerTileAnalysis[], doras: Tile[]): PlayerTileAnalysis;
+    static analyzePlayerEfficiency(counter: Counter, analyses: readonly TileAnalysis[]): PlayerTileAnalysis[];
+    static selectMinPriority(c: Counter, playerAnalyses: readonly PlayerTileAnalysis[], doras: Tile[]): PlayerTileAnalysis;
     private static calcPriority;
 }
 
@@ -1031,7 +1017,7 @@ export declare interface PlayerSession {
 export declare interface PlayerTileAnalysis {
     tile: Tile;
     sum: number;
-    effectiveTiles: {
+    effectiveTiles: readonly {
         tile: Tile;
         count: number;
     }[];
@@ -1061,8 +1047,8 @@ export declare class PointCalculator {
         orig: BoardContext;
     };
     constructor(hand: Hand, params: BoardContext);
-    calc(...hands: readonly Block[][]): WinResult | false;
-    getWinningHands(hands: readonly Block[][]): WinningHand[];
+    calc(...hands: readonly (readonly Block[])[]): WinResult | false;
+    getWinningHands(hands: readonly (readonly Block[])[]): WinningHand[];
     private selectBestHand;
     private calculateScore;
     private hasYakuman;
@@ -1074,43 +1060,43 @@ export declare class PointCalculator {
     private addStickPoints;
     private getBasePoints;
     private getCalledPenalty;
-    dA1(h: readonly Block[]): Yaku[];
-    dB1(h: readonly Block[]): Yaku[];
-    dC1(h: readonly Block[]): Yaku[];
-    dD1(h: readonly Block[]): Yaku[];
-    dE1(h: readonly Block[]): Yaku[];
-    dF1(h: readonly Block[]): Yaku[];
-    dG1(h: readonly Block[]): Yaku[];
-    dH1(h: readonly Block[]): Yaku[];
-    dI1(h: readonly Block[]): Yaku[];
-    dJ1(h: readonly Block[]): Yaku[];
-    dK1(h: readonly Block[]): Yaku[];
-    dX1(h: readonly Block[]): Yaku[];
-    dA2(h: readonly Block[]): Yaku[];
-    dB2(h: readonly Block[]): Yaku[];
-    dC2(h: readonly Block[]): Yaku[];
-    dD2(h: readonly Block[]): Yaku[];
-    dE2(h: readonly Block[]): Yaku[];
-    dF2(h: readonly Block[]): Yaku[];
-    dG2(h: readonly Block[]): Yaku[];
-    dH2(h: readonly Block[]): Yaku[];
-    dI2(h: readonly Block[]): Yaku[];
-    dJ2(h: readonly Block[]): Yaku[];
-    dA3(h: readonly Block[]): Yaku[];
-    dB3(h: readonly Block[]): Yaku[];
-    dC3(h: readonly Block[]): Yaku[];
-    dA6(h: readonly Block[]): Yaku[];
-    dA13(h: readonly Block[]): Yaku[];
-    dB13(h: readonly Block[]): Yaku[];
-    dC13(h: readonly Block[]): Yaku[];
-    dD13(h: readonly Block[]): Yaku[];
-    dE13(h: readonly Block[]): Yaku[];
-    dF13(h: readonly Block[]): Yaku[];
-    dG13(h: readonly Block[]): Yaku[];
-    dH13(h: readonly Block[]): Yaku[];
-    dI13(h: readonly Block[]): Yaku[];
-    dJ13(h: readonly Block[]): Yaku[];
-    dK13(h: readonly Block[]): Yaku[];
+    dA1(h: readonly Block[]): readonly Yaku[];
+    dB1(h: readonly Block[]): readonly Yaku[];
+    dC1(h: readonly Block[]): readonly Yaku[];
+    dD1(h: readonly Block[]): readonly Yaku[];
+    dE1(h: readonly Block[]): readonly Yaku[];
+    dF1(h: readonly Block[]): readonly Yaku[];
+    dG1(h: readonly Block[]): readonly Yaku[];
+    dH1(h: readonly Block[]): readonly Yaku[];
+    dI1(h: readonly Block[]): readonly Yaku[];
+    dJ1(h: readonly Block[]): readonly Yaku[];
+    dK1(h: readonly Block[]): readonly Yaku[];
+    dX1(h: readonly Block[]): readonly Yaku[];
+    dA2(h: readonly Block[]): readonly Yaku[];
+    dB2(h: readonly Block[]): readonly Yaku[];
+    dC2(h: readonly Block[]): readonly Yaku[];
+    dD2(h: readonly Block[]): readonly Yaku[];
+    dE2(h: readonly Block[]): readonly Yaku[];
+    dF2(h: readonly Block[]): readonly Yaku[];
+    dG2(h: readonly Block[]): readonly Yaku[];
+    dH2(h: readonly Block[]): readonly Yaku[];
+    dI2(h: readonly Block[]): readonly Yaku[];
+    dJ2(h: readonly Block[]): readonly Yaku[];
+    dA3(h: readonly Block[]): readonly Yaku[];
+    dB3(h: readonly Block[]): readonly Yaku[];
+    dC3(h: readonly Block[]): readonly Yaku[];
+    dA6(h: readonly Block[]): readonly Yaku[];
+    dA13(h: readonly Block[]): readonly Yaku[];
+    dB13(h: readonly Block[]): readonly Yaku[];
+    dC13(h: readonly Block[]): readonly Yaku[];
+    dD13(h: readonly Block[]): readonly Yaku[];
+    dE13(h: readonly Block[]): readonly Yaku[];
+    dF13(h: readonly Block[]): readonly Yaku[];
+    dG13(h: readonly Block[]): readonly Yaku[];
+    dH13(h: readonly Block[]): readonly Yaku[];
+    dI13(h: readonly Block[]): readonly Yaku[];
+    dJ13(h: readonly Block[]): readonly Yaku[];
+    dK13(h: readonly Block[]): readonly Yaku[];
     calcFu(h: readonly Block[]): number;
 }
 
@@ -1120,12 +1106,12 @@ export declare const prevWind: (w: Wind) => Wind;
 
 export declare function prioritizeDiscardedEvents(events: ChoiceAfterDiscardedEvent[]): {
     events: ChoiceAfterDiscardedEvent[];
-    type: boolean | keyof DiscardedChoice;
+    type: boolean | keyof DiscardChoice;
 };
 
 export declare function prioritizeDrawnEvents(events: ChoiceAfterDrawnEvent[]): {
     events: ChoiceAfterDrawnEvent[];
-    type: boolean | keyof DrawnChoice;
+    type: boolean | keyof DrawChoice;
 };
 
 export declare interface ReachAcceptedEvent {
@@ -1133,8 +1119,8 @@ export declare interface ReachAcceptedEvent {
     type: Extract<Event_2, "REACH_ACCEPTED">;
     wind: Wind;
     reacherInfo: {
-        wind: Wind;
-        tile: string;
+        readonly wind: Wind;
+        readonly tile: string;
     };
 }
 
@@ -1158,7 +1144,7 @@ export declare class Rect extends Mark {
 
 export declare class Replayer {
     index: number;
-    histories: GameHistory[];
+    histories: RoundHistory[];
     constructor(v: string);
     next(): void;
     prev(): void;
@@ -1167,28 +1153,21 @@ export declare class Replayer {
 }
 
 export declare class RiskRank {
-    static selectTile(c: Counter, targetUsers: Wind[], tiles: Tile[]): Tile;
-    static rank(c: Counter, targetUsers: Wind[], t: Tile): number;
+    static selectTile(c: Counter, targetUsers: readonly Wind[], tiles: readonly Tile[]): Tile;
+    static rank(c: Counter, targetUsers: readonly Wind[], t: Tile): number;
     static rankZ(c: Counter, targetUser: Wind, t: Tile): number;
     static rankN(c: Counter, targetUser: Wind, t: Tile): 0 | 5 | 3 | 4 | 6 | 8 | 12;
 }
 
-export declare class River {
-    private m;
-    constructor();
+export declare class River implements IRiver {
+    private all;
+    private byWind;
     discard(t: Tile, w: Wind): void;
-    discards(w?: Wind): {
-        w: Wind;
-        t: Tile;
-        callMarker?: boolean;
-    }[];
-    get lastTile(): {
-        w: Wind;
-        t: Tile;
-        callMarker?: boolean;
-    };
+    discards(w?: Wind): readonly DiscardEntry[];
+    get lastTile(): DiscardEntry;
     markCalled(): void;
-    cannotContinue(): boolean;
+    isFourWindsAbort(): boolean;
+    reset(): void;
 }
 
 export declare interface RonEvent {
@@ -1198,8 +1177,8 @@ export declare interface RonEvent {
     wind: Wind;
     ret: SerializedWinResult;
     victimInfo: {
-        wind: Wind;
-        tile: string;
+        readonly wind: Wind;
+        readonly tile: string;
     };
 }
 
@@ -1243,6 +1222,24 @@ export declare const ROUND_MAP: {
     readonly "4z4": "北４局";
 };
 
+export declare interface RoundHistory {
+    round: Round;
+    scores: {
+        [wind in string]: number;
+    };
+    players: {
+        [id in string]: Wind;
+    };
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    wall: WallProps;
+    choiceEvents: {
+        [id: string]: PlayerEvent[];
+    };
+}
+
 export declare const roundWind: (r: Round) => Wind;
 
 export declare interface ScoreBoardInput {
@@ -1265,16 +1262,16 @@ export declare class ScoreManager {
     private reachValue;
     private m;
     constructor(initial: {
-        [key: string]: number;
+        readonly [id: string]: number;
     });
     get summary(): {
-        [key: string]: number;
+        readonly [id: string]: number;
     };
     reach(id: string): void;
     update(result: {
-        [w in Wind]: number;
+        readonly [w in Wind]: number;
     }, windMap: {
-        [id: string]: Wind;
+        readonly [id: string]: Wind;
     }): void;
 }
 
@@ -1314,8 +1311,6 @@ export declare class ShantenCalculator {
 
 export declare function shuffle<T>(array: T[]): T[];
 
-export declare const sortCalledTiles: (arr: readonly Tile[]) => Tile[];
-
 export declare const STICK_CONTEXT: {
     readonly WIDTH: 125;
     readonly HEIGHT: 27.5;
@@ -1509,12 +1504,7 @@ export declare class Wall {
     get hiddenDoraIndicators(): Tile[];
     get canKan(): boolean;
     get canDraw(): boolean;
-    initialHands(): {
-        "1z": string;
-        "2z": string;
-        "3z": string;
-        "4z": string;
-    };
+    initialHands(): WindMap<string>;
     private init;
     export(): WallProps;
     static clone(walls: WallProps): WallProps;
@@ -1544,8 +1534,10 @@ export declare const WIND_MAP: {
     readonly "4z": "北";
 };
 
+export declare type WindMap<T> = Record<Wind, T>;
+
 declare interface WinningHand {
-    hand: Block[];
+    hand: readonly Block[];
     fu: number;
     yakus: readonly Yaku[];
     han: number;