fix(build): drop the unused readMerged export so the publish gate passes

knip flagged src/lib/storage.ts readMerged as an unused export — its only
caller is readAccountMerged in the same module, so it doesn't need to be
exported. This aborted the 0.72.0 publish gate after the merge; no behaviour
change.

VERSION

@@ -1 +1 @@
-0.69.1
+0.72.0

backend/alembic/versions/0071_plex_tmdb_fields.py

@@ -0,0 +1,52 @@
+"""plex TMDB enrichment columns (E5 S2)
+
+Additive TMDB-sourced fields on plex_items + plex_shows — keywords, full crew, budget/revenue, TMDb
+community score, production companies/countries, recommendations, and a backdrop-path pool — plus a
+`tmdb_id` cache and a `tmdb_enriched_at` watermark. Filled by the new TMDB enrichment job (matched by
+the stored canonical `guid`), SERVED FROM THE ROW (never a live TMDB call). Distinct from the existing
+Plex-sourced `imdb_rating`/`rating`, which are left untouched. Plus `plex_people.tmdb_person_id` (the S2
+foundation for S6's person bios). ADD-only, all nullable → no table rewrite, no ACCESS EXCLUSIVE lock.
+No watermark reset needed: `tmdb_enriched_at` starts NULL, so every eligible row is picked up once.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "0071_plex_tmdb_fields"
+down_revision: Union[str, None] = "0070_fold_maintenance_batch"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+_TABLES = ("plex_items", "plex_shows")
+
+# (name, type) — same set on both movie/leaf rows and show rows. budget/revenue stay NULL for shows.
+_COLS: tuple[tuple[str, sa.types.TypeEngine], ...] = (
+    ("tmdb_id", sa.Integer()),
+    ("tmdb_enriched_at", sa.DateTime(timezone=True)),
+    ("tmdb_rating", sa.Float()),
+    ("tmdb_vote_count", sa.Integer()),
+    ("budget", sa.BigInteger()),
+    ("revenue", sa.BigInteger()),
+    ("keywords", postgresql.JSONB()),
+    ("crew", postgresql.JSONB()),
+    ("studios", postgresql.JSONB()),
+    ("production_countries", postgresql.JSONB()),
+    ("recommendations", postgresql.JSONB()),
+    ("backdrops", postgresql.JSONB()),
+)
+
+
+def upgrade() -> None:
+    for t in _TABLES:
+        for name, type_ in _COLS:
+            op.add_column(t, sa.Column(name, type_, nullable=True))
+    op.add_column("plex_people", sa.Column("tmdb_person_id", sa.Integer(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("plex_people", "tmdb_person_id")
+    for t in _TABLES:
+        for name, _ in reversed(_COLS):
+            op.drop_column(t, name)

backend/alembic/versions/0072_plex_person_bio.py

@@ -0,0 +1,40 @@
+"""plex person TMDB bio columns (E5 S6)
+
+Additive TMDB-sourced person fields on plex_people — biography, birth/death dates, place of birth,
+known-for department, also-known-as, and a `known_for` credit pool ([{tmdb_id, media_type, title}]
+resolved to library rows by guid at serve time) — plus a `tmdb_enriched_at` watermark. Filled the
+first time a person page is opened (from /person/{tmdb_person_id}), then SERVED FROM THE ROW. The
+`tmdb_person_id` link itself already exists (0071). ADD-only, all nullable → no table rewrite, no
+ACCESS EXCLUSIVE lock. `tmdb_enriched_at` starts NULL, so every person is enriched once on first view.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "0072_plex_person_bio"
+down_revision: Union[str, None] = "0071_plex_tmdb_fields"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+_COLS: tuple[tuple[str, sa.types.TypeEngine], ...] = (
+    ("biography", sa.Text()),
+    ("birthday", sa.String(length=10)),
+    ("deathday", sa.String(length=10)),
+    ("place_of_birth", sa.Text()),
+    ("known_for_department", sa.String(length=64)),
+    ("also_known_as", postgresql.JSONB()),
+    ("known_for", postgresql.JSONB()),
+    ("tmdb_enriched_at", sa.DateTime(timezone=True)),
+)
+
+
+def upgrade() -> None:
+    for name, type_ in _COLS:
+        op.add_column("plex_people", sa.Column(name, type_, nullable=True))
+
+
+def downgrade() -> None:
+    for name, _ in reversed(_COLS):
+        op.drop_column("plex_people", name)

backend/alembic/versions/0073_saved_view_source.py

@@ -0,0 +1,39 @@
+"""saved_views.source (ask 4: per-module saved views)
+
+Saved "smart views" were feed-only; the Plex module now has them too. Add a `source` discriminator
+(default "feed" so every existing row stays a feed view) and widen the per-user unique name constraint
+to (user_id, source, name) so a feed view and a Plex view can share a name. `source` is NOT NULL with a
+server_default, so the ADD is a metadata-only rewrite-free change; the constraint swap is quick on a
+small per-user table.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0073_saved_view_source"
+down_revision: Union[str, None] = "0072_plex_person_bio"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "saved_views",
+        sa.Column("source", sa.String(length=16), nullable=False, server_default="feed"),
+    )
+    op.drop_constraint("uq_user_saved_view", "saved_views", type_="unique")
+    op.create_unique_constraint(
+        "uq_user_source_saved_view", "saved_views", ["user_id", "source", "name"]
+    )
+
+
+def downgrade() -> None:
+    # LOSSY / effectively forward-only: upgrade lets a user hold a feed view and a plex view of the same
+    # name, so re-creating the narrow (user_id, name) constraint can raise IntegrityError on such a pair.
+    # De-dup by dropping the non-feed rows first (they can't exist in the pre-0073 schema anyway) so the
+    # narrow constraint re-applies cleanly for the drift test's downgrade→re-upgrade cycle.
+    op.execute("DELETE FROM saved_views WHERE source <> 'feed'")
+    op.drop_constraint("uq_user_source_saved_view", "saved_views", type_="unique")
+    op.create_unique_constraint("uq_user_saved_view", "saved_views", ["user_id", "name"])
+    op.drop_column("saved_views", "source")

backend/app/config.py

@@ -245,6 +245,20 @@ class Settings(BaseSettings):
     # local disk, so the default is fine there.
     plex_hls_dir: str = ""
 
+    # --- TMDB enrichment (E5 S2; optional — enriches the Plex catalog from TMDB) ---
+    # TMDB API key (v3 api_key, 32 hex chars). Server-side only; stored encrypted when set via the
+    # admin Config page. Empty → the TMDB enrichment job no-ops. Feeds keywords / crew / budget /
+    # revenue / TMDb score / recommendations / backdrops onto the mirrored Plex rows, matched by the
+    # stored canonical guid, and SERVED FROM THE DB — never a live TMDB call at serve time.
+    tmdb_api_key: str = ""
+    tmdb_api_base: str = "https://api.themoviedb.org/3"
+    # Metadata language for TMDB fetches (keyword/overview locale). Stored EN by default.
+    tmdb_language: str = "en-US"
+    # How often the TMDB enrichment job fetches a batch of not-yet-enriched Plex titles, in minutes.
+    tmdb_enrich_interval_min: int = 120
+    # Titles fetched per TMDB enrichment run (TMDB is fast + generously rate-limited).
+    tmdb_enrich_batch: int = 100
+
     @property
     def allowed_email_set(self) -> set[str]:
         return {e.strip().lower() for e in self.allowed_emails.split(",") if e.strip()}

backend/app/feedquery.py

@@ -117,7 +117,7 @@ def filtered_query(
     user: User,
     *,
     tags: list[int],
-    tag_mode: str,
+    tag_modes: dict[str, str],
     channel_ids: list[str],
     q: str | None,
     min_duration: int | None,
@@ -293,9 +293,10 @@ def filtered_query(
             query = query.where(or_(func.unaccent(Video.title).ilike(like), channel_match))
 
     if tags:
-        # AND across tag categories (e.g. language AND topic narrows), OR within a category; the any/all
-        # toggle controls multiple topic tags. ⚠️ feed_summary.passes() reimplements this exact rule in
-        # Python for the sidebar count/facets — keep the two in lockstep (equivalence-tested by
+        # AND across tag categories (e.g. language AND topic narrows), OR within a category — unless that
+        # category's mode is "and" (its per-category any/all toggle), which requires a channel to carry
+        # ALL its selected tags. ⚠️ feed_summary.passes() reimplements this exact rule in Python for the
+        # sidebar count/facets — keep the two in lockstep (equivalence-tested by
         # test_feed_summary_matches_count_plus_facets).
         by_category = tags_by_category(db, tags)
         # Facet counting drops the category being counted so its own chips don't zero each
@@ -305,7 +306,7 @@ def filtered_query(
             by_category.pop(exclude_tag_category, None)
         visible = or_(ChannelTag.user_id.is_(None), ChannelTag.user_id == user.id)
         for category, ids in by_category.items():
-            if category == "topic" and tag_mode == "and" and len(ids) > 1:
+            if tag_modes.get(category, "or") == "and" and len(ids) > 1:
                 sub = (
                     select(ChannelTag.channel_id)
                     .where(ChannelTag.tag_id.in_(ids), visible)
@@ -363,8 +364,8 @@ def feed_summary(db: Session, user: User, **params) -> dict:
                  (the tag's own category dropped, unless it's a conjunctive topic-AND — mirroring the
                  old /facets exclude_tag_category logic exactly).
     Tag matching is channel-based, identical to filtered_query's tag block (AND across categories, OR
-    within, topic-AND requires ALL selected topics)."""
-    tag_mode = params.get("tag_mode", "or")
+    within, a category in "and" mode requires ALL its selected tags)."""
+    tag_modes = params.get("tag_modes", {})
 
     # ONE pass: per-channel video counts for the base filter, tags stripped so every candidate channel
     # is present to facet over.
@@ -401,8 +402,8 @@ def feed_summary(db: Session, user: User, **params) -> dict:
         for cat, sel in selected_by_cat.items():
             if cat == exclude_cat:
                 continue
-            if cat == "topic" and tag_mode == "and" and len(sel) > 1:
-                if not sel <= ch_tags:  # conjunctive: channel must carry ALL selected topics
+            if tag_modes.get(cat, "or") == "and" and len(sel) > 1:
+                if not sel <= ch_tags:  # conjunctive: channel must carry ALL this category's selected tags
                     return False
             elif not (sel & ch_tags):  # disjunctive: channel must carry ANY selected tag
                 return False
@@ -416,7 +417,7 @@ def feed_summary(db: Session, user: User, **params) -> dict:
     for category in ("language", "topic", "other"):
         # Drop this category's own selections so its chips keep independent counts; a conjunctive
         # topic-AND keeps them (each remaining chip narrows to channels that ALSO have the selected).
-        exclude = None if (category == "topic" and tag_mode == "and") else category
+        exclude = None if tag_modes.get(category, "or") == "and" else category
         for cid, ch_tags in channel_tags.items():
             if not passes(ch_tags, exclude):
                 continue

backend/app/models.py

@@ -646,19 +646,23 @@ class PlaylistItem(Base):
 
 
 class SavedView(Base, TimestampMixin, UpdatedAtMixin):
-    """A per-user named snapshot of the feed's filter/sort state (a "smart view").
+    """A per-user named snapshot of a module's filter/sort state (a "smart view").
 
-    `filters` is the serialized FeedFilters JSON the frontend applies with one click.
-    `position` orders them in the sidebar (drag-reorder); `is_default` marks the one view
-    applied automatically on load — at most one per user, enforced by the API on set."""
+    `source` names the module the view belongs to ("feed" | "plex"); `filters` is that module's
+    serialized filter JSON the frontend applies with one click. `position` orders them in the sidebar
+    (drag-reorder, per source); `is_default` marks the one view applied automatically on load — at most
+    one per (user, source), enforced by the API on set. The name is unique per (user, source)."""
 
     __tablename__ = "saved_views"
-    __table_args__ = (UniqueConstraint("user_id", "name", name="uq_user_saved_view"),)
+    __table_args__ = (
+        UniqueConstraint("user_id", "source", "name", name="uq_user_source_saved_view"),
+    )
 
     id: Mapped[int] = mapped_column(primary_key=True)
     user_id: Mapped[int] = mapped_column(
         ForeignKey("users.id", ondelete="CASCADE")
     )
+    source: Mapped[str] = mapped_column(String(16), default="feed", server_default="feed")
     name: Mapped[str] = mapped_column(String(80))
     filters: Mapped[dict] = mapped_column(JSON)
     position: Mapped[int] = mapped_column(Integer, default=0, server_default="0")
@@ -1067,6 +1071,20 @@ class PlexShow(Base, TimestampMixin, UpdatedAtMixin):
     imdb_id: Mapped[str | None] = mapped_column(String(16))  # tt… → the clickable IMDb link
     tagline: Mapped[str | None] = mapped_column(Text)
     full_cast: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # ordered [{name, role, thumb}]
+    # --- TMDB enrichment (E5 S2): see the identical block on plex_items for the full rationale. Additive;
+    #     served from the row; NULL until enriched. (`budget`/`revenue` stay NULL for shows — TV has none.) ---
+    tmdb_id: Mapped[int | None] = mapped_column(Integer)
+    tmdb_enriched_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    tmdb_rating: Mapped[float | None] = mapped_column(Float)  # TMDb vote_average (0–10)
+    tmdb_vote_count: Mapped[int | None] = mapped_column(Integer)
+    budget: Mapped[int | None] = mapped_column(BigInteger)
+    revenue: Mapped[int | None] = mapped_column(BigInteger)
+    keywords: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [str]
+    crew: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [{name, job, tmdb_id, thumb}]
+    studios: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # TMDB production companies [str]
+    production_countries: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [str]
+    recommendations: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))
+    backdrops: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))
     # Hungarian-metadata twin fields, written by the overlay sync (E5 S5). NULL = no HU twin matched,
     # so serving falls back to the EN columns. `people_text` is language-neutral, reused for both vectors.
     title_hu: Mapped[str | None] = mapped_column(String(512))
@@ -1184,6 +1202,24 @@ class PlexItem(Base, TimestampMixin, UpdatedAtMixin):
     imdb_id: Mapped[str | None] = mapped_column(String(16))  # tt… → the clickable IMDb link
     tagline: Mapped[str | None] = mapped_column(Text)
     full_cast: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # ordered [{name, role, thumb}]
+    # --- TMDB enrichment (E5 S2): matched by the canonical `guid` ("tmdb:12345"), filled by the TMDB
+    #     backfill job, SERVED FROM THIS ROW (never a live TMDB call). Additive — imdb_rating/rating
+    #     above stay Plex-sourced; `tmdb_rating` is the distinct TMDb community score. NULL until enriched;
+    #     `tmdb_enriched_at` is the "tried" watermark (stamped on a definitive no-match too, so an
+    #     unresolvable title isn't re-fetched every run; left NULL only on a transient fetch error). ---
+    tmdb_id: Mapped[int | None] = mapped_column(Integer)
+    tmdb_enriched_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    tmdb_rating: Mapped[float | None] = mapped_column(Float)  # TMDb vote_average (0–10)
+    tmdb_vote_count: Mapped[int | None] = mapped_column(Integer)
+    budget: Mapped[int | None] = mapped_column(BigInteger)  # USD (movies; TV has none)
+    revenue: Mapped[int | None] = mapped_column(BigInteger)
+    keywords: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [str]
+    crew: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [{name, job, tmdb_id, thumb}]
+    studios: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # TMDB production companies [str]
+    production_countries: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [str]
+    # [{tmdb_id, title, poster, media_type}] — resolved to library rows (by guid) at serve time.
+    recommendations: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))
+    backdrops: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # TMDB backdrop file_paths [str] (crossfade pool, S8)
     # Hungarian-metadata twin fields, written by the overlay sync (E5 S5). NULL = no HU twin matched
     # (serving falls back to the EN columns). `people_text` is language-neutral, reused for both vectors.
     title_hu: Mapped[str | None] = mapped_column(String(512))
@@ -1224,6 +1260,21 @@ class PlexPerson(Base, TimestampMixin, UpdatedAtMixin):
     id: Mapped[int] = mapped_column(primary_key=True)
     name: Mapped[str] = mapped_column(String(255), unique=True, index=True)
     photo_thumb: Mapped[str | None] = mapped_column(Text)  # proxied /person-image URL, or None
+    # TMDB person id, linked by name from a title's TMDB credits (E5 S2 lays the foundation; the /person
+    # biography fetch + person-page render land in S6). NULL until a TMDB-enriched title names this person.
+    tmdb_person_id: Mapped[int | None] = mapped_column(Integer)
+    # --- TMDB person enrichment (E5 S6): fetched from /person/{tmdb_person_id} the first time the person
+    #     page is opened, then SERVED FROM THE ROW. `tmdb_enriched_at` is the watermark (set even on a
+    #     no-op fetch so it isn't retried every open). `known_for` = top combined-credits [{tmdb_id,
+    #     media_type, title}], resolved to library rows by guid at serve time (like recommendations). ---
+    biography: Mapped[str | None] = mapped_column(Text)
+    birthday: Mapped[str | None] = mapped_column(String(10))  # "YYYY-MM-DD", served as-is
+    deathday: Mapped[str | None] = mapped_column(String(10))
+    place_of_birth: Mapped[str | None] = mapped_column(Text)
+    known_for_department: Mapped[str | None] = mapped_column(String(64))
+    also_known_as: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [str]
+    known_for: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [{tmdb_id, media_type, title}]
+    tmdb_enriched_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
 
 
 class PlexCollection(Base, TimestampMixin, UpdatedAtMixin):

backend/app/plex/cards.py

@@ -6,14 +6,32 @@ router. Pure functions — no DB, no request state."""
 from app.models import PlexItem, PlexShow, PlexState
 
 
+# A card's wide backdrop, for a rail's landscape tile or a crossfading hero — but ONLY when the item
+# actually has art. `thumb` is always emitted (its endpoint placeholders a missing poster), but an
+# `art` URL for an item with no `art_key` would resolve to a broken/blank image on every card that
+# tried to use it, so gate it on the stored key and let the client fall back to the poster.
+def _art_url(rating_key: str, art_key: str | None) -> str | None:
+    return f"/api/plex/image/{rating_key}?variant=art" if art_key else None
+
+
+# Card hover-overview: a short synopsis for the reveal panel, trimmed so a strip/related row of cards
+# stays a few hundred bytes each rather than carrying full synopses. (These non-grid card paths serve
+# the EN summary/rating; the main grid coalesces the HU twin in browse.unified_library.)
+def _card_summary(summary: str | None) -> str | None:
+    return (summary or "")[:300] or None
+
+
 def movie_card(it: PlexItem, st: PlexState | None) -> dict:
     return {
         "id": it.rating_key,
         "type": "movie",
         "title": it.title,
         "year": it.year,
+        "rating": it.rating,
+        "summary": _card_summary(it.summary),
         "duration_seconds": it.duration_s,
         "thumb": f"/api/plex/image/{it.rating_key}",
+        "art": _art_url(it.rating_key, it.art_key),
         "playable": it.playable,
         "status": st.status if st else "new",
         "position_seconds": st.position_seconds if st else 0,
@@ -26,7 +44,10 @@ def show_card(sh: PlexShow, status: str = "new") -> dict:
         "type": "show",
         "title": sh.title,
         "year": sh.year,
+        "rating": sh.rating,
+        "summary": _card_summary(sh.summary),
         "thumb": f"/api/plex/image/{sh.rating_key}",
+        "art": _art_url(sh.rating_key, sh.art_key),
         "season_count": sh.child_count,
         # Aggregate watch-state across the show's episodes (new | in_progress | watched) → grid badge.
         "status": status,

backend/app/plex/query.py

@@ -6,7 +6,7 @@ Pure query fragments — every function returns SQLAlchemy expressions or a para
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 
-from sqlalchemy import and_, case, func, or_, type_coerce
+from sqlalchemy import and_, case, func, or_, select, type_coerce
 from sqlalchemy.dialects.postgresql import JSONB
 
 TS_CONFIG = "public.unaccent_simple"
@@ -29,6 +29,11 @@ def title_col(model, lang: str):
     return func.coalesce(model.title_hu, model.title) if lang == "hu" else model.title
 
 
+def summary_col(model, lang: str):
+    """DISPLAY summary, HU-coalesced (EN fallback) — the card hover-overview + info page read this."""
+    return func.coalesce(model.summary_hu, model.summary) if lang == "hu" else model.summary
+
+
 def genres_col(model, lang: str):
     # type_coerce so the JSONB comparator (`.contains` / `@>`, GIN-backed) survives the coalesce.
     if lang == "hu":
@@ -36,6 +41,58 @@ def genres_col(model, lang: str):
     return model.genres
 
 
+def top_art_keys(
+    db, model, lib_ids: list[int], key_col, keys: list[str], *, per: int = 4, extra_conds=()
+) -> dict[str, list[str]]:
+    """For each value in `keys` (a member of the JSONB array `key_col` — e.g. a genre value or a
+    collection rating_key), the rating_keys of its top `per` items (best-rated, then most-recent) as
+    {key: [rating_key, …]}. ONE windowed query: unnest the array, rank within each key, take the top.
+    The caller renders posters from /api/plex/image/{rating_key}, so only the keys are returned."""
+    if not lib_ids or not keys:
+        return {}
+    k = func.jsonb_array_elements_text(key_col).label("k")
+    expanded = (
+        select(model.rating_key.label("rk"), model.rating.label("r"), model.added_at.label("a"), k)
+        .where(model.library_id.in_(lib_ids), func.jsonb_typeof(key_col) == "array", *extra_conds)
+        .subquery()
+    )
+    ranked = select(
+        expanded.c.rk,
+        expanded.c.k,
+        func.row_number()
+        .over(
+            partition_by=expanded.c.k,
+            order_by=(expanded.c.r.desc().nullslast(), expanded.c.a.desc().nullslast()),
+        )
+        .label("rn"),
+    ).subquery()
+    out: dict[str, list[str]] = {}
+    for rk, key in db.execute(
+        select(ranked.c.rk, ranked.c.k)
+        .where(ranked.c.k.in_(keys), ranked.c.rn <= per)
+        .order_by(ranked.c.k, ranked.c.rn)
+    ).all():
+        out.setdefault(key, []).append(rk)
+    return out
+
+
+def runtime_by_key(db, model, lib_ids: list[int], key_col, keys: list[str]) -> dict[str, int]:
+    """Total runtime (sum of duration_s, seconds) of the items under each key in `keys` (a member of the
+    JSONB array `key_col`), as {key: seconds}. ONE grouped query. Used for a collection tile's runtime."""
+    if not lib_ids or not keys:
+        return {}
+    k = func.jsonb_array_elements_text(key_col).label("k")
+    exp = (
+        select(func.coalesce(model.duration_s, 0).label("d"), k)
+        .where(model.library_id.in_(lib_ids), func.jsonb_typeof(key_col) == "array")
+        .subquery()
+    )
+    rows = db.execute(
+        select(exp.c.k, func.sum(exp.c.d)).where(exp.c.k.in_(keys)).group_by(exp.c.k)
+    ).all()
+    return {key: int(total or 0) for key, total in rows}
+
+
 def vector_col(model, lang: str):
     # RANKING vector. In HU we rank by the Hungarian vector; a row matched only via its English vector
     # (see `vector_match`) gets rank 0 and sorts last, which is the intended HU-first ordering.
@@ -135,8 +192,12 @@ def meta_filter_conds(model, p: dict, lang: str = "en") -> list:
     stds = split_csv(p.get("studios"))
     if stds:  # OR
         conds.append(model.studio.in_(stds))
-    if p.get("collection"):
-        conds.append(model.collection_keys.contains([p["collection"]]))
+    for kw in split_csv(p.get("keywords")):  # AND — TMDB keyword chips from the detail page (E5 S5)
+        conds.append(model.keywords.contains([kw]))
+    csel = split_csv(p.get("collections"))
+    if csel:  # OR (any) or AND (all) — a title can belong to several collections, mirroring genre_mode
+        cc = [model.collection_keys.contains([c]) for c in csel]
+        conds.append(and_(*cc) if p.get("collection_mode") == "all" else or_(*cc))
     return conds
 
 
@@ -166,7 +227,9 @@ class LibraryFilters:
         "any"  # how multiple actors combine: any (OR, default) | all (AND)
     )
     studios: str | None = None
-    collection: str | None = None
+    keywords: str | None = None  # TMDB keyword chips (E5 S5), CSV; language-neutral
+    collections: str | None = None  # CSV of collection rating_keys
+    collection_mode: str = "any"  # how multiple collections combine: any (OR, default) | all (AND)
 
     def as_dict(self) -> dict:
         return {
@@ -183,7 +246,9 @@ class LibraryFilters:
             "actors": self.actors,
             "actor_mode": self.actor_mode,
             "studios": self.studios,
-            "collection": self.collection,
+            "keywords": self.keywords,
+            "collections": self.collections,
+            "collection_mode": self.collection_mode,
         }
 
 

backend/app/plex/rollup.py

@@ -42,27 +42,32 @@ def rollup(cards: list[dict]) -> dict:
     }
 
 
-def agg_subquery(db: Session, user_id: int):
+def agg_subquery(db: Session, user_id: int, include_resumed: bool = False):
     """Per-show episode counts for a user: total, watched, in-progress. Reused to (a) filter the show
-    grid by aggregate watch-state and (b) compute each card's badge."""
+    grid by aggregate watch-state, (b) compute each card's badge, and (c) drive the Discover
+    continue-watching rail. `include_resumed` adds `resumed_at` = max(progress_updated_at) across the
+    show's episodes, so the rail can order shows by how recently they were last progressed."""
     ps = aliased(PlexState)
-    return (
-        select(
-            PlexItem.show_id.label("show_id"),
-            func.count(PlexItem.id).label("total"),
-            func.count(case((ps.status == "watched", 1))).label("watched"),
-            func.count(
-                case(
-                    (
-                        and_(
-                            ps.position_seconds > 0,
-                            or_(ps.status.is_(None), ps.status != "watched"),
-                        ),
-                        1,
-                    )
+    cols = [
+        PlexItem.show_id.label("show_id"),
+        func.count(PlexItem.id).label("total"),
+        func.count(case((ps.status == "watched", 1))).label("watched"),
+        func.count(
+            case(
+                (
+                    and_(
+                        ps.position_seconds > 0,
+                        or_(ps.status.is_(None), ps.status != "watched"),
+                    ),
+                    1,
                 )
-            ).label("inprog"),
-        )
+            )
+        ).label("inprog"),
+    ]
+    if include_resumed:
+        cols.append(func.max(ps.progress_updated_at).label("resumed_at"))
+    return (
+        select(*cols)
         .outerjoin(ps, and_(ps.item_id == PlexItem.id, ps.user_id == user_id))
         .where(PlexItem.kind == "episode", PlexItem.show_id.isnot(None))
         .group_by(PlexItem.show_id)
@@ -76,3 +81,21 @@ def state_map(db: Session, user_id: int, show_ids: list[int]) -> dict[int, str]:
         agg_subquery(db, user_id).where(PlexItem.show_id.in_(show_ids))
     ).all()
     return {r.show_id: show_status(r.total, r.watched, r.inprog) for r in rows}
+
+
+def item_state_map(
+    db: Session, user_id: int, item_ids: list[int]
+) -> dict[int, PlexState]:
+    """A user's PlexState rows for a set of leaf items (movies or episodes), keyed by item_id — the
+    leaf analogue of `state_map` (which rolls a show's episodes up to a status string). One batched
+    fetch, so the caller serializes cards without a per-card query. Empty in → empty dict (no `IN ()`)."""
+    if not item_ids:
+        return {}
+    return {
+        s.item_id: s
+        for s in db.execute(
+            select(PlexState).where(
+                PlexState.user_id == user_id, PlexState.item_id.in_(item_ids)
+            )
+        ).scalars()
+    }

backend/app/plex/tmdb.py

@@ -0,0 +1,492 @@
+"""TMDB enrichment for the mirrored Plex catalog (E5 S2).
+
+A thin synchronous TMDB v3 client plus the parse/persist of the enrichment fields onto plex_items /
+plex_shows, matched by the stored canonical `guid` ("tmdb:12345", or imdb/tvdb resolved via /find).
+Server-side ONLY (the api_key from sysconfig). Everything fetched is PERSISTED and served from the DB
+row — there is never a live TMDB call at serve time (the user's explicit rule). Additive: the existing
+Plex-sourced `imdb_rating` / `rating` are left untouched; `tmdb_rating` is the distinct TMDb score.
+
+One-parser rule (mirrors app/plex/detail.py): `parse_tmdb` is the pure parser, `apply_tmdb_detail` writes
+the row. The enrich batch + scheduler entry live here too so the whole TMDB integration is one module.
+"""
+import logging
+import time
+from datetime import datetime, timezone
+
+import httpx
+from sqlalchemy import func, select
+from sqlalchemy.dialects.postgresql import insert as pg_insert
+from sqlalchemy.orm import Session
+
+from app import sysconfig
+from app.config import settings
+from app.models import PlexItem, PlexPerson, PlexShow
+
+log = logging.getLogger("siftlode.tmdb")
+
+# Politeness throttle: TMDB tolerates ~50 req/s; ~33/s leaves comfortable headroom for a shared host.
+_MIN_INTERVAL = 0.03
+
+# The crew jobs worth surfacing on an info page, in DISPLAY-priority order (the stored crew is sorted by
+# this — TMDB's own crew order is arbitrary and buries the lead roles). MOVIE and TV differ on purpose:
+# on a TV show `Director`/`Editor`/`Director of Photography` are PER-EPISODE credits (dozens of names
+# that would flood the list and bury the showrunner), so TV keys on `Creator` (from the payload's
+# top-level `created_by`, not the crew list) + the show-level producers/writers instead.
+_MOVIE_CREW_JOBS = (
+    "Director",
+    "Writer",
+    "Screenplay",
+    "Story",
+    "Producer",
+    "Executive Producer",
+    "Editor",
+    "Director of Photography",
+    "Original Music Composer",
+)
+_TV_CREW_JOBS = ("Creator", "Executive Producer", "Writer", "Producer", "Original Music Composer")
+_MOVIE_PRIORITY = {job: i for i, job in enumerate(_MOVIE_CREW_JOBS)}
+_TV_PRIORITY = {job: i for i, job in enumerate(_TV_CREW_JOBS)}
+
+# append_to_response bundles the sub-resources into ONE request per title (keywords + credits +
+# recommendations + images + external ids). TV uses aggregate_credits (per-person aggregated jobs).
+_MOVIE_APPEND = "keywords,credits,recommendations,images,external_ids"
+_TV_APPEND = "keywords,aggregate_credits,recommendations,images,external_ids"
+
+
+class TmdbError(Exception):
+    """Any transient failure talking to TMDB (network, non-404 HTTP, bad payload). The caller leaves
+    the row's `tmdb_enriched_at` NULL so the next run retries."""
+
+
+class TmdbNotConfigured(TmdbError):
+    """No TMDB API key is set — the module can't do anything."""
+
+
+class TmdbClient:
+    """Bound to the configured api_key + language. Use as a context manager so the httpx client closes."""
+
+    def __init__(self, db: Session, timeout: float = 30.0):
+        self.key = sysconfig.get_str(db, "tmdb_api_key")
+        if not self.key:
+            raise TmdbNotConfigured("TMDB API key is not configured")
+        self.base = settings.tmdb_api_base.rstrip("/")
+        self.language = sysconfig.get_str(db, "tmdb_language") or settings.tmdb_language
+        # `timeout` is caller-tunable so the request-path lazy person enrich can cap how long it may
+        # block a worker thread (the batch job keeps the generous default).
+        self._http = httpx.Client(timeout=timeout)
+        self._last = 0.0
+
+    def __enter__(self) -> "TmdbClient":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self._http.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _throttle(self) -> None:
+        wait = self._last + _MIN_INTERVAL - time.monotonic()
+        if wait > 0:
+            time.sleep(wait)
+        self._last = time.monotonic()
+
+    def _get(self, path: str, params: dict | None = None) -> dict | None:
+        """GET a TMDB path. Returns the JSON dict, None on a 404 (a definitive "no such id"), and raises
+        TmdbError on any transient failure (network / other HTTP status / non-JSON)."""
+        self._throttle()
+        p = {"api_key": self.key, "language": self.language, **(params or {})}
+        try:
+            r = self._http.get(f"{self.base}{path}", params=p)
+        except httpx.HTTPError as e:
+            # NEVER put str(e)/the URL in the message: the request URL carries `?api_key=<secret>` in
+            # its query string, and this message is logged (enrich_batch). Report the type + path only.
+            raise TmdbError(f"TMDB request error on {path}: {type(e).__name__}") from None
+        if r.status_code == 404:
+            return None
+        try:
+            r.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            # Same reason: the HTTPStatusError string embeds the full URL incl. the api_key. Sever the
+            # cause (`from None`) so no traceback can resurface it, and log only status + path.
+            raise TmdbError(f"TMDB {path} returned {e.response.status_code}") from None
+        try:
+            return r.json()
+        except ValueError as e:
+            raise TmdbError("TMDB returned a non-JSON response") from e
+
+    def fetch(self, tmdb_id: int, media_type: str) -> dict | None:
+        """Full enrichment payload for a movie or show (one request via append_to_response)."""
+        if media_type == "tv":
+            return self._get(f"/tv/{tmdb_id}", {"append_to_response": _TV_APPEND})
+        return self._get(f"/movie/{tmdb_id}", {"append_to_response": _MOVIE_APPEND})
+
+    def find(self, external_id: str, source: str) -> dict | None:
+        """Resolve an external id (imdb_id / tvdb_id) to TMDB items via /find."""
+        return self._get(f"/find/{external_id}", {"external_source": source})
+
+    def fetch_person(self, person_id: int) -> dict | None:
+        """One person's bio + combined credits (E5 S6), in a single append_to_response request."""
+        return self._get(f"/person/{person_id}", {"append_to_response": "combined_credits"})
+
+
+def guid_to_tmdb_id(guid: str | None, media_type: str, tmdb: TmdbClient) -> int | None:
+    """Map a stored canonical guid to a TMDB id. `tmdb:` is direct; `imdb:`/`tvdb:` go through /find
+    (picking the movie_results or tv_results list per `media_type`). Returns None for an unmatchable
+    guid — the caller then stamps the watermark so it isn't retried every run."""
+    if not guid or ":" not in guid:
+        return None
+    provider, _, ext = guid.partition(":")
+    if provider == "tmdb":
+        try:
+            return int(ext)
+        except ValueError:
+            return None
+    source = {"imdb": "imdb_id", "tvdb": "tvdb_id"}.get(provider)
+    if not source:
+        return None
+    res = tmdb.find(ext, source)
+    if not res:
+        return None
+    items = res.get("tv_results" if media_type == "tv" else "movie_results") or []
+    return items[0].get("id") if items else None
+
+
+def _dedup_crew(crew: list[dict]) -> list[dict]:
+    seen: set[tuple] = set()
+    out: list[dict] = []
+    for c in crew:
+        key = (c["name"], c["job"])
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(c)
+    return out
+
+
+def parse_tmdb(payload: dict, media_type: str) -> dict:
+    """Pure parser: pull the enrichment fields out of a TMDB movie/tv payload (append_to_response form).
+    Best-effort — any missing sub-resource is just omitted. Returns the row fields plus a `people` list
+    ([{name, tmdb_id}] over cast+crew) for the plex_people id-linking. TMDB image fields are stored as
+    bare paths ("/abc.jpg"); the client builds the image.tmdb.org URL."""
+    is_tv = media_type == "tv"
+    votes = payload.get("vote_count") or 0
+
+    kw_container = payload.get("keywords") or {}
+    kw_list = kw_container.get("results") if is_tv else kw_container.get("keywords")
+    keywords = [k.get("name") for k in (kw_list or []) if k.get("name")][:20]
+
+    priority = _TV_PRIORITY if is_tv else _MOVIE_PRIORITY
+    credits = payload.get("aggregate_credits" if is_tv else "credits") or {}
+    crew: list[dict] = []
+    # A TV show's creators live at the top level (created_by), not in the crew list — surface them.
+    if is_tv:
+        for c in payload.get("created_by") or []:
+            if c.get("name"):
+                crew.append(
+                    {"name": c["name"], "job": "Creator", "tmdb_id": c.get("id"), "profile_path": c.get("profile_path")}
+                )
+    for c in credits.get("crew") or []:
+        # Movie crew entries carry `job`; TV aggregate_credits carry a `jobs` array per person.
+        job = (c.get("jobs") or [{}])[0].get("job") if is_tv else c.get("job")
+        if job in priority and c.get("name"):
+            crew.append(
+                {"name": c["name"], "job": job, "tmdb_id": c.get("id"), "profile_path": c.get("profile_path")}
+            )
+    # Dedup by (name, job) — a person can hold two distinct key roles (Coppola: Director + Writer) — then
+    # order by display priority so the lead roles come first, and cap.
+    crew = _dedup_crew(crew)
+    crew.sort(key=lambda c: priority.get(c["job"], 99))
+    crew = crew[:12]
+
+    # name -> tmdb person id, for the plex_people foundation (S6 fetches bios off these ids).
+    people: list[dict] = []
+    for c in (credits.get("cast") or [])[:30]:
+        if c.get("name") and c.get("id"):
+            people.append({"name": c["name"], "tmdb_id": c["id"]})
+    for c in crew:
+        if c.get("tmdb_id"):
+            people.append({"name": c["name"], "tmdb_id": c["tmdb_id"]})
+
+    recs: list[dict] = []
+    for r in ((payload.get("recommendations") or {}).get("results") or [])[:20]:
+        recs.append(
+            {
+                "tmdb_id": r.get("id"),
+                "title": r.get("title") or r.get("name"),
+                "poster_path": r.get("poster_path"),
+                "media_type": r.get("media_type") or media_type,
+            }
+        )
+
+    backdrops = [
+        b.get("file_path")
+        for b in ((payload.get("images") or {}).get("backdrops") or [])
+        if b.get("file_path")
+    ][:10]
+
+    return {
+        "tmdb_id": payload.get("id"),
+        # vote_average is meaningless with no votes (TMDB returns 0.0) → treat as unknown.
+        "tmdb_rating": payload.get("vote_average") if votes else None,
+        "tmdb_vote_count": votes or None,
+        # 0 is TMDB's "unknown" for money fields; TV has neither.
+        "budget": (payload.get("budget") or None) if not is_tv else None,
+        "revenue": (payload.get("revenue") or None) if not is_tv else None,
+        "keywords": keywords or None,
+        "crew": crew or None,
+        "studios": [c.get("name") for c in (payload.get("production_companies") or []) if c.get("name")][:8]
+        or None,
+        "production_countries": [
+            c.get("name") for c in (payload.get("production_countries") or []) if c.get("name")
+        ]
+        or None,
+        "recommendations": recs or None,
+        "backdrops": backdrops or None,
+        "people": people,
+    }
+
+
+def apply_tmdb_detail(row, parsed: dict) -> None:
+    """Persist the parsed TMDB fields onto a movie/show row. Does NOT touch full_cast / imdb_rating /
+    rating (Plex-owned). The caller stamps `tmdb_enriched_at` and links people separately."""
+    row.tmdb_id = parsed["tmdb_id"]
+    row.tmdb_rating = parsed["tmdb_rating"]
+    row.tmdb_vote_count = parsed["tmdb_vote_count"]
+    row.budget = parsed["budget"]
+    row.revenue = parsed["revenue"]
+    row.keywords = parsed["keywords"]
+    row.crew = parsed["crew"]
+    row.studios = parsed["studios"]
+    row.production_countries = parsed["production_countries"]
+    row.recommendations = parsed["recommendations"]
+    row.backdrops = parsed["backdrops"]
+
+
+def _link_people(db: Session, links: dict[str, int]) -> None:
+    """Upsert plex_people by name, stamping `tmdb_person_id` — keeping any id already set (first wins),
+    filling it where NULL, inserting a bare row where the person isn't cached yet. Deduped by name so a
+    single statement can't hit the conflict target twice (the same rule as people.enrich_row_people)."""
+    values = [{"name": nm, "tmdb_person_id": pid} for nm, pid in links.items() if nm and pid]
+    if not values:
+        return
+    stmt = pg_insert(PlexPerson).values(values)
+    db.execute(
+        stmt.on_conflict_do_update(
+            index_elements=[PlexPerson.name],
+            set_={"tmdb_person_id": func.coalesce(PlexPerson.tmdb_person_id, stmt.excluded.tmdb_person_id)},
+        )
+    )
+
+
+def enrich_batch(db: Session, tmdb: TmdbClient, limit: int) -> int:
+    """Enrich up to `limit` not-yet-TMDB-enriched titles (movies first, shows fill the remainder —
+    mirrors _enrich_people_batch). A transient TmdbError leaves the watermark NULL for retry; a
+    definitive no-match (unresolvable guid / TMDB 404) still stamps the watermark so it isn't re-fetched
+    every run. One commit at the end. Returns the number processed (matched OR definitively unmatched)."""
+    movies = (
+        db.execute(
+            select(PlexItem)
+            .where(
+                PlexItem.kind == "movie",
+                PlexItem.guid.is_not(None),
+                PlexItem.tmdb_enriched_at.is_(None),
+            )
+            .order_by(PlexItem.id)
+            .limit(limit)
+        )
+        .scalars()
+        .all()
+    )
+    shows: list[PlexShow] = []
+    if len(movies) < limit:
+        shows = (
+            db.execute(
+                select(PlexShow)
+                .where(PlexShow.guid.is_not(None), PlexShow.tmdb_enriched_at.is_(None))
+                .order_by(PlexShow.id)
+                .limit(limit - len(movies))
+            )
+            .scalars()
+            .all()
+        )
+
+    processed = 0
+    links: dict[str, int] = {}
+    for row, media_type in [(m, "movie") for m in movies] + [(s, "tv") for s in shows]:
+        try:
+            tmdb_id = guid_to_tmdb_id(row.guid, media_type, tmdb)
+            payload = tmdb.fetch(tmdb_id, media_type) if tmdb_id else None
+        except TmdbError as e:
+            log.warning("tmdb enrich %s failed (will retry): %s", row.rating_key, e)
+            continue  # transient — leave tmdb_enriched_at NULL for the next run
+        if payload:
+            parsed = parse_tmdb(payload, media_type)
+            apply_tmdb_detail(row, parsed)
+            for p in parsed["people"]:
+                links.setdefault(p["name"], p["tmdb_id"])
+        # Stamp even on a definitive no-match so an unresolvable title isn't re-fetched every run.
+        row.tmdb_enriched_at = datetime.now(timezone.utc)
+        processed += 1
+
+    if links:
+        _link_people(db, links)
+    db.commit()
+    return processed
+
+
+def run_enrich(db: Session) -> dict:
+    """Scheduler entry point. No-op (never an error) when the TMDB key isn't configured."""
+    if not sysconfig.get_str(db, "tmdb_api_key"):
+        return {"enriched": 0, "skipped": "tmdb_api_key not set"}
+    with TmdbClient(db) as tmdb:
+        n = enrich_batch(db, tmdb, settings.tmdb_enrich_batch)
+    return {"enriched": n}
+
+
+def resolve_library_guids(
+    db: Session,
+    entries: list[dict] | None,
+    *,
+    movie_lib_ids: list[int] | None = None,
+    show_lib_ids: list[int] | None = None,
+) -> tuple[dict[str, PlexItem], dict[str, PlexShow]]:
+    """Match a list of TMDB credits/recs (each `{tmdb_id, media_type, …}`) to our library rows by the
+    canonical guid `tmdb:<id>`, returning `(movies_by_guid, shows_by_guid)` of the ORM rows.
+
+    ⭐ TMDB movie ids and tv ids are INDEPENDENT sequences (id 603 can be BOTH a movie and a show), so
+    each entry matches ONLY its own media_type's table — a movie credit against a library movie, a tv
+    credit against a library show; a blind numeric match would resolve to an unrelated same-id title.
+    Pass `movie_lib_ids`/`show_lib_ids` to scope to the enabled libraries (the person page); leave them
+    None to match across all libraries (the detail-page recs). An explicit empty list means "that side
+    has no enabled library" → its bucket is skipped entirely."""
+    if not entries:
+        return {}, {}
+    movie_guids = [
+        f"tmdb:{e['tmdb_id']}" for e in entries if e.get("tmdb_id") and e.get("media_type") != "tv"
+    ]
+    tv_guids = [
+        f"tmdb:{e['tmdb_id']}" for e in entries if e.get("tmdb_id") and e.get("media_type") == "tv"
+    ]
+    movies: dict[str, PlexItem] = {}
+    if movie_guids and movie_lib_ids != []:
+        conds = [PlexItem.kind == "movie", PlexItem.guid.in_(movie_guids)]
+        if movie_lib_ids is not None:
+            conds.append(PlexItem.library_id.in_(movie_lib_ids))
+        for m in db.execute(select(PlexItem).where(*conds)).scalars():
+            movies.setdefault(m.guid, m)
+    shows: dict[str, PlexShow] = {}
+    if tv_guids and show_lib_ids != []:
+        conds = [PlexShow.guid.in_(tv_guids)]
+        if show_lib_ids is not None:
+            conds.append(PlexShow.library_id.in_(show_lib_ids))
+        for s in db.execute(select(PlexShow).where(*conds)).scalars():
+            shows.setdefault(s.guid, s)
+    return movies, shows
+
+
+def resolve_recs(db: Session, recs: list[dict] | None) -> list[dict]:
+    """Tag each recommendation with whether it's in OUR library (matched by guid `tmdb:<id>`, bucketed
+    by media_type — see resolve_library_guids) and, if so, its rating_key — so the client can deep-link
+    the ones we have and merely display the rest."""
+    if not recs:
+        return []
+    movies, shows = resolve_library_guids(db, recs)
+    out: list[dict] = []
+    for r in recs:
+        g = f"tmdb:{r.get('tmdb_id')}"
+        row = shows.get(g) if r.get("media_type") == "tv" else movies.get(g)
+        out.append(
+            {**r, "in_library": row is not None, "rating_key": row.rating_key if row else None}
+        )
+    return out
+
+
+def serve_block(db: Session, row) -> dict | None:
+    """The TMDB extras for a movie/show detail response, served from the row (no live TMDB call).
+    None until the row has been TMDB-enriched (the client then shows nothing extra)."""
+    if row.tmdb_enriched_at is None:
+        return None
+    return {
+        "tmdb_id": row.tmdb_id,
+        "rating": row.tmdb_rating,
+        "vote_count": row.tmdb_vote_count,
+        "budget": row.budget,
+        "revenue": row.revenue,
+        "keywords": row.keywords or [],
+        "crew": row.crew or [],
+        "studios": row.studios or [],
+        "production_countries": row.production_countries or [],
+        "recommendations": resolve_recs(db, row.recommendations),
+        "backdrops": row.backdrops or [],
+    }
+
+
+# --- Person enrichment (E5 S6) -------------------------------------------------------------------
+# A person's bio + birth facts + a "Known for" credit pool, fetched once (the first person-page open)
+# and served from the plex_people row. `known_for` stores the top combined-credits ids; the person
+# endpoint resolves them to library rows by guid at serve time (like recommendations).
+
+_KNOWN_FOR_MAX = 15
+
+
+def parse_person(payload: dict) -> dict:
+    """TMDB /person/{id} (+combined_credits) → the persisted bio fields. `known_for` = the person's
+    most-popular movie/tv credits (deduped by id), top `_KNOWN_FOR_MAX`, resolved to library later."""
+    credits = (payload.get("combined_credits") or {}).get("cast") or []
+    # Dedup on (id, media_type), not the bare id: TMDB movie ids and tv ids are independent sequences
+    # (id 603 can be both a movie and a show — see resolve_library_guids), so a same-id movie+show pair
+    # is two distinct credits and both must survive.
+    seen: set[tuple[int, str]] = set()
+    known: list[dict] = []
+    for c in sorted(credits, key=lambda c: c.get("popularity") or 0, reverse=True):
+        tid, mt = c.get("id"), c.get("media_type")
+        if not tid or mt not in ("movie", "tv") or (tid, mt) in seen:
+            continue
+        seen.add((tid, mt))
+        known.append({"tmdb_id": tid, "media_type": mt, "title": c.get("title") or c.get("name")})
+        if len(known) >= _KNOWN_FOR_MAX:
+            break
+    return {
+        "biography": (payload.get("biography") or "").strip() or None,
+        "birthday": payload.get("birthday") or None,
+        "deathday": payload.get("deathday") or None,
+        "place_of_birth": payload.get("place_of_birth") or None,
+        "known_for_department": payload.get("known_for_department") or None,
+        "also_known_as": payload.get("also_known_as") or None,
+        "known_for": known or None,
+    }
+
+
+def apply_person(row: PlexPerson, parsed: dict) -> None:
+    row.biography = parsed["biography"]
+    row.birthday = parsed["birthday"]
+    row.deathday = parsed["deathday"]
+    row.place_of_birth = parsed["place_of_birth"]
+    row.known_for_department = parsed["known_for_department"]
+    row.also_known_as = parsed["also_known_as"]
+    row.known_for = parsed["known_for"]
+    row.tmdb_enriched_at = datetime.now(timezone.utc)
+
+
+def enrich_person(db: Session, person: PlexPerson) -> bool:
+    """Lazily fetch + persist one person's TMDB bio (first person-page open), committing the write so it
+    survives regardless of the read path. No-op (False) without a key or a `tmdb_person_id`; a transient
+    error leaves `tmdb_enriched_at` NULL so the next open retries. A 404 (deleted person) stamps the
+    watermark with empty fields so we don't refetch it every open."""
+    if not person.tmdb_person_id or not sysconfig.get_str(db, "tmdb_api_key"):
+        return False
+    try:
+        # Called from a background task (off the request path — see people._enrich_person_bg), so it no
+        # longer blocks a serve; still cap the outbound TMDB call with a short timeout so a hanging TMDB
+        # doesn't tie up a threadpool worker for the default 30s.
+        with TmdbClient(db, timeout=8.0) as tmdb:
+            payload = tmdb.fetch_person(person.tmdb_person_id)
+    except TmdbError:
+        return False
+    if payload is None:
+        person.tmdb_enriched_at = datetime.now(timezone.utc)
+    else:
+        apply_person(person, parse_person(payload))
+    db.commit()
+    return True

backend/app/routes/feed.py

@@ -48,7 +48,11 @@ FINISH_MARGIN_SECONDS = 10
 # Shared query parameters for /feed and /feed/count.
 def _feed_params(
     tags: list[int] = Query(default=[]),
-    tag_mode: str = "or",
+    # Per-category tag match: each of language / topic / other independently ORs (any) or ANDs (all)
+    # its own selected tags. Defaults to "or". (Superseded the single global `tag_mode`.)
+    tag_mode_language: str = "or",
+    tag_mode_topic: str = "or",
+    tag_mode_other: str = "or",
     channel_ids: list[str] = Query(default=[]),
     q: str | None = None,
     min_duration: int | None = None,
@@ -65,7 +69,11 @@ def _feed_params(
 ) -> dict:
     return {
         "tags": tags,
-        "tag_mode": tag_mode,
+        "tag_modes": {
+            "language": tag_mode_language,
+            "topic": tag_mode_topic,
+            "other": tag_mode_other,
+        },
         "channel_ids": channel_ids,
         "q": q,
         "min_duration": min_duration,
@@ -162,7 +170,7 @@ def get_facets(
         # independent counts (you can OR more of them in). Conjunctive (AND, topics only)
         # keeps them applied, so each remaining chip narrows to channels that ALSO have all
         # already-selected topics — and tags that can't co-occur drop to zero (hidden).
-        conjunctive = category == "topic" and params.get("tag_mode") == "and"
+        conjunctive = params.get("tag_modes", {}).get(category) == "and"
         base, _rank = filtered_query(
             db,
             user,

backend/app/routes/plex/__init__.py

@@ -15,6 +15,7 @@ from app.routes.plex import (
     browse,
     collections,
     detail,
+    discover,
     people,
     playback,
     playlists,
@@ -25,6 +26,7 @@ router.include_router(admin.router)
 router.include_router(browse.router)
 router.include_router(collections.router)
 router.include_router(detail.router)
+router.include_router(discover.router)
 router.include_router(people.router)
 router.include_router(playback.router)
 router.include_router(playlists.router)

backend/app/routes/plex/browse.py

@@ -38,6 +38,7 @@ from app.plex.query import (
     movie_status_case,
     show_status_case,
     split_csv,
+    summary_col,
     title_col,
     vector_col,
     vector_match,
@@ -130,6 +131,8 @@ def unified_library(
                 title_col(PlexItem, lang).label("title"),
                 PlexItem.year.label("year"),
                 PlexItem.rating.label("rating"),
+                # Truncated so the card hover-overview costs a few hundred bytes, not the full synopsis.
+                func.left(summary_col(PlexItem, lang), 300).label("summary"),
                 PlexItem.added_at.label("added_at"),
                 PlexItem.originally_available_at.label("rel"),
                 PlexItem.duration_s.label("duration_s"),
@@ -170,6 +173,7 @@ def unified_library(
                 title_col(PlexShow, lang).label("title"),
                 PlexShow.year.label("year"),
                 PlexShow.rating.label("rating"),
+                func.left(summary_col(PlexShow, lang), 300).label("summary"),
                 PlexShow.added_at.label("added_at"),
                 PlexShow.originally_available_at.label("rel"),
                 cast(null(), Integer).label("duration_s"),
@@ -227,6 +231,8 @@ def unified_library(
                         "type": "movie",
                         "title": r.title,
                         "year": r.year,
+                        "rating": r.rating,
+                        "summary": r.summary,
                         "duration_seconds": r.duration_s,
                         "thumb": f"/api/plex/image/{r.rk}",
                         "playable": r.playable,
@@ -241,6 +247,8 @@ def unified_library(
                         "type": "show",
                         "title": r.title,
                         "year": r.year,
+                        "rating": r.rating,
+                        "summary": r.summary,
                         "thumb": f"/api/plex/image/{r.rk}",
                         "season_count": r.season_count,
                         "status": r.status,
@@ -304,6 +312,7 @@ def facets(
     empty = {
         "genres": [],
         "content_ratings": [],
+        "studios": [],
         "year_min": None,
         "year_max": None,
         "rating_max": None,
@@ -347,6 +356,7 @@ def facets(
 
     genre_counts: dict[str, int] = {}
     cr_counts: dict[str, int] = {}
+    studio_counts: dict[str, int] = {}
     years: list[int] = []
     ratings: list[float] = []
     durs: list[int] = []
@@ -398,6 +408,21 @@ def facets(
         )
         for cr, c in db.execute(crq).all():
             cr_counts[cr] = cr_counts.get(cr, 0) + c
+        # Studios — exclude its own (each offered studio is a valid OR-addition that only widens).
+        stq = (
+            wsq(
+                select(model.studio, func.count()),
+                model,
+                ids,
+                {**p, "studios": None},
+                kind_movie,
+                True,
+            )
+            .where(model.studio.isnot(None))
+            .group_by(model.studio)
+        )
+        for s, c in db.execute(stq).all():
+            studio_counts[s] = studio_counts.get(s, 0) + c
         # Year bounds — exclude the year filter.
         by = db.execute(
             wsq(
@@ -452,6 +477,9 @@ def facets(
     # undo a zero-result selection. Count 0 is fine (genre chips don't display counts).
     for g in split_csv(f.genres):
         genre_counts.setdefault(g, 0)
+    # Same for the actively-selected studios, so a selected studio stays removable even at zero matches.
+    for s in split_csv(f.studios):
+        studio_counts.setdefault(s, 0)
     return {
         "genres": [
             {"value": g, "count": c}
@@ -461,6 +489,10 @@ def facets(
             {"value": cr, "count": c}
             for cr, c in sorted(cr_counts.items(), key=lambda kv: -kv[1])
         ],
+        "studios": [
+            {"value": s, "count": c}
+            for s, c in sorted(studio_counts.items(), key=lambda kv: (-kv[1], kv[0]))
+        ],
         "year_min": min(years) if years else None,
         "year_max": max(years) if years else None,
         "rating_max": max(ratings) if ratings else None,

backend/app/routes/plex/collections.py

@@ -9,13 +9,33 @@ from app.auth import admin_user, current_user
 from app.db import get_db
 from app.models import (
     PlexCollection,
+    PlexItem,
     PlexLibrary,
+    PlexShow,
     User,
 )
+from app.plex import rollup
 from app.plex import sync as plex_sync
+from app.plex.cards import movie_card, show_card
 from app.plex.client import PlexClient, PlexError, PlexNotConfigured
 from app.plex.lookups import by_rating_key
-from app.plex.query import like_escape
+from app.plex.query import like_escape, runtime_by_key, top_art_keys
+from app.routes.plex._shared import _content_libs
+
+# The most-restrictive → least ordering used to pick a collection's effective content rating from its
+# members (Plex shows one cert on the collection; we don't store it, so derive it).
+_CERT_RANK = {
+    "G": 1, "TV-Y": 1, "TV-Y7": 1, "TV-G": 1,
+    "PG": 2, "TV-PG": 2,
+    "PG-13": 3, "TV-14": 3,
+    "R": 4, "TV-MA": 4,
+    "NC-17": 5,
+}
+
+
+def _collection_cert(certs: list[str | None]) -> str | None:
+    ranked = [(c, _CERT_RANK.get(c, 0)) for c in certs if c]
+    return max(ranked, key=lambda x: x[1])[0] if ranked else None
 
 router = APIRouter(prefix="/api/plex", tags=["plex"])
 
@@ -93,7 +113,74 @@ def collections(
             func.lower(PlexCollection.title),
         )
     ).scalars().all()
-    return {"collections": [_collection_card(c) for c in rows]}
+    # A montage of the top titles per tile + the collection's total runtime. Art unions MOVIE and SHOW
+    # members (a collection lives in one library, so exactly one side has art) — a show collection would
+    # otherwise render blank; the collection's own poster is the next fallback, then the colour hash.
+    # Runtime is movie-only (shows have no single duration).
+    movie_ids, show_ids = _content_libs(db)
+    keys = [c.rating_key for c in rows]
+    art_m = top_art_keys(db, PlexItem, movie_ids, PlexItem.collection_keys, keys, per=2)
+    art_s = top_art_keys(db, PlexShow, show_ids, PlexShow.collection_keys, keys, per=2)
+    runtime = runtime_by_key(db, PlexItem, movie_ids, PlexItem.collection_keys, keys)
+
+    def _art(c: PlexCollection) -> list[str]:
+        member = art_m.get(c.rating_key) or art_s.get(c.rating_key)
+        return member or ([c.rating_key] if c.thumb_key else [])
+
+    return {
+        "collections": [
+            {
+                **_collection_card(c),
+                "art": _art(c),
+                "total_runtime_s": runtime.get(c.rating_key, 0),
+            }
+            for c in rows
+        ]
+    }
+
+
+@router.get("/collections/{rating_key}")
+def collection_detail(
+    rating_key: str,
+    user: User = Depends(current_user),
+    db: Session = Depends(get_db),
+) -> dict:
+    """One collection's hero data + its members (movies + shows), ordered by release year then title —
+    the Collection info page. Read-only here; edits go through the admin mutation endpoints below."""
+    col = by_rating_key(db, PlexCollection, rating_key)
+    if col is None:
+        raise HTTPException(status_code=404, detail="Unknown collection")
+    movies = db.execute(
+        select(PlexItem)
+        .where(PlexItem.kind == "movie", PlexItem.collection_keys.contains([rating_key]))
+        .order_by(PlexItem.year.asc().nullslast(), func.lower(PlexItem.title))
+    ).scalars().all()
+    shows = db.execute(
+        select(PlexShow)
+        .where(PlexShow.collection_keys.contains([rating_key]))
+        .order_by(PlexShow.year.asc().nullslast(), func.lower(PlexShow.title))
+    ).scalars().all()
+    mstate = rollup.item_state_map(db, user.id, [m.id for m in movies])
+    sstate = rollup.state_map(db, user.id, [s.id for s in shows])
+    # Merge the two type-homogeneous lists into ONE member list ordered by (year, title).
+    tagged = [(m.year, (m.title or "").lower(), "movie", m) for m in movies] + [
+        (s.year, (s.title or "").lower(), "show", s) for s in shows
+    ]
+    tagged.sort(key=lambda t: (t[0] is None, t[0] or 0, t[1]))
+    items = [
+        movie_card(o, mstate.get(o.id)) if kind == "movie" else show_card(o, sstate.get(o.id, "new"))
+        for _, _, kind, o in tagged
+    ]
+    years = [y for y, _, _, _ in tagged if y is not None]
+    certs = [m.content_rating for m in movies] + [s.content_rating for s in shows]
+    return {
+        **_collection_card(col),
+        "content_rating": _collection_cert(certs),
+        "year_min": min(years) if years else None,
+        "year_max": max(years) if years else None,
+        "total_runtime_s": sum(m.duration_s or 0 for m in movies),
+        "items": items,
+    }
 
 
 def _editable_collection_or_403(db: Session, rating_key: str) -> PlexCollection:
@@ -105,6 +192,41 @@ def _editable_collection_or_403(db: Session, rating_key: str) -> PlexCollection:
     return col
 
 
+def _reject_duplicate_name(
+    db: Session, library_id: int, title: str, exclude_rk: str | None = None
+) -> None:
+    """No two collections in a section may share a name: Plex CONFLATES same-named collections'
+    membership (both rating_keys resolve to one merged member list — a real footgun), so forbid it up
+    front on create + rename rather than mirror the mess."""
+    dup = db.execute(
+        select(PlexCollection).where(
+            PlexCollection.library_id == library_id,
+            func.lower(PlexCollection.title) == title.lower(),
+        )
+    ).scalars().first()
+    if dup is not None and dup.rating_key != exclude_rk:
+        raise HTTPException(status_code=409, detail="A collection with this name already exists")
+
+
+def _write_or_pending_error(wrote: bool, e: Exception) -> HTTPException:
+    """Map a PlexError raised inside a mutate-then-resync block to the honest message. If the mutating
+    call itself failed (``wrote`` False) the write never landed → "Plex write failed". If the write
+    succeeded but the follow-up resync READ (Plex metadata/children) failed, the change IS on the Plex
+    server → don't claim a write failure; say the local copy will reconcile on the next sync.
+
+    Both use 422, NOT a 5xx: the frontend treats 502/503/504 as "gateway unreachable" and raises a
+    sticky offline banner (see api/core.ts RETRIABLE_GATEWAY). A 422 surfaces the detail as an ordinary
+    action-error toast, which is what both of these are — the app answered, it didn't go unreachable."""
+    if wrote:
+        detail = (
+            "Collection updated in Plex, but refreshing the local copy failed; "
+            f"it will reconcile on the next sync ({e})"
+        )
+    else:
+        detail = f"Plex write failed: {e}"
+    return HTTPException(status_code=422, detail=detail)
+
+
 class CreateCollectionIn(BaseModel):
     library: str = ""
     title: str = ""
@@ -125,20 +247,28 @@ def create_collection(
         raise HTTPException(
             status_code=400, detail="title and item_rating_key are required"
         )
-    lib = db.execute(
-        select(PlexLibrary).where(PlexLibrary.plex_key == library)
-    ).scalars().first()
+    if library:
+        lib = db.execute(
+            select(PlexLibrary).where(PlexLibrary.plex_key == library)
+        ).scalars().first()
+    else:
+        # The "New collection" flow only knows the seed title → derive its library.
+        seed_item = by_rating_key(db, PlexItem, seed) or by_rating_key(db, PlexShow, seed)
+        lib = db.get(PlexLibrary, seed_item.library_id) if seed_item else None
     if lib is None:
         raise HTTPException(status_code=404, detail="Unknown library")
+    _reject_duplicate_name(db, lib.id, title)
+    wrote = False
     try:
         with PlexClient(db) as plex:
             new = plex.create_collection(lib.plex_key, title, seed)
+            wrote = True
             col = plex_sync.resync_collection(db, plex, lib, str(new.get("ratingKey")))
             col.editable = True
         db.commit()
     except (PlexError, PlexNotConfigured) as e:
         db.rollback()
-        raise HTTPException(status_code=422, detail=f"Plex write failed: {e}")
+        raise _write_or_pending_error(wrote, e)
     return _collection_card(col)
 
 
@@ -151,14 +281,16 @@ def collection_add_item(
 ) -> dict:
     col = _editable_collection_or_403(db, rating_key)
     lib = db.get(PlexLibrary, col.library_id)
+    wrote = False
     try:
         with PlexClient(db) as plex:
             plex.add_collection_item(rating_key, str(item_rating_key))
+            wrote = True
             col = plex_sync.resync_collection(db, plex, lib, rating_key)
         db.commit()
     except (PlexError, PlexNotConfigured) as e:
         db.rollback()
-        raise HTTPException(status_code=422, detail=f"Plex write failed: {e}")
+        raise _write_or_pending_error(wrote, e)
     return _collection_card(col)
 
 
@@ -171,14 +303,16 @@ def collection_remove_item(
 ) -> dict:
     col = _editable_collection_or_403(db, rating_key)
     lib = db.get(PlexLibrary, col.library_id)
+    wrote = False
     try:
         with PlexClient(db) as plex:
             plex.remove_collection_item(rating_key, str(item_rating_key))
+            wrote = True
             col = plex_sync.resync_collection(db, plex, lib, rating_key)
         db.commit()
     except (PlexError, PlexNotConfigured) as e:
         db.rollback()
-        raise HTTPException(status_code=422, detail=f"Plex write failed: {e}")
+        raise _write_or_pending_error(wrote, e)
     return _collection_card(col)
 
 
@@ -197,15 +331,18 @@ def collection_rename(
     title = body.title.strip()
     if not title:
         raise HTTPException(status_code=400, detail="title is required")
+    _reject_duplicate_name(db, col.library_id, title, exclude_rk=rating_key)
     lib = db.get(PlexLibrary, col.library_id)
+    wrote = False
     try:
         with PlexClient(db) as plex:
             plex.rename_collection(lib.plex_key, rating_key, title)
+            wrote = True
             col = plex_sync.resync_collection(db, plex, lib, rating_key)
         db.commit()
     except (PlexError, PlexNotConfigured) as e:
         db.rollback()
-        raise HTTPException(status_code=422, detail=f"Plex write failed: {e}")
+        raise _write_or_pending_error(wrote, e)
     return _collection_card(col)
 
 

backend/app/routes/plex/detail.py

@@ -23,6 +23,7 @@ from app.models import (
 from app.plex import detail as plex_detail
 from app.plex import people as plex_people
 from app.plex import rollup, subtitles
+from app.plex import tmdb as plex_tmdb
 from app.plex.cards import episode_card, movie_card, show_card
 from app.plex.client import PlexClient, PlexError, PlexNotConfigured
 from app.plex.lookups import by_rating_key
@@ -172,6 +173,8 @@ def show_detail(
             "first": show_roll["first"],
             "episode_count": show_roll["episode_count"],
             "collection_keys": sh.collection_keys or [],
+            # TMDB enrichment (E5 S2), served from the row.
+            "tmdb": plex_tmdb.serve_block(db, sh),
         },
         "seasons": [_season_block(se, by_season.get(se.id, [])) for se in seasons],
         "related": related,
@@ -435,4 +438,6 @@ def item_detail(
         "prev_id": prev_id,
         "next_id": next_id,
         "collections": _collection_strips(db, it, user.id),
+        # TMDB enrichment (E5 S2), served from the row — movies only (episodes aren't enriched).
+        "tmdb": plex_tmdb.serve_block(db, it) if it.kind == "movie" else None,
     }

backend/app/routes/plex/discover.py

@@ -0,0 +1,421 @@
+"""Plex Discover: the rail-surface read-model (E5 S4).
+
+A consolidated payload for the dedicated Discover landing — a stack of horizontal rails:
+Continue watching · Recently added · Browse-by-genre tiles · Because you watched X — plus a
+separate, reshuffling Surprise-me sample. Serve-from-DB only: the recommendation rail reads the
+recs the S2 TMDB engine already persisted (`PlexItem.recommendations`), never a live TMDB call, and
+every card comes from the same `movie_card`/`show_card` serializers the grid uses (so rails inherit
+S1's `art` + S3's rating/summary for free). The rails carry EN metadata (like the other non-grid
+card paths); the HU overlay coalesces only in the main grid.
+
+The sidebar metadata filters (genre / rating / year / collection / …) narrow EVERY rail too, so the
+Discover surface behaves like the Browse grid — the same `LibraryFilters` / `meta_filter_conds` the
+grid uses, applied to each rail's movie + show query (a rail may legitimately come back empty, which
+the client hides). Genre-language matches the grid; duration is movie-only.
+"""
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy import and_, func, or_, select
+from sqlalchemy.orm import Session
+
+from app.auth import current_user
+from app.db import get_db
+from app.models import PlexItem, PlexShow, PlexState, User
+from app.plex import rollup
+from app.plex.cards import leaf_card, movie_card, show_card
+from app.plex.query import (
+    LibraryFilters,
+    apply_meta_filters,
+    apply_show_state_filter,
+    genres_col,
+    meta_filter_conds,
+    top_art_keys,
+)
+from app.plex.tmdb import resolve_recs
+from app.routes.plex._shared import _content_libs, _norm_lang
+
+router = APIRouter(prefix="/api/plex", tags=["plex"])
+
+RAIL_LIMIT = 20
+GENRE_TILES = 12
+SURPRISE_PER_KIND = 3  # Surprise-me: at most this many movies + this many shows (6 total)
+
+
+def _scope_libs(db: Session, scope: str) -> tuple[list[int], list[int]]:
+    """The movie/show library ids visible for this scope (empty list = out of scope)."""
+    movie_ids, show_ids = _content_libs(db)
+    return (
+        movie_ids if scope in ("movie", "both") else [],
+        show_ids if scope in ("show", "both") else [],
+    )
+
+
+def _movie_meta(q, p: dict, lang: str, f: LibraryFilters):
+    """Apply the shared metadata filters + movie-only duration to a movie query (same as the grid)."""
+    q = apply_meta_filters(q, PlexItem, p, lang)
+    if f.duration_min is not None:
+        q = q.where(PlexItem.duration_s >= f.duration_min)
+    if f.duration_max is not None:
+        q = q.where(PlexItem.duration_s <= f.duration_max)
+    return q
+
+
+def _movie_cards(db: Session, uid: int, items: list[PlexItem]) -> list[dict]:
+    sts = rollup.item_state_map(db, uid, [it.id for it in items])
+    return [movie_card(it, sts.get(it.id)) for it in items]
+
+
+def _show_cards(db: Session, uid: int, shows: list[PlexShow]) -> list[dict]:
+    statuses = rollup.state_map(db, uid, [s.id for s in shows])
+    return [show_card(s, statuses.get(s.id, "new")) for s in shows]
+
+
+def _recently_added(
+    db: Session, uid: int, movie_ids: list[int], show_ids: list[int], p: dict, lang: str, f: LibraryFilters
+) -> list[dict]:
+    """Newest movies + shows, interleaved by `added_at` desc into one rail."""
+    movies = (
+        db.execute(
+            _movie_meta(
+                select(PlexItem).where(
+                    PlexItem.kind == "movie", PlexItem.library_id.in_(movie_ids)
+                ),
+                p, lang, f,
+            )
+            .order_by(PlexItem.added_at.desc().nullslast())
+            .limit(RAIL_LIMIT)
+        ).scalars().all()
+        if movie_ids
+        else []
+    )
+    shows = (
+        db.execute(
+            apply_meta_filters(
+                select(PlexShow).where(PlexShow.library_id.in_(show_ids)), PlexShow, p, lang
+            )
+            .order_by(PlexShow.added_at.desc().nullslast())
+            .limit(RAIL_LIMIT)
+        ).scalars().all()
+        if show_ids
+        else []
+    )
+    # Merge the two type-homogeneous lists by added_at, then serialize each side in one batch so the
+    # per-card state lookups stay batched (no N+1). The `(is not None, value)` key sorts a missing
+    # timestamp last under reverse.
+    tagged = [(m.added_at, "movie", m) for m in movies] + [
+        (s.added_at, "show", s) for s in shows
+    ]
+    tagged.sort(key=lambda t: (t[0] is not None, t[0]), reverse=True)
+    top = tagged[:RAIL_LIMIT]
+    # Key the serialized cards back by rating_key (globally unique in Plex — a movie and a show never
+    # share one), so the merge doesn't depend on object identity staying alive.
+    top_movies = [o for _, kind, o in top if kind == "movie"]
+    top_shows = [o for _, kind, o in top if kind == "show"]
+    mcards = {m.rating_key: c for m, c in zip(top_movies, _movie_cards(db, uid, top_movies))}
+    scards = {s.rating_key: c for s, c in zip(top_shows, _show_cards(db, uid, top_shows))}
+    return [
+        mcards[o.rating_key] if kind == "movie" else scards[o.rating_key]
+        for _, kind, o in top
+    ]
+
+
+def _recently_watched(
+    db: Session, uid: int, movie_ids: list[int], show_ids: list[int], p: dict, lang: str, f: LibraryFilters
+) -> list[dict]:
+    """Recently watched rail: the titles the user last FULLY watched, newest first. A movie is its own
+    card; a show contributes the specific EPISODE watched (carrying its show title). Movies honour the
+    sidebar filters (like the other rails); episodes carry no filterable metadata, so they don't."""
+    rows: list[tuple[object, dict]] = []  # (watched_at, card)
+    if movie_ids:
+        mq = (
+            select(PlexItem, PlexState)
+            .join(PlexState, and_(PlexState.item_id == PlexItem.id, PlexState.user_id == uid))
+            .where(
+                PlexItem.kind == "movie",
+                PlexItem.library_id.in_(movie_ids),
+                PlexState.status == "watched",
+            )
+        )
+        for it, st in db.execute(
+            _movie_meta(mq, p, lang, f)
+            .order_by(PlexState.watched_at.desc().nullslast())
+            .limit(RAIL_LIMIT)
+        ).all():
+            rows.append((st.watched_at, leaf_card(it, st)))
+    if show_ids:
+        eq = (
+            select(PlexItem, PlexState, PlexShow.title, PlexShow.rating_key)
+            .join(PlexState, and_(PlexState.item_id == PlexItem.id, PlexState.user_id == uid))
+            .join(PlexShow, PlexShow.id == PlexItem.show_id)
+            .where(
+                PlexItem.kind == "episode",
+                PlexItem.library_id.in_(show_ids),
+                PlexState.status == "watched",
+            )
+            .order_by(PlexState.watched_at.desc().nullslast())
+            .limit(RAIL_LIMIT)
+        )
+        for ep, st, sh_title, sh_rk in db.execute(eq).all():
+            rows.append((st.watched_at, leaf_card(ep, st, show_title=sh_title, show_rk=sh_rk)))
+    rows.sort(key=lambda r: (r[0] is not None, r[0]), reverse=True)
+    return [card for _, card in rows[:RAIL_LIMIT]]
+
+
+def _continue_watching(
+    db: Session, uid: int, movie_ids: list[int], show_ids: list[int], p: dict, lang: str, f: LibraryFilters
+) -> list[dict]:
+    """Resume rail: in-progress movies + partially-watched shows, most-recently-progressed first.
+    A movie's resume time is its own `progress_updated_at`; a show's is the max across its episodes."""
+    rows: list[tuple[object, dict]] = []  # (resumed_at, card)
+
+    if movie_ids:
+        mq = (
+            select(PlexItem, PlexState)
+            .join(
+                PlexState,
+                and_(PlexState.item_id == PlexItem.id, PlexState.user_id == uid),
+            )
+            .where(
+                PlexItem.kind == "movie",
+                PlexItem.library_id.in_(movie_ids),
+                PlexState.position_seconds > 0,
+                # A NULL status is still "started" (mirrors apply_movie_state_filter's in_progress) —
+                # `notin_` alone would drop it, since `NULL NOT IN (...)` is NULL, not TRUE.
+                or_(
+                    PlexState.status.is_(None),
+                    PlexState.status.notin_(["watched", "hidden"]),
+                ),
+            )
+        )
+        mrows = db.execute(
+            _movie_meta(mq, p, lang, f)
+            .order_by(PlexState.progress_updated_at.desc().nullslast())
+            .limit(RAIL_LIMIT)
+        ).all()
+        for it, st in mrows:
+            rows.append((st.progress_updated_at, movie_card(it, st)))
+
+    if show_ids:
+        # Reuse the shared per-show episode rollup (total/watched/inprog) rather than re-inlining it, plus
+        # its `resumed_at` = max(progress_updated_at); the in-progress predicate comes from the same shared
+        # `apply_show_state_filter` the grid uses, so the rail can't drift from the grid's definition.
+        prog = rollup.agg_subquery(db, uid, include_resumed=True).subquery()
+        sq = apply_show_state_filter(
+            select(PlexShow, prog.c.resumed_at).join(prog, prog.c.show_id == PlexShow.id),
+            prog.c.total,
+            prog.c.watched,
+            prog.c.inprog,
+            "in_progress",
+        ).where(PlexShow.library_id.in_(show_ids))
+        srows = db.execute(
+            apply_meta_filters(sq, PlexShow, p, lang)
+            .order_by(prog.c.resumed_at.desc().nullslast())
+            .limit(RAIL_LIMIT)
+        ).all()
+        for sh, resumed_at in srows:
+            rows.append((resumed_at, show_card(sh, "in_progress")))
+
+    rows.sort(key=lambda r: (r[0] is not None, r[0]), reverse=True)
+    return [card for _, card in rows[:RAIL_LIMIT]]
+
+
+def _genre_tiles(
+    db: Session, movie_ids: list[int], show_ids: list[int], p: dict, lang: str
+) -> list[dict]:
+    """The most-common genres across the scope, as {value, count} tiles → tap to filter the grid.
+    The genre vocabulary is language-specific (coalesce(genres_hu, genres) in HU), matching the grid.
+    The active metadata filters narrow the counts too, so the tiles agree with the filtered rails."""
+    counts: dict[str, int] = {}
+    for model, ids in ((PlexItem, movie_ids), (PlexShow, show_ids)):
+        if not ids:
+            continue
+        gcol = genres_col(model, lang)
+        base = select(func.jsonb_array_elements_text(gcol).label("g")).where(
+            model.library_id.in_(ids),
+            func.jsonb_typeof(gcol) == "array",
+            *meta_filter_conds(model, p, lang),
+        )
+        if model is PlexItem:
+            base = base.where(model.kind == "movie")
+        expanded = base.subquery()
+        for g, c in db.execute(
+            select(expanded.c.g, func.count()).group_by(expanded.c.g)
+        ).all():
+            counts[g] = counts.get(g, 0) + c
+    top = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))[:GENRE_TILES]
+    # A 2×2 poster collage per tile: the top movies in that genre (color hash is the client fallback).
+    art = top_art_keys(
+        db,
+        PlexItem,
+        movie_ids,
+        genres_col(PlexItem, lang),
+        [g for g, _ in top],
+        extra_conds=(PlexItem.kind == "movie", *meta_filter_conds(PlexItem, p, lang)),
+    )
+    return [{"value": g, "count": c, "art": art.get(g, [])} for g, c in top]
+
+
+def _because_you_watched(
+    db: Session, uid: int, movie_ids: list[int], show_ids: list[int], p: dict, lang: str, f: LibraryFilters
+) -> dict | None:
+    """Recommendations anchored on the user's most-recently-watched, TMDB-enriched movie. Only the
+    recs that resolve to OUR library (by guid) become cards — the rest aren't actionable here. Returns
+    None (rail hidden) when there's no enriched watch history or none of its recs are in the library.
+    The metadata filters narrow the resolved recs (not the anchor pick) so the rail matches the grid."""
+    if not movie_ids:
+        return None
+    anchor = db.execute(
+        select(PlexItem)
+        .join(
+            PlexState,
+            and_(PlexState.item_id == PlexItem.id, PlexState.user_id == uid),
+        )
+        .where(
+            PlexItem.kind == "movie",
+            PlexItem.library_id.in_(movie_ids),
+            PlexState.status == "watched",
+            PlexItem.recommendations.isnot(None),
+        )
+        .order_by(PlexState.watched_at.desc().nullslast())
+        .limit(1)
+    ).scalars().first()
+    if anchor is None:
+        return None
+    resolved = resolve_recs(db, anchor.recommendations)
+    # Preserve TMDB's recommendation order, keep only in-library hits, and drop the anchor itself.
+    rks = [
+        r["rating_key"]
+        for r in resolved
+        if r.get("in_library") and r.get("rating_key") != anchor.rating_key
+    ]
+    if not rks:
+        return None
+    movies = {
+        m.rating_key: m
+        for m in db.execute(
+            _movie_meta(
+                select(PlexItem).where(
+                    PlexItem.kind == "movie", PlexItem.rating_key.in_(rks)
+                ),
+                p, lang, f,
+            )
+        ).scalars().all()
+    }
+    shows = {
+        s.rating_key: s
+        for s in db.execute(
+            apply_meta_filters(
+                select(PlexShow).where(PlexShow.rating_key.in_(rks)), PlexShow, p, lang
+            )
+        ).scalars().all()
+    }
+    ordered_movies = [movies[rk] for rk in rks if rk in movies]
+    ordered_shows = [shows[rk] for rk in rks if rk in shows]
+    # rating_key is globally unique in Plex, so it keys the serialized cards back safely (no id()).
+    mcards = {m.rating_key: c for m, c in zip(ordered_movies, _movie_cards(db, uid, ordered_movies))}
+    scards = {s.rating_key: c for s, c in zip(ordered_shows, _show_cards(db, uid, ordered_shows))}
+    items: list[dict] = []
+    for rk in rks:
+        if rk in mcards:
+            items.append(mcards[rk])
+        elif rk in scards:
+            items.append(scards[rk])
+    if not items:
+        return None
+    return {"anchor": {"id": anchor.rating_key, "title": anchor.title}, "items": items}
+
+
+@router.get("/discover")
+def discover(
+    scope: str = "both",
+    lang: str = "en",
+    f: LibraryFilters = Depends(),
+    user: User = Depends(current_user),
+    db: Session = Depends(get_db),
+) -> dict:
+    """The Discover landing payload — every rail in one pass (serve-from-DB), narrowed by the active
+    sidebar filters. Empty rails come back as empty lists (the client hides them); `because_you_watched`
+    is null when there's no anchor."""
+    lang = _norm_lang(lang)
+    p = f.as_dict()
+    movie_ids, show_ids = _scope_libs(db, scope)
+    return {
+        "scope": scope,
+        "continue_watching": _continue_watching(db, user.id, movie_ids, show_ids, p, lang, f),
+        "recently_watched": _recently_watched(db, user.id, movie_ids, show_ids, p, lang, f),
+        "recently_added": _recently_added(db, user.id, movie_ids, show_ids, p, lang, f),
+        "genres": _genre_tiles(db, movie_ids, show_ids, p, lang),
+        "because_you_watched": _because_you_watched(db, user.id, movie_ids, show_ids, p, lang, f),
+    }
+
+
+@router.get("/surprise")
+def surprise(
+    scope: str = "both",
+    lang: str = "en",
+    limit: int = Query(default=2 * SURPRISE_PER_KIND, ge=1, le=40),
+    f: LibraryFilters = Depends(),
+    user: User = Depends(current_user),
+    db: Session = Depends(get_db),
+) -> dict:
+    """A fresh random sample for the reshuffling Surprise-me rail (a random draw each call), narrowed by
+    the active filters. Only titles the user has NOT seen — a watched movie / a fully-watched show is
+    excluded (the point is to surface something to watch). Capped at SURPRISE_PER_KIND movies +
+    SURPRISE_PER_KIND shows, drawn separately then interleaved so a lopsided library doesn't crowd out
+    one type."""
+    lang = _norm_lang(lang)
+    p = f.as_dict()
+    movie_ids, show_ids = _scope_libs(db, scope)
+    per = min(limit, SURPRISE_PER_KIND)
+    movies = []
+    if movie_ids:
+        # Exclude movies this user has watched.
+        watched_movie = (
+            select(PlexState.id)
+            .where(
+                PlexState.item_id == PlexItem.id,
+                PlexState.user_id == user.id,
+                PlexState.status == "watched",
+            )
+            .exists()
+        )
+        movies = db.execute(
+            _movie_meta(
+                select(PlexItem).where(
+                    PlexItem.kind == "movie",
+                    PlexItem.library_id.in_(movie_ids),
+                    ~watched_movie,
+                ),
+                p, lang, f,
+            )
+            .order_by(func.random())
+            .limit(per)
+        ).scalars().all()
+    shows = []
+    if show_ids:
+        # Exclude fully-watched shows (LEFT JOIN so a never-started show — no rollup row — still counts
+        # as unseen). `total IS NULL / == 0 / watched < total` == "not fully watched".
+        prog = rollup.agg_subquery(db, user.id).subquery()
+        not_fully_watched = or_(
+            prog.c.total.is_(None), prog.c.total == 0, prog.c.watched < prog.c.total
+        )
+        shows = db.execute(
+            apply_meta_filters(
+                select(PlexShow)
+                .outerjoin(prog, prog.c.show_id == PlexShow.id)
+                .where(PlexShow.library_id.in_(show_ids), not_fully_watched),
+                PlexShow, p, lang,
+            )
+            .order_by(func.random())
+            .limit(per)
+        ).scalars().all()
+    mcards = _movie_cards(db, user.id, movies)
+    scards = _show_cards(db, user.id, shows)
+    # Interleave movie/show cards, then trim to `limit`.
+    items: list[dict] = []
+    for i in range(max(len(mcards), len(scards))):
+        if i < len(mcards):
+            items.append(mcards[i])
+        if i < len(scards):
+            items.append(scards[i])
+    return {"scope": scope, "items": items[:limit]}

backend/app/routes/plex/people.py

@@ -1,24 +1,60 @@
 """Plex people: cast/crew filter-chip cards + a single person's filmography page."""
 
-from fastapi import APIRouter, Depends
+import logging
+import threading
+import time
+
+from fastapi import APIRouter, BackgroundTasks, Depends
 from sqlalchemy import func, or_, select
 from sqlalchemy.orm import Session
 
 from app.auth import current_user
-from app.db import get_db
+from app.db import SessionLocal, get_db
 from app.models import (
     PlexItem,
     PlexPerson,
     PlexShow,
-    PlexState,
     User,
 )
 from app.plex import rollup
+from app.plex import tmdb as plex_tmdb
 from app.plex.cards import movie_card, show_card
 from app.plex.query import split_csv
 from app.routes.plex._shared import _content_libs
 
 router = APIRouter(prefix="/api/plex", tags=["plex"])
+log = logging.getLogger("siftlode.plex")
+
+
+def _resolve_known_for(
+    db: Session,
+    known_for: list | None,
+    uid: int,
+    movie_lib_ids: list[int],
+    show_lib_ids: list[int],
+) -> list[dict]:
+    """The person's TMDB "Known for" credits (top by popularity) that are IN our library, as cards, in
+    popularity order. Matched by the canonical guid `tmdb:<id>`; out-of-library credits are dropped."""
+    if not known_for:
+        return []
+    # Match each credit to a library row by guid, bucketed by media_type (movie ids and tv ids collide
+    # numerically) and scoped to the enabled libraries — the shared helper owns that collision-safe
+    # logic (the detail-page recs use the same one).
+    movies, shows = plex_tmdb.resolve_library_guids(
+        db, known_for, movie_lib_ids=movie_lib_ids, show_lib_ids=show_lib_ids
+    )
+    m_states = rollup.item_state_map(db, uid, [m.id for m in movies.values()])
+    show_statuses = rollup.state_map(db, uid, [s.id for s in shows.values()])
+    out: list[dict] = []
+    for k in known_for:
+        g = f"tmdb:{k.get('tmdb_id')}"
+        # A credit resolves against its OWN media_type's bucket only.
+        if k.get("media_type") == "tv":
+            if g in shows:
+                out.append(show_card(shows[g], show_statuses.get(shows[g].id, "new")))
+        elif g in movies:
+            out.append(movie_card(movies[g], m_states.get(movies[g].id)))
+    return out
 
 
 @router.get("/people/cards")
@@ -78,9 +114,54 @@ def people_cards(
 _PERSON_SECTION_MAX = 200
 
 
+# A person's bio is enriched at most once per this window: it dedups concurrent opens of the same person
+# (each would otherwise schedule its own 8s TMDB task) AND rate-limits re-triggering when TMDB is
+# down/slow (a transient failure leaves tmdb_enriched_at NULL, so without this every reload would spawn a
+# fresh task and pile up on the shared threadpool). In-process + best-effort: a restart just clears it, at
+# worst costing a few extra fetches. A successful enrich stamps the watermark, so the reservation only
+# ever expires harmlessly.
+_ENRICH_COOLDOWN_S = 60.0
+_enrich_inflight: dict[int, float] = {}
+_enrich_lock = threading.Lock()
+
+
+def _should_schedule_enrich(person_id: int) -> bool:
+    """True (and reserves a cooldown) if this person isn't already being enriched / recently attempted."""
+    now = time.monotonic()
+    with _enrich_lock:
+        deadline = _enrich_inflight.get(person_id)
+        if deadline is not None and now < deadline:
+            return False
+        _enrich_inflight[person_id] = now + _ENRICH_COOLDOWN_S
+        # Bound the map: drop expired reservations once it grows (a large library has many people).
+        if len(_enrich_inflight) > 1024:
+            for pid in [p for p, d in _enrich_inflight.items() if d <= now]:
+                del _enrich_inflight[pid]
+        return True
+
+
+def _enrich_person_bg(person_id: int) -> None:
+    """Fetch + persist one person's TMDB bio OFF the request path — a FastAPI background task that runs
+    AFTER the response is sent, so the outbound TMDB call never sits on the serve latency (the module's
+    "no live TMDB call at serve time" invariant). The request's session is already closed by then, so
+    open a fresh one. Best-effort: a TMDB failure just leaves `tmdb_enriched_at` NULL to retry on the
+    next open, and the bio lands from the row by then."""
+    db = SessionLocal()
+    try:
+        person = db.get(PlexPerson, person_id)
+        if person is not None:
+            plex_tmdb.enrich_person(db, person)
+    except Exception:  # noqa: BLE001 — background best-effort; never surfaces to a user
+        db.rollback()
+        log.warning("background person bio enrich failed for id=%s", person_id, exc_info=True)
+    finally:
+        db.close()
+
+
 @router.get("/person/{name}")
 def person_detail(
     name: str,
+    background_tasks: BackgroundTasks,
     user: User = Depends(current_user),
     db: Session = Depends(get_db),
 ) -> dict:
@@ -88,8 +169,24 @@ def person_detail(
     libraries) whose cast OR directors include this name — the inverse of the cast-name → library-filter
     link. The name string is the identity key (Plex cast carries no stable per-person id), so distinct
     people who share a name share a page. Each section is capped at _PERSON_SECTION_MAX. An unknown name
-    simply returns empty sections."""
-    photo = db.scalar(select(PlexPerson.photo_thumb).where(PlexPerson.name == name))
+    simply returns empty sections.
+
+    E5 S6: the first time a page is opened, the person's TMDB bio + "Known for" credits are lazily
+    fetched (from the S2-linked `tmdb_person_id`) and persisted, then served from the row on every open.
+    The fetch runs OFF the request path (a background task); the first open serves whatever's in the row
+    (bio possibly still null) and the bio lands from the row by the next open.
+    """
+    person = db.execute(select(PlexPerson).where(PlexPerson.name == name)).scalars().first()
+    # Lazy one-time bio enrich, scheduled AFTER the response so the TMDB call is never on the serve path.
+    # Gated by a per-person cooldown so concurrent/rapid opens (or repeated opens while TMDB is degraded)
+    # can't pile background tasks onto the shared threadpool.
+    if (
+        person is not None
+        and person.tmdb_person_id
+        and person.tmdb_enriched_at is None
+        and _should_schedule_enrich(person.id)
+    ):
+        background_tasks.add_task(_enrich_person_bg, person.id)
     movie_lib_ids, show_lib_ids = _content_libs(db)
 
     movies: list[dict] = []
@@ -107,16 +204,7 @@ def person_detail(
             .order_by(PlexItem.year.desc().nullslast(), func.lower(PlexItem.title))
             .limit(_PERSON_SECTION_MAX)
         ).scalars().all()
-        item_ids = [it.id for it in items]
-        states = {
-            s.item_id: s
-            for s in db.execute(
-                select(PlexState).where(
-                    PlexState.user_id == user.id,
-                    PlexState.item_id.in_(item_ids or [0]),
-                )
-            ).scalars()
-        }
+        states = rollup.item_state_map(db, user.id, [it.id for it in items])
         movies = [movie_card(it, states.get(it.id)) for it in items]
 
     shows: list[dict] = []
@@ -136,4 +224,19 @@ def person_detail(
         statuses = rollup.state_map(db, user.id, [s.id for s in show_rows])
         shows = [show_card(sh, statuses.get(sh.id, "new")) for sh in show_rows]
 
-    return {"name": name, "photo": photo, "movies": movies, "shows": shows}
+    known_for = _resolve_known_for(
+        db, person.known_for if person else None, user.id, movie_lib_ids, show_lib_ids
+    )
+    return {
+        "name": name,
+        "photo": person.photo_thumb if person else None,
+        "biography": person.biography if person else None,
+        "birthday": person.birthday if person else None,
+        "deathday": person.deathday if person else None,
+        "place_of_birth": person.place_of_birth if person else None,
+        "known_for_department": person.known_for_department if person else None,
+        "also_known_as": (person.also_known_as if person else None) or [],
+        "known_for": known_for,
+        "movies": movies,
+        "shows": shows,
+    }

backend/app/routes/saved_views.py

@@ -9,11 +9,19 @@ from app.db import get_db
 from app.models import SavedView, User
 from app.routes._common import owned_or_404
 
-# Saved "smart views": per-user named snapshots of the feed's FeedFilters. Gated behind
-# require_human so the shared demo account can't pollute a communal list (mirrors how other
-# personal-state writes are scoped).
+# Saved "smart views": per-user named snapshots of a module's filters (feed or plex, keyed by
+# `source`). Gated behind require_human so the shared demo account can't pollute a communal list
+# (mirrors how other personal-state writes are scoped).
 router = APIRouter(prefix="/api/saved-views", tags=["saved-views"])
 
+# The modules that own saved views. A view is scoped to exactly one; the default is "feed" so a caller
+# (or an older client) that omits `source` keeps the original feed behaviour.
+_SOURCES = {"feed", "plex"}
+
+
+def _norm_source(source: str) -> str:
+    return source if source in _SOURCES else "feed"
+
 
 def _serialize(v: SavedView) -> dict:
     return {
@@ -27,12 +35,15 @@ def _serialize(v: SavedView) -> dict:
 
 @router.get("")
 def list_views(
-    user: User = Depends(require_human), db: Session = Depends(get_db)
+    source: str = "feed",
+    user: User = Depends(require_human),
+    db: Session = Depends(get_db),
 ) -> list[dict]:
+    source = _norm_source(source)
     rows = (
         db.execute(
             select(SavedView)
-            .where(SavedView.user_id == user.id)
+            .where(SavedView.user_id == user.id, SavedView.source == source)
             .order_by(SavedView.position, SavedView.id)
         )
         .scalars()
@@ -44,6 +55,7 @@ def list_views(
 class CreateViewIn(BaseModel):
     name: str
     filters: dict
+    source: str = "feed"
 
 
 @router.post("")
@@ -55,13 +67,19 @@ def create_view(
     name = body.name.strip()
     if not name:
         raise HTTPException(status_code=400, detail="name is required")
+    source = _norm_source(body.source)
+    # Position is per (user, source), so each module's views number 0..N independently.
     maxpos = db.execute(
         select(func.coalesce(func.max(SavedView.position), -1)).where(
-            SavedView.user_id == user.id
+            SavedView.user_id == user.id, SavedView.source == source
         )
     ).scalar_one()
     view = SavedView(
-        user_id=user.id, name=name[:80], filters=body.filters, position=maxpos + 1
+        user_id=user.id,
+        source=source,
+        name=name[:80],
+        filters=body.filters,
+        position=maxpos + 1,
     )
     db.add(view)
     try:
@@ -107,10 +125,14 @@ def update_view(
     if "is_default" in sent:
         make_default = bool(body.is_default)
         if make_default:
-            # At most one default per user: clear the flag on the others first.
+            # At most one default per (user, source): clear the flag on this module's others first.
             db.execute(
                 update(SavedView)
-                .where(SavedView.user_id == user.id, SavedView.id != view.id)
+                .where(
+                    SavedView.user_id == user.id,
+                    SavedView.source == view.source,
+                    SavedView.id != view.id,
+                )
                 .values(is_default=False)
             )
         view.is_default = make_default

backend/app/routes/search.py

@@ -12,6 +12,7 @@ Ingested results are flagged (videos.via_search / channels.from_search) so the L
 this search-discovered "noise" by default. Shorts and currently-live/upcoming videos are never
 ingested this way (Shorts are confirmed by the youtube.com/shorts probe; live/upcoming are
 dropped from the search response up front)."""
+import logging
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 
@@ -43,6 +44,8 @@ from app.youtube import search_scrape
 from app.youtube.client import YouTubeClient, YouTubeError
 from app.youtube.shorts import make_client, probe_is_short
 
+log = logging.getLogger("siftlode.search")
+
 router = APIRouter(prefix="/api/search", tags=["search"])
 
 # search.list costs this many quota units per page.
@@ -136,6 +139,10 @@ def _ingest_candidates(
 
     # 2) Video stubs, flagged via_search. Existing rows keep their flags (ON CONFLICT DO
     #    NOTHING), so an organically-synced video stays organic.
+    #    published_at is NOT NULL (migration 0068); the scrape source exposes no publish date
+    #    (only a relative "3 years ago"), so fall back to now() to satisfy the constraint — the
+    #    enrich in step 3 overwrites it with the video's real snippet date.
+    now = datetime.now(timezone.utc)
     insert_stubs(
         db,
         [
@@ -143,7 +150,7 @@ def _ingest_candidates(
                 "id": it["id"],
                 "channel_id": it["channel_id"],
                 "title": it["title"],
-                "published_at": parse_dt(it["published_at"]),
+                "published_at": parse_dt(it["published_at"]) or now,
                 "thumbnail_url": it["thumbnail_url"],
                 "via_search": True,
             }
@@ -158,13 +165,13 @@ def _ingest_candidates(
             detail_by_id = {it["id"]: it for it in yt.get_videos(ids)}
     except YouTubeError:
         detail_by_id = {}
-    now = datetime.now(timezone.utc)
+    enriched_at = datetime.now(timezone.utc)  # when THIS enrich ran (distinct from the stub placeholder)
     for v in videos:
         item = detail_by_id.get(v.id)
         if item is None:
             continue
         apply_video_details(v, item)
-        v.enriched_at = now
+        v.enriched_at = enriched_at
     db.commit()
 
     # 4) Confirm/deny Shorts (no quota) so none enter via search.
@@ -282,7 +289,19 @@ def search_youtube(
                 and it["channel_id"]
                 and it["channel_id"] not in blocked
             ]
-            collected.extend(_ingest_candidates(db, yt, user, candidates))
+            # Ingest (DB writes + enrich) runs outside the page-fetch try above; guard it too so a
+            # write/shape failure degrades to a 422 with a message on this JSON endpoint instead of a
+            # bare 500 hidden behind the FE's generic "search failed" (same rationale as B-core-1).
+            try:
+                collected.extend(_ingest_candidates(db, yt, user, candidates))
+            except Exception as exc:  # noqa: BLE001 — any ingest failure, not just YouTubeError
+                db.rollback()
+                log.exception("live search ingest failed for %r", term)
+                if collected:
+                    break  # keep what earlier pages already gathered
+                raise HTTPException(
+                    status_code=422, detail=f"YouTube search failed: {exc}"
+                ) from exc
             next_cursor = page["next_page_token"]
             # The API source pages cost 100 units each — never auto-page; one page per request.
             if source == "api" or len(collected) >= limit or not next_cursor:

backend/app/scheduler.py

@@ -17,6 +17,7 @@ from app.demo import reset_demo_state
 from app.downloads.gc import run_download_gc
 from app.models import SchedulerSetting, User
 from app.plex.sync import sync as run_plex_sync
+from app.plex.tmdb import run_enrich as run_tmdb_enrich
 from app.plex.watch_sync import run_plex_watch_reconcile, run_plex_watch_sync
 from app.notifications import create_notification
 from app.state import is_sync_paused
@@ -68,6 +69,7 @@ JOB_INTERVALS: dict[str, int] = {
     "plex_sync": settings.plex_sync_interval_min,
     "plex_watch_sync": settings.plex_watch_sync_interval_min,
     "plex_watch_reconcile": settings.plex_watch_reconcile_interval_min,
+    "tmdb_enrich": settings.tmdb_enrich_interval_min,
     "audit_gc": settings.audit_gc_minutes,
 }
 
@@ -351,6 +353,13 @@ def _plex_watch_reconcile_job() -> None:
     _job("plex_watch_reconcile", run_plex_watch_reconcile)
 
 
+def _tmdb_enrich_job() -> None:
+    # Enrich a batch of mirrored Plex titles from TMDB (keywords/crew/budget/revenue/TMDb score/
+    # recommendations/backdrops), matched by guid. External metadata (no YouTube quota); a no-op when
+    # the TMDB key is unset or the Plex catalog is empty.
+    _job("tmdb_enrich", run_tmdb_enrich)
+
+
 def _audit_gc_job() -> None:
     # Prune audit-log rows older than the admin-set retention (audit_retention_days; 0 = keep
     # forever). Pure DB, no quota.
@@ -378,6 +387,7 @@ JOB_FUNCS: dict[str, Callable[[], None]] = {
     "plex_sync": _plex_sync_job,
     "plex_watch_sync": _plex_watch_sync_job,
     "plex_watch_reconcile": _plex_watch_reconcile_job,
+    "tmdb_enrich": _tmdb_enrich_job,
     "audit_gc": _audit_gc_job,
 }
 

backend/app/sync/videos.py

@@ -245,9 +245,15 @@ def apply_video_details(video: Video, item: dict) -> None:
         video.original_title = raw_title
         video.title = normalize_title(raw_title)
     video.description = snippet.get("description")
-    if not video.published_at:
-        # NOT NULL (0068): a fresh insert with no date yet falls back to now() (enrich normally has one).
-        video.published_at = parse_dt(snippet.get("publishedAt")) or _now()
+    # published_at is NOT NULL (0068). Prefer the enrich snippet's real date whenever it has one —
+    # this also corrects a now() placeholder written at stub time (e.g. a scrape-search stub, which
+    # carries no publish date). Only fall back to now() when the row still has nothing at all; never
+    # clobber an existing real date with now() (a re-enrich whose snippet lacks a date).
+    snippet_published = parse_dt(snippet.get("publishedAt"))
+    if snippet_published:
+        video.published_at = snippet_published
+    elif not video.published_at:
+        video.published_at = _now()
     video.thumbnail_url = best_thumbnail(snippet.get("thumbnails")) or video.thumbnail_url
     video.duration_seconds = parse_iso8601_duration(content.get("duration"))
     video.view_count = int(stats["viewCount"]) if stats.get("viewCount") else None

backend/app/sysconfig.py

@@ -102,6 +102,11 @@ SPECS: tuple[ConfigSpec, ...] = (
     ConfigSpec("plex_max_transcodes", "int", "plex", "plex_max_transcodes", min=0, max=16),
     # NOTE: plex_watch_sync_interval_min is a config.py default read by the watch-sync scheduler job
     # (scheduler.py); it is intentionally NOT a runtime admin knob, so it stays out of SPECS.
+    # --- TMDB enrichment (E5 S2; optional) — the API key is the only secret ---
+    ConfigSpec("tmdb_api_key", "str", "tmdb", "tmdb_api_key", secret=True),
+    ConfigSpec("tmdb_language", "str", "tmdb", "tmdb_language"),
+    # (tmdb_enrich_interval_min is a scheduler job, tuned from the Scheduler dashboard; tmdb_enrich_batch
+    # is a config.py default — both stay out of SPECS, like plex_sync_interval_min.)
 )
 
 _BY_KEY: dict[str, ConfigSpec] = {s.key: s for s in SPECS}

backend/tests/test_feed_views.py

@@ -96,6 +96,7 @@ def _seed_tagged(db, make_user):
         "T1": Tag(user_id=None, name="Tech", category="topic"),
         "T2": Tag(user_id=None, name="Gaming", category="topic"),
         "O1": Tag(user_id=None, name="Favourite", category="other"),
+        "O2": Tag(user_id=None, name="Docs", category="other"),
         # A USER-owned tag (+ a user-owned ChannelTag link below) so the visibility branch
         # `ChannelTag.user_id == user.id` is exercised, not only the system `user_id IS NULL` one.
         "U1": Tag(user_id=user.id, name="MyPin", category="other"),
@@ -104,8 +105,17 @@ def _seed_tagged(db, make_user):
     chans = {c: Channel(id=c, title=c, subscriber_count=10) for c in ("chA", "chB", "chC", "chD")}
     db.add_all(chans.values())
     db.flush()
-    # channel -> (system) tag keys
-    links = {"chA": ["L1", "T1"], "chB": ["L1", "T2"], "chC": ["L2", "T1", "O1"], "chD": []}
+    # channel -> (system) tag keys. chA carries two languages (L1+L2); chC two "other" tags (O1+O2)
+    # AND chA carries O1 too — so the per-category any/all match narrows NON-TRIVIALLY (AND != OR) for
+    # language and other, not only topic: e.g. other {O1,O2} → OR {chA,chC} vs AND {chC}; language
+    # {L1,L2} → OR {chA,chB,chC} vs AND {chA}. (For topic, chA and chB each carry a DIFFERENT topic tag
+    # — T1 vs T2 — so topic {T1,T2} → OR {chA,chB,chC} vs AND {} empty.)
+    links = {
+        "chA": ["L1", "L2", "T1", "O1"],
+        "chB": ["L1", "T2"],
+        "chC": ["L2", "T1", "O1", "O2"],
+        "chD": [],
+    }
     for cid, tkeys in links.items():
         db.add(Subscription(user_id=user.id, channel_id=cid, priority=0, hidden=False))
         for tk in tkeys:
@@ -127,8 +137,12 @@ _SUMMARY_CASES = [
     "show=all&tags={L1}",
     "show=all&tags={T1}",
     "show=all&tags={L1}&tags={T1}",
-    "show=all&tags={T1}&tags={T2}&tag_mode=or",
-    "show=all&tags={T1}&tags={T2}&tag_mode=and",
+    "show=all&tags={T1}&tags={T2}&tag_mode_topic=or",
+    "show=all&tags={T1}&tags={T2}&tag_mode_topic=and",
+    # Per-category any/all is NOT topic-only — language and other must drill down identically too.
+    "show=all&tags={L1}&tags={L2}&tag_mode_language=or",
+    "show=all&tags={L1}&tags={L2}&tag_mode_language=and",
+    "show=all&tags={O1}&tags={O2}&tag_mode_other=and",
     "show=all&tags={U1}",  # user-owned tag (visibility == user.id branch)
     "show=all&tags={U1}&tags={L1}",  # user tag AND a system tag, cross-category
     "show=all&q=clip",

backend/tests/test_plex_cards.py

@@ -0,0 +1,31 @@
+"""Plex card serializers (app.plex.cards) — pure model->dict projections, no DB needed.
+
+E5 S1: movie/show cards now also emit `art` (the wide backdrop, for a Discover rail's landscape tile
+and the crossfading hero), but ONLY when the item actually has an `art_key` — otherwise the URL would
+resolve to a blank image on every card that tried to use it, so it must be null and let the client fall
+back to the poster."""
+
+from app.models import PlexItem, PlexShow
+from app.plex.cards import movie_card, show_card
+
+
+def test_movie_card_emits_art_when_art_key_present():
+    it = PlexItem(rating_key="m1", kind="movie", title="M", year=2020, art_key="/library/art/1")
+    card = movie_card(it, None)
+    assert card["thumb"] == "/api/plex/image/m1"
+    assert card["art"] == "/api/plex/image/m1?variant=art"
+
+
+def test_movie_card_art_is_none_without_art_key():
+    it = PlexItem(rating_key="m2", kind="movie", title="M2")
+    assert movie_card(it, None)["art"] is None
+
+
+def test_show_card_emits_art_when_art_key_present():
+    sh = PlexShow(rating_key="s1", title="S", art_key="/library/art/2")
+    assert show_card(sh)["art"] == "/api/plex/image/s1?variant=art"
+
+
+def test_show_card_art_is_none_without_art_key():
+    sh = PlexShow(rating_key="s2", title="S2")
+    assert show_card(sh)["art"] is None

backend/tests/test_plex_collections_filter.py

@@ -0,0 +1,301 @@
+"""Piece 1a: the Plex collection filter is multi-select with any/all combine (a title can belong to
+several collections). `collections=A,B` = ANY (OR, default); `&collection_mode=all` = ALL (AND).
+DB lane (`db` fixture) — skipped without Postgres.
+"""
+from datetime import datetime, timezone
+
+from fastapi.testclient import TestClient
+from sqlalchemy import select
+
+import app.state as state
+from app.auth import admin_user, current_user
+from app.db import get_db
+from app.main import app
+from app.models import PlexCollection, PlexItem, PlexLibrary, PlexShow, User
+from app.plex.client import PlexError
+from app.routes.plex import collections as coll_routes
+
+
+def _seed(db):
+    """Three movies: one in collection A, one in B, one in both — so any/all are distinguishable."""
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    common = dict(
+        library_id=lib.id,
+        kind="movie",
+        people_enriched_at=datetime(2024, 1, 1, tzinfo=timezone.utc),
+    )
+    db.add_all([
+        PlexItem(rating_key="mA", title="Only A", collection_keys=["A"],
+                 added_at=datetime(2024, 1, 1, tzinfo=timezone.utc), **common),
+        PlexItem(rating_key="mB", title="Only B", collection_keys=["B"],
+                 added_at=datetime(2024, 1, 2, tzinfo=timezone.utc), **common),
+        PlexItem(rating_key="mAB", title="A and B", collection_keys=["A", "B"],
+                 added_at=datetime(2024, 1, 3, tzinfo=timezone.utc), **common),
+    ])
+    user = User(email="plexcoll@example.com")
+    db.add(user)
+    db.commit()
+    return user
+
+
+def _get(db, user, monkeypatch, path):
+    monkeypatch.setattr(state, "_configured_cache", True)
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[current_user] = lambda: user
+    try:
+        return TestClient(app).get(path)
+    finally:
+        app.dependency_overrides.clear()
+
+
+def _titles(resp):
+    return {i["title"] for i in resp.json()["items"]}
+
+
+def test_single_collection_filters_to_its_members(db, monkeypatch):
+    user = _seed(db)
+    resp = _get(db, user, monkeypatch, "/api/plex/library?scope=movie&collections=A")
+    assert _titles(resp) == {"Only A", "A and B"}
+
+
+def test_multiple_collections_any_is_the_union(db, monkeypatch):
+    user = _seed(db)
+    resp = _get(db, user, monkeypatch, "/api/plex/library?scope=movie&collections=A,B")
+    assert _titles(resp) == {"Only A", "Only B", "A and B"}
+
+
+def test_multiple_collections_all_is_the_intersection(db, monkeypatch):
+    user = _seed(db)
+    resp = _get(
+        db, user, monkeypatch,
+        "/api/plex/library?scope=movie&collections=A,B&collection_mode=all",
+    )
+    assert _titles(resp) == {"A and B"}
+
+
+def test_collection_cards_carry_montage_art_and_total_runtime(db, monkeypatch):
+    # The browse-tile montage (top films, best-rated first) + the collection's total runtime.
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    db.add(PlexCollection(rating_key="A", library_id=lib.id, title="Coll A", child_count=2))
+    common = dict(library_id=lib.id, kind="movie", collection_keys=["A"])
+    db.add_all([
+        PlexItem(rating_key="m1", title="M1", duration_s=3600, rating=8.0,
+                 added_at=datetime(2024, 1, 1, tzinfo=timezone.utc), **common),
+        PlexItem(rating_key="m2", title="M2", duration_s=1800, rating=9.0,
+                 added_at=datetime(2024, 1, 2, tzinfo=timezone.utc), **common),
+    ])
+    user = User(email="collart@example.com")
+    db.add(user)
+    db.commit()
+    card = next(c for c in _get(db, user, monkeypatch, "/api/plex/collections").json()["collections"]
+                if c["id"] == "A")
+    assert card["art"] == ["m2", "m1"]  # best-rated first (m2 9.0 > m1 8.0)
+    assert card["total_runtime_s"] == 5400  # 3600 + 1800
+
+
+def test_create_collection_rejects_duplicate_name(db, monkeypatch):
+    # Same-named collections conflate in Plex, so a create with an existing name (case-insensitive) is
+    # rejected 409 — BEFORE any Plex call (the guard runs first, so the DB lane can assert it).
+    monkeypatch.setattr(state, "_configured_cache", True)
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    db.add(PlexCollection(rating_key="A", library_id=lib.id, title="Marvel"))
+    db.add(PlexItem(rating_key="m1", library_id=lib.id, kind="movie", title="M1"))
+    user = User(email="dup@example.com")
+    db.add(user)
+    db.commit()
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[current_user] = lambda: user
+    app.dependency_overrides[admin_user] = lambda: user
+    try:
+        r = TestClient(app).post(
+            "/api/plex/collections",
+            json={"library": "1", "title": "marvel", "item_rating_key": "m1"},
+        )
+        assert r.status_code == 409, r.text
+    finally:
+        app.dependency_overrides.clear()
+
+
+def test_collection_detail_hero_and_ordered_members(db, monkeypatch):
+    # The Collection info page: hero aggregates (year range, most-restrictive cert, total runtime) +
+    # members ordered by release year then title.
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    db.add(PlexCollection(rating_key="A", library_id=lib.id, title="Coll A", summary="S", child_count=2))
+    common = dict(library_id=lib.id, kind="movie", collection_keys=["A"])
+    db.add_all([
+        PlexItem(rating_key="later", title="Later", year=1996, duration_s=3600, content_rating="PG", **common),
+        PlexItem(rating_key="early", title="Early", year=1992, duration_s=1800, content_rating="G", **common),
+    ])
+    user = User(email="cd@example.com")
+    db.add(user)
+    db.commit()
+    d = _get(db, user, monkeypatch, "/api/plex/collections/A").json()
+    assert d["title"] == "Coll A" and d["summary"] == "S"
+    assert d["year_min"] == 1992 and d["year_max"] == 1996
+    assert d["content_rating"] == "PG"  # most restrictive of {G, PG}
+    assert d["total_runtime_s"] == 5400
+    assert [i["id"] for i in d["items"]] == ["early", "later"]  # release-year order
+
+
+# --- Write-through collection mutations (create/add/remove/rename write to Plex, then resync the local
+# mirror). We stub PlexClient so the DB lane can drive the happy path, the 422-on-mutation-failure
+# rollback, and the 502-on-resync-failure split (a successful write whose follow-up refresh read fails
+# must NOT be reported as a write failure). ------------------------------------------------------------
+class _CollStub:
+    """A PlexClient stand-in recording calls; `fail_on` makes one method raise PlexError."""
+
+    def __init__(self, fail_on: str | None = None):
+        self.fail_on = fail_on
+        self.calls: list[str] = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+    def _maybe(self, name: str):
+        self.calls.append(name)
+        if self.fail_on == name:
+            raise PlexError("boom")
+
+    def create_collection(self, section_key, title, item_rating_key):
+        self._maybe("create_collection")
+        return {"ratingKey": "NEW"}
+
+    def add_collection_item(self, rk, item):
+        self._maybe("add_collection_item")
+
+    def remove_collection_item(self, rk, item):
+        self._maybe("remove_collection_item")
+
+    def rename_collection(self, section_key, rk, title):
+        self._maybe("rename_collection")
+
+    def delete_collection(self, rk):
+        self._maybe("delete_collection")
+
+
+def _resync_ok(db, plex, lib, rk):
+    """Stand in for the post-write refresh: return the existing local row (no live Plex read)."""
+    return db.execute(select(PlexCollection).where(PlexCollection.rating_key == rk)).scalars().first()
+
+
+def _seed_editable(db):
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    # Plain, admin-editable collection (title isn't a provider word, not smart → source "collection").
+    db.add(PlexCollection(rating_key="A", library_id=lib.id, title="My Coll", editable=True,
+                          child_count=1))
+    db.add(PlexItem(rating_key="m1", library_id=lib.id, kind="movie", title="M1",
+                    collection_keys=["A"]))
+    user = User(email="mut@example.com")
+    db.add(user)
+    db.commit()
+    return lib, user
+
+
+def _admin_client(db, user, monkeypatch, stub, resync=_resync_ok):
+    monkeypatch.setattr(state, "_configured_cache", True)
+    monkeypatch.setattr(coll_routes, "PlexClient", lambda db: stub)
+    monkeypatch.setattr(coll_routes.plex_sync, "resync_collection", resync)
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[current_user] = lambda: user
+    app.dependency_overrides[admin_user] = lambda: user
+    return TestClient(app)
+
+
+def test_rename_writes_through_to_plex(db, monkeypatch):
+    _lib, user = _seed_editable(db)
+    stub = _CollStub()
+    client = _admin_client(db, user, monkeypatch, stub)
+    try:
+        r = client.patch("/api/plex/collections/A", json={"title": "Renamed"})
+        assert r.status_code == 200, r.text
+        assert "rename_collection" in stub.calls
+    finally:
+        app.dependency_overrides.clear()
+
+
+def test_remove_item_writes_through_to_plex(db, monkeypatch):
+    _lib, user = _seed_editable(db)
+    stub = _CollStub()
+    client = _admin_client(db, user, monkeypatch, stub)
+    try:
+        r = client.delete("/api/plex/collections/A/items/m1")
+        assert r.status_code == 200, r.text
+        assert "remove_collection_item" in stub.calls
+    finally:
+        app.dependency_overrides.clear()
+
+
+def test_mutation_failure_returns_422_write_failed(db, monkeypatch):
+    # The Plex mutation itself raised → the write never landed → 422 "Plex write failed", and resync
+    # is never reached (stub.calls holds only the mutating call).
+    _lib, user = _seed_editable(db)
+    stub = _CollStub(fail_on="rename_collection")
+    client = _admin_client(db, user, monkeypatch, stub)
+    try:
+        r = client.patch("/api/plex/collections/A", json={"title": "Renamed"})
+        assert r.status_code == 422, r.text
+        assert "write failed" in r.json()["detail"].lower()
+    finally:
+        app.dependency_overrides.clear()
+
+
+def test_resync_failure_after_successful_write_is_422_and_rolls_back(db, monkeypatch):
+    # The mutation landed on Plex; only the follow-up refresh READ failed. We must (a) NOT claim a
+    # write failure and NOT use a 5xx (which the frontend treats as offline) → 422 with a "reconcile
+    # on the next sync" detail, and (b) roll back any partial local upsert the resync had flushed.
+    _lib, user = _seed_editable(db)
+    stub = _CollStub()
+
+    def _resync_boom(db_, plex, lib_, rk):
+        # Simulate resync having flushed a partial local change before its Plex read blew up — the
+        # route's rollback must undo it (this is what makes the rollback assertion non-vacuous).
+        row = db_.execute(select(PlexCollection).where(PlexCollection.rating_key == rk)).scalars().first()
+        row.title = "PARTIAL_SHOULD_ROLL_BACK"
+        db_.flush()
+        raise PlexError("read failed")
+
+    client = _admin_client(db, user, monkeypatch, stub, resync=_resync_boom)
+    try:
+        r = client.patch("/api/plex/collections/A", json={"title": "Renamed"})
+        assert r.status_code == 422, r.text
+        assert "reconcile" in r.json()["detail"].lower()
+        assert "rename_collection" in stub.calls  # the write DID happen
+    finally:
+        app.dependency_overrides.clear()
+    row = db.execute(select(PlexCollection).where(PlexCollection.rating_key == "A")).scalars().first()
+    assert row.title == "My Coll"  # the partial resync upsert was rolled back
+
+
+def test_show_collection_gets_montage_art_from_shows(db, monkeypatch):
+    # A show-library collection must get its montage from PlexShow members (else it renders blank) — the
+    # A3 fix that unions movie + show art. Runtime stays 0 (shows have no single duration).
+    lib = PlexLibrary(plex_key="2", title="Shows", kind="show", enabled=True)
+    db.add(lib)
+    db.flush()
+    db.add(PlexCollection(rating_key="S", library_id=lib.id, title="Show Coll", child_count=2))
+    db.add_all([
+        PlexShow(rating_key="s1", library_id=lib.id, title="S1", collection_keys=["S"], rating=7.0,
+                 added_at=datetime(2024, 1, 1, tzinfo=timezone.utc)),
+        PlexShow(rating_key="s2", library_id=lib.id, title="S2", collection_keys=["S"], rating=9.0,
+                 added_at=datetime(2024, 1, 2, tzinfo=timezone.utc)),
+    ])
+    user = User(email="showcoll@example.com")
+    db.add(user)
+    db.commit()
+    card = next(c for c in _get(db, user, monkeypatch, "/api/plex/collections").json()["collections"]
+                if c["id"] == "S")
+    assert card["art"] == ["s2", "s1"]  # show members, best-rated first
+    assert card["total_runtime_s"] == 0

backend/tests/test_plex_discover.py

@@ -0,0 +1,267 @@
+"""E5 S4: the Plex Discover rail-surface. GET /api/plex/discover returns the consolidated rail
+payload (continue watching / recently added / genre tiles / because-you-watched) served from the DB,
+and GET /api/plex/surprise returns a scope-bounded random sample. DB lane (`db` fixture) — skipped
+without Postgres.
+"""
+from datetime import datetime, timedelta, timezone
+
+from fastapi.testclient import TestClient
+from sqlalchemy import select
+
+import app.state as state
+from app.auth import current_user
+from app.db import get_db
+from app.main import app
+from app.models import PlexItem, PlexLibrary, PlexShow, PlexState, User
+
+NOW = datetime(2024, 6, 1, tzinfo=timezone.utc)
+
+
+def _seed(db):
+    """A movie + show library. m1 is a watched, TMDB-enriched anchor whose one recommendation is m2
+    (in library by guid); m3 is a movie in-progress; sh1 is a show with an in-progress episode."""
+    lib_m = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    lib_s = PlexLibrary(plex_key="2", title="Shows", kind="show", enabled=True)
+    db.add_all([lib_m, lib_s])
+    db.flush()
+
+    m1 = PlexItem(
+        rating_key="m1", library_id=lib_m.id, kind="movie", title="Anchor Movie",
+        guid="tmdb:111", genres=["Drama"], year=2001,
+        added_at=NOW - timedelta(days=1),
+        tmdb_enriched_at=NOW - timedelta(days=1),
+        recommendations=[
+            {"tmdb_id": 555, "title": "Rec Movie", "poster_path": None, "media_type": "movie"}
+        ],
+    )
+    m2 = PlexItem(
+        rating_key="m2", library_id=lib_m.id, kind="movie", title="Rec Movie",
+        guid="tmdb:555", genres=["Comedy"], year=2002,
+        added_at=NOW - timedelta(days=2),
+    )
+    m3 = PlexItem(
+        rating_key="m3", library_id=lib_m.id, kind="movie", title="Half-Watched Movie",
+        guid="tmdb:333", genres=["Drama"], year=2003, duration_s=6000,
+        added_at=NOW - timedelta(days=3),
+    )
+    sh1 = PlexShow(rating_key="sh1", library_id=lib_s.id, title="A Show", child_count=1,
+                   added_at=NOW - timedelta(hours=1))  # newest → leads recently-added
+    db.add_all([m1, m2, m3, sh1])
+    db.flush()
+    ep1 = PlexItem(
+        rating_key="sh1e1", library_id=lib_s.id, kind="episode", title="Ep 1",
+        show_id=sh1.id, season_number=1, episode_number=1,
+    )
+    ep2 = PlexItem(
+        rating_key="sh1e2", library_id=lib_s.id, kind="episode", title="Ep 2",
+        show_id=sh1.id, season_number=1, episode_number=2,
+    )
+    db.add_all([ep1, ep2])
+
+    user = User(email="discover@example.com")
+    db.add(user)
+    db.flush()
+
+    db.add_all([
+        # m1 watched most recently → the because-you-watched anchor.
+        PlexState(user_id=user.id, item_id=m1.id, status="watched", watched_at=NOW),
+        # m3 in-progress → continue watching.
+        PlexState(user_id=user.id, item_id=m3.id, status="new", position_seconds=1200,
+                  progress_updated_at=NOW - timedelta(hours=1)),
+        # sh1's ep1 in-progress → the show is in continue watching.
+        PlexState(user_id=user.id, item_id=ep1.id, status="new", position_seconds=300,
+                  progress_updated_at=NOW - timedelta(minutes=30)),
+    ])
+    db.commit()
+    return user
+
+
+def _get(db, user, monkeypatch, path):
+    monkeypatch.setattr(state, "_configured_cache", True)
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[current_user] = lambda: user
+    try:
+        client = TestClient(app)  # no context manager: skip lifespan
+        return client.get(path)
+    finally:
+        app.dependency_overrides.clear()
+
+
+def _ids(cards):
+    return [c["id"] for c in cards]
+
+
+def test_discover_shape_and_recently_added_order(db, monkeypatch):
+    user = _seed(db)
+    resp = _get(db, user, monkeypatch, "/api/plex/discover?scope=both")
+    assert resp.status_code == 200, resp.text
+    d = resp.json()
+    assert set(d) >= {"continue_watching", "recently_added", "genres", "because_you_watched"}
+    # Recently added is newest-first; the show (added 1d ago) leads, then m1, m2, m3.
+    assert _ids(d["recently_added"])[:4] == ["sh1", "m1", "m2", "m3"]
+    # Genre tiles carry counts; Drama (m1 + m3) outweighs Comedy (m2).
+    genres = {g["value"]: g["count"] for g in d["genres"]}
+    assert genres.get("Drama") == 2 and genres.get("Comedy") == 1
+
+
+def test_genre_tiles_carry_poster_art(db, monkeypatch):
+    # Each genre tile carries up to 4 poster rating_keys for the 2×2 collage (top_art_keys): the top
+    # movies in that genre, best-rated then newest. No ratings here → newest-first; shows are excluded.
+    user = _seed(db)
+    d = _get(db, user, monkeypatch, "/api/plex/discover?scope=both").json()
+    art = {g["value"]: g["art"] for g in d["genres"]}
+    assert art["Drama"] == ["m1", "m3"]  # both Drama movies, m1 (newer) first
+    assert art["Comedy"] == ["m2"]
+
+
+def test_continue_watching_movies_and_shows(db, monkeypatch):
+    user = _seed(db)
+    d = _get(db, user, monkeypatch, "/api/plex/discover?scope=both").json()
+    ids = _ids(d["continue_watching"])
+    # The in-progress movie and the show with an in-progress episode are both present; the watched
+    # anchor movie (m1) is not. Order is most-recently-progressed first (the show's ep beats m3).
+    assert ids == ["sh1", "m3"]
+    assert "m1" not in ids
+
+
+def test_continue_watching_null_status_in_hidden_out(db, monkeypatch):
+    # A started movie whose PlexState.status is NULL is still "in progress": `NULL NOT IN (...)` is NULL
+    # (not TRUE), so a bare notin_ would wrongly drop it — the or_(is_(None), notin_) branch keeps it.
+    # A hidden started movie must be excluded.
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    m_null = PlexItem(rating_key="mn", library_id=lib.id, kind="movie", title="Null Status", guid="tmdb:1")
+    m_hidden = PlexItem(rating_key="mh", library_id=lib.id, kind="movie", title="Hidden", guid="tmdb:2")
+    db.add_all([m_null, m_hidden])
+    db.flush()
+    user = User(email="cw-null@example.com")
+    db.add(user)
+    db.flush()
+    db.add_all([
+        PlexState(user_id=user.id, item_id=m_null.id, status=None, position_seconds=500,
+                  progress_updated_at=NOW),
+        PlexState(user_id=user.id, item_id=m_hidden.id, status="hidden", position_seconds=500,
+                  progress_updated_at=NOW - timedelta(hours=1)),
+    ])
+    db.commit()
+
+    ids = _ids(_get(db, user, monkeypatch, "/api/plex/discover?scope=movie").json()["continue_watching"])
+    assert "mn" in ids  # NULL-status started movie IS in progress
+    assert "mh" not in ids  # hidden is excluded
+
+
+def test_continue_watching_excludes_fully_watched_show(db, monkeypatch):
+    # A show whose every episode is watched is DONE, not in-progress: the `watched < total` guard must
+    # keep it off the Continue-watching rail (a bare `watched > 0` would wrongly resurface it).
+    lib_s = PlexLibrary(plex_key="2", title="Shows", kind="show", enabled=True)
+    db.add(lib_s)
+    db.flush()
+    sh = PlexShow(rating_key="shw", library_id=lib_s.id, title="All Watched", child_count=1)
+    db.add(sh)
+    db.flush()
+    ep = PlexItem(rating_key="shwe1", library_id=lib_s.id, kind="episode", title="E1",
+                  show_id=sh.id, season_number=1, episode_number=1)
+    db.add(ep)
+    db.flush()
+    user = User(email="fullywatched@example.com")
+    db.add(user)
+    db.flush()
+    db.add(PlexState(user_id=user.id, item_id=ep.id, status="watched", position_seconds=0,
+                     progress_updated_at=NOW))
+    db.commit()
+
+    ids = _ids(_get(db, user, monkeypatch, "/api/plex/discover?scope=show").json()["continue_watching"])
+    assert "shw" not in ids  # fully watched → excluded from continue-watching
+
+
+def test_because_you_watched_resolves_in_library_recs(db, monkeypatch):
+    user = _seed(db)
+    d = _get(db, user, monkeypatch, "/api/plex/discover?scope=both").json()
+    bw = d["because_you_watched"]
+    assert bw is not None
+    assert bw["anchor"]["id"] == "m1" and bw["anchor"]["title"] == "Anchor Movie"
+    # m1's single recommendation (tmdb:555) is m2 in our library → it becomes the one rail card.
+    assert _ids(bw["items"]) == ["m2"]
+
+
+def test_because_you_watched_null_without_history(db, monkeypatch):
+    _seed(db)
+    fresh = User(email="fresh-discover@example.com")
+    db.add(fresh)
+    db.commit()
+    d = _get(db, fresh, monkeypatch, "/api/plex/discover?scope=both").json()
+    # A user with no watched-and-enriched movie gets no recommendation rail.
+    assert d["because_you_watched"] is None
+    assert d["continue_watching"] == []
+
+
+def test_surprise_scope_and_bound(db, monkeypatch):
+    user = _seed(db)
+    resp = _get(db, user, monkeypatch, "/api/plex/surprise?scope=movie&limit=2")
+    assert resp.status_code == 200, resp.text
+    items = resp.json()["items"]
+    assert len(items) <= 2
+    assert all(c["type"] == "movie" for c in items)  # scope=movie excludes shows
+
+
+def test_recently_watched_movies_and_episodes(db, monkeypatch):
+    # The rail lists last-fully-watched titles newest-first: a watched MOVIE as its own card, a show as
+    # the specific watched EPISODE (with its show title). _seed watches m1 (movie); add a watched episode.
+    user = _seed(db)
+    ep2 = db.execute(
+        select(PlexItem).where(PlexItem.rating_key == "sh1e2")
+    ).scalars().one()
+    db.add(PlexState(user_id=user.id, item_id=ep2.id, status="watched", watched_at=NOW))
+    db.commit()
+    rw = _get(db, user, monkeypatch, "/api/plex/discover?scope=both").json()["recently_watched"]
+    by_id = {c["id"]: c for c in rw}
+    assert "m1" in by_id and by_id["m1"]["type"] == "movie"
+    assert "sh1e2" in by_id and by_id["sh1e2"]["type"] == "episode"
+    assert by_id["sh1e2"]["show_title"] == "A Show"  # episode carries its show's title
+    # ep2 was watched at NOW (newest) → it leads over m1 (watched earlier in _seed... same NOW ok).
+    assert set(_ids(rw)) == {"m1", "sh1e2"}
+
+
+def test_surprise_excludes_watched_and_caps_per_kind(db, monkeypatch):
+    # Surprise surfaces only UNSEEN titles: the watched movie (m1) is out; the unwatched (m2), the
+    # in-progress movie (m3) and the partially-watched show (sh1) are eligible. Capped at 3 per kind.
+    user = _seed(db)
+    items = _get(db, user, monkeypatch, "/api/plex/surprise?scope=both").json()["items"]
+    ids = _ids(items)
+    assert "m1" not in ids  # watched → excluded
+    assert set(ids) <= {"m2", "m3", "sh1"}  # only unseen titles
+    assert len([c for c in items if c["type"] == "movie"]) <= 3
+    assert len([c for c in items if c["type"] == "show"]) <= 3
+
+
+def test_discover_scope_movie_excludes_shows(db, monkeypatch):
+    user = _seed(db)
+    d = _get(db, user, monkeypatch, "/api/plex/discover?scope=movie").json()
+    assert all(c["type"] == "movie" for c in d["recently_added"])
+    # The show drops out of continue watching under the movie scope.
+    assert _ids(d["continue_watching"]) == ["m3"]
+
+
+def test_filters_narrow_every_discover_rail(db, monkeypatch):
+    # The sidebar filters constrain the Discover rails just like the Browse grid (ask 3). A genre=Drama
+    # filter keeps only the Drama titles across every rail; the genre-less show and the Comedy rec drop.
+    user = _seed(db)
+    d = _get(db, user, monkeypatch, "/api/plex/discover?scope=both&genres=Drama").json()
+    # Recently-added: m1 + m3 (Drama) survive; Comedy m2 and the genre-less show sh1 are filtered out.
+    assert set(_ids(d["recently_added"])) == {"m1", "m3"}
+    # Continue-watching: only the in-progress Drama movie remains (the show has no genres → excluded).
+    assert _ids(d["continue_watching"]) == ["m3"]
+    # Genre tiles reflect the filtered set — only Drama, count 2 (m1 + m3).
+    assert {g["value"]: g["count"] for g in d["genres"]} == {"Drama": 2}
+    # Because-you-watched: the anchor m1 is watched, but its only rec (m2) is Comedy → filtered → no rail.
+    assert d["because_you_watched"] is None
+
+
+def test_filters_narrow_surprise(db, monkeypatch):
+    user = _seed(db)
+    items = _get(
+        db, user, monkeypatch, "/api/plex/surprise?scope=movie&genres=Comedy"
+    ).json()["items"]
+    # Only the one Comedy movie qualifies under the filter.
+    assert _ids(items) == ["m2"]

backend/tests/test_plex_facets.py

@@ -12,7 +12,33 @@ import app.state as state
 from app.auth import current_user
 from app.db import get_db
 from app.main import app
-from app.models import PlexLibrary, PlexShow, User
+from app.models import PlexItem, PlexLibrary, PlexShow, User
+
+
+def test_facets_returns_studio_vocabulary(db, monkeypatch):
+    """E5 S7: /facets returns the studio vocabulary (distinct studio + count) for the sidebar picker."""
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    db.add_all([
+        PlexItem(rating_key="m1", library_id=lib.id, kind="movie", title="A", studio="Pixar"),
+        PlexItem(rating_key="m2", library_id=lib.id, kind="movie", title="B", studio="Pixar"),
+        PlexItem(rating_key="m3", library_id=lib.id, kind="movie", title="C", studio="A24"),
+        PlexItem(rating_key="m4", library_id=lib.id, kind="movie", title="D"),  # no studio
+    ])
+    user = User(email="studiofacets@example.com")
+    db.add(user)
+    db.commit()
+    monkeypatch.setattr(state, "_configured_cache", True)
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[current_user] = lambda: user
+    try:
+        resp = TestClient(app).get("/api/plex/facets?scope=movie")
+    finally:
+        app.dependency_overrides.clear()
+    assert resp.status_code == 200, resp.text
+    studios = {s["value"]: s["count"] for s in resp.json()["studios"]}
+    assert studios == {"Pixar": 2, "A24": 1}
 
 
 def test_facets_survives_json_null_genres(db, monkeypatch):

backend/tests/test_plex_keyword_filter.py

@@ -0,0 +1,61 @@
+"""E5 S5: the TMDB keyword filter. A keyword chip on the detail page sets ?keywords=<kw>, which
+narrows the unified library to rows whose persisted `keywords` JSONB array contains it. DB lane
+(`db` fixture) — skipped without Postgres.
+"""
+from fastapi.testclient import TestClient
+
+import app.state as state
+from app.auth import current_user
+from app.db import get_db
+from app.main import app
+from app.models import PlexItem, PlexLibrary, User
+
+
+def _seed(db):
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    db.add_all([
+        PlexItem(rating_key="m1", library_id=lib.id, kind="movie", title="Heist Movie",
+                 keywords=["heist", "bank robbery"]),
+        PlexItem(rating_key="m2", library_id=lib.id, kind="movie", title="Space Movie",
+                 keywords=["space", "aliens"]),
+        PlexItem(rating_key="m3", library_id=lib.id, kind="movie", title="No Keywords Movie"),
+    ])
+    user = User(email="kwfilter@example.com")
+    db.add(user)
+    db.commit()
+    return user
+
+
+def _get(db, user, monkeypatch, path):
+    monkeypatch.setattr(state, "_configured_cache", True)
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[current_user] = lambda: user
+    try:
+        return TestClient(app).get(path)
+    finally:
+        app.dependency_overrides.clear()
+
+
+def _titles(resp):
+    return {i["title"] for i in resp.json()["items"]}
+
+
+def test_keyword_filter_narrows_to_matching_rows(db, monkeypatch):
+    user = _seed(db)
+    resp = _get(db, user, monkeypatch, "/api/plex/library?scope=movie&keywords=heist")
+    assert resp.status_code == 200, resp.text
+    assert _titles(resp) == {"Heist Movie"}
+
+
+def test_no_keyword_filter_returns_all(db, monkeypatch):
+    user = _seed(db)
+    resp = _get(db, user, monkeypatch, "/api/plex/library?scope=movie")
+    assert _titles(resp) == {"Heist Movie", "Space Movie", "No Keywords Movie"}
+
+
+def test_unknown_keyword_matches_nothing(db, monkeypatch):
+    user = _seed(db)
+    resp = _get(db, user, monkeypatch, "/api/plex/library?scope=movie&keywords=nonesuch")
+    assert resp.json()["items"] == []

backend/tests/test_plex_person.py

@@ -100,7 +100,20 @@ def test_person_detail_unknown_name_is_empty(db, monkeypatch):
     resp = _get(db, user, monkeypatch, "/api/plex/person/Ghost%20Actor")
     assert resp.status_code == 200, resp.text
     body = resp.json()
-    assert body == {"name": "Ghost Actor", "photo": None, "movies": [], "shows": []}
+    # An unknown name has no plex_people row → no bio, no titles (E5 S6 added the bio fields, all null).
+    assert body == {
+        "name": "Ghost Actor",
+        "photo": None,
+        "biography": None,
+        "birthday": None,
+        "deathday": None,
+        "place_of_birth": None,
+        "known_for_department": None,
+        "also_known_as": [],
+        "known_for": [],
+        "movies": [],
+        "shows": [],
+    }
 
 
 def test_content_libs_partitions_only_enabled(db):

backend/tests/test_plex_person_bio.py

@@ -0,0 +1,292 @@
+"""E5 S6: person page TMDB bio enrichment. `parse_person` shapes the /person payload (bio + a
+popularity-ranked, deduped `known_for`); `enrich_person` lazily fetches + persists once (guarded on a
+key + a tmdb_person_id); and /person/{name} serves the bio + resolves `known_for` to library rows.
+DB lane for the endpoint/enrich tests; parse_person is pure. Skipped without Postgres where DB-backed.
+"""
+from fastapi.testclient import TestClient
+
+import app.state as state
+from app.auth import current_user
+from app.db import get_db
+from app.main import app
+from app.models import PlexItem, PlexLibrary, PlexPerson, User
+from app.plex import tmdb as plex_tmdb
+
+PAYLOAD = {
+    "biography": "  A celebrated actor.  ",
+    "birthday": "1970-01-01",
+    "deathday": None,
+    "place_of_birth": "Springfield",
+    "known_for_department": "Acting",
+    "also_known_as": ["AKA One", "AKA Two"],
+    "combined_credits": {
+        "cast": [
+            {"id": 10, "media_type": "movie", "title": "Mid Movie", "popularity": 50},
+            {"id": 20, "media_type": "tv", "name": "Top Show", "popularity": 80},
+            {"id": 10, "media_type": "movie", "title": "dup", "popularity": 5},  # dup id
+            {"id": 30, "media_type": "movie", "title": "Low Movie", "popularity": 1},
+            {"id": None, "media_type": "movie", "title": "No id", "popularity": 99},  # dropped
+        ]
+    },
+}
+
+
+def test_parse_person_shapes_bio_and_ranked_known_for():
+    p = plex_tmdb.parse_person(PAYLOAD)
+    assert p["biography"] == "A celebrated actor."  # stripped
+    assert p["birthday"] == "1970-01-01"
+    assert p["known_for_department"] == "Acting"
+    assert p["also_known_as"] == ["AKA One", "AKA Two"]
+    # Popularity desc, deduped by id, None-id dropped: Top Show (80) → Mid Movie (50) → Low Movie (1).
+    assert [k["tmdb_id"] for k in p["known_for"]] == [20, 10, 30]
+    assert p["known_for"][0]["media_type"] == "tv"
+
+
+def test_parse_person_empty_payload():
+    p = plex_tmdb.parse_person({})
+    assert p["biography"] is None and p["known_for"] is None
+
+
+def test_parse_person_keeps_same_id_across_media_types():
+    # TMDB movie ids and tv ids are independent, so a movie-42 and a tv-42 credit are two distinct works
+    # and BOTH must survive the dedup (keyed on (id, media_type), not the bare id).
+    payload = {
+        "combined_credits": {
+            "cast": [
+                {"id": 42, "media_type": "movie", "title": "Movie 42", "popularity": 90},
+                {"id": 42, "media_type": "tv", "name": "Show 42", "popularity": 80},
+                {"id": 42, "media_type": "movie", "title": "dup movie 42", "popularity": 5},  # real dup
+            ]
+        }
+    }
+    kf = plex_tmdb.parse_person(payload)["known_for"]
+    assert [(k["tmdb_id"], k["media_type"]) for k in kf] == [(42, "movie"), (42, "tv")]  # both kept, dup dropped
+
+
+class _FakeTmdb:
+    def __init__(self, payload):
+        self.payload = payload
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+    def fetch_person(self, pid):
+        return self.payload
+
+
+def test_enrich_person_persists_and_stamps(db, monkeypatch):
+    person = PlexPerson(name="Actor X", tmdb_person_id=555)
+    db.add(person)
+    db.commit()
+    monkeypatch.setattr(plex_tmdb.sysconfig, "get_str", lambda d, k: "key" if k == "tmdb_api_key" else "")
+    monkeypatch.setattr(plex_tmdb, "TmdbClient", lambda d, timeout=None: _FakeTmdb(PAYLOAD))
+    assert plex_tmdb.enrich_person(db, person) is True
+    assert person.biography == "A celebrated actor."
+    assert person.tmdb_enriched_at is not None
+    assert [k["tmdb_id"] for k in person.known_for] == [20, 10, 30]
+
+
+class _FakeTmdbResult:
+    """Context-manager TmdbClient stand-in whose fetch_person raises / returns a fixed payload."""
+
+    def __init__(self, *, raises=False, payload=None):
+        self._raises = raises
+        self._payload = payload
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+    def fetch_person(self, pid):
+        if self._raises:
+            raise plex_tmdb.TmdbError("429 rate limited")
+        return self._payload
+
+
+def test_enrich_person_transient_error_leaves_watermark_null(db, monkeypatch):
+    # A transient TmdbError must NOT stamp the watermark, so the next open retries (never permanently
+    # blank a person after one blip).
+    person = PlexPerson(name="Transient P", tmdb_person_id=555)
+    db.add(person)
+    db.commit()
+    monkeypatch.setattr(plex_tmdb.sysconfig, "get_str", lambda d, k: "key" if k == "tmdb_api_key" else "")
+    monkeypatch.setattr(plex_tmdb, "TmdbClient", lambda d, timeout=None: _FakeTmdbResult(raises=True))
+    assert plex_tmdb.enrich_person(db, person) is False
+    assert person.tmdb_enriched_at is None  # left NULL → retried next open
+
+
+def test_enrich_person_404_stamps_watermark_without_bio(db, monkeypatch):
+    # A 404 (deleted person → None payload) stamps the watermark so it isn't refetched every open.
+    person = PlexPerson(name="Gone P", tmdb_person_id=555)
+    db.add(person)
+    db.commit()
+    monkeypatch.setattr(plex_tmdb.sysconfig, "get_str", lambda d, k: "key" if k == "tmdb_api_key" else "")
+    monkeypatch.setattr(plex_tmdb, "TmdbClient", lambda d, timeout=None: _FakeTmdbResult(payload=None))
+    assert plex_tmdb.enrich_person(db, person) is True
+    assert person.tmdb_enriched_at is not None  # stamped
+    assert person.biography is None  # nothing fetched
+
+
+def test_enrich_person_noop_without_key(db, monkeypatch):
+    person = PlexPerson(name="Actor Y", tmdb_person_id=555)
+    db.add(person)
+    db.commit()
+    monkeypatch.setattr(plex_tmdb.sysconfig, "get_str", lambda d, k: "")  # no key
+    assert plex_tmdb.enrich_person(db, person) is False
+    assert person.tmdb_enriched_at is None
+
+
+def test_enrich_person_noop_without_tmdb_id(db, monkeypatch):
+    person = PlexPerson(name="Actor Z", tmdb_person_id=None)
+    db.add(person)
+    db.commit()
+    monkeypatch.setattr(plex_tmdb.sysconfig, "get_str", lambda d, k: "key")
+    assert plex_tmdb.enrich_person(db, person) is False
+
+
+def _get(db, user, monkeypatch, path):
+    monkeypatch.setattr(state, "_configured_cache", True)
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[current_user] = lambda: user
+    try:
+        return TestClient(app).get(path)
+    finally:
+        app.dependency_overrides.clear()
+
+
+def test_person_detail_schedules_enrich_off_request_path(db, monkeypatch):
+    # The bio fetch runs OFF the request path (a background task after the response), so the serve never
+    # makes a live TMDB call. An un-enriched person (tmdb_person_id set + tmdb_enriched_at None) schedules
+    # the enrich and the page still renders immediately with whatever's in the row (bio still null).
+    from app.routes.plex import people
+
+    lib = PlexLibrary(plex_key="9", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    db.add(PlexPerson(name="Lazy P", tmdb_person_id=777))
+    user = User(email="lazybg@example.com")
+    db.add(user)
+    db.commit()
+
+    scheduled: list[int] = []
+    monkeypatch.setattr(people, "_enrich_person_bg", lambda pid: scheduled.append(pid))
+    people._enrich_inflight.clear()  # ensure the per-person cooldown guard doesn't suppress this open
+
+    resp = _get(db, user, monkeypatch, "/api/plex/person/Lazy P")
+    assert resp.status_code == 200, resp.text
+    assert resp.json()["biography"] is None  # not enriched yet — the bio lands by the next open
+    assert len(scheduled) == 1  # the enrich was scheduled off the request path
+
+
+def test_enrich_person_bg_closes_session_and_isolates_errors(monkeypatch):
+    # The background-task body must open a fresh session, fetch the person, and ALWAYS close it — rolling
+    # back (never propagating) if enrich_person raises. Pure-unit via a fake session (no DB needed).
+    from app.routes.plex import people
+
+    calls = {"rollback": 0, "close": 0, "enriched": 0}
+
+    class _FakeSession:
+        def __init__(self, person):
+            self._person = person
+
+        def get(self, model, pid):
+            return self._person
+
+        def rollback(self):
+            calls["rollback"] += 1
+
+        def close(self):
+            calls["close"] += 1
+
+    # Success path: person found → enrich called, session closed, no rollback.
+    monkeypatch.setattr(people, "SessionLocal", lambda: _FakeSession(object()))
+    monkeypatch.setattr(
+        people.plex_tmdb, "enrich_person", lambda db, p: calls.__setitem__("enriched", calls["enriched"] + 1)
+    )
+    people._enrich_person_bg(5)
+    assert calls == {"rollback": 0, "close": 1, "enriched": 1}
+
+    # Error path: enrich raises → rollback + close, no exception escapes.
+    calls.update({"rollback": 0, "close": 0, "enriched": 0})
+
+    def _boom(db, p):
+        raise RuntimeError("enrich blew up")
+
+    monkeypatch.setattr(people.plex_tmdb, "enrich_person", _boom)
+    people._enrich_person_bg(5)  # must not raise
+    assert calls["rollback"] == 1 and calls["close"] == 1
+
+    # Missing person (deleted id): None-guard skips enrich, session still closed.
+    calls.update({"rollback": 0, "close": 0, "enriched": 0})
+    monkeypatch.setattr(people, "SessionLocal", lambda: _FakeSession(None))
+    people._enrich_person_bg(9)
+    assert calls == {"rollback": 0, "close": 1, "enriched": 0}
+
+
+def test_should_schedule_enrich_dedups_within_cooldown():
+    # Concurrent/rapid opens of the same person must schedule the enrich only once per cooldown window.
+    from app.routes.plex import people
+
+    people._enrich_inflight.clear()
+    assert people._should_schedule_enrich(12345) is True  # first open reserves
+    assert people._should_schedule_enrich(12345) is False  # within cooldown → deduped
+    assert people._should_schedule_enrich(99999) is True  # a different person is independent
+    people._enrich_inflight.clear()
+
+
+def test_person_detail_no_enrich_when_already_enriched(db, monkeypatch):
+    # An already-enriched person (tmdb_enriched_at set) must NOT schedule another background fetch.
+    from datetime import datetime, timezone
+
+    from app.routes.plex import people
+
+    lib = PlexLibrary(plex_key="8", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    db.add(PlexPerson(name="Done P", tmdb_person_id=888,
+                      tmdb_enriched_at=datetime(2024, 1, 1, tzinfo=timezone.utc), biography="Bio."))
+    user = User(email="donebg@example.com")
+    db.add(user)
+    db.commit()
+
+    scheduled: list[int] = []
+    monkeypatch.setattr(people, "_enrich_person_bg", lambda pid: scheduled.append(pid))
+
+    resp = _get(db, user, monkeypatch, "/api/plex/person/Done P")
+    assert resp.status_code == 200, resp.text
+    assert resp.json()["biography"] == "Bio."
+    assert scheduled == []  # already enriched → no background work
+
+
+def test_person_detail_serves_bio_and_resolves_known_for(db, monkeypatch):
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    db.add(lib)
+    db.flush()
+    # A library movie that IS one of the person's known_for credits (matched by guid tmdb:100).
+    db.add(PlexItem(rating_key="km", library_id=lib.id, kind="movie", title="Known Movie",
+                    guid="tmdb:100", cast_names=["Actor X"]))
+    # Already-enriched person (tmdb_enriched_at set → no lazy fetch), with a known_for pool.
+    from datetime import datetime, timezone
+    db.add(PlexPerson(name="Actor X", tmdb_person_id=555,
+                      tmdb_enriched_at=datetime(2024, 1, 1, tzinfo=timezone.utc),
+                      biography="Bio here.", birthday="1970-01-01", known_for_department="Acting",
+                      also_known_as=["Alt Name"],
+                      known_for=[{"tmdb_id": 100, "media_type": "movie", "title": "Known Movie"},
+                                 {"tmdb_id": 999, "media_type": "movie", "title": "Not In Library"}]))
+    user = User(email="personbio@example.com")
+    db.add(user)
+    db.commit()
+
+    resp = _get(db, user, monkeypatch, "/api/plex/person/Actor X")
+    assert resp.status_code == 200, resp.text
+    j = resp.json()
+    assert j["biography"] == "Bio here."
+    assert j["birthday"] == "1970-01-01"
+    assert j["also_known_as"] == ["Alt Name"]
+    # Only the in-library known_for credit resolves to a card; the out-of-library one is dropped.
+    assert [c["title"] for c in j["known_for"]] == ["Known Movie"]

backend/tests/test_plex_tmdb.py

@@ -0,0 +1,365 @@
+"""TMDB enrichment engine (E5 S2): the pure parser + persister, guid→tmdb-id resolution, and the
+DB-lane batch/serve integration (enrich stamps the watermark + links people; serve_block resolves
+recommendations to library rows; the whole thing no-ops without an API key).
+
+The DB tests use the `db` fixture (real Postgres) — skipped when none is reachable."""
+from datetime import datetime, timezone
+
+import httpx
+import pytest
+
+from app.models import PlexItem, PlexLibrary, PlexPerson, PlexShow
+from app.plex import tmdb
+
+# A TMDB /movie/{id}?append_to_response=keywords,credits,recommendations,images,external_ids payload.
+MOVIE_PAYLOAD = {
+    "id": 238,
+    "vote_average": 8.7,
+    "vote_count": 20000,
+    "budget": 6000000,
+    "revenue": 245066411,
+    "keywords": {"keywords": [{"id": 1, "name": "mafia"}, {"id": 2, "name": "crime family"}]},
+    "credits": {
+        "cast": [
+            {"id": 3084, "name": "Marlon Brando", "character": "Vito", "profile_path": "/a.jpg", "order": 0},
+            {"id": 1158, "name": "Al Pacino", "character": "Michael", "profile_path": "/b.jpg", "order": 1},
+        ],
+        "crew": [
+            {"id": 1776, "name": "Francis Ford Coppola", "job": "Director", "profile_path": "/c.jpg"},
+            {"id": 1776, "name": "Francis Ford Coppola", "job": "Writer", "profile_path": "/c.jpg"},
+            {"id": 9, "name": "Some Gaffer", "job": "Gaffer"},  # not a key job → dropped
+        ],
+    },
+    "production_companies": [{"name": "Paramount"}, {"name": "Alfran"}],
+    "production_countries": [{"name": "United States of America"}],
+    "recommendations": {
+        "results": [
+            {"id": 240, "title": "The Godfather Part II", "poster_path": "/p.jpg", "media_type": "movie"},
+            {"id": 999, "title": "Not In Library", "poster_path": "/q.jpg", "media_type": "movie"},
+        ]
+    },
+    "images": {"backdrops": [{"file_path": "/bd1.jpg"}, {"file_path": "/bd2.jpg"}]},
+    "external_ids": {"imdb_id": "tt0068646"},
+}
+
+# A TMDB /tv payload: keywords under `results`, aggregate_credits with per-person `jobs`, no budget.
+TV_PAYLOAD = {
+    "id": 1396,
+    "vote_average": 9.0,
+    "vote_count": 12000,
+    "created_by": [{"id": 66633, "name": "Vince Gilligan", "profile_path": "/vg.jpg"}],
+    "keywords": {"results": [{"name": "drugs"}, {"name": "new mexico"}]},
+    "aggregate_credits": {
+        "cast": [{"id": 17419, "name": "Bryan Cranston"}],
+        "crew": [
+            {"id": 66633, "name": "Vince Gilligan", "jobs": [{"job": "Executive Producer"}]},
+            {"id": 5, "name": "Someone", "jobs": [{"job": "Sound"}]},  # dropped
+        ],
+    },
+    "production_companies": [{"name": "Sony Pictures Television"}],
+    "production_countries": [{"name": "United States of America"}],
+    "recommendations": {"results": []},
+    "images": {"backdrops": []},
+}
+
+
+class FakeTmdb:
+    """Stand-in for TmdbClient in the parse/batch tests — no network."""
+
+    def __init__(self, payloads=None, find_map=None):
+        self.payloads = payloads or {}  # (media_type, tmdb_id) -> payload
+        self.find_map = find_map or {}  # external_id -> /find result
+
+    def fetch(self, tmdb_id, media_type):
+        return self.payloads.get((media_type, tmdb_id))
+
+    def find(self, external_id, source):
+        return self.find_map.get(external_id)
+
+
+# ---- pure parse/persist --------------------------------------------------------------------------
+
+def test_parse_movie_pulls_all_fields():
+    d = tmdb.parse_tmdb(MOVIE_PAYLOAD, "movie")
+    assert d["tmdb_id"] == 238
+    assert d["tmdb_rating"] == 8.7
+    assert d["tmdb_vote_count"] == 20000
+    assert d["budget"] == 6000000
+    assert d["revenue"] == 245066411
+    assert d["keywords"] == ["mafia", "crime family"]
+    assert d["crew"] == [
+        {"name": "Francis Ford Coppola", "job": "Director", "tmdb_id": 1776, "profile_path": "/c.jpg"},
+        {"name": "Francis Ford Coppola", "job": "Writer", "tmdb_id": 1776, "profile_path": "/c.jpg"},
+    ]  # the Gaffer is filtered; the two Coppola jobs survive (dedup is by name+job)
+    assert d["studios"] == ["Paramount", "Alfran"]
+    assert d["production_countries"] == ["United States of America"]
+    assert [r["tmdb_id"] for r in d["recommendations"]] == [240, 999]
+    assert d["backdrops"] == ["/bd1.jpg", "/bd2.jpg"]
+    # cast + crew names → tmdb person ids for the plex_people foundation
+    links = {(p["name"], p["tmdb_id"]) for p in d["people"]}
+    assert ("Marlon Brando", 3084) in links
+    assert ("Al Pacino", 1158) in links
+    assert ("Francis Ford Coppola", 1776) in links
+
+
+def test_parse_tv_uses_aggregate_credits_and_no_money():
+    d = tmdb.parse_tmdb(TV_PAYLOAD, "tv")
+    assert d["budget"] is None and d["revenue"] is None  # TV has neither
+    assert d["keywords"] == ["drugs", "new mexico"]  # from keywords.results
+    # The showrunner (created_by → Creator) leads; the aggregate-credits EP follows; the Sound person is
+    # filtered; TV jobs are read from jobs[0]. Crew is display-priority ordered (Creator before EP).
+    assert d["crew"] == [
+        {"name": "Vince Gilligan", "job": "Creator", "tmdb_id": 66633, "profile_path": "/vg.jpg"},
+        {"name": "Vince Gilligan", "job": "Executive Producer", "tmdb_id": 66633, "profile_path": None},
+    ]
+    assert d["tmdb_rating"] == 9.0
+    assert ("Bryan Cranston", 17419) in {(p["name"], p["tmdb_id"]) for p in d["people"]}
+
+
+def test_parse_zero_votes_and_money_are_unknown():
+    d = tmdb.parse_tmdb({"id": 1, "vote_average": 0.0, "vote_count": 0, "budget": 0, "revenue": 0}, "movie")
+    assert d["tmdb_rating"] is None  # 0.0 with no votes is meaningless
+    assert d["tmdb_vote_count"] is None
+    assert d["budget"] is None and d["revenue"] is None
+
+
+def test_apply_writes_row_fields_without_touching_plex_owned():
+    it = PlexItem(rating_key="m1", kind="movie", title="The Godfather", imdb_rating=8.7, full_cast=[{"x": 1}])
+    tmdb.apply_tmdb_detail(it, tmdb.parse_tmdb(MOVIE_PAYLOAD, "movie"))
+    assert it.tmdb_id == 238
+    assert it.budget == 6000000
+    assert it.keywords == ["mafia", "crime family"]
+    assert it.imdb_rating == 8.7 and it.full_cast == [{"x": 1}]  # Plex-owned, untouched
+
+
+def test_guid_to_tmdb_id_direct_find_and_bad():
+    fake = FakeTmdb(find_map={"tt0068646": {"movie_results": [{"id": 238}], "tv_results": []}})
+    assert tmdb.guid_to_tmdb_id("tmdb:238", "movie", fake) == 238
+    assert tmdb.guid_to_tmdb_id("imdb:tt0068646", "movie", fake) == 238  # resolved via /find
+    assert tmdb.guid_to_tmdb_id("imdb:tt0000000", "movie", fake) is None  # not in find_map
+    assert tmdb.guid_to_tmdb_id("tmdb:notanumber", "movie", fake) is None
+    assert tmdb.guid_to_tmdb_id(None, "movie", fake) is None
+    assert tmdb.guid_to_tmdb_id("local://abc", "movie", fake) is None
+
+
+def test_guid_to_tmdb_id_tvdb_source_and_tv_media_type():
+    # A tvdb guid for a TV item goes through /find and must pick the tv_results list (not movie_results),
+    # and a tvdb source maps to the tvdb_id external_source. The media_type branch is the whole point.
+    fake = FakeTmdb(find_map={"81189": {"movie_results": [], "tv_results": [{"id": 1396}]}})
+    assert tmdb.guid_to_tmdb_id("tvdb:81189", "tv", fake) == 1396
+    # The SAME /find result, asked for a movie, reads the (empty) movie_results → None.
+    assert tmdb.guid_to_tmdb_id("tvdb:81189", "movie", fake) is None
+    # A direct tmdb guid for a tv item is just the int (no /find).
+    assert tmdb.guid_to_tmdb_id("tmdb:1396", "tv", fake) == 1396
+    # An unknown provider (only imdb/tvdb are /find sources) is unresolvable.
+    assert tmdb.guid_to_tmdb_id("plex:abc", "tv", fake) is None
+
+
+# ---- DB-lane: batch enrich + serve --------------------------------------------------------------
+
+def _lib(db, key="1", kind="movie"):
+    lib = PlexLibrary(plex_key=key, title="L", kind=kind, enabled=True)
+    db.add(lib)
+    db.flush()
+    return lib
+
+
+def test_enrich_batch_persists_stamps_and_links_people(db):
+    lib = _lib(db)
+    mv = PlexItem(rating_key="m1", library_id=lib.id, kind="movie", title="The Godfather", guid="tmdb:238")
+    unmatched = PlexItem(rating_key="m2", library_id=lib.id, kind="movie", title="Nope", guid="tmdb:777")
+    db.add_all([mv, unmatched])
+    db.commit()
+
+    fake = FakeTmdb(payloads={("movie", 238): MOVIE_PAYLOAD})  # 777 has no payload → definitive no-match
+    n = tmdb.enrich_batch(db, fake, 50)
+    assert n == 2  # both processed (one matched, one definitively unmatched)
+
+    db.refresh(mv)
+    assert mv.tmdb_id == 238
+    assert mv.keywords == ["mafia", "crime family"]
+    assert mv.revenue == 245066411
+    assert mv.tmdb_enriched_at is not None
+
+    db.refresh(unmatched)
+    assert unmatched.tmdb_enriched_at is not None  # stamped so it isn't re-fetched every run
+    assert unmatched.tmdb_id is None  # but nothing stored
+
+    brando = db.execute(
+        PlexPerson.__table__.select().where(PlexPerson.name == "Marlon Brando")
+    ).mappings().first()
+    assert brando is not None and brando["tmdb_person_id"] == 3084
+
+
+def test_serve_block_none_until_enriched_and_resolves_recs(db):
+    lib = _lib(db)
+    # A recommendation target that IS in our library (guid tmdb:240) → deep-linkable.
+    sequel = PlexItem(rating_key="m240", library_id=lib.id, kind="movie", title="Part II", guid="tmdb:240")
+    fresh = PlexItem(rating_key="m1", library_id=lib.id, kind="movie", title="The Godfather", guid="tmdb:238")
+    db.add_all([sequel, fresh])
+    db.commit()
+
+    assert tmdb.serve_block(db, fresh) is None  # not enriched yet
+
+    tmdb.apply_tmdb_detail(fresh, tmdb.parse_tmdb(MOVIE_PAYLOAD, "movie"))
+    fresh.tmdb_enriched_at = datetime.now(timezone.utc)
+    db.commit()
+
+    block = tmdb.serve_block(db, fresh)
+    assert block is not None
+    assert block["budget"] == 6000000
+    assert block["keywords"] == ["mafia", "crime family"]
+    recs = {r["tmdb_id"]: r for r in block["recommendations"]}
+    assert recs[240]["in_library"] is True and recs[240]["rating_key"] == "m240"
+    assert recs[999]["in_library"] is False and recs[999]["rating_key"] is None
+
+
+def test_get_never_leaks_api_key_in_error_messages(monkeypatch):
+    # The api_key rides in the request URL query string, so an error message built from the httpx
+    # exception (which embeds that URL) would leak the secret to logs (enrich_batch logs it). Both the
+    # HTTP-status and the network error paths must report status/path only — never the key.
+    monkeypatch.setattr(
+        tmdb.sysconfig, "get_str", lambda d, k: "SECRETKEY" if k == "tmdb_api_key" else "en-US"
+    )
+    client = tmdb.TmdbClient(None)
+    req = httpx.Request(
+        "GET", "https://api.themoviedb.org/3/movie/1?api_key=SECRETKEY&language=en-US"
+    )
+
+    class _StatusHttp:
+        def get(self, url, params=None):
+            return httpx.Response(401, request=req)  # non-404 → raise_for_status → HTTPStatusError
+
+        def close(self):
+            pass
+
+    client._http = _StatusHttp()
+    with pytest.raises(tmdb.TmdbError) as ei:
+        client._get("/movie/1")
+    assert "SECRETKEY" not in str(ei.value) and "401" in str(ei.value)
+
+    class _NetHttp:
+        def get(self, url, params=None):
+            raise httpx.ConnectError("connect failed", request=req)
+
+        def close(self):
+            pass
+
+    client._http = _NetHttp()
+    with pytest.raises(tmdb.TmdbError) as ei2:
+        client._get("/movie/1")
+    assert "SECRETKEY" not in str(ei2.value)
+    client.close()
+
+
+def test_run_enrich_noops_without_key(db):
+    # No tmdb_api_key configured (default "") → clean no-op, never an error.
+    out = tmdb.run_enrich(db)
+    assert out["enriched"] == 0 and "skipped" in out
+
+
+class _RaisingTmdb:
+    """A client whose fetch raises a transient TmdbError (e.g. a 429), to exercise the retry path."""
+
+    def find(self, external_id, source):
+        return None
+
+    def fetch(self, tmdb_id, media_type):
+        raise tmdb.TmdbError("429 rate limited")
+
+
+def test_enrich_batch_transient_error_leaves_watermark_null(db):
+    # A transient TmdbError mid-batch must leave the row's tmdb_enriched_at NULL so the next run retries
+    # it (unlike a definitive no-match, which stamps the watermark). The row is NOT counted as processed.
+    lib = _lib(db)
+    mv = PlexItem(rating_key="m1", library_id=lib.id, kind="movie", title="Godfather", guid="tmdb:238")
+    db.add(mv)
+    db.commit()
+
+    n = tmdb.enrich_batch(db, _RaisingTmdb(), 50)
+    assert n == 0  # the transient failure is skipped, not processed
+    db.refresh(mv)
+    assert mv.tmdb_enriched_at is None  # left NULL → retried next run
+    assert mv.tmdb_id is None
+
+
+def test_enrich_batch_skips_shows_without_guid(db):
+    lib = _lib(db, key="2", kind="show")
+    sh = PlexShow(rating_key="s1", library_id=lib.id, title="No Guid Show")  # guid None → not selected
+    db.add(sh)
+    db.commit()
+    assert tmdb.enrich_batch(db, FakeTmdb(), 50) == 0
+    db.refresh(sh)
+    assert sh.tmdb_enriched_at is None
+
+
+def test_resolve_library_guids_scopes_to_given_libraries(db):
+    # The scoped path (person page) must keep a credit that lives in a NON-scoped library (disabled or an
+    # HU-overlay twin) OUT of the result; the unscoped path (detail recs) matches across all libraries;
+    # and an explicit empty list skips that media side entirely (distinct from None = match all).
+    lib_on = _lib(db, key="on", kind="movie")
+    lib_off = _lib(db, key="off", kind="movie")
+    m_on = PlexItem(rating_key="on1", library_id=lib_on.id, kind="movie", title="In Scope", guid="tmdb:100")
+    m_off = PlexItem(rating_key="off1", library_id=lib_off.id, kind="movie", title="Out", guid="tmdb:200")
+    db.add_all([m_on, m_off])
+    db.commit()
+    entries = [{"tmdb_id": 100, "media_type": "movie"}, {"tmdb_id": 200, "media_type": "movie"}]
+
+    # Scoped to lib_on: the row in lib_off is excluded.
+    movies, shows = tmdb.resolve_library_guids(
+        db, entries, movie_lib_ids=[lib_on.id], show_lib_ids=[]
+    )
+    assert set(movies) == {"tmdb:100"}
+    assert shows == {}
+
+    # Unscoped (None defaults): matches across all libraries.
+    movies_all, _ = tmdb.resolve_library_guids(db, entries)
+    assert set(movies_all) == {"tmdb:100", "tmdb:200"}
+
+    # Empty list for a media side skips its bucket even with candidates present (vs None = match all).
+    _, shows_empty = tmdb.resolve_library_guids(
+        db, [{"tmdb_id": 100, "media_type": "tv"}], show_lib_ids=[]
+    )
+    assert shows_empty == {}
+
+
+def test_resolve_recs_matches_by_media_type_not_bare_id(db):
+    # TMDB movie ids and tv ids are independent, so tmdb:500 can be BOTH a show (in our library) and a
+    # movie recommendation. The match must respect media_type — a bare-id match would deep-link the movie
+    # rec to the unrelated show (and vice-versa).
+    mlib = _lib(db, key="10", kind="movie")
+    slib = _lib(db, key="11", kind="show")
+    show500 = PlexShow(rating_key="s500", library_id=slib.id, title="Show 500", guid="tmdb:500")
+    movie900 = PlexItem(
+        rating_key="m900", library_id=mlib.id, kind="movie", title="Movie 900", guid="tmdb:900"
+    )
+    db.add_all([show500, movie900])
+    db.commit()
+
+    # A movie rec for id 500 must NOT match show s500; a tv rec for id 900 must NOT match movie m900.
+    miss = {
+        r["tmdb_id"]: r
+        for r in tmdb.resolve_recs(
+            db,
+            [
+                {"tmdb_id": 500, "title": "Movie 500", "media_type": "movie"},
+                {"tmdb_id": 900, "title": "Show 900", "media_type": "tv"},
+            ],
+        )
+    }
+    assert miss[500]["in_library"] is False and miss[500]["rating_key"] is None
+    assert miss[900]["in_library"] is False and miss[900]["rating_key"] is None
+
+    # The right media_type DOES resolve to the right row.
+    hit = {
+        r["tmdb_id"]: r
+        for r in tmdb.resolve_recs(
+            db,
+            [
+                {"tmdb_id": 900, "media_type": "movie"},
+                {"tmdb_id": 500, "media_type": "tv"},
+            ],
+        )
+    }
+    assert hit[900]["in_library"] is True and hit[900]["rating_key"] == "m900"
+    assert hit[500]["in_library"] is True and hit[500]["rating_key"] == "s500"

backend/tests/test_saved_views_source.py

@@ -0,0 +1,75 @@
+"""ask 4: saved views are per-module (`source`). Feed and Plex views are separate lists, may share a
+name, and each has its own single default. DB lane (`db` fixture) — skipped without Postgres.
+"""
+from fastapi.testclient import TestClient
+
+import app.state as state
+from app.auth import current_user
+from app.db import get_db
+from app.main import app
+from app.models import User
+
+
+def _client(db, user, monkeypatch):
+    monkeypatch.setattr(state, "_configured_cache", True)  # the request gate 503s an unconfigured app
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[current_user] = lambda: user  # require_human resolves through this
+    return TestClient(app)
+
+
+def _user(db):
+    u = User(email="views@example.com")
+    db.add(u)
+    db.commit()
+    return u
+
+
+def test_views_are_scoped_by_source(db, monkeypatch):
+    user = _user(db)
+    try:
+        c = _client(db, user, monkeypatch)
+        # Same NAME under two sources is allowed (unique is per user+source now).
+        f = c.post("/api/saved-views", json={"name": "Fresh", "filters": {"a": 1}, "source": "feed"})
+        p = c.post("/api/saved-views", json={"name": "Fresh", "filters": {"b": 2}, "source": "plex"})
+        assert f.status_code == 200 and p.status_code == 200, (f.text, p.text)
+
+        feed = c.get("/api/saved-views?source=feed").json()
+        plex = c.get("/api/saved-views?source=plex").json()
+        assert [v["name"] for v in feed] == ["Fresh"]
+        assert [v["name"] for v in plex] == ["Fresh"]
+        assert feed[0]["filters"] == {"a": 1} and plex[0]["filters"] == {"b": 2}
+        # A source-less GET keeps the old feed-only behaviour.
+        assert [v["id"] for v in c.get("/api/saved-views").json()] == [v["id"] for v in feed]
+    finally:
+        app.dependency_overrides.clear()
+
+
+def test_default_is_per_source(db, monkeypatch):
+    user = _user(db)
+    try:
+        c = _client(db, user, monkeypatch)
+        fid = c.post(
+            "/api/saved-views", json={"name": "F", "filters": {}, "source": "feed"}
+        ).json()["id"]
+        pid = c.post(
+            "/api/saved-views", json={"name": "P", "filters": {}, "source": "plex"}
+        ).json()["id"]
+        c.patch(f"/api/saved-views/{fid}", json={"is_default": True})
+        c.patch(f"/api/saved-views/{pid}", json={"is_default": True})
+        # Making the Plex view default must NOT clear the feed view's default (different source).
+        assert c.get("/api/saved-views?source=feed").json()[0]["is_default"] is True
+        assert c.get("/api/saved-views?source=plex").json()[0]["is_default"] is True
+    finally:
+        app.dependency_overrides.clear()
+
+
+def test_duplicate_name_within_a_source_conflicts(db, monkeypatch):
+    user = _user(db)
+    try:
+        c = _client(db, user, monkeypatch)
+        a = c.post("/api/saved-views", json={"name": "Dup", "filters": {}, "source": "plex"})
+        b = c.post("/api/saved-views", json={"name": "Dup", "filters": {}, "source": "plex"})
+        assert a.status_code == 200
+        assert b.status_code == 409  # same (user, source, name)
+    finally:
+        app.dependency_overrides.clear()

backend/tests/test_search_scrape_ingest.py

@@ -0,0 +1,155 @@
+"""Regression: live YouTube search ingest must survive the scrape source carrying no publish date.
+
+`videos.published_at` is NOT NULL (migration 0068, PERF-15). The scrape source exposes only a
+relative time ("3 years ago"), so its stub has `published_at=None`; the ingest used to pass that
+None straight through, which the NOT NULL constraint rejected with an IntegrityError. That error
+is raised OUTSIDE the route's page-fetch try/except, so the whole `/api/search/youtube` request
+500'd and the UI showed the generic "YouTube search failed." — every scrape search was broken.
+
+The stub now falls back to now() (a non-null placeholder), and the enrich overwrites it with the
+video's real snippet date. These DB-lane tests lock both halves: no crash on a date-less stub, and
+a placeholder never becomes the video's permanent date.
+"""
+from datetime import datetime, timezone
+
+from app import sysconfig
+from app.models import User, Video
+from app.routes.search import _ingest_candidates
+
+
+class _FakeYT:
+    """Offline stand-in for YouTubeClient. Channel enrich is a no-op (the from_search stub survives);
+    video enrich returns a real publishedAt plus a long duration so Shorts classification finalises
+    without the youtube.com/shorts probe (no network in the DB lane)."""
+
+    def __init__(self, enrich: dict[str, dict]):
+        self._enrich = enrich
+
+    def get_channels(self, ids):
+        return []
+
+    def get_videos(self, ids):
+        return [self._enrich[i] for i in ids if i in self._enrich]
+
+
+def _candidate(vid: str, ch: str) -> dict:
+    # The scrape shape (see search_scrape._video_item): published_at is ALWAYS None.
+    return {
+        "id": vid,
+        "channel_id": ch,
+        "channel_title": f"Chan {ch}",
+        "title": f"Title {vid}",
+        "published_at": None,
+        "thumbnail_url": None,
+        "live_broadcast": "none",
+    }
+
+
+def _enrich_item(vid: str, published_iso: str) -> dict:
+    # PT30M keeps the video well above shorts_probe_max_seconds so no probe fires.
+    return {
+        "id": vid,
+        "snippet": {"title": f"Title {vid}", "publishedAt": published_iso},
+        "contentDetails": {"duration": "PT30M"},
+        "statistics": {},
+        "status": {},
+    }
+
+
+def test_scrape_ingest_dateless_stub_ingests_and_takes_real_enrich_date(db):
+    # Small cap so the 1800s enrich duration keeps the shorts step offline.
+    sysconfig.set_value(db, "shorts_probe_max_seconds", 60)
+    user = User(email="searcher@example.com")
+    db.add(user)
+    db.commit()
+
+    candidates = [_candidate("vid_aaaaaaa", "UC_chan_a"), _candidate("vid_bbbbbbb", "UC_chan_a")]
+    enrich = {
+        "vid_aaaaaaa": _enrich_item("vid_aaaaaaa", "2021-02-12T19:00:07Z"),
+        "vid_bbbbbbb": _enrich_item("vid_bbbbbbb", "2023-10-30T17:00:08Z"),
+    }
+
+    kept = _ingest_candidates(db, _FakeYT(enrich), user, candidates)
+
+    # No IntegrityError, and both non-Short/non-live videos are kept in input order.
+    assert kept == ["vid_aaaaaaa", "vid_bbbbbbb"]
+    a = db.get(Video, "vid_aaaaaaa")
+    # The now() placeholder was replaced by the video's real snippet date, not left as "now".
+    assert a.published_at == datetime(2021, 2, 12, 19, 0, 7, tzinfo=timezone.utc)
+    assert a.via_search is True
+    assert a.enriched_at is not None
+
+
+def test_scrape_ingest_enrich_miss_keeps_nonnull_placeholder(db):
+    # If enrich yields nothing (proxy blip / omitted row), the stub must STILL satisfy the NOT NULL
+    # constraint (a non-null placeholder) — it simply isn't kept (enriched_at stays None).
+    user = User(email="searcher2@example.com")
+    db.add(user)
+    db.commit()
+
+    kept = _ingest_candidates(db, _FakeYT({}), user, [_candidate("vid_ccccccc", "UC_chan_c")])
+
+    assert kept == []
+    c = db.get(Video, "vid_ccccccc")
+    assert c.published_at is not None  # placeholder wrote a real value → no crash
+    assert c.enriched_at is None
+
+
+def test_search_youtube_route_returns_422_when_ingest_fails(db, monkeypatch):
+    # Route-level guard (B-core-1): an ingest failure with nothing yet collected must surface as a 422
+    # + message on this JSON endpoint (the FE hides 5xx behind a generic "connection lost" + auto-retry,
+    # burning a second quota-costed search), and the session is rolled back. Here the page fetch succeeds
+    # (one candidate) and _ingest_candidates raises → the endpoint returns 422.
+    from fastapi.testclient import TestClient
+
+    import app.state as state
+    from app.auth import require_human
+    from app.db import get_db
+    from app.main import app
+    from app.routes import search as search_mod
+
+    user = User(email="route422@example.com")
+    db.add(user)
+    db.commit()
+
+    monkeypatch.setattr(state, "_configured_cache", True)
+    monkeypatch.setattr(
+        search_mod.sysconfig, "get_str", lambda d, k: "scrape" if k == "search_source" else ""
+    )
+    monkeypatch.setattr(search_mod.sysconfig, "get_int", lambda d, k: 100)  # daily cap not reached
+    monkeypatch.setattr(search_mod.quota, "actions_today", lambda d, uid, action: 0)
+
+    class _FakeYTCM:
+        def __init__(self, *a, **k):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            return False
+
+    monkeypatch.setattr(search_mod, "YouTubeClient", _FakeYTCM)
+    monkeypatch.setattr(
+        search_mod.search_scrape,
+        "search",
+        lambda term, continuation=None: {
+            "items": [_candidate("vid_route12", "UC_route_a")],
+            "next_page_token": None,
+        },
+    )
+
+    def _boom(db_, yt, user_, candidates):
+        raise RuntimeError("ingest exploded")
+
+    monkeypatch.setattr(search_mod, "_ingest_candidates", _boom)
+
+    app.dependency_overrides[get_db] = lambda: db
+    app.dependency_overrides[require_human] = lambda: user
+    try:
+        resp = TestClient(app).get("/api/search/youtube?q=test+term")
+    finally:
+        app.dependency_overrides.clear()
+
+    assert resp.status_code == 422, resp.text
+    assert "YouTube search failed" in resp.json()["detail"]

frontend/e2e/channel.spec.ts

@@ -1,5 +1,5 @@
 import { test, expect } from "@playwright/test";
-import { clickVisibleChannelLink, openApp } from "./helpers";
+import { clickVisibleChannelLink, expectContentType, openApp, toggleContentType } from "./helpers";
 
 // Locks channel-view entry + exit: opening a channel from a feed card replaces the view, and
 // both the in-page Back and the browser Back return to the feed. (This orthogonal channel branch
@@ -68,29 +68,22 @@ test.describe("channel view", () => {
   }) => {
     await openApp(page);
     await expect(page.getByTestId("video-card").first()).toBeVisible();
-    const feedLive = page.getByTestId("feed-content-includeLive");
-    await expect(feedLive).toHaveAttribute("aria-pressed", "false");
+    await expectContentType(page, "includeLive", false);
 
     // Inherit OFF: the channel toolbar's Live/Upcoming stays off, not forced on.
     await page.getByTestId("video-card-channel").first().click();
     await expect(page.getByTestId("channel-title")).toBeVisible();
-    await expect(page.getByTestId("feed-content-includeLive")).toHaveAttribute(
-      "aria-pressed",
-      "false",
-    );
+    await expectContentType(page, "includeLive", false);
     await page.getByTestId("channel-back").click();
     await expect(page.getByTestId("channel-title")).toHaveCount(0);
 
     // Inherit ON: flip the feed's Live/Upcoming on, reopen the channel → it inherits the on state.
-    await feedLive.click();
-    await expect(feedLive).toHaveAttribute("aria-pressed", "true");
+    await toggleContentType(page, "includeLive");
+    await expectContentType(page, "includeLive", true);
     await expect(page.getByTestId("video-card").first()).toBeVisible();
     await page.getByTestId("video-card-channel").first().click();
     await expect(page.getByTestId("channel-title")).toBeVisible();
-    await expect(page.getByTestId("feed-content-includeLive")).toHaveAttribute(
-      "aria-pressed",
-      "true",
-    );
+    await expectContentType(page, "includeLive", true);
   });
 
   // Bug 2 (Platform S5): the channel view is its OWN filter scope — a content toggle made there
@@ -99,27 +92,18 @@ test.describe("channel view", () => {
   test("a channel's content toggle does not leak into the feed", async ({ page }) => {
     await openApp(page);
     await expect(page.getByTestId("video-card").first()).toBeVisible();
-    await expect(page.getByTestId("feed-content-includeLive")).toHaveAttribute(
-      "aria-pressed",
-      "false",
-    );
+    await expectContentType(page, "includeLive", false);
 
     // Turn Live/Upcoming ON inside the channel view.
     await page.getByTestId("video-card-channel").first().click();
     await expect(page.getByTestId("channel-title")).toBeVisible();
-    await page.getByTestId("feed-content-includeLive").click();
-    await expect(page.getByTestId("feed-content-includeLive")).toHaveAttribute(
-      "aria-pressed",
-      "true",
-    );
+    await toggleContentType(page, "includeLive");
+    await expectContentType(page, "includeLive", true);
 
     // Back on the feed, its Live/Upcoming is still off — the channel's change stayed local.
     await page.getByTestId("channel-back").click();
     await expect(page.getByTestId("channel-title")).toHaveCount(0);
-    await expect(page.getByTestId("feed-content-includeLive")).toHaveAttribute(
-      "aria-pressed",
-      "false",
-    );
+    await expectContentType(page, "includeLive", false);
   });
 
   // Platform S4b: the whole channel chrome (banner, identity, tabs, toolbar) is fixed — it stays
@@ -127,7 +111,7 @@ test.describe("channel view", () => {
   test("the channel chrome stays fixed while the video grid scrolls", async ({ page }) => {
     await openApp(page);
     await page.getByTestId("video-card-channel").first().click();
-    const count = page.getByTestId("feed-result-count");
+    const count = page.getByTestId("item-count");
     const title = page.getByTestId("channel-title");
     await expect(count).toBeVisible();
     await expect(page.getByTestId("video-card").first()).toBeVisible();

frontend/e2e/feed.spec.ts

@@ -8,15 +8,18 @@ test.describe("feed", () => {
     await openApp(page);
     await expect(page.getByTestId("video-card").first()).toBeVisible();
 
-    const count = page.getByTestId("feed-result-count");
+    const count = page.getByTestId("item-count");
     await expect(count).toHaveText(/\d/);
     const baseline = await count.innerText();
 
-    // Clean baseline: default filters, so no chips and "unwatched" is the active show.
+    // Clean baseline: default filters, so no chips and "unwatched" is the active show (the Watch-state
+    // pill summarises the current pick).
     await expect(page.getByTestId("active-filter-chip")).toHaveCount(0);
-    await expect(page.getByTestId("feed-show-unwatched")).toHaveAttribute("aria-pressed", "true");
+    await expect(page.getByTestId("feed-show")).toContainText("Unwatched");
 
-    // Narrow to "watched" — the seed guarantees exactly one, a real deterministic change.
+    // Narrow to "watched" — open the Watch-state dropdown and pick it (single-select closes on pick).
+    // The seed guarantees exactly one, a real deterministic change.
+    await page.getByTestId("feed-show").click();
     await page.getByTestId("feed-show-watched").click();
     await expect(page.getByTestId("active-filter-chip")).toHaveCount(1);
     await expect(count).not.toHaveText(baseline);
@@ -24,7 +27,7 @@ test.describe("feed", () => {
     // Remove the chip → default show restored, chips gone.
     await page.getByTestId("active-filter-chip").click();
     await expect(page.getByTestId("active-filter-chip")).toHaveCount(0);
-    await expect(page.getByTestId("feed-show-unwatched")).toHaveAttribute("aria-pressed", "true");
+    await expect(page.getByTestId("feed-show")).toContainText("Unwatched");
   });
 
   test("scrolling virtualizes in fresh cards", async ({ page }) => {
@@ -52,7 +55,7 @@ test.describe("feed", () => {
   // pins in the shell's toolbar band above the scroller, so it stays put while the cards scroll.
   test("the feed toolbar stays pinned while cards scroll", async ({ page }) => {
     await openApp(page);
-    const count = page.getByTestId("feed-result-count");
+    const count = page.getByTestId("item-count");
     await expect(count).toBeVisible();
     const topBefore = await count.evaluate((el) => el.getBoundingClientRect().top);
 
@@ -73,6 +76,7 @@ test.describe("feed", () => {
     expect(await page.getByRole("main").evaluate((el) => el.scrollTop)).toBeGreaterThan(500);
 
     // Switch the show filter → a different result set → back to the top.
+    await page.getByTestId("feed-show").click();
     await page.getByTestId("feed-show-all").click();
     await expect.poll(() => page.getByRole("main").evaluate((el) => el.scrollTop)).toBeLessThan(50);
   });

frontend/e2e/helpers.ts

@@ -33,6 +33,30 @@ export async function clickVisibleChannelLink(page: Page): Promise<boolean> {
   return false;
 }
 
+/**
+ * Assert a content-type (e.g. "includeLive") is on/off via the Content-types FilterSelect dropdown.
+ * The options only exist while the dropdown is open, so this opens it, checks the option's
+ * `aria-checked` (the multi FilterSelect renders its rows as menuitemcheckbox), then closes it
+ * (Escape) so the floating panel can't block a later click.
+ */
+export async function expectContentType(page: Page, value: string, on: boolean): Promise<void> {
+  await page.getByTestId("feed-content").click();
+  await expect(page.getByTestId(`feed-content-${value}`)).toHaveAttribute(
+    "aria-checked",
+    on ? "true" : "false",
+  );
+  await page.keyboard.press("Escape");
+  await expect(page.getByTestId(`feed-content-${value}`)).toHaveCount(0);
+}
+
+/** Toggle a content-type via the Content-types FilterSelect dropdown, then close it. */
+export async function toggleContentType(page: Page, value: string): Promise<void> {
+  await page.getByTestId("feed-content").click();
+  await page.getByTestId(`feed-content-${value}`).click();
+  await page.keyboard.press("Escape");
+  await expect(page.getByTestId(`feed-content-${value}`)).toHaveCount(0);
+}
+
 /** Open the in-app player from the first feed card (clicks its thumbnail link). */
 export async function openFirstVideo(page: Page): Promise<void> {
   await expect(page.getByTestId("video-card").first()).toBeVisible();

frontend/src/App.tsx

@@ -4,7 +4,7 @@ import { useTranslation } from "react-i18next";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { api, getActiveAccount, setActiveAccount, setUnauthorizedHandler } from "./lib/api";
 import { setLanguage, isSupported, type LangCode } from "./i18n";
-import { hasFilterParams, stripUrlParams } from "./lib/urlState";
+import { clearParams } from "./lib/urlState";
 import type { Page } from "./lib/urlState";
 import {
   loadLayout,
@@ -15,7 +15,8 @@ import {
   type PanelLayout,
 } from "./lib/panelLayout";
 import { notify, removeByMetaKind } from "./lib/notifications";
-import { LS, readAccount, setAccountRaw, writeAccount } from "./lib/storage";
+import { LS, setAccountRaw } from "./lib/storage";
+import { usePref } from "./lib/usePref";
 import { useNavigation, useNavigationActions } from "./components/NavigationProvider";
 import { useFeedFilters, useFeedFiltersActions } from "./components/FeedFiltersProvider";
 import { useChannelLayout } from "./components/ChannelsProvider";
@@ -90,37 +91,20 @@ export default function App() {
   }
 
   // Collapse state for the two full-height panels (left nav + filter sidebar). Persisted to the
-  // user's preferences so it follows the account across devices; a localStorage cache seeds the
-  // initial render synchronously so nothing flashes open before the server prefs arrive.
+  // user's preferences (via usePref) so it follows the account across devices; the localStorage mirror
+  // seeds the initial render synchronously so nothing flashes open before the server prefs arrive.
   // Default unpinned (tab + hover-expand overlay); accounts that explicitly pin keep their choice.
-  const [filterCollapsed, setFilterCollapsedState] = useState<boolean>(() =>
-    Boolean(readAccount(LS.filterCollapsed, true)),
-  );
+  const [filterCollapsed, setFilterCollapsed] = usePref<boolean>("filterCollapsed", true, {
+    localKey: LS.filterCollapsed,
+    parse: Boolean,
+  });
   // The Playlists rail has its own collapse flag (it's a list/navigator, not filters).
-  const [playlistsCollapsed, setPlaylistsCollapsedState] = useState<boolean>(() =>
-    Boolean(readAccount(LS.playlistsCollapsed, true)),
-  );
-  function setFilterCollapsed(next: boolean) {
-    setFilterCollapsedState(next);
-    writeAccount(LS.filterCollapsed, next);
-    api.savePrefs({ filterCollapsed: next }).catch(() => {});
-  }
-  function setPlaylistsCollapsed(next: boolean) {
-    setPlaylistsCollapsedState(next);
-    writeAccount(LS.playlistsCollapsed, next);
-    api.savePrefs({ playlistsCollapsed: next }).catch(() => {});
-  }
-  // Filters live in localStorage, not the address bar. If we arrived via a "Share view"
-  // link, its params have already hydrated the initial state — persist them and strip the
-  // query so the URL stays clean from here on.
-  useEffect(() => {
-    const params = new URLSearchParams(window.location.search);
-    if (hasFilterParams(params) || params.has("page")) {
-      // A share link's filters are held in state; they're persisted to the account's key by the
-      // post-login effect (which knows the account id). Here we only clean the address bar.
-      stripUrlParams();
-    }
-  }, []);
+  const [playlistsCollapsed, setPlaylistsCollapsed] = usePref<boolean>("playlistsCollapsed", true, {
+    localKey: LS.playlistsCollapsed,
+    parse: Boolean,
+  });
+  // (The feed filters + page/channel now LIVE in the address bar — FeedFiltersProvider and
+  // NavigationProvider read them on load and keep them mirrored — so there's no query to strip here.)
 
   const queryClient = useQueryClient();
   // First-run install gate: a fresh instance reports configured=false and runs in setup mode.
@@ -152,11 +136,24 @@ export default function App() {
     if (meQuery.data && getActiveAccount() == null) setActiveAccount(meQuery.data.id);
   }, [meQuery.data?.id]);
 
-  // Once signed in, drop any leftover query string from the pre-login flow (e.g.
-  // ?access=requested, ?verify, ?reset). The logged-in app reads nothing from the URL, so the
-  // address bar stays clean. Gated on auth so the logged-out Welcome page still reads its params.
+  // Measure the scrollbar's gutter width once and publish it as --sbw, so the floating header and the
+  // toolbar band can pad their right edge to line up with the scrolled cards (the app scroller reserves
+  // that gutter via scrollbar-gutter: stable). It's a device constant, so a one-shot mount measure is enough.
   useEffect(() => {
-    if (meQuery.data) stripUrlParams();
+    const probe = document.createElement("div");
+    probe.style.cssText =
+      "position:absolute;top:-9999px;width:100px;height:100px;overflow:scroll;scrollbar-gutter:stable";
+    document.body.appendChild(probe);
+    const w = probe.offsetWidth - probe.clientWidth;
+    document.body.removeChild(probe);
+    document.documentElement.style.setProperty("--sbw", `${w}px`);
+  }, []);
+
+  // Once signed in, drop any leftover ONE-TIME query params from the pre-login flow (?access, ?verify,
+  // ?reset) — but NOT the nav/filter params, which the logged-in app now reads from and keeps in the
+  // URL. Gated on auth so the logged-out Welcome page still reads its params first.
+  useEffect(() => {
+    if (meQuery.data) clearParams("access", "verify", "reset");
   }, [meQuery.data?.id]); // eslint-disable-line react-hooks/exhaustive-deps
 
   // Any request that 401s means the session ended server-side. If we were signed in (cached
@@ -188,7 +185,7 @@ export default function App() {
       const key = result === "conflict" || result === "mismatch" ? result : "error";
       notify({ level: "error", message: t(`settings.account.googleLink.${key}`) });
     }
-    stripUrlParams();
+    clearParams("link");
   }, []); // eslint-disable-line react-hooks/exhaustive-deps
 
   // A Google OAuth flow started while already signed in (add-another-account, link, or upgrade) was
@@ -197,12 +194,12 @@ export default function App() {
   useEffect(() => {
     if (new URLSearchParams(window.location.search).get("oauth") !== "cancelled") return;
     notify({ level: "info", message: t("settings.account.googleCancelled") });
-    stripUrlParams();
+    clearParams("oauth");
   }, []); // eslint-disable-line react-hooks/exhaustive-deps
 
   // Deep-link from the "new access request" admin email (?admin=access-requests) → jump straight to
-  // the admin Users → Access requests view. Snapshot the param so the pre-login URL strip doesn't
-  // drop it; act once `me` is known, and only for an admin (others just land on their default page).
+  // the admin Users → Access requests view. Snapshot the param up front (read once at mount); act once
+  // `me` is known, and only for an admin (others just land on their default page).
   const [adminDeepLink] = useState(() => new URLSearchParams(window.location.search).get("admin"));
   useEffect(() => {
     if (adminDeepLink !== "access-requests" || !meQuery.data) return;
@@ -210,12 +207,13 @@ export default function App() {
       focusAccessRequestsTab();
       setPage("users");
     }
-    stripUrlParams();
+    clearParams("admin");
   }, [adminDeepLink, meQuery.data?.id]); // eslint-disable-line react-hooks/exhaustive-deps
 
-  // On login, adopt the server-stored SHELL preferences (panel layouts, rail collapse flags,
-  // language). The Settings-page prefs (theme/perf/hints/notifications) are adopted by PrefsProvider
-  // and the feed view by FeedViewProvider — each via its own passive qk.me() observer.
+  // On login, adopt the server-stored SHELL preferences (panel layouts + language). The rail-collapse
+  // flags (filterCollapsed / playlistsCollapsed) are adopted by their own usePref hooks, the
+  // Settings-page prefs (theme/perf/hints/notifications) by PrefsProvider, and the feed view by
+  // FeedViewProvider — each via its own passive qk.me() observer.
   useEffect(() => {
     const prefs = meQuery.data?.preferences;
     if (!prefs) return;
@@ -227,14 +225,6 @@ export default function App() {
         saveLayoutLocal(p, l);
       }
     });
-    if (typeof prefs.filterCollapsed === "boolean") {
-      setFilterCollapsedState(prefs.filterCollapsed);
-      writeAccount(LS.filterCollapsed, prefs.filterCollapsed);
-    }
-    if (typeof prefs.playlistsCollapsed === "boolean") {
-      setPlaylistsCollapsedState(prefs.playlistsCollapsed);
-      writeAccount(LS.playlistsCollapsed, prefs.playlistsCollapsed);
-    }
     const lang = prefs.language;
     if (typeof lang === "string" && isSupported(lang)) setLanguage(lang);
     // (Per-account filters — incl. the demo account's whole-library default — are loaded by the
@@ -323,7 +313,7 @@ export default function App() {
   const me = meQuery.data!;
   const pageGate = moduleDef(page).gate;
   const activePage: Page = !pageGate || pageGate(me) ? page : "feed";
-  const { Component: PageContent, fadeTop } = PAGE_CONTENT[activePage];
+  const { Component: PageContent, fadeTop, maxWidth } = PAGE_CONTENT[activePage];
   const railDef = channelView ? undefined : PAGE_RAIL[activePage];
 
   return (
@@ -389,6 +379,7 @@ export default function App() {
         ) : (
           <PageShell
             scrollKey={normalScrollKey}
+            maxWidth={maxWidth}
             // Channels: the registry disables the top fade for its sticky-header table, but the card
             // layout has no sticky header, so re-enable it there.
             fadeTop={activePage === "channels" ? channelLayout === "cards" : (fadeTop ?? true)}

frontend/src/components/ActiveFilterChips.tsx

@@ -1,51 +1,258 @@
+import { useLayoutEffect, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
-import { X } from "lucide-react";
+import { Filter, X } from "lucide-react";
 import type { ActiveFilter } from "../lib/useActiveFilters";
+import { decideChipLayout } from "../lib/chipOverflow";
+import { PopoverItem, PopoverSurface, useAnchoredPopover } from "./AnchoredPopover";
 
 // The applied-filter row above the feed: every narrowing currently in force, each removable on its
 // own. It exists because the filter panel now sits collapsed as a tab — without this you'd have to
 // open the panel just to see what you'd filtered by.
+//
+// The row is a single flex line that shares its width with the Sort/View controls pinned to its right,
+// so the chips must never push those off-screen. When they'd overflow it trims responsively:
+//   - wide  -> show as many chips as fit, then a "+N" pill whose popover holds the rest;
+//   - narrow -> collapse every chip into one "N filters" pill whose popover holds them all.
+// Fit is measured off a hidden mirror of the full chip set (so slicing the visible lane can't feed
+// back into the measurement and oscillate).
+
+// Below this lane width an overflow collapses all the way to a single count pill (mobile), instead of
+// the "fit some + N more" treatment used on wider lanes.
+const NARROW_PX = 420;
+
+const chipCls =
+  "chip group inline-flex items-center gap-1 pl-2.5 pr-1.5 py-1 text-sm whitespace-nowrap hover:border-accent hover:bg-accent/20 transition";
+
+function ChipButton({ f, testId }: { f: ActiveFilter; testId?: string }) {
+  const { t } = useTranslation();
+  return (
+    <button
+      data-testid={testId}
+      data-filter-key={f.key}
+      onClick={f.remove}
+      title={t("feed.chips.remove", { name: f.label })}
+      aria-label={t("feed.chips.remove", { name: f.label })}
+      className={chipCls}
+    >
+      <span className="max-w-56 truncate">{f.label}</span>
+      <X className="w-3 h-3 shrink-0 opacity-60 group-hover:opacity-100" />
+    </button>
+  );
+}
+
+// The "+N" / "N filters" pill and its popover listing the (overflowed / all) chips, each removable.
+function OverflowPopover({
+  label,
+  ariaLabel,
+  chips,
+  onClearAll,
+  icon,
+}: {
+  label: string;
+  /** Accessible name for the trigger + popover — describes what's inside (e.g. "3 more filters"),
+   *  since the visible label can be a bare "+3". Defaults to `label`. */
+  ariaLabel?: string;
+  chips: ActiveFilter[];
+  onClearAll: () => void;
+  icon?: boolean;
+}) {
+  const { t } = useTranslation();
+  const [open, setOpen] = useState(false);
+  const pop = useAnchoredPopover({
+    open,
+    onOpenChange: setOpen,
+    mode: "menu",
+    placement: "bottom-end",
+  });
+  const name = ariaLabel ?? label;
+  return (
+    <>
+      <button
+        type="button"
+        ref={pop.refs.setReference}
+        {...pop.getReferenceProps()}
+        aria-label={name}
+        className={`chip inline-flex shrink-0 items-center gap-1 px-2.5 py-1 text-sm whitespace-nowrap transition ${
+          open ? "border-accent text-accent" : "hover:border-accent"
+        }`}
+      >
+        {icon && <Filter className="w-3.5 h-3.5 shrink-0" aria-hidden="true" />}
+        {label}
+      </button>
+      <PopoverSurface
+        popover={pop}
+        ariaLabel={name}
+        className="glass-menu min-w-48 max-w-72 rounded-xl p-1.5 shadow-lg animate-[popIn_0.16s_ease]"
+      >
+        <div role="group" aria-label={name} className="max-h-72 overflow-y-auto no-scrollbar">
+          {chips.map((f) => (
+            <PopoverItem
+              key={f.key}
+              role="menuitem"
+              onSelect={f.remove}
+              label={f.label}
+              className="group flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm text-fg transition"
+            >
+              <span className="flex-1 truncate">{f.label}</span>
+              <X className="w-3.5 h-3.5 shrink-0 opacity-60 group-hover:opacity-100" />
+            </PopoverItem>
+          ))}
+        </div>
+        <div className="mt-1 border-t border-border px-1 pt-1.5">
+          <button
+            type="button"
+            data-testid="active-filter-clear-all"
+            onClick={() => {
+              onClearAll();
+              setOpen(false);
+            }}
+            className="text-xs text-muted hover:text-fg underline underline-offset-2 transition"
+          >
+            {t("sidebar.clearAll")}
+          </button>
+        </div>
+      </PopoverSurface>
+    </>
+  );
+}
+
 export default function ActiveFilterChips({
   filters,
   onClearAll,
+  className,
 }: {
   filters: ActiveFilter[];
   onClearAll: () => void;
+  className?: string;
 }) {
   const { t } = useTranslation();
-  if (filters.length === 0) return null;
+  const laneRef = useRef<HTMLDivElement | null>(null);
+  const labelRef = useRef<HTMLSpanElement | null>(null);
+  const chipRefs = useRef<Array<HTMLSpanElement | null>>([]);
+  const plusRef = useRef<HTMLSpanElement | null>(null);
+  const clearRef = useRef<HTMLSpanElement | null>(null);
+  // How the row is currently laid out: all chips, a fit-count + "+N", or a single count pill.
+  const [layout, setLayout] = useState<{ mode: "all" | "some" | "count"; visible: number }>({
+    mode: "all",
+    visible: filters.length,
+  });
+
+  const n = filters.length;
+  // Re-measure whenever the chip set changes (labels or count) — captures both in one dep.
+  const chipsKey = filters.map((f) => f.key + f.label).join("|");
+
+  useLayoutEffect(() => {
+    const lane = laneRef.current;
+    const labelEl = labelRef.current;
+    if (!lane || !labelEl || n === 0) return;
+
+    const measure = () => {
+      const rightOf = (el: HTMLElement | null | undefined) =>
+        el ? el.offsetLeft + el.offsetWidth : 0;
+      const chips = chipRefs.current.slice(0, n);
+      const plusEl = plusRef.current;
+      // Measure the real rendered gap off the box between the last chip and the "+N" sample, so it
+      // scales with the text-size slider (gap-1.5 is rem) rather than being frozen in px.
+      const lastChip = chips[n - 1];
+      const gap = plusEl && lastChip ? Math.max(0, plusEl.offsetLeft - rightOf(lastChip)) : 6;
+      // "all" mode also renders a Clear all button after the chips (when n > 1), so reserve its width.
+      const clearW = n > 1 ? gap + (clearRef.current?.offsetWidth ?? 0) : 0;
+
+      setLayout(
+        decideChipLayout({
+          n,
+          labelRight: rightOf(labelEl),
+          chipRights: chips.map((c) => rightOf(c)),
+          plusW: plusEl?.offsetWidth ?? 0,
+          clearW,
+          avail: lane.clientWidth,
+          gap,
+          narrowPx: NARROW_PX,
+        }),
+      );
+    };
+
+    measure();
+    const ro = new ResizeObserver(measure);
+    ro.observe(lane);
+    return () => ro.disconnect();
+  }, [n, chipsKey]);
+
+  if (n === 0) return null;
+
+  const hiddenCount = n - layout.visible;
+  const overflowChips = filters.slice(layout.visible);
 
   return (
     <div
+      ref={laneRef}
       data-testid="active-filter-chips"
-      className="flex flex-wrap items-center gap-1.5 pb-3"
+      className={`relative flex min-w-0 items-center gap-1.5 ${className ?? ""}`}
       aria-label={t("feed.chips.label")}
     >
-      <span className="text-2xs uppercase tracking-wider text-muted mr-0.5">
-        {t("feed.chips.label")}
-      </span>
-      {filters.map((f) => (
-        <button
-          key={f.key}
-          data-testid="active-filter-chip"
-          data-filter-key={f.key}
-          onClick={f.remove}
-          title={t("feed.chips.remove", { name: f.label })}
-          aria-label={t("feed.chips.remove", { name: f.label })}
-          className="chip group pl-2.5 pr-1.5 py-1 text-xs hover:border-accent hover:bg-accent/20 transition"
-        >
-          <span className="max-w-56 truncate">{f.label}</span>
-          <X className="w-3 h-3 shrink-0 opacity-60 group-hover:opacity-100" />
-        </button>
-      ))}
-      {filters.length > 1 && (
-        <button
-          data-testid="active-filter-clear-all"
-          onClick={onClearAll}
-          className="ml-0.5 text-xs text-muted hover:text-fg underline underline-offset-2 transition"
-        >
+      {/* Hidden mirror of the full set, used only to measure natural widths. Kept out of the a11y tree
+          and without test ids so it never doubles the visible chip count. */}
+      <div
+        aria-hidden="true"
+        className="pointer-events-none invisible absolute left-0 top-0 flex items-center gap-1.5"
+      >
+        <span ref={labelRef} className="text-xs uppercase tracking-wider text-muted mr-0.5">
+          {t("feed.chips.label")}
+        </span>
+        {filters.map((f, i) => (
+          <span
+            key={f.key}
+            ref={(el) => {
+              chipRefs.current[i] = el;
+            }}
+            className={chipCls}
+          >
+            <span className="max-w-56 truncate">{f.label}</span>
+            <X className="w-3 h-3 shrink-0" />
+          </span>
+        ))}
+        <span ref={plusRef} className="chip inline-flex items-center gap-1 px-2.5 py-1 text-sm">
+          +{n}
+        </span>
+        <span ref={clearRef} className="ml-0.5 text-sm underline underline-offset-2">
           {t("sidebar.clearAll")}
-        </button>
+        </span>
+      </div>
+
+      {/* Visible lane. */}
+      {layout.mode === "count" ? (
+        <OverflowPopover
+          label={t("feed.chips.count", { count: n })}
+          chips={filters}
+          onClearAll={onClearAll}
+          icon
+        />
+      ) : (
+        <>
+          <span className="text-xs uppercase tracking-wider text-muted mr-0.5 shrink-0">
+            {t("feed.chips.label")}
+          </span>
+          {filters.slice(0, layout.visible).map((f) => (
+            <ChipButton key={f.key} f={f} testId="active-filter-chip" />
+          ))}
+          {layout.mode === "some" && hiddenCount > 0 && (
+            <OverflowPopover
+              label={`+${hiddenCount}`}
+              ariaLabel={t("feed.chips.moreCount", { count: hiddenCount })}
+              chips={overflowChips}
+              onClearAll={onClearAll}
+            />
+          )}
+          {layout.mode === "all" && n > 1 && (
+            <button
+              data-testid="active-filter-clear-all"
+              onClick={onClearAll}
+              className="ml-0.5 shrink-0 text-sm text-muted hover:text-fg underline underline-offset-2 transition"
+            >
+              {t("sidebar.clearAll")}
+            </button>
+          )}
+        </>
       )}
     </div>
   );

frontend/src/components/AdminUsers.tsx

@@ -34,7 +34,7 @@ export default function AdminUsers() {
     <>
       {/* The tab bar is fixed chrome; the tab content scrolls under it. */}
       <PageToolbar>
-        <div className="px-4 pt-3 max-w-3xl w-full mx-auto">
+        <div className="px-4 pt-2 max-w-3xl w-full mx-auto">
           <Tabs tabs={tabs} active={active} onChange={setTab} />
         </div>
       </PageToolbar>

frontend/src/components/AnchoredPopover.dom.test.tsx

@@ -0,0 +1,60 @@
+// @vitest-environment jsdom
+//
+// Gates the shared PopoverItem ARIA contract: aria-checked for menuitemradio/menuitemcheckbox and
+// aria-selected for option are rendered as explicit attributes AFTER the floating-ui item props (so they
+// win over getItemProps' single-select guess). Six live menus (LanguageSwitcher, ViewSwitcher,
+// AddToPlaylist, ChannelTags, tableHeader, plexDetailUi) depend on this; without a test, a regression in
+// the shared path would silently drop the checked indicator for screen-reader users. Floating-ui recipe:
+// stub the two observers autoUpdate wires, wrap in a FloatingTree, query the hidden surface.
+import { describe, it, expect, beforeAll, afterEach } from "vitest";
+import { useState } from "react";
+import { render, screen, cleanup } from "@testing-library/react";
+import { FloatingTree } from "@floating-ui/react";
+import { useAnchoredPopover, PopoverSurface, PopoverItem } from "./AnchoredPopover";
+
+beforeAll(() => {
+  class Stub {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() {
+      return [];
+    }
+  }
+  globalThis.ResizeObserver ??= Stub as unknown as typeof ResizeObserver;
+  globalThis.IntersectionObserver ??= Stub as unknown as typeof IntersectionObserver;
+});
+
+afterEach(cleanup);
+
+function Menu() {
+  const [open, setOpen] = useState(true);
+  const pop = useAnchoredPopover({ open, onOpenChange: setOpen, mode: "menu" });
+  return (
+    <PopoverSurface popover={pop} ariaLabel="Choices">
+      <PopoverItem role="menuitemradio" checked onSelect={() => {}}>
+        Newest
+      </PopoverItem>
+      <PopoverItem role="menuitemradio" checked={false} onSelect={() => {}}>
+        Oldest
+      </PopoverItem>
+      <PopoverItem role="menuitemcheckbox" checked onSelect={() => {}}>
+        Show shorts
+      </PopoverItem>
+    </PopoverSurface>
+  );
+}
+
+describe("PopoverItem ARIA contract", () => {
+  it("exposes aria-checked on menuitemradio and menuitemcheckbox items", () => {
+    render(
+      <FloatingTree>
+        <Menu />
+      </FloatingTree>,
+    );
+    const radios = screen.getAllByRole("menuitemradio", { hidden: true });
+    expect(radios.map((r) => r.getAttribute("aria-checked"))).toEqual(["true", "false"]);
+    const checkbox = screen.getByRole("menuitemcheckbox", { hidden: true });
+    expect(checkbox.getAttribute("aria-checked")).toBe("true");
+  });
+});

frontend/src/components/AnchoredPopover.tsx

@@ -2,6 +2,7 @@ import {
   createContext,
   useContext,
   useEffect,
+  useId,
   useLayoutEffect,
   useRef,
   useState,
@@ -61,14 +62,29 @@ import { useFullscreenElement } from "../lib/fullscreen";
 // right role (menuitem / menuitemradio+aria-checked / option+aria-selected). A menu that also holds a
 // free-text input (the tag creator) must stopPropagation non-Escape keys on that input so ↑/↓ and
 // typeahead act on the text, not the list — see ChannelTags.
+//
+// S? adds a "combobox" mode — the ONE right way to build a typeable combobox (a search/filter input
+// with a listbox of options below), so a hand-rolled floating-ui engine (the old MultiSelectChips /
+// PlexSearchBox pattern) is no longer needed. It differs from menu/listbox in exactly the focus model:
+//   - the trigger IS a text input, so open is driven by the caller (focus/typing), NOT useClick;
+//   - focus STAYS on the input — the surface is NOT focus-trapped and list items are never DOM-focused;
+//     arrow-nav is VIRTUAL (useListNavigation `virtual:true` → the ↑/↓/Home/End handler rides on the
+//     input's getReferenceProps and moves an `aria-activedescendant` pointer, not real focus).
+// Because `role:"combobox"` is passed to useRole, Floating UI wires the whole ARIA tree for free: the
+// reference input gets role=combobox + aria-expanded/controls/autocomplete/activedescendant, the surface
+// gets role=listbox, and each <PopoverItem role="option"> gets its option id (so activedescendant has a
+// target). The caller mounts the INPUT as `refs.setReference` (makes it a "typeable combobox reference")
+// and the field box as `refs.setPositionReference` (so the panel anchors under the whole chips+input
+// field). The universal <Combobox> component wraps all of this — call sites use it, not this mode raw.
 
 // Internal to the platform; call sites pass the string literal via `mode`, they don't name the type.
-type PopoverMode = "menu" | "listbox" | "hover" | "dialog";
+type PopoverMode = "menu" | "listbox" | "hover" | "dialog" | "combobox";
 
 export interface AnchoredPopoverOptions {
   open: boolean;
   onOpenChange: (open: boolean, event?: Event) => void;
-  /** "menu"/"listbox"/"dialog" open on click; "hover" opens on hover+focus (tooltips, hover cards). */
+  /** "menu"/"listbox"/"dialog" open on click; "hover" opens on hover+focus (tooltips, hover cards);
+   *  "combobox" is a typeable input + listbox where focus stays in the field (use via <Combobox>). */
   mode?: PopoverMode;
   placement?: Placement;
   /** Gap between trigger and panel, px. Default 4. */
@@ -99,9 +115,14 @@ type AnchoredPopover = ReturnType<typeof useAnchoredPopover>;
 export function useAnchoredPopover(opts: AnchoredPopoverOptions) {
   const mode = opts.mode ?? "menu";
   const isHover = mode === "hover";
+  const isCombobox = mode === "combobox";
   // Roving-keyboard list surfaces: a menu of actions or a listbox of options. A "dialog" popover holds
   // arbitrary focusable content (its own Tab order), and "hover" is a passive tooltip — neither roves.
   const isNav = mode === "menu" || mode === "listbox";
+  // Surfaces that host a navigable item list (registry + list-navigation): the roving menu/listbox AND
+  // the virtual-nav combobox. The combobox navigates WITHOUT moving DOM focus (see below), so it is kept
+  // out of `isNav` (which also gates the focus trap + typeahead + roving tabindex) and folded in here.
+  const roves = isNav || isCombobox;
   // null when not inside a <FloatingTree> — the hook still works, just without nested-layer awareness.
   const nodeId = useFloatingNodeId();
 
@@ -143,6 +164,19 @@ export function useAnchoredPopover(opts: AnchoredPopoverOptions) {
             }),
           ]
         : []),
+      // A combobox panel matches the field's width (with a sane floor for a very narrow rail); its inner
+      // scroll box owns the height cap. `rects.reference` is the POSITION reference — the whole chips+input
+      // field box (the caller mounts it via setPositionReference), not the bare input.
+      ...(isCombobox
+        ? [
+            size({
+              padding: 8,
+              apply({ rects, elements }) {
+                elements.floating.style.width = `${Math.max(rects.reference.width, 192)}px`;
+              },
+            }),
+          ]
+        : []),
       hide({ padding: 8 }),
     ],
   });
@@ -156,7 +190,9 @@ export function useAnchoredPopover(opts: AnchoredPopoverOptions) {
     }
   }, [opts.open]);
 
-  const click = useClick(context, { enabled: !isHover });
+  // A combobox opens from the field's own focus/typing (wired by <Combobox>), never a click-to-toggle —
+  // a click on the input must place the caret, not close the just-opened list.
+  const click = useClick(context, { enabled: !isHover && !isCombobox });
   const hover = useHover(context, {
     enabled: isHover,
     move: false,
@@ -170,9 +206,19 @@ export function useAnchoredPopover(opts: AnchoredPopoverOptions) {
   // stopPropagation the Escape away from a Modal/player underneath, or double-close both.) Outside-
   // press stays with floating-ui (tree-aware).
   const dismiss = useDismiss(context, { escapeKey: false });
-  const role = useRole(context, { role: opts.role ?? (isHover ? "tooltip" : "menu") });
+  // `role:"combobox"` makes Floating UI wire the whole typeable-combobox ARIA tree: the reference input
+  // → role=combobox + aria-expanded/controls/autocomplete + aria-activedescendant (from the virtual nav),
+  // the surface → role=listbox, the items → role=option + their option ids. (`combobox` maps to the
+  // `listbox` aria-role internally.) So <Combobox> sets NO aria-* by hand.
+  const role = useRole(context, {
+    role: opts.role ?? (isHover ? "tooltip" : isCombobox ? "combobox" : "menu"),
+  });
   const listNav = useListNavigation(context, {
-    enabled: isNav,
+    enabled: roves,
+    // Virtual navigation for a combobox: DOM focus stays on the text input while ↑/↓ move an
+    // `aria-activedescendant` pointer over the options (the handler rides on getReferenceProps → the
+    // input). A menu/listbox uses real roving focus instead.
+    virtual: isCombobox,
     listRef: elementsRef,
     activeIndex,
     // Keyboard (and pointer, when floating-ui owns it) navigation takes the visual highlight back from
@@ -188,12 +234,15 @@ export function useAnchoredPopover(opts: AnchoredPopoverOptions) {
     // `isListIndexDisabled`.) No explicit index list needed.
     loop: true,
     // Focus the first item on open for BOTH click and keyboard (the default 'auto' skips pointer-opens,
-    // which strands focus on the menu container — arrows then can't enter the roving list at all).
-    focusItemOnOpen: true,
-    // A menu that hosts a free-text input must NOT pull focus onto a list item when the pointer merely
-    // passes over it (the library default) — that blurs the input mid-typing and mis-routes the next
-    // Enter to the hovered item. Turned off together with typeahead for such menus.
-    focusItemOnHover: !opts.hostsInput,
+    // which strands focus on the menu container — arrows then can't enter the roving list at all). A
+    // combobox opens with NO active item — the caret is in the input, and the first ↓ lands on the first
+    // option; auto-highlighting item 0 on open would fight the typed query.
+    focusItemOnOpen: isCombobox ? false : true,
+    // A menu that hosts a free-text input, and every combobox, must NOT pull focus onto a list item when
+    // the pointer merely passes over it (the library default) — that blurs the input mid-typing and
+    // mis-routes the next Enter to the hovered item. The visual hover highlight is driven off hoverIndex
+    // instead (see PopoverItem), so the pointer still highlights without stealing the caret.
+    focusItemOnHover: isCombobox ? false : !opts.hostsInput,
   });
   const typeahead = useTypeahead(context, {
     enabled: isNav && (opts.typeahead ?? true) && !opts.hostsInput,
@@ -222,6 +271,8 @@ export function useAnchoredPopover(opts: AnchoredPopoverOptions) {
     nodeId,
     mode,
     isNav,
+    isCombobox,
+    roves,
     open: opts.open,
     selectedIndex: opts.selectedIndex ?? null,
     refs,
@@ -245,6 +296,9 @@ interface PopoverListContextValue {
   highlightIndex: number | null;
   setHoverIndex: (index: number | null) => void;
   getItemProps: AnchoredPopover["getItemProps"];
+  /** Combobox surface: items are navigated VIRTUALLY (aria-activedescendant), so a <PopoverItem> never
+   *  takes DOM focus (roving tabindex off) and keeps the caret in the input on click. */
+  virtual: boolean;
 }
 const PopoverListContext = createContext<PopoverListContextValue | null>(null);
 
@@ -302,6 +356,12 @@ export function PopoverItem({
   label?: string;
 } & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onSelect" | "role" | "children" | "className">) {
   const ctx = useContext(PopoverListContext);
+  const virtual = ctx?.virtual ?? false;
+  // A virtual (combobox) option needs a STABLE DOM id from first render: the input's aria-activedescendant
+  // is set to the active option's `.id` when the arrow handler reads it, so the id must already be there
+  // (Floating UI's own on-activation id assignment races the re-render and lands empty through our
+  // indirection). A menu/listbox item uses roving DOM focus instead and needs no id.
+  const generatedId = useId();
   const textLabel = label ?? (typeof children === "string" ? children : undefined);
   const { ref, index } = useListItem({ label: textLabel });
   // Roving tabindex / DOM focus follow the KEYBOARD position (activeIndex); the visible highlight
@@ -309,12 +369,12 @@ export function PopoverItem({
   const focusActive = ctx?.activeIndex === index;
   const visualActive = ctx?.highlightIndex === index;
 
-  const ariaProps =
-    role === "menuitemradio" || role === "menuitemcheckbox"
-      ? { role, "aria-checked": !!checked }
-      : role === "option"
-        ? { role, "aria-selected": !!selected }
-        : { role };
+  // The checked/selected state is rendered as an EXPLICIT attribute after {...handlers} below (so it
+  // wins): for a combobox `role:"combobox"` makes getItemProps emit its own `aria-selected` off the
+  // single selectedIndex, which is always false for a MULTI-select — our per-value truth must override.
+  const ariaChecked =
+    role === "menuitemradio" || role === "menuitemcheckbox" ? !!checked : undefined;
+  const ariaSelected = role === "option" ? !!selected : undefined;
 
   // Route the caller's own props (onClick, onFocus, …) THROUGH floating-ui's item-prop getter, which
   // composes handlers rather than dropping them — spreading `{...rest}` separately would let the
@@ -332,19 +392,37 @@ export function PopoverItem({
     rest.onMouseMove?.(e);
     if (ctx && !disabled && index != null && ctx.highlightIndex !== index) ctx.setHoverIndex(index);
   };
+  // In a combobox, clicking an option must NOT move DOM focus off the input (that would close the list
+  // and drop the caret) — preventDefault the mousedown so focus stays put; the onClick still selects.
+  const mergedMouseDown = (e: React.MouseEvent<HTMLButtonElement>) => {
+    rest.onMouseDown?.(e);
+    if (virtual) e.preventDefault();
+  };
   const handlers = ctx
-    ? ctx.getItemProps({ ...rest, onClick: mergedClick, onMouseMove: mergedMouseMove })
-    : { ...rest, onClick: mergedClick };
+    ? ctx.getItemProps({
+        ...rest,
+        onClick: mergedClick,
+        onMouseMove: mergedMouseMove,
+        onMouseDown: mergedMouseDown,
+      })
+    : { ...rest, onClick: mergedClick, onMouseDown: mergedMouseDown };
 
   return (
     <button
       ref={ref}
       type="button"
-      {...ariaProps}
+      role={role}
       {...handlers}
-      // These win over anything in `handlers` — the roving tabindex must not be a caller override,
-      // and disabled/className/data-active are the platform's to set.
-      tabIndex={focusActive ? 0 : -1}
+      // A virtual option carries its own stable id (the aria-activedescendant target); it wins over any
+      // id Floating UI's getItemProps would inject on activation.
+      id={virtual ? generatedId : undefined}
+      // These win over anything in `handlers` — the roving tabindex must not be a caller override, the
+      // checked/selected truth must beat getItemProps' single-select guess, and disabled/className/
+      // data-active are the platform's to set. A virtual (combobox) item never holds DOM focus, so its
+      // tabindex is always -1; navigation is by aria-activedescendant.
+      aria-checked={ariaChecked}
+      aria-selected={ariaSelected}
+      tabIndex={virtual ? -1 : focusActive ? 0 : -1}
       data-active={visualActive ? "true" : undefined}
       disabled={disabled}
       className={`outline-hidden ${
@@ -409,6 +487,8 @@ function PopoverSurfaceInner({
     isPositioned,
     mode,
     isNav,
+    isCombobox,
+    roves,
     selectedIndex,
     activeIndex,
     highlightIndex,
@@ -441,9 +521,10 @@ function PopoverSurfaceInner({
   if (ariaLabel) delete floatingProps["aria-labelledby"];
 
   const zClass = mode === "hover" ? "z-tooltip" : "z-popover";
-  // Everything but a passive hover card manages focus by default (trap into the surface, return to
-  // the trigger on close).
-  const managed = focusManaged ?? mode !== "hover";
+  // A menu/listbox/dialog traps focus into the surface (and returns it on close). A hover card is
+  // passive, and a COMBOBOX must leave focus in the input (its list is navigated virtually) — neither
+  // is focus-managed.
+  const managed = focusManaged ?? (mode !== "hover" && !isCombobox);
 
   const surface = (
     <div
@@ -477,11 +558,11 @@ function PopoverSurfaceInner({
     </div>
   );
 
-  // Menu/listbox surfaces host the item registry (FloatingList) + active-state context so nested
-  // <PopoverItem>s can self-register and rove.
-  const positioned = isNav ? (
+  // Menu/listbox AND combobox surfaces host the item registry (FloatingList) + active-state context so
+  // nested <PopoverItem>s can self-register and rove/aria-activedescendant.
+  const positioned = roves ? (
     <PopoverListContext.Provider
-      value={{ activeIndex, highlightIndex, setHoverIndex, getItemProps }}
+      value={{ activeIndex, highlightIndex, setHoverIndex, getItemProps, virtual: isCombobox }}
     >
       <FloatingList elementsRef={elementsRef} labelsRef={labelsRef}>
         {surface}

frontend/src/components/Carousel.dom.test.tsx

@@ -0,0 +1,93 @@
+// @vitest-environment jsdom
+//
+// Contract of the shared horizontal rail. jsdom lays out nothing (scrollWidth/clientWidth are 0), so
+// the overflow-driven scroll buttons only appear once we feed the scroller fake metrics and fire a
+// scroll — which is exactly the affordance under test: a button shows ONLY on the clipped edge, and
+// clicking it pages the scroller. i18n is key-passthrough, so asserted names are the i18n keys.
+import { describe, it, expect, vi, beforeAll, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  return { ...actual, useTranslation: () => ({ t: (k: string) => k }) };
+});
+
+import { Carousel } from "./Carousel";
+
+beforeAll(() => {
+  // useHScroll wires a ResizeObserver (watch-the-children); jsdom ships none.
+  class Stub {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() {
+      return [];
+    }
+  }
+  globalThis.ResizeObserver ??= Stub as unknown as typeof ResizeObserver;
+});
+
+afterEach(cleanup);
+
+function setMetrics(
+  el: HTMLElement,
+  m: { scrollWidth: number; clientWidth: number; scrollLeft: number },
+) {
+  Object.defineProperty(el, "scrollWidth", { configurable: true, value: m.scrollWidth });
+  Object.defineProperty(el, "clientWidth", { configurable: true, value: m.clientWidth });
+  Object.defineProperty(el, "scrollLeft", {
+    configurable: true,
+    writable: true,
+    value: m.scrollLeft,
+  });
+}
+
+describe("Carousel", () => {
+  it("renders children and an optional header with a see-all action", () => {
+    const onSeeAll = vi.fn();
+    render(
+      <Carousel title="Recently added" onSeeAll={onSeeAll}>
+        <div>card-a</div>
+        <div>card-b</div>
+      </Carousel>,
+    );
+    expect(screen.getByText("card-a")).toBeTruthy();
+    expect(screen.getByRole("heading", { name: "Recently added" })).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "common.seeAll" }));
+    expect(onSeeAll).toHaveBeenCalledOnce();
+  });
+
+  it("omits the header when no title is given and names the scroll region", () => {
+    render(
+      <Carousel ariaLabel="Cast">
+        <div>x</div>
+      </Carousel>,
+    );
+    expect(screen.queryByRole("heading")).toBeNull();
+    expect(screen.getByRole("group", { name: "Cast" })).toBeTruthy();
+  });
+
+  it("shows only the clipped edge's button and pages the scroller on click", () => {
+    render(
+      <Carousel ariaLabel="rail">
+        <div>x</div>
+      </Carousel>,
+    );
+    const scroller = screen.getByRole("group", { name: "rail" });
+    const scrollBy = vi.fn();
+    scroller.scrollBy = scrollBy as unknown as typeof scroller.scrollBy;
+
+    // At the left boundary with more content to the right → only the right button.
+    setMetrics(scroller, { scrollWidth: 1000, clientWidth: 300, scrollLeft: 0 });
+    fireEvent.scroll(scroller);
+    expect(screen.queryByRole("button", { name: "common.scrollLeft" })).toBeNull();
+    fireEvent.click(screen.getByRole("button", { name: "common.scrollRight" }));
+    expect(scrollBy).toHaveBeenCalled();
+
+    // Scrolled into the middle → both edges clipped → both buttons.
+    setMetrics(scroller, { scrollWidth: 1000, clientWidth: 300, scrollLeft: 350 });
+    fireEvent.scroll(scroller);
+    expect(screen.getByRole("button", { name: "common.scrollLeft" })).toBeTruthy();
+    expect(screen.getByRole("button", { name: "common.scrollRight" })).toBeTruthy();
+  });
+});

frontend/src/components/Carousel.tsx

@@ -0,0 +1,135 @@
+import { useCallback, type ReactNode } from "react";
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import { useTranslation } from "react-i18next";
+import clsx from "clsx";
+import { useScrollEdges } from "../lib/useScrollEdges";
+
+// Shared horizontal rail — the one place the app's "row of cards you scroll sideways" lives, replacing
+// the hand-rolled `flex gap overflow-x-auto` strips (Cast / Related / collections) and the future
+// Plex-Discover rows. Gives every consumer the same affordances for free: edge fade, hover/focus scroll
+// buttons that appear only on the side that actually has more content, a native scrollbar hidden behind
+// `.no-scrollbar`, and reduced-motion-aware paging. Purely presentational — the caller owns the cards.
+
+// Prefer an instant jump when the viewer asked for reduced motion; smooth otherwise. Guarded for jsdom,
+// where matchMedia is often absent (the button paging is still exercised — it just uses "auto" there).
+function scrollBehavior(): ScrollBehavior {
+  const reduce =
+    typeof window !== "undefined" &&
+    typeof window.matchMedia === "function" &&
+    window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  return reduce ? "auto" : "smooth";
+}
+
+// Horizontal scroll-affordance: whether the scroller is clipped on the left / right, so the rail shows
+// a button + fade only where there's more to see. The X-axis face of the shared `useScrollEdges` core
+// (the same watch-the-scroller-and-its-children discipline as the vertical `useScrollFade`), plus the
+// element itself so the paging buttons can scroll it.
+function useHScroll(): {
+  ref: (node: HTMLElement | null) => void;
+  el: HTMLElement | null;
+  left: boolean;
+  right: boolean;
+} {
+  const { ref, el, start, end } = useScrollEdges("x");
+  return { ref, el, left: start, right: end };
+}
+
+const FADE_PX = 28;
+
+export function Carousel({
+  title,
+  onSeeAll,
+  seeAllLabel,
+  ariaLabel,
+  gap = "gap-3",
+  className,
+  children,
+}: {
+  /** Optional built-in header (rails). Omit for a bare scroller inside a card that owns its own heading. */
+  title?: ReactNode;
+  /** When set, a "see all" affordance appears in the header (needs `title`). */
+  onSeeAll?: () => void;
+  seeAllLabel?: string;
+  /** Names the scroll region for AT; falls back to the string `title` when that's a plain string. */
+  ariaLabel?: string;
+  /** Tailwind gap class for the scroller (e.g. "gap-4"). */
+  gap?: string;
+  className?: string;
+  children: ReactNode;
+}) {
+  const { t } = useTranslation();
+  const { ref, el, left, right } = useHScroll();
+
+  const page = useCallback(
+    (dir: -1 | 1) => {
+      if (!el) return;
+      // ~one viewport-worth, but never a hair scroll on a narrow rail (or 0 in a zero-width jsdom box).
+      const amount = Math.max(Math.round(el.clientWidth * 0.85), 200);
+      el.scrollBy({ left: dir * amount, behavior: scrollBehavior() });
+    },
+    [el],
+  );
+
+  // Fade only the clipped edge — no fade at a boundary, none when it all fits (matches useScrollFade).
+  const mask = `linear-gradient(to right, transparent, #000 ${left ? FADE_PX : 0}px, #000 calc(100% - ${
+    right ? FADE_PX : 0
+  }px), transparent)`;
+
+  const label = ariaLabel ?? (typeof title === "string" ? title : undefined);
+
+  const arrowBtn =
+    "absolute top-1/2 -translate-y-1/2 z-10 grid h-9 w-9 place-items-center rounded-full " +
+    "bg-black/55 text-white backdrop-blur-xs border border-white/15 shadow-lg transition " +
+    "opacity-0 group-hover/car:opacity-100 focus-visible:opacity-100 hover:bg-black/75";
+
+  return (
+    <div className={clsx("group/car relative", className)}>
+      {title != null && (
+        <div className="mb-3 flex items-baseline gap-2">
+          <h2 className="text-sm font-semibold">{title}</h2>
+          {onSeeAll && (
+            <button
+              onClick={onSeeAll}
+              className="ml-auto inline-flex items-center gap-0.5 text-xs text-muted transition hover:text-accent"
+            >
+              {seeAllLabel ?? t("common.seeAll")}
+              <ChevronRight className="h-3.5 w-3.5" />
+            </button>
+          )}
+        </div>
+      )}
+
+      <div className="relative">
+        {left && (
+          <button
+            type="button"
+            onClick={() => page(-1)}
+            aria-label={t("common.scrollLeft")}
+            className={clsx(arrowBtn, "left-1")}
+          >
+            <ChevronLeft className="h-5 w-5" />
+          </button>
+        )}
+        <div
+          ref={ref}
+          className={clsx("no-scrollbar flex overflow-x-auto pb-1", gap)}
+          style={{ maskImage: mask, WebkitMaskImage: mask }}
+          role="group"
+          aria-label={label}
+        >
+          {children}
+        </div>
+        {right && (
+          <button
+            type="button"
+            onClick={() => page(1)}
+            aria-label={t("common.scrollRight")}
+            className={clsx(arrowBtn, "right-1")}
+          >
+            <ChevronRight className="h-5 w-5" />
+          </button>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/components/ChannelDiscovery.tsx

@@ -200,7 +200,7 @@ export default function ChannelDiscovery({
     <>
       {/* Intro + the table controls are fixed chrome; only the table rows scroll (sticky header). */}
       <PageToolbar>
-        <div className="px-4 pt-3 max-w-384 mx-auto flex items-start justify-between gap-4">
+        <div className="px-4 pt-2 max-w-384 mx-auto flex items-start justify-between gap-4">
           <p className="text-xs text-muted leading-relaxed">{t("channels.discovery.intro")}</p>
           {/* Cards has no column headers, so a dropdown drives the sort + a pager (table uses its own). */}
           {layout === "cards" && (

frontend/src/components/ChannelPage.tsx

@@ -27,7 +27,7 @@ import { useFeedFilters } from "./FeedFiltersProvider";
 import { useConfirm } from "./ConfirmProvider";
 import { notify } from "../lib/notifications";
 import { notifyYouTubeActionError } from "../lib/youtubeErrors";
-import { api, type FeedFilters, type Me, type ChannelDetail } from "../lib/api";
+import { api, DEFAULT_TAG_MODES, type FeedFilters, type Me, type ChannelDetail } from "../lib/api";
 import type { FeedView } from "../lib/feedView";
 import { channelYouTubeUrl, formatViews } from "../lib/format";
 import { ChannelTagsControl } from "./ChannelTags";
@@ -231,7 +231,7 @@ export default function ChannelPage({
   // the explored, per-user-private videos show — the backend gates them to this explorer).
   const [filters, setFilters] = useState<FeedFilters>(() => ({
     tags: [],
-    tagMode: "or",
+    tagModes: DEFAULT_TAG_MODES,
     q: "",
     sort: "newest",
     scope: "all",

frontend/src/components/ChannelPicker.tsx

@@ -1,11 +1,8 @@
-import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { useQuery } from "@tanstack/react-query";
 import { qk } from "../lib/queryKeys";
-import { X } from "lucide-react";
 import { api, type FeedFilters } from "../lib/api";
-import { useScrollFade } from "../lib/useScrollFade";
-import { inputCls } from "./ui/form";
+import Combobox, { type ComboboxOption } from "./Combobox";
 
 // Pick channels to narrow the feed to — several OR together, so every other filter then applies
 // across all of them. Until this existed the filter was settable only via a shared "?channel=" link:
@@ -22,86 +19,29 @@ export default function ChannelPicker({
   setFilters: (f: FeedFilters) => void;
 }) {
   const { t } = useTranslation();
-  const [query, setQuery] = useState("");
-  // Same edge-fade affordance the nav rail and the panel body use to hint at more content.
-  const fade = useScrollFade();
   const channelsQuery = useQuery({
     queryKey: qk.channels(),
     queryFn: api.channels,
     staleTime: 5 * 60_000,
   });
 
-  const q = query.trim().toLowerCase();
   const all = channelsQuery.data ?? [];
-  const matches = q ? all.filter((c) => (c.title ?? c.id).toLowerCase().includes(q)) : all;
-  const picked = filters.channelIds;
-  const nameOf = (id: string) => all.find((c) => c.id === id)?.title ?? id;
-  const toggle = (id: string) =>
-    setFilters({
-      ...filters,
-      channelIds: picked.includes(id) ? picked.filter((x) => x !== id) : [...picked, id],
-    });
+  // The list order isn't alphabetical — it's the user's channel priority — and Combobox preserves the
+  // options order, so it stays meaningful. selectedLabels keeps a picked channel named even if a later
+  // narrowing ever drops it from the visible rows.
+  const options: ComboboxOption[] = all.map((c) => ({ value: c.id, label: c.title ?? c.id }));
+  const selectedLabels = Object.fromEntries(all.map((c) => [c.id, c.title ?? c.id]));
 
   return (
-    <>
-      {/* The picks sit above the list so they stay visible once the list scrolls away. */}
-      {picked.length > 0 && (
-        <div className="flex flex-wrap gap-1.5 pb-2">
-          {picked.map((id) => (
-            <button
-              key={id}
-              onClick={() => toggle(id)}
-              title={t("sidebar.channelRemove", { name: nameOf(id) })}
-              className="chip-solid inline-flex items-center gap-1 max-w-full pl-2.5 pr-1.5 py-1 rounded-full text-xs shadow-xs hover:opacity-90 transition"
-            >
-              <span className="truncate">{nameOf(id)}</span>
-              <X className="w-3 h-3 shrink-0" />
-            </button>
-          ))}
-        </div>
-      )}
-      <input
-        value={query}
-        onChange={(e) => setQuery(e.target.value)}
-        placeholder={t("sidebar.channelSearch")}
-        aria-label={t("sidebar.channelSearch")}
-        className={inputCls}
-      />
-      {/* The order isn't arbitrary and isn't alphabetical — say so, or the top of the list looks
-          random to anyone who hasn't set a priority. Only while unfiltered: a search reorders nothing
-          but does drop the rows that explain it. */}
-      {!q && all.length > 0 && (
-        <div className="px-2 pt-1.5 text-2xs text-muted">{t("sidebar.channelOrder")}</div>
-      )}
-      <div
-        ref={fade.ref}
-        style={fade.style}
-        className="mt-1.5 max-h-44 overflow-y-auto no-scrollbar flex flex-col gap-0.5"
-      >
-        {matches.length === 0 ? (
-          <div className="px-2 py-1.5 text-xs text-muted">
-            {channelsQuery.isLoading ? t("sidebar.loading") : t("sidebar.noChannelMatch")}
-          </div>
-        ) : (
-          matches.map((c) => {
-            const on = picked.includes(c.id);
-            return (
-              <button
-                key={c.id}
-                onClick={() => toggle(c.id)}
-                aria-pressed={on}
-                // shrink-0 is load-bearing: these are flex children in a max-height box, so without
-                // them they squash to ~12px each and clip their own text instead of the box scrolling.
-                className={`w-full shrink-0 text-left text-sm px-2 py-1.5 rounded-lg truncate transition ${
-                  on ? "text-accent font-medium" : "text-muted hover:text-fg hover:bg-card"
-                }`}
-              >
-                {c.title ?? c.id}
-              </button>
-            );
-          })
-        )}
-      </div>
-    </>
+    <Combobox
+      label={t("sidebar.channelSearch")}
+      placeholder={t("sidebar.channelSearch")}
+      options={options}
+      selected={filters.channelIds}
+      onChange={(channelIds) => setFilters({ ...filters, channelIds })}
+      loading={channelsQuery.isLoading}
+      emptyText={t("sidebar.noChannelMatch")}
+      selectedLabels={selectedLabels}
+    />
   );
 }

frontend/src/components/Combobox.dom.test.tsx

@@ -0,0 +1,249 @@
+// @vitest-environment jsdom
+//
+// The universal combobox (chips + typed search field over the AnchoredPopover `combobox` mode). Covers
+// chip removal, open-on-focus, client filter, toggling, Backspace-removes-last, the big-vocabulary cap,
+// single-select, and the combobox ARIA the old hand-rolled control lacked (role=combobox, aria-expanded,
+// and a virtual aria-activedescendant that keeps DOM focus on the input). i18n is key-passthrough; the
+// floating-ui recipe (ActionMenu's): stub the two observers autoUpdate wires, wrap in a FloatingTree,
+// and query the hidden surface with `{ hidden: true }` since jsdom never positions it.
+import { describe, it, expect, vi, afterEach, beforeAll } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { FloatingTree } from "@floating-ui/react";
+
+beforeAll(() => {
+  class Stub {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() {
+      return [];
+    }
+  }
+  globalThis.ResizeObserver ??= Stub as unknown as typeof ResizeObserver;
+  globalThis.IntersectionObserver ??= Stub as unknown as typeof IntersectionObserver;
+});
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  return { ...actual, useTranslation: () => ({ t: (k: string) => k }) };
+});
+
+import Combobox from "./Combobox";
+
+afterEach(cleanup);
+
+const OPTIONS = [
+  { value: "Drama", count: 120 },
+  { value: "Action", count: 90 },
+  { value: "Comedy", count: 60 },
+];
+
+function wrap(ui: React.ReactElement) {
+  return render(<FloatingTree>{ui}</FloatingTree>);
+}
+
+describe("Combobox", () => {
+  it("renders selected values as removable chips and removes on ✕", () => {
+    const onChange = vi.fn();
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={["Drama"]} onChange={onChange} />);
+    expect(screen.getByText("Drama")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "common.remove" }));
+    expect(onChange).toHaveBeenCalledWith([]); // Drama removed
+  });
+
+  it("exposes combobox ARIA: role=combobox, aria-expanded toggling, aria-controls when open", () => {
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={[]} onChange={vi.fn()} />);
+    const input = screen.getByRole("combobox");
+    expect(input.getAttribute("aria-expanded")).toBe("false");
+    expect(input.getAttribute("aria-controls")).toBeNull();
+    fireEvent.focus(input);
+    expect(input.getAttribute("aria-expanded")).toBe("true");
+    // aria-controls now points at the listbox surface.
+    const controls = input.getAttribute("aria-controls");
+    expect(controls).toBeTruthy();
+    expect(document.getElementById(controls!)?.getAttribute("role")).toBe("listbox");
+  });
+
+  it("focuses the input when the field chrome is pressed (merged ref, not a dead inputRef)", () => {
+    // Regression: the input carried only floating-ui's ref, so `inputRef` stayed null. The field's
+    // onMouseDown then preventDefault()-ed every press (its `e.target !== inputRef.current` guard was
+    // always true) and its compensating inputRef.current?.focus() was a no-op → the box couldn't be
+    // typed into with the mouse. A merged ref feeds the node to both, so pressing the chrome focuses it.
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={[]} onChange={vi.fn()} />);
+    const input = screen.getByRole("combobox");
+    const field = input.parentElement as HTMLElement;
+    expect(document.activeElement).not.toBe(input);
+    fireEvent.mouseDown(field); // press the field padding, not the input itself
+    expect(document.activeElement).toBe(input);
+  });
+
+  it("keeps the option list unmounted until the field is focused", () => {
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={[]} onChange={vi.fn()} />);
+    expect(screen.queryByRole("option", { hidden: true })).toBeNull();
+    fireEvent.focus(screen.getByRole("combobox"));
+    expect(screen.getAllByRole("option", { hidden: true }).length).toBe(3);
+  });
+
+  it("filters the options by the typed query", () => {
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={[]} onChange={vi.fn()} />);
+    const field = screen.getByRole("combobox");
+    fireEvent.focus(field);
+    fireEvent.change(field, { target: { value: "com" } });
+    const items = screen.getAllByRole("option", { hidden: true });
+    expect(items.length).toBe(1);
+    expect(items[0]?.textContent).toContain("Comedy");
+  });
+
+  it("marks a selected option aria-selected and toggles another on", () => {
+    const onChange = vi.fn();
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={["Drama"]} onChange={onChange} />);
+    fireEvent.focus(screen.getByRole("combobox"));
+    const drama = screen
+      .getAllByRole("option", { hidden: true })
+      .find((el) => el.textContent?.includes("Drama"));
+    expect(drama?.getAttribute("aria-selected")).toBe("true");
+    fireEvent.click(screen.getByText("Action")); // clicking the option's label toggles it on
+    expect(onChange).toHaveBeenCalledWith(["Drama", "Action"]);
+  });
+
+  it("moves an aria-activedescendant on ArrowDown while DOM focus stays on the input", () => {
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={[]} onChange={vi.fn()} />);
+    const input = screen.getByRole("combobox");
+    input.focus();
+    fireEvent.focus(input);
+    fireEvent.keyDown(input, { key: "ArrowDown" });
+    // Virtual navigation: the input keeps DOM focus, the active option is referenced by id.
+    expect(document.activeElement).toBe(input);
+    expect(input.getAttribute("aria-activedescendant")).toBeTruthy();
+  });
+
+  it("removes the last chip on Backspace in an empty field", () => {
+    const onChange = vi.fn();
+    wrap(
+      <Combobox
+        label="Genre"
+        options={OPTIONS}
+        selected={["Drama", "Action"]}
+        onChange={onChange}
+      />,
+    );
+    fireEvent.keyDown(screen.getByRole("combobox"), { key: "Backspace" });
+    expect(onChange).toHaveBeenCalledWith(["Drama"]); // last chip dropped
+  });
+
+  it("caps the rendered rows for a large vocabulary and shows a refine hint", () => {
+    // A studio-sized list (hundreds) must not render every row — cap at 50 + a "N more" footer.
+    const many = Array.from({ length: 60 }, (_, i) => ({ value: `Studio ${i}`, count: 60 - i }));
+    wrap(<Combobox label="Studio" options={many} selected={[]} onChange={vi.fn()} />);
+    fireEvent.focus(screen.getByRole("combobox"));
+    expect(screen.getAllByRole("option", { hidden: true }).length).toBe(50);
+    expect(screen.getByText("plex.filter.moreRefine")).toBeTruthy(); // 10 hidden behind search
+  });
+
+  it("Enter commits the pointer-highlighted option, not the arrow-active one", () => {
+    // The visible highlight follows the pointer (hoverIndex); Enter must commit THAT row, not the bare
+    // keyboard activeIndex — otherwise arrow-then-hover-then-Enter toggles a different option than shown.
+    const onChange = vi.fn();
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={[]} onChange={onChange} />);
+    const input = screen.getByRole("combobox");
+    input.focus();
+    fireEvent.focus(input);
+    fireEvent.keyDown(input, { key: "ArrowDown" }); // activeIndex → 0 (Drama)
+    const action = screen
+      .getAllByRole("option", { hidden: true })
+      .find((el) => el.textContent?.includes("Action"))!;
+    fireEvent.mouseMove(action); // hoverIndex → Action (the visibly highlighted row)
+    fireEvent.keyDown(input, { key: "Enter" });
+    expect(onChange).toHaveBeenCalledWith(["Action"]); // the highlighted (hovered) row, not Drama
+  });
+
+  it("Enter commits a hover-highlighted option even with no prior arrow key", () => {
+    const onChange = vi.fn();
+    wrap(<Combobox label="Genre" options={OPTIONS} selected={[]} onChange={onChange} />);
+    const input = screen.getByRole("combobox");
+    input.focus();
+    fireEvent.focus(input);
+    const comedy = screen
+      .getAllByRole("option", { hidden: true })
+      .find((el) => el.textContent?.includes("Comedy"))!;
+    fireEvent.mouseMove(comedy); // highlight via hover, activeIndex still null
+    fireEvent.keyDown(input, { key: "Enter" });
+    expect(onChange).toHaveBeenCalledWith(["Comedy"]); // no longer a silent no-op
+  });
+
+  it("async mode: controlled query + onQueryChange/onOpenChange, no client filter, selectedLabels chip", () => {
+    const onQueryChange = vi.fn();
+    const onOpenChange = vi.fn();
+    const onChange = vi.fn();
+    const serverOpts = [{ value: "id1", label: "Harry Potter", count: 8 }];
+    wrap(
+      <Combobox
+        label="Collection"
+        multiple={false}
+        clientFilter={false}
+        options={serverOpts}
+        selected={["stored-id"]}
+        selectedLabels={{ "stored-id": "Stored Collection" }}
+        query="har"
+        onQueryChange={onQueryChange}
+        onOpenChange={onOpenChange}
+        onChange={onChange}
+      />,
+    );
+    // The selected value's option isn't in the (server-narrowed) list, so its chip uses selectedLabels.
+    expect(screen.getByText("Stored Collection")).toBeTruthy();
+    const input = screen.getByRole("combobox");
+    fireEvent.focus(input);
+    expect(onOpenChange).toHaveBeenCalledWith(true);
+    fireEvent.change(input, { target: { value: "harr" } });
+    expect(onQueryChange).toHaveBeenCalledWith("harr"); // controlled query propagates out
+    // clientFilter=false: the single server option renders verbatim (not re-filtered against "har").
+    const opts = screen.getAllByRole("option", { hidden: true });
+    expect(opts.length).toBe(1);
+    expect(opts[0]?.textContent).toContain("Harry Potter");
+    fireEvent.click(screen.getByText("Harry Potter"));
+    expect(onChange).toHaveBeenCalledWith(["id1"]); // single-select replaces
+  });
+
+  it("shows the any/all match footer only at 2+ selections and reports a mode change", () => {
+    // The per-category any/all toggle: meaningless below 2 selections (any === all), so it appears
+    // only at >= 2, and clicking 'all' reports the mode change out.
+    const onMatchModeChange = vi.fn();
+    const props = {
+      label: "Topic",
+      options: OPTIONS,
+      onChange: vi.fn(),
+      matchMode: "or" as const,
+      onMatchModeChange,
+    };
+    // One selection: no footer.
+    const { rerender } = wrap(<Combobox {...props} selected={["Drama"]} />);
+    fireEvent.focus(screen.getByRole("combobox"));
+    expect(screen.queryByText("sidebar.all")).toBeNull();
+
+    // Two selections: footer appears with an any/all segment.
+    rerender(<FloatingTree>{<Combobox {...props} selected={["Drama", "Action"]} />}</FloatingTree>);
+    fireEvent.focus(screen.getByRole("combobox"));
+    const all = screen.getByText("sidebar.all");
+    expect(all).toBeTruthy();
+    fireEvent.click(all);
+    expect(onMatchModeChange).toHaveBeenCalledWith("and");
+  });
+
+  it("single-select: picking replaces the value and closes the list", () => {
+    const onChange = vi.fn();
+    wrap(
+      <Combobox
+        label="Collection"
+        multiple={false}
+        options={OPTIONS}
+        selected={["Drama"]}
+        onChange={onChange}
+      />,
+    );
+    fireEvent.focus(screen.getByRole("combobox"));
+    fireEvent.click(screen.getByText("Action"));
+    expect(onChange).toHaveBeenCalledWith(["Action"]); // replaced, not appended
+    expect(screen.getByRole("combobox").getAttribute("aria-expanded")).toBe("false"); // closed
+  });
+});

frontend/src/components/Combobox.tsx

@@ -0,0 +1,325 @@
+import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import { useTranslation } from "react-i18next";
+import { Check, ChevronDown, X } from "lucide-react";
+import { useAnchoredPopover, PopoverSurface, PopoverItem } from "./AnchoredPopover";
+import { useScrollFade } from "../lib/useScrollFade";
+
+// The universal combobox: a react-select / Overseerr-style "combi input" — selected values are
+// removable chips that live INSIDE a text field you type into, and a checklist of options opens below.
+// It is the ONE control for "pick value(s) from a (possibly large, possibly async) vocabulary": the E5
+// Plex filters (genre / age-rating / studio, multi-select) and the collection picker (single-select,
+// server-searched) are both instances, and the header search typeahead can move onto it later.
+//
+// All the fiddly parts live in the AnchoredPopover `combobox` mode, NOT here: floating-ui positioning,
+// the paint-before-position + transform-clobber flash guards, the topmost-only Escape layer, and the
+// FULL combobox ARIA tree (input role=combobox + aria-expanded/controls/activedescendant, listbox
+// surface, option ids, virtual ↑/↓ arrow-nav that keeps the caret in the field). This component only
+// adds the field chrome (chips + input + chevron), the query/selection state, and the big-vocabulary
+// render cap. That is what makes it accessible where the old hand-rolled MultiSelectChips was not.
+
+export interface ComboboxOption {
+  value: string;
+  /** Display text; defaults to `value`. */
+  label?: string;
+  /** A facet count shown at the row's end. */
+  count?: number;
+  disabled?: boolean;
+}
+
+export interface ComboboxProps {
+  /** Accessible name for the input (the section heading usually names it visibly too). */
+  label: string;
+  options: readonly ComboboxOption[];
+  /** Selected values. Single-select carries 0 or 1. */
+  selected: string[];
+  onChange: (next: string[]) => void;
+  /** Several values at once (chips accumulate) vs one (picking replaces + closes). Default true. */
+  multiple?: boolean;
+  /** Notified when the list opens/closes — a server-searched caller gates its fetch on `open`. */
+  onOpenChange?: (open: boolean) => void;
+  placeholder?: string;
+  /** Controlled query text — pass with `onQueryChange` for a server-searched (async) vocabulary; omit
+   *  to let the combobox own the query state and filter `options` on the client. */
+  query?: string;
+  onQueryChange?: (q: string) => void;
+  /** Filter `options` by the query on the client (default). Set false when the caller already narrows
+   *  the list server-side (then `options` arrives pre-filtered). */
+  clientFilter?: boolean;
+  loading?: boolean;
+  /** Shown when there are no options to list. */
+  emptyText?: string;
+  /** Cap on rendered rows for a huge vocabulary; the rest hide behind the search. Default 50. */
+  maxVisible?: number;
+  /** Custom row body (icon + label + count …); defaults to a checkbox + label + count. */
+  renderOption?: (option: ComboboxOption, isSelected: boolean) => ReactNode;
+  /** Chip/label text for a selected value whose option is not in the current (e.g. server-narrowed)
+   *  list — the collection picker passes the stored title here so a reloaded filter still names itself. */
+  selectedLabels?: Record<string, string>;
+  /** Optional "any/all" match segment in the popover footer (like SortControl's direction segment):
+   *  "or" = a match on ANY selected value, "and" = must match ALL. Provide BOTH to show it; it appears
+   *  only once 2+ values are selected (below that, any and all are the same). */
+  matchMode?: "or" | "and";
+  onMatchModeChange?: (mode: "or" | "and") => void;
+}
+
+export default function Combobox({
+  label,
+  options,
+  selected,
+  onChange,
+  multiple = true,
+  onOpenChange,
+  placeholder,
+  query: queryProp,
+  onQueryChange,
+  clientFilter = true,
+  loading = false,
+  emptyText,
+  maxVisible = 50,
+  renderOption,
+  selectedLabels,
+  matchMode,
+  onMatchModeChange,
+}: ComboboxProps) {
+  const { t } = useTranslation();
+  const [open, setOpen] = useState(false);
+  // The query is controlled when the caller drives it (async search), else owned here.
+  const [queryState, setQueryState] = useState("");
+  const query = queryProp ?? queryState;
+  const setQuery = (q: string) => {
+    if (queryProp === undefined) setQueryState(q);
+    onQueryChange?.(q);
+  };
+  const inputRef = useRef<HTMLInputElement | null>(null);
+  const fade = useScrollFade();
+
+  // Remember each value's display label as options flow through, so a selected chip can name itself
+  // even after the option leaves the query-narrowed list (async single-select). Caller-supplied
+  // `selectedLabels` win (they survive a page reload where nothing has been fetched yet).
+  const labelCache = useRef<Record<string, string>>({});
+  useEffect(() => {
+    for (const o of options) if (o.label != null) labelCache.current[o.value] = o.label;
+  }, [options]);
+  const labelFor = (v: string) => selectedLabels?.[v] ?? labelCache.current[v] ?? v;
+
+  const setOpenAnd = (next: boolean) => {
+    setOpen(next);
+    onOpenChange?.(next);
+  };
+  const pop = useAnchoredPopover({ open, onOpenChange: setOpenAnd, mode: "combobox" });
+  // The input is the combobox reference for floating-ui AND our own focus target (the field's
+  // click-to-focus handler, and commit() re-focusing after a pick). A merged callback ref feeds the
+  // node to BOTH — without it `inputRef` stays null, so the field's onMouseDown guard (`e.target !==
+  // inputRef.current`) is always true and preventDefault() cancels the input's own click-focus, making
+  // the field impossible to type into with the mouse. Memoised so floating-ui's ref isn't re-attached
+  // every render.
+  const setInputRef = useCallback(
+    (node: HTMLInputElement | null) => {
+      pop.refs.setReference(node);
+      inputRef.current = node;
+    },
+    [pop.refs],
+  );
+  // `highlightIndex` = the row the user actually SEES highlighted (pointer hover, else keyboard); Enter
+  // commits THAT, not the bare keyboard `activeIndex` — otherwise arrow-then-hover-then-Enter would toggle
+  // a different option than the highlighted one, and a hover with no prior arrow (activeIndex still null)
+  // would make Enter a no-op over a highlighted row.
+  const { activeIndex, highlightIndex } = pop;
+
+  // Clear the typed query when the list closes.
+  useEffect(() => {
+    if (!open) setQuery("");
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open]);
+
+  const filtered = useMemo(() => {
+    if (!clientFilter) return options;
+    const q = query.trim().toLowerCase();
+    if (!q) return options;
+    return options.filter((o) => (o.label ?? o.value).toLowerCase().includes(q));
+  }, [options, query, clientFilter]);
+
+  // Options arrive count-desc (facet order), so the capped default view is the most-common values; a
+  // footer flags how many more are reachable through the search.
+  const visible = filtered.slice(0, maxVisible);
+  const hiddenCount = filtered.length - visible.length;
+
+  const commit = (value: string) => {
+    if (multiple) {
+      onChange(
+        selected.includes(value) ? selected.filter((x) => x !== value) : [...selected, value],
+      );
+      // Keep the field focused so the user can keep picking / typing; the list stays open.
+      inputRef.current?.focus();
+    } else {
+      // Single-select is final: close and DON'T re-focus — a refocus fires onFocus, which would
+      // immediately re-open the list (now that the merged ref makes focus() actually work).
+      onChange([value]);
+      setOpenAnd(false);
+    }
+  };
+
+  return (
+    <div>
+      {/* The field: removable chips + a free-text input + a chevron, styled as one input box. The whole
+          box is the POSITION anchor (the panel matches its width); the input is the combobox reference. */}
+      <div
+        ref={pop.refs.setPositionReference}
+        onMouseDown={(e) => {
+          // A press anywhere but the input (padding / a chip gap) focuses the field and opens the list —
+          // focus drives "open", so a caret click never toggles it shut.
+          if (e.target !== inputRef.current) {
+            e.preventDefault();
+            inputRef.current?.focus();
+            setOpenAnd(true);
+          }
+        }}
+        className="glass-card flex min-h-9 w-full cursor-text flex-wrap items-center gap-1 rounded-lg border border-border px-1.5 py-1 transition focus-within:border-accent focus-within:ring-2 focus-within:ring-accent/30"
+      >
+        {selected.map((v) => (
+          <span key={v} className="chip inline-flex items-center gap-1 px-2 py-0.5 text-sm">
+            <span className="max-w-36 truncate">{labelFor(v)}</span>
+            <button
+              type="button"
+              onMouseDown={(e) => {
+                // Keep the box's focus-the-field handler from firing when removing a chip.
+                e.stopPropagation();
+                e.preventDefault();
+              }}
+              onClick={() => onChange(selected.filter((x) => x !== v))}
+              aria-label={t("common.remove", { defaultValue: "Remove" })}
+              className="hover:opacity-70"
+            >
+              <X className="h-3 w-3" />
+            </button>
+          </span>
+        ))}
+        <input
+          ref={setInputRef}
+          {...pop.getReferenceProps({
+            onChange: (e) => {
+              setQuery((e.target as HTMLInputElement).value);
+              setOpenAnd(true);
+            },
+            onFocus: () => setOpenAnd(true),
+            onKeyDown: (e) => {
+              const idx = highlightIndex ?? activeIndex;
+              if (e.key === "Enter" && open && idx != null && visible[idx]) {
+                e.preventDefault(); // select the highlighted option, don't submit a surrounding form
+                if (!visible[idx].disabled) commit(visible[idx].value);
+              } else if (e.key === "Backspace" && query === "" && selected.length > 0) {
+                // Backspace on an empty field removes the last chip (react-select behaviour).
+                onChange(selected.slice(0, -1));
+              }
+            },
+          })}
+          value={query}
+          aria-label={label}
+          placeholder={
+            selected.length === 0
+              ? (placeholder ?? t("common.search", { defaultValue: "Search" }))
+              : ""
+          }
+          // min-w-8 (not -16): flex line-packing sizes the input at its MIN-width, so a wide 64px floor
+          // made a single chip + the reserved input + the chevron overflow a narrow rail field — wrapping
+          // the chevron to a second line while the (empty) input filled the first. A small floor keeps the
+          // chip + input + chevron on one line; flex-1 still grows the input to fill whatever room is left.
+          className="min-w-8 flex-1 bg-transparent px-1 py-0.5 text-sm outline-hidden placeholder:text-muted/60"
+        />
+        <ChevronDown className="pointer-events-none mr-0.5 h-3.5 w-3.5 shrink-0 text-muted" />
+      </div>
+
+      <PopoverSurface
+        popover={pop}
+        ariaLabel={label}
+        className="glass-menu w-full rounded-xl p-1.5 shadow-lg animate-[popIn_0.16s_ease]"
+      >
+        {/* The scroll box owns the height cap AND the scroll-fade mask (ref+style on the same element). */}
+        <div ref={fade.ref} style={fade.style} className="max-h-64 overflow-y-auto no-scrollbar">
+          {loading && filtered.length === 0 ? (
+            <p className="px-2 py-1.5 text-xs text-muted">
+              {t("plex.loading", { defaultValue: "Loading…" })}
+            </p>
+          ) : filtered.length === 0 ? (
+            <p className="px-2 py-1.5 text-xs text-muted">
+              {emptyText ?? t("common.noResults", { defaultValue: "No matches" })}
+            </p>
+          ) : (
+            <>
+              {visible.map((o) => {
+                const on = selected.includes(o.value);
+                return (
+                  <PopoverItem
+                    key={o.value}
+                    role="option"
+                    selected={on}
+                    disabled={o.disabled}
+                    onSelect={() => commit(o.value)}
+                    label={o.label ?? o.value}
+                    className={`flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm transition ${
+                      on ? "text-fg" : "text-muted"
+                    }`}
+                  >
+                    {renderOption ? (
+                      renderOption(o, on)
+                    ) : (
+                      <>
+                        <span
+                          className={`flex h-3.5 w-3.5 shrink-0 items-center justify-center rounded border ${
+                            on ? "border-accent bg-accent text-accent-fg" : "border-border"
+                          }`}
+                        >
+                          {on && <Check className="h-2.5 w-2.5" />}
+                        </span>
+                        <span className="flex-1 truncate">{o.label ?? o.value}</span>
+                        {o.count != null && (
+                          <span className="shrink-0 text-2xs tabular-nums text-muted">
+                            {o.count}
+                          </span>
+                        )}
+                      </>
+                    )}
+                  </PopoverItem>
+                );
+              })}
+              {hiddenCount > 0 && (
+                <p className="px-2 py-1.5 text-2xs text-muted">
+                  {t("plex.filter.moreRefine", {
+                    count: hiddenCount,
+                    defaultValue: "{{count}} more — refine with search",
+                  })}
+                </p>
+              )}
+            </>
+          )}
+        </div>
+        {/* Any/all match segment (like SortControl's direction footer) — only meaningful, so only shown,
+            once 2+ values are picked. mousedown-preventDefault keeps the input focused so the list stays
+            open in the combobox's focus model. */}
+        {matchMode != null && onMatchModeChange && selected.length >= 2 && (
+          <div className="mt-1 flex items-center gap-2 border-t border-border px-1 pt-2">
+            <span className="text-2xs text-muted">{t("sidebar.match")}</span>
+            <div className="ml-auto flex gap-1">
+              {(["or", "and"] as const).map((m) => (
+                <button
+                  key={m}
+                  type="button"
+                  aria-pressed={matchMode === m}
+                  onMouseDown={(e) => e.preventDefault()}
+                  onClick={() => onMatchModeChange(m)}
+                  className={`rounded-md border px-2 py-0.5 text-2xs transition ${
+                    matchMode === m
+                      ? "border-accent bg-accent/15 text-accent"
+                      : "border-border text-muted hover:border-accent/50 hover:text-fg"
+                  }`}
+                >
+                  {t(m === "or" ? "sidebar.any" : "sidebar.all")}
+                </button>
+              ))}
+            </div>
+          </div>
+        )}
+      </PopoverSurface>
+    </div>
+  );
+}

frontend/src/components/DateFilterSelect.tsx

@@ -0,0 +1,191 @@
+import { useLayoutEffect, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { CalendarDays, Check, ChevronDown } from "lucide-react";
+import { PopoverItem, PopoverSurface, useAnchoredPopover } from "./AnchoredPopover";
+import { type FeedFilters } from "../lib/api";
+import { deriveDateKey, selectDateChip, type DatePreset } from "../lib/dateFilter";
+
+// The feed rail's "Upload date" control: a single-select dropdown (the SortControl/FilterSelect pill,
+// but full-width for the rail) over "Any time" + the day presets + a "Custom range". Picking Custom
+// reveals the from/to fields in the popover footer (reveal-on-select) and the trigger then reads the
+// chosen range; the presets and Any time close on pick. Selection logic is the pure lib/dateFilter so
+// it stays testable without mounting this. The popover hosts free-text (date) inputs, so it opens as a
+// `hostsInput` menu and the inputs stop non-Escape keys from reaching the list navigation.
+
+// yyyy-mm-dd -> a local Date at midnight (split so it isn't parsed as UTC, which would shift a day).
+function parseDay(s: string): Date | null {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+  if (!m) return null;
+  return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+}
+
+export default function DateFilterSelect({
+  filters,
+  setFilters,
+  presets,
+}: {
+  filters: FeedFilters;
+  setFilters: (f: FeedFilters) => void;
+  presets: readonly DatePreset[];
+}) {
+  const { t, i18n } = useTranslation();
+  const [open, setOpen] = useState(false);
+  const [customOpen, setCustomOpen] = useState<boolean>(!!(filters.dateFrom || filters.dateTo));
+
+  // If the range is cleared elsewhere (chip-row Clear all / removing the date chip) while this popover
+  // is closed, drop the custom reveal so the trigger reverts to "Any time" instead of lingering on
+  // "Custom range" with empty fields. Guarded on !open so it never closes a freshly-picked Custom the
+  // user hasn't filled in yet — that stays open until they close it (handled by onOpenChange below).
+  // useLayoutEffect (not useEffect) so the reset commits BEFORE paint — otherwise the trigger flashes
+  // one stale "Custom range" frame between the external clear and this reset.
+  useLayoutEffect(() => {
+    if (!open && customOpen && !filters.dateFrom && !filters.dateTo) setCustomOpen(false);
+  }, [open, customOpen, filters.dateFrom, filters.dateTo]);
+
+  const key = deriveDateKey(filters, customOpen, presets);
+
+  const fmt = (s: string) => {
+    const d = parseDay(s);
+    return d
+      ? new Intl.DateTimeFormat(i18n.language, { month: "short", day: "numeric" }).format(d)
+      : s;
+  };
+  const rangeSummary = () => {
+    const { dateFrom: f, dateTo: to } = filters;
+    if (f && to) return `${fmt(f)} – ${fmt(to)}`;
+    if (f) return t("sidebar.date.fromShort", { date: fmt(f) });
+    if (to) return t("sidebar.date.untilShort", { date: fmt(to) });
+    return t("sidebar.date.customRange");
+  };
+  const summary =
+    key === ""
+      ? t("sidebar.date.anyTime")
+      : key === "custom"
+        ? rangeSummary()
+        : t("sidebar.datePreset." + presets.find((p) => String(p.days) === key)!.key);
+
+  const options = [
+    { value: "any", label: t("sidebar.date.anyTime") },
+    ...presets.map((p) => ({ value: String(p.days), label: t("sidebar.datePreset." + p.key) })),
+    { value: "custom", label: t("sidebar.date.customRange") },
+  ];
+
+  const pop = useAnchoredPopover({
+    open,
+    onOpenChange: (next) => {
+      setOpen(next);
+      // Opened Custom but committed no range → drop the reveal on close so it doesn't stick.
+      if (!next && customOpen && !filters.dateFrom && !filters.dateTo) setCustomOpen(false);
+    },
+    mode: "menu",
+    placement: "bottom-start",
+    hostsInput: true,
+  });
+
+  const pick = (value: string) => {
+    const change = selectDateChip(value, filters);
+    setCustomOpen(change.customOpen);
+    setFilters(change.filters);
+    if (value !== "custom") setOpen(false); // Custom stays open to reveal the range fields
+  };
+
+  const dateInputCls =
+    "bg-surface border border-border rounded-md px-2 py-1 text-xs focus:outline-hidden focus:ring-2 focus:ring-accent/40";
+
+  return (
+    <>
+      <button
+        type="button"
+        ref={pop.refs.setReference}
+        {...pop.getReferenceProps()}
+        aria-label={`${t("sidebar.datePresetLabel")}: ${summary}`}
+        className={`glass-card glass-hover flex w-full items-center gap-1.5 rounded-lg border px-2.5 py-1.5 text-sm transition ${
+          open ? "border-accent" : "border-border"
+        }`}
+      >
+        <CalendarDays className="h-3.5 w-3.5 shrink-0 text-muted" aria-hidden="true" />
+        <span className="flex-1 truncate text-left text-fg">{summary}</span>
+        <ChevronDown className="h-3.5 w-3.5 shrink-0 text-muted" aria-hidden="true" />
+      </button>
+
+      <PopoverSurface
+        popover={pop}
+        ariaLabel={t("sidebar.datePresetLabel")}
+        className="glass-menu min-w-52 rounded-xl p-1.5 shadow-lg animate-[popIn_0.16s_ease]"
+      >
+        <div role="group" aria-label={t("sidebar.datePresetLabel")}>
+          {options.map((o) => {
+            const on = o.value === key || (o.value === "any" && key === "");
+            return (
+              <PopoverItem
+                key={o.value}
+                role="menuitemradio"
+                checked={on}
+                onSelect={() => pick(o.value)}
+                label={o.label}
+                className={`flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm transition ${
+                  on ? "text-fg" : "text-muted"
+                }`}
+              >
+                <Check className={`h-3.5 w-3.5 shrink-0 ${on ? "text-accent" : "opacity-0"}`} />
+                <span className="flex-1 truncate">{o.label}</span>
+              </PopoverItem>
+            );
+          })}
+        </div>
+
+        {/* Reveal-on-select: the from/to fields appear once Custom is the chosen option. The inputs
+            stop non-Escape keys so the date-segment arrows act on the field, not the menu's list nav. */}
+        {key === "custom" && (
+          <div className="mt-1 flex flex-col gap-1.5 border-t border-border px-1 pt-2">
+            <label className="flex items-center justify-between gap-2 text-xs">
+              <span className="text-muted">{t("sidebar.from")}</span>
+              <input
+                type="date"
+                value={filters.dateFrom ?? ""}
+                onKeyDown={(e) => {
+                  if (e.key !== "Escape") e.stopPropagation();
+                }}
+                onChange={(e) =>
+                  setFilters({
+                    ...filters,
+                    dateFrom: e.target.value || undefined,
+                    maxAgeDays: undefined,
+                  })
+                }
+                className={dateInputCls}
+              />
+            </label>
+            <label className="flex items-center justify-between gap-2 text-xs">
+              <span className="text-muted">{t("sidebar.to")}</span>
+              <input
+                type="date"
+                value={filters.dateTo ?? ""}
+                onKeyDown={(e) => {
+                  if (e.key !== "Escape") e.stopPropagation();
+                }}
+                onChange={(e) =>
+                  setFilters({
+                    ...filters,
+                    dateTo: e.target.value || undefined,
+                    maxAgeDays: undefined,
+                  })
+                }
+                className={dateInputCls}
+              />
+            </label>
+            {(filters.dateFrom || filters.dateTo) && (
+              <button
+                type="button"
+                onClick={() => setFilters({ ...filters, dateFrom: undefined, dateTo: undefined })}
+                className="text-2xs text-muted hover:text-accent self-end"
+              >
+                {t("sidebar.clearDates")}
+              </button>
+            )}
+          </div>
+        )}
+      </PopoverSurface>
+    </>
+  );
+}

frontend/src/components/DownloadCenter.tsx

@@ -1,14 +1,11 @@
-import { lazy, Suspense, useEffect, useMemo, useState } from "react";
+import { lazy, Suspense, useEffect, useState } from "react";
 import { qk } from "../lib/queryKeys";
 import { useTranslation } from "react-i18next";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   Ban,
-  CalendarClock,
   ClipboardPaste,
-  Copy,
   Download,
-  Link2,
   Pause,
   Play,
   Plus,
@@ -19,11 +16,9 @@ import {
   Pencil,
   Trash2,
 } from "lucide-react";
-import clsx from "clsx";
 import Tabs from "./Tabs";
 import { PageToolbar } from "./PageShell";
 import { LoadingState, StateMessage } from "./QueryState";
-import Modal from "./Modal";
 // Lazy: these dialogs/editors open on demand, so they stay out of the Downloads page chunk until
 // used (the video editor in particular is heavy — filmstrip + scrubber).
 const DownloadDialog = lazy(() => import("./DownloadDialog"));
@@ -35,729 +30,10 @@ import { useLiveQuery } from "../lib/useLiveQuery";
 import { useMe } from "../lib/useMe";
 import { api, type DownloadJob } from "../lib/api";
 import { invalidateDownloads } from "../lib/downloads";
-import { notify } from "../lib/notifications";
-import { copyText } from "../lib/clipboard";
-import { formatBytes, formatDuration, formatEta, formatSpeed, relativeTime } from "../lib/format";
 import { inputCls } from "./ui/form";
-
-const GiB = 1024 ** 3;
-
-const STATUS_CLS: Record<string, string> = {
-  queued: "text-muted",
-  running: "text-accent",
-  paused: "text-warn",
-  done: "text-success",
-  error: "text-danger",
-  canceled: "text-muted",
-};
-
-// Byte-progress phases (show a % bar) vs ffmpeg post-steps (no %, indeterminate pulse).
-// "editing" (the phase-2 editor) reports a real % from ffmpeg's out_time, so it gets a bar.
-const DOWNLOAD_PHASES = ["video", "audio", "editing"];
-const PHASE_KEYS = [
-  "video",
-  "audio",
-  "editing",
-  "merging",
-  "audio_extract",
-  "thumbnail",
-  "sponsorblock",
-  "metadata",
-  "processing",
-];
-
-function StatusPill({ job }: { job: DownloadJob }) {
-  const { t } = useTranslation();
-  // While downloading, show the concrete phase (video / audio / merging) so the user isn't
-  // confused by the bar resetting between the separate video and audio streams.
-  if (job.status === "running" && job.phase && PHASE_KEYS.includes(job.phase)) {
-    return (
-      <span className="text-xs font-medium text-accent">{t(`downloads.phase.${job.phase}`)}</span>
-    );
-  }
-  const key = job.expired ? "expired" : job.status;
-  return (
-    <span className={clsx("text-xs font-medium", STATUS_CLS[job.status] ?? "text-muted")}>
-      {t(`downloads.status.${key}`)}
-    </span>
-  );
-}
-
-function Thumb({ job }: { job: DownloadJob }) {
-  // Prefer OUR self-hosted poster: it's always present on disk, never expires, and is same-origin, so
-  // a source-CDN signature expiry (Facebook's fbcdn URLs expire within days) or an ad-blocker/Shields
-  // rule on the source domain can't break it. The source's remote thumbnail_url is only a fallback for
-  // the rare poster-less asset (a thumbnail-less source whose ffmpeg frame-cut also failed).
-  const remote = job.asset?.thumbnail_url ?? null;
-  const primary = job.poster_url || remote;
-  // On load failure (a genuinely missing poster file) fall back to the remote source thumbnail.
-  const [src, setSrc] = useState(primary);
-  useEffect(() => setSrc(primary), [primary]);
-  return (
-    <div className="w-28 aspect-video shrink-0 rounded-lg overflow-hidden bg-surface border border-border">
-      {src ? (
-        <img
-          src={src}
-          alt=""
-          loading="lazy"
-          className="w-full h-full object-cover"
-          onError={() => {
-            if (remote && src !== remote) setSrc(remote);
-          }}
-        />
-      ) : null}
-    </div>
-  );
-}
-
-function jobTitle(job: DownloadJob): string {
-  return job.display_name || job.asset?.title || job.source_ref;
-}
-
-// The channel to show under the title: a user override wins over the auto-extracted asset value.
-// `url` is null for sources without a channel link (e.g. reddit) — then it renders as plain text.
-function jobChannel(job: DownloadJob): { name: string; url: string | null } {
-  return {
-    name: job.display_uploader || job.asset?.uploader || job.source_ref,
-    url: job.display_uploader_url || job.asset?.uploader_url || null,
-  };
-}
-
-function IconBtn({
-  onClick,
-  title,
-  danger,
-  children,
-}: {
-  onClick: () => void;
-  title: string;
-  danger?: boolean;
-  children: React.ReactNode;
-}) {
-  return (
-    <button
-      onClick={onClick}
-      title={title}
-      className={clsx(
-        "p-1.5 rounded-md hover:bg-surface text-muted transition",
-        danger ? "hover:text-danger" : "hover:text-fg",
-      )}
-    >
-      {children}
-    </button>
-  );
-}
-
-// Compact display of a URL: drop the protocol + trailing slash so "youtube.com/watch?v=…" fits.
-function displayUrl(url: string): string {
-  try {
-    const u = new URL(url);
-    return (u.host + u.pathname + u.search).replace(/\/$/, "");
-  } catch {
-    return url;
-  }
-}
-
-// "Downloaded from" reference: opens the original page in a new tab, or copies the link.
-function SourceRef({ url }: { url: string }) {
-  const { t } = useTranslation();
-  const copy = async () => {
-    if (await copyText(url)) {
-      notify({ level: "success", message: t("downloads.source.copied") });
-    } else {
-      notify({ level: "error", message: t("downloads.source.copyFailed") });
-    }
-  };
-  return (
-    <div className="flex items-center gap-1 mt-1 text-xs text-muted min-w-0">
-      <Link2 className="w-3 h-3 shrink-0" />
-      <a
-        href={url}
-        target="_blank"
-        rel="noopener noreferrer"
-        title={`${t("downloads.source.open")} — ${url}`}
-        className="truncate hover:text-accent hover:underline"
-      >
-        {displayUrl(url)}
-      </a>
-      <button
-        onClick={copy}
-        aria-label={t("downloads.source.copy")}
-        title={t("downloads.source.copy")}
-        className="shrink-0 p-0.5 rounded-sm hover:bg-surface hover:text-fg transition"
-      >
-        <Copy className="w-3 h-3" />
-      </button>
-    </div>
-  );
-}
-
-// Channel under the title — a clickable link when a channel URL is known, plain text otherwise.
-function ChannelLine({ job }: { job: DownloadJob }) {
-  const { name, url } = jobChannel(job);
-  if (url) {
-    return (
-      <div className="text-xs mt-0.5 truncate">
-        <a
-          href={url}
-          target="_blank"
-          rel="noopener noreferrer"
-          title={url}
-          className="text-muted hover:text-accent hover:underline"
-        >
-          {name}
-        </a>
-      </div>
-    );
-  }
-  return <div className="text-xs text-muted truncate mt-0.5">{name}</div>;
-}
-
-function DownloadRow({
-  job,
-  onShowError,
-  children,
-}: {
-  job: DownloadJob;
-  onShowError?: (job: DownloadJob) => void;
-  children?: React.ReactNode;
-}) {
-  const { t } = useTranslation();
-  const running = job.status === "running";
-  return (
-    <div className="flex gap-3 p-2.5 rounded-xl glass-card glass-hover transition">
-      <Thumb job={job} />
-      <div className="min-w-0 flex-1">
-        <div className="font-medium leading-snug line-clamp-1 flex items-center gap-1.5">
-          {job.job_kind === "edit" && (
-            <span className="inline-flex items-center gap-1 shrink-0 px-1.5 py-0.5 rounded-sm text-3xs font-semibold uppercase tracking-wide bg-accent/15 text-accent">
-              <Scissors className="w-3 h-3" /> {t("downloads.clipBadge")}
-            </span>
-          )}
-          <span className="truncate">{jobTitle(job)}</span>
-        </div>
-        <ChannelLine job={job} />
-        <div className="flex items-center gap-2 mt-1 text-xs">
-          <StatusPill job={job} />
-          {job.asset?.size_bytes ? (
-            <span className="text-muted">· {formatBytes(job.asset.size_bytes)}</span>
-          ) : null}
-          {job.asset?.duration_s ? (
-            <span className="text-muted">· {formatDuration(job.asset.duration_s)}</span>
-          ) : null}
-          {job.status === "done" && job.created_at ? (
-            <span
-              className="text-muted inline-flex items-center gap-1"
-              title={new Date(job.created_at).toLocaleString()}
-            >
-              · <CalendarClock className="w-3 h-3" /> {relativeTime(job.created_at)}
-            </span>
-          ) : null}
-          {job.status === "error" ? (
-            <button
-              onClick={() => onShowError?.(job)}
-              className="text-danger hover:opacity-80 inline-flex items-center gap-1 truncate"
-              title={t("downloads.errors.fail.title")}
-            >
-              · {t(`downloads.errors.fail.cat.${job.error_code || "unknown"}.short`)}
-              <span className="text-muted underline">{t("downloads.errors.fail.detailsLink")}</span>
-            </button>
-          ) : null}
-        </div>
-        {job.source_url && <SourceRef url={job.source_url} />}
-        {job.extra_links?.map((url) => (
-          <SourceRef key={url} url={url} />
-        ))}
-        {running && (
-          <div className="mt-1.5">
-            {job.phase && !DOWNLOAD_PHASES.includes(job.phase) ? (
-              // ffmpeg post-steps aren't byte-progress — show an indeterminate pulse, no %.
-              <div className="h-1.5 rounded-full bg-surface overflow-hidden">
-                <div className="h-full w-full bg-accent/60 animate-pulse" />
-              </div>
-            ) : (
-              <>
-                <div className="h-1.5 rounded-full bg-surface overflow-hidden">
-                  <div
-                    className="h-full bg-accent transition-all"
-                    style={{ width: `${job.progress}%` }}
-                  />
-                </div>
-                <div className="text-2xs text-muted mt-0.5 flex gap-2">
-                  <span>{job.progress}%</span>
-                  {job.speed_bps ? <span>{formatSpeed(job.speed_bps)}</span> : null}
-                  {job.eta_s ? <span>{formatEta(job.eta_s)}</span> : null}
-                </div>
-              </>
-            )}
-          </div>
-        )}
-      </div>
-      <div className="flex items-start gap-0.5 shrink-0">{children}</div>
-    </div>
-  );
-}
-
-// --- Rename + Share small modals ------------------------------------------------------------
-
-// Edit a download's display metadata: title, channel (name + link), and extra reference links.
-// All are display-only overrides — the on-disk file is never renamed.
-function MetaEditModal({ job, onClose }: { job: DownloadJob; onClose: () => void }) {
-  const { t } = useTranslation();
-  const qc = useQueryClient();
-  const [name, setName] = useState(job.display_name || job.asset?.title || "");
-  const [channel, setChannel] = useState(job.display_uploader || job.asset?.uploader || "");
-  const [channelUrl, setChannelUrl] = useState(
-    job.display_uploader_url || job.asset?.uploader_url || "",
-  );
-  // Editable extra-link rows; keep one blank row so there's always somewhere to type.
-  const [links, setLinks] = useState<string[]>(() => [...(job.extra_links ?? []), ""]);
-
-  const setLink = (i: number, v: string) => setLinks((ls) => ls.map((l, j) => (j === i ? v : l)));
-  const addLink = () => setLinks((ls) => [...ls, ""]);
-  const removeLink = (i: number) => setLinks((ls) => ls.filter((_, j) => j !== i));
-
-  const save = useMutation({
-    mutationFn: () =>
-      api.updateDownloadMeta(job.id, {
-        display_name: name.trim(),
-        display_uploader: channel.trim(),
-        display_uploader_url: channelUrl.trim(),
-        extra_links: links.map((l) => l.trim()).filter(Boolean),
-      }),
-    onSuccess: () => {
-      qc.invalidateQueries({ queryKey: qk.downloads() });
-      onClose();
-    },
-  });
-
-  return (
-    <Modal title={t("downloads.edit.title")} onClose={onClose}>
-      <div className="space-y-3">
-        <label className="block">
-          <span className="block text-sm font-medium mb-1">{t("downloads.edit.name")}</span>
-          <input
-            value={name}
-            onChange={(e) => setName(e.target.value)}
-            className={inputCls}
-            autoFocus
-          />
-        </label>
-        <label className="block">
-          <span className="block text-sm font-medium mb-1">{t("downloads.edit.channel")}</span>
-          <input
-            value={channel}
-            onChange={(e) => setChannel(e.target.value)}
-            className={inputCls}
-          />
-        </label>
-        <label className="block">
-          <span className="block text-sm font-medium mb-1">{t("downloads.edit.channelUrl")}</span>
-          <input
-            value={channelUrl}
-            onChange={(e) => setChannelUrl(e.target.value)}
-            placeholder="https://…"
-            className={inputCls}
-          />
-        </label>
-        <div>
-          <span className="block text-sm font-medium mb-1">{t("downloads.edit.extraLinks")}</span>
-          <div className="space-y-2">
-            {links.map((l, i) => (
-              <div key={i} className="flex gap-2">
-                <input
-                  value={l}
-                  onChange={(e) => setLink(i, e.target.value)}
-                  placeholder="https://…"
-                  className={inputCls}
-                />
-                <IconBtn
-                  onClick={() => removeLink(i)}
-                  title={t("downloads.edit.removeLink")}
-                  danger
-                >
-                  <Trash2 className="w-4 h-4" />
-                </IconBtn>
-              </div>
-            ))}
-          </div>
-          <button
-            onClick={addLink}
-            className="mt-2 inline-flex items-center gap-1.5 text-sm text-muted hover:text-fg transition"
-          >
-            <Plus className="w-4 h-4" /> {t("downloads.edit.addLink")}
-          </button>
-        </div>
-        <p className="text-xs text-muted">{t("downloads.edit.hint")}</p>
-        <div className="flex justify-end">
-          <button
-            onClick={() => save.mutate()}
-            disabled={!name.trim() || save.isPending}
-            className="px-3 py-1.5 rounded-lg text-sm font-medium btn-primary disabled:opacity-50 transition"
-          >
-            {t("downloads.edit.save")}
-          </button>
-        </div>
-      </div>
-    </Modal>
-  );
-}
-
-// --- Error detail modal ---------------------------------------------------------------------
-
-// Transient failures worth an in-modal Retry button; the rest are permanent (private/geo/DRM/…),
-// where a retry can't help — the queue row still keeps its own retry control regardless.
-const RETRYABLE_ERRORS = ["postprocess", "network", "unknown"];
-
-// A readable "why did this fail" window for a failed job: a category headline + plain explanation,
-// the raw yt-dlp/ffmpeg text behind a disclosure, and a Retry when the failure may be transient.
-function ErrorModal({
-  job,
-  onRetry,
-  onClose,
-}: {
-  job: DownloadJob;
-  onRetry: () => void;
-  onClose: () => void;
-}) {
-  const { t } = useTranslation();
-  const code = job.error_code || "unknown";
-  const [showRaw, setShowRaw] = useState(false);
-  const retryable = RETRYABLE_ERRORS.includes(code);
-  return (
-    <Modal title={t("downloads.errors.fail.title")} onClose={onClose}>
-      <div className="space-y-3">
-        <div className="font-medium">{t(`downloads.errors.fail.cat.${code}.short`)}</div>
-        <p className="text-sm text-muted">{t(`downloads.errors.fail.cat.${code}.body`)}</p>
-        {job.error && (
-          <div>
-            <button
-              onClick={() => setShowRaw((v) => !v)}
-              className="text-xs text-muted hover:text-fg transition"
-            >
-              {t("downloads.errors.fail.detailsToggle")}
-            </button>
-            {showRaw && (
-              <pre className="mt-1.5 text-xs bg-surface rounded-lg p-2.5 overflow-x-auto whitespace-pre-wrap wrap-break-word max-h-40 text-muted">
-                {job.error}
-              </pre>
-            )}
-          </div>
-        )}
-        <div className="flex justify-end gap-2 pt-1">
-          {retryable && (
-            <button
-              onClick={() => {
-                onRetry();
-                onClose();
-              }}
-              className="px-3 py-1.5 rounded-lg text-sm font-medium btn-primary transition"
-            >
-              {t("downloads.actions.retry")}
-            </button>
-          )}
-          <button
-            onClick={onClose}
-            className="px-3 py-1.5 rounded-lg text-sm text-muted hover:text-fg hover:bg-surface transition"
-          >
-            {t("common.close")}
-          </button>
-        </div>
-      </div>
-    </Modal>
-  );
-}
-
-// --- Usage bar ------------------------------------------------------------------------------
-
-function UsageBar() {
-  const { t } = useTranslation();
-  // Poll live (like the library list) so the footprint updates the moment the worker finishes an
-  // edit/download — enqueue only creates a queued job (0 bytes), the size lands asynchronously, so
-  // a one-shot fetch at enqueue time would show a stale 0 B until a manual reload.
-  const usage = useLiveQuery(qk.downloadUsage(), api.downloadUsage, { intervalMs: 2000 });
-  const u = usage.data;
-  if (!u) return null;
-  const pct =
-    u.unlimited || !u.max_bytes ? 0 : Math.min(100, (u.footprint_bytes / u.max_bytes) * 100);
-  return (
-    <div className="rounded-xl glass-card p-3 mb-4">
-      <div className="flex justify-between text-sm mb-1.5">
-        <span className="font-medium">{t("downloads.usage.title")}</span>
-        <span className="text-muted">
-          {formatBytes(u.footprint_bytes)}
-          {u.unlimited ? "" : ` / ${formatBytes(u.max_bytes)}`} ·{" "}
-          {u.unlimited
-            ? t("downloads.usage.unlimited")
-            : t("downloads.usage.items", { used: u.active_jobs, max: u.max_jobs })}
-        </span>
-      </div>
-      {!u.unlimited && (
-        <div className="h-2 rounded-full bg-surface overflow-hidden">
-          <div
-            className={clsx("h-full transition-all", pct > 90 ? "bg-danger" : "bg-accent")}
-            style={{ width: `${pct}%` }}
-          />
-        </div>
-      )}
-    </div>
-  );
-}
-
-// --- Admin system tab -----------------------------------------------------------------------
-
-function QuotaModal({
-  userId,
-  email,
-  onClose,
-}: {
-  userId: number;
-  email: string;
-  onClose: () => void;
-}) {
-  const { t } = useTranslation();
-  const qc = useQueryClient();
-  const q = useQuery({
-    queryKey: qk.dlQuota(userId),
-    queryFn: () => api.adminGetDownloadQuota(userId),
-  });
-  const [form, setForm] = useState<{
-    gb: number;
-    jobs: number;
-    conc: number;
-    unlimited: boolean;
-  } | null>(null);
-  const cur = q.data;
-  const state =
-    form ??
-    (cur
-      ? {
-          gb: Math.round((cur.max_bytes / GiB) * 10) / 10,
-          jobs: cur.max_jobs,
-          conc: cur.max_concurrent,
-          unlimited: cur.unlimited,
-        }
-      : null);
-  const done = () => {
-    qc.invalidateQueries({ queryKey: qk.dlQuota(userId) });
-    qc.invalidateQueries({ queryKey: qk.adminStorage() });
-    onClose();
-  };
-  const save = useMutation({
-    mutationFn: () =>
-      api.adminSetDownloadQuota(userId, {
-        max_bytes: Math.round(state!.gb * GiB),
-        max_jobs: state!.jobs,
-        max_concurrent: state!.conc,
-        unlimited: state!.unlimited,
-      }),
-    onSuccess: done,
-  });
-  const reset = useMutation({
-    mutationFn: () => api.adminResetDownloadQuota(userId),
-    onSuccess: done,
-  });
-  if (!state) return null;
-  const upd = (p: Partial<typeof state>) => setForm({ ...state, ...p });
-  return (
-    <Modal title={t("downloads.admin.quotaTitle", { email })} onClose={onClose}>
-      <div className="space-y-3">
-        <div className="grid grid-cols-3 gap-3">
-          <label className="text-sm">
-            {t("downloads.admin.maxBytes")}
-            <input
-              type="number"
-              value={state.gb}
-              onChange={(e) => upd({ gb: Number(e.target.value) })}
-              className={inputCls}
-              disabled={state.unlimited}
-            />
-          </label>
-          <label className="text-sm">
-            {t("downloads.admin.maxJobs")}
-            <input
-              type="number"
-              value={state.jobs}
-              onChange={(e) => upd({ jobs: Number(e.target.value) })}
-              className={inputCls}
-            />
-          </label>
-          <label className="text-sm">
-            {t("downloads.admin.maxConcurrent")}
-            <input
-              type="number"
-              value={state.conc}
-              onChange={(e) => upd({ conc: Number(e.target.value) })}
-              className={inputCls}
-            />
-          </label>
-        </div>
-        <label className="flex items-center gap-2 text-sm cursor-pointer">
-          <input
-            type="checkbox"
-            checked={state.unlimited}
-            onChange={(e) => upd({ unlimited: e.target.checked })}
-          />
-          {t("downloads.admin.unlimited")}
-        </label>
-        <div className="flex justify-between pt-1">
-          <button
-            onClick={() => reset.mutate()}
-            className="px-3 py-1.5 rounded-lg text-sm text-muted hover:text-fg hover:bg-surface transition"
-          >
-            {t("downloads.admin.reset")}
-          </button>
-          <button
-            onClick={() => save.mutate()}
-            disabled={save.isPending}
-            className="px-3 py-1.5 rounded-lg text-sm font-medium btn-primary disabled:opacity-50 transition"
-          >
-            {t("downloads.admin.save")}
-          </button>
-        </div>
-      </div>
-    </Modal>
-  );
-}
-
-// Pick ANY user to set a download quota for — even one who hasn't downloaded anything yet (the
-// footprint list below only shows users who already have files).
-function QuotaUserPicker({ onPick }: { onPick: (u: { id: number; email: string }) => void }) {
-  const { t } = useTranslation();
-  const [q, setQ] = useState("");
-  const [open, setOpen] = useState(false);
-  const users = useQuery({ queryKey: qk.adminUsers(), queryFn: api.adminUsers });
-  const list = (users.data ?? []).filter((u) => !u.is_demo);
-  const filtered = useMemo(() => {
-    const s = q.trim().toLowerCase();
-    const base = s
-      ? list.filter(
-          (u) =>
-            u.email.toLowerCase().includes(s) || (u.display_name ?? "").toLowerCase().includes(s),
-        )
-      : list;
-    return base.slice(0, 8);
-  }, [q, list]);
-  return (
-    <div className="relative w-full sm:w-72">
-      <input
-        value={q}
-        onChange={(e) => {
-          setQ(e.target.value);
-          setOpen(true);
-        }}
-        onFocus={() => setOpen(true)}
-        onBlur={() => setTimeout(() => setOpen(false), 150)}
-        placeholder={t("downloads.admin.quotaPickPlaceholder")}
-        className={inputCls}
-      />
-      {open && filtered.length > 0 && (
-        <div className="absolute z-base mt-1 w-full rounded-lg glass-menu overflow-hidden">
-          {filtered.map((u) => (
-            <button
-              key={u.id}
-              onClick={() => {
-                onPick({ id: u.id, email: u.email });
-                setQ("");
-                setOpen(false);
-              }}
-              className="w-full text-left px-3 py-2 text-sm hover:bg-surface transition flex flex-col"
-            >
-              <span className="truncate">{u.display_name || u.email}</span>
-              {u.display_name && <span className="text-xs text-muted truncate">{u.email}</span>}
-            </button>
-          ))}
-        </div>
-      )}
-    </div>
-  );
-}
-
-function AdminSystem() {
-  const { t } = useTranslation();
-  const storage = useLiveQuery(qk.adminStorage(), api.adminDownloadStorage, { intervalMs: 5000 });
-  const jobs = useLiveQuery(qk.adminDownloads(), api.adminDownloads, { intervalMs: 5000 });
-  const [quotaFor, setQuotaFor] = useState<{ id: number; email: string } | null>(null);
-  const s = storage.data;
-  return (
-    <div>
-      {s && (
-        <div className="grid grid-cols-2 sm:grid-cols-4 gap-3 mb-5">
-          {[
-            [t("downloads.admin.readyFiles"), String(s.ready_files)],
-            [t("downloads.admin.totalSize"), formatBytes(s.total_bytes)],
-            [
-              t("downloads.admin.cap"),
-              s.total_cap_bytes ? formatBytes(s.total_cap_bytes) : t("downloads.admin.noCap"),
-            ],
-          ].map(([label, val]) => (
-            <div key={label} className="rounded-xl glass-card p-3">
-              <div className="text-xs text-muted">{label}</div>
-              <div className="text-lg font-semibold mt-0.5">{val}</div>
-            </div>
-          ))}
-        </div>
-      )}
-
-      {s && (
-        <div className="mb-6">
-          <div className="flex items-center justify-between gap-3 mb-2 flex-wrap">
-            <div className="text-sm font-medium">{t("downloads.admin.perUser")}</div>
-            {/* Set a quota for any user, regardless of whether they've downloaded anything. */}
-            <QuotaUserPicker onPick={setQuotaFor} />
-          </div>
-          <div className="space-y-1">
-            {s.per_user.map((u) => (
-              <div
-                key={u.user_id}
-                className="flex items-center gap-2 text-sm px-3 py-1.5 rounded-lg bg-card/40"
-              >
-                <span className="flex-1 truncate">{u.email}</span>
-                <span className="text-muted">{formatBytes(u.footprint_bytes)}</span>
-                <button
-                  onClick={() => setQuotaFor({ id: u.user_id, email: u.email ?? "" })}
-                  className="p-1 rounded-sm hover:bg-surface text-muted hover:text-fg"
-                  title={t("downloads.admin.editQuota")}
-                >
-                  <Settings2 className="w-4 h-4" />
-                </button>
-              </div>
-            ))}
-            {s.per_user.length === 0 && (
-              <div className="text-xs text-muted px-3 py-2">{t("downloads.admin.noFootprint")}</div>
-            )}
-          </div>
-        </div>
-      )}
-
-      <div className="text-sm font-medium mb-2">{t("downloads.tabs.system")}</div>
-      <div className="space-y-1.5">
-        {(jobs.data ?? []).map((j) => (
-          <div
-            key={j.id}
-            className="flex items-center gap-3 text-sm px-3 py-1.5 rounded-lg bg-card/40"
-          >
-            <span className="flex-1 truncate">{jobTitle(j)}</span>
-            <span className="text-muted truncate w-40">{j.user_email}</span>
-            <StatusPill job={j} />
-            <span className="text-muted w-16 text-right">
-              {j.asset?.size_bytes ? formatBytes(j.asset.size_bytes) : ""}
-            </span>
-          </div>
-        ))}
-        {jobs.data && jobs.data.length === 0 && (
-          <div className="text-sm text-muted py-6 text-center">{t("downloads.empty.admin")}</div>
-        )}
-      </div>
-
-      {quotaFor && (
-        <QuotaModal userId={quotaFor.id} email={quotaFor.email} onClose={() => setQuotaFor(null)} />
-      )}
-    </div>
-  );
-}
-
-// --- Main -----------------------------------------------------------------------------------
+import { DownloadRow, IconBtn, UsageBar } from "./downloadRow";
+import { MetaEditModal, ErrorModal } from "./downloadModals";
+import { AdminSystem } from "./downloadAdmin";
 
 export default function DownloadCenter() {
   const me = useMe();
@@ -859,7 +135,7 @@ export default function DownloadCenter() {
     <>
       {/* Page title + subtitle + tabs are fixed chrome; the tab content scrolls under them. */}
       <PageToolbar>
-        <div className="px-4 pt-3 max-w-4xl w-full mx-auto">
+        <div className="px-4 pt-2 max-w-4xl w-full mx-auto">
           <div className="flex items-center justify-between gap-3 mb-1">
             <h1 className="text-xl font-semibold">{t("downloads.page.title")}</h1>
             <button

frontend/src/components/Feed.tsx

@@ -13,6 +13,7 @@ import {
   Grid3x3,
   Info,
   LayoutGrid,
+  Library,
   List,
   RefreshCw,
   Rows3,
@@ -36,11 +37,13 @@ import { type SortOption } from "../lib/columnSort";
 import { FEED_VIEWS, type FeedView } from "../lib/feedView";
 import { clearedFilters, useActiveFilters } from "../lib/useActiveFilters";
 import ActiveFilterChips from "./ActiveFilterChips";
+import SelectedViewChip from "./SelectedViewChip";
 import { LoadingState, StateMessage } from "./QueryState";
 import { PageToolbar } from "./PageShell";
 import { useWizard } from "./WizardProvider";
 import SortControl from "./SortControl";
-import FilterChipGroup, { filterChipClass } from "./FilterChipGroup";
+import FilterSelect from "./FilterSelect";
+import ItemCount from "./ItemCount";
 import ViewSwitcher from "./ViewSwitcher";
 import VirtualFeed from "./VirtualFeed";
 // Lazy: the in-app YouTube player (IFrame API) loads only when a video is first opened.
@@ -567,124 +570,109 @@ export default function Feed({
       : SORT_DEFAULT_DIR[k as Exclude<SortKey, "shuffle" | "relevance">],
   }));
 
+  // Sort + view mode are tightly bound to the grid below, so they live pinned to the right of the
+  // applied-filter row (directly above the cards), not up in the filter toolbar. Extracted here so the
+  // same controls render on both the feed and channel-scoped rows.
+  const sortView = (
+    <>
+      <SortControl
+        options={sortOptions}
+        sort={{ key: sortKey, dir: sortDir }}
+        onChange={(next) => {
+          if (!next) return; // the feed is always sorted — no "no sort" option is offered
+          setFilters({
+            ...filters,
+            sort: buildSort(next.key as SortKey, next.dir),
+            seed: next.key === "shuffle" ? rollSeed() : undefined,
+          });
+        }}
+        label={t("feed.sortLabel")}
+        ascLabel={t("feed.dirAsc")}
+        descLabel={t("feed.dirDesc")}
+        trailing={
+          sortKey === "shuffle" ? (
+            <button
+              onClick={() => setFilters({ ...filters, seed: rollSeed() })}
+              title={t("sidebar.reshuffle")}
+              aria-label={t("sidebar.reshuffle")}
+              className="shrink-0 p-1.5 rounded-lg border border-border bg-card text-fg hover:border-accent hover:text-accent active:translate-y-px transition"
+            >
+              <RefreshCw className="w-4 h-4" />
+            </button>
+          ) : undefined
+        }
+      />
+      <span className="mx-0.5 h-5 w-px bg-border" aria-hidden="true" />
+      <ViewSwitcher
+        value={view}
+        options={FEED_VIEWS.map((id) => ({
+          id,
+          label: t("feed.view." + id),
+          icon: VIEW_ICON[id],
+        }))}
+        onChange={setView}
+        label={t("feed.viewLabel")}
+        // The mode's name only earns its place once the window is wide.
+        labelClassName="hidden xl:inline"
+      />
+    </>
+  );
+
   const toolbar = (
-    <div className="pb-3">
+    <div className="pb-1.5">
       <div className="flex items-center gap-1.5 gap-y-2 flex-wrap">
-        <FilterChipGroup
-          ariaLabel={t("feed.showLabel")}
-          options={SHOW_IDS.map((id) => ({
-            value: id,
-            label: t("sidebar.show." + id),
-            testId: `feed-show-${id}`,
-          }))}
-          value={filters.show}
-          onChange={(show) => setFilters({ ...filters, show })}
+        {/* The item count is the fixed leading element — a fixed-width pill so a changing number
+            never shoves the controls beside it (see ItemCount). */}
+        <ItemCount count={summaryQuery.data?.count} />
+        {/* Watch state is single-select (always exactly one); content types are an independent
+            multi-select. Both compress to one labeled dropdown pill via FilterSelect. */}
+        <FilterSelect
+          label={t("feed.showLabel")}
+          testId="feed-show"
+          options={SHOW_IDS.map((id) => ({ value: id, label: t("sidebar.show." + id) }))}
+          selected={[filters.show]}
+          onChange={(next) => setFilters({ ...filters, show: next[0] as FeedFilters["show"] })}
+        />
+        <FilterSelect
+          label={t("feed.contentLabel")}
+          testId="feed-content"
+          multiple
+          options={CONTENT.map((c) => ({ value: c.key, label: t(c.label) }))}
+          selected={CONTENT.filter((c) => filters[c.key]).map((c) => c.key)}
+          onChange={(next) => {
+            const patch = { ...filters };
+            for (const c of CONTENT) patch[c.key] = next.includes(c.key);
+            setFilters(patch);
+          }}
         />
-        <span className="mx-1 h-5 w-px bg-border" aria-hidden="true" />
-        {/* Content-type toggles are MULTI-select (independent booleans) — same chip look via
-            filterChipClass, but not a single-select group. */}
-        <div className="flex flex-wrap gap-1.5" role="group" aria-label={t("feed.contentLabel")}>
-          {CONTENT.map((c) => {
-            const on = filters[c.key];
-            return (
-              <button
-                key={c.key}
-                data-testid={`feed-content-${c.key}`}
-                onClick={() => setFilters({ ...filters, [c.key]: !on })}
-                aria-pressed={on}
-                className={filterChipClass}
-              >
-                {t(c.label)}
-              </button>
-            );
-          })}
-        </div>
         {/* The Source filter (organic / include-search / search-only) is a global-catalog concept —
             it selects how videos ENTERED the library. On a channel-scoped view we already show all
             of this one channel's videos (librarySource is pinned to "all"), so the selector would
             only offer a near-empty, confusing slice — hide it here. */}
         {!channelScoped && (
-          <>
-            <span className="mx-1 h-5 w-px bg-border" aria-hidden="true" />
-            <label className="inline-flex items-center gap-1.5 text-xs text-muted">
-              <span>{t("feed.source.label")}</span>
-              <select
-                value={filters.librarySource ?? "organic"}
-                onChange={(e) =>
-                  setFilters({
-                    ...filters,
-                    librarySource: e.target.value as FeedFilters["librarySource"],
-                  })
-                }
-                title={t("feed.source.tip")}
-                className="bg-surface border border-border rounded-lg px-2 py-1 text-xs focus:outline-hidden focus:ring-2 focus:ring-accent/40"
-              >
-                <option value="organic">{t("feed.source.organic")}</option>
-                <option value="all">{t("feed.source.all")}</option>
-                <option value="search">{t("feed.source.only")}</option>
-              </select>
-            </label>
-          </>
-        )}
-        <span className="mx-1 h-5 w-px bg-border" aria-hidden="true" />
-        <span data-testid="feed-result-count" className="text-xs text-muted whitespace-nowrap">
-          {summaryQuery.data
-            ? t("feed.videoCount", {
-                count: summaryQuery.data.count,
-                formattedCount: summaryQuery.data.count.toLocaleString(),
-              })
-            : " "}
-        </span>
-        <div className="ml-auto flex items-center gap-2">
-          <span className="text-xs text-muted">{t("feed.sortLabel")}</span>
-          <SortControl
-            options={sortOptions}
-            sort={{ key: sortKey, dir: sortDir }}
-            onChange={(next) => {
-              if (!next) return; // the feed is always sorted — no "no sort" option is offered
+          <FilterSelect
+            label={t("feed.source.label")}
+            testId="feed-source"
+            options={[
+              { value: "organic", label: t("feed.source.organic") },
+              { value: "all", label: t("feed.source.all") },
+              { value: "search", label: t("feed.source.only") },
+            ]}
+            selected={[filters.librarySource ?? "organic"]}
+            onChange={(next) =>
               setFilters({
                 ...filters,
-                sort: buildSort(next.key as SortKey, next.dir),
-                seed: next.key === "shuffle" ? rollSeed() : undefined,
-              });
-            }}
-            label={t("feed.sortLabel")}
-            ascLabel={t("feed.dirAsc")}
-            descLabel={t("feed.dirDesc")}
-            trailing={
-              sortKey === "shuffle" ? (
-                <button
-                  onClick={() => setFilters({ ...filters, seed: rollSeed() })}
-                  title={t("sidebar.reshuffle")}
-                  aria-label={t("sidebar.reshuffle")}
-                  className="shrink-0 p-1.5 rounded-lg border border-border bg-card text-fg hover:border-accent hover:text-accent active:translate-y-px transition"
-                >
-                  <RefreshCw className="w-4 h-4" />
-                </button>
-              ) : undefined
+                librarySource: next[0] as FeedFilters["librarySource"],
+              })
             }
           />
-          <span className="mx-0.5 h-5 w-px bg-border" aria-hidden="true" />
-          <ViewSwitcher
-            value={view}
-            options={FEED_VIEWS.map((id) => ({
-              id,
-              label: t("feed.view." + id),
-              icon: VIEW_ICON[id],
-            }))}
-            onChange={setView}
-            label={t("feed.viewLabel")}
-            // This toolbar is packed — show/content chips, source, count, sort — so the mode's name
-            // only earns its place once the window is wide.
-            labelClassName="hidden xl:inline"
-          />
-        </div>
+        )}
       </div>
     </div>
   );
 
   return (
-    <div className={channelScoped ? "px-4 sm:px-6 pb-4" : "px-4 pb-4 pt-2"}>
+    <div className={channelScoped ? "px-4 sm:px-6 pb-4" : "px-4 pb-4 pt-1"}>
       {/* The toolbar (+ active-filter chips) is FIXED chrome: it portals into a PageToolbarSlot so
           it stays put while the cards scroll (bug 4). On the feed page that slot is the shell's top
           band; on a channel page ChannelPage overrides the slot with its own sticky sub-header, so
@@ -692,19 +680,46 @@ export default function Feed({
           baseline (channel-scoped, whole-catalog, show-all), so each would read as a "filter you
           applied" when it's just the page being itself. */}
       <PageToolbar>
-        <div className={channelScoped ? "px-4 sm:px-6" : "px-4 pt-4 pb-1"}>
+        <div className={channelScoped ? "px-4 sm:px-6" : "px-4 pt-2 pb-1"}>
           {toolbar}
-          {!channelScoped && (
-            <ActiveFilterChips
-              filters={activeFilters}
-              onClearAll={() => setFilters(clearedFilters(filters))}
-            />
-          )}
+          {/* The controls row sits directly above the grid: the applied-filter chips flow from the left
+              (overflowing to a "+N"/count pill so they never crowd the controls), while Sort + View stay
+              pinned to the right. Channel-scoped feeds show no chips (their baseline isn't a "filter you
+              applied"), but still get the right-pinned Sort/View. */}
+          <div className="flex items-center gap-2 pb-2">
+            {!channelScoped && (
+              <>
+                {/* The active personal view (if any) leads the applied-filter row. */}
+                <SelectedViewChip />
+                <ActiveFilterChips
+                  filters={activeFilters}
+                  onClearAll={() => setFilters(clearedFilters(filters))}
+                  className="flex-1"
+                />
+              </>
+            )}
+            <div className="ml-auto flex shrink-0 items-center gap-1.5">{sortView}</div>
+          </div>
         </div>
       </PageToolbar>
       {items.length === 0 ? (
         <div className="py-16 text-center text-muted">
           <p>{t("feed.noMatches")}</p>
+          {/* A channel filter under the "Mine" scope returns nothing when that channel is hidden from
+              your subscriptions (or you don't subscribe to it) — its videos only live in the shared
+              Library. Point there rather than leaving a bare "no matches". */}
+          {filters.channelIds.length > 0 && filters.scope === "my" && (
+            <div className="mt-4">
+              <p className="text-sm">{t("feed.channelScopeHint")}</p>
+              <button
+                onClick={() => setFilters({ ...filters, scope: "all" })}
+                className="mt-3 inline-flex items-center gap-2 px-4 py-2 rounded-xl font-semibold btn-primary transition"
+              >
+                <Library className="w-4 h-4" />
+                {t("feed.viewInLibrary")}
+              </button>
+            </div>
+          )}
           {filters.q.trim() && !isDemo && (
             <button
               onClick={() => onYtSearch(filters.q.trim())}

frontend/src/components/FeedFiltersProvider.dom.test.ts

@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+//
+// loadAccountFilters is the localStorage seed path for the feed filters. It must migrate a persisted
+// legacy global `tagMode` (older builds wrote it) into the per-category `tagModes` — the same coercion
+// the saved-view and URL paths do — so an upgrading user's topic any/all match isn't silently lost.
+import { describe, it, expect, beforeEach } from "vitest";
+import { loadAccountFilters } from "./FeedFiltersProvider";
+import { accountKey, LS } from "../lib/storage";
+
+const ID = 7;
+
+beforeEach(() => localStorage.clear());
+
+describe("loadAccountFilters — legacy tagMode migration on seed", () => {
+  it("migrates a persisted legacy tagMode:'and' from the last-session blob into topic", () => {
+    localStorage.setItem(accountKey(LS.filters, ID)!, JSON.stringify({ q: "hi", tagMode: "and" }));
+    const f = loadAccountFilters(ID);
+    expect(f.tagModes).toEqual({ language: "or", topic: "and", other: "or" });
+    expect(f.q).toBe("hi"); // other fields preserved through the merge
+  });
+
+  it("migrates a legacy tagMode:'and' from the default-view mirror when no last-session blob exists", () => {
+    localStorage.setItem(
+      accountKey(LS.defaultViewFilters, ID)!,
+      JSON.stringify({ tagMode: "and" }),
+    );
+    expect(loadAccountFilters(ID).tagModes.topic).toBe("and");
+  });
+
+  it("leaves tagModes at defaults when nothing is stored", () => {
+    expect(loadAccountFilters(ID).tagModes).toEqual({ language: "or", topic: "or", other: "or" });
+  });
+
+  it("preserves an already-migrated per-category tagModes blob", () => {
+    localStorage.setItem(
+      accountKey(LS.filters, ID)!,
+      JSON.stringify({ tagModes: { language: "and", topic: "or", other: "and" } }),
+    );
+    expect(loadAccountFilters(ID).tagModes).toEqual({
+      language: "and",
+      topic: "or",
+      other: "and",
+    });
+  });
+});

frontend/src/components/FeedFiltersProvider.tsx

@@ -9,9 +9,17 @@ import {
 } from "react";
 import { qk } from "../lib/queryKeys";
 import { useQuery } from "@tanstack/react-query";
-import { api, getActiveAccount, type FeedFilters } from "../lib/api";
-import { hasFilterParams, paramsToFilters } from "../lib/urlState";
-import { accountKey, LS, readJSON, readMerged, writeJSON } from "../lib/storage";
+import {
+  api,
+  getActiveAccount,
+  coerceTagModes,
+  DEFAULT_TAG_MODES,
+  type FeedFilters,
+} from "../lib/api";
+import { filterParamUpdates, hasFilterParams, paramsToFilters } from "../lib/urlState";
+import { useUrlMirror } from "../lib/useUrlMirror";
+import { accountKey, LS, readJSON, writeJSON } from "../lib/storage";
+import { useNavigation } from "./NavigationProvider";
 
 // Owns the GLOBAL feed-filter state (the feed's scope/tags/content/sort/show), lifted out of the App
 // god component so consumers read it via a hook instead of prop-drilling `filters`/`setFilters`
@@ -30,7 +38,7 @@ import { accountKey, LS, readJSON, readMerged, writeJSON } from "../lib/storage"
 
 const DEFAULT_FILTERS: FeedFilters = {
   tags: [],
-  tagMode: "or",
+  tagModes: DEFAULT_TAG_MODES,
   channelIds: [],
   q: "",
   sort: "newest",
@@ -47,7 +55,7 @@ const FILTERS_KEY = LS.filters;
 // default saved view wins over the last-session filters (SavedViewsWidget mirrors it here). When
 // the account isn't known yet (first load, before the tab is pinned), start from defaults; the
 // post-login effect loads the real ones once the id arrives.
-function loadAccountFilters(id: number | null): FeedFilters {
+export function loadAccountFilters(id: number | null): FeedFilters {
   // Your last-applied filters win, so a reload keeps whatever view you're on (a saved view you
   // picked, or manual tweaks) — setFilters persists them under LS.filters on every change. The
   // starred default view only SEEDS a fresh account that has never stored filters: it drives the
@@ -60,10 +68,19 @@ function loadAccountFilters(id: number | null): FeedFilters {
   } catch {
     /* localStorage may be unavailable */
   }
-  if (hasStored && fKey) return readMerged(fKey, DEFAULT_FILTERS);
+  // Migrate a persisted legacy global `tagMode` into the per-category `tagModes` on every seed path,
+  // matching what the saved-view (asFilters) and URL (paramsToFilters) paths already do. coerceTagModes
+  // MUST run on the RAW stored blob, not the object merged over DEFAULT_FILTERS: the merge injects
+  // DEFAULT_TAG_MODES (all "or"), which coerceTagModes prefers over the legacy scalar and would mask it.
+  if (hasStored && fKey) {
+    const raw = readJSON<Partial<FeedFilters>>(fKey, {});
+    return { ...DEFAULT_FILTERS, ...raw, tagModes: coerceTagModes(raw) };
+  }
   const dvKey = accountKey(LS.defaultViewFilters, id);
-  const def = dvKey ? readJSON<FeedFilters | null>(dvKey, null) : null;
-  if (def) return { ...DEFAULT_FILTERS, ...def };
+  const def = dvKey ? readJSON<Partial<FeedFilters> | null>(dvKey, null) : null;
+  if (def) {
+    return { ...DEFAULT_FILTERS, ...def, tagModes: coerceTagModes(def) };
+  }
   return { ...DEFAULT_FILTERS };
 }
 
@@ -90,8 +107,8 @@ export function useFeedFiltersActions(): FeedFiltersActions {
 
 export function FeedFiltersProvider({ children }: { children: ReactNode }) {
   const [filters, setFiltersState] = useState<FeedFilters>(loadInitialFilters);
-  // Whether this load arrived via a "Share view" link (captured once, before the URL is stripped)
-  // — such filters win over the account's stored view and are persisted to the account instead.
+  // Whether this load arrived with feed-filter params in the URL (a bookmark/shared link). Captured
+  // once at mount — such filters win over the account's stored view and are persisted to the account.
   const [initialHadUrlFilters] = useState(() =>
     hasFilterParams(new URLSearchParams(window.location.search)),
   );
@@ -108,6 +125,14 @@ export function FeedFiltersProvider({ children }: { children: ReactNode }) {
     if (key) writeJSON(key, next);
   }, []);
 
+  // Mirror the feed filters into the address bar so every feed view is bookmarkable. Gated on
+  // page===feed: on other pages the filter keys are cleared from the URL (localStorage still holds
+  // them; they re-mirror on return to the feed). The channel detail page keeps its own isolated
+  // filters, so those never reach here. useUrlMirror preserves the nav params (?page/?chan/?v/?pl) the
+  // other providers own.
+  const { page } = useNavigation();
+  useUrlMirror(filterParamUpdates(page === "feed" ? filters : null));
+
   // Load THIS account's own filters when the account first resolves or changes (login / switch /
   // add). Filters are per-account localStorage state, so another account's last view (incl. its
   // default saved view) must never carry over. A share link's filters (captured at mount) win and

frontend/src/components/FeedScopeToggle.tsx

@@ -0,0 +1,39 @@
+import { useTranslation } from "react-i18next";
+import { Library, User } from "lucide-react";
+import SegmentedToggle from "./SegmentedToggle";
+import { useFeedFilters, useFeedFiltersActions } from "./FeedFiltersProvider";
+
+// The feed's Mine/Library scope, relocated from the filter sidebar to sit just right of the header
+// search box — mirroring PlexScopeToggle's placement, so the primary "what am I browsing" control is
+// always in reach instead of buried in the (possibly collapsed) filter rail. Same `filters.scope`
+// field, so behaviour is unchanged. The `pointer-events-auto`/`shrink-0` wrapper matches the other
+// header pills: the header band is `pointer-events-none`, and the pill must not collapse in the flex row.
+export default function FeedScopeToggle() {
+  const { t } = useTranslation();
+  const filters = useFeedFilters();
+  const { setFilters } = useFeedFiltersActions();
+  return (
+    <div className="pointer-events-auto shrink-0">
+      <SegmentedToggle
+        size="md"
+        ariaLabel={t("header.scope.label")}
+        options={[
+          {
+            value: "my",
+            label: t("header.scope.my"),
+            icon: <User className="w-3.5 h-3.5" />,
+            title: t("header.scope.myTip"),
+          },
+          {
+            value: "all",
+            label: t("header.scope.all"),
+            icon: <Library className="w-3.5 h-3.5" />,
+            title: t("header.scope.allTip"),
+          },
+        ]}
+        value={filters.scope}
+        onChange={(scope) => setFilters({ ...filters, scope })}
+      />
+    </div>
+  );
+}

frontend/src/components/FeedViewProvider.tsx

@@ -1,26 +1,15 @@
-import {
-  createContext,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useState,
-  type ReactNode,
-} from "react";
-import { qk } from "../lib/queryKeys";
-import { useQuery } from "@tanstack/react-query";
-import { api } from "../lib/api";
+import { createContext, useContext, useMemo, type ReactNode } from "react";
 import { parseFeedView, type FeedView } from "../lib/feedView";
-import { LS, readAccount, writeAccount } from "../lib/storage";
+import { LS } from "../lib/storage";
+import { usePref } from "../lib/usePref";
 
 // Owns the feed's view mode (the card/row/tile density switcher), lifted out of App so both the feed
 // page and the channel page read it via hooks instead of prop-drilling `view`/`setView` through App.
 // Split State + Actions contexts, mirroring the other providers; composed in main.tsx around <App/>.
 //
-// The view mode is an account PREFERENCE, not a filter: it persists to the server on pick (savePrefs)
-// and is adopted from server prefs on login — so unlike the ephemeral list filters, this provider
-// carries the same server-sync the App god component used to. A localStorage mirror seeds the initial
-// render synchronously; the passive qk.me() observer adopts the server value once the account resolves.
+// The view mode is an account PREFERENCE, not a filter: it persists to the server on pick and is
+// adopted from server prefs on login. usePref carries that server-sync (plus the localStorage mirror
+// that seeds the first render synchronously) so this provider is just the two contexts over it.
 
 interface FeedViewActions {
   setView: (v: FeedView) => void;
@@ -37,30 +26,11 @@ export function useFeedViewActions(): FeedViewActions {
 }
 
 export function FeedViewProvider({ children }: { children: ReactNode }) {
-  const [view, setViewState] = useState<FeedView>(() =>
-    parseFeedView(readAccount(LS.feedView, null)),
-  );
-  // Passive observer of the account App fetches (enabled:false → reads cache, re-renders on update).
-  const { data: me } = useQuery({ queryKey: qk.me(), queryFn: api.me, enabled: false });
-
-  // A user pick persists both to the localStorage mirror (instant reload) and to the server.
-  const setView = useCallback((next: FeedView) => {
-    setViewState(next);
-    writeAccount(LS.feedView, next);
-    api.savePrefs({ view: next }).catch(() => {});
-  }, []);
-
-  // Adopt the server-stored view on login / account switch. Writes the mirror but does NOT savePrefs
-  // (that would echo the just-adopted value straight back). parseFeedView also maps the pre-0.45
-  // "grid" / "list" values forward.
-  useEffect(() => {
-    const prefs = me?.preferences;
-    if (!prefs) return;
-    const adopted = parseFeedView(prefs.view);
-    setViewState(adopted);
-    writeAccount(LS.feedView, adopted);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [me?.id]);
+  // parseFeedView also maps the pre-0.45 "grid"/"list" values forward (idempotent for current values).
+  const [view, setView] = usePref<FeedView>("view", "cards", {
+    localKey: LS.feedView,
+    parse: parseFeedView,
+  });
 
   const actions = useMemo<FeedViewActions>(() => ({ setView }), [setView]);
 

frontend/src/components/FilterRail.tsx

@@ -0,0 +1,76 @@
+import { useState, type ReactNode } from "react";
+import { useTranslation } from "react-i18next";
+import { defaultLayout, type PanelId, type PanelLayout } from "../lib/panelLayout";
+import SidePanel from "./SidePanel";
+import PanelGroups, { type PanelItem } from "./PanelGroups";
+
+// The shared filter-rail shell, extracted from the three rails that all render the same SidePanel
+// chrome around a PanelGroups body: the feed Sidebar, the PlexSidebar, and the PlaylistsRail. It owns
+// the customize (reorder/hide) `editing` state and the fixed title-bar wiring (edit toggle, reset to
+// the layout default, edit hint); each rail supplies only what actually differs — its identity
+// (title/icon), the active-filter count + Clear-all action, its `items`, and any content below the
+// groups (`children`, e.g. the feed's tag manager). `kind` is the PanelId (also the layout key), so
+// `children` defaults to nothing for the rails that need none.
+export default function FilterRail({
+  kind,
+  title,
+  icon,
+  count,
+  actions,
+  collapsed,
+  onToggleCollapse,
+  layout,
+  setLayout,
+  items,
+  collapsible = true,
+  iconExpanded,
+  onTitleClick,
+  titleActionLabel,
+  children,
+}: {
+  kind: PanelId;
+  title: string;
+  icon: ReactNode;
+  count?: number;
+  actions?: ReactNode;
+  collapsed: boolean;
+  onToggleCollapse: () => void;
+  layout: PanelLayout;
+  setLayout: (l: PanelLayout) => void;
+  items: PanelItem[];
+  /** Passed to PanelGroups: false renders plain always-open label + control rows (no collapse). */
+  collapsible?: boolean;
+  iconExpanded?: ReactNode;
+  onTitleClick?: () => void;
+  titleActionLabel?: string;
+  children?: ReactNode;
+}) {
+  const { t } = useTranslation();
+  const [editing, setEditing] = useState(false);
+  return (
+    <SidePanel
+      title={title}
+      icon={icon}
+      count={count}
+      collapsed={collapsed}
+      onToggleCollapse={onToggleCollapse}
+      editing={editing}
+      onToggleEditing={() => setEditing((e) => !e)}
+      onReset={() => setLayout(defaultLayout(kind))}
+      editHint={t("sidebar.editHint")}
+      actions={actions}
+      iconExpanded={iconExpanded}
+      onTitleClick={onTitleClick}
+      titleActionLabel={titleActionLabel}
+    >
+      <PanelGroups
+        items={items}
+        layout={layout}
+        setLayout={setLayout}
+        editing={editing}
+        collapsible={collapsible}
+      />
+      {children}
+    </SidePanel>
+  );
+}

frontend/src/components/FilterSelect.dom.test.tsx

@@ -0,0 +1,92 @@
+// @vitest-environment jsdom
+//
+// Contract of the labeled-pill FilterSelect. Labels are plain props (no i18n). Built on the floating-ui
+// AnchoredPopover platform, so we stub the two observers autoUpdate wires and wrap in a FloatingTree.
+// floating-ui never positions in jsdom → the surface stays visibility:hidden, so the menuitem role
+// queries pass `{ hidden: true }`. Single-select rows are `menuitemradio`, multi-select `menuitemcheckbox`
+// (a menu surface with checkable items, not a listbox of orphaned options).
+import { describe, it, expect, vi, afterEach, beforeAll } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { FloatingTree } from "@floating-ui/react";
+import FilterSelect, { type FilterSelectOption } from "./FilterSelect";
+
+beforeAll(() => {
+  class Stub {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() {
+      return [];
+    }
+  }
+  globalThis.ResizeObserver ??= Stub as unknown as typeof ResizeObserver;
+  globalThis.IntersectionObserver ??= Stub as unknown as typeof IntersectionObserver;
+});
+
+afterEach(cleanup);
+
+const STATUS: FilterSelectOption[] = [
+  { value: "all", label: "All" },
+  { value: "new", label: "New" },
+];
+const TYPES: FilterSelectOption[] = [
+  { value: "n", label: "Normal" },
+  { value: "s", label: "Shorts" },
+];
+const tree = (ui: React.ReactNode) => render(<FloatingTree>{ui}</FloatingTree>);
+
+describe("FilterSelect", () => {
+  it("renders a labeled trigger `Label: value` and keeps options unmounted until opened", () => {
+    tree(<FilterSelect label="Status" options={STATUS} selected={["all"]} onChange={vi.fn()} />);
+    const trigger = screen.getByRole("button", { name: /^Status/ });
+    expect(trigger.textContent).toContain("Status:");
+    expect(trigger.textContent).toContain("All");
+    expect(screen.queryByRole("menuitemradio", { hidden: true })).toBeNull();
+  });
+
+  it("single: picking a row replaces the selection and closes", () => {
+    const onChange = vi.fn();
+    tree(<FilterSelect label="Status" options={STATUS} selected={["all"]} onChange={onChange} />);
+    fireEvent.click(screen.getByRole("button", { name: /^Status/ }));
+    const rows = screen.getAllByRole("menuitemradio", { hidden: true });
+    expect(rows.map((o) => o.textContent)).toEqual(["All", "New"]);
+    expect(rows[0]!.getAttribute("aria-checked")).toBe("true"); // "All" is the current selection
+    fireEvent.click(rows[1]!); // New
+    expect(onChange).toHaveBeenCalledWith(["new"]);
+    expect(screen.queryByRole("menuitemradio", { hidden: true })).toBeNull();
+  });
+
+  it("multiple: toggling a row adds it and keeps the panel open", () => {
+    const onChange = vi.fn();
+    tree(
+      <FilterSelect label="Type" multiple options={TYPES} selected={["n"]} onChange={onChange} />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: /^Type/ }));
+    fireEvent.click(screen.getAllByRole("menuitemcheckbox", { hidden: true })[1]!); // Shorts
+    expect(onChange).toHaveBeenCalledWith(["n", "s"]);
+    expect(screen.queryAllByRole("menuitemcheckbox", { hidden: true }).length).toBeGreaterThan(0); // still open
+  });
+
+  it("multiple + requireOne: the last remaining selection can't be turned off", () => {
+    const onChange = vi.fn();
+    tree(
+      <FilterSelect label="Type" multiple options={TYPES} selected={["n"]} onChange={onChange} />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: /^Type/ }));
+    fireEvent.click(screen.getAllByRole("menuitemcheckbox", { hidden: true })[0]!); // Normal — the only one selected
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it("multiple: the trigger summarises extra picks as `First +N`", () => {
+    tree(
+      <FilterSelect
+        label="Type"
+        multiple
+        options={TYPES}
+        selected={["n", "s"]}
+        onChange={vi.fn()}
+      />,
+    );
+    expect(screen.getByRole("button", { name: /^Type/ }).textContent).toContain("Normal +1");
+  });
+});

frontend/src/components/FilterSelect.tsx

@@ -0,0 +1,142 @@
+import { useState } from "react";
+import { ChevronDown, Check } from "lucide-react";
+import { PopoverItem, PopoverSurface, useAnchoredPopover } from "./AnchoredPopover";
+
+// A compact "labeled pill → dropdown" filter control: the trigger reads `Label: value ▾`, and clicking
+// it opens a menu of options (facet counts optional). It replaces a wall of individual toolbar chips
+// with one pill per filter group, in two flavours:
+//   - single  (default): picking a row replaces the choice and closes — always exactly one active.
+//   - multiple: rows toggle independently and the panel stays open; `requireOne` blocks clearing the last.
+// Built on the same AnchoredPopover platform as ActionMenu/Combobox (arrows/typeahead/Escape/anchor-flip);
+// reusable anywhere a small, known set of options currently renders as a chip group. See FilterSelect.dom.test.
+
+export interface FilterSelectOption {
+  value: string;
+  label: string;
+  /** A facet count shown at the row's end. */
+  count?: number;
+  disabled?: boolean;
+}
+
+export interface FilterSelectProps {
+  /** Visible group name shown as the trigger prefix (`Label: value`) and the accessible name. */
+  label: string;
+  options: readonly FilterSelectOption[];
+  selected: string[];
+  onChange: (next: string[]) => void;
+  /** Toggle a subset (default false = pick exactly one). */
+  multiple?: boolean;
+  /** Multi only: keep at least one selected — the last active row can't be turned off. Default true. */
+  requireOne?: boolean;
+  /** Test hook: the trigger gets `data-testid={testId}`; each option gets `${testId}-${value}`. */
+  testId?: string;
+}
+
+export default function FilterSelect({
+  label,
+  options,
+  selected,
+  onChange,
+  multiple = false,
+  requireOne = true,
+  testId,
+}: FilterSelectProps) {
+  const [open, setOpen] = useState(false);
+  const pop = useAnchoredPopover({
+    open,
+    onOpenChange: setOpen,
+    mode: "menu",
+    placement: "bottom-start",
+  });
+
+  const labelOf = (v: string) => options.find((o) => o.value === v)?.label ?? v;
+  // Summarise the trigger value. Multi lists the first chosen (in options order, so it's stable) + "+N".
+  const chosen = options.filter((o) => selected.includes(o.value));
+  const first = chosen[0];
+  const summary = multiple
+    ? first
+      ? `${first.label}${chosen.length > 1 ? ` +${chosen.length - 1}` : ""}`
+      : "—"
+    : labelOf(selected[0] ?? options[0]?.value ?? "");
+
+  const commit = (value: string) => {
+    if (!multiple) {
+      onChange([value]);
+      setOpen(false);
+      return;
+    }
+    const has = selected.includes(value);
+    if (has) {
+      if (requireOne && selected.length === 1) return; // don't let the last one go
+      onChange(selected.filter((x) => x !== value));
+    } else {
+      onChange([...selected, value]);
+    }
+  };
+
+  return (
+    <>
+      <button
+        type="button"
+        ref={pop.refs.setReference}
+        {...pop.getReferenceProps()}
+        data-testid={testId}
+        // Carry the current value in the accessible name (not just the group label), matching
+        // ViewSwitcher — a screen reader announces "Watch state: Unwatched", not a bare "Watch state".
+        aria-label={`${label}: ${summary}`}
+        className={`glass-card glass-hover inline-flex items-center gap-1.5 rounded-full border px-3 py-1 text-sm transition ${
+          open ? "border-accent" : "border-border"
+        }`}
+      >
+        <span className="text-muted">{label}:</span>
+        <span className="text-fg">{summary}</span>
+        <ChevronDown className="h-3.5 w-3.5 shrink-0 text-muted" aria-hidden="true" />
+      </button>
+
+      <PopoverSurface
+        popover={pop}
+        ariaLabel={label}
+        className="glass-menu min-w-52 rounded-xl p-1.5 shadow-lg animate-[popIn_0.16s_ease]"
+      >
+        {/* Single = one exclusive choice (radios), multi = independent toggles (checkboxes). Both are
+            menuitem-family roles scoped by a group, so AT announces the checked state — the surface is a
+            menu (see the mode above), never a bare listbox with orphaned options. */}
+        <div role="group" aria-label={label}>
+          {options.map((o) => {
+            const on = selected.includes(o.value);
+            return (
+              <PopoverItem
+                key={o.value}
+                role={multiple ? "menuitemcheckbox" : "menuitemradio"}
+                checked={on}
+                disabled={o.disabled}
+                onSelect={() => commit(o.value)}
+                label={o.label}
+                data-testid={testId ? `${testId}-${o.value}` : undefined}
+                className={`flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm transition ${
+                  on ? "text-fg" : "text-muted"
+                }`}
+              >
+                {multiple ? (
+                  <span
+                    className={`flex h-3.5 w-3.5 shrink-0 items-center justify-center rounded border ${
+                      on ? "border-accent bg-accent text-accent-fg" : "border-border"
+                    }`}
+                  >
+                    {on && <Check className="h-2.5 w-2.5" />}
+                  </span>
+                ) : (
+                  <Check className={`h-3.5 w-3.5 shrink-0 ${on ? "text-accent" : "opacity-0"}`} />
+                )}
+                <span className="flex-1 truncate">{o.label}</span>
+                {o.count != null && (
+                  <span className="shrink-0 text-2xs tabular-nums text-muted">{o.count}</span>
+                )}
+              </PopoverItem>
+            );
+          })}
+        </div>
+      </PopoverSurface>
+    </>
+  );
+}

frontend/src/components/Header.tsx

@@ -2,20 +2,19 @@ import { forwardRef, type ReactNode } from "react";
 import { useTranslation } from "react-i18next";
 import { Youtube } from "lucide-react";
 import type { Me } from "../lib/api";
-import { moduleLabelKey, moduleOrder, stepModule } from "../lib/modules";
-import ModuleName from "./ModuleName";
 import SearchBar from "./SearchBar";
 import PlexSearchBox from "./PlexSearchBox";
 import PlexScopeToggle from "./PlexScopeToggle";
+import PlexViewToggle from "./PlexViewToggle";
+import FeedScopeToggle from "./FeedScopeToggle";
 import SyncStatus from "./SyncStatus";
-import { useNavigation, useNavigationActions } from "./NavigationProvider";
+import { useNavigation } from "./NavigationProvider";
 import { useFeedFilters, useFeedFiltersActions } from "./FeedFiltersProvider";
 import { usePlaylists, usePlaylistsActions } from "./PlaylistsProvider";
 import { useChannels, useChannelsActions } from "./ChannelsProvider";
 
-// The floating top header: a row of glass pills over the content — a ModuleName pill (label +
-// accent dot + back/forward arrows), the module's SearchBar where it has one, and the per-user
-// sync chip at the right end.
+// The floating top header: a row of glass pills over the content — the module's SearchBar where it
+// has one, and the per-user sync chip at the right end.
 // `forwardRef` so PageShell can attach a ref to the header's root box and measure its real (possibly
 // wrapped) height — that measurement + the `--hdr-h` content pad it drives live in PageShell, which
 // owns both the header slot and the padded content wrapper (E5 S7).
@@ -30,7 +29,6 @@ const Header = forwardRef<
 >(function Header({ me, onYtSearch }, ref) {
   const { t } = useTranslation();
   const { page } = useNavigation();
-  const { setPage } = useNavigationActions();
   const filters = useFeedFilters();
   const { setFilters } = useFeedFiltersActions();
   // Each module's search term lives in its own provider (shared with that module's rail/content):
@@ -40,12 +38,6 @@ const Header = forwardRef<
   const { setSearch: setPlaylistsSearch } = usePlaylistsActions();
   const { search: channelsSearch } = useChannels();
   const { setSearch: setChannelsSearch, goToFullHistory: onGoToFullHistory } = useChannelsActions();
-  // The ◀/▶ arrows step cyclically through the user's available modules (derived from `me`, so
-  // it stays correct as modules are added/gated). Labels of every active module feed ModuleName's
-  // dynamic width so the pill is sized to the widest reachable title in the current language.
-  const order = moduleOrder(me);
-  const moduleLabels = order.map((p) => t(moduleLabelKey[p]));
-  const multiModule = order.length > 1;
   // Drop input focus on Go/Enter for the live-filter modules (feed's Go escalates to YouTube).
   const blur = () => (document.activeElement as HTMLElement | null)?.blur?.();
 
@@ -99,20 +91,23 @@ const Header = forwardRef<
     // slim and/or no filter sidebar is present — no hard-coded offset.
     <div
       ref={ref}
-      className="pointer-events-none absolute top-3 left-3 right-[10%] z-chrome flex flex-wrap items-center gap-x-3 gap-y-2"
+      // left-4 / right = 1rem + the scrollbar gutter defines the full content column; max-w-[--content-mw]
+      // + mx-auto then centres the header band on the SAME width the page's content uses, so on a max-width
+      // page (Plex/Channels/Playlists) the band lines up with the centred grid, not the whole column. `none`
+      // (feed) = full width. Matches the toolbar band below it. `justify-center` then centres the search-box
+      // group (search + scope toggle / sync chip) within that band, so the box sits centred over the cards
+      // once the column is wider than the box's max-w — not hugged to the left edge.
+      className="pointer-events-none absolute top-3 left-4 right-[calc(1rem+var(--sbw))] mx-auto max-w-[var(--content-mw,none)] z-chrome flex flex-wrap items-center justify-center gap-x-3 gap-y-2"
     >
-      <ModuleName
-        label={t(moduleLabelKey[page])}
-        labels={moduleLabels}
-        onPrev={() => setPage(stepModule(me, page, -1))}
-        onNext={() => setPage(stepModule(me, page, 1))}
-        canPrev={multiModule}
-        canNext={multiModule}
-      />
       {search}
+      {/* Mine/Library scope sits right of the feed search box — relocated here from the filter sidebar
+          so the primary "what am I browsing" control is always in reach (mirrors Plex's scope toggle). */}
+      {page === "feed" && <FeedScopeToggle />}
       {/* Library scope (movie/show/both) sits right of the search box on Plex — relocated here from
-          the filter sidebar (S3) so the primary "what am I browsing" control is always in reach. */}
+          the filter sidebar (S3) so the primary "what am I browsing" control is always in reach. The
+          Discover ⟷ Browse toggle sits right beside it (driven via the PlexViewBridge). */}
       {page === "plex" && me.plex_enabled && <PlexScopeToggle />}
+      {page === "plex" && me.plex_enabled && <PlexViewToggle />}
       {/* Per-user sync status — it used to cost the nav rail a whole block. It sits with the other
           pills rather than pinned to the far right: on a wide window that just strands it. Only on
           the two modules it says anything about: the feed those subscriptions fill, and the manager

frontend/src/components/ItemCount.dom.test.tsx

@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+//
+// Contract of the fixed-width count pill. Uses the REAL i18n instance (not a key-passthrough) so the
+// plural selection (itemCount_one/_other) and the "1M+" overflow interpolation are actually exercised —
+// those are the two branches worth guarding. English is forced so the singular/plural strings are stable.
+import { describe, it, expect, beforeAll, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import "../i18n"; // side-effect: initialise the shared i18next instance
+import i18n from "i18next";
+import ItemCount from "./ItemCount";
+
+beforeAll(async () => {
+  await i18n.changeLanguage("en");
+});
+afterEach(cleanup);
+
+const text = () => screen.getByTestId("item-count").textContent;
+
+describe("ItemCount", () => {
+  it("uses the singular string at 1 and the plural above it", () => {
+    render(<ItemCount count={1} />);
+    expect(text()).toBe("1 item");
+  });
+
+  it("pluralises and thousands-separates a normal count", () => {
+    render(<ItemCount count={192045} />);
+    // Separators come from toLocaleString (runtime-locale dependent) — compare against it, not a fixed
+    // en-US string, so the test asserts ItemCount's formatting path rather than the CI locale.
+    expect(text()).toBe(`${(192045).toLocaleString()} items`);
+  });
+
+  it("collapses a count of a million or more to 1M+, with the exact figure in the tooltip", () => {
+    render(<ItemCount count={1_000_000} />);
+    expect(text()).toBe("1M+ items"); // the "1M+" collapse is locale-independent
+    expect(screen.getByTestId("item-count").getAttribute("title")).toBe(
+      (1_000_000).toLocaleString(),
+    );
+  });
+
+  it("shows the icon-only fixed box (empty label) while the count is undefined", () => {
+    render(<ItemCount />);
+    expect(text()).toBe(""); // the Layers icon carries no text
+    expect(screen.getByTestId("item-count").getAttribute("title")).toBeNull();
+  });
+});

frontend/src/components/ItemCount.tsx

@@ -0,0 +1,35 @@
+import { useTranslation } from "react-i18next";
+import { Layers } from "lucide-react";
+
+// At a million and above we stop printing the exact figure — six digits is the readable ceiling, so
+// the pill shows "1M+" and the tooltip carries the precise number.
+const OVERFLOW_AT = 1_000_000;
+
+// A compact, FIXED-WIDTH count pill for a toolbar: the filtered item count in the same glass pill as
+// the filter dropdowns, minus the chevron and the interactivity. The fixed width is the point — a
+// changing number must never shove the controls beside it, so the box is sized to the widest value
+// ("999,999 items") and the content is centred within it. A count of a million or more collapses to
+// "1M+", with the exact figure in the title tooltip. Deliberately generic ("item(s)", dynamic plural)
+// so any surface can reuse it for whatever it counts.
+export default function ItemCount({ count }: { count?: number }) {
+  const { t } = useTranslation();
+  // `count` is undefined only on a first, un-cached load — keep the fixed box (nothing shifts), just
+  // show the icon until the number arrives.
+  const label =
+    count == null
+      ? ""
+      : t("common.itemCount", {
+          count,
+          formattedCount: count >= OVERFLOW_AT ? "1M+" : count.toLocaleString(),
+        });
+  return (
+    <span
+      data-testid="item-count"
+      title={count?.toLocaleString()}
+      className="glass-card inline-flex shrink-0 items-center justify-center gap-1.5 rounded-full border border-border px-3 py-1 text-sm text-muted min-w-[9rem] whitespace-nowrap"
+    >
+      <Layers className="h-3.5 w-3.5 shrink-0 text-muted" aria-hidden="true" />
+      <span className="tabular-nums">{label}</span>
+    </span>
+  );
+}

frontend/src/components/Messages.tsx

@@ -189,7 +189,7 @@ function ConversationList({
                     onClick={() => openChat(c.partner)}
                     title={t("messages.popOut")}
                     aria-label={t("messages.popOut")}
-                    className="shrink-0 mr-1.5 p-1.5 rounded-lg text-muted opacity-0 group-hover:opacity-100 hover:text-accent hover:bg-bg transition"
+                    className="shrink-0 mr-1.5 p-1.5 rounded-lg text-muted reveal hover:text-accent hover:bg-bg transition"
                   >
                     <ExternalLink className="w-4 h-4" />
                   </button>

frontend/src/components/Modal.dom.test.tsx

@@ -0,0 +1,191 @@
+// @vitest-environment jsdom
+//
+// Modal: focus management (FE-9). This was DEFERRED from the E4 deep-review because it's
+// jsdom-untestable as written — `focusablesIn` filters on `el.offsetParent !== null`, and jsdom
+// returns null for EVERY element (it never lays out), so the trap would see zero focusables and do
+// nothing. We stub `HTMLElement.prototype.offsetParent` to report "visible" (non-null) for any
+// connected node, which is exactly what a real browser reports for the shown dialog controls; the
+// separate no-stub describe below documents the raw-jsdom reality (empty → the guard no-ops).
+//
+// The overlay/history machinery (useBackToClose) is exercised in history.dom.test.ts, so it's mocked
+// out here to isolate the focus-trap behaviour from its module-global history side-effects.
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { render, screen, act, cleanup } from "@testing-library/react";
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  return { ...actual, useTranslation: () => ({ t: (key: string) => key }) };
+});
+// Isolate the focus trap from the Back-to-close history stack (tested in history.dom.test.ts).
+vi.mock("../lib/history", () => ({ useBackToClose: () => {} }));
+
+import Modal from "./Modal";
+
+// Fire a keydown on window (where Modal installs its handler), inside act.
+const press = (key: string, shiftKey = false) =>
+  act(() => {
+    window.dispatchEvent(
+      new KeyboardEvent("keydown", { key, shiftKey, bubbles: true, cancelable: true }),
+    );
+  });
+
+const panelEl = () => document.querySelector<HTMLElement>('[tabindex="-1"]')!;
+const closeBtn = () => screen.getByRole("button", { name: "common.close" });
+
+// A modal with three extra focusable controls; DOM order inside the panel is [close, A, input, B].
+function Body() {
+  return (
+    <>
+      <button>alpha</button>
+      <input aria-label="field" />
+      <button>beta</button>
+    </>
+  );
+}
+
+describe("Modal focus trap (offsetParent stubbed 'visible')", () => {
+  let origDesc: PropertyDescriptor | undefined;
+  beforeEach(() => {
+    origDesc = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "offsetParent");
+    Object.defineProperty(HTMLElement.prototype, "offsetParent", {
+      configurable: true,
+      get(this: HTMLElement) {
+        return this.isConnected ? document.body : null;
+      },
+    });
+  });
+  afterEach(() => {
+    cleanup();
+    if (origDesc) Object.defineProperty(HTMLElement.prototype, "offsetParent", origDesc);
+    else delete (HTMLElement.prototype as unknown as Record<string, unknown>).offsetParent;
+  });
+
+  it("moves initial focus to the first control on open", () => {
+    render(
+      <Modal title="t" onClose={() => {}}>
+        <Body />
+      </Modal>,
+    );
+    expect(document.activeElement).toBe(closeBtn());
+  });
+
+  it("Tab from the last control wraps to the first", () => {
+    render(
+      <Modal title="t" onClose={() => {}}>
+        <Body />
+      </Modal>,
+    );
+    screen.getByText("beta").focus(); // last
+    press("Tab");
+    expect(document.activeElement).toBe(closeBtn());
+  });
+
+  it("Shift+Tab from the first control wraps to the last", () => {
+    render(
+      <Modal title="t" onClose={() => {}}>
+        <Body />
+      </Modal>,
+    );
+    closeBtn().focus(); // first
+    press("Tab", true);
+    expect(document.activeElement).toBe(screen.getByText("beta"));
+  });
+
+  it("Tab pulls focus back inside when it has escaped to the page behind", () => {
+    const outside = document.createElement("button");
+    document.body.appendChild(outside);
+    render(
+      <Modal title="t" onClose={() => {}}>
+        <Body />
+      </Modal>,
+    );
+    outside.focus(); // focus escaped the dialog
+    expect(document.activeElement).toBe(outside);
+    press("Tab");
+    expect(document.activeElement).toBe(closeBtn());
+    document.body.removeChild(outside);
+  });
+
+  it("Shift+Tab from the panel container itself goes to the last control (no leak to the background)", () => {
+    render(
+      <Modal title="t" onClose={() => {}}>
+        <Body />
+      </Modal>,
+    );
+    panelEl().focus(); // active === panel (tabIndex=-1, reached by clicking dead space)
+    press("Tab", true);
+    expect(document.activeElement).toBe(screen.getByText("beta"));
+  });
+
+  it("does not trap a Tab in the middle — only the edges wrap", () => {
+    render(
+      <Modal title="t" onClose={() => {}}>
+        <Body />
+      </Modal>,
+    );
+    const mid = screen.getByLabelText("field");
+    mid.focus();
+    press("Tab"); // interior: native Tab handles it, the trap must not force-move
+    expect(document.activeElement).toBe(mid);
+  });
+
+  it("Escape calls onClose", () => {
+    const onClose = vi.fn();
+    render(
+      <Modal title="t" onClose={onClose}>
+        <Body />
+      </Modal>,
+    );
+    press("Escape");
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it("Escape closes only the topmost modal", () => {
+    const outerClose = vi.fn();
+    const innerClose = vi.fn();
+    render(
+      <Modal title="outer" onClose={outerClose}>
+        <button>outer-body</button>
+      </Modal>,
+    );
+    render(
+      <Modal title="inner" onClose={innerClose}>
+        <button>inner-body</button>
+      </Modal>,
+    );
+    press("Escape");
+    expect(innerClose).toHaveBeenCalledTimes(1);
+    expect(outerClose).not.toHaveBeenCalled();
+  });
+
+  it("restores focus to the trigger on unmount", () => {
+    const trigger = document.createElement("button");
+    document.body.appendChild(trigger);
+    trigger.focus(); // captured as restoreTo during Modal's first render
+    const { unmount } = render(
+      <Modal title="t" onClose={() => {}}>
+        <Body />
+      </Modal>,
+    );
+    expect(document.activeElement).not.toBe(trigger); // focus moved into the dialog
+    unmount();
+    expect(document.activeElement).toBe(trigger);
+    document.body.removeChild(trigger);
+  });
+});
+
+describe("Modal focus trap (raw jsdom — every offsetParent null)", () => {
+  afterEach(cleanup);
+
+  it("with no visible focusables: initial focus falls to the panel and Tab is a safe no-op", () => {
+    render(
+      <Modal title="t" onClose={() => {}}>
+        <Body />
+      </Modal>,
+    );
+    // focusablesIn() returns [] in raw jsdom, so the initializer focuses the panel itself.
+    expect(document.activeElement).toBe(panelEl());
+    expect(() => press("Tab")).not.toThrow();
+    expect(document.activeElement).toBe(panelEl());
+  });
+});

frontend/src/components/Modal.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useRef, type ReactNode } from "react";
+import { useEffect, useId, useRef, useState, type ReactNode } from "react";
 import { createPortal } from "react-dom";
 import { useTranslation } from "react-i18next";
 import { X } from "lucide-react";
@@ -6,6 +6,14 @@ import { useBackToClose } from "../lib/history";
 import { pushLayer, removeLayer, isTopmost } from "../lib/layerStack";
 import { useFullscreenElement } from "../lib/fullscreen";
 
+// Tabbable elements inside the dialog, in DOM order. `:not([tabindex="-1"])` drops programmatically
+// focusable-only nodes; the visibility filter (offsetParent) drops display:none ones (e.g. a
+// collapsed disclosure) so the trap never lands focus on something the user can't see.
+const FOCUSABLE =
+  'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+const focusablesIn = (root: HTMLElement): HTMLElement[] =>
+  [...root.querySelectorAll<HTMLElement>(FOCUSABLE)].filter((el) => el.offsetParent !== null);
+
 // Small centered modal shell: backdrop + ESC + scroll-lock close. Each open modal is a layer in the
 // shared `layerStack` so ESC only closes the topmost one — e.g. an error dialog over the tag editor
 // dismisses just the error and returns to the editor underneath, and a player below defers to it
@@ -27,6 +35,13 @@ export default function Modal({
   // Browser/mouse Back closes the topmost modal instead of navigating away.
   useBackToClose(onClose);
   const fsRoot = useFullscreenElement();
+  const panelRef = useRef<HTMLDivElement>(null);
+  const titleId = useId();
+  // Capture the trigger to restore focus to, during THIS render — i.e. before commit runs the
+  // dialog's autoFocus (or our own initial-focus) and moves activeElement into the dialog. Reading
+  // it later (in the effect) would capture a now-inside element that unmounts on close, stranding
+  // focus on <body>. useState initializer runs exactly once, on first render.
+  const [restoreTo] = useState(() => document.activeElement as HTMLElement | null);
 
   // Backdrop-click close must only fire when the press STARTED on the backdrop too. Otherwise a
   // drag that begins inside the dialog (e.g. selecting text in an input) and is released out on
@@ -39,20 +54,57 @@ export default function Modal({
   useEffect(() => {
     const id = pushLayer();
     const onKey = (e: KeyboardEvent) => {
-      if (e.key === "Escape" && isTopmost(id)) {
+      if (!isTopmost(id)) return;
+      if (e.key === "Escape") {
         e.stopPropagation();
         onCloseRef.current();
+        return;
+      }
+      // Focus trap: keep Tab / Shift+Tab cycling inside the dialog instead of reaching the inert
+      // page behind the backdrop. Only the topmost modal traps (a nested one defers to its child).
+      if (e.key === "Tab") {
+        const panel = panelRef.current;
+        if (!panel) return;
+        const items = focusablesIn(panel);
+        const first = items[0];
+        const last = items[items.length - 1];
+        if (!first || !last) {
+          e.preventDefault();
+          return;
+        }
+        const active = document.activeElement;
+        if (!panel.contains(active) || active === panel) {
+          // Focus escaped the dialog, OR sits on the panel container itself (tabIndex=-1, reached by
+          // clicking dialog dead space) — Node.contains(self) is true, so `active === panel` must be
+          // checked explicitly or Shift+Tab from the panel would leak to the background. Pull it back.
+          e.preventDefault();
+          (e.shiftKey ? last : first).focus();
+        } else if (e.shiftKey && active === first) {
+          e.preventDefault();
+          last.focus();
+        } else if (!e.shiftKey && active === last) {
+          e.preventDefault();
+          first.focus();
+        }
       }
     };
     window.addEventListener("keydown", onKey);
     const prev = document.body.style.overflow;
     document.body.style.overflow = "hidden";
+    // Initial focus: unless an autoFocus child already placed it inside (e.g. a rename input), move
+    // focus to the first control so the dialog opens focused, not stranded on the background.
+    const panel = panelRef.current;
+    if (panel && !panel.contains(document.activeElement)) {
+      (focusablesIn(panel)[0] ?? panel).focus();
+    }
     return () => {
       window.removeEventListener("keydown", onKey);
       removeLayer(id);
       document.body.style.overflow = prev;
+      // Restore focus to the trigger, if it's still in the document and focusable.
+      if (restoreTo && restoreTo.isConnected) restoreTo.focus();
     };
-  }, []);
+  }, [restoreTo]);
 
   return createPortal(
     <div
@@ -65,10 +117,17 @@ export default function Modal({
       }}
       role="dialog"
       aria-modal="true"
+      aria-labelledby={titleId}
     >
-      <div className={`glass relative w-full ${maxWidth} max-h-full overflow-y-auto rounded-2xl`}>
+      <div
+        ref={panelRef}
+        tabIndex={-1}
+        className={`glass relative w-full ${maxWidth} max-h-full overflow-y-auto rounded-2xl outline-none`}
+      >
         <div className="flex items-start justify-between gap-3 p-5 pb-3">
-          <h2 className="text-lg font-semibold leading-snug">{title}</h2>
+          <h2 id={titleId} className="text-lg font-semibold leading-snug">
+            {title}
+          </h2>
           <button
             onClick={onClose}
             title={t("common.close")}

frontend/src/components/ModuleName.tsx

@@ -1,90 +0,0 @@
-import { useLayoutEffect, useRef, useState } from "react";
-import { useTranslation } from "react-i18next";
-import { ChevronLeft, ChevronRight } from "lucide-react";
-
-// The floating module-name pill in the top header. The label area is sized to the WIDEST
-// reachable module title (measured live, in the current language only — so dropping a locale or
-// gaining/losing a module just changes the input, nothing is hard-coded), which keeps the label
-// column a constant width: the name never shifts and the arrows stay put when paging between
-// modules. Carries the back/forward arrows that step cyclically through the active modules, plus
-// the accent dot (the former PageTitle "eyebrow" look, folded in here).
-export default function ModuleName({
-  label,
-  labels,
-  onPrev,
-  onNext,
-  canPrev,
-  canNext,
-}: {
-  label: string;
-  // Every reachable module's title in the current language — drives the fixed label width.
-  labels: string[];
-  onPrev: () => void;
-  onNext: () => void;
-  canPrev: boolean;
-  canNext: boolean;
-}) {
-  const { t } = useTranslation();
-  const labelRef = useRef<HTMLSpanElement>(null);
-  const canvasRef = useRef<HTMLCanvasElement | null>(null);
-  const [labelW, setLabelW] = useState<number>();
-
-  // Measure the widest label using the label span's own rendered font (respects font-scale,
-  // tracking and the uppercase transform). Re-runs whenever the label set changes — i.e. on a
-  // language switch or an account switch that changes which modules are reachable.
-  useLayoutEffect(() => {
-    const el = labelRef.current;
-    if (!el || labels.length === 0) return;
-    const cs = getComputedStyle(el);
-    const canvas = canvasRef.current ?? (canvasRef.current = document.createElement("canvas"));
-    const ctx = canvas.getContext("2d");
-    if (!ctx) return;
-    ctx.font = `${cs.fontWeight} ${cs.fontSize} ${cs.fontFamily}`;
-    const ls = parseFloat(cs.letterSpacing) || 0;
-    const upper = cs.textTransform === "uppercase";
-    let max = 0;
-    for (const s of labels) {
-      const txt = upper ? s.toUpperCase() : s;
-      const w = ctx.measureText(txt).width + ls * txt.length;
-      if (w > max) max = w;
-    }
-    setLabelW(Math.ceil(max) + 2);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [labels.join("
")]);
-
-  const arrow =
-    "p-1 rounded-lg text-muted transition hover:text-fg hover:bg-card disabled:opacity-25 disabled:pointer-events-none";
-  return (
-    <div className="pointer-events-auto shrink-0 max-w-[55vw] h-11 px-2.5 rounded-2xl glass-menu flex items-center gap-1.5">
-      <button
-        onClick={onPrev}
-        disabled={!canPrev}
-        title={t("header.prevModule")}
-        aria-label={t("header.prevModule")}
-        className={arrow}
-      >
-        <ChevronLeft className="w-4 h-4" />
-      </button>
-      <button
-        onClick={onNext}
-        disabled={!canNext}
-        title={t("header.nextModule")}
-        aria-label={t("header.nextModule")}
-        className={arrow}
-      >
-        <ChevronRight className="w-4 h-4" />
-      </button>
-      <span className="w-px h-5 bg-border/70 mx-1 shrink-0" />
-      <span className="min-w-0 inline-flex items-center gap-2 text-xs font-semibold uppercase tracking-[0.16em] text-fg">
-        <span className="w-1.5 h-1.5 rounded-full bg-accent shrink-0" />
-        <span
-          ref={labelRef}
-          className="min-w-0 truncate"
-          style={labelW ? { width: labelW } : undefined}
-        >
-          {label}
-        </span>
-      </span>
-    </div>
-  );
-}

frontend/src/components/NavigationProvider.tsx

@@ -9,11 +9,13 @@ import {
   type ReactNode,
 } from "react";
 import { useTranslation } from "react-i18next";
-import { isPage, readPage, type Page } from "../lib/urlState";
+import { urlWithParams, type Page } from "../lib/urlState";
 import { pageTitleKey } from "../lib/pageMeta";
-import { getAccountRaw, LS, setAccountRaw } from "../lib/storage";
+import { setAccountRaw } from "../lib/storage";
 import { useAccountRehydrate } from "../lib/useAccountRehydrate";
 import { setNavigator } from "../lib/nav";
+import { nextNavId, notifyNav } from "../lib/history";
+import { channelViewFrom, loadInitialPage, PAGE_KEY, type ChannelView } from "./navigationInit";
 
 // Owns the app's navigation + browser-history state, lifted out of the App god component so pages
 // consume it via a hook instead of prop-drilling `page`/`setPage`/`onOpenChannel` through the tree.
@@ -26,13 +28,6 @@ import { setNavigator } from "../lib/nav";
 // re-render on a page/channel switch — preserving the memo that keeps feed appends from re-rendering
 // every existing card.
 
-const PAGE_KEY = LS.page;
-
-export interface ChannelView {
-  id: string;
-  name?: string;
-}
-
 export interface NavigationState {
   page: Page;
   /** The open channel page (null = none). Overlays `page`; rides in history.state._chan. */
@@ -49,13 +44,6 @@ export interface NavigationActions {
   exitYtSearch: () => void;
 }
 
-function loadInitialPage(): Page {
-  const params = new URLSearchParams(window.location.search);
-  if (params.has("page")) return readPage();
-  const stored = getAccountRaw(PAGE_KEY);
-  return isPage(stored) ? stored : "feed";
-}
-
 const StateContext = createContext<NavigationState>({
   page: "feed",
   channelView: null,
@@ -88,11 +76,12 @@ export function NavigationProvider({ children }: { children: ReactNode }) {
     return st?._yt && st?._ytScrape ? (st._yt as string) : null;
   });
   // The open channel page rides in history.state (_chan = id, _chanName = a name to show before the
-  // detail loads), so Back closes it and a reload restores it (unlike ytSearch, which is dropped).
-  const [channelView, setChannelView] = useState<ChannelView | null>(() => {
-    const c = window.history.state?._chan as string | undefined;
-    return c ? { id: c, name: (window.history.state?._chanName as string) ?? undefined } : null;
-  });
+  // detail loads) AND is mirrored to the address bar as ?chan=<id>, so Back closes it, a reload restores
+  // it, and a bookmarked ?chan link opens it (unlike ytSearch, which is dropped). Reload of an in-app
+  // entry reads history.state._chan; a fresh bookmark has only the ?chan param.
+  const [channelView, setChannelView] = useState<ChannelView | null>(() =>
+    channelViewFrom(window.history.state, window.location.search),
+  );
 
   // Refs so the STABLE action callbacks can read the latest state without depending on it — a dep
   // would recreate them on every navigation and re-render every actions consumer (e.g. VideoCard).
@@ -116,8 +105,13 @@ export function NavigationProvider({ children }: { children: ReactNode }) {
     setAccountRaw(PAGE_KEY, stored); // no-op re-write, keeps storage authoritative
     // Correct the CURRENT entry (replace, not push) and PRESERVE any markers already on it — a channel
     // (_chan) or YT search (_yt) opened in the pre-pin window survives on top of the restored page,
-    // rather than being orphaned from history so Back can't close it.
-    window.history.replaceState({ ...(window.history.state || {}), sfPage: stored }, "");
+    // rather than being orphaned from history so Back can't close it. Mirror the corrected page to the
+    // address bar too (urlWithParams keeps any ?chan/filter params already there).
+    window.history.replaceState(
+      { ...(window.history.state || {}), sfPage: stored },
+      "",
+      urlWithParams({ page: stored === "feed" ? null : stored }),
+    );
   });
 
   const setPage = useCallback(
@@ -130,9 +124,16 @@ export function NavigationProvider({ children }: { children: ReactNode }) {
       setPageState(next);
       setAccountRaw(PAGE_KEY, next);
       // Push an in-app history entry so browser/mouse Back steps through pages instead of leaving the
-      // app. The URL stays clean — the page rides in history.state. A fresh { sfPage } (no carried-over
-      // _yt/_chan markers) so each page starts at its root.
-      window.history.pushState({ sfPage: next }, "");
+      // app. A fresh { sfPage } (no carried-over _yt/_chan markers) so each page starts at its root, and
+      // the address bar reflects the page (feed is implicit) while clearing the view-specific params
+      // (chan/v/pl) — a page switch resets to that module's root. Feed filters (owned by
+      // FeedFiltersProvider) are left intact.
+      window.history.pushState(
+        { sfPage: next, sfScroll: nextNavId() },
+        "",
+        urlWithParams({ page: next === "feed" ? null : next, chan: null, v: null, pl: null }),
+      );
+      notifyNav();
     },
     [markDirty],
   );
@@ -143,13 +144,20 @@ export function NavigationProvider({ children }: { children: ReactNode }) {
   const openChannel = useCallback((id: string, name?: string) => {
     setChannelView({ id, name });
     const st = window.history.state || {};
-    if (st._chan) window.history.replaceState({ ...st, _chan: id, _chanName: name ?? null }, "");
-    else window.history.pushState({ ...st, _chan: id, _chanName: name ?? null }, "");
+    const url = urlWithParams({ chan: id });
+    if (st._chan)
+      window.history.replaceState({ ...st, _chan: id, _chanName: name ?? null }, "", url);
+    else window.history.pushState({ ...st, _chan: id, _chanName: name ?? null }, "", url);
   }, []);
 
   const closeChannel = useCallback(() => {
     if (window.history.state?._chan) window.history.back();
-    else setChannelView(null);
+    else {
+      // No owned history entry (e.g. opened straight from a ?chan bookmark): just clear the state and
+      // drop the ?chan param from the address bar.
+      setChannelView(null);
+      window.history.replaceState(window.history.state, "", urlWithParams({ chan: null }));
+    }
   }, []);
 
   const enterYtSearch = useCallback((q: string) => {
@@ -189,19 +197,23 @@ export function NavigationProvider({ children }: { children: ReactNode }) {
     document.title = label ? `${label} · ${brand}` : brand;
   }, [page, channelView, i18n.language, t]);
 
-  // In-app Back/Forward: stamp the initial entry with the current page, then sync state from
-  // history.state on popstate. (stripUrlParams preserves history.state, so this stamp survives a
-  // later query-string strip in App.)
+  // In-app Back/Forward: stamp the initial entry with the current page (mirrored to the address bar),
+  // then sync state from history.state on popstate — the browser restores each entry's URL for us, so
+  // the popstate handler only needs to read history.state.
   useEffect(() => {
     // A reload drops a stale _yt EXCEPT when scrape-sourced (zero quota): then keep _yt + _ytScrape
     // so it restores and re-fetches free (ytSearch above already initialised from it). _chan/_chanName
     // are always kept so a channel page survives F5.
     const st = window.history.state || {};
+    // Mirror the resolved initial page to the address bar (feed implicit) so a page reached from the
+    // stored landing pref — not just from the URL — is itself bookmarkable. urlWithParams preserves any
+    // ?chan / ?v / ?pl / filter params the loaders already read.
+    const url = urlWithParams({ page: page === "feed" ? null : page });
     if (st._yt && st._ytScrape) {
-      window.history.replaceState({ ...st, sfPage: page }, "");
+      window.history.replaceState({ ...st, sfPage: page }, "", url);
     } else {
       const { _yt: _staleYt, _ytScrape: _staleScrape, ...rest } = st;
-      window.history.replaceState({ ...rest, sfPage: page }, "");
+      window.history.replaceState({ ...rest, sfPage: page }, "", url);
     }
     function onPop(e: PopStateEvent) {
       const p = (e.state?.sfPage as Page) ?? "feed";
@@ -210,8 +222,11 @@ export function NavigationProvider({ children }: { children: ReactNode }) {
       // The YouTube-search sub-view and the channel page ride in history.state, so Back/Forward
       // restores or clears them to match the entry we landed on.
       setYtSearch((e.state?._yt as string) ?? null);
-      const chan = e.state?._chan as string | undefined;
-      setChannelView(chan ? { id: chan, name: (e.state?._chanName as string) ?? undefined } : null);
+      // The channel page rides in history.state._chan, with a ?chan URL fallback for a fresh bookmark
+      // entry (URL-only, no _chan) — reading e.state alone would wrongly close the channel when a
+      // popstate lands here (e.g. after an overlay's programmatic history.back()). channelViewFrom
+      // shares this resolution with the seed initializer above.
+      setChannelView(channelViewFrom(e.state, window.location.search));
     }
     window.addEventListener("popstate", onPop);
     return () => window.removeEventListener("popstate", onPop);

frontend/src/components/NotificationsPanel.tsx

@@ -123,7 +123,7 @@ export default function NotificationsPanel() {
     <>
       {/* The inbox header (title + mark-all / clear-all) is fixed chrome; only the list scrolls. */}
       <PageToolbar>
-        <div className="px-4 pt-3 max-w-3xl w-full mx-auto">
+        <div className="px-4 pt-2 max-w-3xl w-full mx-auto">
           <div className="glass rounded-2xl p-4 flex items-center gap-3">
             <Bell className="w-5 h-5 text-accent shrink-0" />
             <div className="flex-1 min-w-0">

frontend/src/components/PageScroller.tsx

@@ -1,10 +1,25 @@
 import { useCallback, useLayoutEffect, useRef, type ReactNode } from "react";
 import { useScrollFade } from "../lib/useScrollFade";
+import { ensureNavId, peekNavId, subscribeNav } from "../lib/history";
 
-// Per-view saved scroll offsets. Module-level so a view's position survives its scroller
-// unmounting — opening a channel page swaps in a different shell/scroller — and is restored when
-// the same view returns. Keyed by the shell's `scrollKey`.
+// Saved scroll offsets, keyed by `${historyEntryId}:${scrollKey}`. The entry id ties an offset to the
+// exact history entry, so Back restores where you left it and a forward navigation (a new entry) opens
+// at the top; the scrollKey ties it to the logical content, so a new feed filter still starts at the
+// top WITHIN the same entry. Module-level so a view's position survives its scroller unmounting
+// (opening a channel page swaps in a different shell/scroller) and is restored when it returns.
 const savedScroll = new Map<string, number>();
+// The key embeds an ever-increasing history-entry id, so without a bound this map would grow one
+// entry per scrolled navigation for the life of the session. Cap it with a small LRU (Map preserves
+// insertion order): re-insert on write to mark most-recently-used, evict the oldest past the cap.
+const SCROLL_MEMORY_CAP = 200;
+function rememberScroll(key: string, top: number): void {
+  savedScroll.delete(key);
+  savedScroll.set(key, top);
+  if (savedScroll.size > SCROLL_MEMORY_CAP) {
+    const oldest = savedScroll.keys().next().value;
+    if (oldest !== undefined) savedScroll.delete(oldest);
+  }
+}
 
 // Put the scroller back to `top`. The feed is virtualized, so on a remount the list needs a frame
 // or two to render enough rows to reach its full height; an immediate `scrollTop` would otherwise
@@ -85,23 +100,50 @@ export default function PageScroller({
     [fadeRef],
   );
 
+  // Live scrollKey for the event/nav-bus callbacks (which are bound once, not per scrollKey).
+  const scrollKeyRef = useRef(scrollKey);
+  scrollKeyRef.current = scrollKey;
+  const lastComposite = useRef<string | null>(null);
+  const cancelRef = useRef<() => void>(() => {});
+
+  // Restore (or reset to top) whenever the (history entry + content) identity changes — a page/sub-view
+  // navigation, a Back/Forward, or a feed filter change. Idempotent: a no-op when the composite is
+  // unchanged, so it's safe to call from several triggers.
+  const resolve = useCallback(() => {
+    const el = elRef.current;
+    if (!el || scrollKeyRef.current == null) return;
+    const key = `${ensureNavId()}:${scrollKeyRef.current}`;
+    if (key === lastComposite.current) return;
+    lastComposite.current = key;
+    cancelRef.current();
+    cancelRef.current = restoreScroll(el, savedScroll.get(key) ?? 0);
+  }, []);
+
+  // Trigger 1: mount + a content-key change (page switch, feed filter) — both re-render this component.
+  useLayoutEffect(() => {
+    resolve();
+  }, [scrollKey, resolve]);
+
+  // Trigger 2: Back/Forward (popstate) and a Plex sub-view open (nav bus) — neither necessarily
+  // re-renders this component. Also records the position continuously (not at unmount): the scroller's
+  // scrollTop is unreliable by the time an unmount cleanup runs, so a save-on-scroll survives teardown.
   useLayoutEffect(() => {
     const el = elRef.current;
-    if (!el || scrollKey == null) return;
-    const key = scrollKey;
-    const want = savedScroll.get(key) ?? 0;
-    const cancelRestore = restoreScroll(el, want);
-    // Record position continuously (not at unmount): the scroller's scrollTop is unreliable by the
-    // time an unmount cleanup runs, and a save-on-scroll survives whatever tears down last.
+    if (!el) return;
     const onScroll = () => {
-      savedScroll.set(key, el.scrollTop);
+      if (scrollKeyRef.current == null) return;
+      rememberScroll(`${peekNavId()}:${scrollKeyRef.current}`, el.scrollTop);
     };
     el.addEventListener("scroll", onScroll, { passive: true });
+    window.addEventListener("popstate", resolve);
+    const unsubNav = subscribeNav(resolve);
     return () => {
-      cancelRestore();
+      cancelRef.current();
       el.removeEventListener("scroll", onScroll);
+      window.removeEventListener("popstate", resolve);
+      unsubNav();
     };
-  }, [scrollKey]);
+  }, [resolve]);
 
   return (
     <main

frontend/src/components/PageShell.dom.test.tsx

@@ -43,11 +43,97 @@ describe("PageShell --hdr-h (E5 S7)", () => {
     Object.defineProperty(hdr, "offsetTop", { value: 12, configurable: true });
     Object.defineProperty(hdr, "offsetHeight", { value: 96, configurable: true });
     roCb?.();
-    expect(content.style.getPropertyValue("--hdr-h")).toBe("116px"); // 12 + 96 + 8
+    expect(content.style.getPropertyValue("--hdr-h")).toBe("112px"); // 12 + 96 + 4
   });
 
   it("adds no `--hdr-h` pad when there is no header", () => {
     const { container } = render(<PageShell>content</PageShell>);
     expect(container.querySelector('[class*="pt-(--hdr-h)"]')).toBeNull();
   });
+
+  it("re-measures when the header is removed then restored (feed→channel→back)", () => {
+    // PageShell is REUSED across feed↔channel navigation (same component position in App.tsx) — it
+    // never remounts, so the header DOM node is swapped under a stable PageShell. The measurement
+    // must re-run on that swap; a one-shot effect kept observing the FIRST node and, when it detached,
+    // rewrote --hdr-h to a stale 4px that stuck on Back. Regression for the channel-Back header overlap.
+    const hdr = () => <div data-testid="hdr">H</div>;
+    const { container, rerender } = render(<PageShell header={hdr()}>content</PageShell>);
+    const measure = (top: number, h: number) => {
+      const el = container.querySelector('[data-testid="hdr"]') as HTMLElement;
+      Object.defineProperty(el, "offsetTop", { value: top, configurable: true });
+      Object.defineProperty(el, "offsetHeight", { value: h, configurable: true });
+      roCb?.();
+    };
+    measure(12, 52);
+    const content = () => container.querySelector('[class*="pt-(--hdr-h)"]') as HTMLElement;
+    expect(content().style.getPropertyValue("--hdr-h")).toBe("68px"); // 12 + 52 + 4
+
+    rerender(<PageShell>content</PageShell>); // → channel page: header gone
+    rerender(<PageShell header={hdr()}>content</PageShell>); // → Back: header returns as a NEW node
+    measure(12, 52); // fires the NEW header's observer
+    expect(content().style.getPropertyValue("--hdr-h")).toBe("68px"); // re-measured, not the stale 4px
+  });
+});
+
+// The pinned-rail overlay decision: a rail pins as OVERLAY (--rail-pinned-w 2.25rem, the toolbar keeps a
+// slim gutter and content stays put) once the window is wide enough that the centred content leaves room
+// for the rail in its left margin (maxWidth + ~36rem); below that it pins in-flow (16.75rem). The rem→px
+// conversion must use the LIVE root font-size, not a hardcoded 16, so it stays correct at every text size.
+describe("PageShell --rail-pinned-w / --content-mw", () => {
+  const root = document.documentElement;
+  const setWidth = (w: number) =>
+    Object.defineProperty(window, "innerWidth", { value: w, configurable: true });
+  afterEach(() => {
+    root.style.removeProperty("font-size");
+    root.style.removeProperty("--content-mw");
+    root.style.removeProperty("--rail-pinned-w");
+  });
+
+  it("overlays the rail once the window clears maxWidth + 36rem (at 16px/rem)", () => {
+    setWidth(1600); // 64rem*16 + 36rem*16 = 1024 + 576 = 1600 → exactly roomy
+    render(<PageShell maxWidth="64rem">content</PageShell>);
+    expect(root.style.getPropertyValue("--content-mw")).toBe("64rem");
+    expect(root.style.getPropertyValue("--rail-pinned-w")).toBe("2.25rem");
+  });
+
+  it("keeps the rail in-flow just below the threshold", () => {
+    setWidth(1599);
+    render(<PageShell maxWidth="64rem">content</PageShell>);
+    expect(root.style.getPropertyValue("--rail-pinned-w")).toBe("16.75rem");
+  });
+
+  it("never overlays on a full-width page (no maxWidth)", () => {
+    setWidth(3000);
+    render(<PageShell>content</PageShell>);
+    expect(root.style.getPropertyValue("--content-mw")).toBe("none");
+    expect(root.style.getPropertyValue("--rail-pinned-w")).toBe("16.75rem");
+  });
+
+  it("recomputes on resize", () => {
+    setWidth(1599);
+    render(<PageShell maxWidth="64rem">content</PageShell>);
+    expect(root.style.getPropertyValue("--rail-pinned-w")).toBe("16.75rem");
+    setWidth(1600);
+    window.dispatchEvent(new Event("resize"));
+    expect(root.style.getPropertyValue("--rail-pinned-w")).toBe("2.25rem");
+  });
+
+  it("scales the rem threshold by the live root font-size, not a hardcoded 16", () => {
+    root.style.fontSize = "17px"; // as the --font-scale 1.06 default renders it
+    setWidth(1650); // roomy at 16px/rem (>1600) but NOT at 17px/rem (needs 100rem*17 = 1700)
+    render(<PageShell maxWidth="64rem">content</PageShell>);
+    expect(root.style.getPropertyValue("--rail-pinned-w")).toBe("16.75rem");
+  });
+
+  it("recomputes at runtime when --font-scale changes the root font, without looping", async () => {
+    setWidth(1650); // roomy at 16px/rem (1650 >= 1600) → overlay
+    render(<PageShell maxWidth="64rem">content</PageShell>);
+    expect(root.style.getPropertyValue("--rail-pinned-w")).toBe("2.25rem");
+    // The text-size slider changes the root font-size with NO resize event — the MutationObserver
+    // must recompute. At 17px/rem the threshold is 100rem*17 = 1700 > 1650, so the rail goes in-flow.
+    // (If the observer's self-write guard were broken this would loop forever and time out.)
+    root.style.fontSize = "17px";
+    await new Promise((r) => setTimeout(r, 0)); // flush the MutationObserver microtask
+    expect(root.style.getPropertyValue("--rail-pinned-w")).toBe("16.75rem");
+  });
 });

frontend/src/components/PageShell.tsx

@@ -4,7 +4,6 @@ import {
   isValidElement,
   useContext,
   useLayoutEffect,
-  useRef,
   useState,
   type ReactElement,
   type ReactNode,
@@ -53,6 +52,7 @@ export default function PageShell({
   children,
   scrollKey,
   fadeTop = true,
+  maxWidth,
 }: {
   header?: ReactNode;
   banners?: ReactNode;
@@ -61,43 +61,96 @@ export default function PageShell({
   scrollKey?: string;
   // Off when this page's scroll region starts with a sticky header — see PageScroller.
   fadeTop?: boolean;
+  // The content column's max width (e.g. "1600px"); the header + toolbar centre on the same width via
+  // --content-mw. Omit for a full-width page (feed). See index.css --content-mw.
+  maxWidth?: string;
 }) {
   const [toolbarSlot, setToolbarSlot] = useState<HTMLDivElement | null>(null);
+  // Publish this page's content max-width so the floating header (and toolbar band) can centre on the
+  // same width the content column uses. Global (one page shell renders at a time). Also decide whether
+  // a PINNED filter rail should stay OVERLAY (keep the toolbar's fixed leading gutter, don't push the
+  // centred content) or go in-flow: overlay only when the centred content leaves a wide-enough left
+  // margin for the rail to sit in — else pinning would overlap the content, so it pushes (in-flow).
+  useLayoutEffect(() => {
+    const root = document.documentElement;
+    root.style.setProperty("--content-mw", maxWidth ?? "none");
+    // Room the pinned rail needs: its own width (~16rem) on each side of the centred content, plus the
+    // nav rail (~4rem) = ~36rem. Below that, or on a full-width page (no maxWidth), pin in-flow (w-67).
+    let lastPxPerRem = 0;
+    const apply = () => {
+      // Convert the rem maxWidth (and the 36rem slack) against the LIVE root font-size, not a hardcoded
+      // 16: index.css scales the root by --font-scale (default 1.06 ≈ 17px, slider 0.9–1.3), and the page's
+      // own content wrapper is a rem `max-w-*`, so a fixed 16 mis-sizes the threshold at every text size.
+      const pxPerRem = parseFloat(getComputedStyle(root).fontSize) || 16;
+      lastPxPerRem = pxPerRem;
+      const mwPx = maxWidth
+        ? maxWidth.endsWith("rem")
+          ? parseFloat(maxWidth) * pxPerRem
+          : parseFloat(maxWidth)
+        : null;
+      const roomy = mwPx != null && window.innerWidth >= mwPx + 36 * pxPerRem;
+      root.style.setProperty("--rail-pinned-w", roomy ? "2.25rem" : "16.75rem");
+    };
+    apply();
+    window.addEventListener("resize", apply);
+    // The text-size slider changes --font-scale (hence the root font-size) WITHOUT firing resize, so the
+    // rem→px threshold would go stale. Re-run when the root font actually changes; the pxPerRem guard keeps
+    // our own --rail-pinned-w write (a rem string, no font change) from re-triggering the observer.
+    const fontObserver = new MutationObserver(() => {
+      if ((parseFloat(getComputedStyle(root).fontSize) || 16) !== lastPxPerRem) apply();
+    });
+    fontObserver.observe(root, { attributes: true, attributeFilter: ["style"] });
+    return () => {
+      window.removeEventListener("resize", apply);
+      fontObserver.disconnect();
+      root.style.removeProperty("--content-mw");
+      root.style.removeProperty("--rail-pinned-w");
+    };
+  }, [maxWidth]);
   // The floating header pads the content below it by `--hdr-h`. That must equal the header's REAL
   // height, which grows as the flex-wrap header wraps to 2–3 rows on a narrow window — a fixed pad
-  // would let the content toolbar slide up under it (E5 S7). Measure the header (a ref forwarded onto
-  // its root box) and write its height straight onto the content wrapper that consumes `--hdr-h`, so
-  // the two live together with no assumption about the header's DOM parent.
-  const headerRef = useRef<HTMLDivElement | null>(null);
-  const contentRef = useRef<HTMLDivElement | null>(null);
+  // would let the content toolbar slide up under it (E5 S7). Measure the header and write its height
+  // straight onto the content wrapper that consumes `--hdr-h`.
+  //
+  // Both nodes are held in STATE (callback refs), NOT plain refs behind a one-shot `useLayoutEffect([])`:
+  // PageShell is reused — never remounted — across feed↔channel navigation (same component position in
+  // App.tsx), so the header DOM node is swapped out from under a stable PageShell. A one-shot effect keeps
+  // observing the FIRST header node; when that node detaches on channel-open, its ResizeObserver fires with
+  // a 0 box and rewrites --hdr-h to `0+0+4`=4px on the (still-mounted) content div. On Back the pad class
+  // returns with that stale 4px → the content toolbar slides up under the header, stuck until reload. Keying
+  // the measurement to the live node re-runs it every time the header mounts/unmounts, so it stays correct.
+  const [headerEl, setHeaderEl] = useState<HTMLDivElement | null>(null);
+  const [contentEl, setContentEl] = useState<HTMLDivElement | null>(null);
   useLayoutEffect(() => {
-    const h = headerRef.current;
-    const c = contentRef.current;
-    if (!h || !c) return;
-    // `+ 8` = the header's own gap-y-2 row gap (0.5rem), reused as the gap below it.
-    const apply = () => c.style.setProperty("--hdr-h", `${h.offsetTop + h.offsetHeight + 8}px`);
+    if (!headerEl || !contentEl) {
+      // No header (channel page) → drop any stale pad so a leftover value can't linger.
+      contentEl?.style.removeProperty("--hdr-h");
+      return;
+    }
+    // `+ 4` = a tight gap below the floating header before the content toolbar starts.
+    const apply = () =>
+      contentEl.style.setProperty("--hdr-h", `${headerEl.offsetTop + headerEl.offsetHeight + 4}px`);
     apply();
     const ro = new ResizeObserver(apply);
-    ro.observe(h);
-    return () => {
-      ro.disconnect();
-      c.style.removeProperty("--hdr-h");
-    };
-  }, []);
+    ro.observe(headerEl);
+    return () => ro.disconnect();
+  }, [headerEl, contentEl]);
   const measuredHeader = isValidElement(header)
     ? cloneElement(header as ReactElement<{ ref?: Ref<HTMLDivElement> }>, {
-        ref: headerRef,
+        ref: setHeaderEl,
       })
     : header;
   return (
     <PageToolbarSlot.Provider value={toolbarSlot}>
       {measuredHeader}
       <div
-        ref={contentRef}
+        ref={setContentEl}
         className={`flex-1 min-w-0 min-h-0 flex flex-col ${header ? "pt-(--hdr-h)" : ""}`}
       >
         {banners}
-        <div ref={setToolbarSlot} className="shrink-0" />
+        {/* pr-[--sbw]: the toolbar band isn't the scroller, so without this it would run the
+            scrollbar-gutter's width past the scrolled cards on the right. Pad it back to card width. */}
+        <div ref={setToolbarSlot} className="shrink-0 pr-[var(--sbw)]" />
         <PageScroller scrollKey={scrollKey} fadeTop={fadeTop}>
           {children}
         </PageScroller>

frontend/src/components/PanelGroup.tsx

@@ -1,29 +1,37 @@
 import { type ReactNode, type CSSProperties } from "react";
 import { useTranslation } from "react-i18next";
-import { ChevronDown, Eye, EyeOff, GripVertical } from "lucide-react";
+import { ChevronDown, Eye, EyeOff, GripVertical, Pencil } from "lucide-react";
 import { useSortable } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 
-// One collapsible "island" card inside a SidePanel: a titled glass-card with per-group collapse,
-// and — in the panel's edit mode — a drag handle (reorder) and a hide toggle. Generalized from
-// the feed sidebar's WidgetCard so all three panels share the same island look and behavior.
+// One "island" card inside a SidePanel: a titled glass-card, and — in the panel's edit mode — a drag
+// handle (reorder) and a hide toggle. Generalized from the feed sidebar's WidgetCard so all three
+// panels share the same island look and behavior. `collapsible` groups (the default) get a per-group
+// collapse chevron; non-collapsible groups render as a plain always-open label + control row, and
+// their title can instead act as a trigger via `onTitleClick` (e.g. feed "Your tags" -> tag manager).
 export default function PanelGroup({
   id,
   title,
   editing,
+  collapsible = true,
   collapsed,
   hidden,
   onToggleCollapse,
   onToggleHidden,
+  onTitleClick,
+  titleActionLabel,
   children,
 }: {
   id: string;
   title: string;
   editing: boolean;
+  collapsible?: boolean;
   collapsed: boolean;
   hidden: boolean;
   onToggleCollapse: () => void;
   onToggleHidden: () => void;
+  onTitleClick?: () => void;
+  titleActionLabel?: string;
   children: ReactNode;
 }) {
   const { t } = useTranslation();
@@ -32,7 +40,13 @@ export default function PanelGroup({
     disabled: !editing,
   });
   const style: CSSProperties = { transform: CSS.Transform.toString(transform), transition };
-  const showBody = !editing && !collapsed;
+  // Non-collapsible groups are always open (outside edit mode); collapsible ones honour `collapsed`.
+  const showBody = !editing && (!collapsible || !collapsed);
+  // A non-collapsible group's title acts as a trigger when one is provided.
+  const titleIsTrigger = !editing && !collapsible && !!onTitleClick;
+
+  const titleCls =
+    "flex-1 min-w-0 flex items-center gap-1 text-left select-none text-sm uppercase tracking-wide";
 
   return (
     <div
@@ -53,13 +67,27 @@ export default function PanelGroup({
             <GripVertical className="w-4 h-4" />
           </button>
         )}
-        <button
-          onClick={editing ? undefined : onToggleCollapse}
-          disabled={editing}
-          className="flex-1 min-w-0 flex items-center text-left select-none text-xs uppercase tracking-wide text-muted enabled:hover:text-fg transition"
-        >
-          <span className="truncate">{title}</span>
-        </button>
+        {collapsible && !editing ? (
+          <button
+            onClick={onToggleCollapse}
+            className={`${titleCls} text-muted hover:text-fg transition`}
+          >
+            <span className="truncate">{title}</span>
+          </button>
+        ) : titleIsTrigger ? (
+          <button
+            onClick={onTitleClick}
+            title={titleActionLabel}
+            className={`${titleCls} group text-muted hover:text-accent transition`}
+          >
+            <span className="truncate">{title}</span>
+            <Pencil className="w-3 h-3 shrink-0 text-muted/60 group-hover:text-accent" />
+          </button>
+        ) : (
+          <span className={`${titleCls} text-muted`}>
+            <span className="truncate">{title}</span>
+          </span>
+        )}
         {editing ? (
           <button
             onClick={onToggleHidden}
@@ -69,15 +97,17 @@ export default function PanelGroup({
             {hidden ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
           </button>
         ) : (
-          <button
-            onClick={onToggleCollapse}
-            title={collapsed ? t("sidebar.expand") : t("sidebar.collapse")}
-            className="text-muted hover:text-fg"
-          >
-            <ChevronDown
-              className={`w-4 h-4 transition-transform ${collapsed ? "-rotate-90" : ""}`}
-            />
-          </button>
+          collapsible && (
+            <button
+              onClick={onToggleCollapse}
+              title={collapsed ? t("sidebar.expand") : t("sidebar.collapse")}
+              className="text-muted hover:text-fg"
+            >
+              <ChevronDown
+                className={`w-4 h-4 transition-transform ${collapsed ? "-rotate-90" : ""}`}
+              />
+            </button>
+          )
         )}
       </div>
       {showBody && <div className="px-3 pb-3">{children}</div>}

frontend/src/components/PanelGroups.tsx

@@ -17,7 +17,16 @@ import {
 import type { PanelLayout } from "../lib/panelLayout";
 import PanelGroup from "./PanelGroup";
 
-export type PanelItem = { id: string; title: string; body: ReactNode };
+export type PanelItem = {
+  id: string;
+  title: string;
+  body: ReactNode;
+  /** When set (and the panel is non-collapsible), the group's title becomes a button firing this —
+   *  e.g. the feed's "Your tags" opens the tag manager. */
+  onTitleClick?: () => void;
+  /** Accessible name / tooltip for the title action (what onTitleClick does). */
+  titleActionLabel?: string;
+};
 
 // Renders a panel's islands in the user's saved order, with drag-to-reorder + hide + per-group
 // collapse driven by `layout` (see lib/panelLayout). `items` holds only the currently AVAILABLE
@@ -29,11 +38,15 @@ export default function PanelGroups({
   layout,
   setLayout,
   editing,
+  collapsible = true,
 }: {
   items: PanelItem[];
   layout: PanelLayout;
   setLayout: (l: PanelLayout) => void;
   editing: boolean;
+  /** When false, groups render as plain (always-open) label + control rows — no collapse chevron.
+   *  Reorder + hide (in edit mode) stay. Default true (the collapsible-island look). */
+  collapsible?: boolean;
 }) {
   const sensors = useSensors(
     useSensor(PointerSensor, { activationConstraint: { distance: 4 } }),
@@ -76,10 +89,13 @@ export default function PanelGroups({
               id={id}
               title={byId.get(id)!.title}
               editing={editing}
+              collapsible={collapsible}
               collapsed={!!layout.collapsed[id]}
               hidden={!!layout.hidden[id]}
               onToggleCollapse={() => toggleCollapse(id)}
               onToggleHidden={() => toggleHidden(id)}
+              onTitleClick={byId.get(id)!.onTitleClick}
+              titleActionLabel={byId.get(id)!.titleActionLabel}
             >
               {byId.get(id)!.body}
             </PanelGroup>

frontend/src/components/PersonalViewsModal.tsx

@@ -0,0 +1,242 @@
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { BookmarkPlus, GripVertical, Play, Star, Trash2 } from "lucide-react";
+import {
+  closestCenter,
+  DndContext,
+  PointerSensor,
+  useSensor,
+  useSensors,
+  type DragEndEvent,
+} from "@dnd-kit/core";
+import {
+  arrayMove,
+  SortableContext,
+  useSortable,
+  verticalListSortingStrategy,
+} from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { coercePlexFilters, type FeedFilters, type SavedView } from "../lib/api";
+import Modal from "./Modal";
+import { useSavedViews, asFilters } from "./SavedViewsProvider";
+import { useActiveFilters } from "../lib/useActiveFilters";
+import { buildPlexActiveFilters } from "./usePlexActiveFilters";
+
+// Master–detail manager for saved ("personal") views: the left column lists the views (drag to
+// reorder) plus a "save the current filters" input; the right column shows the selected view's name,
+// what filters it captures, its default flag, apply, and delete. Opened from the filter panel's title
+// or the saved-views popover; all mutations flow through SavedViewsProvider.
+function ViewRow({
+  view,
+  selected,
+  active,
+  onSelect,
+}: {
+  view: SavedView;
+  selected: boolean;
+  active: boolean;
+  onSelect: () => void;
+}) {
+  const { t } = useTranslation();
+  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
+    id: view.id,
+  });
+  return (
+    <div
+      ref={setNodeRef}
+      style={{ transform: CSS.Transform.toString(transform), transition }}
+      className={`flex items-center gap-1.5 rounded-lg pr-1.5 ${isDragging ? "opacity-60" : ""} ${
+        selected ? "bg-accent/15" : "hover:bg-card"
+      }`}
+    >
+      <button
+        {...attributes}
+        {...listeners}
+        aria-label={t("views.reorder")}
+        className="cursor-grab p-1.5 text-muted hover:text-fg"
+      >
+        <GripVertical className="h-3.5 w-3.5" />
+      </button>
+      <button
+        onClick={onSelect}
+        className={`flex-1 min-w-0 truncate py-1.5 text-left text-sm ${
+          selected ? "text-accent" : "text-fg"
+        }`}
+      >
+        {view.name}
+      </button>
+      {view.is_default && <Star className="h-3 w-3 shrink-0 fill-current text-accent" />}
+      {active && <span className="mr-1 h-1.5 w-1.5 shrink-0 rounded-full bg-accent" />}
+    </div>
+  );
+}
+
+export default function PersonalViewsModal() {
+  const { t } = useTranslation();
+  const {
+    source,
+    views,
+    activeViewId,
+    apply,
+    create,
+    rename,
+    toggleDefault,
+    remove,
+    reorder,
+    closeModal,
+  } = useSavedViews();
+  const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 4 } }));
+
+  const [selectedId, setSelectedId] = useState<number | null>(activeViewId ?? views[0]?.id ?? null);
+  const selected = views.find((v) => v.id === selectedId) ?? null;
+  const [draftName, setDraftName] = useState("");
+
+  // The selected view's captured filters, as the same human labels its module's chip row shows. The
+  // feed hook runs unconditionally (fed empty filters off-feed); Plex uses the pure builder (no-op
+  // removes — this is display-only). A plex view captures its rail filters, not the watch-state.
+  const noop = () => {};
+  const feedCaptured = useActiveFilters(
+    source === "feed" && selected
+      ? asFilters(selected.filters as unknown as FeedFilters)
+      : ({ tags: [], channelIds: [] } as never),
+    noop,
+  );
+  const captured =
+    source === "plex" && selected
+      ? buildPlexActiveFilters(coercePlexFilters(selected.filters), "all", noop, noop, t)
+      : feedCaptured;
+
+  async function onDragEnd(e: DragEndEvent) {
+    const { active, over } = e;
+    if (!over || active.id === over.id) return;
+    const ids = views.map((v) => v.id);
+    const next = arrayMove(ids, ids.indexOf(active.id as number), ids.indexOf(over.id as number));
+    await reorder(next);
+  }
+
+  async function onCreate() {
+    const name = draftName.trim();
+    if (!name) return;
+    if (await create(name)) setDraftName("");
+  }
+
+  return (
+    <Modal title={t("views.manageTitle")} onClose={closeModal} maxWidth="max-w-2xl">
+      <div className="grid min-h-[20rem] grid-cols-[minmax(0,14rem)_1fr] gap-4">
+        {/* Left: the list + create */}
+        <div className="flex flex-col border-r border-border/60 pr-4">
+          <div className="flex-1 space-y-1 overflow-y-auto">
+            {views.length === 0 && (
+              <p className="px-1 py-2 text-2xs leading-snug text-muted">{t("views.empty")}</p>
+            )}
+            <DndContext sensors={sensors} collisionDetection={closestCenter} onDragEnd={onDragEnd}>
+              <SortableContext
+                items={views.map((v) => v.id)}
+                strategy={verticalListSortingStrategy}
+              >
+                {views.map((v) => (
+                  <ViewRow
+                    key={v.id}
+                    view={v}
+                    selected={v.id === selectedId}
+                    active={v.id === activeViewId}
+                    onSelect={() => setSelectedId(v.id)}
+                  />
+                ))}
+              </SortableContext>
+            </DndContext>
+          </div>
+          <div className="mt-2 flex items-center gap-1.5 border-t border-border/60 pt-2">
+            <input
+              value={draftName}
+              onChange={(e) => setDraftName(e.target.value)}
+              onKeyDown={(e) => e.key === "Enter" && onCreate()}
+              placeholder={t("views.namePlaceholder")}
+              className="min-w-0 flex-1 rounded-lg border border-border bg-surface px-2 py-1.5 text-sm focus:border-accent focus:outline-hidden focus:ring-2 focus:ring-accent/30"
+            />
+            <button
+              onClick={onCreate}
+              disabled={!draftName.trim()}
+              title={t("views.save")}
+              className="inline-flex shrink-0 items-center gap-1 rounded-lg btn-primary px-2.5 py-1.5 text-sm font-semibold disabled:opacity-40"
+            >
+              <BookmarkPlus className="h-4 w-4" />
+            </button>
+          </div>
+        </div>
+
+        {/* Right: the selected view's detail */}
+        {selected ? (
+          <div className="flex flex-col gap-3">
+            <input
+              key={selected.id}
+              defaultValue={selected.name}
+              onBlur={(e) => {
+                const next = e.target.value.trim();
+                if (next && next !== selected.name) void rename(selected.id, next);
+              }}
+              className="rounded-lg border border-border bg-surface px-3 py-2 text-sm font-medium focus:border-accent focus:outline-hidden focus:ring-2 focus:ring-accent/30"
+            />
+            <div>
+              <div className="mb-1.5 text-2xs font-semibold uppercase tracking-wider text-muted">
+                {t("views.capturedFilters")}
+              </div>
+              {captured.length === 0 ? (
+                <p className="text-xs text-muted">{t("views.capturedNone")}</p>
+              ) : (
+                <div className="flex flex-wrap gap-1.5">
+                  {captured.map((f) => (
+                    <span
+                      key={f.key}
+                      className="rounded-full bg-accent/10 px-2 py-0.5 text-2xs text-accent"
+                    >
+                      {f.label}
+                    </span>
+                  ))}
+                </div>
+              )}
+            </div>
+            <div className="mt-auto flex items-center gap-2 border-t border-border/60 pt-3">
+              <button
+                onClick={() => apply(selected)}
+                className="inline-flex items-center gap-1.5 rounded-lg btn-primary px-3 py-1.5 text-sm font-semibold"
+              >
+                <Play className="h-3.5 w-3.5" />
+                {t("views.apply")}
+              </button>
+              <button
+                onClick={() => void toggleDefault(selected)}
+                title={t("views.default")}
+                className={`inline-flex items-center gap-1.5 rounded-lg border px-3 py-1.5 text-sm transition ${
+                  selected.is_default
+                    ? "border-accent text-accent"
+                    : "border-border text-muted hover:text-fg"
+                }`}
+              >
+                <Star className={`h-3.5 w-3.5 ${selected.is_default ? "fill-current" : ""}`} />
+                {t("views.default")}
+              </button>
+              <button
+                onClick={async () => {
+                  const next = views.find((v) => v.id !== selected.id);
+                  // Only move the selection if the delete actually happened (remove awaits a confirm
+                  // and resolves false on cancel) — otherwise cancelling would still switch the pane.
+                  if (await remove(selected)) setSelectedId(next?.id ?? null);
+                }}
+                title={t("views.delete")}
+                className="ml-auto inline-flex items-center gap-1.5 rounded-lg border border-border px-3 py-1.5 text-sm text-danger transition hover:border-danger"
+              >
+                <Trash2 className="h-3.5 w-3.5" />
+                {t("views.delete")}
+              </button>
+            </div>
+          </div>
+        ) : (
+          <div className="flex items-center justify-center text-sm text-muted">
+            {t("views.selectPrompt")}
+          </div>
+        )}
+      </div>
+    </Modal>
+  );
+}

frontend/src/components/PlayerModal.tsx

@@ -1,9 +1,17 @@
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { createPortal } from "react-dom";
 import { useNavigationActions } from "./NavigationProvider";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { qk } from "../lib/queryKeys";
+import { usePref } from "../lib/usePref";
+import {
+  AUTO_MODES,
+  LOOP_MODES,
+  PlayerTransportControls,
+  type AutoMode,
+  type LoopMode,
+} from "./playerModalControls";
 import {
   AlertTriangle,
   ArrowLeft,
@@ -15,12 +23,7 @@ import {
   Maximize,
   Minimize,
   Minimize2,
-  Repeat,
-  Repeat1,
   Settings,
-  Shuffle,
-  SkipBack,
-  SkipForward,
   Volume2,
   VolumeX,
   X,
@@ -31,7 +34,7 @@ import { PopoverSurface, useAnchoredPopover } from "./AnchoredPopover";
 import { pushLayer, removeLayer, anyLayerAbove } from "../lib/layerStack";
 import DownloadButton from "./DownloadButton";
 import { api, type Video, type VideoStatus } from "../lib/api";
-import type { YTNamespace, YTPlayer, YTPlayerEvent } from "../lib/youtube";
+import type { YTPlayer } from "../lib/youtube";
 import {
   channelYouTubeUrl,
   formatDate,
@@ -40,15 +43,14 @@ import {
   relativeTime,
 } from "../lib/format";
 import { renderDescription } from "../lib/descriptionLinks";
+import { fullscreenElement } from "../lib/fullscreen";
+import { useBackToClose } from "../lib/history";
 import {
-  exitFullscreen,
-  fullscreenElement,
-  onFullscreenChange,
-  requestFullscreen,
-} from "../lib/fullscreen";
-import { useBackToClose, useBackToExit } from "../lib/history";
-import { DEFAULT_VOLUME, normalizeVolume, stepVolume } from "../lib/playerVolume";
-import { LS, readAccountMerged, writeAccount } from "../lib/storage";
+  useNativeControlsYield,
+  useYtBigView,
+  useYtProgress,
+  useYtVolume,
+} from "../lib/playerModalHooks";
 import { useScrollFade } from "../lib/useScrollFade";
 
 // Experiment (branch experiment/inline-player): play the video in-app via the
@@ -57,119 +59,6 @@ import { useScrollFade } from "../lib/useScrollFade";
 // button, the backdrop, or ESC (ESC only while focus is on our page, not inside
 // the cross-origin player iframe — a browser security boundary we can't cross).
 
-// How close to the end (seconds) counts as "finished" → auto-mark watched.
-const FINISH_MARGIN = 10;
-
-// Persistent playback settings (stored in users.preferences). Auto-advance = what plays when a
-// video ends; loop = whether it repeats the current video ("one"), wraps the list at its ends
-// ("all"), or neither ("off"). Both apply to any queued player (feed or playlist).
-type AutoMode = "off" | "next" | "prev" | "random";
-type LoopMode = "off" | "one" | "all";
-const AUTO_MODES: AutoMode[] = ["off", "next", "prev", "random"];
-const LOOP_MODES: LoopMode[] = ["off", "one", "all"];
-
-/** The queue transport cluster — prev / counter / next, then the auto-advance and loop mode toggles.
- *  Rendered in two places with identical logic: the modal's queue bar (`variant:"modal"`, normal glass
- *  theme, labels always shown) and the big-view docked control bar (`variant:"docked"`, white-on-dark,
- *  labels hidden until a breakpoint). Only the theme + label-visibility differ; the behaviour is one,
- *  so a mode/icon change lands once. The wrapper (fragment vs. bordered row) stays at the call site. */
-function PlayerTransportControls({
-  variant,
-  index,
-  queueLength,
-  autoMode,
-  loopMode,
-  onPrev,
-  onNext,
-  onCycleAuto,
-  onCycleLoop,
-}: {
-  variant: "docked" | "modal";
-  index: number;
-  queueLength: number;
-  autoMode: AutoMode;
-  loopMode: LoopMode;
-  onPrev: () => void;
-  onNext: () => void;
-  onCycleAuto: () => void;
-  onCycleLoop: () => void;
-}) {
-  const { t } = useTranslation();
-  const docked = variant === "docked";
-  const navBtn = docked
-    ? "inline-flex items-center gap-1 text-white/80 enabled:hover:text-white disabled:opacity-30 transition"
-    : "inline-flex items-center gap-1.5 text-muted enabled:hover:text-fg disabled:opacity-40 transition";
-  const navLabel = docked ? "hidden sm:inline" : "";
-  const counter = docked ? "tabular-nums text-white/70" : "text-muted tabular-nums";
-  const divider = docked ? "h-4 w-px bg-white/20" : "w-px h-4 bg-border";
-  const toggle = (on: boolean) =>
-    docked
-      ? `inline-flex items-center gap-1 rounded-lg px-2 py-1 transition ${
-          on ? "bg-white/20 text-white" : "text-white/70 hover:bg-white/10 hover:text-white"
-        }`
-      : `inline-flex items-center gap-1.5 rounded-lg px-2.5 py-1 transition ${
-          on ? "bg-accent/15 text-accent" : "text-muted hover:bg-surface hover:text-fg"
-        }`;
-  const toggleLabel = docked ? "hidden md:inline" : "";
-  return (
-    <>
-      <button
-        onClick={onPrev}
-        disabled={index === 0}
-        title={`${t("player.previous")} · Shift+←`}
-        className={navBtn}
-      >
-        <SkipBack className="h-4 w-4" />
-        <span className={navLabel}>{t("player.previous")}</span>
-      </button>
-      <span className={counter}>
-        {index + 1} / {queueLength}
-      </span>
-      <button
-        onClick={onNext}
-        disabled={index === queueLength - 1}
-        title={`${t("player.next")} · Shift+→`}
-        className={navBtn}
-      >
-        <span className={navLabel}>{t("player.next")}</span>
-        <SkipForward className="h-4 w-4" />
-      </button>
-      <span className={divider} />
-      {/* Persistent playback settings — cycle on click, saved to your account. */}
-      <button
-        onClick={onCycleAuto}
-        title={t("player.autoAdvance.hint")}
-        className={toggle(autoMode !== "off")}
-      >
-        {autoMode === "prev" ? (
-          <SkipBack className="h-3.5 w-3.5" />
-        ) : autoMode === "random" ? (
-          <Shuffle className="h-3.5 w-3.5" />
-        ) : (
-          <SkipForward className="h-3.5 w-3.5" />
-        )}
-        <span className={toggleLabel}>
-          {t("player.autoAdvance.label")}: {t(`player.autoAdvance.${autoMode}`)}
-        </span>
-      </button>
-      <button
-        onClick={onCycleLoop}
-        title={t("player.loop.hint")}
-        className={toggle(loopMode !== "off")}
-      >
-        {loopMode === "one" ? (
-          <Repeat1 className="h-3.5 w-3.5" />
-        ) : (
-          <Repeat className="h-3.5 w-3.5" />
-        )}
-        <span className={toggleLabel}>
-          {t("player.loop.label")}: {t(`player.loop.${loopMode}`)}
-        </span>
-      </button>
-    </>
-  );
-}
-
 /** Can `el` (or an ancestor inside the modal) still scroll vertically in `dir` (-1 up, 1 down)?
  * Used to leave ArrowUp/ArrowDown alone while there is content to scroll — the volume shortcut
  * must not eat the only keyboard way to read a long description. Stops at `<body>`: the page
@@ -185,26 +74,6 @@ function canScrollBy(el: HTMLElement | null, dir: -1 | 1): boolean {
   return false;
 }
 
-// --- IFrame Player API loader (singleton) ---
-let apiPromise: Promise<YTNamespace> | null = null;
-function loadYouTubeApi(): Promise<YTNamespace> {
-  if (apiPromise) return apiPromise;
-  apiPromise = new Promise<YTNamespace>((resolve) => {
-    const w = window;
-    if (w.YT && w.YT.Player) return resolve(w.YT);
-    const prev = w.onYouTubeIframeAPIReady;
-    w.onYouTubeIframeAPIReady = () => {
-      if (typeof prev === "function") prev();
-      // The API-ready callback only fires once the script has installed window.YT.
-      resolve(w.YT!);
-    };
-    const tag = document.createElement("script");
-    tag.src = "https://www.youtube.com/iframe_api";
-    document.head.appendChild(tag);
-  });
-  return apiPromise;
-}
-
 export default function PlayerModal({
   video,
   startAt,
@@ -264,11 +133,6 @@ export default function PlayerModal({
     startAt != null && active.id === video.id ? startAt : active.position_seconds || 0;
   const mountRef = useRef<HTMLDivElement | null>(null);
   const playerRef = useRef<YTPlayer | null>(null);
-  const autoMarkedRef = useRef(false);
-  // Bound consecutive unplayable items so an auto-advancing queue (esp. loop=all) can't spin over a
-  // run of dead videos — after the cap we stop on the error overlay instead of skipping forever.
-  const MAX_CONSECUTIVE_ERRORS = 3;
-  const errorStreakRef = useRef(0);
   // Keyboard/wheel controls. We keep focus on the modal card (not the cross-origin player
   // iframe) so F / Space / Esc keep working until the user clicks into YouTube's native
   // controls; the interaction overlay below also stops the iframe stealing focus on a video
@@ -278,52 +142,6 @@ export default function PlayerModal({
   // The whole modal (backdrop + card) — the wheel-to-volume target, so scrolling anywhere over the
   // modal adjusts volume (not just the small player area).
   const dialogRef = useRef<HTMLDivElement | null>(null);
-  const volTimerRef = useRef<number | undefined>(undefined);
-  // Volume level to flash in the on-player overlay (null = hidden). Auto-fades after a moment.
-  const [volumeUi, setVolumeUi] = useState<number | null>(null);
-  // When the user interacts with YouTube's own controls (gear/seek/CC), focus moves into the
-  // cross-origin player iframe. We detect that and drop the interaction overlay's pointer-events
-  // so YouTube's settings menu — which expands DOWN over the video, past our overlay — is fully
-  // navigable (previously the overlay ate clicks below the top items). Moving the pointer off the
-  // video, or the window regaining focus, re-arms our click/scroll/keyboard shortcuts.
-  const [nativeControls, setNativeControls] = useState(false);
-  // True while OUR stage element is the fullscreen element. In fullscreen the interaction overlay
-  // yields entirely (see the overlay's pointer-events below): YouTube's control bar only appears
-  // while the iframe itself sees mouse movement, so an armed overlay kept the bar — and with it
-  // the native fullscreen button — permanently hidden after pressing F.
-  const [isFullscreen, setIsFullscreen] = useState(false);
-  // Our own "fills the viewport" mode (the F key). Not the Fullscreen API — see toggleFullscreen.
-  const [maximized, setMaximized] = useState(false);
-  const maximizedRef = useRef(false);
-  maximizedRef.current = maximized;
-  // Mirrored into a ref because the keydown handler is bound once (deps: [onClose]) and would
-  // otherwise read `false` forever — the house pattern here (see navRef/volumeRef).
-  const isFullscreenRef = useRef(false);
-  // Nested Back: peel fullscreen → maximise → close, one browser/mouse Back at a time (each is a
-  // history layer only while active). Mirrors the Esc ladder in the keydown handler below.
-  useBackToExit(isFullscreen, exitFullscreen);
-  useBackToExit(maximized, () => setMaximized(false));
-  // Volume survives the modal, the next video and a reload: a YT.Player is created per video and
-  // always starts at full volume. Per-account, like the Plex player's prefs. Level 0 IS the muted
-  // state (that's how YouTube's own control behaves), so there's no separate `muted` flag to
-  // contradict it.
-  //
-  // Ref + explicit read/write rather than `useAccountPersistedObject`: nothing RENDERS the level
-  // (the on-player flash has its own `volumeUi` state), the once-bound wheel/key listeners need a
-  // ref anyway, and the hook's write lives inside a `setState` updater — which is both a second
-  // write on every settle and not something React must run while the component is unmounting.
-  // Sanitised HERE, at the boundary where the untrusted value enters (`normalizeVolume`, see
-  // lib/playerVolume): a stored `null` / `"80"` / missing key becomes the default once, instead of
-  // travelling into the arithmetic. Read via a lazy `useState` initializer so it happens once, not
-  // on every render (the house pattern — see the frozen queue above).
-  const [storedVolume] = useState(() =>
-    normalizeVolume(readAccountMerged(LS.ytPlayerPrefs, { volume: DEFAULT_VOLUME }).volume),
-  );
-  const volumeRef = useRef(storedVolume);
-  const volSaveTimerRef = useRef<number | undefined>(undefined);
-  // When the last volume gesture happened — see nudgeVolume (a spin must not re-read the player).
-  const lastNudgeAtRef = useRef(0);
-
   const focusModal = () => cardRef.current?.focus();
   const togglePlay = () => {
     const p = playerRef.current;
@@ -332,84 +150,28 @@ export default function PlayerModal({
       p.pauseVideo?.(); // 1 === playing
     else p.playVideo?.();
   };
-  /** F = maximise, deliberately WITHOUT the Fullscreen API.
-   *
-   * The measured reason (Chrome/Brave/Firefox alike, so it is spec behaviour, not a browser bug):
-   * a cross-origin embed reads its fullscreen state from ITS OWN document. While WE hold the
-   * browser's fullscreen lock — on our wrapper or even on the iframe element — the YouTube player
-   * never learns it is fullscreen, so its own fullscreen button stays in the "enter" state and a
-   * click on it changes nothing visible. That is the reported bug: every other YouTube control
-   * (gear, CC, volume) works, only its fullscreen button looks dead.
-   *
-   * So we don't take the lock at all: `maximized` is a CSS layer that fills the viewport. The page
-   * stays non-fullscreen, which means the embed's own fullscreen button works exactly as it does
-   * anywhere else — and OUR shortcuts and overlays (wheel volume, the level flash, the queue bar)
-   * keep working, because our DOM is what's on screen. The one thing we give up is hiding the
-   * browser's own chrome; YouTube's button provides that, correctly, when the user wants it.
-   */
-  const toggleFullscreen = () => setMaximized((m) => !m);
-  // True browser fullscreen that WE own (the stage element). Unlike YouTube's own fullscreen it keeps
-  // OUR overlay + control bar on screen, so wheel/arrow volume and our controls work inside it too.
-  // We never surface YouTube's own fullscreen button, so the "a cross-origin embed's own button looks
-  // dead while we hold the lock" problem that made F avoid the Fullscreen API does not arise.
-  const toggleTrueFullscreen = () => {
-    if (fullscreenElement()) exitFullscreen();
-    else if (stageRef.current) requestFullscreen(stageRef.current);
-  };
-  // Leave the big view back to the modal card: drop fullscreen first if held, then un-maximise.
-  const exitBigView = () => {
-    if (fullscreenElement()) exitFullscreen();
-    setMaximized(false);
-  };
-  const flashVolume = (level: number) => {
-    setVolumeUi(level);
-    window.clearTimeout(volTimerRef.current);
-    volTimerRef.current = window.setTimeout(() => setVolumeUi(null), 1200);
-  };
-  /** Write the current level out now, cancelling any pending debounce. */
-  const persistVolume = () => {
-    window.clearTimeout(volSaveTimerRef.current);
-    volSaveTimerRef.current = undefined;
-    writeAccount(LS.ytPlayerPrefs, { volume: volumeRef.current });
-  };
-  /** Push a level (0–100) to the player and remember it; 0 also mutes (a player left at zero
-   * volume but unmuted shows YouTube's speaker icon as ON, which reads as broken). */
-  const applyVolume = (level: number, flash = true) => {
-    // Callers hand over an already-normalised level (stepVolume / the stored value), but the
-    // player can still answer NaN, so re-normalise here against the LAST GOOD level — never the
-    // default: jumping a quiet session to full blast is the surprise this feature exists to avoid.
-    const next = normalizeVolume(level, volumeRef.current);
-    const p = playerRef.current;
-    if (p && typeof p.setVolume === "function") {
-      if (next > 0) p.unMute?.();
-      p.setVolume(next);
-      if (next === 0) p.mute?.();
-    }
-    volumeRef.current = next;
-    // Debounced: one write when the spin settles, not one per notch. The unmount cleanup flushes
-    // a pending write, so the last change is never lost.
-    window.clearTimeout(volSaveTimerRef.current);
-    volSaveTimerRef.current = window.setTimeout(persistVolume, 400);
-    if (flash) flashVolume(next);
-  };
-  const nudgeVolume = (delta: number) => {
-    // No early return when the player isn't ready yet: the level lives in `volumeRef` and onReady
-    // applies it, so a wheel spin in the first second after opening (the natural reaction to a
-    // video that starts loud) now lands instead of being silently dropped.
-    const p = playerRef.current;
-    // Whose level do we step from? Our own ref, EXCEPT when the gesture starts fresh — then read
-    // the player, because the user may have moved YouTube's own slider in the meantime.
-    // `getVolume()` is answered across the iframe boundary and lags our `setVolume` by a beat, so
-    // re-reading it mid-spin resurrects a stale level and silently drops notches (measured: five
-    // wheel notches moved 100 → 90 instead of 75).
-    const now = Date.now();
-    const continuing = now - lastNudgeAtRef.current < 1000;
-    lastNudgeAtRef.current = now;
-    const live =
-      p && typeof p.getVolume === "function" ? (p.isMuted?.() ? 0 : p.getVolume()) : null;
-    const cur = continuing || live === null ? volumeRef.current : live;
-    applyVolume(stepVolume(cur, { delta, fallback: volumeRef.current }));
-  };
+  // Per-account volume (wheel over the whole modal + ↑/↓): the level lives in the hook's ref and is
+  // re-applied to each freshly-created player via reapplyStored (onReady).
+  const { volumeUi, reapplyStored, nudgeVolume } = useYtVolume({
+    playerRef,
+    dialogRef,
+    focusModal,
+  });
+  const { nativeControls, setNativeControls } = useNativeControlsYield({
+    playerRef,
+    stageRef,
+    focusModal,
+  });
+  const {
+    isFullscreen,
+    maximized,
+    maximizedRef,
+    isFullscreenRef,
+    toggleFullscreen,
+    toggleTrueFullscreen,
+    exitBigView,
+    setMaximized,
+  } = useYtBigView({ stageRef, playerRef, focusModal });
 
   // The player can navigate to other videos (YouTube links in a description). The
   // currently-playing id may differ from the active item.
@@ -481,36 +243,18 @@ export default function PlayerModal({
     p.seekTo(Math.max(0, (p.getCurrentTime() || 0) + delta), true);
   };
 
-  // Auto-advance + loop are persistent per-user settings. Read the current values from the cached
-  // `me`, mirror them in local state for instant UI, and write both to the server + cache on change
-  // so they apply to every player and survive reloads. A ref feeds the (once-bound) end handler.
-  const savedPrefs = useMemo(
-    () =>
-      (qc.getQueryData<{ preferences?: Record<string, unknown> }>(qk.me())?.preferences ?? {}) as {
-        playerAutoAdvance?: AutoMode;
-        playerLoop?: LoopMode;
-      },
-    [qc],
-  );
-  const [autoMode, setAutoMode] = useState<AutoMode>(savedPrefs.playerAutoAdvance ?? "off");
-  const [loopMode, setLoopMode] = useState<LoopMode>(savedPrefs.playerLoop ?? "off");
+  // Auto-advance + loop are persistent per-user settings (usePref: server + `me` cache, adopted on
+  // login) so they apply to every player and survive reloads. The player mounts after `me` is cached,
+  // so it seeds from the cache — no localStorage mirror. A ref feeds the (once-bound) end handler.
+  const [autoMode, setAutoMode] = usePref<AutoMode>("playerAutoAdvance", "off");
+  const [loopMode, setLoopMode] = usePref<LoopMode>("playerLoop", "off");
   const modeRef = useRef({ autoMode, loopMode });
   modeRef.current = { autoMode, loopMode };
-  const persistPref = (patch: Record<string, string>) => {
-    api.savePrefs(patch).catch(() => {});
-    qc.setQueryData<{ preferences?: Record<string, unknown> } | undefined>(qk.me(), (m) =>
-      m ? { ...m, preferences: { ...(m.preferences || {}), ...patch } } : m,
-    );
-  };
   const cycleAuto = () => {
-    const next = AUTO_MODES[(AUTO_MODES.indexOf(autoMode) + 1) % AUTO_MODES.length]!;
-    setAutoMode(next);
-    persistPref({ playerAutoAdvance: next });
+    setAutoMode(AUTO_MODES[(AUTO_MODES.indexOf(autoMode) + 1) % AUTO_MODES.length]!);
   };
   const cycleLoop = () => {
-    const next = LOOP_MODES[(LOOP_MODES.indexOf(loopMode) + 1) % LOOP_MODES.length]!;
-    setLoopMode(next);
-    persistPref({ playerLoop: next });
+    setLoopMode(LOOP_MODES[(LOOP_MODES.indexOf(loopMode) + 1) % LOOP_MODES.length]!);
   };
   const replayCurrent = () => {
     const p = playerRef.current;
@@ -656,232 +400,29 @@ export default function PlayerModal({
     return () => {
       window.removeEventListener("keydown", onKey);
       document.body.style.overflow = prevOverflow;
-      window.clearTimeout(volTimerRef.current);
-      // Flush a debounced volume write — closing the player right after a wheel spin (the normal
-      // way to leave) must not drop the level the user just set.
-      if (volSaveTimerRef.current != null) persistVolume();
+      // (The debounced volume write is flushed by useYtVolume's own unmount cleanup.)
     };
   }, [onClose]);
 
-  // Mouse-wheel volume over the WHOLE modal (backdrop + card), not just the small player area.
-  // Non-passive so preventDefault stops the modal/page scrolling. Note: the cross-origin iframe
-  // swallows wheel events over its own native-control strips, but the central interaction overlay
-  // is our element (wheel there bubbles here), and everything outside the video works directly.
-  useEffect(() => {
-    const el = dialogRef.current;
-    if (!el) return;
-    const onWheel = (e: WheelEvent) => {
-      // Ctrl/⌘+wheel is the browser's zoom gesture — never swallow it. Volume is the PLAIN wheel
-      // (and ↑/↓); taking the modifier too left zoom unreachable while the player was open.
-      if (e.ctrlKey || e.metaKey) return;
-      e.preventDefault();
-      focusModal(); // re-grab focus if it had slipped into the native controls
-      nudgeVolume(e.deltaY < 0 ? 5 : -5);
-    };
-    el.addEventListener("wheel", onWheel, { passive: false });
-    return () => el.removeEventListener("wheel", onWheel);
-  }, []);
-
-  // Track the browser's fullscreen state. WE never request it any more (F maximises via CSS), so
-  // this is YouTube's own fullscreen — entered from its control bar, left by its button or Esc.
-  useEffect(() => {
-    const onChange = () => {
-      const fsEl = fullscreenElement();
-      // Refs only — this listener is bound once, so it must not close over render values.
-      const p = playerRef.current;
-      const frame = p && typeof p.getIframe === "function" ? p.getIframe() : null;
-      const ours = !!fsEl && (fsEl === stageRef.current || fsEl === frame);
-      isFullscreenRef.current = ours; // read by the once-bound keydown handler
-      setIsFullscreen(ours); // drives the overlay's pointer-events
-      // LEAVING fullscreen is where the user got stranded: to reach YouTube's fullscreen button
-      // they had to click INTO the player, which moves keyboard focus into the cross-origin iframe
-      // — and it stays there afterwards. Our window-level shortcuts then never fire (F went to
-      // YouTube instead, giving a second, control-less fullscreen), so the maximised view had no
-      // way out. Taking focus back here restores F/Space/arrows the moment fullscreen ends.
-      if (!fsEl) focusModal();
-    };
-    return onFullscreenChange(onChange); // both spellings — see lib/fullscreen
-  }, []);
-
-  // Yield the interaction overlay to YouTube's native UI. Clicking a native control (gear / seek
-  // bar / CC) moves focus into the player iframe — the only cross-origin signal we get. While the
-  // iframe holds focus we drop the overlay's pointer-events so the (arbitrarily tall) settings
-  // menu is clickable end to end. Re-arm — restoring click-to-play, wheel volume and our keyboard
-  // shortcuts — when the pointer leaves the video or the window regains focus (a click back on our
-  // card blurs the iframe → the parent window fires 'focus').
-  useEffect(() => {
-    const iframeFocused = () => {
-      const p = playerRef.current;
-      const f = p && typeof p.getIframe === "function" ? p.getIframe() : null;
-      return !!f && document.activeElement === f;
-    };
-    // activeElement settles on the tick after blur, so defer the check.
-    const onBlur = () => window.setTimeout(() => iframeFocused() && setNativeControls(true), 0);
-    const rearm = () => {
-      setNativeControls(false);
-      focusModal();
-    };
-    const stage = stageRef.current;
-    window.addEventListener("blur", onBlur);
-    window.addEventListener("focus", rearm);
-    stage?.addEventListener("mouseleave", rearm);
-    return () => {
-      window.removeEventListener("blur-sm", onBlur);
-      window.removeEventListener("focus", rearm);
-      stage?.removeEventListener("mouseleave", rearm);
-    };
-  }, []);
-
-  // Create the player, resume from the saved position, persist progress, and
-  // auto-mark watched once playback reaches the end.
-  useEffect(() => {
-    let cancelled = false;
-    const id = active.id;
-    autoMarkedRef.current = false;
-    setPlayerError(null);
-
-    // Auto-watch only applies to the active item — not to other videos the player
-    // navigated to via description links.
-    const maybeAutoWatch = (current: number, duration: number): boolean => {
-      if (autoMarkedRef.current || duration <= 0 || currentIdRef.current !== id) return false;
-      // Cap the finish margin at half the clip, so a video shorter than FINISH_MARGIN isn't
-      // auto-marked watched almost immediately (its threshold would otherwise go negative).
-      const margin = Math.min(FINISH_MARGIN, duration / 2);
-      if (current > duration - margin) {
-        autoMarkedRef.current = true;
-        setWatched(true);
-        return true;
-      }
-      return false;
-    };
-    const persist = (): Promise<unknown> | void => {
-      const p = playerRef.current;
-      if (!p || typeof p.getCurrentTime !== "function") return;
-      try {
-        const cur = p.getCurrentTime();
-        const dur = typeof p.getDuration === "function" ? p.getDuration() : 0;
-        // If we just auto-marked watched, skip the near-end progress checkpoint: it would
-        // only clear the resume position, and firing both at once needlessly races the
-        // watched write against the progress row it deletes.
-        if (maybeAutoWatch(cur, dur)) return;
-        // Only checkpoint the feed video we opened with — a navigated-to video may not
-        // be in this user's library, so the server would 404 on it.
-        if (currentIdRef.current === id) {
-          return api.saveProgress(id, cur, dur).catch(() => {});
-        }
-      } catch {
-        /* player may be tearing down */
-      }
-    };
-
-    loadYouTubeApi().then((YT) => {
-      if (cancelled || !mountRef.current) return;
-      playerRef.current = new YT.Player(mountRef.current, {
-        width: "100%",
-        height: "100%",
-        videoId: id,
-        playerVars: {
-          autoplay: 1,
-          start: resumeAt || undefined,
-          rel: 0, // limit "related" to the same channel (full removal is no longer possible)
-          enablejsapi: 1,
-          origin: window.location.origin,
-          playsinline: 1,
-          // Best-effort HD hint. The IFrame API's setPlaybackQuality/suggestedQuality are hard no-ops
-          // now (YouTube removed them), and the undocumented `vq` URL param is only occasionally
-          // honoured — kept because it's harmless. NOTE: YouTube hard-caps an embed's max quality by
-          // the player's on-screen size; a windowed embed is stuck ~360p and only true fullscreen
-          // lifts the cap (after which the higher pick persists for the session). We can't beat that
-          // programmatically — a CSS transform-scale trick was tried and does NOT fool the cap.
-          vq: "hd1080",
-        },
-        events: {
-          // Keep keyboard focus on the modal, not the iframe, so shortcuts work right away, and
-          // restore the remembered volume — a fresh player always starts at 100.
-          onReady: () => {
-            focusModal();
-            applyVolume(volumeRef.current, false);
-          },
-          onStateChange: (e: YTPlayerEvent) => {
-            // 1 === playing → sync the navigated-to video's title/author for display.
-            if (e?.data === 1) {
-              errorStreakRef.current = 0; // a successful play breaks any unplayable run
-              const p = playerRef.current;
-              const d = p && typeof p.getVideoData === "function" ? p.getVideoData() : null;
-              if (d) setLiveData({ title: d.title, author: d.author });
-            }
-            // 0 === ended → mark watched, then advance to the next queue item if any.
-            if (e?.data === 0 && currentIdRef.current === id) {
-              if (!autoMarkedRef.current) {
-                autoMarkedRef.current = true;
-                setWatched(true);
-              }
-              advanceOnEnd();
-            }
-          },
-          // The embed couldn't play this video (embedding disabled, removed, private…).
-          // Surface our own message + an "Open on YouTube" escape hatch.
-          onError: (e: YTPlayerEvent) => {
-            setPlayerError(typeof e?.data === "number" ? e.data : -1);
-            // The IFrame API fires onError (not 'ended') for an unplayable item, so advanceOnEnd()
-            // never runs and an auto-advancing queue would freeze here. Skip forward instead — but
-            // bounded, so a run of dead items (or loop=all over a broken queue) can't spin. We do
-            // NOT mark the broken video watched (only the ended-handler does that).
-            if (currentIdRef.current !== id) return; // a navigated description-link error: leave the queue alone
-            const { autoMode: a } = modeRef.current;
-            const { queue: q } = navRef.current;
-            if (a === "off" || !q || q.length <= 1) return;
-            errorStreakRef.current += 1;
-            if (errorStreakRef.current >= MAX_CONSECUTIVE_ERRORS) return; // give up; leave the overlay
-            advanceOnEnd();
-          },
-        },
-      });
-    });
-
-    // Periodic checkpoint so progress (and auto-watch) survive a crash/refresh.
-    const timer = window.setInterval(persist, 5000);
-    // Save on page unload too (F5/close/navigate): effect cleanup doesn't run on a full reload, so
-    // without this the resume point lags up to 5s (a seek right before F5 would be lost). A keepalive
-    // beacon so the POST survives the unload. Only for the library item we opened with — a navigated
-    // description-link video may not be in this user's library (the server would 404).
-    const onHide = () => {
-      const p = playerRef.current;
-      if (!p || typeof p.getCurrentTime !== "function" || currentIdRef.current !== id) return;
-      try {
-        const cur = p.getCurrentTime();
-        const dur = typeof p.getDuration === "function" ? p.getDuration() : 0;
-        if (cur > 0 && dur > 0) api.saveProgressBeacon(id, cur, dur);
-      } catch {
-        /* player tearing down */
-      }
-    };
-    window.addEventListener("pagehide", onHide);
-
-    return () => {
-      cancelled = true;
-      window.clearInterval(timer);
-      window.removeEventListener("pagehide", onHide);
-      // Final flush, then mark the feed + playlists stale so resume bars reflect this session on the
-      // next natural refetch — WITHOUT refetching every loaded feed page on each player close (PERF-2:
-      // opening/closing the player through a watch session otherwise re-runs the whole infinite query
-      // each time). Progress is already persisted server-side; only the on-screen resume bar waits.
-      Promise.resolve(persist()).finally(() => {
-        qc.invalidateQueries({ queryKey: qk.feed(), refetchType: "none" });
-        qc.invalidateQueries({ queryKey: qk.playlist(), refetchType: "none" });
-      });
-      const p = playerRef.current;
-      if (p && typeof p.destroy === "function") {
-        try {
-          p.destroy();
-        } catch {
-          /* ignore */
-        }
-      }
-      playerRef.current = null;
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [active.id]);
+  // Create the player, resume from the saved position, checkpoint progress, and auto-mark watched at
+  // the end — recreated per active item. The once-bound event closures read fresh queue/mode/volume via
+  // the refs passed in. See lib/playerModalHooks.
+  useYtProgress({
+    activeId: active.id,
+    resumeAt,
+    mountRef,
+    playerRef,
+    currentIdRef,
+    navRef,
+    modeRef,
+    setWatched,
+    setPlayerError,
+    setLiveData,
+    reapplyStored,
+    focusModal,
+    advanceOnEnd,
+    qc,
+  });
 
   // Portaled to <body>, like every other full-screen overlay here. A fixed, full-viewport modal
   // must not render inside the page scroller: once that scroller is a stacking context (its

frontend/src/components/Playlists.tsx

@@ -571,7 +571,7 @@ export default function Playlists() {
       {/* Header (title, actions, view controls) is fixed chrome — it portals into the shell's
           fixed band, so only the video list scrolls. */}
       <PageToolbar>
-        <div className="px-4 pt-3 pb-2">
+        <div className="px-4 pt-2 pb-2 max-w-5xl mx-auto">
           <div className="flex gap-3 items-start mb-4">
             <div className="w-24 h-13.5 rounded-lg bg-card overflow-hidden shrink-0">
               {items[0]?.thumbnail_url && (
@@ -757,7 +757,7 @@ export default function Playlists() {
           accessibility={{ screenReaderInstructions, announcements }}
         >
           {/* Not clipped, so the header's filter popovers can overflow the table box. */}
-          <div className="max-w-5xl">
+          <div className="max-w-5xl mx-auto">
             {/* table-fixed, not auto: every column but the title has a declared width, so the
                 title absorbs the rest and its `truncate` works. Auto layout sizes columns from
                 min-content, and a nowrap title cell's min-content is the entire title. */}

frontend/src/components/PlaylistsProvider.tsx

@@ -1,6 +1,9 @@
 import { createContext, useCallback, useContext, useMemo, useState, type ReactNode } from "react";
-import { getAccountRaw, LS, setAccountRaw } from "../lib/storage";
+import { LS, setAccountRaw } from "../lib/storage";
 import { useAccountRehydrate } from "../lib/useAccountRehydrate";
+import { useUrlMirror } from "../lib/useUrlMirror";
+import { useNavigation } from "./NavigationProvider";
+import { readSelectedId } from "./playlistsInit";
 
 // Owns the Playlists module's shared local state — the rail's name filter and the selected playlist
 // — lifted out of the App god component so the header search box, the PlaylistsRail, and the
@@ -36,11 +39,6 @@ export function usePlaylistsActions(): PlaylistsActions {
   return useContext(ActionsContext);
 }
 
-function readSelectedId(): number | null {
-  const s = getAccountRaw(LS.playlist);
-  return s ? Number(s) : null;
-}
-
 export function PlaylistsProvider({ children }: { children: ReactNode }) {
   const [search, setSearchState] = useState("");
   const [selectedId, setSelectedIdState] = useState<number | null>(readSelectedId);
@@ -59,6 +57,12 @@ export function PlaylistsProvider({ children }: { children: ReactNode }) {
     [markDirty],
   );
 
+  // Mirror the selected playlist to ?pl on the Playlists page so it's bookmarkable; clear it elsewhere
+  // (the localStorage copy still restores it on return). useUrlMirror keeps ?page and the other nav
+  // params intact.
+  const { page } = useNavigation();
+  useUrlMirror({ pl: page === "playlists" && selectedId != null ? String(selectedId) : null });
+
   const state = useMemo<PlaylistsState>(() => ({ search, selectedId }), [search, selectedId]);
   const actions = useMemo<PlaylistsActions>(
     () => ({ setSearch, setSelectedId }),

frontend/src/components/PlaylistsRail.tsx

@@ -8,9 +8,9 @@ import { formatDuration } from "../lib/format";
 import { notify } from "../lib/notifications";
 import { notifyYouTubeActionError } from "../lib/youtubeErrors";
 import { LS, readAccountMerged, writeAccount } from "../lib/storage";
-import { defaultLayout, type PanelLayout } from "../lib/panelLayout";
-import SidePanel from "./SidePanel";
-import PanelGroups, { type PanelItem } from "./PanelGroups";
+import { type PanelLayout } from "../lib/panelLayout";
+import FilterRail from "./FilterRail";
+import { type PanelItem } from "./PanelGroups";
 import SortControl from "./SortControl";
 import { type SortOption } from "../lib/columnSort";
 import { usePlaylists, usePlaylistsActions } from "./PlaylistsProvider";
@@ -58,7 +58,6 @@ export default function PlaylistsRail({
   }, [plSort]);
   const [newName, setNewName] = useState("");
   const [syncing, setSyncing] = useState(false);
-  const [editing, setEditing] = useState(false);
   const selectedRef = useRef<HTMLButtonElement | null>(null);
   const scrolledRef = useRef(false);
 
@@ -260,17 +259,15 @@ export default function PlaylistsRail({
   ];
 
   return (
-    <SidePanel
+    <FilterRail
+      kind="playlists"
       title={t("playlists.title")}
       icon={<ListVideo className="w-4 h-4" />}
       collapsed={collapsed}
       onToggleCollapse={onToggleCollapse}
-      editing={editing}
-      onToggleEditing={() => setEditing((e) => !e)}
-      onReset={() => setLayout(defaultLayout("playlists"))}
-      editHint={t("sidebar.editHint")}
-    >
-      <PanelGroups items={items} layout={layout} setLayout={setLayout} editing={editing} />
-    </SidePanel>
+      layout={layout}
+      setLayout={setLayout}
+      items={items}
+    />
   );
 }

frontend/src/components/PlexCollectionEditor.tsx

@@ -4,6 +4,7 @@ import { useTranslation } from "react-i18next";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { Check, Plus } from "lucide-react";
 import { api } from "../lib/api";
+import { notifyActionError } from "../lib/actionErrors";
 import { useScrollFade } from "../lib/useScrollFade";
 import Modal from "./Modal";
 import { useConfirm } from "./ConfirmProvider";
@@ -100,6 +101,9 @@ export default function PlexCollectionEditor({
       setNewName("");
       setMembers((prev) => new Set(prev).add(col.id));
       refresh();
+    } catch (e) {
+      // Surfaces the 409 when the name duplicates an existing collection (Plex conflates same names).
+      notifyActionError(e, t("plex.collection.editFailed"));
     } finally {
       setBusy(null);
     }

frontend/src/components/PlexCollectionView.tsx

@@ -0,0 +1,423 @@
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { Play, Shuffle, Pencil, Trash2, Plus, X, Lock, Check, Search } from "lucide-react";
+import { qk } from "../lib/queryKeys";
+import { api, isIntrinsicReadOnly, type PlexCard, type PlexCollectionDetail } from "../lib/api";
+import { formatRuntime } from "../lib/format";
+import { notifyActionError } from "../lib/actionErrors";
+import { useDebounced } from "../lib/useDebounced";
+import { useConfirm } from "./ConfirmProvider";
+import { BackBtn, ActionBtn, DetailHero } from "../lib/plexDetailUi";
+import { PlexPosterCard } from "./plexCards";
+import { toggleWatchState } from "../lib/plexWatch";
+import { LoadingState, StateMessage } from "./QueryState";
+
+// The Collection info page (ask B): a hero (art/title/cert/year-range/count/runtime/summary) + the
+// ordered member grid, a Play-all / Shuffle over the playable leaves, and — for a NON-external,
+// admin-enabled collection — rename / delete / add / remove, all write-through to Plex (the mutation
+// endpoints round-trip to Plex, so each edit awaits and re-fetches; no optimism). Read-only ones (smart
+// / imdb / tmdb / … auto-lists) are marked with a lock.
+function shuffled(a: string[]): string[] {
+  const r = [...a];
+  for (let i = r.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const tmp = r[i]!;
+    r[i] = r[j]!;
+    r[j] = tmp;
+  }
+  return r;
+}
+
+export default function PlexCollectionView({
+  collectionId,
+  onBack,
+  onPlay,
+  onOpenCard,
+  onInfoCard,
+}: {
+  collectionId: string;
+  onBack: () => void;
+  onPlay: (rk: string, queue: string[]) => void;
+  onOpenCard: (card: PlexCard) => void;
+  onInfoCard: (card: PlexCard) => void;
+}) {
+  const { t } = useTranslation();
+  const qc = useQueryClient();
+  const confirm = useConfirm();
+  const isAdmin = qc.getQueryData<{ role?: string }>(qk.me())?.role === "admin";
+  const q = useQuery({
+    queryKey: qk.plexCollections("detail", collectionId),
+    queryFn: () => api.plexCollection(collectionId),
+  });
+  const d = q.data;
+
+  const [expanded, setExpanded] = useState(false);
+  const [renaming, setRenaming] = useState(false);
+  const [name, setName] = useState("");
+  const [adding, setAdding] = useState(false);
+  const [busy, setBusy] = useState(false);
+
+  const invalidate = () => {
+    qc.invalidateQueries({ queryKey: qk.plexCollections() });
+    qc.invalidateQueries({ queryKey: qk.plexLibrary() });
+  };
+
+  const items = d?.items ?? [];
+  // The Play queue is the playable-leaf members (movies/episodes) in order — a show can't queue directly.
+  const playable = items.filter((c) => c.type !== "show").map((c) => c.id);
+  const canEdit = isAdmin && !!d?.can_edit;
+  // A plain (non-smart, non-external) collection can be admin-enabled for editing. Shares
+  // isIntrinsicReadOnly with the browse tile so the lock/edit affordance can't drift between them.
+  const canEnableEdit = isAdmin && !d?.can_edit && !d?.editable && !!d && !isIntrinsicReadOnly(d);
+  const readOnly = !d?.can_edit && !canEnableEdit; // external / smart auto-list
+
+  const toggleWatched = (card: PlexCard) =>
+    toggleWatchState(card, t, {
+      optimistic: (next) => {
+        qc.setQueryData<PlexCollectionDetail>(qk.plexCollections("detail", collectionId), (old) =>
+          old
+            ? {
+                ...old,
+                items: old.items.map((c) => (c.id === card.id ? { ...c, status: next } : c)),
+              }
+            : old,
+        );
+      },
+      resync: () => qc.invalidateQueries({ queryKey: qk.plexLibrary() }),
+    });
+
+  async function doRename() {
+    const title = name.trim();
+    if (!title || !d || title === d.title) {
+      setRenaming(false);
+      return;
+    }
+    setBusy(true);
+    try {
+      await api.plexRenameCollection(collectionId, title);
+      invalidate();
+      setRenaming(false);
+    } catch (e) {
+      notifyActionError(e, t("plex.collection.editFailed"));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function doDelete() {
+    if (!d) return;
+    if (!(await confirm({ message: t("plex.collection.deleteConfirm", { title: d.title }) })))
+      return;
+    setBusy(true);
+    try {
+      await api.plexDeleteCollection(collectionId);
+      invalidate();
+      onBack();
+    } catch (e) {
+      notifyActionError(e, t("plex.collection.editFailed"));
+      setBusy(false);
+    }
+  }
+
+  async function doRemove(card: PlexCard) {
+    // Write-through to the shared Plex library — confirm first, matching the delete-collection guard.
+    if (!(await confirm({ message: t("plex.collection.removeConfirm", { title: card.title }) })))
+      return;
+    setBusy(true);
+    try {
+      await api.plexCollectionRemoveItem(collectionId, card.id);
+      invalidate();
+    } catch (e) {
+      notifyActionError(e, t("plex.collection.editFailed"));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function enableEdit() {
+    setBusy(true);
+    try {
+      await api.plexSetCollectionEditable(collectionId, true);
+      invalidate();
+    } catch (e) {
+      notifyActionError(e, t("plex.collection.editFailed"));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  const meta = [
+    d?.year_min != null &&
+      (d.year_max && d.year_max !== d.year_min ? `${d.year_min} — ${d.year_max}` : `${d.year_min}`),
+    d?.content_rating,
+    d && t("plex.browse.items", { count: d.child_count ?? items.length }),
+    formatRuntime(d?.total_runtime_s),
+  ].filter(Boolean) as string[];
+
+  return (
+    <div className="glass-media mx-auto max-w-[1200px] p-4">
+      <BackBtn onBack={onBack} label={t("plex.backToLibrary")} />
+
+      {q.isError && !q.data ? (
+        <StateMessage tone="error" onRetry={() => q.refetch()}>
+          {t("common.loadError")}
+        </StateMessage>
+      ) : q.isLoading || !d ? (
+        <LoadingState label={t("plex.loading")} />
+      ) : (
+        <>
+          <DetailHero
+            thumb={d.thumb ?? `/api/plex/image/${d.id}`}
+            posterTitle={t("plex.play")}
+            posterDisabled={playable.length === 0}
+            showPlayOverlay={playable.length > 0}
+            onPosterClick={() => playable.length > 0 && onPlay(playable[0]!, playable)}
+            customizeMenu={null}
+          >
+            {renaming ? (
+              <input
+                autoFocus
+                value={name}
+                onChange={(e) => setName(e.target.value)}
+                onBlur={doRename}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") doRename();
+                  if (e.key === "Escape") setRenaming(false);
+                }}
+                aria-label={t("plex.collection.rename")}
+                className="glass-card w-full rounded-lg px-2 py-1 text-2xl font-semibold focus:outline-hidden focus:ring-2 focus:ring-accent/40"
+              />
+            ) : (
+              <div className="flex items-center gap-2">
+                <h1 className="text-2xl font-semibold leading-tight">{d.title}</h1>
+                {readOnly && (
+                  <span
+                    className="inline-flex items-center gap-1 rounded-full bg-surface px-2 py-0.5 text-2xs text-muted"
+                    title={t("plex.collection.readOnly")}
+                  >
+                    <Lock className="h-3 w-3" />
+                    {t("plex.collection.readOnly")}
+                  </span>
+                )}
+              </div>
+            )}
+
+            {meta.length > 0 && (
+              <div className="mt-1 flex flex-wrap items-center gap-x-2 text-sm text-muted">
+                {meta.map((m, i) => (
+                  <span key={i}>
+                    {i > 0 && "· "}
+                    {m}
+                  </span>
+                ))}
+              </div>
+            )}
+
+            {d.summary && (
+              <div className="mt-3">
+                <p
+                  className={`text-sm leading-relaxed text-muted ${expanded ? "" : "line-clamp-3"}`}
+                >
+                  {d.summary}
+                </p>
+                <button
+                  onClick={() => setExpanded((v) => !v)}
+                  className="mt-1 text-xs font-medium text-accent hover:underline"
+                >
+                  {expanded ? t("plex.collection.less") : t("plex.collection.more")}
+                </button>
+              </div>
+            )}
+
+            <div className="mt-4 flex flex-wrap gap-2">
+              {playable.length > 0 && (
+                <>
+                  <ActionBtn
+                    primary
+                    onClick={() => onPlay(playable[0]!, playable)}
+                    icon={Play}
+                    label={t("plex.collection.playAll")}
+                  />
+                  <ActionBtn
+                    onClick={() => {
+                      const order = shuffled(playable);
+                      onPlay(order[0]!, order);
+                    }}
+                    icon={Shuffle}
+                    label={t("plex.collection.shuffle")}
+                  />
+                </>
+              )}
+              {canEdit && (
+                <>
+                  <ActionBtn
+                    onClick={() => {
+                      setName(d.title);
+                      setRenaming(true);
+                    }}
+                    icon={Pencil}
+                    label={t("plex.collection.rename")}
+                  />
+                  <ActionBtn
+                    onClick={() => setAdding((v) => !v)}
+                    icon={Plus}
+                    label={t("plex.collection.addItem")}
+                  />
+                  <ActionBtn
+                    onClick={doDelete}
+                    icon={Trash2}
+                    label={t("plex.collection.delete")}
+                    disabled={busy}
+                  />
+                </>
+              )}
+              {canEnableEdit && (
+                <ActionBtn
+                  onClick={enableEdit}
+                  icon={Check}
+                  label={t("plex.collection.enableEdit")}
+                />
+              )}
+            </div>
+          </DetailHero>
+
+          {adding && canEdit && (
+            <AddItemPanel
+              collectionId={collectionId}
+              scope={items.some((c) => c.type === "show") ? "show" : "movie"}
+              existing={new Set(items.map((c) => c.id))}
+              onAdded={invalidate}
+              onClose={() => setAdding(false)}
+            />
+          )}
+
+          {items.length === 0 ? (
+            <p className="text-muted text-sm">{t("plex.collection.empty")}</p>
+          ) : (
+            <div className="grid grid-cols-3 gap-3 sm:grid-cols-4 md:grid-cols-5 lg:grid-cols-6">
+              {items.map((c) => (
+                <div key={c.id} className="relative">
+                  <PlexPosterCard
+                    card={c}
+                    onOpen={() => onOpenCard(c)}
+                    onInfo={() => onInfoCard(c)}
+                    onToggleWatched={toggleWatched}
+                  />
+                  {canEdit && (
+                    <button
+                      onClick={() => doRemove(c)}
+                      disabled={busy}
+                      title={t("plex.collection.removeItem")}
+                      aria-label={t("plex.collection.removeItem")}
+                      className="glass-card glass-hover absolute right-1.5 top-1.5 z-base grid h-6 w-6 place-items-center rounded-full text-fg disabled:opacity-50"
+                    >
+                      <X className="h-3.5 w-3.5" />
+                    </button>
+                  )}
+                </div>
+              ))}
+            </div>
+          )}
+        </>
+      )}
+    </div>
+  );
+}
+
+// A compact search-and-add panel: search the collection's library, click a result to add it (write-
+// through to Plex). Stays open so several items can be added in a row; already-present items are marked.
+function AddItemPanel({
+  collectionId,
+  scope,
+  existing,
+  onAdded,
+  onClose,
+}: {
+  collectionId: string;
+  scope: string;
+  existing: Set<string>;
+  onAdded: () => void;
+  onClose: () => void;
+}) {
+  const { t } = useTranslation();
+  const [term, setTerm] = useState("");
+  const debounced = useDebounced(term.trim(), 300);
+  const [added, setAdded] = useState<Set<string>>(new Set());
+  const q = useQuery({
+    queryKey: qk.plexLibrary("collection-add", scope, debounced),
+    queryFn: () => api.plexLibrary({ scope, q: debounced, limit: 12 }),
+    enabled: debounced.length > 0,
+  });
+  const results = q.data?.items ?? [];
+
+  async function add(card: PlexCard) {
+    try {
+      await api.plexCollectionAddItem(collectionId, card.id);
+      setAdded((s) => new Set(s).add(card.id));
+      onAdded();
+    } catch (e) {
+      notifyActionError(e, t("plex.collection.editFailed"));
+    }
+  }
+
+  return (
+    <div className="glass-card mb-6 rounded-2xl p-4">
+      <div className="mb-3 flex items-center gap-2">
+        <Search className="h-4 w-4 text-muted" />
+        <input
+          autoFocus
+          value={term}
+          onChange={(e) => setTerm(e.target.value)}
+          placeholder={t("plex.collection.addSearch")}
+          aria-label={t("plex.collection.addSearch")}
+          className="glass-card flex-1 rounded-lg px-3 py-1.5 text-sm focus:outline-hidden focus:ring-2 focus:ring-accent/40"
+        />
+        <button
+          onClick={onClose}
+          aria-label={t("common.close")}
+          className="glass-hover grid h-8 w-8 place-items-center rounded-lg"
+        >
+          <X className="h-4 w-4" />
+        </button>
+      </div>
+      {debounced.length === 0 ? (
+        <p className="text-muted text-sm">{t("plex.collection.addHint")}</p>
+      ) : q.isLoading ? (
+        <LoadingState label={t("plex.loading")} />
+      ) : q.isError ? (
+        <p className="text-muted text-sm">{t("common.loadError")}</p>
+      ) : results.length === 0 ? (
+        <p className="text-muted text-sm">{t("plex.collection.addNoResults")}</p>
+      ) : (
+        <ul className="flex flex-col gap-1">
+          {results.map((c) => {
+            const inColl = existing.has(c.id) || added.has(c.id);
+            return (
+              <li key={c.id} className="flex items-center gap-3">
+                <img
+                  src={c.thumb}
+                  alt=""
+                  className="h-12 w-8 shrink-0 rounded object-cover"
+                  loading="lazy"
+                />
+                <span className="min-w-0 flex-1 truncate text-sm">
+                  {c.title}
+                  {c.year != null && <span className="text-muted"> · {c.year}</span>}
+                </span>
+                <button
+                  onClick={() => add(c)}
+                  disabled={inColl}
+                  className="glass-card glass-hover inline-flex items-center gap-1 rounded-lg px-2.5 py-1 text-xs disabled:opacity-50"
+                >
+                  {inColl ? <Check className="h-3.5 w-3.5" /> : <Plus className="h-3.5 w-3.5" />}
+                  {inColl ? t("plex.collection.added") : t("plex.collection.add")}
+                </button>
+              </li>
+            );
+          })}
+        </ul>
+      )}
+    </div>
+  );
+}

frontend/src/components/PlexDiscover.dom.test.tsx

@@ -0,0 +1,238 @@
+// @vitest-environment jsdom
+//
+// E5 S4: the Plex Discover landing. Covers the rail surface served from the mocked /discover +
+// /surprise calls — that each non-empty rail renders, the genre tile fires onGenre, the recently-added
+// "see all" fires onSeeAllRecent, the ↻ reshuffle refetches the surprise rail alone, and an all-empty
+// payload shows the empty message. i18n is key-passthrough; the api is mocked so queries resolve
+// synchronously. The rails scroll inside a Carousel (useHScroll → ResizeObserver), stubbed for jsdom.
+import { describe, it, expect, afterEach, beforeAll, vi } from "vitest";
+import { render, screen, fireEvent, cleanup, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+beforeAll(() => {
+  class Stub {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() {
+      return [];
+    }
+  }
+  globalThis.ResizeObserver ??= Stub as unknown as typeof ResizeObserver;
+});
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  // Interpolate {{title}} so the because-you-watched heading is asserted with its anchor name.
+  return {
+    ...actual,
+    useTranslation: () => ({
+      t: (key: string, opts?: Record<string, unknown>) =>
+        opts?.title ? `${key}:${opts.title}` : key,
+    }),
+  };
+});
+
+const plexDiscover = vi.fn();
+const plexSurprise = vi.fn();
+const plexSetState = vi.fn((..._a: unknown[]) => Promise.resolve());
+vi.mock("../lib/api", () => ({
+  api: {
+    plexDiscover: (...a: unknown[]) => plexDiscover(...a),
+    plexSurprise: (...a: unknown[]) => plexSurprise(...a),
+    plexSetState: (...a: unknown[]) => plexSetState(...a),
+  },
+  // PlexDiscover now reads the active filters via usePlex (PlexProvider); its context default needs
+  // EMPTY_PLEX_FILTERS at import time. No provider is rendered, so the default (empty) filters apply.
+  EMPTY_PLEX_FILTERS: {
+    genres: [],
+    contentRatings: [],
+    directors: [],
+    actors: [],
+    studios: [],
+    keywords: [],
+    collections: [],
+  },
+}));
+
+import PlexDiscover from "./PlexDiscover";
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+const card = (id: string, title: string, type: "movie" | "show" = "movie") => ({
+  id,
+  type,
+  title,
+  year: 2000,
+  duration_seconds: 3600,
+  thumb: `/api/plex/image/${id}`,
+  playable: "direct",
+  status: "new",
+  position_seconds: 0,
+});
+
+const fullPayload = {
+  scope: "both",
+  continue_watching: [card("cw1", "Resume Me")],
+  recently_watched: [card("rw1", "Watched Me")],
+  recently_added: [card("ra1", "Just Added")],
+  genres: [{ value: "Drama", count: 12, art: [] }],
+  because_you_watched: { anchor: { id: "a1", title: "Anchor" }, items: [card("bw1", "Rec One")] },
+};
+
+function wrap(ui: React.ReactElement) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return render(<QueryClientProvider client={qc}>{ui}</QueryClientProvider>);
+}
+
+const noop = () => {};
+
+describe("PlexDiscover", () => {
+  it("renders each non-empty rail, the genre tiles, and the surprise sample", async () => {
+    plexDiscover.mockResolvedValue(fullPayload);
+    plexSurprise.mockResolvedValue({ scope: "both", items: [card("sp1", "Random Pick")] });
+    wrap(
+      <PlexDiscover
+        scope="both"
+        onOpenCard={noop}
+        onInfoCard={noop}
+        onGenre={noop}
+        onSeeAllRecent={noop}
+      />,
+    );
+    await screen.findByText("plex.discover.continueWatching");
+    expect(screen.getByText("plex.discover.recentlyWatched")).toBeTruthy();
+    expect(screen.getByText("plex.discover.recentlyAdded")).toBeTruthy();
+    expect(screen.getByText("plex.discover.surprise")).toBeTruthy();
+    expect(screen.getByText("plex.discover.byGenre")).toBeTruthy();
+    // The because-you-watched heading interpolates the anchor title.
+    expect(screen.getByText("plex.discover.becauseWatched:Anchor")).toBeTruthy();
+    // A card from each rail is present (title rendered in the poster label).
+    expect(screen.getAllByText("Resume Me").length).toBeGreaterThan(0);
+    expect(screen.getAllByText("Watched Me").length).toBeGreaterThan(0);
+    expect(screen.getAllByText("Just Added").length).toBeGreaterThan(0);
+    expect(screen.getAllByText("Random Pick").length).toBeGreaterThan(0);
+    expect(screen.getAllByText("Rec One").length).toBeGreaterThan(0);
+    // Now called with the active filters too (empty default here, no provider mounted).
+    expect(plexDiscover).toHaveBeenCalledWith(
+      "both",
+      "en",
+      expect.objectContaining({ genres: [] }),
+    );
+  });
+
+  it("registers the discover + surprise queries keyed by the active lang", async () => {
+    // The real cache-separation guard (the queryKeys factory test only pins that a lang ARG survives the
+    // spread): inspect the actual keys the component registered. A regression dropping lang from either
+    // qk call would collide HU/EN in the cache even while the queryFn still fetches the right language.
+    plexDiscover.mockResolvedValue(fullPayload);
+    plexSurprise.mockResolvedValue({ scope: "both", items: [] });
+    const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    render(
+      <QueryClientProvider client={qc}>
+        <PlexDiscover
+          scope="both"
+          onOpenCard={noop}
+          onInfoCard={noop}
+          onGenre={noop}
+          onSeeAllRecent={noop}
+        />
+      </QueryClientProvider>,
+    );
+    await screen.findByText("plex.discover.continueWatching");
+    const keys = qc
+      .getQueryCache()
+      .getAll()
+      .map((q) => q.queryKey);
+    expect(keys).toContainEqual([
+      "plex-discover",
+      "both",
+      "en",
+      expect.objectContaining({ genres: [] }),
+    ]);
+    expect(keys).toContainEqual([
+      "plex-surprise",
+      "both",
+      "en",
+      expect.objectContaining({ genres: [] }),
+    ]);
+  });
+
+  it("fires onGenre with the tile's value", async () => {
+    plexDiscover.mockResolvedValue(fullPayload);
+    plexSurprise.mockResolvedValue({ scope: "both", items: [] });
+    const onGenre = vi.fn();
+    wrap(
+      <PlexDiscover
+        scope="both"
+        onOpenCard={noop}
+        onInfoCard={noop}
+        onGenre={onGenre}
+        onSeeAllRecent={noop}
+      />,
+    );
+    fireEvent.click(await screen.findByText("Drama"));
+    expect(onGenre).toHaveBeenCalledWith("Drama");
+  });
+
+  it("fires onSeeAllRecent from the recently-added rail's see-all", async () => {
+    plexDiscover.mockResolvedValue(fullPayload);
+    plexSurprise.mockResolvedValue({ scope: "both", items: [] });
+    const onSeeAllRecent = vi.fn();
+    wrap(
+      <PlexDiscover
+        scope="both"
+        onOpenCard={noop}
+        onInfoCard={noop}
+        onGenre={noop}
+        onSeeAllRecent={onSeeAllRecent}
+      />,
+    );
+    fireEvent.click(await screen.findByRole("button", { name: "common.seeAll" }));
+    expect(onSeeAllRecent).toHaveBeenCalledOnce();
+  });
+
+  it("reshuffles the surprise rail alone (refetch) without refetching the surface", async () => {
+    plexDiscover.mockResolvedValue(fullPayload);
+    plexSurprise.mockResolvedValue({ scope: "both", items: [card("sp1", "Random Pick")] });
+    wrap(
+      <PlexDiscover
+        scope="both"
+        onOpenCard={noop}
+        onInfoCard={noop}
+        onGenre={noop}
+        onSeeAllRecent={noop}
+      />,
+    );
+    await screen.findByText("Random Pick");
+    expect(plexSurprise).toHaveBeenCalledTimes(1);
+    fireEvent.click(screen.getByRole("button", { name: "plex.discover.reshuffle" }));
+    await waitFor(() => expect(plexSurprise).toHaveBeenCalledTimes(2));
+    expect(plexDiscover).toHaveBeenCalledTimes(1); // the whole surface was NOT refetched
+  });
+
+  it("shows the empty message when every rail is empty", async () => {
+    plexDiscover.mockResolvedValue({
+      scope: "both",
+      continue_watching: [],
+      recently_watched: [],
+      recently_added: [],
+      genres: [],
+      because_you_watched: null,
+    });
+    plexSurprise.mockResolvedValue({ scope: "both", items: [] });
+    wrap(
+      <PlexDiscover
+        scope="both"
+        onOpenCard={noop}
+        onInfoCard={noop}
+        onGenre={noop}
+        onSeeAllRecent={noop}
+      />,
+    );
+    await screen.findByText("plex.discover.empty");
+  });
+});

frontend/src/components/PlexDiscover.tsx

@@ -0,0 +1,235 @@
+import { type ReactNode } from "react";
+import { useTranslation } from "react-i18next";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { RotateCcw } from "lucide-react";
+import { qk } from "../lib/queryKeys";
+import { api, type PlexCard, type PlexDiscover as PlexDiscoverData } from "../lib/api";
+import PosterTile from "./PosterTile";
+import { plexLang } from "../i18n";
+import { toggleWatchState } from "../lib/plexWatch";
+import { usePlex } from "./PlexProvider";
+import { Carousel } from "./Carousel";
+import { PlexPosterCard } from "./plexCards";
+import { LoadingState, StateMessage } from "./QueryState";
+
+// The Plex "Discover" landing (E5 S4): a stack of horizontal Carousel rails served from ONE
+// /api/plex/discover call — Continue watching, Recently added, Browse by genre (tiles), Because you
+// watched X — plus a separately-fetched, reshuffling Surprise-me rail. The flat browse grid stays its
+// own view (PlexBrowse's grid branch); a header search or filter flips the user there. Card click /
+// info / watched-toggle handlers come from the shell (PlexBrowse) so a rail card behaves exactly like
+// a grid card; the watched-toggle optimistically flips THIS surface's cache too.
+
+function CardRail({
+  title,
+  ariaLabel,
+  seeAllLabel,
+  onSeeAll,
+  cards,
+  onOpenCard,
+  onInfoCard,
+  onToggleWatched,
+  action,
+}: {
+  title: ReactNode;
+  ariaLabel: string;
+  seeAllLabel?: string;
+  onSeeAll?: () => void;
+  cards: PlexCard[];
+  onOpenCard: (c: PlexCard) => void;
+  onInfoCard: (c: PlexCard) => void;
+  onToggleWatched: (c: PlexCard) => void;
+  action?: ReactNode; // optional header control (e.g. the Surprise-me reshuffle button)
+}) {
+  const heading =
+    action != null ? (
+      <span className="inline-flex items-center gap-2">
+        {title}
+        {action}
+      </span>
+    ) : (
+      title
+    );
+  return (
+    <section className="mb-5">
+      <Carousel title={heading} ariaLabel={ariaLabel} onSeeAll={onSeeAll} seeAllLabel={seeAllLabel}>
+        {cards.map((c) => (
+          <div key={c.id} className="w-[150px] shrink-0">
+            <PlexPosterCard
+              card={c}
+              onOpen={() => onOpenCard(c)}
+              onInfo={() => onInfoCard(c)}
+              onToggleWatched={onToggleWatched}
+            />
+          </div>
+        ))}
+      </Carousel>
+    </section>
+  );
+}
+
+export default function PlexDiscover({
+  scope,
+  onOpenCard,
+  onInfoCard,
+  onGenre,
+  onSeeAllRecent,
+}: {
+  scope: string;
+  onOpenCard: (c: PlexCard) => void;
+  onInfoCard: (c: PlexCard) => void;
+  onGenre: (genre: string) => void;
+  onSeeAllRecent: () => void;
+}) {
+  const { t } = useTranslation();
+  const qc = useQueryClient();
+  const lang = plexLang();
+  // The active sidebar filters narrow every rail, so Discover matches the Browse grid. They're in the
+  // query keys so a filter change refetches (and the watched-toggle setQueryData below keys the same).
+  const { filters } = usePlex();
+  const q = useQuery({
+    queryKey: qk.plexDiscover(scope, lang, filters),
+    queryFn: () => api.plexDiscover(scope, lang, filters),
+  });
+  // Surprise-me is its own query so the ↻ button can redraw it without refetching the whole surface.
+  const surpriseQ = useQuery({
+    queryKey: qk.plexSurprise(scope, lang, filters),
+    queryFn: () => api.plexSurprise(scope, undefined, filters, lang),
+    staleTime: 0,
+  });
+
+  // Watched toggle over BOTH this surface's cache (so a rail card flips instantly) and the surprise
+  // list, then persist + resync via the shared helper — invalidating the grid too so it agrees.
+  const toggleWatched = (card: PlexCard) =>
+    toggleWatchState(card, t, {
+      optimistic: (next) => {
+        const flip = (cards: PlexCard[]) =>
+          cards.map((c) => (c.id === card.id ? { ...c, status: next } : c));
+        qc.setQueryData<PlexDiscoverData>(qk.plexDiscover(scope, lang, filters), (old) =>
+          old
+            ? {
+                ...old,
+                continue_watching: flip(old.continue_watching),
+                recently_added: flip(old.recently_added),
+                because_you_watched: old.because_you_watched
+                  ? { ...old.because_you_watched, items: flip(old.because_you_watched.items) }
+                  : null,
+              }
+            : old,
+        );
+        qc.setQueryData<{ scope: string; items: PlexCard[] }>(
+          qk.plexSurprise(scope, lang, filters),
+          (old) => (old ? { ...old, items: flip(old.items) } : old),
+        );
+      },
+      resync: () => {
+        qc.invalidateQueries({ queryKey: qk.plexDiscover() });
+        qc.invalidateQueries({ queryKey: qk.plexLibrary() });
+      },
+    });
+
+  if (q.isError && !q.data) {
+    return (
+      <StateMessage tone="error" onRetry={() => q.refetch()}>
+        {t("common.loadError")}
+      </StateMessage>
+    );
+  }
+  if (q.isLoading || !q.data) {
+    return <LoadingState label={t("plex.loading")} />;
+  }
+
+  const d = q.data;
+  const surprise = surpriseQ.data?.items ?? [];
+  const bw = d.because_you_watched;
+  const nothing =
+    d.continue_watching.length === 0 &&
+    d.recently_watched.length === 0 &&
+    d.recently_added.length === 0 &&
+    d.genres.length === 0 &&
+    surprise.length === 0 &&
+    (!bw || bw.items.length === 0);
+
+  if (nothing) {
+    return <p className="text-muted text-sm">{t("plex.discover.empty")}</p>;
+  }
+
+  const railProps = { onOpenCard, onInfoCard, onToggleWatched: toggleWatched };
+
+  return (
+    <div>
+      {d.continue_watching.length > 0 && (
+        <CardRail
+          title={t("plex.discover.continueWatching")}
+          ariaLabel={t("plex.discover.continueWatching")}
+          cards={d.continue_watching}
+          {...railProps}
+        />
+      )}
+
+      {d.recently_watched.length > 0 && (
+        <CardRail
+          title={t("plex.discover.recentlyWatched")}
+          ariaLabel={t("plex.discover.recentlyWatched")}
+          cards={d.recently_watched}
+          {...railProps}
+        />
+      )}
+
+      {d.recently_added.length > 0 && (
+        <CardRail
+          title={t("plex.discover.recentlyAdded")}
+          ariaLabel={t("plex.discover.recentlyAdded")}
+          onSeeAll={onSeeAllRecent}
+          cards={d.recently_added}
+          {...railProps}
+        />
+      )}
+
+      {surprise.length > 0 && (
+        <CardRail
+          title={t("plex.discover.surprise")}
+          ariaLabel={t("plex.discover.surprise")}
+          cards={surprise}
+          action={
+            <button
+              type="button"
+              onClick={() => surpriseQ.refetch()}
+              aria-label={t("plex.discover.reshuffle")}
+              title={t("plex.discover.reshuffle")}
+              className="rounded-full p-1 text-muted transition hover:text-accent"
+            >
+              <RotateCcw className={`h-3.5 w-3.5 ${surpriseQ.isFetching ? "animate-spin" : ""}`} />
+            </button>
+          }
+          {...railProps}
+        />
+      )}
+
+      {d.genres.length > 0 && (
+        <section className="mb-5">
+          <h2 className="mb-3 text-sm font-semibold">{t("plex.discover.byGenre")}</h2>
+          <div className="grid grid-cols-2 gap-3 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-6">
+            {d.genres.map((g) => (
+              <PosterTile
+                key={g.value}
+                title={g.value}
+                art={g.art}
+                onClick={() => onGenre(g.value)}
+                className="h-24"
+              />
+            ))}
+          </div>
+        </section>
+      )}
+
+      {bw && bw.items.length > 0 && (
+        <CardRail
+          title={t("plex.discover.becauseWatched", { title: bw.anchor.title })}
+          ariaLabel={t("plex.discover.becauseWatched", { title: bw.anchor.title })}
+          cards={bw.items}
+          {...railProps}
+        />
+      )}
+    </div>
+  );
+}

frontend/src/components/PlexInfo.dom.test.tsx

@@ -0,0 +1,138 @@
+// @vitest-environment jsdom
+//
+// E5 S5: the enriched Plex detail page. Covers the TMDB-fed pieces added on the page variant — the
+// multi-source ratings row (IMDb / TMDb / audience), the facts panel (budget / revenue / studios /
+// countries), the keyword chips (→ onFilter), and the full crew (→ onOpenPerson). i18n is
+// key-passthrough; PlexInfo is prop-driven (no queries) so it just needs a QueryClient for its cache
+// reads. The overlay variant is asserted to stay lean (no facts/keywords/crew).
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  return {
+    ...actual,
+    useTranslation: () => ({
+      t: (key: string, opts?: Record<string, unknown>) =>
+        opts?.name ? `${key}:${opts.name}` : key,
+    }),
+  };
+});
+
+import PlexInfo from "./PlexInfo";
+import type { PlexItemDetail } from "../lib/api";
+
+afterEach(cleanup);
+
+const detail: PlexItemDetail = {
+  id: "m1",
+  kind: "movie",
+  title: "Test Movie",
+  summary: "A summary.",
+  year: 2010,
+  duration_seconds: 7200,
+  playable: "direct",
+  thumb: "/api/plex/image/m1",
+  art: "/api/plex/image/m1?variant=art",
+  cast: [],
+  imdb_rating: 7.8,
+  imdb_id: "tt1",
+  imdb_url: "https://www.imdb.com/title/tt1",
+  rating: 8.4, // Plex audience
+  content_rating: "R",
+  genres: ["Crime"],
+  directors: ["Plex Director"],
+  studio: "Fallback Studio",
+  tagline: "A tagline.",
+  markers: [],
+  audio_streams: [],
+  subtitle_streams: [],
+  status: "new",
+  position_seconds: 0,
+  tmdb: {
+    tmdb_id: 42,
+    rating: 7.2,
+    vote_count: 1234,
+    budget: 160000000,
+    revenue: 830000000,
+    keywords: ["heist", "bank robbery"],
+    crew: [
+      { name: "Jane Director", job: "Director" },
+      { name: "Sam Writer", job: "Writer" },
+    ],
+    studios: ["Studio A", "Studio B"],
+    production_countries: ["United States"],
+    recommendations: [],
+    backdrops: [],
+  },
+};
+
+function wrap(ui: React.ReactElement) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return render(<QueryClientProvider client={qc}>{ui}</QueryClientProvider>);
+}
+
+describe("PlexInfo enriched detail (page)", () => {
+  it("renders the multi-source ratings row (IMDb / TMDb / audience)", () => {
+    wrap(<PlexInfo detail={detail} variant="page" />);
+    expect(screen.getByText("IMDb")).toBeTruthy();
+    expect(screen.getByText("7.8")).toBeTruthy();
+    expect(screen.getByText(/TMDb/)).toBeTruthy(); // "TMDb · 1.2K" (vote count compacted)
+    expect(screen.getByText("7.2")).toBeTruthy();
+    expect(screen.getByText("plex.info.audience")).toBeTruthy();
+    expect(screen.getByText("8.4")).toBeTruthy();
+  });
+
+  it("renders the facts panel with budget / revenue / studios / countries", () => {
+    wrap(<PlexInfo detail={detail} variant="page" />);
+    expect(screen.getByText("plex.info.facts.title")).toBeTruthy();
+    expect(screen.getByText("plex.info.facts.budget")).toBeTruthy();
+    expect(screen.getByText("$160M")).toBeTruthy();
+    expect(screen.getByText("$830M")).toBeTruthy();
+    expect(screen.getByText("Studio A")).toBeTruthy(); // tmdb.studios preferred over the fallback
+    expect(screen.getByText("United States")).toBeTruthy();
+  });
+
+  it("keyword chips filter the library on click", () => {
+    const onFilter = vi.fn();
+    wrap(<PlexInfo detail={detail} variant="page" onFilter={onFilter} />);
+    fireEvent.click(screen.getByText("heist"));
+    expect(onFilter).toHaveBeenCalledWith({ keywords: ["heist"] });
+  });
+
+  it("crew members open the person page on click", () => {
+    const onOpenPerson = vi.fn();
+    wrap(<PlexInfo detail={detail} variant="page" onOpenPerson={onOpenPerson} />);
+    expect(screen.getByText("plex.info.crew")).toBeTruthy();
+    fireEvent.click(screen.getByText("Jane Director"));
+    expect(onOpenPerson).toHaveBeenCalledWith("Jane Director");
+  });
+
+  it("RatingsRow: with no IMDb score, the audience score becomes the filterable one", () => {
+    const onFilter = vi.fn();
+    const noImdb = { ...detail, imdb_rating: null, imdb_id: null, imdb_url: null };
+    wrap(<PlexInfo detail={noImdb} variant="page" onFilter={onFilter} />);
+    expect(screen.queryByText("IMDb")).toBeNull();
+    // audience (8.4) is now the primary/filterable score → clicking it filters ratingMin.
+    fireEvent.click(screen.getByText("8.4"));
+    expect(onFilter).toHaveBeenCalledWith({ ratingMin: 8 });
+  });
+
+  it("RatingsRow: suppresses the duplicate audience chip when it equals the IMDb score", () => {
+    const dupe = { ...detail, rating: 7.8 }; // audience == imdb_rating (7.8)
+    wrap(<PlexInfo detail={dupe} variant="page" />);
+    expect(screen.getByText("IMDb")).toBeTruthy();
+    expect(screen.queryByText("plex.info.audience")).toBeNull(); // duplicate audience chip suppressed
+    expect(screen.getAllByText("7.8")).toHaveLength(1); // the score shows once (IMDb only)
+  });
+
+  it("the overlay variant stays lean (no facts / keywords / crew panels)", () => {
+    wrap(<PlexInfo detail={detail} variant="overlay" />);
+    expect(screen.queryByText("plex.info.facts.title")).toBeNull();
+    expect(screen.queryByText("plex.info.keywords")).toBeNull();
+    expect(screen.queryByText("plex.info.crew")).toBeNull();
+    // but the ratings row still renders (it's compact enough for the overlay)
+    expect(screen.getByText("IMDb")).toBeTruthy();
+  });
+});

frontend/src/components/PlexInfo.tsx

@@ -1,19 +1,22 @@
-import { useState } from "react";
+import { useState, type ReactNode } from "react";
 import { qk } from "../lib/queryKeys";
 import { useTranslation } from "react-i18next";
 import { useQueryClient } from "@tanstack/react-query";
 import { Check, ExternalLink, FolderPlus, ListPlus, Play, RotateCcw, Star, X } from "lucide-react";
 import { api, type PlexFilters, type PlexItemDetail } from "../lib/api";
 import { formatRuntime } from "../lib/format";
-import { pickRatingBadge } from "../lib/plexRating";
 import { notifyActionError } from "../lib/actionErrors";
 import {
   DetailCustomizeMenu,
   Filterable,
   PrefToggle,
-  useArtBackdrop,
+  tmdbBackdropUrl,
+  useCrossfadeBackdrop,
   useDetailPrefs,
 } from "../lib/plexDetailUi";
+import { usePref } from "../lib/usePref";
+import i18n from "../i18n";
+import { Carousel } from "./Carousel";
 import PlexCollectionEditor from "./PlexCollectionEditor";
 import PlexPlaylistAdd from "./PlexPlaylistAdd";
 
@@ -22,6 +25,233 @@ import PlexPlaylistAdd from "./PlexPlaylistAdd";
 // a card's "i" button (variant="page", with a big Play/Resume + watch controls), and a lean overlay
 // over the running player (variant="overlay", opened with "i"). Two GUI elements are user-toggleable
 // personal preferences, persisted in users.preferences: the faint art backdrop and the cast row.
+// The TMDB-enriched pieces (multi-source ratings row, facts, keyword chips, full crew — E5 S5) render
+// on the page variant only; the overlay stays lean.
+
+// Localize the grouping/compact notation to the active language (the app convention, lib/api/core.ts);
+// `i18n.language` is read at call time, and the component re-renders on a language switch. Currency stays
+// USD — TMDB budget/revenue figures are USD regardless of the viewer's language.
+const compact = (n: number) =>
+  new Intl.NumberFormat(i18n.language, { notation: "compact" }).format(n);
+const money = (n: number) =>
+  new Intl.NumberFormat(i18n.language, {
+    notation: "compact",
+    style: "currency",
+    currency: "USD",
+    maximumFractionDigits: 1,
+  }).format(n);
+
+// Multi-source ratings cluster (E5 S5): IMDb (links out) · TMDb (with vote count) · Plex audience —
+// whichever are present. The "primary" score (IMDb, else audience) mirrors the backend rating column
+// (coalesce(imdb, audience)), so only it carries the ratingMin filter; the others are informational.
+function RatingsRow({
+  imdbRating,
+  imdbUrl,
+  audience,
+  tmdbRating,
+  tmdbVotes,
+  onFilterRating,
+}: {
+  imdbRating?: number | null;
+  imdbUrl?: string | null;
+  audience?: number | null;
+  tmdbRating?: number | null;
+  tmdbVotes?: number | null;
+  onFilterRating?: (score: number) => void;
+}) {
+  const { t } = useTranslation();
+  const primary = imdbRating ?? audience ?? null; // the filterable score
+  const chipCls =
+    "inline-flex items-center gap-1 rounded-md bg-amber-400/15 px-1.5 py-0.5 font-semibold text-amber-500";
+  const Score = ({ score, filterable }: { score: number; filterable: boolean }) =>
+    filterable && onFilterRating ? (
+      <button
+        onClick={() => onFilterRating(Math.floor(score))}
+        className="inline-flex items-center gap-1 hover:opacity-80"
+        title={t("plex.info.filterRating", { n: Math.floor(score) })}
+      >
+        <Star className="h-3.5 w-3.5 fill-current" />
+        {score.toFixed(1)}
+      </button>
+    ) : (
+      <span className="inline-flex items-center gap-1">
+        <Star className="h-3.5 w-3.5 fill-current" />
+        {score.toFixed(1)}
+      </span>
+    );
+  const has = (x?: number | null): x is number => x != null;
+  if (!has(imdbRating) && !has(audience) && !has(tmdbRating)) return null;
+  return (
+    <div className="flex flex-wrap items-center gap-2 text-sm">
+      {has(imdbRating) && (
+        <span className={chipCls}>
+          <Score score={imdbRating} filterable={imdbRating === primary} />
+          <span className="text-2xs font-normal opacity-70">IMDb</span>
+          {imdbUrl && (
+            <a
+              href={imdbUrl}
+              target="_blank"
+              rel="noopener noreferrer"
+              title={t("plex.info.openImdb")}
+            >
+              <ExternalLink className="h-3 w-3 opacity-70 hover:opacity-100" />
+            </a>
+          )}
+        </span>
+      )}
+      {has(tmdbRating) && (
+        <span className={chipCls}>
+          <Score score={tmdbRating} filterable={false} />
+          <span className="text-2xs font-normal opacity-70">
+            TMDb{has(tmdbVotes) ? ` · ${compact(tmdbVotes)}` : ""}
+          </span>
+        </span>
+      )}
+      {has(audience) && imdbRating !== audience && (
+        <span className={chipCls}>
+          <Score score={audience} filterable={!has(imdbRating)} />
+          <span className="text-2xs font-normal opacity-70">{t("plex.info.audience")}</span>
+        </span>
+      )}
+    </div>
+  );
+}
+
+// A structured facts panel (E5 S5): release / runtime / cert / budget / revenue / studios / countries,
+// pulling from the item's own fields + the persisted TMDB block. Rendered only when it has something.
+function FactsPanel({
+  detail,
+  onFilter,
+}: {
+  detail: PlexItemDetail;
+  onFilter?: (patch: Partial<PlexFilters>) => void;
+}) {
+  const { t } = useTranslation();
+  const tmdb = detail.tmdb;
+  const studios = tmdb?.studios?.length ? tmdb.studios : detail.studio ? [detail.studio] : [];
+  const rows: { key: string; label: string; node: ReactNode }[] = [];
+  if (detail.year != null)
+    rows.push({ key: "year", label: t("plex.info.facts.release"), node: detail.year });
+  if (detail.duration_seconds)
+    rows.push({
+      key: "runtime",
+      label: t("plex.info.facts.runtime"),
+      node: formatRuntime(detail.duration_seconds),
+    });
+  if (detail.content_rating)
+    rows.push({ key: "cert", label: t("plex.info.facts.cert"), node: detail.content_rating });
+  if (tmdb?.budget)
+    rows.push({ key: "budget", label: t("plex.info.facts.budget"), node: money(tmdb.budget) });
+  if (tmdb?.revenue)
+    rows.push({ key: "revenue", label: t("plex.info.facts.revenue"), node: money(tmdb.revenue) });
+  if (studios.length)
+    rows.push({
+      key: "studios",
+      label: t("plex.info.facts.studios"),
+      node: (
+        <span className="flex flex-wrap gap-x-1.5 gap-y-0.5">
+          {studios.map((s, i) => (
+            <span key={s}>
+              <Filterable
+                onClick={onFilter ? () => onFilter({ studios: [s] }) : undefined}
+                className="hover:text-accent"
+              >
+                {s}
+              </Filterable>
+              {i < studios.length - 1 ? "," : ""}
+            </span>
+          ))}
+        </span>
+      ),
+    });
+  if (tmdb?.production_countries?.length)
+    rows.push({
+      key: "countries",
+      label: t("plex.info.facts.countries"),
+      node: tmdb.production_countries.join(", "),
+    });
+  if (rows.length === 0) return null;
+  return (
+    <div className="glass-card rounded-2xl p-4 sm:p-5">
+      <h2 className="mb-3 text-sm font-semibold">{t("plex.info.facts.title")}</h2>
+      <dl className="grid grid-cols-[auto_1fr] gap-x-4 gap-y-1.5 text-sm">
+        {rows.map((r) => (
+          <div key={r.key} className="contents">
+            <dt className="text-muted">{r.label}</dt>
+            <dd className="min-w-0 font-medium">{r.node}</dd>
+          </div>
+        ))}
+      </dl>
+    </div>
+  );
+}
+
+// TMDB keyword chips (E5 S5) — tap one to filter the library by that keyword (via applyFilter).
+function KeywordsPanel({
+  keywords,
+  onFilter,
+}: {
+  keywords: string[];
+  onFilter?: (patch: Partial<PlexFilters>) => void;
+}) {
+  const { t } = useTranslation();
+  if (keywords.length === 0) return null;
+  return (
+    <div className="glass-card rounded-2xl p-4 sm:p-5">
+      <h2 className="mb-3 text-sm font-semibold">{t("plex.info.keywords")}</h2>
+      <div className="flex flex-wrap gap-1.5">
+        {keywords.map((k) => (
+          <Filterable
+            key={k}
+            className="rounded-full bg-surface px-2.5 py-1 text-xs text-muted hover:text-accent"
+            title={onFilter ? t("plex.info.filterKeyword", { name: k }) : undefined}
+            onClick={onFilter ? () => onFilter({ keywords: [k] }) : undefined}
+          >
+            {k}
+          </Filterable>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+// Full crew (E5 S5) — the TMDB key-crew (Director / Writer / Producer / …), each clickable to open
+// their person page. Complements the hero's Director line (which comes from Plex directly).
+function CrewPanel({
+  crew,
+  onOpenPerson,
+}: {
+  crew: { name: string; job: string }[];
+  onOpenPerson?: (name: string) => void;
+}) {
+  const { t } = useTranslation();
+  if (crew.length === 0) return null;
+  return (
+    <div className="glass-card rounded-2xl p-4 sm:p-5">
+      <h2 className="mb-3 text-sm font-semibold">{t("plex.info.crew")}</h2>
+      {/* Two columns inside the (now narrow) side box — viewport media-queries can't see the box width,
+          so a fixed small column count keeps names from over-spreading. */}
+      <div className="grid grid-cols-2 gap-x-3 gap-y-1.5">
+        {crew.map((c, i) => (
+          <div key={`${c.name}:${c.job}:${i}`} className="min-w-0">
+            {onOpenPerson ? (
+              <button
+                onClick={() => onOpenPerson(c.name)}
+                title={t("plex.info.viewPerson", { name: c.name })}
+                className="truncate text-left text-sm font-medium hover:text-accent"
+              >
+                {c.name}
+              </button>
+            ) : (
+              <div className="truncate text-sm font-medium">{c.name}</div>
+            )}
+            <div className="truncate text-2xs text-muted">{c.job}</div>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
 
 type Props = {
   detail: PlexItemDetail;
@@ -57,7 +287,12 @@ export default function PlexInfo({
   // Personal display prefs (default ON), shared with the series detail pages via useDetailPrefs:
   // artBg/showCast + their toggles and the raw savePref persister. The collection-strip source hiding
   // is PlexInfo-specific state, persisted through the same savePref.
-  const { artBg, showCast, toggleArtBg, toggleCast, savePref } = useDetailPrefs();
+  const { artBg, showCast, crossfade, toggleArtBg, toggleCast, toggleCrossfade, savePref } =
+    useDetailPrefs();
+  // The three TMDB-enriched side panels are each independently hideable (default ON), like the cast row.
+  const [showFacts, setShowFacts] = usePref<boolean>("plexInfoFacts", true);
+  const [showKeywords, setShowKeywords] = usePref<boolean>("plexInfoKeywords", true);
+  const [showCrew, setShowCrew] = usePref<boolean>("plexInfoCrew", true);
   const prefs = (qc.getQueryData<{ preferences?: Record<string, unknown> }>(qk.me())?.preferences ??
     {}) as { plexHiddenStripSources?: string[] };
   // Which collection-strip source buckets the user has HIDDEN (default: none → all shown). Toggled
@@ -76,9 +311,15 @@ export default function PlexInfo({
   const [editorOpen, setEditorOpen] = useState(false);
   const [playlistOpen, setPlaylistOpen] = useState(false);
 
-  // Faint art backdrop, HTPC-style (page variant only) — the shared hook paints the item's art as a
-  // fixed background on <main> and clears it on unmount / when disabled / in the overlay variant.
-  useArtBackdrop(detail.art, variant !== "overlay" && artBg);
+  // Faint art backdrop, HTPC-style (page variant only) — cross-dissolves through the item's own art,
+  // its TMDB backdrops (E5 S2), and its collection siblings' art (E5 S8). Cleared in the overlay
+  // variant / when disabled / on unmount.
+  const backdropPool = [
+    detail.art,
+    ...(detail.tmdb?.backdrops ?? []).map(tmdbBackdropUrl),
+    ...(detail.collections?.flatMap((c) => c.items.map((i) => i.art)) ?? []),
+  ];
+  useCrossfadeBackdrop(backdropPool, variant !== "overlay" && artBg, crossfade);
 
   const inProgress = (detail.position_seconds ?? 0) > 0 && detail.status !== "watched";
   const setState = async (status: "new" | "watched") => {
@@ -105,9 +346,24 @@ export default function PlexInfo({
   const sourceLabel = (src: string) =>
     t(`plex.info.stripSource.${src}`, { defaultValue: src.toUpperCase() });
 
+  // Whether each enriched side panel has anything to show — drives both its render and its toggle row
+  // (no toggle for a panel that would be empty anyway).
+  const tmdb = detail.tmdb;
+  const hasFacts =
+    detail.year != null ||
+    !!detail.duration_seconds ||
+    !!detail.content_rating ||
+    !!tmdb?.budget ||
+    !!tmdb?.revenue ||
+    !!tmdb?.studios?.length ||
+    !!detail.studio ||
+    !!tmdb?.production_countries?.length;
+  const hasKeywords = (tmdb?.keywords?.length ?? 0) > 0;
+  const hasCrew = (tmdb?.crew?.length ?? 0) > 0;
+
   return (
     <div className={overlay ? "relative w-full max-w-3xl" : "relative glass-media"}>
-      <div className={overlay ? "p-5" : "flex flex-col gap-4 p-3 sm:p-4"}>
+      <div className={overlay ? "p-5" : "flex flex-col gap-3 p-3 sm:p-4"}>
         {/* Hero block: floats as a frosted glass panel over the fixed art backdrop (page variant). */}
         <div className={overlay ? "" : "glass rounded-2xl p-4 sm:p-6"}>
           {/* Header: close (overlay) / customize */}
@@ -126,17 +382,44 @@ export default function PlexInfo({
               overlay={overlay}
               artBg={artBg}
               onToggleArtBg={toggleArtBg}
+              crossfade={crossfade}
+              onToggleCrossfade={toggleCrossfade}
               showCast={showCast}
               onToggleCast={toggleCast}
               hasCast={detail.cast.length > 0}
-              extra={presentSources.map((src) => (
-                <PrefToggle
-                  key={src}
-                  label={sourceLabel(src)}
-                  on={!hiddenSources.includes(src)}
-                  onClick={() => toggleSource(src)}
-                />
-              ))}
+              extra={
+                <>
+                  {hasFacts && (
+                    <PrefToggle
+                      label={t("plex.info.prefFacts")}
+                      on={showFacts}
+                      onClick={() => setShowFacts(!showFacts)}
+                    />
+                  )}
+                  {hasKeywords && (
+                    <PrefToggle
+                      label={t("plex.info.prefKeywords")}
+                      on={showKeywords}
+                      onClick={() => setShowKeywords(!showKeywords)}
+                    />
+                  )}
+                  {hasCrew && (
+                    <PrefToggle
+                      label={t("plex.info.prefCrew")}
+                      on={showCrew}
+                      onClick={() => setShowCrew(!showCrew)}
+                    />
+                  )}
+                  {presentSources.map((src) => (
+                    <PrefToggle
+                      key={src}
+                      label={sourceLabel(src)}
+                      on={!hiddenSources.includes(src)}
+                      onClick={() => toggleSource(src)}
+                    />
+                  ))}
+                </>
+              }
             />
             {overlay && onClose && (
               <button
@@ -196,42 +479,18 @@ export default function PlexInfo({
                     {detail.studio}
                   </Filterable>
                 )}
-                {(() => {
-                  // IMDb score when we have one (with the IMDb link); otherwise the Plex audience
-                  // score (no IMDb link/branding, so a non-IMDb score is never mislabelled as IMDb).
-                  const badge = pickRatingBadge(detail.imdb_rating, detail.rating);
-                  if (!badge) return null;
-                  const { score, isImdb } = badge;
-                  return (
-                    // decorative rating gold — intentionally NOT a status token
-                    <span className="inline-flex items-center gap-1 rounded-md bg-amber-400/15 px-1.5 py-0.5 font-semibold text-amber-500">
-                      <button
-                        onClick={
-                          onFilter ? () => onFilter({ ratingMin: Math.floor(score) }) : undefined
-                        }
-                        className={`inline-flex items-center gap-1 ${onFilter ? "cursor-pointer hover:opacity-80" : "cursor-default"}`}
-                        title={
-                          onFilter
-                            ? t("plex.info.filterRating", { n: Math.floor(score) })
-                            : undefined
-                        }
-                      >
-                        <Star className="w-3.5 h-3.5 fill-current" />
-                        {score.toFixed(1)}
-                      </button>
-                      {isImdb && detail.imdb_url && (
-                        <a
-                          href={detail.imdb_url}
-                          target="_blank"
-                          rel="noopener noreferrer"
-                          title={t("plex.info.openImdb")}
-                        >
-                          <ExternalLink className="w-3 h-3 opacity-70 hover:opacity-100" />
-                        </a>
-                      )}
-                    </span>
-                  );
-                })()}
+              </div>
+
+              {/* Multi-source ratings row (E5 S5): IMDb / TMDb / audience, whichever are present. */}
+              <div className="mt-2">
+                <RatingsRow
+                  imdbRating={detail.imdb_rating}
+                  imdbUrl={detail.imdb_url}
+                  audience={detail.rating}
+                  tmdbRating={detail.tmdb?.rating}
+                  tmdbVotes={detail.tmdb?.vote_count}
+                  onFilterRating={onFilter ? (n) => onFilter({ ratingMin: n }) : undefined}
+                />
               </div>
 
               {detail.tagline && (
@@ -342,13 +601,26 @@ export default function PlexInfo({
         </div>
         {/* End hero panel. */}
 
+        {/* Enriched detail (E5 S5) — page variant only; the overlay stays lean. Details / Keywords /
+            Crew sit side by side (each its natural height, items-start) so no single box hogs the full
+            width with dead space; each is independently hideable from the customize menu. */}
+        {!overlay && (showFacts || showKeywords || showCrew) && (
+          <div className="grid items-start gap-3 sm:grid-cols-2 xl:grid-cols-3">
+            {showFacts && <FactsPanel detail={detail} onFilter={onFilter} />}
+            {showKeywords && (
+              <KeywordsPanel keywords={detail.tmdb?.keywords ?? []} onFilter={onFilter} />
+            )}
+            {showCrew && <CrewPanel crew={detail.tmdb?.crew ?? []} onOpenPerson={onOpenPerson} />}
+          </div>
+        )}
+
         {/* Cast row (toggleable), circular photos. */}
         {cast.length > 0 && (
           <div className={overlay ? "mt-5" : "glass-card rounded-2xl p-4 sm:p-5"}>
             <h2 className={`mb-2 text-sm font-semibold ${overlay ? "text-white/80" : ""}`}>
               {t("plex.info.cast")}
             </h2>
-            <div className="flex gap-3 overflow-x-auto pb-2">
+            <Carousel ariaLabel={t("plex.info.cast")} gap="gap-3">
               {cast.map((c, i) => {
                 const clickable = !!(onOpenPerson || onFilter);
                 const inner = (
@@ -403,10 +675,12 @@ export default function PlexInfo({
                   </div>
                 );
               })}
-            </div>
+            </Carousel>
           </div>
         )}
 
+        {/* (Full crew now lives in the enriched Details/Keywords/Crew grid above the cast row.) */}
+
         {/* Collection strips — the other titles in this movie's collection(s), directly playable.
             Each source bucket (Collections / IMDb / TMDb / smart / …) is independently hideable. */}
         {detail.collections
@@ -419,14 +693,19 @@ export default function PlexInfo({
                 </h2>
                 {onFilter && (
                   <button
-                    onClick={() => onFilter({ collection: col.id, collectionTitle: col.title })}
+                    onClick={() =>
+                      onFilter({
+                        collections: [col.id],
+                        collectionTitles: { [col.id]: col.title },
+                      })
+                    }
                     className="shrink-0 text-xs text-muted hover:text-accent"
                   >
                     {t("plex.info.browseCollection")}
                   </button>
                 )}
               </div>
-              <div className="flex gap-3 overflow-x-auto pb-2">
+              <Carousel ariaLabel={col.title} gap="gap-3">
                 {col.items.map((m) => (
                   <button
                     key={m.id}
@@ -471,7 +750,7 @@ export default function PlexInfo({
                     {m.year ? <div className="text-2xs text-muted">{m.year}</div> : null}
                   </button>
                 ))}
-              </div>
+              </Carousel>
             </div>
           ))}
       </div>

frontend/src/components/PlexPersonView.dom.test.tsx

@@ -5,10 +5,23 @@
 // filter gesture only when no onOpenPerson is wired) and PlexPersonView's render (headshot/name hero,
 // the Movies/Shows sections, and the "filter library by this person" action). i18n is key-passthrough
 // and the api is mocked so the query resolves synchronously in the test.
-import { describe, it, expect, afterEach, vi } from "vitest";
+import { describe, it, expect, afterEach, beforeAll, vi } from "vitest";
 import { render, screen, fireEvent, cleanup } from "@testing-library/react";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 
+beforeAll(() => {
+  // CastStrip now scrolls inside a Carousel, whose useHScroll wires a ResizeObserver; jsdom ships none.
+  class Stub {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() {
+      return [];
+    }
+  }
+  globalThis.ResizeObserver ??= Stub as unknown as typeof ResizeObserver;
+});
+
 vi.mock("react-i18next", async (importOriginal) => {
   const actual = await importOriginal<typeof import("react-i18next")>();
   return { ...actual, useTranslation: () => ({ t: (key: string) => key }) };
@@ -25,7 +38,8 @@ vi.mock("../lib/api", () => ({
   plexFilterCount: () => 0,
 }));
 
-import { CastStrip, PlexPersonView } from "./PlexBrowse";
+import { CastStrip } from "./plexCards";
+import { PlexPersonView } from "./plexViews";
 
 afterEach(cleanup);
 
@@ -71,6 +85,12 @@ describe("PlexPersonView", () => {
     plexPerson.mockResolvedValue({
       name: "Jane Doe",
       photo: null,
+      biography: "A celebrated actor.",
+      birthday: "1970-01-01",
+      place_of_birth: "Springfield",
+      known_for_department: "Acting",
+      also_known_as: ["Janie D"],
+      known_for: [card("kf1", "Famous Film")],
       movies: [card("m1", "Movie One")],
       shows: [card("s1", "Show One", "show")],
     });
@@ -90,13 +110,30 @@ describe("PlexPersonView", () => {
     expect(screen.getByText("plex.person.movies")).toBeTruthy(); // section headings (key passthrough)
     expect(screen.getByText("plex.person.shows")).toBeTruthy();
 
+    // E5 S6 bio hero: department, biography, birth facts, aka.
+    expect(screen.getByText("Acting")).toBeTruthy();
+    expect(screen.getByText("A celebrated actor.")).toBeTruthy();
+    expect(screen.getByText(/1970-01-01/)).toBeTruthy();
+    expect(screen.getByText(/plex\.person\.aka/)).toBeTruthy();
+    expect(screen.getByText(/Janie D/)).toBeTruthy();
+    // "Known for" rail renders its card.
+    expect(screen.getByText("plex.person.knownFor")).toBeTruthy();
+    expect(screen.getAllByText("Famous Film").length).toBeGreaterThan(0);
+
     fireEvent.click(screen.getByText("plex.person.filterBy"));
     expect(onFilter).toHaveBeenCalledWith({ actors: ["Jane Doe"] });
     expect(plexPerson).toHaveBeenCalledWith("Jane Doe");
   });
 
   it("shows the empty message when the person has no titles", async () => {
-    plexPerson.mockResolvedValue({ name: "Nobody", photo: null, movies: [], shows: [] });
+    plexPerson.mockResolvedValue({
+      name: "Nobody",
+      photo: null,
+      also_known_as: [],
+      known_for: [],
+      movies: [],
+      shows: [],
+    });
     wrap(
       <PlexPersonView
         name="Nobody"

frontend/src/components/PlexProvider.tsx

@@ -1,5 +1,5 @@
 import { createContext, useCallback, useContext, useMemo, useState, type ReactNode } from "react";
-import { EMPTY_PLEX_FILTERS, type PlexFilters } from "../lib/api";
+import { coercePlexFilters, EMPTY_PLEX_FILTERS, type PlexFilters } from "../lib/api";
 import { parseSortState, type SortState } from "../lib/columnSort";
 import { parsePlexField, type PlexSearchField } from "../lib/plexSearch";
 import { PLEX_SORT_FALLBACK } from "../lib/plexSort";
@@ -122,10 +122,11 @@ export function PlexProvider({ children }: { children: ReactNode }) {
   const [filtersRaw, setFiltersRaw] = useState<string>(readPlexFiltersRaw);
   const filters = useMemo<PlexFilters>(() => {
     try {
-      // Drop the legacy `sortDir` — direction now lives in the sort SortState. Left here it would leak
-      // into the facets query key and be re-persisted on every filter change.
-      const { sortDir: _drop, ...rest } = JSON.parse(filtersRaw);
-      return { ...EMPTY_PLEX_FILTERS, ...rest };
+      // coercePlexFilters fills defaults, drops the legacy `sortDir` (direction now lives in the sort
+      // SortState — left here it would leak into the facets key and be re-persisted), and migrates the
+      // legacy single `collection`/`collectionTitle` into `collections`/`collectionTitles`. Shared with
+      // the saved-views provider so the localStorage seed and a DB view blob coerce identically.
+      return coercePlexFilters(JSON.parse(filtersRaw));
     } catch {
       return EMPTY_PLEX_FILTERS;
     }

frontend/src/components/PlexScopeToggle.dom.test.tsx

@@ -1,9 +1,10 @@
 // @vitest-environment jsdom
 //
-// Contract of the header library-scope toggle (S3 relocation): it renders the three scopes, marks
-// the current one, and writes the picked scope back to the provider. i18n is key-passthrough and the
-// provider is mocked so the test drives scope directly; SegmentedToggle is a plain button group (no
-// floating-ui), so no observer stubs are needed.
+// Contract of the header library-scope pill (S3 relocation + Piece 2 browse modes): it renders the
+// three library scopes PLUS the Playlist/Collection browse-mode entries, marks the active one, writes a
+// picked scope to the provider, and drives the playlists/collections views through the PlexViewBridge.
+// i18n is key-passthrough and both the provider and the bridge are mocked; SegmentedToggle is a plain
+// button group (no floating-ui), so no observer stubs are needed.
 import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
 import { render, screen, fireEvent, cleanup } from "@testing-library/react";
 
@@ -19,32 +20,70 @@ vi.mock("./PlexProvider", () => ({
   usePlexActions: () => ({ setScope }),
 }));
 
+// The bridge: a controllable current view kind + an open spy.
+const controls = { kind: "discover" as string, open: vi.fn() };
+vi.mock("./PlexViewBridge", () => ({
+  usePlexViewControls: () => controls,
+}));
+
 import PlexScopeToggle from "./PlexScopeToggle";
 
 beforeEach(() => {
   plexState.scope = "both";
+  controls.kind = "discover";
   setScope.mockReset();
+  controls.open.mockReset();
 });
 afterEach(cleanup);
 
+const buttons = () => [
+  ...screen.getByRole("group", { name: "plex.filter.scope" }).querySelectorAll("button"),
+];
+const labels = () => buttons().map((b) => b.textContent);
+const pressed = () =>
+  buttons()
+    .filter((b) => b.getAttribute("aria-pressed") === "true")
+    .map((b) => b.textContent);
+
 describe("PlexScopeToggle", () => {
-  it("renders the three library scopes, current one pressed", () => {
+  it("renders the three scopes plus the two browse modes, the current scope pressed", () => {
     plexState.scope = "movie";
     render(<PlexScopeToggle />);
-    const group = screen.getByRole("group", { name: "plex.filter.scope" });
-    const btns = [...group.querySelectorAll("button")];
-    expect(btns.map((b) => b.textContent)).toEqual([
+    expect(labels()).toEqual([
       "plex.filter.scopeOpt.both",
       "plex.filter.scopeOpt.movie",
       "plex.filter.scopeOpt.show",
+      "plex.filter.scopeOpt.playlists",
+      "plex.filter.scopeOpt.collections",
     ]);
-    const pressed = btns.filter((b) => b.getAttribute("aria-pressed") === "true");
-    expect(pressed.map((b) => b.textContent)).toEqual(["plex.filter.scopeOpt.movie"]);
+    expect(pressed()).toEqual(["plex.filter.scopeOpt.movie"]);
   });
 
-  it("writes the picked scope back to the provider", () => {
+  it("writes a picked scope back to the provider (no view switch when already on a title view)", () => {
     render(<PlexScopeToggle />);
     fireEvent.click(screen.getByRole("button", { name: "plex.filter.scopeOpt.show" }));
     expect(setScope).toHaveBeenCalledWith("show");
+    expect(controls.open).not.toHaveBeenCalled();
+  });
+
+  it("opens the playlists view (not a scope change) for the Playlist mode", () => {
+    render(<PlexScopeToggle />);
+    fireEvent.click(screen.getByRole("button", { name: "plex.filter.scopeOpt.playlists" }));
+    expect(controls.open).toHaveBeenCalledWith({ kind: "playlists" });
+    expect(setScope).not.toHaveBeenCalled();
+  });
+
+  it("marks the Collection mode active when the current view is collections", () => {
+    controls.kind = "collections";
+    render(<PlexScopeToggle />);
+    expect(pressed()).toEqual(["plex.filter.scopeOpt.collections"]);
+  });
+
+  it("returns to the title grid when a scope is picked from a browse mode", () => {
+    controls.kind = "playlists";
+    render(<PlexScopeToggle />);
+    fireEvent.click(screen.getByRole("button", { name: "plex.filter.scopeOpt.movie" }));
+    expect(setScope).toHaveBeenCalledWith("movie");
+    expect(controls.open).toHaveBeenCalledWith({ kind: "grid" });
   });
 });

frontend/src/components/PlexScopeToggle.tsx

@@ -1,25 +1,48 @@
 import { useTranslation } from "react-i18next";
 import SegmentedToggle from "./SegmentedToggle";
 import { usePlex, usePlexActions } from "./PlexProvider";
+import { usePlexViewControls } from "./PlexViewBridge";
 
-// The Plex library scope (both | movie | show) as a compact header control, sitting next to the
-// search box (S3 toolbar relocation — it used to be a sidebar island). Reads/writes the same
-// provider state the sidebar did, so scope stays in sync everywhere; reuses the shared
-// SegmentedToggle and the existing plex.filter.scopeOpt.* labels.
+// The Plex "browse target" as a compact header control next to the search box: the three library
+// scopes (both | movie | show, which browse TITLES) plus two extra entry points — Playlist and
+// Collection — that switch the content area to a grid of the user's playlists / of the collections.
+// The scopes read/write the shared provider state (so scope stays in sync everywhere); the two extra
+// modes drive PlexBrowse's sub-view through the PlexViewBridge. Picking a scope while in a
+// playlists/collections surface returns to the title grid at that scope.
 const SCOPES = ["both", "movie", "show"] as const;
 
 export default function PlexScopeToggle() {
   const { t } = useTranslation();
   const { scope } = usePlex();
   const { setScope } = usePlexActions();
+  const ctl = usePlexViewControls();
+  const inPlaylists = ctl?.kind === "playlists";
+  const inCollections = ctl?.kind === "collections";
+  // The active segment: the browse-mode when in one, else the library scope.
+  const value = inPlaylists ? "playlists" : inCollections ? "collections" : scope;
+
+  const onChange = (v: string) => {
+    if (v === "playlists" || v === "collections") {
+      ctl?.open({ kind: v });
+      return;
+    }
+    setScope(v);
+    // Leaving the playlists/collections surface for a title scope → show the title grid.
+    if (inPlaylists || inCollections) ctl?.open({ kind: "grid" });
+  };
+
   return (
     <div className="pointer-events-auto shrink-0">
       <SegmentedToggle
         size="md"
         ariaLabel={t("plex.filter.scope")}
-        options={SCOPES.map((s) => ({ value: s, label: t(`plex.filter.scopeOpt.${s}`) }))}
-        value={scope}
-        onChange={setScope}
+        options={[
+          ...SCOPES.map((s) => ({ value: s, label: t(`plex.filter.scopeOpt.${s}`) })),
+          { value: "playlists", label: t("plex.filter.scopeOpt.playlists") },
+          { value: "collections", label: t("plex.filter.scopeOpt.collections") },
+        ]}
+        value={value}
+        onChange={onChange}
       />
     </div>
   );

frontend/src/components/PlexSidebar.tsx

@@ -3,17 +3,21 @@ import { qk } from "../lib/queryKeys";
 import { useTranslation } from "react-i18next";
 import { plexLang } from "../i18n";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { Layers, ListMusic, Plus, SlidersHorizontal, X } from "lucide-react";
+import { ListMusic, Plus, SlidersHorizontal, X } from "lucide-react";
 import { api, plexFilterCount, type PlexFilters } from "../lib/api";
-import { defaultLayout, type PanelLayout } from "../lib/panelLayout";
+import { type PanelLayout } from "../lib/panelLayout";
+import { type MediaSourceKind } from "../lib/mediaSource";
 import { useDebounced } from "../lib/useDebounced";
-import { useScrollFade } from "../lib/useScrollFade";
-import SidePanel from "./SidePanel";
-import PanelGroups, { type PanelItem } from "./PanelGroups";
+import FilterRail from "./FilterRail";
+import { type PanelItem } from "./PanelGroups";
 import SegmentedToggle from "./SegmentedToggle";
-import FilterChipGroup, { filterChipClass } from "./FilterChipGroup";
-import { usePlexClearFilters } from "./usePlexActiveFilters";
+import FilterChipGroup from "./FilterChipGroup";
+import Combobox, { type ComboboxOption } from "./Combobox";
+import SavedViewsPopover from "./SavedViewsPopover";
+import PersonalViewsModal from "./PersonalViewsModal";
+import { useSavedViews } from "./SavedViewsProvider";
 import { usePlex, usePlexActions } from "./PlexProvider";
+import { useMe } from "../lib/useMe";
 
 // The Plex module's left filter column — now the shared floating SidePanel with its filter groups
 // as reorderable "islands" (same system as the feed rail). Movie libraries get the full metadata
@@ -27,7 +31,6 @@ type Props = {
   onToggleCollapse: () => void;
 };
 
-const SHOW_OPTS = ["all", "unwatched", "in_progress", "watched"] as const;
 const RATING_STEPS = [5, 6, 7, 8, 9];
 const ADDED_OPTS = ["24h", "1w", "1m", "6m", "1y"] as const;
 const DURATION_BUCKETS: { key: string; min: number | null; max: number | null }[] = [
@@ -66,21 +69,17 @@ export default function PlexSidebar({ layout, setLayout, collapsed, onToggleColl
   // the header search box); this rail is the primary editor of them. Opening a playlist is a
   // hand-off to PlexBrowse via the shared `playlistOpen` slot.
   const { scope, show, filters } = usePlex();
-  const { setShow, setFilters, setPlaylistOpen: onOpenPlaylist } = usePlexActions();
-  const collFade = useScrollFade();
-  const playlistsQ = useQuery({ queryKey: qk.plexPlaylists(), queryFn: () => api.plexPlaylists() });
-  const [newPlaylist, setNewPlaylist] = useState("");
-  const [editing, setEditing] = useState(false);
-  const qc = useQueryClient();
-  async function createPlaylist() {
-    const title = newPlaylist.trim();
-    if (!title) return;
-    const pl = await api.plexCreatePlaylist(title);
-    setNewPlaylist("");
-    qc.invalidateQueries({ queryKey: qk.plexPlaylists() });
-    onOpenPlaylist(pl.id);
-  }
-  const { collectionTitle: _ct, ...facetKey } = filters;
+  const { setFilters } = usePlexActions();
+  const isDemo = useMe().is_demo;
+  // Personal ("saved") views for the Plex module: the rail header icon opens a quick-pick popover, the
+  // title opens the full manager modal (same shared components as the feed). Hidden for the demo account.
+  const { openModal, modalOpen } = useSavedViews();
+  // This rail's media source (the Plex library) — names the abstraction the feed and Plex rails
+  // share; drives the panel layout key. `FilterRail` owns the customize `editing` state now.
+  const source: MediaSourceKind = "plex";
+  // Titles are display-only (chip labels) — keep them OUT of the facet query key so renaming/relabelling
+  // never refetches. collectionMode stays IN the key: any/all changes the result set.
+  const { collectionTitles: _cts, ...facetKey } = filters;
   const lang = plexLang(); // HU/EN genre vocabulary — refetch facets on a language switch
   const facetsQ = useQuery({
     queryKey: qk.plexFacets(scope, show, facetKey, lang),
@@ -90,31 +89,19 @@ export default function PlexSidebar({ layout, setLayout, collapsed, onToggleColl
   });
   const facets = facetsQ.data;
 
-  const [collSearch, setCollSearch] = useState("");
-  const collSearchDeb = useDebounced(collSearch.trim(), 300);
-  const collectionsQ = useQuery({
-    queryKey: qk.plexCollections("union", collSearchDeb),
-    queryFn: () => api.plexCollections(undefined, collSearchDeb || undefined),
-    enabled: !filters.collection,
-  });
-  const collections = collectionsQ.data?.collections ?? [];
-
   const fCount = plexFilterCount(filters);
   // Scope and sort moved to the header / above-the-grid toolbar (S3); the panel badge now counts only
   // the filters that still live in this panel (expanded filters + watch-state).
   const activeCount = fCount + (show !== "all" ? 1 : 0);
-  const anyActive = activeCount > 0;
 
   const patch = (p: Partial<PlexFilters>) => setFilters({ ...filters, ...p });
-  const toggleIn = (arr: string[], v: string) =>
-    arr.includes(v) ? arr.filter((x) => x !== v) : [...arr, v];
-  const clearAll = usePlexClearFilters();
 
   const durBucketKey = DURATION_BUCKETS.find(
     (b) => (filters.durationMin ?? null) === b.min && (filters.durationMax ?? null) === b.max,
   )?.key;
-  const peopleActive =
-    filters.directors.length + filters.actors.length + filters.studios.length > 0;
+  // Directors + actors have no picker (they're added from the detail/cast surfaces) — this section
+  // just lists them as removable chips. Studios now have their own picker section (below).
+  const peopleActive = filters.directors.length + filters.actors.length > 0;
 
   // Group bodies (no title — the PanelGroup card supplies it). Only available groups are pushed,
   // so facet-gated / scope-gated sections drop out cleanly; PanelGroups orders them by the saved
@@ -123,56 +110,7 @@ export default function PlexSidebar({ layout, setLayout, collapsed, onToggleColl
     {
       id: "playlists",
       title: t("plex.playlist.section"),
-      body: (
-        <>
-          <div className="mb-1.5 flex gap-1.5">
-            <input
-              value={newPlaylist}
-              onChange={(e) => setNewPlaylist(e.target.value)}
-              onKeyDown={(e) => e.key === "Enter" && createPlaylist()}
-              placeholder={t("plex.playlist.newPlaceholder")}
-              className="glass-card min-w-0 flex-1 rounded-lg px-2 py-1 text-xs focus:outline-hidden focus:ring-2 focus:ring-accent/40"
-            />
-            <button
-              onClick={createPlaylist}
-              disabled={!newPlaylist.trim()}
-              title={t("plex.playlist.create")}
-              className="glass-card glass-hover shrink-0 rounded-lg p-1.5 disabled:opacity-50"
-            >
-              <Plus className="h-3.5 w-3.5" />
-            </button>
-          </div>
-          {(playlistsQ.data?.playlists ?? []).length === 0 ? (
-            <p className="text-xs text-muted">{t("plex.playlist.none")}</p>
-          ) : (
-            <div className="space-y-0.5">
-              {playlistsQ.data!.playlists.map((p) => (
-                <button
-                  key={p.id}
-                  onClick={() => onOpenPlaylist(p.id)}
-                  className="glass-hover flex w-full items-center gap-2 rounded-sm px-1.5 py-1 text-left text-sm"
-                >
-                  <ListMusic className="h-3.5 w-3.5 shrink-0 text-muted" />
-                  <span className="min-w-0 flex-1 truncate">{p.title}</span>
-                  <span className="shrink-0 text-xs text-muted">{p.item_count}</span>
-                </button>
-              ))}
-            </div>
-          )}
-        </>
-      ),
-    },
-    {
-      id: "watch",
-      title: t("plex.filter.show"),
-      body: (
-        <FilterChipGroup
-          ariaLabel={t("plex.filter.show")}
-          options={SHOW_OPTS.map((s) => ({ value: s, label: t(`plex.filter.showOpt.${s}`) }))}
-          value={show}
-          onChange={setShow}
-        />
-      ),
+      body: <PlaylistPicker />,
     },
     ...(peopleActive
       ? [
@@ -203,13 +141,6 @@ export default function PlexSidebar({ layout, setLayout, collapsed, onToggleColl
                     onRemove={() => patch({ actors: filters.actors.filter((x) => x !== a) })}
                   />
                 ))}
-                {filters.studios.map((s) => (
-                  <RemovableChip
-                    key={`s:${s}`}
-                    label={s}
-                    onRemove={() => patch({ studios: filters.studios.filter((x) => x !== s) })}
-                  />
-                ))}
               </div>
             ),
           },
@@ -218,44 +149,14 @@ export default function PlexSidebar({ layout, setLayout, collapsed, onToggleColl
     {
       id: "collection",
       title: t("plex.filter.collection"),
-      body: filters.collection ? (
-        <div className="flex flex-wrap gap-1.5">
-          <RemovableChip
-            label={filters.collectionTitle || filters.collection}
-            onRemove={() => patch({ collection: null, collectionTitle: null })}
-          />
-        </div>
-      ) : (
-        <div>
-          <input
-            value={collSearch}
-            onChange={(e) => setCollSearch(e.target.value)}
-            placeholder={t("plex.filter.collectionSearch")}
-            className="mb-1.5 w-full rounded-lg border border-border bg-surface px-2 py-1 text-sm focus:outline-hidden focus:ring-2 focus:ring-accent/40"
-          />
-          <div
-            ref={collFade.ref}
-            style={collFade.style}
-            className="flex max-h-56 flex-col gap-0.5 overflow-y-auto no-scrollbar"
-          >
-            {collections.map((c) => (
-              <button
-                key={c.id}
-                onClick={() => patch({ collection: c.id, collectionTitle: c.title })}
-                className="glass-hover flex items-center gap-2 rounded-lg px-2 py-1 text-left text-sm"
-              >
-                <Layers className="w-3.5 h-3.5 shrink-0 text-muted" />
-                <span className="flex-1 truncate">{c.title}</span>
-                <span className="text-xs text-muted">{c.child_count}</span>
-              </button>
-            ))}
-            {collections.length === 0 && (
-              <span className="px-2 py-1 text-xs text-muted">
-                {t("plex.filter.collectionEmpty")}
-              </span>
-            )}
-          </div>
-        </div>
+      body: (
+        <CollectionPicker
+          values={filters.collections}
+          titles={filters.collectionTitles}
+          mode={filters.collectionMode ?? "any"}
+          onChange={(collections, collectionTitles) => patch({ collections, collectionTitles })}
+          onModeChange={(m) => patch({ collectionMode: m })}
+        />
       ),
     },
     {
@@ -281,27 +182,19 @@ export default function PlexSidebar({ layout, setLayout, collapsed, onToggleColl
             body: (
               <>
                 {filters.genres.length > 1 && (
-                  <MatchToggle
-                    mode={filters.genreMode ?? "any"}
-                    onChange={(m) => patch({ genreMode: m })}
-                  />
+                  <div className="mb-1.5">
+                    <MatchToggle
+                      mode={filters.genreMode ?? "any"}
+                      onChange={(m) => patch({ genreMode: m })}
+                    />
+                  </div>
                 )}
-                <div
-                  className="flex flex-wrap gap-1.5"
-                  role="group"
-                  aria-label={t("plex.filter.genre")}
-                >
-                  {facets.genres.map((g) => (
-                    <button
-                      key={g.value}
-                      onClick={() => patch({ genres: toggleIn(filters.genres, g.value) })}
-                      aria-pressed={filters.genres.includes(g.value)}
-                      className={filterChipClass}
-                    >
-                      {g.value}
-                    </button>
-                  ))}
-                </div>
+                <Combobox
+                  label={t("plex.filter.genre")}
+                  options={facets.genres}
+                  selected={filters.genres}
+                  onChange={(next) => patch({ genres: next })}
+                />
               </>
             ),
           },
@@ -377,24 +270,28 @@ export default function PlexSidebar({ layout, setLayout, collapsed, onToggleColl
             id: "contentrating",
             title: t("plex.filter.contentRating"),
             body: (
-              <div
-                className="flex flex-wrap gap-1.5"
-                role="group"
-                aria-label={t("plex.filter.contentRating")}
-              >
-                {facets.content_ratings.map((c) => (
-                  <button
-                    key={c.value}
-                    onClick={() =>
-                      patch({ contentRatings: toggleIn(filters.contentRatings, c.value) })
-                    }
-                    aria-pressed={filters.contentRatings.includes(c.value)}
-                    className={filterChipClass}
-                  >
-                    {c.value}
-                  </button>
-                ))}
-              </div>
+              <Combobox
+                label={t("plex.filter.contentRating")}
+                options={facets.content_ratings}
+                selected={filters.contentRatings}
+                onChange={(next) => patch({ contentRatings: next })}
+              />
+            ),
+          },
+        ]
+      : []),
+    ...(facets && facets.studios.length > 0
+      ? [
+          {
+            id: "studio",
+            title: t("plex.filter.studio"),
+            body: (
+              <Combobox
+                label={t("plex.filter.studio")}
+                options={facets.studios}
+                selected={filters.studios}
+                onChange={(next) => patch({ studios: next })}
+              />
             ),
           },
         ]
@@ -402,30 +299,166 @@ export default function PlexSidebar({ layout, setLayout, collapsed, onToggleColl
   ];
 
   return (
-    <SidePanel
-      title={t("sidebar.filters")}
-      icon={<SlidersHorizontal className="w-4 h-4" />}
-      count={activeCount}
-      collapsed={collapsed}
-      onToggleCollapse={onToggleCollapse}
-      editing={editing}
-      onToggleEditing={() => setEditing((e) => !e)}
-      onReset={() => setLayout(defaultLayout("plex"))}
-      editHint={t("sidebar.editHint")}
-      actions={
-        anyActive ? (
-          <button
-            onClick={clearAll}
-            className="inline-flex items-center gap-1 text-xs text-muted hover:text-accent transition px-1 whitespace-nowrap"
-          >
-            <X className="w-3.5 h-3.5" />
-            {t("plex.filter.clearAll")}
-          </button>
-        ) : undefined
+    <>
+      <FilterRail
+        kind={source}
+        title={t("sidebar.filters")}
+        icon={<SlidersHorizontal className="w-4 h-4" />}
+        count={activeCount}
+        collapsed={collapsed}
+        onToggleCollapse={onToggleCollapse}
+        layout={layout}
+        setLayout={setLayout}
+        items={items}
+        // The Plex widgets are simple label + control rows now, not collapsible islands (matches the
+        // feed rail). The rail's own "Clear all" is dropped too — the chip row above the grid owns it.
+        collapsible={false}
+        // Saved ("personal") views: header icon → quick-pick popover, title → the manager modal. Hidden
+        // for the demo account. Same shared components as the feed rail (SavedViewsProvider switches source).
+        iconExpanded={
+          isDemo ? undefined : (
+            <SavedViewsPopover trigger={<SlidersHorizontal className="w-4 h-4" />} />
+          )
+        }
+        onTitleClick={isDemo ? undefined : openModal}
+        titleActionLabel={isDemo ? undefined : t("views.manageTitle")}
+      />
+      {/* The manager modal lives here (rail is always mounted on plex); Modal portals to <body>. */}
+      {modalOpen && <PersonalViewsModal />}
+    </>
+  );
+}
+
+// The playlists section: a combobox that stays compact (just a field + chevron) until opened, instead
+// of an always-expanded list that grew the rail with every playlist. Picking a playlist opens it (the
+// PlexBrowse `playlistOpen` hand-off); typing a name that doesn't exist yet offers a "Create …" row so
+// you can still add one — the same reuse-the-Combobox idea as the feed's "Your tags" widget. `selected`
+// stays empty: this picks an action (open / create), it doesn't hold a persistent selection.
+const CREATE_PLAYLIST = "__create__";
+function PlaylistPicker() {
+  const { t } = useTranslation();
+  const { setPlaylistOpen: onOpenPlaylist } = usePlexActions();
+  const qc = useQueryClient();
+  const [query, setQuery] = useState("");
+  const playlistsQ = useQuery({ queryKey: qk.plexPlaylists(), queryFn: () => api.plexPlaylists() });
+  const playlists = playlistsQ.data?.playlists ?? [];
+
+  const q = query.trim();
+  const ql = q.toLowerCase();
+  const matches = ql ? playlists.filter((p) => p.title.toLowerCase().includes(ql)) : playlists;
+  const exact = playlists.some((p) => p.title.toLowerCase() === ql);
+  const options: ComboboxOption[] = [
+    ...matches.map((p) => ({ value: `pl:${p.id}`, label: p.title, count: p.item_count })),
+    // Offer to create only when the typed name isn't already a playlist.
+    ...(q && !exact ? [{ value: CREATE_PLAYLIST, label: q }] : []),
+  ];
+
+  async function createPlaylist(title: string) {
+    const pl = await api.plexCreatePlaylist(title);
+    qc.invalidateQueries({ queryKey: qk.plexPlaylists() });
+    onOpenPlaylist(pl.id);
+  }
+
+  return (
+    <Combobox
+      label={t("plex.playlist.section")}
+      multiple={false}
+      clientFilter={false} // we build `options` (incl. the create row) against the query ourselves
+      options={options}
+      selected={[]}
+      query={query}
+      onQueryChange={setQuery}
+      placeholder={t("plex.playlist.pickerPlaceholder")}
+      emptyText={t("plex.playlist.none")}
+      renderOption={(o) =>
+        o.value === CREATE_PLAYLIST ? (
+          <>
+            <Plus className="h-3.5 w-3.5 shrink-0 text-accent" />
+            <span className="flex-1 truncate">
+              {t("plex.playlist.createNamed", { name: o.label })}
+            </span>
+          </>
+        ) : (
+          <>
+            <ListMusic className="h-3.5 w-3.5 shrink-0 text-muted" />
+            <span className="flex-1 truncate">{o.label}</span>
+            {o.count != null && (
+              <span className="shrink-0 text-2xs tabular-nums text-muted">{o.count}</span>
+            )}
+          </>
+        )
       }
-    >
-      <PanelGroups items={items} layout={layout} setLayout={setLayout} editing={editing} />
-    </SidePanel>
+      onChange={(next) => {
+        const v = next[0];
+        if (!v) return;
+        if (v === CREATE_PLAYLIST) createPlaylist(q);
+        else onOpenPlaylist(Number(v.slice(3)));
+      }}
+    />
+  );
+}
+
+// The collection filter (E5 S7 → combobox; now multi-select): a combi-input matching the genre/studio
+// pickers, its vocabulary searched SERVER-side (the union can run to hundreds). The generic <Combobox>
+// owns the field/keyboard/ARIA + the any/all match footer; this wrapper owns the query→fetch (gated on
+// `open`) and maps collections to options. A title can belong to several collections, so multiple can
+// be picked and combined with Any/All. Titles are carried alongside the ids for the active-filter chips.
+function CollectionPicker({
+  values,
+  titles,
+  mode,
+  onChange,
+  onModeChange,
+}: {
+  values: string[];
+  titles: Record<string, string> | undefined;
+  mode: "any" | "all";
+  onChange: (values: string[], titles: Record<string, string> | undefined) => void;
+  onModeChange: (mode: "any" | "all") => void;
+}) {
+  const { t } = useTranslation();
+  const [open, setOpen] = useState(false);
+  const [search, setSearch] = useState("");
+  const searchDeb = useDebounced(search.trim(), 300);
+  const q = useQuery({
+    queryKey: qk.plexCollections("union", searchDeb),
+    queryFn: () => api.plexCollections(undefined, searchDeb || undefined),
+    enabled: open, // only fetch while the picker is open
+  });
+  const options: ComboboxOption[] = (q.data?.collections ?? []).map((c) => ({
+    value: c.id,
+    label: c.title,
+    count: c.child_count ?? undefined,
+  }));
+  // Combine the fetched labels with the ones already stored so the trip through onChange keeps every
+  // selected collection's title (the fetched list is narrowed by the current search).
+  const labelMap: Record<string, string> = { ...titles };
+  for (const o of options) if (o.label) labelMap[o.value] = o.label;
+
+  return (
+    <Combobox
+      label={t("plex.filter.collection")}
+      clientFilter={false} // the server already narrows to `search`
+      options={options}
+      selected={values}
+      selectedLabels={titles}
+      query={search}
+      onQueryChange={setSearch}
+      onOpenChange={setOpen}
+      loading={q.isFetching}
+      placeholder={t("plex.filter.collectionSearch")}
+      emptyText={t("plex.filter.collectionEmpty")}
+      matchMode={mode === "all" ? "and" : "or"}
+      onMatchModeChange={(m) => onModeChange(m === "and" ? "all" : "any")}
+      onChange={(next) => {
+        // Carry only the selected ids' titles forward (drop titles for de-selected ones). Collapse an
+        // empty map to undefined so a clear-all key-matches the pristine state (an empty {} still hashes
+        // differently from an absent key), mirroring the chip-row remove handler.
+        const nextTitles: Record<string, string> = {};
+        for (const id of next) nextTitles[id] = labelMap[id] ?? titles?.[id] ?? id;
+        onChange(next, next.length ? nextTitles : undefined);
+      }}
+    />
   );
 }
 

frontend/src/components/PlexViewBridge.tsx

@@ -0,0 +1,32 @@
+import { createContext, useContext, useState, type ReactNode } from "react";
+import { type Sub } from "./plexSubUrl";
+
+// A one-way bridge so the always-mounted Header can host the Plex Discover ⟷ Browse toggle even though
+// the sub-view state lives in (and is owned by) the plex-only PlexBrowse. PlexBrowse PUBLISHES its
+// current top-level view + opener here (on mount and on view change) and clears it on unmount; the
+// Header READS it to render the toggle beside the library-scope pill.
+//
+// Why a bridge and not a global sub-view provider: PlexBrowse's `useHistorySubview` REMOUNTS every time
+// you enter the plex page, re-seeding the view from history (a page switch clears ?v + drops _sub, so
+// each plex entry starts at the Discover root). Lifting that hook to an always-mounted provider would
+// lose the remount and let the view go stale across navigation. Keeping it in PlexBrowse preserves the
+// reseed; the bridge only mirrors the small slice the header needs.
+export type PlexViewControls = {
+  kind: Sub["kind"]; // the current top-level plex view — the header controls derive their state from it
+  open: (v: Sub) => void;
+};
+
+const ReadCtx = createContext<PlexViewControls | null>(null);
+const PublishCtx = createContext<(c: PlexViewControls | null) => void>(() => {});
+
+export function PlexViewBridge({ children }: { children: ReactNode }) {
+  const [controls, setControls] = useState<PlexViewControls | null>(null);
+  return (
+    <PublishCtx.Provider value={setControls}>
+      <ReadCtx.Provider value={controls}>{children}</ReadCtx.Provider>
+    </PublishCtx.Provider>
+  );
+}
+
+export const usePlexViewControls = () => useContext(ReadCtx);
+export const usePublishPlexView = () => useContext(PublishCtx);

frontend/src/components/PlexViewToggle.dom.test.tsx

@@ -0,0 +1,65 @@
+// @vitest-environment jsdom
+//
+// Contract of the header Discover ⟷ Browse toggle. The floating header wrapper is pointer-events-none,
+// so the toggle MUST re-enable pointer events on its root or it is click-dead (the bug this test guards
+// against). Also: it only renders on the two title-browse views, marks the active one, and drives
+// PlexBrowse's sub-view through the bridge. i18n is key-passthrough; the bridge is mocked.
+import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  return { ...actual, useTranslation: () => ({ t: (key: string) => key }) };
+});
+
+const controls = { kind: "discover" as string, open: vi.fn() };
+vi.mock("./PlexViewBridge", () => ({
+  usePlexViewControls: () => controls,
+}));
+
+import PlexViewToggle from "./PlexViewToggle";
+
+beforeEach(() => {
+  controls.kind = "discover";
+  controls.open.mockReset();
+});
+afterEach(cleanup);
+
+describe("PlexViewToggle", () => {
+  it("re-enables pointer events on its root (the header wrapper is pointer-events-none)", () => {
+    const { container } = render(<PlexViewToggle />);
+    // Without this class the whole toggle is click-dead inside the pointer-events-none header.
+    expect(container.querySelector(".pointer-events-auto")).not.toBeNull();
+  });
+
+  it("renders the two options with the current view pressed", () => {
+    render(<PlexViewToggle />);
+    const btns = [
+      ...screen.getByRole("group", { name: "plex.view.label" }).querySelectorAll("button"),
+    ];
+    expect(btns.map((b) => b.textContent)).toEqual(["plex.discover.tab", "plex.view.browse"]);
+    const pressed = btns
+      .filter((b) => b.getAttribute("aria-pressed") === "true")
+      .map((b) => b.textContent);
+    expect(pressed).toEqual(["plex.discover.tab"]);
+  });
+
+  it("opens the grid view when Browse is picked", () => {
+    render(<PlexViewToggle />);
+    fireEvent.click(screen.getByRole("button", { name: "plex.view.browse" }));
+    expect(controls.open).toHaveBeenCalledWith({ kind: "grid" });
+  });
+
+  it("opens the discover view when Discover is picked from the grid", () => {
+    controls.kind = "grid";
+    render(<PlexViewToggle />);
+    fireEvent.click(screen.getByRole("button", { name: "plex.discover.tab" }));
+    expect(controls.open).toHaveBeenCalledWith({ kind: "discover" });
+  });
+
+  it("renders nothing on a deeper view (no Discover/Browse choice there)", () => {
+    controls.kind = "playlists";
+    const { container } = render(<PlexViewToggle />);
+    expect(container.firstChild).toBeNull();
+  });
+});

frontend/src/components/PlexViewToggle.tsx

@@ -0,0 +1,30 @@
+import { useTranslation } from "react-i18next";
+import SegmentedToggle from "./SegmentedToggle";
+import { usePlexViewControls } from "./PlexViewBridge";
+
+// The Discover ⟷ Browse switch, hosted in the header next to the library-scope pill (All/Movies/Shows).
+// It reflects + drives PlexBrowse's top-level sub-view through the PlexViewBridge, and hides itself on
+// the deeper views (a show/info/person page has no Discover/Browse choice).
+export default function PlexViewToggle() {
+  const { t } = useTranslation();
+  const ctl = usePlexViewControls();
+  // Only the two title-browse views host the Discover/Browse choice; deeper views (show/info/person/…)
+  // and the playlists/collections browse surfaces hide it.
+  if (!ctl || (ctl.kind !== "discover" && ctl.kind !== "grid")) return null;
+  // The floating header wrapper is pointer-events-none (so clicks fall through its empty area to the
+  // content below); every interactive child must re-enable pointer events or it is click-dead — the
+  // sibling PlexScopeToggle does the same.
+  return (
+    <SegmentedToggle
+      size="md"
+      className="pointer-events-auto shrink-0"
+      ariaLabel={t("plex.view.label")}
+      options={[
+        { value: "discover", label: t("plex.discover.tab") },
+        { value: "grid", label: t("plex.view.browse") },
+      ]}
+      value={ctl.kind === "discover" ? "discover" : "grid"}
+      onChange={(v) => ctl.open(v === "discover" ? { kind: "discover" } : { kind: "grid" })}
+    />
+  );
+}

frontend/src/components/PosterTile.tsx

@@ -0,0 +1,61 @@
+import { type ReactNode } from "react";
+import { hueOf, hueTileGradient } from "../lib/hueTile";
+
+// A browse tile split in two: the TOP half shows up to 2 montage posters (from /api/plex/image/{key}),
+// the BOTTOM half is a solid colour-hash band that carries the label — so the text is always readable
+// (a full-bleed poster collage drowned it). A group with no art falls back to an all-colour tile, never
+// blank. Shared by the Discover genre tiles and the Playlist/Collection browse tiles.
+export default function PosterTile({
+  title,
+  subtitle,
+  topRight,
+  art,
+  onClick,
+  className,
+}: {
+  title: string;
+  subtitle?: ReactNode; // a bottom sub-line under the title (e.g. "12 items · 4h 30m")
+  topRight?: ReactNode; // top-right corner content on the colour band (e.g. an icon)
+  art?: string[]; // up to 2 poster rating_keys; fewer/none falls back to the colour hash
+  onClick: () => void;
+  className?: string; // caller sets the height (e.g. "h-20" / "h-28")
+}) {
+  const posters = (art ?? []).slice(0, 2);
+  const band = hueTileGradient(hueOf(title));
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      title={title}
+      className={`glass-hover group relative flex flex-col overflow-hidden rounded-xl text-left transition ${className ?? ""}`}
+    >
+      {/* Top half: 2 montage posters, or the colour hash when a group has no art. */}
+      <div
+        className="grid h-1/2 min-h-0 grid-cols-2"
+        aria-hidden
+        style={posters.length === 0 ? { background: band } : undefined}
+      >
+        {posters.length > 0 &&
+          [0, 1].map((i) =>
+            posters[i] ? (
+              <img
+                key={i}
+                src={`/api/plex/image/${posters[i]}`}
+                alt=""
+                loading="lazy"
+                className="h-full w-full object-cover"
+              />
+            ) : (
+              <div key={i} style={{ background: hueTileGradient(hueOf(title + i)) }} />
+            ),
+          )}
+      </div>
+      {/* Bottom half: solid colour band — the label lives here so it stays readable over any art. */}
+      <div className="relative flex flex-1 flex-col justify-end p-2.5" style={{ background: band }}>
+        {topRight != null && <span className="absolute right-2 top-2">{topRight}</span>}
+        <div className="truncate text-sm font-semibold text-white drop-shadow">{title}</div>
+        {subtitle != null && <div className="truncate text-2xs text-white/80">{subtitle}</div>}
+      </div>
+    </button>
+  );
+}

frontend/src/components/SavedViewsPopover.tsx

@@ -0,0 +1,84 @@
+import { useState, type ReactNode } from "react";
+import { useTranslation } from "react-i18next";
+import { Bookmark, Check, Settings2 } from "lucide-react";
+import { PopoverItem, PopoverSurface, useAnchoredPopover } from "./AnchoredPopover";
+import { useSavedViews } from "./SavedViewsProvider";
+
+// The saved-views quick-picker. The filter-panel header's icon (and the toolbar's view chip) use it as
+// their trigger: click → a popover list of the user's saved views (apply on click, the active one
+// checked) + a "Manage views…" entry that opens the Personal Views modal, where the editing lives.
+export default function SavedViewsPopover({
+  trigger,
+  className,
+  ariaLabel,
+  placement = "bottom-start",
+}: {
+  trigger: ReactNode;
+  className?: string;
+  ariaLabel?: string;
+  placement?: "bottom-start" | "bottom-end";
+}) {
+  const { t } = useTranslation();
+  const { views, activeViewId, apply, openModal } = useSavedViews();
+  const [open, setOpen] = useState(false);
+  const pop = useAnchoredPopover({ open, onOpenChange: setOpen, placement });
+  const label = ariaLabel ?? t("views.saved");
+  return (
+    <>
+      <button
+        type="button"
+        ref={pop.refs.setReference}
+        {...pop.getReferenceProps()}
+        aria-label={label}
+        className={className ?? "shrink-0 flex text-accent transition hover:text-fg"}
+      >
+        {trigger}
+      </button>
+      <PopoverSurface
+        popover={pop}
+        ariaLabel={label}
+        className="glass-menu min-w-56 rounded-xl p-1.5 shadow-lg animate-[popIn_0.16s_ease]"
+      >
+        {views.length === 0 ? (
+          <p className="px-2 py-1.5 text-2xs leading-snug text-muted">{t("views.empty")}</p>
+        ) : (
+          <div role="group" aria-label={label}>
+            {views.map((v) => (
+              <PopoverItem
+                key={v.id}
+                role="menuitemradio"
+                checked={v.id === activeViewId}
+                onSelect={() => {
+                  apply(v);
+                  setOpen(false);
+                }}
+                label={v.name}
+                className={`flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm transition ${
+                  v.id === activeViewId ? "text-fg" : "text-muted"
+                }`}
+              >
+                <Bookmark className="h-3.5 w-3.5 shrink-0 text-muted" aria-hidden="true" />
+                <span className="flex-1 truncate">{v.name}</span>
+                {v.id === activeViewId && <Check className="h-3.5 w-3.5 shrink-0 text-accent" />}
+              </PopoverItem>
+            ))}
+          </div>
+        )}
+        <div className="mt-1 border-t border-border pt-1">
+          <PopoverItem
+            role="menuitem"
+            onSelect={() => {
+              openModal();
+              setOpen(false);
+            }}
+            label={t("views.manage")}
+            className="flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm text-muted transition hover:text-fg"
+          >
+            <Settings2 className="h-3.5 w-3.5 shrink-0" aria-hidden="true" />
+            <span className="flex-1">{t("views.manage")}</span>
+          </PopoverItem>
+        </div>
+      </PopoverSurface>
+    </>
+  );
+}

frontend/src/components/SavedViewsProvider.tsx

@@ -0,0 +1,243 @@
+import { createContext, useContext, useEffect, useMemo, useState, type ReactNode } from "react";
+import { useTranslation } from "react-i18next";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { qk } from "../lib/queryKeys";
+import {
+  api,
+  coercePlexFilters,
+  coerceTagModes,
+  getActiveAccount,
+  plexFiltersSignature,
+  type FeedFilters,
+  type PlexFilters,
+  type SavedView,
+} from "../lib/api";
+import { filtersToParams } from "../lib/urlState";
+import { preferSticky } from "../lib/savedViews";
+import { notifyActionError } from "../lib/actionErrors";
+import { accountKey, LS, writeJSON } from "../lib/storage";
+import { useConfirm } from "./ConfirmProvider";
+import { useNavigation } from "./NavigationProvider";
+import { useFeedFilters, useFeedFiltersActions } from "./FeedFiltersProvider";
+import { usePlex, usePlexActions } from "./PlexProvider";
+
+// Saved "smart views" now serve TWO modules — the feed and Plex — keyed by `source`. This one provider
+// switches which module it operates on by the active page (both filter providers are global, so it can
+// read either), so the shared UI (popover / modal / chip) works on the feed page against feed views and
+// on the plex page against plex views without a second provider or an App-layout change.
+
+// A saved view's `filters` is an opaque JSON blob from the DB; coerce it to the module's shape before it
+// reaches app state or a serializer (an older build's dropped field just falls away — NOT a migration).
+export const asFilters = (raw: FeedFilters): FeedFilters => ({
+  ...raw,
+  tags: raw.tags ?? [],
+  channelIds: raw.channelIds ?? [],
+  tagModes: coerceTagModes(raw),
+});
+
+type ViewSource = "feed" | "plex";
+
+// The per-source wiring the generic logic runs on: the live filters, how to apply a view's, a stable
+// signature for matching, coercion, and what to strip before saving (the feed's transient shuffle seed).
+interface ViewConfig {
+  source: ViewSource;
+  filters: Record<string, unknown>;
+  setFilters: (f: Record<string, unknown>) => void;
+  keyOf: (f: Record<string, unknown>) => string;
+  asFilters: (raw: Record<string, unknown>) => Record<string, unknown>;
+  stripForSave: (f: Record<string, unknown>) => Record<string, unknown>;
+  /** Feed only: mirror the default view's filters to localStorage so it seeds before the network returns. */
+  syncDefaultMirror?: (views: SavedView[]) => void;
+}
+
+const feedKeyOf = (f: Record<string, unknown>) =>
+  filtersToParams(asFilters(f as unknown as FeedFilters)).toString();
+const plexKeyOf = (f: Record<string, unknown>) => plexFiltersSignature(coercePlexFilters(f));
+
+// Mirror the feed default view's filters to localStorage (read by FeedFiltersProvider on load).
+function syncFeedDefaultMirror(views: SavedView[]): void {
+  const key = accountKey(LS.defaultViewFilters, getActiveAccount());
+  if (!key) return;
+  const def = views.find((v) => v.is_default);
+  writeJSON(key, def ? def.filters : null);
+}
+
+export interface SavedViewsContext {
+  /** Which module these views belong to — the shared UI branches its filter-describer on it. */
+  source: ViewSource;
+  views: SavedView[];
+  loading: boolean;
+  activeViewId: number | null;
+  displayView: SavedView | null;
+  isDirty: boolean;
+  modalOpen: boolean;
+  openModal: () => void;
+  closeModal: () => void;
+  apply: (v: SavedView) => void;
+  clearActive: () => void;
+  create: (name: string) => Promise<boolean>;
+  rename: (id: number, name: string) => Promise<boolean>;
+  toggleDefault: (v: SavedView) => Promise<void>;
+  remove: (v: SavedView) => Promise<boolean>;
+  reorder: (nextIds: number[]) => Promise<void>;
+}
+
+const Ctx = createContext<SavedViewsContext | null>(null);
+
+export function SavedViewsProvider({ children }: { children: ReactNode }) {
+  const { t } = useTranslation();
+  const qc = useQueryClient();
+  const confirm = useConfirm();
+  const { page } = useNavigation();
+
+  // Both filter providers are global — read both, then use the one the active page owns.
+  const feedFilters = useFeedFilters();
+  const { setFilters: setFeedFilters } = useFeedFiltersActions();
+  const { filters: plexFilters } = usePlex();
+  const { setFilters: setPlexFilters } = usePlexActions();
+
+  const cfg: ViewConfig = useMemo(() => {
+    if (page === "plex") {
+      return {
+        source: "plex",
+        filters: plexFilters as unknown as Record<string, unknown>,
+        setFilters: (f) => setPlexFilters(f as unknown as PlexFilters),
+        keyOf: plexKeyOf,
+        asFilters: (raw) => coercePlexFilters(raw) as unknown as Record<string, unknown>,
+        stripForSave: (f) => f, // Plex has no transient field to drop
+      };
+    }
+    return {
+      source: "feed",
+      filters: feedFilters as unknown as Record<string, unknown>,
+      setFilters: (f) => setFeedFilters(f as unknown as FeedFilters),
+      keyOf: feedKeyOf,
+      asFilters: (raw) =>
+        asFilters(raw as unknown as FeedFilters) as unknown as Record<string, unknown>,
+      // Strip the transient shuffle seed so a saved "shuffle" view re-rolls fresh on apply.
+      stripForSave: (f) => {
+        const { seed: _seed, ...rest } = f;
+        return rest;
+      },
+      syncDefaultMirror: syncFeedDefaultMirror,
+    };
+  }, [page, feedFilters, plexFilters, setFeedFilters, setPlexFilters]);
+
+  const source = cfg.source;
+  const viewsQuery = useQuery({
+    queryKey: qk.savedViews(source),
+    queryFn: () => api.savedViews(source),
+  });
+  const views = useMemo(() => viewsQuery.data ?? [], [viewsQuery.data]);
+
+  const [stickyId, setStickyId] = useState<number | null>(null);
+  const [modalOpen, setModalOpen] = useState(false);
+
+  // Switching modules (feed ⟷ plex) starts fresh: a feed view can't be the sticky/active one on plex,
+  // and a feed modal shouldn't linger open on plex.
+  useEffect(() => {
+    setStickyId(null);
+    setModalOpen(false);
+  }, [source]);
+
+  // Feed only: keep the default-view mirror (read on load) in sync with the server state. Depend on the
+  // mirror fn (a module-stable ref, or undefined for plex) NOT the whole `cfg` object — cfg re-memoizes
+  // on every live filter edit, which would fire this synchronous localStorage write far beyond its intent.
+  const syncMirror = cfg.syncDefaultMirror;
+  useEffect(() => {
+    if (viewsQuery.data) syncMirror?.(viewsQuery.data);
+  }, [viewsQuery.data, syncMirror]);
+
+  const currentKey = cfg.keyOf(cfg.filters);
+  const activeView = useMemo(
+    () =>
+      preferSticky(
+        views.filter((v) => cfg.keyOf(v.filters) === currentKey),
+        stickyId,
+      ),
+    [views, currentKey, stickyId, cfg],
+  );
+  useEffect(() => {
+    if (activeView) setStickyId(activeView.id);
+  }, [activeView]);
+
+  const stickyView = useMemo(
+    () => (stickyId == null ? null : (views.find((v) => v.id === stickyId) ?? null)),
+    [views, stickyId],
+  );
+  const displayView = activeView ?? stickyView;
+  const isDirty = displayView != null && activeView == null;
+
+  const refresh = () => qc.invalidateQueries({ queryKey: qk.savedViews(source) });
+  async function runViewMutation(fn: () => Promise<unknown>, failMsg: string): Promise<boolean> {
+    try {
+      await fn();
+      return true;
+    } catch (e) {
+      notifyActionError(e, failMsg);
+      return false;
+    } finally {
+      refresh();
+    }
+  }
+
+  const value: SavedViewsContext = {
+    source,
+    views,
+    loading: viewsQuery.isLoading,
+    activeViewId: activeView?.id ?? null,
+    displayView,
+    isDirty,
+    modalOpen,
+    openModal: () => setModalOpen(true),
+    closeModal: () => setModalOpen(false),
+    apply: (v) => {
+      cfg.setFilters(cfg.asFilters(v.filters));
+      setStickyId(v.id);
+    },
+    clearActive: () => setStickyId(null),
+    create: async (name) => {
+      const clean = name.trim();
+      if (!clean) return false;
+      return runViewMutation(
+        () => api.createView(clean, cfg.stripForSave(cfg.filters), source),
+        t("views.actionFailed"),
+      );
+    },
+    rename: async (id, name) => {
+      const next = name.trim();
+      if (!next) return false;
+      return runViewMutation(() => api.updateView(id, { name: next }), t("views.actionFailed"));
+    },
+    toggleDefault: (v) =>
+      runViewMutation(
+        () => api.updateView(v.id, { is_default: !v.is_default }),
+        t("views.actionFailed"),
+      ).then(() => undefined),
+    remove: async (v) => {
+      const ok = await confirm({
+        message: t("views.deleteConfirm", { name: v.name }),
+        confirmLabel: t("views.delete"),
+        danger: true,
+      });
+      if (!ok) return false;
+      if (stickyId === v.id) setStickyId(null);
+      return runViewMutation(() => api.deleteView(v.id), t("views.actionFailed"));
+    },
+    reorder: async (nextIds) => {
+      qc.setQueryData<SavedView[]>(
+        qk.savedViews(source),
+        nextIds.map((id) => views.find((v) => v.id === id)!).filter(Boolean),
+      );
+      await runViewMutation(() => api.reorderViews(nextIds), t("views.reorderFailed"));
+    },
+  };
+
+  return <Ctx.Provider value={value}>{children}</Ctx.Provider>;
+}
+
+export function useSavedViews(): SavedViewsContext {
+  const ctx = useContext(Ctx);
+  if (!ctx) throw new Error("useSavedViews must be used within a SavedViewsProvider");
+  return ctx;
+}

frontend/src/components/SavedViewsWidget.tsx

@@ -1,366 +0,0 @@
-import { useEffect, useState } from "react";
-import { useTranslation } from "react-i18next";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { qk } from "../lib/queryKeys";
-import { BookmarkPlus, Check, GripVertical, Pencil, Share2, Star, Trash2, X } from "lucide-react";
-import {
-  closestCenter,
-  DndContext,
-  PointerSensor,
-  useSensor,
-  useSensors,
-  type DragEndEvent,
-} from "@dnd-kit/core";
-import {
-  arrayMove,
-  SortableContext,
-  useSortable,
-  verticalListSortingStrategy,
-} from "@dnd-kit/sortable";
-import { CSS } from "@dnd-kit/utilities";
-import { api, getActiveAccount, type FeedFilters, type SavedView } from "../lib/api";
-import { filtersToParams, shareUrl } from "../lib/urlState";
-import { notify } from "../lib/notifications";
-import { notifyActionError } from "../lib/actionErrors";
-import { copyText } from "../lib/clipboard";
-import { accountKey, LS, writeJSON } from "../lib/storage";
-import { useConfirm } from "./ConfirmProvider";
-
-// Compact, order-independent signature of a filter set (reuses the share serializer, which
-// emits only non-default values and ignores the transient shuffle seed). Used to highlight the
-// saved view that matches the feed's current filters.
-const keyOf = (f: FeedFilters) => filtersToParams(asFilters(f)).toString();
-
-// A saved view's `filters` is a JSON blob straight from the DB — the FeedFilters type says nothing
-// about what an older build actually wrote there, so coerce the array fields before the blob reaches
-// app state or a serializer. Deliberately NOT a migration: a view saved against a dropped field just
-// loses that filter.
-const asFilters = (raw: FeedFilters): FeedFilters => ({
-  ...raw,
-  tags: raw.tags ?? [],
-  channelIds: raw.channelIds ?? [],
-});
-
-function syncDefaultMirror(views: SavedView[]): void {
-  const key = accountKey(LS.defaultViewFilters, getActiveAccount());
-  if (!key) return;
-  const def = views.find((v) => v.is_default);
-  writeJSON(key, def ? def.filters : null);
-}
-
-export default function SavedViewsWidget({
-  filters,
-  onApply,
-}: {
-  filters: FeedFilters;
-  onApply: (f: FeedFilters) => void;
-}) {
-  const { t } = useTranslation();
-  const qc = useQueryClient();
-  const confirm = useConfirm();
-  const viewsQuery = useQuery({ queryKey: qk.savedViews(), queryFn: api.savedViews });
-  const views = viewsQuery.data ?? [];
-  const [naming, setNaming] = useState(false);
-  const [draftName, setDraftName] = useState("");
-  const [renameId, setRenameId] = useState<number | null>(null);
-
-  const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 4 } }));
-
-  // Keep the default-view mirror (read on load) in sync with the server state.
-  useEffect(() => {
-    if (viewsQuery.data) syncDefaultMirror(viewsQuery.data);
-  }, [viewsQuery.data]);
-
-  const refresh = () => qc.invalidateQueries({ queryKey: qk.savedViews() });
-
-  // Run a saved-view mutation with uniform feedback: on failure surface the server's reason instead
-  // of a silent swallow, and always refetch afterwards (which also reverts an optimistic change to
-  // the server's truth). Returns whether it succeeded, so callers can gate success-only side effects
-  // (e.g. closing an editor) and keep the input open — with the user's text — on failure.
-  async function runViewMutation(fn: () => Promise<unknown>, failMsg: string): Promise<boolean> {
-    try {
-      await fn();
-      return true;
-    } catch (e) {
-      notifyActionError(e, failMsg);
-      return false;
-    } finally {
-      refresh();
-    }
-  }
-  const currentKey = keyOf(filters);
-
-  async function save() {
-    const name = draftName.trim();
-    if (!name) return;
-    // Strip the transient shuffle seed so a saved "shuffle" view re-rolls fresh on apply.
-    const { seed: _seed, ...clean } = filters;
-    // Close the naming input only on success, so a failed create keeps the user's typed name.
-    if (await runViewMutation(() => api.createView(name, clean), t("views.actionFailed"))) {
-      setNaming(false);
-      setDraftName("");
-    }
-  }
-
-  async function rename(id: number, name: string) {
-    const next = name.trim();
-    if (!next) {
-      setRenameId(null);
-      return;
-    }
-    // Close the rename editor only on success, so a failed rename stays open for a retry.
-    if (await runViewMutation(() => api.updateView(id, { name: next }), t("views.actionFailed"))) {
-      setRenameId(null);
-    }
-  }
-
-  async function toggleDefault(v: SavedView) {
-    await runViewMutation(
-      () => api.updateView(v.id, { is_default: !v.is_default }),
-      t("views.actionFailed"),
-    );
-  }
-
-  async function remove(v: SavedView) {
-    const ok = await confirm({
-      message: t("views.deleteConfirm", { name: v.name }),
-      confirmLabel: t("views.delete"),
-      danger: true,
-    });
-    if (!ok) return;
-    await runViewMutation(() => api.deleteView(v.id), t("views.actionFailed"));
-  }
-
-  async function share(v: SavedView) {
-    if (await copyText(shareUrl(asFilters(v.filters)))) {
-      notify({ level: "success", message: t("views.shareCopied") });
-    } else {
-      notify({ level: "warning", message: t("sidebar.shareFailed") });
-    }
-  }
-
-  async function onDragEnd(e: DragEndEvent) {
-    const { active, over } = e;
-    if (!over || active.id === over.id) return;
-    const ids = views.map((v) => v.id);
-    const oldIndex = ids.indexOf(active.id as number);
-    const newIndex = ids.indexOf(over.id as number);
-    if (oldIndex < 0 || newIndex < 0) return;
-    const next = arrayMove(ids, oldIndex, newIndex);
-    // Optimistic reorder so the drop sticks visually before the round-trip.
-    qc.setQueryData<SavedView[]>(
-      qk.savedViews(),
-      next.map((id) => views.find((v) => v.id === id)!),
-    );
-    // On failure runViewMutation's refetch reverts the optimistic order to the server's truth;
-    // without the toast the drop would silently snap back with no explanation.
-    await runViewMutation(() => api.reorderViews(next), t("views.reorderFailed"));
-  }
-
-  return (
-    <div className="space-y-2">
-      {views.length === 0 && !naming && (
-        <p className="text-2xs text-muted leading-snug">{t("views.empty")}</p>
-      )}
-
-      <DndContext sensors={sensors} collisionDetection={closestCenter} onDragEnd={onDragEnd}>
-        <SortableContext items={views.map((v) => v.id)} strategy={verticalListSortingStrategy}>
-          <div className="space-y-1">
-            {views.map((v) => (
-              <ViewRow
-                key={v.id}
-                view={v}
-                active={keyOf(v.filters) === currentKey}
-                renaming={renameId === v.id}
-                onApply={() => onApply(asFilters(v.filters))}
-                onStartRename={() => setRenameId(v.id)}
-                onRename={(name) => rename(v.id, name)}
-                onCancelRename={() => setRenameId(null)}
-                onToggleDefault={() => toggleDefault(v)}
-                onShare={() => share(v)}
-                onDelete={() => remove(v)}
-              />
-            ))}
-          </div>
-        </SortableContext>
-      </DndContext>
-
-      {naming ? (
-        <div className="flex items-center gap-1">
-          <input
-            autoFocus
-            value={draftName}
-            onChange={(e) => setDraftName(e.target.value)}
-            onKeyDown={(e) => {
-              if (e.key === "Enter") void save();
-              if (e.key === "Escape") setNaming(false);
-            }}
-            placeholder={t("views.namePlaceholder")}
-            maxLength={80}
-            className="flex-1 min-w-0 bg-surface border border-border rounded-lg px-2 py-1 text-xs focus:outline-hidden focus:ring-2 focus:ring-accent/40"
-          />
-          <button
-            onClick={() => void save()}
-            title={t("views.saveAction")}
-            className="p-1 rounded-lg text-muted hover:text-accent hover:bg-card transition"
-          >
-            <Check className="w-4 h-4" />
-          </button>
-          <button
-            onClick={() => setNaming(false)}
-            title={t("views.cancel")}
-            className="p-1 rounded-lg text-muted hover:text-fg hover:bg-card transition"
-          >
-            <X className="w-4 h-4" />
-          </button>
-        </div>
-      ) : (
-        <button
-          onClick={() => {
-            setDraftName("");
-            setNaming(true);
-          }}
-          className="w-full inline-flex items-center justify-center gap-1.5 text-xs px-2 py-1.5 rounded-lg border border-dashed border-border text-muted hover:text-accent hover:border-accent transition"
-        >
-          <BookmarkPlus className="w-3.5 h-3.5" />
-          {t("views.save")}
-        </button>
-      )}
-    </div>
-  );
-}
-
-function ViewRow({
-  view,
-  active,
-  renaming,
-  onApply,
-  onStartRename,
-  onRename,
-  onCancelRename,
-  onToggleDefault,
-  onShare,
-  onDelete,
-}: {
-  view: SavedView;
-  active: boolean;
-  renaming: boolean;
-  onApply: () => void;
-  onStartRename: () => void;
-  onRename: (name: string) => void;
-  onCancelRename: () => void;
-  onToggleDefault: () => void;
-  onShare: () => void;
-  onDelete: () => void;
-}) {
-  const { t } = useTranslation();
-  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
-    id: view.id,
-  });
-  const [draft, setDraft] = useState(view.name);
-  // Reset the edit draft to the current name each time rename mode opens (so a second rename
-  // doesn't start from a stale value).
-  useEffect(() => {
-    if (renaming) setDraft(view.name);
-  }, [renaming, view.name]);
-  const style = {
-    transform: CSS.Transform.toString(transform),
-    transition,
-    opacity: isDragging ? 0.5 : 1,
-  };
-
-  if (renaming) {
-    return (
-      <div ref={setNodeRef} style={style} className="flex items-center gap-1">
-        <input
-          autoFocus
-          value={draft}
-          onChange={(e) => setDraft(e.target.value)}
-          onKeyDown={(e) => {
-            if (e.key === "Enter") onRename(draft);
-            if (e.key === "Escape") onCancelRename();
-          }}
-          maxLength={80}
-          className="flex-1 min-w-0 bg-surface border border-border rounded-lg px-2 py-1 text-xs focus:outline-hidden focus:ring-2 focus:ring-accent/40"
-        />
-        <button
-          onClick={() => onRename(draft)}
-          title={t("views.saveAction")}
-          className="p-1 rounded-lg text-muted hover:text-accent hover:bg-card transition"
-        >
-          <Check className="w-4 h-4" />
-        </button>
-        <button
-          onClick={onCancelRename}
-          title={t("views.cancel")}
-          className="p-1 rounded-lg text-muted hover:text-fg hover:bg-card transition"
-        >
-          <X className="w-4 h-4" />
-        </button>
-      </div>
-    );
-  }
-
-  return (
-    <div
-      ref={setNodeRef}
-      style={style}
-      className={`group flex items-center gap-0.5 rounded-lg pr-1 ${
-        active ? "bg-accent/10" : "hover:bg-card"
-      }`}
-    >
-      <button
-        {...attributes}
-        {...listeners}
-        title={t("views.reorder")}
-        className="p-1 text-muted/60 hover:text-muted cursor-grab touch-none shrink-0"
-      >
-        <GripVertical className="w-3.5 h-3.5" />
-      </button>
-      <button
-        onClick={onApply}
-        title={t("views.apply")}
-        aria-current={active ? "true" : undefined}
-        className={`flex-1 min-w-0 text-left text-xs py-1 truncate ${
-          active ? "text-accent font-medium" : "text-fg"
-        }`}
-      >
-        {view.name}
-      </button>
-      <div className="flex items-center shrink-0">
-        <button
-          onClick={onToggleDefault}
-          title={view.is_default ? t("views.isDefault") : t("views.makeDefault")}
-          className={`p-1 rounded transition ${
-            view.is_default
-              ? "text-accent"
-              : "text-muted opacity-0 group-hover:opacity-100 group-focus-within:opacity-100 hover:text-accent"
-          }`}
-        >
-          <Star className={`w-3.5 h-3.5 ${view.is_default ? "fill-current" : ""}`} />
-        </button>
-        <button
-          onClick={onShare}
-          title={t("views.share")}
-          className="p-1 rounded-sm text-muted opacity-0 group-hover:opacity-100 group-focus-within:opacity-100 hover:text-fg transition"
-        >
-          <Share2 className="w-3.5 h-3.5" />
-        </button>
-        <button
-          onClick={onStartRename}
-          title={t("views.rename")}
-          className="p-1 rounded-sm text-muted opacity-0 group-hover:opacity-100 group-focus-within:opacity-100 hover:text-fg transition"
-        >
-          <Pencil className="w-3.5 h-3.5" />
-        </button>
-        <button
-          onClick={onDelete}
-          title={t("views.delete")}
-          className="p-1 rounded-sm text-muted opacity-0 group-hover:opacity-100 group-focus-within:opacity-100 hover:text-danger transition"
-        >
-          <Trash2 className="w-3.5 h-3.5" />
-        </button>
-      </div>
-    </div>
-  );
-}

frontend/src/components/Scheduler.tsx

@@ -198,7 +198,7 @@ function JobRow({
                 className="group text-muted font-normal hover:text-accent inline-flex items-center gap-1 transition"
               >
                 · {t("scheduler.everyMin", { count: job.interval_minutes })}
-                <Pencil className="w-3 h-3 opacity-0 group-hover:opacity-100 transition" />
+                <Pencil className="w-3 h-3 reveal transition" />
               </button>
             </Tooltip>
           )}

frontend/src/components/SelectedViewChip.tsx

@@ -0,0 +1,34 @@
+import { useTranslation } from "react-i18next";
+import { Bookmark, ChevronDown } from "lucide-react";
+import SavedViewsPopover from "./SavedViewsPopover";
+import { useSavedViews } from "./SavedViewsProvider";
+
+// The active personal view, shown as the leading pill before the active-filter chip row. Styled like
+// the toolbar's FilterSelect pills; a warn-coloured dot appears when the live filters have diverged
+// from the saved view. Clicking it opens the saved-views picker to switch views. Renders nothing when
+// no view is active (nothing applied and the filters match no saved view).
+export default function SelectedViewChip() {
+  const { t } = useTranslation();
+  const { displayView, isDirty } = useSavedViews();
+  if (!displayView) return null;
+  return (
+    <SavedViewsPopover
+      ariaLabel={t("views.saved")}
+      className="glass-card glass-hover inline-flex items-center gap-1.5 rounded-full border border-border px-3 py-1 text-sm text-fg transition hover:border-accent/60"
+      trigger={
+        <>
+          <Bookmark className="h-3.5 w-3.5 shrink-0 text-accent" aria-hidden="true" />
+          <span className="max-w-40 truncate">{displayView.name}</span>
+          {isDirty && (
+            <span
+              className="h-1.5 w-1.5 shrink-0 rounded-full bg-warn"
+              title={t("views.modified")}
+              aria-label={t("views.modified")}
+            />
+          )}
+          <ChevronDown className="h-3.5 w-3.5 shrink-0 text-muted" aria-hidden="true" />
+        </>
+      }
+    />
+  );
+}

frontend/src/components/SidePanel.tsx

@@ -20,6 +20,9 @@ export default function SidePanel({
   onReset,
   editHint,
   actions,
+  iconExpanded,
+  onTitleClick,
+  titleActionLabel,
   children,
 }: {
   title: string;
@@ -34,6 +37,13 @@ export default function SidePanel({
   editHint?: string;
   // Extra header controls shown when NOT editing (e.g. the feed's Clear all + Share view).
   actions?: ReactNode;
+  // Optional override for the icon in the EXPANDED header only (the collapsed tab keeps the plain
+  // `icon`) — the feed passes its saved-views popover trigger here so the header icon opens the picker.
+  iconExpanded?: ReactNode;
+  // When set, the expanded-header title becomes a button (the feed opens its Personal Views modal).
+  onTitleClick?: () => void;
+  // Accessible name / tooltip describing what onTitleClick does (the plain title text alone doesn't).
+  titleActionLabel?: string;
   children: ReactNode;
 }) {
   const { t } = useTranslation();
@@ -44,14 +54,16 @@ export default function SidePanel({
 
   return (
     // Layout slot: reserves only the tab's gutter when unpinned, so the expanded card overlays
-    // content instead of pushing it. Pinned reserves the full width (in-flow), as before.
+    // content instead of pushing it. Pinned reserves --rail-pinned-w: 16.75rem (in-flow, pushes) on a
+    // full-width page or a narrow window, but 2.25rem (overlay, doesn't push) when the centred content
+    // leaves room for the rail to sit in its left margin — see PageShell. Default 16.75rem = old w-67.
     <div
       // Focus is tracked container-wide (keyboard: tab anywhere inside holds it open). HOVER is NOT
       // on this full-height slot — that made the whole column next to the nav rail a live target, so
       // merely approaching the rail popped the panel open. Hover now lives only on the visible tab
       // handle + the expanded card below, so only pointing AT the tab opens it.
       {...peek.focusHandlers}
-      className={`hidden md:block relative shrink-0 transition-[width] ${pinned ? "w-67" : "w-9"}`}
+      className={`hidden md:block relative shrink-0 transition-[width] ${pinned ? "w-[var(--rail-pinned-w,16.75rem)]" : "w-9"}`}
     >
       {/* The tab: a small handle flush against the nav rail, flat on the docked edge. It stays
           mounted while the card is open — swapping it out from under the pointer would drop the very
@@ -74,7 +86,7 @@ export default function SidePanel({
           </span>
         )}
         <span
-          className="text-2xs font-semibold uppercase tracking-[0.18em] text-muted"
+          className="text-xs font-semibold uppercase tracking-[0.18em] text-muted"
           style={{ writingMode: "vertical-rl", transform: "rotate(180deg)" }}
         >
           {title}
@@ -97,10 +109,21 @@ export default function SidePanel({
             >
               {pinned ? <PinOff className="w-4 h-4" /> : <Pin className="w-4 h-4" />}
             </button>
-            <span className="shrink-0 flex text-accent">{icon}</span>
-            <span className="flex-1 min-w-0 truncate text-xs font-bold uppercase tracking-[0.12em]">
-              {title}
-            </span>
+            {iconExpanded ?? <span className="shrink-0 flex text-accent">{icon}</span>}
+            {onTitleClick ? (
+              <button
+                onClick={onTitleClick}
+                title={titleActionLabel}
+                aria-label={titleActionLabel}
+                className="flex-1 min-w-0 truncate text-left text-sm font-bold uppercase tracking-[0.12em] transition hover:text-accent"
+              >
+                {title}
+              </button>
+            ) : (
+              <span className="flex-1 min-w-0 truncate text-sm font-bold uppercase tracking-[0.12em]">
+                {title}
+              </span>
+            )}
             {count > 0 && (
               <span
                 title={t("sidebar.activeCount", { count })}