The rules of Conway's Game of Life aren't working in my Javascript version. What am I doing wrong?

const cellCount = 10;

// Let's define the same grid, but rather than harcoding it,
// let's just generate it off of a single number:
const emptyCells = [...new Array(cellCount)].map((_) => [...new Array(cellCount)].fill(0));

// Then, initialize the current cells from that empty grid.
let currentCells = structuredClone(emptyCells);

// To see things work, let's add a "glider"
[[0, 1],[1, 2],[2, 0],[2, 1],[2, 2]].forEach(([i, j]) => (currentCells[i][j] = 1));

// Then, our control logic: we'll have the sim run
// with a button to pause-resume the simulation.
let nextRun;
let paused = false;
toggle.addEventListener(`click`, () => {
  paused = !paused;
  if (paused) clearTimeout(nextRun);
  else runSimulation();
});

// And then: run the program!
showBoard();
runSimulation();

// It doesn't matter where we put functions in JS: the parser first
// reads in every function, and only *then* starts running, letting
// us organize things in terms of "the overall program" first, and
// then "the functions that our program relies on" after.

// draw our board with □ and ■ for dead and live cells, respectively.
function showBoard() {
  board.textContent = currentCells
    .map((row) => row.join(` `).replaceAll(`0`, `□`).replaceAll(`1`, `■`))
    .join(`n`);
}

// our simulation just runs through the grid, updating
// an initially empty "next" grid based on the four
// Game of Life rules.
function runSimulation() {
  const next = structuredClone(emptyCells);
  for (let i = 0; i < cellCount; i++) {
    for (let j = 0; j < cellCount; j++) {
      const alive = currentCells[i][j] === 1;
      const neighbourCount = getNeighbourCount(i, j);
      if (alive && (neighbourCount === 2 || neighbourCount === 3)) {
        next[i][j] = 1;
      } else if (neighbourCount === 3) {
        next[i][j] = 1;
      }
    }
  }
  // update our grid, draw it, and then if we're not paused,
  // schedule the next call half a second into the future.
  currentCells = next;
  showBoard();
  if (!paused) {
    nextRun = setTimeout(runSimulation, 500);
  }
}

// In order to count how many neighbours we have, we need to
// sum *up to* eight values. This requires making sure that
// we check that a neighbour even exists, of course, because
// (0,0), for instance, has nothing to the left/above it.
function getNeighbourCount(i, j, cells = currentCells) {
  let sum = 0;
  for (let u = -1; u <= 1; u++) {
    if (i + u < 0 || i + u >= cellCount) continue;
    for (let v = -1; v <= 1; v++) {
      if (j + v < 0 || j + v >= cellCount) continue;
      if (u === 0 && v === 0) continue;
      sum += cells[i + u][j + v];
    }
  }
  return sum;
}

<pre id="board"></pre>
<button id="toggle">play/pause</button>