refactor(jellyseerr): keep the server version out of the field UI; enforce it at login

The resolver field only needs to find the working URL — the Jellyseerr version requirement is irrelevant there and only polluted the UI.

- jellyseerrProbe: validate reachability + that it's a jellyseerr (no version gate, no version-too-low outcome).

- Drop the version-too-low reason from the whole resolver stack (types, resolve, hook, status text, i18n).

- Min version 2.0.0 stays enforced in JellyseerrApi.test() at login: now writes an error log + toast, and uses numeric isVersionBelow (fixes the "2.10.0" < "2.0.0" string-compare bug).

app/(auth)/(tabs)/(home)/settings/plugins/marlin-search/page.tsx

@@ -11,12 +11,15 @@ import {
 } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 import { toast } from "sonner-native";
+import { ServerUrlStatusText } from "@/components/common/ServerUrlStatusText";
 import { Text } from "@/components/common/Text";
 import { ListGroup } from "@/components/list/ListGroup";
 import { ListItem } from "@/components/list/ListItem";
 import DisabledSetting from "@/components/settings/DisabledSetting";
 import { useNetworkAwareQueryClient } from "@/hooks/useNetworkAwareQueryClient";
+import { useServerUrlResolver } from "@/hooks/useServerUrlResolver";
 import { useSettings } from "@/utils/atoms/settings";
+import { reachabilityProbe } from "@/utils/serverUrl/probes/reachability";
 
 export default function MarlinSearchPage() {
   const navigation = useNavigation();
@@ -29,6 +32,7 @@ export default function MarlinSearchPage() {
   const queryClient = useNetworkAwareQueryClient();
 
   const [value, setValue] = useState<string>(settings?.marlinServerUrl || "");
+  const urlResolver = useServerUrlResolver(reachabilityProbe);
 
   const onSave = (val: string) => {
     updateSettings({
@@ -127,8 +131,17 @@ export default function MarlinSearchPage() {
               autoCapitalize='none'
               textContentType='URL'
               onChangeText={(text) => setValue(text)}
+              onBlur={() => {
+                const candidate = value.trim();
+                if (candidate) {
+                  urlResolver.resolve(candidate).then((r) => {
+                    if (r.ok) setValue(r.url);
+                  });
+                }
+              }}
             />
           </View>
+          <ServerUrlStatusText state={urlResolver} className='mt-1' />
         </DisabledSetting>
         <Text className='px-4 text-xs text-neutral-500 mt-1'>
           {t("home.settings.plugins.marlin_search.marlin_search_hint")}{" "}

app/(auth)/(tabs)/(home)/settings/plugins/streamystats/page.tsx

@@ -11,11 +11,14 @@ import {
 } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 import { toast } from "sonner-native";
+import { ServerUrlStatusText } from "@/components/common/ServerUrlStatusText";
 import { Text } from "@/components/common/Text";
 import { ListGroup } from "@/components/list/ListGroup";
 import { ListItem } from "@/components/list/ListItem";
 import { useNetworkAwareQueryClient } from "@/hooks/useNetworkAwareQueryClient";
+import { useServerUrlResolver } from "@/hooks/useServerUrlResolver";
 import { useSettings } from "@/utils/atoms/settings";
+import { reachabilityProbe } from "@/utils/serverUrl/probes/reachability";
 
 export default function StreamystatsPage() {
   const { t } = useTranslation();
@@ -32,6 +35,7 @@ export default function StreamystatsPage() {
 
   // Local state for all editable fields
   const [url, setUrl] = useState<string>(settings?.streamyStatsServerUrl || "");
+  const urlResolver = useServerUrlResolver(reachabilityProbe);
   const [useForSearch, setUseForSearch] = useState<boolean>(
     settings?.searchEngine === "Streamystats",
   );
@@ -152,9 +156,20 @@ export default function StreamystatsPage() {
               autoCapitalize='none'
               textContentType='URL'
               onChangeText={setUrl}
+              onBlur={() => {
+                const candidate = url.trim();
+                if (candidate) {
+                  urlResolver.resolve(candidate).then((r) => {
+                    if (r.ok) setUrl(r.url);
+                  });
+                }
+              }}
             />
           </ListItem>
         </ListGroup>
+        <View className='px-4 mt-1'>
+          <ServerUrlStatusText state={urlResolver} />
+        </View>
 
         <Text className='px-4 text-xs text-neutral-500 mt-1'>
           {t("home.settings.plugins.streamystats.streamystats_search_hint")}{" "}

app/(auth)/player/direct-player.tsx

@@ -439,15 +439,21 @@ export default function DirectPlayerPage() {
     if (!item?.Id || !stream?.sessionId || offline || !api) return;
 
     const currentTimeInTicks = msToTicks(progress.get());
-    await getPlaystateApi(api).reportPlaybackStopped({
+    await getPlaystateApi(api).onPlaybackStopped({
-      playbackStopInfo: {
+      itemId: item.Id,
-        ItemId: item.Id,
+      mediaSourceId: mediaSourceId,
-        MediaSourceId: mediaSourceId,
+      positionTicks: currentTimeInTicks,
-        PositionTicks: currentTimeInTicks,
+      playSessionId: stream.sessionId,
-        PlaySessionId: stream.sessionId,
-      },
     });
-  }, [api, item, mediaSourceId, stream, progress, offline]);
+  }, [
+    api,
+    item,
+    mediaSourceId,
+    stream,
+    progress,
+    offline,
+    revalidateProgressCache,
+  ]);
 
   const stop = useCallback(() => {
     // Update URL with final playback position before stopping
@@ -465,10 +471,9 @@ export default function DirectPlayerPage() {
   useEffect(() => {
     const beforeRemoveListener = navigation.addListener("beforeRemove", stop);
     return () => {
-      reportPlaybackStopped();
       beforeRemoveListener();
     };
-  }, [navigation, stop, reportPlaybackStopped]);
+  }, [navigation, stop]);
 
   const currentPlayStateInfo = useCallback(():
     | PlaybackProgressInfo

components/common/ServerUrlField.tsx

@@ -0,0 +1,99 @@
+import { useCallback, useRef } from "react";
+import { View } from "react-native";
+import { useServerUrlResolver } from "@/hooks/useServerUrlResolver";
+import type { ResolveOptions } from "@/utils/serverUrl/resolve";
+import type { ServerProbe } from "@/utils/serverUrl/types";
+import { Input } from "./Input";
+import { ServerUrlStatusText } from "./ServerUrlStatusText";
+import { Text } from "./Text";
+
+interface ServerUrlFieldProps {
+  /** Raw user input (controlled). */
+  value: string;
+  onChangeText: (text: string) => void;
+  /** Service-specific validator. Pass a stable (module-level) reference. */
+  probe: ServerProbe;
+  /** Called with the canonical URL once a candidate validates. */
+  onResolved?: (url: string, meta?: Record<string, unknown>) => void;
+  label?: string;
+  hint?: string;
+  placeholder?: string;
+  editable?: boolean;
+  resolveOptions?: ResolveOptions;
+}
+
+/**
+ * Unified server-URL input: the user types a loose address (`media.example.com`,
+ * `https://…`, `host:port`); on blur it auto-resolves via the given probe,
+ * adopts the canonical URL into the field, and persists it. A small status line
+ * (checking / resolved / error) shows underneath.
+ */
+export function ServerUrlField({
+  value,
+  onChangeText,
+  probe,
+  onResolved,
+  label,
+  hint,
+  placeholder,
+  editable = true,
+  resolveOptions,
+}: ServerUrlFieldProps) {
+  const resolver = useServerUrlResolver(probe, resolveOptions);
+  const lastResolvedInput = useRef<string | null>(null);
+
+  const runResolve = useCallback(async () => {
+    const input = value.trim();
+    if (!input) {
+      resolver.reset();
+      lastResolvedInput.current = null;
+      return;
+    }
+    lastResolvedInput.current = input;
+    const result = await resolver.resolve(input);
+    if (result.ok) {
+      onChangeText(result.url); // adopt the canonical URL into the field
+      onResolved?.(result.url, result.meta);
+    }
+  }, [value, resolver, onChangeText, onResolved]);
+
+  const handleBlur = useCallback(() => {
+    const input = value.trim();
+    if (input && input !== lastResolvedInput.current) runResolve();
+  }, [value, runResolve]);
+
+  const handleChange = useCallback(
+    (text: string) => {
+      onChangeText(text);
+      // Editing invalidates a previous result; drop the stale status.
+      if (resolver.status !== "idle") resolver.reset();
+      lastResolvedInput.current = null;
+    },
+    [onChangeText, resolver],
+  );
+
+  return (
+    <View>
+      {label ? <Text className='font-bold mb-1'>{label}</Text> : null}
+      {hint ? <Text className='text-xs text-gray-500 mb-2'>{hint}</Text> : null}
+
+      <Input
+        value={value}
+        onChangeText={handleChange}
+        onBlur={handleBlur}
+        onSubmitEditing={runResolve}
+        placeholder={placeholder}
+        editable={editable}
+        extraClassName='border border-neutral-800'
+        keyboardType='url'
+        autoCapitalize='none'
+        autoCorrect={false}
+        returnKeyType='go'
+        textContentType='URL'
+        clearButtonMode='never'
+      />
+
+      <ServerUrlStatusText state={resolver} className='mt-2' />
+    </View>
+  );
+}

components/common/ServerUrlStatusText.tsx

@@ -0,0 +1,49 @@
+import { useTranslation } from "react-i18next";
+import { ActivityIndicator, View } from "react-native";
+import type { ServerUrlResolverState } from "@/hooks/useServerUrlResolver";
+import { Text } from "./Text";
+
+/**
+ * Compact status line for the server-URL resolver, for screens whose layout
+ * (e.g. ListItem rows) doesn't fit the full `ServerUrlField`. Renders nothing
+ * while idle.
+ */
+export function ServerUrlStatusText({
+  state,
+  className = "",
+}: {
+  state: ServerUrlResolverState;
+  className?: string;
+}) {
+  const { t } = useTranslation();
+
+  if (state.status === "idle") return null;
+
+  if (state.status === "resolving") {
+    return (
+      <View className={`flex-row items-center ${className}`}>
+        <ActivityIndicator size='small' color='#9ca3af' />
+        <Text className='text-xs text-neutral-400 ml-2'>
+          {t("server_url.resolving")}
+        </Text>
+      </View>
+    );
+  }
+
+  if (state.status === "ok") {
+    return (
+      <Text className={`text-xs text-green-500 ${className}`}>
+        {t("server_url.resolved", { url: state.resolvedUrl })}
+      </Text>
+    );
+  }
+
+  const message =
+    state.reason === "wrong-service"
+      ? t("server_url.wrong_service")
+      : state.reason === "invalid"
+        ? t("server_url.invalid_url")
+        : t("server_url.unreachable");
+
+  return <Text className={`text-xs text-red-500 ${className}`}>{message}</Text>;
+}

components/companion/CompanionLoginScreen.tsx

@@ -11,10 +11,13 @@ import {
   View,
 } from "react-native";
 import { Button } from "@/components/Button";
+import { ServerUrlStatusText } from "@/components/common/ServerUrlStatusText";
 import { Text } from "@/components/common/Text";
 import useRouter from "@/hooks/useAppRouter";
+import { useServerUrlResolver } from "@/hooks/useServerUrlResolver";
 import { apiAtom, userAtom } from "@/providers/JellyfinProvider";
 import { sendCredentialsToTV } from "@/utils/pairingService";
+import { jellyfinProbe } from "@/utils/serverUrl/probes/jellyfin";
 
 type ScreenState =
   | "scanning"
@@ -49,6 +52,7 @@ export const CompanionLoginScreen: React.FC = () => {
   const [username, setUsername] = useState("");
   const [password, setPassword] = useState("");
   const [errorMessage, setErrorMessage] = useState<string | null>(null);
+  const serverResolver = useServerUrlResolver(jellyfinProbe);
 
   // Pre-fill server URL and username from current session
   useEffect(() => {
@@ -405,7 +409,16 @@ export const CompanionLoginScreen: React.FC = () => {
               autoCorrect={false}
               keyboardType='url'
               returnKeyType='next'
+              onBlur={() => {
+                const candidate = serverUrl.trim();
+                if (candidate) {
+                  serverResolver.resolve(candidate).then((r) => {
+                    if (r.ok) setServerUrl(r.url);
+                  });
+                }
+              }}
             />
+            <ServerUrlStatusText state={serverResolver} className='mt-2' />
           </View>
 
           <View className='mb-5'>

components/settings/Jellyseerr.tsx

@@ -7,8 +7,11 @@ import { toast } from "sonner-native";
 import { JellyseerrApi, useJellyseerr } from "@/hooks/useJellyseerr";
 import { userAtom } from "@/providers/JellyfinProvider";
 import { useSettings } from "@/utils/atoms/settings";
+import { jellyseerrProbe } from "@/utils/serverUrl/probes/jellyseerr";
+import { resolveServerUrl } from "@/utils/serverUrl/resolve";
 import { Button } from "../Button";
 import { Input } from "../common/Input";
+import { ServerUrlField } from "../common/ServerUrlField";
 import { Text } from "../common/Text";
 import { ListGroup } from "../list/ListGroup";
 import { ListItem } from "../list/ListItem";
@@ -26,26 +29,44 @@ export const JellyseerrSettings = () => {
     string | undefined
   >(undefined);
 
-  const [jellyseerrServerUrl, setjellyseerrServerUrl] = useState<
+  const [jellyseerrServerUrl, setjellyseerrServerUrl] = useState<string>(
-    string | undefined
+    settings?.jellyseerrServerUrl ?? "",
-  >(settings?.jellyseerrServerUrl || undefined);
+  );
+  const [resolvedUrl, setResolvedUrl] = useState<string | undefined>(
+    settings?.jellyseerrServerUrl ?? undefined,
+  );
 
   const loginToJellyseerrMutation = useMutation({
     mutationFn: async () => {
-      if (!jellyseerrServerUrl && !settings?.jellyseerrServerUrl)
-        throw new Error("Missing server url");
       if (!user?.Name)
         throw new Error("Missing required information for login");
-      const jellyseerrTempApi = new JellyseerrApi(
+
-        jellyseerrServerUrl || settings.jellyseerrServerUrl || "",
+      // Prefer the already-resolved URL; otherwise resolve the raw input now
+      // (covers tapping Login before the field's on-blur resolve settled).
+      let finalUrl = resolvedUrl || settings?.jellyseerrServerUrl || "";
+      if (!finalUrl && jellyseerrServerUrl) {
+        const resolved = await resolveServerUrl(
+          jellyseerrServerUrl,
+          jellyseerrProbe,
         );
+        if (!resolved.ok) throw new Error("Invalid server url");
+        finalUrl = resolved.url;
+      }
+      if (!finalUrl) throw new Error("Missing server url");
+
+      const jellyseerrTempApi = new JellyseerrApi(finalUrl);
       const testResult = await jellyseerrTempApi.test();
       if (!testResult.isValid) throw new Error("Invalid server url");
-      return jellyseerrTempApi.login(user.Name, jellyseerrPassword || "");
+      const loggedInUser = await jellyseerrTempApi.login(
+        user.Name,
+        jellyseerrPassword || "",
+      );
+      return { user: loggedInUser, url: finalUrl };
     },
-    onSuccess: (user) => {
+    onSuccess: ({ user: loggedInUser, url }) => {
-      setJellyseerrUser(user);
+      setJellyseerrUser(loggedInUser);
-      updateSettings({ jellyseerrServerUrl });
+      setResolvedUrl(url);
+      updateSettings({ jellyseerrServerUrl: url });
     },
     onError: () => {
       toast.error(t("jellyseerr.failed_to_login"));
@@ -59,7 +80,8 @@ export const JellyseerrSettings = () => {
     clearAllJellyseerData().finally(() => {
       setJellyseerrUser(undefined);
       setJellyseerrPassword(undefined);
-      setjellyseerrServerUrl(undefined);
+      setjellyseerrServerUrl("");
+      setResolvedUrl(undefined);
     });
   };
 
@@ -118,30 +140,20 @@ export const JellyseerrSettings = () => {
             <Text className='text-xs text-red-600 mb-2'>
               {t("home.settings.plugins.jellyseerr.jellyseerr_warning")}
             </Text>
-            <Text className='font-bold mb-1'>
+            <View className='mb-2'>
-              {t("home.settings.plugins.jellyseerr.server_url")}
+              <ServerUrlField
-            </Text>
+                value={jellyseerrServerUrl}
-            <View className='flex flex-col shrink mb-2'>
+                onChangeText={setjellyseerrServerUrl}
-              <Text className='text-xs text-gray-600'>
+                onResolved={(url) => setResolvedUrl(url)}
-                {t("home.settings.plugins.jellyseerr.server_url_hint")}
+                probe={jellyseerrProbe}
-              </Text>
+                label={t("home.settings.plugins.jellyseerr.server_url")}
-            </View>
+                hint={t("home.settings.plugins.jellyseerr.server_url_hint")}
-            <Input
-              className='border border-neutral-800 mb-2'
                 placeholder={t(
                   "home.settings.plugins.jellyseerr.server_url_placeholder",
                 )}
-              value={jellyseerrServerUrl ?? settings?.jellyseerrServerUrl}
-              defaultValue={
-                settings?.jellyseerrServerUrl ?? jellyseerrServerUrl
-              }
-              keyboardType='url'
-              returnKeyType='done'
-              autoCapitalize='none'
-              textContentType='URL'
-              onChangeText={setjellyseerrServerUrl}
                 editable={!loginToJellyseerrMutation.isPending}
               />
+            </View>
             <View>
               <Text className='font-bold mb-2'>
                 {t("home.settings.plugins.jellyseerr.password")}

components/settings/LocalNetworkSettings.tsx

@@ -12,8 +12,9 @@ import {
   type LocalNetworkConfig,
   updateServerLocalConfig,
 } from "@/utils/secureCredentials";
+import { jellyfinProbe } from "@/utils/serverUrl/probes/jellyfin";
 import { Button } from "../Button";
-import { Input } from "../common/Input";
+import { ServerUrlField } from "../common/ServerUrlField";
 import { Text } from "../common/Text";
 import { ListGroup } from "../list/ListGroup";
 import { ListItem } from "../list/ListItem";
@@ -162,13 +163,12 @@ export function LocalNetworkSettings(): React.ReactElement | null {
             }
           >
             <View className=''>
-              <Input
+              <ServerUrlField
-                placeholder={t("home.settings.network.local_url_placeholder")}
                 value={config.localUrl}
                 onChangeText={handleLocalUrlChange}
-                keyboardType='url'
+                onResolved={(url) => saveConfig({ ...config, localUrl: url })}
-                autoCapitalize='none'
+                probe={jellyfinProbe}
-                autoCorrect={false}
+                placeholder={t("home.settings.network.local_url_placeholder")}
               />
             </View>
           </ListGroup>

hooks/useJellyseerr.ts

@@ -48,6 +48,7 @@ import type {
   TvDetails,
 } from "@/utils/jellyseerr/server/models/Tv";
 import { writeErrorLog } from "@/utils/log";
+import { isVersionBelow } from "@/utils/serverUrl/semver";
 
 interface SearchParams {
   query: string;
@@ -141,10 +142,13 @@ export class JellyseerrApi {
       .then((response) => {
         const { status, headers, data } = response;
         if (inRange(status, 200, 299)) {
-          if (data.version < "2.0.0") {
+          if (data.version && isVersionBelow(data.version, "2.0.0")) {
             const error = t(
               "jellyseerr.toasts.jellyseer_does_not_meet_requirements",
             );
+            writeErrorLog(
+              `Jellyseerr version ${data.version} is below the required 2.0.0`,
+            );
             toast.error(error);
             throw Error(error);
           }

hooks/useServerUrlResolver.ts

@@ -0,0 +1,65 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  type ResolveFailureReason,
+  type ResolveOptions,
+  type ResolveResult,
+  resolveServerUrl,
+} from "@/utils/serverUrl/resolve";
+import type { ServerProbe } from "@/utils/serverUrl/types";
+
+export type ServerUrlResolverState =
+  | { status: "idle" }
+  | { status: "resolving" }
+  | { status: "ok"; resolvedUrl: string; meta?: Record<string, unknown> }
+  | { status: "error"; reason: ResolveFailureReason };
+
+/**
+ * Stateful wrapper around `resolveServerUrl` for screens.
+ *
+ * `resolve(input)` cancels any in-flight resolution, drives the state machine
+ * (idle → resolving → ok | error) and returns the raw result. Pass a stable
+ * (module-level) probe; memoize `options` if you supply one.
+ */
+export function useServerUrlResolver(
+  probe: ServerProbe,
+  options?: ResolveOptions,
+) {
+  const [state, setState] = useState<ServerUrlResolverState>({
+    status: "idle",
+  });
+  const abortRef = useRef<AbortController | null>(null);
+
+  const resolve = useCallback(
+    async (input: string): Promise<ResolveResult> => {
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setState({ status: "resolving" });
+
+      const result = await resolveServerUrl(input, probe, {
+        ...options,
+        signal: controller.signal,
+      });
+
+      // Ignore results from a resolution that was superseded/cancelled.
+      if (!controller.signal.aborted) {
+        setState(
+          result.ok
+            ? { status: "ok", resolvedUrl: result.url, meta: result.meta }
+            : { status: "error", reason: result.reason },
+        );
+      }
+      return result;
+    },
+    [probe, options],
+  );
+
+  const reset = useCallback(() => {
+    abortRef.current?.abort();
+    setState({ status: "idle" });
+  }, []);
+
+  useEffect(() => () => abortRef.current?.abort(), []);
+
+  return { ...state, resolve, reset };
+}

providers/JellyfinProvider.tsx

@@ -619,11 +619,6 @@ export const JellyfinProvider: React.FC<{ children: ReactNode }> = ({
             setUser(storedUser);
           }
 
-          // Dismiss splash screen with cached data immediately,
-          // fetch fresh user data in the background
-          setInitialLoaded(true);
-
-          try {
           const response = await getUserApi(apiInstance).getCurrentUser();
           setUser(response.data);
 
@@ -658,15 +653,10 @@ export const JellyfinProvider: React.FC<{ children: ReactNode }> = ({
               });
             }
           }
-          } catch (e) {
-            // Background fetch failed — app already rendered with cached data
-            console.warn("Background user fetch failed, using cached data:", e);
-          }
-        } else {
-          setInitialLoaded(true);
         }
       } catch (e) {
         console.error(e);
+      } finally {
         setInitialLoaded(true);
       }
     };

providers/WebSocketProvider.tsx

@@ -1,5 +1,4 @@
 import { getSessionApi } from "@jellyfin/sdk/lib/utils/api";
-import { router } from "expo-router";
 import { useAtomValue } from "jotai";
 import {
   createContext,
@@ -12,6 +11,7 @@ import {
   useState,
 } from "react";
 import { AppState, type AppStateStatus } from "react-native";
+import useRouter from "@/hooks/useAppRouter";
 import { useNetworkAwareQueryClient } from "@/hooks/useNetworkAwareQueryClient";
 import { apiAtom, getOrSetDeviceId } from "@/providers/JellyfinProvider";
 import { useNetworkStatus } from "@/providers/NetworkStatusProvider";
@@ -28,20 +28,6 @@ const LIBRARY_CHANGE_QUERY_KEYS = [
   ["episodes"],
 ] as const;
 
-// Query keys that depend on per-user playback state (resume position, played
-// status, favorites) and should be refreshed when the server reports a
-// `UserDataChanged`. Scoped to the progression-based sections so finishing an
-// episode does not pointlessly refetch "recently added" or suggestions.
-const USER_DATA_CHANGE_QUERY_KEYS = [
-  ["home", "continueAndNextUp"],
-  ["home", "resumeItems"],
-  ["home", "nextUp-all"],
-  ["home", "heroItems"],
-  ["resumeItems"],
-  ["nextUp-all"],
-  ["nextUp"],
-] as const;
-
 interface WebSocketMessage {
   MessageType: string;
   Data: any;
@@ -52,30 +38,10 @@ interface WebSocketProviderProps {
   children: ReactNode;
 }
 
-/**
- * Handler invoked for every message of a given `MessageType`. Receives the
- * message `Data` payload and the full message.
- */
-type WebSocketMessageHandler = (data: any, message: WebSocketMessage) => void;
-
 interface WebSocketContextType {
   ws: WebSocket | null;
   isConnected: boolean;
-  /**
-   * @deprecated Prefer `subscribe`. `lastMessage` only keeps the most recent
-   * message, so bursts arriving in the same tick are coalesced and lost. Kept
-   * for `useWebsockets` (GeneralCommand handling) until it is migrated.
-   */
   lastMessage: WebSocketMessage | null;
-  /**
-   * Subscribe to a given message type. The handler is called synchronously for
-   * every matching message (no coalescing, unlike `lastMessage`). Returns an
-   * unsubscribe function to call on cleanup.
-   */
-  subscribe: (
-    messageType: string,
-    handler: WebSocketMessageHandler,
-  ) => () => void;
   sendMessage: (message: any) => void;
   clearLastMessage: () => void;
 }
@@ -88,6 +54,7 @@ export const WebSocketProvider = ({ children }: WebSocketProviderProps) => {
   const [ws, setWs] = useState<WebSocket | null>(null);
   const [isConnected, setIsConnected] = useState(false);
   const [lastMessage, setLastMessage] = useState<WebSocketMessage | null>(null);
+  const router = useRouter();
   const queryClient = useNetworkAwareQueryClient();
   const deviceId = useMemo(() => {
     return getOrSetDeviceId();
@@ -96,52 +63,6 @@ export const WebSocketProvider = ({ children }: WebSocketProviderProps) => {
   const libraryChangeDebounceRef = useRef<ReturnType<typeof setTimeout> | null>(
     null,
   );
-  const userDataChangeDebounceRef = useRef<ReturnType<
-    typeof setTimeout
-  > | null>(null);
-
-  // Pub/sub registry: messageType -> set of handlers. Stored in a ref so
-  // subscribing/dispatching never triggers a re-render.
-  const listenersRef = useRef<Map<string, Set<WebSocketMessageHandler>>>(
-    new Map(),
-  );
-
-  const subscribe = useCallback(
-    (messageType: string, handler: WebSocketMessageHandler) => {
-      const listeners = listenersRef.current;
-      let handlers = listeners.get(messageType);
-      if (!handlers) {
-        handlers = new Set();
-        listeners.set(messageType, handlers);
-      }
-      handlers.add(handler);
-      return () => {
-        handlers?.delete(handler);
-        if (handlers && handlers.size === 0) {
-          listeners.delete(messageType);
-        }
-      };
-    },
-    [],
-  );
-
-  const dispatchMessage = useCallback((message: WebSocketMessage) => {
-    const handlers = listenersRef.current.get(message.MessageType);
-    if (!handlers || handlers.size === 0) return;
-    // Copy to tolerate handlers that unsubscribe during dispatch.
-    for (const handler of [...handlers]) {
-      // Isolate each handler so one throwing subscriber can't abort the rest
-      // (and isn't misreported as a parse failure by the outer onmessage catch).
-      try {
-        handler(message.Data, message);
-      } catch (error) {
-        console.error(
-          `Error handling WebSocket message type "${message.MessageType}":`,
-          error,
-        );
-      }
-    }
-  }, []);
 
   const connectWebSocket = useCallback(() => {
     if (!deviceId || !api?.accessToken || !isNetworkConnected) {
@@ -192,10 +113,7 @@ export const WebSocketProvider = ({ children }: WebSocketProviderProps) => {
     newWebSocket.onmessage = (e) => {
       try {
         const message = JSON.parse(e.data);
-        // Legacy single-slot state, still consumed by useWebsockets.
+        setLastMessage(message); // Store the last message in context
-        setLastMessage(message);
-        // Pub/sub: deliver to every subscriber without coalescing.
-        dispatchMessage(message);
       } catch (error) {
         console.error("Error parsing WebSocket message:", error);
       }
@@ -208,7 +126,7 @@ export const WebSocketProvider = ({ children }: WebSocketProviderProps) => {
       }
       newWebSocket.close();
     };
-  }, [api, deviceId, isNetworkConnected, dispatchMessage]);
+  }, [api, deviceId, isNetworkConnected]);
 
   const handleLibraryChanged = useCallback(
     (data: any) => {
@@ -239,53 +157,27 @@ export const WebSocketProvider = ({ children }: WebSocketProviderProps) => {
     [queryClient],
   );
 
-  const handleUserDataChanged = useCallback(
+  useEffect(() => {
-    (data: any) => {
+    if (!lastMessage) {
-      // Jellyfin sends UserDataChanged when playback position, played status
-      // or favorites change (e.g. finishing an episode). Only the
-      // progression-based home sections care about it.
-      if (!((data?.UserDataList?.length ?? 0) > 0)) {
       return;
     }
-
+    if (lastMessage.MessageType === "Play") {
-      // Finishing an item can emit several UserDataChanged messages, so
+      handlePlayCommand(lastMessage.Data);
-      // debounce to invalidate the affected sections only once.
+    } else if (lastMessage.MessageType === "LibraryChanged") {
-      if (userDataChangeDebounceRef.current) {
+      handleLibraryChanged(lastMessage.Data);
-        clearTimeout(userDataChangeDebounceRef.current);
     }
-      userDataChangeDebounceRef.current = setTimeout(() => {
+  }, [lastMessage, router, handleLibraryChanged]);
-        for (const queryKey of USER_DATA_CHANGE_QUERY_KEYS) {
-          queryClient.invalidateQueries({ queryKey: [...queryKey] });
-        }
-      }, 800);
-    },
-    [queryClient],
-  );
-
-  // Refresh library-dependent queries when the server reports a change.
-  useEffect(
-    () => subscribe("LibraryChanged", handleLibraryChanged),
-    [subscribe, handleLibraryChanged],
-  );
-
-  // Refresh "Continue Watching" / "Next Up" when playback state changes.
-  useEffect(
-    () => subscribe("UserDataChanged", handleUserDataChanged),
-    [subscribe, handleUserDataChanged],
-  );
 
   useEffect(() => {
     return () => {
       if (libraryChangeDebounceRef.current) {
         clearTimeout(libraryChangeDebounceRef.current);
       }
-      if (userDataChangeDebounceRef.current) {
-        clearTimeout(userDataChangeDebounceRef.current);
-      }
     };
   }, []);
 
-  const handlePlayCommand = useCallback((data: any) => {
+  const handlePlayCommand = useCallback(
+    (data: any) => {
       if (!data?.ItemIds?.length) {
         return;
       }
@@ -304,12 +196,8 @@ export const WebSocketProvider = ({ children }: WebSocketProviderProps) => {
           offline: "false",
         },
       });
-  }, []);
+    },
-
+    [router],
-  // Server-initiated "Play me this item" remote command.
-  useEffect(
-    () => subscribe("Play", handlePlayCommand),
-    [subscribe, handlePlayCommand],
   );
 
   useEffect(() => {
@@ -379,14 +267,7 @@ export const WebSocketProvider = ({ children }: WebSocketProviderProps) => {
   }, []);
   return (
     <WebSocketContext.Provider
-      value={{
+      value={{ ws, isConnected, lastMessage, sendMessage, clearLastMessage }}
-        ws,
-        isConnected,
-        lastMessage,
-        subscribe,
-        sendMessage,
-        clearLastMessage,
-      }}
     >
       {children}
     </WebSocketContext.Provider>

translations/en.json

@@ -1,4 +1,12 @@
 {
+  "server_url": {
+    "resolving": "Checking…",
+    "resolved": "→ {{url}}",
+    "connected": "Connected to {{url}}",
+    "unreachable": "Server unreachable",
+    "wrong_service": "Reachable, but not the expected server",
+    "invalid_url": "Enter a valid address"
+  },
   "login": {
     "username_required": "Username Is Required",
     "error_title": "Error",

utils/serverUrl/candidates.ts

@@ -0,0 +1,75 @@
+/**
+ * Generic server-URL candidate generator.
+ *
+ * Turns loose user input (`media.uruk.dev`, `https://media.uruk.dev`,
+ * `host:8096`, `http://10.0.0.5:3000/path`) into an ordered list of full URLs
+ * to probe — https first, http as fallback — while preserving any explicit
+ * port and path. Service-agnostic: unlike the Jellyfin SDK's `getAddressCandidates`
+ * it adds no Jellyfin-specific ports, so it suits Jellyseerr/Streamystats/etc.
+ */
+
+// scheme? host (port)? (path/query/hash)?
+const URL_RE = /^(?:(https?):\/\/)?([^/:\s?#]+)(?::(\d+))?([/?#].*)?$/i;
+
+export interface ParsedServerInput {
+  scheme?: "http" | "https";
+  host: string;
+  port?: string;
+  /** Normalized path+query+hash, without a trailing slash; "" when none. */
+  path: string;
+}
+
+function normalizePath(path?: string): string {
+  if (!path || path === "/") return "";
+  return path.replace(/\/+$/, "");
+}
+
+/** Parse loose user input. Returns null when it can't be understood. */
+export function parseServerInput(input: string): ParsedServerInput | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+
+  const match = URL_RE.exec(trimmed);
+  if (!match) return null;
+
+  const [, scheme, host, port, rawPath] = match;
+  return {
+    scheme: scheme ? (scheme.toLowerCase() as "http" | "https") : undefined,
+    host: host.toLowerCase(),
+    port,
+    path: normalizePath(rawPath),
+  };
+}
+
+function buildUrl(
+  scheme: "http" | "https",
+  host: string,
+  port: string | undefined,
+  path: string,
+): string {
+  return `${scheme}://${host}${port ? `:${port}` : ""}${path}`;
+}
+
+/**
+ * Ordered, de-duplicated candidate URLs for the given input.
+ *
+ * - Explicit scheme AND port → trusted as-is (single candidate).
+ * - Otherwise https is tried before http (prefer secure), keeping any port/path.
+ *
+ * @returns [] when the input can't be parsed.
+ */
+export function getServerUrlCandidates(input: string): string[] {
+  const parsed = parseServerInput(input);
+  if (!parsed) return [];
+
+  const { scheme, host, port, path } = parsed;
+
+  // Fully specified: don't second-guess the user.
+  if (scheme && port) return [buildUrl(scheme, host, port, path)];
+
+  // Secure-first; the typed scheme (if any) is still covered by this set.
+  const candidates = (["https", "http"] as const).map((s) =>
+    buildUrl(s, host, port, path),
+  );
+  return Array.from(new Set(candidates));
+}

utils/serverUrl/index.ts

@@ -0,0 +1,16 @@
+export {
+  getServerUrlCandidates,
+  type ParsedServerInput,
+  parseServerInput,
+} from "./candidates";
+export { jellyfinProbe } from "./probes/jellyfin";
+export { jellyseerrProbe } from "./probes/jellyseerr";
+export { reachabilityProbe } from "./probes/reachability";
+export {
+  type ResolveFailureReason,
+  type ResolveOptions,
+  type ResolveResult,
+  resolveServerUrl,
+} from "./resolve";
+export { isVersionBelow } from "./semver";
+export type { ServerProbe, ServerProbeOutcome } from "./types";

utils/serverUrl/probes/jellyfin.ts

@@ -0,0 +1,24 @@
+import axios from "axios";
+import type { ServerProbe } from "../types";
+
+/** Public, unauthenticated Jellyfin endpoint; `ProductName` confirms the service. */
+const PRODUCT_NAME = "Jellyfin Server";
+
+export const jellyfinProbe: ServerProbe = async (url, signal) => {
+  try {
+    const { status, data } = await axios.get(`${url}/System/Info/Public`, {
+      signal,
+      timeout: 8000, // backstop; the resolver aborts via signal first
+    });
+
+    if (status < 200 || status >= 300) return { status: "unreachable" };
+    if (data?.ProductName !== PRODUCT_NAME) return { status: "wrong-service" };
+
+    return {
+      status: "ok",
+      meta: { version: data?.Version, serverName: data?.ServerName },
+    };
+  } catch {
+    return { status: "unreachable" };
+  }
+};

utils/serverUrl/probes/jellyseerr.ts

@@ -0,0 +1,30 @@
+import axios from "axios";
+import type { ServerProbe } from "../types";
+
+/**
+ * Probe for a Jellyseerr server. `/api/v1/status` is jellyseerr/overseerr
+ * specific and unauthenticated, so it both proves reachability and confirms we
+ * hit the right service. The minimum-version requirement is enforced at login
+ * time (see JellyseerrApi.test) — not surfaced here, to keep the field UI clean.
+ */
+export const jellyseerrProbe: ServerProbe = async (url, signal) => {
+  try {
+    const { status, data } = await axios.get(`${url}/api/v1/status`, {
+      signal,
+      timeout: 8000, // backstop; the resolver aborts via signal first
+    });
+
+    if (status < 200 || status >= 300) return { status: "unreachable" };
+
+    // A JSON body carrying version/commitTag identifies a real jellyseerr.
+    const looksLikeJellyseerr =
+      !!data &&
+      typeof data === "object" &&
+      (typeof data.version === "string" || "commitTag" in data);
+    if (!looksLikeJellyseerr) return { status: "wrong-service" };
+
+    return { status: "ok", meta: { version: data.version } };
+  } catch {
+    return { status: "unreachable" };
+  }
+};

utils/serverUrl/probes/reachability.ts

@@ -0,0 +1,23 @@
+import axios from "axios";
+import type { ServerProbe } from "../types";
+
+/**
+ * Minimal probe for services without a known/unauthenticated health endpoint
+ * (e.g. Marlin Search, Streamystats). Any HTTP response — even 4xx — proves the
+ * host is up and speaking HTTP at this protocol/port, which is enough to pick
+ * https vs http. It cannot detect a "wrong service".
+ */
+export const reachabilityProbe: ServerProbe = async (url, signal) => {
+  try {
+    await axios.get(url, {
+      signal,
+      timeout: 8000,
+      validateStatus: () => true, // any status = the server answered
+    });
+    return { status: "ok" };
+  } catch (error) {
+    // A delivered response that still threw counts as reachable.
+    if ((error as { response?: unknown })?.response) return { status: "ok" };
+    return { status: "unreachable" };
+  }
+};

utils/serverUrl/resolve.ts

@@ -0,0 +1,88 @@
+import { getServerUrlCandidates } from "./candidates";
+import type { ServerProbe, ServerProbeOutcome } from "./types";
+
+export type ResolveFailureReason =
+  | "empty"
+  | "invalid"
+  | "wrong-service"
+  | "unreachable";
+
+export type ResolveResult =
+  | { ok: true; url: string; meta?: Record<string, unknown> }
+  | { ok: false; reason: ResolveFailureReason };
+
+export interface ResolveOptions {
+  /** Per-candidate probe timeout in ms. Default 5000. */
+  timeoutMs?: number;
+  /** Abort the whole resolution (cancels every in-flight probe). */
+  signal?: AbortSignal;
+}
+
+// Order in which to surface a failure when no candidate validated:
+// the more specific/actionable the reason, the earlier it is reported.
+const FAILURE_PRIORITY = [
+  "wrong-service",
+  "unreachable",
+] as const satisfies ReadonlyArray<ResolveFailureReason>;
+
+/**
+ * Resolve loose user input to a single working, canonical server URL.
+ *
+ * Generates candidates (https-first), probes them in parallel with a per-candidate
+ * timeout, and returns the first candidate (in preference order) the probe
+ * accepted. When none work, the most actionable failure is returned.
+ */
+export async function resolveServerUrl(
+  input: string,
+  probe: ServerProbe,
+  options: ResolveOptions = {},
+): Promise<ResolveResult> {
+  const { timeoutMs = 5000, signal } = options;
+
+  if (!input.trim()) return { ok: false, reason: "empty" };
+
+  const candidates = getServerUrlCandidates(input);
+  if (candidates.length === 0) return { ok: false, reason: "invalid" };
+
+  const outcomes = await Promise.all(
+    candidates.map((url) => runProbe(url, probe, timeoutMs, signal)),
+  );
+
+  // Prefer the first candidate (https-first) that validated.
+  for (let i = 0; i < candidates.length; i++) {
+    const outcome = outcomes[i];
+    if (outcome.status === "ok") {
+      return { ok: true, url: candidates[i], meta: outcome.meta };
+    }
+  }
+
+  // Nothing validated: report the most useful failure.
+  for (const reason of FAILURE_PRIORITY) {
+    const hit = outcomes.find((outcome) => outcome.status === reason);
+    if (hit) {
+      return { ok: false, reason };
+    }
+  }
+  return { ok: false, reason: "unreachable" };
+}
+
+async function runProbe(
+  url: string,
+  probe: ServerProbe,
+  timeoutMs: number,
+  parentSignal?: AbortSignal,
+): Promise<ServerProbeOutcome> {
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  parentSignal?.addEventListener("abort", abort);
+  const timer = setTimeout(abort, timeoutMs);
+
+  try {
+    return await probe(url, controller.signal);
+  } catch {
+    return { status: "unreachable" };
+  } finally {
+    clearTimeout(timer);
+    parentSignal?.removeEventListener("abort", abort);
+  }
+}

utils/serverUrl/semver.ts

@@ -0,0 +1,22 @@
+/**
+ * Strict numeric "below" comparison for dotted versions.
+ *
+ * Avoids the string-comparison bug (`"1.9.9" < "2.0.0"` works by luck but
+ * `"2.10.0" < "2.0.0"` is wrongly true). Non-numeric/pre-release suffixes on a
+ * segment are ignored (e.g. `2.0.0-beta` → 2.0.0).
+ */
+export function isVersionBelow(version: string, minimum: string): boolean {
+  const parse = (v: string) =>
+    v.split(".").map((segment) => Number.parseInt(segment, 10) || 0);
+
+  const a = parse(version);
+  const b = parse(minimum);
+  const length = Math.max(a.length, b.length);
+
+  for (let i = 0; i < length; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (x !== y) return x < y;
+  }
+  return false;
+}

utils/serverUrl/types.ts

@@ -0,0 +1,15 @@
+/** Result of probing a single candidate URL for a specific service. */
+export type ServerProbeOutcome =
+  | { status: "ok"; meta?: Record<string, unknown> }
+  | { status: "wrong-service" }
+  | { status: "unreachable" };
+
+/**
+ * Validates one fully-qualified candidate URL for a given service.
+ * Implementations must resolve (never reject) — map errors to "unreachable".
+ * The provided signal is aborted on timeout or cancellation.
+ */
+export type ServerProbe = (
+  url: string,
+  signal: AbortSignal,
+) => Promise<ServerProbeOutcome>;