@johnmorrisdotca/kumimoji 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to this project are written down here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.1] - 2026-09-30
+
+### Fixed
+
+- The package loads through `require()` as well as `import` (Node 22 and
+  later, and test runners that compile to CommonJS): each export's condition is
+  `default` rather than `import`.
+
+## [1.0.0] - 2026-09-30
+
+The first stable release: the API as documented in the README is now kept stable
+until a 2.0.0.
+
+## [0.1.0] - 2026-09-30
+
+The first release.
+
+### Added
+
+- Games dealt from a seed by laying a crossword first, so every bag can be
+  finished: hands of 3, 7 or 11, three levels of wild tiles, short, medium and
+  full games, and two English sets at once.
+- English and Japanese: 144 tiles in each, 110,316 English words from SCOWL and
+  163,461 Japanese readings from JMdict, loaded when first needed.
+- Playing a game as plain values: lay, move, swap, lift, sort, draw and trade
+  one tile for three; wild tiles given any letter or kana.
+- Every run across and down judged against the list, with Diagonals as a
+  choice; a finished grid checked against its bag in time proportional to its
+  size; points for a finish, ten a tile and more for speed.
+- Help: the words the hand's own tiles spell, longest first.
+- A table of two to eight sharing one bag: turns, drawing together, the last
+  round, going out, resigning, joining and leaving, kept as text; and a
+  computer player that can take a seat.
+- Turning the table a quarter at a time with every tile kept upright, and the
+  sums for fitting, zooming and panning a view of it.
+- A whole game alone in plain DOM (`@johnmorrisdotca/kumimoji/ui`), light and
+  dark, themeable through CSS variables.
+- `KumimojiBoard` and `KumimojiTable`, React components, from
+  `@johnmorrisdotca/kumimoji/react`.
+- A static demo for GitHub Pages.
+
+[Unreleased]: https://github.com/johnmorrisdotca/kumimoji/compare/v1.0.1...HEAD
+[1.0.1]: https://github.com/johnmorrisdotca/kumimoji/releases/tag/v1.0.1
+[1.0.0]: https://github.com/johnmorrisdotca/kumimoji/releases/tag/v1.0.0
+[0.1.0]: https://github.com/johnmorrisdotca/kumimoji/commits/v1.0.0

package/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing to Kumimoji
+
+Thank you for wanting to help. Bug reports, rule questions and pull requests are
+all welcome.
+
+## Reporting a bug
+
+Open an [issue](https://github.com/johnmorrisdotca/kumimoji/issues) with what you did,
+what you expected and what happened. A game's seed makes almost any bug
+reproducible: include it, and the moves if you have them.
+
+## Making a change
+
+```sh
+git clone https://github.com/johnmorrisdotca/kumimoji.git
+cd kumimoji
+pnpm install
+pnpm run check    # lint, types and tests, as CI runs them
+pnpm run site     # build the demo into site/ and open site/index.html
+```
+
+- The rules are pure functions over plain values: a function returns a new
+  game and never changes the one it was given. Keep it that way.
+- Anything random is drawn from the game's own seeded random, so a game always
+  replays from its seed. Never call `Math.random` inside the rules.
+- Add or change a test beside the code you change (`*.test.ts`).
+- Note the change under **Unreleased** in [CHANGELOG.md](CHANGELOG.md).
+- Keep pull requests to one change each, with a message that says what a player
+  or a developer would notice.
+
+## Releasing
+
+Maintainers bump the version in `package.json`, move **Unreleased** in the
+changelog under the new version and date, tag `v<version>`, and publish with
+`pnpm publish --access public`.
+
+By contributing you agree that your work is released under the
+[MIT licence](LICENSE), and to follow the [code of conduct](CODE_OF_CONDUCT.md).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 John Morris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE.md

@@ -0,0 +1,38 @@
+# Notice: the word lists' licences
+
+The code of this package is under the MIT licence (see [LICENSE](LICENSE)). The
+two word lists it ships are other people's work, used under their own terms.
+
+## English: SCOWL
+
+`src/words.en.data.ts` is written from SCOWL 2020.12.07
+(http://wordlist.aspell.net/), sizes 10 to 70, English and American spellings,
+every length from 2 to 15: 110,316 words. Its notice, which its licence asks to
+travel with the lists:
+
+> The collective work is Copyright 2000-2018 by Kevin Atkinson as well
+> as any of the copyrights mentioned below:
+>
+>   Copyright 2000-2018 by Kevin Atkinson
+>
+>   Permission to use, copy, modify, distribute and sell these word
+>   lists, the associated scripts, the output created from the scripts,
+>   and its documentation for any purpose is hereby granted without fee,
+>   provided that the above copyright notice appears in all copies and
+>   that both that copyright notice and this permission notice appear in
+>   supporting documentation. Kevin Atkinson makes no representations
+>   about the suitability of this array for any purpose. It is provided
+>   "as is" without express or implied warranty.
+
+The full notice, with the copyrights of the lists SCOWL is built from, is in
+SCOWL's own distribution.
+
+## Japanese: JMdict
+
+`src/words.ja.data.ts` is derived from JMdict, the Japanese-Multilingual
+Dictionary of the Electronic Dictionary Research and Development Group
+(https://www.edrdg.org/), release 2026-09-28: 163,461 hiragana readings of 2 to
+15 kana, each spelt in the 45 base kana the tiles show. JMdict is the property of
+the EDRDG and is used under the Creative Commons Attribution-ShareAlike 4.0
+licence, with the group's conditions: https://www.edrdg.org/edrdg/licence.html.
+This derived list is shared under the same licence.

package/README.md

@@ -0,0 +1,233 @@
+# Kumimoji 組み文字
+
+[![CI](https://github.com/johnmorrisdotca/kumimoji/actions/workflows/ci.yml/badge.svg)](https://github.com/johnmorrisdotca/kumimoji/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@johnmorrisdotca/kumimoji.svg)](https://www.npmjs.com/package/@johnmorrisdotca/kumimoji)
+[![Licence: MIT](https://img.shields.io/badge/licence-MIT-blue.svg)](LICENSE)
+![Types included](https://img.shields.io/badge/types-TypeScript-3178c6.svg)
+![Dependencies: none](https://img.shields.io/badge/dependencies-none-brightgreen.svg)
+
+**The crossword tile race, in English and Japanese, as pure and seeded TypeScript.**
+
+Build one crossword from every tile in the bag. Lay your hand as words that
+cross, and when your hand is empty and every run across and down is a word, draw
+the next tile. A tile you cannot use can be traded for three. Use the last tile
+in the bag and you are done. Play alone against the clock, or at a table of two
+to eight sharing one bag, in English or in Japanese.
+
+*Kumimoji* (組み文字) is "letters put together".
+
+**[Play it](https://johnmorrisdotca.github.io/kumimoji/)**
+
+<p>
+  <img src="docs/desktop.jpg" alt="An English game: BACK across and RAW down, with a wild tile left in hand" width="560">
+  <img src="docs/phone.jpg" alt="The same game on a phone in dark mode" width="200">
+</p>
+
+- **Dealt from a seed.** `generateKumimoji` lays a crossword first and deals its
+  tiles, so every bag can be finished, and two players racing the same seed get
+  the same tiles in the same order.
+- **English and Japanese.** 144 tiles in each: the English letter mix, or 45 base
+  kana where が plays as か, ゃ as や and を as お. 110,316 English words and
+  163,461 Japanese readings, from 2 to 15 tiles.
+- **Wild tiles** that take any letter or kana, and are read as that letter in
+  every word they are part of.
+- **Diagonals**, if chosen: every diagonal run of three or more must be a word
+  too.
+- **The rules as plain functions.** A game in progress is a value
+  (`TilePlay`): `deal`, `placeFromHand`, `moveOnTable`, `liftToHand`, `draw`,
+  `trade` each return a new one. `judgeWithWords` says which runs are not words
+  and which tiles are apart; `checkKumimoji` checks a finished grid against its
+  bag, in time proportional to its size.
+- **A table of two to eight** (`startParty`, `endTurn`, `drawAll`, `resign`,
+  `joinParty`, `leaveParty`), kept as text (`encodeParty`, `decodeParty`), with a
+  computer player that can take a seat (`planComputerTurn`).
+- **A table to play on.** `mountKumimoji` plays a whole game alone in plain DOM;
+  `KumimojiBoard` draws a grid in React.
+
+It is the Kumimoji on [Itsutsu](https://itsutsu.com/games/kumimoji), which plays
+alone, in races, round one device and across several with this package.
+
+## How to play
+
+1. Everyone starts with a hand of tiles from the bag: 3, 7 or 11.
+2. Lay your tiles on the table as a crossword of your own. Every run of two or
+   more tiles, across and down, must be a word, and every tile must join the
+   one crossword. Move and take back tiles as often as you like.
+3. When your hand is empty and the crossword is sound, draw the next tile. At a
+   table, everyone draws together.
+4. Stuck with a tile you cannot use? Trade it for three from the bag.
+5. A wild tile is any letter or kana you give it, and reads as that in every
+   word it is part of.
+6. Near the end of the bag, a player who lays their last tile in a sound
+   crossword goes out. Everyone else has one last turn to do the same, and all
+   who go out win. Alone, you use every tile in the bag and race the clock.
+
+## Install
+
+```sh
+pnpm add @johnmorrisdotca/kumimoji   # or: npm install @johnmorrisdotca/kumimoji
+```
+
+Or straight from a GitHub release, pinned to its version:
+
+```sh
+pnpm add https://github.com/johnmorrisdotca/kumimoji/releases/download/v1.0.1/johnmorrisdotca-kumimoji-1.0.1.tgz
+```
+
+ES modules with types, and no dependencies. The React components need React 18
+or later.
+
+## Play a game in code
+
+```ts
+import { deal, draw, generateKumimoji, judgeWithWords, loadTileWords, mayDraw, placeFromHand, squareAt } from "@johnmorrisdotca/kumimoji";
+
+const words = await loadTileWords("english"); // fetched once, the first time
+const dealt = generateKumimoji(7, "medium", 2026); // a hand of 7, some wilds, seed 2026
+let play = deal(dealt.givens, 7);
+
+play = placeFromHand(play, 0, squareAt(0, 0)); // the first tile of the hand, on row 0, column 0
+const verdict = judgeWithWords(play.tiles, words);
+if (mayDraw(play, verdict)) play = draw(play);
+```
+
+- `generateKumimoji(hand, level, seed, options?)`: a hand of 3, 7 or 11; a
+  level of `"easy"`, `"medium"` or `"hard"` (more wild tiles, fewer, none);
+  options `language`, `gameLength` (`"short"`, `"medium"`, or `"full"`, the
+  whole set), `doubleSet` (two English sets) and `diagonals`. Returns the bag as
+  `givens` and one finished grid as `solution`.
+- A square is a string key, `squareAt(row, col)`; the grid has no edges.
+- A tile is one character: an English letter, `*` for a wild with no letter, a
+  capital for a wild given that letter (`assignHandTile`), and for Japanese a
+  private-use character per kana (`tileFace` says what is printed on any tile).
+- `isFinished(play, verdict)`: the hand empty, the bag empty, and every run a
+  word in one piece.
+
+### Checking a finished game
+
+```ts
+import { checkKumimoji, encodeGrid } from "@johnmorrisdotca/kumimoji";
+
+checkKumimoji(7, dealt.givens, encodeGrid(play.tiles), { level: "medium" });
+// { ok: true } or { ok: false, reason: "zqx is not in the word list" }
+```
+
+It checks that the grid uses exactly the tiles of the bag, is all one piece, and
+that every run is a word. Nothing is searched, so a server can run it on every
+game handed in.
+
+### The word lists
+
+In a browser, `loadTileWords(language)` fetches the list as its own module the
+first time it is needed (about 600 KB for English, 700 KB for Japanese before
+compression), so nothing else carries it. On a server, in a test or in a script,
+import the `words` entry once, which reads the lists from this package's files:
+
+```ts
+import "@johnmorrisdotca/kumimoji/words";
+```
+
+`tileWords(language)` then hands back the loaded list: `allowed` (every word),
+`byLength`, the tile `mix`, and the functions that turn tiles into words.
+
+### A table of players
+
+```ts
+import { endTurn, handCanSpell, judgeWithWords, placeFromHand, seatPlay, squareAt, startParty, withSeatPlay } from "@johnmorrisdotca/kumimoji";
+
+let game = startParty(
+  { size: 7, level: "medium", seed: 1, gameLength: "short", language: "english", doubleSet: false, diagonals: false, hints: false },
+  dealt.givens,
+  ["Ann", { name: "Computer", computer: true }],
+);
+// The player to move plays their own hand and table as a TilePlay:
+game = withSeatPlay(game, placeFromHand(seatPlay(game), 0, squareAt(0, 0)));
+game = endTurn(game, judgeWithWords(seatPlay(game).tiles, words), (hand) => handCanSpell(hand, words));
+```
+
+`afterComputerTurn(game, words)` plays a computer seat's whole turn;
+`planComputerTurn` lists its steps, for a page to show them one at a time.
+
+## Play on a page
+
+```html
+<div id="table"></div>
+<script type="module">
+  import { mountKumimoji } from "@johnmorrisdotca/kumimoji/ui";
+  mountKumimoji(document.getElementById("table"), {
+    language: "english",
+    hand: 7,
+    onFinish: ({ elapsedMs }) => console.log(`Finished in ${elapsedMs / 1000}s`),
+  });
+</script>
+```
+
+Options: `language`, `hand`, `level`, `gameLength`, `diagonals`, `seed`,
+`onFinish`. The handle has `play()`, `newGame(options?)` and `destroy()`.
+Colours are CSS variables on `.km-root` (`--km-felt`, `--km-tile` and the
+rest), light and dark.
+
+### In React
+
+```tsx
+import { KumimojiBoard, KumimojiTable } from "@johnmorrisdotca/kumimoji/react";
+
+<KumimojiBoard tiles={play.tiles} verdict={verdict} glyphOf={words.glyphOf} onSquare={(square) => press(square)} />
+<KumimojiTable language="japanese" hand={7} />
+```
+
+## API at a glance
+
+| Entry | What it holds |
+| --- | --- |
+| `@johnmorrisdotca/kumimoji` | Dealing: `generateKumimoji`, `KUMIMOJI_HANDS`; playing alone: `deal`, `placeFromHand`, `moveOnTable`, `swapWithHand`, `liftToHand`, `liftAll`, `sortHand`, `assignHandTile`, `draw`, `trade`, `mayDraw`, `mayTrade`, `isFinished`; judging: `judgeWithWords`, `runsOf`, `checkKumimoji`, `kumimojiPoints`; words: `loadTileWords`, `tileWords`, `wordsInHand`; a table: `startParty`, `endTurn`, `drawAll`, `resign`, `joinParty`, `leaveParty`, `encodeParty`, `decodeParty`; the computer: `planComputerTurn`, `afterComputerTurn`; views: `fitView`, `zoomView`, `panView`, `turnView`; and every type (`TilePlay`, `PartyGame`, `GridVerdict`, …). |
+| `@johnmorrisdotca/kumimoji/words` | Loads both word lists from this package's files, for a server, a test or a script. |
+| `@johnmorrisdotca/kumimoji/ui` | `mountKumimoji`, a whole game in plain DOM; `boardModel` for drawing a board yourself. |
+| `@johnmorrisdotca/kumimoji/react` | `KumimojiBoard` and `KumimojiTable`. |
+
+Every function is typed and documented in the source, and your editor shows the
+documentation as you type.
+
+## Browser support
+
+Any browser that runs ES2022 modules: current Chrome, Edge, Firefox and Safari,
+on a desk or a phone. The rules have no DOM in them and run the same in Node 20
+or later, Deno, Bun and web workers. The table follows the system's light or
+dark mode and needs nothing but a container element.
+
+## Develop
+
+```sh
+pnpm install
+pnpm test         # the rules, the lists, the table and the computer player
+pnpm run build    # dist/
+pnpm run site     # the demo in site/, as GitHub Pages serves it
+```
+
+## Roadmap
+
+- More languages, each from a real dictionary of that language.
+- Playing the plain-DOM table from a keyboard, as the React one can.
+- A computer player at three strengths.
+- Word definitions for a finished crossword.
+
+## Contributing
+
+Issues and pull requests are welcome. [CONTRIBUTING.md](CONTRIBUTING.md) says
+how to set up, what the checks are and how a change is written up, and everyone
+taking part follows the [code of conduct](CODE_OF_CONDUCT.md).
+
+## Licence and notices
+
+The code is MIT, © John Morris; see [LICENSE](LICENSE).
+
+The word lists are other people's work, used under their own terms, and set out
+in full in [NOTICE.md](NOTICE.md):
+
+- **English**: from [SCOWL](http://wordlist.aspell.net/), © Kevin Atkinson and
+  others, under a permissive licence whose notice travels with the lists.
+- **Japanese**: readings derived from
+  [JMdict](https://www.edrdg.org/jmdict/j_jmdict.html), © the Electronic
+  Dictionary Research and Development Group, under
+  [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). The
+  Japanese list file (`src/words.ja.data.ts`) is shared under the same licence.

package/dist/check.d.ts

@@ -0,0 +1,19 @@
+import type { KumimojiCheck, KumimojiLevel, KumimojiOptions } from "./kumimoji.types.ts";
+/**
+ * WHETHER A GRID FINISHES A KUMIMOJI: the one check the server also runs.
+ * O(squares) and a lookup a word, nothing searched: the grid uses exactly the
+ * tiles of the bag, as many of each, it is all one piece, and every run of two
+ * or more across or down is in the list — and, for a game set up with
+ * Diagonals, every run of three or more along a diagonal. Which tiles were
+ * traded on the way does not matter — a finished game holds the whole bag
+ * whatever came out of it when — so the answer is the grid alone.
+ *
+ * Written out here rather than asked of the play page, which is what made the
+ * grid; the list must have been loaded (`loadTileWords`), and a check that
+ * cannot read it refuses.
+ */
+export declare function checkKumimoji(size: number, givens: string, answer: string, options?: KumimojiOptions & {
+    level?: KumimojiLevel;
+}): KumimojiCheck;
+/** A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed. */
+export declare function kumimojiPoints(givens: string, elapsedMs: number): number;

package/dist/check.js

@@ -0,0 +1,70 @@
+import { decodeGrid, lettersOf, sameLetters } from "./grid.js";
+import { judgeWithWords } from "./judge.js";
+import { kumimojiTileCount, kumimojiWildCount, KUMIMOJI_SCORE, TILE_MIX_TOTAL } from "./tiles.constants.js";
+import { tileWords } from "./tileWords.js";
+/**
+ * WHETHER A GRID FINISHES A KUMIMOJI: the one check the server also runs.
+ * O(squares) and a lookup a word, nothing searched: the grid uses exactly the
+ * tiles of the bag, as many of each, it is all one piece, and every run of two
+ * or more across or down is in the list — and, for a game set up with
+ * Diagonals, every run of three or more along a diagonal. Which tiles were
+ * traded on the way does not matter — a finished game holds the whole bag
+ * whatever came out of it when — so the answer is the grid alone.
+ *
+ * Written out here rather than asked of the play page, which is what made the
+ * grid; the list must have been loaded (`loadTileWords`), and a check that
+ * cannot read it refuses.
+ */
+export function checkKumimoji(size, givens, answer, options = {}) {
+    const gameLength = options.gameLength ?? "short";
+    const language = options.language ?? "english";
+    const doubleSet = language === "english" && (options.doubleSet ?? false);
+    const level = options.level ?? "medium";
+    const multiplier = doubleSet ? 2 : 1;
+    let words;
+    let inBag;
+    try {
+        words = tileWords(language);
+        const setSize = [...words.mix.values()].reduce((sum, count) => sum + count, 0);
+        inBag = kumimojiTileCount(size, gameLength, language === "english" ? TILE_MIX_TOTAL : setSize, doubleSet);
+    }
+    catch {
+        return { ok: false, reason: `no Kumimoji with a hand of ${size}` };
+    }
+    const bag = [...givens];
+    if (typeof givens !== "string" || bag.length !== inBag)
+        return { ok: false, reason: "the givens are not a bag of tiles" };
+    const expectedWilds = kumimojiWildCount(size, level, inBag);
+    if (bag.filter(words.isWild).length !== expectedWilds)
+        return { ok: false, reason: "the bag has the wrong number of wild tiles" };
+    for (const [tile, count] of lettersOf(bag.filter((each) => !words.isWild(each)))) {
+        const face = words.inventoryKey(tile);
+        const code = face === null ? null : words.codeOf(face);
+        if (code === null || count > (words.mix.get(code) ?? 0) * multiplier)
+            return { ok: false, reason: "the bag exceeds the tile set" };
+    }
+    const tiles = decodeGrid(answer);
+    if (tiles === null)
+        return { ok: false, reason: "the answer is not a grid" };
+    const bagIdentities = bag.map(words.familyKey);
+    const tileIdentities = [...tiles.values()].map(words.familyKey);
+    if (bagIdentities.some((tile) => tile === null) || tileIdentities.some((tile) => tile === null) || !sameLetters(lettersOf(tileIdentities), lettersOf(bagIdentities))) {
+        return { ok: false, reason: "the grid does not use exactly the tiles of the bag" };
+    }
+    const verdict = judgeWithWords(tiles, words, { diagonals: options.diagonals === true });
+    if (verdict.apart.size > 0)
+        return { ok: false, reason: "the tiles are not all joined" };
+    if (verdict.notWords.length > 0)
+        return { ok: false, reason: `${verdict.notWords[0]} is not in the word list` };
+    if (!verdict.sound)
+        return { ok: false, reason: "the grid is not finished" };
+    return { ok: true };
+}
+/** A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed. */
+export function kumimojiPoints(givens, elapsedMs) {
+    const tiles = givens.length;
+    const base = KUMIMOJI_SCORE.tile * tiles;
+    const slowest = KUMIMOJI_SCORE.slowestMsATile * tiles;
+    const speed = Math.max(0, Math.round(base * (1 - Math.max(0, elapsedMs) / slowest)));
+    return base + speed;
+}

package/dist/computer.types.d.ts

@@ -0,0 +1,23 @@
+import type { PartyGame } from "./party.types.ts";
+/** What a computer did in one step of its turn, for the line over its table. */
+export type ComputerSaid = {
+    kind: "rebuilt";
+} | {
+    kind: "laid";
+    word: string;
+} | {
+    kind: "drew";
+} | {
+    kind: "traded";
+    tile: string;
+} | {
+    kind: "done";
+    out: boolean;
+} | {
+    kind: "resigned";
+};
+/** One step of a computer's turn: the game after it, and what it did. The last step's game is the one kept. */
+export type ComputerStep = {
+    game: PartyGame;
+    said: ComputerSaid;
+};

package/dist/computer.types.js

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

package/dist/computerPlay.d.ts

@@ -0,0 +1,17 @@
+import { type GridRules, type GridVerdict, type Tiles } from "./grid.ts";
+import { type TilePlay } from "./play.ts";
+import type { TileWords } from "./tileWords.ts";
+/** Whether a grid is sound, read against the loaded word list by the game's rules: the same judgement the desk shows. */
+export declare function judgeTiles(tiles: Tiles, words: TileWords, rules?: GridRules): GridVerdict;
+/**
+ * THE COMPUTER'S NEXT WORD: its play after laying the best word its hand can
+ * lay on its table, and the word, or null when there is none. The grid after
+ * it is judged against the list, by the game's rules (`rules`), and is
+ * always sound.
+ */
+export declare function bestLaying(play: TilePlay, words: TileWords, rules?: GridRules): {
+    play: TilePlay;
+    word: string;
+} | null;
+/** The tile a computer trades: its rarest letter in the set, the first of those in its hand; never a wild. Null for a hand of wilds. */
+export declare function tradeChoice(hand: readonly string[], words: TileWords): number | null;