dev: bump to 0.1.66 and harden resolveurl + serienstream

addon/plugins/_template_plugin.py

@@ -1,9 +1,15 @@
-"""Template fuer ein neues ViewIt-Plugin (Basis: serienstream_plugin).
+"""Template fuer ein neues ViewIt-Plugin.
 
 Diese Datei wird NICHT automatisch geladen (Dateiname beginnt mit `_`).
-Zum Verwenden:
-1) Kopiere/benenne die Datei um (ohne fuehrenden Unterstrich), z.B. `my_site_plugin.py`
-2) Passe `name`, `BASE_URL` und die Implementierungen an.
+
+Vorgehen fuer ein neues Plugin:
+
+1. Datei kopieren/umbenennen (ohne fuehrenden Unterstrich), z.B. `my_site_plugin.py`
+2. `name`, `ADDON_ID`, `BASE_URL` und Header anpassen
+3. `search_titles`, `seasons_for`, `episodes_for` gemaess Zielseite implementieren
+4. Optional weitere Methoden wie `stream_link_for`, `resolve_stream_link`,
+   `popular_series`, `genres`, `titles_for_genre`, `available_hosters_for` etc.
+   implementieren – siehe `docs/PLUGIN_DEVELOPMENT.md` und bestehende Plugins.
 """
 
 from __future__ import annotations
@@ -48,20 +54,33 @@ HEADERS = {
     "Connection": "keep-alive",
 }
 
+ProgressCallback = Optional[Callable[[str, Optional[int]], Any]]
+
 
 @dataclass(frozen=True)
 class TitleHit:
-    """Ein Suchtreffer mit Titel und Detail-URL."""
+    """Ein einfacher Suchtreffer mit Titel und Detail-URL."""
 
     title: str
     url: str
 
 
 class TemplatePlugin(BasisPlugin):
-    """Vorlage fuer eine Streamingseiten-Integration.
+    """Vorlage fuer eine HTML-basierte Streamingseiten-Integration.
 
-    Optional kann ein Plugin Capabilities deklarieren (z.B. `popular_series`),
-    damit der Router passende Menüpunkte anbieten kann.
+    Dieses Template zeigt nur die MINIMALE, aber reale Schnittstelle:
+
+    Pflicht:
+    - `async search_titles(query, progress_callback=None) -> list[str]`
+    - `seasons_for(title) -> list[str]`
+    - `episodes_for(title, season) -> list[str]`
+
+    Empfohlen (optional, je nach Use-Case):
+    - `capabilities()` mit z.B. `popular_series`, `genres`, `latest_episodes`
+    - `popular_series()`, `titles_for_genre()`, `titles_for_genre_page()`
+    - `stream_link_for(...)` und/oder `stream_link_for_url(...)`
+    - `resolve_stream_link(link)` fuer Hosters/Redirects
+    - `metadata_for(title)` fuer eigene Metadaten (siehe bestehende Plugins)
     """
 
     name = "Template"
@@ -71,15 +90,25 @@ class TemplatePlugin(BasisPlugin):
 
     @property
     def is_available(self) -> bool:
+        """Signalisiert dem Router, ob das Plugin nutzbar ist (z.B. Abhaengigkeiten vorhanden)."""
+
         return REQUESTS_AVAILABLE
 
     @property
     def unavailable_reason(self) -> str:
+        """Optionaler Grund, warum `is_available` false ist (z.B. fehlende Pakete)."""
+
         if REQUESTS_AVAILABLE:
             return ""
         return f"requests/bs4 nicht verfuegbar: {REQUESTS_IMPORT_ERROR}"
 
     def _get_session(self) -> RequestsSession:
+        """Gibt eine vorkonfigurierte `requests.Session` zurueck.
+
+        In echten Plugins kann hier auch `http_session_pool.get_requests_session(...)`
+        genutzt werden, wenn mehrere Module sich Sessions teilen sollen.
+        """
+
         if requests is None:
             raise RuntimeError(self.unavailable_reason)
         if self._session is None:
@@ -91,41 +120,72 @@ class TemplatePlugin(BasisPlugin):
     async def search_titles(
         self,
         query: str,
-        progress_callback: Optional[Callable[[str, Optional[int]], Any]] = None,
+        progress_callback: ProgressCallback = None,
     ) -> List[str]:
-        """TODO: Suche auf der Zielseite implementieren."""
+        """Sucht Titel auf der Zielseite und liefert eine Liste an Titel-Strings.
+
+        Best Practices:
+        - Nur passende Titel liefern (wortbasiert, keine Zufallstreffer).
+        - `progress_callback(message, percent)` sparsam nutzen, um lange Suchen anzuzeigen.
+        - HTTP-Requests robust kapseln (Timeouts, Fehlerbehandlung, optionales Logging).
+        """
+
         _ = (query, progress_callback)
         return []
 
     def seasons_for(self, title: str) -> List[str]:
-        """TODO: Staffeln fuer einen Titel liefern."""
+        """Liefert alle Staffeln fuer einen Titel, z.B. `['Staffel 1', 'Staffel 2']`.
+
+        Fuer reine Film-Provider kann stattdessen z.B. `['Film']` zurueckgegeben werden
+        (siehe \"Film Provider Standard\" in `docs/PLUGIN_DEVELOPMENT.md`).
+        """
+
         _ = title
         return []
 
     def episodes_for(self, title: str, season: str) -> List[str]:
-        """TODO: Episoden fuer Titel+Staffel liefern."""
+        """Liefert Episoden-Labels fuer einen Titel und eine Staffel.
+
+        Beispiele:
+        - `['Episode 1', 'Episode 2']`
+        - `['Episode 1: Pilot', 'Episode 2: Finale']`
+        """
+
         _ = (title, season)
         return []
 
     def capabilities(self) -> set[str]:
-        """Optional: Deklariert Fähigkeiten dieses Plugins.
+        """Optional: Deklariert die Faehigkeiten dieses Plugins.
 
         Beispiele:
-        - `popular_series`: Plugin kann beliebte Serien liefern
-        - `genres`: Plugin unterstützt Genre-Browser
+        - `popular_series`: Plugin kann beliebte Titel liefern
+        - `genres`: Plugin unterstuetzt Genre-Browser
+        - `latest_episodes`: Plugin liefert eine Liste neuer Episoden
         """
 
         return set()
 
     def popular_series(self) -> List[str]:
-        """Optional: Liste beliebter Serien (nur wenn `popular_series` gesetzt ist)."""
+        """Optional: Liste beliebter Titel (wenn `popular_series` in `capabilities()` gesetzt ist)."""
+
         return []
 
     def stream_link_for(self, title: str, season: str, episode: str) -> Optional[str]:
-        """Optional: Embed-/Hoster-Link fuer eine Episode."""
+        """Optional: Embed-/Hoster-Link fuer eine Episode.
+
+        Der Router ruft diese Methode nur auf, wenn sie existiert. Der Rueckgabewert
+        ist entweder ein finaler Stream-Link oder ein Hoster-/Embed-Link, der spaeter
+        ueber `resolve_stream_link` oder ResolveURL weiter aufgeloest werden kann.
+        """
+
         _ = (title, season, episode)
         return None
 
     def resolve_stream_link(self, link: str) -> Optional[str]:
-        """Optional: Redirect-/Mirror-Aufloesung."""
+        """Optional: Redirect-/Mirror-Aufloesung fuer Hoster-Links.
+
+        Falls nicht ueberschrieben, kann der Router (oder ResolveURL) den Link
+        direkt verwenden. Plugins koennen hier z.B. HTTP-Redirects verfolgen.
+        """
+
         return link

addon/plugins/aniworld_plugin.py

@@ -39,6 +39,8 @@ from plugin_interface import BasisPlugin
 from plugin_helpers import dump_response_html, get_setting_bool, get_setting_string, log_error, log_url, notify_url
 from http_session_pool import get_requests_session
 from regex_patterns import DIGITS, SEASON_EPISODE_TAG, SEASON_EPISODE_URL, STAFFEL_NUM_IN_URL
+from search_utils import matches_query as _shared_matches_query, normalize_search_text as _shared_normalize_search_text
+from genre_utils import normalize_genre_label as _normalize_genre_label
 
 if TYPE_CHECKING:  # pragma: no cover
     from requests import Session as RequestsSession
@@ -257,10 +259,7 @@ def _log_error(message: str) -> None:
 
 
 def _normalize_search_text(value: str) -> str:
-    value = (value or "").casefold()
-    value = re.sub(r"[^a-z0-9]+", " ", value)
-    value = re.sub(r"\s+", " ", value).strip()
-    return value
+    return _shared_normalize_search_text(value)
 
 
 def _strip_html(text: str) -> str:
@@ -270,11 +269,7 @@ def _strip_html(text: str) -> str:
 
 
 def _matches_query(query: str, *, title: str) -> bool:
-    normalized_query = _normalize_search_text(query)
-    if not normalized_query:
-        return False
-    haystack = f" {_normalize_search_text(title)} "
-    return f" {normalized_query} " in haystack
+    return _shared_matches_query(query, title=title)
 
 
 def _ensure_requests() -> None:
@@ -357,28 +352,6 @@ def _get_soup_simple(url: str) -> BeautifulSoupT:
     return BeautifulSoup(body, "html.parser")
 
 
-def _normalize_genre_label(raw: str) -> str:
-    text = unescape(re.sub(r"\s+", " ", str(raw or ""))).strip()
-    if not text:
-        return ""
-    key_prefix = "filter.genre_"
-    if text.casefold().startswith(key_prefix):
-        slug = text[len(key_prefix) :].strip().casefold()
-        slug = slug.replace("_", "-")
-        slug = re.sub(r"[^a-z0-9-]+", "-", slug).strip("-")
-        if not slug:
-            return ""
-        special = {
-            "doku-soap": "Doku-Soap",
-            "scifi": "SciFi",
-            "fighting-shounen": "Fighting-Shounen",
-        }
-        if slug in special:
-            return special[slug]
-        return " ".join(chunk.capitalize() for chunk in slug.split("-") if chunk)
-    return text
-
-
 def _extract_genre_names_from_html(body: str) -> List[str]:
     names: List[str] = []
     seen: set[str] = set()

addon/plugins/dokustreams_plugin.py

@@ -21,6 +21,7 @@ else:
 
 from plugin_interface import BasisPlugin
 from plugin_helpers import dump_response_html, get_setting_bool, get_setting_string, log_error, log_url, notify_url
+from search_utils import matches_query as _shared_matches_query, normalize_search_text as _shared_normalize_search_text
 from http_session_pool import get_requests_session
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -161,18 +162,11 @@ def _absolute_url(url: str) -> str:
 
 
 def _normalize_search_text(value: str) -> str:
-    value = (value or "").casefold()
-    value = re.sub(r"[^a-z0-9]+", " ", value)
-    value = re.sub(r"\s+", " ", value).strip()
-    return value
+    return _shared_normalize_search_text(value)
 
 
 def _matches_query(query: str, *, title: str) -> bool:
-    normalized_query = _normalize_search_text(query)
-    if not normalized_query:
-        return False
-    haystack = f" {_normalize_search_text(title)} "
-    return f" {normalized_query} " in haystack
+    return _shared_matches_query(query, title=title)
 
 
 def _log_url_event(url: str, *, kind: str = "VISIT") -> None:

addon/plugins/einschalten_plugin.py

@@ -31,6 +31,7 @@ except ImportError:  # pragma: no cover - allow running outside Kodi
 
 from plugin_interface import BasisPlugin
 from plugin_helpers import dump_response_html, get_setting_bool, log_error, log_url, notify_url
+from search_utils import matches_query as _shared_matches_query, normalize_search_text as _shared_normalize_search_text
 
 ADDON_ID = "plugin.video.viewit"
 SETTING_BASE_URL = "einschalten_base_url"
@@ -97,18 +98,11 @@ class MovieDetail:
 
 
 def _normalize_search_text(value: str) -> str:
-    value = (value or "").casefold()
-    value = re.sub(r"[^a-z0-9]+", " ", value)
-    value = re.sub(r"\s+", " ", value).strip()
-    return value
+    return _shared_normalize_search_text(value)
 
 
 def _matches_query(query: str, *, title: str) -> bool:
-    normalized_query = _normalize_search_text(query)
-    if not normalized_query:
-        return False
-    haystack = f" {_normalize_search_text(title)} "
-    return f" {normalized_query} " in haystack
+    return _shared_matches_query(query, title=title)
 
 
 def _filter_movies_by_title(query: str, movies: List[MovieItem]) -> List[MovieItem]:

addon/plugins/filmpalast_plugin.py

@@ -27,6 +27,7 @@ else:
 
 from plugin_interface import BasisPlugin
 from plugin_helpers import dump_response_html, get_setting_bool, get_setting_string, log_error, log_url, notify_url
+from search_utils import matches_query as _shared_matches_query, normalize_search_text as _shared_normalize_search_text
 from http_session_pool import get_requests_session
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -106,18 +107,11 @@ def _absolute_url(url: str) -> str:
 
 
 def _normalize_search_text(value: str) -> str:
-    value = (value or "").casefold()
-    value = re.sub(r"[^a-z0-9]+", " ", value)
-    value = re.sub(r"\s+", " ", value).strip()
-    return value
+    return _shared_normalize_search_text(value)
 
 
 def _matches_query(query: str, *, title: str) -> bool:
-    normalized_query = _normalize_search_text(query)
-    if not normalized_query:
-        return False
-    haystack = f" {_normalize_search_text(title)} "
-    return f" {normalized_query} " in haystack
+    return _shared_matches_query(query, title=title)
 
 
 def _is_probably_content_url(url: str) -> bool:

addon/plugins/serienstream_plugin.py

@@ -43,8 +43,10 @@ except ImportError:  # pragma: no cover - allow running outside Kodi
 
 from plugin_interface import BasisPlugin
 from plugin_helpers import dump_response_html, get_setting_bool, get_setting_string, log_error, log_url, notify_url
-from http_session_pool import get_requests_session
+from http_session_pool import close_all_sessions, get_requests_session
 from regex_patterns import SEASON_EPISODE_TAG, SEASON_EPISODE_URL
+from search_utils import matches_query as _matches_query, normalize_search_text as _normalize_search_text
+from genre_utils import normalize_genre_label as _normalize_genre_label
 
 if TYPE_CHECKING:  # pragma: no cover
     from requests import Session as RequestsSession
@@ -293,27 +295,6 @@ def _normalize_text(value: str) -> str:
     return value
 
 
-def _normalize_search_text(value: str) -> str:
-    """Normalisiert Text für die Suche ohne Wortgrenzen zu "verschmelzen".
-
-    Wichtig: Wir ersetzen Nicht-Alphanumerisches durch Leerzeichen, statt es zu entfernen.
-    Dadurch entstehen keine künstlichen Treffer über Wortgrenzen hinweg (z.B. "an" + "na" -> "anna").
-    """
-
-    value = (value or "").casefold()
-    value = re.sub(r"[^a-z0-9]+", " ", value)
-    value = re.sub(r"\s+", " ", value).strip()
-    return value
-
-
-def _matches_query(query: str, *, title: str) -> bool:
-    normalized_query = _normalize_search_text(query)
-    if not normalized_query:
-        return False
-    haystack = f" {_normalize_search_text(title)} "
-    return f" {normalized_query} " in haystack
-
-
 def _is_episode_tba(title: str, original_title: str) -> bool:
     combined = f"{title} {original_title}".casefold()
     markers = ("tba", "demnächst", "demnaechst", "coming soon", "to be announced")
@@ -392,6 +373,42 @@ def _ensure_requests() -> None:
         raise RuntimeError("requests/bs4 sind nicht verfuegbar.")
 
 
+def _is_retryable_http_error(exc: Exception) -> bool:
+    text = str(exc or "").casefold()
+    markers = (
+        "connection reset by peer",
+        "connection aborted",
+        "remote end closed connection",
+        "temporarily unavailable",
+        "timed out",
+        "read timeout",
+    )
+    return any(marker in text for marker in markers)
+
+
+def _http_get(url: str, *, timeout: int, params: Optional[dict[str, str]] = None):
+    _ensure_requests()
+    last_exc: Exception | None = None
+    for attempt in range(2):
+        sess = get_requests_session("serienstream", headers=HEADERS)
+        try:
+            response = sess.get(url, params=params, headers=HEADERS, timeout=timeout)
+            response.raise_for_status()
+            return response
+        except Exception as exc:
+            last_exc = exc
+            if attempt >= 1 or not _is_retryable_http_error(exc):
+                raise
+            _log_error(f"GET {url} retry nach Fehler: {exc}")
+            try:
+                close_all_sessions()
+            except Exception:
+                pass
+    if last_exc is not None:
+        raise last_exc
+    raise RuntimeError(f"GET {url} fehlgeschlagen")
+
+
 def _looks_like_cloudflare_challenge(body: str) -> bool:
     lower = body.lower()
     markers = (
@@ -409,11 +426,13 @@ def _looks_like_cloudflare_challenge(body: str) -> bool:
 def _get_soup(url: str, *, session: Optional[RequestsSession] = None) -> BeautifulSoupT:
     _ensure_requests()
     _log_visit(url)
-    sess = session or get_requests_session("serienstream", headers=HEADERS)
     response = None
     try:
-        response = sess.get(url, headers=HEADERS, timeout=DEFAULT_TIMEOUT)
-        response.raise_for_status()
+        if session is not None:
+            response = session.get(url, headers=HEADERS, timeout=DEFAULT_TIMEOUT)
+            response.raise_for_status()
+        else:
+            response = _http_get(url, timeout=DEFAULT_TIMEOUT)
     except Exception as exc:
         _log_error(f"GET {url} failed: {exc}")
         raise
@@ -437,11 +456,9 @@ def _get_soup(url: str, *, session: Optional[RequestsSession] = None) -> Beautif
 def _get_html_simple(url: str) -> str:
     _ensure_requests()
     _log_visit(url)
-    sess = get_requests_session("serienstream", headers=HEADERS)
     response = None
     try:
-        response = sess.get(url, headers=HEADERS, timeout=DEFAULT_TIMEOUT)
-        response.raise_for_status()
+        response = _http_get(url, timeout=DEFAULT_TIMEOUT)
     except Exception as exc:
         _log_error(f"GET {url} failed: {exc}")
         raise
@@ -468,27 +485,6 @@ def _get_soup_simple(url: str) -> BeautifulSoupT:
 
 
 def _extract_genre_names_from_html(body: str) -> List[str]:
-    def _normalize_genre_label(raw: str) -> str:
-        text = unescape(re.sub(r"\s+", " ", str(raw or ""))).strip()
-        if not text:
-            return ""
-        key_prefix = "filter.genre_"
-        if text.casefold().startswith(key_prefix):
-            slug = text[len(key_prefix) :].strip().casefold()
-            slug = slug.replace("_", "-")
-            slug = re.sub(r"[^a-z0-9-]+", "-", slug).strip("-")
-            if not slug:
-                return ""
-            special = {
-                "doku-soap": "Doku-Soap",
-                "scifi": "SciFi",
-                "fighting-shounen": "Fighting-Shounen",
-            }
-            if slug in special:
-                return special[slug]
-            return " ".join(chunk.capitalize() for chunk in slug.split("-") if chunk)
-        return text
-
     names: List[str] = []
     seen: set[str] = set()
     pattern = re.compile(
@@ -577,9 +573,6 @@ def _search_series_api(query: str) -> List[SeriesResult]:
 def _search_series_server(query: str) -> List[SeriesResult]:
     if not query:
         return []
-    api_results = _search_series_api(query)
-    if api_results:
-        return api_results
     base = _get_base_url()
     search_url = f"{base}/search?q={quote(query)}"
     alt_url = f"{base}/suche?q={quote(query)}"
@@ -614,6 +607,9 @@ def _search_series_server(query: str) -> List[SeriesResult]:
             results.append(SeriesResult(title=title, description="", url=url_abs))
         if results:
             return results
+    api_results = _search_series_api(query)
+    if api_results:
+        return api_results
     return []
 
 
@@ -718,56 +714,45 @@ def search_series(query: str, *, progress_callback: ProgressCallback = None) ->
     _ensure_requests()
     if not _normalize_search_text(query):
         return []
-    _emit_progress(progress_callback, "Server-Suche", 15)
-    server_results = _search_series_server(query)
-    if server_results:
-        _emit_progress(progress_callback, f"Server-Treffer: {len(server_results)}", 35)
-        return [entry for entry in server_results if entry.title and _matches_query(query, title=entry.title)]
-    _emit_progress(progress_callback, "Pruefe Such-Cache", 42)
+    _emit_progress(progress_callback, "Pruefe Such-Cache", 15)
     cached = _load_catalog_index_from_cache()
     if cached is not None:
-        _emit_progress(progress_callback, f"Cache-Treffer: {len(cached)}", 52)
-        return [entry for entry in cached if entry.title and _matches_query(query, title=entry.title)]
+        matched_from_cache = [entry for entry in cached if entry.title and _matches_query(query, title=entry.title)]
+        _emit_progress(progress_callback, f"Cache-Treffer: {len(cached)}", 35)
+        if matched_from_cache:
+            return matched_from_cache
 
-    _emit_progress(progress_callback, "Lade Katalogseite", 58)
+    _emit_progress(progress_callback, "Lade Katalogseite", 42)
     catalog_url = f"{_get_base_url()}/serien?by=genre"
-    body = _get_html_simple(catalog_url)
-    items = _extract_catalog_index_from_html(body, progress_callback=progress_callback)
-    if not items:
-        _emit_progress(progress_callback, "Fallback-Parser", 70)
-        soup = BeautifulSoup(body, "html.parser")
+    items: List[SeriesResult] = []
+    try:
+        # Bevorzugt den Soup-Helper, damit Tests HTML einfache injizieren koennen.
+        soup = _get_soup_simple(catalog_url)
         items = _catalog_index_from_soup(soup)
+    except Exception:
+        body = _get_html_simple(catalog_url)
+        items = _extract_catalog_index_from_html(body, progress_callback=progress_callback)
+        if not items:
+            _emit_progress(progress_callback, "Fallback-Parser", 58)
+            soup = BeautifulSoup(body, "html.parser")
+            items = _catalog_index_from_soup(soup)
     if items:
         _store_catalog_index_in_cache(items)
-    _emit_progress(progress_callback, f"Filtere Treffer ({len(items)})", 85)
-    return [entry for entry in items if entry.title and _matches_query(query, title=entry.title)]
+        _emit_progress(progress_callback, f"Filtere Treffer ({len(items)})", 70)
+        return [entry for entry in items if entry.title and _matches_query(query, title=entry.title)]
+
+    _emit_progress(progress_callback, "Server-Suche", 85)
+    server_results = _search_series_server(query)
+    if server_results:
+        _emit_progress(progress_callback, f"Server-Treffer: {len(server_results)}", 95)
+        return [entry for entry in server_results if entry.title and _matches_query(query, title=entry.title)]
+    return []
 
 
 def parse_series_catalog(soup: BeautifulSoupT) -> Dict[str, List[SeriesResult]]:
     """Parst die Serien-Übersicht (/serien) und liefert Genre -> Serienliste."""
     catalog: Dict[str, List[SeriesResult]] = {}
 
-    def _normalize_genre_label(raw: str) -> str:
-        text = re.sub(r"\s+", " ", str(raw or "")).strip()
-        if not text:
-            return ""
-        key_prefix = "filter.genre_"
-        if text.casefold().startswith(key_prefix):
-            slug = text[len(key_prefix) :].strip().casefold()
-            slug = slug.replace("_", "-")
-            slug = re.sub(r"[^a-z0-9-]+", "-", slug).strip("-")
-            if not slug:
-                return ""
-            special = {
-                "doku-soap": "Doku-Soap",
-                "scifi": "SciFi",
-                "fighting-shounen": "Fighting-Shounen",
-            }
-            if slug in special:
-                return special[slug]
-            return " ".join(chunk.capitalize() for chunk in slug.split("-") if chunk)
-        return text
-
     # Neues Layout (Stand: 2026-01): Gruppen-Header + Liste.
     # - Header: `div.background-1 ...` mit `h3`
     # - Einträge: `ul.series-list` -> `li.series-item[data-search]` -> `a[href]`

addon/plugins/topstreamfilm_plugin.py

@@ -46,6 +46,7 @@ except ImportError:  # pragma: no cover - allow running outside Kodi
 from plugin_interface import BasisPlugin
 from plugin_helpers import dump_response_html, get_setting_bool, log_error, log_url, notify_url
 from regex_patterns import DIGITS
+from search_utils import matches_query as _shared_matches_query, normalize_search_text as _shared_normalize_search_text
 
 if TYPE_CHECKING:  # pragma: no cover
     from requests import Session as RequestsSession
@@ -98,24 +99,12 @@ class SearchHit:
 
 
 def _normalize_search_text(value: str) -> str:
-    """Normalisiert Text für robuste, wortbasierte Suche/Filter.
-
-    Wir ersetzen Nicht-Alphanumerisches durch Leerzeichen und kollabieren Whitespace.
-    Dadurch kann z.B. "Star Trek: Lower Decks – Der Film" sauber auf Tokens gematcht werden.
-    """
-
-    value = (value or "").casefold()
-    value = re.sub(r"[^a-z0-9]+", " ", value)
-    value = re.sub(r"\s+", " ", value).strip()
-    return value
+    return _shared_normalize_search_text(value)
 
 
 def _matches_query(query: str, *, title: str, description: str) -> bool:
-    normalized_query = _normalize_search_text(query)
-    if not normalized_query:
-        return False
-    haystack = f" {_normalize_search_text(title)} "
-    return f" {normalized_query} " in haystack
+    _ = description
+    return _shared_matches_query(query, title=title)
 
 
 def _strip_der_film_suffix(title: str) -> str: