<reasoning_content>
*   Task: Implement priority-based job scheduling.
    *    Input: A `JobQueue` class (implied, though not provided, so I need to define it).
    *    Requirements:
        1. `add_job(name, data, priority=0)`: Add job with priority.
        2. Higher priority first (Priority 2 > 1 > 0).
        3. FIFO for same priority.
        4. `get_next_job() -> tuple[str, dict] | None`: Get highest priority.
    *    Constraints: No explanations, only Python code.

    *   To handle priorities and FIFO efficiently, a Priority Queue is ideal.
    *   Python's `heapq` module implements a min-heap.
    *   To make it a max-heap for priority (where higher number = higher priority), I should store priorities as negative numbers.
    *   To handle FIFO for same priority, I need a tie-breaker (a sequence counter).

    ```python
    import heapq

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

        def add_job(self, name: str, data: dict, priority: int = 0):
            # heapq is min-heap.
            # Higher priority number = higher priority.
            # To use min-heap for max-priority, use -priority.
            # Tie-breaker is the counter to ensure FIFO.
            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)
    ```

    *   Requirements check:
        1. `add_job` accepts optional priority? Yes.
        2. Higher priority first? Yes (`-priority` in min-heap makes 2 < 1 < 0, so -2 < -1 < 0).
        3. Same priority FIFO? Yes (`self.counter`).
        4. `get_next_job` signature? Yes.

    *   Refinement on Return Type: `tuple[str, dict] | None`.
</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 to have higher priority.
        # Use self.counter as a tie-breaker to maintain FIFO order.
        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>