feat(search): answer search from a local index; tier downloads by lifetime

Search's instant leg read only downloaded items, so with no downloads it
returned nothing and every keystroke fell through to a full Recursive=true
server query. It now reads the whole synced catalog through the same
availability CTE get_items uses, gated on the same include_catalog_browse
flag so search and browse cannot diverge. (UR-065, DR-108)

Also fixes three defects found while confirming that:

- items_fts grew by a full duplicate index every catalog pass. INSERT OR
  REPLACE fires no AFTER DELETE trigger without recursive_triggers, so the
  old index row was orphaned, and a TEXT PRIMARY KEY meant the replacement
  took a fresh rowid and inserted a second entry. Now a real upsert, with
  migration 021 rebuilding existing indexes. (DR-110)
- DELETE FROM items existed nowhere, so server-side deletions never
  propagated. Adds a post-crawl mark-and-sweep, scoped to crawled types,
  skipping downloaded items, and refusing to run after a partial crawl
  because items.parent_id cascades. (DR-110)
- The index omitted MusicArtist, Playlist and People, which search groups
  results by. Adds them plus people_fts (migration 022). (DR-111)

Re-indexing moves from a frontend startup call to a Rust background task
with a 6h TTL, so a long session no longer searches a stale catalog and a
restart no longer forces a crawl regardless of freshness. (DR-109, IR-030)

Downloads gain a lifetime tier. Eviction selected every completed row by
age with no download_source filter, so hitting the storage limit deleted
the oldest download -- typically one saved deliberately for offline -- to
make room for a precached track. It now reclaims only 'auto' rows, and
expired ones are reclaimed first, before live cache is evicted.
(DR-126, DR-127)

Downloaded video and audio-only handoffs now play from disk instead of
streaming; the video path had never consulted downloads at all. No
transcode is involved: MPV runs video=no and ExoPlayer has no surface for
an Audio item. (DR-123 in part, DR-128)

FTS queries are built as quoted phrases so apostrophes, hyphens and
slashes are data rather than operator syntax, and the item-type filter is
bound rather than interpolated.

Specs: docs/specs/catalog-index-search.md,
docs/specs/read-through-media-cache.md

Includes concurrently-developed favourites browsing and background-audio
stream-end handling; the two workstreams share offline.rs, lib.rs and
online.rs, so no subset of files builds independently.

src/lib/services/favorites.ts

@@ -1,10 +1,11 @@
 // Favorites service - Handles toggling favorite status with optimistic updates
-// TRACES: UR-017 | DR-021
+// TRACES: UR-017, UR-068 | DR-021, DR-119
 
 import { get } from "svelte/store";
 import { commands } from "$lib/api/bindings";
 import { auth } from "$lib/stores/auth";
 import { isConnected } from "$lib/stores/connectivity";
+import { setFavorite } from "$lib/stores/favorites";
 
 /**
  * Toggle the favorite status of an item.
@@ -33,6 +34,10 @@ export async function toggleFavorite(
   // 1. Update local database first (optimistic update)
   await commands.storageToggleFavorite(userId, itemId, newIsFavorite);
 
+  // Publish to every mounted view at once, so the heart on a card, the detail
+  // page and the Favourites grid never disagree. TRACES: UR-068 | DR-119
+  setFavorite(itemId, newIsFavorite);
+
   // 2. Sync to Jellyfin server.
   //
   // Only attempt this when we're actually connected. When offline, the server

src/lib/services/offlineCatalog.ts

@@ -66,9 +66,14 @@ function currentHandle(): string | null {
 }
 
 /**
- * Walk every library and cache the full catalog. Best-effort and non-blocking:
- * safe to call on startup (while online) and on reconnect. No-ops if not
- * connected or a sync is already running.
+ * Force a full re-index now, ignoring freshness.
+ *
+ * Routine scheduling is the Rust indexer's job (DR-109) — this is the manual
+ * override, for a "re-index now" affordance. It is deliberately *not* called on
+ * startup or reconnect any more: doing so forced a full crawl on every launch
+ * regardless of how fresh the index was.
+ *
+ * The backend refuses overlapping passes, so this is safe to call at any time.
  */
 export async function syncCatalog(): Promise<void> {
   if (syncInProgress) return;
@@ -124,6 +129,8 @@ export async function refreshSyncStatus(): Promise<void> {
  */
 export async function onReconnected(): Promise<void> {
   await resumeQueued();
-  // Fire-and-forget: don't block reconnection handling on a potentially long walk.
-  void syncCatalog();
+  // Re-indexing on reconnect is the Rust indexer's job (DR-109) — it re-checks
+  // staleness every tick, so it picks this up without a nudge from here. Queued
+  // downloads still need resolving from the frontend, which is why this
+  // function remains.
 }

src/lib/services/preload.test.ts

@@ -17,6 +17,7 @@ function makeConfig(overrides: Partial<CacheConfig> = {}): CacheConfig {
     albumAffinityThreshold: 0.75,
     storageLimit: 2 * 1024 * 1024 * 1024,
     wifiOnly: false,
+    temporaryTtlHours: 24 * 7,
     ...overrides,
   };
 }
@@ -177,14 +178,7 @@ describe("preload service", () => {
     });
 
     it("should support all config options", async () => {
-      const config = {
-        queuePrecacheEnabled: true,
-        queuePrecacheCount: 5,
-        albumAffinityEnabled: false,
-        albumAffinityThreshold: 0.75,
-        storageLimit: 2 * 1024 * 1024 * 1024,
-        wifiOnly: true,
-      };
+      const config = makeConfig({ wifiOnly: true, albumAffinityEnabled: false });
 
       await expect(updateCacheConfig(config)).resolves.toBeUndefined();
     });

src/lib/services/syncService.ts

@@ -84,19 +84,10 @@ class SyncService {
     return id;
   }
 
-  /**
-   * Queue a favorite toggle
-   * Also updates local state immediately
-   */
-  async queueFavorite(itemId: string, isFavorite: boolean): Promise<number> {
-    // Update local state first
-    await commands.storageToggleFavorite(auth.getUserId() ?? "", itemId, isFavorite);
-
-    return this.queueMutation(
-      isFavorite ? "mark_favorite" : "unmark_favorite",
-      itemId
-    );
-  }
+  // NOTE: `queueFavorite` is gone. Favourites are drained by Rust on the
+  // `connectivity:reconnected` signal (DR-120) — the local write already sets
+  // `pending_sync`, and a second queue here would push the same change twice.
+  // See src-tauri/src/commands/favorites.rs.
 
   /**
    * Queue playback progress update