<reasoning_content>
*   Task: Implement priority-based job scheduling for a job queue.
    *    Requirements:
        1.  `add_job` needs an optional `priority` parameter (default=0).
        2.  Higher priority numbers come first (e.g., 2 > 1 > 0).
        3.  Same priority = FIFO (First-In-First-Out).
        4.  `get_next_job()` should return the highest priority job as a tuple `(name, data)`.
    *    Priority Levels: 0 (Normal), 1 (High), 2 (Critical).
    *    Constraint: Write only Python code, no explanations.

    *   I need a way to store jobs efficiently for priority extraction. A `heapq` (priority queue) is standard for this.
    *   However, `heapq` is a min-heap (smallest value first). The requirements say higher priority numbers come first.
    *   To use `heapq` for a max-priority style (where higher number is better):
        *   Option A: Store negative priority (e.g., -2, -1, 0).
        *   Option B: Store items as `(priority, sequence_number, name, data)`.
    *   Requirement 3 (FIFO for same priority): This necessitates a sequence number. If I just put `(priority, name)`, and `name` is different, `heapq` will sort by name alphabetically. So, `(priority, sequence_number)` is needed.
    *   Actually, for "Higher priority first", if I use a min-heap and want 2 to come before 1, I should store negative values. Or, I can just store priority normally and use a `PriorityQueue` from `queue` module? Wait, `queue.PriorityQueue` is also a min-heap.
    *   Let's stick to a simple list with `heapq` or a sorted list. Given standard queue behaviors, `heapq` is usually most efficient for "priority".
    *   But let's look at the priority values: 0, 1, 2.
    *   If I store `(-priority, counter, name, data)`, `heapq.heappush` will keep the smallest value at the front.
        *   Priority 2 -> `-2`
        *   Priority 1 -> `-1`
        *   Priority 0 -> `0`
        *   Smallest is `-2`. Perfect.

    *   `JobQueue` class.
    *   `__init__`: Initialize a list for the heap and a counter for FIFO.
    *   `add_job(name, data, priority=0)`:
        *   Push `(-priority, counter, name, data)` into heap.
    *   `get_next_job()`:
        *   Pop from heap.
        *   Return `(name, data)`.

    ```python
    import heapq

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

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

        def get_next_job(self) -> tuple[str, dict] | None:
            if not self.heap:
                return None
            priority, counter, name, data = heapq.heappop(self.heap)
            return (name, data)
    ```

    *   `add_job` accepts optional priority? Yes.
    *   Higher priority first? Yes (via negative priority).
    *   Same priority FIFO? Yes (via counter).
    *   `get_next_job` return type? Yes.

    Wait, the prompt asks to "Modify `add_job`...". This implies there might be an existing `JobQueue` class? The prompt doesn't provide an existing class, just the requirements. I should provide the class structure.

    One detail: "Higher priority jobs should be processed before lower priority jobs".
    Example:
    - Normal (0)
    - Critical (2)
    - High (1)
    Result: Critical (2), High (1), Normal (0).
    Since `heapq` is a min-heap, putting -2, -1, 0 puts -2 at the top. Correct.

    *   `heapq` is efficient.
    *   `counter` is required for tie-breaking.
    *   Tuple structure in heap: `(-priority, sequence_number, name, data)`.

    Wait, the prompt says: `get_next_job() -> tuple[str, dict] | None`.
    I'll make sure the code is clean.

    Let's double check the prompt for any specific implementation details.
    None provided.

    ```python
    import heapq

    class JobQueue:
        def __init__(self):
            self._queue = []
            self._counter = 0

        def add_job(self, name: str, data: dict, priority: int = 0):
            # Negative priority for max-heap behavior in heapq min-heap
            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)
    ```

    Actually, I'll use standard naming for internal variables or just simple ones.

    One small check: Should I handle the priority levels strictly?
    "Priority levels: 0: Normal, 1: High, 2: Critical".
    The code works regardless of how many levels there are, as long as higher number = higher priority.

    Let's make sure the `tuple` hint works for Python 3.10+ or use `Optional`.
    The prompt used `tuple[str, dict] | None`, which is Python 3.10 syntax.

    Final check on `get_next_job` return type.
    `Returns critical job first` from example.
    Example usage:
    ```python
    queue = JobQueue()
    queue.add_job("normal", {"type": "normal"}, priority=0)
    queue.add_job("critical", {"type": "critical"}, priority=2)
    queue.add_job("high", {"type": "high"}, priority=1)

    job = queue.get_next_job()  # Returns ("critical", {"type": "critical"}))
    ```
    Yes, my logic holds.

    Code block only. 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 negative priority because heapq is a min-heap, 
        # and we want higher priority numbers (e.g., 2) to be processed first.
        # The counter ensures FIFO order for jobs with the same priority.
        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>