Reveal a Minesweeper Region

You are given a rectangular Minesweeper board. A mine is encoded as -1, and every unrevealed empty cell is encoded as 0.
Reveal the region that begins at the empty cell (startRow, startCol). Two cells are adjacent when their row and column differ by at most one, excluding the cell itself.
When an unrevealed empty cell is reached:
Count the mines among its at most eight adjacent cells.
If the count is positive, replace the cell with that count and do not expand from it.
If the count is zero, replace the cell with -2, then continue the reveal from each adjacent cell that is still 0.
Mines remain -1, and empty cells that are never reached remain 0. Return the resulting board.

Function
revealRegion(board: int[][], startRow: int, startCol: int) → int[][]

Examples
Example 1
board = [[0,0,0,0,0],[0,0,0,-1,0],[0,0,0,0,0],[0,0,0,0,0]]
startRow = 3
startCol = 0
return = [[-2,-2,1,0,0],[-2,-2,1,-1,0],[-2,-2,1,1,1],[-2,-2,-2,-2,-2]]
The reveal begins in the mine-free lower-left region. Every zero-clue cell in that region becomes -2, and its numbered boundary is revealed. Expansion stops at those numbered cells, so the two empty cells beyond the mine remain 0.
Example 2
board = [[0,0,0],[0,0,0]]
startRow = 0
startCol = 1
return = [[-2,-2,-2],[-2,-2,-2]]
The board contains no mines. Every empty cell is connected to the reveal origin and has zero adjacent mines, so every cell becomes -2.
Example 3
board = [[0,-1,0],[0,0,0],[0,0,-1]]
startRow = 1
startCol = 1
return = [[0,-1,0],[0,2,0],[0,0,-1]]
The origin has two adjacent mines, so it is revealed as 2. Because its clue is positive, the reveal does not expand to any neighbor.

Constraints
1 <= board.length <= 200.
1 <= board[r].length <= 200, and every row has the same length.
Every initial cell is -1 or 0.
0 <= startRow < board.length and 0 <= startCol < board[0].length.
board[startRow][startCol] == 0.

The trick is that the cell's own state tells you whether it's been visited. Only process a cell if it's in bounds and still 0. Count mines in the 8 neighbors. If the count is positive, write the count and stop. If zero, write -2 and push every neighbor that is still 0. Because you mark -2 before expanding, you never revisit, so no separate visited array is needed. The common pitfall is using 4-directional movement, or recursing so deep that a 200 by 200 empty board blows the stack. Use an explicit stack or queue to be safe. Another slip is counting a cell's mines after overwriting it, or expanding from numbered cells. Check Example 3 against your code: a positive origin changes nothing else. Complexity is O(rows * cols * 8). If you freeze on the live OA, StealthCoder can surface this BFS skeleton quietly, but the logic here is small enough to own.

Drill it cold or hedge it with StealthCoder. Either way, don't walk into the OA hoping you remember the trick.