@konoui/mjimage 0.7.0 → 0.9.0

package/dist/index.d.ts

@@ -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;
@@ -43,9 +56,10 @@ export declare abstract class BaseActor {
         "4z": 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 +104,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 +124,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 +138,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 +225,7 @@ export declare interface BoardContext {
         readonly reach: number;
         readonly dead: number;
     };
-    reached?: 1 | 2;
+    doubleReached?: boolean;
     replacementWin?: boolean;
     quadWin?: boolean;
     finalWallWin?: boolean;
@@ -238,7 +252,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 +260,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 +271,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,10 +295,10 @@ 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 compareTiles: (i: Tile, j: Tile) => number;
@@ -294,8 +308,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 +365,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 +375,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 +397,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 +410,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>;
@@ -425,25 +445,12 @@ export declare const convertInput: (i: TableInput) => {
 };
 
 export declare class Counter {
-    disable: boolean;
+    disabled: boolean;
     private c;
-    safeTileMap: {
-        "1z": {
-            [name: string]: boolean;
-        };
-        "2z": {
-            [name: string]: boolean;
-        };
-        "3z": {
-            [name: string]: boolean;
-        };
-        "4z": {
-            [name: string]: boolean;
-        };
-    };
-    constructor(disable?: 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,6 +458,8 @@ export declare class Counter {
     private initial;
 }
 
+export declare const createBlockHand: (helper: ImageHelper, blocks: readonly Block[], options?: DrawOptions) => MySVGElement;
+
 export declare const createControllerMachine: (c: Controller) => StateMachine<ControllerContext, {
 type: "";
 } | {
@@ -504,7 +513,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>;
 
@@ -515,12 +524,6 @@ export declare const createEventEmitter: () => {
 
 export declare const createEventPipe: () => [EventHandler, EventHandler];
 
-export declare const createHand: (helper: ImageHelper, blocks: Block[], options?: DrawOptions) => {
-    e: G;
-    width: number;
-    height: number;
-};
-
 export declare const createLocalGame: (params?: {
     debug?: boolean;
     shuffle?: boolean;
@@ -538,11 +541,7 @@ export declare const createLocalGame: (params?: {
     p4: Player;
 };
 
-export declare const createTable: (helper: ImageHelper, fontCtx: FontContext, handsProps: HandsInput, discardsProps: DiscardsInput, scoreBoardProps: ScoreBoardInput) => {
-    e: G;
-    width: number;
-    height: number;
-};
+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;
@@ -553,10 +552,10 @@ export declare function createWindMap<T>(initial: T, clone?: boolean): {
 
 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;
 }
 
@@ -579,28 +578,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">;
@@ -610,18 +618,9 @@ 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 {
-    doraText?: boolean;
-    tsumoText?: boolean;
+    enableDoraText?: boolean;
+    enableTsumoText?: boolean;
 }
 
 export declare const drawTable: (svg: Svg, tableInput: string, config: ImageHelperConfig | undefined, fontCtx: FontContext, params?: {
@@ -629,13 +628,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[];
@@ -645,20 +644,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;
 }
@@ -687,8 +686,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[];
@@ -703,24 +702,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: {
@@ -735,7 +716,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;
@@ -767,10 +748,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 {
@@ -784,8 +765,18 @@ export { Image_2 as Image }
 
 export declare class ImageHelper extends BaseHelper {
     readonly blockMargin: number;
-    createBlockHandDiscard(block: Block): G;
-    createBlockPonChiKan(block: Block): G;
+    createBlockDiscard(block: BlockOther): G;
+    createBlockHand(block: BlockHand): G;
+    createBlockChi(block: BlockChi): G;
+    createBlockPon(block: BlockChi): G;
+    createBlockShoKan(block: BlockShoKan): G;
+    createBlockDaiKan(block: BlockDaiKan): G;
+    createBlockAnKan(block: BlockAnKan): G;
+    createBlockDora(block: BlockOther, enableText?: boolean): G;
+    createBlockTsumo(block: BlockOther, enableText?: boolean): G;
+    protected createBlockSingleText(block: Block, text: string, enableText?: boolean): G;
+    protected createHorizontalBlock(tiles: readonly Tile[]): G;
+    protected findHorizontalIndex(block: Block): number;
 }
 
 export declare interface ImageHelperConfig {
@@ -801,7 +792,7 @@ export declare const INPUT_SEPARATOR = ",";
 
 export declare interface IRiver {
     discard(t: Tile, w: Wind): void;
-    discards(w?: Wind): {
+    discards(w?: Wind): readonly {
         w: Wind;
         t: Tile;
         callMarker?: boolean;
@@ -812,7 +803,7 @@ export declare interface IRiver {
         callMarker?: boolean;
     };
     markCalled(): void;
-    cannotContinue(): boolean;
+    isFourWindsAbort(): boolean;
 }
 
 export declare function is5Tile(t: Tile): boolean;
@@ -827,10 +818,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;
     };
 }
 
@@ -874,6 +865,12 @@ export declare const MyRect: typeof Rect;
 
 export declare const MySVG: typeof SVG;
 
+export declare interface MySVGElement {
+    e: G;
+    width: number;
+    height: number;
+}
+
 export declare const MyText: typeof Text_2;
 
 export declare const MyUse: typeof Use;
@@ -905,7 +902,7 @@ export declare class Observer extends BaseActor {
 export declare const OP: {
     readonly TSUMO: "t";
     readonly RON: "v";
-    readonly DORA: "d";
+    readonly IMAGE_DORA: "d";
     readonly HORIZONTAL: "-";
     readonly RED: "r";
     readonly COLOR_GRAYSCALE: "^";
@@ -923,11 +920,17 @@ export declare const parse: (s: string) => {
 
 export declare class Parser {
     readonly input: string;
+    readonly options: {
+        enableImplicitTsumoBlock?: boolean;
+    };
     readonly maxInputLength = 600;
-    constructor(input: string);
-    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;
     private makeBlocks;
     private validate;
 }
@@ -967,20 +970,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;
@@ -991,7 +996,7 @@ export declare class PlaceManager {
     wind(id: string): Wind;
     playerID(w: Wind): string;
     get playerMap(): {
-        [id: string]: Wind;
+        readonly [id: string]: Wind;
     };
 }
 
@@ -1006,8 +1011,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;
 }
 
@@ -1021,7 +1026,7 @@ export declare interface PlayerSession {
 export declare interface PlayerTileAnalysis {
     tile: Tile;
     sum: number;
-    effectiveTiles: {
+    effectiveTiles: readonly {
         tile: Tile;
         count: number;
     }[];
@@ -1051,8 +1056,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;
@@ -1063,44 +1068,44 @@ export declare class PointCalculator {
     private calculateTsumoDeltas;
     private addStickPoints;
     private getBasePoints;
-    private minus;
-    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[];
+    private getCalledPenalty;
+    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;
 }
 
@@ -1110,12 +1115,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 {
@@ -1123,8 +1128,8 @@ export declare interface ReachAcceptedEvent {
     type: Extract<Event_2, "REACH_ACCEPTED">;
     wind: Wind;
     reacherInfo: {
-        wind: Wind;
-        tile: string;
+        readonly wind: Wind;
+        readonly tile: string;
     };
 }
 
@@ -1148,7 +1153,7 @@ export declare class Rect extends Mark {
 
 export declare class Replayer {
     index: number;
-    histories: GameHistory[];
+    histories: RoundHistory[];
     constructor(v: string);
     next(): void;
     prev(): void;
@@ -1157,8 +1162,8 @@ 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;
 }
@@ -1178,7 +1183,7 @@ export declare class River {
         callMarker?: boolean;
     };
     markCalled(): void;
-    cannotContinue(): boolean;
+    isFourWindsAbort(): boolean;
 }
 
 export declare interface RonEvent {
@@ -1188,8 +1193,8 @@ export declare interface RonEvent {
     wind: Wind;
     ret: SerializedWinResult;
     victimInfo: {
-        wind: Wind;
-        tile: string;
+        readonly wind: Wind;
+        readonly tile: string;
     };
 }
 
@@ -1233,6 +1238,26 @@ 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 {
     doras: readonly Tile[];
     round: BoardRound;
@@ -1253,16 +1278,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: {
-        [key: string]: Wind;
+        readonly [id: string]: Wind;
     }): void;
 }
 
@@ -1533,7 +1558,7 @@ export declare const WIND_MAP: {
 };
 
 declare interface WinningHand {
-    hand: Block[];
+    hand: readonly Block[];
     fu: number;
     yakus: readonly Yaku[];
     han: number;