scrabble-solver 2.16.6 → 2.17.0

package/packages/solver/build/MoveGenerator.js

@@ -0,0 +1,686 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveGenerator = void 0;
+/* eslint-disable max-depth, max-lines, max-statements, no-bitwise */
+const gaddag_1 = require("@kamilmielnik/gaddag");
+const constants_1 = require("@scrabble-solver/constants");
+const types_1 = require("@scrabble-solver/types");
+const MAX_ALPHABET_SIZE = 64;
+// The result sort key packs (direction, line, start, end) into one integer.
+const MAX_BOARD_DIMENSION = 32;
+/**
+ * Anchor-based move generation over a {@link Gaddag} (Gordon, 1994).
+ *
+ * For every anchor (an empty cell adjacent to a tile, or the board center when
+ * the board is empty) the generator extends leftwards from the anchor through
+ * the reversed-prefix part of the GADDAG, crosses the separator, and extends
+ * rightwards — validating perpendicular words with precomputed cross-check
+ * masks. Both directions run the same code path: the vertical pass remaps
+ * (line, position) to transposed coordinates. Each placement is scored and
+ * emitted as a compact {@link ResultJson} — placed tiles plus placement — from
+ * which {@link Result.fromJson} rebuilds the full cells and collisions against
+ * the board.
+ */
+class MoveGenerator {
+    constructor(gaddag, config, board, tiles) {
+        this.blanksLeft = 0;
+        this.rackTotal = 0;
+        this.boardIsEmpty = true;
+        // Current pass (direction) data, indexed by line * lineLength + position.
+        this.isHorizontal = true;
+        this.lineLength = 0;
+        this.linesCount = 0;
+        // Current line/anchor state.
+        this.line = 0;
+        this.lineBase = 0;
+        this.anchorPos = 0;
+        this.limit = 0;
+        this.anchorRightOpen = false;
+        this.leftMost = 0;
+        this.placedCount = 0;
+        // Single-tile placements are the only ones both passes can emit; multi-tile
+        // placements determine their line, span, and anchor uniquely.
+        this.seenSingleTiles = new Set();
+        this.results = [];
+        // Board cells are immutable during a solve, so their JSON is shared between results.
+        // Sort keys reproducing the previous solver's result order:
+        // horizontal before vertical, then by line, start, and end position.
+        this.sortKeys = [];
+        // Secondary sort keys resolving ties within the same word span: the
+        // previous solver filled cells left to right, trying rack tiles in their
+        // original order (and, for blanks, alphabet characters in config order).
+        this.rankKeys = [];
+        this.blankRackIndex = 0;
+        this.gaddag = gaddag;
+        this.config = config;
+        this.width = board.columnsCount;
+        this.height = board.rowsCount;
+        this.cellsCount = this.width * this.height;
+        this.blankScore = config.blankScore;
+        this.rackSize = config.rackSize;
+        this.digraphs = config.twoCharacterTiles;
+        const alphabet = config.alphabet;
+        if (alphabet.length > MAX_ALPHABET_SIZE) {
+            throw new Error(`Alphabets larger than ${MAX_ALPHABET_SIZE} tiles are not supported`);
+        }
+        if (this.width > MAX_BOARD_DIMENSION || this.height > MAX_BOARD_DIMENSION) {
+            throw new Error(`Boards larger than ${MAX_BOARD_DIMENSION}x${MAX_BOARD_DIMENSION} are not supported`);
+        }
+        this.alphaSize = alphabet.length;
+        this.alphaChars = alphabet;
+        this.alphaLetter1 = new Int32Array(this.alphaSize);
+        this.alphaLetter2 = new Int32Array(this.alphaSize);
+        this.alphaPoints = new Int32Array(this.alphaSize);
+        for (let index = 0; index < this.alphaSize; ++index) {
+            const character = alphabet[index];
+            this.alphaLetter1[index] = gaddag.getLetter(character.charCodeAt(0));
+            this.alphaLetter2[index] = character.length > 1 ? gaddag.getLetter(character.charCodeAt(1)) : 0;
+            this.alphaPoints[index] = config.pointsMap[character] || 0;
+        }
+        const lettersCount = MAX_ALPHABET_SIZE;
+        this.leftAlphaStart = new Int32Array(lettersCount + 1);
+        this.rightAlphaStart = new Int32Array(lettersCount + 1);
+        this.leftAlphaList = new Int32Array(this.alphaSize);
+        this.rightAlphaList = new Int32Array(this.alphaSize);
+        this.alphaSecondLeft = new Int32Array(this.alphaSize);
+        this.alphaSecondRight = new Int32Array(this.alphaSize);
+        for (let pass = 0; pass < 2; ++pass) {
+            for (let index = 0; index < this.alphaSize; ++index) {
+                const letter1 = this.alphaLetter1[index];
+                const letter2 = this.alphaLetter2[index];
+                if (letter1 <= 0 || letter2 < 0) {
+                    continue;
+                }
+                const leftLead = letter2 === 0 ? letter1 : letter2;
+                if (pass === 0) {
+                    ++this.leftAlphaStart[leftLead + 1];
+                    ++this.rightAlphaStart[letter1 + 1];
+                }
+                else {
+                    this.leftAlphaList[this.leftAlphaStart[leftLead]++] = index;
+                    this.rightAlphaList[this.rightAlphaStart[letter1]++] = index;
+                    this.alphaSecondLeft[index] = letter2 === 0 ? 0 : letter1;
+                    this.alphaSecondRight[index] = letter2;
+                }
+            }
+            if (pass === 0) {
+                for (let letter = 0; letter < lettersCount; ++letter) {
+                    this.leftAlphaStart[letter + 1] += this.leftAlphaStart[letter];
+                    this.rightAlphaStart[letter + 1] += this.rightAlphaStart[letter];
+                }
+            }
+        }
+        // The second pass advanced the start offsets by each bucket's size; shift them back.
+        for (let letter = lettersCount; letter > 0; --letter) {
+            this.leftAlphaStart[letter] = this.leftAlphaStart[letter - 1];
+            this.rightAlphaStart[letter] = this.rightAlphaStart[letter - 1];
+        }
+        this.leftAlphaStart[0] = 0;
+        this.rightAlphaStart[0] = 0;
+        this.rackCounts = new Int32Array(this.alphaSize);
+        this.alphaFirstRackIndex = new Int32Array(this.alphaSize).fill(tiles.length);
+        this.blankRackIndex = tiles.length;
+        for (let tileIndex = 0; tileIndex < tiles.length; ++tileIndex) {
+            const tile = tiles[tileIndex];
+            if (tile.isBlank) {
+                if (this.blanksLeft === 0) {
+                    this.blankRackIndex = tileIndex;
+                }
+                ++this.blanksLeft;
+                ++this.rackTotal;
+                continue;
+            }
+            const alphaIndex = alphabet.indexOf(tile.character);
+            if (alphaIndex !== -1) {
+                if (this.rackCounts[alphaIndex] === 0) {
+                    this.alphaFirstRackIndex[alphaIndex] = tileIndex;
+                }
+                ++this.rackCounts[alphaIndex];
+                ++this.rackTotal;
+            }
+        }
+        this.bonusType = new Uint8Array(this.cellsCount);
+        this.bonusMult = new Int32Array(this.cellsCount);
+        this.bonusReq = new Int32Array(this.cellsCount).fill(-1);
+        // Iterate backwards so the first matching bonus wins, mirroring config.getCellBonus.
+        for (let index = config.bonuses.length - 1; index >= 0; --index) {
+            const bonus = config.bonuses[index];
+            if (bonus.x < 0 || bonus.x >= this.width || bonus.y < 0 || bonus.y >= this.height) {
+                continue;
+            }
+            const cellIndex = bonus.y * this.width + bonus.x;
+            if (bonus.type === constants_1.BONUS_CHARACTER) {
+                this.bonusType[cellIndex] = 1;
+            }
+            else if (bonus.type === constants_1.BONUS_WORD) {
+                this.bonusType[cellIndex] = 2;
+            }
+            else {
+                this.bonusType[cellIndex] = 0;
+            }
+            this.bonusMult[cellIndex] = bonus.multiplier;
+            this.bonusReq[cellIndex] = typeof bonus.score === 'number' ? bonus.score : -1;
+        }
+        this.boardFilled = new Uint8Array(this.cellsCount);
+        this.boardChar = Array.from({ length: this.cellsCount });
+        this.boardIsBlank = new Uint8Array(this.cellsCount);
+        this.boardScore = new Int32Array(this.cellsCount);
+        this.boardLetter1 = new Int32Array(this.cellsCount);
+        this.boardLetter2 = new Int32Array(this.cellsCount);
+        this.anchor = new Uint8Array(this.cellsCount);
+        for (let y = 0; y < this.height; ++y) {
+            const row = board.rows[y];
+            for (let x = 0; x < this.width; ++x) {
+                const cell = row[x];
+                if (!cell.isFilled()) {
+                    continue;
+                }
+                const cellIndex = y * this.width + x;
+                const character = cell.tile.character;
+                this.boardIsEmpty = false;
+                this.boardFilled[cellIndex] = 1;
+                this.boardChar[cellIndex] = character;
+                this.boardIsBlank[cellIndex] = cell.tile.isBlank ? 1 : 0;
+                this.boardScore[cellIndex] = cell.tile.isBlank ? this.blankScore : config.pointsMap[character] || 0;
+                this.boardLetter1[cellIndex] = gaddag.getLetter(character.charCodeAt(0));
+                this.boardLetter2[cellIndex] = character.length > 1 ? gaddag.getLetter(character.charCodeAt(1)) : 0;
+            }
+        }
+        for (let y = 0; y < this.height; ++y) {
+            for (let x = 0; x < this.width; ++x) {
+                const cellIndex = y * this.width + x;
+                if (this.boardFilled[cellIndex] === 1) {
+                    continue;
+                }
+                const up = y > 0 && this.boardFilled[cellIndex - this.width] === 1;
+                const down = y < this.height - 1 && this.boardFilled[cellIndex + this.width] === 1;
+                const left = x > 0 && this.boardFilled[cellIndex - 1] === 1;
+                const right = x < this.width - 1 && this.boardFilled[cellIndex + 1] === 1;
+                this.anchor[cellIndex] = up || down || left || right ? 1 : 0;
+            }
+        }
+        this.passFilled = new Uint8Array(this.cellsCount);
+        this.passLetter1 = new Int32Array(this.cellsCount);
+        this.passLetter2 = new Int32Array(this.cellsCount);
+        this.passScore = new Int32Array(this.cellsCount);
+        this.passGlobal = new Int32Array(this.cellsCount);
+        this.passAnchor = new Uint8Array(this.cellsCount);
+        this.maskLo = new Int32Array(this.cellsCount);
+        this.maskHi = new Int32Array(this.cellsCount);
+        this.crossBase = new Int32Array(this.cellsCount);
+        this.hasCross = new Uint8Array(this.cellsCount);
+        const maxLineLength = Math.max(this.width, this.height);
+        this.placedAt = new Int32Array(maxLineLength).fill(-1);
+        this.placedBlankAt = new Uint8Array(maxLineLength);
+    }
+    run() {
+        if (this.rackTotal === 0) {
+            return this.results;
+        }
+        this.runPass(true);
+        this.runPass(false);
+        // Reorder results to match the previous solver's enumeration order, so
+        // that ties (equal points) resolve to the same result in the UI.
+        const order = this.results.map((_, index) => index);
+        const { rankKeys, sortKeys } = this;
+        order.sort((a, b) => {
+            const difference = sortKeys[a] - sortKeys[b];
+            if (difference !== 0) {
+                return difference;
+            }
+            const rankA = rankKeys[a];
+            const rankB = rankKeys[b];
+            if (rankA < rankB) {
+                return -1;
+            }
+            return rankA > rankB ? 1 : 0;
+        });
+        return order.map((resultIndex, index) => {
+            const result = this.results[resultIndex];
+            result.id = index;
+            return result;
+        });
+    }
+    runPass(horizontal) {
+        this.isHorizontal = horizontal;
+        this.linesCount = horizontal ? this.height : this.width;
+        this.lineLength = horizontal ? this.width : this.height;
+        this.setupPass();
+        const centerLine = horizontal ? Math.floor(this.height / 2) : Math.floor(this.width / 2);
+        const centerPos = horizontal ? Math.floor(this.width / 2) : Math.floor(this.height / 2);
+        for (let line = 0; line < this.linesCount; ++line) {
+            this.line = line;
+            this.lineBase = line * this.lineLength;
+            for (let position = 0; position < this.lineLength; ++position) {
+                const isAnchor = this.boardIsEmpty
+                    ? line === centerLine && position === centerPos
+                    : this.passAnchor[this.lineBase + position] === 1;
+                if (!isAnchor) {
+                    continue;
+                }
+                this.anchorPos = position;
+                this.anchorRightOpen = position + 1 >= this.lineLength || this.passFilled[this.lineBase + position + 1] === 0;
+                let limit = 0;
+                const maxLimit = this.rackTotal - 1;
+                for (let left = position - 1; left >= 0 && limit < maxLimit; --left) {
+                    const index = this.lineBase + left;
+                    if (this.passFilled[index] === 1 || (!this.boardIsEmpty && this.passAnchor[index] === 1)) {
+                        break;
+                    }
+                    ++limit;
+                }
+                this.limit = limit;
+                this.generateLeft(position, this.gaddag.rootRef);
+            }
+        }
+    }
+    setupPass() {
+        const { lineLength, linesCount } = this;
+        for (let line = 0; line < linesCount; ++line) {
+            const base = line * lineLength;
+            for (let position = 0; position < lineLength; ++position) {
+                const passIndex = base + position;
+                const globalIndex = this.isHorizontal ? passIndex : position * this.width + line;
+                this.passGlobal[passIndex] = globalIndex;
+                this.passFilled[passIndex] = this.boardFilled[globalIndex];
+                this.passLetter1[passIndex] = this.boardLetter1[globalIndex];
+                this.passLetter2[passIndex] = this.boardLetter2[globalIndex];
+                this.passScore[passIndex] = this.boardScore[globalIndex];
+                this.passAnchor[passIndex] = this.anchor[globalIndex];
+            }
+        }
+        this.computeCrossChecks();
+    }
+    /**
+     * For every empty cell with perpendicular neighbors, computes the set of
+     * placeable tile characters (as a 64-bit mask), the sum of the existing
+     * perpendicular tiles' scores, and the perpendicular word span.
+     */
+    computeCrossChecks() {
+        const { gaddag, lineLength, linesCount } = this;
+        const preLetters = [];
+        const postLetters = [];
+        for (let line = 0; line < linesCount; ++line) {
+            for (let position = 0; position < lineLength; ++position) {
+                const passIndex = line * lineLength + position;
+                if (this.passFilled[passIndex] === 1) {
+                    continue;
+                }
+                const upFilled = line > 0 && this.passFilled[passIndex - lineLength] === 1;
+                const downFilled = line < linesCount - 1 && this.passFilled[passIndex + lineLength] === 1;
+                if (!upFilled && !downFilled) {
+                    this.maskLo[passIndex] = -1;
+                    this.maskHi[passIndex] = -1;
+                    this.hasCross[passIndex] = 0;
+                    continue;
+                }
+                let spanLo = line;
+                while (spanLo > 0 && this.passFilled[(spanLo - 1) * lineLength + position] === 1) {
+                    --spanLo;
+                }
+                let spanHi = line;
+                while (spanHi < linesCount - 1 && this.passFilled[(spanHi + 1) * lineLength + position] === 1) {
+                    ++spanHi;
+                }
+                const hasDigraphs = this.digraphs.length > 0;
+                const previousCharacter = hasDigraphs && spanLo < line ? this.boardChar[this.passGlobal[passIndex - lineLength]] : '';
+                const nextCharacter = hasDigraphs && spanHi > line ? this.boardChar[this.passGlobal[passIndex + lineLength]] : '';
+                preLetters.length = 0;
+                postLetters.length = 0;
+                let base = 0;
+                let lettersValid = true;
+                let crossSpellingValid = true;
+                let previousCrossCharacter = '';
+                for (let crossLine = spanLo; crossLine <= spanHi; ++crossLine) {
+                    if (crossLine === line) {
+                        continue;
+                    }
+                    const crossIndex = crossLine * lineLength + position;
+                    base += this.passScore[crossIndex];
+                    if (hasDigraphs) {
+                        const character = this.boardChar[this.passGlobal[crossIndex]];
+                        if (previousCrossCharacter !== '' && this.digraphs.includes(previousCrossCharacter + character)) {
+                            crossSpellingValid = false;
+                        }
+                        previousCrossCharacter = crossLine === line - 1 ? '' : character;
+                    }
+                    const letters = crossLine < line ? preLetters : postLetters;
+                    const letter1 = this.passLetter1[crossIndex];
+                    const letter2 = this.passLetter2[crossIndex];
+                    if (letter1 <= 0 || letter2 < 0) {
+                        lettersValid = false;
+                    }
+                    letters.push(letter1);
+                    if (letter2 !== 0) {
+                        letters.push(letter2);
+                    }
+                }
+                this.hasCross[passIndex] = 1;
+                this.crossBase[passIndex] = base;
+                let maskLo = 0;
+                let maskHi = 0;
+                if (lettersValid && crossSpellingValid) {
+                    // The perpendicular word is pre + tile + post; its pure-reverse GADDAG
+                    // path is rev(post), rev(tile characters), rev(pre). rev(post) is shared
+                    // across all candidate tiles.
+                    let postRef = gaddag.rootRef;
+                    for (let index = postLetters.length - 1; index >= 0 && postRef !== 0; --index) {
+                        postRef = gaddag.getArc(postRef, postLetters[index]);
+                    }
+                    if (postRef !== 0) {
+                        for (let alpha = 0; alpha < this.alphaSize; ++alpha) {
+                            const letter1 = this.alphaLetter1[alpha];
+                            const letter2 = this.alphaLetter2[alpha];
+                            if (letter1 <= 0 || letter2 < 0) {
+                                continue;
+                            }
+                            if (hasDigraphs && this.spellsDigraphWithNeighbor(alpha, previousCharacter, nextCharacter)) {
+                                continue;
+                            }
+                            let ref = postRef;
+                            if (letter2 !== 0) {
+                                ref = gaddag.getArc(ref, letter2);
+                                if (ref === 0) {
+                                    continue;
+                                }
+                            }
+                            ref = gaddag.getArc(ref, letter1);
+                            for (let index = preLetters.length - 1; index >= 0 && ref !== 0; --index) {
+                                ref = gaddag.getArc(ref, preLetters[index]);
+                            }
+                            if ((ref & 1) === 1) {
+                                if (alpha < 32) {
+                                    maskLo |= 1 << alpha;
+                                }
+                                else {
+                                    maskHi |= 1 << (alpha - 32);
+                                }
+                            }
+                        }
+                    }
+                }
+                this.maskLo[passIndex] = maskLo;
+                this.maskHi[passIndex] = maskHi;
+            }
+        }
+    }
+    /**
+     * A digraph must be played as its single tile, so a candidate that would
+     * spell a digraph with the adjacent perpendicular tile is not placeable.
+     * {@link record} enforces the same rule along the main word.
+     */
+    spellsDigraphWithNeighbor(alpha, previousCharacter, nextCharacter) {
+        const character = this.alphaChars[alpha];
+        return ((previousCharacter !== '' && this.digraphs.includes(previousCharacter + character)) ||
+            (nextCharacter !== '' && this.digraphs.includes(character + nextCharacter)));
+    }
+    isOpen(position) {
+        return position < 0 || position >= this.lineLength || this.passFilled[this.lineBase + position] === 0;
+    }
+    generateLeft(position, ref) {
+        const { gaddag, lineBase } = this;
+        const inBounds = position >= 0;
+        const passIndex = lineBase + position;
+        if (inBounds && this.passFilled[passIndex] === 1) {
+            // Read an existing tile (reversed character order when moving left).
+            const letter2 = this.passLetter2[passIndex];
+            let nextRef = ref;
+            if (letter2 !== 0) {
+                nextRef = letter2 > 0 ? gaddag.getArc(nextRef, letter2) : 0;
+                if (nextRef === 0) {
+                    return;
+                }
+            }
+            const letter1 = this.passLetter1[passIndex];
+            nextRef = letter1 > 0 ? gaddag.getArc(nextRef, letter1) : 0;
+            if (nextRef === 0) {
+                return;
+            }
+            this.recordLeftIfWord(nextRef, position);
+            this.generateLeft(position - 1, nextRef);
+            return;
+        }
+        // The cell at `position` is empty or off-board, so the left part may stop here.
+        const separatorRef = gaddag.getArc(ref, gaddag_1.SEPARATOR);
+        if (separatorRef !== 0) {
+            this.leftMost = position + 1;
+            this.generateRight(this.anchorPos + 1, separatorRef);
+        }
+        if (!inBounds || (position !== this.anchorPos && this.anchorPos - position > this.limit)) {
+            return;
+        }
+        this.placeAt(position, passIndex, ref, true);
+    }
+    generateRight(position, ref) {
+        const { gaddag, lineBase } = this;
+        const inBounds = position < this.lineLength;
+        const passIndex = lineBase + position;
+        if (inBounds && this.passFilled[passIndex] === 1) {
+            const letter1 = this.passLetter1[passIndex];
+            let nextRef = letter1 > 0 ? gaddag.getArc(ref, letter1) : 0;
+            if (nextRef === 0) {
+                return;
+            }
+            const letter2 = this.passLetter2[passIndex];
+            if (letter2 !== 0) {
+                nextRef = letter2 > 0 ? gaddag.getArc(nextRef, letter2) : 0;
+                if (nextRef === 0) {
+                    return;
+                }
+            }
+            if ((nextRef & 1) === 1 && this.isOpen(position + 1)) {
+                this.record(this.leftMost, position);
+            }
+            this.generateRight(position + 1, nextRef);
+            return;
+        }
+        if (!inBounds) {
+            return;
+        }
+        this.placeAt(position, passIndex, ref, false);
+    }
+    /**
+     * Tries every rack tile (and blank interpretation) at an empty cell,
+     * recursing further. Iterates the state's arcs instead of the alphabet:
+     * deep GADDAG states have very few arcs, so this is much cheaper than
+     * probing every letter.
+     */
+    placeAt(position, passIndex, ref, leftward) {
+        let arcIndex = ref >>> 1;
+        if (arcIndex === 0 || this.placedCount >= this.rackTotal) {
+            return;
+        }
+        const maskLo = this.maskLo[passIndex];
+        const maskHi = this.maskHi[passIndex];
+        if (maskLo === 0 && maskHi === 0) {
+            return;
+        }
+        const { gaddag } = this;
+        const labels = gaddag.arcLabels;
+        const targets = gaddag.arcTargets;
+        const alphaStart = leftward ? this.leftAlphaStart : this.rightAlphaStart;
+        const alphaList = leftward ? this.leftAlphaList : this.rightAlphaList;
+        const alphaSecond = leftward ? this.alphaSecondLeft : this.alphaSecondRight;
+        // Restored by every recursive call, so stable across loop iterations.
+        const hasBlank = this.blanksLeft > 0;
+        for (;;) {
+            const label = labels[arcIndex];
+            const letter = label & gaddag_1.LETTER_MASK;
+            if (letter !== gaddag_1.SEPARATOR) {
+                const target = targets[arcIndex];
+                const alphasEnd = alphaStart[letter + 1];
+                for (let alphaIndex = alphaStart[letter]; alphaIndex < alphasEnd; ++alphaIndex) {
+                    const alpha = alphaList[alphaIndex];
+                    const hasTile = this.rackCounts[alpha] > 0;
+                    if (!hasTile && !hasBlank) {
+                        continue;
+                    }
+                    const allowed = alpha < 32 ? (maskLo & (1 << alpha)) !== 0 : (maskHi & (1 << (alpha - 32))) !== 0;
+                    if (!allowed) {
+                        continue;
+                    }
+                    const second = alphaSecond[alpha];
+                    const nextRef = second === 0 ? target : gaddag.getArc(target, second);
+                    if (nextRef === 0) {
+                        continue;
+                    }
+                    if (hasTile) {
+                        --this.rackCounts[alpha];
+                        this.pushPlacement(position, alpha, false);
+                        this.afterPlacement(position, nextRef, leftward);
+                        this.popPlacement(position);
+                        ++this.rackCounts[alpha];
+                    }
+                    if (hasBlank) {
+                        --this.blanksLeft;
+                        this.pushPlacement(position, alpha, true);
+                        this.afterPlacement(position, nextRef, leftward);
+                        this.popPlacement(position);
+                        ++this.blanksLeft;
+                    }
+                }
+            }
+            if (label >= gaddag_1.LAST_ARC_FLAG) {
+                return;
+            }
+            ++arcIndex;
+        }
+    }
+    pushPlacement(position, alpha, isBlank) {
+        this.placedAt[position] = alpha;
+        this.placedBlankAt[position] = isBlank ? 1 : 0;
+        ++this.placedCount;
+    }
+    popPlacement(position) {
+        this.placedAt[position] = -1;
+        --this.placedCount;
+    }
+    afterPlacement(position, ref, leftward) {
+        if (leftward) {
+            this.recordLeftIfWord(ref, position);
+            this.generateLeft(position - 1, ref);
+        }
+        else {
+            if ((ref & 1) === 1 && this.isOpen(position + 1)) {
+                this.record(this.leftMost, position);
+            }
+            this.generateRight(position + 1, ref);
+        }
+    }
+    /**
+     * Records a word that ends at the anchor (a pure reversed-word GADDAG path).
+     * Words spanning a single cell are skipped: a lone tile's word is the
+     * perpendicular one, generated by the other pass.
+     */
+    recordLeftIfWord(ref, position) {
+        if ((ref & 1) === 1 && this.anchorRightOpen && position < this.anchorPos && this.isOpen(position - 1)) {
+            this.record(position, this.anchorPos);
+        }
+    }
+    record(startPosition, endPosition) {
+        const { lineBase } = this;
+        if (this.digraphs.length > 0 && this.hasInvalidDigraph(startPosition, endPosition)) {
+            return;
+        }
+        if (this.placedCount === 1) {
+            let placedPosition = startPosition;
+            while (this.passFilled[lineBase + placedPosition] === 1) {
+                ++placedPosition;
+            }
+            const key = this.passGlobal[lineBase + placedPosition] * 128 +
+                this.placedAt[placedPosition] * 2 +
+                this.placedBlankAt[placedPosition];
+            if (this.seenSingleTiles.has(key)) {
+                return;
+            }
+            this.seenSingleTiles.add(key);
+        }
+        // Score and emit ResultJson in a single pass.
+        let mainScore = 0;
+        let wordMultiplier = 1;
+        let collisionsScore = 0;
+        const tiles = [];
+        const blankIndices = [];
+        for (let position = startPosition; position <= endPosition; ++position) {
+            const passIndex = lineBase + position;
+            if (this.passFilled[passIndex] === 1) {
+                mainScore += this.passScore[passIndex];
+                continue;
+            }
+            const globalIndex = this.passGlobal[passIndex];
+            const alpha = this.placedAt[position];
+            const isBlank = this.placedBlankAt[position] === 1;
+            const tileScore = isBlank ? this.blankScore : this.alphaPoints[alpha];
+            let characterMultiplier = 1;
+            let cellWordMultiplier = 1;
+            const bonusType = this.bonusType[globalIndex];
+            if (bonusType === 1) {
+                const requirement = this.bonusReq[globalIndex];
+                if (requirement === -1 || requirement === this.alphaPoints[alpha]) {
+                    characterMultiplier = this.bonusMult[globalIndex];
+                }
+            }
+            else if (bonusType === 2) {
+                cellWordMultiplier = this.bonusMult[globalIndex];
+            }
+            mainScore += tileScore * characterMultiplier;
+            wordMultiplier *= cellWordMultiplier;
+            if (isBlank) {
+                blankIndices.push(tiles.length);
+            }
+            tiles.push(this.alphaChars[alpha]);
+            if (this.hasCross[passIndex] === 1) {
+                collisionsScore += (this.crossBase[passIndex] + tileScore * characterMultiplier) * cellWordMultiplier;
+            }
+        }
+        let points = mainScore * wordMultiplier + collisionsScore;
+        if (this.placedCount === this.rackSize) {
+            const bingo = this.config.bingo;
+            if ((0, types_1.isScoreBingo)(bingo)) {
+                points += bingo.score;
+            }
+            else if ((0, types_1.isMultiplierBingo)(bingo)) {
+                points = mainScore * wordMultiplier * bingo.multiplier + collisionsScore;
+            }
+        }
+        let rankKey = '';
+        for (let position = startPosition; position <= endPosition; ++position) {
+            if (this.passFilled[lineBase + position] === 0) {
+                const alpha = this.placedAt[position];
+                const isBlank = this.placedBlankAt[position] === 1;
+                const rackIndex = isBlank ? this.blankRackIndex : this.alphaFirstRackIndex[alpha];
+                rankKey += String.fromCharCode(rackIndex * 64 + (isBlank ? alpha : 0));
+            }
+        }
+        this.sortKeys.push((this.isHorizontal ? 0 : 1 << 20) | (this.line << 15) | (startPosition << 8) | endPosition);
+        this.rankKeys.push(rankKey);
+        this.results.push({
+            blankIndices,
+            id: this.results.length,
+            isHorizontal: this.isHorizontal,
+            points,
+            tiles,
+            x: this.isHorizontal ? startPosition : this.line,
+            y: this.isHorizontal ? this.line : startPosition,
+        });
+    }
+    hasInvalidDigraph(startPosition, endPosition) {
+        let previousCharacter = this.characterAt(startPosition);
+        for (let position = startPosition + 1; position <= endPosition; ++position) {
+            const character = this.characterAt(position);
+            if (this.digraphs.includes(previousCharacter + character)) {
+                return true;
+            }
+            previousCharacter = character;
+        }
+        return false;
+    }
+    characterAt(position) {
+        const passIndex = this.lineBase + position;
+        if (this.passFilled[passIndex] === 1) {
+            return this.boardChar[this.passGlobal[passIndex]];
+        }
+        return this.alphaChars[this.placedAt[position]];
+    }
+}
+exports.MoveGenerator = MoveGenerator;