feat(ui): make the collections QAM navigable and declutter its panel

First of two PRs for #1539. Restructures the collections QAM so it stays usable as the virtual-collection list grows.

- **Search** — a fuzzy name filter over the collection list (a shared `fuzzyMatch` util).
- **Render cap** — the list paints at most 50 rows plus a "N more — refine your search" hint, so a large virtual list never strains the renderer.
- **Per-type filter** — on the Virtual sub-tab, an All / Franchise / IGDB Collection control narrows by type.
- **Enable All / Disable All act on the current filter** — a new `save_collections_sync` batch callable toggles exactly the matched collections; enabling a whole kind (no filter) asks for confirmation first.
- **Declutter** — the "Show collection games in platform groups" toggle moves to Settings → Library, leaving the Collections panel for browsing and selection.

The collection naming/provenance toggle (`collection_naming_mode`) is the second PR.

Part of #1539.

Author: danielcopper

docs/architecture/backend-architecture.md

@@ -531,6 +531,15 @@ key while preserving every enabled id, so a previously-enabled franchise collect
 required. (The historical v2 → v3 split still produces the `franchise` bucket; the v10 → v11 step renames it afterwards,
 so that frozen step is untouched.)
 
+**Batch collection enable — `save_collections_sync` for a filtered subset (#1539).** The Collections tab adds a name
+search and (on Virtual) a per-type filter, and its **Enable All / Disable All** act on the current filter. When the view
+is a bounded subset (a search or per-type filter is active) the frontend calls `save_collections_sync` with the matched
+ids, the kind, and the enabled flag — a single settings write that stamps every id into the `kind` bucket, so the whole
+kind is never touched. An unknown kind or a non-list id argument is rejected with the canonical failure shape; an empty
+id list is a success no-op. The **unfiltered** whole-kind case still uses `set_all_collections_sync` (which re-fetches
+the kind from the server) so a large id list never crosses the WebSocket bridge; the frontend gates that whole-kind call
+behind a confirm. Both live on `LibraryFetcher`.
+
 **Collection owner-scope filter — "Own" is a sync scope, not just a display filter (#1532).** RomM's collection list
 endpoints return the signed-in user's own collections plus every other user's _public_ collection. The QAM
 `Show

docs/user-guide/syncing-your-library.md

@@ -225,10 +225,19 @@ The **Collections** page splits collections into three sub-tabs plus a dedicated
 - **Virtual** sub-tab — auto-generated groupings RomM derives from IGDB metadata: both IGDB **franchise** groupings and
   IGDB **collection** (series) groupings. Each row is labelled with its type (Franchise / IGDB Collection).
 
-Each sub-tab shows its visible count in the section header (e.g. `MY COLLECTIONS (4)`) and lets you toggle individual
-collections, or use the paired **Enable All** / **Disable All** buttons to bulk-toggle just that sub-tab. The global
-**Show collection games in platform groups** toggle controls whether games pulled in via a collection also get added to
-their platform's Steam group.
+Each sub-tab shows its match count in the section header (e.g. `MY COLLECTIONS (4)`) and lets you toggle individual
+collections. A **search box** above the list filters the current sub-tab by name — most useful on **Virtual**, which can
+run to hundreds of entries. On the **Virtual** sub-tab a segmented **All / Franchise / IGDB Collection** control narrows
+the list to one virtual type. The list itself is capped for performance: when more collections match than fit, the first
+rows render and a `… more — refine your search` hint appears — type in the search box to bring the rest into view.
+
+The paired **Enable All** / **Disable All** buttons act on the **current filter**: with a search or the Virtual per-type
+filter active, they toggle exactly the matching collections; with no filter they toggle the whole sub-tab and ask for
+confirmation first, since that can be a large number.
+
+The **Show collection games in platform groups** setting — whether games pulled in via a collection also get added to
+their platform's Steam group — now lives on the **Settings** page under **Library**, alongside the preferred-region
+preference. It applies to every sync, so it sits with the other set-and-forget preferences rather than on this tab.
 
 #### Own / All
 
@@ -241,7 +250,7 @@ On a **shared RomM server** the collection list includes every other user's _pub
   sync, even if one was enabled earlier — switching back to **All** brings your earlier choices back, since the scope
   filters over your enable state rather than changing it.
 
-**Virtual collections always sync** under either setting: they are auto-generated groupings that belong to no one, so
+**Virtual collections always appear** under either setting: they are auto-generated groupings that have no owner, so
 "Own" never hides them. The filter only becomes active once the plugin knows your account identity, which it learns the
 first time you sign in (existing sign-ins pick it up on the next connection check). Until then, **Own** behaves exactly
 like **All** — it never hides a collection it can't yet attribute.

main.py

@@ -332,6 +332,10 @@ async def get_collections(self):
     async def save_collection_sync(self, collection_id, kind, enabled):
         return self._sync_service.save_collection_sync(collection_id, kind, enabled)
 
+    @migration_blocked
+    async def save_collections_sync(self, collection_ids, kind, enabled):
+        return self._sync_service.save_collections_sync(collection_ids, kind, enabled)
+
     @migration_blocked
     async def set_all_collections_sync(self, enabled, scope=None):
         return await self._sync_service.set_all_collections_sync(enabled, scope)

py_modules/services/library/fetcher.py

@@ -348,6 +348,31 @@ def save_collection_sync(self, collection_id, kind, enabled):
         self._settings_persister.save_settings()
         return {"success": True}
 
+    def save_collections_sync(self, collection_ids, kind, enabled):
+        """Batch-stamp a bounded set of collection ids into one kind's bucket.
+
+        The frontend uses this for the filtered-subset Enable/Disable All (a
+        search or per-type filter is active) so the whole-kind
+        ``set_all_collections_sync`` — which re-fetches every collection from the
+        server — stays reserved for the unfiltered case. One settings write
+        stamps every id in ``collection_ids`` to ``enabled`` in the ``kind``
+        bucket. An unknown kind or a non-list id argument is rejected with the
+        canonical failure shape; an empty id list is a success no-op (nothing to
+        stamp, no write).
+        """
+        if kind not in ("user", "smart", "virtual"):
+            return {"success": False, "reason": "invalid_kind", "message": f"Invalid collection kind: {kind}"}
+        if not isinstance(collection_ids, list):
+            return {"success": False, "reason": "invalid_ids", "message": "collection_ids must be a list"}
+        if not collection_ids:
+            return {"success": True}
+        buckets = self._get_enabled_collections_buckets()
+        for cid in collection_ids:
+            buckets[kind][str(cid)] = bool(enabled)
+        self._settings["enabled_collections"] = buckets
+        self._settings_persister.save_settings()
+        return {"success": True}
+
     async def set_all_collections_sync(self, enabled, scope=None):
         enabled = bool(enabled)
         if scope not in (None, "user", "smart", "virtual"):

py_modules/services/library/service.py

@@ -290,6 +290,9 @@ async def get_collections(self):
     def save_collection_sync(self, collection_id, kind, enabled):
         return self._fetcher.save_collection_sync(collection_id, kind, enabled)
 
+    def save_collections_sync(self, collection_ids, kind, enabled):
+        return self._fetcher.save_collections_sync(collection_ids, kind, enabled)
+
     async def set_all_collections_sync(self, enabled, scope=None):
         return await self._fetcher.set_all_collections_sync(enabled, scope)
 

src/api/backend.ts

@@ -161,6 +161,13 @@ export const getCollections = callable<
 export const saveCollectionSync = callable<[string, CollectionKind, boolean], { success: boolean; message?: string }>(
   "save_collection_sync",
 );
+// Batch stamp for a bounded, filtered subset of collections (search / per-type
+// filter active). The whole-kind Enable/Disable All keeps setAllCollectionsSync
+// so a huge id list never crosses the wire.
+export const saveCollectionsSync = callable<
+  [string[], CollectionKind, boolean],
+  { success: boolean; reason?: string; message?: string }
+>("save_collections_sync");
 export const setAllCollectionsSync = callable<
   [boolean, "user" | "smart" | "virtual" | null],
   { success: boolean; message?: string }

src/components/DangerZone.tsx

@@ -36,6 +36,7 @@ import { clearPlatformCollection, clearAllRomMCollections } from "../utils/colle
 import { formatUninstallStatus } from "../utils/formatters";
 import type { RegistryPlatform } from "../types";
 import { detach } from "../utils/detach";
+import { fuzzyMatch } from "../utils/fuzzyMatch";
 
 const DEFAULT_WHITELIST_PATTERNS: string[] = [
   "retrodeck",
@@ -55,17 +56,6 @@ const DEFAULT_WHITELIST_PATTERNS: string[] = [
   "nonsteamlaunchers",
 ];
 
-// Fuzzy match: each character of the query must appear in order in the target (like fzf)
-const fuzzyMatch = (query: string, target: string): boolean => {
-  const q = query.toLowerCase();
-  const t = target.toLowerCase();
-  let qi = 0;
-  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
-    if (t[ti] === q[qi]) qi++;
-  }
-  return qi === q.length;
-};
-
 interface NonSteamApp {
   appId: number;
   name: string;