MangaUpdates 400 error on empty localized name kills entire provider chain

[xxxarmitagexxx]

Summary

When a series in Kavita has no localized name set, as is the default behavior for most Mangas source, Kavita returns an empty string "" for that field. Komf picks it up as an alternative title and includes it in the search title list. When MangaUpdates receives a search request with an empty search field, it returns a 400 Bad Request. Komf treats this as a fatal provider error and aborts the entire matching attempt — no other configured providers (AniList, MangaBaka, etc.) are tried for that series.

---

Steps to reproduce

1. Have a series in Kavita with no localized name set (this is the default state for any series that hasn't had one manually entered).
2. Configure Komf with MangaUpdates enabled at a higher priority than other providers.
3. Trigger a library scan or metadata refresh for that series.
4. Observe: MangaUpdates is called twice — once with the actual series title, once with "". The second call returns 400. No other provider runs.

Tested with "Frieren - Beyond Journey's End" and "Witch Hat Atelier" in Kavita, which are both referenced in MangaUpdate as their Japanese romanized title.

---

Root cause

Two separate issues combine to produce this:

Issue 1 — Missing blank check in KavitaMediaServerClientAdapter

KavitaMediaServerClientAdapter.kt maps Kavita's localizedName field to alternativeTitles:

alternativeTitles = series.localizedName?.let { listOf(MediaServerAlternativeTitle("Localized", it)) }
    ?: emptyList()

The ?.let guards against null but not against "". Kavita returns "" when no localized name is set, so the guard passes and the empty string ends up in the list.

Issue 2 — ProviderException escapes firstNotNullOfOrNull in MetadataService

matchSeries() wraps every provider exception into a ProviderException and re-throws it:

val result = try {
    provider.matchSeriesMetadata(...)
} catch (e: Exception) {
    throw ProviderException(provider.providerName(), e)
}

The caller uses firstNotNullOfOrNull to iterate providers in priority order:

metadataProviders.providers(...).firstNotNullOfOrNull { provider ->
    matchSeries(series, books, searchTitles, provider, null, eventFlow)
        ?.let { provider to it }
}

firstNotNullOfOrNull only handles null — it doesn't catch exceptions. So when MangaUpdates throws on the empty string, the exception escapes the loop and the remaining providers are never reached. This means a single provider failure on one search title can silently block all fallback providers for the entire series.

---

Expected behaviour

• KavitaMediaServerClientAdapter should skip blank localized names rather than include them as alternative titles.
• matchSeries / firstNotNullOfOrNull should treat a provider error as a non-fatal per-provider failure, log it, and continue to the next provider in the chain.

[xxxarmitagexxx]

Proposed Fixes

Fix 1 — Blank-check localizedName before adding to alternativeTitles

In KavitaMediaServerClientAdapter, change the guard to also reject empty strings:

alternativeTitles = series.localizedName?.takeIf { it.isNotBlank() }
    ?.let { listOf(MediaServerAlternativeTitle("Localized", it)) }
    ?: emptyList()

File: komf-mediaserver/.../kavita/KavitaMediaServerClientAdapter.kt, around line 291.

Fix 2 — Provider failure should not kill the chain (correctness bug)

In MetadataService, wrap the matchSeries() call inside firstNotNullOfOrNull in a
try/catch for ProviderException. On catch, log a warning and return null so the next
provider is tried. The exception is already caught and reported at the job level (line ~420)
for the case where all providers fail, so this change only affects the per-provider loop.

File: komf-mediaserver/.../metadata/MetadataService.kt, around line 186.

Fix 3 — Tiered search with associated name matching and Kavita write-back

Change MangaUpdatesMetadataProvider.matchSeriesMetadata() to implement a three-tier search:

Tier 1 (current, fast): Search MangaUpdates, match against primary title. Return immediately
if found.

Tier 2 (current, fast): Already handled upstream — MetadataService loops over Kavita
alternate titles as additional search terms, each hitting Tier 1.

Tier 3 (new, slow path): If Tier 1 and 2 both fail, re-use the same search results already
fetched and for each result call getSeries() to fetch the full record. Check the series name
against the associated names list. Return the match if found.

The Tier 3 slow path is only triggered when Tier 1 and 2 fail, so the extra API calls are not
incurred on normal runs.

Write-back to avoid repeated slow path lookups:

When a match is found via Tier 3, the MangaUpdates primary title (e.g. "Sousou no Frieren")
should be written back to Kavita as an alternate title for that series. On subsequent runs,
MetadataService will include it in searchTitles, Tier 1 will match directly, and the slow
path is never needed again.

Implementation note: matchSeriesMetadata() currently returns ProviderSeriesMetadata? and
has no mechanism to trigger a Kavita write-back. The recommended approach is to introduce a
Pair<ProviderSeriesMetadata, String?> return type scoped to MangaUpdatesMetadataProvider
(not the shared MetadataProvider interface), and handle the write-back in MetadataService
after the provider loop — calling updateSeriesMetadata() on mediaServerClient with only
alternativeTitles set to the matched primary title. This keeps the interface stable and
the concern localised.

Files Affected

• komf-mediaserver/.../kavita/KavitaMediaServerClientAdapter.kt
• komf-mediaserver/.../metadata/MetadataService.kt
• komf-core/.../mangaupdates/MangaUpdatesMetadataProvider.kt