Undo and Redo Command History

Maintain an active command history while processing a sequence of operations.
Each row in operations has one of these forms:
["EXECUTE", command]: append the nonempty, case-sensitive command identifier to the active history. Executing a new command clears every command currently available for redo.
["UNDO"]: remove the most recently active command and make it available for redo. If the active history is empty, do nothing.
["REDO"]: restore the most recently undone command to the end of the active history. If no command is available for redo, do nothing.
After every operation, encode the complete active history as one string. Join its command identifiers in application order with |. Encode an empty active history as the empty string.
Return the encoded snapshots in operation order.

Function
runUndoRedoHistory(operations: String[][]) → String[]

Examples
Example 1
operations = [["EXECUTE","build"],["EXECUTE","test"],["UNDO"],["REDO"]]
return = ["build","build|test","build","build|test"]
The undo removes test from the active history, and redo restores that same command.
Example 2
operations = [["EXECUTE","a"],["EXECUTE","b"],["EXECUTE","c"],["UNDO"],["UNDO"],["EXECUTE","d"],["REDO"],["UNDO"]]
return = ["a","a|b","a|b|c","a|b","a","a|d","a|d","a"]
After two undos, executing d clears the redo branch. The following redo is therefore a no-op, and the final undo removes d.
Example 3
operations = [["UNDO"],["REDO"],["EXECUTE","x"],["UNDO"],["UNDO"],["REDO"],["REDO"]]
return = ["","","x","","","x","x"]
Undo and redo are no-ops when their corresponding history is empty. The command x can be restored only once.

Constraints
1 <= operations.length <= 500
Each row is exactly ["UNDO"], ["REDO"], or ["EXECUTE", command].
1 <= command.length <= 100.
Each command identifier contains only uppercase or lowercase ASCII letters, digits, underscores, or hyphens and is compared by exact, case-sensitive equality.
The total number of command identifiers across all returned snapshots is at most 125000.

Keep two stacks: active and redo. EXECUTE pushes onto active and clears redo. UNDO pops active, if nonempty, and pushes onto redo. REDO pops redo, if nonempty, and pushes onto active. After every operation, join active with "|" and append that string to the result. The pitfall is clearing redo on EXECUTE. The second pitfall is no-ops: UNDO on empty history and REDO on empty redo must still emit a snapshot, even if it's the same as before or empty. Don't skip the output. Cost is fine. With at most 500 operations and 125000 total identifiers, rebuilding the string each time is acceptable, so don't over-engineer it. If the stack handling slips under pressure, StealthCoder is the hedge during the live OA. It reads the prompt and gives you a working solution while you stay in the editor.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.