@johnmorrisdotca/domino 1.0.0 → 1.1.1

package/dist/strings.js

@@ -0,0 +1,214 @@
+/**
+ * Every word Domino says to a person, in English and Japanese: what a table
+ * says (whose turn it is, what was laid, how the round ended) and what the
+ * command line says. One table, so the two languages are kept side by side
+ * and a test can hold them together. `{n}`, `{who}` and the other braces are
+ * filled in with `dominoSay`; a table of your own must keep them.
+ */
+/** Every string, in both languages. The Japanese has not yet been read by a native reader. */
+export const DOMINO_STRINGS = {
+    en: {
+        set9: "Double-nine",
+        set12: "Double-twelve",
+        set15: "Double-fifteen",
+        lengthFull: "Every double",
+        lengthShort: "Short",
+        doublesOne: "Cover one",
+        doublesChain: "Chain",
+        mexicanAny: "Anyone, any time",
+        mexicanOwnFirst: "After your own",
+        you: "You",
+        computer: "Computer {n}",
+        player: "Player {n}",
+        mexican: "Mexican Train",
+        trainYours: "Your train",
+        trainOf: "{who}'s train",
+        open: "open",
+        closed: "closed",
+        tilesLeft: "{n} left",
+        boneyard: "Boneyard: {n}",
+        round: "Round {n} of {total}, hub double {engine}",
+        needs: "Next: {n}",
+        hub: "Hub",
+        total: "Total",
+        pips: "{n} pips",
+        layHere: "Lay here",
+        draw: "Draw a tile",
+        pass: "Pass",
+        nextRound: "Next round",
+        again: "Play again",
+        yourTurn: "Your turn. Tap a tile to lay it.",
+        yourTurnCover: "Your turn. Cover the double.",
+        yourTurnDraw: "Nothing fits. Draw a tile.",
+        yourTurnPass: "Nothing fits. Pass.",
+        yourTurnChoose: "Choose a train for the tile.",
+        thinking: "{who} to play.",
+        roundOver: "Round over. {why}",
+        outBy: "{who} played out.",
+        blocked: "Nobody can play.",
+        gameOver: "Game over. {who} won with {pips} pips.",
+        laid: "{who} laid {tile} on {train}.",
+        drew: "{who} drew a tile.",
+        passed: "{who} passed.",
+        dealt: "Round {n} dealt: the hub double is {engine}.",
+        cliUsage: `Usage: domino <command> [options]
+
+Dominoes and Mexican Train: the same deal for the same seed, on every machine.
+
+  domino deal --seed 2026 --players 4      the deal a seed makes: every hand, and the hub double
+  domino play --seed 2026 --players 4      a game played out by computers, with its scores
+  domino play --seed 2026 --moves          ...and every move, in words
+  domino play --seed 2026 --save           ...and the saved game, as text
+  domino check "<saved game>"              read a saved game back through the rules, and say where it stands
+  domino replay "<saved game>"             every move of a saved game, in words
+
+Options:
+      --set <9|12|15>        the set, by its highest double (12 unless said)
+      --players <2..8>       how many sit at the table (4 unless said)
+  -s, --seed <n>             a whole number (one is drawn, and named on standard error, unless given)
+      --length <full|short>  every round, or half of them (full unless said)
+      --doubles <one|chain>  cover each double at once, or chain doubles (one unless said)
+      --mexican <any|own-first>
+                             the Mexican Train open to all, or only once you have laid on your own
+      --moves                play: print every move
+      --save                 play: print the saved game on the last line
+      --stdin                check, replay: read the saved game from standard input
+  -j, --json                 print JSON (format 1) for deal, play and check
+      --lang <en|ja>         English or Japanese (default: your system's)
+  -h, --help                 this help
+  -v, --version              the version
+
+Exit codes: 0 done, 1 what was asked for could not be done (a saved game the
+rules refuse), 2 the command was wrong.
+`,
+        cliUnknown: "unknown option {part}",
+        cliNeeds: "{part} needs a value",
+        cliTryHelp: "Try `domino --help`.",
+        cliLangBad: "--lang takes en or ja",
+        cliNoCommand: "say what to do: deal, play, check or replay",
+        cliCommandBad: "“{part}” is not a command: deal, play, check or replay",
+        cliSetBad: "--set takes 9, 12 or 15",
+        cliPlayersBad: "--players takes a whole number from 2 to 8",
+        cliSeedBad: "--seed takes a whole number from 0 to 4294967295",
+        cliValueBad: "{part} takes one of: {choices}",
+        cliNoSaved: "there is no saved game to read: give it after the command, or with --stdin",
+        cliSavedBad: "that is not a game these rules can play out again",
+        cliFresh: "seed {seed} (pass --seed {seed} to repeat this)",
+        cliDeal: "{set}, {players} players, seed {seed}",
+        cliSeat: "{who}: {tiles}",
+        cliBoneyard: "Boneyard: {n} tiles",
+        cliPlayed: "{set}, {players} players, seed {seed}, {rounds} rounds; moves made: {moves}",
+        cliWinner: "Winner: {who} with {pips} pips.",
+        cliWinners: "Winners: {who}, each with {pips} pips.",
+        cliSaved: "Saved game:",
+        cliPhasePlaying: "Round {n} of {total} is being played; {who} is to play.",
+        cliPhaseRoundOver: "Round {n} of {total} is over; the next is to be dealt.",
+        cliPhaseFinished: "The game is over.",
+    },
+    ja: {
+        set9: "ダブルナイン",
+        set12: "ダブルトゥエルブ",
+        set15: "ダブルフィフティーン",
+        lengthFull: "すべてのダブル",
+        lengthShort: "短め",
+        doublesOne: "1枚で覆う",
+        doublesChain: "連続",
+        mexicanAny: "いつでも誰でも",
+        mexicanOwnFirst: "自分の道のあと",
+        you: "あなた",
+        computer: "コンピューター{n}",
+        player: "プレイヤー{n}",
+        mexican: "メキシカントレイン",
+        trainYours: "あなたの道",
+        trainOf: "{who}の道",
+        open: "開放",
+        closed: "閉鎖",
+        tilesLeft: "残り{n}枚",
+        boneyard: "山: {n}枚",
+        round: "第{n}ラウンド（全{total}）、ハブのダブル {engine}",
+        needs: "次: {n}",
+        hub: "ハブ",
+        total: "合計",
+        pips: "{n}点",
+        layHere: "ここに置く",
+        draw: "1枚引く",
+        pass: "パス",
+        nextRound: "次のラウンド",
+        again: "もう一度",
+        yourTurn: "あなたの番です。牌をタップして置きます。",
+        yourTurnCover: "あなたの番です。ダブルを覆ってください。",
+        yourTurnDraw: "置ける牌がありません。1枚引いてください。",
+        yourTurnPass: "置ける牌がありません。パスしてください。",
+        yourTurnChoose: "牌を置く道を選んでください。",
+        thinking: "{who}の番です。",
+        roundOver: "ラウンド終了。{why}",
+        outBy: "{who}が出し切りました。",
+        blocked: "誰も置けません。",
+        gameOver: "ゲーム終了。{who}の勝ち（{pips}点）。",
+        laid: "{who}が{tile}を{train}に置きました。",
+        drew: "{who}が1枚引きました。",
+        passed: "{who}はパスしました。",
+        dealt: "第{n}ラウンドを配りました。ハブのダブルは{engine}です。",
+        cliUsage: `使い方: domino <コマンド> [オプション]
+
+ドミノとメキシカントレイン。同じシードなら、どの環境でも同じ配りになります。
+
+  domino deal --seed 2026 --players 4      シードが作る配り（全員の手牌とハブのダブル）
+  domino play --seed 2026 --players 4      コンピューターだけで最後まで遊び、得点を表示
+  domino play --seed 2026 --moves          ...さらに、すべての手を言葉で表示
+  domino play --seed 2026 --save           ...さらに、保存したゲームをテキストで表示
+  domino check "<保存したゲーム>"          保存したゲームをルールどおりに読み直し、状況を表示
+  domino replay "<保存したゲーム>"         保存したゲームのすべての手を言葉で表示
+
+オプション:
+      --set <9|12|15>        セット（最大のダブルで指定。指定なしは12）
+      --players <2..8>       卓の人数（指定なしは4）
+  -s, --seed <n>             整数（指定がなければ決めて、標準エラーに表示します）
+      --length <full|short>  すべてのラウンド、またはその半分（指定なしは full）
+      --doubles <one|chain>  ダブルをすぐ覆う、または連続で出せる（指定なしは one）
+      --mexican <any|own-first>
+                             メキシカントレインを誰でも使える、または自分の道に置いたあと
+      --moves                play: すべての手を表示
+      --save                 play: 最後の行に保存したゲームを表示
+      --stdin                check, replay: 保存したゲームを標準入力から読む
+  -j, --json                 deal, play, check の結果をJSON（形式1）で表示
+      --lang <en|ja>         英語または日本語（指定なしはシステムの言語）
+  -h, --help                 このヘルプ
+  -v, --version              バージョン
+
+終了コード: 0 完了、1 できなかった（ルールが受け付けない保存ゲーム）、
+2 コマンドの誤り。
+`,
+        cliUnknown: "不明なオプションです: {part}",
+        cliNeeds: "{part} には値が必要です",
+        cliTryHelp: "`domino --help` をご覧ください。",
+        cliLangBad: "--lang は en か ja です",
+        cliNoCommand: "コマンドを指定してください: deal, play, check, replay",
+        cliCommandBad: "「{part}」はコマンドではありません: deal, play, check, replay",
+        cliSetBad: "--set は 9、12、15 のいずれかです",
+        cliPlayersBad: "--players は2〜8の整数です",
+        cliSeedBad: "--seed は0〜4294967295の整数です",
+        cliValueBad: "{part} は次のいずれかです: {choices}",
+        cliNoSaved: "読む保存ゲームがありません。コマンドの後ろに書くか、--stdin を使ってください",
+        cliSavedBad: "このルールでは最後まで再現できないゲームです",
+        cliFresh: "シード {seed}（--seed {seed} で同じ結果を再現できます）",
+        cliDeal: "{set}、{players}人、シード {seed}",
+        cliSeat: "{who}: {tiles}",
+        cliBoneyard: "山: {n}枚",
+        cliPlayed: "{set}、{players}人、シード {seed}、{rounds}ラウンド、手数: {moves}",
+        cliWinner: "勝者: {who}（{pips}点）。",
+        cliWinners: "勝者: {who}（それぞれ{pips}点）。",
+        cliSaved: "保存したゲーム:",
+        cliPhasePlaying: "第{n}ラウンド（全{total}）の途中です。{who}の番です。",
+        cliPhaseRoundOver: "第{n}ラウンド（全{total}）が終わりました。次のラウンドを配ります。",
+        cliPhaseFinished: "ゲームは終了しています。",
+    },
+};
+/** A string with its braces filled in from `values`; a brace with no value is left as it is. */
+export function dominoSay(text, values = {}) {
+    return text.replace(/\{(\w+)\}/g, (whole, name) => (name in values ? String(values[name]) : whole));
+}
+/** The language a person asked for, by `en` or `ja` or a tag that begins with one: English for anything else. */
+export function dominoLanguage(tag) {
+    return (tag ?? "en").toLowerCase().startsWith("ja") ? "ja" : "en";
+}

package/dist/tile-sounds.d.ts

@@ -0,0 +1,68 @@
+/**
+ * THE SOUNDS OF A DOMINO TABLE: tiles shuffled, a tile drawn from the
+ * boneyard, a tile laid, a knock on the table for a pass. The recordings are
+ * poker chips set down and handled (Kenney's Casino Audio, CC0; see
+ * docs/credits.md), the nearest recorded sound of a hard tile on a table that
+ * is free to use. They are loaded the first time a sound is played and never
+ * before, so a page that stays silent never fetches them. Where they cannot be
+ * loaded or decoded, a short sound made in the browser stands in. Nothing here
+ * throws: a platform with no audio, a context the browser holds still, or a
+ * failed decode is simply silent.
+ *
+ * Domino never makes a sound by itself. A table asks for one with `play`.
+ */
+/** Every kind of sound, in the order a game meets them. */
+export declare const TILE_SOUND_KINDS: readonly ["shuffle", "draw", "lay", "knock"];
+/** One kind of sound: `shuffle` the tiles stirred face down, `draw` a tile taken from the boneyard, `lay` a tile set down on a train, `knock` a rap on the table, which is how a pass is announced. */
+export type TileSoundKind = (typeof TILE_SOUND_KINDS)[number];
+/** The recordings, by name (`lay-2`), as base64 AAC. */
+export type TileSoundData = Readonly<Record<string, string>>;
+/** The parts of a window the sounds use: an audio context and `atob`. Any of them may be missing. */
+export type TileSoundWindow = {
+    AudioContext?: typeof AudioContext;
+    webkitAudioContext?: typeof AudioContext;
+    atob?: (text: string) => string;
+};
+/** How a table's sounds are made. Every field may be left out. */
+export type TileSoundsOptions = {
+    /** Start muted: nothing plays, and nothing is fetched, until `setMuted(false)`. Unless said, not muted. */
+    muted?: boolean;
+    /** How loud, from 0 to 1. Unless said, 0.6. */
+    volume?: number;
+    /** Where the recordings come from: the package's own module unless another is handed in. */
+    load?: () => Promise<{
+        TILE_SOUND_DATA: TileSoundData;
+    }>;
+    /** The window to make sound in: the page's own unless another is handed in (a test's, or none for silence). */
+    window?: TileSoundWindow | null;
+};
+/** How one sound is played. */
+export type PlayTileSoundOptions = {
+    /** How many tiles: `draw` with 7 is seven tiles taken one after another (heard as at most `MOST_SOUNDS_AT_ONCE`). Unless said, one. */
+    count?: number;
+    /** Milliseconds between one tile's sound and the next. Unless said, 85. */
+    gap?: number;
+    /** Milliseconds to wait before the first. Unless said, none. */
+    delay?: number;
+};
+/** A table's sounds: `play` one, mute and unmute, change the volume, `close` when the table goes. */
+export type TileSounds = {
+    /** Play a sound, or several of one kind in a row; nothing while muted or closed. */
+    play(kind: TileSoundKind, options?: PlayTileSoundOptions): void;
+    /** Fetch and decode the recordings now, rather than at the first sound. True once they are ready; false where they cannot be had. */
+    load(): Promise<boolean>;
+    /** Whether it is muted. */
+    readonly muted: boolean;
+    /** Mute or unmute. Muting stops nothing already playing; it only keeps anything new from starting. */
+    setMuted(muted: boolean): void;
+    /** How loud, from 0 to 1. */
+    volume: number;
+    /** Stop for good, and let the audio context go. */
+    close(): void;
+};
+/** As many sounds as one call plays: fifteen tiles drawn are eight clicks, not a wall of noise. */
+export declare const MOST_SOUNDS_AT_ONCE = 8;
+/** When each of `count` sounds starts, in milliseconds from the first: one every `gap`, and no more than `MOST_SOUNDS_AT_ONCE`, spread over the same time. */
+export declare function soundTimes(count: number, gap?: number): number[];
+/** A table's tile sounds. Nothing is fetched and no audio context is made until the first sound. */
+export declare function createTileSounds(options?: TileSoundsOptions): TileSounds;

package/dist/tile-sounds.js

@@ -0,0 +1,212 @@
+/**
+ * THE SOUNDS OF A DOMINO TABLE: tiles shuffled, a tile drawn from the
+ * boneyard, a tile laid, a knock on the table for a pass. The recordings are
+ * poker chips set down and handled (Kenney's Casino Audio, CC0; see
+ * docs/credits.md), the nearest recorded sound of a hard tile on a table that
+ * is free to use. They are loaded the first time a sound is played and never
+ * before, so a page that stays silent never fetches them. Where they cannot be
+ * loaded or decoded, a short sound made in the browser stands in. Nothing here
+ * throws: a platform with no audio, a context the browser holds still, or a
+ * failed decode is simply silent.
+ *
+ * Domino never makes a sound by itself. A table asks for one with `play`.
+ */
+/** Every kind of sound, in the order a game meets them. */
+export const TILE_SOUND_KINDS = ["shuffle", "draw", "lay", "knock"];
+/** As many sounds as one call plays: fifteen tiles drawn are eight clicks, not a wall of noise. */
+export const MOST_SOUNDS_AT_ONCE = 8;
+/** When each of `count` sounds starts, in milliseconds from the first: one every `gap`, and no more than `MOST_SOUNDS_AT_ONCE`, spread over the same time. */
+export function soundTimes(count, gap = 85) {
+    const whole = Math.max(1, Math.floor(Number.isFinite(count) ? count : 1));
+    const span = (whole - 1) * Math.max(0, gap);
+    const heard = Math.min(whole, MOST_SOUNDS_AT_ONCE);
+    if (heard === 1)
+        return [0];
+    return Array.from({ length: heard }, (_, at) => Math.round((at * span) / (heard - 1)));
+}
+const clampVolume = (value) => (Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0.6);
+function bytesOf(base64, atob) {
+    const text = atob(base64);
+    const bytes = new Uint8Array(text.length);
+    for (let i = 0; i < text.length; i++)
+        bytes[i] = text.charCodeAt(i);
+    return bytes.buffer;
+}
+/** Decoding as a promise, on browsers that take callbacks and on those that return one. */
+function decode(ctx, data) {
+    return new Promise((resolve, reject) => {
+        const pending = ctx.decodeAudioData(data, resolve, reject);
+        if (pending !== undefined && typeof pending.then === "function")
+            pending.then(resolve, reject);
+    });
+}
+/** What a sound made here is like, for when the recordings cannot be had: bursts of noise, each band-passed and cut off fast. */
+const MADE = {
+    lay: { ticks: 1, over: 0, length: 0.04, pitch: 2200 },
+    draw: { ticks: 2, over: 0.04, length: 0.035, pitch: 1800 },
+    knock: { ticks: 1, over: 0, length: 0.05, pitch: 1100 },
+    shuffle: { ticks: 18, over: 0.9, length: 0.03, pitch: 2000 },
+};
+/** A table's tile sounds. Nothing is fetched and no audio context is made until the first sound. */
+export function createTileSounds(options = {}) {
+    const win = options.window === null ? undefined : (options.window ?? (typeof window === "undefined" ? undefined : window));
+    const load = options.load ?? (() => import("./sounds.js"));
+    let muted = options.muted === true;
+    let volume = clampVolume(options.volume ?? 0.6);
+    let ctx = null;
+    let out = null;
+    let loaded = null;
+    let closed = false;
+    function context() {
+        if (ctx !== null)
+            return ctx;
+        const Context = win?.AudioContext ?? win?.webkitAudioContext;
+        if (Context === undefined)
+            return null;
+        ctx = new Context();
+        out = ctx.createGain();
+        out.gain.value = volume;
+        out.connect(ctx.destination);
+        return ctx;
+    }
+    function recordings(audio) {
+        loaded ?? (loaded = (async () => {
+            try {
+                const atob = win?.atob ?? globalThis.atob;
+                const { TILE_SOUND_DATA } = await load();
+                const names = Object.keys(TILE_SOUND_DATA).sort();
+                const buffers = await Promise.all(names.map((name) => decode(audio, bytesOf(TILE_SOUND_DATA[name], atob))));
+                const made = {};
+                names.forEach((name, at) => {
+                    const kind = name.replace(/-\d+$/, "");
+                    if (TILE_SOUND_KINDS.includes(kind))
+                        (made[kind] ?? (made[kind] = [])).push(buffers[at]);
+                });
+                return Object.keys(made).length > 0 ? made : null;
+            }
+            catch {
+                return null;
+            }
+        })());
+        return loaded;
+    }
+    function recorded(audio, buffer, at, gain) {
+        const source = audio.createBufferSource();
+        source.buffer = buffer;
+        source.playbackRate.value = 0.94 + Math.random() * 0.12;
+        const level = audio.createGain();
+        level.gain.value = gain;
+        source.connect(level);
+        level.connect(out);
+        source.start(at);
+    }
+    function madeHere(audio, kind, at, gain) {
+        const shape = MADE[kind];
+        const length = Math.max(1, Math.round(audio.sampleRate * shape.length));
+        for (let tick = 0; tick < shape.ticks; tick++) {
+            const buffer = audio.createBuffer(1, length, audio.sampleRate);
+            const data = buffer.getChannelData(0);
+            for (let i = 0; i < length; i++)
+                data[i] = (Math.random() * 2 - 1) * (1 - i / length) ** 3;
+            const source = audio.createBufferSource();
+            source.buffer = buffer;
+            const band = audio.createBiquadFilter();
+            band.type = "bandpass";
+            band.frequency.value = shape.pitch * (0.9 + Math.random() * 0.2);
+            band.Q.value = 1.2;
+            const level = audio.createGain();
+            level.gain.value = gain * 1.4;
+            source.connect(band);
+            band.connect(level);
+            level.connect(out);
+            source.start(at + (shape.ticks === 1 ? 0 : (tick * shape.over) / (shape.ticks - 1)) + Math.random() * 0.006);
+        }
+    }
+    function schedule(audio, sounds, kind, times, began) {
+        const pick = (list) => list[Math.floor(Math.random() * list.length)];
+        const each = 0.9 / Math.sqrt(times.length);
+        // The first sound waits for the recordings to be fetched and decoded; the rest keep their spacing from it, so nothing is lost or bunched.
+        const late = Math.max(0, audio.currentTime - began);
+        for (const ms of times) {
+            const at = began + late + ms / 1000;
+            const gain = each * (0.8 + Math.random() * 0.4);
+            const takes = sounds?.[kind];
+            if (takes !== undefined && takes.length > 0)
+                recorded(audio, pick(takes), at, gain);
+            else
+                madeHere(audio, kind, at, gain);
+        }
+    }
+    return {
+        play(kind, how = {}) {
+            if (closed || muted || !TILE_SOUND_KINDS.includes(kind))
+                return;
+            try {
+                const audio = context();
+                if (audio === null)
+                    return;
+                const times = soundTimes(how.count ?? 1, how.gap ?? 85).map((ms) => ms + Math.max(0, how.delay ?? 0));
+                const go = () => {
+                    const began = audio.currentTime;
+                    void recordings(audio).then((sounds) => {
+                        try {
+                            if (!closed && !muted)
+                                schedule(audio, sounds, kind, times, began);
+                        }
+                        catch {
+                            // A node that will not start is a tile without its sound, nothing more.
+                        }
+                    });
+                };
+                // A browser holds a context still until the page has been touched; a sound asked for by code before then stays silent.
+                if (audio.state === "running")
+                    go();
+                else
+                    void audio.resume().then(() => {
+                        if (audio.state === "running")
+                            go();
+                    }, () => undefined);
+            }
+            catch {
+                // No audio here, or none allowed: the game goes on.
+            }
+        },
+        async load() {
+            if (closed)
+                return false;
+            try {
+                const audio = context();
+                if (audio === null)
+                    return false;
+                return (await recordings(audio)) !== null;
+            }
+            catch {
+                return false;
+            }
+        },
+        get muted() {
+            return muted;
+        },
+        setMuted(next) {
+            muted = next === true;
+        },
+        get volume() {
+            return volume;
+        },
+        set volume(next) {
+            volume = clampVolume(next);
+            if (out !== null)
+                out.gain.value = volume;
+        },
+        close() {
+            closed = true;
+            try {
+                void ctx?.close().catch(() => undefined);
+            }
+            catch {
+                // Already closed.
+            }
+            ctx = null;
+        },
+    };
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version. */
-export declare const VERSION = "1.0.0";
+export declare const VERSION = "1.1.1";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version. */
-export const VERSION = "1.0.0";
+export const VERSION = "1.1.1";

package/dist/words.d.ts

@@ -0,0 +1,26 @@
+import type { TrainGame, TrainSeat } from "./mexicanTrain/mexicanTrain.types.ts";
+import { type Language } from "./strings.ts";
+/**
+ * A TABLE'S WORDS, in English or Japanese: who is who, what just happened,
+ * and what is wanted of whoever is to play. They read a game and say what its
+ * rules have already decided, so they can never disagree with the rules; a
+ * table draws them under its trains, and the command line prints them.
+ *
+ * `you` is the seat of the person at this device. Where there is none (a
+ * computers-only game, or a command line) it is left out, and every seat is
+ * named the same way.
+ */
+/** The set's name by its highest double ("Double-twelve"), or null for a number that is no set offered. */
+export declare function trainSetLabel(set: number, language: Language): string | null;
+/** A seat's name: the one given at the table, or "You" for the person at this device, or "Computer 3" or "Player 3" for the seat's number. */
+export declare function trainSeatName(game: Pick<TrainGame, "players" | "computers">, seat: TrainSeat, language: Language, you?: TrainSeat): string;
+/** A train's name: "Your train", "Computer 2's train", or the Mexican Train. */
+export declare function trainName(game: Pick<TrainGame, "players" | "computers">, train: number, language: Language, you?: TrainSeat): string;
+/** What the last move did, in a line, or "" before there is one: "Computer 2 laid 9–4 on Your train." */
+export declare function trainNews(game: TrainGame, language: Language, you?: TrainSeat): string;
+/**
+ * What is going on, in a line: who is to play, or what the person at `you` is
+ * asked to do (lay, cover a double, draw, pass), or how the round or the game
+ * ended.
+ */
+export declare function trainStatus(game: TrainGame, language: Language, you?: TrainSeat): string;

package/dist/words.js

@@ -0,0 +1,83 @@
+import { tileWords } from "./mexicanTrain/dominoes.js";
+import { TRAIN_PHASES, mexicanOf, trainMoves, trainTotals } from "./mexicanTrain/mexicanTrain.js";
+import { DOMINO_STRINGS, dominoSay } from "./strings.js";
+/**
+ * A TABLE'S WORDS, in English or Japanese: who is who, what just happened,
+ * and what is wanted of whoever is to play. They read a game and say what its
+ * rules have already decided, so they can never disagree with the rules; a
+ * table draws them under its trains, and the command line prints them.
+ *
+ * `you` is the seat of the person at this device. Where there is none (a
+ * computers-only game, or a command line) it is left out, and every seat is
+ * named the same way.
+ */
+/** The set's name by its highest double ("Double-twelve"), or null for a number that is no set offered. */
+export function trainSetLabel(set, language) {
+    const t = DOMINO_STRINGS[language];
+    return { 9: t.set9, 12: t.set12, 15: t.set15 }[set] ?? null;
+}
+/** A seat's name: the one given at the table, or "You" for the person at this device, or "Computer 3" or "Player 3" for the seat's number. */
+export function trainSeatName(game, seat, language, you) {
+    const t = DOMINO_STRINGS[language];
+    const given = game.players[seat]?.trim() ?? "";
+    if (given !== "")
+        return given;
+    if (seat === you)
+        return t.you;
+    return dominoSay(game.computers[seat] ? t.computer : t.player, { n: seat + 1 });
+}
+/** A train's name: "Your train", "Computer 2's train", or the Mexican Train. */
+export function trainName(game, train, language, you) {
+    const t = DOMINO_STRINGS[language];
+    if (train === mexicanOf(game))
+        return t.mexican;
+    if (train === you)
+        return t.trainYours;
+    return dominoSay(t.trainOf, { who: trainSeatName(game, train, language, you) });
+}
+/** What the last move did, in a line, or "" before there is one: "Computer 2 laid 9–4 on Your train." */
+export function trainNews(game, language, you) {
+    const t = DOMINO_STRINGS[language];
+    const last = game.last;
+    if (last === null)
+        return "";
+    const who = trainSeatName(game, last.seat, language, you);
+    switch (last.move.kind) {
+        case "play":
+            return dominoSay(t.laid, { who, tile: tileWords(last.move.tile), train: trainName(game, last.move.train, language, you) });
+        case "draw":
+            return dominoSay(t.drew, { who });
+        case "pass":
+            return dominoSay(t.passed, { who });
+        case "next":
+            return dominoSay(t.dealt, { n: game.round + 1, engine: game.engine });
+    }
+}
+/** Why a round ended, in a line: who played out, or that nobody could play. */
+function why(game, language, you) {
+    const t = DOMINO_STRINGS[language];
+    const result = game.results[game.results.length - 1];
+    return result !== undefined && result.ending === "domino" && result.out !== null ? dominoSay(t.outBy, { who: trainSeatName(game, result.out, language, you) }) : t.blocked;
+}
+/**
+ * What is going on, in a line: who is to play, or what the person at `you` is
+ * asked to do (lay, cover a double, draw, pass), or how the round or the game
+ * ended.
+ */
+export function trainStatus(game, language, you) {
+    const t = DOMINO_STRINGS[language];
+    if (game.phase === TRAIN_PHASES.finished) {
+        const who = game.winners.map((seat) => trainSeatName(game, seat, language, you)).join(" & ");
+        return dominoSay(t.gameOver, { who, pips: Math.min(...trainTotals(game)) });
+    }
+    if (game.phase === TRAIN_PHASES.roundOver)
+        return dominoSay(t.roundOver, { why: why(game, language, you) });
+    if (you === undefined || game.toPlay !== you)
+        return dominoSay(t.thinking, { who: trainSeatName(game, game.toPlay, language, you) });
+    const first = trainMoves(game)[0];
+    if (first?.kind === "draw")
+        return t.yourTurnDraw;
+    if (first?.kind === "pass")
+        return t.yourTurnPass;
+    return game.uncovered.length > 0 ? t.yourTurnCover : t.yourTurn;
+}

package/docs/credits.md

@@ -0,0 +1,49 @@
+# Credits: where the sounds come from
+
+Everything in Domino was written for it, under its MIT licence, except what
+this page names. Each item says where it came from, its licence as read at
+its source, and the day that was checked. Nothing here is GPL or LGPL, and
+nothing is used whose licence has not been read.
+
+## The tile sounds
+
+**Casino Audio (1.1)** by Kenney Vleugels,
+[https://kenney.nl/assets/casino-audio](https://kenney.nl/assets/casino-audio).
+
+- **Licence:** Creative Commons Zero, CC0 1.0
+  ([creativecommons.org/publicdomain/zero/1.0](http://creativecommons.org/publicdomain/zero/1.0/)),
+  as the pack's page says and as its own `License.txt` states: "You may use
+  these assets in personal and commercial projects. Credit (Kenney or
+  www.kenney.nl) would be nice but is not mandatory."
+- **Checked:** 2026-10-01, on the pack's page and in `License.txt` inside
+  `kenney_casino-audio.zip` (SHA-256
+  `f36250766ac5bc378c13708ddf12a23a8e54a3251f8d482c7536e51b5dbafa18`).
+
+**What they are, said plainly.** The pack has no dominoes. These are
+recordings of poker chips, which are hard and click on a table the way a
+tile does, and they are the nearest sound that is free to use. Nine of the
+pack's recordings are used, each cut short and re-encoded:
+
+| File here | From the pack | What it is | Length | Size |
+| --- | --- | --- | --- | --- |
+| `sounds/lay-1.m4a` | `Audio/chip-lay-1.ogg` | a chip set down on a table: a tile laid | 0.09 s | 1,681 bytes |
+| `sounds/lay-2.m4a` | `Audio/chip-lay-2.ogg` | a chip set down on a table: a tile laid | 0.15 s | 1,901 bytes |
+| `sounds/lay-3.m4a` | `Audio/chip-lay-3.ogg` | a chip set down on a table: a tile laid | 0.15 s | 1,947 bytes |
+| `sounds/draw-1.m4a` | `Audio/chips-handle-3.ogg` | a chip picked up: a tile taken from the boneyard | 0.19 s | 2,293 bytes |
+| `sounds/draw-2.m4a` | `Audio/chips-handle-4.ogg` | a chip picked up: a tile taken from the boneyard | 0.30 s | 3,174 bytes |
+| `sounds/shuffle-1.m4a` | `Audio/chips-handle-5.ogg` | chips stirred about: the tiles shuffled | 0.81 s | 6,058 bytes |
+| `sounds/shuffle-2.m4a` | `Audio/chips-handle-6.ogg` | chips stirred about: the tiles shuffled | 0.33 s | 3,644 bytes |
+| `sounds/knock-1.m4a` | `Audio/chips-collide-1.ogg` | two chips knocked together: a rap on the table for a pass | 0.08 s | 1,557 bytes |
+| `sounds/knock-2.m4a` | `Audio/chips-collide-4.ogg` | two chips knocked together: a rap on the table for a pass | 0.06 s | 1,520 bytes |
+
+23,775 bytes in all.
+
+**What was done to them**, by `scripts/sounds-cut.mjs` on a Mac: each
+recording was decoded from Ogg Vorbis, mixed to one channel, cut from where
+it first reaches a tenth of its peak to where it falls quiet (or to a length
+chosen for it), faded at both ends, brought to the same peak level, and
+encoded as AAC at 48 kbit/s in an `.m4a`, which every current browser
+decodes, Safari on an iPhone included. The empty padding the encoder leaves
+in the file was taken out. Then `pnpm sounds` writes them into
+`src/sounds.ts` as base64, and a test fails if that module and the files fall
+out of step, or if a file is not named on this page.