TypeScript engine

export function contiguousLineLength(
  board: Board,
  row: number,
  column: number,
  axis: "row" | "column",
): number {
  assertBoard(board);
  if (!isInside(row, column) || board[indexOf(row, column)] === EMPTY) return 0;

  const [rowStep, columnStep] = axis === "row" ? [0, 1] : [1, 0];
  let count = 1;
  for (const direction of [-1, 1]) {
    let nextRow = row + rowStep * direction;
    let nextColumn = column + columnStep * direction;
    while (
      isInside(nextRow, nextColumn) &&
      board[indexOf(nextRow, nextColumn)] !== EMPTY
    ) {
      count += 1;
      nextRow += rowStep * direction;
      nextColumn += columnStep * direction;
    }
  }
  return count;
}

export function findPoppers(board: Board): number[] {
  assertBoard(board);
  const poppers: number[] = [];
  for (let row = 0; row < BOARD_SIZE; row += 1) {
    for (let column = 0; column < BOARD_SIZE; column += 1) {
      const index = indexOf(row, column);
      const cell = board[index];
      if (!isNumbered(cell)) continue;
      if (
        contiguousLineLength(board, row, column, "row") === cell ||
        contiguousLineLength(board, row, column, "column") === cell
      ) {
        poppers.push(index);
      }
    }
  }
  return poppers;

/** Clear one simultaneous wave and apply every adjacent hit before gravity. */
function clearWave(board: Board, poppers: readonly number[]): ClearedWave {
  const next = board.slice();
  const popping = new Set(poppers);
  for (const index of poppers) next[index] = EMPTY;

  const revealIndexes: number[] = [];
  for (let row = 0; row < BOARD_SIZE; row += 1) {
    for (let column = 0; column < BOARD_SIZE; column += 1) {
      const index = indexOf(row, column);
      const cell = board[index];
      if (cell !== SOLID && cell !== CRACKED) continue;

      let hits = 0;
      for (const [rowDelta, columnDelta] of DIRECTIONS) {
        const neighborRow = row + rowDelta;
        const neighborColumn = column + columnDelta;
        if (
          isInside(neighborRow, neighborColumn) &&
          popping.has(indexOf(neighborRow, neighborColumn))
        ) {
          hits += 1;
        }
      }
      if (hits === 0) continue;

      const hitsNeeded = cell === SOLID ? 2 : 1;
      if (hits >= hitsNeeded) {
        revealIndexes.push(index);
      } else {
        next[index] = CRACKED;
      }
    }
  }
  return { board: next, revealIndexes };

    const assignReveals = (revealIndex: number, branchProbability: number) => {
      if (shouldStop()) throw new SearchAbortedError();
      if (revealIndex === cleared.revealIndexes.length) {
        visit(
          applyGravity(cleared.board),
          depth + 1,
          score + points,
          branchProbability,
          nextWaves,
        );
        return;
      }

      const boardIndex = cleared.revealIndexes[revealIndex];
      for (let value = 1; value <= BOARD_SIZE; value += 1) {
        cleared.board[boardIndex] = value as DiscValue;
        assignReveals(revealIndex + 1, branchProbability / BOARD_SIZE);
      }
    };

    assignReveals(0, probability);
  };

  visit(board, startingDepth, 0, 1, []);