Filesystem Entity Total Size

A valid filesystem is supplied by parallel arrays. Entity i has unique ID ids[i], parent ID parentIds[i], type FILE or DIRECTORY, and stored size sizes[i]. The root directory has an empty parent ID. Every other entity's parent is a directory.
A file's total size is its own stored size. A directory's total size is the sum of the stored sizes of every descendant file at any depth. Return the total size of queryId.
Interview Follow-Ups
Disk-backed traversal: If the filesystem metadata is too large to fit in memory, fetch each directory's children page by page and accumulate file sizes as the pages stream in. Persist each open directory's continuation token and partial subtotal so the traversal can resume from a checkpoint after an interruption.
All directory subtotals: To compute and store every directory's total, process the tree in postorder. Add each file size or completed child-directory subtotal to its parent, then store the completed subtotal for that directory.
These follow-ups are discussion variants. The judged function still receives the complete arrays and returns only the total for queryId.

Function
totalEntitySize(ids: String[], parentIds: String[], types: String[], sizes: long[], queryId: String) → long

Examples
Example 1
ids = ["root","d","a","b"]
parentIds = ["","root","d","d"]
types = ["DIRECTORY","DIRECTORY","FILE","FILE"]
sizes = [0,0,5,6]
queryId = "root"
return = 11
The root contains two files beneath its child directory, so both sizes contribute.
Example 2
ids = ["root","d","a","outside"]
parentIds = ["","root","d","root"]
types = ["DIRECTORY","DIRECTORY","FILE","FILE"]
sizes = [0,0,5,20]
queryId = "d"
return = 5
The file outside directory d is not a descendant of the query.

Constraints
1 <= ids.length <= 200000; all four entity arrays have equal length.
IDs are unique nonempty printable ASCII strings of length at most 60; queryId exists.
The entities form one valid rooted tree with exactly one root directory whose parent is the empty string.
Every file size is between 0 and 1000000000; directory stored sizes are 0.
The requested total fits in a signed 64-bit integer.

Build a children map once: parentId to a list of child indexes, plus an ID to index map. That's O(n). Then traverse from queryId and sum sizes of FILE nodes only. The brute force trap is scanning all n entities to find children at every directory, which goes quadratic and dies at 200000. The second trap is recursion depth. A chain of 200000 nested directories will overflow the stack in most languages, so use an explicit stack or iterative DFS. Third, use a 64-bit accumulator, since 200000 files at 1000000000 each overflows 32-bit. If the query is a file, return its own size. Directory stored sizes are 0, but skip them by type anyway. The follow-ups (postorder subtotals, paged traversal) are discussion only. If the live OA rattles you, StealthCoder can hand you the iterative version fast.

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