kryten-webqueue 0.16.0__tar.gz → 0.18.0__tar.gz

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/CHANGELOG.md

@@ -6,6 +6,27 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 
+## [0.18.0] — 2026-06-17
+
+### Fixed
+
+- **Active scheduled event lingered on the admin page after it ended.** The `active_schedule` row was only removed by the manual "Clear Active Schedule" button — the lock auto-lifted but the row (and its banner) stayed. The queue shadow now clears it automatically on the next poll once the event is genuinely over, via two signals: the last scheduled item has left the queue (event temp items auto-remove after playing), or the estimated end is more than 5 minutes in the past (safety net for a missed boundary or a restart mid-event). The schedules page also hides a well-past banner immediately and re-checks every 15s.
+
+### Added
+
+- **Live admin dashboard.** The admin page now subscribes to the same `/ws` feed as the public queue, so the queue item count and now-playing update without a reload. Job status refreshes every 5s while the tab is visible (jobs are DB-polled, not broadcast), and a fired schedule triggers an immediate jobs refresh.
+
+[0.18.0]: https://github.com/grobertson/kryten-webqueue/releases/tag/v0.18.0
+
+## [0.17.0] — 2026-06-17
+
+### Added
+
+- **Search now combines with category/tag filters.** A free-text search ANDs with the selected category and/or tag instead of ignoring them. `db.search()` / `db.search_count()` accept `category` and `tag`; the `/catalog/search` page and JSON route pass them through and keep the dropdowns populated/selected; `applyFacets()` includes the active facets when a query is present. (Shared `_facet_filter()` SQL helper keeps browse and search behavior identical.)
+- **Clear empty-results messaging.** When a search and/or facet filter returns nothing, the catalog page now explains *why* — naming the active query and filters — and offers one-click escapes ("Search without filters", "Clear filters", "Back to browse") instead of a bare "No items found."
+
+[0.17.0]: https://github.com/grobertson/kryten-webqueue/releases/tag/v0.17.0
+
 ## [0.16.0] — 2026-06-17
 
 ### Added

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryten-webqueue
-Version: 0.16.0
+Version: 0.18.0
 Summary: Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube
 Author: grobertson
 License-Expression: MIT

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/kryten_webqueue/catalog/db.py

@@ -59,6 +59,36 @@ def _hidden_exclusion(alias: str = "c") -> tuple[str, list]:
     return sql, [*HIDDEN_CATEGORY_NAMES, *HIDDEN_TAG_NAMES]
 
 
+def _facet_filter(alias: str, category: str | None, tag: str | None) -> tuple[str, list]:
+    """SQL fragment (+ params) AND-filtering by a category slug and/or tag name.
+
+    Each filter is an ``AND friendly_token IN (...)`` subquery on the catalog row
+    under ``alias``; an absent filter contributes nothing. Shared by browse() and
+    search() so the two paths narrow results identically.
+    """
+    sql = ""
+    params: list = []
+    if category:
+        sql += f"""
+            AND {alias}.friendly_token IN (
+                SELECT cc.friendly_token FROM catalog_categories cc
+                JOIN categories cat ON cc.category_id = cat.id
+                WHERE cat.slug = ?
+            )
+        """
+        params.append(category)
+    if tag:
+        sql += f"""
+            AND {alias}.friendly_token IN (
+                SELECT ct.friendly_token FROM catalog_tags ct
+                JOIN tags t ON ct.tag_id = t.id
+                WHERE t.name = ?
+            )
+        """
+        params.append(tag)
+    return sql, params
+
+
 # Default quality-weighted ordering (see browse() for rationale).
 _DEFAULT_ORDER = """
     ORDER BY
@@ -446,7 +476,8 @@ class Database:
         row = await self._fetch_one(query, params)
         return row["cnt"] if row else 0
 
-    async def search(self, query_text: str, *, page: int = 1, per_page: int = 24, show_hidden: bool = False, sort: str = "default") -> list[dict]:
+    async def search(self, query_text: str, *, category: str | None = None, tag: str | None = None,
+                     page: int = 1, per_page: int = 24, show_hidden: bool = False, sort: str = "default") -> list[dict]:
         sql = """
             SELECT c.friendly_token, c.title, c.duration_sec, c.cover_art_path, c.cover_art_source, c.thumbnail_url, c.manifest_url,
                    rank AS relevance
@@ -464,6 +495,11 @@ class Database:
             excl_sql, excl_params = _hidden_exclusion("c")
             sql += excl_sql
             params.extend(excl_params)
+        # Category/tag facets AND with the text match (same subqueries browse()
+        # uses), so a search can be narrowed by the selected facets.
+        facet_sql, facet_params = _facet_filter("c", category, tag)
+        sql += facet_sql
+        params.extend(facet_params)
         # Relevance is the natural default for a text query; other sort keys let
         # the user reorder the matched set explicitly.
         sql += " ORDER BY rank " if (sort or "default") == "default" else _browse_order_clause(sort)
@@ -471,7 +507,8 @@ class Database:
         params.extend([per_page, (page - 1) * per_page])
         return await self._fetch_all(sql, params)
 
-    async def search_count(self, query_text: str, *, show_hidden: bool = False) -> int:
+    async def search_count(self, query_text: str, *, category: str | None = None, tag: str | None = None,
+                           show_hidden: bool = False) -> int:
         sql = """
             SELECT COUNT(*) as cnt
             FROM catalog_fts fts
@@ -488,6 +525,9 @@ class Database:
             excl_sql, excl_params = _hidden_exclusion("c")
             sql += excl_sql
             params.extend(excl_params)
+        facet_sql, facet_params = _facet_filter("c", category, tag)
+        sql += facet_sql
+        params.extend(facet_params)
         row = await self._fetch_one(sql, params)
         return row["cnt"] if row else 0
 

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/kryten_webqueue/queue/shadow.py

@@ -23,6 +23,19 @@ def _to_seconds(value) -> float:
         return 0.0
 
 
+def _parse_iso(value) -> datetime | None:
+    """Parse an ISO-8601 timestamp to an aware UTC datetime, or None."""
+    if not value:
+        return None
+    try:
+        dt = datetime.fromisoformat(str(value))
+    except (ValueError, TypeError):
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    return dt
+
+
 class QueueShadow:
     """Local mirror of the CyTube playlist state."""
 
@@ -116,6 +129,7 @@ class QueueShadow:
             self._items = new_items
             await self._recalculate_estimated_starts()
             await self._maybe_lift_event_lock()
+            await self._maybe_expire_active_schedule()
 
     async def _maybe_lift_event_lock(self):
         """Auto-lift a scheduled-event lock once its last item begins playing.
@@ -142,6 +156,52 @@ class QueueShadow:
         except (TypeError, ValueError):
             return
 
+    async def _maybe_expire_active_schedule(self):
+        """Clear the active-schedule row once the event is genuinely over.
+
+        The lock auto-lifts when the last scheduled item *starts* (see
+        :meth:`_maybe_lift_event_lock`), but the row itself used to linger so the
+        admin banner kept showing a finished event. This clears it via two
+        signals:
+
+        * **Event-driven (primary):** the last scheduled item has left the queue
+          (event items are temp and auto-remove after playing), and something is
+          still playing — so the event has played out.
+        * **Time safety net:** the estimated end is well in the past (covers a
+          missed boundary, a restart mid-event, or ``last_item_uid`` never being
+          captured).
+        """
+        active = await self._db.get_active_schedule()
+        if not active:
+            return
+
+        # Event-driven: last scheduled item is gone from the queue.
+        last_uid = active.get("last_item_uid")
+        if last_uid is not None and self._now_playing is not None:
+            try:
+                last_uid_int = int(last_uid)
+            except (TypeError, ValueError):
+                last_uid_int = None
+            if last_uid_int is not None:
+                present = False
+                for it in self._items:
+                    try:
+                        if int(it.get("uid")) == last_uid_int:
+                            present = True
+                            break
+                    except (TypeError, ValueError):
+                        continue
+                if not present:
+                    await self._db.clear_active_schedule()
+                    logger.info("Active schedule cleared: last scheduled item has played out")
+                    return
+
+        # Time safety net: estimated end well in the past.
+        end_dt = _parse_iso(active.get("estimated_end_at"))
+        if end_dt is not None and datetime.now(UTC) > end_dt + timedelta(minutes=5):
+            await self._db.clear_active_schedule()
+            logger.info("Active schedule cleared: estimated end passed (stale row)")
+
     def _now_playing_index(self) -> int | None:
         """Index of the currently-playing item within ``self._items``.
 

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/kryten_webqueue/routes/catalog.py

@@ -19,15 +19,19 @@ async def browse(request: Request, category: str | None = None, tag: str | None
 
 
 @router.get("/search")
-async def search(request: Request, q: str = "", page: int = 1, show_hidden: int = 0,
+async def search(request: Request, q: str = "", category: str | None = None, tag: str | None = None,
+                 page: int = 1, show_hidden: int = 0,
                  sort: str = "default", user: dict = Depends(get_current_user)):
-    """Full-text search of catalog."""
+    """Full-text search of catalog, optionally narrowed by category/tag."""
     if not q.strip():
         raise HTTPException(400, "Query required")
     db = request.app.state.db
     show_hidden = bool(show_hidden) and (user.get("rank") or 0) >= 3
-    items = await db.search(q, page=page, show_hidden=show_hidden, sort=sort)
-    return {"items": items, "query": q, "page": page, "sort": sort}
+    items = await db.search(q, category=category, tag=tag, page=page, show_hidden=show_hidden, sort=sort)
+    categories = await db.get_categories(show_hidden=show_hidden)
+    tags = await db.get_tags(show_hidden=show_hidden)
+    return {"items": items, "categories": categories, "tags": tags,
+            "query": q, "active_category": category, "active_tag": tag, "page": page, "sort": sort}
 
 
 @router.get("/item/{friendly_token}")

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/kryten_webqueue/routes/pages.py

@@ -107,6 +107,7 @@ async def catalog_browse_page(request: Request, category: str | None = None,
 
 @router.get("/catalog/search", response_class=HTMLResponse)
 async def catalog_search_page(request: Request, q: str = "", page: int = 1,
+                             category: str | None = None, tag: str | None = None,
                              show_hidden: int = 0, sort: str = "default"):
     user = _get_user_or_none(request)
     if not user:
@@ -117,8 +118,8 @@ async def catalog_search_page(request: Request, q: str = "", page: int = 1,
     is_admin = (user.get("rank") or 0) >= 3
     show_hidden = bool(show_hidden) and is_admin
     sort = sort if sort in _VALID_SORTS else "default"
-    items = await db.search(q, page=page, show_hidden=show_hidden, sort=sort)
-    total = await db.search_count(q, show_hidden=show_hidden)
+    items = await db.search(q, category=category, tag=tag, page=page, show_hidden=show_hidden, sort=sort)
+    total = await db.search_count(q, category=category, tag=tag, show_hidden=show_hidden)
     total_pages = max(1, (total + 23) // 24)
     categories = await db.get_categories(show_hidden=show_hidden)
     tags = await db.get_tags(show_hidden=show_hidden)
@@ -130,8 +131,8 @@ async def catalog_search_page(request: Request, q: str = "", page: int = 1,
         "tags": tags,
         "page": page,
         "total_pages": total_pages,
-        "active_category": None,
-        "active_tag": None,
+        "active_category": category,
+        "active_tag": tag,
         "query": q,
         "is_admin": is_admin,
         "show_hidden": show_hidden,

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/kryten_webqueue/templates/admin/index.html

@@ -234,11 +234,7 @@ async function loadAdminData() {
     // Queue status
     const qResp = await fetch('/queue/state');
     if (qResp.ok) {
-        const state = await qResp.json();
-        document.getElementById('queue-status').innerHTML = `
-            <p>Items in queue: ${(state.items || []).length}</p>
-            <p>Now playing: ${state.now_playing ? escapeHtml(state.now_playing.title || 'Unknown') : 'Nothing'}</p>
-        `;
+        renderQueueStatus(await qResp.json());
     }
 
     // Sync logs
@@ -265,6 +261,46 @@ async function loadAdminData() {
     }
 }
 
+// Render the live queue-status block. Shared by the initial load and the
+// WebSocket so the count + now-playing stay current without a reload.
+function renderQueueStatus(state) {
+    const el = document.getElementById('queue-status');
+    if (!el) return;
+    const np = state && state.now_playing;
+    el.innerHTML = `
+        <p>Items in queue: ${((state && state.items) || []).length}</p>
+        <p>Now playing: ${np ? escapeHtml(np.title || 'Unknown') : 'Nothing'}</p>
+    `;
+}
+
+// Subscribe to the same /ws feed the public queue page uses, so queue size and
+// now-playing update live. Jobs are DB-polled (below) since they aren't
+// broadcast.
+let adminWs = null;
+let adminWsReconnect = null;
+function connectAdminWebSocket() {
+    const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    adminWs = new WebSocket(`${proto}//${location.host}/ws`);
+    adminWs.onmessage = (event) => {
+        let msg;
+        try { msg = JSON.parse(event.data); } catch (e) { return; }
+        if (msg.type === 'queue_state' || msg.type === 'queue_update') {
+            renderQueueStatus(msg.data);
+        } else if (msg.type === 'schedule_fired') {
+            showToast(`Scheduled playlist loaded: ${msg.data.playlist_name}`);
+            loadJobs();
+        }
+    };
+    adminWs.onclose = () => {
+        adminWsReconnect = setTimeout(connectAdminWebSocket, 3000);
+    };
+    setInterval(() => {
+        if (adminWs && adminWs.readyState === WebSocket.OPEN) {
+            adminWs.send(JSON.stringify({type: 'ping'}));
+        }
+    }, 30000);
+}
+
 function escapeHtml(str) {
     const div = document.createElement('div');
     div.textContent = str;
@@ -294,5 +330,12 @@ function summarizeRunDetail(detail) {
 
 loadAdminData();
 loadJobs();
+connectAdminWebSocket();
+
+// Jobs are DB-polled (not broadcast), so refresh them periodically while the
+// tab is visible to reflect running/finished status without a reload.
+setInterval(() => {
+    if (document.visibilityState === 'visible') loadJobs();
+}, 5000);
 </script>
 {% endblock %}

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/kryten_webqueue/templates/admin/schedules.html

@@ -42,6 +42,15 @@ async function loadActive() {
     if (!resp.ok) { banner.classList.add('hidden'); return; }
     const a = await resp.json();
     if (!a || !a.schedule_id) { banner.classList.add('hidden'); return; }
+    // Treat a well-past estimated end as ended even before the backend clears
+    // the row on its next poll, so the banner never lingers.
+    if (a.estimated_end_at) {
+        const end = new Date(a.estimated_end_at);
+        if (!isNaN(end) && (Date.now() - end.getTime()) > 5 * 60 * 1000) {
+            banner.classList.add('hidden');
+            return;
+        }
+    }
     const name = playlistMap[a.playlist_id] || `Playlist #${a.playlist_id}`;
     banner.classList.remove('hidden');
     const locked = a.is_immutable && !a.lock_disabled;
@@ -203,5 +212,11 @@ function showModal(html) {
 function closeModal() { const m = document.getElementById('admin-modal'); if (m) m.remove(); }
 
 loadSchedules();
+
+// Keep the active-event banner fresh without a reload: re-check every 15s while
+// the tab is visible (the backend clears the row once the event plays out).
+setInterval(() => {
+    if (document.visibilityState === 'visible') loadActive();
+}, 15000);
 </script>
 {% endblock %}

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/kryten_webqueue/templates/catalog/browse.html

@@ -101,13 +101,41 @@
     {% endfor %}
 </div>
 
+{% set sort_q = ('&sort=' ~ sort) if (sort and sort != 'default') else '' %}
 {% if not items %}
 <div class="empty-state">
-    <p>No items found.</p>
+    {% if query and (active_category or active_tag) %}
+        <p>No results for "{{ query }}" within the selected filter{% if active_category and active_tag %}s{% endif %}.</p>
+        <p class="muted">
+            Active:
+            {% if active_category %}<strong>category</strong>{% endif %}
+            {% if active_category and active_tag %} and {% endif %}
+            {% if active_tag %}<strong>tag “{{ active_tag }}”</strong>{% endif %}.
+            Try widening your search.
+        </p>
+        <p>
+            <a class="btn btn-sm" href="/catalog/search?q={{ query | urlencode }}{{ sort_q }}">Search without filters</a>
+            <a class="btn btn-sm" href="/catalog/browse">Clear search</a>
+        </p>
+    {% elif query %}
+        <p>No results for "{{ query }}".</p>
+        <p class="muted">Check the spelling or try fewer / different words.</p>
+        <p><a class="btn btn-sm" href="/catalog/browse">Back to browse</a></p>
+    {% elif active_category or active_tag %}
+        <p>No items match the selected filter{% if active_category and active_tag %}s{% endif %}.</p>
+        <p class="muted">
+            Active:
+            {% if active_category %}<strong>category</strong>{% endif %}
+            {% if active_category and active_tag %} and {% endif %}
+            {% if active_tag %}<strong>tag “{{ active_tag }}”</strong>{% endif %}.
+        </p>
+        <p><a class="btn btn-sm" href="/catalog/browse">Clear filters</a></p>
+    {% else %}
+        <p>No items found.</p>
+    {% endif %}
 </div>
 {% endif %}
 
-{% set sort_q = ('&sort=' ~ sort) if (sort and sort != 'default') else '' %}
 <div class="pagination">
     {% if page > 1 %}
         <a href="?page={{ page - 1 }}{% if query %}&q={{ query }}{% endif %}{% if active_category %}&category={{ active_category }}{% endif %}{% if active_tag %}&tag={{ active_tag | urlencode }}{% endif %}{{ sort_q }}" class="btn btn-sm">&larr; Prev</a>
@@ -141,13 +169,13 @@ function applyFacets() {
     const sort = document.getElementById('sort-select').value;
     try { localStorage.setItem('browse_sort', sort); } catch (e) { /* ignore */ }
     const params = new URLSearchParams();
-    // On a search results page, preserve the query and stay on /catalog/search.
+    // On a search results page keep the query AND apply the facets so search
+    // results are narrowed by category/tag (they AND together server-side).
     if (CURRENT_QUERY) {
         params.set('q', CURRENT_QUERY);
-    } else {
-        if (cat) params.set('category', cat);
-        if (tag) params.set('tag', tag);
     }
+    if (cat) params.set('category', cat);
+    if (tag) params.set('tag', tag);
     if (sort && sort !== 'default') params.set('sort', sort);
     const base = CURRENT_QUERY ? '/catalog/search' : '/catalog/browse';
     const qs = params.toString();

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryten-webqueue"
-version = "0.16.0"
+version = "0.18.0"
 description = "Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube"
 readme = "README.md"
 license = "MIT"

{kryten_webqueue-0.16.0 → kryten_webqueue-0.18.0}/tests/test_phase4_live_fixes.py

@@ -152,6 +152,52 @@ async def test_event_lock_stays_until_last_item(db):
     assert await db.is_event_lock_active() is True
 
 
+# --- active-schedule auto-expiry (v0.18.0) ---
+
+async def test_active_schedule_cleared_when_last_item_plays_out(db):
+    await _make_event(db, last_item_uid=3)
+    shadow = QueueShadow(db)
+    # The last scheduled item (uid=3) is still in the queue -> row kept.
+    await shadow.apply_poll_result(
+        [_polled(1), _polled(2), _polled(3)], {"uid": 2, "seconds": 100, "currentTime": 0}
+    )
+    assert (await db.get_active_schedule()) is not None
+    # uid=3 has now left the queue (played out, temp item removed) -> row cleared.
+    await shadow.apply_poll_result(
+        [_polled(4), _polled(5)], {"uid": 4, "seconds": 100, "currentTime": 0}
+    )
+    assert (await db.get_active_schedule()) is None
+
+
+async def test_active_schedule_not_cleared_when_nothing_playing(db):
+    await _make_event(db, last_item_uid=3)
+    shadow = QueueShadow(db)
+    # Last item absent but nothing is playing (transient empty poll) -> keep row.
+    await shadow.apply_poll_result([], None)
+    assert (await db.get_active_schedule()) is not None
+
+
+async def test_active_schedule_cleared_when_estimated_end_passed(db):
+    # last_item_uid is None so the event-driven path can't fire; rely on the
+    # time safety net with an estimated end well in the past.
+    pid = await db.create_saved_playlist(
+        name="Stale", description=None, is_immutable=True, created_by="admin"
+    )
+    sid = await db.create_schedule(
+        playlist_id=pid, label="Stale", fire_at=datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S"),
+        is_active=1, created_by="admin",
+    )
+    past = datetime.now(UTC) - timedelta(hours=1)
+    await db.set_active_schedule(
+        schedule_id=sid, playlist_id=pid, is_immutable=True,
+        started_at=(past - timedelta(hours=1)).isoformat(),
+        estimated_end_at=past.isoformat(), last_item_uid=None,
+    )
+    shadow = QueueShadow(db)
+    await shadow.apply_poll_result([_polled(1)], {"uid": 1, "seconds": 100, "currentTime": 0})
+    assert (await db.get_active_schedule()) is None
+
+
 # --- #4 pre-fire lock override ---
 
 async def test_pre_fire_lock_can_be_disabled(db):

kryten_webqueue-0.18.0/tests/test_search_facets.py

@@ -0,0 +1,81 @@
+"""Search combines with category/tag facets (Item 4 of the UX polish plan).
+
+A free-text search now ANDs with the selected category and/or tag, mirroring how
+browse() already filters. These tests pin that behavior at the DB layer.
+"""
+
+import pytest
+
+from kryten_webqueue.catalog.db import Database
+
+MEDIACMS = "https://www.dropsugar.com"
+
+
+@pytest.fixture
+async def db(tmp_path):
+    database = Database(str(tmp_path / "search_facets.db"))
+    await database.connect()
+    await database.run_migrations()
+    yield database
+    await database.close()
+
+
+async def _add_catalog(db, token, title):
+    await db.insert_catalog({
+        "friendly_token": token,
+        "title": title,
+        "description": "",
+        "duration_sec": 600,
+        "manifest_url": f"{MEDIACMS}/api/v1/media/cytube/{token}.json?format=json",
+        "thumbnail_url": "",
+        "synced_at": "2026-01-01T00:00:00+00:00",
+    })
+
+
+async def test_search_ands_with_category_and_tag(db):
+    # Three items all matching the query "Dragon", differentiated by facets.
+    await _add_catalog(db, "tok_action", "Dragon Action")
+    await _add_catalog(db, "tok_comedy", "Dragon Comedy")
+    await _add_catalog(db, "tok_plain", "Dragon Plain")
+
+    action_id = await db.upsert_category("Action")
+    comedy_id = await db.upsert_category("Comedy")
+    await db.set_catalog_categories("tok_action", [action_id])
+    await db.set_catalog_categories("tok_comedy", [comedy_id])
+
+    epic_tag = await db.upsert_tag("Epic")
+    await db.set_catalog_tags("tok_action", [epic_tag])
+
+    # Resolve the Action slug (upsert derives it).
+    action_slug = next(c["slug"] for c in await db.get_categories() if c["name"] == "Action")
+
+    # Plain query: all three match.
+    assert {r["friendly_token"] for r in await db.search("Dragon")} == {
+        "tok_action", "tok_comedy", "tok_plain",
+    }
+    assert await db.search_count("Dragon") == 3
+
+    # Query + category: only the Action item.
+    cat_results = {r["friendly_token"] for r in await db.search("Dragon", category=action_slug)}
+    assert cat_results == {"tok_action"}
+    assert await db.search_count("Dragon", category=action_slug) == 1
+
+    # Query + tag: only the Epic-tagged item.
+    tag_results = {r["friendly_token"] for r in await db.search("Dragon", tag="Epic")}
+    assert tag_results == {"tok_action"}
+    assert await db.search_count("Dragon", tag="Epic") == 1
+
+    # Query + category + tag that don't co-occur: empty (true intersection).
+    assert await db.search("Dragon", category=action_slug, tag="Nonexistent") == []
+    assert await db.search_count("Dragon", category=action_slug, tag="Nonexistent") == 0
+
+
+async def test_search_facet_with_no_text_match_is_empty(db):
+    await _add_catalog(db, "tok1", "Comedy Night")
+    comedy_id = await db.upsert_category("Comedy")
+    await db.set_catalog_categories("tok1", [comedy_id])
+    comedy_slug = next(c["slug"] for c in await db.get_categories() if c["name"] == "Comedy")
+
+    # The category matches the item, but the query does not -> no results.
+    assert await db.search("Horror", category=comedy_slug) == []
+    assert await db.search_count("Horror", category=comedy_slug) == 0