fix(reader): the Takeout import holds up under abuse, races and a run it cannot see

- Uploads: one at a time per user and ten an hour, each refused only after its body arrived;
  the history read an entry at a time (32 MiB cap), a Watch later list capped at YouTube's 5000,
  a user's kept videos at 200k; any unreadable shape is a 422, not a 500.
- Quota: Watch later lookups stop at the backfill reserve and at a per-user daily share; what is
  not asked about waits, known videos still go in, and the shorts job retries the rest.
- Staging and settling share one per-user advisory lock (no deadlock); a run settles only the
  rows it read, so a row staged meanwhile is never called gone.
- A failed run's notice names a translated failure, never the upstream's text.
- The status says when an import is queued; the page watches it to its end even when left, then
  reads the feed, its counts and the playlists again.
- Settings: one live region, the zone kept (unavailable) while a run goes, focus handed back,
  a missed drop kept from the browser, an oversize file refused before it is sent.
- Scheduler and run lists show Takeout runs by the importing user.

backend/app/reader/service.py

@@ -510,6 +510,15 @@ def detach_user_tag(db: Session, user: User, channel_id: str, tag_id: int) -> No
 # --- Google Takeout --------------------------------------------------------------------------
 
 _TAKEOUT_BATCH = 1000
+# The advisory-lock namespace of one user's Takeout rows ("TO"), so a key cannot meet another lock's.
+_TAKEOUT_LOCK_NS = 0x544F
+
+
+def lock_takeout(db: Session, user: User) -> None:
+    """Hold the user's Takeout rows for the rest of the transaction. An upload's staging and an
+    import's settling each lock many of the same rows, one statement after another and in no common
+    order, so without one lock over both the two can deadlock."""
+    db.execute(select(func.pg_advisory_xact_lock(_TAKEOUT_LOCK_NS, user.id)))
 
 
 def stage_takeout(
@@ -518,6 +527,7 @@ def stage_takeout(
     """Keep the videos of one Takeout file, `{video id: (time, channel id)}`, for the import job.
     A second upload of the same export, or a newer one, adds what is new: a video already kept keeps
     the later time, and a row the import has settled keeps its outcome."""
+    lock_takeout(db, user)
     values = [
         {"user_id": user.id, "kind": kind, "video_id": vid, "at": at, "channel_id": channel}
         for vid, (at, channel) in rows.items()
@@ -551,6 +561,7 @@ def apply_takeout_watched(db: Session, user: User) -> dict[str, int]:
     past is not watching it), and a state the user set here wins: watched or hidden, or anything
     changed after the Takeout time. The upsert's own condition is that rule, so a state set while
     the import runs wins too."""
+    lock_takeout(db, user)
     short: list[int] = []
     todo: dict[str, tuple[int, datetime]] = {}
     for row_id, video_id, at, is_short in queries.takeout_watched_ready(db, user):
@@ -590,19 +601,22 @@ def apply_takeout_watched(db: Session, user: User) -> dict[str, int]:
     return {"watched": len(marked), "kept": len(kept), "shorts": len(short)}
 
 
-def apply_takeout_watch_later(db: Session, user: User) -> dict[str, int]:
-    """Put the videos of the user's YouTube Watch later list into theirs here, oldest first, after
-    what it already holds. Called once the catalog has fetched what it could: a video still unknown
-    is one YouTube no longer has."""
-    waiting = queries.takeout_waiting(db, user, TakeoutKind.WATCH_LATER)
-    if not waiting:
+def apply_takeout_watch_later(
+    db: Session, user: User, rows: list[tuple[int, str]], asked: set[str]
+) -> dict[str, int]:
+    """Put the videos of the user's waiting Watch later `rows`, (row id, video id) oldest first, into
+    their list here, after what it already holds. `asked` is the videos YouTube was just asked for: one
+    of those the catalog still lacks is gone from YouTube; any other unknown one keeps waiting."""
+    if not rows:
         return {}
-    known = queries.known_video_ids(db, [vid for _, vid in waiting])
+    lock_takeout(db, user)
+    known = queries.known_video_ids(db, [vid for _, vid in rows])
     pl = watch_later(db, user)
     done: dict[TakeoutOutcome, list[int]] = {o: [] for o in TakeoutOutcome}
-    for row_id, vid in waiting:
+    for row_id, vid in rows:
         if vid not in known:
-            done[TakeoutOutcome.MISSING].append(row_id)
+            if vid in asked:
+                done[TakeoutOutcome.MISSING].append(row_id)
         elif add_item(db, pl, vid, mark_dirty=False):
             done[TakeoutOutcome.ADDED].append(row_id)
         else: