fix(plex): address S1 code-review findings

- Restore synchronize_session=False on the remove-bulk Core delete (the 2.0
  default is 'auto'; keep the pre-conversion contract explicit).
- _episode_nav: list(...scalars()) instead of [r[0] for r in ...all()], matching
  the house style used across the conversion.
- Extract app/plex/lookups.by_rating_key() and migrate the get-by-rating_key
  pattern at 13 sites (imgcache x4, _shared.item_or_404, playback show/season,
  browse x6).
- Coverage: add TestFacetsWithData (the converted wsq aggregation with real
  data — the highest-risk untested builder), TestPlaylistAndCollectionEndpoints
  (playlist CRUD + collections list), and an item-state playback test.

Full suite 256 passed, 2 skipped; ruff clean.

backend/app/plex/imgcache.py

@@ -9,11 +9,11 @@ The cache directory (``cache.CACHE_DIR``) is shared with the subtitle cache (see
 """
 
 from fastapi import Response
-from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from app.models import PlexCollection, PlexItem, PlexSeason, PlexShow
 from app.plex.cache import CACHE_DIR
+from app.plex.lookups import by_rating_key
 
 _EXT_CT = [("jpg", "image/jpeg"), ("png", "image/png"), ("webp", "image/webp")]
 _CT_EXT = {ct: ext for ext, ct in _EXT_CT}
@@ -25,24 +25,16 @@ SIZES = {"thumb": (400, 600), "art": (1280, 720)}
 def key_for(db: Session, rating_key: str, variant: str) -> str | None:
     """The stored Plex image path for a known rating_key (item/show/season). Only mirrored keys
     are proxyable — this is not an open image proxy."""
-    it = db.execute(
-        select(PlexItem).where(PlexItem.rating_key == rating_key)
-    ).scalars().first()
+    it = by_rating_key(db, PlexItem, rating_key)
     if it is not None:
         return it.art_key if variant == "art" else it.thumb_key
-    sh = db.execute(
-        select(PlexShow).where(PlexShow.rating_key == rating_key)
-    ).scalars().first()
+    sh = by_rating_key(db, PlexShow, rating_key)
     if sh is not None:
         return sh.art_key if variant == "art" else sh.thumb_key
-    se = db.execute(
-        select(PlexSeason).where(PlexSeason.rating_key == rating_key)
-    ).scalars().first()
+    se = by_rating_key(db, PlexSeason, rating_key)
     if se is not None:
         return se.thumb_key
-    col = db.execute(
-        select(PlexCollection).where(PlexCollection.rating_key == rating_key)
-    ).scalars().first()
+    col = by_rating_key(db, PlexCollection, rating_key)
     if col is not None:
         return col.thumb_key
     return None

backend/app/plex/lookups.py

@@ -0,0 +1,11 @@
+"""Small shared Plex row lookups, so the get-by-rating_key pattern lives in one place."""
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+
+def by_rating_key(db: Session, model, rating_key: str):
+    """The mirrored row for a Plex rating_key, or None. `model` is any of the rating_key-keyed Plex
+    tables (PlexItem / PlexShow / PlexSeason / PlexCollection)."""
+    return db.execute(
+        select(model).where(model.rating_key == str(rating_key))
+    ).scalars().first()

backend/app/routes/plex/_shared.py

@@ -3,20 +3,18 @@
 import logging
 
 from fastapi import HTTPException
-from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from app.models import (
     PlexItem,
 )
+from app.plex.lookups import by_rating_key
 
 log = logging.getLogger("siftlode.plex")
 
 
 def item_or_404(db: Session, rating_key: str) -> PlexItem:
-    it = db.execute(
-        select(PlexItem).where(PlexItem.rating_key == str(rating_key))
-    ).scalars().first()
+    it = by_rating_key(db, PlexItem, rating_key)
     if it is None:
         raise HTTPException(status_code=404, detail="Unknown Plex item")
     return it

backend/app/routes/plex/browse.py

@@ -43,6 +43,7 @@ from app.plex import people as plex_people
 from app.plex import rollup, subtitles
 from app.plex import sync as plex_sync
 from app.plex.client import PlexClient, PlexError, PlexNotConfigured
+from app.plex.lookups import by_rating_key
 from app.routes._common import owned_or_404
 from app.routes.admin import admin_user
 from app.routes.feed import to_tsquery_str
@@ -738,9 +739,7 @@ def collections(
 
 
 def _editable_collection_or_403(db: Session, rating_key: str) -> PlexCollection:
-    col = db.execute(
-        select(PlexCollection).where(PlexCollection.rating_key == str(rating_key))
-    ).scalars().first()
+    col = by_rating_key(db, PlexCollection, rating_key)
     if col is None:
         raise HTTPException(status_code=404, detail="Unknown collection")
     if not _collection_editable(col):
@@ -882,9 +881,7 @@ def collection_set_editable(
 ) -> dict:
     """Mark an existing Plex collection as 'mine to edit' (or unmark). Smart / auto-list collections
     (IMDb/TMDb/…) can never be made editable — they're regenerated outside Plex."""
-    col = db.execute(
-        select(PlexCollection).where(PlexCollection.rating_key == str(rating_key))
-    ).scalars().first()
+    col = by_rating_key(db, PlexCollection, rating_key)
     if col is None:
         raise HTTPException(status_code=404, detail="Unknown collection")
     want = body.editable
@@ -1008,9 +1005,7 @@ def create_playlist(
     count = 0
     thumb_rk = None
     if seed:
-        it = db.execute(
-            select(PlexItem).where(PlexItem.rating_key == seed)
-        ).scalars().first()
+        it = by_rating_key(db, PlexItem, seed)
         if it is not None:
             db.add(PlexPlaylistItem(playlist_id=pl.id, item_id=it.id, position=0))
             count, thumb_rk = 1, it.rating_key
@@ -1105,9 +1100,7 @@ def playlist_add_item(
     db: Session = Depends(get_db),
 ) -> dict:
     pl = _own_playlist_or_404(db, pid, user)
-    it = db.execute(
-        select(PlexItem).where(PlexItem.rating_key == body.item_rating_key)
-    ).scalars().first()
+    it = by_rating_key(db, PlexItem, body.item_rating_key)
     if it is None:
         raise HTTPException(status_code=404, detail="Unknown item")
     exists = db.execute(
@@ -1137,9 +1130,7 @@ def playlist_remove_item(
     db: Session = Depends(get_db),
 ) -> dict:
     pl = _own_playlist_or_404(db, pid, user)
-    it = db.execute(
-        select(PlexItem).where(PlexItem.rating_key == str(item_rating_key))
-    ).scalars().first()
+    it = by_rating_key(db, PlexItem, item_rating_key)
     if it is not None:
         db.execute(
             delete(PlexPlaylistItem).where(
@@ -1237,7 +1228,8 @@ def playlist_remove_bulk(
         removed = db.execute(
             delete(PlexPlaylistItem).where(
                 PlexPlaylistItem.playlist_id == pid, PlexPlaylistItem.item_id.in_(ids)
-            )
+            ),
+            execution_options={"synchronize_session": False},
         ).rowcount
         if removed:
             pl.updated_at = datetime.now(timezone.utc)
@@ -1332,9 +1324,7 @@ def show_detail(
     db: Session = Depends(get_db),
 ) -> dict:
     """A show's seasons + episodes (the drill-down view) with per-user watch state."""
-    sh = db.execute(
-        select(PlexShow).where(PlexShow.rating_key == str(rating_key))
-    ).scalars().first()
+    sh = by_rating_key(db, PlexShow, rating_key)
     if sh is None:
         raise HTTPException(status_code=404, detail="Unknown Plex show")
     seasons = db.execute(
@@ -1633,18 +1623,16 @@ def _collection_strips(db: Session, it: PlexItem, user_id: int) -> list[dict]:
 def _episode_nav(db: Session, it: PlexItem) -> tuple[str | None, str | None]:
     if it.kind != "episode" or it.show_id is None:
         return None, None
-    keys = [
-        r[0]
-        for r in db.execute(
+    keys = list(
+        db.execute(
             select(PlexItem.rating_key)
             .where(PlexItem.show_id == it.show_id, PlexItem.kind == "episode")
             .order_by(
                 PlexItem.season_number.asc().nullsfirst(),
                 PlexItem.episode_number.asc().nullsfirst(),
             )
-        )
-        .all()
-    ]
+        ).scalars()
+    )
     try:
         i = keys.index(it.rating_key)
     except ValueError:

backend/app/routes/plex/playback.py

@@ -30,6 +30,7 @@ from app.models import (
 )
 from app.plex import imgcache, subtitles
 from app.plex import paths as plex_paths
+from app.plex.lookups import by_rating_key
 from app.plex import people as plex_people
 from app.plex import stream as plex_stream
 from app.plex import watch_sync as plex_watch
@@ -412,9 +413,7 @@ def show_state(
     db: Session = Depends(get_db),
 ) -> dict:
     """Mark a whole show watched/unwatched (all its episodes) for the current user + push to Plex."""
-    sh = db.execute(
-        select(PlexShow).where(PlexShow.rating_key == str(rating_key))
-    ).scalars().first()
+    sh = by_rating_key(db, PlexShow, rating_key)
     if sh is None:
         raise HTTPException(status_code=404, detail="Unknown Plex show")
     watched = body.watched
@@ -434,9 +433,7 @@ def season_state(
     db: Session = Depends(get_db),
 ) -> dict:
     """Mark a whole season watched/unwatched (all its episodes) for the current user + push to Plex."""
-    se = db.execute(
-        select(PlexSeason).where(PlexSeason.rating_key == str(rating_key))
-    ).scalars().first()
+    se = by_rating_key(db, PlexSeason, rating_key)
     if se is None:
         raise HTTPException(status_code=404, detail="Unknown Plex season")
     watched = body.watched