@johnmorrisdotca/kumimoji 1.0.1

package/dist/grid.d.ts

@@ -0,0 +1,97 @@
+/**
+ * A KUMIMOJI GRID: letter tiles on a table with no edges. Each tile stands on
+ * a square named by its row and column, which may be any whole numbers,
+ * negative too — the table grows whichever way the player builds. Pure, like
+ * every rule here: nothing is changed in place.
+ *
+ * As a string, for an answer and a kept game, the grid is drawn from its own
+ * top-left tile: its rows in order, joined by "/", each row written as runs of
+ * empty squares (a number) and tiles. English letters keep their short form;
+ * other tiles are URI-escaped between `~` and `;`. `cat/2o/2w` is CAT across
+ * and COW down from its C. Only
+ * where the tiles stand beside one another is written, never where on the
+ * table they were, so one grid has one spelling however far it was dragged.
+ */
+export type Tiles = ReadonlyMap<string, string>;
+/** A square's name, "row,col". */
+export declare function squareAt(row: number, col: number): string;
+/** A square's row and column, from its name. */
+export declare function placeOf(square: string): {
+    row: number;
+    col: number;
+};
+/** The rows and columns the tiles stand within, or null for no tiles. */
+export type Bounds = {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+};
+export declare function boundsOf(tiles: Tiles): Bounds | null;
+export declare function encodeGrid(tiles: Tiles): string;
+/**
+ * A grid read back, its first row at row 0, or null for anything that is not
+ * one: a stray character, a capital, a grid wider or taller than any grid of
+ * fifty tiles can be. An empty string is no tiles.
+ */
+export declare function decodeGrid(code: string): Map<string, string> | null;
+/** How many of each letter. */
+export declare function lettersOf(letters: Iterable<string>): Map<string, number>;
+/** Whether two tallies hold the same letters, as many of each. */
+export declare function sameLetters(a: Map<string, number>, b: Map<string, number>): boolean;
+/**
+ * THE LINES A RUN MAY LIE ALONG, each read top to bottom (and across, left to
+ * right): across and down always, and the two diagonals when the game was set
+ * up with Diagonals — down to the right, and down to the left.
+ */
+export type RunLine = "across" | "down" | "downRight" | "downLeft";
+/**
+ * The fewest tiles a diagonal run needs before it is read. Two tiles touching
+ * at a corner are what every crossword is full of — the letter above a word
+ * and the one beside it — so a pair is free, and only three or more in a
+ * line are a diagonal word.
+ */
+export declare const DIAGONAL_RUN_LEAST = 3;
+/** How a grid is read: whether its diagonals are (`KumimojiOptions.diagonals`). */
+export type GridRules = {
+    diagonals?: boolean;
+};
+/** A run of tiles along one line: the word it spells and the squares it stands on, in reading order. */
+export type Run = {
+    word: string;
+    squares: string[];
+    line: RunLine;
+};
+/**
+ * Every run the grid is read by: two or more tiles across, then down, and
+ * with Diagonals three or more down to the right, then down to the left. A
+ * tile with nothing beside it in a line is no run.
+ */
+export declare function runsOf(tiles: Tiles, rules?: GridRules): Run[];
+/**
+ * The tiles in groups that touch across or down, largest first. With `links`
+ * — the diagonal runs a grid with Diagonals reads — the tiles next to each
+ * other in one of those runs are joined too: a diagonal word holds a
+ * crossword together as a word across does. A pair touching at a corner is
+ * never a link, because it is never read.
+ */
+export declare function groupsOf(tiles: Tiles, links?: readonly Run[]): string[][];
+/**
+ * WHAT IS WRONG WITH A GRID, tile by tile, so the table can mark it: the tiles
+ * in a run that is not a word, the tiles not joined to the main grid, and
+ * whether the whole is sound — two tiles or more, all joined, every run a word.
+ * With Diagonals (`rules`), the diagonal runs of three or more are runs too:
+ * each must be a word, a misspelt one is marked as any other is, and each
+ * joins its tiles (`groupsOf`).
+ */
+export type GridVerdict = {
+    sound: boolean;
+    tiles: number;
+    /** Tiles standing in a run the list does not know. */
+    misspelt: ReadonlySet<string>;
+    /** Tiles in a group apart from the largest. */
+    apart: ReadonlySet<string>;
+    /** The runs that are not words, as spelled, for the line under the table. */
+    notWords: readonly string[];
+};
+export declare function judgeGrid(tiles: Tiles, isWord: (word: string) => boolean, readable?: (word: string) => string, rules?: GridRules): GridVerdict;

package/dist/grid.js

@@ -0,0 +1,208 @@
+import { KUMIMOJI_GRID_MOST } from "./tiles.constants.js";
+/** A square's name, "row,col". */
+export function squareAt(row, col) {
+    return `${row},${col}`;
+}
+/** A square's row and column, from its name. */
+export function placeOf(square) {
+    const [row, col] = square.split(",").map(Number);
+    return { row: row, col: col };
+}
+export function boundsOf(tiles) {
+    let bounds = null;
+    for (const square of tiles.keys()) {
+        const { row, col } = placeOf(square);
+        bounds =
+            bounds === null
+                ? { top: row, left: col, bottom: row, right: col }
+                : { top: Math.min(bounds.top, row), left: Math.min(bounds.left, col), bottom: Math.max(bounds.bottom, row), right: Math.max(bounds.right, col) };
+    }
+    return bounds;
+}
+export function encodeGrid(tiles) {
+    const bounds = boundsOf(tiles);
+    if (bounds === null)
+        return "";
+    const rows = [];
+    for (let row = bounds.top; row <= bounds.bottom; row += 1) {
+        let line = "";
+        let gap = 0;
+        for (let col = bounds.left; col <= bounds.right; col += 1) {
+            const letter = tiles.get(squareAt(row, col));
+            if (letter === undefined) {
+                gap += 1;
+                continue;
+            }
+            if (letter === "")
+                throw new Error("A Kumimoji tile cannot be empty.");
+            line += `${gap > 0 ? gap : ""}${/^[a-z]$/.test(letter) ? letter : `~${encodeURIComponent(letter)};`}`;
+            gap = 0;
+        }
+        rows.push(line);
+    }
+    return rows.join("/");
+}
+/**
+ * A grid read back, its first row at row 0, or null for anything that is not
+ * one: a stray character, a capital, a grid wider or taller than any grid of
+ * fifty tiles can be. An empty string is no tiles.
+ */
+export function decodeGrid(code) {
+    if (typeof code !== "string")
+        return null;
+    const tiles = new Map();
+    if (code === "")
+        return tiles;
+    const rows = code.split("/");
+    if (rows.length > KUMIMOJI_GRID_MOST)
+        return null;
+    for (const [row, line] of rows.entries()) {
+        let col = 0;
+        let at = 0;
+        while (at < line.length) {
+            const gapStart = at;
+            while (at < line.length && /\d/.test(line[at]))
+                at += 1;
+            const gap = line.slice(gapStart, at);
+            let letter;
+            if (/^[a-z]$/.test(line[at] ?? "")) {
+                letter = line[at];
+                at += 1;
+            }
+            else if (line[at] === "~") {
+                const end = line.indexOf(";", at + 1);
+                if (end === -1)
+                    return null;
+                try {
+                    letter = decodeURIComponent(line.slice(at + 1, end));
+                }
+                catch {
+                    return null;
+                }
+                if (letter.length === 0 || letter.length > 8)
+                    return null;
+                at = end + 1;
+            }
+            else {
+                return null;
+            }
+            col += gap === "" ? 0 : Number(gap);
+            if (col >= KUMIMOJI_GRID_MOST)
+                return null;
+            tiles.set(squareAt(row, col), letter);
+            col += 1;
+        }
+    }
+    return tiles;
+}
+/** How many of each letter. */
+export function lettersOf(letters) {
+    const counts = new Map();
+    for (const letter of letters)
+        if (letter !== "")
+            counts.set(letter, (counts.get(letter) ?? 0) + 1);
+    return counts;
+}
+/** Whether two tallies hold the same letters, as many of each. */
+export function sameLetters(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const [letter, count] of a)
+        if (b.get(letter) !== count)
+            return false;
+    return true;
+}
+/** One step along each line, as rows and columns. */
+const STEP = { across: [0, 1], down: [1, 0], downRight: [1, 1], downLeft: [1, -1] };
+/**
+ * The fewest tiles a diagonal run needs before it is read. Two tiles touching
+ * at a corner are what every crossword is full of — the letter above a word
+ * and the one beside it — so a pair is free, and only three or more in a
+ * line are a diagonal word.
+ */
+export const DIAGONAL_RUN_LEAST = 3;
+function runsAlong(tiles, line, least) {
+    const [down, across] = STEP[line];
+    const runs = [];
+    for (const [square] of tiles) {
+        const { row, col } = placeOf(square);
+        // Only from a run's first tile: nothing before it in this line.
+        if (tiles.has(squareAt(row - down, col - across)))
+            continue;
+        const squares = [];
+        for (let step = 0;; step += 1) {
+            const at = squareAt(row + step * down, col + step * across);
+            if (!tiles.has(at))
+                break;
+            squares.push(at);
+        }
+        if (squares.length >= least)
+            runs.push({ word: squares.map((at) => tiles.get(at)).join(""), squares, line });
+    }
+    return runs;
+}
+/**
+ * Every run the grid is read by: two or more tiles across, then down, and
+ * with Diagonals three or more down to the right, then down to the left. A
+ * tile with nothing beside it in a line is no run.
+ */
+export function runsOf(tiles, rules = {}) {
+    const runs = [...runsAlong(tiles, "across", 2), ...runsAlong(tiles, "down", 2)];
+    if (rules.diagonals === true)
+        runs.push(...runsAlong(tiles, "downRight", DIAGONAL_RUN_LEAST), ...runsAlong(tiles, "downLeft", DIAGONAL_RUN_LEAST));
+    return runs;
+}
+/**
+ * The tiles in groups that touch across or down, largest first. With `links`
+ * — the diagonal runs a grid with Diagonals reads — the tiles next to each
+ * other in one of those runs are joined too: a diagonal word holds a
+ * crossword together as a word across does. A pair touching at a corner is
+ * never a link, because it is never read.
+ */
+export function groupsOf(tiles, links = []) {
+    const joined = new Map();
+    const join = (a, b) => joined.set(a, [...(joined.get(a) ?? []), b]);
+    for (const run of links) {
+        for (let at = 1; at < run.squares.length; at += 1) {
+            join(run.squares[at - 1], run.squares[at]);
+            join(run.squares[at], run.squares[at - 1]);
+        }
+    }
+    const seen = new Set();
+    const groups = [];
+    for (const start of tiles.keys()) {
+        if (seen.has(start))
+            continue;
+        const group = [];
+        const queue = [start];
+        seen.add(start);
+        while (queue.length > 0) {
+            const at = queue.pop();
+            group.push(at);
+            const { row, col } = placeOf(at);
+            for (const near of [squareAt(row - 1, col), squareAt(row + 1, col), squareAt(row, col - 1), squareAt(row, col + 1), ...(joined.get(at) ?? [])]) {
+                if (tiles.has(near) && !seen.has(near)) {
+                    seen.add(near);
+                    queue.push(near);
+                }
+            }
+        }
+        groups.push(group);
+    }
+    return groups.sort((a, b) => b.length - a.length);
+}
+export function judgeGrid(tiles, isWord, readable = (word) => word, rules = {}) {
+    const misspelt = new Set();
+    const notWords = [];
+    const runs = runsOf(tiles, rules);
+    for (const run of runs) {
+        if (isWord(run.word))
+            continue;
+        notWords.push(readable(run.word));
+        for (const at of run.squares)
+            misspelt.add(at);
+    }
+    const groups = groupsOf(tiles, runs.filter((run) => run.line === "downRight" || run.line === "downLeft"));
+    const apart = new Set(groups.slice(1).flat());
+    return { sound: tiles.size >= 2 && groups.length === 1 && notWords.length === 0, tiles: tiles.size, misspelt, apart, notWords };
+}

package/dist/help.d.ts

@@ -0,0 +1,20 @@
+import type { TilePlay } from "./play.ts";
+import type { TileWords } from "./tileWords.ts";
+/**
+ * HELP: THE HAND ARRANGED INTO A WORD. John, 2026-09-28: "a help button next
+ * to the sort button where if you click it, the letters in your board are all
+ * arranged to make words. Every time you click the help button it cycles
+ * through a different word… Even though it's a little cheating, they still
+ * have to find a place for it on the board so it's not super powerful."
+ *
+ * Chosen on the set-up screen or not at all (the puzzles' `hints=1`), and each
+ * press is counted as a hint, so a helped game is kept and priced as one.
+ * Only the hand's own tiles are read — a wild is left for the player to place
+ * — and nothing on the table is moved.
+ */
+/** How many words one hand offers before the presses go round again: the longest first. */
+export declare const HELP_WORDS_MOST = 40;
+/** The words the hand's own tiles spell, longest first and then in the list's order; wilds are not used. */
+export declare function wordsInHand(hand: readonly string[], words: TileWords): string[];
+/** The hand with `word`'s tiles first, in its order, and the rest after them as they were. */
+export declare function handSpelling(play: TilePlay, word: string): TilePlay;

package/dist/help.js

@@ -0,0 +1,57 @@
+/**
+ * HELP: THE HAND ARRANGED INTO A WORD. John, 2026-09-28: "a help button next
+ * to the sort button where if you click it, the letters in your board are all
+ * arranged to make words. Every time you click the help button it cycles
+ * through a different word… Even though it's a little cheating, they still
+ * have to find a place for it on the board so it's not super powerful."
+ *
+ * Chosen on the set-up screen or not at all (the puzzles' `hints=1`), and each
+ * press is counted as a hint, so a helped game is kept and priced as one.
+ * Only the hand's own tiles are read — a wild is left for the player to place
+ * — and nothing on the table is moved.
+ */
+/** How many words one hand offers before the presses go round again: the longest first. */
+export const HELP_WORDS_MOST = 40;
+/** The words the hand's own tiles spell, longest first and then in the list's order; wilds are not used. */
+export function wordsInHand(hand, words) {
+    const have = new Map();
+    for (const tile of hand)
+        if (!words.isWild(tile))
+            have.set(tile, (have.get(tile) ?? 0) + 1);
+    const tiles = [...have.values()].reduce((sum, count) => sum + count, 0);
+    const found = [];
+    const need = new Map();
+    for (let length = tiles; length >= 2 && found.length < HELP_WORDS_MOST; length -= 1) {
+        for (const word of words.byLength.get(length) ?? []) {
+            need.clear();
+            let spelt = true;
+            for (const tile of word) {
+                const count = (need.get(tile) ?? 0) + 1;
+                if (count > (have.get(tile) ?? 0)) {
+                    spelt = false;
+                    break;
+                }
+                need.set(tile, count);
+            }
+            if (!spelt)
+                continue;
+            found.push(word);
+            if (found.length >= HELP_WORDS_MOST)
+                break;
+        }
+    }
+    return found;
+}
+/** The hand with `word`'s tiles first, in its order, and the rest after them as they were. */
+export function handSpelling(play, word) {
+    const rest = [...play.hand];
+    const front = [];
+    for (const tile of word) {
+        const at = rest.indexOf(tile);
+        if (at === -1)
+            return play;
+        front.push(tile);
+        rest.splice(at, 1);
+    }
+    return { ...play, hand: [...front, ...rest] };
+}

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Kumimoji 組み文字: the race to build a crossword from a bag of letter
+ * tiles, in English or Japanese, alone or at a table of two to eight, as
+ * plain functions over plain data.
+ *
+ * A game is dealt from a seed (`generateKumimoji`), so two players racing the
+ * same bag get the same tiles in the same order. The tiles you hold and the
+ * grid you build are values (`deal`, `placeFromHand`, `draw`, `trade` and the
+ * rest), and every run across and down is judged against a word list
+ * (`judgeWithWords`, `checkKumimoji`). A table of players shares one bag
+ * (`startParty`, `endTurn`), and a computer player can sit at it
+ * (`planComputerTurn`). Nothing here touches the DOM or a clock.
+ *
+ * The word lists are loaded when first needed: in a browser by
+ * `loadTileWords`, which fetches them as their own modules; on a server or in
+ * a test through `@johnmorrisdotca/kumimoji/words`, which reads them from
+ * disk.
+ */
+export * from "./kumimoji.types.ts";
+export * from "./tiles.constants.ts";
+export * from "./kana.ts";
+export * from "./tileFace.ts";
+export * from "./tileFamily.ts";
+export * from "./tileWords.ts";
+export * from "./grid.ts";
+export * from "./placement.ts";
+export * from "./wilds.ts";
+export * from "./judge.ts";
+export * from "./check.ts";
+export * from "./generate.ts";
+export * from "./play.ts";
+export * from "./help.ts";
+export * from "./turn.ts";
+export * from "./tableView.ts";
+export * from "./showcase.ts";
+export * from "./party.types.ts";
+export * from "./party.ts";
+export * from "./partyTurns.ts";
+export * from "./partySeats.ts";
+export * from "./partyKept.ts";
+export * from "./computer.types.ts";
+export * from "./computerPlay.ts";
+export * from "./computerTurn.ts";
+export * from "./random.ts";

package/dist/index.js

@@ -0,0 +1,44 @@
+/**
+ * Kumimoji 組み文字: the race to build a crossword from a bag of letter
+ * tiles, in English or Japanese, alone or at a table of two to eight, as
+ * plain functions over plain data.
+ *
+ * A game is dealt from a seed (`generateKumimoji`), so two players racing the
+ * same bag get the same tiles in the same order. The tiles you hold and the
+ * grid you build are values (`deal`, `placeFromHand`, `draw`, `trade` and the
+ * rest), and every run across and down is judged against a word list
+ * (`judgeWithWords`, `checkKumimoji`). A table of players shares one bag
+ * (`startParty`, `endTurn`), and a computer player can sit at it
+ * (`planComputerTurn`). Nothing here touches the DOM or a clock.
+ *
+ * The word lists are loaded when first needed: in a browser by
+ * `loadTileWords`, which fetches them as their own modules; on a server or in
+ * a test through `@johnmorrisdotca/kumimoji/words`, which reads them from
+ * disk.
+ */
+export * from "./kumimoji.types.js";
+export * from "./tiles.constants.js";
+export * from "./kana.js";
+export * from "./tileFace.js";
+export * from "./tileFamily.js";
+export * from "./tileWords.js";
+export * from "./grid.js";
+export * from "./placement.js";
+export * from "./wilds.js";
+export * from "./judge.js";
+export * from "./check.js";
+export * from "./generate.js";
+export * from "./play.js";
+export * from "./help.js";
+export * from "./turn.js";
+export * from "./tableView.js";
+export * from "./showcase.js";
+export * from "./party.types.js";
+export * from "./party.js";
+export * from "./partyTurns.js";
+export * from "./partySeats.js";
+export * from "./partyKept.js";
+export * from "./computer.types.js";
+export * from "./computerPlay.js";
+export * from "./computerTurn.js";
+export * from "./random.js";

package/dist/judge.d.ts

@@ -0,0 +1,13 @@
+import { type GridRules, type GridVerdict, type Tiles } from "./grid.ts";
+import type { TileWords } from "./tileWords.ts";
+/**
+ * A GRID JUDGED AGAINST ITS LANGUAGE'S LIST, the one way the solo game, each
+ * seat of a pass-and-play game and the server's check all ask it: a run is a
+ * word when its tiles spell one the list holds (`wordOf`, so a wild reads as
+ * the letter or kana it was given), and a run that is not is named as it
+ * reads. A wild given no letter reads as whichever letter makes every run
+ * through it a word (`readWilds`); where none does, the grid is judged as
+ * laid and the run is named with its `*`. `rules` says whether the diagonals
+ * are read (`GridRules`).
+ */
+export declare function judgeWithWords(tiles: Tiles, words: TileWords, rules?: GridRules): GridVerdict;

package/dist/judge.js

@@ -0,0 +1,19 @@
+import { judgeGrid } from "./grid.js";
+import { readWilds } from "./wilds.js";
+/**
+ * A GRID JUDGED AGAINST ITS LANGUAGE'S LIST, the one way the solo game, each
+ * seat of a pass-and-play game and the server's check all ask it: a run is a
+ * word when its tiles spell one the list holds (`wordOf`, so a wild reads as
+ * the letter or kana it was given), and a run that is not is named as it
+ * reads. A wild given no letter reads as whichever letter makes every run
+ * through it a word (`readWilds`); where none does, the grid is judged as
+ * laid and the run is named with its `*`. `rules` says whether the diagonals
+ * are read (`GridRules`).
+ */
+export function judgeWithWords(tiles, words, rules = {}) {
+    const read = readWilds(tiles, words, rules) ?? tiles;
+    return judgeGrid(read, (codes) => {
+        const word = words.wordOf(codes);
+        return word !== null && words.allowed.has(word);
+    }, (codes) => words.wordOf(codes) ?? codes, rules);
+}

package/dist/kana.d.ts

@@ -0,0 +1,25 @@
+/**
+ * JAPANESE KUMIMOJI'S TILES ARE THE 45 BASE KANA, and every other kana is one
+ * of them played another way. John, 2026-09-28: "any letters can have it work
+ * like the HA letter", and of を, combine it "with something similar".
+ *
+ * - A voiced or half-voiced kana is its base: が is か, ば and ぱ are は.
+ * - A small kana is its large one: ゃ is や, っ is つ.
+ * - を is お, which it sounds like; ゐ and ゑ, which no modern word uses, are い and え.
+ *
+ * So a line of tiles is a word when it spells one read that way, the rule
+ * Japanese crosswords have always kept for small kana, and nobody chooses a
+ * form: は then ん is はん, ばん and ぱん at once. The word list is stored
+ * already read this way (`scripts/word-lists-ja.mjs` folds it with the same
+ * table), so checking a line is one lookup.
+ */
+export declare const BASE_KANA = "\u3042\u3044\u3046\u3048\u304A\u304B\u304D\u304F\u3051\u3053\u3055\u3057\u3059\u305B\u305D\u305F\u3061\u3064\u3066\u3068\u306A\u306B\u306C\u306D\u306E\u306F\u3072\u3075\u3078\u307B\u307E\u307F\u3080\u3081\u3082\u3084\u3086\u3088\u3089\u308A\u308B\u308C\u308D\u308F\u3093";
+/** The tile a kana is played with, or null for anything that is not hiragana (ー, katakana, a letter). */
+export declare function tileKana(kana: string): string | null;
+/**
+ * WHAT A TILE SHOWS SMALL IN ITS CORNER: the other ways it is commonly played
+ * (John, 2026-09-28: "the tiles like Yu can show the regular and small version
+ * in that tile to show its versatility"). Only the forms a player reaches for;
+ * the rare ones (ぁ, ゎ, ゔ) still play, and the rules say so.
+ */
+export declare const CORNER_FORMS: Readonly<Record<string, string>>;

package/dist/kana.js

@@ -0,0 +1,38 @@
+/**
+ * JAPANESE KUMIMOJI'S TILES ARE THE 45 BASE KANA, and every other kana is one
+ * of them played another way. John, 2026-09-28: "any letters can have it work
+ * like the HA letter", and of を, combine it "with something similar".
+ *
+ * - A voiced or half-voiced kana is its base: が is か, ば and ぱ are は.
+ * - A small kana is its large one: ゃ is や, っ is つ.
+ * - を is お, which it sounds like; ゐ and ゑ, which no modern word uses, are い and え.
+ *
+ * So a line of tiles is a word when it spells one read that way, the rule
+ * Japanese crosswords have always kept for small kana, and nobody chooses a
+ * form: は then ん is はん, ばん and ぱん at once. The word list is stored
+ * already read this way (`scripts/word-lists-ja.mjs` folds it with the same
+ * table), so checking a line is one lookup.
+ */
+export const BASE_KANA = "あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわん";
+const SMALL_AND_OLD = {
+    ぁ: "あ", ぃ: "い", ぅ: "う", ぇ: "え", ぉ: "お", っ: "つ", ゃ: "や", ゅ: "ゆ", ょ: "よ", ゎ: "わ", ゕ: "か", ゖ: "け", を: "お", ゐ: "い", ゑ: "え",
+};
+/** The tile a kana is played with, or null for anything that is not hiragana (ー, katakana, a letter). */
+export function tileKana(kana) {
+    const bare = kana.normalize("NFD").replace(/[゙゚]/gu, "").normalize("NFC");
+    const base = SMALL_AND_OLD[bare] ?? bare;
+    return base.length === 1 && BASE_KANA.includes(base) ? base : null;
+}
+/**
+ * WHAT A TILE SHOWS SMALL IN ITS CORNER: the other ways it is commonly played
+ * (John, 2026-09-28: "the tiles like Yu can show the regular and small version
+ * in that tile to show its versatility"). Only the forms a player reaches for;
+ * the rare ones (ぁ, ゎ, ゔ) still play, and the rules say so.
+ */
+export const CORNER_FORMS = {
+    か: "が", き: "ぎ", く: "ぐ", け: "げ", こ: "ご",
+    さ: "ざ", し: "じ", す: "ず", せ: "ぜ", そ: "ぞ",
+    た: "だ", ち: "ぢ", つ: "っづ", て: "で", と: "ど",
+    は: "ばぱ", ひ: "びぴ", ふ: "ぶぷ", へ: "べぺ", ほ: "ぼぽ",
+    や: "ゃ", ゆ: "ゅ", よ: "ょ", お: "を",
+};

package/dist/kumimoji.types.d.ts

@@ -0,0 +1,49 @@
+export type KumimojiLength = "short" | "medium" | "full";
+/** How many of the bag's tiles are wild: easy the most, hard none (`KUMIMOJI_WILDS`). */
+export type KumimojiLevel = "easy" | "medium" | "hard";
+export type KumimojiLanguage = "english" | "japanese";
+/** How far the player has turned the table to look at it: quarter turns clockwise, 0 to 3. The view alone; the grid never turns. */
+export type Turn = 0 | 1 | 2 | 3;
+/**
+ * WHAT A KUMIMOJI WAS SET UP AS, beyond its hand and level: the choices that
+ * make one game a different game from another at the same seed, carried
+ * together wherever a game is made, checked, kept or raced. Each is optional,
+ * and its absence is the default: Short, English, one set, no diagonals.
+ */
+export type KumimojiOptions = {
+    gameLength?: KumimojiLength;
+    doubleSet?: boolean;
+    language?: KumimojiLanguage;
+    /**
+     * Diagonals (John, 2026-09-28: "we could allow people to play diagonally…
+     * An option at startup is the right choice"): every diagonal run of three
+     * or more tiles, read top to bottom, must be a word too, and joins its
+     * tiles as a word across or down does (`judgeGrid`). Off by default.
+     */
+    diagonals?: boolean;
+};
+/** The answer to "does this grid finish the game?": yes, or no and why. */
+export type KumimojiCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * A GAME DEALT (`generateKumimoji`): the bag, in the order its tiles come out,
+ * as one string of tile codes (`*` a wild), and one finished grid of those
+ * tiles that proves the bag can be finished, never shown to the player.
+ */
+export type KumimojiDeal = {
+    kind: "kumimoji";
+    /** The opening hand: 3, 7 or 11 tiles (`KUMIMOJI_HANDS`). */
+    size: number;
+    level: KumimojiLevel;
+    seed: number;
+    givens: string;
+    solution: string;
+    gameLength: KumimojiLength;
+    doubleSet: boolean;
+    language: KumimojiLanguage;
+    diagonals?: boolean;
+};

package/dist/kumimoji.types.js

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