From 082b69f50981171b70d1feae0ae4c59e42f56353 Mon Sep 17 00:00:00 2001
From: KoalaDev <6156589+Shik3i@users.noreply.github.com>
Date: Mon, 17 Aug 2026 16:49:53 +0200
Subject: [PATCH] fix(extension): support cross-origin media frames

---
 .github/workflows/release.yml                 |  14 +-
 docs/CHANGELOG.md                             |  21 +
 docs/ROADMAP.md                               |  19 +-
 docs/TESTED_SERVICES.md                       |   4 +-
 docs/devops.md                                |   1 +
 extension/background.js                       | 784 +++++++++++++++---
 extension/content.js                          | 358 +++++---
 extension/manifest.base.json                  |   3 +-
 extension/media-frame-monitor.js              | 196 +++++
 extension/media-frame-target.js               | 536 ++++++++++++
 extension/media-frame-target.test.mjs         | 483 +++++++++++
 extension/modules/tab-manager.js              |   5 +-
 extension/popup.js                            |   4 +-
 extension/target-tab-lifecycle.test.mjs       |  40 +-
 scripts/test-content-video-finder.cjs         |  98 ++-
 tests/e2e/extension.spec.mjs                  | 313 ++++++-
 tests/e2e/fixture-server.mjs                  |   7 +
 .../cross-origin-internal-switching.html      |  32 +
 .../e2e/fixtures/pages/cross-origin-late.html |  10 +
 .../fixtures/pages/cross-origin-nested.html   |  18 +
 .../pages/cross-origin-reloading.html         |  13 +
 .../pages/cross-origin-switching.html         |  38 +
 .../pages/deep-hidden-cross-origin.html       |  10 +
 .../pages/frames/cross-origin-wrapper.html    |   9 +
 .../fixtures/pages/frames/deep-wrapper-1.html |   5 +
 .../fixtures/pages/frames/deep-wrapper-2.html |   9 +
 .../pages/frames/late-player-frame.html       |  15 +
 .../pages/frames/wrapper-switch-player.html   |  30 +
 .../pages/hidden-redirect-cross-origin.html   |  10 +
 .../fixtures/pages/hidden-same-origin.html    |  14 +
 .../e2e/fixtures/pages/player-css-switch.html |  22 +
 31 files changed, 2858 insertions(+), 263 deletions(-)
 create mode 100644 extension/media-frame-monitor.js
 create mode 100644 extension/media-frame-target.js
 create mode 100644 extension/media-frame-target.test.mjs
 create mode 100644 tests/e2e/fixtures/pages/cross-origin-internal-switching.html
 create mode 100644 tests/e2e/fixtures/pages/cross-origin-late.html
 create mode 100644 tests/e2e/fixtures/pages/cross-origin-nested.html
 create mode 100644 tests/e2e/fixtures/pages/cross-origin-reloading.html
 create mode 100644 tests/e2e/fixtures/pages/cross-origin-switching.html
 create mode 100644 tests/e2e/fixtures/pages/deep-hidden-cross-origin.html
 create mode 100644 tests/e2e/fixtures/pages/frames/cross-origin-wrapper.html
 create mode 100644 tests/e2e/fixtures/pages/frames/deep-wrapper-1.html
 create mode 100644 tests/e2e/fixtures/pages/frames/deep-wrapper-2.html
 create mode 100644 tests/e2e/fixtures/pages/frames/late-player-frame.html
 create mode 100644 tests/e2e/fixtures/pages/frames/wrapper-switch-player.html
 create mode 100644 tests/e2e/fixtures/pages/hidden-redirect-cross-origin.html
 create mode 100644 tests/e2e/fixtures/pages/hidden-same-origin.html
 create mode 100644 tests/e2e/fixtures/pages/player-css-switch.html

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index bda4da8..b7014be 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -103,19 +103,23 @@ jobs:
           jq --arg v "$VERSION" '.version = $v' package.json > tmp.json && mv tmp.json package.json
           echo "  ✓ package.json -> $VERSION"
 
-          # 4. website/version.json
+          # 4. package-lock.json root package metadata
+          jq --arg v "$VERSION" '.version = $v | .packages[""].version = $v' package-lock.json > tmp.json && mv tmp.json package-lock.json
+          echo "  ✓ package-lock.json -> $VERSION"
+
+          # 5. website/version.json
           jq -n --arg v "$VERSION" --arg d "$DATE" '{version: $v, date: $d}' > website/version.json
           echo "  ✓ website/version.json -> version $VERSION, date $DATE"
 
-          # 5. website/template.html — SoftwareApplication schema
+          # 6. website/template.html — SoftwareApplication schema
           sed -i "s/\"softwareVersion\": \".*\"/\"softwareVersion\": \"$VERSION\"/" website/template.html
           echo "  ✓ website/template.html -> softwareVersion $VERSION"
 
-          # 6. website/llms.txt — machine-readable release metadata
+          # 7. website/llms.txt — machine-readable release metadata
           sed -i "s/Current website release: .*/Current website release: $VERSION/" website/llms.txt
           echo "  ✓ website/llms.txt -> $VERSION"
 
-          # 7. README.md — version badge & banner
+          # 8. README.md — version badge & banner
           sed -i "s|Release-v[0-9]\+\.[0-9]\+\.[0-9]\+-blue|Release-v$VERSION-blue|g" README.md
           sed -i "s/New v[0-9]\+\.[0-9]\+\.[0-9]\+ Release/New v$VERSION Release/g" README.md
           echo "  ✓ README.md -> v$VERSION"
@@ -126,7 +130,7 @@ jobs:
         run: |
           git config --local user.email "action@github.com"
           git config --local user.name "GitHub Action"
-          git add extension/manifest.base.json shared/constants.js package.json website/version.json website/template.html website/llms.txt README.md
+          git add extension/manifest.base.json shared/constants.js package.json package-lock.json website/version.json website/template.html website/llms.txt README.md
           git commit -m "chore(release): update versions to $GITHUB_REF_NAME [skip ci]" || echo "No changes to commit"
           git push origin HEAD:main
         env:
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 3be5676..b7672bc 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -4,6 +4,27 @@ All notable changes to the KoalaSync browser extension and relay server.
 
 ---
 
+## [v3.1.2] — 2026-08-17
+
+This release adds generic control for HTML5 players inside cross-origin frames.
+It restores the intended Google Drive support, whose earlier workaround was
+developed on a separate branch but never merged into `main`, and covers nested
+external players such as YummyAnime without a site-specific host list.
+
+### Added
+- **Extension: Cross-origin player targeting** — Probes every accessible frame, elects the visible real player from video readiness, source, rendering, playback, controls, size and background-video signals, then injects and routes playback, force sync, heartbeat, chat and audio processing to that exact frame and document.
+- **Extension: Embedded-player recovery** — Re-elects the target when a player frame becomes hidden, loses its video, reloads or is replaced by another frame. Equally ranked frames without visibility evidence are rejected instead of controlling an arbitrary preload or ad.
+- **Testing: Cross-origin lifecycle E2E coverage** — Drives the packed Chromium extension through ordered play, pause and seek in a two-level external player; verifies hidden duplicate rejection, CSS visibility switches without a remote-command trigger, selected-frame document reloads and videos inserted late inside child frames.
+
+### Fixed
+- **Extension: Google Drive playback** — Detects Drive's current visible `youtube.googleapis.com/embed` player and keeps Drive's top-page title, URL and platform identity in debug output while controlling the embedded video.
+- **Extension: External anime players** — Supports same-origin wrappers whose real player is hosted on a different origin, including the current YummyAnime structure with a visible external player and hidden duplicate frames.
+- **Extension: Frame-specific message routing** — Sends remote commands, state reads, audio settings, host-control feedback, episode-lobby events and teardown only to the selected frame/document instead of assuming the top frame.
+- **Extension: Force Sync in embedded players** — Reads the current time through the background's selected-frame route, so Jump to Me no longer queries only the top document.
+
+### Changed
+- **Extension: Debug frame context** — Reports the selected frame ID and origin while preserving the selected tab's top-level URL and title. Google Drive is identified as Google Drive instead of the embedded YouTube API host.
+
 ## [v3.1.1] — 2026-08-15
 
 A single fix: the popup could get stuck at double width for the rest of a
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index db8c1f8..e052443 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -49,14 +49,6 @@
 
 *Ideas and feature requests under evaluation.*
 
-### Cross-origin frame video detection and control
-
-- **Priority:** P3
-- **Category:** Compatibility / Embedded Players
-- **Background:** KoalaSync injects on demand into the selected tab's top frame. Since the same-origin frame walk shipped, the top-frame script also reaches players inside first-party iframes (`jkanime.net`-style `/jkplayer/` frames, `srcdoc` and `about:blank` frames that inherit the parent origin). What remains uncovered is the real `<video>` living inside a **cross-origin** iframe, where `contentDocument` is unreachable by design.
-- **Possible approach:** Add an opt-in frame bridge (`allFrames: true` injection) where child frames announce detected videos to the top frame, and the top frame routes remote play/pause/seek commands to the active child video. Needs a frame-election rule so ad frames cannot claim the session.
-- **Status:** Same-origin part completed; cross-origin frame bridge still open. Not needed for current Emby behavior.
-
 ### Sticky player selection
 
 - **Priority:** P3
@@ -90,6 +82,17 @@
 
 ---
 
+## ✅ Completed
+
+### Cross-origin frame video detection and control
+
+- **Priority:** P3
+- **Category:** Compatibility / Embedded Players
+- **Completed:** v3.1.2
+- **Outcome:** The background probes accessible frames, elects the visible HTML5 player without trusting child-frame claims, and routes injection, ordered commands, state, chat, audio and teardown to the selected document. Hidden equal candidates without visibility evidence are rejected. A tab-wide frame sentinel plus subframe-navigation events recover CSS visibility switches, document reloads, lazy video insertion and failed delivery. Google Drive and YummyAnime-style nested external players are covered by live topology inspection plus packed-Chromium E2E fixtures; live two-peer service runs remain tracked separately.
+
+---
+
 ## ❌ Rejected
 
 *Declined features with rationale — keeps decisions documented so they don't get re-debated.*
diff --git a/docs/TESTED_SERVICES.md b/docs/TESTED_SERVICES.md
index dcd2d91..7c58922 100644
--- a/docs/TESTED_SERVICES.md
+++ b/docs/TESTED_SERVICES.md
@@ -26,6 +26,8 @@ This document tracks which streaming platforms and media servers are supported b
 | **ARD / ZDF Mediathek** | Not tested | Not tested | Not tested | — | — | — | — |
 | **Vix** | ✅ Full | ✅ Full | ✅ Full | — | — | — | Everything works correctly. |
 | **JkAnime** | ✅ Full | ❌ | ❌ | 2026-08-14 | Shik3i | v3.1.0 | Player sits in a same-origin `/jkplayer/` iframe, so it needs the same-origin frame walk added in v3.1.0. No MediaSession metadata is exposed, and the page title carries no episode pattern (`… Futari 18 Sub Español …`). |
+| **Google Drive** | ⚠️ Partial | ✅ Full | ❌ N/A | 2026-08-17 | Shik3i / Codex | v3.1.2 | Live inspection confirms the visible `youtube.googleapis.com/embed` child topology; packed-Chromium fixtures cover exact-document control and recovery. A live two-peer Drive relay run is still pending. |
+| **YummyAnime** | ⚠️ Partial | ⚠️ Partial | ❌ | 2026-08-17 | Shik3i / Codex | v3.1.2 | Live inspection confirms the same-origin wrapper plus external `thealloha.club` player topology; packed-Chromium fixtures cover nested control and recovery. A live two-peer site run is still pending, and the page title lacks the selected episode. |
 
 ### Legend
 
@@ -71,4 +73,4 @@ Websites with heavily obfuscated custom players may require platform-specific wo
 
 Since v3.1.0 the content script walks **same-origin** frames, so a player wrapped in the site's own iframe is found and controlled without a site-specific workaround. This also covers `srcdoc` and `about:blank` frames, which inherit the parent origin.
 
-Frames on a **different origin** remain out of reach, because the browser blocks `contentDocument` access by design. Note that a subdomain counts as a different origin: a player served from `player.example.com` inside `example.com` is *not* reachable. Sites that embed their player from an external host (common for anime and sports streaming mirrors) fall into this category. Tracked on the roadmap as the cross-origin frame bridge.
+Since v3.1.2 the background can also inspect accessible **cross-origin** frames and inject KoalaSync into the exact frame/document containing the visible player. Frame election uses visibility and media signals so hidden preloads, trailers and ad players do not win accidentally. When browser site access for the external player origin is withheld, KoalaSync uses the existing website-access recovery flow instead of bypassing the browser permission.
diff --git a/docs/devops.md b/docs/devops.md
index 2b249b2..a9d08e0 100644
--- a/docs/devops.md
+++ b/docs/devops.md
@@ -19,6 +19,7 @@ When you push a Git tag matching `v*` (e.g., `v2.5.1`), the GitHub Actions relea
    - `extension/manifest.base.json`
    - `shared/constants.js` (updates `APP_VERSION`)
    - `package.json`
+   - `package-lock.json` (root package metadata)
    - `website/version.json`
    - `website/template.html` (updates `softwareVersion` schema)
    - `README.md` (updates badge and announcement banner)
diff --git a/extension/background.js b/extension/background.js
index e1d887d..63ef7fa 100644
--- a/extension/background.js
+++ b/extension/background.js
@@ -9,6 +9,12 @@ import { buildChatRelayPayload, encodeSocketEvent } from './chat-wire.js';
 import { createChatEchoTracker, createChatSendLimiter, createLatestTaskQueue, normalizeRoomId, shouldShowChatNotification } from './chat-session.js';
 import { createChatActivityStore } from './chat-activity.js';
 import { HOST_ACCESS_REQUIRED_STATUS, normalizeTabId, inspectTabHostAccess, isHostAccessError, addTabHostAccessRequest, removeTabHostAccessRequest } from './host-access.js';
+import {
+    MEDIA_FRAME_ACCESS_REQUIRED,
+    MEDIA_FRAME_AMBIGUOUS,
+    listMediaFrameScriptTargets,
+    resolveMediaContentTarget
+} from './media-frame-target.js';
 import './page-api-seek-overrides.js';
 
 // --- Uninstall URL Initialization ---
@@ -66,8 +72,16 @@ let peerId = null; // initialized via getPeerId()
 let currentRoom = null;
 let currentTabId = null;
 let currentTabTitle = null; // New: for Smart Matching
+let currentTargetFrameId = 0;
+let currentTargetDocumentId = null;
+let currentTargetHasVideo = false;
 let targetActivationGeneration = 0;
 let activeTargetActivation = null;
+let mediaTargetRefreshTask = null;
+let mediaTargetRefreshTabId = null;
+let mediaTargetRefreshDirty = false;
+let mediaTargetRefreshFollowupTimer = null;
+let contentCommandQueue = Promise.resolve();
 let logs = [];
 let history = []; // New: for Action History
 let storageInitialized = false;
@@ -202,12 +216,24 @@ function ensureState() {
                 'logs', 'history', 'currentRoom', 'lastActionState', 
                 'eventQueue', 'isForceSyncInitiator', 'forceSyncAcks', 
                 'forceSyncDeadline', 'reconnectFailed', 'reconnectStartTime', 'reconnectAttempts', 'currentTabId', 'currentTabTitle',
+                'currentTargetFrameId', 'currentTargetDocumentId', 'currentTargetHasVideo',
                 '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);
+                currentTargetFrameId = currentTabId !== null
+                    && Number.isInteger(data.currentTargetFrameId)
+                    && data.currentTargetFrameId >= 0
+                    ? data.currentTargetFrameId
+                    : 0;
+                currentTargetDocumentId = currentTabId !== null
+                    && typeof data.currentTargetDocumentId === 'string'
+                    && data.currentTargetDocumentId
+                    ? data.currentTargetDocumentId
+                    : null;
+                currentTargetHasVideo = currentTabId !== null && data.currentTargetHasVideo === true;
                 if (data.currentTabTitle !== undefined) {
                     currentTabTitle = currentTabId !== null && typeof data.currentTabTitle === 'string'
                         ? data.currentTabTitle
@@ -572,6 +598,11 @@ function markRoomPotentiallyIdle() {
 function invalidateTargetActivations() {
     targetActivationGeneration++;
     activeTargetActivation = null;
+    mediaTargetRefreshDirty = false;
+    if (mediaTargetRefreshFollowupTimer !== null) {
+        clearTimeout(mediaTargetRefreshFollowupTimer);
+        mediaTargetRefreshFollowupTimer = null;
+    }
     return targetActivationGeneration;
 }
 
@@ -580,6 +611,88 @@ function isCurrentTargetIdentity(tabId, generation) {
         && targetActivationGeneration === generation;
 }
 
+function normalizeFrameId(value) {
+    return Number.isInteger(value) && value >= 0 ? value : 0;
+}
+
+function currentContentTarget() {
+    return {
+        frameId: normalizeFrameId(currentTargetFrameId),
+        documentId: typeof currentTargetDocumentId === 'string' && currentTargetDocumentId
+            ? currentTargetDocumentId
+            : null,
+        hasVideo: currentTargetHasVideo
+    };
+}
+
+function targetMessageOptions(frameId, documentId = null) {
+    return typeof documentId === 'string' && documentId
+        ? { documentId }
+        : { frameId: normalizeFrameId(frameId) };
+}
+
+function sendMessageToFrame(tabId, frameId, message, callback = null, documentId = null) {
+    const options = targetMessageOptions(frameId, documentId);
+    if (typeof callback === 'function') {
+        return chrome.tabs.sendMessage(tabId, message, options, callback);
+    }
+    return chrome.tabs.sendMessage(tabId, message, options);
+}
+
+function sendMessageToCurrentContent(message, callback = null) {
+    const tabId = normalizeTabId(currentTabId);
+    if (tabId === null) {
+        return typeof callback === 'function' ? undefined : Promise.reject(new Error('No target tab selected'));
+    }
+    return sendMessageToFrame(
+        tabId,
+        currentTargetFrameId,
+        message,
+        callback,
+        currentTargetDocumentId
+    );
+}
+
+function sendMessageToContentTab(tabId, message, callback = null) {
+    if (normalizeTabId(tabId) === normalizeTabId(currentTabId)) {
+        return sendMessageToCurrentContent(message, callback);
+    }
+    if (typeof callback === 'function') {
+        return chrome.tabs.sendMessage(tabId, message, callback);
+    }
+    return chrome.tabs.sendMessage(tabId, message);
+}
+
+function isCurrentContentSender(sender) {
+    if (!sender?.tab) return false;
+    const senderTabId = normalizeTabId(sender.tab.id);
+    const senderFrameId = normalizeFrameId(sender.frameId);
+    const matchesActivation = senderTabId === normalizeTabId(activeTargetActivation?.tabId)
+        && senderFrameId === normalizeFrameId(activeTargetActivation?.frameId)
+        && (!activeTargetActivation?.documentId
+            || sender.documentId === activeTargetActivation.documentId);
+    if (Number.isInteger(activeTargetActivation?.frameId)) return matchesActivation;
+    return senderTabId === normalizeTabId(currentTabId)
+        && senderFrameId === normalizeFrameId(currentTargetFrameId)
+        && (!currentTargetDocumentId || sender.documentId === currentTargetDocumentId);
+}
+
+function isExtensionPageSender(sender) {
+    const extensionRoot = chrome.runtime.getURL('');
+    return typeof sender?.url === 'string' && sender.url.startsWith(extensionRoot);
+}
+
+function sameContentTarget(left, right) {
+    return normalizeFrameId(left?.frameId) === normalizeFrameId(right?.frameId)
+        && (!left?.documentId || !right?.documentId || left.documentId === right.documentId);
+}
+
+function clearCurrentContentTarget() {
+    currentTargetFrameId = 0;
+    currentTargetDocumentId = null;
+    currentTargetHasVideo = false;
+}
+
 function clearTargetTabForIdle(expectedTabId = null, expectedGeneration = null) {
     if (expectedTabId !== null && normalizeTabId(currentTabId) !== normalizeTabId(expectedTabId)) {
         return false;
@@ -594,6 +707,7 @@ function clearTargetTabForIdle(expectedTabId = null, expectedGeneration = null)
     if (currentTabId) deactivateTargetTab(currentTabId).catch(() => {});
     currentTabId = null;
     currentTabTitle = null;
+    clearCurrentContentTarget();
     lastContentHeartbeatAt = null;
     if (currentRoom) {
         roomIdleSince = Date.now();
@@ -601,6 +715,9 @@ function clearTargetTabForIdle(expectedTabId = null, expectedGeneration = null)
     chrome.storage.session.set({
         currentTabId,
         currentTabTitle,
+        currentTargetFrameId,
+        currentTargetDocumentId,
+        currentTargetHasVideo,
         roomIdleSince,
         lastContentHeartbeatAt
     }).catch(() => {});
@@ -631,6 +748,7 @@ async function leaveRoomAfterIdleGrace(reason) {
     invalidateTargetActivations();
     currentTabId = null;
     currentTabTitle = null;
+    clearCurrentContentTarget();
     roomIdleSince = null;
     lastContentHeartbeatAt = null;
     clearEpisodeLobbyState();
@@ -640,6 +758,9 @@ async function leaveRoomAfterIdleGrace(reason) {
         chatActivityTimeline: [],
         currentTabId: null,
         currentTabTitle: null,
+        currentTargetFrameId: 0,
+        currentTargetDocumentId: null,
+        currentTargetHasVideo: false,
         roomIdleSince: null,
         lastContentHeartbeatAt: null,
         episodeLobby: null,
@@ -859,7 +980,7 @@ function broadcastControlMode() {
     chrome.runtime.sendMessage(payload).catch(() => {});
     if (currentTabId) {
         const tabId = parseInt(currentTabId);
-        if (!isNaN(tabId)) chrome.tabs.sendMessage(tabId, payload).catch(() => {});
+        if (!isNaN(tabId)) sendMessageToCurrentContent(payload).catch(() => {});
     }
 }
 
@@ -871,7 +992,7 @@ function broadcastConnectionStatus(status) {
         status = 'idle';
     }
     chrome.runtime.sendMessage({ type: 'CONNECTION_STATUS', status }).catch(() => {});
-    if (currentTabId) chrome.tabs.sendMessage(Number(currentTabId), { type: 'CONNECTION_STATUS', status }).catch(() => {});
+    if (currentTabId) sendMessageToCurrentContent({ type: 'CONNECTION_STATUS', status }).catch(() => {});
     updateBadgeStatus();
 }
 
@@ -1019,7 +1140,7 @@ function sendChatActivity(action, senderId, timestamp = Date.now()) {
     if (!entry) return;
     if (storageInitialized) chrome.storage.session.set({ chatActivityTimeline: chatActivityStore.snapshot() }).catch(() => {});
     if (!currentTabId) return;
-    chrome.tabs.sendMessage(Number(currentTabId), {
+    sendMessageToCurrentContent({
         type: 'CHAT_EVENT',
         event: entry
     }).catch(error => addLog(`Chat activity delivery failed: ${error.message}`, 'warn'));
@@ -1230,7 +1351,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) chrome.tabs.sendMessage(Number(currentTabId), { type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+            if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
             hcmEnforceDesyncInvariant();
             broadcastControlMode();
             markRoomPotentiallyIdle();
@@ -1265,7 +1386,7 @@ async function handleServerEvent(event, data) {
                 if (currentTabId) {
                     const tabId = parseInt(currentTabId);
                     if (!isNaN(tabId)) {
-                        chrome.tabs.sendMessage(tabId, {
+                        sendMessageToCurrentContent({
                             type: 'EPISODE_LOBBY',
                             expectedTitle: episodeLobby.expectedTitle
                         }).catch(() => {});
@@ -1329,7 +1450,7 @@ async function handleServerEvent(event, data) {
                         (typeof candidate === 'object' ? candidate.peerId : candidate) === received.senderId
                     );
                     if (Number.isInteger(tabId)) {
-                        chrome.tabs.sendMessage(tabId, {
+                        sendMessageToCurrentContent({
                             type: 'CHAT_MESSAGE',
                             message: {
                                 id: received.id,
@@ -1518,7 +1639,7 @@ async function handleServerEvent(event, data) {
                         // current playback state so the newcomer syncs immediately
                         // instead of waiting up to a full heartbeat interval.
                         if (wasSolo && currentTabId) {
-                            chrome.tabs.sendMessage(currentTabId, { type: 'REQUEST_HEARTBEAT' }).catch(() => {});
+                            sendMessageToCurrentContent({ type: 'REQUEST_HEARTBEAT' }).catch(() => {});
                         }
 
                         if (episodeLobby && episodeLobby.initiatorPeerId === peerId) {
@@ -1611,7 +1732,7 @@ async function handleServerEvent(event, data) {
                 if (currentTabId) {
                     const tabId = parseInt(currentTabId);
                     if (!isNaN(tabId)) {
-                        chrome.tabs.sendMessage(tabId, {
+                        sendMessageToCurrentContent({
                             type: 'EPISODE_LOBBY',
                             expectedTitle: data.expectedTitle
                         }).catch(() => {});
@@ -1724,7 +1845,7 @@ function clearEpisodeLobbyState() {
     if (currentTabId) {
         const tabId = parseInt(currentTabId);
         if (!isNaN(tabId)) {
-            chrome.tabs.sendMessage(tabId, { type: 'EPISODE_LOBBY_CANCEL' }).catch(() => {});
+            sendMessageToCurrentContent({ type: 'EPISODE_LOBBY_CANCEL' }).catch(() => {});
         }
     }
 }
@@ -1848,22 +1969,27 @@ function updateLastAction(action, senderId, timestamp = Date.now()) {
     chrome.runtime.sendMessage({ type: 'ACTION_UPDATE', state: lastActionState }).catch(() => {});
 }
 
-async function routeToContent(action, payload) {
-    if (!currentTabId) return;
-
+function routeToContent(action, payload) {
     const tabId = normalizeTabId(currentTabId);
-    if (tabId === null) return;
-    const targetGeneration = targetActivationGeneration;
-
+    if (tabId === null) return Promise.resolve();
     const actionTimestamp = payload?.actionTimestamp || Date.now();
     const commandSenderId = payload?.senderId || null;
-
-    _routeToContentInternal(tabId, action, payload, actionTimestamp, commandSenderId, 0, targetGeneration);
+    const deliver = () => _routeToContentInternal(
+        tabId,
+        action,
+        payload,
+        actionTimestamp,
+        commandSenderId,
+        0
+    );
+    const queued = contentCommandQueue.catch(() => {}).then(deliver);
+    contentCommandQueue = queued;
+    return queued;
 }
 
 function getTabVideoState(tabId) {
     return new Promise((resolve) => {
-        chrome.tabs.sendMessage(tabId, { type: 'GET_VIDEO_STATE' }, (res) => {
+        sendMessageToContentTab(tabId, { type: 'GET_VIDEO_STATE' }, (res) => {
             if (chrome.runtime.lastError) {
                 resolve({ error: chrome.runtime.lastError.message });
                 return;
@@ -1873,10 +1999,39 @@ function getTabVideoState(tabId) {
     });
 }
 
+async function decorateVideoState(tabId, state) {
+    if (!state || state.error) return state;
+    try {
+        const tab = await chrome.tabs.get(tabId);
+        const frameUrl = state.url;
+        let frameOrigin = null;
+        try { frameOrigin = new URL(frameUrl).origin; } catch { /* unavailable */ }
+        const topUrl = tab?.url || state.url;
+        let platform = state.platform;
+        try {
+            if (new URL(topUrl).hostname.toLowerCase() === 'drive.google.com') platform = 'Google Drive';
+        } catch { /* keep the content-reported platform */ }
+        return {
+            ...state,
+            url: topUrl,
+            pageTitle: tab?.title || state.pageTitle,
+            frameOrigin,
+            frameId: normalizeFrameId(currentTargetFrameId),
+            inIframe: normalizeFrameId(currentTargetFrameId) !== 0 || state.inIframe === true,
+            platform
+        };
+    } catch {
+        return state;
+    }
+}
+
 async function getReadyTabVideoState(tabId, expectedGeneration = targetActivationGeneration) {
+    if (!isCurrentTargetIdentity(tabId, expectedGeneration)) {
+        return { error: 'Target tab changed before video state could be read' };
+    }
     let state = await getTabVideoState(tabId);
-    if (!state || state.error) {
-        const activation = await reactivateCurrentTarget(tabId, { expectedGeneration });
+    if (!state || state.error || state.found === false) {
+        const activation = await refreshCurrentMediaTarget(tabId);
         if (activation?.status !== 'ok') {
             return { error: 'Target tab changed before content script recovery completed' };
         }
@@ -1889,7 +2044,7 @@ async function getReadyTabVideoState(tabId, expectedGeneration = targetActivatio
             return { error: 'Target tab changed while video state was being read' };
         }
     }
-    return state;
+    return decorateVideoState(tabId, state);
 }
 
 async function simulateRemoteSeek(delta, explicitTargetTime = null) {
@@ -2034,12 +2189,63 @@ function setPageApiSeekEnabled(enabled) {
     window.KOALA_PAGE_API_SEEK_ENABLED = enabled === true;
 }
 
-async function deactivateTargetTab(tabId) {
+async function deactivateMediaFrameMonitors(tabId) {
+    const targets = await listMediaFrameScriptTargets(chrome, tabId);
+    await Promise.all(targets.map(async target => {
+        const documentId = target.documentIds?.[0];
+        const frameId = target.frameIds?.[0];
+        try {
+            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;
-    resetAudioProcessingInTab(normalizedTabId);
-    await chrome.tabs.sendMessage(normalizedTabId, { type: 'TARGET_DEACTIVATE' }).catch(() => {});
-    await chrome.tabs.sendMessage(normalizedTabId, { type: 'CHAT_DESTROY' }).catch(() => {});
+    if (deactivateMonitor) {
+        await deactivateMediaFrameMonitors(normalizedTabId);
+    }
+    const target = contentTarget
+        || (normalizedTabId === normalizeTabId(currentTabId) ? currentContentTarget() : null)
+        || (normalizedTabId === normalizeTabId(activeTargetActivation?.tabId)
+            ? {
+                frameId: activeTargetActivation.frameId,
+                documentId: activeTargetActivation.documentId
+            }
+            : null)
+        || { frameId: 0, documentId: null };
+    resetAudioProcessingInTab(normalizedTabId, target);
+    await sendMessageToFrame(
+        normalizedTabId,
+        target.frameId,
+        { type: 'TARGET_DEACTIVATE' },
+        null,
+        target.documentId
+    ).catch(() => {});
+    await sendMessageToFrame(
+        normalizedTabId,
+        target.frameId,
+        { type: 'CHAT_DESTROY' },
+        null,
+        target.documentId
+    ).catch(() => {});
 }
 
 function createHostAccessRequiredError(access, requestAdded, cause) {
@@ -2066,31 +2272,102 @@ function injectionFailureResponse(error) {
     return { status: 'error', message: error?.message || 'Script injection failed' };
 }
 
-async function injectContentScript(tabId, { requestHostAccess = true } = {}) {
+function isMediaTargetNavigationError(error) {
+    const message = String(error?.message || '');
+    return error?.code === 'media_target_navigated'
+        || message.includes('No document with id')
+        || message.includes('No document with ID');
+}
+
+async function injectMediaFrameMonitors(tabId, contentTarget) {
+    const targets = await listMediaFrameScriptTargets(chrome, tabId);
+    let injectedCount = 0;
+    await Promise.all(targets.map(async target => {
+        try {
+            await chrome.scripting.executeScript({
+                target,
+                files: ['media-frame-monitor.js']
+            });
+            injectedCount++;
+        } 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 chrome.scripting.executeScript({
+                target,
+                files: ['media-frame-monitor.js']
+            });
+            injectedCount++;
+        } catch {
+            // Main injection below reports a real selected-target failure.
+        }
+    }
+}
+
+async function injectContentScript(tabId, {
+    requestHostAccess = true,
+    navigationRetries = 2
+} = {}) {
     const normalizedTabId = normalizeTabId(tabId);
     if (normalizedTabId === null) throw new Error('Invalid tab ID');
     tabId = normalizedTabId;
     let needsPageApiSeek = false;
     let pageApiSeekReady = false;
     let access = null;
+    let contentTarget = {
+        frameId: 0,
+        documentId: null,
+        frameUrl: null,
+        hasVideo: false,
+        scriptTarget: { tabId }
+    };
     try {
         access = await inspectTabHostAccess(chrome, tabId);
         const url = access.url || '';
         needsPageApiSeek = shouldUsePageApiSeek(url);
-    } catch (_e) {
-        // Fall through to the generic content script injection.
+        contentTarget = await resolveMediaContentTarget(chrome, tabId);
+        if (activeTargetActivation?.tabId === tabId) {
+            activeTargetActivation.frameId = contentTarget.frameId;
+            activeTargetActivation.documentId = contentTarget.documentId;
+        }
+    } catch (error) {
+        if (error?.code === MEDIA_FRAME_ACCESS_REQUIRED) {
+            // addHostAccessRequest() only grants the tab's top origin. Embedded
+            // player origins must be requested explicitly by the popup.
+            const requestAdded = false;
+            throw createHostAccessRequiredError({
+                tab: { id: tabId },
+                host: error.host,
+                originPattern: error.originPattern
+            }, requestAdded, error);
+        }
+        if (error?.code === MEDIA_FRAME_AMBIGUOUS) throw error;
+        addLog(`Media frame probe fell back to the top frame: ${error.message}`, 'warn');
     }
 
+    const scriptTarget = contentTarget.scriptTarget;
+    const selectedDocumentId = contentTarget.documentId;
+
     try {
+        await injectMediaFrameMonitors(tabId, contentTarget);
         if (needsPageApiSeek) {
             try {
                 await chrome.scripting.executeScript({
-                    target: { tabId },
+                    target: scriptTarget,
                     world: 'MAIN',
                     files: ['page-api-seek-overrides.js']
                 });
                 await chrome.scripting.executeScript({
-                    target: { tabId },
+                    target: scriptTarget,
                     world: 'MAIN',
                     func: installPageApiSeekBridge
                 });
@@ -2101,19 +2378,42 @@ async function injectContentScript(tabId, { requestHostAccess = true } = {}) {
         }
 
         await chrome.scripting.executeScript({
-            target: { tabId },
+            target: scriptTarget,
             files: ['page-api-seek-overrides.js']
         });
         await chrome.scripting.executeScript({
-            target: { tabId },
+            target: scriptTarget,
             func: setPageApiSeekEnabled,
             args: [pageApiSeekReady]
         });
-        return await chrome.scripting.executeScript({
-            target: { tabId },
+        const injectionResults = await chrome.scripting.executeScript({
+            target: scriptTarget,
             files: ['chat-format.js', 'chat-overlay.js', 'content.js']
         });
+        const frameResult = Array.isArray(injectionResults)
+            ? injectionResults.find(result => normalizeFrameId(result?.frameId) === contentTarget.frameId)
+            : null;
+        if (selectedDocumentId && frameResult?.documentId !== selectedDocumentId) {
+            const navigationError = new Error('Selected media document navigated during injection');
+            navigationError.code = 'media_target_navigated';
+            throw navigationError;
+        }
+        contentTarget.documentId = typeof frameResult?.documentId === 'string'
+            ? frameResult.documentId
+            : contentTarget.documentId;
+        if (activeTargetActivation?.tabId === tabId) {
+            activeTargetActivation.frameId = contentTarget.frameId;
+            activeTargetActivation.documentId = contentTarget.documentId;
+        }
+        return contentTarget;
     } catch (error) {
+        if (navigationRetries > 0 && isMediaTargetNavigationError(error)) {
+            return injectContentScript(tabId, {
+                requestHostAccess,
+                navigationRetries: navigationRetries - 1
+            });
+        }
+        try { error.contentTarget = contentTarget; } catch { /* immutable browser error */ }
         // A temporary activeTab grant is intentionally allowed to win: even if
         // permissions.contains() reports false, a successful injection above is
         // valid. Only convert an actual injection failure into a host-access UX.
@@ -2299,6 +2599,8 @@ async function activateTargetTab(tabId, tabTitle, {
     const activationGeneration = ++targetActivationGeneration;
     activeTargetActivation = { generation: activationGeneration, tabId: selectedTabId };
     const previousTabId = normalizeTabId(currentTabId);
+    const previousContentTarget = currentContentTarget();
+    let injectedContentTarget = { frameId: 0, documentId: null, hasVideo: false };
 
     try {
         if (previousTabId && previousTabId !== selectedTabId) {
@@ -2308,11 +2610,11 @@ async function activateTargetTab(tabId, tabTitle, {
             return { status: 'superseded' };
         }
         try {
-            await injectContentScript(selectedTabId, { requestHostAccess });
+            injectedContentTarget = await injectContentScript(selectedTabId, { requestHostAccess });
         } catch (error) {
             if (activationGeneration !== targetActivationGeneration) {
                 if (normalizeTabId(currentTabId) !== selectedTabId) {
-                    await deactivateTargetTab(selectedTabId);
+                    await deactivateTargetTab(selectedTabId, error?.contentTarget || injectedContentTarget);
                 }
                 if (error?.code === HOST_ACCESS_REQUIRED_STATUS
                     && error.requestAdded === true
@@ -2325,16 +2627,29 @@ async function activateTargetTab(tabId, tabTitle, {
                 }
                 return { status: 'superseded' };
             }
+            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();
-            if (previousTabId) {
-                await deactivateTargetTab(previousTabId);
+            const failedContentTarget = error?.contentTarget || injectedContentTarget;
+            await deactivateTargetTab(selectedTabId, failedContentTarget);
+            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
             });
@@ -2368,32 +2683,44 @@ async function activateTargetTab(tabId, tabTitle, {
         }
 
         if (activationGeneration !== targetActivationGeneration) {
-            if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId);
+            if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId, injectedContentTarget);
             return { status: 'superseded' };
         }
 
-        await applyAudioSettingsToTab(selectedTabId);
+        await applyAudioSettingsToTab(selectedTabId, injectedContentTarget);
         if (activationGeneration !== targetActivationGeneration) {
-            if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId);
+            if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId, injectedContentTarget);
             return { status: 'superseded' };
         }
         await removeTabHostAccessRequest(chrome, selectedTabId);
         if (activationGeneration !== targetActivationGeneration) {
-            if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId);
+            if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId, injectedContentTarget);
             return { status: 'superseded' };
         }
         await clearPendingTarget();
         if (activationGeneration !== targetActivationGeneration) {
-            if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId);
+            if (currentTabId !== selectedTabId) await deactivateTargetTab(selectedTabId, injectedContentTarget);
             return { status: 'superseded' };
         }
+        if (previousTabId === selectedTabId
+            && !sameContentTarget(previousContentTarget, injectedContentTarget)) {
+            await deactivateTargetTab(previousTabId, previousContentTarget, { deactivateMonitor: false });
+        }
         currentTabId = selectedTabId;
         currentTabTitle = typeof tabTitle === 'string' ? tabTitle : null;
+        currentTargetFrameId = normalizeFrameId(injectedContentTarget.frameId);
+        currentTargetDocumentId = typeof injectedContentTarget.documentId === 'string'
+            ? injectedContentTarget.documentId
+            : null;
+        currentTargetHasVideo = injectedContentTarget.hasVideo === true;
         lastContentHeartbeatAt = null;
         if (currentRoom) roomIdleSince = Date.now();
         await chrome.storage.session.set({
             currentTabId,
             currentTabTitle,
+            currentTargetFrameId,
+            currentTargetDocumentId,
+            currentTargetHasVideo,
             roomIdleSince,
             lastContentHeartbeatAt
         });
@@ -2401,7 +2728,14 @@ async function activateTargetTab(tabId, tabTitle, {
             return { status: 'superseded' };
         }
         updateBadgeStatus();
-        return { status: 'ok', tabId: selectedTabId, generation: activationGeneration };
+        return {
+            status: 'ok',
+            tabId: selectedTabId,
+            frameId: currentTargetFrameId,
+            documentId: currentTargetDocumentId,
+            hasVideo: currentTargetHasVideo,
+            generation: activationGeneration
+        };
     } finally {
         if (activeTargetActivation?.generation === activationGeneration) {
             activeTargetActivation = null;
@@ -2423,6 +2757,65 @@ async function reactivateCurrentTarget(tabId, { expectedGeneration = targetActiv
     });
 }
 
+function refreshCurrentMediaTarget(tabId, { queueIfRunning = false } = {}) {
+    const selectedTabId = normalizeTabId(tabId);
+    if (selectedTabId === null || normalizeTabId(currentTabId) !== selectedTabId) {
+        return Promise.resolve({ status: 'superseded' });
+    }
+    if (mediaTargetRefreshTask && mediaTargetRefreshTabId === selectedTabId) {
+        if (queueIfRunning) mediaTargetRefreshDirty = true;
+        return mediaTargetRefreshTask;
+    }
+    if (activeTargetActivation?.tabId === selectedTabId) {
+        return Promise.resolve({ status: 'activation_in_progress' });
+    }
+
+    const task = (async () => {
+        let result;
+        let pass = 0;
+        do {
+            pass++;
+            mediaTargetRefreshDirty = false;
+            const expectedGeneration = targetActivationGeneration;
+            result = await reactivateCurrentTarget(selectedTabId, { expectedGeneration });
+            // Let lifecycle messages queued during the final probe/injection
+            // mark the refresh dirty before deciding whether a trailing pass is needed.
+            await new Promise(resolve => setTimeout(resolve, 0));
+        } while (mediaTargetRefreshDirty
+            && pass < 2
+            && normalizeTabId(currentTabId) === selectedTabId);
+        return result;
+    })();
+    let wrappedTask;
+    mediaTargetRefreshTabId = selectedTabId;
+    wrappedTask = task.finally(() => {
+        if (mediaTargetRefreshTask !== wrappedTask) return;
+        const needsFollowup = mediaTargetRefreshDirty
+            && normalizeTabId(currentTabId) === selectedTabId;
+        mediaTargetRefreshTask = null;
+        mediaTargetRefreshTabId = null;
+        mediaTargetRefreshDirty = false;
+        if (needsFollowup && mediaTargetRefreshFollowupTimer === null) {
+            mediaTargetRefreshFollowupTimer = setTimeout(() => {
+                mediaTargetRefreshFollowupTimer = null;
+                refreshCurrentMediaTarget(selectedTabId, { queueIfRunning: true }).catch(() => {});
+            }, 250);
+        }
+    });
+    mediaTargetRefreshTask = wrappedTask;
+    return wrappedTask;
+}
+
+async function waitForMediaTargetRefresh(sender) {
+    const senderTabId = normalizeTabId(sender?.tab?.id);
+    if (senderTabId === null
+        || mediaTargetRefreshTabId !== senderTabId
+        || !mediaTargetRefreshTask) {
+        return;
+    }
+    await mediaTargetRefreshTask.catch(() => {});
+}
+
 async function retryPendingTarget({ expectedRequestId = null, requireGrantedAccess = false } = {}) {
     let pending = await readPendingTarget();
     if (!pending || (expectedRequestId !== null && pending.requestId !== expectedRequestId)) {
@@ -2433,17 +2826,15 @@ async function retryPendingTarget({ expectedRequestId = null, requireGrantedAcce
     }
 
     if (requireGrantedAccess) {
-        let access;
+        let granted;
         try {
-            access = await inspectTabHostAccess(chrome, pending.tabId);
-        } catch {
-            await clearPendingTarget({
-                expectedRequestId: pending.requestId,
-                expectedTabId: pending.tabId
+            granted = await chrome.permissions.contains({
+                origins: [pending.originPattern]
             });
-            return { status: 'invalid_tab' };
+        } catch {
+            return { status: 'permission_not_granted' };
         }
-        if (access.granted !== true || access.originPattern !== pending.originPattern) {
+        if (granted !== true) {
             return { status: 'permission_not_granted' };
         }
         pending = await readPendingTarget();
@@ -2498,6 +2889,22 @@ if (chrome.permissions?.onAdded?.addListener) {
     });
 }
 
+if (chrome.webNavigation?.onCompleted?.addListener) {
+    chrome.webNavigation.onCompleted.addListener((details) => {
+        ensureState().then(async () => {
+            const tabId = normalizeTabId(details?.tabId);
+            const frameId = normalizeFrameId(details?.frameId);
+            if (tabId === null
+                || tabId !== normalizeTabId(currentTabId)
+                || frameId === 0
+                || (frameId !== normalizeFrameId(currentTargetFrameId) && currentTargetHasVideo)) {
+                return;
+            }
+            await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
+        }).catch(error => addLog(`Media frame navigation refresh failed: ${error.message}`, 'warn'));
+    });
+}
+
 if (chrome.tabs?.onRemoved?.addListener) {
     chrome.tabs.onRemoved.addListener((removedTabId) => {
         ensureState().then(async () => {
@@ -2518,6 +2925,7 @@ if (chrome.tabs?.onRemoved?.addListener) {
             if (isCurrent) {
                 currentTabId = null;
                 currentTabTitle = null;
+                clearCurrentContentTarget();
                 lastContentHeartbeatAt = null;
                 if (currentRoom) roomIdleSince = Date.now();
             }
@@ -2530,6 +2938,9 @@ if (chrome.tabs?.onRemoved?.addListener) {
             await chrome.storage.session.set({
                 currentTabId,
                 currentTabTitle,
+                currentTargetFrameId,
+                currentTargetDocumentId,
+                currentTargetHasVideo,
                 roomIdleSince,
                 lastContentHeartbeatAt
             });
@@ -2571,41 +2982,68 @@ if (chrome.tabs?.onRemoved?.addListener) {
     });
 }
 
-function _routeToContentInternal(tabId, action, payload, actionTimestamp, commandSenderId, retries, targetGeneration) {
-    if (!isCurrentTargetIdentity(tabId, targetGeneration)) return;
-    chrome.tabs.sendMessage(tabId, { 
-        type: 'SERVER_COMMAND',
-        action,
-        payload,
-        actionTimestamp,
-        commandSenderId
-    }).catch(err => {
-        if (!isCurrentTargetIdentity(tabId, targetGeneration)) return;
-        if (retries >= 3) {
-            addLog(`Content Script not responding in tab ${tabId} after ${retries} retries`, 'warn');
-            clearTargetTabForIdle(tabId, targetGeneration);
-            return;
-        }
-        if (err.message.includes('Receiving end does not exist') || err.message.includes('Extension context invalidated')) {
-            reactivateCurrentTarget(tabId, { expectedGeneration: targetGeneration }).then(response => {
-                if (response?.status !== 'ok') return;
-                setTimeout(() => _routeToContentInternal(
+async function _routeToContentInternal(tabId, action, payload, actionTimestamp, commandSenderId, retries) {
+    if (normalizeTabId(currentTabId) !== normalizeTabId(tabId)) return;
+    if (mediaTargetRefreshTask && mediaTargetRefreshTabId === normalizeTabId(tabId)) {
+        await mediaTargetRefreshTask.catch(() => {});
+        if (normalizeTabId(currentTabId) !== normalizeTabId(tabId)) return;
+    }
+
+    const targetGeneration = targetActivationGeneration;
+    try {
+        await sendMessageToContentTab(tabId, {
+            type: 'SERVER_COMMAND',
+            action,
+            payload,
+            actionTimestamp,
+            commandSenderId
+        });
+    } catch (error) {
+        if (!isCurrentTargetIdentity(tabId, targetGeneration)) {
+            if (normalizeTabId(currentTabId) === normalizeTabId(tabId) && retries < 3) {
+                await _routeToContentInternal(
                     tabId,
                     action,
                     payload,
                     actionTimestamp,
                     commandSenderId,
-                    retries + 1,
-                    response.generation
-                ), 500);
-            }).catch(_err => {
-                addLog(`Auto-reinject failed for tab ${tabId}`, 'warn');
-            });
-        } else {
-            addLog(`Content Script not responding in tab ${tabId}`, 'warn');
-            clearTargetTabForIdle(tabId, targetGeneration);
+                    retries + 1
+                );
+            }
+            return;
         }
-    });
+        if (retries >= 3) {
+            addLog(`Content Script not responding in tab ${tabId} after ${retries} retries`, 'warn');
+            clearTargetTabForIdle(tabId, targetGeneration);
+            return;
+        }
+
+        const message = String(error?.message || '');
+        if (message.includes('Receiving end does not exist')
+            || message.includes('Extension context invalidated')
+            || message.includes('No document with id')
+            || message.includes('No document with ID')) {
+            try {
+                const response = await refreshCurrentMediaTarget(tabId);
+                if (response?.status !== 'ok' && response?.status !== 'activation_in_progress') return;
+                await new Promise(resolve => setTimeout(resolve, 150));
+                await _routeToContentInternal(
+                    tabId,
+                    action,
+                    payload,
+                    actionTimestamp,
+                    commandSenderId,
+                    retries + 1
+                );
+            } catch (refreshError) {
+                addLog(`Auto-reinject failed for tab ${tabId}: ${refreshError.message}`, 'warn');
+            }
+            return;
+        }
+
+        addLog(`Content Script not responding in tab ${tabId}`, 'warn');
+        clearTargetTabForIdle(tabId, targetGeneration);
+    }
 }
 
 // --- Keep-Alive Mechanism ---
@@ -2648,7 +3086,7 @@ chrome.alarms.onAlarm.addListener(async (alarm) => {
 
 function leaveOldRoomIfSwitching(newRoomId) {
     if (currentRoom && currentRoom.roomId !== newRoomId) {
-        if (currentTabId) chrome.tabs.sendMessage(Number(currentTabId), { type: 'CHAT_RESET' }).catch(() => {});
+        if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_RESET' }).catch(() => {});
         addLog(`Switching rooms: leaving ${currentRoom.roomId} to join ${newRoomId}`, 'info');
         forceDisconnect();
         currentRoom = null;
@@ -2682,19 +3120,48 @@ function leaveOldRoomIfSwitching(newRoomId) {
     }
 }
 
-function resetAudioProcessingInTab(tabId) {
+function resetAudioProcessingInTab(tabId, contentTarget = null) {
     if (!tabId) return;
+    if (contentTarget) {
+        sendMessageToFrame(
+            tabId,
+            contentTarget.frameId,
+            { action: 'RESET_AUDIO_PROCESSING' },
+            null,
+            contentTarget.documentId
+        ).catch(() => {});
+        return;
+    }
+    if (normalizeTabId(tabId) === normalizeTabId(currentTabId)) {
+        sendMessageToCurrentContent({ action: 'RESET_AUDIO_PROCESSING' }).catch(() => {});
+        return;
+    }
     chrome.tabs.sendMessage(tabId, { action: 'RESET_AUDIO_PROCESSING' }).catch(() => {});
 }
 
-async function applyAudioSettingsToTab(tabId) {
+async function applyAudioSettingsToTab(tabId, contentTarget = null) {
     if (!tabId) return;
     // Local-only: audioSettings are never read from storage.sync.
     const data = await chrome.storage.local.get(['audioSettings']);
-    chrome.tabs.sendMessage(tabId, {
+    const message = {
         action: 'APPLY_AUDIO_SETTINGS',
         settings: data.audioSettings
-    }).catch(() => {});
+    };
+    if (contentTarget) {
+        sendMessageToFrame(
+            tabId,
+            contentTarget.frameId,
+            message,
+            null,
+            contentTarget.documentId
+        ).catch(() => {});
+        return;
+    }
+    if (normalizeTabId(tabId) === normalizeTabId(currentTabId)) {
+        sendMessageToCurrentContent(message).catch(() => {});
+        return;
+    }
+    chrome.tabs.sendMessage(tabId, message).catch(() => {});
 }
 
 // --- Extension Message Listeners ---
@@ -2709,18 +3176,32 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
 chrome.storage.onChanged.addListener((changes, area) => {
     if (area !== 'local') return;
     if (changes.browserNotifications && currentTabId) {
-        chrome.tabs.sendMessage(Number(currentTabId), { type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+        sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
     }
     if (!changes.roomId && !changes.chatKey && !changes.chatEnabled) return;
     if (changes.chatKey) chatSecretGuard = validateChatSecret(changes.chatKey.newValue);
     invalidateChatSession();
-    if (currentTabId) chrome.tabs.sendMessage(Number(currentTabId), { type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+    if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
 });
 
 async function handleAsyncMessage(message, sender, sendResponse) {
     if (!message) return;
     await ensureState();
 
+    const senderTabId = normalizeTabId(sender?.tab?.id);
+    const mediaLifecycleMessage = message.type === 'MEDIA_FRAME_CANDIDATE_CHANGED'
+        || message.type === 'MEDIA_FRAME_VISIBILITY'
+        || message.type === 'MEDIA_TARGET_REFRESH';
+    if (!mediaLifecycleMessage) await waitForMediaTargetRefresh(sender);
+
+    const mustRevalidateEmbeddedSender = senderTabId !== null
+        && normalizeFrameId(currentTargetFrameId) !== 0
+        && isCurrentContentSender(sender)
+        && (message.type === 'CONTENT_EVENT' || message.type === 'HEARTBEAT');
+    if (mustRevalidateEmbeddedSender) {
+        await refreshCurrentMediaTarget(senderTabId).catch(() => {});
+    }
+
     if (message.type === 'CONNECT') {
         webJoinCoordinator.invalidate();
         const settings = await getSettings();
@@ -2729,7 +3210,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) chrome.tabs.sendMessage(Number(currentTabId), { type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+            if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
             await broadcastJoinStatus({ type: 'JOIN_STATUS', success: true, message: 'Already in room' });
             if (typeof sendResponse === 'function') sendResponse({ status: 'ok' });
             return;
@@ -2785,6 +3266,9 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             peers: currentRoom ? currentRoom.peers : [],
             lastActionState,
             targetTabId: currentTabId,
+            targetFrameId: currentTargetFrameId,
+            targetDocumentId: currentTargetDocumentId,
+            targetHasVideo: currentTargetHasVideo,
             pendingTargetTabId: pendingTarget?.tabId ?? null,
             pendingTargetHost: pendingTarget?.host ?? null,
             pendingTargetOriginPattern: pendingTarget?.originPattern ?? null,
@@ -2809,8 +3293,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             chatEnabled: settings.chatEnabled
         });
     } else if (message.type === 'GET_CHAT_CONTEXT') {
-        const senderTabId = sender.tab?.id;
-        if (!currentRoom || !currentTabId || senderTabId !== Number(currentTabId)) {
+        if (!currentRoom || !currentTabId || !isCurrentContentSender(sender)) {
             sendResponse({ supported: false, hasKey: false });
             return;
         }
@@ -2857,8 +3340,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             }
         });
     } else if (message.type === 'CHAT_SEND') {
-        const senderTabId = sender.tab?.id;
-        if (!currentRoom || !currentTabId || senderTabId !== Number(currentTabId)) {
+        if (!currentRoom || !currentTabId || !isCurrentContentSender(sender)) {
             sendResponse({ status: 'invalid_tab' });
             return;
         }
@@ -2960,7 +3442,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         // "Solo" to the host (stale-badge split-brain).
         sendResponse({ controlMode, hostPeerId, controllers, amHost: amHost(), amController: amController(), desynced: hcmDesynced, hostControlSupported: serverSupports(CAPABILITIES.HOST_CONTROL), coHostSupported: serverSupports(CAPABILITIES.CO_HOST) });
     } else if (message.type === 'REQUEST_HOST_SYNC') {
-        if (sender.tab && normalizeTabId(currentTabId) !== normalizeTabId(sender.tab.id)) {
+        if (sender.tab && !isCurrentContentSender(sender)) {
             sendResponse({ status: 'ignored_unselected_tab', target: null });
             return;
         }
@@ -2987,7 +3469,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
     } else if (message.type === 'HCM_DESYNC_STATE') {
         // content.js tells us whether the local user chose to watch on their own.
         // Only accept from the currently selected tab.
-        if (sender.tab && normalizeTabId(currentTabId) !== normalizeTabId(sender.tab.id)) {
+        if (sender.tab && !isCurrentContentSender(sender)) {
             sendResponse({ status: 'ignored_unselected_tab' });
             return;
         }
@@ -3015,10 +3497,11 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         // Notify content.js/popup BEFORE currentTabId is cleared so they drop any
         // stale guest-side HCM state (dialog/badge/desync) — H-2/H-3.
         broadcastControlMode();
-        if (currentTabId) await deactivateTargetTab(currentTabId);
+        if (currentTabId) await deactivateTargetTab(currentTabId, currentContentTarget());
         invalidateTargetActivations();
         currentTabId = null;
         currentTabTitle = null;
+        clearCurrentContentTarget();
         roomIdleSince = null;
         lastContentHeartbeatAt = null;
 
@@ -3038,6 +3521,9 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             chatActivityTimeline: [],
             currentTabId: null,
             currentTabTitle: null,
+            currentTargetFrameId: 0,
+            currentTargetDocumentId: null,
+            currentTargetHasVideo: false,
             roomIdleSince: null,
             lastContentHeartbeatAt: null,
             isForceSyncInitiator: false,
@@ -3103,7 +3589,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) chrome.tabs.sendMessage(Number(currentTabId), { type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
+                    if (currentTabId) sendMessageToCurrentContent({ type: 'CHAT_CONTEXT_UPDATE' }).catch(() => {});
                     const statusSent = await broadcastJoinStatus(
                         { type: 'JOIN_STATUS', success: true, message: 'Already in room' },
                         isCurrentJoin
@@ -3157,17 +3643,15 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             sendResponse({ peerId: newId });
         });
     } else if (message.type === 'GET_VIDEO_STATE') {
-        const { tabId } = message;
-        if (!tabId) {
+        const tabId = normalizeTabId(message.tabId);
+        if (tabId === null) {
             sendResponse({ error: 'No tabId provided' });
             return;
         }
-        chrome.tabs.sendMessage(tabId, { type: 'GET_VIDEO_STATE' }, (res) => {
-            if (chrome.runtime.lastError) {
-                sendResponse({ error: chrome.runtime.lastError.message });
-            } else {
-                sendResponse(res);
-            }
+        getReadyTabVideoState(tabId).then(state => {
+            sendResponse(state);
+        }).catch(error => {
+            sendResponse({ error: error.message });
         });
     } else if (message.type === 'DEV_SIMULATE_REMOTE_SEEK') {
         if (!(await devRemoteToolsAllowed())) {
@@ -3186,7 +3670,8 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             sendResponse({ status: 'error', message: err.message });
         });
     } else if (message.type === 'CONTENT_EVENT') {
-        if (!sender?.tab && message.expectedTabId !== undefined) {
+        const senderIsContent = !!sender?.tab && !isExtensionPageSender(sender);
+        if (!senderIsContent && message.expectedTabId !== undefined) {
             const expectedTabId = normalizeTabId(message.expectedTabId);
             if (expectedTabId === null || normalizeTabId(currentTabId) !== expectedTabId) {
                 sendResponse({ status: 'stale_target' });
@@ -3202,12 +3687,12 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             if (controlMode === CONTROL_MODES.HOST_ONLY && hostPeerId && !amController() &&
                 HOST_ONLY_GATED_ACTIONS.includes(message.action)) {
                 addLog(`Host-only: blocked local ${message.action} (you are a guest)`, 'warn');
-                if (sender.tab && sender.tab.id) {
-                    chrome.tabs.sendMessage(sender.tab.id, {
+                if (senderIsContent && sender.tab.id) {
+                    sendMessageToFrame(sender.tab.id, sender.frameId, {
                         type: 'HOST_BLOCKED',
                         action: message.action,
                         target: getHostSyncTarget()
-                    }).catch(() => {});
+                    }, null, sender.documentId).catch(() => {});
                 }
                 sendResponse({ status: 'blocked_host_only' });
                 return;
@@ -3251,7 +3736,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             updateLastAction(message.action, 'You', timestamp);
             
             const hasPlaybackTime = Number.isFinite(payload.currentTime) || Number.isFinite(payload.targetTime);
-            if (!sender?.tab && (message.action === EVENTS.PLAY || message.action === EVENTS.PAUSE) && !hasPlaybackTime) {
+            if (!senderIsContent && (message.action === EVENTS.PLAY || message.action === EVENTS.PAUSE) && !hasPlaybackTime) {
                 const tabId = currentTabId ? parseInt(currentTabId) : NaN;
                 if (!isNaN(tabId)) {
                     const state = await getReadyTabVideoState(tabId);
@@ -3273,7 +3758,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
                 currentTime: payload.currentTime !== undefined ? payload.currentTime : (payload.targetTime !== undefined ? payload.targetTime : undefined)
             });
 
-            if (!sender?.tab && (message.action === EVENTS.PLAY || message.action === EVENTS.PAUSE || message.action === EVENTS.SEEK)) {
+            if (!senderIsContent && (message.action === EVENTS.PLAY || message.action === EVENTS.PAUSE || message.action === EVENTS.SEEK)) {
                 routeToContent(message.action, message.payload);
             }
 
@@ -3315,10 +3800,8 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             sendResponse({ status: 'ok' });
         };
 
-        if (sender.tab) {
-            const senderTabId = sender.tab.id;
-            
-            if (!currentTabId || currentTabId !== senderTabId) {
+        if (senderIsContent) {
+            if (!isCurrentContentSender(sender)) {
                 sendResponse({ status: 'ignored_unselected_tab' });
                 return;
             }
@@ -3337,7 +3820,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             });
         }
     } else if (message.type === 'FORCE_SYNC_ACK') {
-        if (sender.tab && normalizeTabId(currentTabId) !== normalizeTabId(sender.tab.id)) {
+        if (sender.tab && !isCurrentContentSender(sender)) {
             sendResponse({ status: 'ignored_unselected_tab' });
             return;
         }
@@ -3365,7 +3848,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         }
         sendResponse({ status: 'ok' });
     } else if (message.type === 'CMD_ACK') {
-        if (sender.tab && normalizeTabId(currentTabId) !== normalizeTabId(sender.tab.id)) {
+        if (sender.tab && !isCurrentContentSender(sender)) {
             sendResponse({ status: 'ignored_unselected_tab' });
             return;
         }
@@ -3385,9 +3868,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         sendResponse({ status: 'ok' });
     } else if (message.type === 'HEARTBEAT') {
         if (sender.tab) {
-            const senderTabId = sender.tab.id;
-            
-            if (!currentTabId || currentTabId !== senderTabId) {
+            if (!isCurrentContentSender(sender)) {
                 sendResponse({ status: 'ignored_unselected_tab' });
                 return;
             }
@@ -3446,9 +3927,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             return true;
         }
 
-        reactivateCurrentTarget(tabId, {
-            expectedGeneration: targetActivationGeneration
-        }).then(response => {
+        refreshCurrentMediaTarget(tabId).then(response => {
             sendResponse(response);
         }).catch(err => {
             addLog(`Failed to inject into tab: ${err.message}`, 'warn');
@@ -3458,19 +3937,24 @@ async function handleAsyncMessage(message, sender, sendResponse) {
     } else if (message.type === 'SET_TARGET_TAB') {
         if (message.tabId === null || message.tabId === undefined || message.tabId === '') {
             const previousTabId = currentTabId;
+            const previousContentTarget = currentContentTarget();
             completeForceSyncBeforeTargetChange(null);
             invalidateTargetActivations();
             currentTabId = null;
             currentTabTitle = null;
+            clearCurrentContentTarget();
             lastContentHeartbeatAt = null;
             if (currentRoom) roomIdleSince = Date.now();
             if (previousTabId) {
-                await deactivateTargetTab(previousTabId);
+                await deactivateTargetTab(previousTabId, previousContentTarget);
             }
             await clearPendingTarget();
             await chrome.storage.session.set({
                 currentTabId: null,
                 currentTabTitle: null,
+                currentTargetFrameId: 0,
+                currentTargetDocumentId: null,
+                currentTargetHasVideo: false,
                 roomIdleSince,
                 lastContentHeartbeatAt: null
             });
@@ -3498,8 +3982,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
     } else if (message.type === 'EPISODE_CHANGED') {
         // Content script detected an episode transition
         if (sender.tab) {
-            const senderTabId = sender.tab.id;
-            if (!currentTabId || currentTabId !== senderTabId) {
+            if (!isCurrentContentSender(sender)) {
                 sendResponse({ status: 'ignored_unselected_tab' });
                 return;
             }
@@ -3584,10 +4067,10 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         // Tell content script to pause the video and start polling
         // (This is the only place we pause — after confirming the feature is enabled)
         if (sender.tab && sender.tab.id) {
-            chrome.tabs.sendMessage(sender.tab.id, {
+            sendMessageToFrame(sender.tab.id, sender.frameId, {
                 type: 'PAUSE_FOR_LOBBY',
                 expectedTitle: lobbyTitle
-            }).catch(() => {});
+            }, null, sender.documentId).catch(() => {});
         }
 
         // Broadcast to room
@@ -3602,8 +4085,7 @@ async function handleAsyncMessage(message, sender, sendResponse) {
         sendResponse({ status: 'lobby_created' });
     } else if (message.type === 'EPISODE_READY_LOCAL') {
         if (sender.tab) {
-            const senderTabId = sender.tab.id;
-            if (!currentTabId || currentTabId !== senderTabId) {
+            if (!isCurrentContentSender(sender)) {
                 sendResponse({ status: 'ignored_unselected_tab' });
                 return;
             }
@@ -3642,13 +4124,44 @@ async function handleAsyncMessage(message, sender, sendResponse) {
             });
         }
         if (currentRoom && currentTabId) {
-            chrome.tabs.sendMessage(currentTabId, { type: 'REQUEST_HEARTBEAT' }).catch(() => {});
+            sendMessageToCurrentContent({ type: 'REQUEST_HEARTBEAT' }).catch(() => {});
         }
         sendResponse({ status: 'ok' });
+    } else if (message.type === 'MEDIA_FRAME_CANDIDATE_CHANGED') {
+        const tabId = normalizeTabId(sender.tab?.id);
+        if (tabId === null || tabId !== normalizeTabId(currentTabId)) {
+            sendResponse({ status: 'ignored_stale_tab' });
+            return;
+        }
+        const activation = await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
+        sendResponse(activation || { status: 'invalid_tab' });
+    } else if (message.type === 'MEDIA_FRAME_VISIBILITY') {
+        if (!isCurrentContentSender(sender)) {
+            sendResponse({ status: 'ignored_stale_frame' });
+            return;
+        }
+        if (message.visible !== false) {
+            sendResponse({ status: 'ok' });
+            return;
+        }
+        const tabId = normalizeTabId(sender.tab?.id);
+        const activation = tabId === null
+            ? null
+            : await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
+        sendResponse(activation || { status: 'invalid_tab' });
+    } else if (message.type === 'MEDIA_TARGET_REFRESH') {
+        if (!isCurrentContentSender(sender)) {
+            sendResponse({ status: 'ignored_stale_frame' });
+            return;
+        }
+        const tabId = normalizeTabId(sender.tab?.id);
+        const activation = tabId === null
+            ? null
+            : await refreshCurrentMediaTarget(tabId, { queueIfRunning: true });
+        sendResponse(activation || { status: 'invalid_tab' });
     } else if (message.type === 'CONTENT_BOOT') {
         if (sender.tab) {
-            const senderTabId = sender.tab.id;
-            if (!currentTabId || currentTabId !== senderTabId) {
+            if (!isCurrentContentSender(sender)) {
                 sendResponse({ status: 'ignored_unselected_tab' });
                 return;
             }
@@ -3674,8 +4187,9 @@ async function handleAsyncMessage(message, sender, sendResponse) {
 
 initTabManager({
     getCurrentTabId: () => currentTabId,
-    reactivateCurrentTarget,
-    ensureState
+    reactivateCurrentTarget: tabId => refreshCurrentMediaTarget(tabId, { queueIfRunning: true }),
+    ensureState,
+    sendToCurrentContent: sendMessageToCurrentContent
 });
 
 // Initial Connect — only if user has an active room configuration
diff --git a/extension/content.js b/extension/content.js
index 5a7228b..b96816d 100644
--- a/extension/content.js
+++ b/extension/content.js
@@ -17,6 +17,7 @@
     const lifecycleTimeouts = new Set();
     const seekPollTimers = new Set();
     const attachedVideos = new Set();
+    let activeVideo = null;
 
     function scheduleLifecycleTimeout(callback, delay) {
         const timer = setTimeout(() => {
@@ -40,6 +41,34 @@
             return Promise.resolve(undefined);
         }
     }
+
+    const isEmbeddedContentFrame = (() => {
+        try { return window.top !== window; } catch (_e) { return true; }
+    })();
+    let mediaTargetRefreshTimeout = null;
+    let mediaTargetRefreshBlockedUntil = 0;
+    let lastMediaFrameVisible = window.innerWidth > 0 && window.innerHeight > 0;
+
+    function requestMediaTargetRefresh(reason) {
+        if (destroyed || mediaTargetRefreshTimeout || Date.now() < mediaTargetRefreshBlockedUntil) return;
+        mediaTargetRefreshTimeout = scheduleLifecycleTimeout(() => {
+            mediaTargetRefreshTimeout = null;
+            mediaTargetRefreshBlockedUntil = Date.now() + 1500;
+            runtimeMessage({ type: 'MEDIA_TARGET_REFRESH', reason }).catch(() => {});
+        }, 750);
+    }
+
+    function handleMediaFrameResize() {
+        if (destroyed || !isEmbeddedContentFrame) return;
+        const visible = window.innerWidth > 0 && window.innerHeight > 0;
+        if (visible === lastMediaFrameVisible) return;
+        lastMediaFrameVisible = visible;
+        runtimeMessage({ type: 'MEDIA_FRAME_VISIBILITY', visible }).catch(() => {});
+    }
+
+    if (isEmbeddedContentFrame) {
+        window.addEventListener('resize', handleMediaFrameResize, { passive: true });
+    }
 

     // --- SHARED_EVENTS_INJECT_START ---

     // This block is automatically updated by /scripts/build-extension.cjs
@@ -225,8 +254,9 @@
     // 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 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;

@@ -599,12 +629,75 @@
         return out;

     }

 

-    // Rendered size in CSS pixels. Intrinsic resolution (videoWidth) is

-    // deliberately not used here: a display:none element still reports its full

-    // intrinsic size, which let hidden preloads outrank the visible player.

-    function getRenderedVideoArea(video) {

-        return (video.offsetWidth || 0) * (video.offsetHeight || 0);

-    }

+    function getElementRenderBox(element) {
+        try {
+            if (typeof element.getBoundingClientRect === 'function') {
+                const rect = element.getBoundingClientRect();
+                return {
+                    width: Math.max(0, Number(rect.width) || 0),
+                    height: Math.max(0, Number(rect.height) || 0),
+                    top: Number(rect.top) || 0,
+                    right: Number(rect.right) || 0,
+                    bottom: Number(rect.bottom) || 0,
+                    left: Number(rect.left) || 0
+                };
+            }
+        } catch (_e) { /* detached element */ }
+        const width = Math.max(0, Number(element.offsetWidth) || 0);
+        const height = Math.max(0, Number(element.offsetHeight) || 0);
+        return { width, height, top: 0, right: width, bottom: height, left: 0 };
+    }
+
+    function elementStylesAllowRendering(element) {
+        let current = element;
+        while (current) {
+            try {
+                const view = current.ownerDocument?.defaultView;
+                const style = view?.getComputedStyle?.(current);
+                if (style && (style.display === 'none'
+                    || style.visibility === 'hidden'
+                    || Number(style.opacity) === 0)) {
+                    return false;
+                }
+                if (typeof current.checkVisibility === 'function'
+                    && !current.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true })) {
+                    return false;
+                }
+            } catch (_e) { /* use geometry when style inspection is unavailable */ }
+            const parent = current.parentElement;
+            if (parent) {
+                current = parent;
+                continue;
+            }
+            try { current = current.getRootNode?.().host || null; } catch (_e) { current = null; }
+        }
+        return true;
+    }
+
+    function isElementRendered(element) {
+        if (!element || !elementStylesAllowRendering(element)) return false;
+        const rect = getElementRenderBox(element);
+        if (rect.width <= 0 || rect.height <= 0) return false;
+        const view = element.ownerDocument?.defaultView;
+        const viewportWidth = Number(view?.innerWidth);
+        const viewportHeight = Number(view?.innerHeight);
+        if (Number.isFinite(viewportWidth) && Number.isFinite(viewportHeight)
+            && viewportWidth > 0 && viewportHeight > 0) {
+            return rect.bottom > 0
+                && rect.right > 0
+                && rect.top < viewportHeight
+                && rect.left < viewportWidth;
+        }
+        return true;
+    }
+
+    // Rendered size in CSS pixels. Intrinsic resolution (videoWidth) is
+    // deliberately not used here: hidden preloads keep their intrinsic size.
+    function getRenderedVideoArea(video) {
+        if (!isVideoRendered(video)) return 0;
+        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.

@@ -612,11 +705,19 @@
         return Math.round(Math.sqrt(getRenderedVideoArea(video)) / 40);

     }

 

-    function isVideoRendered(video) {

-        // A non-zero box is proof enough, and it also covers position:fixed

-        // players, whose offsetParent is null even though they are on screen.

-        if (getRenderedVideoArea(video) > 0) return true;

-        return video.offsetParent !== null && video.offsetParent !== undefined;

+    function isVideoRendered(video) {
+        if (!isElementRendered(video)) return false;
+        // Same-origin videos may be discovered recursively from the top frame.
+        // Their own box can remain non-zero while an ancestor iframe is hidden.
+        let view = video.ownerDocument?.defaultView;
+        const seen = new Set();
+        while (view?.frameElement && !seen.has(view.frameElement)) {
+            const frame = view.frameElement;
+            seen.add(frame);
+            if (!isElementRendered(frame)) return false;
+            view = frame.ownerDocument?.defaultView;
+        }
+        return true;
     }

 

     function hasPlayableVideoSource(video) {

@@ -631,22 +732,32 @@
         return !!video.loop && !!video.muted && !video.controls;

     }

 

-    function isVideoPlaying(video) {

-        return video.paused === false && video.ended !== true;

-    }

+    function isVideoPlaying(video) {
+        return video.paused === false && video.ended !== true;
+    }
+
+    function isShortUncontrolledVideo(video) {
+        return !video.controls
+            && video.duration
+            && isFinite(video.duration)
+            && 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.

-    const VIDEO_RANKING_SIGNALS = [

-        video => (hasPlayableVideoSource(video) ? 1 : 0),

-        video => (isVideoRendered(video) ? 1 : 0),

-        video => (isBackgroundVideo(video) ? 0 : 1),

-        video => getVideoSizeBucket(video),

-        video => (isVideoPlaying(video) ? 1 : 0),

-        video => (video.controls ? 1 : 0),

-        video => (video.duration && isFinite(video.duration) ? video.duration : 0)

+    const VIDEO_RANKING_SIGNALS = [
+        video => (hasPlayableVideoSource(video) ? 1 : 0),
+        video => (isVideoRendered(video) ? 1 : 0),
+        video => (isBackgroundVideo(video) ? 0 : 1),
+        video => (isShortUncontrolledVideo(video) ? 0 : 1),
+        video => (isVideoPlaying(video) ? 1 : 0),
+        video => (video.controls ? 1 : 0),
+        video => Number.isInteger(video.readyState) ? video.readyState : 0,
+        video => (video.duration && isFinite(video.duration) ? video.duration : 0),
+        video => getVideoSizeBucket(video)
     ];

 

     function compareVideoRanks(a, b) {

@@ -658,11 +769,11 @@
 

     // 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) {

+    function pickBestVideo(candidates) {
         let best = null;

         let bestRank = null;

         for (const video of candidates) {

-            if (!video || video.tagName !== 'VIDEO') continue;

+            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;

@@ -1307,7 +1418,10 @@
 

             const platform = (() => {

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

-                if (h === 'youtube.com' || h.endsWith('.youtube.com')) return 'YouTube';

+                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';

@@ -1447,10 +1561,10 @@
     // 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) {
+    function sendContentEvent(action, expectedVideo = null) {
         if (destroyed) return;
         const video = findVideo();
-        if (!video) return;

+        if (!video || (expectedVideo && (video !== expectedVideo || activeVideo !== expectedVideo))) return;
 

         const current = getSyncCurrentTime(video);
         if (current === null) return;
@@ -1477,12 +1591,14 @@
     // 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;

-        pendingPlayPauseAction = null;

+        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;

-        sendContentEvent(finalAction);

+        sendContentEvent(finalAction, sourceVideo);
     }

 

     function reportEvent(action) {
@@ -1529,12 +1645,14 @@
         if (action === EVENTS.PLAY || action === EVENTS.PAUSE) {

             if (playPauseCoalesceTimer === null) {

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

-                sendContentEvent(action);

-                pendingPlayPauseAction = null;

-            } else {

+                sendContentEvent(action, video);
+                pendingPlayPauseAction = null;
+                pendingPlayPauseVideo = null;
+            } else {
                 // Window open → part of a burst. Defer to the trailing flush.

-                pendingPlayPauseAction = action;

-                clearTimeout(playPauseCoalesceTimer);

+                pendingPlayPauseAction = action;
+                pendingPlayPauseVideo = video;
+                clearTimeout(playPauseCoalesceTimer);
             }

             playPauseCoalesceTimer = setTimeout(flushPlayPause, PLAY_PAUSE_COALESCE_MS);

             return;

@@ -1589,7 +1707,7 @@
         // 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 (playPauseCoalesceTimer) { clearTimeout(playPauseCoalesceTimer); playPauseCoalesceTimer = null; pendingPlayPauseAction = null; }
+        cancelPendingVideoEvents();
         observer.disconnect();
         observedDocs = new WeakSet();
     }
@@ -1600,7 +1718,12 @@
         pageSuspended = false;
         pageVisible = !document.hidden;
         if (pageVisible) visibilityGraceUntil = Date.now() + VISIBILITY_GRACE_MS;
-        observer.observe(document.documentElement, { childList: true, subtree: true });
+        observer.observe(document.documentElement, {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            attributeFilter: ['style', 'class', 'hidden', 'aria-hidden']
+        });
         observeSameOriginFrames();
         setupListeners();
         connectKeepAlivePort();
@@ -1612,17 +1735,28 @@
     window.addEventListener('pagehide', handlePageHide);
     window.addEventListener('pageshow', handlePageShow);
 

-    const handlePlay = () => reportEvent(EVENTS.PLAY);

-    const handlePause = () => reportEvent(EVENTS.PAUSE);

+    function isCurrentVideoEvent(event) {
+        const source = event?.currentTarget;
+        return !!source && source === activeVideo && source === findVideo();
+    }
+
+    const handlePlay = event => {
+        if (isCurrentVideoEvent(event)) reportEvent(EVENTS.PLAY);
+    };
+    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).

-    const handleWaiting = () => { hcmBufferingUntil = Date.now() + HCM_BUFFERING_GRACE_MS; };

+    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.

-    const handleSeeked = () => {

-        const video = findVideo();

-        if (!video) return;

+    const handleSeeked = event => {
+        if (!isCurrentVideoEvent(event)) return;
+        const video = event.currentTarget;
         const current = getSyncCurrentTime(video);
         if (current === null) return;
 

@@ -1653,11 +1787,11 @@
 

         // 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;

-            const v = findVideo();

-            if (!v) return;

+        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;

@@ -1672,25 +1806,48 @@
     let lastVideoSrc = undefined;

 

     // Episode detection handler for loadeddata event

-    const handleLoadedData = () => {

-        checkEpisodeTransition();

-    };

-

+    const handleLoadedData = event => {
+        if (isCurrentVideoEvent(event)) checkEpisodeTransition();
+    };
+
+    function detachVideoListeners(video) {
+        if (!video) return;
+        const handlers = video._koalaHandlers;
+        if (handlers) {
+            video.removeEventListener('play', handlers.play);
+            video.removeEventListener('pause', handlers.pause);
+            video.removeEventListener('seeked', handlers.seeked);
+            video.removeEventListener('loadeddata', handlers.loadeddata);
+            if (handlers.waiting) video.removeEventListener('waiting', handlers.waiting);
+            delete video._koalaHandlers;
+        }
+        try { delete video.dataset.koalaAttached; } catch (_e) { /* detached element */ }
+        attachedVideos.delete(video);
+        if (activeVideo === video) activeVideo = null;
+    }
+
+    function cancelPendingVideoEvents() {
+        if (seekDebounceTimer) { clearTimeout(seekDebounceTimer); seekDebounceTimer = null; }
+        if (playPauseCoalesceTimer) { clearTimeout(playPauseCoalesceTimer); playPauseCoalesceTimer = null; }
+        pendingPlayPauseAction = null;
+        pendingPlayPauseVideo = null;
+    }
+
     function setupListeners() {
         if (destroyed) return;
         const video = findVideo();
+        if (activeVideo !== video) cancelPendingVideoEvents();
+        for (const attached of [...attachedVideos]) {
+            if (attached !== video) detachVideoListeners(attached);
+        }
+        activeVideo = video || null;
         if (video) {
             if (currentAudioVideo && currentAudioVideo !== video) {

                 bypassCurrentAudioProcessing();

-            }

-            const existing = video._koalaHandlers;

-            if (existing) {

-                video.removeEventListener('play', existing.play);

-                video.removeEventListener('pause', existing.pause);

-                video.removeEventListener('seeked', existing.seeked);

-                video.removeEventListener('loadeddata', existing.loadeddata);

-                if (existing.waiting) video.removeEventListener('waiting', existing.waiting);

-            }

+            }
+            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);

@@ -1717,16 +1874,24 @@
         if (destroyed) return;
         lastMutate = Date.now();
         observeSameOriginFrames();
-        const video = findVideo();

-

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

-            reportLog('Video element removed from page', 'warn');

-            lastVideoSrc = undefined;

-            closeAudioContext();

-            return;

-        }

-

-        if (!video) return;

+        const video = findVideo();
+
+        if (!video && lastVideoSrc !== undefined) {
+            setupListeners();
+            reportLog('Video element removed from page', 'warn');
+            lastVideoSrc = undefined;
+            closeAudioContext();
+            requestMediaTargetRefresh('video_removed');
+            return;
+        }
+
+        if (!video) {
+            setupListeners();
+            if (isEmbeddedContentFrame || document.querySelector('iframe, frame')) {
+                requestMediaTargetRefresh('video_missing');
+            }
+            return;
+        }
 

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

 

@@ -1750,7 +1915,12 @@
             if (doc === document || observedDocs.has(doc)) continue;
             if (!doc.documentElement) continue;
             observedDocs.add(doc);
-            observer.observe(doc.documentElement, { childList: true, subtree: true });
+            observer.observe(doc.documentElement, {
+                childList: true,
+                subtree: true,
+                attributes: true,
+                attributeFilter: ['style', 'class', 'hidden', 'aria-hidden']
+            });
         }
         // Ad and SPA frames get torn down and recreated constantly; drop the
         // detached ones so the hook set doesn't grow for the page's lifetime.
@@ -1775,7 +1945,12 @@
         // document's tree.
         observer.disconnect();
         observedDocs = new WeakSet();
-        observer.observe(document.documentElement, { childList: true, subtree: true });
+        observer.observe(document.documentElement, {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            attributeFilter: ['style', 'class', 'hidden', 'aria-hidden']
+        });
         observeSameOriginFrames();
         checkVideo();
     }
@@ -1790,7 +1965,12 @@
             observerTimeout = setTimeout(checkVideo, 1000 - (now - lastMutate));

         }

     });

-    observer.observe(document.documentElement, { childList: true, subtree: true });

+    observer.observe(document.documentElement, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ['style', 'class', 'hidden', 'aria-hidden']
+    });
     observeSameOriginFrames();

 

     // --- SHARED_HEARTBEAT_INJECT_START ---

@@ -1851,8 +2031,9 @@
         }, 500); // 500ms stabilization delay

     }

 

-    // Initial Setup

-    setupListeners();

+    // Initial Setup
+    setupListeners();
+    checkVideo();
 

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

     let keepAlivePort = null;
@@ -1889,13 +2070,11 @@
 
         if (hcmDialogTimer) { clearTimeout(hcmDialogTimer); hcmDialogTimer = null; }
         if (episodeTransitionDebounce) { clearTimeout(episodeTransitionDebounce); episodeTransitionDebounce = null; }
-        if (seekDebounceTimer) { clearTimeout(seekDebounceTimer); seekDebounceTimer = null; }
-        if (playPauseCoalesceTimer) { clearTimeout(playPauseCoalesceTimer); playPauseCoalesceTimer = null; }
+        cancelPendingVideoEvents();
         if (observerTimeout) { clearTimeout(observerTimeout); observerTimeout = null; }
         if (heartbeatTimeout) { clearTimeout(heartbeatTimeout); heartbeatTimeout = null; }
         if (proactiveHeartbeatTimeout) { clearTimeout(proactiveHeartbeatTimeout); proactiveHeartbeatTimeout = null; }
         stopLobbyPoll();
-        pendingPlayPauseAction = null;
         hcmDeferredSnapPending = false;
 
         observer.disconnect();
@@ -1909,25 +2088,16 @@
             keepAlivePort = null;
         }
 
-        for (const video of attachedVideos) {
-            const handlers = video._koalaHandlers;
-            if (handlers) {
-                video.removeEventListener('play', handlers.play);
-                video.removeEventListener('pause', handlers.pause);
-                video.removeEventListener('seeked', handlers.seeked);
-                video.removeEventListener('loadeddata', handlers.loadeddata);
-                if (handlers.waiting) video.removeEventListener('waiting', handlers.waiting);
-                delete video._koalaHandlers;
-            }
-            delete video.dataset.koalaAttached;
-        }
+        for (const video of [...attachedVideos]) detachVideoListeners(video);
         attachedVideos.clear();
+        activeVideo = null;
 
         document.removeEventListener('keydown', _hcmGesture, true);
         document.removeEventListener('pointerdown', _hcmGesture, true);
         document.removeEventListener('visibilitychange', handleVisibilityChange);
         window.removeEventListener('pagehide', handlePageHide);
         window.removeEventListener('pageshow', handlePageShow);
+        window.removeEventListener('resize', handleMediaFrameResize);
         window.removeEventListener('message', handlePageApiTime);
         if (hcmBadgeDomReadyHandler) {
             document.removeEventListener('DOMContentLoaded', hcmBadgeDomReadyHandler);
diff --git a/extension/manifest.base.json b/extension/manifest.base.json
index 851c3f0..437cfc0 100644
--- a/extension/manifest.base.json
+++ b/extension/manifest.base.json
@@ -11,7 +11,8 @@
     "scripting",
     "alarms",
     "activeTab",
-    "notifications"
+    "notifications",
+    "webNavigation"
   ],
   "host_permissions": [
     "<all_urls>"
diff --git a/extension/media-frame-monitor.js b/extension/media-frame-monitor.js
new file mode 100644
index 0000000..040546f
--- /dev/null
+++ b/extension/media-frame-monitor.js
@@ -0,0 +1,196 @@
+/**
+ * Lightweight per-frame sentinel. It does not control media; it only tells the
+ * background that the selected tab's candidate set or frame layout changed.
+ */
+(function installKoalaMediaFrameMonitor() {
+    try { window.__koalaMediaFrameMonitorCleanup?.(); } catch { /* stale monitor */ }
+
+    let destroyed = false;
+    let notifyTimer = null;
+    const hookedFrames = new Set();
+    let lastCandidateSignature = null;
+
+    function geometryBucket(value) {
+        return Math.round(value / 8);
+    }
+
+    function elementStylesAllowRendering(element) {
+        let current = element;
+        while (current) {
+            try {
+                const style = window.getComputedStyle(current);
+                if (style.display === 'none'
+                    || style.visibility === 'hidden'
+                    || Number(style.opacity) === 0) {
+                    return false;
+                }
+            } catch { /* detached or browser-owned node */ }
+            const parent = current.parentElement;
+            if (parent) {
+                current = parent;
+                continue;
+            }
+            try { current = current.getRootNode?.().host || null; } catch { current = null; }
+        }
+        return true;
+    }
+
+    function candidateSignature() {
+        const parts = [];
+        for (const element of document.querySelectorAll('video, iframe, frame')) {
+            try {
+                const rect = element.getBoundingClientRect();
+                const style = window.getComputedStyle(element);
+                const browserReportsVisible = typeof element.checkVisibility === 'function'
+                    ? element.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true })
+                    : true;
+                const visible = rect.width > 0
+                    && rect.height > 0
+                    && rect.bottom > 0
+                    && rect.right > 0
+                    && rect.top < window.innerHeight
+                    && rect.left < window.innerWidth
+                    && browserReportsVisible
+                    && elementStylesAllowRendering(element)
+                    && style.display !== 'none'
+                    && style.visibility !== 'hidden'
+                    && Number(style.opacity) !== 0;
+                const source = element.tagName === 'VIDEO'
+                    ? (element.currentSrc || element.src || element.querySelector?.('source[src]')?.src || '')
+                    : (element.src || '');
+                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
+                    ].join(',')
+                    : '';
+                parts.push([
+                    element.tagName,
+                    source,
+                    visible ? 1 : 0,
+                    geometryBucket(rect.left),
+                    geometryBucket(rect.top),
+                    geometryBucket(rect.width),
+                    geometryBucket(rect.height),
+                    mediaState
+                ].join(':'));
+            } catch {
+                parts.push('detached');
+            }
+        }
+        return parts.join('|');
+    }
+
+    function send(reason) {
+        if (destroyed) return;
+        try {
+            chrome.runtime.sendMessage({ type: 'MEDIA_FRAME_CANDIDATE_CHANGED', reason }).catch(() => {});
+        } catch {
+            cleanup();
+        }
+    }
+
+    function schedule(reason, { force = false } = {}) {
+        if (destroyed || notifyTimer !== null) return;
+        notifyTimer = setTimeout(() => {
+            notifyTimer = null;
+            const nextSignature = candidateSignature();
+            if (!force && nextSignature === lastCandidateSignature) return;
+            lastCandidateSignature = nextSignature;
+            send(reason);
+        }, 0);
+    }
+
+    function containsAddedMediaNode(node) {
+        return node?.nodeType === 1
+            && (node.matches?.('video, iframe, frame') || node.querySelector?.('video, iframe, frame'));
+    }
+
+    function attributeAffectsCandidate(node) {
+        return node?.nodeType === 1
+            && (node.matches?.('video, iframe, frame') || node.querySelector?.('video, iframe, frame'));
+    }
+
+    function hookFrames() {
+        for (const frame of hookedFrames) {
+            if (frame.isConnected) continue;
+            frame.removeEventListener('load', handleFrameLoad);
+            hookedFrames.delete(frame);
+        }
+        for (const frame of document.querySelectorAll('iframe, frame')) {
+            if (hookedFrames.has(frame)) continue;
+            hookedFrames.add(frame);
+            frame.addEventListener('load', handleFrameLoad);
+        }
+    }
+
+    function handleFrameLoad() {
+        hookFrames();
+        schedule('frame_load', { force: true });
+    }
+
+    const observer = new MutationObserver((mutations) => {
+        let relevant = false;
+        for (const mutation of mutations) {
+            if (mutation.type === 'attributes') {
+                if (attributeAffectsCandidate(mutation.target)) relevant = true;
+            } else if ([...mutation.addedNodes, ...mutation.removedNodes].some(containsAddedMediaNode)) {
+                relevant = true;
+            }
+            if (relevant) break;
+        }
+        if (!relevant) return;
+        hookFrames();
+        schedule('media_dom_changed');
+    });
+
+    function handlePageHide() { send('frame_pagehide'); }
+    function handlePageShow() { schedule('frame_pageshow', { force: true }); }
+    function handleResize() { schedule('frame_resize'); }
+    function handleMediaState(event) {
+        if (event.target?.tagName === 'VIDEO') schedule(`media_${event.type}`);
+    }
+    function handleMessage(message) {
+        if (message?.type === 'MEDIA_MONITOR_DEACTIVATE') cleanup();
+    }
+
+    function cleanup() {
+        if (destroyed) return;
+        destroyed = true;
+        if (notifyTimer !== null) clearTimeout(notifyTimer);
+        notifyTimer = null;
+        observer.disconnect();
+        for (const frame of hookedFrames) frame.removeEventListener('load', handleFrameLoad);
+        hookedFrames.clear();
+        window.removeEventListener('pagehide', handlePageHide);
+        window.removeEventListener('pageshow', handlePageShow);
+        window.removeEventListener('resize', handleResize);
+        for (const type of MEDIA_STATE_EVENTS) {
+            document.removeEventListener(type, handleMediaState, true);
+        }
+        try { chrome.runtime.onMessage.removeListener(handleMessage); } catch { /* invalidated */ }
+        if (window.__koalaMediaFrameMonitorCleanup === cleanup) {
+            delete window.__koalaMediaFrameMonitorCleanup;
+        }
+    }
+
+    observer.observe(document.documentElement, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ['class', 'style', 'hidden', 'src', 'controls']
+    });
+    hookFrames();
+    lastCandidateSignature = candidateSignature();
+    window.addEventListener('pagehide', handlePageHide);
+    window.addEventListener('pageshow', handlePageShow);
+    window.addEventListener('resize', handleResize, { passive: true });
+    const MEDIA_STATE_EVENTS = ['play', 'pause', 'loadedmetadata', 'loadeddata', 'canplay', 'durationchange', 'emptied'];
+    for (const type of MEDIA_STATE_EVENTS) {
+        document.addEventListener(type, handleMediaState, true);
+    }
+    chrome.runtime.onMessage.addListener(handleMessage);
+    window.__koalaMediaFrameMonitorCleanup = cleanup;
+})();
diff --git a/extension/media-frame-target.js b/extension/media-frame-target.js
new file mode 100644
index 0000000..a4a92c7
--- /dev/null
+++ b/extension/media-frame-target.js
@@ -0,0 +1,536 @@
+export const MEDIA_FRAME_ACCESS_REQUIRED = 'media_frame_access_required';
+export const MEDIA_FRAME_AMBIGUOUS = 'media_frame_ambiguous';
+
+const MIN_PLAYER_FRAME_AREA = 320 * 180;
+const MIN_PLAYER_ASPECT_RATIO = 1.15;
+const MAX_PLAYER_ASPECT_RATIO = 2.6;
+
+function normalizeFrameId(value) {
+    return Number.isInteger(value) && value >= 0 ? value : 0;
+}
+
+function safeOrigin(value) {
+    try {
+        const url = new URL(value);
+        return (url.protocol === 'http:' || url.protocol === 'https:') ? url.origin : null;
+    } catch {
+        return null;
+    }
+}
+
+function originPattern(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') return null;
+        // WebExtension match patterns intentionally omit ports. Chromium treats
+        // the host pattern port-independently; Firefox rejects explicit ports.
+        return `${url.protocol}//${url.hostname}/*`;
+    } catch {
+        return null;
+    }
+}
+
+function isGoogleDrivePlayerUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.hostname.toLowerCase() !== 'youtube.googleapis.com'
+            || (url.pathname !== '/embed' && !url.pathname.startsWith('/embed/'))) {
+            return false;
+        }
+        const parentOrigin = url.searchParams.get('origin') || url.searchParams.get('post_message_origin');
+        return parentOrigin === 'https://drive.google.com';
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Runs inside every frame through chrome.scripting.executeScript. Keep this
+ * function self-contained: extension functions outside its body are not
+ * available in the injected isolated world.
+ */
+export function inspectMediaFrame(expectedVisibilityToken = null) {
+    const elementIsVisible = (element, rect) => {
+        if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+        const view = element.ownerDocument?.defaultView || window;
+        const style = view.getComputedStyle(element);
+        if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity) === 0) {
+            return false;
+        }
+        if (typeof element.checkVisibility === 'function'
+            && !element.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true })) {
+            return false;
+        }
+        return rect.bottom > 0
+            && rect.right > 0
+            && rect.top < view.innerHeight
+            && rect.left < view.innerWidth;
+    };
+
+    const collectVideos = (doc, depth = 0, ancestorVisible = true, videos = [], seen = new Set()) => {
+        if (depth >= 4 || typeof doc.querySelectorAll !== 'function') return videos;
+        for (const video of doc.querySelectorAll('video')) {
+            if (!seen.has(video)) {
+                seen.add(video);
+                videos.push({ video, ancestorVisible });
+            }
+        }
+        const hosts = doc.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 host of hosts) {
+            if (!host.shadowRoot) continue;
+            for (const video of host.shadowRoot.querySelectorAll('video')) {
+                if (!seen.has(video)) {
+                    seen.add(video);
+                    videos.push({ video, ancestorVisible });
+                }
+            }
+        }
+
+        for (const frame of doc.querySelectorAll('iframe, frame')) {
+            try {
+                const frameRect = frame.getBoundingClientRect();
+                const frameVisible = ancestorVisible && elementIsVisible(frame, frameRect);
+                const frameDoc = frame.contentDocument;
+                if (frameDoc) collectVideos(frameDoc, depth + 1, frameVisible, videos, seen);
+            } catch {
+                // Cross-origin media is inspected in its own execution result.
+            }
+        }
+        return videos;
+    };
+
+    const videoDetails = collectVideos(document).map(({ video, ancestorVisible }) => {
+        const rect = video.getBoundingClientRect();
+        const rendered = ancestorVisible && elementIsVisible(video, rect);
+        const hasSource = !!(video.currentSrc || video.src || video.srcObject
+            || video.querySelector?.('source[src]'));
+        const background = !!video.loop && !!video.muted && !video.controls;
+        const duration = Number.isFinite(video.duration) && video.duration > 0 ? video.duration : 0;
+        const shortUncontrolled = !video.controls && duration > 0 && duration < 300;
+        const renderedArea = Math.max(0, rect.width) * Math.max(0, rect.height);
+        return {
+            hasSource,
+            rendered,
+            background,
+            shortUncontrolled,
+            sizeBucket: Math.round(Math.sqrt(renderedArea) / 40),
+            playing: video.paused === false && video.ended !== true,
+            controls: !!video.controls,
+            readyState: Number.isInteger(video.readyState) ? video.readyState : 0,
+            duration,
+            renderedArea
+        };
+    });
+
+    const compareVideo = (left, right) => {
+        const leftRank = [
+            left.hasSource ? 1 : 0,
+            left.rendered ? 1 : 0,
+            left.background ? 0 : 1,
+            left.shortUncontrolled ? 0 : 1,
+            left.playing ? 1 : 0,
+            left.controls ? 1 : 0,
+            left.readyState,
+            left.duration,
+            left.sizeBucket
+        ];
+        const rightRank = [
+            right.hasSource ? 1 : 0,
+            right.rendered ? 1 : 0,
+            right.background ? 0 : 1,
+            right.shortUncontrolled ? 0 : 1,
+            right.playing ? 1 : 0,
+            right.controls ? 1 : 0,
+            right.readyState,
+            right.duration,
+            right.sizeBucket
+        ];
+        for (let index = 0; index < leftRank.length; index++) {
+            if (leftRank[index] !== rightRank[index]) return rightRank[index] - leftRank[index];
+        }
+        return 0;
+    };
+    videoDetails.sort(compareVideo);
+
+    // Recursively list direct and same-origin-descendant frame elements. This
+    // lets the background identify a large inaccessible player origin even if
+    // an all-frame probe is rejected by the browser's site-access policy.
+    const embeddedFrames = [];
+    const collectEmbeddedFrames = (doc, depth = 0, ancestorVisible = true) => {
+        if (depth >= 4 || typeof doc.querySelectorAll !== 'function') return;
+        for (const frame of doc.querySelectorAll('iframe, frame')) {
+            const rect = frame.getBoundingClientRect();
+            const directVisible = elementIsVisible(frame, rect);
+            const visible = ancestorVisible && directVisible;
+            let href = '';
+            try { href = new URL(frame.src || '', doc.location.href).href; } catch { href = ''; }
+            embeddedFrames.push({
+                href,
+                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),
+                height: Math.max(0, rect.height),
+                visible,
+                depth: depth + 1,
+                mediaHint: frame.allowFullscreen === true
+                    || frame.hasAttribute?.('allowfullscreen')
+                    || /autoplay|fullscreen|picture-in-picture|encrypted-media/i.test(frame.getAttribute('allow') || '')
+                    || /player|video|stream|watch|embed|media|xfp/i.test([
+                        frame.id,
+                        frame.name,
+                        frame.className,
+                        frame.title,
+                        href
+                    ].join(' '))
+            });
+            try {
+                const frameDoc = frame.contentDocument;
+                if (frameDoc) collectEmbeddedFrames(frameDoc, depth + 1, visible);
+            } catch {
+                // Cross-origin descendants are represented by their frame URL.
+            }
+        }
+    };
+    collectEmbeddedFrames(document);
+
+    const storedParentVisibility = window.__koalaParentFrameVisibility;
+    const parentVisibility = expectedVisibilityToken
+        && storedParentVisibility?.token === expectedVisibilityToken
+        ? storedParentVisibility
+        : null;
+    return {
+        href: window.location.href,
+        origin: window.location.origin,
+        isTop: window.top === window,
+        videoCount: videoDetails.length,
+        bestVideo: videoDetails[0] || null,
+        frameArea: Math.max(0, window.innerWidth) * Math.max(0, window.innerHeight),
+        parentFrameVisible: window.top === window
+            ? true
+            : parentVisibility?.visible ?? null,
+        parentFrameArea: window.top === window
+            ? Math.max(0, window.innerWidth) * Math.max(0, window.innerHeight)
+            : (Number.isFinite(parentVisibility?.area) ? parentVisibility.area : null),
+        embeddedFrames
+    };
+}
+
+/** Runs inside every frame before the visibility dispatch. */
+export function installParentFrameVisibilityProbe(token) {
+    try { window.__koalaFrameVisibilityCleanup?.(); } catch { /* stale probe */ }
+    window.__koalaParentFrameVisibility = { token, visible: null, area: null };
+    let timeout = null;
+    const cleanup = () => {
+        window.removeEventListener('message', handler);
+        if (timeout !== null) clearTimeout(timeout);
+        if (window.__koalaFrameVisibilityCleanup === cleanup) {
+            delete window.__koalaFrameVisibilityCleanup;
+        }
+    };
+    const handler = (event) => {
+        if (event.source !== window.parent
+            || event.data?.type !== 'KOALASYNC_FRAME_VISIBILITY'
+            || event.data?.token !== token) {
+            return;
+        }
+        window.__koalaParentFrameVisibility = {
+            token,
+            visible: event.data.visible === true,
+            area: Number.isFinite(event.data.area) ? event.data.area : 0
+        };
+    };
+    window.addEventListener('message', handler);
+    timeout = setTimeout(cleanup, 1000);
+    window.__koalaFrameVisibilityCleanup = cleanup;
+}
+
+/** Runs inside every frame; each parent reports geometry to its direct children. */
+export function dispatchParentFrameVisibilityProbe(token) {
+    const ancestor = window.top === window ? { visible: true, area: Infinity } : window.__koalaParentFrameVisibility;
+    for (const frame of document.querySelectorAll('iframe, frame')) {
+        try {
+            const rect = frame.getBoundingClientRect();
+            const style = window.getComputedStyle(frame);
+            const area = Math.max(0, rect.width) * Math.max(0, rect.height);
+            const intersectsViewport = rect.bottom > 0
+                && rect.right > 0
+                && rect.top < window.innerHeight
+                && rect.left < window.innerWidth;
+            const browserReportsVisible = typeof frame.checkVisibility === 'function'
+                ? frame.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true })
+                : true;
+            const directlyVisible = area > 0
+                && intersectsViewport
+                && browserReportsVisible
+                && style.display !== 'none'
+                && style.visibility !== 'hidden'
+                && Number(style.opacity) !== 0;
+            const visible = directlyVisible && ancestor?.visible !== false;
+            const inheritedArea = Number.isFinite(ancestor?.area) ? ancestor.area : area;
+            const effectiveArea = Math.min(area, inheritedArea);
+            frame.contentWindow?.postMessage({
+                type: 'KOALASYNC_FRAME_VISIBILITY',
+                token,
+                visible,
+                area: effectiveArea
+            }, '*');
+        } catch {
+            // A detached or browser-owned frame is not a candidate.
+        }
+    }
+}
+
+function mediaCandidateRank(entry) {
+    const result = entry.result;
+    const video = result.bestVideo;
+    const visibility = result.parentFrameVisible === true
+        ? 2
+        : result.parentFrameVisible === false
+            ? 0
+            : 1;
+    return [
+        visibility,
+        video.hasSource ? 1 : 0,
+        video.rendered ? 1 : 0,
+        video.background ? 0 : 1,
+        video.shortUncontrolled ? 0 : 1,
+        video.playing ? 1 : 0,
+        video.controls ? 1 : 0,
+        video.readyState,
+        video.duration,
+        video.sizeBucket,
+        result.isTop ? 1 : 0,
+        Number.isFinite(result.parentFrameArea) ? result.parentFrameArea : result.frameArea
+    ];
+}
+
+function compareRanks(left, right) {
+    const leftRank = mediaCandidateRank(left);
+    const rightRank = mediaCandidateRank(right);
+    for (let index = 0; index < leftRank.length; index++) {
+        if (leftRank[index] !== rightRank[index]) return rightRank[index] - leftRank[index];
+    }
+    return 0;
+}
+
+function sameMeaningfulRank(left, right) {
+    const leftRank = mediaCandidateRank(left);
+    const rightRank = mediaCandidateRank(right);
+    // Ignore duration, size, top-frame preference, and raw frame area. Two
+    // otherwise identical frames are unsafe to distinguish by preload metadata.
+    return leftRank.slice(0, 8).every((value, index) => value === rightRank[index]);
+}
+
+export function selectMediaFrame(injectionResults) {
+    const candidates = (Array.isArray(injectionResults) ? injectionResults : [])
+        .filter(entry => Number.isInteger(entry?.frameId)
+            && entry?.result?.bestVideo?.rendered === true)
+        .filter(entry => entry.result.parentFrameVisible !== false)
+        .sort(compareRanks);
+    if (candidates.length === 0) return null;
+    if (candidates.length > 1
+        && candidates[0].result.parentFrameVisible !== true
+        && candidates[1].result.parentFrameVisible !== true
+        && sameMeaningfulRank(candidates[0], candidates[1])) {
+        return null;
+    }
+    return candidates[0];
+}
+
+function findMissingPlayerAccess(results) {
+    const accessibleOrigins = new Set();
+    for (const entry of results) {
+        const origin = safeOrigin(entry?.result?.href);
+        if (origin) accessibleOrigins.add(origin);
+    }
+
+    const missingByOrigin = new Map();
+    for (const entry of results) {
+        for (const frame of entry?.result?.embeddedFrames || []) {
+            if (!frame.visible || accessibleOrigins.has(frame.origin) || !frame.origin) continue;
+            const aspectRatio = frame.height > 0 ? frame.width / frame.height : 0;
+            const drivePlayer = isGoogleDrivePlayerUrl(frame.href);
+            const looksLikePlayer = frame.mediaHint === true
+                && frame.area >= MIN_PLAYER_FRAME_AREA
+                && aspectRatio >= MIN_PLAYER_ASPECT_RATIO
+                && aspectRatio <= MAX_PLAYER_ASPECT_RATIO;
+            if (!drivePlayer && !looksLikePlayer) continue;
+            const previous = missingByOrigin.get(frame.origin);
+            if (!previous || frame.area > previous.area || drivePlayer) {
+                missingByOrigin.set(frame.origin, { ...frame, drivePlayer });
+            }
+        }
+    }
+
+    const missing = Array.from(missingByOrigin.values()).sort((left, right) => {
+        if (left.drivePlayer !== right.drivePlayer) return left.drivePlayer ? -1 : 1;
+        return right.area - left.area;
+    });
+    if (missing.length === 0) return null;
+    if (!missing[0].drivePlayer && missing.length > 1 && missing[0].area < missing[1].area * 1.5) {
+        return null;
+    }
+    return {
+        host: new URL(missing[0].origin).hostname,
+        originPattern: originPattern(missing[0].origin),
+        area: missing[0].area,
+        drivePlayer: missing[0].drivePlayer === true
+    };
+}
+
+function shouldPreferMissingAccess(access, selected) {
+    if (!access) return false;
+    if (access.drivePlayer || !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;
+    return weakAccessibleCandidate
+        && access.area >= Math.max(MIN_PLAYER_FRAME_AREA, selectedArea * 1.5);
+}
+
+function accessRequiredError(access) {
+    const error = new Error(`Embedded player access is required for ${access.host}`);
+    error.code = MEDIA_FRAME_ACCESS_REQUIRED;
+    error.host = access.host;
+    error.originPattern = access.originPattern;
+    return error;
+}
+
+function ambiguousFrameError() {
+    const error = new Error('The active embedded video frame could not be identified safely');
+    error.code = MEDIA_FRAME_AMBIGUOUS;
+    return error;
+}
+
+function contentTarget(tabId, selected) {
+    const frameId = normalizeFrameId(selected?.frameId);
+    const documentId = typeof selected?.documentId === 'string' ? selected.documentId : null;
+    return {
+        frameId,
+        documentId,
+        frameUrl: typeof selected?.result?.href === 'string' ? selected.result.href : null,
+        hasVideo: !!selected?.result?.bestVideo,
+        scriptTarget: documentId
+            ? { tabId, documentIds: [documentId] }
+            : (frameId === 0 ? { tabId } : { tabId, frameIds: [frameId] })
+    };
+}
+
+export async function listMediaFrameScriptTargets(chromeApi, tabId) {
+    if (chromeApi.webNavigation?.getAllFrames) {
+        try {
+            const frames = await chromeApi.webNavigation.getAllFrames({ tabId });
+            if (Array.isArray(frames) && frames.length > 0) {
+                return frames
+                    .filter(frame => Number.isInteger(frame?.frameId))
+                    .map(frame => (typeof frame.documentId === 'string' && frame.documentId
+                        ? { tabId, documentIds: [frame.documentId] }
+                        : { tabId, frameIds: [frame.frameId] }));
+            }
+        } catch {
+            // Older browsers fall back to the all-frames probe below.
+        }
+    }
+    return [{ tabId, allFrames: true }];
+}
+
+async function executeInAccessibleFrames(chromeApi, targets, func, args) {
+    const settled = await Promise.all(targets.map(async target => {
+        try {
+            return await chromeApi.scripting.executeScript({ target, func, args });
+        } catch {
+            return [];
+        }
+    }));
+    return settled.flat();
+}
+
+export async function resolveMediaContentTarget(chromeApi, tabId, {
+    attempts = 8,
+    retryDelayMs = 200,
+    probeDelayMs = 60
+} = {}) {
+    let fallback = null;
+    let missingAccess = null;
+    let ambiguous = false;
+
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        const scriptTargets = await listMediaFrameScriptTargets(chromeApi, tabId);
+        let results = await executeInAccessibleFrames(
+            chromeApi,
+            scriptTargets,
+            inspectMediaFrame,
+            [null]
+        );
+        if (results.length === 0) {
+            try {
+                results = await chromeApi.scripting.executeScript({
+                    target: { tabId },
+                    func: inspectMediaFrame,
+                    args: [null]
+                });
+            } catch {
+                return contentTarget(tabId, null);
+            }
+        }
+
+        if (results.length > 1) {
+            const token = `${tabId}:${attempt}:${Date.now()}:${Math.random()}`;
+            try {
+                await executeInAccessibleFrames(
+                    chromeApi,
+                    scriptTargets,
+                    installParentFrameVisibilityProbe,
+                    [token]
+                );
+                // Four passes match the maximum same-origin recursion depth.
+                for (let pass = 0; pass < 4; pass++) {
+                    await executeInAccessibleFrames(
+                        chromeApi,
+                        scriptTargets,
+                        dispatchParentFrameVisibilityProbe,
+                        [token]
+                    );
+                    await new Promise(resolve => setTimeout(resolve, probeDelayMs));
+                }
+                const inspected = await executeInAccessibleFrames(
+                    chromeApi,
+                    scriptTargets,
+                    inspectMediaFrame,
+                    [token]
+                );
+                if (inspected.length > 0) results = inspected;
+            } catch {
+                // Initial results remain usable, but equally-ranked unknown
+                // frames will be rejected below rather than guessed.
+            }
+        }
+
+        const selected = selectMediaFrame(results);
+        const videoCandidates = results.filter(entry => entry?.result?.bestVideo?.rendered === true
+            && entry.result.parentFrameVisible !== false);
+        const currentMissingAccess = findMissingPlayerAccess(results);
+        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);
+            }
+        }
+
+        if (attempt < attempts - 1) {
+            await new Promise(resolve => setTimeout(resolve, retryDelayMs));
+        }
+    }
+
+    if (missingAccess) throw accessRequiredError(missingAccess);
+    if (fallback) return contentTarget(tabId, fallback);
+    if (ambiguous) throw ambiguousFrameError();
+    return contentTarget(tabId, null);
+}
diff --git a/extension/media-frame-target.test.mjs b/extension/media-frame-target.test.mjs
new file mode 100644
index 0000000..bcaee18
--- /dev/null
+++ b/extension/media-frame-target.test.mjs
@@ -0,0 +1,483 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+    MEDIA_FRAME_ACCESS_REQUIRED,
+    MEDIA_FRAME_AMBIGUOUS,
+    inspectMediaFrame,
+    resolveMediaContentTarget,
+    selectMediaFrame
+} from './media-frame-target.js';
+
+function video(overrides = {}) {
+    const candidate = {
+        hasSource: true,
+        rendered: true,
+        background: false,
+        shortUncontrolled: false,
+        sizeBucket: 18,
+        playing: false,
+        controls: true,
+        readyState: 4,
+        duration: 1200,
+        renderedArea: 830 * 498,
+        ...overrides
+    };
+    candidate.shortUncontrolled = overrides.shortUncontrolled ?? (
+        !candidate.controls && candidate.duration > 0 && candidate.duration < 300
+    );
+    return candidate;
+}
+
+function frame(frameId, overrides = {}) {
+    return {
+        frameId,
+        documentId: `document-${frameId}`,
+        result: {
+            href: `https://player-${frameId}.example/embed`,
+            origin: `https://player-${frameId}.example`,
+            isTop: frameId === 0,
+            videoCount: 1,
+            bestVideo: video(),
+            frameArea: 830 * 498,
+            parentFrameVisible: true,
+            parentFrameArea: 830 * 498,
+            embeddedFrames: [],
+            ...overrides
+        }
+    };
+}
+
+describe('cross-origin media-frame targeting', () => {
+    it('selects a visible cross-origin player over a hidden loaded copy', () => {
+        const selected = selectMediaFrame([
+            frame(4),
+            frame(5, { parentFrameVisible: false, bestVideo: video({ playing: true }) })
+        ]);
+        expect(selected.frameId).toBe(4);
+    });
+
+    it('does not select a video hidden inside a same-origin descendant', () => {
+        expect(selectMediaFrame([
+            frame(0, { bestVideo: video({ rendered: false }) }),
+            frame(6, {
+                parentFrameVisible: false,
+                bestVideo: video({ rendered: true, playing: true })
+            })
+        ])).toBeNull();
+    });
+
+    it('keeps a real player ahead of a larger muted looping background video', () => {
+        const selected = selectMediaFrame([
+            frame(2, { bestVideo: video({ sizeBucket: 24, background: true, controls: false }) }),
+            frame(7, { bestVideo: video({ sizeBucket: 18 }) })
+        ]);
+        expect(selected.frameId).toBe(7);
+    });
+
+    it('keeps an active long player ahead of a larger ordinary ad video', () => {
+        const selected = selectMediaFrame([
+            frame(2, { bestVideo: video({ sizeBucket: 24, duration: 30, playing: false, controls: false }) }),
+            frame(7, { bestVideo: video({ sizeBucket: 18, duration: 1200, playing: true, controls: true }) })
+        ]);
+        expect(selected.frameId).toBe(7);
+    });
+
+    it('keeps a paused long player ahead of a playing short uncontrolled ad', () => {
+        const selected = selectMediaFrame([
+            frame(2, { bestVideo: video({
+                sizeBucket: 24,
+                duration: 30,
+                playing: true,
+                controls: false,
+                shortUncontrolled: true
+            }) }),
+            frame(7, { bestVideo: video({
+                sizeBucket: 18,
+                duration: 1200,
+                playing: false,
+                controls: true
+            }) })
+        ]);
+        expect(selected.frameId).toBe(7);
+    });
+
+    it('keeps same-origin reachable media under the top-frame controller', () => {
+        const sharedVideo = video();
+        const selected = selectMediaFrame([
+            frame(0, { bestVideo: sharedVideo, videoCount: 1 }),
+            frame(6, { bestVideo: sharedVideo, videoCount: 1 })
+        ]);
+        expect(selected.frameId).toBe(0);
+    });
+
+    it('refuses to guess between equally-ranked frames without visibility evidence', () => {
+        expect(selectMediaFrame([
+            frame(3, { parentFrameVisible: null }),
+            frame(4, { parentFrameVisible: null })
+        ])).toBeNull();
+    });
+
+    it('returns the exact selected frame and document after probing', async () => {
+        const results = [frame(0, { bestVideo: null, videoCount: 0 }), frame(8)];
+        const executeScript = vi.fn().mockResolvedValue(results);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            42,
+            { attempts: 1, probeDelayMs: 0 }
+        )).resolves.toEqual({
+            frameId: 8,
+            documentId: 'document-8',
+            frameUrl: 'https://player-8.example/embed',
+            hasVideo: true,
+            scriptTarget: { tabId: 42, documentIds: ['document-8'] }
+        });
+        const visibilityDispatches = executeScript.mock.calls.filter(([options]) => (
+            options.func?.name === 'dispatchParentFrameVisibilityProbe'
+        ));
+        expect(visibilityDispatches).toHaveLength(4);
+    });
+
+    it('keeps the top target inactive when the only discovered video is hidden', async () => {
+        const results = [
+            frame(0, { bestVideo: video({ rendered: false }) }),
+            frame(6, { parentFrameVisible: false })
+        ];
+        const executeScript = vi.fn().mockResolvedValue(results);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            42,
+            { attempts: 1, probeDelayMs: 0 }
+        )).resolves.toEqual({
+            frameId: 0,
+            documentId: null,
+            frameUrl: null,
+            hasVideo: false,
+            scriptTarget: { tabId: 42 }
+        });
+    });
+
+    it('keeps an accessible player when an unrelated child frame is denied', async () => {
+        const top = frame(0, {
+            bestVideo: null,
+            videoCount: 0,
+            embeddedFrames: [
+                {
+                    href: 'https://player-8.example/embed',
+                    origin: 'https://player-8.example',
+                    area: 830 * 498,
+                    width: 830,
+                    height: 498,
+                    visible: true,
+                    mediaHint: true
+                },
+                {
+                    href: 'https://widget-denied.example/frame',
+                    origin: 'https://widget-denied.example',
+                    area: 300 * 250,
+                    width: 300,
+                    height: 250,
+                    visible: true,
+                    mediaHint: false
+                }
+            ]
+        });
+        const player = frame(8);
+        const getAllFrames = vi.fn().mockResolvedValue([
+            { frameId: 0, documentId: 'document-0' },
+            { frameId: 8, documentId: 'document-8' },
+            { frameId: 9, documentId: 'document-9' }
+        ]);
+        const executeScript = vi.fn().mockImplementation(async ({ target, func }) => {
+            const documentId = target.documentIds?.[0];
+            if (documentId === 'document-9') throw new Error('Cannot access contents of the page');
+            if (func?.name !== 'inspectMediaFrame') return [];
+            return documentId === 'document-8' ? [player] : [top];
+        });
+
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript }, webNavigation: { getAllFrames } },
+            42,
+            { attempts: 1, probeDelayMs: 0 }
+        )).resolves.toMatchObject({
+            frameId: 8,
+            documentId: 'document-8',
+            hasVideo: true
+        });
+        expect(executeScript.mock.calls.some(([options]) => options.target.allFrames === true)).toBe(false);
+        expect(executeScript.mock.calls.some(([options]) => options.target.documentIds?.[0] === 'document-9')).toBe(true);
+    });
+
+    it('does not trust parent visibility from an older probe token', () => {
+        const originalWindow = globalThis.window;
+        const originalDocument = globalThis.document;
+        const fakeWindow = {
+            top: {},
+            location: { href: 'https://player.example/embed', origin: 'https://player.example' },
+            innerWidth: 800,
+            innerHeight: 450,
+            __koalaParentFrameVisibility: { token: 'old-token', visible: true, area: 360000 }
+        };
+        const fakeDocument = {
+            location: fakeWindow.location,
+            defaultView: fakeWindow,
+            querySelectorAll: () => []
+        };
+        globalThis.window = fakeWindow;
+        globalThis.document = fakeDocument;
+        try {
+            expect(inspectMediaFrame('new-token')).toMatchObject({
+                parentFrameVisible: null,
+                parentFrameArea: null
+            });
+        } finally {
+            if (originalWindow === undefined) delete globalThis.window;
+            else globalThis.window = originalWindow;
+            if (originalDocument === undefined) delete globalThis.document;
+            else globalThis.document = originalDocument;
+        }
+    });
+
+    it('recognizes the current Google Drive youtube.googleapis.com player', async () => {
+        const top = frame(0, {
+            href: 'https://drive.google.com/drive/u/0/search?q=video',
+            origin: 'https://drive.google.com',
+            bestVideo: null,
+            videoCount: 0,
+            embeddedFrames: [{
+                href: 'https://youtube.googleapis.com/embed/drive-file-id?origin=https%3A%2F%2Fdrive.google.com',
+                origin: 'https://youtube.googleapis.com',
+                area: 280 * 157,
+                width: 280,
+                height: 157,
+                visible: true,
+                depth: 1,
+                mediaHint: false
+            }]
+        });
+        const executeScript = vi.fn()
+            .mockResolvedValueOnce([top])
+            .mockResolvedValueOnce([top]);
+
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            42,
+            { attempts: 1, probeDelayMs: 0 }
+        )).rejects.toMatchObject({
+            code: MEDIA_FRAME_ACCESS_REQUIRED,
+            host: 'youtube.googleapis.com',
+            originPattern: 'https://youtube.googleapis.com/*'
+        });
+    });
+
+    it('recognizes a YummyAnime-style nested inaccessible player origin', async () => {
+        const top = frame(0, {
+            href: 'https://yummyanime.tv/show.html',
+            origin: 'https://yummyanime.tv',
+            bestVideo: null,
+            videoCount: 0,
+            embeddedFrames: [{
+                href: 'https://absciss.thealloha.club/?token=redacted',
+                origin: 'https://absciss.thealloha.club',
+                area: 830 * 498,
+                width: 830,
+                height: 498,
+                visible: true,
+                depth: 2,
+                mediaHint: true
+            }]
+        });
+        const executeScript = vi.fn()
+            .mockResolvedValueOnce([top])
+            .mockResolvedValueOnce([top]);
+
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            43,
+            { attempts: 1, probeDelayMs: 0 }
+        )).rejects.toMatchObject({
+            code: MEDIA_FRAME_ACCESS_REQUIRED,
+            host: 'absciss.thealloha.club',
+            originPattern: 'https://absciss.thealloha.club/*'
+        });
+    });
+
+    it('requests the inaccessible player instead of selecting an accessible background video', async () => {
+        const top = frame(0, {
+            bestVideo: video({ background: true, controls: false, renderedArea: 900 * 506 }),
+            embeddedFrames: [{
+                href: 'https://player.external.example/watch',
+                origin: 'https://player.external.example',
+                area: 900 * 506,
+                width: 900,
+                height: 506,
+                visible: true,
+                mediaHint: true
+            }]
+        });
+        const executeScript = vi.fn().mockResolvedValue([top]);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            44,
+            { attempts: 1, probeDelayMs: 0 }
+        )).rejects.toMatchObject({
+            code: MEDIA_FRAME_ACCESS_REQUIRED,
+            originPattern: 'https://player.external.example/*'
+        });
+    });
+
+    it('requests the inaccessible main player instead of selecting a larger short ad', async () => {
+        const top = frame(0, {
+            bestVideo: video({
+                playing: true,
+                controls: false,
+                duration: 30,
+                renderedArea: 500 * 281,
+                sizeBucket: 24
+            }),
+            embeddedFrames: [{
+                href: 'https://player.external.example/watch',
+                origin: 'https://player.external.example',
+                area: 900 * 506,
+                width: 900,
+                height: 506,
+                visible: true,
+                mediaHint: true
+            }]
+        });
+        const executeScript = vi.fn().mockResolvedValue([top]);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            44,
+            { attempts: 1, probeDelayMs: 0 }
+        )).rejects.toMatchObject({
+            code: MEDIA_FRAME_ACCESS_REQUIRED,
+            originPattern: 'https://player.external.example/*'
+        });
+    });
+
+    it('keeps a paused long custom player over a larger inaccessible heuristic frame', async () => {
+        const top = frame(0, {
+            bestVideo: video({
+                playing: false,
+                controls: false,
+                duration: 7200,
+                renderedArea: 600 * 338
+            }),
+            embeddedFrames: [{
+                href: 'https://widget.external.example/watch',
+                origin: 'https://widget.external.example',
+                area: 900 * 506,
+                width: 900,
+                height: 506,
+                visible: true,
+                mediaHint: true
+            }]
+        });
+        const executeScript = vi.fn().mockResolvedValue([top]);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            44,
+            { attempts: 1, probeDelayMs: 0 }
+        )).resolves.toMatchObject({ frameId: 0, hasVideo: true });
+    });
+
+    it('uses Firefox-compatible portless match patterns for embedded origins', async () => {
+        const top = frame(0, {
+            bestVideo: null,
+            videoCount: 0,
+            embeddedFrames: [{
+                href: 'http://127.0.0.1:4173/player',
+                origin: 'http://127.0.0.1:4173',
+                area: 900 * 506,
+                width: 900,
+                height: 506,
+                visible: true,
+                mediaHint: true
+            }]
+        });
+        const executeScript = vi.fn().mockResolvedValue([top]);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            45,
+            { attempts: 1, probeDelayMs: 0 }
+        )).rejects.toMatchObject({ originPattern: 'http://127.0.0.1/*' });
+    });
+
+    it('does not request access for one large non-media iframe', async () => {
+        const top = frame(0, {
+            bestVideo: null,
+            videoCount: 0,
+            embeddedFrames: [{
+                href: 'https://maps.example/view',
+                origin: 'https://maps.example',
+                area: 900 * 506,
+                width: 900,
+                height: 506,
+                visible: true,
+                mediaHint: false
+            }]
+        });
+        const executeScript = vi.fn().mockResolvedValue([top]);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            46,
+            { attempts: 1, probeDelayMs: 0 }
+        )).resolves.toMatchObject({ frameId: 0, hasVideo: false });
+    });
+
+    it('does not retain a permission prompt for a player frame that disappeared', async () => {
+        const withPlayer = frame(0, {
+            bestVideo: null,
+            videoCount: 0,
+            embeddedFrames: [{
+                href: 'https://player.external.example/watch',
+                origin: 'https://player.external.example',
+                area: 900 * 506,
+                width: 900,
+                height: 506,
+                visible: true,
+                mediaHint: true
+            }]
+        });
+        const withoutPlayer = frame(0, { bestVideo: null, videoCount: 0, embeddedFrames: [] });
+        const executeScript = vi.fn()
+            .mockResolvedValueOnce([withPlayer])
+            .mockResolvedValueOnce([withoutPlayer]);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            46,
+            { attempts: 2, retryDelayMs: 0, probeDelayMs: 0 }
+        )).resolves.toMatchObject({ frameId: 0, hasVideo: false });
+    });
+
+    it('does not request access for small or ambiguously-sized embedded frames', async () => {
+        const top = frame(0, {
+            bestVideo: null,
+            videoCount: 0,
+            embeddedFrames: [
+                { href: 'https://ad-one.example', origin: 'https://ad-one.example', area: 300 * 250, width: 300, height: 250, visible: true },
+                { href: 'https://ad-two.example', origin: 'https://ad-two.example', area: 300 * 250, width: 300, height: 250, visible: true }
+            ]
+        });
+        const executeScript = vi.fn()
+            .mockResolvedValueOnce([top])
+            .mockResolvedValueOnce([top]);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            44,
+            { attempts: 1, probeDelayMs: 0 }
+        )).resolves.toMatchObject({ frameId: 0, scriptTarget: { tabId: 44 } });
+    });
+
+    it('reports ambiguity rather than controlling an arbitrary equal player', async () => {
+        const results = [
+            frame(3, { parentFrameVisible: null }),
+            frame(4, { parentFrameVisible: null })
+        ];
+        const executeScript = vi.fn().mockResolvedValue(results);
+        await expect(resolveMediaContentTarget(
+            { scripting: { executeScript } },
+            45,
+            { attempts: 1, probeDelayMs: 0 }
+        )).rejects.toMatchObject({ code: MEDIA_FRAME_AMBIGUOUS });
+    });
+});
diff --git a/extension/modules/tab-manager.js b/extension/modules/tab-manager.js
index 18cde2f..e6d7e93 100644
--- a/extension/modules/tab-manager.js
+++ b/extension/modules/tab-manager.js
@@ -1,7 +1,8 @@
 export function initTabManager({
     getCurrentTabId,
     reactivateCurrentTarget,
-    ensureState
+    ensureState,
+    sendToCurrentContent
 }) {
     chrome.storage.onChanged.addListener(async (changes, area) => {
         if (area !== 'local' || !changes.audioSettings) return;
@@ -9,7 +10,7 @@ export function initTabManager({
         const tabId = getCurrentTabId();
         if (!tabId) return;
 
-        chrome.tabs.sendMessage(tabId, {
+        sendToCurrentContent({
             action: 'APPLY_AUDIO_SETTINGS',
             settings: changes.audioSettings.newValue
         }).catch(() => {});
diff --git a/extension/popup.js b/extension/popup.js
index b464beb..df1076e 100644
--- a/extension/popup.js
+++ b/extension/popup.js
@@ -2196,7 +2196,7 @@ elements.forceSyncBtn.addEventListener('click', async () => {
                 failForceSyncTime();
                 return;
             }
-            chrome.tabs.sendMessage(tabId, { action: 'get_current_time' }, (retryResponse) => {
+            chrome.runtime.sendMessage({ type: 'GET_VIDEO_STATE', tabId }, (retryResponse) => {
                 if (chrome.runtime.lastError || !retryResponse || !Number.isFinite(retryResponse.currentTime)) {
                     failForceSyncTime();
                     return;
@@ -2204,7 +2204,7 @@ elements.forceSyncBtn.addEventListener('click', async () => {
                 sendForceSync(retryResponse.currentTime);
             });
         };
-        chrome.tabs.sendMessage(tabId, { action: 'get_current_time' }, (response) => {
+        chrome.runtime.sendMessage({ type: 'GET_VIDEO_STATE', tabId }, (response) => {
             if (Number.isFinite(response?.currentTime)) {
                 sendForceSync(response.currentTime);
                 return;
diff --git a/extension/target-tab-lifecycle.test.mjs b/extension/target-tab-lifecycle.test.mjs
index 5b60dab..291be09 100644
--- a/extension/target-tab-lifecycle.test.mjs
+++ b/extension/target-tab-lifecycle.test.mjs
@@ -7,12 +7,15 @@ const extensionDir = path.dirname(fileURLToPath(import.meta.url));
 const backgroundSource = fs.readFileSync(path.join(extensionDir, 'background.js'), 'utf8');
 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 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("target: { tabId }");
+        expect(backgroundSource).toContain('contentTarget = await resolveMediaContentTarget(chrome, tabId)');
+        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/*' })");
 
@@ -27,20 +30,49 @@ describe('target tab lifecycle', () => {
     });
 
     it('fully deactivates old and superseded target injections', () => {
-        expect(backgroundSource).toContain("chrome.tabs.sendMessage(normalizedTabId, { type: 'TARGET_DEACTIVATE' })");
-        expect(backgroundSource.match(/await deactivateTargetTab\(selectedTabId\)/g)?.length).toBeGreaterThanOrEqual(4);
+        expect(backgroundSource).toContain("{ type: 'TARGET_DEACTIVATE' }");
+        expect(backgroundSource).toContain('target.documentId');
+        expect(backgroundSource.match(/await deactivateTargetTab\(selectedTabId,/g)?.length).toBeGreaterThanOrEqual(6);
         expect(contentSource).toContain("if (message.type === 'TARGET_DEACTIVATE')");
         expect(overlaySource).toContain("message?.type === 'TARGET_DEACTIVATE'");
     });
 
+    it('binds cross-origin targets to an exact document and monitors every accessible frame', () => {
+        expect(backgroundSource).toContain("files: ['media-frame-monitor.js']");
+        expect(backgroundSource).toContain('const targets = await listMediaFrameScriptTargets(chrome, tabId)');
+        expect(backgroundSource).toContain('One denied widget frame must not block the selected player');
+        expect(backgroundSource).toContain("navigationError.code = 'media_target_navigated'");
+        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');
+        expect(monitorSource).toContain("const MEDIA_STATE_EVENTS = ['play', 'pause', 'loadedmetadata'");
+        expect(monitorSource).toContain("node.querySelector?.('video, iframe, frame')");
+        expect(manifest.permissions).toContain('webNavigation');
+        expect(backgroundSource).toContain('chrome.webNavigation.onCompleted.addListener');
+    });
+
+    it('serializes content commands and coalesces target refreshes', () => {
+        expect(backgroundSource).toContain('contentCommandQueue.catch(() => {}).then(deliver)');
+        expect(backgroundSource).toContain('if (mediaTargetRefreshTask && mediaTargetRefreshTabId === selectedTabId)');
+        expect(backgroundSource).toContain('if (queueIfRunning) mediaTargetRefreshDirty = true');
+        expect(backgroundSource).toContain('&& pass < 2');
+        expect(backgroundSource).toContain('const needsFollowup = mediaTargetRefreshDirty');
+        expect(backgroundSource).not.toContain('Re-elect before every remote command');
+        expect(backgroundSource).toContain('await sendMessageToContentTab(tabId');
+    });
+
     it('tears down every persistent content-script resource', () => {
         expect(contentSource).toContain('function destroyContentScript()');
         expect(contentSource).toContain('observer.disconnect()');
         expect(contentSource).toContain('keepAlivePort.disconnect()');
-        expect(contentSource).toContain('for (const video of attachedVideos)');
+        expect(contentSource).toContain('for (const video of [...attachedVideos]) detachVideoListeners(video);');
         expect(contentSource).toContain("document.removeEventListener('visibilitychange', handleVisibilityChange)");
         expect(contentSource).toContain("window.removeEventListener('pagehide', handlePageHide)");
         expect(contentSource).toContain("window.removeEventListener('pageshow', handlePageShow)");
+        expect(contentSource).toContain("window.removeEventListener('resize', handleMediaFrameResize)");
         expect(contentSource).toContain('chrome.storage.onChanged.removeListener(handleStorageChanged)');
         expect(contentSource).toContain('chrome.runtime.onMessage.removeListener(handleRuntimeMessage)');
         expect(contentSource).toContain('window.koalaSyncInjected = false');
diff --git a/scripts/test-content-video-finder.cjs b/scripts/test-content-video-finder.cjs
index 5ac3412..0a42805 100644
--- a/scripts/test-content-video-finder.cjs
+++ b/scripts/test-content-video-finder.cjs
@@ -36,6 +36,10 @@ function makeVideo(name, width, height, options = {}) {
     offsetWidth: width,
     offsetHeight: height,
     muted: options.muted ?? true,
+    controls: options.controls ?? true,
+    paused: options.paused ?? true,
+    ended: options.ended ?? false,
+    currentSrc: options.currentSrc ?? 'fixture.mp4',
     duration: options.duration ?? 0,
     currentTime: options.currentTime ?? 0,
     seekable: options.seekable ?? makeSeekable()
@@ -66,12 +70,16 @@ const fakeDocument = {
 const VIDEO_FINDER_PARTS = [
   'findVideo',
   'collectVideoCandidates',
+  'getElementRenderBox',
+  'elementStylesAllowRendering',
+  'isElementRendered',
   'getRenderedVideoArea',
   'getVideoSizeBucket',
   'isVideoRendered',
   'hasPlayableVideoSource',
   'isBackgroundVideo',
   'isVideoPlaying',
+  'isShortUncontrolledVideo',
   'compareVideoRanks',
   'pickBestVideo'
 ];
@@ -97,9 +105,9 @@ assert.strictEqual(
   'findVideo should score Shadow DOM videos together with light DOM videos'
 );
 
-// Invariant that protects every already-working single-player site: with one
-// candidate the ranking is never consulted, so no signal can turn a page that
-// used to sync into "no video found".
+// A hidden preload must not become the active controller merely because it is
+// the only video currently present. The media-frame monitor re-runs discovery
+// if its geometry becomes visible later.
 const lonelyBadCandidate = makeVideo('lonely', 0, 0, { muted: true, duration: 0 });
 lonelyBadCandidate.loop = true;
 lonelyBadCandidate.controls = false;
@@ -115,8 +123,88 @@ const lonelyDocument = {
 
 assert.strictEqual(
   findVideo(lonelyDocument),
-  lonelyBadCandidate,
-  'a single candidate is returned even when every ranking signal is against it'
+  null,
+  'a hidden single candidate is not returned as an active player'
+);
+
+function attachRenderEnvironment(documentNode, elements, { frameElement = null } = {}) {
+  const view = {
+    innerWidth: 1000,
+    innerHeight: 700,
+    frameElement,
+    getComputedStyle(element) {
+      return element._style || { display: 'block', visibility: 'visible', opacity: '1' };
+    }
+  };
+  documentNode.defaultView = view;
+  for (const element of elements) {
+    element.ownerDocument = documentNode;
+    element.getBoundingClientRect = () => element._rect || {
+      width: element.offsetWidth,
+      height: element.offsetHeight,
+      top: 0,
+      left: 0,
+      right: element.offsetWidth,
+      bottom: element.offsetHeight
+    };
+  }
+  return view;
+}
+
+const hiddenPlayingVideo = makeVideo('hidden-playing', 900, 506, {
+  controls: true,
+  paused: false,
+  duration: 1200
+});
+hiddenPlayingVideo._style = { display: 'block', visibility: 'hidden', opacity: '1' };
+const visiblePausedVideo = makeVideo('visible-paused', 800, 450, {
+  controls: true,
+  paused: true,
+  duration: 1200
+});
+const visibilityDocument = {
+  querySelectorAll(selector) {
+    if (selector === 'video') return [hiddenPlayingVideo, visiblePausedVideo];
+    return [];
+  }
+};
+attachRenderEnvironment(visibilityDocument, [hiddenPlayingVideo, visiblePausedVideo]);
+assert.strictEqual(
+  findVideo(visibilityDocument),
+  visiblePausedVideo,
+  'a hidden playing preload must not outrank the visible paused player'
+);
+
+const framedHiddenVideo = makeVideo('framed-hidden', 900, 506, {
+  controls: true,
+  paused: false,
+  duration: 1200
+});
+const hiddenFrameDocument = {
+  querySelectorAll(selector) {
+    if (selector === 'video') return [framedHiddenVideo];
+    return [];
+  }
+};
+const hiddenAncestorFrame = {
+  offsetWidth: 900,
+  offsetHeight: 506,
+  _style: { display: 'block', visibility: 'hidden', opacity: '1' },
+  contentDocument: hiddenFrameDocument
+};
+const hiddenFrameTopDocument = {
+  querySelectorAll(selector) {
+    if (selector === 'video') return [];
+    if (selector === 'iframe, frame') return [hiddenAncestorFrame];
+    return [];
+  }
+};
+attachRenderEnvironment(hiddenFrameTopDocument, [hiddenAncestorFrame]);
+attachRenderEnvironment(hiddenFrameDocument, [framedHiddenVideo], { frameElement: hiddenAncestorFrame });
+assert.strictEqual(
+  findVideo(hiddenFrameTopDocument),
+  null,
+  'a video inside a hidden same-origin ancestor frame must not be selected'
 );
 
 // Same-origin player iframe (jkanime.net): the top document has no <video>,
diff --git a/tests/e2e/extension.spec.mjs b/tests/e2e/extension.spec.mjs
index f7918ef..f14da24 100644
--- a/tests/e2e/extension.spec.mjs
+++ b/tests/e2e/extension.spec.mjs
@@ -27,16 +27,51 @@ async function selectTargetTab(context, extensionId, pageUrl) {
 
 async function sendServerCommand(context, extensionId, tabId, action, payload) {
     return withExtensionPage(context, extensionId, page => page.evaluate(async ({ tabId, action, payload }) => {
-        return chrome.tabs.sendMessage(tabId, {
-            type: 'SERVER_COMMAND',
+        return chrome.runtime.sendMessage({
+            type: 'CONTENT_EVENT',
             action,
-            payload,
-            actionTimestamp: Date.now(),
-            commandSenderId: 'e2e'
+            payload: payload || {},
+            expectedTabId: tabId
         });
     }, { tabId, action, payload }));
 }
 
+async function sendServerCommandBurst(context, extensionId, tabId, commands) {
+    return withExtensionPage(context, extensionId, page => page.evaluate(async ({ tabId, commands }) => {
+        return Promise.all(commands.map(({ action, payload }) => chrome.runtime.sendMessage({
+            type: 'CONTENT_EVENT',
+            action,
+            payload: payload || {},
+            expectedTabId: tabId
+        })));
+    }, { tabId, commands }));
+}
+
+async function getExtensionState(context, extensionId, message) {
+    return withExtensionPage(context, extensionId, page => page.evaluate(
+        request => chrome.runtime.sendMessage(request),
+        message
+    ));
+}
+
+async function getFrameMonitorState(context, extensionId, pageUrl, frameUrlPart) {
+    return withExtensionPage(context, extensionId, page => page.evaluate(async ({ pageUrl, frameUrlPart }) => {
+        const [tab] = await chrome.tabs.query({ url: pageUrl });
+        if (!tab) throw new Error(`no tab matched ${pageUrl}`);
+        const frames = await chrome.webNavigation.getAllFrames({ tabId: tab.id });
+        const frame = frames.find(candidate => candidate.url.includes(frameUrlPart));
+        if (!frame) throw new Error(`no frame matched ${frameUrlPart}`);
+        const target = frame.documentId
+            ? { tabId: tab.id, documentIds: [frame.documentId] }
+            : { tabId: tab.id, frameIds: [frame.frameId] };
+        const [result] = await chrome.scripting.executeScript({
+            target,
+            func: () => typeof window.__koalaMediaFrameMonitorCleanup
+        });
+        return result?.result;
+    }, { pageUrl, frameUrlPart }));
+}
+
 test('injects into the target tab and attaches to a same-origin frame player', async ({ context, extensionId, baseURL }) => {
     const url = `${baseURL}/pages/iframe-player.html`;
     const page = await context.newPage();
@@ -67,7 +102,8 @@ test('applies remote play, pause and seek to the framed player', async ({ contex
         return video ? video.dataset.koalaAttached : null;
     })).toBe('true');
 
-    await sendServerCommand(context, extensionId, tabId, 'play');
+    const playResponse = await sendServerCommand(context, extensionId, tabId, 'play');
+    expect(playResponse).toMatchObject({ status: 'ok_solo' });
     await expect.poll(() => page.evaluate(FRAMED_VIDEO_PAUSED), { message: 'remote play should start playback' }).toBe(false);
 
     await sendServerCommand(context, extensionId, tabId, 'pause');
@@ -159,6 +195,271 @@ test('re-attaches when a nested player frame swaps its document', async ({ conte
     ).toBe('true');
 });
 
+test('moves local event listeners after a CSS-only player switch', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/player-css-switch.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+    await selectTargetTab(context, extensionId, url);
+
+    await expect.poll(() => page.locator('#first').getAttribute('data-koala-attached')).toBe('true');
+    await page.waitForTimeout(250);
+    const beforeBurst = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    await page.evaluate(() => {
+        const first = document.getElementById('first');
+        first.dispatchEvent(new window.Event('play'));
+        first.dispatchEvent(new window.Event('pause'));
+        window.switchPlayer();
+    });
+    await expect.poll(async () => {
+        const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+        return status.lastActionState.action === 'play'
+            && status.lastActionState.timestamp > beforeBurst.lastActionState.timestamp;
+    }).toBe(true);
+    const leading = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    await expect.poll(
+        () => page.locator('#second').getAttribute('data-koala-attached'),
+        { message: 'attribute-only visibility changes must move the active controller' }
+    ).toBe('true');
+    expect(await page.locator('#first').getAttribute('data-koala-attached')).toBeNull();
+    const afterSwitch = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(afterSwitch.lastActionState.action).toBe('play');
+    expect(afterSwitch.lastActionState.timestamp).toBe(leading.lastActionState.timestamp);
+
+    const before = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    await page.locator('#first').evaluate(video => video.dispatchEvent(new window.Event('play')));
+    await page.waitForTimeout(250);
+    const afterStale = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+    expect(afterStale.lastActionState.timestamp).toBe(before.lastActionState.timestamp);
+
+    await page.locator('#second').evaluate(video => video.dispatchEvent(new window.Event('play')));
+    await expect.poll(async () => {
+        const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+        return status.lastActionState.timestamp;
+    }).toBeGreaterThan(afterStale.lastActionState.timestamp);
+});
+
+test('re-elects after a wrapper-only change inside an unselected cross-origin frame', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/cross-origin-internal-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('slot=first'));
+    const second = page.frames().find(frame => frame.url().includes('slot=second'));
+    await selectTargetTab(context, extensionId, url);
+
+    await expect.poll(() => first.locator('video').getAttribute('data-koala-attached')).toBe('true');
+    expect(await second.locator('video').getAttribute('data-koala-attached')).toBeNull();
+    await page.evaluate(() => window.switchInternalPlayer());
+    await expect.poll(
+        () => second.locator('video').getAttribute('data-koala-attached'),
+        { message: 'an unselected frame must announce its internally-visible player' }
+    ).toBe('true');
+    expect(await first.locator('video').getAttribute('data-koala-attached')).toBeNull();
+});
+
+test('targets a visible nested cross-origin player and keeps top-page debug context', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/cross-origin-nested.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+
+    const visiblePlayer = () => page.frames().find(frame => frame.url().includes('/frames/player-frame.html?visible=1'));
+    await expect.poll(async () => visiblePlayer()?.locator('video').getAttribute('src')).toContain('player-480p-12s.mp4');
+
+    const { tabId, response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok' });
+    expect(response.frameId).toBeGreaterThan(0);
+
+    await expect.poll(() => visiblePlayer()?.locator('video').getAttribute('data-koala-attached')).toBe('true');
+    const hiddenPlayer = page.frames().find(frame => frame.url().includes('/frames/player-frame-2.html?hidden=1'));
+    expect(await hiddenPlayer.locator('video').getAttribute('data-koala-attached')).toBeNull();
+
+    const playResponse = await sendServerCommand(context, extensionId, tabId, 'play');
+    expect(playResponse).toMatchObject({ status: 'ok_solo' });
+    await expect.poll(() => visiblePlayer().locator('video').evaluate(video => video.paused)).toBe(false);
+    await sendServerCommand(context, extensionId, tabId, 'pause');
+    await expect.poll(() => visiblePlayer().locator('video').evaluate(video => video.paused)).toBe(true);
+    await sendServerCommand(context, extensionId, tabId, 'seek', { targetTime: 6 });
+    await expect.poll(() => visiblePlayer().locator('video').evaluate(video => video.currentTime)).toBeGreaterThan(5);
+
+    await sendServerCommand(context, extensionId, tabId, 'pause');
+    await sendServerCommandBurst(context, extensionId, tabId, [
+        { action: 'seek', payload: { targetTime: 8 } },
+        { action: 'play', payload: { currentTime: 8 } }
+    ]);
+    await expect.poll(() => visiblePlayer().locator('video').evaluate(video => ({
+        paused: video.paused,
+        currentTime: video.currentTime
+    }))).toMatchObject({ paused: false, currentTime: expect.any(Number) });
+    await expect.poll(() => visiblePlayer().locator('video').evaluate(video => video.currentTime)).toBeGreaterThan(7);
+
+    const state = await getExtensionState(context, extensionId, { type: 'GET_VIDEO_STATE', tabId });
+    expect(state).toMatchObject({
+        found: true,
+        url,
+        pageTitle: 'Nested cross-origin player',
+        frameOrigin: new URL(baseURL.replace('localhost', '127.0.0.1')).origin,
+        inIframe: true
+    });
+});
+
+test('re-elects the visible cross-origin player after an iframe switch', 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, response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok' });
+    const firstFrameId = response.frameId;
+
+    await expect.poll(() => first.locator('video').getAttribute('data-koala-attached')).toBe('true');
+    await page.evaluate(() => window.switchPlayer());
+    await expect.poll(() => second.locator('video').getAttribute('data-koala-attached')).toBe('true');
+    await expect.poll(async () => {
+        const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+        return status.targetFrameId;
+    }).not.toBe(firstFrameId);
+
+    const playResponse = await sendServerCommand(context, extensionId, tabId, 'play');
+    expect(playResponse).toMatchObject({ status: 'ok_solo' });
+    await expect.poll(() => second.locator('video').evaluate(video => video.paused)).toBe(false);
+    expect(await first.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();
+    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 { tabId, response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok' });
+    await expect.poll(() => first.locator('video').getAttribute('data-koala-attached')).toBe('true');
+
+    await page.evaluate(() => window.startGeometryChurn());
+    try {
+        await page.waitForTimeout(300);
+        await sendServerCommand(context, extensionId, tabId, 'play', { currentTime: 1 });
+        await expect.poll(
+            () => first.locator('video').evaluate(video => video.paused),
+            { timeout: 3000, message: 'bounded refresh passes must not starve commands' }
+        ).toBe(false);
+    } finally {
+        await page.evaluate(() => window.stopGeometryChurn());
+    }
+});
+
+test('deactivates media monitors in child frames after a target-tab switch', async ({ context, extensionId, baseURL }) => {
+    const firstUrl = `${baseURL}/pages/cross-origin-nested.html`;
+    const secondUrl = `${baseURL}/pages/simple-player.html`;
+    const firstPage = await context.newPage();
+    const secondPage = await context.newPage();
+    await firstPage.goto(firstUrl);
+    await firstPage.waitForFunction(() => window.__fixtureReady === true);
+    await secondPage.goto(secondUrl);
+    await secondPage.waitForFunction(() => window.__fixtureReady === true);
+    await selectTargetTab(context, extensionId, firstUrl);
+    await expect.poll(() => getFrameMonitorState(
+        context,
+        extensionId,
+        firstUrl,
+        '/frames/player-frame.html?visible=1'
+    )).toBe('function');
+    await selectTargetTab(context, extensionId, secondUrl);
+    await expect.poll(
+        () => getFrameMonitorState(
+            context,
+            extensionId,
+            firstUrl,
+            '/frames/player-frame.html?visible=1'
+        ),
+        { message: 'child-frame monitor should be destroyed with the old target tab' }
+    ).toBe('undefined');
+});
+
+test('re-attaches after a selected cross-origin frame navigates', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/cross-origin-reloading.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('generation=first'));
+    const { tabId, response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok' });
+    await expect.poll(() => first.locator('video').getAttribute('data-koala-attached')).toBe('true');
+    const firstDocumentId = (await getExtensionState(context, extensionId, { type: 'GET_STATUS' })).targetDocumentId;
+
+    await page.evaluate(() => window.reloadPlayer());
+    await expect.poll(() => page.frames().find(frame => frame.url().includes('generation=second'))?.locator('video').getAttribute('data-koala-attached')).toBe('true');
+    await expect.poll(async () => {
+        const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+        return status.targetDocumentId;
+    }).not.toBe(firstDocumentId);
+
+    const state = await getExtensionState(context, extensionId, { type: 'GET_VIDEO_STATE', tabId });
+    expect(state).toMatchObject({ found: true, inIframe: true });
+});
+
+test('discovers a video inserted late inside a cross-origin frame', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/cross-origin-late.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+    const lateFrame = page.frames().find(frame => frame.url().includes('/frames/late-player-frame.html'));
+    const { response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok', hasVideo: false });
+
+    await expect.poll(
+        () => lateFrame.locator('#late-player').getAttribute('data-koala-attached'),
+        { timeout: 12_000, message: 'late cross-origin video should trigger target re-election' }
+    ).toBe('true');
+    await expect.poll(async () => {
+        const status = await getExtensionState(context, extensionId, { type: 'GET_STATUS' });
+        return status.targetHasVideo;
+    }).toBe(true);
+});
+
+test('rejects a cross-origin player hidden three frame levels deep', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/deep-hidden-cross-origin.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+    const hiddenFrame = page.frames().find(frame => frame.url().includes('deep=hidden'));
+    await expect.poll(() => hiddenFrame?.locator('video').getAttribute('src')).toContain('player-1080p-30s.mp4');
+
+    const { response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok', frameId: 0, hasVideo: false });
+    expect(await hiddenFrame.locator('video').getAttribute('data-koala-attached')).toBeNull();
+});
+
+test('rejects a player inside a hidden same-origin frame', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/hidden-same-origin.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+    const hiddenFrame = page.frames().find(frame => frame.url().includes('hidden=same-origin'));
+    await expect.poll(() => hiddenFrame?.locator('video').getAttribute('src')).toContain('player-480p-12s.mp4');
+
+    const { response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok', frameId: 0, hasVideo: false });
+    expect(await hiddenFrame.locator('video').getAttribute('data-koala-attached')).toBeNull();
+});
+
+test('rejects a hidden cross-origin player after its iframe URL redirects', async ({ context, extensionId, baseURL }) => {
+    const url = `${baseURL}/pages/hidden-redirect-cross-origin.html`;
+    const page = await context.newPage();
+    await page.goto(url);
+    await page.waitForFunction(() => window.__fixtureReady === true);
+    const redirectedFrame = page.frames().find(frame => frame.url().includes('redirected=hidden'));
+    await expect.poll(() => redirectedFrame?.locator('video').getAttribute('src')).toContain('player-1080p-30s.mp4');
+
+    const { response } = await selectTargetTab(context, extensionId, url);
+    expect(response).toMatchObject({ status: 'ok', frameId: 0, hasVideo: false });
+    expect(await redirectedFrame.locator('video').getAttribute('data-koala-attached')).toBeNull();
+});
+
 function FRAMED_VIDEO_PAUSED() {
     return document.querySelector('iframe').contentDocument.querySelector('video').paused;
 }
diff --git a/tests/e2e/fixture-server.mjs b/tests/e2e/fixture-server.mjs
index b608a4b..ce24c94 100644
--- a/tests/e2e/fixture-server.mjs
+++ b/tests/e2e/fixture-server.mjs
@@ -20,6 +20,13 @@ const TYPES = {
 
 const server = http.createServer((req, res) => {
     const requested = decodeURIComponent(new URL(req.url, 'http://localhost').pathname);
+    if (requested === '/redirect/hidden-player') {
+        res.writeHead(302, {
+            Location: `http://127.0.0.1:${port}/pages/frames/player-frame-2.html?redirected=hidden`,
+            'Cache-Control': 'no-store'
+        }).end();
+        return;
+    }
     const filePath = path.resolve(root, `.${requested}`);
 
     if (!filePath.startsWith(root + path.sep)) {
diff --git a/tests/e2e/fixtures/pages/cross-origin-internal-switching.html b/tests/e2e/fixtures/pages/cross-origin-internal-switching.html
new file mode 100644
index 0000000..cd28c31
--- /dev/null
+++ b/tests/e2e/fixtures/pages/cross-origin-internal-switching.html
@@ -0,0 +1,32 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Cross-origin internal wrapper switch</title>
+  <style>
+    iframe { width: 640px; height: 360px; border: 0; display: block; }
+  </style>
+</head>
+<body>
+  <iframe id="first" allow="autoplay; fullscreen"></iframe>
+  <iframe id="second" allow="autoplay; fullscreen"></iframe>
+  <script>
+    const playerOrigin = `http://127.0.0.1:${location.port}`;
+    const first = document.getElementById('first');
+    const second = document.getElementById('second');
+    first.src = `${playerOrigin}/pages/frames/wrapper-switch-player.html?slot=first&visible=1`;
+    second.src = `${playerOrigin}/pages/frames/wrapper-switch-player.html?slot=second&visible=0`;
+    let loaded = 0;
+    const ready = () => {
+      loaded++;
+      if (loaded === 2) window.__fixtureReady = true;
+    };
+    first.addEventListener('load', ready);
+    second.addEventListener('load', ready);
+    window.switchInternalPlayer = () => {
+      first.contentWindow.postMessage('koala-hide', playerOrigin);
+      second.contentWindow.postMessage('koala-show', playerOrigin);
+    };
+  </script>
+</body>
+</html>
diff --git a/tests/e2e/fixtures/pages/cross-origin-late.html b/tests/e2e/fixtures/pages/cross-origin-late.html
new file mode 100644
index 0000000..1ff87a1
--- /dev/null
+++ b/tests/e2e/fixtures/pages/cross-origin-late.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Late cross-origin player</title>
+<style>body { margin: 0; } iframe { border: 0; }</style>
+<iframe id="player" width="860" height="490" allowfullscreen></iframe>
+<script>
+  const player = document.getElementById('player');
+  player.src = `http://127.0.0.1:${location.port}/pages/frames/late-player-frame.html`;
+  player.addEventListener('load', () => { window.__fixtureReady = true; }, { once: true });
+</script>
diff --git a/tests/e2e/fixtures/pages/cross-origin-nested.html b/tests/e2e/fixtures/pages/cross-origin-nested.html
new file mode 100644
index 0000000..d5a0157
--- /dev/null
+++ b/tests/e2e/fixtures/pages/cross-origin-nested.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Nested cross-origin player</title>
+<style>
+  body { margin: 0; }
+  iframe { border: 0; }
+  #hidden-player { display: none; }
+</style>
+<iframe id="wrapper" width="870" height="500" src="frames/cross-origin-wrapper.html" allowfullscreen></iframe>
+<iframe id="hidden-player" width="870" height="500" allowfullscreen></iframe>
+<script>
+  const hidden = document.getElementById('hidden-player');
+  hidden.src = `http://127.0.0.1:${location.port}/pages/frames/player-frame-2.html?hidden=1`;
+  Promise.all([
+    new Promise(resolve => document.getElementById('wrapper').addEventListener('load', resolve, { once: true })),
+    new Promise(resolve => hidden.addEventListener('load', resolve, { once: true }))
+  ]).then(() => { window.__fixtureReady = true; });
+</script>
diff --git a/tests/e2e/fixtures/pages/cross-origin-reloading.html b/tests/e2e/fixtures/pages/cross-origin-reloading.html
new file mode 100644
index 0000000..3e2617f
--- /dev/null
+++ b/tests/e2e/fixtures/pages/cross-origin-reloading.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Reloading cross-origin player</title>
+<style>body { margin: 0; } iframe { border: 0; }</style>
+<iframe id="player" width="860" height="490" allowfullscreen></iframe>
+<script>
+  const player = document.getElementById('player');
+  player.src = `http://127.0.0.1:${location.port}/pages/frames/player-frame.html?generation=first`;
+  player.addEventListener('load', () => { window.__fixtureReady = true; }, { once: true });
+  window.reloadPlayer = () => {
+    player.src = `http://127.0.0.1:${location.port}/pages/frames/player-frame-2.html?generation=second`;
+  };
+</script>
diff --git a/tests/e2e/fixtures/pages/cross-origin-switching.html b/tests/e2e/fixtures/pages/cross-origin-switching.html
new file mode 100644
index 0000000..910e528
--- /dev/null
+++ b/tests/e2e/fixtures/pages/cross-origin-switching.html
@@ -0,0 +1,38 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Switching cross-origin players</title>
+<style>
+  body { margin: 0; }
+  iframe { border: 0; }
+  #second { display: none; }
+</style>
+<iframe id="first" width="860" height="490" allowfullscreen></iframe>
+<iframe id="second" width="860" height="490" allowfullscreen></iframe>
+<script>
+  const first = document.getElementById('first');
+  const second = document.getElementById('second');
+  first.src = `http://127.0.0.1:${location.port}/pages/frames/player-frame.html?slot=first`;
+  second.src = `http://127.0.0.1:${location.port}/pages/frames/player-frame-2.html?slot=second`;
+  Promise.all([
+    new Promise(resolve => first.addEventListener('load', resolve, { once: true })),
+    new Promise(resolve => second.addEventListener('load', resolve, { once: true }))
+  ]).then(() => { window.__fixtureReady = true; });
+  window.switchPlayer = () => {
+    first.style.visibility = 'hidden';
+    first.style.position = 'absolute';
+    first.style.left = '-10000px';
+    second.style.display = 'block';
+  };
+  let geometryChurn = null;
+  window.startGeometryChurn = () => {
+    let wide = false;
+    geometryChurn = setInterval(() => {
+      wide = !wide;
+      first.style.width = wide ? '840px' : '800px';
+    }, 80);
+  };
+  window.stopGeometryChurn = () => {
+    clearInterval(geometryChurn);
+    geometryChurn = null;
+  };
+</script>
diff --git a/tests/e2e/fixtures/pages/deep-hidden-cross-origin.html b/tests/e2e/fixtures/pages/deep-hidden-cross-origin.html
new file mode 100644
index 0000000..de31061
--- /dev/null
+++ b/tests/e2e/fixtures/pages/deep-hidden-cross-origin.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Deep hidden cross-origin player</title>
+<style>body { margin: 0; } iframe { border: 0; } #hidden-wrapper { visibility: hidden; }</style>
+<iframe id="hidden-wrapper" width="870" height="500" src="frames/deep-wrapper-1.html" allowfullscreen></iframe>
+<script>
+  document.getElementById('hidden-wrapper').addEventListener('load', () => {
+    window.__fixtureReady = true;
+  }, { once: true });
+</script>
diff --git a/tests/e2e/fixtures/pages/frames/cross-origin-wrapper.html b/tests/e2e/fixtures/pages/frames/cross-origin-wrapper.html
new file mode 100644
index 0000000..e1eee8d
--- /dev/null
+++ b/tests/e2e/fixtures/pages/frames/cross-origin-wrapper.html
@@ -0,0 +1,9 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Cross-origin wrapper</title>
+<style>body { margin: 0; } iframe { border: 0; }</style>
+<iframe id="inner-player" width="860" height="490" allowfullscreen></iframe>
+<script>
+  document.getElementById('inner-player').src =
+    `http://127.0.0.1:${location.port}/pages/frames/player-frame.html?visible=1`;
+</script>
diff --git a/tests/e2e/fixtures/pages/frames/deep-wrapper-1.html b/tests/e2e/fixtures/pages/frames/deep-wrapper-1.html
new file mode 100644
index 0000000..63b1108
--- /dev/null
+++ b/tests/e2e/fixtures/pages/frames/deep-wrapper-1.html
@@ -0,0 +1,5 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Deep wrapper 1</title>
+<style>body { margin: 0; } iframe { border: 0; }</style>
+<iframe width="860" height="490" src="deep-wrapper-2.html" allowfullscreen></iframe>
diff --git a/tests/e2e/fixtures/pages/frames/deep-wrapper-2.html b/tests/e2e/fixtures/pages/frames/deep-wrapper-2.html
new file mode 100644
index 0000000..5a7ea34
--- /dev/null
+++ b/tests/e2e/fixtures/pages/frames/deep-wrapper-2.html
@@ -0,0 +1,9 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Deep wrapper 2</title>
+<style>body { margin: 0; } iframe { border: 0; }</style>
+<iframe id="deep-player" width="850" height="480" allowfullscreen></iframe>
+<script>
+  document.getElementById('deep-player').src =
+    `http://127.0.0.1:${location.port}/pages/frames/player-frame-2.html?deep=hidden`;
+</script>
diff --git a/tests/e2e/fixtures/pages/frames/late-player-frame.html b/tests/e2e/fixtures/pages/frames/late-player-frame.html
new file mode 100644
index 0000000..7bcb38e
--- /dev/null
+++ b/tests/e2e/fixtures/pages/frames/late-player-frame.html
@@ -0,0 +1,15 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Late player frame</title>
+<style>body { margin: 0; }</style>
+<script>
+  setTimeout(() => {
+    const video = document.createElement('video');
+    video.id = 'late-player';
+    video.width = 854;
+    video.height = 480;
+    video.controls = true;
+    video.src = '../../media/player-480p-12s.mp4';
+    document.body.append(video);
+  }, 8000);
+</script>
diff --git a/tests/e2e/fixtures/pages/frames/wrapper-switch-player.html b/tests/e2e/fixtures/pages/frames/wrapper-switch-player.html
new file mode 100644
index 0000000..efd4cfa
--- /dev/null
+++ b/tests/e2e/fixtures/pages/frames/wrapper-switch-player.html
@@ -0,0 +1,30 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Wrapper-switch player</title>
+  <style>
+    html, body { margin: 0; }
+    #wrapper.hidden { visibility: hidden; }
+    video { width: 640px; height: 360px; }
+  </style>
+</head>
+<body>
+  <div id="wrapper">
+    <video id="player" controls preload="auto"></video>
+  </div>
+  <script>
+    const params = new URLSearchParams(location.search);
+    const wrapper = document.getElementById('wrapper');
+    const player = document.getElementById('player');
+    wrapper.classList.toggle('hidden', params.get('visible') !== '1');
+    player.src = params.get('slot') === 'second'
+      ? '../../media/player-1080p-30s.mp4'
+      : '../../media/player-480p-12s.mp4';
+    window.addEventListener('message', event => {
+      if (event.data === 'koala-show') wrapper.classList.remove('hidden');
+      if (event.data === 'koala-hide') wrapper.classList.add('hidden');
+    });
+  </script>
+</body>
+</html>
diff --git a/tests/e2e/fixtures/pages/hidden-redirect-cross-origin.html b/tests/e2e/fixtures/pages/hidden-redirect-cross-origin.html
new file mode 100644
index 0000000..6eba2f2
--- /dev/null
+++ b/tests/e2e/fixtures/pages/hidden-redirect-cross-origin.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Hidden redirected cross-origin player</title>
+<style>body { margin: 0; } iframe { border: 0; visibility: hidden; }</style>
+<iframe id="player" width="860" height="490" allowfullscreen></iframe>
+<script>
+  const player = document.getElementById('player');
+  player.src = `http://localhost:${location.port}/redirect/hidden-player`;
+  player.addEventListener('load', () => { window.__fixtureReady = true; }, { once: true });
+</script>
diff --git a/tests/e2e/fixtures/pages/hidden-same-origin.html b/tests/e2e/fixtures/pages/hidden-same-origin.html
new file mode 100644
index 0000000..b207286
--- /dev/null
+++ b/tests/e2e/fixtures/pages/hidden-same-origin.html
@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Hidden same-origin frame</title>
+  <style>
+    iframe { width: 800px; height: 450px; border: 0; visibility: hidden; }
+  </style>
+</head>
+<body>
+  <iframe src="frames/player-frame.html?hidden=same-origin" allow="autoplay; fullscreen"></iframe>
+  <script>window.__fixtureReady = true;</script>
+</body>
+</html>
diff --git a/tests/e2e/fixtures/pages/player-css-switch.html b/tests/e2e/fixtures/pages/player-css-switch.html
new file mode 100644
index 0000000..ec77f24
--- /dev/null
+++ b/tests/e2e/fixtures/pages/player-css-switch.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>CSS player switch</title>
+  <style>
+    video { width: 640px; height: 360px; }
+    #second { visibility: hidden; }
+  </style>
+</head>
+<body>
+  <video id="first" controls preload="auto" src="../media/player-480p-12s.mp4"></video>
+  <video id="second" controls preload="auto" src="../media/player-1080p-30s.mp4"></video>
+  <script>
+    window.switchPlayer = () => {
+      document.getElementById('first').style.visibility = 'hidden';
+      document.getElementById('second').style.visibility = 'visible';
+    };
+    window.__fixtureReady = true;
+  </script>
+</body>
+</html>