Spiral Order with Obstacles

You are given a nonempty rectangular integer matrix matrix. A cell containing -1 is an obstacle; every other cell contains a value to visit.
Start at matrix[0][0] facing right. Append the current cell's value to the output. Before every move:
Continue in the current direction when the next cell is inside the matrix, is not an obstacle, and has not been visited.
Otherwise, rotate clockwise and test the next direction. Rotate at most four times for one move.
The input guarantees that matrix[0][0] is not an obstacle and that this rule reaches every non-obstacle cell exactly once. Return the values in visit order.

Function
spiralOrderWithObstacles(matrix: int[][]) → int[]

Examples
Example 1
matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
return = [1,2,3,4,8,12,11,10,9,5,6,7]
Without obstacles, the walk follows the ordinary clockwise outer layer and then the remaining inner cells.
Example 2
matrix = [[1,2,3,4],[5,6,-1,7],[8,9,10,11],[12,13,14,15]]
return = [1,2,3,4,7,11,15,14,13,12,8,5,6,9,10]
The center obstacle forces additional right turns before the walk reaches 9 and 10.
Example 3
matrix = [[1,-1,7],[2,-1,6],[3,4,5]]
return = [1,2,3,4,5,6,7]
The first attempted right move is blocked, so the walk rotates downward and reaches the right column from below.

Constraints
1 <= matrix.length and 1 <= matrix[0].length.
matrix is rectangular.
matrix.length * matrix[0].length <= 100000.
-10^9 <= matrix[r][c] <= 10^9.
-1 denotes an obstacle and is not used as a visitable value.
matrix[0][0] != -1.
The clockwise walk reaches every non-obstacle cell exactly once.

Simulate the walk. Keep a boolean visited array the same size as the matrix, a row and column pointer, and a direction index into the arrays dr = [0,1,0,-1] and dc = [1,0,-1,0]. Append the current value, mark it visited, then try to move. If the next cell is in bounds, not -1, and not visited, go. Otherwise rotate the direction index by one and test again, up to four rotations. Stop when no direction works. Time is O(rows * cols), space is O(rows * cols) for the visited grid. The common pitfall is rotating permanently before checking the straight move, or forgetting to mark the start cell visited. Another is stopping on a fixed count of cells, when obstacles change how many you visit. Loop until all four rotations fail. If you freeze on the turn order during the live OA, StealthCoder gives you the loop as a hedge.

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