diff --git a/css/player-base.js b/css/player-base.js
index ad62f2ce..b5dc68db 100644
--- a/css/player-base.js
+++ b/css/player-base.js
@@ -2,429 +2,686 @@
 var _yt_player = videojs;
 
 var versionclient = "youtube.player.web_20250917_22_RC00"
- // video.js 8 init - source can be seen in https://poketube.fun/static/vjs.min.js or the vjs.min.js file
+
+
+
+
+
 document.addEventListener("DOMContentLoaded", () => {
-  const player = videojs("video", {
-    controls: true,
-    autoplay: false,
-    preload: "auto",
-    errorDisplay: false,
-  });
+    // 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 qs = new URLSearchParams(window.location.search);
-  const qua = qs.get("quality") || "";
-  const vidKey = qs.get("v");
-  try { if (vidKey) localStorage.setItem(`progress-${vidKey}`, 0); } catch {}
+    // 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');
 
-  // keep the hidden audio out of the way
-  try {
-    audioEl.controls = false;
-    audioEl.setAttribute("aria-hidden", "true");
-    audioEl.setAttribute("tabindex", "-1");
-    audioEl.setAttribute("controlslist", "noplaybackrate nodownload noremoteplayback");
-    audioEl.disableRemotePlayback = true;
-    videoEl.setAttribute("playsinline", "");
-    audioEl.setAttribute("playsinline", "");
-    audioEl.preload = "auto";
-  } 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();
 
-  const srcObj = player.src();
-  const initialVideoSrc = Array.isArray(srcObj) ? (srcObj[0] && srcObj[0].src) : srcObj;
+    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;
 
-  // state
-  let audioReady = false, videoReady = false;
-  let mediaSessionReady = false;
-
-  // sync thresholds
-  const BIG_DRIFT   = 0.45;
-  const MICRO_DRIFT = 0.035;
-  const EPS         = 0.12;
-
-  // guards
-  let volGuard = false;
-  let syncGuard = false;
-  let couplingGuard = false;
-  let seekingActive = false;       // <- we’re inside a seek
-  let audioPauseForSeek = false;   // <- suppress audio pause echo during seek
-
-  // tiny helpers
-  const clamp01 = v => Math.max(0, Math.min(1, Number(v)));
-  function safeSetCT(m, t){ try{ if(isFinite(t) && t>=0) m.currentTime = t; }catch{} }
-  function timeInBuffered(m, t){
-    try{
-      const b = m.buffered;
-      if(!b || b.length===0 || !isFinite(t)) return false;
-      for(let i=0;i<b.length;i++){
-        const s = b.start(i)-EPS, e = b.end(i)+EPS;
-        if(t>=s && t<=e) return true;
-      }
-    }catch{}
-    return false;
-  }
-  function canPlayAt(m, t){
-    try{
-      const rs = Number(m.readyState||0);
-      if(!isFinite(t)) return false;
-      if(rs >= 3) return true;
-      return timeInBuffered(m,t);
-    }catch{ return false; }
-  }
-  function bothPlayableAt(t){ return canPlayAt(videoEl,t) && canPlayAt(audioEl,t); }
-  function isLooping(){ try { return !!player.loop?.() || !!videoEl.loop; } catch { return !!videoEl.loop; } }
-
-  // volume/mute mirror
-  function mirrorFromPlayerVolumeMute(){
+  // keep mute/volume mirrored either way
+  function mirrorFromPlayerVolumeMute() {
     if (volGuard) return; volGuard = true;
-    try{
+    try {
       const m = !!player.muted();
       const v = clamp01(player.volume());
       audioEl.muted = m;
-      if(!m) audioEl.volume = v;
-      try{ videoEl.muted = m; }catch{}
-    }finally{ volGuard = false; }
+      if (!m) audioEl.volume = v;
+      try { videoEl.muted = m; } catch {}
+    } catch {}
+    volGuard = false;
   }
-  function mirrorFromAudioVolumeMute(){
+  function mirrorFromAudioVolumeMute() {
     if (volGuard) return; volGuard = true;
-    try{
+    try {
       const m = !!audioEl.muted;
       const v = clamp01(audioEl.volume);
       player.muted(m);
-      if(!m) player.volume(v);
-      try{ videoEl.muted = m; }catch{}
-    }finally{ volGuard = false; }
+      if (!m) player.volume(v);
+      try { videoEl.muted = m; } catch {}
+    } catch {}
+    volGuard = false;
   }
   player.on("volumechange", mirrorFromPlayerVolumeMute);
   audioEl.addEventListener("volumechange", mirrorFromAudioVolumeMute);
   player.ready(() => mirrorFromPlayerVolumeMute());
 
-  // coupled play/pause
-  function playBoth(){
-    if (couplingGuard) return;
-    couplingGuard = true;
-    player.play()?.catch(()=>{});
-    audioEl.play()?.catch(()=>{});
-    couplingGuard = false;
-  }
-  function pauseBoth(){
-    if (couplingGuard) return;
-    couplingGuard = true;
-    player.pause();
-    audioEl.pause();
-    couplingGuard = false;
-  }
+    // readiness + sync state
+    let audioReady = false, videoReady = false;
+    let syncInterval = null;
 
-  // always keep audio in lockstep with player
-  player.on("play", () => {
-    if (seekingActive) return; // don’t fight the seek flow
-    if (audioEl.paused) audioEl.play()?.catch(()=>{});
-    try { if ("mediaSession" in navigator) navigator.mediaSession.playbackState = "playing"; } catch {}
-  });
-  player.on("pause", () => {
-    if (!audioEl.paused) audioEl.pause();
-    try { if ("mediaSession" in navigator) navigator.mediaSession.playbackState = "paused"; } catch {}
-  });
+    // thresholds / constants
+    const BIG_DRIFT = 0.5;
+    const MICRO_DRIFT = 0.05;
+    const SYNC_INTERVAL_MS = 250;
 
-  // don’t let audio start/stop by itself
-  audioEl.addEventListener("play", () => {
-    if (seekingActive) { audioEl.pause(); return; }
-    if (player.paused()) playBoth();
-  });
-  audioEl.addEventListener("pause", () => {
-    if (audioPauseForSeek) return;         // ignore our deliberate pause during seek
-    if (!player.paused()) pauseBoth();
-  });
-
-  // media session (OS controls)
-  let lastMSPos = 0, lastMSAt = 0;
-  const MS_THROTTLE_MS = 250;
-  function getDuration(){
-    let d = Number(videoEl.duration);
-    if (!isFinite(d) || d<=0) d = Number(player.duration());
-    if (!isFinite(d) || d<=0) d = Number(audioEl.duration);
-    return isFinite(d) && d>0 ? d : null;
-  }
-  function updateMSPositionState(throttle=true){
-    if (!("mediaSession" in navigator)) return;
-    const now = performance.now();
-    if (throttle && (now - lastMSAt) < MS_THROTTLE_MS) return;
-    const dur = getDuration(); if (!dur) return;
-    let pos = Number(player.currentTime()); if (!isFinite(pos)||pos<0) pos = 0;
-    if (pos + 0.2 < lastMSPos && isLooping()) lastMSPos = 0;
-    else {
-      if (pos < lastMSPos && (lastMSPos - pos) < 0.2) pos = lastMSPos;
-      lastMSPos = pos;
-    }
-    lastMSAt = now;
-    try{
-      if ("setPositionState" in navigator.mediaSession){
-        navigator.mediaSession.setPositionState({
-          duration: dur,
-          playbackRate: Number(player.playbackRate()) || 1,
-          position: Math.max(0, Math.min(dur, pos)),
-        });
-      }
-    }catch{}
-  }
-  function setupMediaSession(){
-    if (mediaSessionReady) return;
-    if (!("mediaSession" in navigator)) return;
-
-    try {
-      navigator.mediaSession.metadata = new MediaMetadata({
-        title: document.title || "Video",
-        artist: "",
-        album: "",
-        artwork: []
-      });
-    } catch {}
-
-    const tagState = () => {
-      try { navigator.mediaSession.playbackState = player.paused() ? "paused" : "playing"; } catch {}
-      updateMSPositionState(false);
-    };
-
-    // IMPORTANT: OS seek should pause both and remain paused after
-    function msSeekTo(t){
-      seekingActive = true;
-      audioPauseForSeek = true;
-      pauseBoth();
-      syncGuard = true;
-      try {
-        if ("fastSeek" in audioEl) { try { audioEl.fastSeek(t); } catch { safeSetCT(audioEl, t); } }
-        else { safeSetCT(audioEl, t); }
-        player.currentTime(t);
-      } finally {
-        syncGuard = false;
-        audioPauseForSeek = false;
-        seekingActive = false;
-      }
-      tagState(); // stay paused
-    }
-
-    navigator.mediaSession.setActionHandler("play",  () => { playBoth(); tagState(); });
-    navigator.mediaSession.setActionHandler("pause", () => { pauseBoth(); tagState(); });
-    navigator.mediaSession.setActionHandler("stop",  () => {
-      pauseBoth();
-      try { player.currentTime(0); } catch {}
-      try { audioEl.currentTime = 0; } catch {}
-      tagState();
-    });
-    navigator.mediaSession.setActionHandler("seekbackward", ({seekOffset}) => {
-      const to = Math.max(0, Number(player.currentTime()) - (seekOffset || 10));
-      msSeekTo(to);
-    });
-    navigator.mediaSession.setActionHandler("seekforward", ({seekOffset}) => {
-      const to = Number(player.currentTime()) + (seekOffset || 10);
-      msSeekTo(to);
-    });
-    navigator.mediaSession.setActionHandler("seekto", ({seekTime}) => {
-      if (!isFinite(seekTime)) return;
-      msSeekTo(seekTime);
-    });
-
-    player.on("timeupdate", () => updateMSPositionState(true));
-    player.on("ratechange", () => updateMSPositionState(false));
-    player.on("loadedmetadata", () => { lastMSPos = 0; updateMSPositionState(false); });
-    player.on("durationchange", () => updateMSPositionState(false));
-    player.on("play",  () => { try { navigator.mediaSession.playbackState = "playing"; } catch {} updateMSPositionState(false); });
-    player.on("pause", () => { try { navigator.mediaSession.playbackState = "paused";  } catch {} updateMSPositionState(false); });
-    audioEl.addEventListener("loadedmetadata", () => updateMSPositionState(false));
-    audioEl.addEventListener("timeupdate", () => updateMSPositionState(true));
-
-    mediaSessionReady = true;
-  }
-
-  // media keys fallback
-  document.addEventListener("keydown", e => {
-    switch (e.code) {
-      case "AudioPlay":
-      case "MediaPlayPause":
-        if (player.paused()) playBoth(); else pauseBoth();
-        break;
-      case "AudioPause":
-        pauseBoth();
-        break;
-      case "AudioNext":
-      case "MediaTrackNext": {
-        const t = 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;
-      }
-    }
-  });
-
-  // simple event-driven sync (kept — but seeks will keep us paused)
-  let lastVideoTime = 0;
-  player.on("timeupdate", () => {
-    if (syncGuard) return;
-    const vt = Number(player.currentTime());
-    const at = Number(audioEl.currentTime);
-    if (!isFinite(vt) || !isFinite(at)) return;
-
-    if (vt + 0.02 < lastVideoTime && isLooping()) {
-      safeSetCT(audioEl, vt);
-      lastMSPos = 0; updateMSPositionState(false);
-      lastVideoTime = vt;
-      return;
-    }
-    lastVideoTime = vt;
-
-    if (!bothPlayableAt(vt)) 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.97, Math.min(1.03, target)); } catch {}
-    } else {
-      try { audioEl.playbackRate = 1; } catch {}
-    }
-  });
-
-  // player seek: ALWAYS pause both and keep paused after
-  player.on("seeking", () => {
-    seekingActive = true;
-    audioPauseForSeek = true;
-    pauseBoth(); // <- fixes Android loop (play/pause ping-pong)
-    const t = Number(player.currentTime());
-    syncGuard = true;
-    try {
-      safeSetCT(audioEl, t);
-    } finally {
-      syncGuard = false;
-      audioPauseForSeek = false;
-    }
-    updateMSPositionState(false);
-  });
-  player.on("seeked", () => {
-    const t = Number(player.currentTime());
-    syncGuard = true;
-    try { safeSetCT(audioEl, t); } finally { syncGuard = false; }
-    seekingActive = false;
-    // stay paused after a seek on mobile/desktop
-    try { player.pause(); } catch {}
-    try { audioEl.pause(); } catch {}
-    updateMSPositionState(false);
-  });
-
-  // if some platform seeks audio first, mirror to video but keep both paused
-  audioEl.addEventListener("seeking", () => {
-    seekingActive = true;
-    audioPauseForSeek = true;
-    pauseBoth();
-    const at = Number(audioEl.currentTime) || 0;
-    syncGuard = true;
-    try { player.currentTime(at); } finally { syncGuard = false; }
-    updateMSPositionState(false);
-  });
-  audioEl.addEventListener("seeked", () => {
-    const at = Number(audioEl.currentTime) || 0;
-    syncGuard = true;
-    try { player.currentTime(at); } finally { syncGuard = false; }
-    seekingActive = false;
-    try { player.pause(); } catch {}
-    try { audioEl.pause(); } catch {}
-    updateMSPositionState(false);
-  });
-
-  // buffering tweaks (don’t stop on loop)
-  player.on("waiting", () => {
-    const d = Number(player.duration()), t = Number(player.currentTime());
-    if (isLooping() && isFinite(d) && isFinite(t) && d - t < 0.25) return;
-    audioEl.pause();
-  });
-  player.on("playing", () => {
-    if (!player.paused() && !seekingActive) audioEl.play()?.catch(()=>{});
-  });
-
-  // end / loop
-  player.on("ended", () => {
-    if (isLooping()) {
-      safeSetCT(audioEl, 0);
-      player.currentTime(0);
-      // stay consistent with your previous behavior: keep looping playback on
-      player.play()?.catch(()=>{});
-      audioEl.play()?.catch(()=>{});
-      lastMSPos = 0; updateMSPositionState(false);
-    } else {
-      audioEl.pause();
-    }
-  });
-
-  // fullscreen exit -> pause
-  document.addEventListener("fullscreenchange", () => {
-    if (!document.fullscreenElement) {
-      pauseBoth();
-    }
-  });
-
-  // small retry to mark readiness
-  function attachReady(elm, resolveSrc, markReady) {
-    const onLoaded = () => { try { markReady(); } catch {} tryStart(); };
-    elm.addEventListener("loadeddata", onLoaded, { once: true });
-    elm.addEventListener("loadedmetadata", onLoaded, { once: true });
-    elm.addEventListener("error", () => {
-      const retryURL = resolveSrc?.();
-      if (retryURL) {
+    // 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 {
-          elm.removeAttribute("src");
-          [...elm.querySelectorAll("source")].forEach(n => n.remove());
-          elm.src = retryURL;
-          elm.load();
+            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 {}
-      }
-    }, { once: true });
-  }
-
-  function tryStart() {
-    if (audioReady && videoReady) {
-      const t = Number(player.currentTime());
-      if (isFinite(t) && Math.abs(Number(audioEl.currentTime) - t) > 0.1) safeSetCT(audioEl, t);
-      if (bothPlayableAt(t)) {
-        // start paused initially; user chooses play
-        try { player.pause(); } catch {}
-        try { audioEl.pause(); } catch {}
-      }
-      setupMediaSession();
+        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?`;
   }
 
-  if (qua !== "medium") {
-    const pickAudioSrc = () => {
-      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;
-      return null;
-    };
-    attachReady(audioEl, pickAudioSrc, () => { audioReady = true; });
-    attachReady(videoEl, () => {
-      const s = player.src();
-      return Array.isArray(s) ? (s[0] && s[0].src) : (s || initialVideoSrc);
-    }, () => { videoReady = true; });
-  }
-
-  // one user gesture to allow playback later
-  player.ready(() => {
-    player.el().addEventListener("click", () => {}, { once: true });
-  });
+  errorBox.textContent = message;
+  errorBox.style.display = 'block';
+  errorBox.style.width = 'fit-content';
 });
 
- 
+
+        // 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
+
+        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 {}
+        });
+    }
+});
 
 
  // https://codeberg.org/ashley/poke/src/branch/main/src/libpoketube/libpoketube-youtubei-objects.json