This is a bit hard to read. Something like this for updating the board should be easier to understand:

const newBoard = state.board.map(row => row.slice());
newBoard[move.x][move.y] = state.turn;

Clever! Fixed.

There are some parameters which don't change over time:

• getPossibleNextStatesFn
• isGameOverFn
• getScoreFn

We can have a higher-order (builder) function, which accepts them and returns a new function, which does the rest:

const minimaxBuilder = (getPossibleNextStatesFn, isGameOverFn, getScoreFn) => {
  const minimax = (state, maximize, depth, alpha, beta) => {
    // ...
  };
  return minimax;
};

This way we'll change the public API a bit:

const minimax = minimaxBuilder(...);
const result = minimax(...);

Great idea! Fixed.

Is this used for an optimization so we stop the loop earlier?

If we stop when alpha === beta can't we miss later cases when alpha is larger than beta, which will lead to a better outcome?

That's right, it's an optimization called "Alpha-beta pruning".
That's not the case. If alpha is larger then beta, then we know that this whole leaf won't be chosen anyway. I couldn't explain it better than 20 seconds of this video.

That's a fantastic example! As you suggested in your comment, it's leaning a bit towards an integration test.

I think, having a simpler game is fine as well. This way we won't need that much logic to setup our tests and they'll be less error prone. Consider a game where each next step is a binary decision, and the leafs of the binary tree determine which player is the winner.

I really like this example, so I'd love to keep it, and also add another test group which tests the minimax example with a simpler binary game.

I'm glad you like it!
Sounds reasonable. I'm not sure if I follow the idea of the simpler game. What do you mean by the leafs of the binary tree determine which player is the winner? Should I create some binary tree with one "winning leaf"?

It doesn't have to be a real game, it can be any game. My proposal is for something like this:

     o
   /    \
  o      o
 /  \   /  \
1   -1 1   -1

If we get 1 player "A" wins, otherwise, if we get -1 player "B" wins. It's pretty much pre-defined, depends on who would start first. It'll be easier to reason about IMO.

I think I got it. Indeed, it's much simpler.

Same as above.