Diff Two Filesystem Hash Trees

Two finite filesystems are represented by parallel path and UTF-8 text arrays. Each path is a unique normalized absolute file path; parent directories are implicit.
Return every file path whose presence or content differs between the two filesystems, sorted lexicographically. A path that appears on only one side is changed.
This is the observable diff operation for a filesystem Merkle tree: equal subtree hashes may be skipped, while unequal leaves are reported. Hashes are an optimization and must not change exact content equality.

Function
diffFileSystems(pathsA: String[], contentsA: String[], pathsB: String[], contentsB: String[]) → String[]

Examples
Example 1
pathsA = ["/a.txt","/docs/b.txt"]
contentsA = ["one","two"]
pathsB = ["/a.txt","/docs/b.txt"]
contentsB = ["one","changed"]
return = ["/docs/b.txt"]
Only the nested file changed.
Example 2
pathsA = ["/a","/gone"]
contentsA = ["x","old"]
pathsB = ["/a","/new"]
contentsB = ["x","fresh"]
return = ["/gone","/new"]
Removed and added paths are both reported in lexical order.
Example 3
pathsA = []
contentsA = []
pathsB = []
contentsB = []
return = []
Two empty filesystems have no changed files.

Constraints
0 <= pathsA.length == contentsA.length <= 100000 and likewise for B.
Paths are unique within each side and contain at most 500 UTF-8 bytes.
The combined content size is at most 2 * 10^6 UTF-8 bytes.
Hash equality may prune work only when exact equality remains collision-safe.

The trick is to ignore the Merkle framing. Build a map from path to content for A and for B. Collect every path in either map. A path goes in the result if it's missing from one side or the strings differ. Then sort lexicographically and return. The pitfall is the last constraint: hashes may only prune work when equality stays collision-safe. If you compare only a hash code and skip the real string comparison, a collision gives you a wrong answer. Compare the actual content strings. Second pitfall: sort order. Lexicographic by string, not by directory depth, so "/a" and "/docs/b.txt" follow plain string comparison. Cost is O(total bytes + n log n) with n up to 100000 paths, which is fine. Empty inputs should return an empty list. If the live OA has you second-guessing the collision rule or the sort, StealthCoder is the hedge that hands you a clean solution on screen without the proctor seeing it.

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