feat(offline): play downloaded video, and drain the offline sync queue (0.4.6)

Bundles this session's work plus the concurrent search/offline/player changes.
Every gate passes on the combined tree: 885 frontend tests, 610 Rust tests,
clippy clean, boundary clean, trace coverage 86%.

Offline video playback — four separate defects, each of which alone stopped it:

  DR-133  A completed download's file_path is already absolute (the worker
          rewrites it on completion), but the player rooted it a second time and
          handed the webview /data/user/0/app//data/user/0/app/videos/x.mp4.
  DR-134  The asset protocol was never enabled: no protocol-asset feature and no
          assetProtocol config, so convertFileSrc produced URLs nothing answered.
          Also silently defeated the cached-thumbnail path, which fails soft to
          the server copy and hid it whenever the server was reachable.
  DR-137  Tauri's asset protocol answers a range-less request by reading the
          whole file into memory, and only advertises Accept-Ranges from inside
          its range branch, so the first request never learns ranges exist.
          Chromium gave up with PIPELINE_ERROR_READ after ~31s. Local media is
          now served by a loopback HTTP server: bounded 4 MiB chunks streamed
          from the file handle, every response length-delimited, and a range-less
          request answered with one chunk rather than the file. Confined by a
          per-session token and to the app data directory, because loopback is
          shared between apps on Android.
  DR-138  Release builds set usesCleartextTraffic=false, so Android rejected the
          request to that server before any I/O. A network-security-config
          exempts 127.0.0.1 only; a remote server must still be HTTPS.

Downloads:

  DR-135  download_item never records media_type and the reconnect resolver read
          that NULL as 'audio', so a movie queued from a media card had its URL
          resolved by get_audio_stream_url and completed as an audio-only
          transcode. The item's own type now decides.
  DR-136  Rows already downloaded that way are requeued on reconnect, since
          prevention alone leaves them reading "downloaded" and still unplayable.

Known limitation: a download taken at `original` quality is a byte copy of the
source, so it can be any container. One such file is an AVI holding XVID, which
the webview cannot play in any case — the media server serves it correctly and
Chromium refuses it. That needs either a transcoded download preset or the
native ExoPlayer surface work, and is not addressed here.

Also fixes two ID collisions between concurrent work: DR-143 defined twice
(search vs offline gate) and UT-131 defined twice (Episode Focus hero vs channel
cap). The search requirement is now DR-147 and the channel-cap test UT-141, with
their code references and matrix rows updated.

src/routes/search/+page.svelte

@@ -5,40 +5,46 @@
   import Search from "$lib/components/Search.svelte";
   import SearchResults from "$lib/components/search/SearchResults.svelte";
   import SearchScopeChips from "$lib/components/search/SearchScopeChips.svelte";
-  import { resolveSearchScope, SEARCH_SCOPES, type SearchScope } from "$lib/utils/searchScope";
+  import {
+    parseSearchScope,
+    searchRouteUrl,
+    seedFromSearchUrl,
+    type SearchScope,
+    type SearchSeed,
+  } from "$lib/utils/searchScope";
+  import { episodeFocusHref } from "$lib/components/library/seriesNavigation";
   import type { MediaItem } from "$lib/api/types";
 
-  // `?q=` / `?scope=` seed the page so the desktop header search bar can hand
-  // a query over by navigating here — /search is the only surface that renders
-  // results, so every other search affordance routes into it.
+  // `?q=` / `?scope=` seed the page so the header search bar can hand a query
+  // over by navigating here — /search is the only surface that renders results,
+  // so every other search affordance routes into it.
   // TRACES: UR-049 | DR-063
-  const initialQuery = $page.url.searchParams.get("q") ?? "";
-  const initialScope = $page.url.searchParams.get("scope");
+  let searchQuery = $state($page.url.searchParams.get("q") ?? "");
+  let scope = $state<SearchScope>(parseSearchScope($page.url.searchParams.get("scope")));
 
-  let searchQuery = $state(initialQuery);
+  // The URL is *consumed*, not continuously reconciled: `applied` records the
+  // seed already taken, so the user's typing and chip picks stand until a real
+  // navigation brings a different one. It is a plain `let` on purpose — as
+  // `$state` it would be a dependency of the effect that writes it and the
+  // effect would re-run itself.
+  //
+  // Reading `$library.searchQuery` here instead (the previous shape) made every
+  // search re-run this effect, which then re-asserted the URL's query over
+  // whatever had been typed since — the input snapped back a keystroke later.
+  // TRACES: UR-049 | DR-063, DR-064, DR-147
+  let applied: SearchSeed | null = null;
 
-  // Route resolves the *initial* scope only. Deriving it reactively would snap
-  // a user who widened to All back to the route's scope on any navigation.
-  // TRACES: UR-049 | DR-064
-  let scope = $state<SearchScope>(
-    SEARCH_SCOPES.includes(initialScope as SearchScope)
-      ? (initialScope as SearchScope)
-      : resolveSearchScope($page.url.pathname)
-  );
-
-  // A query arriving in the URL must actually run — mounting with a seeded
-  // input alone would render the empty state with a filled box.
   $effect(() => {
-    const q = $page.url.searchParams.get("q") ?? "";
-    if (!q.trim()) return;
-    const urlScope = $page.url.searchParams.get("scope");
-    const nextScope = SEARCH_SCOPES.includes(urlScope as SearchScope)
-      ? (urlScope as SearchScope)
-      : "all";
-    if (q === $library.searchQuery && nextScope === scope) return;
-    searchQuery = q;
-    scope = nextScope;
-    library.search(q, nextScope);
+    const seed = seedFromSearchUrl($page.url.searchParams, applied);
+    if (!seed) return;
+    applied = seed;
+    searchQuery = seed.query;
+    scope = seed.scope;
+    if (seed.query.trim()) {
+      library.search(seed.query, seed.scope);
+    } else {
+      library.clearSearch();
+    }
   });
 
   async function handleSearch(query: string) {
@@ -49,9 +55,19 @@
     }
   }
 
-  // Changing the chip re-runs the current query; changing the query keeps scope.
+  // Chips write the scope to the URL so the header bar (which searches with
+  // whatever scope the URL carries) and this page cannot disagree about it.
+  // Applied optimistically as well, so the chip highlights on click rather than
+  // a navigation later.
+  // TRACES: UR-049 | DR-064, DR-147
   async function handleScopeChange(next: SearchScope) {
     scope = next;
+    applied = { query: searchQuery, scope: next };
+    await goto(searchRouteUrl(searchQuery, next), {
+      replaceState: true,
+      keepFocus: true,
+      noScroll: true,
+    });
     if (searchQuery.trim()) {
       await library.search(searchQuery, next);
     }
@@ -75,8 +91,11 @@
         goto(`/library/${item.id}`);
         break;
       case "Episode":
-        // Episodes play directly
-        goto(`/player/${item.id}`);
+        // Tap opens, it does not play (ux-flows §5B.1/§5B.5) — a search hit
+        // went straight to the player, so it was the one episode entry point
+        // with no way to reach download, cast or the rest of the episode.
+        // TRACES: UR-058 | DR-142
+        goto(episodeFocusHref(item));
         break;
       default:
         goto(`/library/${item.id}`);
@@ -88,13 +107,17 @@
 <div class="max-w-6xl mx-auto">
   <h1 class="text-2xl font-bold mb-6">Search</h1>
 
-  <!-- Search Input -->
+  <!-- Search input. On md+ the header bar owns the input (it is present on this
+       route too), so rendering one here as well would put two search boxes on
+       the same screen; below md the header has none and this is the only one. -->
   <div class="mb-6 space-y-3">
-    <Search
-      bind:value={searchQuery}
-      placeholder="Search your library..."
-      onSearch={handleSearch}
-    />
+    <div class="md:hidden">
+      <Search
+        bind:value={searchQuery}
+        placeholder="Search your library..."
+        onSearch={handleSearch}
+      />
+    </div>
     <SearchScopeChips {scope} onChange={handleScopeChange} />
   </div>
 

src/routes/search/searchPage.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Regression: `/search` must not fight the user's typing when the page was
+ * seeded from the URL (`?q=`), i.e. when the desktop header search navigated
+ * here.
+ *
+ * The original seeding effect read `$library.searchQuery`, so every store write
+ * re-ran it and re-asserted the URL's `q` over whatever had been typed since.
+ * Typing one more character therefore snapped the input back to the query the
+ * header had sent, and picking a scope chip snapped back to the URL's scope.
+ * Arriving from the bottom-nav Search tab (no `?q=`) hit the effect's
+ * empty-query early return, so the same component behaved correctly — the bug
+ * only showed up on the header's route into the page.
+ *
+ * TRACES: UR-049 | DR-147
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, fireEvent, waitFor } from "@testing-library/svelte";
+
+const { pageStore, libState, search, clearSearch, goto } = vi.hoisted(() => {
+  // svelte/store is safe to import inside a hoisted factory (no test-file TDZ).
+  const { writable } = require("svelte/store");
+  return {
+    pageStore: writable({ url: new URL("http://localhost/search") }),
+    libState: writable({ searchQuery: "", searchResults: [], loadingCount: 0 }),
+    search: vi.fn(),
+    clearSearch: vi.fn(),
+    goto: vi.fn(),
+  };
+});
+
+vi.mock("$app/stores", () => ({ page: pageStore, navigating: { subscribe: () => () => {} } }));
+vi.mock("$app/navigation", () => ({ goto, afterNavigate: vi.fn(), beforeNavigate: vi.fn() }));
+vi.mock("$lib/stores/library", () => ({
+  library: { subscribe: libState.subscribe, search, clearSearch },
+}));
+
+import Page from "./+page.svelte";
+
+/** The store write `library.search` performs — the trigger for the old loop. */
+function primeSearch() {
+  search.mockImplementation(async (query: string) => {
+    libState.update((s: Record<string, unknown>) => ({ ...s, searchQuery: query }));
+  });
+  clearSearch.mockImplementation(() => {
+    libState.update((s: Record<string, unknown>) => ({ ...s, searchQuery: "", searchResults: [] }));
+  });
+}
+
+/** Wait past Search.svelte's 300ms input debounce, then let effects settle. */
+const afterDebounce = () => new Promise((resolve) => setTimeout(resolve, 450));
+
+function input(): HTMLInputElement {
+  return screen.getByPlaceholderText("Search your library...") as HTMLInputElement;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  libState.set({ searchQuery: "", searchResults: [], loadingCount: 0 });
+  pageStore.set({ url: new URL("http://localhost/search") });
+  primeSearch();
+  // Model SvelteKit: a goto publishes the new URL through the page store, so a
+  // scope chip's URL round trip really runs through the seeding effect.
+  goto.mockImplementation(async (url: string) => {
+    pageStore.set({ url: new URL(url, "http://localhost") });
+  });
+});
+
+describe("/search seeded from the URL", () => {
+  it("keeps the text the user types on top of the seeded query", async () => {
+    pageStore.set({ url: new URL("http://localhost/search?q=abc") });
+    render(Page);
+
+    await waitFor(() => expect(search).toHaveBeenCalledWith("abc", "all"));
+
+    await fireEvent.input(input(), { target: { value: "abcd" } });
+    await afterDebounce();
+
+    expect(input().value).toBe("abcd");
+    expect(search).toHaveBeenLastCalledWith("abcd", "all");
+  });
+
+  it("keeps a scope chip the user picks instead of snapping back to the URL", async () => {
+    pageStore.set({ url: new URL("http://localhost/search?q=abc&scope=music") });
+    render(Page);
+
+    await waitFor(() => expect(search).toHaveBeenCalledWith("abc", "music"));
+
+    await fireEvent.click(screen.getByRole("radio", { name: "All" }));
+    await afterDebounce();
+
+    expect(screen.getByRole("radio", { name: "All" }).getAttribute("aria-checked")).toBe("true");
+    expect(search).toHaveBeenLastCalledWith("abc", "all");
+  });
+
+  it("re-seeds when a fresh query arrives in the URL (header search on this page)", async () => {
+    pageStore.set({ url: new URL("http://localhost/search?q=abc") });
+    render(Page);
+    await waitFor(() => expect(search).toHaveBeenCalledWith("abc", "all"));
+
+    pageStore.set({ url: new URL("http://localhost/search?q=zeppelin") });
+
+    await waitFor(() => expect(search).toHaveBeenLastCalledWith("zeppelin", "all"));
+    expect(input().value).toBe("zeppelin");
+  });
+
+  it("clears when the URL query is emptied", async () => {
+    pageStore.set({ url: new URL("http://localhost/search?q=abc") });
+    render(Page);
+    await waitFor(() => expect(search).toHaveBeenCalledWith("abc", "all"));
+
+    pageStore.set({ url: new URL("http://localhost/search") });
+
+    await waitFor(() => expect(input().value).toBe(""));
+    expect(screen.getByText("Search your entire library")).toBeTruthy();
+  });
+});
+
+describe("/search entered with no query (bottom-nav Search tab)", () => {
+  it("searches what the user types and leaves it alone", async () => {
+    render(Page);
+
+    await fireEvent.input(input(), { target: { value: "moon" } });
+    await afterDebounce();
+
+    expect(input().value).toBe("moon");
+    expect(search).toHaveBeenLastCalledWith("moon", "all");
+  });
+});