Deep Copy a Random-Pointer List

A linked list has n nodes in next-pointer order. Each node contains an integer value and a random pointer that may target any node or be null.
The list is encoded by nodes, where nodes[i] = [value, randomIndex]. The next pointer of node i targets node i + 1, except for the last node. A randomIndex of -1 means null.
Create a deep copy whose next and random pointers target only copied nodes. For this exercise, after copying, mutate the original node at mutationIndex: set its value to newValue and its random pointer to newRandomIndex.
Return two encoded snapshots in order: the mutated original list, then the unchanged deep copy.
Follow-up: in the pointer-node model, perform the deep copy with O(1) auxiliary space beyond the copied nodes and returned snapshots. You may interleave copied nodes with originals temporarily, but restore the original next-pointer chain before returning.

Function
copyAndMutateRandomList(nodes: int[][], mutationIndex: int, newValue: int, newRandomIndex: int) → int[][][]

Examples
Example 1
nodes = [[7,-1],[13,0],[11,4],[10,2],[1,0]]
mutationIndex = 1
newValue = 130
newRandomIndex = 4
return = [[[7,-1],[130,4],[11,4],[10,2],[1,0]],[[7,-1],[13,0],[11,4],[10,2],[1,0]]]
The second original node changes to [130,4]. The second copied node remains [13,0], so the copy is independent.
Example 2
nodes = [[1,1],[2,1]]
mutationIndex = 0
newValue = 10
newRandomIndex = -1
return = [[[10,-1],[2,1]],[[1,1],[2,1]]]
The first original node loses its random pointer. The copy retains both original random references.
Example 3
nodes = [[5,0]]
mutationIndex = 0
newValue = 6
newRandomIndex = -1
return = [[[6,-1]],[[5,0]]]
The one-node copy keeps its self-random pointer even after the original is changed.

Constraints
1 <= nodes.length <= 10^4.
Every row of nodes contains exactly two integers.
-10^9 <= nodes[i][0], newValue <= 10^9.
Every random index and newRandomIndex is -1 or an index from 0 through nodes.length - 1.
0 <= mutationIndex < nodes.length.

The core is a two-pass copy. The easy way: pass one creates a copy node for every original and stores it in a map keyed by original node (or just an array by index, since the input is index-encoded). Pass two wires next and random through the map. The O(1) follow-up interleaves: insert each copy right after its original, set copy.random = original.random.next, then split the lists and restore the original next chain. The pitfall is a null random, where you must not dereference it. The second pitfall is mutating before the copy is fully separated. Apply the mutation only after the lists are split and restored. Then encode each list back to [value, randomIndex] by mapping nodes to indices. Check Example 3, a one-node self-pointer, since it breaks sloppy null handling. If the interleave logic slips under pressure, StealthCoder is the hedge that hands you a clean version live.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.