<reasoning_content>
*   Goal: Implement priority-based job scheduling.
    *   Input: `add_job(name, data, priority=0)`, `get_next_job()`.
    *   Priority Rules:
        *   Higher priority first (Critical=2, High=1, Normal=0).
        *   Tie-breaker: FIFO (First-In-First-Out).
    *   Data structures: A priority queue is ideal. Since Python's `heapq` is a min-heap, and we want *higher* priority first, we can use negative values or a custom tuple.
    *   FIFO Tie-breaker: Need a counter or timestamp to ensure that jobs with the same priority are processed in the order they were added.

    *   `heapq` is the standard way to implement priority queues in Python.
    *   To handle FIFO with `heapq`: Store items as `(priority, counter, job_name, job_data)`.
    *   Since `heapq` is a min-heap:
        *   Priority: Use negative values (e.g., -2 for Critical, -1 for High, 0 for Normal).
        *   Counter: Incremental integer (always increasing).
    *   `get_next_job()`: Pop the smallest tuple and return `(name, data)`.

    *   `JobQueue` class.
    *   `__init__`: Initialize a list (heap) and a counter.
    *   `add_job(name, data, priority=0)`:
        *   Negate the priority (e.g., `priority = -priority`).
        *   Push `(priority, counter, name, data)` into heap.
        *   Increment counter.
    *   `get_next_job()`:
        *   Pop from heap if not empty.
        *   Return `(name, data)`.

    *   Input: `priority=2` -> stored as `-2`.
    *   Input: `priority=1` -> stored as `-1`.
    *   Input: `priority=0` -> stored as `0`.
    *   Min-heap order: `-2 < -1 < 0`. Correct.
    *   Tie-breaker: `counter` increases, so `(priority, 1)` < `(priority, 2)`. Correct.

    *   Write code only.
    *   No explanation.
</reasoning_content>

<content>
```python
import heapq

class JobQueue:
    def __init__(self):
        self.queue = []
        self.counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0):
        # Use negative priority because heapq is a min-heap, 
        # and we want higher numbers (Critical=2) processed first.
        # The counter ensures FIFO order for equal priorities.
        heapq.heappush(self.queue, (-priority, self.counter, name, data))
        self.counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self.queue:
            return None
        
        priority_neg, count, name, data = heapq.heappop(self.queue)
        return (name, data)
```
</content>