N-Ary Tree BFS Codec

Implement both directions of a codec for ordered N-ary trees with signed integer node values. Process each row of operations in order and return one result per row.
["SERIALIZE", tree] converts canonical tree text into the breadth-first wire format below.
["DESERIALIZE", data] converts valid wire data into canonical tree text.
Canonical tree text
An empty tree is the empty string. A leaf is its decimal value. A non-leaf is its value followed by its children in parentheses, separated by commas. Child order is significant. For example, 1(3(5,6),2,4) has root 1 with children 3, 2, and 4.
Breadth-first wire format
An empty tree is again the empty string. A nonempty encoding begins with the root value. Later levels are separated by |. Within a later level, list each parent's child values from left to right and terminate that parent's child list with #. Parents are processed in the previous level's left-to-right order. Omit a final level that would contain only # markers.
For example, 1(3(5,6),2,4) serializes as 1|3,2,4,#|5,6,#,#,#. In the last segment, the first # closes node 3's children, and the remaining markers record that nodes 2 and 4 have no children.

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

Examples
Example 1
operations = [["SERIALIZE","1(3(5,6),2,4)"],["DESERIALIZE","7|8,9,10,#|#,11,#,#"]]
return = ["1|3,2,4,#|5,6,#,#,#","7(8,9(11),10)"]
The first operation writes the tree level by level and uses # to close each parent's child list. In the second operation, node 9 is the only child on its level that receives a child.
Example 2
operations = [["SERIALIZE","42"],["DESERIALIZE","-1|2,3,#"]]
return = ["42","-1(2,3)"]
A single node needs no later level. The second wire string gives the root two leaf children.

Constraints
1 <= operations.length <= 200.
Every operation has exactly two strings and uses SERIALIZE or DESERIALIZE.
Every supplied tree text and wire string is valid under the stated grammar.
Each tree contains at most 5000 nodes.
Every node value is a signed 32-bit integer.
The total number of nodes across all operations is at most 20000.

The trick is that you do two jobs per operation. SERIALIZE needs a recursive-descent or stack parser for the canonical text, including negative values and nested parentheses, then a BFS queue. For each node in the queue, append its children and then a #, and join levels with |. Drop the final level if it's only # markers. DESERIALIZE reverses it: keep a queue of parents for the previous level, read the next segment, and consume children until each # closes a parent. The pitfalls are trailing all-# levels, the single-node case, and splitting on commas without respecting nesting. With 5000 nodes per tree, avoid deep recursion if your language has a small stack. Use an explicit stack for parsing. If you blank on the pointer logic during the live OA, StealthCoder can give you the structure so you can verify against the examples.

If you see this problem in your OA tomorrow, the play is to recognize the pattern in 30 seconds. StealthCoder buys you that recognition.