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/lib/utils/layoutShell.test.ts

@@ -19,6 +19,7 @@ import {
   showBottomNav,
   showGlobalMiniPlayer,
   showGlobalHeader,
+  showHeaderSearch,
   routeOwnsLayout,
   showBottomUi,
   shellReservesBottomInset,
@@ -179,3 +180,25 @@ describe("shellReservesBottomInset", () => {
     expect(shellReservesBottomInset({ pathname: "/", isAuthenticated: false })).toBe(false);
   });
 });
+
+describe("showHeaderSearch", () => {
+  it("renders the bar on the library routes", () => {
+    expect(showHeaderSearch({ pathname: "/library" })).toBe(true);
+    expect(showHeaderSearch({ pathname: "/library/music/albums" })).toBe(true);
+    expect(showHeaderSearch({ pathname: "/library/abc123" })).toBe(true);
+  });
+
+  it("keeps the bar on /search, so searching does not swap you to another input", () => {
+    // The regression: the bar existed only under /library, so a header search
+    // landed the user on /search with the box they were typing in gone and a
+    // different one (belonging to the page) in its place.
+    expect(showHeaderSearch({ pathname: "/search" })).toBe(true);
+    expect(showHeaderSearch({ pathname: "/search/" })).toBe(true);
+  });
+
+  it("stays off routes with nothing to search", () => {
+    expect(showHeaderSearch({ pathname: "/" })).toBe(false);
+    expect(showHeaderSearch({ pathname: "/downloads" })).toBe(false);
+    expect(showHeaderSearch({ pathname: "/settings" })).toBe(false);
+  });
+});

src/lib/utils/layoutShell.ts

@@ -17,6 +17,8 @@
  * TRACES: UR-005 | DR-009
  */
 
+import { isSearchRoute } from "$lib/utils/searchScope";
+
 export interface BottomUiVisibilityInput {
   /** Current route pathname, e.g. `$page.url.pathname`. */
   pathname: string;
@@ -90,6 +92,21 @@ export function showGlobalHeader({
   );
 }
 
+/**
+ * Whether the header renders its search box on this route (md+ only; below md
+ * the bottom-nav Search tab and /search's own input serve that role).
+ *
+ * `/search` is included deliberately: the bar is the single md+ search input,
+ * so it must survive the hop onto the results page instead of being replaced by
+ * a second input belonging to that page. The library routes keep it because
+ * that is where a search is most often started.
+ *
+ * TRACES: UR-049, UR-054 | DR-063
+ */
+export function showHeaderSearch({ pathname }: { pathname: string }): boolean {
+  return pathname.startsWith("/library") || isSearchRoute(pathname);
+}
+
 /**
  * Whether any bottom UI is showing for this route (mini player, nav, or both).
  * The bottom UI is rendered in flex flow below the scroller (see BottomUi.svelte),

src/lib/utils/searchScope.test.ts

@@ -3,11 +3,14 @@ import {
   composeSearchGroups,
   DEFAULT_GROUP_ORDER,
   groupsForScope,
+  isSearchRoute,
   moveGroup,
   normalizeGroupOrder,
+  parseSearchScope,
   reorderGroups,
   resolveSearchScope,
   searchRouteUrl,
+  seedFromSearchUrl,
   shouldNavigateToSearch,
   type SearchGroupId,
 } from "./searchScope";
@@ -397,3 +400,66 @@ describe("shouldNavigateToSearch", () => {
     expect(shouldNavigateToSearch("/library/music", "  ")).toBe(false);
   });
 });
+
+describe("isSearchRoute", () => {
+  it("recognises the search surface through query strings and trailing slashes", () => {
+    expect(isSearchRoute("/search")).toBe(true);
+    expect(isSearchRoute("/search/")).toBe(true);
+    expect(isSearchRoute("/search?q=jazz&scope=music")).toBe(true);
+    expect(isSearchRoute("/library/music")).toBe(false);
+    expect(isSearchRoute("/")).toBe(false);
+  });
+});
+
+describe("parseSearchScope", () => {
+  it("accepts the known scopes", () => {
+    expect(parseSearchScope("music")).toBe("music");
+    expect(parseSearchScope("tv")).toBe("tv");
+  });
+
+  it("falls back on absent or unrecognised values", () => {
+    expect(parseSearchScope(null)).toBe("all");
+    expect(parseSearchScope("")).toBe("all");
+    expect(parseSearchScope("books")).toBe("all");
+    expect(parseSearchScope(null, "music")).toBe("music");
+  });
+});
+
+describe("seedFromSearchUrl", () => {
+  const params = (search: string) => new URL(`http://x/search${search}`).searchParams;
+
+  it("seeds a fresh page from the URL", () => {
+    expect(seedFromSearchUrl(params("?q=jazz&scope=music"), null)).toEqual({
+      query: "jazz",
+      scope: "music",
+    });
+  });
+
+  it("seeds an empty query so an emptied URL clears the page", () => {
+    expect(seedFromSearchUrl(params(""), null)).toEqual({ query: "", scope: "all" });
+    expect(seedFromSearchUrl(params(""), { query: "jazz", scope: "all" })).toEqual({
+      query: "",
+      scope: "all",
+    });
+  });
+
+  it("asks for nothing once that same URL has been applied", () => {
+    // The regression this exists for: the page must consume the URL once, not
+    // keep re-asserting it. While the seed is unchanged the user's typing and
+    // chip picks own the input — re-applying snapped it back a keystroke later.
+    const applied = { query: "jazz", scope: "music" } as const;
+    expect(seedFromSearchUrl(params("?q=jazz&scope=music"), applied)).toBeNull();
+  });
+
+  it("re-seeds when the query or the scope actually changes", () => {
+    const applied = { query: "jazz", scope: "music" } as const;
+    expect(seedFromSearchUrl(params("?q=blues&scope=music"), applied)).toEqual({
+      query: "blues",
+      scope: "music",
+    });
+    expect(seedFromSearchUrl(params("?q=jazz"), applied)).toEqual({
+      query: "jazz",
+      scope: "all",
+    });
+  });
+});

src/lib/utils/searchScope.ts

@@ -71,6 +71,16 @@ export function searchRouteUrl(query: string, scope: SearchScope): string {
   return `/search?${params.toString().replace(/\+/g, "%20")}`;
 }
 
+/** Normalise a pathname for comparison: drop query, hash and trailing slashes. */
+function normalizePath(pathname: string): string {
+  return pathname.split(/[?#]/)[0].replace(/\/+$/, "") || "/";
+}
+
+/** Whether `pathname` is the search surface itself. */
+export function isSearchRoute(pathname: string): boolean {
+  return normalizePath(pathname) === "/search";
+}
+
 /**
  * Whether a search typed on `pathname` must navigate to `/search` to be seen.
  *
@@ -82,8 +92,48 @@ export function searchRouteUrl(query: string, scope: SearchScope): string {
  */
 export function shouldNavigateToSearch(pathname: string, query: string): boolean {
   if (!query.trim()) return false;
-  const path = pathname.split(/[?#]/)[0].replace(/\/+$/, "") || "/";
-  return path !== "/search";
+  return !isSearchRoute(pathname);
+}
+
+/** Read a `?scope=` value, falling back when it is absent or unrecognised. */
+export function parseSearchScope(
+  raw: string | null | undefined,
+  fallback: SearchScope = "all"
+): SearchScope {
+  return SEARCH_SCOPES.includes(raw as SearchScope) ? (raw as SearchScope) : fallback;
+}
+
+/** The query + scope a `/search` URL asks the page to show. */
+export interface SearchSeed {
+  query: string;
+  scope: SearchScope;
+}
+
+/**
+ * What a `/search` URL should seed the page with, or `null` if it asks for
+ * nothing new.
+ *
+ * The URL is *consumed once per value*, not continuously reconciled against the
+ * live input. `applied` is the seed the caller last took from the URL: while it
+ * still matches, the user's own typing and chip picks govern, and only a real
+ * navigation (the header search sending a new query) re-seeds the page.
+ *
+ * Reconciling instead of consuming was the bug this replaced — the old effect
+ * compared the URL against `library.searchQuery`, so every keystroke's search
+ * re-ran it and snapped the input back to the query the header had sent.
+ *
+ * TRACES: UR-049 | DR-063, DR-064
+ */
+export function seedFromSearchUrl(
+  params: URLSearchParams,
+  applied: SearchSeed | null
+): SearchSeed | null {
+  const seed: SearchSeed = {
+    query: params.get("q") ?? "",
+    scope: parseSearchScope(params.get("scope")),
+  };
+  if (applied && applied.query === seed.query && applied.scope === seed.scope) return null;
+  return seed;
 }
 
 // ---------------------------------------------------------------------------