Task Processor: Dependencies and Deadlines

You are building a task processor. Each task has a string id, an integer deadline, and a list of subtasks that must be consumed before the task itself can be consumed.
Given all tasks up front, repeatedly consume one eligible task until no tasks remain. A task is eligible when all of its subtasks have already been consumed. Among all eligible tasks, always consume the task with the smallest deadline. If multiple eligible tasks have the same deadline, consume the lexicographically smaller task id first.
Return the ids of the tasks in the order they are consumed.

Function
consumeTasks(taskIds: String[], deadlines: int[], subtasks: String[][]) → String[]

Examples
Example 1
taskIds = ["1", "2"]
deadlines = [2, 4]
subtasks = [["2"], []]
return = ["2", "1"]
Task 1 has the earlier deadline, but it depends on task 2, so task 2 must be consumed first.
Example 2
taskIds = ["a", "b", "c"]
deadlines = [5, 1, 3]
subtasks = [[], [], []]
return = ["b", "c", "a"]
With no dependencies, tasks are consumed by increasing deadline.

Constraints
taskIds.length == deadlines.length == subtasks.length
Task ids are unique non-empty strings.
Every id listed in subtasks appears in taskIds.
The dependency graph is a DAG.
Use a min-heap or priority queue for currently eligible tasks.

The trick is Kahn's algorithm with a priority queue instead of a plain queue. Build an in-degree count for each task from its subtasks list, and a reverse map from each subtask to the tasks that depend on it. Push every task with in-degree zero into a min-heap keyed by (deadline, id). Pop one, append it to the result, then decrement in-degree for each dependent and push any that hit zero. The edge case that breaks the naive version is sorting everything by deadline up front, which ignores dependencies. A second pitfall is comparing ids as numbers instead of strings, so "10" must sort before "2". Also remember the subtasks list holds ids, not indexes, so map id to index first. Complexity is O(n log n + edges). If you blank on the reverse-edge direction, StealthCoder is the hedge during the live OA.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.