diff --git a/css/player-base-new.js b/css/player-base-new.js
index a150705c..66df2ece 100644
--- a/css/player-base-new.js
+++ b/css/player-base-new.js
@@ -5,658 +5,633 @@ var versionclient = "youtube.player.web_20250917_22_RC00"
 
 
 
-
-
 document.addEventListener("DOMContentLoaded", () => {
-    // video.js 8 init - source can be seen in https://poketube.fun/static/vjs.min.js or the vjs.min.js file
-    const video = videojs('video', {
-        controls: true,
-        autoplay: false,
-        preload: 'auto',
-        errorDisplay: false,
-    });
+   const player = videojs('video', {
+    controls: true,
+    autoplay: false,
+    preload: 'auto',
+    errorDisplay: false,
+  });
 
-    // todo : remove this code lol
-    const qs = new URLSearchParams(window.location.search);
-    const qua = qs.get("quality") || "";
-    const vidKey = qs.get('v');
-    try { localStorage.setItem(`progress-${vidKey}`, 0); } catch {}
+  const videoEl = document.getElementById('video'); 
+  const audioEl = document.getElementById('aud');
 
-    // raw media elements
-    const videoEl = document.getElementById('video');
-    const audio = document.getElementById('aud');
+   const qs = new URLSearchParams(location.search);
+  const qua = qs.get("quality") || "";
+  const vidKey = qs.get('v') || '';
+  try { if (vidKey) localStorage.setItem(`progress-${vidKey}`, 0); } catch {}
 
-    // resolve initial sources robustly (works whether <audio src> or <source> children are used)
-    const pickAudioSrc = () => {
-        const s = audio?.getAttribute?.('src');
-        if (s) return s;
-        const child = audio?.querySelector?.('source');
-        if (child?.getAttribute?.('src')) return child.getAttribute('src');
-        if (audio?.currentSrc) return audio.currentSrc;
-        return null;
-    };
-    let audioSrc = pickAudioSrc();
+  // --- Source helpers --------------------------------------------------------
+  const initialSrcObj = player.src();
+  const initialVideoSrc = Array.isArray(initialSrcObj) ? (initialSrcObj[0]?.src || null) : (initialSrcObj || null);
+  const initialVideoType = Array.isArray(initialSrcObj) ? (initialSrcObj[0]?.type || undefined) : undefined;
 
-    const srcObj = video.src();
-    const videoSrc = Array.isArray(srcObj) ? (srcObj[0] && srcObj[0].src) : srcObj;
-    const videoType = Array.isArray(srcObj) ? (srcObj[0] && srcObj[0].type) : undefined;
+  function pickAudioSrc() {
+    try {
+      const s = audioEl?.getAttribute?.('src');
+      if (s) return s;
+      const child = audioEl?.querySelector?.('source');
+      if (child?.getAttribute?.('src')) return child.getAttribute('src');
+      if (audioEl?.currentSrc) return audioEl.currentSrc;
+    } catch {}
+    return null;
+  }
+  let audioSrc = pickAudioSrc();
 
-    // readiness + sync state
-    let audioReady = false, videoReady = false;
-    let syncInterval = null;
-
-    // thresholds / constants
-    const BIG_DRIFT = 0.5;
-    const MICRO_DRIFT = 0.05;
-    const SYNC_INTERVAL_MS = 250;
-
-    // fix: helpers to decide if a given time is playable for a media element (buffered or sufficiently ready)
-    const EPS = 0.15;
-    function timeInBuffered(media, t) {
-        try {
-            const br = media.buffered;
-            if (!br || br.length === 0 || !isFinite(t)) return false;
-            for (let i = 0; i < br.length; i++) {
-                const s = br.start(i) - EPS, e = br.end(i) + EPS;
-                if (t >= s && t <= e) return true;
-            }
-        } catch {}
-        return false;
-    }
-    function canPlayAt(media, t) {
-        try {
-            // readyState: 0-NOTHING,1-METADATA,2-CURRENT,3-FUTURE,4-ENOUGH
-            const rs = Number(media.readyState || 0);
-            if (!isFinite(t)) return false;
-            // fast path if we clearly have forward data
-            if (rs >= 3) return true;
-            // otherwise, require that moment to be inside buffered
-            return timeInBuffered(media, t);
-        } catch { return false; }
-    }
-    function bothPlayableAt(t) {
-        return canPlayAt(videoEl, t) && canPlayAt(audio, t);
-    }
-
-    // utility: safe currentTime set (avoid DOMExceptions before ready)
-    function safeSetCT(media, t) {
-        try {
-            if (!isFinite(t) || t < 0) return;
-            // readyState >= 1 (HAVE_METADATA) generally safe, but clamp anyway
-            media.currentTime = t;
-        } catch {}
-    }
-
-    // clear sync ticker
-    function clearSyncLoop() {
-        if (syncInterval) {
-            clearInterval(syncInterval);
-            syncInterval = null;
-            try { audio.playbackRate = 1; } catch {}
-        }
-    }
-
-    // drift-compensation loop for micro-sync
-    function startSyncLoop() {
-        clearSyncLoop();
-        syncInterval = setInterval(() => {
-            const vt = Number(video.currentTime());
-            const at = Number(audio.currentTime);
-            if (!isFinite(vt) || !isFinite(at)) return;
-
-            const delta = vt - at;
-
-            // large drift → snap
-            if (Math.abs(delta) > BIG_DRIFT) {
-                safeSetCT(audio, vt);
-                try { audio.playbackRate = 1; } catch {}
-                return;
-            }
-
-            // micro drift → gentle nudge by rate
-            if (Math.abs(delta) > MICRO_DRIFT) {
-                const targetRate = 1 + (delta * 0.12); // slightly stronger nudge
-                try {
-                    // cap to avoid audible artifacts
-                    audio.playbackRate = Math.max(0.85, Math.min(1.15, targetRate));
-                } catch {}
-            } else {
-                try { audio.playbackRate = 1; } catch {}
-            }
-        }, SYNC_INTERVAL_MS);
-    }
-
-    // align start when both are ready
-    function tryStart() {
-        if (audioReady && videoReady) {
-            const t = Number(video.currentTime());
-            if (isFinite(t) && Math.abs(Number(audio.currentTime) - t) > 0.1) {
-                safeSetCT(audio, t);
-            }
-            // fix: only kick off playback if the moment is actually playable for BOTH
-            if (bothPlayableAt(t)) {
-                video.play()?.catch(()=>{});
-                audio.play()?.catch(()=>{});
-                startSyncLoop();
-            } else {
-                // not playable yet → keep things aligned and idle
-                try { video.pause(); } catch {}
-                try { audio.pause(); } catch {}
-                clearSyncLoop();
-            }
-            setupMediaSession();
-        }
-    }
-
-    // generic one-shot retry helper for DOM media element
-    function attachRetry(elm, resolveSrc, markReady) {
-        const src = resolveSrc?.(); // defer resolving to latest url if possible
-
-        // mark readiness
-        const onLoaded = () => {
-            try { elm._didRetry = false; } catch {}
-            markReady();
-            tryStart();
-        };
-        elm.addEventListener('loadeddata', onLoaded, { once: true });
-        elm.addEventListener('loadedmetadata', onLoaded, { once: true });
-
-        // one quiet retry on error
-        elm.addEventListener('error', () => {
-            // only retry once, and only if we have a valid src
-            const retryURL = resolveSrc?.() || src;
-            if (!elm._didRetry && retryURL) {
-                elm._didRetry = true;
-                try {
-                    // If <source> children were used, switch to a direct src
-                    elm.removeAttribute('src');
-                    // clear existing <source> nodes to avoid ambiguous state
-                    [...elm.querySelectorAll('source')].forEach(n => n.remove());
-                    elm.src = retryURL;
-                    elm.load();
-                } catch {}
-            } else {
-                // swallow to avoid console spam/UI noise
-            }
-        }, { once: true });
-    }
-
-    // media session / hardware keys
-    function setupMediaSession() {
-        if ('mediaSession' in navigator) {
-            try {
-                navigator.mediaSession.metadata = new MediaMetadata({
-                    title: document.title || 'Video',
-                    artist: '',
-                    album: '',
-                    artwork: []
-                });
-            } catch {}
-
-            navigator.mediaSession.setActionHandler('play', () => {
-                video.play()?.catch(()=>{}); audio.play()?.catch(()=>{});
-            });
-            navigator.mediaSession.setActionHandler('pause', () => {
-                video.pause(); audio.pause();
-            });
-            navigator.mediaSession.setActionHandler('seekbackward', ({ seekOffset }) => {
-                const skip = seekOffset || 10;
-                const to = Math.max(0, Number(video.currentTime()) - skip);
-                video.currentTime(to);
-                safeSetCT(audio, to);
-            });
-            navigator.mediaSession.setActionHandler('seekforward', ({ seekOffset }) => {
-                const skip = seekOffset || 10;
-                const to = Number(video.currentTime()) + skip;
-                video.currentTime(to);
-                safeSetCT(audio, to);
-            });
-            navigator.mediaSession.setActionHandler('seekto', ({ seekTime, fastSeek }) => {
-                if (!isFinite(seekTime)) return;
-                if (fastSeek && 'fastSeek' in audio) try { audio.fastSeek(seekTime); } catch { safeSetCT(audio, seekTime); }
-                else safeSetCT(audio, seekTime);
-                video.currentTime(seekTime);
-            });
-            navigator.mediaSession.setActionHandler('stop', () => {
-                video.pause(); audio.pause();
-                try { video.currentTime(0); } catch {}
-                try { audio.currentTime = 0; } catch {}
-                clearSyncLoop();
-            });
-        }
-    }
-
-    // ** DESKTOP MEDIA-KEY FALLBACK **
-    document.addEventListener('keydown', e => {
-        switch (e.code) {
-            case 'AudioPlay':
-            case 'MediaPlayPause':
-                if (video.paused()) { video.play()?.catch(()=>{}); audio.play()?.catch(()=>{}); }
-                else { video.pause(); audio.pause(); }
-                break;
-            case 'AudioPause':
-                video.pause(); audio.pause();
-                break;
-            case 'AudioNext':
-            case 'MediaTrackNext': {
-                const tFwd = Number(video.currentTime()) + 10;
-                video.currentTime(tFwd); safeSetCT(audio, tFwd);
-                break;
-            }
-            case 'AudioPrevious':
-            case 'MediaTrackPrevious': {
-                const tBwd = Math.max(0, Number(video.currentTime()) - 10);
-                video.currentTime(tBwd); safeSetCT(audio, tBwd);
-                break;
-            }
-        }
-    });
-
-    // === PRIMARY SYNC/RETRY LOGIC (skips when qua=medium) ===
-    if (qua !== "medium") {
-        // attach retry & ready markers to the real elements
-        attachRetry(audio, pickAudioSrc, () => { audioReady = true; });
-        attachRetry(videoEl, () => {
-            // prefer current player src if any; fallback to initial
-            const s = video.src();
-            return Array.isArray(s) ? (s[0] && s[0].src) : (s || videoSrc);
-        }, () => { videoReady = true; });
-
-        // keep audio volume mirrored to player volume both ways
-        const clamp = v => Math.max(0, Math.min(1, Number(v)));
-        video.on('volumechange', () => { try { audio.volume = clamp(video.volume()); } catch {} });
-        audio.addEventListener('volumechange', () => { try { video.volume(clamp(audio.volume)); } catch {} });
-
-        // rate sync (rare, but keep consistent)
-        video.on('ratechange', () => {
-            try { audio.playbackRate = video.playbackRate(); } catch {}
-        });
-
-        // Sync when playback starts
-        video.on('play', () => {
-            if (!syncInterval) startSyncLoop();
-            const vt = Number(video.currentTime());
-            if (Math.abs(vt - Number(audio.currentTime)) > 0.3) {
-                safeSetCT(audio, vt);
-            }
-            if (audioReady) audio.play()?.catch(()=>{});
-        });
-
-        video.on('pause', () => {
-            audio.pause();
-            clearSyncLoop();
-        });
-
-        // pause audio when video is buffering :3
-        video.on('waiting', () => {
-            audio.pause();
-            clearSyncLoop();
-        });
-
-        // resume audio when video resumes
-        video.on('playing', () => {
-            if (audioReady) audio.play()?.catch(()=>{});
-            if (!syncInterval) startSyncLoop();
-        });
-
-const errorBox = document.getElementById('loopedIndicator');
-
-video.on('error', () => {
-  const mediaError = video.error();
-  let message = 'An unknown error occurred.';
-
-  if (mediaError) {
-    // Skip showing error if code === 1
-    if (mediaError.code === 1) {
-      return;
-    }
-    message = `Error ${mediaError.code} : ${mediaError.message || 'No message provided'} try to refresh the page?`;
+  function currentVideoSrc() {
+    const s = player.src();
+    return Array.isArray(s) ? (s[0]?.src || null) : (s || null);
+  }
+  function currentVideoType() {
+    const s = player.src();
+    return Array.isArray(s) ? (s[0]?.type || undefined) : undefined;
   }
 
-  errorBox.textContent = message;
-  errorBox.style.display = 'block';
-  errorBox.style.width = 'fit-content';
-});
+  // --- State -----------------------------------------------------------------
+  let audioReady = false, videoReady = false;
+  let syncInterval = null;
+  let mediaSessionReady = false;
 
+  // Thresholds
+  const BIG_DRIFT = 0.5;       // hard snap
+  const MICRO_DRIFT = 0.05;    // rate nudge
+  const SYNC_INTERVAL_MS = 250;
+  const EPS = 0.15;
 
-        // seeks: keep tight alignment
-        // fix: remember if video was actually playing before the seek, so we don't resume wrongly
-        let wasPlayingBeforeSeek = false; // fix: track pre-seek playback state
+  // --- Buffer/ready checks ---------------------------------------------------
+  function timeInBuffered(media, t) {
+    try {
+      const br = media.buffered;
+      if (!br || br.length === 0 || !isFinite(t)) return false;
+      for (let i = 0; i < br.length; i++) {
+        const s = br.start(i) - EPS, e = br.end(i) + EPS;
+        if (t >= s && t <= e) return true;
+      }
+    } catch {}
+    return false;
+  }
+  function canPlayAt(media, t) {
+    try {
+      const rs = Number(media.readyState || 0);  // 0..4
+      if (!isFinite(t)) return false;
+      if (rs >= 3) return true;                  // HAVE_FUTURE_DATA
+      return timeInBuffered(media, t);
+    } catch { return false; }
+  }
+  function bothPlayableAt(t) {
+    return canPlayAt(videoEl, t) && canPlayAt(audioEl, t);
+  }
+  function safeSetCT(media, t) {
+    try { if (isFinite(t) && t >= 0) media.currentTime = t; } catch {}
+  }
 
-        video.on('seeking', () => {
-            wasPlayingBeforeSeek = !video.paused(); // fix: snapshot state
-            audio.pause();
-            clearSyncLoop();
-            const vt = Number(video.currentTime());
-            if (Math.abs(vt - Number(audio.currentTime)) > 0.1) safeSetCT(audio, vt);
-        });
-
-        video.on('seeked', () => {
-            const vt = Number(video.currentTime());
-            if (Math.abs(vt - Number(audio.currentTime)) > 0.05) safeSetCT(audio, vt);
-
-            // fix: after a seek, auto-play both only if that instant is playable; otherwise keep both paused
-            if (wasPlayingBeforeSeek && bothPlayableAt(vt)) {
-                video.play()?.catch(()=>{});
-                if (audioReady) audio.play()?.catch(()=>{});
-                if (!syncInterval) startSyncLoop();
-            } else {
-                try { video.pause(); } catch {}
-                try { audio.pause(); } catch {}
-                clearSyncLoop();
-            }
-        });
-
-        // Detects when video or audio finishes buffering; nudge sync
-        video.on('canplaythrough', () => {
-            const vt = Number(video.currentTime());
-            if (Math.abs(vt - Number(audio.currentTime)) > 0.1) safeSetCT(audio, vt);
-        });
-        audio.addEventListener('canplaythrough', () => {
-            const vt = Number(video.currentTime());
-            if (Math.abs(vt - Number(audio.currentTime)) > 0.1) safeSetCT(audio, vt);
-        });
-
-        // stop everything on media end
-        video.on('ended', () => { try { audio.pause(); } catch {}; clearSyncLoop(); });
-        audio.addEventListener('ended', () => { try { video.pause(); } catch {}; clearSyncLoop(); });
-
-        // pause when exiting full screen :3 
-        document.addEventListener('fullscreenchange', () => {
-            if (!document.fullscreenElement) {
-                video.pause();
-                audio.pause();
-                clearSyncLoop();
-            }
-        });
-
-        // === VIDEO.JS AUTO-RETRY (30s GRACE + ONLY WHEN REALLY BROKEN) ===
-        // We completely ignore all tech errors for the first 30s after the stream actually starts (play or loadeddata).
-        // After 30s, retries stay invisible and only trigger if playback is genuinely stuck (no advancement, bad readyState, or real net/decode error).
-        const VJS_RETRY_STEPS_MS = [250, 400, 650, 900, 1200, 1600, 2000, 2600]; // tight, subtle backoff
-        let vjsRetryCount = 0;
-        let allowRetries = false;          // becomes true only after grace window
-        let graceTimerStarted = false;
-        let graceTimerId = null;
-
-        // tiny watchdog state
-        let watch = { t: 0, at: 0, active: false };
-        const WATCH_GRACE_MS = 2200;       // if no time advance for ~2.2s while "playing" post-grace → retry
-
-        function currentVideoSrc() {
-            const s = video.src();
-            return Array.isArray(s) ? (s[0] && s[0].src) : s;
-        }
-        function currentVideoType() {
-            const s = video.src();
-            return Array.isArray(s) ? (s[0] && s[0].type) : undefined;
-        }
-
-        // treat as *healthy* if we clearly have playable media or are advancing time
-        function isPlaybackHealthy() {
-            try {
-                if (!video.paused() && Number(video.currentTime()) > 0) return true;
-                if (typeof video.readyState === 'function') {
-                    if (video.readyState() >= 2 && isFinite(video.duration()) && video.duration() > 0) return true;
-                }
-                // also check tech el if available
-                const el = videoEl;
-                if (el && typeof el.readyState === 'number' && el.readyState >= 2) return true;
-            } catch {}
-            return false;
-        }
-
-        // start 30s grace on first real start signal
-        function startGraceIfNeeded() {
-            if (graceTimerStarted) return;
-            graceTimerStarted = true;
-            graceTimerId = setTimeout(() => {
-                // after 30s, only enable retries if we are not healthy
-                allowRetries = true;
-                if (!isPlaybackHealthy()) {
-                    scheduleVideoRetry('post-30s-initial');
-                }
-            }, 30000);
-        }
-
-        video.one('loadeddata', startGraceIfNeeded);
-        video.one('play',       startGraceIfNeeded);
-
-        // only retry when truly broken, and only after grace
-        function scheduleVideoRetry(reason) {
-            if (!allowRetries) return;            // do nothing inside 30s grace
-            if (isPlaybackHealthy()) {            // if at any point we look fine, reset and stop
-                vjsRetryCount = 0;
-                return;
-            }
-            if (navigator && 'onLine' in navigator && !navigator.onLine) {
-                // wait until we come back online, then retry once
-                const onlineOnce = () => {
-                    window.removeEventListener('online', onlineOnce);
-                    scheduleVideoRetry('back-online');
-                };
-                window.addEventListener('online', onlineOnce, { once: true });
-                return;
-            }
-
-            const step = Math.min(vjsRetryCount, VJS_RETRY_STEPS_MS.length - 1);
-            const delay = VJS_RETRY_STEPS_MS[step];
-            vjsRetryCount++;
-
-            const keepTime = Number(video.currentTime());
-
-            // pause & clear sync while we refetch 
-            try { video.pause(); } catch {}
-            try { audio.pause(); } catch {}
-            clearSyncLoop();
-
-            setTimeout(() => {
-                const srcUrl  = currentVideoSrc() || videoSrc;
-                const type    = currentVideoType() || videoType;
-
-                try {
-                    if (type) video.src({ src: srcUrl, type });
-                    else      video.src(srcUrl);
-                } catch {}
-
-                // force underlying tech to refresh if available
-                try { videoEl.load && videoEl.load(); } catch {}
-
-                video.one('loadeddata', () => {
-                    try {
-                        if (isFinite(keepTime)) {
-                            video.currentTime(keepTime);
-                            safeSetCT(audio, keepTime);
-                        }
-                    } catch {}
-                    // fix: after refresh, only spin up if that point can actually play now
-                    if (bothPlayableAt(Number(video.currentTime()))) {
-                        video.play()?.catch(()=>{});
-                        if (audioReady) audio.play()?.catch(()=>{});
-                        if (!syncInterval) startSyncLoop();
-                    } else {
-                        try { video.pause(); } catch {}
-                        try { audio.pause(); } catch {}
-                        clearSyncLoop();
-                    }
-                });
-            }, delay);
-        }
-
-        // watchdog: only active after grace; if time does not advance while “playing”, do a fast retry
-        function startWatchdog() {
-            watch.active = true;
-            watch.t  = Number(video.currentTime());
-            watch.at = Date.now();
-        }
-        function stopWatchdog() {
-            watch.active = false;
-        }
-        video.on('playing', () => { startWatchdog(); if (allowRetries) vjsRetryCount = 0; });
-        video.on('pause',   () => { stopWatchdog(); });
-        video.on('waiting', () => { startWatchdog(); });
-
-        video.on('timeupdate', () => {
-            if (!allowRetries || !watch.active) return;
-            const ct = Number(video.currentTime());
-            if (ct !== watch.t) {
-                watch.t = ct;
-                watch.at = Date.now();
-                return;
-            }
-            if ((Date.now() - watch.at) > WATCH_GRACE_MS && !video.paused()) {
-                scheduleVideoRetry('watchdog');
-                stopWatchdog();
-            }
-        });
-
-        // error gating: ignore everything until grace ends; after that, only retry if truly broken
-        function browserThinksPlayable() {
-            try {
-                const type = currentVideoType() || videoType;
-                if (type && videoEl && typeof videoEl.canPlayType === 'function') {
-                    const res = videoEl.canPlayType(type);
-                    return !!(res && res !== 'no');
-                }
-            } catch {}
-            return false;
-        }
-
-        function shouldRetryForError(err) {
-            if (!allowRetries) return false;      // never react during grace window
-            if (isPlaybackHealthy()) return false;
-            if (!err) return true; // sometimes empty error objects are emitted for real stalls
-
-            // HTML5 codes: 1=aborted, 2=network, 3=decode, 4=src not supported (noisy)
-            if (err.code === 2 || err.code === 3) return true;
-
-            // For code 4, only retry if we already had data or browser says it can play this type
-            if (err.code === 4) {
-                if (videoReady || browserThinksPlayable()) return true;
-                return false; // real "not supported" → do not loop
-            }
-
-            const msg = String(err.message || '').toLowerCase();
-            if (
-                msg.includes('network error') ||
-                msg.includes('media download') ||
-                msg.includes('server or network failed') ||
-                msg.includes('demuxer') ||
-                msg.includes('decode')
-            ) return true;
-
-            return false;
-        }
-
-        // main error hook (gated by 30s)
-        video.on('error', () => {
-            const err = video.error && video.error();
-            if (shouldRetryForError(err)) {
-                scheduleVideoRetry('error');
-            }
-        });
-
-        // treat transient stalls/aborts as retryable, but only after grace and only if not healthy
-        video.on('stalled', () => { if (allowRetries && !isPlaybackHealthy()) scheduleVideoRetry('stalled'); });
-        video.on('abort',   () => { if (allowRetries && !isPlaybackHealthy()) scheduleVideoRetry('abort'); });
-        video.on('suspend', () => { if (allowRetries && !isPlaybackHealthy()) scheduleVideoRetry('suspend'); });
-        video.on('emptied', () => { if (allowRetries && !isPlaybackHealthy()) scheduleVideoRetry('emptied'); });
-
-        // if we truly can play, reset counters; also cancel grace if we’re definitely healthy early
-        function markHealthy() {
-            vjsRetryCount = 0;
-            // no explicit cancel of grace; just a no-op once healthy
-        }
-        video.on('canplay',     markHealthy);
-        video.on('playing',     markHealthy);
-        video.on('loadeddata',  markHealthy);
-
-        // === AUDIO WATCHDOG (quiet, invisible) ===
-        // If audio gets stuck (e.g., CORS hiccup / network) while video advances,
-        // reload audio source silently and resync.
-        let audioWatch = { t: 0, at: 0, playing: false };
-        const AUDIO_WATCH_MS = 2500;
-        const AUDIO_RETRY_STEPS_MS = [200, 350, 500, 700, 900, 1200];
-        let audioRetryCount = 0;
-
-        function audioStartWatch() {
-            audioWatch.t = Number(audio.currentTime) || 0;
-            audioWatch.at = Date.now();
-            audioWatch.playing = true;
-        }
-        function audioStopWatch() {
-            audioWatch.playing = false;
-        }
-
-        const audioWatchTicker = setInterval(() => {
-            if (!allowRetries || !audioWatch.playing) return;
-            const at = Number(audio.currentTime) || 0;
-            if (at !== audioWatch.t) {
-                audioWatch.t = at;
-                audioWatch.at = Date.now();
-                return;
-            }
-            // not advancing while video is playing → consider retry
-            if (!video.paused() && (Date.now() - audioWatch.at) > AUDIO_WATCH_MS) {
-                // backoff
-                const step = Math.min(audioRetryCount, AUDIO_RETRY_STEPS_MS.length - 1);
-                const delay = AUDIO_RETRY_STEPS_MS[step];
-                audioRetryCount++;
-
-                const keep = Number(video.currentTime()) || at;
-
-                // pause quietly
-                try { audio.pause(); } catch {}
-                try { clearSyncLoop(); } catch {}
-
-                setTimeout(() => {
-                    // refresh audio src (prefer currentSrc if available, else original)
-                    audioSrc = pickAudioSrc() || audioSrc;
-                    try {
-                        audio.removeAttribute('src');
-                        [...audio.querySelectorAll('source')].forEach(n => n.remove());
-                        if (audioSrc) audio.src = audioSrc;
-                        audio.load();
-                    } catch {}
-
-                    audio.addEventListener('loadeddata', function relinkOnce() {
-                        audio.removeEventListener('loadeddata', relinkOnce);
-                        try {
-                            if (isFinite(keep)) safeSetCT(audio, keep);
-                            // fix: only spin up audio again if both sides can actually play now
-                            const tNow = Number(video.currentTime());
-                            if (bothPlayableAt(tNow)) {
-                                audio.play()?.catch(()=>{});
-                                if (!syncInterval) startSyncLoop();
-                                audioRetryCount = 0;
-                                audioStartWatch();
-                            } else {
-                                try { audio.pause(); } catch {}
-                                clearSyncLoop();
-                            }
-                        } catch {}
-                    }, { once: true });
-                }, delay);
-            }
-        }, 400);
-
-        // keep audio watchdog aligned with video state
-        video.on('playing', audioStartWatch);
-        video.on('pause',   audioStopWatch);
-        video.on('waiting', audioStartWatch);
-        audio.addEventListener('playing', audioStartWatch);
-        audio.addEventListener('pause',   audioStopWatch);
-
-        // clean up on unload (avoid stray timers)
-        window.addEventListener('beforeunload', () => {
-            clearSyncLoop();
-            try { clearInterval(audioWatchTicker); } catch {}
-            try { clearTimeout(graceTimerId); } catch {}
-        });
+  // --- Sync loop (micro-drift) ----------------------------------------------
+  function clearSyncLoop() {
+    if (syncInterval) {
+      clearInterval(syncInterval);
+      syncInterval = null;
     }
+    try { audioEl.playbackRate = 1; } catch {}
+  }
+  function startSyncLoop() {
+    clearSyncLoop();
+    syncInterval = setInterval(() => {
+      const vt = Number(player.currentTime());
+      const at = Number(audioEl.currentTime);
+      if (!isFinite(vt) || !isFinite(at)) return;
+      const delta = vt - at;
+
+      if (Math.abs(delta) > BIG_DRIFT) {
+        safeSetCT(audioEl, vt);
+        try { audioEl.playbackRate = 1; } catch {}
+        return;
+      }
+      if (Math.abs(delta) > MICRO_DRIFT) {
+        const target = 1 + (delta * 0.12);
+        try { audioEl.playbackRate = Math.max(0.85, Math.min(1.15, target)); } catch {}
+      } else {
+        try { audioEl.playbackRate = 1; } catch {}
+      }
+    }, SYNC_INTERVAL_MS);
+  }
+
+  // --- Retry glue for raw media ---------------------------------------------
+  function attachRetry(elm, resolveSrc, markReady) {
+    const onLoaded = () => {
+      try { elm._didRetry = false; } catch {}
+      try { markReady && markReady(); } catch {}
+      tryStart();
+    };
+    elm.addEventListener('loadeddata', onLoaded, { once: true });
+    elm.addEventListener('loadedmetadata', onLoaded, { once: true });
+
+    elm.addEventListener('error', () => {
+      const retryURL = resolveSrc?.();
+      if (!elm._didRetry && retryURL) {
+        elm._didRetry = true;
+        try {
+          elm.removeAttribute('src');
+          [...elm.querySelectorAll('source')].forEach(n => n.remove());
+          elm.src = retryURL;
+          elm.load();
+        } catch {}
+      }
+    }, { once: true });
+  }
+
+  // --- Volume & mute mirroring (both directions, loop-safe) -----------------
+  let volSyncGuard = false;
+  function clamp01(v) { return Math.max(0, Math.min(1, Number(v))); }
+
+  function mirrorFromPlayerVolumeMute() {
+    if (volSyncGuard) return;
+    volSyncGuard = true;
+    try {
+      const vMuted = !!player.muted();
+      const vVol = clamp01(player.volume());
+      // Apply to audio
+      audioEl.muted = vMuted;
+      audioEl.volume = vMuted ? audioEl.volume : vVol; // keep volume value but mute controls audibility
+      // Also ensure <video> DOM element mirrors mute (some browsers read underlying muted)
+      try { videoEl.muted = vMuted; } catch {}
+    } catch {}
+    volSyncGuard = false;
+  }
+  function mirrorFromAudioVolumeMute() {
+    if (volSyncGuard) return;
+    volSyncGuard = true;
+    try {
+      const aMuted = !!audioEl.muted;
+      const aVol = clamp01(audioEl.volume);
+      // Apply to player (Video.js)
+      player.muted(aMuted);
+      if (!aMuted) player.volume(aVol);
+      // Also set underlying <video> mute for consistency
+      try { videoEl.muted = aMuted; } catch {}
+    } catch {}
+    volSyncGuard = false;
+  }
+
+  // Initial mirror (handles default mute/volume + mute button clicks later)
+  player.on('volumechange', mirrorFromPlayerVolumeMute);
+  audioEl.addEventListener('volumechange', mirrorFromAudioVolumeMute);
+  // Some browsers fire 'emptied'/'loadedmetadata' before volumechange reflects; do a kick
+  player.ready(() => mirrorFromPlayerVolumeMute());
+
+  // --- Play/pause + seek coupling -------------------------------------------
+  function tryStart() {
+    if (audioReady && videoReady) {
+      const t = Number(player.currentTime());
+      if (isFinite(t) && Math.abs(Number(audioEl.currentTime) - t) > 0.1) {
+        safeSetCT(audioEl, t);
+      }
+      // Start only if frame is truly playable for both
+      if (bothPlayableAt(t)) {
+        player.play()?.catch(()=>{});
+        audioEl.play()?.catch(()=>{});
+        startSyncLoop();
+      } else {
+        try { player.pause(); } catch {}
+        try { audioEl.pause(); } catch {}
+        clearSyncLoop();
+      }
+      setupMediaSession(); // idempotent
+    }
+  }
+
+  // --- Media Session (desktop KDE / Android keys) ---------------------------
+  function updateMSPositionState() {
+    try {
+      if (!('mediaSession' in navigator)) return;
+      if (!('setPositionState' in navigator.mediaSession)) return;
+      const duration = Number(player.duration()) || 0;
+      const position = Number(player.currentTime()) || 0;
+      const playbackRate = Number(player.playbackRate()) || 1;
+      navigator.mediaSession.setPositionState({ duration, playbackRate, position });
+    } catch {}
+  }
+
+  function setupMediaSession() {
+    if (mediaSessionReady) return;
+    if (!('mediaSession' in navigator)) return;
+
+    try {
+      navigator.mediaSession.metadata = new MediaMetadata({
+        title: document.title || 'Video',
+        artist: '',
+        album: '',
+        artwork: [] // add thumbs if you want lockscreen art
+      });
+    } catch {}
+
+    function setState() {
+      try {
+        navigator.mediaSession.playbackState = player.paused() ? 'paused' : 'playing';
+      } catch {}
+      updateMSPositionState();
+    }
+
+    navigator.mediaSession.setActionHandler('play', () => {
+      // Play both; if autoplay restrictions, user gesture will resolve
+      player.play()?.then(() => audioEl.play()?.catch(()=>{})).catch(()=>{});
+      setState();
+    });
+    navigator.mediaSession.setActionHandler('pause', () => {
+      player.pause();
+      audioEl.pause();
+      setState();
+      clearSyncLoop();
+    });
+    navigator.mediaSession.setActionHandler('stop', () => {
+      player.pause();
+      audioEl.pause();
+      try { player.currentTime(0); } catch {}
+      try { audioEl.currentTime = 0; } catch {}
+      clearSyncLoop();
+      setState();
+    });
+    navigator.mediaSession.setActionHandler('seekbackward', ({ seekOffset }) => {
+      const skip = seekOffset || 10;
+      const to = Math.max(0, Number(player.currentTime()) - skip);
+      player.currentTime(to);
+      safeSetCT(audioEl, to);
+      setState();
+    });
+    navigator.mediaSession.setActionHandler('seekforward', ({ seekOffset }) => {
+      const skip = seekOffset || 10;
+      const to = Number(player.currentTime()) + skip;
+      player.currentTime(to);
+      safeSetCT(audioEl, to);
+      setState();
+    });
+    navigator.mediaSession.setActionHandler('seekto', ({ seekTime, fastSeek }) => {
+      if (!isFinite(seekTime)) return;
+      if (fastSeek && 'fastSeek' in audioEl) { try { audioEl.fastSeek(seekTime); } catch { safeSetCT(audioEl, seekTime); } }
+      else { safeSetCT(audioEl, seekTime); }
+      player.currentTime(seekTime);
+      setState();
+    });
+
+    mediaSessionReady = true;
+    // Keep position state fresh
+    player.on('timeupdate', updateMSPositionState);
+    player.on('ratechange', updateMSPositionState);
+    player.on('play', setState);
+    player.on('pause', setState);
+  }
+
+  // --- Desktop media-key fallback -------------------------------------------
+  document.addEventListener('keydown', e => {
+    switch (e.code) {
+      case 'AudioPlay':
+      case 'MediaPlayPause':
+        if (player.paused()) { player.play()?.catch(()=>{}); audioEl.play()?.catch(()=>{}); }
+        else { player.pause(); audioEl.pause(); }
+        break;
+      case 'AudioPause':
+        player.pause(); audioEl.pause();
+        break;
+      case 'AudioNext':
+      case 'MediaTrackNext': {
+        const t = Math.max(0, Number(player.currentTime()) + 10);
+        player.currentTime(t); safeSetCT(audioEl, t);
+        break;
+      }
+      case 'AudioPrevious':
+      case 'MediaTrackPrevious': {
+        const t = Math.max(0, Number(player.currentTime()) - 10);
+        player.currentTime(t); safeSetCT(audioEl, t);
+        break;
+      }
+    }
+  });
+
+  // --- Primary coupling (skip when qua=medium) -------------------------------
+  if (qua !== "medium") {
+    // Attach robust one-shot retries + ready marks
+    attachRetry(audioEl, pickAudioSrc, () => { audioReady = true; });
+    attachRetry(videoEl, () => currentVideoSrc() || initialVideoSrc, () => { videoReady = true; });
+
+    // Keep rate aligned (rare)
+    player.on('ratechange', () => {
+      try { audioEl.playbackRate = player.playbackRate(); } catch {}
+    });
+
+    // Start: when player starts, pull audio along
+    player.on('play', () => {
+      if (!syncInterval) startSyncLoop();
+      const vt = Number(player.currentTime());
+      if (Math.abs(vt - Number(audioEl.currentTime)) > 0.3) safeSetCT(audioEl, vt);
+      if (audioReady) audioEl.play()?.catch(()=>{});
+      try {
+        if ('mediaSession' in navigator) navigator.mediaSession.playbackState = 'playing';
+      } catch {}
+    });
+
+    player.on('pause', () => {
+      audioEl.pause();
+      clearSyncLoop();
+      try {
+        if ('mediaSession' in navigator) navigator.mediaSession.playbackState = 'paused';
+      } catch {}
+    });
+
+    // Buffering
+    player.on('waiting', () => {
+      audioEl.pause();
+      clearSyncLoop();
+    });
+    player.on('playing', () => {
+      if (audioReady) audioEl.play()?.catch(()=>{});
+      if (!syncInterval) startSyncLoop();
+    });
+
+    // Error UI (skip code 1)
+    const errorBox = document.getElementById('loopedIndicator');
+    player.on('error', () => {
+      const mediaError = player.error();
+      let message = 'An unknown error occurred.';
+      if (mediaError) {
+        if (mediaError.code === 1) return;
+        message = `Error ${mediaError.code} : ${mediaError.message || 'No message provided'} try to refresh the page?`;
+      }
+      if (errorBox) {
+        errorBox.textContent = message;
+        errorBox.style.display = 'block';
+        errorBox.style.width = 'fit-content';
+      }
+    });
+
+    // Seek coupling (resume only if previously playing and frame is playable)
+    let wasPlayingBeforeSeek = false;
+    player.on('seeking', () => {
+      wasPlayingBeforeSeek = !player.paused();
+      audioEl.pause();
+      clearSyncLoop();
+      const vt = Number(player.currentTime());
+      if (Math.abs(vt - Number(audioEl.currentTime)) > 0.1) safeSetCT(audioEl, vt);
+    });
+    player.on('seeked', () => {
+      const vt = Number(player.currentTime());
+      if (Math.abs(vt - Number(audioEl.currentTime)) > 0.05) safeSetCT(audioEl, vt);
+      if (wasPlayingBeforeSeek && bothPlayableAt(vt)) {
+        player.play()?.catch(()=>{});
+        if (audioReady) audioEl.play()?.catch(()=>{});
+        if (!syncInterval) startSyncLoop();
+      } else {
+        try { player.pause(); } catch {}
+        try { audioEl.pause(); } catch {}
+        clearSyncLoop();
+      }
+    });
+
+    // Small nudges when fully buffered
+    player.on('canplaythrough', () => {
+      const vt = Number(player.currentTime());
+      if (Math.abs(vt - Number(audioEl.currentTime)) > 0.1) safeSetCT(audioEl, vt);
+    });
+    audioEl.addEventListener('canplaythrough', () => {
+      const vt = Number(player.currentTime());
+      if (Math.abs(vt - Number(audioEl.currentTime)) > 0.1) safeSetCT(audioEl, vt);
+    });
+
+    // End handling
+    player.on('ended', () => { try { audioEl.pause(); } catch {}; clearSyncLoop(); });
+    audioEl.addEventListener('ended', () => { try { player.pause(); } catch {}; clearSyncLoop(); });
+
+    // Exit fullscreen: pause both
+    document.addEventListener('fullscreenchange', () => {
+      if (!document.fullscreenElement) {
+        player.pause(); audioEl.pause(); clearSyncLoop();
+      }
+    });
+
+    // --- Video retry logic (post-grace, only when truly stalled) ------------
+    const VJS_RETRY_STEPS_MS = [250, 400, 650, 900, 1200, 1600, 2000, 2600];
+    let vjsRetryCount = 0;
+    let allowRetries = false;
+    let graceTimerStarted = false;
+    let graceTimerId = null;
+
+    let watch = { t: 0, at: 0, active: false };
+    const WATCH_GRACE_MS = 2200;
+
+    function isPlaybackHealthy() {
+      try {
+        if (!player.paused() && Number(player.currentTime()) > 0) return true;
+        if (typeof player.readyState === 'function') {
+          if (player.readyState() >= 2 && isFinite(player.duration()) && player.duration() > 0) return true;
+        }
+        if (videoEl && typeof videoEl.readyState === 'number' && videoEl.readyState >= 2) return true;
+      } catch {}
+      return false;
+    }
+
+    function startGraceIfNeeded() {
+      if (graceTimerStarted) return;
+      graceTimerStarted = true;
+      graceTimerId = setTimeout(() => {
+        allowRetries = true;
+        if (!isPlaybackHealthy()) scheduleVideoRetry('post-30s-initial');
+      }, 30000);
+    }
+
+    player.one('loadeddata', startGraceIfNeeded);
+    player.one('play', startGraceIfNeeded);
+
+    function browserThinksPlayable() {
+      try {
+        const type = currentVideoType() || initialVideoType;
+        if (type && videoEl && typeof videoEl.canPlayType === 'function') {
+          const res = videoEl.canPlayType(type);
+          return !!(res && res !== 'no');
+        }
+      } catch {}
+      return false;
+    }
+
+    function shouldRetryForError(err) {
+      if (!allowRetries) return false;
+      if (isPlaybackHealthy()) return false;
+      if (!err) return true;
+      if (err.code === 2 || err.code === 3) return true;
+      if (err.code === 4) return (videoReady || browserThinksPlayable());
+      const msg = String(err.message || '').toLowerCase();
+      if (
+        msg.includes('network error') ||
+        msg.includes('media download') ||
+        msg.includes('server or network failed') ||
+        msg.includes('demuxer') ||
+        msg.includes('decode')
+      ) return true;
+      return false;
+    }
+
+    function scheduleVideoRetry(_reason) {
+      if (!allowRetries) return;
+      if (isPlaybackHealthy()) { vjsRetryCount = 0; return; }
+      if ('onLine' in navigator && !navigator.onLine) {
+        const onlineOnce = () => { window.removeEventListener('online', onlineOnce); scheduleVideoRetry('back-online'); };
+        window.addEventListener('online', onlineOnce, { once: true });
+        return;
+      }
+      const step = Math.min(vjsRetryCount, VJS_RETRY_STEPS_MS.length - 1);
+      const delay = VJS_RETRY_STEPS_MS[step];
+      vjsRetryCount++;
+
+      const keepTime = Number(player.currentTime());
+
+      try { player.pause(); } catch {}
+      try { audioEl.pause(); } catch {}
+      clearSyncLoop();
+
+      setTimeout(() => {
+        const srcUrl  = currentVideoSrc() || initialVideoSrc;
+        const type    = currentVideoType() || initialVideoType;
+        try { type ? player.src({ src: srcUrl, type }) : player.src(srcUrl); } catch {}
+        try { videoEl.load && videoEl.load(); } catch {}
+
+        player.one('loadeddata', () => {
+          try {
+            if (isFinite(keepTime)) {
+              player.currentTime(keepTime);
+              safeSetCT(audioEl, keepTime);
+            }
+          } catch {}
+          const now = Number(player.currentTime());
+          if (bothPlayableAt(now)) {
+            player.play()?.catch(()=>{});
+            if (audioReady) audioEl.play()?.catch(()=>{});
+            if (!syncInterval) startSyncLoop();
+          } else {
+            try { player.pause(); } catch {}
+            try { audioEl.pause(); } catch {}
+            clearSyncLoop();
+          }
+        });
+      }, delay);
+    }
+
+    function startWatchdog() {
+      watch.active = true;
+      watch.t  = Number(player.currentTime());
+      watch.at = Date.now();
+    }
+    function stopWatchdog() { watch.active = false; }
+
+    player.on('playing', () => { startWatchdog(); if (allowRetries) vjsRetryCount = 0; });
+    player.on('pause',   () => { stopWatchdog(); });
+    player.on('waiting', () => { startWatchdog(); });
+
+    player.on('timeupdate', () => {
+      if (!allowRetries || !watch.active) return;
+      const ct = Number(player.currentTime());
+      if (ct !== watch.t) { watch.t = ct; watch.at = Date.now(); return; }
+      if ((Date.now() - watch.at) > WATCH_GRACE_MS && !player.paused()) {
+        scheduleVideoRetry('watchdog');
+        stopWatchdog();
+      }
+    });
+
+    // Forward additional "broken-ish" events only after grace
+    player.on('stalled', () => { if (allowRetries && !isPlaybackHealthy()) scheduleVideoRetry('stalled'); });
+    player.on('abort',   () => { if (allowRetries && !isPlaybackHealthy()) scheduleVideoRetry('abort'); });
+    player.on('suspend', () => { if (allowRetries && !isPlaybackHealthy()) scheduleVideoRetry('suspend'); });
+    player.on('emptied', () => { if (allowRetries && !isPlaybackHealthy()) scheduleVideoRetry('emptied'); });
+
+    // Healthy markers reset retry counters
+    function markHealthy() { vjsRetryCount = 0; }
+    player.on('canplay', markHealthy);
+    player.on('playing', markHealthy);
+    player.on('loadeddata', markHealthy);
+
+    // --- Audio watchdog (silent refresh) ------------------------------------
+    let audioWatch = { t: 0, at: 0, playing: false };
+    const AUDIO_WATCH_MS = 2500;
+    const AUDIO_RETRY_STEPS_MS = [200, 350, 500, 700, 900, 1200];
+    let audioRetryCount = 0;
+
+    function audioStartWatch() {
+      audioWatch.t = Number(audioEl.currentTime) || 0;
+      audioWatch.at = Date.now();
+      audioWatch.playing = true;
+    }
+    function audioStopWatch() { audioWatch.playing = false; }
+
+    const audioWatchTicker = setInterval(() => {
+      if (!allowRetries || !audioWatch.playing) return;
+      const at = Number(audioEl.currentTime) || 0;
+      if (at !== audioWatch.t) { audioWatch.t = at; audioWatch.at = Date.now(); return; }
+      if (!player.paused() && (Date.now() - audioWatch.at) > AUDIO_WATCH_MS) {
+        const step = Math.min(audioRetryCount, AUDIO_RETRY_STEPS_MS.length - 1);
+        const delay = AUDIO_RETRY_STEPS_MS[step];
+        audioRetryCount++;
+
+        const keep = Number(player.currentTime()) || at;
+
+        try { audioEl.pause(); } catch {}
+        clearSyncLoop();
+
+        setTimeout(() => {
+          audioSrc = pickAudioSrc() || audioSrc;
+          try {
+            audioEl.removeAttribute('src');
+            [...audioEl.querySelectorAll('source')].forEach(n => n.remove());
+            if (audioSrc) audioEl.src = audioSrc;
+            audioEl.load();
+          } catch {}
+
+          audioEl.addEventListener('loadeddata', function relinkOnce() {
+            audioEl.removeEventListener('loadeddata', relinkOnce);
+            try {
+              if (isFinite(keep)) safeSetCT(audioEl, keep);
+              const tNow = Number(player.currentTime());
+              if (bothPlayableAt(tNow)) {
+                audioEl.play()?.catch(()=>{});
+                if (!syncInterval) startSyncLoop();
+                audioRetryCount = 0;
+                audioStartWatch();
+              } else {
+                try { audioEl.pause(); } catch {}
+                clearSyncLoop();
+              }
+            } catch {}
+          }, { once: true });
+        }, delay);
+      }
+    }, 400);
+
+    // Keep audio watchdog aligned with player state
+    player.on('playing', audioStartWatch);
+    player.on('pause',   audioStopWatch);
+    player.on('waiting', audioStartWatch);
+    audioEl.addEventListener('playing', audioStartWatch);
+    audioEl.addEventListener('pause',   audioStopWatch);
+
+    // Clean up
+    window.addEventListener('beforeunload', () => {
+      clearSyncLoop();
+      try { clearInterval(audioWatchTicker); } catch {}
+      try { clearTimeout(graceTimerId); } catch {}
+    });
+  }
+
+  // --- Autoplay / user-gesture nudge (Android browsers esp.) ----------------
+  // If initial play fails due to gesture policy, clicking anywhere on the player surface will start both.
+  player.ready(() => {
+    const tryKick = () => {
+      if (audioReady && videoReady && player.paused()) {
+        const t = Number(player.currentTime());
+        if (bothPlayableAt(t)) {
+          player.play()?.catch(()=>{});
+          audioEl.play()?.catch(()=>{});
+          startSyncLoop();
+        }
+      }
+    };
+    player.el().addEventListener('click', tryKick, { once: true });
+  });
 });
-
-
  // https://codeberg.org/ashley/poke/src/branch/main/src/libpoketube/libpoketube-youtubei-objects.json