fix(images): key favorites by the real root and case-normalized path

Folder names are not unique across gallery roots, so two roots shown as
"output" shared each other's stars. Favorites are now keyed by the
root's real, case-normalized path (server-side only) and a
case-normalized relative path, so a Windows case-only rename keeps its
star while distinct Linux files stay distinct. Toggles look the file up
in a per-scan dictionary instead of walking the listing.

database/image_favorites.py

@@ -1,8 +1,11 @@
-"""Persisted image favorites, keyed by gallery root label + relative path.
+"""Persisted image favorites, keyed by gallery root + relative path.
 
-The root label is the root's public form (``_public_path``), so a favorite
-follows its folder when the configured roots are reordered. Optional in old
-backups, required once a database is current (see ``library_schema.py``).
+The root key is the root's real, case-normalized path and the relative key is
+case-normalized the same way (see ``py/api/images.py``); both stay
+server-side. Folder names alone are not unique across roots, so a favorite
+follows the directory itself when the configured roots are reordered.
+Optional in old backups, required once a database is current (see
+``library_schema.py``).
 """
 
 import re
@@ -13,12 +16,12 @@ TABLE = "image_favorites"
 MAX_KEY_LENGTH = 4096
 _LOOKUP_CHUNK = 500
 _DDL = (
-    f"CREATE TABLE {TABLE} (root_label TEXT NOT NULL, relative_path TEXT NOT NULL, "
-    "created_at TEXT NOT NULL, PRIMARY KEY(root_label, relative_path))"
+    f"CREATE TABLE {TABLE} (root_key TEXT NOT NULL, relative_path TEXT NOT NULL, "
+    "created_at TEXT NOT NULL, PRIMARY KEY(root_key, relative_path))"
 )
 _AUTOINDEX = f"sqlite_autoindex_{TABLE}_1"
 _COLUMNS = (
-    ("root_label", "TEXT", 1, 1),
+    ("root_key", "TEXT", 1, 1),
     ("relative_path", "TEXT", 1, 2),
     ("created_at", "TEXT", 1, 0),
 )
@@ -58,19 +61,19 @@ def image_favorites_schema_error(
     # Bytes bound characters from above (UTF-8 is at most 4 bytes each).
     limit = MAX_KEY_LENGTH * 4
     if conn.execute(
-        f"SELECT 1 FROM {TABLE} WHERE typeof(root_label) != 'text' "
+        f"SELECT 1 FROM {TABLE} WHERE typeof(root_key) != 'text' "
         "OR typeof(relative_path) != 'text' OR typeof(created_at) != 'text' "
-        f"OR length(CAST(root_label AS BLOB)) > {limit} "
+        f"OR length(CAST(root_key AS BLOB)) > {limit} "
         f"OR length(CAST(relative_path AS BLOB)) > {limit} "
         "OR length(CAST(created_at AS BLOB)) > 64 LIMIT 1"
     ).fetchone():
         return "Image favorites contains invalid values"
-    for label, path in conn.execute(
-        f"SELECT CAST(root_label AS BLOB), CAST(relative_path AS BLOB) FROM {TABLE} "
-        f"WHERE length(CAST(root_label AS BLOB)) > {MAX_KEY_LENGTH} "
+    for root, path in conn.execute(
+        f"SELECT CAST(root_key AS BLOB), CAST(relative_path AS BLOB) FROM {TABLE} "
+        f"WHERE length(CAST(root_key AS BLOB)) > {MAX_KEY_LENGTH} "
         f"OR length(CAST(relative_path AS BLOB)) > {MAX_KEY_LENGTH}"
     ):
-        for raw in (label, path):
+        for raw in (root, path):
             if len(bytes(raw).decode("utf-8", "replace")) > MAX_KEY_LENGTH:
                 return "Image favorites contains invalid values"
     return None
@@ -97,30 +100,30 @@ def migrate_image_favorites(conn: sqlite3.Connection) -> None:
 class ImageFavoriteOperations:
     """PromptDatabase mixin: set, clear and look up image favorites."""
 
-    def set_image_favorite(self, root_label: str, relative_path: str) -> bool:
+    def set_image_favorite(self, root_key: str, relative_path: str) -> bool:
         """Mark one file as a favorite; repeating it is a no-op. Returns True."""
         from .models import utc_now_iso  # models imports this module's schema
 
         with self.model.get_connection() as conn:
             conn.execute(
                 "INSERT OR IGNORE INTO image_favorites VALUES (?, ?, ?)",
-                (root_label, relative_path, utc_now_iso()),
+                (root_key, relative_path, utc_now_iso()),
             )
         return True
 
-    def clear_image_favorite(self, root_label: str, relative_path: str) -> bool:
+    def clear_image_favorite(self, root_key: str, relative_path: str) -> bool:
         """Remove one favorite; True when a row was removed."""
         with self.model.get_connection() as conn:
             cursor = conn.execute(
-                "DELETE FROM image_favorites WHERE root_label=? AND relative_path=?",
-                (root_label, relative_path),
+                "DELETE FROM image_favorites WHERE root_key=? AND relative_path=?",
+                (root_key, relative_path),
             )
         return cursor.rowcount > 0
 
     def get_image_favorites(
-        self, root_label: str, relative_paths: Iterable[str]
+        self, root_key: str, relative_paths: Iterable[str]
     ) -> set[str]:
-        """The subset of *relative_paths* favorited under *root_label*."""
+        """The subset of *relative_paths* favorited under *root_key*."""
         wanted = list(dict.fromkeys(relative_paths))
         found: set[str] = set()
         conn = self.model.get_connection()
@@ -128,9 +131,9 @@ class ImageFavoriteOperations:
             chunk = wanted[start : start + _LOOKUP_CHUNK]
             marks = ",".join("?" * len(chunk))
             rows = conn.execute(  # only "?" placeholders are interpolated
-                "SELECT relative_path FROM image_favorites WHERE root_label=? "
+                "SELECT relative_path FROM image_favorites WHERE root_key=? "
                 f"AND relative_path IN ({marks})",  # nosec B608
-                (root_label, *chunk),
+                (root_key, *chunk),
             )
             found.update(path for (path,) in rows)
         return found