Problem Narrative

You’re building the Tasker app for a logistics marketplace with millions of monthly active contractors. Taskers often lose connectivity in elevators, basements, or rural delivery routes, but they still need to open job details (address, instructions, safety notes) for their upcoming assignments. To keep the offline experience reliable without bloating storage, the app pre-downloads a limited set of job detail payloads.

Formal Problem Statement

You are given a list of jobs the Tasker may need soon. Each job has:

• job_id (unique integer)
• last_updated (integer timestamp; larger means more recent)
• size_kb (positive integer; offline payload size)
• priority (integer; larger means more important to keep offline)

You have an offline storage budget of capacity_kb. Implement:

def select_jobs_for_offline(jobs: list[tuple[int, int, int, int]], capacity_kb: int) -> list[int]:

Return a list of job_ids to cache such that:

1. The total size of selected jobs is <= capacity_kb.
2. The selection maximizes total priority.
3. If multiple selections have the same total priority, choose the one with the largest sum of last_updated (prefer fresher data).
4. If still tied, choose the selection whose sorted list of job_ids is lexicographically smallest.

If capacity_kb is too small to fit any job, return an empty list.

Examples

Example 1

Input: jobs = [(10, 100, 4, 7), (11, 90, 3, 6), (12, 110, 5, 8)], capacity_kb = 7

Output: [10, 11]

Explanation:

• You can fit jobs 10 and 11: size 4 + 3 = 7, priority 7 + 6 = 13.
• Job 12 alone has priority 8, which is worse than 13.

Example 2

Input: jobs = [(1, 5, 2, 4), (2, 6, 2, 4), (3, 1, 4, 8)], capacity_kb = 4

Output: [3]

Explanation:

• Either pick job 3 (priority 8) or pick jobs 1+2 (priority 8).
• Priorities tie, so compare freshness sum: job 3 has 1, jobs 1+2 have 5+6=11, so [1,2] would win by freshness — but it does not fit because 2+2=4 fits; actually it fits, so winner is [1, 2].

Note: This example illustrates tie-breaking; ensure your implementation follows rules exactly.

Constraints

• 1 <= len(jobs) <= 200
• 0 <= capacity_kb <= 10_000
• 1 <= size_kb <= 10_000
• 0 <= priority <= 10_000
• 0 <= last_updated <= 10^9
• job_id values are unique

Notes / Clarifications

• You may return job_ids in any order, but tie-breaking rule #4 is based on the sorted list of selected IDs.
• This is a classic 0/1 knapsack variant with deterministic tie-breaking.