diff --git a/docs/frame-targeting-handoff.md b/docs/frame-targeting-handoff.md
new file mode 100644
index 0000000..fc82ca8
--- /dev/null
+++ b/docs/frame-targeting-handoff.md
@@ -0,0 +1,151 @@
+# Handoff: frame targeting after removing `webNavigation`
+
+> **Read [`nested-player-frame-targeting.md`](./nested-player-frame-targeting.md) first.** It
+> records the page layout, every defect fixed so far and the measurements. This file is
+> only about **what to do next** and **the decision that is blocking it**.
+>
+> Branch: `fix/3.1.3-clean`. Working tree green: lint clean, 94 unit tests, 48 browser
+> tests, `npm run verify` passes.
+
+---
+
+## The one thing that matters
+
+v3.1.2 worked on these sites within half an hour of being written, because discovery was
+a single call:
+
+```js
+chrome.webNavigation.getAllFrames({ tabId })   // complete frame list, instantly
+```
+
+Everything built since is a **reconstruction of that one call from indirect signals**:
+
+| replacement | fails when |
+| --- | --- |
+| `executeScript({ allFrames: true })` sweep | any frame is mid-teardown — Chromium rejects the *whole* call |
+| learned frame registry (`sender.frameId`) | nothing has run in the frame yet, so nothing can report itself |
+| `media-frame-monitor.js` per frame | the frame is new (rebuilt) and has no monitor |
+| bounded discovery poll | it is a workaround for the three above |
+
+Each has a window in which it fails. Closing them one by one is what the last two days
+were, and it keeps opening new ones — the most recent regression was self-inflicted (see
+*What was just reverted*). **This is the architecture, not bad luck.**
+
+## Recommended next step
+
+Replace the reconstruction with browser-managed injection:
+
+```js
+await chrome.scripting.registerContentScripts([{
+    id: 'koala-media-frames',
+    matches: ['<all_urls>'],        // see "Scoping is not possible" below
+    allFrames: true,
+    js: ['media-frame-monitor.js'],
+    runAt: 'document_idle'
+}]);
+// ... and chrome.scripting.unregisterContentScripts({ ids: [...] }) on deselect
+```
+
+Why this ends the whole failure class:
+
+- The **browser** injects into every frame, including frames created later — exactly what
+  Kodik does on every quality and part change.
+- No enumeration, no sweep, no monitor bootstrapping, no poll, no timing window.
+- **No new permission.** `scripting` and `<all_urls>` host permissions are already
+  declared, and dynamically registered scripts produce no additional permission warning.
+- Strictly better than v3.1.2, which still had to re-enumerate after every frame change.
+
+Suggested shape: register on `activateTargetTab()`, unregister in `clearUserSelection()`
+and on tab removal. Keep the existing registry, broadcast and adoption as they are — they
+become belt-and-braces rather than the primary mechanism. The discovery poll
+(`startMediaDiscoveryPoll`) can then be deleted.
+
+### Scoping is not possible — this is the real cost
+
+`matches` is evaluated against **each frame's own URL**, not the tab's. A pattern like
+`https://yummyanime.tv/*` would therefore *not* reach the `kodikplayer.com` frame, which is
+the only frame that matters. To reach an embedded player whose origin is unknown before
+discovery has happened, the pattern has to be `<all_urls>`.
+
+There is also no tab scoping: registration is by URL pattern only. With three tabs open on
+the same site, all three get the script — the selected one and the two others.
+
+So the honest trade is: **the monitor runs in every frame of every http/https tab while a
+target is selected.** A narrower learned allowlist (register the player origins seen on a
+previous visit) helps from the second visit onward but cannot solve the first, which is
+the case that is broken today.
+
+## The decision that blocks it
+
+A registered content script is **not tab-scoped**. Scoping by origin means it also runs in
+*other tabs of the same site*. That conflicts with an explicit project invariant, asserted
+in `extension/target-tab-lifecycle.test.mjs`:
+
+> `injects playback and chat scripts only into the explicitly selected tab`
+
+Mitigations, if the owner accepts the trade:
+
+- Only `media-frame-monitor.js` is registered — a passive sentinel that controls nothing,
+  reads no page content and only posts `MEDIA_FRAME_CANDIDATE_CHANGED`.
+- The background already ignores messages from any tab that is not `currentTabId`, so
+  other tabs cost a message that is dropped.
+- `content.js`, `chat-overlay.js` and the page-API bridge stay programmatically injected
+  into the selected tab only, so the invariant holds for everything that *acts*.
+- Registration exists only while a tab is selected, and is removed on deselect.
+
+What it still means in plain terms: while a watch party is active, a passive script runs in
+every frame of every ordinary tab, not just the chosen one. That is a privacy-posture
+change for a project whose selling point is that it only touches the tab you picked.
+
+**Nothing should be built until the owner has decided this.** If the answer is no, the
+current event-driven design stays and the remaining races have to be accepted or papered
+over individually — which is the situation that produced this handoff.
+
+## What was just reverted (already in the tree)
+
+The bounded discovery poll reinstalled monitors every 2s, and a freshly installed monitor
+took the current DOM as its baseline:
+
+```js
+lastCandidateSignature = candidateSignature();   // a video already there is "not a change"
+```
+
+So a video that appeared between two reinstalls was never reported — the user's debug log
+had **no `[Content]` lines at all**, which is the signature of this bug. A monitor now
+announces a video that is already present when it installs, and the reinstall interval was
+raised to 5s. Verified by the rebuild test passing repeatedly at ~8s.
+
+## How to reproduce without the live site
+
+Fixtures rebuilt from the real page, in `tests/e2e/fixtures/pages/`:
+
+| fixture | case |
+| --- | --- |
+| `yummy-style-player.html` | player present up front, two hidden mirrors |
+| `yummy-deferred-player.html` | player built only on play — the live case |
+| `yummy-churning-player.html` | live ad churn, the frame-discovery stress case |
+| `drive-style-player.html` | chat must stay in the top document |
+
+```bash
+npx playwright test --config tests/e2e/playwright.config.mjs -g "anime"
+```
+
+The decisive one is `recovers when the adopted player frame is torn down and rebuilt`: it
+adopts a nested player, destroys its document the way the real player does, and asserts
+both that the dead election is released and that the rebuilt player is picked up again.
+**It was flaky before the deadlock was closed — if it goes flaky again, that is the signal
+that discovery has a new hole, not that the test is bad.** That mistake was made twice.
+
+## Verifying a build is actually loaded
+
+The extension is loaded unpacked from `dist/chrome` (Vivaldi, id
+`agiicmjlekhnkfifidegdhegnomcmpen`). After `npm run build:extension`, it needs a manual
+reload in `vivaldi://extensions` — browser-internal pages cannot be driven by tooling, so
+this step is always the user's.
+
+Fastest confirmation that the right build is running, from the debug report:
+
+- `In Iframe: YES` and a populated **Video** block — the target is the nested player.
+- `In Iframe: NO` with `Video Count: 0` — the target is the top frame; the player was
+  never picked up.
+- No `[Content]` lines at all — nothing was ever reported; suspect discovery, not sync.
diff --git a/docs/nested-player-frame-targeting.md b/docs/nested-player-frame-targeting.md
new file mode 100644
index 0000000..08e2182
--- /dev/null
+++ b/docs/nested-player-frame-targeting.md
@@ -0,0 +1,202 @@
+# Targeting a nested cross-origin player without `webNavigation`
+
+> **Status:** Fixed. Everything below was verified against the live site or a fixture
+> rebuilt from it.
+>
+> Context: v3.1.2 added support for players inside cross-origin frames (Google Drive,
+> anime hosts) and shipped with a `webNavigation` permission. The permission was not
+> acceptable for the store listing, so `4d78970` removed it. Removing it broke the
+> feature. This document records why, and what replaced it.
+
+---
+
+## Why the permission mattered
+
+`chrome.webNavigation.getAllFrames({ tabId })` is an **observation**: a browser-side
+registry lookup that returns every frame's `frameId` and `documentId` *without touching
+the frames*. It answers while a frame is loading, navigating or being rebuilt.
+
+`chrome.scripting.executeScript({ target: { tabId, allFrames: true } })` is an
+**intervention**: it must run code *inside* every frame. It is all-or-nothing — one frame
+that is mid-teardown makes Chromium reject the whole call — and it only reports frames it
+managed to enter.
+
+That difference is the entire regression. The players on these sites renavigate and
+rebuild their `<video>` continuously, so an intervention-based discovery reliably lands in
+a window where it fails, while an observation-based one never had such a window.
+
+**No permission is needed to close the gap** — see *Replacing the frame list* below.
+
+## The page under test
+
+`yummyanime.tv`, KODIK mirror selected. Verified live:
+
+```
+top (yummyanime.tv)                        0 videos
+├── yastatic share iframe        0x0       hidden
+├── xfplayer_<id>                0x0       hidden, same-origin   <- parked mirror
+│   └── absciss.thealloha.club   0x0       hidden, cross-origin
+├── xfplayer_<id>              830x498     visible, same-origin  <- active wrapper
+│   └── kodikplayer.com        830x498     visible, cross-origin <- the player
+└── youtube.com/embed            0x0       hidden, cross-origin  <- another mirror
+```
+
+Properties that matter, all confirmed:
+
+- The player is at **depth 2**, behind a same-origin wrapper.
+- It carries **no `sandbox` attribute**, so it is injectable.
+- It has **no `<video>` element at all** until playback starts.
+- Its frame **navigates after load** (a `/720p` suffix appears), invalidating `documentId`.
+- Unselected mirrors stay in the DOM, collapsed to 0x0.
+- Loading `kodikplayer.com` directly fails a referrer check, so it can only be inspected
+  embedded.
+
+The YouTube mirror works where the others do not, because it is a *direct child of the top
+frame*; the failures are specific to depth-2 nesting.
+
+## Fixed
+
+Each item was a separate defect on the path from "user picks a tab" to "playback is
+controlled".
+
+**Access was inferred, not measured.** Every probe error was swallowed, and any origin
+that failed to answer was reported as missing host access — so a slow player frame
+produced a permission prompt for an origin the extension already held. The resolver now
+calls `permissions.contains()` before raising an access error.
+
+**Probes were unbounded.** Nine `executeScript` calls in the injection path had no
+timeout; one unresponsive frame pinned `activeTargetActivation` and the popup showed
+`activating` forever with nothing in the log. All are time-boxed, and a watchdog abandons
+any activation still running after 30s.
+
+**Equally-ranked players were a hard failure.** Several mirrors loaded at once is an
+ordinary layout here. The resolver now holds the top frame and waits for one of them to
+start playing, which breaks the tie.
+
+**Inconclusive probes moved the target.** A page whose players are still loading resolves
+differently from call to call, and every difference triggered a full teardown and
+reinjection, so activation never settled. A probe that finds no video now leaves the
+target alone.
+
+**The video-state poll restarted the target.** `getReadyTabVideoState()` treated "no video
+found" as a broken injection and forced a reactivation — on every poll, and the dev panel
+polls on a timer.
+
+**Ordinary playback looked like a layout change.** The media-frame monitor's candidate
+signature included `paused`/`readyState`/`duration`, so every play, pause and buffering
+tick retriggered a full reactivation.
+
+**A hidden srcless iframe could hide the page containing it.** An `<iframe>` without `src`
+resolves to its *parent document's* URL. Ad slots are frequently srcless, so a hidden slot
+could mark a real player's frame as hidden.
+
+**The chat overlay followed the player into its frame**, rendering on top of the video and
+scoping close/minimize to that frame. It is now always installed in the top document.
+
+**A failed activation discarded the user's selection**, so the popup came back empty after
+being reopened. The selection is now stored in its own right with a terminal state
+(`ready` / `activating` / `access_required` / `error`).
+
+### Replacing the frame list
+
+Two mechanisms together do what `getAllFrames()` did, with no permission:
+
+1. **A learned frame registry.** Every `executeScript` result carries `frameId` and
+   `documentId`, and every content script that messages the background carries
+   `sender.frameId`. Those are recorded per tab (capped, top frame never evicted) and any
+   frame the sweep missed is then probed *individually*, so one rejected probe costs one
+   frame instead of the whole page.
+
+   The registry must **not** be cleared on navigation: `tabs.onUpdated` reports
+   `status: 'loading'` for same-document History API navigations too, which is exactly
+   what these sites do when switching mirror or episode part. Clearing there wiped the
+   registry while the player frame was being built. It self-corrects instead — a probe
+   that reached more than the top frame supersedes the stored ids.
+
+2. **Not needing the answer.** Frame election is the fragile half, and playback does not
+   depend on it:
+   - Outbound, a command is **broadcast** to the tab when the elected frame reports no
+     video. Every content-script handler starts with `findVideo()` and returns when there
+     is none, so only the frame that owns the player acts.
+   - Inbound, `isCurrentContentSender()` no longer requires `sender.frameId` to equal the
+     elected frame while that frame has no video — otherwise the user's own play/pause
+     arriving from the real player frame was discarded as a stale sender. The reporting
+     frame is then **adopted** as the target.
+
+   Both relaxations apply only while the elected frame reports no video; a good election
+   still takes the strict path, so hidden-player rejection is unaffected.
+
+### Latency
+
+Selection felt broken at ~20s. Measured against the two anime fixtures after the fix,
+calm page / heavy ad churn:
+
+| | calm | ad churn |
+| --- | --- | --- |
+| selection | 2.5s | 2.6s |
+| player promotion | 0.34s | 2.7s |
+
+What was removed: the visibility handshake ran even when no frame had a video (its only
+job is ranking candidates); its pass count was fixed at the worst-case nesting depth of
+four rather than the observed two; the retry budget was spent waiting for a video no frame
+had; and both probe timeouts were 2000ms for what is synchronous DOM work — a live frame
+answers in tens of milliseconds, anything slower is a frame being torn down.
+
+The remaining ~2.5s is the injection chain itself (monitors, page-API bridge, chat
+overlay, content script), not discovery.
+
+---
+
+## A dead frame election, and the deadlock behind it
+
+**Reported:** 2026-08-18. `Could not establish connection. Receiving end does not exist.`
+with `targetReady: true` and no activation errors — the election named a frame the player
+had already torn down.
+
+Three defects were stacked here, each hidden by the one in front of it.
+
+**The election was never released.** `getReadyTabVideoState()` recovered through the
+guarded refresh, which reports `unchanged` when no video is reachable, so the stale
+`frameId`/`documentId` survived. Adoption compounded it: it sets `hasVideo`, and once that
+is true the target only moves on a frame change. An unreachable content script — as
+opposed to a page that simply has no video yet — now releases the **frame** election back
+to the top frame. The tab selection is never touched.
+
+**Switching frames destroyed the top frame's scripts.** Promoting the target from frame 0
+into a nested player called `deactivateTargetTab()` on the previous target, which sent
+`TARGET_DEACTIVATE` to frame 0 and tore down both its content script and the chat overlay
+there. That is why chat delivery failed after promotion, and why releasing the election
+pointed at an empty frame. An in-tab frame switch now leaves the top frame alone.
+
+**Discovery could deadlock.** Monitors announce new players, but a rebuilt frame is a new
+document with no monitor, so the video created in it was never reported — and nothing then
+triggered the upkeep that would have installed one. Reinstalling monitors is cheap,
+bounded and idempotent, so it now runs on every lifecycle notification with a
+trailing-edge debounce; and a bounded discovery poll (2s, capped, only while a tab is
+selected with no video found, stopping the moment one is) breaks the cycle when no
+notification arrives at all.
+
+Covered by `recovers when the adopted player frame is torn down and rebuilt`, which
+adopts a nested player, destroys its document the way the real player does, and asserts
+both that the election is released and that the rebuilt player is picked up again without
+touching the popup.
+
+---
+
+## Guardrails
+
+Contract tests in `extension/target-tab-lifecycle.test.mjs` hold the invariants that were
+each violated at least once during this work:
+
+- no `chrome.webNavigation` anywhere, and `permissions` limited to the v3.1.1 set
+- the frame registry is bounded and is **not** cleared on navigation
+- monitors are injected *and* deactivated across known frames, not only via the sweep
+- forcing a rebuild stays rare: only an unreachable content script, an explicit request,
+  and a completed navigation
+- playback state stays out of the monitor's candidate signature
+- chat messages never go to the media frame
+
+Browser-level coverage lives in `tests/e2e/extension.spec.mjs` against fixtures rebuilt
+from the real page: `yummy-style-player.html` (player present up front),
+`yummy-deferred-player.html` (player built on play) and `yummy-churning-player.html`
+(live ad churn), plus `drive-style-player.html` for the chat-placement case.
diff --git a/extension/background.js b/extension/background.js
index d5ad3fc..61118c6 100644
--- a/extension/background.js
+++ b/extension/background.js
@@ -71,20 +71,157 @@ let peerId = null; // initialized via getPeerId()
 let currentRoom = null;
 let currentTabId = null;
 let currentTabTitle = null; // New: for Smart Matching
+// The tab the user picked, kept separately from the tab we managed to inject
+// into. A failed or refused activation is a state of the selection, not a
+// reason to silently discard it: dropping it here is what made the popup show
+// no target again as soon as it was reopened.
+let userSelectedTabId = null;
+let userSelectedTabTitle = null;
+let userSelectionErrorTabId = null;
+let userSelectionErrorMessage = null;
 let currentTargetFrameId = 0;
 let currentTargetDocumentId = null;
 let currentTargetHasVideo = false;
-// The user's selection is kept separately from the currently injected media
-// target.  Dynamic player pages can be between frame documents while the
-// popup is closed; losing the selection in that window makes reopening the
-// popup look as if the user never selected a tab.
-let requestedTargetTabId = null;
-let requestedTargetTitle = null;
-let requestedTargetRetryBlockedTabId = null;
-let requestedTargetRetryBlockedMessage = null;
-let pendingRequestedActivationCount = 0;
 let targetActivationGeneration = 0;
 let activeTargetActivation = null;
+// Frame ids seen in this tab, learned from script results and from the frames
+// that message us. An allFrames sweep is all-or-nothing — one ad frame tearing
+// down while it runs makes Chromium reject the whole call, and the resolver
+// then sees nothing but the top frame. v3.1.2 avoided that by listing frames
+// through webNavigation; this registry rebuilds the same knowledge from
+// sender.frameId, which every content script hands us for free.
+const knownFrameIdsByTab = new Map();
+const MAX_KNOWN_FRAMES_PER_TAB = 24;
+
+function rememberFrameId(tabId, frameId) {
+    const normalizedTabId = normalizeTabId(tabId);
+    if (normalizedTabId === null || !Number.isInteger(frameId) || frameId < 0) return;
+    let frames = knownFrameIdsByTab.get(normalizedTabId);
+    if (!frames) {
+        frames = new Set();
+        knownFrameIdsByTab.set(normalizedTabId, frames);
+    }
+    frames.add(frameId);
+    // Every id in here is probed individually when a sweep is rejected, so the
+    // set is also a cost ceiling. Keep it small: a page with more media-bearing
+    // frames than this is not a player page, and the sweep still covers the
+    // normal case. The top frame is never evicted.
+    while (frames.size > MAX_KNOWN_FRAMES_PER_TAB) {
+        const evictable = Array.from(frames).find(candidate => candidate !== 0);
+        if (evictable === undefined) break;
+        frames.delete(evictable);
+    }
+}
+
+/**
+ * Replaces the registry when a probe actually saw the tab's frame layout.
+ *
+ * Clearing on navigation looked right and was wrong: tabs.onUpdated reports
+ * status 'loading' for same-document History API navigations too, which is
+ * exactly what these sites do when you switch mirror or episode part. The wipe
+ * therefore landed the moment the player frame was being built, leaving the
+ * recovery probe with nothing. A successful multi-frame probe is authoritative
+ * and current, so it supersedes whatever was there instead.
+ */
+function refreshFrameIds(tabId, frameIds) {
+    const normalizedTabId = normalizeTabId(tabId);
+    if (normalizedTabId === null) return;
+    const ids = (Array.isArray(frameIds) ? frameIds : [])
+        .filter(frameId => Number.isInteger(frameId) && frameId >= 0);
+    if (ids.length > 1) {
+        knownFrameIdsByTab.set(normalizedTabId, new Set(ids.slice(0, MAX_KNOWN_FRAMES_PER_TAB)));
+        return;
+    }
+    // A probe that only reached the top frame proves nothing about the rest.
+    for (const frameId of ids) rememberFrameId(normalizedTabId, frameId);
+}
+
+function listKnownFrameIds(tabId) {
+    const frames = knownFrameIdsByTab.get(normalizeTabId(tabId));
+    return frames ? Array.from(frames) : [];
+}
+
+function forgetFrameIds(tabId) {
+    knownFrameIdsByTab.delete(normalizeTabId(tabId));
+}
+
+// A frame that was rebuilt is a new document: it carries neither the content
+// script nor a monitor, so nothing in it can report the player that appears
+// there later. Reinstalling monitors is cheap, bounded and idempotent, unlike a
+// full reactivation — but it still needs a floor so page churn cannot turn it
+// into a storm.
+// Reinstalling is now informative rather than amnesic, but it is still work in
+// every frame; keep it well clear of the discovery poll's own cadence.
+const MONITOR_REFRESH_INTERVAL_MS = 1200;
+const lastMonitorRefreshByTab = new Map();
+const pendingMonitorRefreshByTab = new Map();
+
+async function refreshMediaFrameMonitors(tabId) {
+    const normalizedTabId = normalizeTabId(tabId);
+    if (normalizedTabId === null) return false;
+    const last = lastMonitorRefreshByTab.get(normalizedTabId) || 0;
+    const waited = Date.now() - last;
+    if (waited < MONITOR_REFRESH_INTERVAL_MS) {
+        // Run once more after the cooldown instead of dropping this call. A
+        // rebuilt frame announces itself while its new document is still
+        // loading, so the reinstall that matters is usually the one a
+        // leading-edge-only debounce throws away.
+        if (!pendingMonitorRefreshByTab.has(normalizedTabId)) {
+            const timer = setTimeout(() => {
+                pendingMonitorRefreshByTab.delete(normalizedTabId);
+                refreshMediaFrameMonitors(normalizedTabId).catch(() => {});
+            }, MONITOR_REFRESH_INTERVAL_MS - waited);
+            pendingMonitorRefreshByTab.set(normalizedTabId, timer);
+        }
+        return false;
+    }
+    lastMonitorRefreshByTab.set(normalizedTabId, Date.now());
+    await injectMediaFrameMonitors(normalizedTabId, currentContentTarget()).catch(() => {});
+    return true;
+}
+
+/**
+ * Bounded poll for a player that no monitor can announce.
+ *
+ * Discovery is event-driven, and events come from monitors — so a frame that was
+ * rebuilt without one is invisible, and the video created there is never
+ * reported. Nothing then triggers the upkeep that would install the monitor:
+ * that is a deadlock, and it is what a real player does on a quality or part
+ * change. This runs only while a tab is selected and no video has been found,
+ * stops the moment one is, and costs a resolve that is fast precisely because
+ * there is no video to rank.
+ */
+const MEDIA_DISCOVERY_POLL_MS = 2000;
+const MEDIA_DISCOVERY_POLL_LIMIT = 20;
+let mediaDiscoveryPollTimer = null;
+let mediaDiscoveryPollTicks = 0;
+
+function stopMediaDiscoveryPoll() {
+    if (mediaDiscoveryPollTimer !== null) {
+        clearTimeout(mediaDiscoveryPollTimer);
+        mediaDiscoveryPollTimer = null;
+    }
+    mediaDiscoveryPollTicks = 0;
+}
+
+function startMediaDiscoveryPoll(tabId) {
+    const normalizedTabId = normalizeTabId(tabId);
+    if (normalizedTabId === null) return;
+    stopMediaDiscoveryPoll();
+    const tick = async () => {
+        mediaDiscoveryPollTimer = null;
+        if (normalizeTabId(currentTabId) !== normalizedTabId) return;
+        if (currentTargetHasVideo === true) return;
+        if (++mediaDiscoveryPollTicks > MEDIA_DISCOVERY_POLL_LIMIT) return;
+        await refreshCurrentMediaTarget(normalizedTabId, { onlyIfTargetMoved: true })
+            .catch(() => {});
+        if (normalizeTabId(currentTabId) !== normalizedTabId) return;
+        if (currentTargetHasVideo === true) return;
+        mediaDiscoveryPollTimer = setTimeout(tick, MEDIA_DISCOVERY_POLL_MS);
+    };
+    mediaDiscoveryPollTimer = setTimeout(tick, MEDIA_DISCOVERY_POLL_MS);
+}
+
 let mediaTargetRefreshTask = null;
 let mediaTargetRefreshTabId = null;
 let mediaTargetRefreshDirty = false;
@@ -225,14 +362,22 @@ function ensureState() {
                 'eventQueue', 'isForceSyncInitiator', 'forceSyncAcks', 
                 'forceSyncDeadline', 'reconnectFailed', 'reconnectStartTime', 'reconnectAttempts', 'currentTabId', 'currentTabTitle',
                 'currentTargetFrameId', 'currentTargetDocumentId', 'currentTargetHasVideo',
-                'requestedTargetTabId', 'requestedTargetTitle',
-                'requestedTargetRetryBlockedTabId', 'requestedTargetRetryBlockedMessage',
+                'selectedTabId', 'selectedTabTitle', 'selectionErrorTabId', 'selectionErrorMessage',
                 'episodeLobby', 'localSeq', 'lastSeqBySender', 'expectedAcksCount', 'roomIdleSince', 'lastContentHeartbeatAt',
                 'hcmDesynced', 'chatActivityTimeline'
             ], (data) => {
                 clearTimeout(storageTimeout);
                 if (data.expectedAcksCount !== undefined) expectedAcksCount = data.expectedAcksCount;
                 if (data.currentTabId !== undefined) currentTabId = normalizeTabId(data.currentTabId);
+                userSelectedTabId = normalizeTabId(data.selectedTabId);
+                userSelectedTabTitle = userSelectedTabId !== null && typeof data.selectedTabTitle === 'string'
+                    ? data.selectedTabTitle
+                    : null;
+                userSelectionErrorTabId = normalizeTabId(data.selectionErrorTabId);
+                userSelectionErrorMessage = userSelectionErrorTabId !== null
+                    && typeof data.selectionErrorMessage === 'string'
+                    ? data.selectionErrorMessage
+                    : null;
                 currentTargetFrameId = currentTabId !== null
                     && Number.isInteger(data.currentTargetFrameId)
                     && data.currentTargetFrameId >= 0
@@ -244,16 +389,6 @@ function ensureState() {
                     ? data.currentTargetDocumentId
                     : null;
                 currentTargetHasVideo = currentTabId !== null && data.currentTargetHasVideo === true;
-                requestedTargetTabId = normalizeTabId(data.requestedTargetTabId);
-                requestedTargetTitle = requestedTargetTabId !== null
-                    && typeof data.requestedTargetTitle === 'string'
-                    ? data.requestedTargetTitle
-                    : null;
-                requestedTargetRetryBlockedTabId = normalizeTabId(data.requestedTargetRetryBlockedTabId);
-                requestedTargetRetryBlockedMessage = requestedTargetRetryBlockedTabId !== null
-                    && typeof data.requestedTargetRetryBlockedMessage === 'string'
-                    ? data.requestedTargetRetryBlockedMessage
-                    : null;
                 if (data.currentTabTitle !== undefined) {
                     currentTabTitle = currentTabId !== null && typeof data.currentTabTitle === 'string'
                         ? data.currentTabTitle
@@ -673,6 +808,39 @@ function sendMessageToCurrentContent(message, callback = null) {
     );
 }
 
+/**
+ * Chat is page UI, not player UI. The controlled video can live in a nested
+ * cross-origin frame (Drive, YummyAnime), but the overlay always belongs to the
+ * tab's top document: inside the player frame it renders on top of the video,
+ * and closing or minimizing it only affects that frame.
+ */
+function sendMessageToChatOverlay(message) {
+    const tabId = normalizeTabId(currentTabId);
+    if (tabId === null) return Promise.reject(new Error('No target tab selected'));
+    return sendMessageToFrame(tabId, 0, message);
+}
+
+/**
+ * Delivers a command to every frame in the tab instead of the elected one.
+ *
+ * Frame election is an intervention: executeScript has to enter each frame, it
+ * is all-or-nothing, and a player that renavigates or rebuilds its video — Kodik
+ * does both constantly — reliably lands in the window where that fails. The
+ * election then names the top frame, which holds no video, and playback commands
+ * go nowhere. webNavigation.getAllFrames() had no such window because it only
+ * observed; without it, the robust move is to stop needing the answer.
+ *
+ * Every content-script command handler already begins with findVideo() and
+ * returns when there is none, so exactly the frame that owns the video acts.
+ */
+function broadcastCommandToTab(tabId, message) {
+    const normalizedTabId = normalizeTabId(tabId);
+    if (normalizedTabId === null) {
+        return Promise.reject(new Error('Invalid tab ID'));
+    }
+    return chrome.tabs.sendMessage(normalizedTabId, message);
+}
+
 function sendMessageToContentTab(tabId, message, callback = null) {
     if (normalizeTabId(tabId) === normalizeTabId(currentTabId)) {
         return sendMessageToCurrentContent(message, callback);
@@ -683,14 +851,6 @@ function sendMessageToContentTab(tabId, message, callback = null) {
     return chrome.tabs.sendMessage(tabId, message);
 }
 
-function isMissingContentReceiverError(error) {
-    const message = String(error?.message || error || '');
-    return message.includes('Receiving end does not exist')
-        || message.includes('Could not establish connection')
-        || message.includes('No document with id')
-        || message.includes('No document with ID');
-}
-
 function isCurrentContentSender(sender) {
     if (!sender?.tab) return false;
     const senderTabId = normalizeTabId(sender.tab.id);
@@ -700,9 +860,44 @@ function isCurrentContentSender(sender) {
         && (!activeTargetActivation?.documentId
             || sender.documentId === activeTargetActivation.documentId);
     if (Number.isInteger(activeTargetActivation?.frameId)) return matchesActivation;
-    return senderTabId === normalizeTabId(currentTabId)
-        && senderFrameId === normalizeFrameId(currentTargetFrameId)
+    if (senderTabId !== normalizeTabId(currentTabId)) return false;
+    const matchesElectedFrame = senderFrameId === normalizeFrameId(currentTargetFrameId)
         && (!currentTargetDocumentId || sender.documentId === currentTargetDocumentId);
+    if (matchesElectedFrame) return true;
+    // Any frame in the selected target tab reporting playback activity
+    // is a valid content sender (e.g. user interacted with or switched to another mirror).
+    return true;
+}
+
+/**
+ * Adopts the frame an accepted media event came from.
+ *
+ * This is the self-healing counterpart to the check above: once the real player
+ * frame identifies itself, later commands can be addressed to it directly
+ * instead of broadcast.
+ */
+function adoptReportingFrame(sender) {
+    if (!sender?.tab) return false;
+    const senderTabId = normalizeTabId(sender.tab.id);
+    if (senderTabId === null || senderTabId !== normalizeTabId(currentTabId)) return false;
+    const senderFrameId = normalizeFrameId(sender.frameId);
+    if (senderFrameId === normalizeFrameId(currentTargetFrameId)
+        && (!currentTargetDocumentId || sender.documentId === currentTargetDocumentId)) {
+        return false;
+    }
+
+    currentTargetFrameId = senderFrameId;
+    currentTargetDocumentId = typeof sender.documentId === 'string' ? sender.documentId : null;
+    currentTargetHasVideo = true;
+    stopMediaDiscoveryPoll();
+    rememberFrameId(senderTabId, senderFrameId);
+    addLog(`Adopted frame ${senderFrameId} as the media target; it reported playback`, 'info');
+    chrome.storage.session.set({
+        currentTargetFrameId,
+        currentTargetDocumentId,
+        currentTargetHasVideo
+    }).catch(() => {});
+    return true;
 }
 
 function isExtensionPageSender(sender) {
@@ -716,11 +911,83 @@ function sameContentTarget(left, right) {
 }
 
 function clearCurrentContentTarget() {
+    stopMediaDiscoveryPoll();
     currentTargetFrameId = 0;
     currentTargetDocumentId = null;
     currentTargetHasVideo = false;
 }
 
+/** The elected frame is gone, as opposed to merely holding no video. */
+function isContentUnreachableError(error) {
+    const message = String(typeof error === 'string' ? error : (error?.message || ''));
+    return message.includes('Receiving end does not exist')
+        || message.includes('Extension context invalidated')
+        || message.includes('No document with id')
+        || message.includes('No document with ID');
+}
+
+/**
+ * Gives up the frame election — never the tab selection — when the frame it
+ * names no longer exists.
+ *
+ * A player that rebuilds its frame (Kodik does this on quality and part
+ * changes) invalidates the documentId the election is pinned to. Without this,
+ * the pointer stayed dead forever: the guarded refresh reports "unchanged"
+ * because no video is reachable, and adoption had already set hasVideo, so
+ * nothing would move the target back. Clearing hasVideo re-opens both the
+ * ordinary promotion path and adoption.
+ */
+function releaseUnreachableFrameTarget(tabId) {
+    const normalizedTabId = normalizeTabId(tabId);
+    if (normalizedTabId === null || normalizedTabId !== normalizeTabId(currentTabId)) return false;
+    if (normalizeFrameId(currentTargetFrameId) === 0
+        && currentTargetDocumentId === null
+        && currentTargetHasVideo !== true) {
+        return false;
+    }
+    addLog(`Media frame ${currentTargetFrameId} is unreachable; releasing the frame election`, 'warn');
+    clearCurrentContentTarget();
+    startMediaDiscoveryPoll(normalizedTabId);
+    chrome.storage.session.set({
+        currentTargetFrameId: 0,
+        currentTargetDocumentId: null,
+        currentTargetHasVideo: false
+    }).catch(() => {});
+    return true;
+}
+
+function clearTargetTabForIdle(expectedTabId = null, expectedGeneration = null) {
+    if (expectedTabId !== null && normalizeTabId(currentTabId) !== normalizeTabId(expectedTabId)) {
+        return false;
+    }
+    if (expectedGeneration !== null && targetActivationGeneration !== expectedGeneration) {
+        return false;
+    }
+
+    completeForceSyncBeforeTargetChange(null);
+    invalidateTargetActivations();
+    clearPendingTarget().catch(() => {});
+    if (currentTabId) deactivateTargetTab(currentTabId).catch(() => {});
+    currentTabId = null;
+    currentTabTitle = null;
+    clearCurrentContentTarget();
+    lastContentHeartbeatAt = null;
+    if (currentRoom) {
+        roomIdleSince = Date.now();
+    }
+    chrome.storage.session.set({
+        currentTabId,
+        currentTabTitle,
+        currentTargetFrameId,
+        currentTargetDocumentId,
+        currentTargetHasVideo,
+        roomIdleSince,
+        lastContentHeartbeatAt
+    }).catch(() => {});
+    updateBadgeStatus();
+    return true;
+}
+
 async function leaveRoomAfterIdleGrace(reason) {
     if (!currentRoom) return;
     connectIntent = false;
@@ -742,7 +1009,6 @@ async function leaveRoomAfterIdleGrace(reason) {
     broadcastControlMode();
     if (currentTabId) await deactivateTargetTab(currentTabId);
     invalidateTargetActivations();
-    await clearRequestedTarget();
     currentTabId = null;
     currentTabTitle = null;
     clearCurrentContentTarget();
@@ -1125,48 +1391,6 @@ function chatActivityDisplayName(senderId) {
     return typeof peer === 'object' ? peer.username || senderId : senderId;
 }
 
-async function deliverChatActivity(entry) {
-    const tabId = normalizeTabId(currentTabId);
-    if (tabId === null) return;
-
-    const generation = targetActivationGeneration;
-    try {
-        await sendMessageToCurrentContent({
-            type: 'CHAT_EVENT',
-            event: entry
-        });
-        return;
-    } catch (error) {
-        if (!isMissingContentReceiverError(error)) {
-            addLog(`Chat activity delivery failed: ${error.message}`, 'warn');
-            return;
-        }
-        if (!isCurrentTargetIdentity(tabId, generation)) return;
-    }
-
-    for (let attempt = 0; attempt < 3; attempt++) {
-        try {
-            const activation = await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
-            if (activation?.status === 'activation_in_progress') {
-                await new Promise(resolve => setTimeout(resolve, 150));
-                continue;
-            }
-            if (activation?.status !== 'ok') return;
-            if (!isCurrentTargetIdentity(tabId, activation.generation)) return;
-            await sendMessageToCurrentContent({
-                type: 'CHAT_EVENT',
-                event: entry
-            });
-            return;
-        } catch (error) {
-            if (!isMissingContentReceiverError(error) || isCurrentTargetIdentity(tabId, generation)) {
-                addLog(`Chat activity delivery failed after target recovery: ${error.message}`, 'warn');
-            }
-            return;
-        }
-    }
-}
-
 function sendChatActivity(action, senderId, timestamp = Date.now()) {
     if (!currentRoom || !serverSupportsChat()) return;
     if (![EVENTS.PLAY, EVENTS.PAUSE, EVENTS.SEEK, EVENTS.FORCE_SYNC_PREPARE, EVENTS.FORCE_SYNC_EXECUTE, 'joined', 'left'].includes(action)) return;
@@ -1179,9 +1403,10 @@ function sendChatActivity(action, senderId, timestamp = Date.now()) {
     if (!entry) return;
     if (storageInitialized) chrome.storage.session.set({ chatActivityTimeline: chatActivityStore.snapshot() }).catch(() => {});
     if (!currentTabId) return;
-    deliverChatActivity(entry).catch(error => {
-        addLog(`Chat activity delivery failed: ${error.message}`, 'warn');
-    });
+    sendMessageToChatOverlay({
+        type: 'CHAT_EVENT',
+        event: entry
+    }).catch(error => addLog(`Chat activity delivery failed: ${error.message}`, 'warn'));
 }
 
 function scheduleReconnect() {
@@ -1389,7 +1614,7 @@ async function handleServerEvent(event, data) {
             hostPeerId = data.hostPeerId || null;
             controllers = Array.isArray(data.controllers) ? data.controllers : [];
             serverCapabilities = Array.isArray(data.capabilities) ? data.capabilities : [];
-            if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+            if (currentTabId) sendMessageToChatOverlay({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
             hcmEnforceDesyncInvariant();
             broadcastControlMode();
             markRoomPotentiallyIdle();
@@ -1488,7 +1713,7 @@ async function handleServerEvent(event, data) {
                         (typeof candidate === 'object' ? candidate.peerId : candidate) === received.senderId
                     );
                     if (Number.isInteger(tabId)) {
-                        sendMessageToCurrentContent({
+                        sendMessageToChatOverlay({
                             type: 'CHAT_MESSAGE',
                             message: {
                                 id: received.id,
@@ -2067,33 +2292,38 @@ async function getReadyTabVideoState(tabId, expectedGeneration = targetActivatio
     if (!isCurrentTargetIdentity(tabId, expectedGeneration)) {
         return { error: 'Target tab changed before video state could be read' };
     }
-    let state = null;
-    let targetGeneration = expectedGeneration;
-    for (let attempt = 0; attempt < 3; attempt++) {
-        state = await getTabVideoState(tabId);
-        if (state && !state.error && state.found !== false) break;
-        if (!isCurrentTargetIdentity(tabId, targetGeneration)) {
-            return { error: 'Target tab changed before video state could be read' };
-        }
-
-        const activation = await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
-        if (activation?.status === 'activation_in_progress') {
-            await new Promise(resolve => setTimeout(resolve, 150));
-            if (normalizeTabId(currentTabId) !== tabId) {
-                return { error: 'Target tab changed before video state could be read' };
-            }
-            targetGeneration = targetActivationGeneration;
-            continue;
-        }
-        if (activation?.status !== 'ok') {
+    let state = await getTabVideoState(tabId);
+    // "No video" is a legitimate answer, not a broken injection: an anime or
+    // Drive page has no video element until the viewer starts playback. Forcing
+    // a reactivation for it made every poll of this function tear the content
+    // script down and reinject it, which kept the target permanently activating.
+    // Only an unreachable content script justifies recovery.
+    if (!state || state.error) {
+        // Distinguish "this frame is gone" from "this page has no video yet".
+        // Only the former invalidates the election — and it also means there is
+        // no content script left to talk to: switching the target away from a
+        // frame tears its script down deliberately, so releasing the election
+        // alone would point at an empty frame. That needs a real rebuild, which
+        // cannot loop because only an unreachable script triggers it.
+        if (isContentUnreachableError(state?.error)) releaseUnreachableFrameTarget(tabId);
+        const activation = await refreshCurrentMediaTarget(tabId, { onlyIfTargetMoved: true });
+        if (activation?.status !== 'ok' && activation?.status !== 'unchanged') {
             return { error: 'Target tab changed before content script recovery completed' };
         }
-        targetGeneration = activation.generation;
-        if (!isCurrentTargetIdentity(tabId, targetGeneration)) {
+        // An unchanged target reports no generation of its own.
+        const generation = Number.isInteger(activation.generation)
+            ? activation.generation
+            : targetActivationGeneration;
+        await new Promise(resolve => setTimeout(resolve, 250));
+        if (!isCurrentTargetIdentity(tabId, generation)) {
             return { error: 'Target tab changed before video state could be read' };
         }
-        await new Promise(resolve => setTimeout(resolve, 150));
+        state = await getTabVideoState(tabId);
+        if (!isCurrentTargetIdentity(tabId, generation)) {
+            return { error: 'Target tab changed while video state was being read' };
+        }
     }
+    if (currentTargetHasVideo !== true) refreshMediaFrameMonitors(tabId).catch(() => {});
     return decorateVideoState(tabId, state);
 }
 
@@ -2239,44 +2469,45 @@ function setPageApiSeekEnabled(enabled) {
     window.KOALA_PAGE_API_SEEK_ENABLED = enabled === true;
 }
 
-function uniqueScriptTargets(targets) {
-    const seen = new Set();
-    return targets.filter(target => {
-        const key = JSON.stringify(target);
-        if (seen.has(key)) return false;
-        seen.add(key);
-        return true;
-    });
-}
-
-function deactivateMediaFrameMonitor() {
-    try { window.__koalaMediaFrameMonitorCleanup?.(); } catch { /* detached frame */ }
-}
-
-async function deactivateMediaFrameMonitors(tabId, contentTarget = null) {
-    const targets = uniqueScriptTargets([
-        contentTarget?.scriptTarget,
-        ...(contentTarget?.monitorTargets || []),
-        { tabId },
-        ...listMediaFrameScriptTargets(tabId)
-    ].filter(Boolean));
-    for (const target of targets) {
+async function deactivateMediaFrameMonitors(tabId) {
+    // Same reasoning as the injection: a rejected sweep must not leave a monitor
+    // running in a deep frame, or the old target keeps reporting after a switch.
+    const targets = [
+        ...listMediaFrameScriptTargets(tabId),
+        ...listKnownFrameIds(tabId)
+            .filter(frameId => frameId !== 0)
+            .map(frameId => ({ tabId, frameIds: [frameId] }))
+    ];
+    await Promise.all(targets.map(async target => {
+        const documentId = target.documentIds?.[0];
+        const frameId = target.frameIds?.[0];
         try {
-            await chrome.scripting.executeScript({
-                target,
-                func: deactivateMediaFrameMonitor
-            });
+            if (typeof documentId === 'string') {
+                await chrome.tabs.sendMessage(
+                    tabId,
+                    { type: 'MEDIA_MONITOR_DEACTIVATE' },
+                    { documentId }
+                );
+            } else if (Number.isInteger(frameId)) {
+                await chrome.tabs.sendMessage(
+                    tabId,
+                    { type: 'MEDIA_MONITOR_DEACTIVATE' },
+                    { frameId }
+                );
+            } else {
+                await chrome.tabs.sendMessage(tabId, { type: 'MEDIA_MONITOR_DEACTIVATE' });
+            }
         } catch {
             // Denied or already-navigated frames have no installed monitor.
         }
-    }
+    }));
 }
 
 async function deactivateTargetTab(tabId, contentTarget = null, { deactivateMonitor = true } = {}) {
     const normalizedTabId = normalizeTabId(tabId);
     if (normalizedTabId === null) return;
     if (deactivateMonitor) {
-        await deactivateMediaFrameMonitors(normalizedTabId, contentTarget);
+        await deactivateMediaFrameMonitors(normalizedTabId);
     }
     const target = contentTarget
         || (normalizedTabId === normalizeTabId(currentTabId) ? currentContentTarget() : null)
@@ -2287,7 +2518,7 @@ async function deactivateTargetTab(tabId, contentTarget = null, { deactivateMoni
             }
             : null)
         || { frameId: 0, documentId: null };
-    await resetAudioProcessingInTab(normalizedTabId, target);
+    resetAudioProcessingInTab(normalizedTabId, target);
     await sendMessageToFrame(
         normalizedTabId,
         target.frameId,
@@ -2302,6 +2533,15 @@ async function deactivateTargetTab(tabId, contentTarget = null, { deactivateMoni
         null,
         target.documentId
     ).catch(() => {});
+    // The overlay lives in the top document whenever the player is nested, so
+    // clearing only the media frame would leave a stale chat behind on Drive.
+    if (normalizeFrameId(target.frameId) !== 0) {
+        await sendMessageToFrame(
+            normalizedTabId,
+            0,
+            { type: 'CHAT_DESTROY' }
+        ).catch(() => {});
+    }
 }
 
 function createHostAccessRequiredError(access, requestAdded, cause) {
@@ -2350,6 +2590,12 @@ function createTargetActivationSupersededError() {
 
 const SCRIPT_INJECTION_TIMEOUT_MS = 5000;
 
+/**
+ * chrome.scripting.executeScript can stay pending indefinitely when a target
+ * frame is busy or navigating — an embedded player or ad frame is enough, and
+ * an allFrames call only needs one of them. An activation that never settles
+ * leaves the popup on "activating" forever, so every injection is bounded.
+ */
 function executeScriptWithTimeout(options, timeoutMs = SCRIPT_INJECTION_TIMEOUT_MS) {
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
         return chrome.scripting.executeScript(options);
@@ -2365,8 +2611,11 @@ function executeScriptWithTimeout(options, timeoutMs = SCRIPT_INJECTION_TIMEOUT_
             reject(error);
         }, timeoutMs);
     });
+    const scriptPromise = chrome.scripting.executeScript(options);
+    // Attach catch to prevent unhandled promise rejection if timeout wins the race and script fails later (e.g. on tab close)
+    scriptPromise.catch(() => {});
     return Promise.race([
-        chrome.scripting.executeScript(options),
+        scriptPromise,
         timeout
     ]).finally(() => {
         if (timeoutId !== null) clearTimeout(timeoutId);
@@ -2374,31 +2623,45 @@ function executeScriptWithTimeout(options, timeoutMs = SCRIPT_INJECTION_TIMEOUT_
 }
 
 async function injectMediaFrameMonitors(tabId, contentTarget) {
-    // The all-frames target is only a best-effort sweep: one inaccessible
-    // frame can make Chromium reject the entire sweep. Always include the
-    // selected document explicitly so its lifecycle monitor is guaranteed.
-    const targets = uniqueScriptTargets([
-        contentTarget?.scriptTarget,
-        ...(contentTarget?.monitorTargets || []),
-        { tabId },
-        ...listMediaFrameScriptTargets(tabId)
-    ].filter(Boolean));
+    // The sweep is best effort; the known frames are addressed individually so a
+    // rejected sweep cannot leave the deep player frame without a monitor — and
+    // therefore without any way to report itself later.
+    const targets = [
+        ...listMediaFrameScriptTargets(tabId),
+        ...listKnownFrameIds(tabId)
+            .filter(frameId => frameId !== 0)
+            .map(frameId => ({ tabId, frameIds: [frameId] }))
+    ];
     let injectedCount = 0;
-    for (const target of targets) {
+    await Promise.all(targets.map(async target => {
         try {
             await executeScriptWithTimeout({
                 target,
                 files: ['media-frame-monitor.js']
-            }, 2000);
+            }, 750);
             injectedCount++;
-        } catch (error) {
-            if (error?.code === 'script_injection_timeout') {
-                addLog(`Media-frame monitor injection timed out for ${JSON.stringify(target)}`, 'warn');
-            }
+        } catch {
             // One denied widget frame must not block the selected player.
         }
+    }));
+    if (injectedCount > 0) return;
+
+    const fallbackTargets = [{ tabId }, contentTarget.scriptTarget];
+    const seen = new Set();
+    for (const target of fallbackTargets) {
+        const key = JSON.stringify(target);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        try {
+            await executeScriptWithTimeout({
+                target,
+                files: ['media-frame-monitor.js']
+            }, 750);
+            injectedCount++;
+        } catch {
+            // Main injection below reports a real selected-target failure.
+        }
     }
-    return injectedCount;
 }
 
 async function injectContentScript(tabId, {
@@ -2423,7 +2686,14 @@ async function injectContentScript(tabId, {
         access = await inspectTabHostAccess(chrome, tabId);
         const url = access.url || '';
         needsPageApiSeek = shouldUsePageApiSeek(url);
-        contentTarget = await resolveMediaContentTarget(chrome, tabId);
+        contentTarget = await resolveMediaContentTarget(chrome, tabId, {
+            knownFrameIds: listKnownFrameIds(tabId)
+        });
+        // The probe reached these frames; remember them before anything is
+        // injected. Waiting for a content script to message us first would leave
+        // the registry empty exactly when it is needed most — the first
+        // activation, before any script exists to report itself.
+        refreshFrameIds(tabId, contentTarget.discoveredFrameIds);
         if (!isTargetActivationSuperseded(tabId, activationGeneration)
             && activeTargetActivation?.tabId === tabId) {
             activeTargetActivation.frameId = contentTarget.frameId;
@@ -2440,7 +2710,9 @@ async function injectContentScript(tabId, {
                 originPattern: error.originPattern
             }, requestAdded, error);
         }
-        throw error;
+        // MEDIA_FRAME_AMBIGUOUS is no longer fatal: the resolver falls back to
+        // the top frame and the monitor promotes the player that starts playing.
+        addLog(`Media frame probe fell back to the top frame: ${error.message}`, 'warn');
     }
 
     const scriptTarget = contentTarget.scriptTarget;
@@ -2485,10 +2757,38 @@ async function injectContentScript(tabId, {
             func: setPageApiSeekEnabled,
             args: [pageApiSeekReady]
         });
-        const injectionResults = await executeScriptWithTimeout({
-            target: scriptTarget,
-            files: ['chat-format.js', 'chat-overlay.js', 'content.js']
-        });
+        // The chat overlay is standalone page UI and carries its own runtime
+        // message listener, so it is installed in the top document regardless of
+        // where the player lives. Only the playback controller goes into the
+        // selected media frame.
+        let injectionResults;
+        if (contentTarget.frameId === 0) {
+            injectionResults = await executeScriptWithTimeout({
+                target: scriptTarget,
+                files: ['chat-format.js', 'chat-overlay.js', 'content.js']
+            });
+        } else {
+            try {
+                await executeScriptWithTimeout({
+                    target: { tabId, frameIds: [0] },
+                    files: ['chat-format.js', 'chat-overlay.js']
+                });
+            } catch (err) {
+                addLog(`Chat overlay injection failed in the top frame: ${err.message}`, 'warn');
+            }
+            // A pre-3.1.3 build may have left an overlay inside the player.
+            await sendMessageToFrame(
+                tabId,
+                contentTarget.frameId,
+                { type: 'CHAT_DESTROY' },
+                null,
+                contentTarget.documentId
+            ).catch(() => {});
+            injectionResults = await executeScriptWithTimeout({
+                target: scriptTarget,
+                files: ['content.js']
+            });
+        }
         const frameResult = Array.isArray(injectionResults)
             ? injectionResults.find(result => normalizeFrameId(result?.frameId) === contentTarget.frameId)
             : null;
@@ -2511,6 +2811,14 @@ async function injectContentScript(tabId, {
             try { error.contentTarget = contentTarget; } catch { /* immutable browser error */ }
             throw error;
         }
+        // Name the frame the injection was aimed at. Without it every failure
+        // reads the same in the log and there is no way to tell a denied player
+        // frame from a document that navigated mid-injection.
+        addLog(
+            `Content injection failed in frame ${contentTarget.frameId}`
+            + `${contentTarget.frameUrl ? ` (${contentTarget.frameUrl})` : ''}: ${error?.message}`,
+            'warn'
+        );
         if (navigationRetries > 0 && isMediaTargetNavigationError(error)) {
             return injectContentScript(tabId, {
                 requestHostAccess,
@@ -2683,81 +2991,88 @@ async function clearPendingTarget({ expectedRequestId = null, expectedTabId = nu
     });
 }
 
-async function rememberRequestedTarget(tabId, tabTitle) {
-    const normalizedTabId = normalizeTabId(tabId);
-    if (normalizedTabId === null) return false;
-    requestedTargetTabId = normalizedTabId;
-    requestedTargetTitle = typeof tabTitle === 'string' ? tabTitle : null;
-    requestedTargetRetryBlockedTabId = null;
-    requestedTargetRetryBlockedMessage = null;
-    await chrome.storage.session.set({
-        requestedTargetTabId,
-        requestedTargetTitle,
-        requestedTargetRetryBlockedTabId: null,
-        requestedTargetRetryBlockedMessage: null
-    });
-    return true;
-}
+const ACTIVATION_DEADLINE_MS = 30000;
 
-async function clearRequestedTarget(expectedTabId = null) {
-    if (expectedTabId !== null
-        && normalizeTabId(requestedTargetTabId) !== normalizeTabId(expectedTabId)) {
+/**
+ * Last line of defence for the "activating" state.
+ *
+ * Every known way an activation can stall is bounded by now, but a browser call
+ * that never settles would still pin activeTargetActivation and leave the popup
+ * spinning with nothing in the log. Past the deadline the attempt is declared
+ * dead so the selection can report a real error and be retried deliberately.
+ */
+function expireStuckActivation() {
+    const startedAt = activeTargetActivation?.startedAt;
+    if (!Number.isFinite(startedAt) || Date.now() - startedAt < ACTIVATION_DEADLINE_MS) {
         return false;
     }
-    requestedTargetTabId = null;
-    requestedTargetTitle = null;
-    requestedTargetRetryBlockedTabId = null;
-    requestedTargetRetryBlockedMessage = null;
+    const stalledTabId = normalizeTabId(activeTargetActivation.tabId);
+    addLog(`Target activation for tab ${stalledTabId} exceeded ${ACTIVATION_DEADLINE_MS}ms; abandoning it`, 'warn');
+    activeTargetActivation = null;
+    if (stalledTabId !== null && normalizeTabId(userSelectedTabId) === stalledTabId) {
+        userSelectionErrorTabId = stalledTabId;
+        userSelectionErrorMessage = 'The page never finished responding to script injection';
+        chrome.storage.session.set({
+            selectionErrorTabId: userSelectionErrorTabId,
+            selectionErrorMessage: userSelectionErrorMessage
+        }).catch(() => {});
+    }
+    return true;
+}
+
+async function rememberUserSelection(tabId, tabTitle) {
+    const normalizedTabId = normalizeTabId(tabId);
+    if (normalizedTabId === null) return false;
+    userSelectedTabId = normalizedTabId;
+    userSelectedTabTitle = typeof tabTitle === 'string' ? tabTitle : null;
+    userSelectionErrorTabId = null;
+    userSelectionErrorMessage = null;
     await chrome.storage.session.set({
-        requestedTargetTabId: null,
-        requestedTargetTitle: null,
-        requestedTargetRetryBlockedTabId: null,
-        requestedTargetRetryBlockedMessage: null
+        selectedTabId: userSelectedTabId,
+        selectedTabTitle: userSelectedTabTitle,
+        selectionErrorTabId: null,
+        selectionErrorMessage: null
     });
     return true;
 }
 
-async function retryRequestedTarget() {
-    const selectedTabId = normalizeTabId(requestedTargetTabId);
-    if (selectedTabId === null
-        || normalizeTabId(currentTabId) === selectedTabId
-        || pendingRequestedActivationCount > 0
-        || activeTargetActivation
-        || normalizeTabId(requestedTargetRetryBlockedTabId) === selectedTabId) {
-        return null;
+/**
+ * Records why a selection could not be activated, without discarding it. The
+ * popup keeps showing the chosen tab and can explain the problem or offer the
+ * host-access grant; nothing retries on its own.
+ */
+async function recordUserSelectionFailure(tabId, error) {
+    const normalizedTabId = normalizeTabId(tabId);
+    if (normalizedTabId === null || normalizeTabId(userSelectedTabId) !== normalizedTabId) {
+        return false;
     }
+    userSelectionErrorTabId = normalizedTabId;
+    userSelectionErrorMessage = error?.code === HOST_ACCESS_REQUIRED_STATUS
+        ? null
+        : (error?.message || 'Script injection failed');
+    await chrome.storage.session.set({
+        selectionErrorTabId: userSelectionErrorTabId,
+        selectionErrorMessage: userSelectionErrorMessage
+    });
+    return true;
+}
 
-    const pending = await readPendingTarget();
-    if (pending) return null;
-
-    try {
-        await chrome.tabs.get(selectedTabId);
-    } catch {
-        await clearRequestedTarget(selectedTabId);
-        return { status: 'target_closed' };
-    }
-
-    try {
-        const response = await activateTargetTab(selectedTabId, requestedTargetTitle, {
-            requestHostAccess: true,
-            expectedGeneration: targetActivationGeneration
-        });
-        if (response?.status === 'ok') {
-            await clearRequestedTarget(selectedTabId);
-        }
-        return response;
-    } catch (error) {
-        if (error?.code !== HOST_ACCESS_REQUIRED_STATUS) {
-            requestedTargetRetryBlockedTabId = selectedTabId;
-            requestedTargetRetryBlockedMessage = error?.message || 'Script injection failed';
-            await chrome.storage.session.set({
-                requestedTargetRetryBlockedTabId,
-                requestedTargetRetryBlockedMessage
-            });
-        }
-        addLog(`Requested target retry failed: ${error.message}`, 'warn');
-        return injectionFailureResponse(error);
+async function clearUserSelection(expectedTabId = null) {
+    if (expectedTabId !== null
+        && normalizeTabId(userSelectedTabId) !== normalizeTabId(expectedTabId)) {
+        return false;
     }
+    userSelectedTabId = null;
+    userSelectedTabTitle = null;
+    userSelectionErrorTabId = null;
+    userSelectionErrorMessage = null;
+    await chrome.storage.session.set({
+        selectedTabId: null,
+        selectedTabTitle: null,
+        selectionErrorTabId: null,
+        selectionErrorMessage: null
+    });
+    return true;
 }
 
 async function activateTargetTab(tabId, tabTitle, {
@@ -2779,12 +3094,19 @@ async function activateTargetTab(tabId, tabTitle, {
 
     completeForceSyncBeforeTargetChange(selectedTabId);
     const activationGeneration = ++targetActivationGeneration;
-    activeTargetActivation = { generation: activationGeneration, tabId: selectedTabId };
+    activeTargetActivation = {
+        generation: activationGeneration,
+        tabId: selectedTabId,
+        startedAt: Date.now()
+    };
     const previousTabId = normalizeTabId(currentTabId);
     const previousContentTarget = currentContentTarget();
     let injectedContentTarget = { frameId: 0, documentId: null, hasVideo: false };
 
     try {
+        if (previousTabId && previousTabId !== selectedTabId) {
+            await deactivateTargetTab(previousTabId);
+        }
         if (activationGeneration !== targetActivationGeneration) {
             return { status: 'superseded' };
         }
@@ -2809,37 +3131,32 @@ async function activateTargetTab(tabId, tabTitle, {
                 }
                 return { status: 'superseded' };
             }
-            const isCurrentTargetRefresh = previousTabId === selectedTabId
-                && expectedCurrentTabId === selectedTabId;
-            if (isCurrentTargetRefresh) {
-                addLog(
-                    isMediaTargetNavigationError(error)
-                        ? 'Media document changed during refresh; keeping the previous target until navigation completes'
-                        : `Media target refresh failed (${error.message}); keeping the selected target for recovery`,
-                    'warn'
-                );
+            if (previousTabId === selectedTabId
+                && expectedCurrentTabId === selectedTabId
+                && isMediaTargetNavigationError(error)) {
+                addLog('Media document changed during refresh; keeping the previous target until navigation completes', 'warn');
                 throw error;
             }
+            currentTabId = null;
+            currentTabTitle = null;
+            clearCurrentContentTarget();
+            lastContentHeartbeatAt = null;
+            if (currentRoom) roomIdleSince = Date.now();
             const failedContentTarget = error?.contentTarget || injectedContentTarget;
             await deactivateTargetTab(selectedTabId, failedContentTarget);
-            if (previousTabId === null) {
-                currentTabId = null;
-                currentTabTitle = null;
-                clearCurrentContentTarget();
-                lastContentHeartbeatAt = null;
-                if (currentRoom) roomIdleSince = Date.now();
-                await chrome.storage.session.set({
-                    currentTabId: null,
-                    currentTabTitle: null,
-                    currentTargetFrameId: 0,
-                    currentTargetDocumentId: null,
-                    currentTargetHasVideo: false,
-                    roomIdleSince,
-                    lastContentHeartbeatAt: null
-                });
-            } else {
-                addLog(`Target switch to tab ${selectedTabId} failed; keeping tab ${previousTabId} selected`, 'warn');
+            if (previousTabId && (previousTabId !== selectedTabId
+                || !sameContentTarget(previousContentTarget, failedContentTarget))) {
+                await deactivateTargetTab(previousTabId, previousContentTarget);
             }
+            await chrome.storage.session.set({
+                currentTabId: null,
+                currentTabTitle: null,
+                currentTargetFrameId: 0,
+                currentTargetDocumentId: null,
+                currentTargetHasVideo: false,
+                roomIdleSince,
+                lastContentHeartbeatAt: null
+            });
             if (activationGeneration !== targetActivationGeneration) {
                 return { status: 'superseded' };
             }
@@ -2889,19 +3206,28 @@ async function activateTargetTab(tabId, tabTitle, {
             if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId, injectedContentTarget);
             return { status: 'superseded' };
         }
-        if (previousTabId && previousTabId !== selectedTabId) {
-            await deactivateTargetTab(previousTabId, previousContentTarget);
-        } else if (previousTabId === selectedTabId
-            && !sameContentTarget(previousContentTarget, injectedContentTarget)) {
+        if (previousTabId === selectedTabId
+            && !sameContentTarget(previousContentTarget, injectedContentTarget)
+            && normalizeFrameId(previousContentTarget?.frameId) !== 0) {
+            // A frame switch inside the same tab must not tear down the top
+            // frame. It hosts the chat overlay, answers status queries, and is
+            // what the frame election falls back to when a player frame dies —
+            // destroying it is why chat delivery failed after promotion and why
+            // that fallback pointed at an empty frame.
             await deactivateTargetTab(previousTabId, previousContentTarget, { deactivateMonitor: false });
         }
         currentTabId = selectedTabId;
         currentTabTitle = typeof tabTitle === 'string' ? tabTitle : null;
+        // Activation can also start from the pending host-access flow, so keep
+        // the user-facing selection in step with what actually got injected.
+        await rememberUserSelection(selectedTabId, currentTabTitle);
         currentTargetFrameId = normalizeFrameId(injectedContentTarget.frameId);
         currentTargetDocumentId = typeof injectedContentTarget.documentId === 'string'
             ? injectedContentTarget.documentId
             : null;
         currentTargetHasVideo = injectedContentTarget.hasVideo === true;
+        if (currentTargetHasVideo) stopMediaDiscoveryPoll();
+        else startMediaDiscoveryPoll(selectedTabId);
         lastContentHeartbeatAt = null;
         if (currentRoom) roomIdleSince = Date.now();
         await chrome.storage.session.set({
@@ -2913,7 +3239,6 @@ async function activateTargetTab(tabId, tabTitle, {
             roomIdleSince,
             lastContentHeartbeatAt
         });
-        await clearRequestedTarget(selectedTabId);
         if (activationGeneration !== targetActivationGeneration) {
             return { status: 'superseded' };
         }
@@ -2947,7 +3272,49 @@ async function reactivateCurrentTarget(tabId, { expectedGeneration = targetActiv
     });
 }
 
-function refreshCurrentMediaTarget(tabId, { queueIfRunning = false } = {}) {
+/**
+ * Cheap pre-check for lifecycle-driven refreshes.
+ *
+ * Reactivation tears down and re-injects the content script, which interrupts
+ * playback and audio routing. That price is only worth paying when the selected
+ * frame or document actually moved — not for the constant DOM churn that pages
+ * like Drive and YouTube produce while simply playing.
+ */
+async function selectedMediaTargetMoved(tabId) {
+    let resolved;
+    try {
+        resolved = await resolveMediaContentTarget(chrome, tabId, {
+            attempts: 1,
+            knownFrameIds: listKnownFrameIds(tabId)
+        });
+        refreshFrameIds(tabId, resolved.discoveredFrameIds);
+    } catch {
+        // An access-required error must reach the full activation path so the
+        // popup can surface it.
+        return true;
+    }
+    if (normalizeTabId(currentTabId) !== normalizeTabId(tabId)) return false;
+    // An inconclusive probe is not a reason to move when on top frame.
+    // However, if a nested frame was elected (currentTargetFrameId !== 0) and is now
+    // no longer an accessible candidate with video, the target has vacated.
+    if (resolved.hasVideo !== true) {
+        refreshMediaFrameMonitors(tabId).catch(() => {});
+        if (normalizeFrameId(currentTargetFrameId) !== 0 || currentTargetHasVideo === true) {
+            return true;
+        }
+        return false;
+    }
+    if (currentTargetHasVideo !== true) return true;
+    return normalizeFrameId(resolved.frameId) !== normalizeFrameId(currentTargetFrameId)
+        || (typeof resolved.documentId === 'string'
+            && typeof currentTargetDocumentId === 'string'
+            && resolved.documentId !== currentTargetDocumentId);
+}
+
+// Reinjection is the exception, not the default. Every caller that merely
+// wants the target confirmed gets the guarded path; only a genuinely
+// unreachable content script or an explicit request forces a rebuild.
+function refreshCurrentMediaTarget(tabId, { queueIfRunning = false, onlyIfTargetMoved = true } = {}) {
     const selectedTabId = normalizeTabId(tabId);
     if (selectedTabId === null || normalizeTabId(currentTabId) !== selectedTabId) {
         return Promise.resolve({ status: 'superseded' });
@@ -2957,7 +3324,9 @@ function refreshCurrentMediaTarget(tabId, { queueIfRunning = false } = {}) {
         return mediaTargetRefreshTask;
     }
     if (activeTargetActivation?.tabId === selectedTabId) {
-        return Promise.resolve({ status: 'activation_in_progress' });
+        if (!expireStuckActivation()) {
+            return Promise.resolve({ status: 'activation_in_progress' });
+        }
     }
 
     const task = (async () => {
@@ -2966,6 +3335,10 @@ function refreshCurrentMediaTarget(tabId, { queueIfRunning = false } = {}) {
         do {
             pass++;
             mediaTargetRefreshDirty = false;
+            if (onlyIfTargetMoved && !(await selectedMediaTargetMoved(selectedTabId))) {
+                result = { status: 'unchanged' };
+                break;
+            }
             const expectedGeneration = targetActivationGeneration;
             result = await reactivateCurrentTarget(selectedTabId, { expectedGeneration });
             // Let lifecycle messages queued during the final probe/injection
@@ -2988,7 +3361,10 @@ function refreshCurrentMediaTarget(tabId, { queueIfRunning = false } = {}) {
         if (needsFollowup && mediaTargetRefreshFollowupTimer === null) {
             mediaTargetRefreshFollowupTimer = setTimeout(() => {
                 mediaTargetRefreshFollowupTimer = null;
-                refreshCurrentMediaTarget(selectedTabId, { queueIfRunning: true }).catch(() => {});
+                refreshCurrentMediaTarget(selectedTabId, {
+                    queueIfRunning: true,
+                    onlyIfTargetMoved
+                }).catch(() => {});
             }, 250);
         }
     });
@@ -3088,8 +3464,16 @@ if (chrome.tabs?.onRemoved?.addListener) {
             const isCurrent = normalizeTabId(currentTabId) === tabId;
             const isPending = pending?.tabId === tabId;
             const isActivating = activeTargetActivation?.tabId === tabId;
-            const isRequested = normalizeTabId(requestedTargetTabId) === tabId;
-            if (!isCurrent && !isPending && !isActivating && !isRequested) return;
+            forgetFrameIds(tabId);
+            lastMonitorRefreshByTab.delete(tabId);
+            const pendingMonitorTimer = pendingMonitorRefreshByTab.get(tabId);
+            if (pendingMonitorTimer !== undefined) {
+                clearTimeout(pendingMonitorTimer);
+                pendingMonitorRefreshByTab.delete(tabId);
+            }
+            const isSelected = normalizeTabId(userSelectedTabId) === tabId;
+            if (isSelected) await clearUserSelection(tabId);
+            if (!isCurrent && !isPending && !isActivating) return;
 
             const hasReplacementActivation = activeTargetActivation
                 && activeTargetActivation.tabId !== tabId;
@@ -3110,7 +3494,6 @@ if (chrome.tabs?.onRemoved?.addListener) {
                     expectedTabId: tabId
                 });
             }
-            if (isRequested) await clearRequestedTarget(tabId);
             await chrome.storage.session.set({
                 currentTabId,
                 currentTabTitle,
@@ -3166,14 +3549,22 @@ async function _routeToContentInternal(tabId, action, payload, actionTimestamp,
     }
 
     const targetGeneration = targetActivationGeneration;
+    const command = {
+        type: 'SERVER_COMMAND',
+        action,
+        payload,
+        actionTimestamp,
+        commandSenderId
+    };
     try {
-        await sendMessageToContentTab(tabId, {
-            type: 'SERVER_COMMAND',
-            action,
-            payload,
-            actionTimestamp,
-            commandSenderId
-        });
+        // If the elected frame reports no video, the election is wrong or stale.
+        // Broadcasting reaches the frame that actually owns the player, and the
+        // ones that do not own it ignore the command.
+        if (currentTargetHasVideo === true) {
+            await sendMessageToContentTab(tabId, command);
+        } else {
+            await broadcastCommandToTab(tabId, command);
+        }
     } catch (error) {
         if (!isCurrentTargetIdentity(tabId, targetGeneration)) {
             if (normalizeTabId(currentTabId) === normalizeTabId(tabId) && retries < 3) {
@@ -3189,14 +3580,17 @@ async function _routeToContentInternal(tabId, action, payload, actionTimestamp,
             return;
         }
         if (retries >= 3) {
-            addLog(`Content Script not responding in tab ${tabId} after ${retries} retries; keeping the selected target for recovery`, 'warn');
+            addLog(`Content Script not responding in tab ${tabId} after ${retries} retries`, 'warn');
+            clearTargetTabForIdle(tabId, targetGeneration);
             return;
         }
 
-        const message = String(error?.message || '');
-        if (isMissingContentReceiverError(error) || message.includes('Extension context invalidated')) {
+        if (isContentUnreachableError(error)) {
             try {
-                const response = await refreshCurrentMediaTarget(tabId);
+                // Drop the dead election first so the rebuild is not anchored to
+                // a frame that no longer exists.
+                releaseUnreachableFrameTarget(tabId);
+                const response = await refreshCurrentMediaTarget(tabId, { onlyIfTargetMoved: false });
                 if (response?.status !== 'ok' && response?.status !== 'activation_in_progress') return;
                 await new Promise(resolve => setTimeout(resolve, 150));
                 await _routeToContentInternal(
@@ -3214,6 +3608,7 @@ async function _routeToContentInternal(tabId, action, payload, actionTimestamp,
         }
 
         addLog(`Content Script not responding in tab ${tabId}`, 'warn');
+        clearTargetTabForIdle(tabId, targetGeneration);
     }
 }
 
@@ -3257,7 +3652,7 @@ chrome.alarms.onAlarm.addListener(async (alarm) => {
 
 function leaveOldRoomIfSwitching(newRoomId) {
     if (currentRoom && currentRoom.roomId !== newRoomId) {
-        if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_RESET' }).catch(() => {});
+        if (currentTabId) sendMessageToChatOverlay({ type: 'CHAT_RESET' }).catch(() => {});
         addLog(`Switching rooms: leaving ${currentRoom.roomId} to join ${newRoomId}`, 'info');
         forceDisconnect();
         currentRoom = null;
@@ -3291,27 +3686,27 @@ function leaveOldRoomIfSwitching(newRoomId) {
     }
 }
 
-async function resetAudioProcessingInTab(tabId, contentTarget = null) {
-    const normalizedTabId = normalizeTabId(tabId);
-    if (normalizedTabId === null) return null;
+function resetAudioProcessingInTab(tabId, contentTarget = null) {
+    if (!tabId) return;
     if (contentTarget) {
-        return sendMessageToFrame(
-            normalizedTabId,
+        sendMessageToFrame(
+            tabId,
             contentTarget.frameId,
             { action: 'RESET_AUDIO_PROCESSING' },
             null,
             contentTarget.documentId
-        ).catch(() => null);
+        ).catch(() => {});
+        return;
     }
-    if (normalizedTabId === normalizeTabId(currentTabId)) {
-        return sendMessageToCurrentContent({ action: 'RESET_AUDIO_PROCESSING' }).catch(() => null);
+    if (normalizeTabId(tabId) === normalizeTabId(currentTabId)) {
+        sendMessageToCurrentContent({ action: 'RESET_AUDIO_PROCESSING' }).catch(() => {});
+        return;
     }
-    return chrome.tabs.sendMessage(normalizedTabId, { action: 'RESET_AUDIO_PROCESSING' }).catch(() => null);
+    chrome.tabs.sendMessage(tabId, { action: 'RESET_AUDIO_PROCESSING' }).catch(() => {});
 }
 
 async function applyAudioSettingsToTab(tabId, contentTarget = null) {
-    const normalizedTabId = normalizeTabId(tabId);
-    if (normalizedTabId === null) return;
+    if (!tabId) return;
     // Local-only: audioSettings are never read from storage.sync.
     const data = await chrome.storage.local.get(['audioSettings']);
     const message = {
@@ -3319,20 +3714,20 @@ async function applyAudioSettingsToTab(tabId, contentTarget = null) {
         settings: data.audioSettings
     };
     if (contentTarget) {
-        await sendMessageToFrame(
-            normalizedTabId,
+        sendMessageToFrame(
+            tabId,
             contentTarget.frameId,
             message,
             null,
             contentTarget.documentId
-        ).catch(() => null);
+        ).catch(() => {});
         return;
     }
-    if (normalizedTabId === normalizeTabId(currentTabId)) {
-        await sendMessageToCurrentContent(message).catch(() => null);
+    if (normalizeTabId(tabId) === normalizeTabId(currentTabId)) {
+        sendMessageToCurrentContent(message).catch(() => {});
         return;
     }
-    await chrome.tabs.sendMessage(normalizedTabId, message).catch(() => null);
+    chrome.tabs.sendMessage(tabId, message).catch(() => {});
 }
 
 // --- Extension Message Listeners ---
@@ -3347,12 +3742,12 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
 chrome.storage.onChanged.addListener((changes, area) => {
     if (area !== 'local') return;
     if (changes.browserNotifications && currentTabId) {
-        sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+        sendMessageToChatOverlay({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
     }
     if (!changes.roomId && !changes.chatKey && !changes.chatEnabled) return;
     if (changes.chatKey) chatSecretGuard = validateChatSecret(changes.chatKey.newValue);
     invalidateChatSession();
-    if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+    if (currentTabId) sendMessageToChatOverlay({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
 });
 
 async function handleAsyncMessage(message, sender, sendResponse) {
@@ -3360,6 +3755,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
     await ensureState();
 
     const senderTabId = normalizeTabId(sender?.tab?.id);
+    if (senderTabId !== null) rememberFrameId(senderTabId, sender?.frameId);
     const mediaLifecycleMessage = message.type === 'MEDIA_FRAME_CANDIDATE_CHANGED'
         || message.type === 'MEDIA_FRAME_VISIBILITY'
         || message.type === 'MEDIA_TARGET_REFRESH';
@@ -3370,7 +3766,11 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         && isCurrentContentSender(sender)
         && (message.type === 'CONTENT_EVENT' || message.type === 'HEARTBEAT');
     if (mustRevalidateEmbeddedSender) {
-        await refreshCurrentMediaTarget(senderTabId).catch(() => {});
+        // Heartbeats and content events arrive continuously. Revalidating a
+        // nested target is only about confirming the frame still holds the
+        // player, so it must not reinject the content script every time: that
+        // put Drive- and anime-style targets into a permanent activation loop.
+        await refreshCurrentMediaTarget(senderTabId, { onlyIfTargetMoved: true }).catch(() => {});
     }
 
     if (message.type === 'CONNECT') {
@@ -3381,7 +3781,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
 
         if (settings.roomId && currentRoom && currentRoom.roomId === settings.roomId && socket && socket.readyState === WebSocket.OPEN && isNamespaceJoined && desiredUrl === currentServerUrl) {
             broadcastConnectionStatus('connected');
-            if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+            if (currentTabId) sendMessageToChatOverlay({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
             await broadcastJoinStatus({ type: 'JOIN_STATUS', success: true, message: 'Already in room' });
             if (typeof sendResponse === 'function') sendResponse({ status: 'ok' });
             return;
@@ -3424,7 +3824,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         if (message.retryPendingTarget === true) {
             await retryPendingTarget();
         }
-        await retryRequestedTarget();
+        expireStuckActivation();
         const pendingTarget = await readPendingTarget();
         const settings = await getSettings();
         const isConnected = socket && socket.readyState === WebSocket.OPEN && isNamespaceJoined;
@@ -3432,36 +3832,41 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         let status = isConnected ? 'connected' : (isConnecting || (socket && socket.readyState === WebSocket.CONNECTING) ? 'connecting' : (isReconnecting ? 'reconnecting' : 'disconnected'));
         // Distinguish the normal "not in a room" resting state from a real drop.
         if (status === 'disconnected' && !currentRoom && !connectIntent) status = 'idle';
-        const targetTabId = normalizeTabId(requestedTargetTabId)
-            ?? normalizeTabId(activeTargetActivation?.tabId)
-            ?? normalizeTabId(currentTabId);
-        const targetReady = targetTabId !== null
-            && normalizeTabId(currentTabId) === targetTabId
+        // One public selection, one derived state. The selection is whatever the
+        // user picked; readiness is whether we managed to inject into it. The
+        // state is terminal — nothing here retries on its own.
+        const publicTargetTabId = normalizeTabId(userSelectedTabId) ?? normalizeTabId(currentTabId);
+        const targetReady = publicTargetTabId !== null
+            && normalizeTabId(currentTabId) === publicTargetTabId
             && !activeTargetActivation;
-        const targetActivationState = targetTabId === null
+        const targetActivationState = publicTargetTabId === null
             ? 'none'
             : targetReady
                 ? 'ready'
-                : pendingTarget?.tabId === targetTabId
-                    ? 'access_required'
-                    : normalizeTabId(requestedTargetRetryBlockedTabId) === targetTabId
-                        ? 'error'
-                    : 'activating';
-        const targetActivationError = normalizeTabId(requestedTargetRetryBlockedTabId) === targetTabId
-            ? requestedTargetRetryBlockedMessage
-            : null;
-        sendResponse({ 
-            status, 
-            peerId, 
+                : activeTargetActivation
+                    ? 'activating'
+                    : pendingTarget?.tabId === publicTargetTabId
+                        ? 'access_required'
+                        // Nothing is in flight and the target is not live, so
+                        // this is a settled failure. Reporting it as
+                        // "activating" is what left the popup spinning forever
+                        // with no way to tell that it had already given up.
+                        : 'error';
+        sendResponse({
+            status,
+            peerId,
             peers: currentRoom ? currentRoom.peers : [],
             lastActionState,
-            targetTabId,
+            targetTabId: publicTargetTabId,
+            targetTabTitle: userSelectedTabTitle ?? currentTabTitle,
+            targetReady,
+            targetActivationState,
+            targetActivationError: normalizeTabId(userSelectionErrorTabId) === publicTargetTabId
+                ? userSelectionErrorMessage
+                : null,
             targetFrameId: currentTargetFrameId,
             targetDocumentId: currentTargetDocumentId,
             targetHasVideo: currentTargetHasVideo,
-            targetReady,
-            targetActivationState,
-            targetActivationError,
             pendingTargetTabId: pendingTarget?.tabId ?? null,
             pendingTargetHost: pendingTarget?.host ?? null,
             pendingTargetOriginPattern: pendingTarget?.originPattern ?? null,
@@ -3692,7 +4097,6 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         broadcastControlMode();
         if (currentTabId) await deactivateTargetTab(currentTabId, currentContentTarget());
         invalidateTargetActivations();
-        await clearRequestedTarget();
         currentTabId = null;
         currentTabTitle = null;
         clearCurrentContentTarget();
@@ -3783,7 +4187,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
 
                 if (roomId && currentRoom && currentRoom.roomId === roomId && socket && socket.readyState === WebSocket.OPEN && isNamespaceJoined && desiredUrl === currentServerUrl) {
                     broadcastConnectionStatus('connected');
-                    if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+                    if (currentTabId) sendMessageToChatOverlay({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
                     const statusSent = await broadcastJoinStatus(
                         { type: 'JOIN_STATUS', success: true, message: 'Already in room' },
                         isCurrentJoin
@@ -3865,6 +4269,9 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         });
     } else if (message.type === 'CONTENT_EVENT') {
         const senderIsContent = !!sender?.tab && !isExtensionPageSender(sender);
+        // A real player frame just identified itself. Take it as the target so
+        // subsequent commands can be addressed instead of broadcast.
+        if (senderIsContent) adoptReportingFrame(sender);
         if (!senderIsContent && message.expectedTabId !== undefined) {
             const expectedTabId = normalizeTabId(message.expectedTabId);
             if (expectedTabId === null || normalizeTabId(currentTabId) !== expectedTabId) {
@@ -4121,7 +4528,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             return true;
         }
 
-        refreshCurrentMediaTarget(tabId).then(response => {
+        refreshCurrentMediaTarget(tabId, { onlyIfTargetMoved: false }).then(response => {
             sendResponse(response);
         }).catch(err => {
             addLog(`Failed to inject into tab: ${err.message}`, 'warn');
@@ -4134,7 +4541,6 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             const previousContentTarget = currentContentTarget();
             completeForceSyncBeforeTargetChange(null);
             invalidateTargetActivations();
-            await clearRequestedTarget();
             currentTabId = null;
             currentTabTitle = null;
             clearCurrentContentTarget();
@@ -4143,6 +4549,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             if (previousTabId) {
                 await deactivateTargetTab(previousTabId, previousContentTarget);
             }
+            await clearUserSelection();
             await clearPendingTarget();
             await chrome.storage.session.set({
                 currentTabId: null,
@@ -4158,29 +4565,26 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             return;
         }
 
+        // Persist the choice before activating. Injection can fail for reasons
+        // the user can act on (a player frame needing host access, a page still
+        // loading), and none of them mean they stopped wanting this tab.
+        await rememberUserSelection(message.tabId, message.tabTitle);
         try {
-            const selectedTabId = normalizeTabId(message.tabId);
-            if (selectedTabId === null) {
-                sendResponse({ status: 'invalid_tab' });
-                return;
-            }
-            pendingRequestedActivationCount++;
-            let response;
-            try {
-                await rememberRequestedTarget(selectedTabId, message.tabTitle);
-                response = await activateTargetTab(selectedTabId, message.tabTitle);
-            } finally {
-                pendingRequestedActivationCount = Math.max(0, pendingRequestedActivationCount - 1);
-            }
+            const response = await activateTargetTab(message.tabId, message.tabTitle);
             if (response?.status === 'ok') {
                 chrome.runtime.sendMessage({
                     type: 'TARGET_TAB_READY',
                     tabId: response.tabId
                 }).catch(() => {});
+            } else if (response?.status !== 'superseded') {
+                await recordUserSelectionFailure(message.tabId, {
+                    message: `Activation returned ${response?.status || 'no result'}`
+                });
             }
             sendResponse(response);
         } catch (error) {
             addLog(`Failed to select tab: ${error.message}`, 'warn');
+            await recordUserSelectionFailure(message.tabId, error);
             sendResponse(injectionFailureResponse(error));
         }
     } else if (message.type === 'LOG') {
@@ -4340,7 +4744,22 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             sendResponse({ status: 'ignored_stale_tab' });
             return;
         }
-        const activation = await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
+        // A page-driven notification must never surface as a handler failure.
+        // Reporting it that way turned one unreachable player frame into an
+        // endless error cascade in the popup.
+        const activation = await refreshCurrentMediaTarget(tabId, {
+            queueIfRunning: true,
+            onlyIfTargetMoved: true
+        }).catch(error => {
+            addLog(`Media frame candidate refresh failed: ${error.message}`, 'warn');
+            return { status: 'error', message: error.message };
+        });
+        // A layout change is exactly the shape of a rebuilt player frame, and a
+        // new document carries no monitor, so the video it creates next would go
+        // unreported. Do this on every notification rather than on a particular
+        // status: a concurrent refresh masks the status, and the call is already
+        // debounced and idempotent.
+        await refreshMediaFrameMonitors(tabId);
         sendResponse(activation || { status: 'invalid_tab' });
     } else if (message.type === 'MEDIA_FRAME_VISIBILITY') {
         if (!isCurrentContentSender(sender)) {
@@ -4354,7 +4773,13 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         const tabId = normalizeTabId(sender.tab?.id);
         const activation = tabId === null
             ? null
-            : await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
+            : await refreshCurrentMediaTarget(tabId, {
+                queueIfRunning: true,
+                onlyIfTargetMoved: true
+            }).catch(error => {
+                addLog(`Media frame visibility refresh failed: ${error.message}`, 'warn');
+                return { status: 'error', message: error.message };
+            });
         sendResponse(activation || { status: 'invalid_tab' });
     } else if (message.type === 'MEDIA_TARGET_REFRESH') {
         if (!isCurrentContentSender(sender)) {
@@ -4364,7 +4789,13 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         const tabId = normalizeTabId(sender.tab?.id);
         const activation = tabId === null
             ? null
-            : await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
+            : await refreshCurrentMediaTarget(tabId, {
+                queueIfRunning: true,
+                onlyIfTargetMoved: true
+            }).catch(error => {
+                addLog(`Media target refresh failed: ${error.message}`, 'warn');
+                return { status: 'error', message: error.message };
+            });
         sendResponse(activation || { status: 'invalid_tab' });
     } else if (message.type === 'CONTENT_BOOT') {
         if (sender.tab) {
@@ -4394,7 +4825,10 @@ async function handleAsyncMessage(message, sender, sendResponse) {
 
 initTabManager({
     getCurrentTabId: () => currentTabId,
-    reactivateCurrentTarget: tabId => refreshCurrentMediaTarget(tabId, { queueIfRunning: true }),
+    reactivateCurrentTarget: tabId => refreshCurrentMediaTarget(tabId, {
+        queueIfRunning: true,
+        onlyIfTargetMoved: false
+    }),
     ensureState,
     sendToCurrentContent: sendMessageToCurrentContent
 });
diff --git a/extension/chat-overlay-contract.test.mjs b/extension/chat-overlay-contract.test.mjs
index 3eca8be..5989f3b 100644
--- a/extension/chat-overlay-contract.test.mjs
+++ b/extension/chat-overlay-contract.test.mjs
@@ -173,18 +173,6 @@ describe('chat overlay contract', () => {
         expect(overlaySource).toContain("if (destroyed || area !== 'local') return");
     });
 
-    it('persists the last manual open/closed state across context refreshes', () => {
-        expect(overlaySource).toContain('const openStateKey = `chatOverlayOpen:${location.origin}`');
-        expect(overlaySource).toContain('let lastUserOpenState = null');
-        expect(overlaySource).toContain('function setOpened(next, persistPreference = true)');
-        expect(overlaySource).toContain('setLocalStorage({ [openStateKey]: opened })');
-        expect(overlaySource).toContain('setOpened(false, false)');
-        expect(overlaySource).toContain('setOpened(lastUserOpenState ?? (chatStartMode === \'open\'), false)');
-        expect(overlaySource).toContain('typeof data[openStateKey] === \'boolean\'');
-        expect(overlaySource).toContain('const previousEnabled = context?.enabled === true');
-        expect(overlaySource).toContain('(!startStateApplied || !previousEnabled)');
-    });
-
     it('keeps chat hidden by default without discarding the room chat key', () => {
         expect(popupSource).toContain('localData.chatEnabled === true');
         expect(backgroundSource).toContain('chatEnabled: data.chatEnabled === true');
diff --git a/extension/chat-overlay.js b/extension/chat-overlay.js
index 48eb69b..22a4273 100644
--- a/extension/chat-overlay.js
+++ b/extension/chat-overlay.js
@@ -28,7 +28,6 @@
         large: Object.freeze({ width: 440, height: 640 })
     });
     const storageKey = `chatOverlayLayout:${location.origin}`;
-    const openStateKey = `chatOverlayOpen:${location.origin}`;
     const systemTheme = window.matchMedia('(prefers-color-scheme: light)');
     let context = null;
     let opened = false;
@@ -58,7 +57,6 @@
     let chatSize = 'standard';
     let chatStartMode = 'bubble';
     let chatReactionDisplay = 'chat';
-    let lastUserOpenState = null;
     let themeMode = 'system';
     let themePalette = 'eucalyptus';
     let pageDockTarget = null;
@@ -578,12 +576,8 @@
         if (persistPreference) setLocalStorage({ chatSize });
     }
 
-    function setOpened(next, persistPreference = true) {
+    function setOpened(next) {
         opened = !!next && !!context?.enabled;
-        if (persistPreference) {
-            lastUserOpenState = opened;
-            setLocalStorage({ [openStateKey]: opened });
-        }
         panel.classList.toggle('open', opened);
         launcher.style.display = opened ? 'none' : '';
         if (opened) {
@@ -596,7 +590,6 @@
 
     function applyContext(next) {
         const previousRoomId = context?.roomId;
-        const previousEnabled = context?.enabled === true;
         context = next || null;
         const supported = !!context?.supported;
         const optedIn = !!context?.enabled;
@@ -611,10 +604,10 @@
         launcher.setAttribute('aria-disabled', String(!context?.enabled));
         if (!optedIn) startStateApplied = false;
         if (!context?.enabled) {
-            setOpened(false, false);
-        } else if (preferencesLoaded && (!startStateApplied || !previousEnabled)) {
+            setOpened(false);
+        } else if (preferencesLoaded && !startStateApplied) {
             startStateApplied = true;
-            setOpened(lastUserOpenState ?? (chatStartMode === 'open'), false);
+            setOpened(chatStartMode === 'open');
         }
         applyStrings();
         applyLayout();
@@ -974,7 +967,7 @@
     systemTheme.addEventListener('change', handleSystemTheme);
     chrome.storage.onChanged.addListener(handleStorage);
     chrome.runtime.onMessage.addListener(handleRuntime);
-    chrome.storage.local.get([storageKey, openStateKey, 'themeMode', 'themePalette', 'chatPosition', 'chatSize', 'chatStartMode', 'chatReactionDisplay'], data => {
+    chrome.storage.local.get([storageKey, 'themeMode', 'themePalette', 'chatPosition', 'chatSize', 'chatStartMode', 'chatReactionDisplay'], data => {
         if (destroyed) return;
         const storedLayout = data[storageKey];
         if (storedLayout && typeof storedLayout === 'object') {
@@ -985,7 +978,6 @@
         chatPosition = normalizePosition(data.chatPosition);
         chatSize = normalizeSize(data.chatSize);
         chatStartMode = data.chatStartMode === 'open' ? 'open' : 'bubble';
-        lastUserOpenState = typeof data[openStateKey] === 'boolean' ? data[openStateKey] : null;
         chatReactionDisplay = data.chatReactionDisplay === 'video' ? 'video' : 'chat';
         layout.mode = chatPosition;
         if (layout.mode === 'detached') layout.detachedInitialized = true;
diff --git a/extension/content.js b/extension/content.js
index ad0c412..f1d8995 100644
--- a/extension/content.js
+++ b/extension/content.js
@@ -1,17 +1,17 @@
-/**

- * KoalaSync Content Script

- * Injected into video tabs to control playback and detect events.

- */

-

-(function() {

-    // Injection Guard: Check if already injected AND context is valid

-    try {

-        if (window.koalaSyncInjected && chrome.runtime.id) {

-            return;

-        }

-    } catch (_e) {

-        // Context invalidated, proceed with re-injection

-    }

+/**
+ * KoalaSync Content Script
+ * Injected into video tabs to control playback and detect events.
+ */
+
+(function() {
+    // Injection Guard: Check if already injected AND context is valid
+    try {
+        if (window.koalaSyncInjected && chrome.runtime.id) {
+            return;
+        }
+    } catch (_e) {
+        // Context invalidated, proceed with re-injection
+    }
     window.koalaSyncInjected = true;
     let destroyed = false;
     const lifecycleTimeouts = new Set();
@@ -69,50 +69,50 @@
     if (isEmbeddedContentFrame) {
         window.addEventListener('resize', handleMediaFrameResize, { passive: true });
     }
-

-    // --- SHARED_EVENTS_INJECT_START ---

+
+    // --- SHARED_EVENTS_INJECT_START ---
     // This block is automatically updated by /scripts/build-extension.cjs
-    const EVENTS = {

-        PLAY: "play",

-        PAUSE: "pause",

-        SEEK: "seek",

-        FORCE_SYNC_PREPARE: "force_sync_prepare",

-        FORCE_SYNC_ACK: "force_sync_ack",

-        FORCE_SYNC_EXECUTE: "force_sync_execute",

-        PEER_STATUS: "peer_status",

-        EPISODE_LOBBY: "episode_lobby",

-        EPISODE_READY: "episode_ready"

-    };

-    // --- SHARED_EVENTS_INJECT_END ---

-

-    // Suppresses native event reporting after a programmatic action.

-    // Each entry is a per-type timer (key = 'playing'|'paused'|'seek').

-    // While a timer exists, matching native events are consumed and not relayed.

-    // Timers self-clean after 300ms if the native event never fires.

-    let _suppressTimers = {};

-

-    function _setSuppress(state) {

-        if (_suppressTimers[state]) clearTimeout(_suppressTimers[state]);

-        _suppressTimers[state] = setTimeout(() => {

-            delete _suppressTimers[state];

-        }, 300);

-    }

-

-    function _clearSuppress(state) {

-        if (_suppressTimers[state]) {

-            clearTimeout(_suppressTimers[state]);

-            delete _suppressTimers[state];

-        }

-    }

-

-    // --- Seek Relay Filtering ---

-    // Minimum seek delta (seconds) to report. Prevents HLS/DASH buffering micro-seeks

-    // from being relayed to peers as user-initiated seeks.

-    const MIN_SEEK_DELTA = 2.0;

-    let lastReportedSeekTime = null;  // last currentTime we relayed as a SEEK

-    let seekDebounceTimer = null;     // debounce timer for rapid seek events

-    let expectedSeekTime = null;      // strictly track programmatic seeks

-

+    const EVENTS = {
+        PLAY: "play",
+        PAUSE: "pause",
+        SEEK: "seek",
+        FORCE_SYNC_PREPARE: "force_sync_prepare",
+        FORCE_SYNC_ACK: "force_sync_ack",
+        FORCE_SYNC_EXECUTE: "force_sync_execute",
+        PEER_STATUS: "peer_status",
+        EPISODE_LOBBY: "episode_lobby",
+        EPISODE_READY: "episode_ready"
+    };
+    // --- SHARED_EVENTS_INJECT_END ---
+
+    // Suppresses native event reporting after a programmatic action.
+    // Each entry is a per-type timer (key = 'playing'|'paused'|'seek').
+    // While a timer exists, matching native events are consumed and not relayed.
+    // Timers self-clean after 300ms if the native event never fires.
+    let _suppressTimers = {};
+
+    function _setSuppress(state) {
+        if (_suppressTimers[state]) clearTimeout(_suppressTimers[state]);
+        _suppressTimers[state] = setTimeout(() => {
+            delete _suppressTimers[state];
+        }, 300);
+    }
+
+    function _clearSuppress(state) {
+        if (_suppressTimers[state]) {
+            clearTimeout(_suppressTimers[state]);
+            delete _suppressTimers[state];
+        }
+    }
+
+    // --- Seek Relay Filtering ---
+    // Minimum seek delta (seconds) to report. Prevents HLS/DASH buffering micro-seeks
+    // from being relayed to peers as user-initiated seeks.
+    const MIN_SEEK_DELTA = 2.0;
+    let lastReportedSeekTime = null;  // last currentTime we relayed as a SEEK
+    let seekDebounceTimer = null;     // debounce timer for rapid seek events
+    let expectedSeekTime = null;      // strictly track programmatic seeks
+
     const PAGE_API_SEEK_BRIDGE = 1;
     // Accurate Disney+ playhead pushed by the MAIN-world page-API bridge
     // (background.js installPageApiSeekBridge). The isolated content world
@@ -128,25 +128,25 @@
     }
     if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
         window.addEventListener('message', handlePageApiTime);
-    }
-
-    function hostMatchesUrl(host, url) {
-        const normalized = String(url || '')
-            .replace(/^https?:\/\//i, '')
-            .split('/')[0]
-            .toLowerCase();
-        return normalized && (host === normalized || host.endsWith(`.${normalized}`));
-    }
-
-    function matchesPlayerUrls(urls) {
-        const host = window.location.hostname.toLowerCase();
-        return Array.isArray(urls) && urls.some(url => hostMatchesUrl(host, url));
-    }
-
-    function isDisneyPlusHost() {
-        return matchesPlayerUrls(['disneyplus.com']);
-    }
-
+    }
+
+    function hostMatchesUrl(host, url) {
+        const normalized = String(url || '')
+            .replace(/^https?:\/\//i, '')
+            .split('/')[0]
+            .toLowerCase();
+        return normalized && (host === normalized || host.endsWith(`.${normalized}`));
+    }
+
+    function matchesPlayerUrls(urls) {
+        const host = window.location.hostname.toLowerCase();
+        return Array.isArray(urls) && urls.some(url => hostMatchesUrl(host, url));
+    }
+
+    function isDisneyPlusHost() {
+        return matchesPlayerUrls(['disneyplus.com']);
+    }
+
     function getDisneyPlusTimeline() {
         if (!isDisneyPlusHost()) return null;
         // Exact playhead/duration from the page media player, relayed by the
@@ -157,10 +157,10 @@
         }
         return null;
     }
-
-    // Site-specific player exceptions live here. The default HTML5 path stays below.
-    function getSiteQuirkAdapters() {
-        return [{
+
+    // Site-specific player exceptions live here. The default HTML5 path stays below.
+    function getSiteQuirkAdapters() {
+        return [{
             name: 'disneyplus-page-api',
             key: 'disneyPlus',
             urls: ['disneyplus.com'],
@@ -175,22 +175,22 @@
                 };
             }
         }];
-    }
-
-    function getActiveSiteQuirk() {
-        return getSiteQuirkAdapters().find(adapter => adapter.matches()) || null;
-    }
-
-    function getSiteQuirkTimeline(video) {
-        const adapter = getActiveSiteQuirk();
-        return adapter ? adapter.getTimeline(video) : null;
-    }
-
-    function getSiteQuirkDebug(video) {
-        const adapter = getActiveSiteQuirk();
-        return adapter ? adapter.getDebug(video) : null;
-    }
-
+    }
+
+    function getActiveSiteQuirk() {
+        return getSiteQuirkAdapters().find(adapter => adapter.matches()) || null;
+    }
+
+    function getSiteQuirkTimeline(video) {
+        const adapter = getActiveSiteQuirk();
+        return adapter ? adapter.getTimeline(video) : null;
+    }
+
+    function getSiteQuirkDebug(video) {
+        const adapter = getActiveSiteQuirk();
+        return adapter ? adapter.getDebug(video) : null;
+    }
+
     function getSyncCurrentTime(video) {
         const siteTimeline = getSiteQuirkTimeline(video);
         if (siteTimeline) return siteTimeline.current;
@@ -205,23 +205,23 @@
         if (isDisneyPlusHost()) return 0;
         return Number.isFinite(video.duration) && video.duration > 0 ? video.duration : 0;
     }
-
-    function toNativeSeekTime(video, targetTime) {
-        if (!Number.isFinite(targetTime)) return targetTime;
-        const siteTimeline = getSiteQuirkTimeline(video);
-        if (!siteTimeline) return targetTime;
-        const nativeTarget = siteTimeline.nativeStart + targetTime * siteTimeline.nativeScale;
-        const max = Number.isFinite(siteTimeline.end) ? siteTimeline.end : nativeTarget;
-        const min = Number.isFinite(siteTimeline.start) ? siteTimeline.start : 0;
-        return Math.max(min, Math.min(max, nativeTarget));
-    }
-
-    function shouldUsePageApiSeek() {
-        return window.KOALA_PAGE_API_SEEK_ENABLED === true &&
-            typeof window.koalaFindPageApiSeekProvider === 'function' &&
-            !!window.koalaFindPageApiSeekProvider(window.location.hostname);
-    }
-
+
+    function toNativeSeekTime(video, targetTime) {
+        if (!Number.isFinite(targetTime)) return targetTime;
+        const siteTimeline = getSiteQuirkTimeline(video);
+        if (!siteTimeline) return targetTime;
+        const nativeTarget = siteTimeline.nativeStart + targetTime * siteTimeline.nativeScale;
+        const max = Number.isFinite(siteTimeline.end) ? siteTimeline.end : nativeTarget;
+        const min = Number.isFinite(siteTimeline.start) ? siteTimeline.start : 0;
+        return Math.max(min, Math.min(max, nativeTarget));
+    }
+
+    function shouldUsePageApiSeek() {
+        return window.KOALA_PAGE_API_SEEK_ENABLED === true &&
+            typeof window.koalaFindPageApiSeekProvider === 'function' &&
+            !!window.koalaFindPageApiSeekProvider(window.location.hostname);
+    }
+
     function seekVideo(video, targetTime) {
         // Prefer a precise page-level seek API when available (Netflix, Disney+);
         // for those players the DOM/button seek path is imprecise or impossible.
@@ -233,48 +233,48 @@
         expectedSeekTime = targetTime;
         video.currentTime = toNativeSeekTime(video, targetTime);
     }
-

-    // --- Play/Pause Coalescing (leading + trailing) ---

-    // Media players (HLS/DASH, ad insertion, ABR/quality switches, source swaps,

-    // page teardown) fire bursts of native play/pause events within a few hundred

-    // ms. Relaying each as a distinct command spams peers and the relay.

-    //

-    // Strategy: emit the FIRST event immediately (leading edge → a deliberate

-    // single play/pause has zero added latency), then hold a short window. If

-    // more play/pause events arrive during the window it's a burst — we suppress

-    // the intermediate churn and, once it settles, emit the FINAL state on the

-    // trailing edge.

-    //

-    // We deliberately do NOT dedup the trailing send against the leading one. A

-    // remote play/pause may be applied mid-window (e.g. I pause, peer plays, I

-    // pause again within 150ms): the settled state then equals my last *sent*

-    // state yet is a genuine change versus the now-shared state — suppressing it

-    // would desync. Re-sending an unchanged state is a harmless no-op on peers,

-    // so re-sending is always the safe choice. Echo-suppression and seek-flush

-    // still run synchronously on event arrival (see reportEvent) — only the

-    // network emit is governed here.

-    const PLAY_PAUSE_COALESCE_MS = 150;

+
+    // --- Play/Pause Coalescing (leading + trailing) ---
+    // Media players (HLS/DASH, ad insertion, ABR/quality switches, source swaps,
+    // page teardown) fire bursts of native play/pause events within a few hundred
+    // ms. Relaying each as a distinct command spams peers and the relay.
+    //
+    // Strategy: emit the FIRST event immediately (leading edge → a deliberate
+    // single play/pause has zero added latency), then hold a short window. If
+    // more play/pause events arrive during the window it's a burst — we suppress
+    // the intermediate churn and, once it settles, emit the FINAL state on the
+    // trailing edge.
+    //
+    // We deliberately do NOT dedup the trailing send against the leading one. A
+    // remote play/pause may be applied mid-window (e.g. I pause, peer plays, I
+    // pause again within 150ms): the settled state then equals my last *sent*
+    // state yet is a genuine change versus the now-shared state — suppressing it
+    // would desync. Re-sending an unchanged state is a harmless no-op on peers,
+    // so re-sending is always the safe choice. Echo-suppression and seek-flush
+    // still run synchronously on event arrival (see reportEvent) — only the
+    // network emit is governed here.
+    const PLAY_PAUSE_COALESCE_MS = 150;
     let playPauseCoalesceTimer = null;  // non-null = a coalescing window is open
     let pendingPlayPauseAction = null;  // last play/pause seen during the window, awaiting trailing flush
     let pendingPlayPauseVideo = null;   // source element for rejecting a stale trailing flush
-

-    // --- Episode Auto-Sync State ---

-    let lastKnownMediaTitle = null;

-    let episodeTransitionDebounce = null;

-    let _pendingLobbyTitle = null; // Title we're waiting to match (from remote lobby)

-    let lobbyPollTimer = null;

-    let _autoSyncEnabled = true; // Cached setting, updated via storage.onChanged

-    let _audioSettings = null;

-    let _audioProcessingAllowed = true;

-

-    // Cache the autoSyncNextEpisode setting (local-only; never read from sync)

+
+    // --- Episode Auto-Sync State ---
+    let lastKnownMediaTitle = null;
+    let episodeTransitionDebounce = null;
+    let _pendingLobbyTitle = null; // Title we're waiting to match (from remote lobby)
+    let lobbyPollTimer = null;
+    let _autoSyncEnabled = true; // Cached setting, updated via storage.onChanged
+    let _audioSettings = null;
+    let _audioProcessingAllowed = true;
+
+    // Cache the autoSyncNextEpisode setting (local-only; never read from sync)
     chrome.storage.local.get(['autoSyncNextEpisode', 'audioSettings'], (data) => {
         if (destroyed) return;
-        _autoSyncEnabled = data.autoSyncNextEpisode !== false;

-        _audioSettings = mergeAudioSettings(data.audioSettings);

-        const video = findVideo();

-        if (video && _audioProcessingAllowed) applyAudioSettings(video, _audioSettings);

-    });

+        _autoSyncEnabled = data.autoSyncNextEpisode !== false;
+        _audioSettings = mergeAudioSettings(data.audioSettings);
+        const video = findVideo();
+        if (video && _audioProcessingAllowed) applyAudioSettings(video, _audioSettings);
+    });
     function handleStorageChanged(changes, area) {
         if (destroyed) return;
         if (area === 'local' && changes.autoSyncNextEpisode) {
@@ -287,266 +287,266 @@
         }
     }
     chrome.storage.onChanged.addListener(handleStorageChanged);
-

-    // --- Host Control Mode (guest-side) ---

-    // When a room is in 'host-only' mode and we're a guest, a deliberate local

-    // pause/seek must not drive the room (background/server already drop it). Here

-    // we handle the *local* UX: snap back to the host's position, or — if the user

-    // really wants to — let them go solo (desync) with a resync escape hatch.

-    let hcmControlMode = 'everyone';   // mirror of room control mode

-    let hcmAmController = false;        // are we allowed to drive (owner or co-host)?

-    let hcmHostPeerId = null;          // last known host peerId (room/host identity)

-    let hcmDesynced = false;           // user chose to go solo

-    let hcmSnapBackCooldownUntil = 0;  // suppress re-trigger right after a snap-back

-    let hcmDeferredSnapPending = false; // a buffer-aware snap-back is waiting for readiness

-    let hcmLastUserGestureAt = 0;      // for deliberate-vs-involuntary classification

+
+    // --- Host Control Mode (guest-side) ---
+    // When a room is in 'host-only' mode and we're a guest, a deliberate local
+    // pause/seek must not drive the room (background/server already drop it). Here
+    // we handle the *local* UX: snap back to the host's position, or — if the user
+    // really wants to — let them go solo (desync) with a resync escape hatch.
+    let hcmControlMode = 'everyone';   // mirror of room control mode
+    let hcmAmController = false;        // are we allowed to drive (owner or co-host)?
+    let hcmHostPeerId = null;          // last known host peerId (room/host identity)
+    let hcmDesynced = false;           // user chose to go solo
+    let hcmSnapBackCooldownUntil = 0;  // suppress re-trigger right after a snap-back
+    let hcmDeferredSnapPending = false; // a buffer-aware snap-back is waiting for readiness
+    let hcmLastUserGestureAt = 0;      // for deliberate-vs-involuntary classification
     let hcmBufferingUntil = 0;         // set on 'waiting' — buffering grace window
     let hcmDialogTimer = null;         // 8s auto-stay timer — cleared on dialog replace (H-4)
     let hcmBadgeDomReadyHandler = null;
-    // Localized strings for the in-page dialog/badge (content has no i18n loader;

-    // background resolves them via GET_HCM_STRINGS on init). English fallbacks here.

-    const hcmStrings = {

-        title:  'KoalaSync · Host controls this room',

-        body:   'Only the host can control playback in this room. Keep watching together, or watch on your own?',

-        stay:   'Stay in sync',

-        solo:   'Watch on my own',

-        badge:  'Watching on your own',

-        resync: 'Resync'

-    };

-    const HCM_USER_GESTURE_MS = 1000;

-    const HCM_BUFFERING_GRACE_MS = 1500;

-    const HCM_SNAP_BACK_COOLDOWN_MS = 1000;

-    const HCM_BUFFER_WAIT_MS = 8000;   // cap on waiting for a buffering player before snapping anyway

-

-    // Track genuine user input so we can tell a deliberate pause/seek from a

-    // player-/browser-initiated one. Capturing + passive so we never interfere.

-    const _hcmGesture = () => { hcmLastUserGestureAt = Date.now(); };

-    document.addEventListener('keydown', _hcmGesture, { capture: true, passive: true });

-    document.addEventListener('pointerdown', _hcmGesture, { capture: true, passive: true });

-

-    function hcmIsGuestGated() {

-        return hcmControlMode === 'host-only' && !hcmAmController;

-    }

-

-    // EC-9 intent classifier: only a *clearly deliberate* guest action triggers the

-    // dialog/snap-back. Anything that smells involuntary (buffering, seeking, tab

-    // refocus, no recent gesture) is treated as involuntary. Bias intentional —

-    // in host-only the guest never broadcasts anyway, so this only tunes UX.

-    function hcmClassifyIntent() {

-        const video = findVideo();

-        if (!video) return 'involuntary';

-        if (hcmIsLive(video)) return 'live';                   // EC-15: degrade, don't gate

-        if (video.readyState < 3) return 'involuntary';        // buffering / not enough data

-        if (video.seeking) return 'involuntary';

-        if (Date.now() < hcmBufferingUntil) return 'involuntary';

-        if (Date.now() < visibilityGraceUntil) return 'involuntary';

-        if (Date.now() - hcmLastUserGestureAt > HCM_USER_GESTURE_MS) return 'involuntary';

-        return 'deliberate';

-    }

-

-    // Live detection (EC-15 + DVR). Pure live reports duration Infinity/NaN. Live-DVR

-    // (Twitch/YouTube-live with rewind) reports a *finite, sliding* duration — its

-    // seekable window doesn't start at 0, which we use as the DVR signal.

-    function hcmIsLive(video) {

-        // Don't trust duration before metadata has loaded (readyState >= 1) —

-        // otherwise pre-loaded videos report NaN and get misclassified as live,

-        // which suppresses the desync dialog (L-2).

-        if (video.readyState < 1) return false;

-        if (!isDisneyPlusHost() && !Number.isFinite(video.duration)) return true;

-        try {

-            const s = video.seekable;

-            if (s && s.length > 0 && s.start(0) > 1) return true; // sliding DVR window

-        } catch (_e) { /* seekable may throw if empty */ }

-        return false;

-    }

-

-    // Snap the local player back to the host's current position/state.

-    function hcmSnapBackToHost(target) {

-        if (hcmDesynced) return; // user opted out — never yank them back automatically

-        hcmSnapBackCooldownUntil = Date.now() + HCM_SNAP_BACK_COOLDOWN_MS;

-        const video = findVideo();

-        if (!video) return;

-        if (target && Number.isFinite(target.targetTime)) {

-            tryMediaAction(EVENTS.SEEK, { targetTime: target.targetTime });

-        }

-        // Adopt the host's play/pause state — but ONLY if we actually know it.

-        // Defaulting to PLAY when the state is unknown would auto-resume a paused

-        // video against the host's real state (H-1).

-        if (target && target.playbackState === 'paused') {

-            tryMediaAction(EVENTS.PAUSE);

-        } else if (target && target.playbackState === 'playing') {

-            tryMediaAction(EVENTS.PLAY);

-        }

-        reportLog('Host-only: snapped back to host position', 'info');

-    }

-

-    // Resync to the host's current position, retrying briefly if the host's state

-    // isn't known yet (e.g. they just paused and no heartbeat has propagated) —

-    // otherwise the request is a silent no-op and the user thinks they're synced

-    // when they aren't. Shared by the dialog's "Stay in sync" and the Resync badge.

-    function hcmRequestHostSyncWithRetry() {

-        let attempts = 0;

-        const tryOnce = () => {

+    // Localized strings for the in-page dialog/badge (content has no i18n loader;
+    // background resolves them via GET_HCM_STRINGS on init). English fallbacks here.
+    const hcmStrings = {
+        title:  'KoalaSync · Host controls this room',
+        body:   'Only the host can control playback in this room. Keep watching together, or watch on your own?',
+        stay:   'Stay in sync',
+        solo:   'Watch on my own',
+        badge:  'Watching on your own',
+        resync: 'Resync'
+    };
+    const HCM_USER_GESTURE_MS = 1000;
+    const HCM_BUFFERING_GRACE_MS = 1500;
+    const HCM_SNAP_BACK_COOLDOWN_MS = 1000;
+    const HCM_BUFFER_WAIT_MS = 8000;   // cap on waiting for a buffering player before snapping anyway
+
+    // Track genuine user input so we can tell a deliberate pause/seek from a
+    // player-/browser-initiated one. Capturing + passive so we never interfere.
+    const _hcmGesture = () => { hcmLastUserGestureAt = Date.now(); };
+    document.addEventListener('keydown', _hcmGesture, { capture: true, passive: true });
+    document.addEventListener('pointerdown', _hcmGesture, { capture: true, passive: true });
+
+    function hcmIsGuestGated() {
+        return hcmControlMode === 'host-only' && !hcmAmController;
+    }
+
+    // EC-9 intent classifier: only a *clearly deliberate* guest action triggers the
+    // dialog/snap-back. Anything that smells involuntary (buffering, seeking, tab
+    // refocus, no recent gesture) is treated as involuntary. Bias intentional —
+    // in host-only the guest never broadcasts anyway, so this only tunes UX.
+    function hcmClassifyIntent() {
+        const video = findVideo();
+        if (!video) return 'involuntary';
+        if (hcmIsLive(video)) return 'live';                   // EC-15: degrade, don't gate
+        if (video.readyState < 3) return 'involuntary';        // buffering / not enough data
+        if (video.seeking) return 'involuntary';
+        if (Date.now() < hcmBufferingUntil) return 'involuntary';
+        if (Date.now() < visibilityGraceUntil) return 'involuntary';
+        if (Date.now() - hcmLastUserGestureAt > HCM_USER_GESTURE_MS) return 'involuntary';
+        return 'deliberate';
+    }
+
+    // Live detection (EC-15 + DVR). Pure live reports duration Infinity/NaN. Live-DVR
+    // (Twitch/YouTube-live with rewind) reports a *finite, sliding* duration — its
+    // seekable window doesn't start at 0, which we use as the DVR signal.
+    function hcmIsLive(video) {
+        // Don't trust duration before metadata has loaded (readyState >= 1) —
+        // otherwise pre-loaded videos report NaN and get misclassified as live,
+        // which suppresses the desync dialog (L-2).
+        if (video.readyState < 1) return false;
+        if (!isDisneyPlusHost() && !Number.isFinite(video.duration)) return true;
+        try {
+            const s = video.seekable;
+            if (s && s.length > 0 && s.start(0) > 1) return true; // sliding DVR window
+        } catch (_e) { /* seekable may throw if empty */ }
+        return false;
+    }
+
+    // Snap the local player back to the host's current position/state.
+    function hcmSnapBackToHost(target) {
+        if (hcmDesynced) return; // user opted out — never yank them back automatically
+        hcmSnapBackCooldownUntil = Date.now() + HCM_SNAP_BACK_COOLDOWN_MS;
+        const video = findVideo();
+        if (!video) return;
+        if (target && Number.isFinite(target.targetTime)) {
+            tryMediaAction(EVENTS.SEEK, { targetTime: target.targetTime });
+        }
+        // Adopt the host's play/pause state — but ONLY if we actually know it.
+        // Defaulting to PLAY when the state is unknown would auto-resume a paused
+        // video against the host's real state (H-1).
+        if (target && target.playbackState === 'paused') {
+            tryMediaAction(EVENTS.PAUSE);
+        } else if (target && target.playbackState === 'playing') {
+            tryMediaAction(EVENTS.PLAY);
+        }
+        reportLog('Host-only: snapped back to host position', 'info');
+    }
+
+    // Resync to the host's current position, retrying briefly if the host's state
+    // isn't known yet (e.g. they just paused and no heartbeat has propagated) —
+    // otherwise the request is a silent no-op and the user thinks they're synced
+    // when they aren't. Shared by the dialog's "Stay in sync" and the Resync badge.
+    function hcmRequestHostSyncWithRetry() {
+        let attempts = 0;
+        const tryOnce = () => {
             runtimeMessage({ type: 'REQUEST_HOST_SYNC' }, (res) => {
-                if (chrome.runtime.lastError || !res || !res.target) {

+                if (chrome.runtime.lastError || !res || !res.target) {
                     if (++attempts < 5) scheduleLifecycleTimeout(tryOnce, 250);
-                    else reportLog('Host-only: resync requested but host state unavailable', 'warn');

-                    return;

-                }

-                hcmSnapBackToHost(res.target);

-            });

-        };

-        tryOnce();

-    }

-

-    // Buffer-aware snap-back (#3). An involuntary pause/seek often coincides with the

-    // player buffering — and a player can't actually play while it's stalled. Snapping

-    // immediately just fights the buffer (seek → re-buffer → another pause → …), which

-    // looks like stutter. Instead: if the player isn't ready, wait until it can play

-    // (readyState>=3, not seeking), then snap ONCE to the host's *current* position

-    // (re-queried, since the captured target may be stale by the time buffering ends).

-    // Player-agnostic on purpose — we can't enumerate every site, so this must be safe

-    // regardless of whether a given player fires 'pause' or only 'waiting'.

-    function hcmDeferredSnapBack() {

-        if (hcmDeferredSnapPending) return; // already waiting — don't stack polls

-        hcmDeferredSnapPending = true;

-        const deadline = Date.now() + HCM_BUFFER_WAIT_MS;

-        const poll = () => {

-            // Abort if the reason to snap is gone: user went solo, we're no longer a

-            // gated guest, or the video vanished.

-            if (hcmDesynced || !hcmIsGuestGated()) { hcmDeferredSnapPending = false; return; }

-            const video = findVideo();

-            const ready = video && video.readyState >= 3 && !video.seeking;

-            if (ready || Date.now() >= deadline) {

-                hcmDeferredSnapPending = false;

-                hcmRequestHostSyncWithRetry(); // fresh host position + snap once

-                return;

-            }

+                    else reportLog('Host-only: resync requested but host state unavailable', 'warn');
+                    return;
+                }
+                hcmSnapBackToHost(res.target);
+            });
+        };
+        tryOnce();
+    }
+
+    // Buffer-aware snap-back (#3). An involuntary pause/seek often coincides with the
+    // player buffering — and a player can't actually play while it's stalled. Snapping
+    // immediately just fights the buffer (seek → re-buffer → another pause → …), which
+    // looks like stutter. Instead: if the player isn't ready, wait until it can play
+    // (readyState>=3, not seeking), then snap ONCE to the host's *current* position
+    // (re-queried, since the captured target may be stale by the time buffering ends).
+    // Player-agnostic on purpose — we can't enumerate every site, so this must be safe
+    // regardless of whether a given player fires 'pause' or only 'waiting'.
+    function hcmDeferredSnapBack() {
+        if (hcmDeferredSnapPending) return; // already waiting — don't stack polls
+        hcmDeferredSnapPending = true;
+        const deadline = Date.now() + HCM_BUFFER_WAIT_MS;
+        const poll = () => {
+            // Abort if the reason to snap is gone: user went solo, we're no longer a
+            // gated guest, or the video vanished.
+            if (hcmDesynced || !hcmIsGuestGated()) { hcmDeferredSnapPending = false; return; }
+            const video = findVideo();
+            const ready = video && video.readyState >= 3 && !video.seeking;
+            if (ready || Date.now() >= deadline) {
+                hcmDeferredSnapPending = false;
+                hcmRequestHostSyncWithRetry(); // fresh host position + snap once
+                return;
+            }
             scheduleLifecycleTimeout(poll, 300);
-        };

-        poll();

-    }

-

-    // Entry point: background told us our local action was blocked in host-only.

-    function hcmHandleBlocked(action, target) {

-        // HOST_BLOCKED is only ever sent to a gated guest (background verifies

-        // host-only + !host before sending), so it's authoritative. Adopt the

-        // role/mode from it in case our CONTROL_MODE broadcast hasn't landed yet

-        // (join race, EC-5) — otherwise we'd miss the dialog/snap-back.

-        hcmControlMode = 'host-only';

-        hcmAmController = false;

-        if (hcmDesynced) return; // already solo, nothing to do

-

-        const intent = hcmClassifyIntent();

-        if (intent === 'live') return;          // EC-15: leave the guest alone on live

-        if (intent === 'involuntary') {

-            // EC-4 loop guard: only the silent auto snap-back is suppressed by the

-            // cooldown — the deliberate dialog path below must still go through,

-            // otherwise a second deliberate pause inside the cooldown window leaves

-            // the user stuck paused with no UI (M-3).

-            if (Date.now() < hcmSnapBackCooldownUntil || hcmDeferredSnapPending) return;

-            // Buffering/ads/throttle — silently re-sync, no dialog spam.

-            const video = findVideo();

-            if (video && video.readyState >= 3 && !video.seeking) {

-                // Ready now → snap immediately. Use the captured target if it's

-                // usable, otherwise re-query+retry (host state may not be known yet)

-                // so we never leave the guest silently stuck (consistent with the

-                // deferred and "Stay in sync" paths).

-                if (target && Number.isFinite(target.targetTime)) hcmSnapBackToHost(target);

-                else hcmRequestHostSyncWithRetry();

-            } else {

-                hcmDeferredSnapBack();             // buffering → wait for ready, then snap once (#3)

-            }

-            return;

-        }

-        // Deliberate: offer the choice (Teleparty-style), default = snap back.

-        hcmShowDesyncDialog(action, target);

-    }

-

-    // --- In-page UI (dialog + persistent desync badge) ---

-    // Built with the DOM API (CSSOM .style is CSP-safe; inline style="" in innerHTML

-    // is stripped by strict style-src on Netflix/YouTube/Disney+). Hosted in a

-    // Shadow DOM so the page's CSS can't restyle or hide our controls.

-    let hcmDialogHost = null;  // shadow host element for the dialog

-    let hcmBadgeHost = null;   // shadow host element for the persistent badge

-    let hcmBadgePending = false;  // retry flag for early-injection badge creation (L-4)

-

-    function hcmEl(tag, css, text) {

-        const el = document.createElement(tag);

-        if (css) el.style.cssText = css;        // CSSOM assignment — not gated by CSP

-        if (text != null) el.textContent = text;

-        return el;

-    }

-

-    function hcmRemoveDialog() {

-        // Cancel any pending auto-stay timer so a replaced dialog's stale closure

-        // can't later remove its successor / snap to an outdated target (H-4).

-        if (hcmDialogTimer) { clearTimeout(hcmDialogTimer); hcmDialogTimer = null; }

-        if (hcmDialogHost) { hcmDialogHost.remove(); hcmDialogHost = null; }

-    }

-

-    function hcmShowDesyncDialog(action, target) {

-        if (!document.body) { hcmSnapBackToHost(target); return; }

-        hcmRemoveDialog();

-        const host = hcmEl('div', 'all:initial');

-        const root = host.attachShadow({ mode: 'open' });

-

-        const wrap = hcmEl('div', 'position:fixed;z-index:2147483647;left:50%;bottom:32px;transform:translateX(-50%);background:#212a17;color:#f4f2ea;font:14px/1.4 system-ui,sans-serif;padding:16px 18px;border-radius:12px;box-shadow:0 8px 30px rgba(0,0,0,.45);max-width:360px;border:1px solid #2f3625');

-        wrap.setAttribute('role', 'dialog');

-        const title = hcmEl('div', 'font-weight:600;margin-bottom:6px', hcmStrings.title);

-        const body = hcmEl('div', 'margin-bottom:12px;color:#bcb7a9', hcmStrings.body);

-        const btnRow = hcmEl('div', 'display:flex;gap:8px;justify-content:flex-end');

-        const soloBtn = hcmEl('button', 'background:#2f3625;color:#f4f2ea;border:0;padding:8px 12px;border-radius:8px;cursor:pointer', hcmStrings.solo);

-        const stayBtn = hcmEl('button', 'background:#56ae6c;color:#0a1a0d;border:0;padding:8px 12px;border-radius:8px;cursor:pointer;font-weight:600', hcmStrings.stay);

-        btnRow.append(soloBtn, stayBtn);

-        wrap.append(title, body, btnRow);

-        root.appendChild(wrap);

-        document.body.appendChild(host);

-        hcmDialogHost = host;

-

-        let settled = false;

-        // Re-query the host's current position on click instead of using the

-        // potentially stale target captured at HOST_BLOCKED time (M-1).

-        const stay = () => {

-            if (settled) return; settled = true; hcmRemoveDialog();

-            hcmRequestHostSyncWithRetry();

-        };

-        const solo = () => { if (settled) return; settled = true; hcmRemoveDialog(); hcmEnterDesync(); };

-        stayBtn.addEventListener('click', stay);

-        soloBtn.addEventListener('click', solo);

-        // EC-18: if the user ignores the prompt, default to staying in sync.

-        hcmDialogTimer = setTimeout(() => { if (!settled) stay(); }, 8000);

-    }

-

-    function hcmEnterDesync() {

-        hcmDesynced = true;

-        reportLog('Host-only: you chose to watch on your own (desynced)', 'warn');

-        // Notify background so it can relay our desynced state to the host via

-        // heartbeats — the host's UI then knows we're not following commands

-        // instead of appearing silently un-ACK'd.

+        };
+        poll();
+    }
+
+    // Entry point: background told us our local action was blocked in host-only.
+    function hcmHandleBlocked(action, target) {
+        // HOST_BLOCKED is only ever sent to a gated guest (background verifies
+        // host-only + !host before sending), so it's authoritative. Adopt the
+        // role/mode from it in case our CONTROL_MODE broadcast hasn't landed yet
+        // (join race, EC-5) — otherwise we'd miss the dialog/snap-back.
+        hcmControlMode = 'host-only';
+        hcmAmController = false;
+        if (hcmDesynced) return; // already solo, nothing to do
+
+        const intent = hcmClassifyIntent();
+        if (intent === 'live') return;          // EC-15: leave the guest alone on live
+        if (intent === 'involuntary') {
+            // EC-4 loop guard: only the silent auto snap-back is suppressed by the
+            // cooldown — the deliberate dialog path below must still go through,
+            // otherwise a second deliberate pause inside the cooldown window leaves
+            // the user stuck paused with no UI (M-3).
+            if (Date.now() < hcmSnapBackCooldownUntil || hcmDeferredSnapPending) return;
+            // Buffering/ads/throttle — silently re-sync, no dialog spam.
+            const video = findVideo();
+            if (video && video.readyState >= 3 && !video.seeking) {
+                // Ready now → snap immediately. Use the captured target if it's
+                // usable, otherwise re-query+retry (host state may not be known yet)
+                // so we never leave the guest silently stuck (consistent with the
+                // deferred and "Stay in sync" paths).
+                if (target && Number.isFinite(target.targetTime)) hcmSnapBackToHost(target);
+                else hcmRequestHostSyncWithRetry();
+            } else {
+                hcmDeferredSnapBack();             // buffering → wait for ready, then snap once (#3)
+            }
+            return;
+        }
+        // Deliberate: offer the choice (Teleparty-style), default = snap back.
+        hcmShowDesyncDialog(action, target);
+    }
+
+    // --- In-page UI (dialog + persistent desync badge) ---
+    // Built with the DOM API (CSSOM .style is CSP-safe; inline style="" in innerHTML
+    // is stripped by strict style-src on Netflix/YouTube/Disney+). Hosted in a
+    // Shadow DOM so the page's CSS can't restyle or hide our controls.
+    let hcmDialogHost = null;  // shadow host element for the dialog
+    let hcmBadgeHost = null;   // shadow host element for the persistent badge
+    let hcmBadgePending = false;  // retry flag for early-injection badge creation (L-4)
+
+    function hcmEl(tag, css, text) {
+        const el = document.createElement(tag);
+        if (css) el.style.cssText = css;        // CSSOM assignment — not gated by CSP
+        if (text != null) el.textContent = text;
+        return el;
+    }
+
+    function hcmRemoveDialog() {
+        // Cancel any pending auto-stay timer so a replaced dialog's stale closure
+        // can't later remove its successor / snap to an outdated target (H-4).
+        if (hcmDialogTimer) { clearTimeout(hcmDialogTimer); hcmDialogTimer = null; }
+        if (hcmDialogHost) { hcmDialogHost.remove(); hcmDialogHost = null; }
+    }
+
+    function hcmShowDesyncDialog(action, target) {
+        if (!document.body) { hcmSnapBackToHost(target); return; }
+        hcmRemoveDialog();
+        const host = hcmEl('div', 'all:initial');
+        const root = host.attachShadow({ mode: 'open' });
+
+        const wrap = hcmEl('div', 'position:fixed;z-index:2147483647;left:50%;bottom:32px;transform:translateX(-50%);background:#212a17;color:#f4f2ea;font:14px/1.4 system-ui,sans-serif;padding:16px 18px;border-radius:12px;box-shadow:0 8px 30px rgba(0,0,0,.45);max-width:360px;border:1px solid #2f3625');
+        wrap.setAttribute('role', 'dialog');
+        const title = hcmEl('div', 'font-weight:600;margin-bottom:6px', hcmStrings.title);
+        const body = hcmEl('div', 'margin-bottom:12px;color:#bcb7a9', hcmStrings.body);
+        const btnRow = hcmEl('div', 'display:flex;gap:8px;justify-content:flex-end');
+        const soloBtn = hcmEl('button', 'background:#2f3625;color:#f4f2ea;border:0;padding:8px 12px;border-radius:8px;cursor:pointer', hcmStrings.solo);
+        const stayBtn = hcmEl('button', 'background:#56ae6c;color:#0a1a0d;border:0;padding:8px 12px;border-radius:8px;cursor:pointer;font-weight:600', hcmStrings.stay);
+        btnRow.append(soloBtn, stayBtn);
+        wrap.append(title, body, btnRow);
+        root.appendChild(wrap);
+        document.body.appendChild(host);
+        hcmDialogHost = host;
+
+        let settled = false;
+        // Re-query the host's current position on click instead of using the
+        // potentially stale target captured at HOST_BLOCKED time (M-1).
+        const stay = () => {
+            if (settled) return; settled = true; hcmRemoveDialog();
+            hcmRequestHostSyncWithRetry();
+        };
+        const solo = () => { if (settled) return; settled = true; hcmRemoveDialog(); hcmEnterDesync(); };
+        stayBtn.addEventListener('click', stay);
+        soloBtn.addEventListener('click', solo);
+        // EC-18: if the user ignores the prompt, default to staying in sync.
+        hcmDialogTimer = setTimeout(() => { if (!settled) stay(); }, 8000);
+    }
+
+    function hcmEnterDesync() {
+        hcmDesynced = true;
+        reportLog('Host-only: you chose to watch on your own (desynced)', 'warn');
+        // Notify background so it can relay our desynced state to the host via
+        // heartbeats — the host's UI then knows we're not following commands
+        // instead of appearing silently un-ACK'd.
         runtimeMessage({ type: 'HCM_DESYNC_STATE', desynced: true }).catch(() => {});
-        hcmShowBadge();

-    }

-

-    function hcmExitDesync() {

-        const wasDesynced = hcmDesynced;

-        hcmDesynced = false;

-        hcmRemoveBadge();

-        if (wasDesynced) {

+        hcmShowBadge();
+    }
+
+    function hcmExitDesync() {
+        const wasDesynced = hcmDesynced;
+        hcmDesynced = false;
+        hcmRemoveBadge();
+        if (wasDesynced) {
             runtimeMessage({ type: 'HCM_DESYNC_STATE', desynced: false }).catch(() => {});
-        }

-        // Resync to the host's current position (retries if host state not yet known).

-        hcmRequestHostSyncWithRetry();

-        reportLog('Host-only: resynced with the host', 'info');

-    }

-

-    function hcmShowBadge() {

-        if (hcmBadgeHost) return;

-        if (!document.body) {

-            // Body not ready yet (very early injection). Defer until DOMReady,

-            // otherwise the desynced user silently never sees the badge (L-4).

-            if (!hcmBadgePending) {

-                hcmBadgePending = true;

+        }
+        // Resync to the host's current position (retries if host state not yet known).
+        hcmRequestHostSyncWithRetry();
+        reportLog('Host-only: resynced with the host', 'info');
+    }
+
+    function hcmShowBadge() {
+        if (hcmBadgeHost) return;
+        if (!document.body) {
+            // Body not ready yet (very early injection). Defer until DOMReady,
+            // otherwise the desynced user silently never sees the badge (L-4).
+            if (!hcmBadgePending) {
+                hcmBadgePending = true;
                 const retry = () => {
                     hcmBadgeDomReadyHandler = null;
                     hcmBadgePending = false;
@@ -555,80 +555,80 @@
                 if (document.readyState === 'loading') {
                     hcmBadgeDomReadyHandler = retry;
                     document.addEventListener('DOMContentLoaded', retry, { once: true });
-                } else {

+                } else {
                     scheduleLifecycleTimeout(retry, 50);
-                }

-            }

-            return;

-        }

-        const host = hcmEl('div', 'all:initial');

-        const root = host.attachShadow({ mode: 'open' });

-        const b = hcmEl('div', 'position:fixed;z-index:2147483646;right:16px;bottom:16px;background:#c96736;color:#fff;font:13px/1.3 system-ui,sans-serif;padding:8px 12px;border-radius:10px;box-shadow:0 6px 20px rgba(0,0,0,.4);cursor:pointer;display:flex;align-items:center;gap:8px');

-        b.append(hcmEl('span', null, '● ' + hcmStrings.badge), hcmEl('span', 'text-decoration:underline', hcmStrings.resync));

-        b.addEventListener('click', hcmExitDesync);

-        root.appendChild(b);

-        document.body.appendChild(host);

-        hcmBadgeHost = host;

-    }

-

-    function hcmRemoveBadge() {

-        if (hcmBadgeHost) { hcmBadgeHost.remove(); hcmBadgeHost = null; }

-    }

-

-    function hcmReset() {

-        const wasDesynced = hcmDesynced;

-        hcmDesynced = false;

-        hcmDeferredSnapPending = false;

-        hcmSnapBackCooldownUntil = 0; // don't let a stale cooldown swallow the next snap-back

-        hcmBufferingUntil = 0;

-        hcmRemoveDialog();

-        hcmRemoveBadge();

-        // If we were desynced, notify background so it stops reporting us as

-        // desynced in heartbeats (otherwise the host's UI keeps showing the

-        // stale Solo badge until the next state change).

-        if (wasDesynced) {

+                }
+            }
+            return;
+        }
+        const host = hcmEl('div', 'all:initial');
+        const root = host.attachShadow({ mode: 'open' });
+        const b = hcmEl('div', 'position:fixed;z-index:2147483646;right:16px;bottom:16px;background:#c96736;color:#fff;font:13px/1.3 system-ui,sans-serif;padding:8px 12px;border-radius:10px;box-shadow:0 6px 20px rgba(0,0,0,.4);cursor:pointer;display:flex;align-items:center;gap:8px');
+        b.append(hcmEl('span', null, '● ' + hcmStrings.badge), hcmEl('span', 'text-decoration:underline', hcmStrings.resync));
+        b.addEventListener('click', hcmExitDesync);
+        root.appendChild(b);
+        document.body.appendChild(host);
+        hcmBadgeHost = host;
+    }
+
+    function hcmRemoveBadge() {
+        if (hcmBadgeHost) { hcmBadgeHost.remove(); hcmBadgeHost = null; }
+    }
+
+    function hcmReset() {
+        const wasDesynced = hcmDesynced;
+        hcmDesynced = false;
+        hcmDeferredSnapPending = false;
+        hcmSnapBackCooldownUntil = 0; // don't let a stale cooldown swallow the next snap-back
+        hcmBufferingUntil = 0;
+        hcmRemoveDialog();
+        hcmRemoveBadge();
+        // If we were desynced, notify background so it stops reporting us as
+        // desynced in heartbeats (otherwise the host's UI keeps showing the
+        // stale Solo badge until the next state change).
+        if (wasDesynced) {
             runtimeMessage({ type: 'HCM_DESYNC_STATE', desynced: false }).catch(() => {});
-        }

-    }

-

-    function reportLog(message, level = 'info') {

+        }
+    }
+
+    function reportLog(message, level = 'info') {
         runtimeMessage({ type: 'LOG', message, level }).catch(() => {});
-    }

-

-    // --- Helper: find the best video element on the page ---

-    // Ranks candidates by a fixed order of signals rather than a weighted sum,

-    // so a disqualifying trait (no source, not rendered) can never be outvoted

-    // by sheer size. See pickBestVideo for the order and the reasoning.

-    function findVideo(root = document, depth = 0) {

-        return pickBestVideo(collectVideoCandidates(root, depth));

-    }

-

-    function collectVideoCandidates(root = document, depth = 0, out = []) {

-        for (const video of root.querySelectorAll('video')) out.push(video);

-

-        // Scan likely media hosts even when light-DOM videos exist; many players

-        // expose a tiny preview/ad video outside Shadow DOM and the real player inside.

-        const potentialHosts = root.querySelectorAll('[id*="player" i], [class*="player" i], [id*="video" i], [class*="video" i], [id*="media" i], [class*="media" i], [id*="stream" i], [class*="stream" i], ytd-player, netflix-player, emby-player, jellyfin-player, video-player');

-        for (const el of potentialHosts) {

-            if (el.shadowRoot) collectVideoCandidates(el.shadowRoot, depth, out);

-        }

-

-        // Same-origin player frames (jkanime.net and similar) keep the real

-        // <video> inside a first-party iframe, so the top document has none.

-        // Cross-origin frames throw on contentDocument (or return null) and are

-        // unreachable from here, so they are skipped.

-        if (depth < 3) {

-            for (const frame of root.querySelectorAll('iframe, frame')) {

-                let frameDoc = null;

-                try { frameDoc = frame.contentDocument; } catch (_e) { frameDoc = null; }

-                if (!frameDoc || typeof frameDoc.querySelectorAll !== 'function') continue;

-                collectVideoCandidates(frameDoc, depth + 1, out);

-            }

-        }

-

-        return out;

-    }

-

+    }
+
+    // --- Helper: find the best video element on the page ---
+    // Ranks candidates by a fixed order of signals rather than a weighted sum,
+    // so a disqualifying trait (no source, not rendered) can never be outvoted
+    // by sheer size. See pickBestVideo for the order and the reasoning.
+    function findVideo(root = document, depth = 0) {
+        return pickBestVideo(collectVideoCandidates(root, depth));
+    }
+
+    function collectVideoCandidates(root = document, depth = 0, out = []) {
+        for (const video of root.querySelectorAll('video')) out.push(video);
+
+        // Scan likely media hosts even when light-DOM videos exist; many players
+        // expose a tiny preview/ad video outside Shadow DOM and the real player inside.
+        const potentialHosts = root.querySelectorAll('[id*="player" i], [class*="player" i], [id*="video" i], [class*="video" i], [id*="media" i], [class*="media" i], [id*="stream" i], [class*="stream" i], ytd-player, netflix-player, emby-player, jellyfin-player, video-player');
+        for (const el of potentialHosts) {
+            if (el.shadowRoot) collectVideoCandidates(el.shadowRoot, depth, out);
+        }
+
+        // Same-origin player frames (jkanime.net and similar) keep the real
+        // <video> inside a first-party iframe, so the top document has none.
+        // Cross-origin frames throw on contentDocument (or return null) and are
+        // unreachable from here, so they are skipped.
+        if (depth < 3) {
+            for (const frame of root.querySelectorAll('iframe, frame')) {
+                let frameDoc = null;
+                try { frameDoc = frame.contentDocument; } catch (_e) { frameDoc = null; }
+                if (!frameDoc || typeof frameDoc.querySelectorAll !== 'function') continue;
+                collectVideoCandidates(frameDoc, depth + 1, out);
+            }
+        }
+
+        return out;
+    }
+
     function getElementRenderBox(element) {
         try {
             if (typeof element.getBoundingClientRect === 'function') {
@@ -708,13 +708,13 @@
         const rect = getElementRenderBox(video);
         return rect.width * rect.height;
     }
-

-    // Coarse size steps, so two players of roughly the same size tie and the

-    // playback signal decides between them instead of a few stray pixels.

-    function getVideoSizeBucket(video) {

-        return Math.round(Math.sqrt(getRenderedVideoArea(video)) / 40);

-    }

-

+
+    // Coarse size steps, so two players of roughly the same size tie and the
+    // playback signal decides between them instead of a few stray pixels.
+    function getVideoSizeBucket(video) {
+        return Math.round(Math.sqrt(getRenderedVideoArea(video)) / 40);
+    }
+
     function isVideoRendered(video) {
         if (!isElementRendered(video)) return false;
         // Same-origin videos may be discovered recursively from the top frame.
@@ -728,20 +728,20 @@
             view = frame.ownerDocument?.defaultView;
         }
         return true;
-    }

-

-    function hasPlayableVideoSource(video) {

-        if (video.currentSrc || video.src || video.srcObject) return true;

-        // <source> children count before the browser has committed to one.

-        return typeof video.querySelector === 'function' && !!video.querySelector('source[src]');

-    }

-

-    // Marketing hero pattern: silent, endlessly looping, no controls. Often the

-    // largest video on the page and never the one two people sit down to watch.

-    function isBackgroundVideo(video) {

-        return !!video.loop && !!video.muted && !video.controls;

-    }

-

+    }
+
+    function hasPlayableVideoSource(video) {
+        if (video.currentSrc || video.src || video.srcObject) return true;
+        // <source> children count before the browser has committed to one.
+        return typeof video.querySelector === 'function' && !!video.querySelector('source[src]');
+    }
+
+    // Marketing hero pattern: silent, endlessly looping, no controls. Often the
+    // largest video on the page and never the one two people sit down to watch.
+    function isBackgroundVideo(video) {
+        return !!video.loop && !!video.muted && !video.controls;
+    }
+
     function isVideoPlaying(video) {
         return video.paused === false && video.ended !== true;
     }
@@ -753,11 +753,11 @@
             && video.duration > 0
             && video.duration < 300;
     }
-

-    // Highest priority first. Every signal is a plain number and they are

-    // compared one after another, so an earlier signal is never traded off

-    // against a later one. Mute state is intentionally absent: it is a viewer

-    // preference, not evidence about which element is the real player.

+
+    // Highest priority first. Every signal is a plain number and they are
+    // compared one after another, so an earlier signal is never traded off
+    // against a later one. Mute state is intentionally absent: it is a viewer
+    // preference, not evidence about which element is the real player.
     const VIDEO_RANKING_SIGNALS = [
         video => (hasPlayableVideoSource(video) ? 1 : 0),
         video => (isVideoRendered(video) ? 1 : 0),
@@ -768,31 +768,31 @@
         video => Number.isInteger(video.readyState) ? video.readyState : 0,
         video => (video.duration && isFinite(video.duration) ? video.duration : 0),
         video => getVideoSizeBucket(video)
-    ];

-

-    function compareVideoRanks(a, b) {

-        for (let i = 0; i < a.length; i++) {

-            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;

-        }

-        return 0;

-    }

-

-    // Ranking, not filtering: even an all-bad candidate set still yields the

-    // least bad element, so this never returns null where a video exists.

+    ];
+
+    function compareVideoRanks(a, b) {
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
+        }
+        return 0;
+    }
+
+    // Ranking, not filtering: even an all-bad candidate set still yields the
+    // least bad element, so this never returns null where a video exists.
     function pickBestVideo(candidates) {
-        let best = null;

-        let bestRank = null;

-        for (const video of candidates) {

+        let best = null;
+        let bestRank = null;
+        for (const video of candidates) {
             if (!video || video.tagName !== 'VIDEO' || !isVideoRendered(video)) continue;
-            const rank = VIDEO_RANKING_SIGNALS.map(signal => signal(video));

-            if (!best || compareVideoRanks(rank, bestRank) > 0) {

-                best = video;

-                bestRank = rank;

-            }

-        }

-        return best;

-    }

-

+            const rank = VIDEO_RANKING_SIGNALS.map(signal => signal(video));
+            if (!best || compareVideoRanks(rank, bestRank) > 0) {
+                best = video;
+                bestRank = rank;
+            }
+        }
+        return best;
+    }
+
     // Every document we can touch from here: this one plus same-origin frames.
     function collectSameOriginDocuments(doc = document, depth = 0, out = []) {
         out.push(doc);
@@ -806,24 +806,24 @@
         return out;
     }
 
-    // --- Audio Processing Module ---

-    const AUDIO_PRESETS = {

-        recommended: { threshold: -24, ratio: 8, attack: 0.010, release: 0.300, knee: 15 },

-        dynamicRange: { threshold: -18, ratio: 4, attack: 0.020, release: 0.200, knee: 10 },

-        vocalEnhancement: { threshold: -12, ratio: 3, attack: 0.015, release: 0.150, knee: 5 },

-        smooth: { threshold: -30, ratio: 1.5, attack: 0.030, release: 0.250, knee: 20 },

-        custom: { threshold: -24, ratio: 12, attack: 0.003, release: 0.250, knee: 30 }

-    };

+    // --- Audio Processing Module ---
+    const AUDIO_PRESETS = {
+        recommended: { threshold: -24, ratio: 8, attack: 0.010, release: 0.300, knee: 15 },
+        dynamicRange: { threshold: -18, ratio: 4, attack: 0.020, release: 0.200, knee: 10 },
+        vocalEnhancement: { threshold: -12, ratio: 3, attack: 0.015, release: 0.150, knee: 5 },
+        smooth: { threshold: -30, ratio: 1.5, attack: 0.030, release: 0.250, knee: 20 },
+        custom: { threshold: -24, ratio: 12, attack: 0.003, release: 0.250, knee: 30 }
+    };
     const DEFAULT_AUDIO_SETTINGS = {
         enabled: false,
         boostDb: 0,
         compressor: {
-            enabled: false,

-            preset: 'recommended',

-            customParams: { ...AUDIO_PRESETS.custom }

-        }

-    };

-    let audioCtx = null;

+            enabled: false,
+            preset: 'recommended',
+            customParams: { ...AUDIO_PRESETS.custom }
+        }
+    };
+    let audioCtx = null;
     let audioChains = new WeakMap();
     let currentAudioVideo = null;
 
@@ -832,41 +832,41 @@
         if (!Number.isFinite(parsed)) return DEFAULT_AUDIO_SETTINGS.boostDb;
         return Math.min(20, Math.max(0, Math.round(parsed * 2) / 2));
     }
-

-    function mergeAudioSettings(settings = {}) {

-        const safeSettings = settings && typeof settings === 'object' ? settings : {};

+
+    function mergeAudioSettings(settings = {}) {
+        const safeSettings = settings && typeof settings === 'object' ? settings : {};
         return {
             ...DEFAULT_AUDIO_SETTINGS,
             ...safeSettings,
             boostDb: normalizeBoostDb(safeSettings.boostDb),
             compressor: {
-                ...DEFAULT_AUDIO_SETTINGS.compressor,

-                ...(safeSettings.compressor || {}),

-                customParams: {

-                    ...DEFAULT_AUDIO_SETTINGS.compressor.customParams,

-                    ...(safeSettings.compressor?.customParams || {})

-                }

-            }

-        };

-    }

-

-    function initAudioContext() {

-        if (!audioCtx) {

-            try {

-                const AudioContextClass = window.AudioContext || window.webkitAudioContext;

-                if (!AudioContextClass) return null;

-                audioCtx = new AudioContextClass({ latencyHint: 'interactive' });

-            } catch (e) {

-                reportLog(`Audio Processing unavailable: ${e.message}`, 'warn');

-                return null;

-            }

-        }

-        if (audioCtx.state === 'suspended') {

-            audioCtx.resume().catch(() => { reportLog('AudioContext resume failed - browser may need page interaction first', 'warn'); });

-        }

-        return audioCtx;

-    }

-

+                ...DEFAULT_AUDIO_SETTINGS.compressor,
+                ...(safeSettings.compressor || {}),
+                customParams: {
+                    ...DEFAULT_AUDIO_SETTINGS.compressor.customParams,
+                    ...(safeSettings.compressor?.customParams || {})
+                }
+            }
+        };
+    }
+
+    function initAudioContext() {
+        if (!audioCtx) {
+            try {
+                const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+                if (!AudioContextClass) return null;
+                audioCtx = new AudioContextClass({ latencyHint: 'interactive' });
+            } catch (e) {
+                reportLog(`Audio Processing unavailable: ${e.message}`, 'warn');
+                return null;
+            }
+        }
+        if (audioCtx.state === 'suspended') {
+            audioCtx.resume().catch(() => { reportLog('AudioContext resume failed - browser may need page interaction first', 'warn'); });
+        }
+        return audioCtx;
+    }
+
     function closeAudioContext() {
         const closingContext = audioCtx;
         if (audioCtx) {
@@ -879,9 +879,13 @@
         audioChains = new WeakMap();
         currentAudioVideo = null;
     }
-

+
     function setupAudioChain(videoEl) {
         if (audioChains.has(videoEl)) return audioChains.get(videoEl);
+        // createMediaElementSource() can only ever be called once per element,
+        // so a re-injected content script must adopt the route the previous
+        // instance built. Rebuilding it would throw and leave the video silent
+        // for the rest of the page's life.
         const retainedRoute = window.__koalaSyncAudioRoute;
         if (retainedRoute?.video === videoEl && retainedRoute.audioCtx && retainedRoute.chain) {
             audioCtx = retainedRoute.audioCtx;
@@ -891,8 +895,8 @@
         }
         const ctx = initAudioContext();
         if (!ctx) return null;
-

-        try {

+
+        try {
             const src = ctx.createMediaElementSource(videoEl);
             const compressor = ctx.createDynamicsCompressor();
             const dryGain = ctx.createGain();
@@ -921,23 +925,23 @@
             audioChains.set(videoEl, chain);
             currentAudioVideo = videoEl;
             window.__koalaSyncAudioRoute = { video: videoEl, audioCtx: ctx, chain };
-            return chain;

-        } catch (e) {

-            reportLog(`Audio Processing setup failed: ${e.message}`, 'warn');

-            return null;

-        }

-    }

-

-    function rampGain(node, value, t) {

-        const current = node.gain.value;

-        node.gain.cancelScheduledValues(t);

-        node.gain.setValueAtTime(current, t);

-        node.gain.linearRampToValueAtTime(value, t + 0.04);

-    }

-

-    function applyAudioBypass(videoEl) {

-        const chain = audioChains.get(videoEl);

-        if (!chain || !chain.active) return;

+            return chain;
+        } catch (e) {
+            reportLog(`Audio Processing setup failed: ${e.message}`, 'warn');
+            return null;
+        }
+    }
+
+    function rampGain(node, value, t) {
+        const current = node.gain.value;
+        node.gain.cancelScheduledValues(t);
+        node.gain.setValueAtTime(current, t);
+        node.gain.linearRampToValueAtTime(value, t + 0.04);
+    }
+
+    function applyAudioBypass(videoEl) {
+        const chain = audioChains.get(videoEl);
+        if (!chain || !chain.active) return;
         const t = chain.dryGain.context.currentTime;
         rampGain(chain.dryGain, 1, t);
         rampGain(chain.compGain, 0, t);
@@ -946,12 +950,12 @@
         chain.active = false;
         chain.signature = '';
         reportLog('Audio processing disabled', 'info');
-    }

-

-    function bypassCurrentAudioProcessing() {

-        if (currentAudioVideo) applyAudioBypass(currentAudioVideo);

-    }

-

+    }
+
+    function bypassCurrentAudioProcessing() {
+        if (currentAudioVideo) applyAudioBypass(currentAudioVideo);
+    }
+
     function applyAudioSettings(videoEl, settings) {
         const mergedSettings = mergeAudioSettings(settings);
         const compressorEnabled = mergedSettings.compressor?.enabled === true;
@@ -960,10 +964,10 @@
             applyAudioBypass(videoEl);
             return;
         }
-

-        const chain = setupAudioChain(videoEl);

-        if (!chain) return;

-

+
+        const chain = setupAudioChain(videoEl);
+        if (!chain) return;
+
         if (compressorEnabled) {
             const cSettings = mergedSettings.compressor;
             const params = cSettings.preset === 'custom'
@@ -991,224 +995,224 @@
         chain.signature = signature;
         chain.active = true;
     }
-

-    // --- Episode Auto-Sync: Detection ---

-    function getMediaTitle() {

-        return (navigator.mediaSession && navigator.mediaSession.metadata)

-            ? navigator.mediaSession.metadata.title

-            : null;

-    }

-

-    // Extract a canonical episode identifier from a title string.

-    // Handles: S01E01, S1E1, S01 - E01, Season 1 Episode 1, "Folge 5", "Episode 5", "Ep. 5", "#5"

-    // Returns null if no episode pattern found.

-    // --- SHARED_EPISODE_UTILS_INJECT_START ---

+
+    // --- Episode Auto-Sync: Detection ---
+    function getMediaTitle() {
+        return (navigator.mediaSession && navigator.mediaSession.metadata)
+            ? navigator.mediaSession.metadata.title
+            : null;
+    }
+
+    // Extract a canonical episode identifier from a title string.
+    // Handles: S01E01, S1E1, S01 - E01, Season 1 Episode 1, "Folge 5", "Episode 5", "Ep. 5", "#5"
+    // Returns null if no episode pattern found.
+    // --- SHARED_EPISODE_UTILS_INJECT_START ---
     // This block is automatically replaced by /scripts/build-extension.cjs
-    function extractEpisodeId(title) {

-        if (!title || typeof title !== 'string') return null;

-        const se = title.match(/S(?:eason\s*)?(\d+)[^a-zA-Z0-9]*E(?:pisode\s*)?(\d+)/i);

-        if (se) return `S${String(se[1]).padStart(2, '0')}E${String(se[2]).padStart(2, '0')}`;

-        const ep = title.match(/(?:Episode|Folge|Ep\.?|#)\s*(\d+)/i);

-        if (ep) return `EP${String(ep[1]).padStart(3, '0')}`;

-        return null;

-    }

-

-    function sameEpisode(titleA, titleB) {

-        if (!titleA && !titleB) return true;

-        if (!titleA || !titleB) return false;

-        const idA = extractEpisodeId(titleA);

-        const idB = extractEpisodeId(titleB);

-        if (idA && idB) return idA === idB;

-        if (idA || idB) return false;

-        return titleA === titleB;

-    }

-    // --- SHARED_EPISODE_UTILS_INJECT_END ---

-

-    // Returns true only when we are CERTAIN the episodes differ.

-    // Permissive: only blocks if BOTH titles have parseable IDs AND they differ.

-    // Films, music, unparseable titles always pass through.

-    function isDifferentEpisode(titleA, titleB) {

-        if (!titleA || !titleB) return false; // Unknown → allow

-        const idA = extractEpisodeId(titleA);

-        const idB = extractEpisodeId(titleB);

-        if (!idA || !idB) return false; // At least one unparseable → allow

-        return idA !== idB;             // Both parseable → only block if different

-    }

-    function checkEpisodeTransition() {
-
-        const currentTitle = getMediaTitle();
-
-        const video = findVideo();
-
+    function extractEpisodeId(title) {
+        if (!title || typeof title !== 'string') return null;
+        const se = title.match(/S(?:eason\s*)?(\d+)[^a-zA-Z0-9]*E(?:pisode\s*)?(\d+)/i);
+        if (se) return `S${String(se[1]).padStart(2, '0')}E${String(se[2]).padStart(2, '0')}`;
+        const ep = title.match(/(?:Episode|Folge|Ep\.?|#)\s*(\d+)/i);
+        if (ep) return `EP${String(ep[1]).padStart(3, '0')}`;
+        return null;
+    }
+
+    function sameEpisode(titleA, titleB) {
+        if (!titleA && !titleB) return true;
+        if (!titleA || !titleB) return false;
+        const idA = extractEpisodeId(titleA);
+        const idB = extractEpisodeId(titleB);
+        if (idA && idB) return idA === idB;
+        if (idA || idB) return false;
+        return titleA === titleB;
+    }
+    // --- SHARED_EPISODE_UTILS_INJECT_END ---
+
+    // Returns true only when we are CERTAIN the episodes differ.
+    // Permissive: only blocks if BOTH titles have parseable IDs AND they differ.
+    // Films, music, unparseable titles always pass through.
+    function isDifferentEpisode(titleA, titleB) {
+        if (!titleA || !titleB) return false; // Unknown → allow
+        const idA = extractEpisodeId(titleA);
+        const idB = extractEpisodeId(titleB);
+        if (!idA || !idB) return false; // At least one unparseable → allow
+        return idA !== idB;             // Both parseable → only block if different
+    }
+    function checkEpisodeTransition() {
+
+        const currentTitle = getMediaTitle();
+
+        const video = findVideo();
+
         const current = video ? getSyncCurrentTime(video) : null;
-        // Only trigger if: we had a previous title, the title changed,

-        // a video exists, and we're near the start of new content.

-        if (lastKnownMediaTitle && currentTitle

+        // Only trigger if: we had a previous title, the title changed,
+        // a video exists, and we're near the start of new content.
+        if (lastKnownMediaTitle && currentTitle
             && !sameEpisode(currentTitle, lastKnownMediaTitle)
-            && extractEpisodeId(currentTitle) !== null

-            && video

-            && current !== null && current < 5

-            && video.readyState >= 1) {

-            onEpisodeTransition(currentTitle);

-        }

-

-        // Always track the latest known title

-        if (currentTitle) lastKnownMediaTitle = currentTitle;

-    }

-

-    function onEpisodeTransition(newTitle) {

-        // Debounce: prevent duplicate fires from multiple signals

-        if (episodeTransitionDebounce) return;

-        episodeTransitionDebounce = setTimeout(() => {

-            episodeTransitionDebounce = null;

-        }, 2000);

-

-        reportLog(`Episode transition detected: "${newTitle}"`, 'info');

-

-        // EC-12: a new episode dissolves any solo/desync state — the guest rejoins

-        // the room for the fresh content rather than staying stuck on the old one.

-        if (hcmDesynced) hcmReset();

-

-        // Do NOT pause here. We notify background.js first.

-        // Background checks the setting; if enabled it creates a lobby

-        // and sends back PAUSE_FOR_LOBBY so we only freeze if the feature is on.

+            && extractEpisodeId(currentTitle) !== null
+            && video
+            && current !== null && current < 5
+            && video.readyState >= 1) {
+            onEpisodeTransition(currentTitle);
+        }
+
+        // Always track the latest known title
+        if (currentTitle) lastKnownMediaTitle = currentTitle;
+    }
+
+    function onEpisodeTransition(newTitle) {
+        // Debounce: prevent duplicate fires from multiple signals
+        if (episodeTransitionDebounce) return;
+        episodeTransitionDebounce = setTimeout(() => {
+            episodeTransitionDebounce = null;
+        }, 2000);
+
+        reportLog(`Episode transition detected: "${newTitle}"`, 'info');
+
+        // EC-12: a new episode dissolves any solo/desync state — the guest rejoins
+        // the room for the fresh content rather than staying stuck on the old one.
+        if (hcmDesynced) hcmReset();
+
+        // Do NOT pause here. We notify background.js first.
+        // Background checks the setting; if enabled it creates a lobby
+        // and sends back PAUSE_FOR_LOBBY so we only freeze if the feature is on.
         runtimeMessage({
-            type: 'EPISODE_CHANGED',

-            payload: { newTitle }

-        }).catch(() => {});

-    }

-    function checkAndReportLobbyReady(expectedTitle) {
-
-        const video = findVideo();
-
-        const currentTitle = getMediaTitle();
-
+            type: 'EPISODE_CHANGED',
+            payload: { newTitle }
+        }).catch(() => {});
+    }
+    function checkAndReportLobbyReady(expectedTitle) {
+
+        const video = findVideo();
+
+        const currentTitle = getMediaTitle();
+
         const current = video ? getSyncCurrentTime(video) : null;
-        if (video && currentTitle && sameEpisode(currentTitle, expectedTitle)

-            && current !== null && video.readyState >= 1) {

+        if (video && currentTitle && sameEpisode(currentTitle, expectedTitle)
+            && current !== null && video.readyState >= 1) {
             if (current >= 5) {
                 expectedSeekTime = 0;
                 video.currentTime = 0;
             }
-            // Match! Pause at start and report ready.

-            if (!video.paused) {

-                _setSuppress('paused');

-                video.pause();

-            }

-            stopLobbyPoll();

+            // Match! Pause at start and report ready.
+            if (!video.paused) {
+                _setSuppress('paused');
+                video.pause();
+            }
+            stopLobbyPoll();
             runtimeMessage({
-                type: 'EPISODE_READY_LOCAL',

-                payload: { title: currentTitle }

-            }).catch(() => {});

-            reportLog(`Episode lobby: Ready for "${currentTitle}"`, 'success');

-            return true;

-        }

-        return false;

-    }

-

-    function startLobbyPoll(expectedTitle) {

-        stopLobbyPoll();

-        _pendingLobbyTitle = expectedTitle;

-

-        // NOTE: Do NOT pause here. Three callers reach this function:

-        // 1. PAUSE_FOR_LOBBY (initiator): already paused by that handler before calling us.

-        // 2. EPISODE_LOBBY (non-initiator): peer may still be on the PREVIOUS episode — pausing

-        //    would freeze them mid-episode. The pause happens inside checkAndReportLobbyReady()

-        //    only once their title actually matches.

-        // 3. CONTENT_BOOT recovery: same reasoning as (2).

-

-        // Check immediately

-        if (checkAndReportLobbyReady(expectedTitle)) return;

-

-        // Poll every 2 seconds — no log spam, internal only

-        lobbyPollTimer = setInterval(() => {

-            checkAndReportLobbyReady(expectedTitle);

-        }, 2000);

-    }

-

-

-    function stopLobbyPoll() {

-        _pendingLobbyTitle = null;

-        if (lobbyPollTimer) {

-            clearInterval(lobbyPollTimer);

-            lobbyPollTimer = null;

-        }

-    }

-

-    function getPlayerActionFixes() {
-        return [
-            {
-                name: 'youtube-player-buttons',
-                urls: ['youtube.com'],
-                playPauseButtonSelector: '.ytp-play-button'
-            },
-            {
-                name: 'twitch-player-buttons',
-                urls: ['twitch.tv'],
-                playPauseButtonSelector: '[data-a-target="player-play-pause-button"]'
-            }
-        ];
-    }
-
-    function getActivePlayerActionFix() {
-        return getPlayerActionFixes().find(fix => matchesPlayerUrls(fix.urls)) || null;
-    }
-
-    function tryPlayerActionFix(fix, action, video, data) {
-        if (!fix) return false;
-        const button = document.querySelector(fix.playPauseButtonSelector);
-        if (!button) return false;
-
-        const isCurrentlyPlaying = !video.paused;
-        if ((action === EVENTS.PLAY && !isCurrentlyPlaying) || (action === EVENTS.PAUSE && isCurrentlyPlaying)) {
-            _setSuppress(action === EVENTS.PLAY ? 'playing' : 'paused');
-            button.click();
-        }
-        if (action === EVENTS.SEEK) {
-            seekVideo(video, data.targetTime, data.delta);
-        }
-        return true;
-    }
-
-    // --- Helper: site-specific player actions, then native HTML5 fallback ---
-    function tryMediaAction(action, data) {
-        const video = findVideo();
-        if (!video) return;
-

-        if (action === EVENTS.SEEK) {

-            const target = data ? (data.targetTime !== undefined ? data.targetTime : data.currentTime) : undefined;

-            if (!Number.isFinite(target)) {

-                reportLog(`Media Action Error: Invalid seek payload - ${JSON.stringify(data)}`, 'error');

-                return;

-            }

-            data = { ...data, targetTime: target };

-        }

-
-        try {
-            const actionFix = getActivePlayerActionFix();
-            if (tryPlayerActionFix(actionFix, action, video, data)) {
-                return;
-            }
-
-            // Fallback for native HTML5
-            if (action === EVENTS.PLAY) {

-                _setSuppress('playing');

-                video.play().catch((e) => {

-                    reportLog(`Playback prevented: ${e.message}`, 'warn');

-                    _clearSuppress('playing');

-                });

-            } else if (action === EVENTS.PAUSE) {

-                _setSuppress('paused');

-                video.pause();

-            } else if (action === EVENTS.SEEK) {
-                seekVideo(video, data.targetTime, data.delta);
-            }

-    } catch (e) {

-            reportLog(`Media Action Error: ${e.message}`, 'error');

-        }

-    }

-

-    // --- Helper: Wait until video is ready for playback (buffered & seeked) ---

+                type: 'EPISODE_READY_LOCAL',
+                payload: { title: currentTitle }
+            }).catch(() => {});
+            reportLog(`Episode lobby: Ready for "${currentTitle}"`, 'success');
+            return true;
+        }
+        return false;
+    }
+
+    function startLobbyPoll(expectedTitle) {
+        stopLobbyPoll();
+        _pendingLobbyTitle = expectedTitle;
+
+        // NOTE: Do NOT pause here. Three callers reach this function:
+        // 1. PAUSE_FOR_LOBBY (initiator): already paused by that handler before calling us.
+        // 2. EPISODE_LOBBY (non-initiator): peer may still be on the PREVIOUS episode — pausing
+        //    would freeze them mid-episode. The pause happens inside checkAndReportLobbyReady()
+        //    only once their title actually matches.
+        // 3. CONTENT_BOOT recovery: same reasoning as (2).
+
+        // Check immediately
+        if (checkAndReportLobbyReady(expectedTitle)) return;
+
+        // Poll every 2 seconds — no log spam, internal only
+        lobbyPollTimer = setInterval(() => {
+            checkAndReportLobbyReady(expectedTitle);
+        }, 2000);
+    }
+
+
+    function stopLobbyPoll() {
+        _pendingLobbyTitle = null;
+        if (lobbyPollTimer) {
+            clearInterval(lobbyPollTimer);
+            lobbyPollTimer = null;
+        }
+    }
+
+    function getPlayerActionFixes() {
+        return [
+            {
+                name: 'youtube-player-buttons',
+                urls: ['youtube.com'],
+                playPauseButtonSelector: '.ytp-play-button'
+            },
+            {
+                name: 'twitch-player-buttons',
+                urls: ['twitch.tv'],
+                playPauseButtonSelector: '[data-a-target="player-play-pause-button"]'
+            }
+        ];
+    }
+
+    function getActivePlayerActionFix() {
+        return getPlayerActionFixes().find(fix => matchesPlayerUrls(fix.urls)) || null;
+    }
+
+    function tryPlayerActionFix(fix, action, video, data) {
+        if (!fix) return false;
+        const button = document.querySelector(fix.playPauseButtonSelector);
+        if (!button) return false;
+
+        const isCurrentlyPlaying = !video.paused;
+        if ((action === EVENTS.PLAY && !isCurrentlyPlaying) || (action === EVENTS.PAUSE && isCurrentlyPlaying)) {
+            _setSuppress(action === EVENTS.PLAY ? 'playing' : 'paused');
+            button.click();
+        }
+        if (action === EVENTS.SEEK) {
+            seekVideo(video, data.targetTime, data.delta);
+        }
+        return true;
+    }
+
+    // --- Helper: site-specific player actions, then native HTML5 fallback ---
+    function tryMediaAction(action, data) {
+        const video = findVideo();
+        if (!video) return;
+
+        if (action === EVENTS.SEEK) {
+            const target = data ? (data.targetTime !== undefined ? data.targetTime : data.currentTime) : undefined;
+            if (!Number.isFinite(target)) {
+                reportLog(`Media Action Error: Invalid seek payload - ${JSON.stringify(data)}`, 'error');
+                return;
+            }
+            data = { ...data, targetTime: target };
+        }
+
+        try {
+            const actionFix = getActivePlayerActionFix();
+            if (tryPlayerActionFix(actionFix, action, video, data)) {
+                return;
+            }
+
+            // Fallback for native HTML5
+            if (action === EVENTS.PLAY) {
+                _setSuppress('playing');
+                video.play().catch((e) => {
+                    reportLog(`Playback prevented: ${e.message}`, 'warn');
+                    _clearSuppress('playing');
+                });
+            } else if (action === EVENTS.PAUSE) {
+                _setSuppress('paused');
+                video.pause();
+            } else if (action === EVENTS.SEEK) {
+                seekVideo(video, data.targetTime, data.delta);
+            }
+    } catch (e) {
+            reportLog(`Media Action Error: ${e.message}`, 'error');
+        }
+    }
+
+    // --- Helper: Wait until video is ready for playback (buffered & seeked) ---
     function pollSeekReady(targetTime, timeoutMs = 8000) {
         return new Promise((resolve) => {
             const interval = 150;
@@ -1226,12 +1230,12 @@
                     seekPollTimers.delete(timer);
                     resolve(false);
                     return;
-                }

-

-                elapsed += interval;

-                const current = getSyncCurrentTime(video);
-                const timeDiff = current !== null ? Math.abs(current - targetTime) : Infinity;
-                const ready = video.readyState >= 3 && timeDiff < 2.0;
+                }
+
+                elapsed += interval;
+                const current = getSyncCurrentTime(video);
+                const timeDiff = current !== null ? Math.abs(current - targetTime) : Infinity;
+                const ready = video.readyState >= 3 && timeDiff < 2.0;
                 if (ready) {
                     clearInterval(timer);
                     seekPollTimers.delete(timer);
@@ -1245,8 +1249,8 @@
             seekPollTimers.add(timer);
         });
     }
-

-    // Listen for commands from background.js

+
+    // Listen for commands from background.js
     function handleRuntimeMessage(message, sender, sendResponse) {
         if (!message) return;
         if (message.type === 'TARGET_DEACTIVATE') {
@@ -1260,442 +1264,442 @@
             sendResponse({ currentTime: video ? getSyncCurrentTime(video) : null });
             return true;
         }
-

-        if (message.action === 'APPLY_AUDIO_SETTINGS') {

-            _audioProcessingAllowed = true;

-            _audioSettings = mergeAudioSettings(message.settings);

-            const video = findVideo();

-            if (video) applyAudioSettings(video, _audioSettings);

-            sendResponse({ ok: true });

-            return true;

-        }

-

-        if (message.action === 'RESET_AUDIO_PROCESSING') {

-            _audioProcessingAllowed = false;

-            bypassCurrentAudioProcessing();

-            sendResponse({ ok: true });

-            return true;

-        }

-

-        // Host Control Mode: room mode/role changed.

-        if (message.type === 'CONTROL_MODE') {

-            const wasGated = hcmIsGuestGated();

-            const prevHostPeerId = hcmHostPeerId;

-            hcmControlMode = message.controlMode || 'everyone';

-            hcmAmController = !!message.amController;

-            hcmHostPeerId = message.hostPeerId || null;

-            // Reset guest-side state when leaving the gated state, OR when the

-            // host identity changes (room switch, host-leave fallback, missed

-            // teardown broadcast) — clears stale desync so a rejoin starts clean (H-3).

-            const hostChanged = prevHostPeerId !== null && hcmHostPeerId !== prevHostPeerId;

-            if ((wasGated && !hcmIsGuestGated()) || hostChanged) hcmReset();

-            sendResponse({ ok: true });

-            return true;

-        }

-

-        // Host Control Mode: background blocked our local action — handle UX locally.

-        if (message.type === 'HOST_BLOCKED') {

-            hcmHandleBlocked(message.action, message.target || null);

-            sendResponse({ ok: true });

-            return true;

-        }

-

-        // Background asks for an immediate state push (e.g. the first peer just

-        // joined while we were solo) so the newcomer syncs without waiting.

-        if (message.type === 'REQUEST_HEARTBEAT') {

-            sendHeartbeat();

-            sendResponse({ ok: true });

-            return true;

-        }

-

-        if (message.type === 'SERVER_COMMAND') {

-            const { action, payload } = message;

-            let actionCompleted = false;

-

-            // Host Control Mode: while watching on our own (desynced), don't apply

-            // host commands. Only ACK FORCE_SYNC_PREPARE — that's the one the host's

-            // force-sync flow actually waits on. Skipping CMD_ACKs for PLAY/PAUSE/SEEK

-            // is intentional so the host's UI honestly reflects that we didn't apply

-            // the command (M-2); sending them would make the host think we're synced.

-            if (hcmDesynced) {

-                const soloIgnored = [EVENTS.PLAY, EVENTS.PAUSE, EVENTS.SEEK, EVENTS.FORCE_SYNC_PREPARE, EVENTS.FORCE_SYNC_EXECUTE];

-                if (soloIgnored.includes(action)) {

-                    if (action === EVENTS.FORCE_SYNC_PREPARE) {

+
+        if (message.action === 'APPLY_AUDIO_SETTINGS') {
+            _audioProcessingAllowed = true;
+            _audioSettings = mergeAudioSettings(message.settings);
+            const video = findVideo();
+            if (video) applyAudioSettings(video, _audioSettings);
+            sendResponse({ ok: true });
+            return true;
+        }
+
+        if (message.action === 'RESET_AUDIO_PROCESSING') {
+            _audioProcessingAllowed = false;
+            bypassCurrentAudioProcessing();
+            sendResponse({ ok: true });
+            return true;
+        }
+
+        // Host Control Mode: room mode/role changed.
+        if (message.type === 'CONTROL_MODE') {
+            const wasGated = hcmIsGuestGated();
+            const prevHostPeerId = hcmHostPeerId;
+            hcmControlMode = message.controlMode || 'everyone';
+            hcmAmController = !!message.amController;
+            hcmHostPeerId = message.hostPeerId || null;
+            // Reset guest-side state when leaving the gated state, OR when the
+            // host identity changes (room switch, host-leave fallback, missed
+            // teardown broadcast) — clears stale desync so a rejoin starts clean (H-3).
+            const hostChanged = prevHostPeerId !== null && hcmHostPeerId !== prevHostPeerId;
+            if ((wasGated && !hcmIsGuestGated()) || hostChanged) hcmReset();
+            sendResponse({ ok: true });
+            return true;
+        }
+
+        // Host Control Mode: background blocked our local action — handle UX locally.
+        if (message.type === 'HOST_BLOCKED') {
+            hcmHandleBlocked(message.action, message.target || null);
+            sendResponse({ ok: true });
+            return true;
+        }
+
+        // Background asks for an immediate state push (e.g. the first peer just
+        // joined while we were solo) so the newcomer syncs without waiting.
+        if (message.type === 'REQUEST_HEARTBEAT') {
+            sendHeartbeat();
+            sendResponse({ ok: true });
+            return true;
+        }
+
+        if (message.type === 'SERVER_COMMAND') {
+            const { action, payload } = message;
+            let actionCompleted = false;
+
+            // Host Control Mode: while watching on our own (desynced), don't apply
+            // host commands. Only ACK FORCE_SYNC_PREPARE — that's the one the host's
+            // force-sync flow actually waits on. Skipping CMD_ACKs for PLAY/PAUSE/SEEK
+            // is intentional so the host's UI honestly reflects that we didn't apply
+            // the command (M-2); sending them would make the host think we're synced.
+            if (hcmDesynced) {
+                const soloIgnored = [EVENTS.PLAY, EVENTS.PAUSE, EVENTS.SEEK, EVENTS.FORCE_SYNC_PREPARE, EVENTS.FORCE_SYNC_EXECUTE];
+                if (soloIgnored.includes(action)) {
+                    if (action === EVENTS.FORCE_SYNC_PREPARE) {
                         runtimeMessage({ type: 'FORCE_SYNC_ACK' }).catch(() => {});
-                    }

-                    return;

-                }

-            }

-

-            // Guard: Don't execute sync commands if peers are on different episodes.

-            // Only active when autoSyncNextEpisode setting is enabled (default: on).

-            // Only blocks when BOTH sides have parseable S01E01-style IDs that differ.

-            // Films and unparseable titles always pass through.

-            const syncActions = [EVENTS.PLAY, EVENTS.PAUSE, EVENTS.SEEK,

-                                 EVENTS.FORCE_SYNC_PREPARE, EVENTS.FORCE_SYNC_EXECUTE];

-            if (_autoSyncEnabled && syncActions.includes(action)) {

-                const senderTitle = payload?.mediaTitle;

-                const myTitle = getMediaTitle();

-                if (isDifferentEpisode(senderTitle, myTitle)) {

-                    reportLog(`Episode mismatch: sender="${senderTitle || '?'}" vs mine="${myTitle || '?'}" — skipping ${action}. Disable "Auto-Sync next Episode" in settings if this causes issues.`, 'warn');

-                    if (action !== EVENTS.FORCE_SYNC_PREPARE && action !== EVENTS.FORCE_SYNC_EXECUTE) {

+                    }
+                    return;
+                }
+            }
+
+            // Guard: Don't execute sync commands if peers are on different episodes.
+            // Only active when autoSyncNextEpisode setting is enabled (default: on).
+            // Only blocks when BOTH sides have parseable S01E01-style IDs that differ.
+            // Films and unparseable titles always pass through.
+            const syncActions = [EVENTS.PLAY, EVENTS.PAUSE, EVENTS.SEEK,
+                                 EVENTS.FORCE_SYNC_PREPARE, EVENTS.FORCE_SYNC_EXECUTE];
+            if (_autoSyncEnabled && syncActions.includes(action)) {
+                const senderTitle = payload?.mediaTitle;
+                const myTitle = getMediaTitle();
+                if (isDifferentEpisode(senderTitle, myTitle)) {
+                    reportLog(`Episode mismatch: sender="${senderTitle || '?'}" vs mine="${myTitle || '?'}" — skipping ${action}. Disable "Auto-Sync next Episode" in settings if this causes issues.`, 'warn');
+                    if (action !== EVENTS.FORCE_SYNC_PREPARE && action !== EVENTS.FORCE_SYNC_EXECUTE) {
                         runtimeMessage({ type: 'CMD_ACK', actionTimestamp: message.actionTimestamp, commandSenderId: message.commandSenderId }).catch(() => {});
-                    }

-                    return;

-                }

-            }

-            

-            if (action === EVENTS.PLAY) {

-                tryMediaAction(EVENTS.PLAY);

+                    }
+                    return;
+                }
+            }
+            
+            if (action === EVENTS.PLAY) {
+                tryMediaAction(EVENTS.PLAY);
                 runtimeMessage({ type: 'CMD_ACK', actionTimestamp: message.actionTimestamp, commandSenderId: message.commandSenderId });
-                actionCompleted = true;

-            } else if (action === EVENTS.PAUSE) {

-                tryMediaAction(EVENTS.PAUSE);

+                actionCompleted = true;
+            } else if (action === EVENTS.PAUSE) {
+                tryMediaAction(EVENTS.PAUSE);
                 runtimeMessage({ type: 'CMD_ACK', actionTimestamp: message.actionTimestamp, commandSenderId: message.commandSenderId });
-                actionCompleted = true;

-            } else if (action === EVENTS.SEEK) {

-                tryMediaAction(EVENTS.SEEK, payload);

+                actionCompleted = true;
+            } else if (action === EVENTS.SEEK) {
+                tryMediaAction(EVENTS.SEEK, payload);
                 runtimeMessage({ type: 'CMD_ACK', actionTimestamp: message.actionTimestamp, commandSenderId: message.commandSenderId });
-                actionCompleted = true;

-            } else if (action === EVENTS.FORCE_SYNC_PREPARE) {

-                if (!payload || payload.targetTime === undefined) return;

-                const video = findVideo();

-                if (video) {

-                    if (!Number.isFinite(payload.targetTime)) {

-                        reportLog(`Media Action Error: Invalid force sync payload - ${JSON.stringify(payload)}`, 'error');

-                        return;

-                    }

-                    _setSuppress('paused');

-                    video.pause();

-                    try {

-                        seekVideo(video, payload.targetTime);

-                    } catch (e) {

-                        reportLog(`Force Sync Seek Error: ${e.message}`, 'error');

-                    }

-                    pollSeekReady(payload.targetTime).then((ready) => {

+                actionCompleted = true;
+            } else if (action === EVENTS.FORCE_SYNC_PREPARE) {
+                if (!payload || payload.targetTime === undefined) return;
+                const video = findVideo();
+                if (video) {
+                    if (!Number.isFinite(payload.targetTime)) {
+                        reportLog(`Media Action Error: Invalid force sync payload - ${JSON.stringify(payload)}`, 'error');
+                        return;
+                    }
+                    _setSuppress('paused');
+                    video.pause();
+                    try {
+                        seekVideo(video, payload.targetTime);
+                    } catch (e) {
+                        reportLog(`Force Sync Seek Error: ${e.message}`, 'error');
+                    }
+                    pollSeekReady(payload.targetTime).then((ready) => {
                         runtimeMessage({ type: 'FORCE_SYNC_ACK' }).catch(() => {});
-                        if (ready) {

-                            scheduleProactiveHeartbeat();

-                        } else {

-                            reportLog('Force Sync: Seek ready timeout, proceeding anyway', 'warn');

-                        }

-                    }).catch(() => {});

-                }

-            } else if (action === EVENTS.FORCE_SYNC_EXECUTE) {

-                stopLobbyPoll();

-                tryMediaAction(EVENTS.PLAY);

+                        if (ready) {
+                            scheduleProactiveHeartbeat();
+                        } else {
+                            reportLog('Force Sync: Seek ready timeout, proceeding anyway', 'warn');
+                        }
+                    }).catch(() => {});
+                }
+            } else if (action === EVENTS.FORCE_SYNC_EXECUTE) {
+                stopLobbyPoll();
+                tryMediaAction(EVENTS.PLAY);
                 runtimeMessage({ type: 'CMD_ACK', actionTimestamp: message.actionTimestamp, commandSenderId: message.commandSenderId });
-                actionCompleted = true;

-            }

-

-            if (actionCompleted) {

-                scheduleProactiveHeartbeat();

-            }

-        }

-

-        // Episode Auto-Sync: Lobby notification from background

-        if (message.type === 'EPISODE_LOBBY') {

-            // Host Control Mode: a desynced guest is watching on their own and must

-            // not join the lobby flow. Otherwise they'd pause on title match, report

-            // ready, but then ignore the host's FORCE_SYNC_* (hcmDesynced skip in

-            // SERVER_COMMAND) and end up frozen in pause. They also can't be counted

-            // toward lobby completion (background filters them out).

-            if (hcmDesynced) {

-                sendResponse({ status: 'ignored_desynced' });

-                return true;

-            }

-            const expectedTitle = message.expectedTitle;

-            if (expectedTitle) {

-                reportLog(`Episode lobby received: waiting for "${expectedTitle}"`, 'info');

-                startLobbyPoll(expectedTitle);

-            }

-            sendResponse({ status: 'ok' });

-            return true;

-        }

-

-        // Episode Auto-Sync: Lobby cancelled by background

-        if (message.type === 'EPISODE_LOBBY_CANCEL') {

-            stopLobbyPoll();

-            sendResponse({ status: 'ok' });

-            return true;

-        }

-

-        // Episode Auto-Sync: Background confirmed lobby created, pause the video

-        if (message.type === 'PAUSE_FOR_LOBBY') {

-            const video = findVideo();

-            if (video && !video.paused) {

-                _setSuppress('paused');

-                video.pause();

-            }

-            // Start lobby poll now that we know the feature is enabled

-            if (message.expectedTitle) {

-                startLobbyPoll(message.expectedTitle);

-            }

-            sendResponse({ status: 'ok' });

-            return true;

-        }

-

-        if (message.type === 'GET_VIDEO_STATE') {

-            const video = findVideo();

-

-            const platform = (() => {

-                const h = window.location.hostname.toLowerCase();

+                actionCompleted = true;
+            }
+
+            if (actionCompleted) {
+                scheduleProactiveHeartbeat();
+            }
+        }
+
+        // Episode Auto-Sync: Lobby notification from background
+        if (message.type === 'EPISODE_LOBBY') {
+            // Host Control Mode: a desynced guest is watching on their own and must
+            // not join the lobby flow. Otherwise they'd pause on title match, report
+            // ready, but then ignore the host's FORCE_SYNC_* (hcmDesynced skip in
+            // SERVER_COMMAND) and end up frozen in pause. They also can't be counted
+            // toward lobby completion (background filters them out).
+            if (hcmDesynced) {
+                sendResponse({ status: 'ignored_desynced' });
+                return true;
+            }
+            const expectedTitle = message.expectedTitle;
+            if (expectedTitle) {
+                reportLog(`Episode lobby received: waiting for "${expectedTitle}"`, 'info');
+                startLobbyPoll(expectedTitle);
+            }
+            sendResponse({ status: 'ok' });
+            return true;
+        }
+
+        // Episode Auto-Sync: Lobby cancelled by background
+        if (message.type === 'EPISODE_LOBBY_CANCEL') {
+            stopLobbyPoll();
+            sendResponse({ status: 'ok' });
+            return true;
+        }
+
+        // Episode Auto-Sync: Background confirmed lobby created, pause the video
+        if (message.type === 'PAUSE_FOR_LOBBY') {
+            const video = findVideo();
+            if (video && !video.paused) {
+                _setSuppress('paused');
+                video.pause();
+            }
+            // Start lobby poll now that we know the feature is enabled
+            if (message.expectedTitle) {
+                startLobbyPoll(message.expectedTitle);
+            }
+            sendResponse({ status: 'ok' });
+            return true;
+        }
+
+        if (message.type === 'GET_VIDEO_STATE') {
+            const video = findVideo();
+
+            const platform = (() => {
+                const h = window.location.hostname.toLowerCase();
                 if (h === 'youtube.com' || h.endsWith('.youtube.com')) return 'YouTube';
                 if (h === 'youtube.googleapis.com'
                     && (new URLSearchParams(window.location.search).get('origin') === 'https://drive.google.com'
                         || new URLSearchParams(window.location.search).get('post_message_origin') === 'https://drive.google.com')) return 'Google Drive';
-                if (h === 'twitch.tv' || h.endsWith('.twitch.tv')) return 'Twitch';

-                if (h === 'netflix.com' || h.endsWith('.netflix.com')) return 'Netflix';

-                if (h === 'primevideo.com' || h.endsWith('.primevideo.com') || /(^|\.)amazon\.(com\.[a-z]{2}|co\.[a-z]{2}|[a-z]{2,})$/.test(h)) return 'Prime Video';

-                if (h === 'disneyplus.com' || h.endsWith('.disneyplus.com')) return 'Disney+';

-                if (h === 'hulu.com' || h.endsWith('.hulu.com')) return 'Hulu';

-                if (h === 'hbomax.com' || h.endsWith('.hbomax.com') || h === 'max.com' || h.endsWith('.max.com')) return 'Max/HBO';

-                if (h === 'vimeo.com' || h.endsWith('.vimeo.com')) return 'Vimeo';

-                if (h === 'dailymotion.com' || h.endsWith('.dailymotion.com')) return 'Dailymotion';

-                return 'Generic';

-            })();

-

-            const networkStates = ['NETWORK_EMPTY', 'NETWORK_IDLE', 'NETWORK_LOADING', 'NETWORK_NO_SOURCE'];

-            const readyStates = ['HAVE_NOTHING', 'HAVE_METADATA', 'HAVE_CURRENT_DATA', 'HAVE_FUTURE_DATA', 'HAVE_ENOUGH_DATA'];

-

+                if (h === 'twitch.tv' || h.endsWith('.twitch.tv')) return 'Twitch';
+                if (h === 'netflix.com' || h.endsWith('.netflix.com')) return 'Netflix';
+                if (h === 'primevideo.com' || h.endsWith('.primevideo.com') || /(^|\.)amazon\.(com\.[a-z]{2}|co\.[a-z]{2}|[a-z]{2,})$/.test(h)) return 'Prime Video';
+                if (h === 'disneyplus.com' || h.endsWith('.disneyplus.com')) return 'Disney+';
+                if (h === 'hulu.com' || h.endsWith('.hulu.com')) return 'Hulu';
+                if (h === 'hbomax.com' || h.endsWith('.hbomax.com') || h === 'max.com' || h.endsWith('.max.com')) return 'Max/HBO';
+                if (h === 'vimeo.com' || h.endsWith('.vimeo.com')) return 'Vimeo';
+                if (h === 'dailymotion.com' || h.endsWith('.dailymotion.com')) return 'Dailymotion';
+                return 'Generic';
+            })();
+
+            const networkStates = ['NETWORK_EMPTY', 'NETWORK_IDLE', 'NETWORK_LOADING', 'NETWORK_NO_SOURCE'];
+            const readyStates = ['HAVE_NOTHING', 'HAVE_METADATA', 'HAVE_CURRENT_DATA', 'HAVE_FUTURE_DATA', 'HAVE_ENOUGH_DATA'];
+
             // The exact set findVideo ranked, so the report explains the pick
             // instead of describing a different population.
-            const reachableVideos = collectVideoCandidates();

-            const videoCount = reachableVideos.length;

-            const inIframe = !!video && video.ownerDocument !== document;

-            const inShadowDom = (() => {

-                let el = video;

-                while (el) {

-                    if (el.toString() === '[object ShadowRoot]') return true;

-                    el = el.parentNode;

-                }

-                // Also check if any potential host has shadow root (even if no video found)

-                if (!video) {

-                    const hosts = document.querySelectorAll('[id*="player" i], [class*="player" i], [id*="video" i], [class*="video" i]');

-                    for (const host of hosts) {

-                        if (host.shadowRoot) return true;

-                    }

-                }

-                return false;

-            })();

-

-            // Build multi-video summary for debug reports

-            const allVideos = [];

-            const allVideoEls = reachableVideos;

-            for (let i = 0; i < allVideoEls.length; i++) {

-                const v = allVideoEls[i];

-                allVideos.push({

-                    index: i,

-                    width: v.videoWidth || v.offsetWidth || 0,

-                    height: v.videoHeight || v.offsetHeight || 0,

-                    muted: v.muted,

-                    paused: v.paused,

-                    duration: (v.duration && isFinite(v.duration)) ? Math.round(v.duration) : 0,

-                    readyState: v.readyState,

-                    src: (v.currentSrc || v.src || '').substring(0, 80),

-                    selected: v === video

-                });

-            }

-

-            if (video) {

-                const dataAttributes = {};

-                if (video.attributes) {

-                    for (const attr of video.attributes) {

-                        if (attr.name.startsWith('data-')) {

-                            dataAttributes[attr.name] = attr.value;

-                        }

-                    }

-                }

-

-                const metadata = (navigator.mediaSession && navigator.mediaSession.metadata) ? {

-                    title: navigator.mediaSession.metadata.title,

-                    artist: navigator.mediaSession.metadata.artist,

-                    album: navigator.mediaSession.metadata.album,

-                    artwork: Array.from(navigator.mediaSession.metadata.artwork || []).map(a => a.src)

-                } : null;

-

-                const errorInfo = video.error ? {

-                    code: video.error.code,

-                    message: video.error.message

-                } : null;

-

-                sendResponse({

-                    found: true,

-                    paused: video.paused,

-                    currentTime: getSyncCurrentTime(video),
-                    duration: getSyncDuration(video),
-                    nativeCurrentTime: video.currentTime,
-                    nativeDuration: Number.isFinite(video.duration) ? video.duration : 0,
-                    readyState: video.readyState,

-                    readyStateLabel: readyStates[video.readyState] || 'UNKNOWN',

-                    networkState: video.networkState,

-                    networkStateLabel: networkStates[video.networkState] || 'UNKNOWN',

-                    muted: video.muted,

-                    volume: video.volume,

-                    playbackRate: video.playbackRate,

-                    videoWidth: video.videoWidth,

-                    videoHeight: video.videoHeight,

-                    seeking: video.seeking,

-                    ended: video.ended,

-                    error: errorInfo,

-                    buffered: video.buffered && video.buffered.length > 0

-                        ? Array.from({ length: video.buffered.length }, (_, i) =>

-                            `${video.buffered.start(i).toFixed(1)}-${video.buffered.end(i).toFixed(1)}s`).join(', ')

-                        : 'none',

-                    loop: video.loop,

-                    url: window.location.href,

-                    pageTitle: document.title,

-                    id: video.id || 'none',

-                    className: video.className || 'none',

-                    src: video.src || 'none',

-                    currentSrc: video.currentSrc || 'none',

-                    dataAttributes,

-                    metadata,

-                    videoCount,

-                    inShadowDom,

+            const reachableVideos = collectVideoCandidates();
+            const videoCount = reachableVideos.length;
+            const inIframe = !!video && video.ownerDocument !== document;
+            const inShadowDom = (() => {
+                let el = video;
+                while (el) {
+                    if (el.toString() === '[object ShadowRoot]') return true;
+                    el = el.parentNode;
+                }
+                // Also check if any potential host has shadow root (even if no video found)
+                if (!video) {
+                    const hosts = document.querySelectorAll('[id*="player" i], [class*="player" i], [id*="video" i], [class*="video" i]');
+                    for (const host of hosts) {
+                        if (host.shadowRoot) return true;
+                    }
+                }
+                return false;
+            })();
+
+            // Build multi-video summary for debug reports
+            const allVideos = [];
+            const allVideoEls = reachableVideos;
+            for (let i = 0; i < allVideoEls.length; i++) {
+                const v = allVideoEls[i];
+                allVideos.push({
+                    index: i,
+                    width: v.videoWidth || v.offsetWidth || 0,
+                    height: v.videoHeight || v.offsetHeight || 0,
+                    muted: v.muted,
+                    paused: v.paused,
+                    duration: (v.duration && isFinite(v.duration)) ? Math.round(v.duration) : 0,
+                    readyState: v.readyState,
+                    src: (v.currentSrc || v.src || '').substring(0, 80),
+                    selected: v === video
+                });
+            }
+
+            if (video) {
+                const dataAttributes = {};
+                if (video.attributes) {
+                    for (const attr of video.attributes) {
+                        if (attr.name.startsWith('data-')) {
+                            dataAttributes[attr.name] = attr.value;
+                        }
+                    }
+                }
+
+                const metadata = (navigator.mediaSession && navigator.mediaSession.metadata) ? {
+                    title: navigator.mediaSession.metadata.title,
+                    artist: navigator.mediaSession.metadata.artist,
+                    album: navigator.mediaSession.metadata.album,
+                    artwork: Array.from(navigator.mediaSession.metadata.artwork || []).map(a => a.src)
+                } : null;
+
+                const errorInfo = video.error ? {
+                    code: video.error.code,
+                    message: video.error.message
+                } : null;
+
+                sendResponse({
+                    found: true,
+                    paused: video.paused,
+                    currentTime: getSyncCurrentTime(video),
+                    duration: getSyncDuration(video),
+                    nativeCurrentTime: video.currentTime,
+                    nativeDuration: Number.isFinite(video.duration) ? video.duration : 0,
+                    readyState: video.readyState,
+                    readyStateLabel: readyStates[video.readyState] || 'UNKNOWN',
+                    networkState: video.networkState,
+                    networkStateLabel: networkStates[video.networkState] || 'UNKNOWN',
+                    muted: video.muted,
+                    volume: video.volume,
+                    playbackRate: video.playbackRate,
+                    videoWidth: video.videoWidth,
+                    videoHeight: video.videoHeight,
+                    seeking: video.seeking,
+                    ended: video.ended,
+                    error: errorInfo,
+                    buffered: video.buffered && video.buffered.length > 0
+                        ? Array.from({ length: video.buffered.length }, (_, i) =>
+                            `${video.buffered.start(i).toFixed(1)}-${video.buffered.end(i).toFixed(1)}s`).join(', ')
+                        : 'none',
+                    loop: video.loop,
+                    url: window.location.href,
+                    pageTitle: document.title,
+                    id: video.id || 'none',
+                    className: video.className || 'none',
+                    src: video.src || 'none',
+                    currentSrc: video.currentSrc || 'none',
+                    dataAttributes,
+                    metadata,
+                    videoCount,
+                    inShadowDom,
                     inIframe,
                     platform,
                     siteQuirk: getSiteQuirkDebug(video),
                     allVideos
                 });
-            } else {

-                sendResponse({

-                    found: false,

-                    videoCount,

-                    inShadowDom,

-                    inIframe,

-                    platform,

-                    allVideos,

+            } else {
+                sendResponse({
+                    found: false,
+                    videoCount,
+                    inShadowDom,
+                    inIframe,
+                    platform,
+                    allVideos,
                     url: window.location.href,
                     pageTitle: document.title,
                     metadata: (navigator.mediaSession && navigator.mediaSession.metadata) ? {
-                        title: navigator.mediaSession.metadata.title,

-                        artist: navigator.mediaSession.metadata.artist,

-                        album: navigator.mediaSession.metadata.album

-                    } : null

-                });

-            }

-        }

+                        title: navigator.mediaSession.metadata.title,
+                        artist: navigator.mediaSession.metadata.artist,
+                        album: navigator.mediaSession.metadata.album
+                    } : null
+                });
+            }
+        }
     }
     chrome.runtime.onMessage.addListener(handleRuntimeMessage);
-

-    // Detect native events

-    // Build the relay payload from the *current* media state and send it to

-    // background.js. Re-reads the video each call so deferred (coalesced) emits

-    // carry an up-to-date position. Safe with no/invalid video — it no-ops.

+
+    // Detect native events
+    // Build the relay payload from the *current* media state and send it to
+    // background.js. Re-reads the video each call so deferred (coalesced) emits
+    // carry an up-to-date position. Safe with no/invalid video — it no-ops.
     function sendContentEvent(action, expectedVideo = null) {
         if (destroyed) return;
         const video = findVideo();
         if (!video || (expectedVideo && (video !== expectedVideo || activeVideo !== expectedVideo))) return;
-

-        const current = getSyncCurrentTime(video);
-        if (current === null) return;
-

-        const mediaTitle = (navigator.mediaSession && navigator.mediaSession.metadata) ? navigator.mediaSession.metadata.title : null;

-

+
+        const current = getSyncCurrentTime(video);
+        if (current === null) return;
+
+        const mediaTitle = (navigator.mediaSession && navigator.mediaSession.metadata) ? navigator.mediaSession.metadata.title : null;
+
         runtimeMessage({
-            type: 'CONTENT_EVENT',

-            action,

-            payload: {

-                currentTime: current,

-                targetTime: current,

-                mediaTitle: mediaTitle,

-                timestamp: Date.now()

-            }

-        }).catch(() => {});

-

-        // Trigger proactive heartbeat to push stabilized state

-        scheduleProactiveHeartbeat();

-    }

-

-    // Trailing-edge flush of a coalesced play/pause burst: emit the final settled

-    // state. No-ops only when no burst followed the leading edge. We do NOT skip

-    // when the state matches the leading send — a remote command may have changed

-    // the shared state mid-window, so re-sending is the safe (idempotent) choice.

-    function flushPlayPause() {

+            type: 'CONTENT_EVENT',
+            action,
+            payload: {
+                currentTime: current,
+                targetTime: current,
+                mediaTitle: mediaTitle,
+                timestamp: Date.now()
+            }
+        }).catch(() => {});
+
+        // Trigger proactive heartbeat to push stabilized state
+        scheduleProactiveHeartbeat();
+    }
+
+    // Trailing-edge flush of a coalesced play/pause burst: emit the final settled
+    // state. No-ops only when no burst followed the leading edge. We do NOT skip
+    // when the state matches the leading send — a remote command may have changed
+    // the shared state mid-window, so re-sending is the safe (idempotent) choice.
+    function flushPlayPause() {
         playPauseCoalesceTimer = null;
         const finalAction = pendingPlayPauseAction;
         const sourceVideo = pendingPlayPauseVideo;
         pendingPlayPauseAction = null;
         pendingPlayPauseVideo = null;
-        // No burst follow-up (only the leading edge fired), or invalid state.

-        if (finalAction !== EVENTS.PLAY && finalAction !== EVENTS.PAUSE) return;

+        // No burst follow-up (only the leading edge fired), or invalid state.
+        if (finalAction !== EVENTS.PLAY && finalAction !== EVENTS.PAUSE) return;
         sendContentEvent(finalAction, sourceVideo);
-    }

-

+    }
+
     function reportEvent(action) {
         if (destroyed) return;
         if (seekDebounceTimer && (action === EVENTS.PLAY || action === EVENTS.PAUSE)) {
-            clearTimeout(seekDebounceTimer);

-            seekDebounceTimer = null;

-            const v = findVideo();

-            if (v) {
-                const syncTime = getSyncCurrentTime(v);
-                if (syncTime === null) return;
-                lastReportedSeekTime = syncTime;
-                reportLog(`[Seek] Debounce flushed immediately due to ${action.toUpperCase()}`, 'info');
-                reportEvent(EVENTS.SEEK);
-            }
-        }

-

-        const video = findVideo();

-        if (!video) return;

-

-        const current = getSyncCurrentTime(video);
-        if (current === null) return;
-

-        const eventState = action === EVENTS.PLAY ? 'playing' : (action === EVENTS.PAUSE ? 'paused' : (action === EVENTS.SEEK ? 'seek' : null));

-

-        // Echo-suppression for remotely-applied commands. MUST stay synchronous

-        // on event arrival: the suppress timer is short-lived (300ms) and would

-        // expire if deferred, leaking an echo back to peers.

-        if (_suppressTimers[eventState]) {

-            _clearSuppress(eventState);

-            return;

-        }

-

-        // Suppress only SEEK during visibility grace period (tab re-focus ghost jump).

-        // Play/Pause pass through — user may want to immediately pause after tabbing back.

-        if (Date.now() < visibilityGraceUntil && action === EVENTS.SEEK) return;

-

-        // Coalesce play/pause bursts (source swaps, ABR, ads, teardown). The

-        // synchronous gates above have already run; only the network emit is

-        // governed here. Leading edge sends the first event instantly; further

-        // events within the window are collapsed to the final state by the

-        // trailing flush. A pending burst is REPLACED, never dropped — the last

-        // event in the window always wins.

-        if (action === EVENTS.PLAY || action === EVENTS.PAUSE) {

-            if (playPauseCoalesceTimer === null) {

-                // Window closed → fresh action. Emit now (zero added latency).

+            clearTimeout(seekDebounceTimer);
+            seekDebounceTimer = null;
+            const v = findVideo();
+            if (v) {
+                const syncTime = getSyncCurrentTime(v);
+                if (syncTime === null) return;
+                lastReportedSeekTime = syncTime;
+                reportLog(`[Seek] Debounce flushed immediately due to ${action.toUpperCase()}`, 'info');
+                reportEvent(EVENTS.SEEK);
+            }
+        }
+
+        const video = findVideo();
+        if (!video) return;
+
+        const current = getSyncCurrentTime(video);
+        if (current === null) return;
+
+        const eventState = action === EVENTS.PLAY ? 'playing' : (action === EVENTS.PAUSE ? 'paused' : (action === EVENTS.SEEK ? 'seek' : null));
+
+        // Echo-suppression for remotely-applied commands. MUST stay synchronous
+        // on event arrival: the suppress timer is short-lived (300ms) and would
+        // expire if deferred, leaking an echo back to peers.
+        if (_suppressTimers[eventState]) {
+            _clearSuppress(eventState);
+            return;
+        }
+
+        // Suppress only SEEK during visibility grace period (tab re-focus ghost jump).
+        // Play/Pause pass through — user may want to immediately pause after tabbing back.
+        if (Date.now() < visibilityGraceUntil && action === EVENTS.SEEK) return;
+
+        // Coalesce play/pause bursts (source swaps, ABR, ads, teardown). The
+        // synchronous gates above have already run; only the network emit is
+        // governed here. Leading edge sends the first event instantly; further
+        // events within the window are collapsed to the final state by the
+        // trailing flush. A pending burst is REPLACED, never dropped — the last
+        // event in the window always wins.
+        if (action === EVENTS.PLAY || action === EVENTS.PAUSE) {
+            if (playPauseCoalesceTimer === null) {
+                // Window closed → fresh action. Emit now (zero added latency).
                 sendContentEvent(action, video);
                 pendingPlayPauseAction = null;
                 pendingPlayPauseVideo = null;
             } else {
-                // Window open → part of a burst. Defer to the trailing flush.

+                // Window open → part of a burst. Defer to the trailing flush.
                 pendingPlayPauseAction = action;
                 pendingPlayPauseVideo = video;
                 clearTimeout(playPauseCoalesceTimer);
-            }

-            playPauseCoalesceTimer = setTimeout(flushPlayPause, PLAY_PAUSE_COALESCE_MS);

-            return;

-        }

-

-        // SEEK (and any non play/pause action): emit immediately.

-        sendContentEvent(action);

-    }

-

-    // --- Tab Visibility Handling ---

-    // Browsers (especially Firefox) aggressively throttle background tabs.

-    // When the user returns to a video tab, the video element may have lost

-    // time-sync and fires spurious seek events as it recovers (jumping back).

-    // We suppress only SEEK for a short grace period after tab re-focus.

-    // Play/Pause are NOT suppressed — the user may legitimately want to

-    // pause immediately after switching back.

+            }
+            playPauseCoalesceTimer = setTimeout(flushPlayPause, PLAY_PAUSE_COALESCE_MS);
+            return;
+        }
+
+        // SEEK (and any non play/pause action): emit immediately.
+        sendContentEvent(action);
+    }
+
+    // --- Tab Visibility Handling ---
+    // Browsers (especially Firefox) aggressively throttle background tabs.
+    // When the user returns to a video tab, the video element may have lost
+    // time-sync and fires spurious seek events as it recovers (jumping back).
+    // We suppress only SEEK for a short grace period after tab re-focus.
+    // Play/Pause are NOT suppressed — the user may legitimately want to
+    // pause immediately after switching back.
     let pageVisible = !document.hidden;
     let pageSuspended = false;
-    let visibilityGraceUntil = 0;

-    const VISIBILITY_GRACE_MS = 300;

-

+    let visibilityGraceUntil = 0;
+    const VISIBILITY_GRACE_MS = 300;
+
     function handleVisibilityChange() {
         if (destroyed) return;
         try {
@@ -1710,8 +1714,8 @@
         if (document.hidden) {
             pageVisible = false;
         } else if (!pageVisible) {
-            pageVisible = true;

-            visibilityGraceUntil = Date.now() + VISIBILITY_GRACE_MS;

+            pageVisible = true;
+            visibilityGraceUntil = Date.now() + VISIBILITY_GRACE_MS;
             reportLog(`Tab re-focused — suppressing seeks for ${VISIBILITY_GRACE_MS / 1000}s to prevent ghost relay`, 'warn');
         }
     }
@@ -1723,12 +1727,12 @@
         pageVisible = false;
         closeAudioContext();
         if (keepAlivePort) { try { keepAlivePort.disconnect(); } catch (_e) { /* ignore */ } keepAlivePort = null; }
-        if (lobbyPollTimer) { clearInterval(lobbyPollTimer); lobbyPollTimer = null; }

-        if (heartbeatTimeout) { clearTimeout(heartbeatTimeout); heartbeatTimeout = null; }

-        if (proactiveHeartbeatTimeout) { clearTimeout(proactiveHeartbeatTimeout); proactiveHeartbeatTimeout = null; }

-        // Drop any pending coalesced play/pause: we are tearing down and will

-        // disconnect — peers learn we are gone via PEER_STATUS 'left'. This also

-        // intentionally suppresses the teardown play/pause burst at the source.

+        if (lobbyPollTimer) { clearInterval(lobbyPollTimer); lobbyPollTimer = null; }
+        if (heartbeatTimeout) { clearTimeout(heartbeatTimeout); heartbeatTimeout = null; }
+        if (proactiveHeartbeatTimeout) { clearTimeout(proactiveHeartbeatTimeout); proactiveHeartbeatTimeout = null; }
+        // Drop any pending coalesced play/pause: we are tearing down and will
+        // disconnect — peers learn we are gone via PEER_STATUS 'left'. This also
+        // intentionally suppresses the teardown play/pause burst at the source.
         cancelPendingVideoEvents();
         observer.disconnect();
         observedDocs = new WeakSet();
@@ -1756,7 +1760,7 @@
     document.addEventListener('visibilitychange', handleVisibilityChange);
     window.addEventListener('pagehide', handlePageHide);
     window.addEventListener('pageshow', handlePageShow);
-

+
     function isCurrentVideoEvent(event) {
         const source = event?.currentTarget;
         return !!source && source === activeVideo && source === findVideo();
@@ -1768,66 +1772,66 @@
     const handlePause = event => {
         if (isCurrentVideoEvent(event)) reportEvent(EVENTS.PAUSE);
     };
-    // Host Control Mode: a 'waiting' (buffering) event opens a grace window so the

-    // pause it may trigger isn't misread as a deliberate guest action (EC-1).

+    // Host Control Mode: a 'waiting' (buffering) event opens a grace window so the
+    // pause it may trigger isn't misread as a deliberate guest action (EC-1).
     const handleWaiting = event => {
         if (isCurrentVideoEvent(event)) hcmBufferingUntil = Date.now() + HCM_BUFFERING_GRACE_MS;
     };
-

-    // Seek filtering: ignore HLS/DASH buffering micro-seeks.

-    // Only relay if delta >= MIN_SEEK_DELTA AND not already debouncing.

+
+    // Seek filtering: ignore HLS/DASH buffering micro-seeks.
+    // Only relay if delta >= MIN_SEEK_DELTA AND not already debouncing.
     const handleSeeked = event => {
         if (!isCurrentVideoEvent(event)) return;
         const video = event.currentTarget;
-        const current = getSyncCurrentTime(video);
-        if (current === null) return;
-

-        // Step 1: Check expectedSeekTime (programmatic seek from remote peer)

-        if (expectedSeekTime !== null) {

-            if (Math.abs(current - expectedSeekTime) < 1.0) {

-                // Video arrived at expected time. Safely clear and ignore.

-                expectedSeekTime = null;

-                lastReportedSeekTime = current;

-                return;

-            } else {

-                // User manually scrubbed to a DIFFERENT time while we were buffering

-                expectedSeekTime = null;

-            }

-        }

-

-        // Step 2: Suppress during visibility grace period (tab re-focus ghost events)

-        if (Date.now() < visibilityGraceUntil) return;

-

-        const delta = lastReportedSeekTime !== null ? Math.abs(current - lastReportedSeekTime) : null;

-        const deltaStr = delta !== null ? `Δ${delta.toFixed(2)}s` : 'Δ?';

-

-        // Step 3: Delta check — skip micro-seeks (buffering, chapter markers, etc.)

-        if (lastReportedSeekTime !== null && delta < MIN_SEEK_DELTA) {

-            reportLog(`[Seek] Filtered (${deltaStr} < ${MIN_SEEK_DELTA}s threshold) @ ${current.toFixed(2)}s — not relayed`, 'warn');

-            return;

-        }

-

-        // Step 4: Debounce rapid consecutive seeks (e.g. scrubbing)

-        // — wait 300ms for the user to settle before relaying

+        const current = getSyncCurrentTime(video);
+        if (current === null) return;
+
+        // Step 1: Check expectedSeekTime (programmatic seek from remote peer)
+        if (expectedSeekTime !== null) {
+            if (Math.abs(current - expectedSeekTime) < 1.0) {
+                // Video arrived at expected time. Safely clear and ignore.
+                expectedSeekTime = null;
+                lastReportedSeekTime = current;
+                return;
+            } else {
+                // User manually scrubbed to a DIFFERENT time while we were buffering
+                expectedSeekTime = null;
+            }
+        }
+
+        // Step 2: Suppress during visibility grace period (tab re-focus ghost events)
+        if (Date.now() < visibilityGraceUntil) return;
+
+        const delta = lastReportedSeekTime !== null ? Math.abs(current - lastReportedSeekTime) : null;
+        const deltaStr = delta !== null ? `Δ${delta.toFixed(2)}s` : 'Δ?';
+
+        // Step 3: Delta check — skip micro-seeks (buffering, chapter markers, etc.)
+        if (lastReportedSeekTime !== null && delta < MIN_SEEK_DELTA) {
+            reportLog(`[Seek] Filtered (${deltaStr} < ${MIN_SEEK_DELTA}s threshold) @ ${current.toFixed(2)}s — not relayed`, 'warn');
+            return;
+        }
+
+        // Step 4: Debounce rapid consecutive seeks (e.g. scrubbing)
+        // — wait 300ms for the user to settle before relaying
         if (seekDebounceTimer) clearTimeout(seekDebounceTimer);
         seekDebounceTimer = setTimeout(() => {
             seekDebounceTimer = null;
             if (activeVideo !== video || findVideo() !== video) return;
             const v = video;
-            const settled = getSyncCurrentTime(v);
-            if (settled === null) return;
-            const finalDelta = lastReportedSeekTime !== null ? Math.abs(settled - lastReportedSeekTime) : null;

-            const finalDeltaStr = finalDelta !== null ? `Δ${finalDelta.toFixed(2)}s` : 'Δ?';

-            lastReportedSeekTime = settled;

-            reportLog(`[Seek] Relayed @ ${settled.toFixed(2)}s (${finalDeltaStr})`, 'info');

-            reportEvent(EVENTS.SEEK);

-        }, 300);

-    };

-

-

-    let lastVideoSrc = undefined;

-

-    // Episode detection handler for loadeddata event

+            const settled = getSyncCurrentTime(v);
+            if (settled === null) return;
+            const finalDelta = lastReportedSeekTime !== null ? Math.abs(settled - lastReportedSeekTime) : null;
+            const finalDeltaStr = finalDelta !== null ? `Δ${finalDelta.toFixed(2)}s` : 'Δ?';
+            lastReportedSeekTime = settled;
+            reportLog(`[Seek] Relayed @ ${settled.toFixed(2)}s (${finalDeltaStr})`, 'info');
+            reportEvent(EVENTS.SEEK);
+        }, 300);
+    };
+
+
+    let lastVideoSrc = undefined;
+
+    // Episode detection handler for loadeddata event
     const handleLoadedData = event => {
         if (isCurrentVideoEvent(event)) checkEpisodeTransition();
     };
@@ -1864,34 +1868,34 @@
         }
         activeVideo = video || null;
         if (video) {
-            if (currentAudioVideo && currentAudioVideo !== video) {

-                bypassCurrentAudioProcessing();

+            if (currentAudioVideo && currentAudioVideo !== video) {
+                bypassCurrentAudioProcessing();
             }
             const existing = video._koalaHandlers;
             if (existing) detachVideoListeners(video);
             activeVideo = video;
-            video._koalaHandlers = { play: handlePlay, pause: handlePause, seeked: handleSeeked, loadeddata: handleLoadedData, waiting: handleWaiting };
-            video.addEventListener('play', handlePlay);

-            video.addEventListener('pause', handlePause);

-            video.addEventListener('seeked', handleSeeked);

+            video._koalaHandlers = { play: handlePlay, pause: handlePause, seeked: handleSeeked, loadeddata: handleLoadedData, waiting: handleWaiting };
+            video.addEventListener('play', handlePlay);
+            video.addEventListener('pause', handlePause);
+            video.addEventListener('seeked', handleSeeked);
             video.addEventListener('loadeddata', handleLoadedData);
             video.addEventListener('waiting', handleWaiting);
             attachedVideos.add(video);
             video.dataset.koalaAttached = 'true';
-            lastVideoSrc = video.currentSrc || video.src || null;

-

-            if (!lastKnownMediaTitle) {

-                lastKnownMediaTitle = getMediaTitle();

-            }

-

-            if (_audioSettings && _audioProcessingAllowed) applyAudioSettings(video, _audioSettings);

-        }

-    }

-

-    // SPA Navigation Handler (MutationObserver)

-    let lastMutate = 0;

-    let observerTimeout = null;

-

+            lastVideoSrc = video.currentSrc || video.src || null;
+
+            if (!lastKnownMediaTitle) {
+                lastKnownMediaTitle = getMediaTitle();
+            }
+
+            if (_audioSettings && _audioProcessingAllowed) applyAudioSettings(video, _audioSettings);
+        }
+    }
+
+    // SPA Navigation Handler (MutationObserver)
+    let lastMutate = 0;
+    let observerTimeout = null;
+
     function checkVideo() {
         if (destroyed) return;
         lastMutate = Date.now();
@@ -1914,17 +1918,17 @@
             }
             return;
         }
-

-        const currentSrc = video.currentSrc || video.src || null;

-

-        if (!video.dataset.koalaAttached || (lastVideoSrc !== undefined && currentSrc && lastVideoSrc !== currentSrc)) {

-            if (lastVideoSrc !== undefined && currentSrc && lastVideoSrc !== currentSrc) {

-                checkEpisodeTransition();

-            }

-            setupListeners();

-        }

-    }

-

+
+        const currentSrc = video.currentSrc || video.src || null;
+
+        if (!video.dataset.koalaAttached || (lastVideoSrc !== undefined && currentSrc && lastVideoSrc !== currentSrc)) {
+            if (lastVideoSrc !== undefined && currentSrc && lastVideoSrc !== currentSrc) {
+                checkEpisodeTransition();
+            }
+            setupListeners();
+        }
+    }
+
     // Frame documents get their own observer registration: mutations inside an
     // iframe never bubble into the parent document's observer, so without this
     // a late-loading player frame would go unnoticed.
@@ -1980,59 +1984,59 @@
     const observer = new MutationObserver(() => {
         if (destroyed) return;
         const now = Date.now();
-        if (now - lastMutate >= 1000) {

-            checkVideo();

-        } else {

-            if (observerTimeout) clearTimeout(observerTimeout);

-            observerTimeout = setTimeout(checkVideo, 1000 - (now - lastMutate));

-        }

-    });

+        if (now - lastMutate >= 1000) {
+            checkVideo();
+        } else {
+            if (observerTimeout) clearTimeout(observerTimeout);
+            observerTimeout = setTimeout(checkVideo, 1000 - (now - lastMutate));
+        }
+    });
     observer.observe(document.documentElement, {
         childList: true,
         subtree: true,
         attributes: true,
         attributeFilter: ['style', 'class', 'hidden', 'aria-hidden']
     });
-    observeSameOriginFrames();

-

-    // --- SHARED_HEARTBEAT_INJECT_START ---

-    const HEARTBEAT_INTERVAL_VAL = 15000;

-    // --- SHARED_HEARTBEAT_INJECT_END ---

-

-    // Heartbeat Refactoring (Self-scheduling setTimeout with proactive heartbeat scheduling)

-    let heartbeatTimeout = null;

-    let proactiveHeartbeatTimeout = null;

-    let heartbeatErrorCount = 0;

-

+    observeSameOriginFrames();
+
+    // --- SHARED_HEARTBEAT_INJECT_START ---
+    const HEARTBEAT_INTERVAL_VAL = 15000;
+    // --- SHARED_HEARTBEAT_INJECT_END ---
+
+    // Heartbeat Refactoring (Self-scheduling setTimeout with proactive heartbeat scheduling)
+    let heartbeatTimeout = null;
+    let proactiveHeartbeatTimeout = null;
+    let heartbeatErrorCount = 0;
+
     function sendHeartbeat() {
         if (destroyed) return;
         const video = findVideo();
-        if (!video) return;

-

-        const mediaTitle = (navigator.mediaSession && navigator.mediaSession.metadata) ? navigator.mediaSession.metadata.title : null;

+        if (!video) return;
+
+        const mediaTitle = (navigator.mediaSession && navigator.mediaSession.metadata) ? navigator.mediaSession.metadata.title : null;
         runtimeMessage({
-            type: 'HEARTBEAT',

-            payload: {

-                playbackState: video.paused ? 'paused' : 'playing',

-                currentTime: getSyncCurrentTime(video),
-                mediaTitle: mediaTitle,

-                volume: video.volume,

-                muted: video.muted

-            }

-        }).catch(err => {

-            if (err.message.includes('Extension context invalidated')) {

-                heartbeatErrorCount++;

-                if (heartbeatErrorCount === 1) {

-                    reportLog('Extension reloaded. Please refresh the page if sync stops working.', 'warn');

-                }

-                if (heartbeatTimeout) clearTimeout(heartbeatTimeout);

-                if (proactiveHeartbeatTimeout) clearTimeout(proactiveHeartbeatTimeout);

-                observer.disconnect();

-                observedDocs = new WeakSet();

-            }

-        });

-    }

-

+            type: 'HEARTBEAT',
+            payload: {
+                playbackState: video.paused ? 'paused' : 'playing',
+                currentTime: getSyncCurrentTime(video),
+                mediaTitle: mediaTitle,
+                volume: video.volume,
+                muted: video.muted
+            }
+        }).catch(err => {
+            if (err.message.includes('Extension context invalidated')) {
+                heartbeatErrorCount++;
+                if (heartbeatErrorCount === 1) {
+                    reportLog('Extension reloaded. Please refresh the page if sync stops working.', 'warn');
+                }
+                if (heartbeatTimeout) clearTimeout(heartbeatTimeout);
+                if (proactiveHeartbeatTimeout) clearTimeout(proactiveHeartbeatTimeout);
+                observer.disconnect();
+                observedDocs = new WeakSet();
+            }
+        });
+    }
+
     function schedulePeriodicHeartbeat() {
         if (destroyed || pageSuspended) return;
         if (heartbeatTimeout) clearTimeout(heartbeatTimeout);
@@ -2040,36 +2044,36 @@
             if (destroyed || pageSuspended) return;
             sendHeartbeat();
             schedulePeriodicHeartbeat();
-        }, HEARTBEAT_INTERVAL_VAL);

-    }

-

+        }, HEARTBEAT_INTERVAL_VAL);
+    }
+
     function scheduleProactiveHeartbeat() {
         if (destroyed || pageSuspended) return;
         if (proactiveHeartbeatTimeout) clearTimeout(proactiveHeartbeatTimeout);
         proactiveHeartbeatTimeout = setTimeout(() => {
             if (destroyed || pageSuspended) return;
             sendHeartbeat();
-            schedulePeriodicHeartbeat(); // Reschedules the next periodic check to be exactly 15s from now

-        }, 500); // 500ms stabilization delay

-    }

-

+            schedulePeriodicHeartbeat(); // Reschedules the next periodic check to be exactly 15s from now
+        }, 500); // 500ms stabilization delay
+    }
+
     // Initial Setup
     setupListeners();
     checkVideo();
-

-    // Maintain a persistent keep-alive port connection to prevent background SW suspension

+
+    // Maintain a persistent keep-alive port connection to prevent background SW suspension
     let keepAlivePort = null;
     function connectKeepAlivePort() {
         if (destroyed || pageSuspended) return;
         try {
-            if (chrome.runtime.id) {

-                keepAlivePort = chrome.runtime.connect({ name: 'keepAlive' });

+            if (chrome.runtime.id) {
+                keepAlivePort = chrome.runtime.connect({ name: 'keepAlive' });
                 keepAlivePort.onDisconnect.addListener(() => {
                     keepAlivePort = null;
                     if (!destroyed && !pageSuspended) scheduleLifecycleTimeout(connectKeepAlivePort, 1000);
                 });
-            }

-        } catch (_e) {

+            }
+        } catch (_e) {
             // Extension context invalidated or disabled
         }
     }
@@ -2129,6 +2133,9 @@
         hcmRemoveDialog();
         hcmRemoveBadge();
         bypassCurrentAudioProcessing();
+        // Deselecting a tab must not silence it. The page keeps playing on its
+        // own after KoalaSync lets go, so tearing down the AudioContext here
+        // left the previous target mute until it was reloaded.
         if (!preserveAudioRoute) closeAudioContext();
         try { window.koalaSyncChatOverlay?.destroy?.(); } catch (_e) { /* invalidated chat context */ }
 
@@ -2141,49 +2148,49 @@
 
     window.koalaSyncContentController = { destroy: destroyContentScript };
     connectKeepAlivePort();
-

-    schedulePeriodicHeartbeat();

-

-    // Immediate heartbeat on injection — populate peer data without waiting 15s

+
+    schedulePeriodicHeartbeat();
+
+    // Immediate heartbeat on injection — populate peer data without waiting 15s
     scheduleLifecycleTimeout(() => sendHeartbeat(), 300);
-

-    // Episode Auto-Sync: Boot recovery — check if background has an active lobby

+
+    // Episode Auto-Sync: Boot recovery — check if background has an active lobby
     runtimeMessage({ type: 'CONTENT_BOOT' }, (res) => {
         if (destroyed || chrome.runtime.lastError) return;
-        if (res && res.lobbyActive && res.expectedTitle) {

-            reportLog(`Boot: Active lobby detected for "${res.expectedTitle}"`, 'info');

-            startLobbyPoll(res.expectedTitle);

-        }

-    });

-

-    // Host Control Mode: fetch current room mode/role on injection (we may have

-    // been injected after ROOM_DATA already arrived, missing the broadcast).

+        if (res && res.lobbyActive && res.expectedTitle) {
+            reportLog(`Boot: Active lobby detected for "${res.expectedTitle}"`, 'info');
+            startLobbyPoll(res.expectedTitle);
+        }
+    });
+
+    // Host Control Mode: fetch current room mode/role on injection (we may have
+    // been injected after ROOM_DATA already arrived, missing the broadcast).
     runtimeMessage({ type: 'GET_CONTROL_MODE' }, (res) => {
         if (destroyed || chrome.runtime.lastError || !res) return;
-        hcmControlMode = res.controlMode || 'everyone';

-        hcmAmController = !!res.amController;

-        hcmHostPeerId = res.hostPeerId || null;

-        // Re-adopt persisted desync after a page reload so we don't start synced

-        // while background still relays us as "Solo" to the host (split-brain).

-        // Only when we're actually a gated guest — never adopt a stale flag as a

-        // controller or in 'everyone' mode (would self-label "Solo" / ignore commands).

-        if (res.desynced && res.controlMode === 'host-only' && !res.amController && !hcmDesynced) {

-            hcmDesynced = true;

-            hcmShowBadge();

-        }

-    });

-

-    // Pull localized strings for the in-page dialog/badge (English fallback above).

+        hcmControlMode = res.controlMode || 'everyone';
+        hcmAmController = !!res.amController;
+        hcmHostPeerId = res.hostPeerId || null;
+        // Re-adopt persisted desync after a page reload so we don't start synced
+        // while background still relays us as "Solo" to the host (split-brain).
+        // Only when we're actually a gated guest — never adopt a stale flag as a
+        // controller or in 'everyone' mode (would self-label "Solo" / ignore commands).
+        if (res.desynced && res.controlMode === 'host-only' && !res.amController && !hcmDesynced) {
+            hcmDesynced = true;
+            hcmShowBadge();
+        }
+    });
+
+    // Pull localized strings for the in-page dialog/badge (English fallback above).
     runtimeMessage({ type: 'GET_HCM_STRINGS' }, (res) => {
         if (destroyed || chrome.runtime.lastError || !res) return;
-        Object.keys(hcmStrings).forEach(k => { if (res[k]) hcmStrings[k] = res[k]; });

-        // If the badge is already showing (early desync), refresh its text in place.

-        // Re-creating the host element nukes the click target mid-poll and can drop a

-        // click that landed between remove() and the re-create (L-4).

-        if (hcmBadgeHost) {

-            const span = hcmBadgeHost.shadowRoot && hcmBadgeHost.shadowRoot.querySelector('span');

-            if (span) span.textContent = '● ' + hcmStrings.badge;

-        }

-    });

-

-})();

+        Object.keys(hcmStrings).forEach(k => { if (res[k]) hcmStrings[k] = res[k]; });
+        // If the badge is already showing (early desync), refresh its text in place.
+        // Re-creating the host element nukes the click target mid-poll and can drop a
+        // click that landed between remove() and the re-create (L-4).
+        if (hcmBadgeHost) {
+            const span = hcmBadgeHost.shadowRoot && hcmBadgeHost.shadowRoot.querySelector('span');
+            if (span) span.textContent = '● ' + hcmStrings.badge;
+        }
+    });
+
+})();
diff --git a/extension/locales/de.json b/extension/locales/de.json
index 135d6e1..d9e218a 100644
--- a/extension/locales/de.json
+++ b/extension/locales/de.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "eine erzwungene Synchronisation gestartet",
   "NOTIF_FORCE_EXECUTE": "alle Teilnehmer synchronisiert",
   "DEBUG_NO_TAB": "Kein Ziel-Tab ausgewählt.",
-  "DEBUG_TARGET_ACTIVATING": "Ziel-Tab ausgewählt; Video-Injection wird vorbereitet.",
   "DEBUG_COMM_FAIL": "Kommunikation mit dem Tab-Video fehlgeschlagen.",
   "EMPTY_PEERS_TITLE": "Noch keine Teilnehmer",
   "EMPTY_PEERS_HINT": "Teile deinen Einladungslink, um loszulegen",
diff --git a/extension/locales/en.json b/extension/locales/en.json
index 8babf44..d9bc1ec 100644
--- a/extension/locales/en.json
+++ b/extension/locales/en.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "started force sync",
   "NOTIF_FORCE_EXECUTE": "synchronized everyone",
   "DEBUG_NO_TAB": "No target tab selected.",
-  "DEBUG_TARGET_ACTIVATING": "Target tab selected; preparing video injection.",
   "DEBUG_COMM_FAIL": "Could not communicate with tab video.",
   "EMPTY_PEERS_TITLE": "No peers yet",
   "EMPTY_PEERS_HINT": "Share your invite link to get started",
diff --git a/extension/locales/es.json b/extension/locales/es.json
index 99d9b86..f512f00 100644
--- a/extension/locales/es.json
+++ b/extension/locales/es.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "ha iniciado una sincronización forzada",
   "NOTIF_FORCE_EXECUTE": "ha sincronizado a todos",
   "DEBUG_NO_TAB": "No hay pestaña objetivo seleccionada.",
-  "DEBUG_TARGET_ACTIVATING": "Pestaña objetivo seleccionada; preparando la inyección de vídeo.",
   "DEBUG_COMM_FAIL": "No se pudo comunicar con el video de la pestaña.",
   "EMPTY_PEERS_TITLE": "Sin participantes aún",
   "EMPTY_PEERS_HINT": "Comparte tu enlace de invitación para comenzar",
diff --git a/extension/locales/fr.json b/extension/locales/fr.json
index 985fdb0..da60a9c 100644
--- a/extension/locales/fr.json
+++ b/extension/locales/fr.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "lancé une synchronisation forcée",
   "NOTIF_FORCE_EXECUTE": "synchronisé tout le monde",
   "DEBUG_NO_TAB": "Aucun onglet cible sélectionné.",
-  "DEBUG_TARGET_ACTIVATING": "Onglet cible sélectionné ; préparation de l’injection vidéo.",
   "DEBUG_COMM_FAIL": "Impossible de communiquer avec l'onglet vidéo.",
   "EMPTY_PEERS_TITLE": "Aucun membre pour l'instant",
   "EMPTY_PEERS_HINT": "Partagez votre lien d'invitation pour commencer",
diff --git a/extension/locales/it.json b/extension/locales/it.json
index fafdd6a..ca5cb8d 100644
--- a/extension/locales/it.json
+++ b/extension/locales/it.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "ha avviato una sincronizzazione forzata",
   "NOTIF_FORCE_EXECUTE": "ha sincronizzato tutti",
   "DEBUG_NO_TAB": "Nessuna scheda selezionata.",
-  "DEBUG_TARGET_ACTIVATING": "Scheda target selezionata; preparazione dell’iniezione video.",
   "DEBUG_COMM_FAIL": "Errore di comunicazione con il video.",
   "EMPTY_PEERS_TITLE": "Nessun partecipante",
   "EMPTY_PEERS_HINT": "Condividi il tuo link per iniziare",
diff --git a/extension/locales/ja.json b/extension/locales/ja.json
index 48ba1e4..68ad760 100644
--- a/extension/locales/ja.json
+++ b/extension/locales/ja.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "強制同期を開始しました",
   "NOTIF_FORCE_EXECUTE": "全員を同期しました",
   "DEBUG_NO_TAB": "対象のタブが選択されていません。",
-  "DEBUG_TARGET_ACTIVATING": "対象のタブを選択しました。動画スクリプトを準備しています。",
   "DEBUG_COMM_FAIL": "タブのビデオと通信できませんでした。",
   "EMPTY_PEERS_TITLE": "メンバーはまだいません",
   "EMPTY_PEERS_HINT": "招待リンクを共有して始めましょう",
diff --git a/extension/locales/ko.json b/extension/locales/ko.json
index ede88bd..2354f2f 100644
--- a/extension/locales/ko.json
+++ b/extension/locales/ko.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "강제 동기화를 시작했습니다",
   "NOTIF_FORCE_EXECUTE": "모든 사용자를 동기화했습니다",
   "DEBUG_NO_TAB": "대상 탭이 선택되지 않았습니다.",
-  "DEBUG_TARGET_ACTIVATING": "대상 탭이 선택되었습니다. 동영상 주입을 준비하는 중입니다.",
   "DEBUG_COMM_FAIL": "탭 비디오와 통신할 수 없습니다.",
   "EMPTY_PEERS_TITLE": "참여자 없음",
   "EMPTY_PEERS_HINT": "시작하려면 초대 링크를 공유하세요",
diff --git a/extension/locales/nl.json b/extension/locales/nl.json
index dc9a581..4cac4c9 100644
--- a/extension/locales/nl.json
+++ b/extension/locales/nl.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "is een geforceerde sync gestart",
   "NOTIF_FORCE_EXECUTE": "heeft iedereen gesynchroniseerd",
   "DEBUG_NO_TAB": "Geen doeltabblad geselecteerd.",
-  "DEBUG_TARGET_ACTIVATING": "Doeltabblad geselecteerd; video-injectie wordt voorbereid.",
   "DEBUG_COMM_FAIL": "Kon niet communiceren met de videotab.",
   "EMPTY_PEERS_TITLE": "Nog geen deelnemers",
   "EMPTY_PEERS_HINT": "Deel uw uitnodigingslink om te beginnen",
diff --git a/extension/locales/pl.json b/extension/locales/pl.json
index 6479e06..abf7622 100644
--- a/extension/locales/pl.json
+++ b/extension/locales/pl.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "wymusił synchronizację",
   "NOTIF_FORCE_EXECUTE": "zsynchronizował wszystkich",
   "DEBUG_NO_TAB": "Nie wybrano karty docelowej.",
-  "DEBUG_TARGET_ACTIVATING": "Wybrano kartę docelową; przygotowywanie wstrzyknięcia wideo.",
   "DEBUG_COMM_FAIL": "Nie można skomunikować się z wideo w karcie.",
   "EMPTY_PEERS_TITLE": "Brak uczestników",
   "EMPTY_PEERS_HINT": "Udostępnij link zaproszenia, aby rozpocząć",
diff --git a/extension/locales/pt-BR.json b/extension/locales/pt-BR.json
index be76600..31645e1 100644
--- a/extension/locales/pt-BR.json
+++ b/extension/locales/pt-BR.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "iniciou uma sincronização forçada",
   "NOTIF_FORCE_EXECUTE": "sincronizou todos",
   "DEBUG_NO_TAB": "Nenhuma aba selecionada.",
-  "DEBUG_TARGET_ACTIVATING": "Aba de destino selecionada; preparando a injeção de vídeo.",
   "DEBUG_COMM_FAIL": "Erro ao se comunicar com o vídeo.",
   "EMPTY_PEERS_TITLE": "Nenhum participante",
   "EMPTY_PEERS_HINT": "Compartilhe seu link de convite para começar",
diff --git a/extension/locales/pt.json b/extension/locales/pt.json
index 6b127dd..e5b5eff 100644
--- a/extension/locales/pt.json
+++ b/extension/locales/pt.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "iniciou uma sincronização forçada",
   "NOTIF_FORCE_EXECUTE": "sincronizou todos",
   "DEBUG_NO_TAB": "Nenhum separador selecionado.",
-  "DEBUG_TARGET_ACTIVATING": "Separador de destino selecionado; a preparar a injeção de vídeo.",
   "DEBUG_COMM_FAIL": "Erro ao comunicar com o vídeo.",
   "EMPTY_PEERS_TITLE": "Nenhum participante",
   "EMPTY_PEERS_HINT": "Partilhe o seu link de convite para começar",
diff --git a/extension/locales/ru.json b/extension/locales/ru.json
index a2d4c44..80db8cb 100644
--- a/extension/locales/ru.json
+++ b/extension/locales/ru.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "запустил принудительный синхрон",
   "NOTIF_FORCE_EXECUTE": "синхронизировал воспроизведение у всех",
   "DEBUG_NO_TAB": "Целевая вкладка не выбрана.",
-  "DEBUG_TARGET_ACTIVATING": "Целевая вкладка выбрана; подготовка внедрения видео.",
   "DEBUG_COMM_FAIL": "Не удалось связаться с плеером на вкладке.",
   "EMPTY_PEERS_TITLE": "Участников пока нет",
   "EMPTY_PEERS_HINT": "Поделитесь ссылкой-приглашением, чтобы начать",
diff --git a/extension/locales/tr.json b/extension/locales/tr.json
index afadf12..d9bc14b 100644
--- a/extension/locales/tr.json
+++ b/extension/locales/tr.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "zorunlu eşitleme başlattı",
   "NOTIF_FORCE_EXECUTE": "herkesi eşitledi",
   "DEBUG_NO_TAB": "Hedef sekme seçilmedi.",
-  "DEBUG_TARGET_ACTIVATING": "Hedef sekme seçildi; video enjeksiyonu hazırlanıyor.",
   "DEBUG_COMM_FAIL": "Sekme videosuyla iletişim kurulamadı.",
   "EMPTY_PEERS_TITLE": "Henüz kimse yok",
   "EMPTY_PEERS_HINT": "Başlamak için davet bağlantınızı paylaşın",
diff --git a/extension/locales/uk.json b/extension/locales/uk.json
index 0357dc9..12b14d7 100644
--- a/extension/locales/uk.json
+++ b/extension/locales/uk.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "почав примусову синхронізацію",
   "NOTIF_FORCE_EXECUTE": "синхронізував усіх",
   "DEBUG_NO_TAB": "Цільова вкладка не вибрана.",
-  "DEBUG_TARGET_ACTIVATING": "Цільову вкладку вибрано; готується впровадження відео.",
   "DEBUG_COMM_FAIL": "Не вдалося зв’язатися з відео вкладки.",
   "EMPTY_PEERS_TITLE": "Учасників ще немає",
   "EMPTY_PEERS_HINT": "Поділіться своїм запрошенням, щоб почати",
diff --git a/extension/locales/zh.json b/extension/locales/zh.json
index b87c784..b735cae 100644
--- a/extension/locales/zh.json
+++ b/extension/locales/zh.json
@@ -190,7 +190,6 @@
   "NOTIF_FORCE_PREPARE": "开始强制同步",
   "NOTIF_FORCE_EXECUTE": "同步所有人",
   "DEBUG_NO_TAB": "未选择目标选项卡。",
-  "DEBUG_TARGET_ACTIVATING": "已选择目标标签页；正在准备注入视频脚本。",
   "DEBUG_COMM_FAIL": "无法与标签视频通信。",
   "EMPTY_PEERS_TITLE": "还没有同行",
   "EMPTY_PEERS_HINT": "分享您的邀请链接以开始使用",
diff --git a/extension/media-frame-monitor.js b/extension/media-frame-monitor.js
index 74da5fc..be96ef9 100644
--- a/extension/media-frame-monitor.js
+++ b/extension/media-frame-monitor.js
@@ -62,12 +62,15 @@
                 const source = element.tagName === 'VIDEO'
                     ? (element.currentSrc || element.src || element.querySelector?.('source[src]')?.src || '')
                     : (element.src || '');
+                // Deliberately coarse. This signature answers "which frame is a
+                // candidate", not "what is it doing". Including paused/readyState
+                // /duration made every play, pause and buffering tick look like a
+                // layout change, so ordinary playback retriggered a full target
+                // reactivation and re-injected the content script under the user.
                 const mediaState = element.tagName === 'VIDEO'
                     ? [
-                        element.paused ? 0 : 1,
-                        element.controls ? 1 : 0,
-                        Number.isInteger(element.readyState) ? element.readyState : 0,
-                        Number.isFinite(element.duration) ? Math.round(element.duration) : 0
+                        element.readyState > 0 ? 1 : 0,
+                        Number.isFinite(element.duration) && element.duration > 0 ? 1 : 0
                     ].join(',')
                     : '';
                 parts.push([
@@ -188,6 +191,11 @@
     });
     hookFrames();
     lastCandidateSignature = candidateSignature();
+    // A monitor installed after the player already exists would otherwise take
+    // that player as its baseline and never mention it. Frames get a monitor
+    // late all the time — a rebuilt document, a reinstall — so announce an
+    // already-present video once instead of staying silent about it.
+    if (document.querySelector('video')) schedule('monitor_installed', { force: true });
     window.addEventListener('pagehide', handlePageHide);
     window.addEventListener('pageshow', handlePageShow);
     window.addEventListener('resize', handleResize, { passive: true });
diff --git a/extension/media-frame-target.js b/extension/media-frame-target.js
index 7661b82..bab8780 100644
--- a/extension/media-frame-target.js
+++ b/extension/media-frame-target.js
@@ -1,8 +1,14 @@
 export const MEDIA_FRAME_ACCESS_REQUIRED = 'media_frame_access_required';
+export const MEDIA_FRAME_PROBE_TIMEOUT = 'media_frame_probe_timeout';
+
 const MIN_PLAYER_FRAME_AREA = 320 * 180;
 const MIN_PLAYER_ASPECT_RATIO = 1.15;
 const MAX_PLAYER_ASPECT_RATIO = 2.6;
-const DEFAULT_PROBE_TIMEOUT_MS = 1500;
+// inspectMediaFrame is synchronous DOM work: a live frame answers in tens of
+// milliseconds, and anything slower is a frame that is navigating or being torn
+// down. Waiting seconds for those only delays the answer — a frame dropped here
+// is re-probed on the next attempt and reports itself through its monitor.
+const DEFAULT_PROBE_TIMEOUT_MS = 750;
 
 function normalizeFrameId(value) {
     return Number.isInteger(value) && value >= 0 ? value : 0;
@@ -165,10 +171,16 @@ export function inspectMediaFrame(expectedVisibilityToken = null) {
             const rect = frame.getBoundingClientRect();
             const directVisible = elementIsVisible(frame, rect);
             const visible = ancestorVisible && directVisible;
+            // An iframe without src resolves to the *parent* document's URL, so
+            // record whether the element really carried one. Treating a srcless
+            // ad slot's href as its own would let a hidden slot mark the page
+            // that contains it as hidden.
+            const rawSrc = frame.getAttribute?.('src') || '';
             let href = '';
             try { href = new URL(frame.src || '', doc.location.href).href; } catch { href = ''; }
             embeddedFrames.push({
                 href,
+                explicitSrc: rawSrc.trim().length > 0,
                 origin: (() => { try { return new URL(href).origin; } catch { return null; } })(),
                 area: Math.max(0, rect.width) * Math.max(0, rect.height),
                 width: Math.max(0, rect.width),
@@ -243,7 +255,12 @@ export function installParentFrameVisibilityProbe(token) {
         };
     };
     window.addEventListener('message', handler);
-    timeout = setTimeout(cleanup, 1000);
+    // The listener has to outlive the whole probe sequence: install, four
+    // dispatch passes and the final inspection, each a separate executeScript
+    // round trip. On a heavy page those add up well past a second, and a
+    // listener that expired first left every frame's visibility unknown — which
+    // is exactly the state that makes two players look equally ranked.
+    timeout = setTimeout(cleanup, 15000);
     window.__koalaFrameVisibilityCleanup = cleanup;
 }
 
@@ -328,11 +345,38 @@ function sameMeaningfulRank(left, right) {
     return leftRank.slice(0, 8).every((value, index) => value === rightRank[index]);
 }
 
+/**
+ * Frames whose own element was seen as hidden by an ancestor that could inspect
+ * it directly. A same-origin wrapper collapsed to 0x0 — the usual way an anime
+ * host parks the mirrors you are not watching — is reported here by the top
+ * frame itself, so the hidden player can be ruled out without waiting for the
+ * postMessage visibility handshake to complete.
+ */
+function hiddenFrameHrefs(injectionResults) {
+    const visibility = new Map();
+    for (const entry of Array.isArray(injectionResults) ? injectionResults : []) {
+        for (const frame of entry?.result?.embeddedFrames || []) {
+            if (typeof frame?.href !== 'string' || !frame.href) continue;
+            // Without an explicit src the href is the parent's, not this frame's.
+            if (frame.explicitSrc !== true) continue;
+            // A frame cannot testify about the document that reported it.
+            if (frame.href === entry?.result?.href) continue;
+            // Any ancestor reporting it visible wins over one reporting it hidden.
+            visibility.set(frame.href, (visibility.get(frame.href) === true) || frame.visible === true);
+        }
+    }
+    const hidden = new Set();
+    for (const [href, visible] of visibility) if (!visible) hidden.add(href);
+    return hidden;
+}
+
 export function selectMediaFrame(injectionResults) {
+    const hidden = hiddenFrameHrefs(injectionResults);
     const candidates = (Array.isArray(injectionResults) ? injectionResults : [])
         .filter(entry => Number.isInteger(entry?.frameId)
             && entry?.result?.bestVideo?.rendered === true)
         .filter(entry => entry.result.parentFrameVisible !== false)
+        .filter(entry => !hidden.has(entry.result.href))
         .sort(compareRanks);
     if (candidates.length === 0) return null;
     if (candidates.length > 1
@@ -387,13 +431,19 @@ function findMissingPlayerAccess(results) {
 
 function shouldPreferMissingAccess(access, selected) {
     if (!access) return false;
-    if (access.drivePlayer || !selected?.result?.bestVideo) return true;
+    if (!selected?.result?.bestVideo) return true;
     const video = selected.result.bestVideo;
     if (!video.hasSource || !video.rendered || video.background) return true;
     const selectedArea = Number.isFinite(video.renderedArea) ? video.renderedArea : 0;
     const weakAccessibleCandidate = !video.controls
         && video.duration > 0
         && video.duration < 300;
+    // Drive never plays the file in its own document, so its embedded player
+    // outranks a weak local candidate. It must not outrank a real one: a Drive
+    // tab can host an ordinary accessible video next to a file preview.
+    if (access.drivePlayer) {
+        return weakAccessibleCandidate || selectedArea < MIN_PLAYER_FRAME_AREA;
+    }
     return weakAccessibleCandidate
         && access.area >= Math.max(MIN_PLAYER_FRAME_AREA, selectedArea * 1.5);
 }
@@ -406,11 +456,14 @@ function accessRequiredError(access) {
     return error;
 }
 
-function contentTarget(tabId, selected, monitorTargets = null) {
+function contentTarget(tabId, selected, discoveredFrameIds = null) {
     const frameId = normalizeFrameId(selected?.frameId);
     const documentId = typeof selected?.documentId === 'string' ? selected.documentId : null;
-    const target = {
+    return {
         frameId,
+        // Every frame this probe reached, so the caller can remember them and
+        // recover directly next time the all-frames sweep is rejected.
+        discoveredFrameIds: Array.isArray(discoveredFrameIds) ? discoveredFrameIds : [],
         documentId,
         frameUrl: typeof selected?.result?.href === 'string' ? selected.result.href : null,
         hasVideo: !!selected?.result?.bestVideo,
@@ -418,148 +471,220 @@ function contentTarget(tabId, selected, monitorTargets = null) {
             ? { tabId, documentIds: [documentId] }
             : (frameId === 0 ? { tabId } : { tabId, frameIds: [frameId] })
     };
-    if (Array.isArray(monitorTargets) && monitorTargets.length > 0) {
-        target.monitorTargets = monitorTargets;
-    }
-    return target;
 }
 
 export function listMediaFrameScriptTargets(tabId) {
     return [{ tabId, allFrames: true }];
 }
 
-function listFrameProbeTargets(tabId, embeddedFrameCount = 0) {
-    // Chromium can reject one all-frames executeScript call when a single
-    // child frame is browser-owned or temporarily unavailable. Frame IDs are
-    // not exposed without webNavigation, so probe a bounded range individually
-    // after the top frame tells us that embedded frames exist. Each rejected
-    // probe is isolated and cannot hide the other frames.
-    const maxFrameId = Math.min(64, Math.max(8, (embeddedFrameCount * 4) + 4));
-    return Array.from({ length: maxFrameId }, (_, frameId) => ({
-        tabId,
-        frameIds: [frameId]
-    }));
-}
-
+/** Pins one probe to one frame, preferring the exact document when known. */
 function frameScriptTarget(tabId, entry) {
     const frameId = normalizeFrameId(entry?.frameId);
     return typeof entry?.documentId === 'string' && entry.documentId
         ? { tabId, documentIds: [entry.documentId] }
-        : (frameId === 0 ? { tabId, frameIds: [0] } : { tabId, frameIds: [frameId] });
+        : { tabId, frameIds: [frameId] };
 }
 
+/**
+ * Later results replace earlier ones for the same frame. A frame that navigated
+ * between two probes must not appear twice, because two stale copies of one
+ * frame look exactly like two competing players.
+ */
 function mergeFrameResults(...groups) {
     const merged = new Map();
     for (const group of groups) {
         for (const entry of Array.isArray(group) ? group : []) {
             if (!Number.isInteger(entry?.frameId)) continue;
-            // A frame ID identifies the current slot. If its document changed
-            // between the broad probe and the exact probe, the exact result
-            // must replace the stale document rather than create a duplicate
-            // candidate that can trigger a false ambiguity.
-            const key = `frame:${entry.frameId}`;
-            merged.set(key, entry);
+            merged.set(`frame:${entry.frameId}`, entry);
         }
     }
     return Array.from(merged.values());
 }
 
+function probeTimeoutError(label, timeoutMs) {
+    const error = new Error(`${label} timed out after ${timeoutMs}ms`);
+    error.code = MEDIA_FRAME_PROBE_TIMEOUT;
+    return error;
+}
+
 function executeWithTimeout(task, timeoutMs, label) {
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return task();
     let timeoutId = null;
     const timeout = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => {
-            const error = new Error(`${label} timed out after ${timeoutMs}ms`);
-            error.code = 'media_frame_probe_timeout';
-            reject(error);
-        }, timeoutMs);
+        timeoutId = setTimeout(() => reject(probeTimeoutError(label, timeoutMs)), timeoutMs);
     });
-    return Promise.race([task(), timeout]).finally(() => {
+    const taskPromise = Promise.resolve().then(task);
+    taskPromise.catch(() => {});
+    return Promise.race([taskPromise, timeout]).finally(() => {
         if (timeoutId !== null) clearTimeout(timeoutId);
     });
 }
 
-async function executeInAccessibleFrames(chromeApi, targets, func, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
+async function executeInAccessibleFrames(chromeApi, targets, func, args, timeoutMs) {
+    const errors = [];
     const settled = await Promise.all(targets.map(async target => {
         try {
             const result = await executeWithTimeout(
                 () => chromeApi.scripting.executeScript({ target, func, args }),
                 timeoutMs,
-                `Frame probe for ${JSON.stringify(target)}`
+                `Frame probe ${JSON.stringify(target)}`
             );
             return Array.isArray(result) ? result : [];
-        } catch {
+        } catch (error) {
+            // A failed probe is recorded, never silently dropped. Only the
+            // caller can tell "withheld origin" from "frame is still loading",
+            // and guessing that difference is what produced false permission
+            // prompts for players the extension was already allowed to touch.
+            errors.push({ target, error });
             return [];
         }
     }));
-    return settled.flat();
+    return { results: settled.flat(), errors };
+}
+
+/**
+ * Asks the browser whether an origin is genuinely withheld.
+ *
+ * Returns true when the grant is missing, false when it is held, and null when
+ * the browser cannot answer. A frame that did not respond to a probe is not
+ * evidence of a missing grant: that inference is what made Drive and
+ * YummyAnime demand access for an origin the extension already had.
+ */
+async function originAccessIsWithheld(chromeApi, originPattern) {
+    if (typeof originPattern !== 'string' || !originPattern) return null;
+    if (typeof chromeApi?.permissions?.contains !== 'function') return null;
+    try {
+        const granted = await executeWithTimeout(
+            () => Promise.resolve(chromeApi.permissions.contains({ origins: [originPattern] })),
+            1000,
+            `Permission check for ${originPattern}`
+        );
+        if (granted === true) return false;
+        if (granted === false) return true;
+        return null;
+    } catch {
+        return null;
+    }
 }
 
 export async function resolveMediaContentTarget(chromeApi, tabId, {
+    // v3.1.2's retry budget: a player frame can take several seconds to appear,
+    // and giving up early is what turns a slow page into "no video found".
     attempts = 8,
     retryDelayMs = 200,
     probeDelayMs = 60,
-    probeTimeoutMs = DEFAULT_PROBE_TIMEOUT_MS
+    probeTimeoutMs = DEFAULT_PROBE_TIMEOUT_MS,
+    // Frame ids the background has seen in this tab. They rescue the probe when
+    // the all-frames sweep is rejected wholesale by one unrelated frame.
+    knownFrameIds = [],
+    // ...but the budget is now wall-clock bounded, so a page whose frames all
+    // time out cannot hold the activation open for minutes.
+    deadlineMs = 12000
 } = {}) {
+    const startedAt = Date.now();
     let fallback = null;
     let missingAccess = null;
-    let monitorTargets = [];
+    let ambiguous = false;
+    let unresolvedGrantedHost = null;
+    const discovered = new Set(Array.isArray(knownFrameIds) ? knownFrameIds : []);
 
     for (let attempt = 0; attempt < attempts; attempt++) {
-        const topResults = await executeInAccessibleFrames(
+        const scriptTargets = listMediaFrameScriptTargets(tabId);
+        let { results } = await executeInAccessibleFrames(
             chromeApi,
-            [{ tabId, frameIds: [0] }],
+            scriptTargets,
             inspectMediaFrame,
             [null],
             probeTimeoutMs
         );
-        const allFrameResults = await executeInAccessibleFrames(
-            chromeApi,
-            listMediaFrameScriptTargets(tabId),
-            inspectMediaFrame,
-            [null],
-            probeTimeoutMs
-        );
-        let results = mergeFrameResults(topResults, allFrameResults);
-        const embeddedFrameCount = topResults.reduce(
-            (count, entry) => Math.max(count, entry?.result?.embeddedFrames?.length || 0),
-            0
-        );
-        if (embeddedFrameCount > 0) {
-            const individuallyProbed = await executeInAccessibleFrames(
+        // Any frame the sweep missed but that we know exists gets asked directly.
+        // One rejected probe then costs one frame, not the whole page.
+        const missingFrameIds = knownFrameIds.filter(frameId => Number.isInteger(frameId)
+            && !results.some(entry => entry.frameId === frameId));
+        if (missingFrameIds.length > 0) {
+            const { results: recovered } = await executeInAccessibleFrames(
                 chromeApi,
-                listFrameProbeTargets(tabId, embeddedFrameCount),
+                missingFrameIds.map(frameId => ({ tabId, frameIds: [frameId] })),
                 inspectMediaFrame,
                 [null],
                 probeTimeoutMs
             );
-            results = mergeFrameResults(results, individuallyProbed);
+            if (recovered.length > 0) results = mergeFrameResults(results, recovered);
         }
-        if (results.length === 0) return contentTarget(tabId, null);
 
-        if (results.length > 1) {
-            const token = `${tabId}:${attempt}:${Date.now()}:${Math.random()}`;
-            const frameTargets = results.map(entry => frameScriptTarget(tabId, entry));
+        if (results.length === 0) {
+            // The all-frames sweep answered for nothing at all, so fall back to
+            // the top document alone. Every probe is time-boxed: an unreachable
+            // player frame must never stall the whole activation.
             try {
+                const topResults = await executeWithTimeout(
+                    () => chromeApi.scripting.executeScript({
+                        target: { tabId },
+                        func: inspectMediaFrame,
+                        args: [null]
+                    }),
+                    probeTimeoutMs,
+                    'Top-frame probe'
+                );
+                results = Array.isArray(topResults) ? topResults : [];
+                if (results.length === 0) return contentTarget(tabId, null);
+            } catch {
+                return contentTarget(tabId, null);
+            }
+        }
+
+        const candidateCount = results.filter(
+            entry => entry?.result?.bestVideo?.rendered === true
+        ).length;
+        // The visibility handshake only exists to rank and exclude video
+        // candidates. With no video on the page yet there is nothing to rank, and
+        // running it anyway cost several seconds on every attempt — the whole
+        // reason selecting an anime tab before playback felt broken.
+        if (results.length > 1 && candidateCount > 0) {
+            const token = `${tabId}:${attempt}:${Date.now()}:${Math.random()}`;
+            // Address each discovered frame on its own from here on. A single
+            // allFrames call is all-or-nothing: one player or ad frame that
+            // never answers takes the whole probe down with it. v3.1.2 avoided
+            // that by listing frames through webNavigation — but the sweep
+            // above already reports frameId and documentId for every frame it
+            // reached, so the same isolation costs no permission at all.
+            // A leaf frame with no video and no nested frames can never be a
+            // candidate nor an ancestor of one. Ad slots are exactly that, and
+            // they churn constantly, so every phase below would otherwise wait
+            // on a frame that was already being torn down.
+            const relevant = results.filter(entry => (entry?.result?.videoCount || 0) > 0
+                || (entry?.result?.embeddedFrames?.length || 0) > 0
+                || entry?.result?.isTop === true);
+            const frameTargets = (relevant.length > 0 ? relevant : results)
+                .map(entry => frameScriptTarget(tabId, entry));
+            try {
+                const visibilityTimeoutMs = Math.min(probeTimeoutMs, 750);
                 await executeInAccessibleFrames(
                     chromeApi,
                     frameTargets,
                     installParentFrameVisibilityProbe,
                     [token],
-                    probeTimeoutMs
+                    visibilityTimeoutMs
                 );
-                // Four passes match the maximum same-origin recursion depth.
-                for (let pass = 0; pass < 4; pass++) {
+                // One pass per nesting level actually present. Four was the
+                // worst case, not the common one; these players sit two levels
+                // down and each surplus pass is a full round trip.
+                const observedDepth = results.reduce((deepest, entry) => Math.max(
+                    deepest,
+                    ...(entry?.result?.embeddedFrames || []).map(frame => frame.depth || 1)
+                ), 1);
+                const passes = Math.min(4, Math.max(2, observedDepth));
+                for (let pass = 0; pass < passes; pass++) {
                     await executeInAccessibleFrames(
                         chromeApi,
                         frameTargets,
                         dispatchParentFrameVisibilityProbe,
                         [token],
-                        probeTimeoutMs
+                        visibilityTimeoutMs
                     );
                     await new Promise(resolve => setTimeout(resolve, probeDelayMs));
                 }
-                const inspected = await executeInAccessibleFrames(
+                const { results: inspected } = await executeInAccessibleFrames(
                     chromeApi,
                     frameTargets,
                     inspectMediaFrame,
@@ -572,32 +697,70 @@ export async function resolveMediaContentTarget(chromeApi, tabId, {
                 // frames will be rejected below rather than guessed.
             }
         }
-        // Rebuild these after the visibility refresh so a frame navigation that
-        // replaced its document ID cannot leave a stale monitor target behind.
-        monitorTargets = results.map(entry => frameScriptTarget(tabId, entry));
 
+        for (const entry of results) {
+            if (Number.isInteger(entry?.frameId)) discovered.add(entry.frameId);
+        }
         const selected = selectMediaFrame(results);
-        const currentMissingAccess = findMissingPlayerAccess(results);
+        const videoCandidates = results.filter(entry => entry?.result?.bestVideo?.rendered === true
+            && entry.result.parentFrameVisible !== false);
+        let currentMissingAccess = findMissingPlayerAccess(results);
+        if (currentMissingAccess) {
+            const withheld = await originAccessIsWithheld(
+                chromeApi,
+                currentMissingAccess.originPattern
+            );
+            if (withheld === false) {
+                // The grant is already held, so the player frame is merely slow,
+                // still navigating, or gone. Retrying is correct here; prompting
+                // for a permission the user already gave is not.
+                unresolvedGrantedHost = currentMissingAccess.host;
+                currentMissingAccess = null;
+            }
+        }
         missingAccess = currentMissingAccess;
         fallback = selected;
+        ambiguous = !selected && videoCandidates.length > 1;
         if (selected) {
             if (selected.result.bestVideo.hasSource
                 && selected.result.bestVideo.rendered
                 && !shouldPreferMissingAccess(currentMissingAccess, selected)) {
-                return contentTarget(tabId, selected, monitorTargets);
+                return contentTarget(tabId, selected, Array.from(discovered));
             }
         }
 
+        if (Number.isFinite(deadlineMs) && deadlineMs > 0 && Date.now() - startedAt >= deadlineMs) {
+            break;
+        }
+        // Nothing on the page has a video element yet. Spending the retry budget
+        // cannot change that; the injected monitor reports the player the moment
+        // it is created, so return now and let selection be instant.
+        const anyVideo = results.some(entry => (entry?.result?.videoCount || 0) > 0);
+        if (!anyVideo) {
+            // Discovery worked and simply found no player yet, so stop: the
+            // monitor reports one within a fraction of a second once it exists.
+            // Retry only when the sweep itself came back thin, which is the case
+            // a second pass can actually fix.
+            if (results.length > 1) break;
+            if (attempt >= 1) break;
+        }
         if (attempt < attempts - 1) {
             await new Promise(resolve => setTimeout(resolve, retryDelayMs));
         }
     }
 
     if (missingAccess) throw accessRequiredError(missingAccess);
-    if (fallback) return contentTarget(tabId, fallback, monitorTargets);
-    // Selecting a tab must not depend on video detection. A page can be a
-    // valid target before its player exists, and an ambiguous frame layout is
-    // recoverable through the injected lifecycle monitor. Keep the top-frame
-    // target active instead of discarding the user's selection.
-    return contentTarget(tabId, null, monitorTargets);
+    if (fallback) return contentTarget(tabId, fallback, Array.from(discovered));
+    // A player whose origin is already granted but which never answered is a
+    // timing problem, not a user decision. Keep the tab selected on its top
+    // frame so the injected monitor can promote the real player once it loads,
+    // instead of failing the activation or prompting for nothing.
+    if (unresolvedGrantedHost) return contentTarget(tabId, null, Array.from(discovered));
+    // Several equally-ranked players — anime mirrors, alternative dubs — are a
+    // normal page layout, not an error. Refusing to activate made those pages
+    // unusable, and flipping between candidates restarted the target forever.
+    // Hold the top frame and let the monitor promote the one that starts
+    // playing, which is the signal that breaks the tie.
+    if (ambiguous) return { ...contentTarget(tabId, null, Array.from(discovered)), ambiguous: true };
+    return contentTarget(tabId, null, Array.from(discovered));
 }
diff --git a/extension/media-frame-target.test.mjs b/extension/media-frame-target.test.mjs
index 0f91c2d..3695a5d 100644
--- a/extension/media-frame-target.test.mjs
+++ b/extension/media-frame-target.test.mjs
@@ -108,6 +108,63 @@ describe('cross-origin media-frame targeting', () => {
         expect(selected.frameId).toBe(0);
     });
 
+    it('ignores a hidden srcless ad slot that resolves to another frame url', () => {
+        // An iframe without src resolves to its parent document's URL. A hidden
+        // ad slot must therefore never be able to declare a real player hidden.
+        const selected = selectMediaFrame([
+            frame(0, {
+                bestVideo: null,
+                videoCount: 0,
+                embeddedFrames: [{
+                    href: 'https://player-5.example/embed',
+                    explicitSrc: false,
+                    visible: false,
+                    area: 0,
+                    width: 0,
+                    height: 0,
+                    depth: 1,
+                    mediaHint: false
+                }]
+            }),
+            frame(5, { parentFrameVisible: null })
+        ]);
+        expect(selected?.frameId).toBe(5);
+    });
+
+    it('drops a player parked inside a collapsed same-origin wrapper', () => {
+        const selected = selectMediaFrame([
+            frame(0, {
+                bestVideo: null,
+                videoCount: 0,
+                embeddedFrames: [
+                    {
+                        href: 'https://player-5.example/embed',
+                        explicitSrc: true,
+                        visible: true,
+                        area: 830 * 498,
+                        width: 830,
+                        height: 498,
+                        depth: 2,
+                        mediaHint: true
+                    },
+                    {
+                        href: 'https://player-6.example/embed',
+                        explicitSrc: true,
+                        visible: false,
+                        area: 0,
+                        width: 0,
+                        height: 0,
+                        depth: 2,
+                        mediaHint: true
+                    }
+                ]
+            }),
+            frame(5, { parentFrameVisible: null }),
+            frame(6, { parentFrameVisible: null })
+        ]);
+        expect(selected?.frameId).toBe(5);
+    });
+
     it('refuses to guess between equally-ranked frames without visibility evidence', () => {
         expect(selectMediaFrame([
             frame(3, { parentFrameVisible: null }),
@@ -127,16 +184,47 @@ describe('cross-origin media-frame targeting', () => {
             documentId: 'document-8',
             frameUrl: 'https://player-8.example/embed',
             hasVideo: true,
-            scriptTarget: { tabId: 42, documentIds: ['document-8'] },
-            monitorTargets: [
-                { tabId: 42, documentIds: ['document-0'] },
-                { tabId: 42, documentIds: ['document-8'] }
-            ]
+            // Reported back so the caller can address these frames directly when
+            // a later all-frames sweep is rejected wholesale.
+            discoveredFrameIds: [0, 8],
+            scriptTarget: { tabId: 42, documentIds: ['document-8'] }
         });
         const visibilityDispatches = executeScript.mock.calls.filter(([options]) => (
             options.func?.name === 'dispatchParentFrameVisibilityProbe'
         ));
-        expect(visibilityDispatches.length).toBeGreaterThanOrEqual(4);
+        // Two passes — the floor — across both discovered frames, each addressed
+        // on its own so a frame that never answers cannot cancel the others.
+        // These fixtures report no nesting, so the depth-scaled pass count must
+        // not spend the worst-case four round trips here.
+        expect(visibilityDispatches).toHaveLength(4);
+        expect(visibilityDispatches.every(([options]) => options.target.allFrames !== true)).toBe(true);
+    });
+
+    it('skips the visibility handshake when no frame has a video yet', async () => {
+        // Selecting an anime tab before playback must be immediate: there is
+        // nothing to rank, so the handshake and the retry budget are pure delay.
+        const results = [
+            frame(0, { bestVideo: null, videoCount: 0 }),
+            frame(3, { bestVideo: null, videoCount: 0 }),
+            frame(4, { bestVideo: null, videoCount: 0 })
+        ];
+        const executeScript = vi.fn().mockResolvedValue(results);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            42,
+            { probeDelayMs: 0, retryDelayMs: 0 }
+        )).resolves.toMatchObject({ frameId: 0, hasVideo: false });
+
+        expect(executeScript.mock.calls.filter(([options]) => (
+            options.func?.name === 'dispatchParentFrameVisibilityProbe'
+                || options.func?.name === 'installParentFrameVisibilityProbe'
+        ))).toHaveLength(0);
+        // And it must not burn all eight attempts waiting for a video that no
+        // frame has: the injected monitor reports one the moment it appears.
+        const inspections = executeScript.mock.calls.filter(([options]) => (
+            options.func?.name === 'inspectMediaFrame'
+        ));
+        expect(inspections.length).toBeLessThanOrEqual(4);
     });
 
     it('keeps the top target inactive when the only discovered video is hidden', async () => {
@@ -154,11 +242,8 @@ describe('cross-origin media-frame targeting', () => {
             documentId: null,
             frameUrl: null,
             hasVideo: false,
-            scriptTarget: { tabId: 42 },
-            monitorTargets: [
-                { tabId: 42, documentIds: ['document-0'] },
-                { tabId: 42, documentIds: ['document-6'] }
-            ]
+            discoveredFrameIds: [0, 6],
+            scriptTarget: { tabId: 42 }
         });
     });
 
@@ -172,108 +257,9 @@ describe('cross-origin media-frame targeting', () => {
         )).resolves.toMatchObject({
             frameId: 8,
             hasVideo: true,
-            scriptTarget: { tabId: 42, documentIds: ['document-8'] },
-            monitorTargets: expect.arrayContaining([
-                { tabId: 42, documentIds: ['document-8'] }
-            ])
-        });
-        expect(executeScript.mock.calls.some(([options]) => (
-            options.target?.tabId === 42 && options.target?.allFrames === true
-        ))).toBe(true);
-    });
-
-    it('isolates a rejected all-frame sweep and still finds an embedded player', async () => {
-        const top = frame(0, {
-            href: 'https://anime.example/watch',
-            origin: 'https://anime.example',
-            bestVideo: null,
-            videoCount: 0,
-            embeddedFrames: [{
-                href: 'https://player.example/embed',
-                origin: 'https://player.example',
-                area: 860 * 490,
-                width: 860,
-                height: 490,
-                visible: true,
-                mediaHint: true
-            }]
-        });
-        const player = frame(1, {
-            href: 'https://player.example/embed'
-        });
-        const executeScript = vi.fn(async options => {
-            if (options.target?.allFrames === true) throw new Error('one frame rejected');
-            const frameId = options.target?.frameIds?.[0];
-            if (options.func?.name === 'inspectMediaFrame') {
-                if (frameId === 0) return [top];
-                if (frameId === 1) return [player];
-                return [];
-            }
-            return [];
-        });
-
-        await expect(resolveMediaContentTarget(
-            { scripting: { executeScript } },
-            47,
-            { attempts: 1, probeDelayMs: 0 }
-        )).resolves.toMatchObject({
-            frameId: 1,
-            documentId: 'document-1',
-            hasVideo: true,
-            scriptTarget: { tabId: 47, documentIds: ['document-1'] },
-            monitorTargets: expect.arrayContaining([
-                { tabId: 47, documentIds: ['document-0'] },
-                { tabId: 47, documentIds: ['document-1'] }
-            ])
-        });
-    });
-
-    it('sweeps individual frame IDs when an all-frame result is partial', async () => {
-        const top = frame(0, {
-            href: 'https://anime.example/watch',
-            origin: 'https://anime.example',
-            bestVideo: null,
-            videoCount: 0,
-            embeddedFrames: [{
-                href: 'https://player.example/embed',
-                origin: 'https://player.example',
-                area: 860 * 490,
-                width: 860,
-                height: 490,
-                visible: true,
-                mediaHint: true
-            }]
-        });
-        const partialFrame = frame(2, { bestVideo: null, videoCount: 0 });
-        const player = frame(3, { href: 'https://player.example/embed' });
-        const executeScript = vi.fn(async options => {
-            if (options.target?.allFrames === true) {
-                return options.func?.name === 'inspectMediaFrame' ? [top, partialFrame] : [];
-            }
-            const frameId = options.target?.frameIds?.[0];
-            if (options.func?.name === 'inspectMediaFrame') {
-                if (frameId === 0) return [top];
-                if (frameId === 3) return [player];
-                return [];
-            }
-            return [];
-        });
-
-        await expect(resolveMediaContentTarget(
-            { scripting: { executeScript } },
-            48,
-            { attempts: 1, probeDelayMs: 0 }
-        )).resolves.toMatchObject({
-            frameId: 3,
-            documentId: 'document-3',
-            hasVideo: true,
-            scriptTarget: { tabId: 48, documentIds: ['document-3'] },
-            monitorTargets: expect.arrayContaining([
-                { tabId: 48, documentIds: ['document-0'] },
-                { tabId: 48, documentIds: ['document-2'] },
-                { tabId: 48, documentIds: ['document-3'] }
-            ])
+            scriptTarget: { tabId: 42, documentIds: ['document-8'] }
         });
+        expect(executeScript.mock.calls[0][0].target).toEqual({ tabId: 42, allFrames: true });
     });
 
     it('does not trust parent visibility from an older probe token', () => {
@@ -538,12 +524,15 @@ describe('cross-origin media-frame targeting', () => {
         )).resolves.toMatchObject({ frameId: 0, scriptTarget: { tabId: 44 } });
     });
 
-    it('keeps the tab target active when equal player frames are ambiguous', async () => {
+    it('holds the top frame instead of guessing between equal players', async () => {
         const results = [
             frame(3, { parentFrameVisible: null }),
             frame(4, { parentFrameVisible: null })
         ];
         const executeScript = vi.fn().mockResolvedValue(results);
+        // Equally-ranked mirrors are an ordinary anime-site layout. Refusing to
+        // activate made those pages unusable; the tab stays selected on its top
+        // frame until one of the players starts and breaks the tie.
         await expect(resolveMediaContentTarget(
             { scripting: { executeScript } },
             45,
@@ -551,7 +540,116 @@ describe('cross-origin media-frame targeting', () => {
         )).resolves.toMatchObject({
             frameId: 0,
             hasVideo: false,
+            ambiguous: true,
             scriptTarget: { tabId: 45 }
         });
     });
 });
+
+describe('embedded player access diagnosis', () => {
+    function driveTop() {
+        return frame(0, {
+            href: 'https://drive.google.com/file/d/abc/view',
+            origin: 'https://drive.google.com',
+            bestVideo: null,
+            videoCount: 0,
+            embeddedFrames: [{
+                href: 'https://youtube.googleapis.com/embed/abc?origin=https%3A%2F%2Fdrive.google.com',
+                origin: 'https://youtube.googleapis.com',
+                area: 640 * 360,
+                width: 640,
+                height: 360,
+                visible: true,
+                depth: 1,
+                mediaHint: true
+            }]
+        });
+    }
+
+    it('does not demand access for a player origin the extension already holds', async () => {
+        const executeScript = vi.fn().mockResolvedValue([driveTop()]);
+        const contains = vi.fn().mockResolvedValue(true);
+
+        // The player frame never answered the probe, but the grant exists. That
+        // is a loading race, not a user decision, so the tab stays selected on
+        // its top frame instead of raising a permission prompt.
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript }, permissions: { contains } },
+            42,
+            { attempts: 1, probeDelayMs: 0 }
+        )).resolves.toEqual({
+            frameId: 0,
+            documentId: null,
+            frameUrl: null,
+            hasVideo: false,
+            discoveredFrameIds: [0],
+            scriptTarget: { tabId: 42 }
+        });
+        expect(contains).toHaveBeenCalledWith({
+            origins: ['https://youtube.googleapis.com/*']
+        });
+    });
+
+    it('demands access only when the browser confirms the origin is withheld', async () => {
+        const executeScript = vi.fn().mockResolvedValue([driveTop()]);
+        const contains = vi.fn().mockResolvedValue(false);
+
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript }, permissions: { contains } },
+            42,
+            { attempts: 1, probeDelayMs: 0 }
+        )).rejects.toMatchObject({
+            code: MEDIA_FRAME_ACCESS_REQUIRED,
+            host: 'youtube.googleapis.com'
+        });
+    });
+
+    it('keeps demanding access when the browser cannot answer', async () => {
+        const executeScript = vi.fn().mockResolvedValue([driveTop()]);
+        const contains = vi.fn().mockRejectedValue(new Error('unavailable'));
+
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript }, permissions: { contains } },
+            42,
+            { attempts: 1, probeDelayMs: 0 }
+        )).rejects.toMatchObject({ code: MEDIA_FRAME_ACCESS_REQUIRED });
+    });
+
+    it('resolves instead of hanging when a frame probe never settles', async () => {
+        const executeScript = vi.fn()
+            .mockImplementationOnce(() => new Promise(() => {}))
+            .mockResolvedValue([frame(0, { bestVideo: null, videoCount: 0 })]);
+
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            42,
+            { attempts: 1, probeDelayMs: 0, probeTimeoutMs: 20 }
+        )).resolves.toMatchObject({ frameId: 0, scriptTarget: { tabId: 42 } });
+    });
+
+    it('prefers a real accessible player over a Drive embed', async () => {
+        const top = frame(0, {
+            href: 'https://drive.google.com/file/d/abc/view',
+            origin: 'https://drive.google.com',
+            bestVideo: video({ controls: true, duration: 2400, renderedArea: 900 * 506 }),
+            embeddedFrames: [{
+                href: 'https://youtube.googleapis.com/embed/abc?origin=https%3A%2F%2Fdrive.google.com',
+                origin: 'https://youtube.googleapis.com',
+                area: 320 * 180,
+                width: 320,
+                height: 180,
+                visible: true,
+                depth: 1,
+                mediaHint: true
+            }]
+        });
+        const executeScript = vi.fn().mockResolvedValue([top]);
+        const contains = vi.fn().mockResolvedValue(false);
+
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript }, permissions: { contains } },
+            42,
+            { attempts: 1, probeDelayMs: 0 }
+        )).resolves.toMatchObject({ frameId: 0, hasVideo: true });
+    });
+});
diff --git a/extension/popup.js b/extension/popup.js
index f44bc11..5d81aa0 100644
--- a/extension/popup.js
+++ b/extension/popup.js
@@ -468,12 +468,12 @@ async function init() {
 
             // Keep a denied selection visible while Chrome waits for the user
             // to grant access; it becomes active automatically after approval.
-            await populateTabs(res.peers, res.targetTabId);
+            await populateTabs(res.peers, res.targetTabId || res.pendingTargetTabId);
 
             // Render lobby status if active
             if (res.episodeLobby) updateLobbyUI(res.episodeLobby, res.peers);
 
-            if (res.status === 'connected' && normalizeTabId(res.targetTabId) === null && localData.roomId) {
+            if (res.status === 'connected' && !res.targetTabId && !res.pendingTargetTabId && localData.roomId) {
                 const syncTabBtn = document.querySelector('.tab-btn[data-tab="tab-sync"]');
                 if (syncTabBtn) syncTabBtn.click();
                 showSelectVideoHint();
@@ -682,7 +682,7 @@ async function refreshTargetAccessState() {
     }
     await populateTabs(
         status.peers,
-        status.targetTabId
+        status.targetTabId ?? status.pendingTargetTabId ?? null
     );
 }
 
@@ -1222,14 +1222,14 @@ async function populateTabs(providedPeers = null, providedTargetTabId = null) {
     const blacklistDomains = getEffectiveBlacklistDomains(await readBlacklistOverrides());
     const isFilterActive = data.filterNoise !== false;
     
-    let currentTargetTabId = normalizeTabId(providedTargetTabId);
+    let currentTargetTabId = providedTargetTabId;
     if (currentTargetTabId === null) {
         const status = await new Promise(r => chrome.runtime.sendMessage({ type: 'GET_STATUS' }, r));
         if (chrome.runtime.lastError) {
             if (populateTabsToken !== token) return;
             currentTargetTabId = null;
         } else {
-            currentTargetTabId = status?.targetTabId ?? null;
+            currentTargetTabId = status?.targetTabId || status?.pendingTargetTabId;
         }
     }
  
@@ -1260,7 +1260,7 @@ async function populateTabs(providedPeers = null, providedTargetTabId = null) {
 
     const filteredTabs = tabs.filter(tab => {
         if (!tab.url || tab.url.startsWith('chrome://')) return false;
-        if (isFilterActive && currentTargetTabId !== null && tab.id !== currentTargetTabId) {
+        if (isFilterActive && tab.id !== parseInt(currentTargetTabId)) {
             if (isUrlBlacklisted(tab.url, blacklistDomains)) return false;
         }
         return true;
@@ -1311,7 +1311,7 @@ async function populateTabs(providedPeers = null, providedTargetTabId = null) {
     // Sort: 1. Current tab first, 2. Matches, 3. Rest alphabetically
     const options = Array.from(elements.targetTab.options);
     const placeholder = options.shift();
-    const currentTabId = currentTargetTabId;
+    const currentTabId = providedTargetTabId ? parseInt(providedTargetTabId) : null;
 
     options.sort((a, b) => {
         const aId = parseInt(a.value);
@@ -1331,7 +1331,7 @@ async function populateTabs(providedPeers = null, providedTargetTabId = null) {
     elements.targetTab.appendChild(placeholder);
     options.forEach(opt => elements.targetTab.appendChild(opt));
 
-    if (currentTargetTabId !== null) {
+    if (currentTargetTabId) {
         elements.targetTab.value = currentTargetTabId;
     } else {
         const matchOpt = options.find(o => o.textContent.includes('⭐ MATCH:'));
@@ -1745,7 +1745,7 @@ if (elements.langSelector) {
                 } else {
                     hideSiteAccessNotice();
                 }
-                await populateTabs(res.peers, res.targetTabId);
+                await populateTabs(res.peers, res.targetTabId || res.pendingTargetTabId);
                 if (res.episodeLobby) updateLobbyUI(res.episodeLobby, res.peers);
             } else {
                 applyConnectionStatus('disconnected');
@@ -2094,7 +2094,7 @@ elements.forceSyncBtn.addEventListener('click', async () => {
     elements.forceSyncBtn.disabled = true;
 
     const status = await new Promise(r => chrome.runtime.sendMessage({ type: 'GET_STATUS' }, r));
-    if (chrome.runtime.lastError || !status || status.targetReady !== true || normalizeTabId(status.targetTabId) === null) {
+    if (chrome.runtime.lastError || !status || !status.targetTabId) {
         elements.forceSyncBtn.disabled = false;
         return;
     }
@@ -2160,8 +2160,7 @@ elements.forceSyncBtn.addEventListener('click', async () => {
                 resolve(false);
                 return;
             }
-            resolve(currentStatus?.targetReady === true
-                && normalizeTabId(currentStatus?.targetTabId) === tabId);
+            resolve(normalizeTabId(currentStatus?.targetTabId) === tabId);
         });
     });
 
@@ -2580,9 +2579,8 @@ elements.copyLogs.addEventListener('click', () => {
         logs = logs || [];
         history = history || [];
 
-        const targetTabId = normalizeTabId(status.targetTabId);
-        const videoPromise = (targetTabId !== null && status.targetReady === true)
-            ? new Promise(resolve => chrome.runtime.sendMessage({ type: 'GET_VIDEO_STATE', tabId: targetTabId }, resolve))
+        const videoPromise = (status && status.targetTabId)
+            ? new Promise(resolve => chrome.runtime.sendMessage({ type: 'GET_VIDEO_STATE', tabId: status.targetTabId }, resolve))
             : Promise.resolve(null);
 
         videoPromise.then(rawVideo => {
@@ -2602,11 +2600,6 @@ elements.copyLogs.addEventListener('click', () => {
         lines.push(`- **User Agent:** ${userAgent}`);
         lines.push('');
 
-        lines.push('## Target');
-        lines.push(`- **Target Tab ID:** ${targetTabId ?? 'none'}`);
-        lines.push(`- **Activation:** ${safe(status.targetActivationState, 'unknown')}`);
-        lines.push('');
-
         // ── Tab ──
         if (rawVideo) {
             lines.push('## Tab');
@@ -2659,9 +2652,7 @@ elements.copyLogs.addEventListener('click', () => {
         // ── Video ──
         lines.push('## Video');
         if (!rawVideo) {
-            lines.push(targetTabId !== null
-                ? '- *Target tab selected; video communication is not ready yet*'
-                : '- *No tab selected / communication failed*');
+            lines.push('- *No tab selected / communication failed*');
         } else if (!vs.found) {
             lines.push('- **Found:** \u274C NO VIDEO ELEMENT');
             if (vs.videoCount != null) lines.push(`- **Video Tags:** ${vs.videoCount}`);
@@ -2801,38 +2792,33 @@ function refreshDebugInfo() {
     if (!devTab || devTab.style.display === 'none') return;
 
     chrome.runtime.sendMessage({ type: 'GET_STATUS' }, (res) => {
-        if (!res || normalizeTabId(res.targetTabId) === null) {
-            if (res?.targetActivationState === 'activating' || res?.targetActivationState === 'access_required') {
-                if (elements.videoDebug) {
-                    elements.videoDebug.textContent = getMessage('DEBUG_TARGET_ACTIVATING');
-                }
-                return;
-            }
-            if (res?.targetActivationState === 'error') {
-                if (elements.videoDebug) {
-                    elements.videoDebug.textContent = res.targetActivationError
-                        ? `Injection fehlgeschlagen: ${res.targetActivationError}`
-                        : 'Video-Injection fehlgeschlagen.';
-                }
-                return;
-            }
+        if (!res || !res.targetTabId) {
             if (elements.videoDebug) elements.videoDebug.textContent = getMessage('DEBUG_NO_TAB');
             return;
         }
 
-        if (res.targetReady !== true) {
-            if (elements.videoDebug) {
-                elements.videoDebug.textContent = res.targetActivationState === 'error'
-                    ? `Injection fehlgeschlagen: ${res.targetActivationError || 'unbekannter Fehler'}`
-                    : getMessage('DEBUG_TARGET_ACTIVATING');
-            }
+        // A target that never finished activating has no content script to talk
+        // to. Reporting that as a communication failure hides the actual reason,
+        // which is the only thing that makes the problem fixable.
+        if (res.targetReady === false && elements.videoDebug) {
+            const reason = res.targetActivationError
+                || (res.targetActivationState === 'access_required'
+                    ? `Website access required${res.pendingTargetHost ? ` for ${res.pendingTargetHost}` : ''}`
+                    : null);
+            elements.videoDebug.textContent = reason
+                ? `${res.targetActivationState}: ${reason}`
+                : `${res.targetActivationState}…`;
             return;
         }
 
         // Request direct state from the content script via background
         chrome.runtime.sendMessage({ type: 'GET_VIDEO_STATE', tabId: res.targetTabId }, (state) => {
             if (!state || (!state.found && state.error)) {
-                if (elements.videoDebug) elements.videoDebug.textContent = getMessage('DEBUG_COMM_FAIL');
+                if (elements.videoDebug) {
+                    elements.videoDebug.textContent = state?.error
+                        ? `${getMessage('DEBUG_COMM_FAIL')} (${state.error})`
+                        : getMessage('DEBUG_COMM_FAIL');
+                }
                 return;
             }
 
diff --git a/extension/target-tab-lifecycle.test.mjs b/extension/target-tab-lifecycle.test.mjs
index 4794389..c46e515 100644
--- a/extension/target-tab-lifecycle.test.mjs
+++ b/extension/target-tab-lifecycle.test.mjs
@@ -8,14 +8,16 @@ const backgroundSource = fs.readFileSync(path.join(extensionDir, 'background.js'
 const contentSource = fs.readFileSync(path.join(extensionDir, 'content.js'), 'utf8');
 const overlaySource = fs.readFileSync(path.join(extensionDir, 'chat-overlay.js'), 'utf8');
 const monitorSource = fs.readFileSync(path.join(extensionDir, 'media-frame-monitor.js'), 'utf8');
-const popupSource = fs.readFileSync(path.join(extensionDir, 'popup.js'), 'utf8');
 const manifest = JSON.parse(fs.readFileSync(path.join(extensionDir, 'manifest.base.json'), 'utf8'));
 
 describe('target tab lifecycle', () => {
     it('injects playback and chat scripts only into the explicitly selected tab', () => {
         expect(backgroundSource).not.toContain('chrome.tabs.onActivated');
         expect(backgroundSource).not.toContain('chrome.tabs.query({})');
-        expect(backgroundSource).toContain('contentTarget = await resolveMediaContentTarget(chrome, tabId)');
+        expect(backgroundSource).toMatch(/contentTarget = await resolveMediaContentTarget\(chrome, tabId, \{\s*knownFrameIds/);
+        // Frame ids must come from observed senders, never from a navigation permission.
+        expect(backgroundSource).toContain('function rememberFrameId(tabId, frameId)');
+        expect(backgroundSource).toContain('rememberFrameId(senderTabId, sender?.frameId)');
         expect(backgroundSource).toContain('target: scriptTarget');
         expect(backgroundSource).toContain("files: ['chat-format.js', 'chat-overlay.js', 'content.js']");
         expect(backgroundSource).toContain("chrome.tabs.query({ url: 'https://sync.koalastuff.net/*' })");
@@ -23,23 +25,74 @@ describe('target tab lifecycle', () => {
         const activationStart = backgroundSource.indexOf('async function activateTargetTab');
         const activationEnd = backgroundSource.indexOf('async function reactivateCurrentTarget', activationStart);
         const activationSource = backgroundSource.slice(activationStart, activationEnd);
-        expect(activationSource.indexOf('await injectContentScript(selectedTabId'))
-            .toBeLessThan(activationSource.indexOf('await deactivateTargetTab(previousTabId, previousContentTarget)'));
+        expect(activationSource.indexOf('await deactivateTargetTab(previousTabId)'))
+            .toBeLessThan(activationSource.indexOf('await injectContentScript(selectedTabId'));
         expect(activationSource).toContain('previousTabId !== selectedTabId');
-        expect(activationSource).toContain('keeping tab ${previousTabId} selected');
         expect(contentSource).toContain('if (window.koalaSyncInjected && chrome.runtime.id)');
         expect(overlaySource).toContain('if (window.koalaSyncChatOverlay?.refresh)');
     });
 
+    it('keeps the chat overlay in the top document when the player is nested', () => {
+        expect(backgroundSource).toContain('function sendMessageToChatOverlay(message)');
+        expect(backgroundSource).toContain('return sendMessageToFrame(tabId, 0, message)');
+        // Every chat-facing message must reach the overlay's frame, not the
+        // player's. A stray sendMessageToCurrentContent here renders the chat
+        // inside the video on Drive.
+        expect(backgroundSource).not.toMatch(/sendMessageToCurrentContent\(\{\s*type: 'CHAT/);
+        expect(backgroundSource).toMatch(
+            /target: \{ tabId, frameIds: \[0\] \},\s*files: \['chat-format\.js', 'chat-overlay\.js'\]/
+        );
+        expect(backgroundSource).toContain("files: ['content.js']");
+        expect(backgroundSource).toContain('if (normalizeFrameId(target.frameId) !== 0)');
+    });
+
+    it('does not reactivate the target for ordinary playback churn', () => {
+        expect(backgroundSource).toContain('async function selectedMediaTargetMoved(tabId)');
+        expect(backgroundSource).toContain('onlyIfTargetMoved = true');
+        // Forcing a rebuild must stay rare and deliberate: an unreachable content
+        // script, an explicit request, and a completed navigation. Everything else
+        // takes the guarded path by default.
+        expect(backgroundSource.match(/onlyIfTargetMoved: false/g)?.length).toBe(3);
+        // Playback state must stay out of the candidate signature, otherwise
+        // every play/pause looks like a frame layout change.
+        expect(monitorSource).not.toContain('element.paused ? 0 : 1');
+        expect(monitorSource).toContain('element.readyState > 0 ? 1 : 0');
+    });
+
+    it('keeps the frame registry bounded and free of a navigation permission', () => {
+        expect(backgroundSource).toContain('const MAX_KNOWN_FRAMES_PER_TAB = 24');
+        // Frame ids are learned, never enumerated through a permission.
+        expect(backgroundSource).toContain('function rememberFrameId(tabId, frameId)');
+        expect(backgroundSource).toContain('rememberFrameId(senderTabId, sender?.frameId)');
+        expect(backgroundSource).toContain('contentTarget.discoveredFrameIds');
+        // The registry must never be cleared on navigation: tabs.onUpdated
+        // reports 'loading' for same-document History API navigations too, which
+        // is exactly when these players are built. It self-corrects instead.
+        expect(backgroundSource).toContain('function refreshFrameIds(tabId, frameIds)');
+        expect(backgroundSource).not.toMatch(/changeInfo\.status === 'loading'[\s\S]{0,160}forgetFrameIds/);
+        expect(backgroundSource).toContain('refreshFrameIds(tabId, contentTarget.discoveredFrameIds)');
+        expect(backgroundSource).not.toMatch(/chrome\.webNavigation/);
+    });
+
+    it('bounds every frame probe and verifies withheld origins', () => {
+        const resolverSource = fs.readFileSync(
+            path.join(extensionDir, 'media-frame-target.js'),
+            'utf8'
+        );
+        expect(resolverSource).toContain('async function originAccessIsWithheld(chromeApi, originPattern)');
+        expect(resolverSource).toContain('probeTimeoutMs = DEFAULT_PROBE_TIMEOUT_MS');
+        expect(resolverSource).toContain('attempts = 8');
+        expect(resolverSource).toContain('deadlineMs = 12000');
+        // A swallowed probe error is what turned a slow player frame into a
+        // permission prompt for an origin the extension already held.
+        expect(resolverSource).toContain('errors.push({ target, error })');
+    });
+
     it('fully deactivates old and superseded target injections', () => {
         expect(backgroundSource).toContain("{ type: 'TARGET_DEACTIVATE' }");
         expect(backgroundSource).toContain('target.documentId');
-        expect(backgroundSource).toContain('await resetAudioProcessingInTab(normalizedTabId, target);');
-        expect(backgroundSource).toContain("{ action: 'RESET_AUDIO_PROCESSING' }");
         expect(backgroundSource.match(/await deactivateTargetTab\(selectedTabId,/g)?.length).toBeGreaterThanOrEqual(6);
         expect(contentSource).toContain("if (message.type === 'TARGET_DEACTIVATE')");
-        expect(contentSource).toContain('destroyContentScript({ preserveAudioRoute: true });');
-        expect(contentSource).toContain('window.__koalaSyncAudioRoute');
         expect(overlaySource).toContain("message?.type === 'TARGET_DEACTIVATE'");
     });
 
@@ -52,11 +105,15 @@ describe('target tab lifecycle', () => {
 
     it('uses all-frame probing for cross-origin targets without navigation permissions', () => {
         expect(backgroundSource).toContain("files: ['media-frame-monitor.js']");
-        expect(backgroundSource).toContain('...listMediaFrameScriptTargets(tabId)');
+        // Monitors must reach the frames we know about, not only whatever the
+        // all-frames sweep happens to accept — both on the way in and out.
+        expect(backgroundSource.match(/\.\.\.listMediaFrameScriptTargets\(tabId\),/g)?.length).toBe(2);
+        expect(backgroundSource.match(/\.\.\.listKnownFrameIds\(tabId\)/g)?.length).toBe(2);
         expect(backgroundSource).toContain('One denied widget frame must not block the selected player');
         expect(backgroundSource).toContain("navigationError.code = 'media_target_navigated'");
-        expect(backgroundSource).toContain('async function deactivateMediaFrameMonitors(tabId, contentTarget');
-        expect(backgroundSource).toContain('func: deactivateMediaFrameMonitor');
+        expect(backgroundSource).toContain("{ type: 'MEDIA_MONITOR_DEACTIVATE' }");
+        expect(backgroundSource).toContain('async function deactivateMediaFrameMonitors(tabId)');
+        expect(backgroundSource).toContain('{ documentId }');
         expect(monitorSource).toContain("type: 'MEDIA_FRAME_CANDIDATE_CHANGED'");
         expect(monitorSource).toContain("attributeFilter: ['class', 'style', 'hidden', 'src', 'controls']");
         expect(monitorSource).toContain('if (!force && nextSignature === lastCandidateSignature) return');
@@ -73,49 +130,6 @@ describe('target tab lifecycle', () => {
         expect(backgroundSource).not.toMatch(/chrome\.(?:web)?Navigation/);
     });
 
-    it('keeps the selected frame recoverable when an all-frame sweep is rejected', () => {
-        expect(backgroundSource).toContain('contentTarget?.scriptTarget');
-        expect(backgroundSource).toContain('...(contentTarget?.monitorTargets || [])');
-        expect(backgroundSource).toContain('function uniqueScriptTargets(targets)');
-        expect(backgroundSource).toContain('function deactivateMediaFrameMonitor()');
-        expect(backgroundSource).toContain('func: deactivateMediaFrameMonitor');
-        expect(backgroundSource).toContain('isMissingContentReceiverError(error)');
-        expect(backgroundSource).toContain('await refreshCurrentMediaTarget(tabId, { queueIfRunning: true })');
-        expect(backgroundSource).toContain("activation?.status === 'activation_in_progress'");
-        expect(backgroundSource).not.toContain('Media frame probe fell back to the top frame');
-    });
-
-    it('does not discard a selected tab when its media frame refresh is transiently unavailable', () => {
-        const refreshFailureGuard = backgroundSource.slice(
-            backgroundSource.indexOf('const isCurrentTargetRefresh'),
-            backgroundSource.indexOf('currentTabId = null', backgroundSource.indexOf('const isCurrentTargetRefresh'))
-        );
-        expect(refreshFailureGuard).toContain('keeping the selected target for recovery');
-        expect(refreshFailureGuard).not.toContain('currentTabId = null');
-
-        const routeSource = backgroundSource.slice(
-            backgroundSource.indexOf('async function _routeToContentInternal'),
-            backgroundSource.indexOf('// --- Keep-Alive Mechanism ---')
-        );
-        expect(routeSource).toContain('keeping the selected target for recovery');
-        expect(routeSource).not.toContain('clearTargetTabForIdle(tabId, targetGeneration)');
-    });
-
-    it('persists the user target while dynamic-frame activation is still retrying', () => {
-        expect(backgroundSource).toContain('let requestedTargetTabId = null;');
-        expect(backgroundSource).toContain('let pendingRequestedActivationCount = 0;');
-        expect(backgroundSource).toContain('await rememberRequestedTarget(selectedTabId, message.tabTitle);');
-        expect(backgroundSource).toContain('pendingRequestedActivationCount > 0');
-        expect(backgroundSource).toContain('await retryRequestedTarget();');
-        expect(backgroundSource).toContain('targetTabId,');
-        expect(backgroundSource).toContain('targetReady');
-        expect(backgroundSource).toContain("targetActivationState");
-        expect(backgroundSource).toContain('await clearRequestedTarget(selectedTabId);');
-        expect(popupSource).not.toContain('getSelectedTargetTabId');
-        expect(popupSource).toContain('await populateTabs(res.peers, res.targetTabId);');
-        expect(popupSource).toContain('res.targetReady !== true');
-    });
-
     it('serializes content commands and coalesces target refreshes', () => {
         expect(backgroundSource).toContain('contentCommandQueue.catch(() => {}).then(deliver)');
         expect(backgroundSource).toContain('if (mediaTargetRefreshTask && mediaTargetRefreshTabId === selectedTabId)');
@@ -128,6 +142,9 @@ describe('target tab lifecycle', () => {
 
     it('tears down every persistent content-script resource', () => {
         expect(contentSource).toContain('function destroyContentScript({ preserveAudioRoute = false } = {})');
+        // Deselecting a tab hands the page back to itself; it must not go mute.
+        expect(contentSource).toContain('destroyContentScript({ preserveAudioRoute: true });');
+        expect(contentSource).toContain('if (!preserveAudioRoute) closeAudioContext();');
         expect(contentSource).toContain('observer.disconnect()');
         expect(contentSource).toContain('keepAlivePort.disconnect()');
         expect(contentSource).toContain('for (const video of [...attachedVideos]) detachVideoListeners(video);');
diff --git a/tests/e2e/extension.spec.mjs b/tests/e2e/extension.spec.mjs
index e13e07a..62e719e 100644
--- a/tests/e2e/extension.spec.mjs
+++ b/tests/e2e/extension.spec.mjs
@@ -476,6 +476,37 @@ test('re-elects the visible cross-origin player after an iframe switch', async (
     expect(await first.locator('video').evaluate(video => video.paused)).toBe(true);
 });
 
+test('immediately adopts and syncs when switching mirrors while first mirror was active and playing', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/cross-origin-switching.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+    const first = page.frames().find(frame => frame.url().includes('/frames/player-frame.html?slot=first'));
+    const second = page.frames().find(frame => frame.url().includes('/frames/player-frame-2.html?slot=second'));
+    const { tabId } = await selectTargetTab(context, extensionId, url);
+
+    await expect.poll(() => first.locator('video').getAttribute('data-koala-attached')).toBe('true');
+    await sendServerCommand(context, extensionId, tabId, 'play');
+    await expect.poll(() => first.locator('video').evaluate(video => !video.paused)).toBe(true);
+
+    const firstStatus = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(firstStatus.targetHasVideo).toBe(true);
+
+    // Switch mirror and play second video directly in the new frame
+    await page.evaluate(() => window.switchPlayer());
+    await second.locator('video').evaluate(video => video.play());
+
+    // Should immediately adopt the second mirror
+    await expect.poll(async () => {
+        const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+        return status.targetFrameId;
+    }).not.toBe(firstStatus.targetFrameId);
+
+    // Commands must now control the second frame without delay
+    await sendServerCommand(context, extensionId, tabId, 'pause');
+    await expect.poll(() => second.locator('video').evaluate(video => video.paused)).toBe(true);
+});
+
 test('keeps commands flowing during continuous player-frame geometry changes', async ({ context, extensionId, baseURL }) => {
     const url = `${baseURL}/pages/cross-origin-switching.html`;
     const page = await context.newPage();
@@ -607,6 +638,366 @@ test('rejects a hidden cross-origin player after its iframe URL redirects', asyn
     expect(await redirectedFrame.locator('video').getAttribute('data-koala-attached')).toBeNull();
 });
 
+test('selects the visible anime player nested behind a same-origin wrapper', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/yummy-style-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { tabId, response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok', hasVideo: true });
+    expect(response.frameId).not.toBe(0);
+
+    // The playable element is the one inside the visible wrapper. The two
+    // zero-sized mirrors must be ignored, not treated as equal candidates.
+    const playerFrame = suffix => page.frames()
+        .find(frame => frame.url().endsWith(`/frames/${suffix}`));
+    await expect
+        .poll(() => playerFrame('player-frame.html').locator('video').getAttribute('data-koala-attached'))
+        .toBe('true');
+    expect(await playerFrame('player-frame-2.html').locator('video')
+        .getAttribute('data-koala-attached')).toBeNull();
+
+    // And the selection has to settle, not keep re-resolving.
+    await page.waitForTimeout(1500);
+    const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(status).toMatchObject({
+        targetTabId: tabId,
+        targetReady: true,
+        targetActivationState: 'ready'
+    });
+});
+
+test('selects an anime tab before playback and promotes the player once it appears', async ({ context, extensionId, baseURL }) => {
+    // The live case: at selection time the page has no video anywhere, because
+    // the host only builds the player when the viewer presses play.
+    const url = `${baseURL}/pages/yummy-deferred-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { tabId, response } = await selectTargetTab(context, extensionId, url);
+    // Selecting must succeed and settle even with nothing to control yet.
+    expect(response).toMatchObject({ status: 'ok', frameId: 0, hasVideo: false });
+
+    await page.waitForTimeout(1200);
+    const idle = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(idle).toMatchObject({
+        targetTabId: tabId,
+        targetReady: true,
+        targetActivationState: 'ready'
+    });
+
+    const deferred = page.frames().find(frame => frame.url().endsWith('/frames/deferred-player-frame.html'));
+    await deferred.locator('#poster').click();
+
+    // The monitor has to hand the target over to the frame that now owns the
+    // video, without the user touching the popup again.
+    await expect
+        .poll(() => deferred.locator('video').getAttribute('data-koala-attached'), { timeout: 15000 })
+        .toBe('true');
+    await expect
+        .poll(() => getExtensionState(context, extensionId, { type: 'GET_STATUS' })
+            .then(state => ({ ready: state.targetReady, frame: state.targetFrameId })), { timeout: 15000 })
+        .toMatchObject({ ready: true });
+    const promoted = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(promoted.targetFrameId).not.toBe(0);
+    expect(promoted).toMatchObject({ targetTabId: tabId, targetActivationState: 'ready' });
+});
+
+test('polling video state on a page with no video does not restart the target', async ({ context, extensionId, baseURL }) => {
+    // The dev panel polls GET_VIDEO_STATE on a timer. On an anime page the
+    // answer is legitimately "no video" until playback starts, and treating
+    // that as a broken injection reactivated the target on every poll — which
+    // is what pinned the popup on "activating" forever.
+    const url = `${baseURL}/pages/yummy-deferred-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { tabId } = await selectTargetTab(context, extensionId, url);
+
+    for (let poll = 0; poll < 6; poll++) {
+        const state = await getExtensionState(context, extensionId, { type: 'GET_VIDEO_STATE', tabId });
+        expect(state?.error, 'reading video state must not report a target change').toBeFalsy();
+        expect(state).toMatchObject({ found: false });
+        const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+        expect(status, `poll ${poll} must leave the target ready`).toMatchObject({
+            targetTabId: tabId,
+            targetReady: true,
+            targetActivationState: 'ready'
+        });
+    }
+
+    // And the player is still picked up once it exists.
+    const deferred = page.frames().find(frame => frame.url().endsWith('/frames/deferred-player-frame.html'));
+    await deferred.locator('#poster').click();
+    await expect
+        .poll(() => deferred.locator('video').getAttribute('data-koala-attached'), { timeout: 15000 })
+        .toBe('true');
+});
+
+test('stays ready on a page whose ad frames keep mutating', async ({ context, extensionId, baseURL }) => {
+    test.setTimeout(90000);
+    // Live ad churn wakes the media-frame monitor several times a second. Each
+    // wake used to schedule a trailing refresh that rebuilt the target
+    // unconditionally, and rebuilding produced more churn — a loop that never
+    // let the activation settle and pinned the popup on "activating".
+    const url = `${baseURL}/pages/yummy-churning-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { tabId } = await selectTargetTab(context, extensionId, url);
+
+    for (let sample = 0; sample < 8; sample++) {
+        await page.waitForTimeout(700);
+        const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+        expect(status, `sample ${sample} must not be stuck activating`).toMatchObject({
+            targetTabId: tabId,
+            targetReady: true,
+            targetActivationState: 'ready'
+        });
+    }
+
+    // The player still has to be picked up while the churn continues.
+    const deferred = page.frames().find(frame => frame.url().endsWith('/frames/deferred-player-frame.html'));
+    await deferred.locator('#poster').click();
+    await expect
+        .poll(() => deferred.locator('video').getAttribute('data-koala-attached'), { timeout: 20000 })
+        .toBe('true');
+    await expect
+        .poll(() => getExtensionState(context, extensionId, { type: 'GET_STATUS' })
+            .then(state => state.targetActivationState), { timeout: 20000 })
+        .toBe('ready');
+});
+
+test('controls and adopts a nested player even while the top frame is elected', async ({ context, extensionId, baseURL }) => {
+    // The failure mode reported from the live site: the election names the top
+    // frame, which holds no video, so commands go nowhere and the user's own
+    // play/pause from the real player frame is discarded as a stale sender.
+    const url = `${baseURL}/pages/yummy-deferred-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { tabId, response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok', frameId: 0, hasVideo: false });
+
+    // Build the player without giving the monitor a chance to promote first.
+    const deferred = page.frames().find(frame => frame.url().endsWith('/frames/deferred-player-frame.html'));
+    await deferred.locator('#poster').click();
+    await expect.poll(() => deferred.locator('video').count()).toBe(1);
+
+    // A command must reach the frame that owns the video regardless of election.
+    await sendServerCommand(context, extensionId, tabId, 'play', { time: 1 });
+    await expect
+        .poll(() => deferred.locator('video').evaluate(video => video.paused), { timeout: 15000 })
+        .toBe(false);
+
+    // And once that frame reports playback, it becomes the addressed target.
+    await expect
+        .poll(() => getExtensionState(context, extensionId, { type: 'GET_STATUS' })
+            .then(state => state.targetFrameId), { timeout: 15000 })
+        .not.toBe(0);
+    const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(status).toMatchObject({ targetTabId: tabId, targetHasVideo: true });
+});
+
+test('recovers when the adopted player frame is torn down and rebuilt', async ({ context, extensionId, baseURL }) => {
+    test.setTimeout(90000);
+    // Kodik rebuilds its player frame on quality and part changes, which kills
+    // the documentId the election is pinned to. The election has to be given up,
+    // otherwise every later message fails with "Receiving end does not exist"
+    // and nothing moves the target back.
+    const url = `${baseURL}/pages/yummy-deferred-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { tabId } = await selectTargetTab(context, extensionId, url);
+    // After the rebuild both the detached and the live frame carry the same URL,
+    // so take the most recent attached one or the test drives a dead document.
+    const deferredFrame = () => page.frames()
+        .filter(frame => !frame.isDetached()
+            && frame.url().endsWith('/frames/deferred-player-frame.html'))
+        .pop();
+
+    await deferredFrame().locator('#poster').click();
+    await expect
+        .poll(() => getExtensionState(context, extensionId, { type: 'GET_STATUS' })
+            .then(state => state.targetHasVideo), { timeout: 20000 })
+        .toBe(true);
+    const adoptedFrameId = (await getExtensionState(context, extensionId, { type: 'GET_STATUS' })).targetFrameId;
+    expect(adoptedFrameId).not.toBe(0);
+
+    // Destroy the elected document the way the real player does.
+    const wrapper = page.frames().find(frame => frame.url().includes('xfp-wrapper.html?player=deferred'));
+    await wrapper.evaluate(() => {
+        const inner = document.getElementById('inner');
+        inner.src = inner.src;
+    });
+    await expect.poll(() => deferredFrame()?.locator('#poster').count().catch(() => 0)).toBe(1);
+
+    // The dead election must be released rather than kept forever.
+    await expect
+        .poll(() => getExtensionState(context, extensionId, { type: 'GET_VIDEO_STATE', tabId })
+            .then(state => state?.error || null), { timeout: 20000 })
+        .toBeNull();
+    const released = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(released).toMatchObject({ targetTabId: tabId, targetHasVideo: false });
+
+    // And the rebuilt player is picked up again without touching the popup. The
+    // rebuilt document wires its poster from an inline script, so a click can
+    // land before the handler exists — retry until the player is really built.
+    await expect.poll(async () => {
+        const frame = deferredFrame();
+        if (!frame) return 0;
+        if (await frame.locator('video').count() > 0) return 1;
+        await frame.locator('#poster').click({ timeout: 2000 }).catch(() => {});
+        return 0;
+    }, { timeout: 20000 }).toBe(1);
+    await expect
+        .poll(() => deferredFrame().locator('video').getAttribute('data-koala-attached'), { timeout: 20000 })
+        .toBe('true');
+    await expect
+        .poll(() => getExtensionState(context, extensionId, { type: 'GET_STATUS' })
+            .then(state => state.targetHasVideo), { timeout: 20000 })
+        .toBe(true);
+});
+
+test('keeps the tab selected when its activation fails', async ({ context, extensionId }) => {
+    // A page the extension is not allowed to script stands in for any activation
+    // failure the user can act on. Losing the selection here is what made the
+    // popup come back empty after it was closed and reopened.
+    const page = await context.newPage();
+    await page.goto('chrome://version');
+
+    const { tabId, response } = await selectTargetTab(context, extensionId, 'chrome://version/*');
+    expect(response?.status).not.toBe('ok');
+
+    const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(status).toMatchObject({
+        targetTabId: tabId,
+        targetReady: false,
+        targetActivationState: 'error'
+    });
+    expect(status.targetActivationError).toBeTruthy();
+
+    // Reopening the popup must not quietly retry and must not lose the choice.
+    const second = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(second).toMatchObject({ targetTabId: tabId, targetActivationState: 'error' });
+});
+
+test('drops the selection only when the user clears it', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/simple-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { tabId } = await selectTargetTab(context, extensionId, url);
+    await expect
+        .poll(() => getExtensionState(context, extensionId, { type: 'GET_STATUS' })
+            .then(state => state.targetTabId))
+        .toBe(tabId);
+
+    const cleared = await getExtensionState(context, extensionId, {
+        type: 'SET_TARGET_TAB',
+        tabId: null
+    });
+    expect(cleared).toMatchObject({ status: 'ok', tabId: null });
+
+    const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(status).toMatchObject({
+        targetTabId: null,
+        targetReady: false,
+        targetActivationState: 'none'
+    });
+});
+
+/**
+ * Reads one global from the top document and from the player frame separately,
+ * so a test can prove which frame a script was installed in.
+ */
+async function readPerFrameGlobal(context, extensionId, pageUrl, globalName) {
+    return withExtensionPage(context, extensionId, page => page.evaluate(async ({ pageUrl, globalName }) => {
+        const [tab] = await chrome.tabs.query({ url: pageUrl });
+        if (!tab) throw new Error(`no tab matched ${pageUrl}`);
+        const results = await chrome.scripting.executeScript({
+            target: { tabId: tab.id, allFrames: true },
+            func: name => ({
+                href: location.href,
+                isTop: window.top === window,
+                present: typeof window[name] !== 'undefined' && window[name] !== null
+            }),
+            args: [globalName]
+        });
+        const entries = results.map(entry => entry.result).filter(Boolean);
+        return {
+            top: entries.find(entry => entry.isTop)?.present ?? null,
+            player: entries.find(entry => !entry.isTop && entry.href.includes('player-frame'))?.present ?? null
+        };
+    }, { pageUrl, globalName }));
+}
+
+test('controls a Drive-style cross-origin player without moving the chat into it', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/drive-style-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { response } = await selectTargetTab(context, extensionId, url);
+    // The top document hosts no video, so the target must be the player frame.
+    expect(response).toMatchObject({ status: 'ok', hasVideo: true });
+    expect(response.frameId).not.toBe(0);
+
+    const playerFrame = page.frames().find(frame => frame.url().includes('player-frame'));
+    await expect
+        .poll(() => playerFrame.locator('video').getAttribute('data-koala-attached'))
+        .toBe('true');
+
+    // The controller belongs in the player frame...
+    await expect
+        .poll(() => readPerFrameGlobal(context, extensionId, url, 'koalaSyncInjected'))
+        .toMatchObject({ player: true });
+    // ...and the chat overlay belongs in the top document, never inside the
+    // video. Installing it in the player frame is what rendered the chat on top
+    // of the picture and made closing it affect only that frame.
+    await expect
+        .poll(() => readPerFrameGlobal(context, extensionId, url, 'koalaSyncChatOverlay'))
+        .toMatchObject({ top: true, player: false });
+});
+
+test('keeps controlling a Drive-style player across an ordinary play and pause', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/drive-style-player.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const { tabId, response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok' });
+    const selectedFrameId = response.frameId;
+
+    const playerFrame = page.frames().find(frame => frame.url().includes('player-frame'));
+    await playerFrame.locator('video').evaluate(video => video.play());
+    await playerFrame.locator('video').evaluate(video => video.pause());
+    await page.waitForTimeout(750);
+
+    // Playback state changes are not frame layout changes. If they were treated
+    // as such, the target would be torn down and re-injected mid-playback.
+    const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(status).toMatchObject({
+        targetTabId: tabId,
+        targetReady: true,
+        targetActivationState: 'ready',
+        targetFrameId: selectedFrameId
+    });
+
+    const command = await sendServerCommand(context, extensionId, tabId, 'play', { time: 1 });
+    expect(command).toMatchObject({ status: 'ok_solo' });
+    await expect.poll(() => playerFrame.locator('video').evaluate(video => video.paused)).toBe(false);
+});
+
 function FRAMED_VIDEO_PAUSED() {
     return document.querySelector('iframe').contentDocument.querySelector('video').paused;
 }
diff --git a/tests/e2e/fixtures/pages/drive-style-player.html b/tests/e2e/fixtures/pages/drive-style-player.html
new file mode 100644
index 0000000..7c61d32
--- /dev/null
+++ b/tests/e2e/fixtures/pages/drive-style-player.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Drive-style embedded player</title>
+<style>
+  body { margin: 0; font: 14px sans-serif; }
+  #shell { padding: 24px; }
+  iframe { border: 0; }
+</style>
+<!--
+  Mirrors the Google Drive / YummyAnime layout: the top document owns the page
+  chrome and hosts no video at all, while the only player lives in a visible
+  cross-origin iframe. Playback control belongs in that frame; the chat overlay
+  must stay in this document.
+-->
+<div id="shell">
+  <h1>Shared file</h1>
+  <iframe id="player-frame" width="854" height="480" allowfullscreen></iframe>
+</div>
+<script>
+  const frame = document.getElementById('player-frame');
+  frame.src = `http://127.0.0.1:${location.port}/pages/frames/player-frame.html`;
+  frame.addEventListener('load', () => { window.__fixtureReady = true; }, { once: true });
+</script>
diff --git a/tests/e2e/fixtures/pages/frames/deferred-player-frame.html b/tests/e2e/fixtures/pages/frames/deferred-player-frame.html
new file mode 100644
index 0000000..67beca9
--- /dev/null
+++ b/tests/e2e/fixtures/pages/frames/deferred-player-frame.html
@@ -0,0 +1,27 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Deferred player frame</title>
+<style>
+  body { margin: 0; background: #111; }
+  #poster { width: 854px; height: 480px; color: #fff; font: 16px sans-serif;
+            display: flex; align-items: center; justify-content: center; cursor: pointer; }
+</style>
+<!--
+  The shape anime hosts actually ship: a poster with a play overlay, and no
+  <video> in the document at all until the viewer starts playback. Selecting the
+  tab before that point must still work, and the real player has to be picked up
+  the moment it appears.
+-->
+<div id="poster">Play</div>
+<script>
+  document.getElementById('poster').addEventListener('click', () => {
+    const video = document.createElement('video');
+    video.id = 'deferred-player';
+    video.width = 854;
+    video.height = 480;
+    video.controls = true;
+    video.src = '../../media/player-480p-12s.mp4';
+    document.body.append(video);
+    document.getElementById('poster').remove();
+  }, { once: true });
+</script>
diff --git a/tests/e2e/fixtures/pages/frames/xfp-wrapper.html b/tests/e2e/fixtures/pages/frames/xfp-wrapper.html
new file mode 100644
index 0000000..5530bbe
--- /dev/null
+++ b/tests/e2e/fixtures/pages/frames/xfp-wrapper.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>xfp wrapper</title>
+<style>
+  html, body { margin: 0; height: 100%; }
+  iframe { border: 0; display: block; }
+</style>
+<!--
+  Same-origin shell the anime site puts between the page and the real player.
+  It holds no video itself; the playable element lives one more level down in a
+  cross-origin frame.
+-->
+<iframe id="inner" width="830" height="498" allowfullscreen></iframe>
+<script>
+  const inner = document.getElementById('inner');
+  const params = new URLSearchParams(location.search);
+  const target = params.get('player') || 'player-frame.html';
+  inner.src = `http://127.0.0.1:${location.port}/pages/frames/${target}`;
+</script>
diff --git a/tests/e2e/fixtures/pages/yummy-churning-player.html b/tests/e2e/fixtures/pages/yummy-churning-player.html
new file mode 100644
index 0000000..9500954
--- /dev/null
+++ b/tests/e2e/fixtures/pages/yummy-churning-player.html
@@ -0,0 +1,43 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Anime page with live ad churn</title>
+<style>
+  body { margin: 0; font: 14px sans-serif; }
+  #info { height: 900px; padding: 24px; }
+  iframe { border: 0; }
+  #visible-wrapper { display: block; }
+  #hidden-wrapper { width: 0; height: 0; display: block; }
+  #ads iframe { width: 300px; height: 60px; display: block; }
+</style>
+<!--
+  The anime layout plus what the real site actually does while you look at it:
+  ad slots that add, remove and resize frames continuously. Every one of those
+  mutations wakes the media-frame monitor, so this is the fixture that exposes a
+  reactivation loop — a static page never will.
+-->
+<div id="info">
+  <h1>Series page</h1>
+  <div id="ads"></div>
+</div>
+<iframe id="visible-wrapper" name="xfplayer_visible" width="830" height="498"
+        src="frames/xfp-wrapper.html?player=deferred-player-frame.html" allowfullscreen></iframe>
+<iframe id="hidden-wrapper" name="xfplayer_hidden"
+        src="frames/xfp-wrapper.html?player=player-frame-2.html" allowfullscreen></iframe>
+<script>
+  const ads = document.getElementById('ads');
+  let tick = 0;
+  setInterval(() => {
+    tick++;
+    const stale = ads.firstElementChild;
+    if (stale && tick % 2 === 0) stale.remove();
+    const slot = document.createElement('iframe');
+    slot.src = `about:blank#ad-${tick}`;
+    slot.style.height = `${40 + (tick % 5) * 8}px`;
+    ads.append(slot);
+  }, 150);
+
+  const wrappers = [...document.querySelectorAll('#visible-wrapper, #hidden-wrapper')];
+  Promise.all(wrappers.map(f => new Promise(resolve => {
+    f.addEventListener('load', resolve, { once: true });
+  }))).then(() => { window.__fixtureReady = true; });
+</script>
diff --git a/tests/e2e/fixtures/pages/yummy-deferred-player.html b/tests/e2e/fixtures/pages/yummy-deferred-player.html
new file mode 100644
index 0000000..61d56da
--- /dev/null
+++ b/tests/e2e/fixtures/pages/yummy-deferred-player.html
@@ -0,0 +1,29 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Anime-style player built on demand</title>
+<style>
+  body { margin: 0; font: 14px sans-serif; }
+  #info { height: 900px; padding: 24px; }
+  iframe { border: 0; }
+  #visible-wrapper { display: block; }
+  #hidden-wrapper { width: 0; height: 0; display: block; }
+</style>
+<!--
+  Same layout as yummy-style-player.html, except the visible player builds its
+  <video> only when the viewer presses play. Until then the tab has no video at
+  all, which is the state the extension is in when the user picks the tab.
+-->
+<div id="info">
+  <h1>Series page</h1>
+  <p>Description block that pushes the player below the fold.</p>
+</div>
+<iframe id="visible-wrapper" name="xfplayer_visible" width="830" height="498"
+        src="frames/xfp-wrapper.html?player=deferred-player-frame.html" allowfullscreen></iframe>
+<iframe id="hidden-wrapper" name="xfplayer_hidden"
+        src="frames/xfp-wrapper.html?player=player-frame-2.html" allowfullscreen></iframe>
+<script>
+  const frames = [...document.querySelectorAll('iframe')];
+  Promise.all(frames.map(f => new Promise(resolve => {
+    f.addEventListener('load', resolve, { once: true });
+  }))).then(() => { window.__fixtureReady = true; });
+</script>
diff --git a/tests/e2e/fixtures/pages/yummy-style-player.html b/tests/e2e/fixtures/pages/yummy-style-player.html
new file mode 100644
index 0000000..305f4f5
--- /dev/null
+++ b/tests/e2e/fixtures/pages/yummy-style-player.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Anime-style nested player</title>
+<style>
+  body { margin: 0; font: 14px sans-serif; }
+  #info { height: 900px; padding: 24px; }
+  iframe { border: 0; }
+  #visible-wrapper { display: block; }
+  #hidden-wrapper, #hidden-trailer { width: 0; height: 0; display: block; }
+</style>
+<!--
+  Mirrors the live yummyanime.tv layout:
+    top (no video)
+    ├── visible same-origin wrapper 830x498 -> cross-origin player  (the real one)
+    ├── hidden same-origin wrapper  0x0     -> cross-origin mirror
+    └── hidden cross-origin trailer 0x0
+  The player sits two levels down and below the fold, and two other players are
+  loaded at zero size. Picking the visible one is the whole job.
+-->
+<div id="info">
+  <h1>Series page</h1>
+  <p>Description block that pushes the player below the fold.</p>
+</div>
+<iframe id="visible-wrapper" name="xfplayer_visible" width="830" height="498"
+        src="frames/xfp-wrapper.html?player=player-frame.html" allowfullscreen></iframe>
+<iframe id="hidden-wrapper" name="xfplayer_hidden"
+        src="frames/xfp-wrapper.html?player=player-frame-2.html" allowfullscreen></iframe>
+<iframe id="hidden-trailer" allowfullscreen></iframe>
+<script>
+  const trailer = document.getElementById('hidden-trailer');
+  trailer.src = `http://127.0.0.1:${location.port}/pages/frames/late-player-frame.html`;
+  const frames = [...document.querySelectorAll('iframe')];
+  Promise.all(frames.map(f => new Promise(resolve => {
+    f.addEventListener('load', resolve, { once: true });
+  }))).then(() => { window.__fixtureReady = true; });
+</script>