<reasoning_content>
*   Task: Implement priority-based job scheduling for a queue.
    *   Requirement 1: `add_job(name, data, priority=0)`.
    *   Requirement 2: Higher priority values processed first.
    *   Requirement 3: Same priority uses FIFO (First-In-First-Out).
    *   Requirement 4: `get_next_job() -> tuple[str, dict] | None`.
    *   Priority levels: 0 (Normal), 1 (High), 2 (Critical).

    *   A simple list or `collections.deque` is fine for FIFO, but for priority, a `heapq` is standard.
    *   *Wait*, `heapq` in Python is a min-heap. The requirement says *higher* priority numbers are higher priority.
    *   To use `heapq` for a max-heap effect: store priority as `-priority`.
    *   To handle FIFO for identical priorities: `heapq` compares the next element in the tuple if the first element (priority) is tied.
    *   The next element should be a sequence number (counter) to ensure FIFO behavior.

    *   `self.jobs = []` (the heap)
    *   `self.counter = 0` (to maintain FIFO)
    *   `add_job(name, data, priority=0)`:
        *   `heapq.heappush(self.jobs, (-priority, self.counter, name, data))`
        *   `self.counter += 1`
    *   `get_next_job()`:
        *   If `not self.jobs`, return `None`.
        *   `_, _, name, data = heapq.heappop(self.jobs)`
        *   Return `(name, data)`

    *   `add_job("normal", ..., 0)` -> `heapq.heappush(..., (0, 0, "normal", ...))`
    *   `add_job("critical", ..., 2)` -> `heapq.heappush(..., (-2, 1, "critical", ...))`
    *   `add_job("high", ..., 1)` -> `heapq.heappush(..., (-1, 2, "high", ...))`
    *   Pop 1: `-2` is smallest -> `("critical", ...)`
    *   Pop 2: `-1` is next smallest -> `("high", ...)`
    *   Pop 3: `0` is next smallest -> `("normal", ...)`
    *   FIFO check:
        *   `add_job("A", ..., 1)` -> `(-1, 0, "A", ...)`
        *   `add_job("B", ..., 1)` -> `(-1, 1, "B", ...)`
        *   `heappop` returns `(-1, 0, ...)` then `(-1, 1, ...)` -> Correct.

    *   `import heapq`
    *   Class `JobQueue`
    *   `__init__`
    *   `add_job`
    *   `get_next_job`

    *   Only Python code.
    *   No explanations.
</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 -priority for max-heap behavior with heapq (min-heap)
        # Use self._counter to maintain FIFO order for identical 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
        
        _, _, name, data = heapq.heappop(self._queue)
        return name, data
```
</content>