<reasoning_content>
The objective is to implement a priority-based job queue in Python.

    *   `add_job(name, data, priority=0)`: Adds a job with a priority.
    *   `get_next_job()`: Returns the highest priority job (tuple of `(name, data)`).
    *   Priority Levels: 0 (Normal), 1 (High), 2 (Critical).
    *   Tie-breaking: If priorities are equal, use FIFO (First-In-First-Out).
    *   Internal Structure: A priority queue is usually implemented using a heap (`heapq` module in Python).

    *   Python's `heapq` implements a min-heap.
    *   Priority levels are: 0 (lowest), 1, 2 (highest).
    *   Requirement says "Higher priority jobs should be processed before lower priority jobs".
    *   Wait, let's look at the example: `priority=2` is "Critical" and it's returned first.
    *   In a min-heap, the smallest number comes out first.
    *   To make higher numbers (like 2) come out first, I can store them as negative values (e.g., -2).
    *   OR, I can just use a max-heap logic. But `heapq` is a min-heap.
    *   Let's map:
        *   Critical (2) -> Priority value -2
        *   High (1) -> Priority value -1
        *   Normal (0) -> Priority value 0
    *   Actually, the simplest way is to store `(-priority, counter, name, data)`.
    *   Why a `counter`? To ensure FIFO order for identical priorities. `heapq` compares elements sequentially. If priorities are equal, it compares the next element in the tuple. A monotonically increasing counter ensures the earlier job stays first.

    *   `import heapq`
    *   `class JobQueue:`
    *   `def __init__(self): self.queue = []`, `self.counter = 0`
    *   `def add_job(self, name, data, priority=0):`
        *   `heapq.heappush(self.queue, (-priority, self.counter, name, data))`
        *   `self.counter += 1`
    *   `def get_next_job(self):`
        *   `if not self.queue: return None`
        *   `prio, count, name, data = heapq.heappop(self.queue)`
        *   `return (name, data))`

    *   `queue.add_job("normal", ..., priority=0)` -> `(0, 0, "normal", ...)`
    *   `queue.add_job("critical", ..., priority=2)` -> `(-2, 1, "critical", ...)`
    *   `queue.add_job("high", ..., priority=1)` -> `(-1, 2, "high", ...)`
    *   Heap: `[(-2, 1, "critical", ...), (-1, 2, "high", ...), (0, 0, "normal", ...)]`
    *   `heappop` returns `(-2, 1, "critical", ...)`.
    *   Result: `("critical", ...)`. Correct.

    *   Requirement 1: `add_job` accepts `priority=0`. Done.
    *   Requirement 2: Higher priority (2) before lower (0). Done (via negative mapping).
    *   Requirement 3: Same priority = FIFO. Done (via counter).
    *   Requirement 4: `get_next_job() -> tuple[str, dict] | None`. Done.
</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
        # 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, count, name, data = heapq.heappop(self.queue)
        return (name, data)
```
</content>