@johnmorrisdotca/kumimoji 1.0.1

package/dist/tileFace.js

@@ -0,0 +1,39 @@
+import { BASE_KANA, CORNER_FORMS } from "./kana.js";
+/**
+ * WHAT A TILE CODE SHOWS, without the word list. A bag, a kept game and a
+ * finished grid hold one character a tile: an English letter as itself (a wild
+ * given a letter is that letter in capitals, a wild with none is `*`), and a
+ * Japanese kana as a private-use character, its place in `BASE_KANA` above
+ * `KANA_TILE_START`, or above `KANA_WILD_START` for a wild given that kana.
+ * So the set-up's preview and a finished game's page draw Japanese tiles
+ * without fetching the dictionary, and `tileWords` reads the same codes.
+ */
+export const KANA_TILE_START = 0xe000;
+export const KANA_WILD_START = 0xf000;
+const KANA = [...BASE_KANA];
+/** The code of a base kana's tile, or of a wild given that kana. */
+export function kanaTileCode(kana, wild = false) {
+    const at = KANA.indexOf(kana);
+    return at === -1 ? null : String.fromCodePoint((wild ? KANA_WILD_START : KANA_TILE_START) + at);
+}
+export function tileFace(tile) {
+    if (tile === "*")
+        return { glyph: "五", forms: "", wild: true, blank: true };
+    if (/^[A-Z]$/.test(tile))
+        return { glyph: tile.toLowerCase(), forms: "", wild: true, blank: false };
+    const point = tile.length === 1 ? tile.codePointAt(0) : -1;
+    const kana = KANA[point - KANA_TILE_START];
+    if (kana !== undefined)
+        return { glyph: kana, forms: CORNER_FORMS[kana] ?? "", wild: false, blank: false };
+    const wildKana = KANA[point - KANA_WILD_START];
+    if (wildKana !== undefined)
+        return { glyph: wildKana, forms: "", wild: true, blank: false };
+    return { glyph: tile, forms: "", wild: false, blank: false };
+}
+/** What a screen reader says for a tile: its letter, or that it is a wild and what it stands for. */
+export function tileDescription(tile) {
+    const face = tileFace(tile);
+    if (face.wild)
+        return `Wild, ${face.blank ? "unassigned" : face.glyph}`;
+    return face.glyph.toUpperCase();
+}

package/dist/tileFamily.d.ts

@@ -0,0 +1,11 @@
+import type { KumimojiLanguage } from "./kumimoji.types.ts";
+/**
+ * WHICH TILE OF THE SET A TILE IS, without the word lists: a letter is
+ * itself, and any wild — blank or given a face — is the wild. The same answer
+ * the loaded list's `familyKey` gives (`tileWords.ts`), for code that must
+ * never load a dictionary: the server checking a party table's move on
+ * several devices (docs/plans/party-online/README.md, John 2026-09-29: the
+ * browser checks the words, the server only that the tiles are real).
+ * `tileFamily.test.ts` holds the two to one another.
+ */
+export declare function familyKeyOf(language: KumimojiLanguage): (tile: string) => string | null;

package/dist/tileFamily.js

@@ -0,0 +1,23 @@
+import { BASE_KANA } from "./kana.js";
+import { KANA_TILE_START, KANA_WILD_START, tileFace } from "./tileFace.js";
+/**
+ * WHICH TILE OF THE SET A TILE IS, without the word lists: a letter is
+ * itself, and any wild — blank or given a face — is the wild. The same answer
+ * the loaded list's `familyKey` gives (`tileWords.ts`), for code that must
+ * never load a dictionary: the server checking a party table's move on
+ * several devices (docs/plans/party-online/README.md, John 2026-09-29: the
+ * browser checks the words, the server only that the tiles are real).
+ * `tileFamily.test.ts` holds the two to one another.
+ */
+export function familyKeyOf(language) {
+    if (language === "english") {
+        return (tile) => (tile === "*" || /^[A-Z]$/.test(tile) ? "*" : /^[a-z]$/.test(tile) ? tile : null);
+    }
+    const offset = (tile, start) => (tile.length === 1 ? tile.codePointAt(0) - start : -1);
+    const within = (at) => at >= 0 && at < [...BASE_KANA].length;
+    return (tile) => {
+        if (tile === "*" || within(offset(tile, KANA_WILD_START)))
+            return "*";
+        return within(offset(tile, KANA_TILE_START)) ? tileFace(tile).glyph : null;
+    };
+}

package/dist/tileWords.d.ts

@@ -0,0 +1,70 @@
+import type { KumimojiLanguage } from "./kumimoji.types.ts";
+/**
+ * KUMIMOJI'S WORD LIST, loaded once, when a game opens.
+ *
+ * The list is about six hundred kilobytes before compression (a hundred and
+ * ten thousand words, `words.en.data.ts`), so it is its own module, fetched by
+ * a dynamic import only when a Kumimoji is made or checked: no other page, and
+ * not the set-up screen, carries a byte of it. The kana Gomoji loads its lists
+ * the same way (`kanaWords.ts`).
+ *
+ * `loadTileWords` fetches and reads it once; `tileWords` hands back the list
+ * already loaded, and refuses rather than answering for a list it does not
+ * have — a check that could not read the list must not say a word is fine.
+ */
+export type TileWords = {
+    language: KumimojiLanguage;
+    /** Every word, for asking "is this a word?". */
+    allowed: ReadonlySet<string>;
+    /** Encoded tile words of each length, for the generator to choose among. */
+    byLength: ReadonlyMap<number, readonly string[]>;
+    /** The physical set, keyed by its one-character tile codes. */
+    mix: ReadonlyMap<string, number>;
+    /** Visible glyph for a tile code. */
+    glyphOf: (tile: string) => string;
+    /** Reading represented by a tile code, or null for an unassigned wild. */
+    soundOf: (tile: string) => string | null;
+    /** Turn a run of tile codes into its word, or null for an invalid/unassigned tile. */
+    wordOf: (tiles: string) => string | null;
+    /** Physical wildcard, with `sound` assigned. */
+    wildFor: (sound: string) => string | null;
+    /** Whether this code is a wildcard, assigned or not. */
+    isWild: (tile: string) => boolean;
+    /** Display the sound assigned to a wildcard, or null if it has none. */
+    wildSound: (tile: string) => string | null;
+    /** Identity used to verify that the exact physical bag was played. */
+    inventoryKey: (tile: string) => string | null;
+    /** Which tile of the set this is, a wild being any wild. */
+    familyKey: (tile: string) => string | null;
+    /** The other forms a tile plays as, shown small in its corner: ば and ぱ on は. */
+    formsOf: (tile: string) => string;
+    /** Possible readings for a wild tile. */
+    wildOptions: readonly string[];
+    /** Internal tile code for a visible letter or mora. */
+    codeOf: (face: string) => string | null;
+};
+/** Front-coded words of one length read back (see `scripts/tile-words.mjs`): a shared-prefix character, then the rest. */
+export declare function unpackLength(packed: string, length: number): string[];
+export declare function unpackTileWords(data: Readonly<Record<number, string>>): TileWords;
+/** Used by `tileWordsModule.ts` only: how to read a list where there is no browser. */
+export declare function readTileWordsWith(source: (language: KumimojiLanguage) => Promise<TileWords>): void;
+/** A list read from its module, for `tileWordsModule.ts`. */
+export declare function tileWordsFrom(language: KumimojiLanguage, data: unknown): TileWords;
+/**
+ * THE LIST, ONCE. In a browser (or its worker) it arrives as its own script,
+ * fetched by the dynamic import below the first time a Kumimoji needs it.
+ *
+ * ONLY IN A BROWSER, AND SAID SO WHERE THE BUILD CAN SEE IT. The page's
+ * components are drawn on the server too, and a dynamic import in them is a
+ * copy of its target in every server function — two lists, 1.3 MB, which put
+ * the site's grouped function over its size limit (`functionSizeGate`). The
+ * build writes `typeof window` as a constant — "undefined" on the server,
+ * "object" in a browser bundle, its worker included — so on the server the
+ * branch, and the import with it, is gone before anything is traced. The
+ * server reads the list through `tileWordsModule.ts` instead, which only the
+ * server's own checks and the tests import.
+ */
+export declare function loadTileWords(language?: KumimojiLanguage): Promise<TileWords>;
+export declare function tileWords(language?: KumimojiLanguage): TileWords;
+/** Whether the list has been fetched yet, for a page to say "loading" rather than throw. */
+export declare function tileWordsReady(language?: KumimojiLanguage): boolean;

package/dist/tileWords.js

@@ -0,0 +1,164 @@
+import { tileKana } from "./kana.js";
+import { KANA_TILE_START, KANA_WILD_START, kanaTileCode, tileFace } from "./tileFace.js";
+import { JAPANESE_TILE_MIX, TILE_MIX } from "./tiles.constants.js";
+const loaded = new Map();
+/** Front-coded words of one length read back (see `scripts/tile-words.mjs`): a shared-prefix character, then the rest. */
+export function unpackLength(packed, length) {
+    const words = [];
+    const text = packed.replace(/\s+/g, "");
+    let before = "";
+    let at = 0;
+    while (at < text.length) {
+        const shared = parseInt(text[at], 16);
+        const rest = length - shared;
+        const word = before.slice(0, shared) + text.slice(at + 1, at + 1 + rest);
+        words.push(word);
+        before = word;
+        at += 1 + rest;
+    }
+    return words;
+}
+export function unpackTileWords(data) {
+    const byLength = new Map();
+    const allowed = new Set();
+    for (const [length, packed] of Object.entries(data)) {
+        const words = unpackLength(packed, Number(length));
+        byLength.set(Number(length), words);
+        for (const word of words)
+            allowed.add(word);
+    }
+    const letters = [...Object.keys(TILE_MIX)];
+    const assigned = new Map(letters.map((letter) => [letter.toUpperCase(), letter]));
+    const soundOf = (tile) => (tile === "*" ? null : assigned.get(tile) ?? (/^[a-z]$/.test(tile) ? tile : null));
+    const isWild = (tile) => tile === "*" || assigned.has(tile);
+    return {
+        language: "english",
+        allowed,
+        byLength,
+        mix: new Map(Object.entries(TILE_MIX)),
+        glyphOf: (tile) => soundOf(tile) ?? (tile === "*" ? "五" : tile),
+        soundOf,
+        wordOf: (tiles) => {
+            const sounds = [...tiles].map(soundOf);
+            return sounds.some((sound) => sound === null) ? null : sounds.join("");
+        },
+        wildFor: (sound) => (/^[a-z]$/.test(sound) ? sound.toUpperCase() : null),
+        isWild,
+        wildSound: (tile) => (assigned.has(tile) ? assigned.get(tile) : null),
+        inventoryKey: (tile) => (isWild(tile) ? "*" : /^[a-z]$/.test(tile) ? tile : null),
+        familyKey: (tile) => (isWild(tile) ? "*" : /^[a-z]$/.test(tile) ? tile : null),
+        formsOf: () => "",
+        wildOptions: letters,
+        codeOf: (face) => (/^[a-z]$/.test(face) ? face : null),
+    };
+}
+/**
+ * The Japanese list, spelt in the 45 base kana (`kana.ts`): a tile is its
+ * kana's code above `KANA_TILE_START`, so a line of tiles reads straight off
+ * as the folded word it spells, and が, ゃ and を are found by the tile they
+ * are played with.
+ */
+function unpackJapaneseWords(data) {
+    const kana = [...data.kana];
+    if (kana.some((face, at) => kanaTileCode(face) !== String.fromCodePoint(KANA_TILE_START + at)))
+        throw new Error("The Japanese Kumimoji list's kana are not the tiles' own order.");
+    const tileOfPacked = new Map([...data.codes].map((code, at) => [code, kanaTileCode(kana[at])]));
+    const byLength = new Map();
+    const allowed = new Set();
+    for (const [length, packed] of Object.entries(data.byLength)) {
+        const words = unpackLength(packed, Number(length)).map((word) => [...word].map((code) => tileOfPacked.get(code)).join(""));
+        byLength.set(Number(length), words);
+        for (const word of words)
+            allowed.add([...word].map((tile) => tileFace(tile).glyph).join(""));
+    }
+    const mix = new Map(Object.entries(JAPANESE_TILE_MIX).map(([face, count]) => [kanaTileCode(face), count]));
+    const isTile = (tile) => tile.length === 1 && tile.codePointAt(0) - KANA_TILE_START >= 0 && tile.codePointAt(0) - KANA_TILE_START < kana.length;
+    const isAssignedWild = (tile) => tile.length === 1 && tile.codePointAt(0) - KANA_WILD_START >= 0 && tile.codePointAt(0) - KANA_WILD_START < kana.length;
+    const isWild = (tile) => tile === "*" || isAssignedWild(tile);
+    const soundOf = (tile) => (isTile(tile) || isAssignedWild(tile) ? tileFace(tile).glyph : null);
+    const identity = (tile) => (isWild(tile) ? "*" : isTile(tile) ? tileFace(tile).glyph : null);
+    return {
+        language: "japanese",
+        allowed,
+        byLength,
+        mix,
+        glyphOf: (tile) => tileFace(tile).glyph,
+        soundOf,
+        wordOf: (tiles) => {
+            const sounds = [...tiles].map(soundOf);
+            return sounds.some((sound) => sound === null) ? null : sounds.join("");
+        },
+        wildFor: (sound) => {
+            const base = tileKana(sound);
+            return base === null ? null : kanaTileCode(base, true);
+        },
+        isWild,
+        wildSound: (tile) => (isAssignedWild(tile) ? tileFace(tile).glyph : null),
+        inventoryKey: identity,
+        familyKey: identity,
+        formsOf: (tile) => (isTile(tile) ? tileFace(tile).forms : ""),
+        wildOptions: kana,
+        codeOf: (face) => {
+            const base = tileKana(face);
+            return base === null ? null : kanaTileCode(base);
+        },
+    };
+}
+/**
+ * Where the lists come from where there is no browser — a server checking a
+ * solve, a unit test, a browser spec's own process — registered by the
+ * loader that imports them (`tileWordsModule.ts`). Null until one does.
+ */
+let fromModule = null;
+/** Used by `tileWordsModule.ts` only: how to read a list where there is no browser. */
+export function readTileWordsWith(source) {
+    fromModule = source;
+}
+/** A list read from its module, for `tileWordsModule.ts`. */
+export function tileWordsFrom(language, data) {
+    return language === "english"
+        ? unpackTileWords(data)
+        : unpackJapaneseWords(data);
+}
+/**
+ * THE LIST, ONCE. In a browser (or its worker) it arrives as its own script,
+ * fetched by the dynamic import below the first time a Kumimoji needs it.
+ *
+ * ONLY IN A BROWSER, AND SAID SO WHERE THE BUILD CAN SEE IT. The page's
+ * components are drawn on the server too, and a dynamic import in them is a
+ * copy of its target in every server function — two lists, 1.3 MB, which put
+ * the site's grouped function over its size limit (`functionSizeGate`). The
+ * build writes `typeof window` as a constant — "undefined" on the server,
+ * "object" in a browser bundle, its worker included — so on the server the
+ * branch, and the import with it, is gone before anything is traced. The
+ * server reads the list through `tileWordsModule.ts` instead, which only the
+ * server's own checks and the tests import.
+ */
+export async function loadTileWords(language = "english") {
+    const already = loaded.get(language);
+    if (already !== undefined)
+        return already;
+    let words;
+    if (typeof window !== "undefined") {
+        words = language === "english"
+            ? unpackTileWords((await import("./words.en.data.js")).TILE_WORDS_EN)
+            : unpackJapaneseWords((await import("./words.ja.data.js")).TILE_WORDS_JA);
+    }
+    else {
+        if (fromModule === null)
+            throw new Error("Kumimoji's words are read on the server through tileWordsModule.ts (loadTileWordsFromModule), which was not imported.");
+        words = await fromModule(language);
+    }
+    loaded.set(language, words);
+    return words;
+}
+export function tileWords(language = "english") {
+    const words = loaded.get(language);
+    if (words === undefined)
+        throw new Error(`The ${language} Kumimoji words have not been loaded (loadTileWords).`);
+    return words;
+}
+/** Whether the list has been fetched yet, for a page to say "loading" rather than throw. */
+export function tileWordsReady(language = "english") {
+    return loaded.has(language);
+}

package/dist/tileWordsModule.d.ts

@@ -0,0 +1,4 @@
+import { type TileWords } from "./tileWords.ts";
+import type { KumimojiLanguage } from "./kumimoji.types.ts";
+/** The list, read from its module: `loadTileWords` for a caller with no browser. */
+export declare function loadTileWordsFromModule(language?: KumimojiLanguage): Promise<TileWords>;

package/dist/tileWordsModule.js

@@ -0,0 +1,13 @@
+import { loadTileWords, readTileWordsWith, tileWordsFrom } from "./tileWords.js";
+/**
+ * KUMIMOJI'S LISTS WHERE THERE IS NO BROWSER: a server checking a handed-in
+ * solve or a race (`preparePuzzleOnServer`), a unit test, a browser spec's own
+ * process. Importing this module is what lets `loadTileWords` answer there; a
+ * page's components never import it, so no page's server function carries the
+ * lists for the browser's sake (see `loadTileWords`).
+ */
+readTileWordsWith(async (language) => tileWordsFrom(language, language === "english" ? (await import("./words.en.data.js")).TILE_WORDS_EN : (await import("./words.ja.data.js")).TILE_WORDS_JA));
+/** The list, read from its module: `loadTileWords` for a caller with no browser. */
+export function loadTileWordsFromModule(language = "english") {
+    return loadTileWords(language);
+}

package/dist/tiles.constants.d.ts

@@ -0,0 +1,108 @@
+import type { KumimojiLength } from "./kumimoji.types.ts";
+/**
+ * KUMIMOJI 組文字: build one crossword of your own from letter tiles drawn
+ * from a bag, and draw more whenever the hand is used and the grid is sound.
+ *
+ * Every number the game is played by is here, in one table each, so John can
+ * tune the game without reading the code that plays it.
+ */
+/**
+ * THE MIX: how many of each letter a full set holds, 144 tiles in all. This is
+ * the letter-frequency table of the best-known anagram-grid tile game, a fact
+ * about how often English uses its letters and nobody's rule text. Short and
+ * Medium games draw from it; Full uses all 144 tiles. Double uses two copies.
+ *
+ * To tune the letters, change the counts here. The total is checked by
+ * `tiles.test.ts`, so an edit that loses a tile says so.
+ */
+export declare const TILE_MIX: Readonly<Record<string, number>>;
+/**
+ * THE JAPANESE SET: 144 hiragana tiles in 45 kinds (`kana.ts`), as the English
+ * set is 144 letters. Shared by how often each kana is used in the commonest
+ * words — the answers the kana Gomoji hides, each kana read as its tile — with
+ * one of any kana that comes out below one; measured that way, English comes
+ * out the shape of the table above. So ぬ, へ, ね, ろ, れ, む and の are the
+ * hard tiles, Japanese's Q, X and Z, and う, ん, い and し, which end and join
+ * everything, are its E's. John, 2026-09-28: "the letters that you don't
+ * really wanna get… should really be low counts just like Z and XNQ".
+ *
+ * Fixed here rather than taken from the monthly dictionary refresh, which
+ * prints what it measures beside this table (`scripts/word-lists-ja.mjs`): a
+ * kept game's bag is checked against these counts.
+ */
+export declare const JAPANESE_TILE_MIX: Readonly<Record<string, number>>;
+/** The whole set, counted from the table. */
+export declare const TILE_MIX_TOTAL: number;
+/**
+ * THERE IS NO BOARD. John, 2026-09-26: "curious if we just have a large board
+ * that iphone users have to zoom in and out, scroll, etc… since literally
+ * there is no board in the real world game." The tiles lie on a table that
+ * grows with them (`tableView.ts`), so a grid is as wide and as tall as its
+ * player builds it. This is only the most a finished grid may measure either
+ * way before the check refuses it unread: fifty tiles in one line is fifty.
+ */
+export declare const KUMIMOJI_GRID_MOST = 60;
+/**
+ * THE HANDS, which are the puzzle's sizes: the tiles a game opens with. John,
+ * 2026-09-26: "you were given seven or 11 starting tiles". Three is for the
+ * browser tests alone — a game that can be finished in a few presses — and is
+ * never offered on the set-up screen.
+ */
+export declare const KUMIMOJI_HANDS: {
+    readonly tiny: 3;
+    readonly quick: 7;
+    readonly classic: 11;
+};
+/**
+ * SHORT GAME TOTALS, by opening hand. Medium and Full derive from the tile
+ * inventory in `kumimojiTileCount`; these stay the existing Short lengths.
+ */
+export declare const KUMIMOJI_BAG: Readonly<Record<number, number>>;
+/** Wild tiles per original 40/50-tile game, included within the bag total. */
+export declare const KUMIMOJI_WILDS: Readonly<Record<number, Readonly<Record<"easy" | "medium" | "hard", number>>>>;
+/** Tile count for a selected length and inventory size. Double supplies two sets. */
+export declare function kumimojiTileCount(hand: number, length: KumimojiLength, setSize?: number, doubleSet?: boolean): number;
+/** Wilds scale with the bag; doubling the tile set doubles the wild count too. */
+export declare function kumimojiWildCount(hand: number, level: "easy" | "medium" | "hard", totalTiles: number): number;
+/** How many tiles one Draw takes from the bag, once the hand is used and the grid is sound. */
+export declare const KUMIMOJI_DRAW = 1;
+/**
+ * THE TRADE: one awkward tile back into the bag for three new ones — the
+ * classic way out of a hand of Q, X and J. The tile given back goes to the
+ * bottom of the bag, so it comes round again before the end; offered only
+ * while the bag has three to give.
+ */
+export declare const KUMIMOJI_TRADE: {
+    readonly give: 1;
+    readonly take: 3;
+};
+/**
+ * WHAT A FINISHED GAME SCORES on its leaderboard, as the other puzzles score
+ * theirs (`puzzlePoints.ts`): ten for every tile laid, and as much again for
+ * speed, which falls away evenly until a game that took half a minute a tile
+ * earns no speed at all. A Classic game of fifty tiles in ten minutes is
+ * 500 + 300 = 800. The time is the browser's clock, as every solo time here is.
+ */
+export declare const KUMIMOJI_SCORE: {
+    readonly tile: 10;
+    readonly slowestMsATile: 30000;
+};
+/**
+ * PASS AND PLAY: up to eight people round one device, each with a hand and a
+ * table of their own from one shared bag (`party.ts`). John, 2026-09-28: "pass
+ * and play with up to eight players". One player is the solo game, unchanged.
+ * A name is optional and kept to a line: it is shown on the cover and the
+ * finish, never sent anywhere.
+ */
+/**
+ * `doubleFrom`: from this many players the set-up screen recommends the Double
+ * set, and chooses it when the count reaches it (John, 2026-09-28: "when having
+ * 6 or more players, we should recommend the double size 288 version"); in
+ * Japanese, which has no Double, the Full game instead.
+ */
+export declare const KUMIMOJI_PARTY: {
+    readonly least: 2;
+    readonly most: 8;
+    readonly nameMost: 20;
+    readonly doubleFrom: 6;
+};

package/dist/tiles.constants.js

@@ -0,0 +1,132 @@
+/**
+ * KUMIMOJI 組文字: build one crossword of your own from letter tiles drawn
+ * from a bag, and draw more whenever the hand is used and the grid is sound.
+ *
+ * Every number the game is played by is here, in one table each, so John can
+ * tune the game without reading the code that plays it.
+ */
+/**
+ * THE MIX: how many of each letter a full set holds, 144 tiles in all. This is
+ * the letter-frequency table of the best-known anagram-grid tile game, a fact
+ * about how often English uses its letters and nobody's rule text. Short and
+ * Medium games draw from it; Full uses all 144 tiles. Double uses two copies.
+ *
+ * To tune the letters, change the counts here. The total is checked by
+ * `tiles.test.ts`, so an edit that loses a tile says so.
+ */
+export const TILE_MIX = {
+    a: 13, b: 3, c: 3, d: 6, e: 18, f: 3, g: 4, h: 3, i: 12, j: 2, k: 2, l: 5, m: 3,
+    n: 8, o: 11, p: 3, q: 2, r: 9, s: 6, t: 9, u: 6, v: 3, w: 3, x: 2, y: 3, z: 2,
+};
+/**
+ * THE JAPANESE SET: 144 hiragana tiles in 45 kinds (`kana.ts`), as the English
+ * set is 144 letters. Shared by how often each kana is used in the commonest
+ * words — the answers the kana Gomoji hides, each kana read as its tile — with
+ * one of any kana that comes out below one; measured that way, English comes
+ * out the shape of the table above. So ぬ, へ, ね, ろ, れ, む and の are the
+ * hard tiles, Japanese's Q, X and Z, and う, ん, い and し, which end and join
+ * everything, are its E's. John, 2026-09-28: "the letters that you don't
+ * really wanna get… should really be low counts just like Z and XNQ".
+ *
+ * Fixed here rather than taken from the monthly dictionary refresh, which
+ * prints what it measures beside this table (`scripts/word-lists-ja.mjs`): a
+ * kept game's bag is checked against these counts.
+ */
+export const JAPANESE_TILE_MIX = {
+    あ: 2, い: 11, う: 12, え: 1, お: 2, か: 7, き: 6, く: 6, け: 3, こ: 4,
+    さ: 3, し: 10, す: 2, せ: 3, そ: 2, た: 4, ち: 3, つ: 6, て: 2, と: 3,
+    な: 1, に: 1, ぬ: 1, ね: 1, の: 1, は: 2, ひ: 2, ふ: 2, へ: 1, ほ: 1,
+    ま: 2, み: 1, む: 1, め: 1, も: 1, や: 2, ゆ: 4, よ: 6, ら: 1, り: 3,
+    る: 3, れ: 1, ろ: 1, わ: 1, ん: 11,
+};
+/** The whole set, counted from the table. */
+export const TILE_MIX_TOTAL = Object.values(TILE_MIX).reduce((sum, count) => sum + count, 0);
+/**
+ * THERE IS NO BOARD. John, 2026-09-26: "curious if we just have a large board
+ * that iphone users have to zoom in and out, scroll, etc… since literally
+ * there is no board in the real world game." The tiles lie on a table that
+ * grows with them (`tableView.ts`), so a grid is as wide and as tall as its
+ * player builds it. This is only the most a finished grid may measure either
+ * way before the check refuses it unread: fifty tiles in one line is fifty.
+ */
+export const KUMIMOJI_GRID_MOST = 60;
+/**
+ * THE HANDS, which are the puzzle's sizes: the tiles a game opens with. John,
+ * 2026-09-26: "you were given seven or 11 starting tiles". Three is for the
+ * browser tests alone — a game that can be finished in a few presses — and is
+ * never offered on the set-up screen.
+ */
+export const KUMIMOJI_HANDS = { tiny: 3, quick: 7, classic: 11 };
+/**
+ * SHORT GAME TOTALS, by opening hand. Medium and Full derive from the tile
+ * inventory in `kumimojiTileCount`; these stay the existing Short lengths.
+ */
+export const KUMIMOJI_BAG = {
+    [KUMIMOJI_HANDS.tiny]: 5,
+    [KUMIMOJI_HANDS.quick]: 40,
+    [KUMIMOJI_HANDS.classic]: 50,
+};
+/** Wild tiles per original 40/50-tile game, included within the bag total. */
+export const KUMIMOJI_WILDS = {
+    [KUMIMOJI_HANDS.tiny]: { easy: 0, medium: 0, hard: 0 },
+    [KUMIMOJI_HANDS.quick]: { easy: 6, medium: 3, hard: 0 },
+    [KUMIMOJI_HANDS.classic]: { easy: 8, medium: 4, hard: 0 },
+};
+/** Tile count for a selected length and inventory size. Double supplies two sets. */
+export function kumimojiTileCount(hand, length, setSize = TILE_MIX_TOTAL, doubleSet = false) {
+    const short = KUMIMOJI_BAG[hand];
+    if (short === undefined)
+        throw new Error(`No Kumimoji with a hand of ${hand}.`);
+    if (!Number.isInteger(setSize) || setSize < 1)
+        throw new Error(`Invalid Kumimoji set size: ${setSize}.`);
+    const multiplier = doubleSet ? 2 : 1;
+    const available = setSize * multiplier;
+    if (short * multiplier > available)
+        throw new Error(`A short game needs more tiles than the ${available}-tile set holds.`);
+    if (length === "short")
+        return short * multiplier;
+    if (length === "medium")
+        return Math.floor(available / 2);
+    return available;
+}
+/** Wilds scale with the bag; doubling the tile set doubles the wild count too. */
+export function kumimojiWildCount(hand, level, totalTiles) {
+    const short = KUMIMOJI_BAG[hand];
+    const wilds = KUMIMOJI_WILDS[hand];
+    if (short === undefined || wilds === undefined)
+        throw new Error(`No Kumimoji with a hand of ${hand}.`);
+    if (!Number.isInteger(totalTiles) || totalTiles < short)
+        throw new Error(`Invalid Kumimoji tile count: ${totalTiles}.`);
+    return Math.round((wilds[level] * totalTiles) / short);
+}
+/** How many tiles one Draw takes from the bag, once the hand is used and the grid is sound. */
+export const KUMIMOJI_DRAW = 1;
+/**
+ * THE TRADE: one awkward tile back into the bag for three new ones — the
+ * classic way out of a hand of Q, X and J. The tile given back goes to the
+ * bottom of the bag, so it comes round again before the end; offered only
+ * while the bag has three to give.
+ */
+export const KUMIMOJI_TRADE = { give: 1, take: 3 };
+/**
+ * WHAT A FINISHED GAME SCORES on its leaderboard, as the other puzzles score
+ * theirs (`puzzlePoints.ts`): ten for every tile laid, and as much again for
+ * speed, which falls away evenly until a game that took half a minute a tile
+ * earns no speed at all. A Classic game of fifty tiles in ten minutes is
+ * 500 + 300 = 800. The time is the browser's clock, as every solo time here is.
+ */
+export const KUMIMOJI_SCORE = { tile: 10, slowestMsATile: 30000 };
+/**
+ * PASS AND PLAY: up to eight people round one device, each with a hand and a
+ * table of their own from one shared bag (`party.ts`). John, 2026-09-28: "pass
+ * and play with up to eight players". One player is the solo game, unchanged.
+ * A name is optional and kept to a line: it is shown on the cover and the
+ * finish, never sent anywhere.
+ */
+/**
+ * `doubleFrom`: from this many players the set-up screen recommends the Double
+ * set, and chooses it when the count reaches it (John, 2026-09-28: "when having
+ * 6 or more players, we should recommend the double size 288 version"); in
+ * Japanese, which has no Double, the Full game instead.
+ */
+export const KUMIMOJI_PARTY = { least: 2, most: 8, nameMost: 20, doubleFrom: 6 };

package/dist/turn.d.ts

@@ -0,0 +1,62 @@
+import type { Turn } from "./kumimoji.types.ts";
+import type { Area, View } from "./tableView.ts";
+/**
+ * TURNING THE TABLE, WITH EVERY TILE KEPT UPRIGHT. John, 2026-09-28: "if you
+ * rotate the board like flip it 180° for example then all the tiles will flip
+ * 180° to right themselves directly just so that they're not backwards for you
+ * or upside down."
+ *
+ * So the turn is a mapping of squares, never a rotation of the picture: the
+ * grid (its squares, `encodeGrid`, the kept game, the check) stays where the
+ * player built it, and only WHERE each square is drawn is turned — about the
+ * middle of square (0, 0), a quarter clockwise per press. A tile drawn at its
+ * turned place is drawn as it always is, so its letter reads the right way up
+ * whichever way the table faces. A point on the screen means the square drawn
+ * there, so a tap or a drop lands where the finger is.
+ *
+ * Pure, like the rest of the view (`tableView.ts`), which works on the turned
+ * squares unchanged: fitting, zooming and panning are all in screen terms.
+ */
+/** The next turn a press gives: a quarter clockwise, and four presses back to the start. */
+export declare function nextTurn(turn: Turn): Turn;
+/**
+ * Where square (row, col) of the grid is drawn with the table turned: a
+ * quarter clockwise sends a word running right to one running down, and one
+ * running down to one running left. It is linear, so it turns a step (a
+ * direction) as well as a square.
+ */
+export declare function turnPlace(row: number, col: number, turn: Turn): {
+    row: number;
+    col: number;
+};
+/** The grid's square drawn at (row, col) of the turned table: `turnPlace` undone. */
+export declare function unturnPlace(row: number, col: number, turn: Turn): {
+    row: number;
+    col: number;
+};
+/** The squares a turned table shows: the grid's area, turned. */
+export declare function turnArea(area: Area, turn: Turn): Area;
+/**
+ * A view the player zoomed or panned, turned a quarter clockwise with the
+ * table about the middle of its box: the same zoom, and the spot of the table
+ * that was in the middle stays there. (A fitted view simply fits again.)
+ *
+ * On the screen a square's corner is `x + col * tile`; the turn takes a point
+ * (row v, col u) of the table to (row u, col 1 - v), which is a quarter turn
+ * about the middle of square (0, 0) — the same turn as `turnPlace`.
+ */
+export declare function turnView(view: View, width: number, height: number): View;
+/**
+ * Which way typed letters run ON THE SCREEN. Typing lays a word across or
+ * down the grid, so that it reads as a word; with the table turned, that is
+ * another way on the screen, and the cursor's arrow points it.
+ */
+export declare function typingWay(across: boolean, turn: Turn): {
+    arrow: string;
+    name: string;
+};
+/** The step in the grid an arrow key means: the square that way on the screen, with the table turned. Null for any other key. */
+export declare function arrowStep(key: string, turn: Turn): {
+    row: number;
+    col: number;
+} | null;