@cinecrew/cinecrew-player 0.1.1

package/src/native/media/web/useWebMediaSession.js

@@ -0,0 +1,90 @@
+import { useEffect } from 'react';
+import { isWeb } from '../../../utils/runtimePlatform';
+
+/**
+ * Hook to integrate the browser MediaSession API for background audio,
+ * OS lock-screen controls, notification media controls, and hardware media keys.
+ */
+export function useWebMediaSession({
+  title,
+  posterUrl,
+  isLive,
+  paused,
+  videoRef,
+  pausedRef,
+  lastKnownPosRef,
+  onTogglePlayPause,
+  onSeekBy,
+}) {
+  useEffect(() => {
+    if (!isWeb() || typeof navigator === 'undefined' || !('mediaSession' in navigator)) {
+      return undefined;
+    }
+
+    try {
+      if (typeof window !== 'undefined' && window.MediaMetadata) {
+        navigator.mediaSession.metadata = new window.MediaMetadata({
+          title: title || 'Now Playing',
+          artist: 'Xtream API Media Player',
+          album: isLive ? 'Live TV' : (title || 'Media Stream'),
+          artwork: posterUrl
+            ? [{ src: posterUrl, sizes: '512x512', type: 'image/jpeg' }]
+            : [],
+        });
+      }
+
+      navigator.mediaSession.playbackState = paused ? 'paused' : 'playing';
+
+      const playHandler = () => {
+        if (pausedRef) pausedRef.current = false;
+        const video = videoRef?.current;
+        if (video) video.play().catch(() => {});
+        if (typeof onTogglePlayPause === 'function') onTogglePlayPause(true);
+      };
+
+      const pauseHandler = () => {
+        if (pausedRef) pausedRef.current = true;
+        const video = videoRef?.current;
+        if (video) video.pause();
+        if (typeof onTogglePlayPause === 'function') onTogglePlayPause(false);
+      };
+
+      const seekBackwardHandler = (details) => {
+        const skip = details?.seekOffset || 10;
+        const video = videoRef?.current;
+        if (video && Number.isFinite(video.currentTime)) {
+          video.currentTime = Math.max(0, video.currentTime - skip);
+          if (lastKnownPosRef) lastKnownPosRef.current = video.currentTime;
+        }
+        if (typeof onSeekBy === 'function') onSeekBy(-skip);
+      };
+
+      const seekForwardHandler = (details) => {
+        const skip = details?.seekOffset || 10;
+        const video = videoRef?.current;
+        if (video && Number.isFinite(video.currentTime)) {
+          video.currentTime = Math.min(video.duration || 999999, video.currentTime + skip);
+          if (lastKnownPosRef) lastKnownPosRef.current = video.currentTime;
+        }
+        if (typeof onSeekBy === 'function') onSeekBy(skip);
+      };
+
+      navigator.mediaSession.setActionHandler('play', playHandler);
+      navigator.mediaSession.setActionHandler('pause', pauseHandler);
+      navigator.mediaSession.setActionHandler('seekbackward', seekBackwardHandler);
+      navigator.mediaSession.setActionHandler('seekforward', seekForwardHandler);
+      navigator.mediaSession.setActionHandler('stop', pauseHandler);
+
+      return () => {
+        navigator.mediaSession.setActionHandler('play', null);
+        navigator.mediaSession.setActionHandler('pause', null);
+        navigator.mediaSession.setActionHandler('seekbackward', null);
+        navigator.mediaSession.setActionHandler('seekforward', null);
+        navigator.mediaSession.setActionHandler('stop', null);
+      };
+    } catch (e) {
+     String(e);
+      return undefined;
+    }
+  }, [title, posterUrl, isLive, paused, videoRef, pausedRef, lastKnownPosRef, onTogglePlayPause, onSeekBy]);
+}

package/src/native/media/web/useWebMpegTsPlayback.native.js

@@ -0,0 +1,3 @@
+export function useWebMpegTsPlayback() {
+  return { useMpegTs: false, useAc3Fallback: false };
+}

package/src/native/media/web/useWebMpegTsPlayback.web.js

@@ -0,0 +1,356 @@
+import { useEffect, useRef, useState } from 'react';
+import mpegts from '../../../../vendor/mpegts.js/mpegts.js';
+import {
+  WEB_AC3_UNSUPPORTED_CODE,
+  WEB_AC3_UNSUPPORTED_MESSAGE,
+} from './webPlaybackErrors';
+
+if (mpegts.LoggingControl) {
+  mpegts.LoggingControl.enableAll = false;
+}
+
+const isRawLiveTransportStream = (url) => {
+  if (typeof url !== 'string') return false;
+  try {
+    const parsed = new URL(url, 'http://localhost');
+    return /\.ts$/i.test(parsed.pathname)
+      || (/\/live\//i.test(parsed.pathname) && !/\.m3u8$/i.test(parsed.pathname));
+  } catch {
+    return /\/live\/.*\.ts(?:\?|$)/i.test(url);
+  }
+};
+
+const isHlsUrl = (url) => /\.m3u8(?:$|[?#])/i.test(String(url || ''));
+
+function containsAc3Codec(value) {
+  const normalized = String(value || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+  return normalized.includes('ac3') || normalized.includes('dolby');
+}
+
+function buildRetryFailureMessage(message) {
+  const detail = message ? ` (${message})` : '';
+  return 'The live stream connection failed after 3 reconnect attempts' + detail + '.';
+}
+
+function redactStreamDetails(value) {
+  return String(value || '')
+    .replace(/https?:\/\/\S+/gi, '[stream endpoint]')
+    .replace(/\/live\/[^?#\s]*/gi, '/live/[redacted]');
+}
+
+function isTransientStreamFailure(detailCode, status) {
+  return detailCode === 'Exception'
+    || /NetworkError|Timeout/i.test(detailCode)
+    || [408, 425, 429].includes(status)
+    || status >= 500;
+}
+
+function formatStreamFailure({ detailCode, status, isTransient, recoveryAttempts, message }) {
+  if (detailCode === 'HttpStatusCodeInvalid') {
+    if (Number.isFinite(status) && status > 0) return `Stream request failed (HTTP ${status}).`;
+    return 'Stream request failed with an unreadable HTTP response.';
+  }
+  if (isTransient && recoveryAttempts >= 3) return buildRetryFailureMessage(message);
+  const prefix = detailCode || 'Failed to load live stream.';
+  return message ? `${prefix}: ${message}` : prefix;
+}
+
+function createErrorContext(type, detail, info, player) {
+  const detailCode = String(detail || type || '');
+  const mediaSourceMessage = String(info?.msg || info?.message || '');
+  const codecText = [
+    detailCode,
+    mediaSourceMessage,
+    player?.mediaInfo?.audioCodec,
+    player?.mediaInfo?.mimeType,
+  ].filter(Boolean).join(' ');
+  const status = Number(info?.code);
+  return {
+    detailCode,
+    mediaSourceMessage,
+    isAc3: containsAc3Codec(codecText),
+    status,
+    isTransient: isTransientStreamFailure(detailCode, status),
+  };
+}
+
+export function useWebMpegTsPlayback({
+  streamUrl,
+  activeUrl,
+  isLive,
+  videoOnly = false,
+  videoRef,
+  pausedRef,
+  onErrorRef,
+  onBufferingRef,
+}) {
+  const [unavailableForUrl, setUnavailableForUrl] = useState('');
+  const [ac3FallbackForUrl, setAc3FallbackForUrl] = useState('');
+  const ac3FallbackForUrlRef = useRef('');
+  const useMpegTs = isLive
+    // The resolver may return an opaque temporary URL whose pathname no
+    // longer ends in .ts or /live/. Keep the source format from the original
+    // Xtream URL so those redirects still go through the TS demuxer. If the
+    // resolver explicitly returned HLS, let the HLS player own that source.
+    && (isRawLiveTransportStream(streamUrl) || isRawLiveTransportStream(activeUrl))
+    && !isHlsUrl(activeUrl)
+    && unavailableForUrl !== streamUrl;
+  const useVideoOnly = useMpegTs && videoOnly;
+  const useAc3Fallback = useMpegTs && !useVideoOnly && ac3FallbackForUrl === streamUrl;
+
+  useEffect(() => {
+    setUnavailableForUrl('');
+    ac3FallbackForUrlRef.current = '';
+    setAc3FallbackForUrl('');
+  }, [streamUrl]);
+
+  useEffect(() => {
+    if (!activeUrl || !useMpegTs || typeof window === 'undefined') return undefined;
+    const video = videoRef.current;
+    if (!video) return undefined;
+
+    let disposed = false;
+    let blockedByAudioCodec = false;
+    let player;
+    const previousVideoVisibility = video.style.visibility;
+    let recoveryTimer = null;
+    let recoveryAttempts = 0;
+    let recoveryPending = false;
+    let stallWatchdog = null;
+    let stablePlaybackTimer = null;
+    let lastPlaybackProgressAt = Date.now();
+    let lastPlaybackTime = Number(video.currentTime) || 0;
+
+    const clearStablePlaybackTimer = () => {
+      if (stablePlaybackTimer) {
+        clearTimeout(stablePlaybackTimer);
+        stablePlaybackTimer = null;
+      }
+    };
+
+    const notePlaybackProgress = () => {
+      const currentTime = Number(video.currentTime) || 0;
+      if (currentTime < lastPlaybackTime - 1) {
+        lastPlaybackTime = currentTime;
+        lastPlaybackProgressAt = Date.now();
+        return;
+      }
+      if (currentTime <= lastPlaybackTime + 0.05) return;
+      lastPlaybackTime = currentTime;
+      lastPlaybackProgressAt = Date.now();
+      if (stablePlaybackTimer || recoveryAttempts === 0) return;
+      stablePlaybackTimer = setTimeout(() => {
+        stablePlaybackTimer = null;
+        if (!disposed && !pausedRef.current && video.readyState >= 2
+          && Date.now() - lastPlaybackProgressAt < 2500) {
+          recoveryAttempts = 0;
+        }
+      }, 15000);
+    };
+
+    const scheduleRecovery = (message, httpStatus = null, error = null) => {
+      if (disposed || recoveryPending || pausedRef.current || !player) return;
+      if (recoveryAttempts >= 3) {
+        onErrorRef.current?.({
+          message: buildRetryFailureMessage(message),
+          httpStatus,
+          err: error,
+        });
+        return;
+      }
+
+      clearStablePlaybackTimer();
+      const delayMs = [500, 1200, 2500][recoveryAttempts];
+      recoveryAttempts += 1;
+      recoveryPending = true;
+      lastPlaybackProgressAt = Date.now();
+      onBufferingRef.current?.(true);
+      recoveryTimer = setTimeout(() => {
+        recoveryTimer = null;
+        recoveryPending = false;
+        if (disposed || !player || pausedRef.current) return;
+        try {
+          player.unload();
+          player.load();
+          lastPlaybackTime = Number(video.currentTime) || 0;
+          lastPlaybackProgressAt = Date.now();
+          const playResult = player.play();
+          playResult?.catch?.(() => {});
+        } catch (recoveryError) {
+          onErrorRef.current?.({
+            message: recoveryError?.message || 'Could not reconnect to the live stream.',
+            err: recoveryError,
+          });
+        }
+      }, delayMs);
+    };
+    const handlePlaying = () => {
+      lastPlaybackProgressAt = Date.now();
+      if (recoveryAttempts > 0 && !stablePlaybackTimer) {
+        stablePlaybackTimer = setTimeout(() => {
+          stablePlaybackTimer = null;
+          if (!disposed && !pausedRef.current && video.readyState >= 2
+            && Date.now() - lastPlaybackProgressAt < 2500) {
+            recoveryAttempts = 0;
+          }
+        }, 15000);
+      }
+    };
+    const handleWaiting = () => onBufferingRef.current?.(true);
+
+    const blockAc3Playback = () => {
+      if (disposed || blockedByAudioCodec) return;
+      blockedByAudioCodec = true;
+      video.dataset.mpegtsCodecGate = 'blocked';
+      video.style.visibility = 'hidden';
+      video.pause();
+      onBufferingRef.current?.(false);
+      try {
+        player?.pause();
+      } catch {
+        // The media engine may already have been disposed.
+      }
+      try {
+        player?.unload();
+      } catch {
+        // The media engine may already have been disposed.
+      }
+      onErrorRef.current?.({
+        code: WEB_AC3_UNSUPPORTED_CODE,
+        blockPlayback: true,
+        message: WEB_AC3_UNSUPPORTED_MESSAGE,
+      });
+    };
+
+    const handleMediaInfo = (info) => {
+      const codecSummary = [info?.audioCodec, info?.mimeType].filter(Boolean).join(' ');
+      if (containsAc3Codec(codecSummary)) {
+        blockAc3Playback();
+        return;
+      }
+      delete video.dataset.mpegtsCodecGate;
+      if (!pausedRef.current && player) {
+        const playResult = player.play();
+        playResult?.catch?.(() => {});
+      }
+    };
+
+    try {
+      if (!mpegts.isSupported()) {
+        setUnavailableForUrl(streamUrl);
+        return undefined;
+      }
+
+      player = mpegts.createPlayer({
+        type: 'mpegts',
+        url: activeUrl,
+        isLive: true,
+        hasAudio: !useAc3Fallback && !useVideoOnly,
+        hasVideo: true,
+      }, {
+        enableWorker: !useVideoOnly,
+        lazyLoad: false,
+        enableStashBuffer: true,
+        // Match the standalone Sony test: allow a deeper forward buffer to
+        // absorb provider jitter instead of constantly chasing the live edge.
+        stashInitialSize: useVideoOnly ? 2048 : 512 * 1024,
+        liveBufferLatencyChasing: !useVideoOnly,
+        liveBufferLatencyMaxLatency: 8,
+        liveBufferLatencyMinRemain: 3,
+        autoCleanupSourceBuffer: true,
+        autoCleanupMaxBackwardDuration: useVideoOnly ? 120 : 30,
+        autoCleanupMinBackwardDuration: useVideoOnly ? 60 : 15,
+        disableAudio: useAc3Fallback || useVideoOnly,
+      });
+      // Wait until the MPEG-TS demuxer reports its codecs so unsupported AC3
+      // streams can be stopped before the browser renders their video.
+      video.autoplay = false;
+      video.dataset.mpegtsCodecGate = 'pending';
+      player.on(mpegts.Events.MEDIA_INFO, handleMediaInfo);
+      video.addEventListener('timeupdate', notePlaybackProgress);
+      video.addEventListener('playing', handlePlaying);
+      video.addEventListener('waiting', handleWaiting);
+
+      player.on(mpegts.Events.ERROR, (type, detail, info) => {
+        if (disposed || recoveryPending || blockedByAudioCodec) return;
+        const errorContext = createErrorContext(type, detail, info, player);
+        const { detailCode, mediaSourceMessage, status, isTransient } = errorContext;
+        if (errorContext.isAc3) {
+          if (isLive) {
+            blockAc3Playback();
+            return;
+          }
+          if (ac3FallbackForUrlRef.current !== streamUrl) {
+            ac3FallbackForUrlRef.current = streamUrl;
+            setAc3FallbackForUrl(streamUrl);
+          }
+          return;
+        }
+        const safeMediaSourceMessage = redactStreamDetails(mediaSourceMessage);
+        if (isTransient && recoveryAttempts < 3) {
+          scheduleRecovery(safeMediaSourceMessage || detailCode, status, info || detail || type);
+          return;
+        }
+        const message = formatStreamFailure({
+          detailCode,
+          status,
+          isTransient,
+          recoveryAttempts,
+          message: safeMediaSourceMessage,
+        });
+        onErrorRef.current?.({
+          message,
+          httpStatus: Number.isFinite(status) && status > 0 ? status : null,
+          err: info || detail || type,
+        });
+      });
+      player.attachMediaElement(video);
+      player.load();
+      stallWatchdog = setInterval(() => {
+        if (disposed || pausedRef.current || recoveryPending || video.currentTime <= 0) return;
+        if (Date.now() - lastPlaybackProgressAt >= 12000) {
+          scheduleRecovery('playback stalled');
+        }
+      }, 3000);
+    } catch (error) {
+      setUnavailableForUrl(streamUrl);
+      onErrorRef.current?.({ message: error?.message || 'Failed to initialize live playback.', err: error });
+    }
+
+    return () => {
+      disposed = true;
+      if (recoveryTimer) clearTimeout(recoveryTimer);
+      if (stallWatchdog) clearInterval(stallWatchdog);
+      clearStablePlaybackTimer();
+      video.removeEventListener('timeupdate', notePlaybackProgress);
+      video.removeEventListener('playing', handlePlaying);
+      video.removeEventListener('waiting', handleWaiting);
+      delete video.dataset.mpegtsCodecGate;
+      video.autoplay = !pausedRef.current;
+      video.style.visibility = previousVideoVisibility;
+      if (!player) return;
+      try {
+        player.pause();
+      } catch {
+        // The media engine may already be disposed.
+      }
+      try {
+        player.unload();
+      } catch {
+        // The media engine may already be disposed.
+      }
+      try {
+        player.detachMediaElement();
+      } catch {
+        // The media engine may already be disposed.
+      }
+      try {
+        player.destroy();
+      } catch {
+        // The media engine may already be disposed.
+      }
+    };
+  }, [activeUrl, useMpegTs, useAc3Fallback, useVideoOnly, streamUrl, videoRef, pausedRef, onErrorRef, onBufferingRef]);
+
+  return { useMpegTs, useAc3Fallback };
+}

package/src/native/media/web/useWebVideoAspectRatio.js

@@ -0,0 +1,52 @@
+import { useState, useCallback, useEffect } from 'react';
+
+/**
+ * Hook to manage video aspect ratio scaling styles (FIT, FILL, STRETCH, CENTER, custom aspect ratios).
+ */
+export function useWebVideoAspectRatio(videoAspectRatio, audioOnly) {
+  const [aspectFit, setAspectFit] = useState('contain');
+  const [aspectRatioVal, setAspectRatioVal] = useState(undefined);
+
+  const applyAspectRatio = useCallback((aspect) => {
+    if (aspect === 'FILL_SCREEN' || aspect === 'FILL') {
+      setAspectFit('cover');
+      setAspectRatioVal(undefined);
+    } else if (aspect === 'STRETCH') {
+      setAspectFit('fill');
+      setAspectRatioVal(undefined);
+    } else if (aspect === 'CENTER') {
+      setAspectFit('none');
+      setAspectRatioVal(undefined);
+    } else if (typeof aspect === 'string' && aspect.includes(':')) {
+      const parts = aspect.split(':');
+      setAspectFit('contain');
+      setAspectRatioVal(`${parts[0]}/${parts[1]}`);
+    } else {
+      setAspectFit('contain');
+      setAspectRatioVal(undefined);
+    }
+  }, []);
+
+  useEffect(() => {
+    applyAspectRatio(videoAspectRatio);
+  }, [videoAspectRatio, applyAspectRatio]);
+
+  const useCustomRatio = Boolean(aspectRatioVal) && !audioOnly;
+  const videoStyle = {
+    width: useCustomRatio ? 'auto' : '100%',
+    height: useCustomRatio ? 'auto' : '100%',
+    ...(useCustomRatio
+      ? { maxWidth: '100%', maxHeight: '100%', aspectRatio: aspectRatioVal }
+      : {}),
+    objectFit: useCustomRatio ? 'contain' : aspectFit,
+    backgroundColor: '#000',
+    ...(audioOnly ? { opacity: 0 } : {}),
+  };
+
+  return {
+    aspectFit,
+    aspectRatioVal,
+    videoStyle,
+    applyAspectRatio,
+  };
+}

package/src/native/media/web/webPlaybackErrors.js

@@ -0,0 +1,4 @@
+export const WEB_AC3_UNSUPPORTED_MESSAGE =
+  'This browser playback path cannot decode the stream’s AC3 audio. Use a player or platform with AC3 support, or provide a browser-compatible stream.';
+
+export const WEB_AC3_UNSUPPORTED_CODE = 'WEB_AC3_UNSUPPORTED';

package/src/utils/layoutUtils.js

@@ -0,0 +1,12 @@
+export function getFontSize(baseSize, windowWidth = 390, windowHeight = 0) {
+  const width = Number(windowWidth) || 390;
+  const height = Number(windowHeight) || width;
+  const shortSide = Math.min(width, height);
+  const scale = Math.max(0.85, Math.min(1.15, shortSide / 390));
+  return Math.max(9, Math.round(Number(baseSize) * scale));
+}
+
+export function getFontWeight(baseWeight) {
+  const weights = { normal: 400, bold: 700 };
+  return String(weights[baseWeight] || Number(baseWeight) || 400);
+}

package/src/utils/mediaUtils.js

@@ -0,0 +1,7 @@
+export function cleanPlayerTitle(title, episodeLabel, isMobile = false) {
+  const clean = String(title || '').trim();
+  if (!clean) return 'Now Playing';
+  const episode = String(episodeLabel || '').trim();
+  if (!isMobile || !episode || clean.toLowerCase().includes(episode.toLowerCase())) return clean;
+  return clean;
+}

package/src/utils/recording.js

@@ -0,0 +1,8 @@
+export function formatRecElapsed(ms) {
+  const total = Math.max(0, Math.floor((Number(ms) || 0) / 1000));
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor((total % 3600) / 60);
+  const seconds = total % 60;
+  if (hours > 0) return `${hours}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+  return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+}

package/src/utils/runtimePlatform.js

@@ -0,0 +1,19 @@
+import { Platform } from 'react-native';
+
+export function isElectron() {
+  if (typeof window === 'undefined') return false;
+  if (typeof navigator !== 'undefined' && /cursor/i.test(navigator.userAgent)) return false;
+  return Boolean(window.process?.versions?.electron);
+}
+
+export function isWeb() {
+  return Platform.OS === 'web' && !isElectron();
+}
+
+export function isAndroid() {
+  return Platform.OS === 'android';
+}
+
+export function isIOS() {
+  return Platform.OS === 'ios';
+}

package/src/utils/sourceUtils.js

@@ -0,0 +1,99 @@
+import { useEffect, useRef, useState } from 'react';
+
+export function normalizePlayerSource(source, url) {
+  const value = source ?? url ?? '';
+  if (typeof value === 'string') return { uri: value };
+  return value && typeof value === 'object' ? value : { uri: '' };
+}
+
+export function getYouTubeVideoId(source) {
+  const media = typeof source === 'string' ? { uri: source } : source || {};
+  const explicitId = media.youtubeVideoId || (String(media.type || '').toLowerCase() === 'youtube' ? media.id : null);
+  const isValidId = (value) => /^[\w-]{11}$/.test(String(value || ''));
+  if (isValidId(explicitId)) return String(explicitId);
+
+  const raw = String(media.uri || media.url || '').trim();
+  if (!raw) return null;
+  try {
+    const parsed = new URL(raw);
+    const host = parsed.hostname.toLowerCase().replace(/^www\./, '');
+    if (host === 'youtu.be') {
+      const id = parsed.pathname.split('/').find(Boolean);
+      return isValidId(id) ? id : null;
+    }
+    if (host !== 'youtube.com' && host !== 'youtube-nocookie.com' && host !== 'm.youtube.com') return null;
+    const queryId = parsed.searchParams.get('v');
+    if (isValidId(queryId)) return queryId;
+    const match = /^\/(?:embed|shorts|live)\/([\w-]{11})/.exec(parsed.pathname);
+    return isValidId(match?.[1]) ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+export function getWebRuntimePlatform() {
+  if (typeof window === 'undefined') return 'web';
+  const electronProcess = Boolean(window.process?.versions?.electron);
+  const electronUserAgent = typeof navigator !== 'undefined' && /\bElectron\//i.test(navigator.userAgent || '');
+  return electronProcess || electronUserAgent ? 'electron' : 'web';
+}
+
+function sourceKey(source, url) {
+  const value = source ?? url ?? '';
+  if (typeof value === 'string') return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value?.uri || value?.url || '');
+  }
+}
+
+/** Apply an optional consumer-owned resolver without rewriting the input URL. */
+export function useResolvedPlayerSource(source, url, resolveSource, platform) {
+  const key = sourceKey(source, url);
+  const resolverRef = useRef(resolveSource);
+  const inputRef = useRef(normalizePlayerSource(source, url));
+  const resolverEnabled = typeof resolveSource === 'function';
+  resolverRef.current = resolveSource;
+  inputRef.current = normalizePlayerSource(source, url);
+  const [result, setResult] = useState({ key: null, source: null, loading: false, error: null });
+
+  useEffect(() => {
+    let cancelled = false;
+    const input = inputRef.current;
+    const resolver = resolverRef.current;
+    if (typeof resolver !== 'function' || !(input.uri || input.url)) {
+      setResult({ key, source: input, loading: false, error: null });
+      return () => { cancelled = true; };
+    }
+
+    setResult({ key, source: null, loading: true, error: null });
+    Promise.resolve()
+      .then(() => resolver(input, { platform }))
+      .then((resolved) => {
+        if (resolved === null || resolved === undefined || resolved === '') {
+          throw new Error('The source resolver did not return a playable media source.');
+        }
+        if (!cancelled) {
+          setResult({
+            key,
+            source: { ...input, ...normalizePlayerSource(resolved) },
+            loading: false,
+            error: null,
+          });
+        }
+      })
+      .catch((error) => {
+        if (!cancelled) setResult({ key, source: null, loading: false, error });
+      });
+    return () => { cancelled = true; };
+  }, [key, platform, resolverEnabled]);
+
+  if (result.key === key) return result;
+  return {
+    key,
+    source: resolverEnabled ? null : normalizePlayerSource(source, url),
+    loading: resolverEnabled,
+    error: null,
+  };
+}