<reasoning_content>
*   Task: Implement priority-based job scheduling for a `JobQueue` class.
    *    Requirements:
        1. `add_job` accepts `priority` (default=0).
        2. Higher priority first (priority 2 > 1 > 0).
        3. Same priority = FIFO order.
        4. `get_next_job()` returns the highest priority job as a tuple `(name, data)`.
    *    Constraints: Python code only, no explanations.

    *   To handle priority + FIFO, a Priority Queue (Heap) is the standard data structure.
    *   In a min-heap (Python's `heapq`), we want high numbers to be "smaller" (processed first). Since 2 is higher than 0, we can use negative values (e.g., -2, -1, 0).
    *   To ensure FIFO for same priorities, we need a secondary ordering key, which is an incrementing counter.

    *   `self.queue`: A list to act as a heap.
    *   `self.counter`: An integer to track the insertion order.

    *   `add_job(self, name: str, data: dict, priority: int = 0)`:
        *   Convert priority to negative: `-priority`.
        *   Push `(-priority, self.counter, name, data)` into the heap.
        *   Increment `self.counter`.

    *   `get_next_job(self) -> tuple[str, dict] | None`:
        *   If heap is empty, return `None`.
        *   Pop the smallest element (which has the largest negative priority, i.e., highest positive priority).
        *   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):
            # Use negative priority because heapq is a min-heap
            # Counter ensures FIFO for same 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_neg, count, name, data = heapq.heappop(self.heap)
            return (name, data)
    ```

    *   `add_job` modified? Yes.
    *   Higher priority first? Yes (priority 2 -> -2 is smaller than -1).
    *   FIFO for same priority? Yes (`self.counter` handles this).
    *   `get_next_job()` return type? `tuple[str, dict] | None`. Yes.

    (Code only).
</reasoning_content>

<content>
```python
import heapq

class JobQueue:
    def __init__(self):
        self.heap = []
        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 identical 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
        
        _, _, name, data = heapq.heappop(self.heap)
        return (name, data)
```
</content>