@johnmorrisdotca/domino 1.0.0

package/dist/mexicanTrain/mexicanTrain.js

@@ -0,0 +1,339 @@
+// Relative, like the rest of lib/party: the browser specs import this, and Playwright resolves no alias.
+import { seededRandom, shuffled } from "../random.js";
+import { everyTile, fits, isDouble, laidAgainst, laidEnds, pipsOf, tileOf } from "./dominoes.js";
+import { TRAIN_DEFAULT_OPTIONS, TRAIN_DOUBLES, TRAIN_MEXICAN, handSizeFor, roundsFor } from "./mexicanTrain.constants.js";
+/**
+ * MEXICAN TRAIN, THE DOMINO GAME: the rules, and nothing else.
+ *
+ * Pure, as the engine is: every function returns a new game and leaves the
+ * one it was given untouched. A game is its table (the set, the options, the
+ * seed, the seats) and its moves, in order; hands, trains, the boneyard and
+ * whose turn it is are always read again from those (`replayTrain`), so a game
+ * read back out of a browser's storage is exactly the game its moves make,
+ * or none. Every shuffle is drawn from the game's seed and the round's
+ * number, so a reload deals exactly what it dealt before.
+ *
+ * The rules as the site plays them, most published rules' own:
+ *
+ *  - a round is dealt round the engine double, the set's highest in the
+ *    first round and one fewer each round after, which sits in the hub;
+ *  - every player has a train of their own out of the hub, and there is one
+ *    more, the Mexican Train, anybody may play on;
+ *  - on your turn lay one tile against the open end of your own train, the
+ *    Mexican Train, or any player's train whose marker is out;
+ *  - nothing to lay: draw one tile; lay it if it goes, or put your marker out
+ *    and pass (with nothing to draw, just put it out); lay on your own train
+ *    and your marker comes in;
+ *  - a double must be covered before anything else is played anywhere, and
+ *    whoever lays one lays again to cover it (`DoublesRule` for the house
+ *    rule that lets doubles be chained);
+ *  - a round ends when somebody lays their last tile, or when nobody can lay
+ *    and there is nothing left to draw; every player scores the pips left in
+ *    their hand, and after the last round the lowest total wins.
+ */
+export const TRAIN_PHASES = { playing: "playing", roundOver: "roundOver", finished: "finished" };
+/** The sets a table may be dealt from, and how many may sit at it. */
+const SPEC = { sizes: [9, 12, 15], fewestPlayers: 2, mostPlayers: 8 };
+/** The longest name a seat keeps. */
+export const TRAIN_NAME_MOST = 20;
+/** A seat's name as given, its spaces tidied and cut to `TRAIN_NAME_MOST` characters. */
+export function cleanTrainName(name) {
+    return name.replace(/\s+/g, " ").trim().slice(0, TRAIN_NAME_MOST);
+}
+/** The Mexican Train's number among a game's trains: after every seat's own. */
+export function mexicanOf(game) {
+    return game.players.length;
+}
+/** The number a train's next tile must match: its last tile's open end, or the engine double's when nothing is laid on it yet. */
+export function openEnd(game, train) {
+    const laid = game.trains[train].laid;
+    return laid.length === 0 ? game.engine : laidEnds(laid[laid.length - 1])[1];
+}
+/** A shuffle for this round of this game, the same in every browser: the seed and the round decide it. */
+function shuffleFor(seed, round) {
+    return seededRandom((seed ^ Math.imul(round + 1, 0x9e3779b1)) >>> 0);
+}
+/**
+ * Deal round `round` of a game at this table: the engine double to the hub,
+ * a hand each from the rest, shuffled, and the rest face down to draw from.
+ * The first round is led by the first player, and each round after by the
+ * next player round the table.
+ */
+function dealRound(table, round) {
+    const count = table.players.length;
+    const engine = table.set - round;
+    const random = shuffleFor(table.seed, round);
+    const deck = shuffled(everyTile(table.set).filter((tile) => tile !== tileOf(engine, engine)), random);
+    const each = handSizeFor(table.set, count);
+    const hands = table.players.map((_, seat) => deck.slice(seat * each, (seat + 1) * each));
+    return {
+        ...table,
+        round,
+        engine,
+        hands,
+        trains: [...table.players.map(() => ({ laid: [], open: false })), { laid: [], open: true }],
+        boneyard: deck.slice(count * each),
+        toPlay: round % count,
+        uncovered: [],
+        chaining: false,
+        drew: false,
+        passes: 0,
+        turn: table.turn + (round === 0 ? 0 : 1),
+        phase: TRAIN_PHASES.playing,
+    };
+}
+/**
+ * A new game: the set (its highest double), the names at the table (one a
+ * seat), which seats a computer plays, the options, and the seed every
+ * shuffle is drawn from. Null for a table the game is not offered for — a set
+ * not in `PARTY_SPECS`, or too few or too many players — rather than a game
+ * nobody chose.
+ */
+export function startTrain(set, players, seed = 1, options = TRAIN_DEFAULT_OPTIONS, computers = players.map(() => false)) {
+    if (!SPEC.sizes.includes(set))
+        return null;
+    if (players.length < SPEC.fewestPlayers || players.length > SPEC.mostPlayers)
+        return null;
+    if (computers.length !== players.length)
+        return null;
+    if (!Number.isInteger(seed))
+        return null;
+    const table = {
+        set,
+        options: { ...options },
+        seed,
+        players: players.map(cleanTrainName),
+        computers: [...computers],
+        history: null,
+        rounds: roundsFor(set, options.length),
+        round: 0,
+        engine: set,
+        hands: [],
+        trains: [],
+        boneyard: [],
+        toPlay: 0,
+        uncovered: [],
+        chaining: false,
+        drew: false,
+        passes: 0,
+        turn: 0,
+        phase: TRAIN_PHASES.playing,
+        results: [],
+        winners: [],
+        last: null,
+    };
+    return dealRound(table, 0);
+}
+/** Whether `seat` may lay on this train at all now, before asking whether a tile fits it. */
+function mayLayOn(game, seat, train) {
+    if (train === seat)
+        return true;
+    const mexican = mexicanOf(game);
+    if (train === mexican)
+        return game.options.mexican !== TRAIN_MEXICAN.ownFirst || game.trains[seat].laid.length > 0;
+    return game.trains[train].open;
+}
+/**
+ * Every tile the player to move may lay, and where: what `moves` offers, and
+ * what the table lights up. While a double is uncovered anywhere the only
+ * lay is to cover the last of them, on whoever's train it is — or, under the
+ * chained-doubles rule, another double laid by the player still laying them.
+ */
+export function legalPlays(game) {
+    if (game.phase !== TRAIN_PHASES.playing)
+        return [];
+    const seat = game.toPlay;
+    const hand = game.hands[seat];
+    const plays = [];
+    const lastOpen = game.uncovered.length === 0 ? null : game.uncovered[game.uncovered.length - 1];
+    if (lastOpen !== null) {
+        const end = openEnd(game, lastOpen);
+        for (const tile of hand)
+            if (fits(tile, end))
+                plays.push({ tile, train: lastOpen });
+        if (!game.chaining)
+            return plays;
+    }
+    const trains = game.trains.length;
+    for (let train = 0; train < trains; train += 1) {
+        if (lastOpen !== null && game.uncovered.includes(train))
+            continue;
+        if (!mayLayOn(game, seat, train))
+            continue;
+        const end = openEnd(game, train);
+        for (const tile of hand) {
+            if (lastOpen !== null && !isDouble(tile))
+                continue;
+            if (fits(tile, end))
+                plays.push({ tile, train });
+        }
+    }
+    return plays;
+}
+/**
+ * Whether the player to move may lay this tile on this train now: the same
+ * answer `legalPlays` gives, for one tile, without listing every other.
+ */
+export function mayLay(game, tile, train) {
+    if (game.phase !== TRAIN_PHASES.playing || train < 0 || train >= game.trains.length)
+        return false;
+    const seat = game.toPlay;
+    if (!game.hands[seat].includes(tile) || !fits(tile, openEnd(game, train)))
+        return false;
+    const lastOpen = game.uncovered.length === 0 ? null : game.uncovered[game.uncovered.length - 1];
+    if (lastOpen === train)
+        return true;
+    if (lastOpen !== null && (!game.chaining || !isDouble(tile) || game.uncovered.includes(train)))
+        return false;
+    return mayLayOn(game, seat, train);
+}
+/** Whether the player to move has any tile to lay: what decides between laying, drawing and passing. */
+function canLay(game) {
+    const hand = game.hands[game.toPlay];
+    for (let train = 0; train < game.trains.length; train += 1) {
+        const end = openEnd(game, train);
+        for (const tile of hand)
+            if (fits(tile, end) && mayLay(game, tile, train))
+                return true;
+    }
+    return false;
+}
+/** Every move the player to move may make now; none once the game is over. */
+export function trainMoves(game) {
+    if (game.phase === TRAIN_PHASES.finished)
+        return [];
+    if (game.phase === TRAIN_PHASES.roundOver)
+        return [{ kind: "next" }];
+    const plays = legalPlays(game).map(({ tile, train }) => ({ kind: "play", tile, train }));
+    if (plays.length > 0)
+        return plays;
+    return game.boneyard.length > 0 && !game.drew ? [{ kind: "draw" }] : [{ kind: "pass" }];
+}
+/** Every move a game has made, first to last. */
+export function movesOf(game) {
+    const moves = [];
+    for (let link = game.history; link !== null; link = link.before)
+        moves.push(link.move);
+    return moves.reverse();
+}
+/** How many moves a game has made. */
+export function moveCount(game) {
+    return game.history?.count ?? 0;
+}
+/** Each seat's total over every round played: the lowest wins. */
+export function trainTotals(game) {
+    return game.players.map((_, seat) => game.results.reduce((sum, result) => sum + result.pips[seat], 0));
+}
+/** The pips in a hand, which count against its holder when the round ends. */
+export function handPips(hand) {
+    return hand.reduce((sum, tile) => sum + pipsOf(tile), 0);
+}
+/** The round over, scored; the game over too after its last round, its lowest totals the winners. */
+function endRound(game, ending, out) {
+    const result = { engine: game.engine, pips: game.hands.map(handPips), ending, out };
+    const results = [...game.results, result];
+    const finished = results.length >= game.rounds;
+    const totals = trainTotals({ players: game.players, results });
+    const lowest = Math.min(...totals);
+    return {
+        ...game,
+        results,
+        uncovered: [],
+        chaining: false,
+        phase: finished ? TRAIN_PHASES.finished : TRAIN_PHASES.roundOver,
+        winners: finished ? totals.flatMap((total, seat) => (total === lowest ? [seat] : [])) : [],
+    };
+}
+/** The turn passes to the next seat round the table. */
+function nextSeat(game) {
+    return { ...game, toPlay: (game.toPlay + 1) % game.players.length, turn: game.turn + 1, drew: false, chaining: false };
+}
+/** A tile laid: from the hand to the train, turned to fit, and what it leaves to be done this turn. */
+function lay(game, tile, train) {
+    const seat = game.toPlay;
+    const end = openEnd(game, train);
+    const hands = game.hands.map((hand, at) => (at === seat ? hand.filter((one) => one !== tile) : hand));
+    const trains = game.trains.map((one, at) => at === train ? { laid: [...one.laid, laidAgainst(tile, end)], open: at === seat ? false : one.open } : one);
+    const covering = game.uncovered.length > 0 && game.uncovered[game.uncovered.length - 1] === train;
+    const uncovered = covering ? game.uncovered.slice(0, -1) : game.uncovered;
+    const laid = { ...game, hands, trains, uncovered, passes: 0, drew: false };
+    if (hands[seat].length === 0)
+        return endRound(laid, "domino", seat);
+    if (isDouble(tile))
+        return { ...laid, uncovered: [...uncovered, train], chaining: game.options.doubles === TRAIN_DOUBLES.chain };
+    // Covering one of several doubles: the same player goes on covering the rest.
+    if (covering && uncovered.length > 0)
+        return { ...laid, chaining: false };
+    return nextSeat(laid);
+}
+/** Whether a move is one `trainMoves` offers now, asked of that move alone. */
+function allowedNow(game, move) {
+    if (move.kind === "next")
+        return game.phase === TRAIN_PHASES.roundOver;
+    if (game.phase !== TRAIN_PHASES.playing)
+        return false;
+    if (move.kind === "play")
+        return mayLay(game, move.tile, move.train);
+    if (canLay(game))
+        return false;
+    const mayDraw = game.boneyard.length > 0 && !game.drew;
+    return move.kind === "draw" ? mayDraw : !mayDraw;
+}
+/**
+ * The game after that move, or null for a move that may not be made now.
+ * The game given is left untouched, and the move is added to its record.
+ */
+export function playTrain(game, move) {
+    if (!allowedNow(game, move))
+        return null;
+    const seat = game.toPlay;
+    const history = { move, before: game.history, count: (game.history?.count ?? 0) + 1 };
+    const recorded = { ...game, history, last: { seat, move } };
+    switch (move.kind) {
+        case "next":
+            return dealRound(recorded, game.round + 1);
+        case "draw": {
+            const [drawn, ...boneyard] = game.boneyard;
+            const hands = game.hands.map((hand, at) => (at === seat ? [...hand, drawn] : hand));
+            return { ...recorded, hands, boneyard, drew: true };
+        }
+        case "pass": {
+            const trains = game.trains.map((one, at) => (at === seat ? { ...one, open: true } : one));
+            const passes = game.passes + 1;
+            const passed = { ...recorded, trains, passes };
+            if (game.boneyard.length === 0 && passes >= game.players.length)
+                return endRound(passed, "blocked", null);
+            return nextSeat(passed);
+        }
+        case "play":
+            return lay(recorded, move.tile, move.train);
+    }
+}
+/**
+ * A game played again from its table and its moves: what reading a kept game
+ * back does. Null if any move is one the rules would not have taken.
+ */
+export function replayTrain(set, players, seed, options, computers, moves) {
+    let game = startTrain(set, players, seed, options, computers);
+    for (const move of moves) {
+        if (game === null)
+            return null;
+        game = playTrain(game, move);
+    }
+    return game;
+}
+/** The same table again, the same seats and options, with a fresh shuffle. */
+export function trainAgain(game, seed) {
+    return startTrain(game.set, game.players, seed, game.options, game.computers);
+}
+/** A seat's name as the table reads it: the one given, or "Computer 3" for a computer's seat left blank, "Player 3" for a person's. */
+export function trainPlayerName(game, seat) {
+    const given = game.players[seat]?.trim() ?? "";
+    if (given !== "")
+        return given;
+    return `${game.computers[seat] ? "Computer" : "Player"} ${seat + 1}`;
+}
+/** The seats a person plays: a table with two or more of them passes the device, and covers each hand between turns. */
+export function peopleAt(game) {
+    return game.computers.flatMap((computer, seat) => (computer ? [] : [seat]));
+}

package/dist/mexicanTrain/mexicanTrain.types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Mexican Train, as its rules module (`mexicanTrain.ts`) speaks of it.
+ *
+ * A TILE IS A NUMBER: `low * 16 + high`, its two ends with the smaller first,
+ * so the set's every tile is one small integer and a hand is a list of them.
+ * Sixteen, because the largest set offered is double-fifteen (`tileOf`).
+ *
+ * A TILE LAID IN A TRAIN IS A NUMBER TOO: `from * 16 + to`, the end that
+ * touches the train first. `to` is the end the next tile must match, so a
+ * train's open end is the last laid tile's `to`, or the round's engine double
+ * when nothing has been laid on it yet.
+ *
+ * THE TRAINS ARE NUMBERED BY SEAT: train `s` is seat `s`'s own, and train
+ * `players.length` is the Mexican Train, which belongs to nobody and is open
+ * to everybody.
+ */
+/** Who sits where: 0 is the first player, round the table in the order the set-up named them. */
+export type TrainSeat = number;
+/** A domino in a hand or the boneyard: `low * 16 + high`. */
+export type Domino = number;
+/** A domino laid in a train, turned so its `from` end touches the train: `from * 16 + to`. */
+export type LaidDomino = number;
+/**
+ * How a double is dealt with, the table's one house rule about them.
+ *
+ * - `one` (the default, as most published rules play it): a double must be
+ *   covered before anything else is played anywhere, and whoever laid it lays
+ *   again to cover it.
+ * - `chain`: after laying a double you may lay another double in the same
+ *   turn, anywhere one fits, before covering; then every double left open is
+ *   covered, the last laid first, before anything else is played.
+ */
+export type DoublesRule = "one" | "chain";
+/**
+ * When the Mexican Train may be started.
+ *
+ * - `any` (the default): on any turn, by anybody, as most published rules say.
+ * - `ownFirst`: a player may lay on the Mexican Train only once their own
+ *   train has been started, the common house rule that keeps a first turn
+ *   about your own train.
+ */
+export type MexicanStart = "any" | "ownFirst";
+/** How many rounds: all of them, one for every double from the set's highest down to double blank, or half as many. */
+export type TrainLength = "full" | "short";
+/** What the set-up chose, beyond the set and the players. */
+export type TrainOptions = {
+    length: TrainLength;
+    doubles: DoublesRule;
+    mexican: MexicanStart;
+};
+/** A train on the table: the tiles laid on it in order, and whether its owner's marker says anybody may play on it. */
+export type Train = {
+    laid: readonly LaidDomino[];
+    /** Open to everybody: the Mexican Train always, a player's own once they could not play. */
+    open: boolean;
+};
+/**
+ * One move at the table.
+ *
+ * - `play`: lay a tile from your hand on a train.
+ * - `draw`: take one tile from the boneyard, when you have nothing to play.
+ * - `pass`: nothing to play and nothing to draw (or the tile drawn will not
+ *   go): your train's marker goes on, and the turn passes.
+ * - `next`: a round is over and everybody has seen how it went; deal the next.
+ */
+export type TrainMove = {
+    kind: "play";
+    tile: Domino;
+    train: number;
+} | {
+    kind: "draw";
+} | {
+    kind: "pass";
+} | {
+    kind: "next";
+};
+/** One link of a game's record: a move, and every move before it. */
+export type TrainHistory = {
+    readonly move: TrainMove;
+    readonly before: TrainHistory | null;
+    /** How many moves the record holds, this one included. */
+    readonly count: number;
+};
+export type TrainPhase = "playing" | "roundOver" | "finished";
+/** Why a round ended: somebody played their last tile, or nobody could play and nothing was left to draw. */
+export type RoundEnding = "domino" | "blocked";
+/** A round's result, kept for the table of scores. */
+export type RoundResult = {
+    /** The round's engine double, by its number: 12 for double-twelve. */
+    engine: number;
+    /** Pips left in each seat's hand when it ended: that round's score. */
+    pips: readonly number[];
+    ending: RoundEnding;
+    /** The seat that played out, on a round that ended that way. */
+    out: TrainSeat | null;
+};
+/**
+ * A game, as its table and moves make it. Only the set, the options, the
+ * seed, the seats and the moves are ever kept (`encodeTrain`); everything
+ * else is read again from them (`replayTrain`), so a kept game can never hold
+ * a hand or a train its moves do not make, and a reload cannot deal again.
+ */
+export type TrainGame = {
+    /** The set, by its highest double: 9, 12 or 15. The party game's "board size". */
+    set: number;
+    options: TrainOptions;
+    /** What every shuffle of this game is drawn from. */
+    seed: number;
+    /** The names given at the table, in seat order: "" for one left blank. */
+    players: readonly string[];
+    /** Which seats a computer plays. */
+    computers: readonly boolean[];
+    /**
+     * Every move made, the last first, each pointing at the record before it:
+     * the game's whole record (`movesOf` reads it out in order). A chain rather
+     * than a list, so a move adds one link and copies nothing — a double-fifteen
+     * game runs to thousands of moves, and a list copied on every one of them
+     * is millions of copies a game.
+     */
+    history: TrainHistory | null;
+    /** How many rounds this game plays, and which one is being played (0 for the first). */
+    rounds: number;
+    round: number;
+    /** The engine double's number this round: the set's highest in the first, one fewer each round after. */
+    engine: number;
+    hands: readonly (readonly Domino[])[];
+    /** Every seat's train, then the Mexican Train last. */
+    trains: readonly Train[];
+    /** The tiles still face down, in the order they will be drawn. */
+    boneyard: readonly Domino[];
+    toPlay: TrainSeat;
+    /**
+     * Trains whose last tile is a double not yet covered, the last laid last:
+     * while any is open, the only play anywhere is to cover the last of them.
+     */
+    uncovered: readonly number[];
+    /** The player to move laid a double this turn and may still lay another before covering (`chain` only). */
+    chaining: boolean;
+    /** The player to move has drawn this turn: the tile drawn must be played if it can, or they pass. */
+    drew: boolean;
+    /** Turns passed in a row with nothing played: a whole table of them with the boneyard empty ends the round. */
+    passes: number;
+    /** Counts every change of the player to move: a new number is a new turn, and a covered hand to pass on. */
+    turn: number;
+    phase: TrainPhase;
+    results: readonly RoundResult[];
+    /** On a finished game, every seat with the lowest total. */
+    winners: readonly TrainSeat[];
+    /** The last move played, for the line that says what just happened. */
+    last: {
+        seat: TrainSeat;
+        move: TrainMove;
+    } | null;
+};

package/dist/mexicanTrain/mexicanTrain.types.js

@@ -0,0 +1,17 @@
+/**
+ * Mexican Train, as its rules module (`mexicanTrain.ts`) speaks of it.
+ *
+ * A TILE IS A NUMBER: `low * 16 + high`, its two ends with the smaller first,
+ * so the set's every tile is one small integer and a hand is a list of them.
+ * Sixteen, because the largest set offered is double-fifteen (`tileOf`).
+ *
+ * A TILE LAID IN A TRAIN IS A NUMBER TOO: `from * 16 + to`, the end that
+ * touches the train first. `to` is the end the next tile must match, so a
+ * train's open end is the last laid tile's `to`, or the round's engine double
+ * when nothing has been laid on it yet.
+ *
+ * THE TRAINS ARE NUMBERED BY SEAT: train `s` is seat `s`'s own, and train
+ * `players.length` is the Mexican Train, which belongs to nobody and is open
+ * to everybody.
+ */
+export {};

package/dist/mexicanTrain/trainCodec.d.ts

@@ -0,0 +1,4 @@
+import type { TrainGame } from "./mexicanTrain.types.ts";
+export declare function encodeTrain(game: TrainGame): string;
+/** A kept game read back, or null for nothing kept or anything these rules cannot play out again. */
+export declare function decodeTrain(text: string | null): TrainGame | null;

package/dist/mexicanTrain/trainCodec.js

@@ -0,0 +1,90 @@
+// Relative, like the rest of lib/party: the browser specs import this, and Playwright resolves no alias.
+import { TRAIN_DOUBLES, TRAIN_LENGTHS, TRAIN_MEXICAN } from "./mexicanTrain.constants.js";
+import { movesOf, replayTrain } from "./mexicanTrain.js";
+/**
+ * A GAME OF MEXICAN TRAIN AS TEXT, and back: what the table keeps in this
+ * browser after every move. Only the table and the moves are written — never
+ * a hand, a train or the boneyard, which the moves make again from the seed
+ * (`replayTrain`) — so what is read back is exactly the game those moves
+ * make, or nothing at all.
+ *
+ * A move is a few characters: `p<tile>.<train>` for a tile laid, `d` for a
+ * draw, `x` for a pass, `n` for the next round dealt.
+ */
+/** The version this text is written in: a kept game of any other is not read. */
+const VERSION = 1;
+function moveText(move) {
+    switch (move.kind) {
+        case "play":
+            return `p${move.tile}.${move.train}`;
+        case "draw":
+            return "d";
+        case "pass":
+            return "x";
+        case "next":
+            return "n";
+    }
+}
+function moveOf(text) {
+    if (text === "d")
+        return { kind: "draw" };
+    if (text === "x")
+        return { kind: "pass" };
+    if (text === "n")
+        return { kind: "next" };
+    const played = /^p(\d+)\.(\d+)$/.exec(text);
+    return played === null ? null : { kind: "play", tile: Number(played[1]), train: Number(played[2]) };
+}
+export function encodeTrain(game) {
+    return JSON.stringify({
+        v: VERSION,
+        set: game.set,
+        options: game.options,
+        seed: game.seed,
+        players: game.players,
+        computers: game.computers,
+        moves: movesOf(game).map(moveText).join(","),
+    });
+}
+const isString = (value) => typeof value === "string";
+function optionsOf(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const { length, doubles, mexican } = value;
+    if (!Object.values(TRAIN_LENGTHS).includes(length))
+        return null;
+    if (!Object.values(TRAIN_DOUBLES).includes(doubles))
+        return null;
+    if (!Object.values(TRAIN_MEXICAN).includes(mexican))
+        return null;
+    return { length, doubles, mexican };
+}
+/** A kept game read back, or null for nothing kept or anything these rules cannot play out again. */
+export function decodeTrain(text) {
+    if (text === null)
+        return null;
+    let kept;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        kept = parsed;
+    }
+    catch {
+        return null;
+    }
+    const { v, set, seed, players, computers, moves } = kept;
+    const options = optionsOf(kept.options);
+    if (v !== VERSION || typeof set !== "number" || typeof seed !== "number" || options === null)
+        return null;
+    if (!Array.isArray(players) || !players.every(isString))
+        return null;
+    if (!Array.isArray(computers) || !computers.every((one) => typeof one === "boolean"))
+        return null;
+    if (!isString(moves))
+        return null;
+    const parsedMoves = moves === "" ? [] : moves.split(",").map(moveOf);
+    if (parsedMoves.some((move) => move === null))
+        return null;
+    return replayTrain(set, players, seed, options, computers, parsedMoves);
+}

package/dist/mexicanTrain/trainComputer.d.ts

@@ -0,0 +1,10 @@
+import type { Domino, TrainGame, TrainMove } from "./mexicanTrain.types.ts";
+/**
+ * The longest run of tiles from `hand` that can be laid one after another
+ * against `end`, in the order they would be laid. A depth-first search over
+ * the hand, bounded by `PLAN_STEPS`, preferring the heavier run of two the
+ * same length: pips laid are pips that do not count.
+ */
+export declare function longestRun(hand: readonly Domino[], end: number): Domino[];
+/** The move the computer in the seat to move makes now: the best-scored lay, or the draw, pass or next round it must take. */
+export declare function computerMove(game: TrainGame): TrainMove;