@johnmorrisdotca/kumimoji 1.0.1

package/dist/computerPlay.js

@@ -0,0 +1,203 @@
+import { boundsOf, placeOf, squareAt } from "./grid.js";
+import { judgeWithWords } from "./judge.js";
+import { crossingFit } from "./placement.js";
+import { assignHandTile, placeFromHand } from "./play.js";
+import { KUMIMOJI_GRID_MOST } from "./tiles.constants.js";
+/**
+ * WHAT A COMPUTER PLAYER LAYS: one word at a time, from its own hand, onto its
+ * own table. Pure, and with no randomness at all — the same hand on the same
+ * table lays the same word — so a computer's turn replays exactly after a
+ * reload (`computerTurn.ts`).
+ *
+ * On an empty table it lays the longest word its hand spells, across. After
+ * that, each word crosses a tile already down, laid by the generator's own
+ * rule (`crossingFit`): nothing at either end and nothing at a new tile's
+ * sides, so a sound grid stays sound, and every laying is judged once more
+ * (`judgeGrid`) before it is kept. At a table set up with Diagonals it lays
+ * only where every diagonal run of three or more stays a word, and judges
+ * by that rule too, so it never leaves an unsound diagonal either. It never moves a tile it has laid, which is
+ * what a good player does and it does not: that, and not looking for words
+ * that run beside others, is what keeps it beatable.
+ *
+ * WILDS are played, never left: a word short of a letter or two the hand
+ * lacks uses a wild for each, given that letter as it is laid — but a word
+ * that needs none is always preferred to one as long that does.
+ */
+/** A tile's letter as the word list spells it (`a`, or a kana's base code), whatever wild it is on; "" for a wild with none. */
+function plainOf(tile, words) {
+    const sound = words.soundOf(tile);
+    return sound === null ? "" : (words.codeOf(sound) ?? "");
+}
+/** Whether a grid is sound, read against the loaded word list by the game's rules: the same judgement the desk shows. */
+export function judgeTiles(tiles, words, rules = {}) {
+    return judgeWithWords(tiles, words, rules);
+}
+function countHand(hand, words) {
+    const letters = new Map();
+    let wilds = 0;
+    for (const tile of hand) {
+        if (words.isWild(tile))
+            wilds += 1;
+        else
+            letters.set(plainOf(tile, words), (letters.get(plainOf(tile, words)) ?? 0) + 1);
+    }
+    return { letters, wilds };
+}
+/** How many letters of `word` the hand lacks, stopping once past `most`. */
+function lacking(word, hand, most) {
+    const used = new Map();
+    let short = 0;
+    for (const letter of word) {
+        const count = (used.get(letter) ?? 0) + 1;
+        used.set(letter, count);
+        if (count > (hand.letters.get(letter) ?? 0)) {
+            short += 1;
+            if (short > most)
+                return short;
+        }
+    }
+    return short;
+}
+/** How many tiles already down one word may run through: two lets it bridge a gap, as players do. */
+const CROSSED_MOST = 2;
+/** How many placements are tried in one search at most, so a turn's thinking stays a fraction of a second on a phone. */
+const FITS_MOST = 20000;
+/** A laying's worth: tiles used first, rare letters next, wilds spent last. */
+function worth(fresh, wilds, words) {
+    let rare = 0;
+    for (const { letter } of fresh)
+        rare += 1 / Math.max(1, words.mix.get(letter) ?? 1);
+    return fresh.length * 10 + rare * 2 - wilds * 4;
+}
+/** The letters new tiles need, covered by the hand: how many wilds that takes, or null where even the wilds cannot cover it. */
+function wildsNeeded(fresh, hand) {
+    const used = new Map();
+    let wilds = 0;
+    for (const { letter } of fresh) {
+        const count = (used.get(letter) ?? 0) + 1;
+        used.set(letter, count);
+        if (count > (hand.letters.get(letter) ?? 0))
+            wilds += 1;
+    }
+    return wilds > hand.wilds ? null : wilds;
+}
+/** Every laying of the hand on this table, best first; an empty table takes one word across from its first square. */
+function layings(play, words, rules) {
+    const hand = countHand(play.hand, words);
+    const empty = play.tiles.size === 0;
+    const letterAt = (row, col) => {
+        const tile = play.tiles.get(squareAt(row, col));
+        return tile === undefined ? "" : plainOf(tile, words) || "?";
+    };
+    // With Diagonals, a laying must leave every diagonal run of three or more a word (`crossingFit`).
+    const diagonalWord = rules.diagonals === true
+        ? (run) => {
+            const read = words.wordOf(run);
+            return read !== null && words.allowed.has(read);
+        }
+        : null;
+    const anchors = new Map();
+    for (const square of [...play.tiles.keys()].sort()) {
+        const letter = letterAt(placeOf(square).row, placeOf(square).col);
+        anchors.set(letter, [...(anchors.get(letter) ?? []), placeOf(square)]);
+    }
+    const bounds = boundsOf(play.tiles);
+    const fits = (first, last) => bounds === null ||
+        (Math.max(bounds.bottom, last.row) - Math.min(bounds.top, first.row) < KUMIMOJI_GRID_MOST && Math.max(bounds.right, last.col) - Math.min(bounds.left, first.col) < KUMIMOJI_GRID_MOST);
+    const found = [];
+    let tried = 0;
+    let mostFresh = 0;
+    const keep = (laying) => {
+        found.push(laying);
+        mostFresh = Math.max(mostFresh, laying.fresh.length);
+    };
+    const crossed = empty ? 0 : CROSSED_MOST;
+    const longest = Math.min(play.hand.length + crossed, Math.max(...words.byLength.keys()));
+    for (let length = longest; length >= 2 && tried < FITS_MOST; length -= 1) {
+        // Nothing shorter can use more tiles than the best already found: a word crossing one tile lays one fewer than its length.
+        if ((empty ? length : length - 1) < mostFresh)
+            break;
+        for (const word of words.byLength.get(length) ?? []) {
+            if (lacking(word, hand, hand.wilds + crossed) > hand.wilds + crossed)
+                continue;
+            if (empty) {
+                const fresh = [...word].map((letter, col) => ({ square: squareAt(0, col), letter }));
+                const wilds = wildsNeeded(fresh, hand);
+                if (wilds !== null)
+                    keep({ word, fresh, wilds, score: worth(fresh, wilds, words) });
+                continue;
+            }
+            for (let at = 0; at < word.length && tried < FITS_MOST; at += 1) {
+                for (const anchor of anchors.get(word[at]) ?? []) {
+                    for (const across of [true, false]) {
+                        tried += 1;
+                        const fit = crossingFit(letterAt, () => true, word, anchor, at, across, diagonalWord);
+                        if (fit === null)
+                            continue;
+                        const step = across ? { row: 0, col: 1 } : { row: 1, col: 0 };
+                        if (!fits(fit.first, { row: fit.first.row + (length - 1) * step.row, col: fit.first.col + (length - 1) * step.col }))
+                            continue;
+                        const fresh = fit.fresh.map((square) => ({ square: squareAt(square.row, square.col), letter: word[(square.row - fit.first.row) + (square.col - fit.first.col)] }));
+                        const wilds = wildsNeeded(fresh, hand);
+                        if (wilds !== null)
+                            keep({ word, fresh, wilds, score: worth(fresh, wilds, words) });
+                    }
+                }
+            }
+        }
+    }
+    // A stable sort: equal worth keeps the list's own order, so the choice never depends on anything but the hand and the table.
+    return found.sort((a, b) => b.score - a.score);
+}
+/** A laying made with the solo game's own moves: a tile of that letter from the hand, or a wild given it. */
+function lay(play, laying, words) {
+    let now = play;
+    for (const { square, letter } of laying.fresh) {
+        let at = now.hand.findIndex((tile) => !words.isWild(tile) && plainOf(tile, words) === letter);
+        if (at === -1) {
+            at = now.hand.findIndex((tile) => words.isWild(tile));
+            const sound = words.soundOf(letter);
+            const wild = sound === null ? null : words.wildFor(sound);
+            if (at === -1 || wild === null)
+                return null;
+            now = assignHandTile(now, at, wild);
+        }
+        now = placeFromHand(now, at, square);
+    }
+    return now;
+}
+/** How many of the best layings are judged before giving up on a hand: each is sound by construction, so the first nearly always is. */
+const JUDGED_MOST = 12;
+/**
+ * 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 function bestLaying(play, words, rules = {}) {
+    if (play.hand.length === 0)
+        return null;
+    if (play.tiles.size > 0 && !judgeTiles(play.tiles, words, rules).sound)
+        return null;
+    for (const laying of layings(play, words, rules).slice(0, JUDGED_MOST)) {
+        const next = lay(play, laying, words);
+        if (next !== null && judgeTiles(next.tiles, words, rules).sound)
+            return { play: next, word: laying.word };
+    }
+    return 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 function tradeChoice(hand, words) {
+    let chosen = null;
+    let fewest = Infinity;
+    hand.forEach((tile, at) => {
+        if (words.isWild(tile))
+            return;
+        const count = words.mix.get(plainOf(tile, words)) ?? 0;
+        if (count < fewest) {
+            fewest = count;
+            chosen = at;
+        }
+    });
+    return chosen;
+}

package/dist/computerTurn.d.ts

@@ -0,0 +1,31 @@
+import type { ComputerStep } from "./computer.types.ts";
+import type { PartyGame } from "./party.types.ts";
+import type { TileWords } from "./tileWords.ts";
+/**
+ * A COMPUTER'S TURN in a pass-and-play game (John, 2026-09-28: "Also you can
+ * add computer bots"), planned whole before any of it is shown: a list of
+ * steps, each the game after one thing it did, the last one the game it
+ * passes on. The page shows them one at a time with a short pause and keeps
+ * only the last (`KumimojiPartyComputer`), so a reload in the middle plays
+ * the same turn again from its start — the plan is pure and has no
+ * randomness, so it is the same turn — and a reload after it finds it done.
+ *
+ * Its play, by the same rules as anybody's and through the same moves:
+ *
+ * - Lay the best word it can (`bestLaying`): its own tiles only, crossing
+ *   what is down, the grid sound after every word.
+ * - Draw whenever its hand is used and its grid sound, so everybody takes a
+ *   tile, and play on.
+ * - Trade its rarest tile when its hand lays nothing, once a turn at most,
+ *   as anybody may (`mayTradeThisTurn`).
+ * - Press Done — going out, when its hand is used and the bag cannot give
+ *   everybody a tile — once it is done or has taken `COMPUTER_STEPS_MOST`
+ *   steps, which keeps a turn to a few seconds to watch.
+ * - Resign only where the rules offer it (`mayResign`) and it can do nothing
+ *   at all: nothing to lay, nothing to trade for, and it is not its last turn.
+ */
+/** The most things a computer does in one turn before pressing Done: at the page's pause, a turn of about three seconds. */
+export declare const COMPUTER_STEPS_MOST = 8;
+export declare function planComputerTurn(game: PartyGame, words: TileWords): ComputerStep[];
+/** The game a computer's turn passes on: its plan's last step, or the game as it was where there is nothing to play. */
+export declare function afterComputerTurn(game: PartyGame, words: TileWords): PartyGame;

package/dist/computerTurn.js

@@ -0,0 +1,94 @@
+import { bestLaying, judgeTiles, tradeChoice } from "./computerPlay.js";
+import { drawAll, isComputer, mayDrawAll, mayTradeThisTurn, seatPlay, withSeatPlay } from "./party.js";
+import { doneRefused, endTurn, goesOut, handCanSpell, isLastTurn, laidThisTurn, mayResign, resign } from "./partyTurns.js";
+import { liftAll, mayTrade, trade } from "./play.js";
+/**
+ * A COMPUTER'S TURN in a pass-and-play game (John, 2026-09-28: "Also you can
+ * add computer bots"), planned whole before any of it is shown: a list of
+ * steps, each the game after one thing it did, the last one the game it
+ * passes on. The page shows them one at a time with a short pause and keeps
+ * only the last (`KumimojiPartyComputer`), so a reload in the middle plays
+ * the same turn again from its start — the plan is pure and has no
+ * randomness, so it is the same turn — and a reload after it finds it done.
+ *
+ * Its play, by the same rules as anybody's and through the same moves:
+ *
+ * - Lay the best word it can (`bestLaying`): its own tiles only, crossing
+ *   what is down, the grid sound after every word.
+ * - Draw whenever its hand is used and its grid sound, so everybody takes a
+ *   tile, and play on.
+ * - Trade its rarest tile when its hand lays nothing, once a turn at most,
+ *   as anybody may (`mayTradeThisTurn`).
+ * - Press Done — going out, when its hand is used and the bag cannot give
+ *   everybody a tile — once it is done or has taken `COMPUTER_STEPS_MOST`
+ *   steps, which keeps a turn to a few seconds to watch.
+ * - Resign only where the rules offer it (`mayResign`) and it can do nothing
+ *   at all: nothing to lay, nothing to trade for, and it is not its last turn.
+ */
+/** The most things a computer does in one turn before pressing Done: at the page's pause, a turn of about three seconds. */
+export const COMPUTER_STEPS_MOST = 8;
+/** How many settling steps may be needed at the end to be allowed Done at all; one trade a turn and a hand of tiles, so it is bounded anyway. */
+const SETTLING_MOST = 200;
+export function planComputerTurn(game, words) {
+    const steps = [];
+    if (game.ending !== null || !isComputer(game, game.turn))
+        return steps;
+    let now = game;
+    const take = (next, said) => {
+        now = next;
+        steps.push({ game: next, said });
+    };
+    // The game's own rules, Diagonals included, for every judgement and every word it lays.
+    const rules = { diagonals: game.settings.diagonals };
+    const verdict = () => judgeTiles(now.players[now.turn].tiles, words, rules);
+    const handSpells = (hand) => handCanSpell(hand, words);
+    // Only its own moves ever reach its table, so this is a guard: a table that is not sound is taken up and built again.
+    if (now.players[now.turn].tiles.size > 0 && !verdict().sound)
+        take(withSeatPlay(now, liftAll(seatPlay(now))), { kind: "rebuilt" });
+    while (steps.length < COMPUTER_STEPS_MOST) {
+        const play = seatPlay(now);
+        if (play.hand.length === 0) {
+            if (!mayDrawAll(now, verdict()))
+                break;
+            take(drawAll(now), { kind: "drew" });
+            continue;
+        }
+        const laid = bestLaying(play, words, rules);
+        if (laid !== null) {
+            take(withSeatPlay(now, laid.play), { kind: "laid", word: laid.word });
+            continue;
+        }
+        const worst = tradeChoice(play.hand, words);
+        if (!mayTradeThisTurn(now) || worst === null)
+            break;
+        take(withSeatPlay(now, trade(play, worst)), { kind: "traded", tile: play.hand[worst] });
+    }
+    // Done may be held back: a hand that must be traded first, or the last one standing with nothing laid. Lay or trade until it is not.
+    for (let settle = 0; settle < SETTLING_MOST && doneRefused(now, verdict(), handSpells) !== null; settle += 1) {
+        const play = seatPlay(now);
+        const laid = bestLaying(play, words, rules);
+        const worst = tradeChoice(play.hand, words) ?? 0;
+        if (laid !== null)
+            take(withSeatPlay(now, laid.play), { kind: "laid", word: laid.word });
+        else if (mayTradeThisTurn(now))
+            take(withSeatPlay(now, trade(play, worst)), { kind: "traded", tile: play.hand[worst] });
+        else
+            break;
+    }
+    const hand = now.players[now.turn].hand;
+    const stuck = hand.length > 0 && !laidThisTurn(now) && !mayTrade(seatPlay(now)) && bestLaying(seatPlay(now), words, rules) === null;
+    const refused = doneRefused(now, verdict(), handSpells) !== null;
+    if ((refused || (stuck && !isLastTurn(now))) && mayResign(now)) {
+        take(resign(now), { kind: "resigned" });
+        return steps;
+    }
+    // Done held back with no resigning either cannot happen (a refusal the bag cannot trade away is one resigning answers); the page stops rather than play the turn again.
+    if (refused)
+        return steps;
+    take(endTurn(now, verdict(), handSpells), { kind: "done", out: goesOut(now, verdict()) });
+    return steps;
+}
+/** The game a computer's turn passes on: its plan's last step, or the game as it was where there is nothing to play. */
+export function afterComputerTurn(game, words) {
+    return planComputerTurn(game, words).at(-1)?.game ?? game;
+}

package/dist/generate.d.ts

@@ -0,0 +1,29 @@
+import type { KumimojiDeal, KumimojiLevel, KumimojiOptions } from "./kumimoji.types.ts";
+/**
+ * MAKING A KUMIMOJI, in the browser, from a seed: the bag the game is played
+ * from, in the order its tiles come out.
+ *
+ * A bag drawn blind from the mix can be one nobody can finish — two Q's and
+ * no U, and every tile must be laid before the game ends. So the bag is made
+ * the other way round: a crossword is laid first, word by word, from letters
+ * drawn from the mix (`TILE_MIX`), and the bag is that crossword's tiles,
+ * shuffled. Every bag has at least one finished grid, which is the puzzle's
+ * `solution` — kept only to prove that, never shown — and a player may build
+ * any other.
+ *
+ * The crossword grows from a word across the middle: each next word crosses
+ * a tile already down, its new tiles touching nothing at their sides, so every
+ * run on it is a word by construction. Words are chosen to use the letters
+ * drawn from the mix, and never a letter more times than the whole set holds,
+ * so the bag reads like a handful from the full set.
+ *
+ * With Diagonals, the crossword must read as a word along its diagonals too:
+ * a new tile that would make a diagonal run of three or more is laid only
+ * where that run is a word (`fit`), so the proof holds under the rule the
+ * game is played by. Without, nothing about the laying changes, and a seed
+ * deals the bag it always dealt.
+ *
+ * Deterministic in the seed, like every generator here: two browsers in a
+ * race, or one tomorrow, deal the same bag in the same order.
+ */
+export declare function generateKumimoji(size: number, level: KumimojiLevel, seed: number, options?: KumimojiOptions): KumimojiDeal;

package/dist/generate.js

@@ -0,0 +1,278 @@
+import { seededRandom, shuffled } from "./random.js";
+import { encodeGrid, squareAt } from "./grid.js";
+import { crossingFit } from "./placement.js";
+import { kumimojiTileCount, kumimojiWildCount, TILE_MIX_TOTAL } from "./tiles.constants.js";
+import { tileWords } from "./tileWords.js";
+/**
+ * MAKING A KUMIMOJI, in the browser, from a seed: the bag the game is played
+ * from, in the order its tiles come out.
+ *
+ * A bag drawn blind from the mix can be one nobody can finish — two Q's and
+ * no U, and every tile must be laid before the game ends. So the bag is made
+ * the other way round: a crossword is laid first, word by word, from letters
+ * drawn from the mix (`TILE_MIX`), and the bag is that crossword's tiles,
+ * shuffled. Every bag has at least one finished grid, which is the puzzle's
+ * `solution` — kept only to prove that, never shown — and a player may build
+ * any other.
+ *
+ * The crossword grows from a word across the middle: each next word crosses
+ * a tile already down, its new tiles touching nothing at their sides, so every
+ * run on it is a word by construction. Words are chosen to use the letters
+ * drawn from the mix, and never a letter more times than the whole set holds,
+ * so the bag reads like a handful from the full set.
+ *
+ * With Diagonals, the crossword must read as a word along its diagonals too:
+ * a new tile that would make a diagonal run of three or more is laid only
+ * where that run is a word (`fit`), so the proof holds under the rule the
+ * game is played by. Without, nothing about the laying changes, and a seed
+ * deals the bag it always dealt.
+ *
+ * Deterministic in the seed, like every generator here: two browsers in a
+ * race, or one tomorrow, deal the same bag in the same order.
+ */
+export function generateKumimoji(size, level, seed, options = {}) {
+    const gameLength = options.gameLength ?? "short";
+    const language = options.language ?? "english";
+    const doubleSet = language === "english" && (options.doubleSet ?? false);
+    const diagonals = options.diagonals === true;
+    const multiplier = doubleSet ? 2 : 1;
+    const words = tileWords(language);
+    const setSize = [...words.mix.values()].reduce((sum, count) => sum + count, 0);
+    const tiles = kumimojiTileCount(size, gameLength, language === "english" ? TILE_MIX_TOTAL : setSize, doubleSet);
+    const wilds = kumimojiWildCount(size, level, tiles);
+    const random = seededRandom(seed);
+    const side = layingSideFor(tiles);
+    let bestProgress = 0;
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        const squares = layCrossword(tiles, random, words, side, multiplier, words.mix, (laid) => { bestProgress = Math.max(bestProgress, laid); }, diagonals);
+        if (squares === null)
+            continue;
+        const positions = shuffled(squares.flatMap((tile, at) => tile === "" ? [] : [at]), random);
+        const wildAt = new Set(positions.slice(0, wilds));
+        const bag = squares.flatMap((tile, at) => {
+            if (tile === "")
+                return [];
+            if (!wildAt.has(at))
+                return [tile];
+            const assigned = words.wildFor(words.soundOf(tile) ?? tile);
+            if (assigned === null)
+                throw new Error(`No wild tile can represent ${tile}.`);
+            squares[at] = assigned;
+            return ["*"];
+        });
+        return { kind: "kumimoji", size, level, seed, givens: shuffled(bag, random).join(""), solution: encodeGrid(tilesOf(squares, side)), gameLength, doubleSet, language, ...(diagonals ? { diagonals } : {}) };
+    }
+    throw new Error(`Could not lay a Kumimoji of ${tiles} tiles from seed ${seed}; furthest attempt laid ${bestProgress}.`);
+}
+/**
+ * The generator lays its crossword on a square of its own, this wide, from
+ * the middle out; only where the tiles stand beside each other is kept
+ * (`encodeGrid`), so the square is scaffolding and not a board.
+ */
+const MIN_LAYING_SIDE = 21;
+function layingSideFor(tiles) {
+    return Math.max(MIN_LAYING_SIDE, Math.ceil(Math.sqrt(tiles * 4)));
+}
+/** The laid square's tiles, by row and column. */
+function tilesOf(squares, side) {
+    const tiles = new Map();
+    squares.forEach((letter, index) => {
+        if (letter !== "")
+            tiles.set(squareAt(Math.floor(index / side), index % side), letter);
+    });
+    return tiles;
+}
+/** The longest word the generator lays: long words leave no room to cross. */
+const LONGEST_LAID = 7;
+/** How many tiles it tries to cross from, and how many words of a length it reads for each. */
+const ANCHORS_TRIED = 8;
+const WORDS_READ = 60;
+const FINISH_BRANCHES = 40;
+const FINISH_NODES = 2000;
+/**
+ * With Diagonals the last tiles are placed from every tile but a sample of
+ * words, and a try that cannot finish is given up sooner: a crossword read
+ * along its diagonals too has fewer ways to finish, and reading every word
+ * from every tile of a full game at each step took minutes where starting
+ * again takes a moment. Measured 2026-09-28, a try that finishes does so in
+ * under ten steps; fifteen keeps a full game to a second or two.
+ */
+const DIAGONAL_FINISH_NODES = 15;
+/**
+ * A GAME THIS BIG FINISHES THE SAME WAY. Reading every word from every tile
+ * of a table of a hundred-odd tiles is about seventeen million checks a step,
+ * and a Full game with a Quick hand (seed 2) ran over five minutes on
+ * "Making your puzzle…" (found 2026-09-28). A bag of more than this many
+ * tiles — Full, and Double at Medium or Full — is laid the way a Diagonals
+ * game is: a sample of words from every tile, and fewer steps before a try
+ * starts again. Smaller bags are laid exactly as before, so their games, kept
+ * and raced, are the same tiles they always were.
+ */
+const WIDE_FINISH_FROM = 100;
+/** A crossword of exactly `tiles` tiles, or null where this try got stuck (the caller tries again). */
+function layCrossword(tiles, random, words, side, multiplier, mix, progress, diagonals) {
+    const squares = new Array(side * side).fill("");
+    const wide = diagonals || tiles > WIDE_FINISH_FROM;
+    // What the set still holds of each letter, and the handful drawn from it that the words are chosen to use.
+    const left = new Map([...mix].map(([letter, count]) => [letter, count * multiplier]));
+    const wanted = new Map();
+    const set = [...mix].flatMap(([letter, count]) => new Array(count * multiplier).fill(letter));
+    for (const letter of shuffled(set, random).slice(0, tiles))
+        wanted.set(letter, (wanted.get(letter) ?? 0) + 1);
+    const lay = (placement) => {
+        const step = placement.across ? 1 : side;
+        [...placement.word].forEach((letter, at) => {
+            const index = placement.start + at * step;
+            if (squares[index] !== "")
+                return;
+            squares[index] = letter;
+            left.set(letter, (left.get(letter) ?? 0) - 1);
+            wanted.set(letter, (wanted.get(letter) ?? 0) - 1);
+        });
+    };
+    const lift = (placement) => {
+        const step = placement.across ? 1 : side;
+        [...placement.word].forEach((letter, at) => {
+            const index = placement.start + at * step;
+            if (!placement.fresh.includes(index))
+                return;
+            squares[index] = "";
+            left.set(letter, (left.get(letter) ?? 0) + 1);
+            wanted.set(letter, (wanted.get(letter) ?? 0) + 1);
+        });
+    };
+    // The first word, across the middle.
+    const firstLength = Math.min(tiles, 3 + Math.floor(random() * 4));
+    const first = bestOf(sample(words.byLength.get(firstLength) ?? [], WORDS_READ * 4, random).map((word) => {
+        const start = Math.floor(side / 2) * side + Math.floor((side - firstLength) / 2);
+        return scored(word, start, true, Array.from({ length: word.length }, (_, at) => start + at), left, wanted, random, undefined, side);
+    }));
+    if (first === null)
+        return null;
+    lay(first);
+    let laid = firstLength;
+    progress(laid);
+    /*
+     * Where the next word could go: from a few tiles, a sample of words
+     * (`sampled`); from every tile, a sample of words (`wide`, Diagonals only);
+     * or from every tile, every word (`exhaustive`).
+     */
+    const placementsFor = (room, reach) => {
+        const exhaustive = reach === "exhaustive";
+        const anchors = shuffled(squares.flatMap((letter, index) => (letter === "" ? [] : [index])), random).slice(0, reach === "sampled" ? ANCHORS_TRIED : squares.length);
+        const found = [];
+        for (const anchor of anchors) {
+            for (const across of [true, false]) {
+                for (let length = 2; length <= LONGEST_LAID; length += 1) {
+                    const letter = squares[anchor];
+                    const candidates = words.byLength.get(length) ?? [];
+                    for (const word of sample(candidates, exhaustive ? candidates.length : WORDS_READ, random, letter)) {
+                        for (let at = 0; at < word.length; at += 1) {
+                            if (word[at] !== letter)
+                                continue;
+                            const placement = fit(squares, word, anchor, at, across, room, left, wanted, random, side, diagonals ? words : null);
+                            if (placement !== null)
+                                found.push(placement);
+                        }
+                    }
+                }
+            }
+        }
+        return found;
+    };
+    let finishNodes = 0;
+    const finish = (room) => {
+        if (room === 0)
+            return true;
+        if (finishNodes >= (wide ? DIAGONAL_FINISH_NODES : FINISH_NODES))
+            return false;
+        finishNodes += 1;
+        const placements = placementsFor(room, wide ? "wide" : "exhaustive")
+            .sort((a, b) => b.score - a.score || b.fresh.length - a.fresh.length)
+            .slice(0, FINISH_BRANCHES);
+        for (const placement of placements) {
+            lay(placement);
+            const nextRoom = room - placement.fresh.length;
+            progress(tiles - nextRoom);
+            if (finish(nextRoom))
+                return true;
+            lift(placement);
+        }
+        return false;
+    };
+    while (laid < tiles) {
+        const room = tiles - laid;
+        if (room <= 10) {
+            if (!finish(room))
+                return null;
+            laid = tiles;
+            break;
+        }
+        /* With Diagonals, or a big bag, a few tiles often offer nothing: every tile is tried before this try is given up. */
+        const next = bestOf(placementsFor(room, "sampled")) ?? (wide ? bestOf(placementsFor(room, "wide")) : null);
+        if (next === null)
+            return null;
+        lay(next);
+        laid += next.fresh.length;
+        progress(laid);
+    }
+    return squares;
+}
+/** Up to `count` words of a list, read from a random place onward, only those holding `letter` when one is named. */
+function sample(list, count, random, letter) {
+    if (list.length === 0)
+        return [];
+    const out = [];
+    const from = Math.floor(random() * list.length);
+    for (let read = 0; read < list.length && out.length < count; read += 1) {
+        const word = list[(from + read) % list.length];
+        if (letter === undefined || word.includes(letter))
+            out.push(word);
+    }
+    return out;
+}
+/**
+ * Where `word` would stand crossing the tile at `anchor` with its letter at
+ * `at`, or null where it cannot: the laying rule every crossword here keeps
+ * (`crossingFit`: on the laying square, nothing at either end, no new tile
+ * with a neighbour at its side, and with Diagonals no diagonal run of three
+ * or more that is not a word), then more new tiles than the bag has room
+ * for, or a letter the set has run out of.
+ */
+function fit(squares, word, anchor, at, across, room, left, wanted, random, side, diagonalWords = null) {
+    const place = crossingFit((row, col) => squares[row * side + col], (row, col) => row >= 0 && row < side && col >= 0 && col < side, word, { row: Math.floor(anchor / side), col: anchor % side }, at, across, diagonalWords === null
+        ? null
+        : (run) => {
+            const read = diagonalWords.wordOf(run);
+            return read !== null && diagonalWords.allowed.has(read);
+        });
+    if (place === null || place.fresh.length > room)
+        return null;
+    const fresh = place.fresh.map((square) => square.row * side + square.col);
+    return scored(word, place.first.row * side + place.first.col, across, fresh, left, wanted, random, squares, side);
+}
+/** A placement's worth: a letter drawn from the mix is worth two, any other costs three, and the set's own counts are a wall. */
+function scored(word, start, across, fresh, left, wanted, random, squares, side = MIN_LAYING_SIDE) {
+    const step = across ? 1 : side;
+    const using = new Map();
+    let score = 0;
+    for (let k = 0; k < word.length; k += 1) {
+        const index = start + k * step;
+        if (squares !== undefined && squares[index] !== "")
+            continue;
+        const letter = word[k];
+        const count = (using.get(letter) ?? 0) + 1;
+        using.set(letter, count);
+        if (count > (left.get(letter) ?? 0))
+            return null;
+        score += (count <= (wanted.get(letter) ?? 0) ? 2 : -3) + 8 / Math.max(1, left.get(letter) ?? 0);
+    }
+    return { word, start, across, fresh, score: score + 0.3 * fresh.length + 0.5 * random() };
+}
+function bestOf(placements) {
+    let best = null;
+    for (const placement of placements)
+        if (placement !== null && (best === null || placement.score > best.score))
+            best = placement;
+    return best;
+}