diff --git a/CLAUDE.md b/CLAUDE.md
index 63931934..f023b889 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -618,9 +618,11 @@ then woke a fresh background with no record of the user's toolbar choice, so an
 allowlisted site auto-started MPV again even after the user had picked the
 in-page player or Off. The same loss dropped the one-hand-off-per-page latch,
 so the page's next stream request after a wake opened a second mpv window.
-`TabTracker.saveTabState` now writes `url`, `isOn`, `isMpv`, `regexMatched`,
+`TabTracker.saveTabState` now writes `url`, `isOn`, `isMpv`, `mpvOnPlay`, `regexMatched`,
 `mpvMatched` and `mpvAutoOpened` per tab to `chrome.storage.session` whenever
 one of them changes (toolbar click, URL change, mpv hand-off and its failure),
+and since 2026-10-03 (#158) the failure shown as "!" (`mpvError`) and the shortcut's
+waiting play (`mpvPlayPendingUntil`, `mpvPlayedVideo`, `mpvLastPlaySend`),
 and `restoreTabStates` puts them back inside `ensureOptions()`, which every
 state-changing listener already awaits. A new field that has to survive a wake
 goes into `PersistedTabFields`, and every place that sets it saves. Within one
@@ -676,6 +678,16 @@ forgotten. A frame whose page never named itself to this background (it restarte
 since) proves nothing and the player counts. mpv-shortcut's `/late` page pins the
 state the race left.
 
+**A player a page frames itself (2026-10-03, #225).** `player/index.html` is
+web-accessible, so a page, or an ad's iframe in it, can frame it with any
+`parent_frame_id`. The player's own load is a moz-extension request that webRequest never
+sees, so the background took that id on trust: the named frame (the top one) counted as
+holding a player, with the effect above. Now `PLAYER_LOADED` adopts the named parent only
+when the opener is that frame's page or the player frame's own
+(`TabHolder.playerParentProof`); when the background does not know the frame's name (it
+restarted since), it asks the frame's content script (`IS_PLAYER_OPENER`). Otherwise the
+player is answered null and forgotten. mpv-shortcut's `/framed` page pins it.
+
 **Gone pages, and a page Back brings back (2026-09-30).** `TabHolder.goneDocuments`
 keeps the 16 latest pages that left a tab, by name, with what each had detected. A page
 leaves when its `FRAME_REMOVED` is taken, when another page names itself in its frame
@@ -1554,7 +1566,7 @@ Opted in: `background.mjs` (2026-10-01) and the rest of `chrome/background/` but
 (`native-host/faststream-mpv-host.mjs`). The types are Chrome's (`@types/chrome`,
 which matches the `chrome.*` calls, callbacks included) plus Node's (the host, tests
 and tools), and `types/firefox-chrome.d.ts` adds the Firefox-only fields read here
-(`cookieStoreId`, `originUrl`). background.mjs's own fixes were JSDoc, a few
+(`cookieStoreId`). background.mjs's own fixes were JSDoc, a few
 `undefined` checks that return what the code returned before (through a throw), and
 one guard: a message from a page outside any tab is no longer handled as a tab's. The
 player's files are next; fix what tsc reports only with the playback suites to hand.
diff --git a/chrome/background/BackgroundUtils.mjs b/chrome/background/BackgroundUtils.mjs
index ad4fd4cd..63414c39 100644
--- a/chrome/background/BackgroundUtils.mjs
+++ b/chrome/background/BackgroundUtils.mjs
@@ -1,4 +1,6 @@
 // @ts-check
+import {URLUtils} from '../player/utils/URLUtils.mjs';
+
 const PlayerURL = chrome.runtime.getURL('player/index.html');
 
 export class BackgroundUtils {
@@ -21,6 +23,20 @@ export class BackgroundUtils {
     return BackgroundUtils.PlayerOpeningResponses.includes(response);
   }
 
+  /**
+   * The player mode of a source a site script reports (DETECTED_SOURCE, custom/*.js). Its
+   * page can post such a report too (Instagram's): one without an address, or of a type
+   * the player does not play, was recorded as a source of no mode.
+   * @param {*} msg - The message.
+   * @return {?string} The mode, or null for no source.
+   */
+  static detectedSourceMode(msg) {
+    if (!msg || typeof msg.url !== 'string' || !msg.url) {
+      return null;
+    }
+    return URLUtils.getModeFromExtension(msg.ext) || null;
+  }
+
   static checkMessageError(message, suppress = false) {
     if (chrome.runtime.lastError) {
       if (!suppress) console.warn(`Unable to send message '${message}'`, chrome.runtime.lastError);
@@ -136,6 +152,25 @@ export class BackgroundUtils {
     return url.substring(0, PlayerURL.length) === PlayerURL;
   }
 
+  /**
+   * Whether a tab's new URL (tabs.onUpdated) is still the same page: only its fragment
+   * changed, to an anchor (#comments) or a time (#t=120), which Firefox reports as it
+   * reports a new page. A hash route (#/episode/2, #!/...) is a page of its own, as is
+   * the same URL again (a reload).
+   * @param {?string|undefined} oldUrl - The tab's URL before.
+   * @param {string} newUrl - Its URL now.
+   * @return {boolean}
+   */
+  static isSamePageUrlChange(oldUrl, newUrl) {
+    if (!oldUrl || !newUrl || oldUrl === newUrl) {
+      return false;
+    }
+    const hash = (url) => (url.includes('#') ? url.slice(url.indexOf('#') + 1) : '');
+    const strip = (url) => url.split('#')[0];
+    const isRoute = (url) => hash(url).startsWith('/') || hash(url).startsWith('!');
+    return strip(oldUrl) === strip(newUrl) && !isRoute(oldUrl) && !isRoute(newUrl);
+  }
+
   static getPlayerUrl() {
     return PlayerURL;
   }
diff --git a/chrome/background/ManifestTypes.mjs b/chrome/background/ManifestTypes.mjs
index 2b277c5b..ad851ab9 100644
--- a/chrome/background/ManifestTypes.mjs
+++ b/chrome/background/ManifestTypes.mjs
@@ -30,3 +30,26 @@ export function contentTypeOf(headers) {
 export function modeFromContentType(headers) {
   return MANIFEST_TYPES.get(contentTypeOf(headers));
 }
+
+// Files a media element plays that the player's MP4 mode cannot read (it reads MP4 only):
+// played as they are, as a .webm URL already is (URLUtils).
+const DIRECT_TYPES = ['video/webm', 'video/ogg'];
+
+/**
+ * The player mode for a file a <video> or <audio> element loaded, whose URL names no type:
+ * by its Content-Type. Every such file used to be taken for an MP4 video: a site's
+ * notification sound or a podcast's MP3 too, which on the MPV allowlist went to mpv as the
+ * page's first stream, and on a tab that is on opened the player.
+ * @param {Array<{name: string, value?: string}>} [headers] - webRequest's responseHeaders.
+ * @return {string|null} The mode, or null for audio, which is no video.
+ */
+export function modeFromMediaType(headers) {
+  const type = contentTypeOf(headers);
+  if (type.startsWith('audio/')) {
+    return null;
+  }
+  if (DIRECT_TYPES.includes(type)) {
+    return PlayerModes.DIRECT;
+  }
+  return PlayerModes.ACCELERATED_MP4;
+}
diff --git a/chrome/background/MultiRegexMatcher.mjs b/chrome/background/MultiRegexMatcher.mjs
index b0ba2769..bcbab7da 100644
--- a/chrome/background/MultiRegexMatcher.mjs
+++ b/chrome/background/MultiRegexMatcher.mjs
@@ -53,42 +53,76 @@ export class MultiRegexMatcher {
     this.compiledRegexes.length = 0;
 
     regexesByFlags.forEach((regexes, flags) => {
-      const regexesByOutput = new Map();
-      for (const {regex, output} of regexes) {
-        if (!regexesByOutput.has(output)) {
-          regexesByOutput.set(output, []);
+      // A backreference counts groups by position, and the groups the joined form adds
+      // move them: \1 came to mean the group wrapped around the pattern. Such a pattern
+      // is compiled on its own.
+      const alone = regexes.filter(({regex}) => /\\(?:[1-9]|k<)/.test(regex));
+      const joinable = regexes.filter((entry) => !alone.includes(entry));
+      if (joinable.length > 0) {
+        try {
+          this.compiledRegexes.push(MultiRegexMatcher.join(joinable, flags));
+        } catch (e) {
+          // A pattern valid on its own that the joined form refuses - a group of its own
+          // named like the ones added (o0) - left all of them out, and the matcher before
+          // stayed in use. Each on its own instead.
+          alone.push(...joinable);
         }
-        regexesByOutput.get(output).push(regex);
       }
+      for (const {regex, output} of alone) {
+        this.compiledRegexes.push({regex: new RegExp(regex, flags), output});
+      }
+    });
+  }
 
-      const joinedRegexes = [];
-      const outputByGroupName = new Map();
-      let groupIndex = 0;
-      regexesByOutput.forEach((regexes, output) => {
-        // Named group, not a plain wrapping group: a raw regex with its own
-        // capturing group(s) would otherwise shift every later output's
-        // positional group index, silently misrouting the match to the
-        // wrong (or a nonexistent) output.
-        const groupName = 'o' + groupIndex++;
-        outputByGroupName.set(groupName, output);
-        joinedRegexes.push(`(?<${groupName}>${regexes.join('|')})`);
-      });
+  /**
+   * One regex for many patterns: each output's patterns in a named group of its own.
+   * @param {Array<{regex: string, output: *}>} regexes - The patterns, all with one set
+   *   of flags.
+   * @param {string} flags - Those flags.
+   * @return {{regex: RegExp, outputByGroupName: Map<string, *>}}
+   */
+  static join(regexes, flags) {
+    const regexesByOutput = new Map();
+    for (const {regex, output} of regexes) {
+      if (!regexesByOutput.has(output)) {
+        regexesByOutput.set(output, []);
+      }
+      regexesByOutput.get(output).push(regex);
+    }
 
-      this.compiledRegexes.push({
-        regex: new RegExp(joinedRegexes.join('|'), flags),
-        outputByGroupName,
-      });
+    const joinedRegexes = [];
+    const outputByGroupName = new Map();
+    let groupIndex = 0;
+    regexesByOutput.forEach((regexes, output) => {
+      // Named group, not a plain wrapping group: a raw regex with its own
+      // capturing group(s) would otherwise shift every later output's
+      // positional group index, silently misrouting the match to the
+      // wrong (or a nonexistent) output.
+      const groupName = 'o' + groupIndex++;
+      outputByGroupName.set(groupName, output);
+      joinedRegexes.push(`(?<${groupName}>${regexes.join('|')})`);
     });
+
+    return {
+      regex: new RegExp(joinedRegexes.join('|'), flags),
+      outputByGroupName,
+    };
   }
 
   match(str) {
-    for (const {regex, outputByGroupName} of this.compiledRegexes) {
+    for (const {regex, output, outputByGroupName} of this.compiledRegexes) {
       const match = str.match(regex);
-      if (match?.groups) {
-        for (const groupName in match.groups) {
-          if (match.groups[groupName] !== undefined) {
-            return outputByGroupName.get(groupName);
-          }
+      if (!match) {
+        continue;
+      }
+      if (!outputByGroupName) {
+        return output;
+      }
+      // By the groups this matcher added, not every group the match has: a pattern's own
+      // named group came first in a match of a later output, and gave no output at all.
+      for (const [groupName, groupOutput] of outputByGroupName) {
+        if (match.groups?.[groupName] !== undefined) {
+          return groupOutput;
         }
       }
     }
diff --git a/chrome/background/NetRequestRuleManager.mjs b/chrome/background/NetRequestRuleManager.mjs
index e2c3eb86..005c1a2e 100644
--- a/chrome/background/NetRequestRuleManager.mjs
+++ b/chrome/background/NetRequestRuleManager.mjs
@@ -33,7 +33,7 @@ export class RuleManager {
     this.idStart = 10 + Math.floor(Math.random() * 1000) * 1000;
     this.rules = [];
     this.isLoopRunning = false;
-    this.dumpRules();
+    this.dumpRules().catch((e) => console.warn('Could not clear the header rules left from before', e));
   }
 
   getInsertionIndex(id) {
@@ -66,7 +66,7 @@ export class RuleManager {
       return;
     }
     setTimeout(() => this.mainLoop(), 1000);
-    this.filterRules();
+    this.filterRules().catch((e) => console.warn('Could not remove expired header rules', e));
   }
 
   async filterRules() {
@@ -80,9 +80,24 @@ export class RuleManager {
       return true;
     });
 
-    return chrome.declarativeNetRequest.updateSessionRules({
-      removeRuleIds: removed.map((rule) => rule.id),
-    });
+    try {
+      await chrome.declarativeNetRequest.updateSessionRules({
+        removeRuleIds: removed.map((rule) => rule.id),
+      });
+    } catch (e) {
+      // The browser may still hold them. Back in the list, their ids are not handed out
+      // again (getNextID), which a new rule would be refused for, and the next round tries
+      // again - three times, then they are given up.
+      for (const rule of removed) {
+        rule.removeAttempts = (rule.removeAttempts || 0) + 1;
+        const index = this.getInsertionIndex(rule.id);
+        if (rule.removeAttempts < 3 && index !== -1) {
+          this.rules.splice(index, 0, rule);
+        }
+      }
+      this.startLoop();
+      throw e;
+    }
   }
 
   async addHeaderRule(url, tabId, requestHeaderCommands) {
diff --git a/chrome/background/TabTracker.mjs b/chrome/background/TabTracker.mjs
index e193a436..916b6b17 100644
--- a/chrome/background/TabTracker.mjs
+++ b/chrome/background/TabTracker.mjs
@@ -1,5 +1,50 @@
 // @ts-check
+import {PlayerModes} from '../player/enums/PlayerModes.mjs';
 import {BackgroundUtils} from './BackgroundUtils.mjs';
+import {StreamLengths} from './StreamLengths.mjs';
+
+// What a frame keeps of the streams and subtitle files its page asked for (addSource,
+// addSubtitle). A page that is never left grew both lists without end: an HLS or DASH
+// player's pieces (seg-14.mp4, seg-14.vtt) are detected one by one, thousands in an
+// evening, each with its request's headers; every one went again to each player tab
+// (sendSourcesToMainFramePlayers), and a player opened then read the length of each.
+// - At most SameShapeLimit files of one shape (StreamLengths.shape): the first stays, so
+//   the shape is still known as a stream's pieces (StreamLengths.lengthsOf), and the
+//   oldest after it goes.
+// - At most TrackedLimit in all: the oldest file goes first, a manifest only once no file
+//   is left.
+const SameShapeLimit = 20;
+const TrackedLimit = 200;
+
+/**
+ * Brings a list of a frame's streams or subtitles, just added to, back to the limits above.
+ * @param {Array<Object>} list - The list; its last entry is the new one.
+ * @param {(entry: Object) => string} urlOf - An entry's URL.
+ * @param {(entry: Object) => boolean} isFile - Whether an entry is a file (one piece of a
+ *   stream, possibly), not a manifest.
+ */
+function trimTracked(list, urlOf, isFile) {
+  const added = list[list.length - 1];
+  if (added && isFile(added)) {
+    const shape = StreamLengths.shape(urlOf(added));
+    const same = list.filter((entry) => isFile(entry) && StreamLengths.shape(urlOf(entry)) === shape);
+    if (same.length > SameShapeLimit) {
+      list.splice(list.indexOf(same[1]), 1);
+    }
+  }
+  while (list.length > TrackedLimit) {
+    const file = list.findIndex(isFile);
+    list.splice(file === -1 ? 0 : file, 1);
+  }
+}
+
+/**
+ * @param {Object} source - A detected source.
+ * @return {boolean} Whether it is a file (MP4 or a direct one), not a manifest.
+ */
+function isFileSource(source) {
+  return source.mode === PlayerModes.ACCELERATED_MP4 || source.mode === PlayerModes.DIRECT;
+}
 
 export class FrameHolder {
   constructor(tab, frameId) {
@@ -7,7 +52,11 @@ export class FrameHolder {
     this.frameId = frameId;
     this.parent = null;
     this.children = new Set();
-    this.loadedCallbacks = new Set();
+    // Set by reset(), as the rest of a frame's page state.
+    /** @type {Array<Object>} */
+    this.trackedSubtitles = [];
+    /** @type {Array<Object>} */
+    this.trackedSources = [];
     this.reset();
   }
 
@@ -21,13 +70,39 @@ export class FrameHolder {
     this.isPlayer = false;
     this.trackedSubtitles = [];
     this.trackedSources = [];
-    this.requestHeaders = new Map();
     this.url = '';
     /**
      * The name content.js gave the page it shows (FRAME_ADDED); null when unknown.
      * @type {?string}
      */
     this.documentKey = null;
+    /**
+     * What sendSources last handed a player in a frame inside this one (noteHandedToPlayer).
+     * @type {?{frameId: number, subtitles: Array<Object>, sources: Array<Object>, video: ?Object}}
+     */
+    this.handedToPlayer = null;
+  }
+
+  /**
+   * Keeps what a player in a frame inside this one was handed (sendSources), for that
+   * player loading again in its frame ("Reload Frame" on it): sendSources takes what it
+   * hands out of the frames, so the player asked again and got nothing.
+   * @param {number} playerFrameId - The player's frame.
+   * @param {{subtitles: Array<Object>, sources: Array<Object>, video: ?Object}} handed - What
+   *   it was handed.
+   */
+  noteHandedToPlayer(playerFrameId, handed) {
+    this.handedToPlayer = {frameId: playerFrameId, ...handed};
+  }
+
+  /**
+   * What noteHandedToPlayer kept for a player's frame.
+   * @param {number} playerFrameId - The player's frame.
+   * @return {?{frameId: number, subtitles: Array<Object>, sources: Array<Object>, video: ?Object}}
+   *   Null when the last player handed sources here was in another frame.
+   */
+  handedTo(playerFrameId) {
+    return this.handedToPlayer && this.handedToPlayer.frameId === playerFrameId ? this.handedToPlayer : null;
   }
 
   removeChildFrame(childFrame) {
@@ -68,6 +143,24 @@ export class FrameHolder {
     return this.trackedSources;
   }
 
+  /**
+   * Keeps a stream the page asked for, within the limits (trimTracked).
+   * @param {{url: string, mode: string}} source - The source.
+   */
+  addSource(source) {
+    this.trackedSources.push(source);
+    trimTracked(this.trackedSources, (s) => s.url, isFileSource);
+  }
+
+  /**
+   * Keeps a subtitle file the page asked for, within the limits (trimTracked).
+   * @param {{source: string}} subtitle - The subtitle.
+   */
+  addSubtitle(subtitle) {
+    this.trackedSubtitles.push(subtitle);
+    trimTracked(this.trackedSubtitles, (s) => s.source, () => true);
+  }
+
   /**
    * Whether the tab still tracks this frame under its id. A new page in the frame keeps it
    * (FRAME_ADDED resets it in place); a frame forgotten (FRAME_REMOVED), or dropped with its
@@ -95,6 +188,10 @@ export class FrameHolder {
 // How many gone pages a tab remembers (TabHolder.goneDocuments). Navigating a tab would
 // otherwise grow it without end; the oldest go first.
 const GoneDocumentLimit = 16;
+// How many requests' headers a tab keeps while their responses are awaited
+// (TabHolder.requestHeaders). Each goes when its response or its error comes; this only
+// bounds those that never get either.
+const RequestHeaderLimit = 500;
 
 /**
  * @param {string} a - A URL, or anything else.
@@ -119,6 +216,13 @@ export class TabHolder {
     // (restoreGoneDocument), and to refuse a player still starting that names one
     // (isPlayerOfGoneDocument). Not cleared by reset(), see there.
     this.goneDocuments = new Map();
+    // The headers of the tab's requests still waiting for a response, by request id
+    // (rememberRequestHeaders). The tab's, not a frame's, and not cleared by reset(): a
+    // request can be sent before the page that made it named itself (a preload, 103
+    // Early Hints) or before the reset on a new site, and answered after, and a stream
+    // found without the Referer its CDN checks got a 403 in the player.
+    /** @type {Map<string, *>} */
+    this.requestHeaders = new Map();
 
     this.isOn = false;
     this.isMpv = false;
@@ -138,6 +242,10 @@ export class TabHolder {
     // reset() - it's a short-lived timestamp that's harmless to carry across
     // a same-tab navigation and naturally goes stale on its own.
     this.popupGuardArmedUntil = 0;
+    // A start by address waiting for the new page to name itself (background.mjs
+    // startWithTrackedLater); the next address change cancels it.
+    /** @type {ReturnType<typeof setTimeout>|undefined} */
+    this.urlStartTimer = undefined;
 
     this.reset();
   }
@@ -163,6 +271,10 @@ export class TabHolder {
     // What that play plays (content.js's playedVideo): a stream plainly another length is
     // not its stream.
     this.mpvPlayedVideo = null;
+    // While a stream is checked for such a play, the streams detected meanwhile, to be
+    // checked next (background.mjs sendPendingPlay); null otherwise.
+    /** @type {?Array<Object>} */
+    this.mpvPlayChecking = null;
   }
 
   /**
@@ -213,6 +325,19 @@ export class TabHolder {
     this.playerCount = players;
   }
 
+  /**
+   * Keeps a request's headers until its response or its error comes (forgetRequestHeaders).
+   * @param {string} requestId - webRequest's id, unique in the session.
+   * @param {*} headers - Its requestHeaders.
+   */
+  rememberRequestHeaders(requestId, headers) {
+    this.requestHeaders.delete(requestId);
+    this.requestHeaders.set(requestId, headers);
+    while (this.requestHeaders.size > RequestHeaderLimit) {
+      this.requestHeaders.delete(this.requestHeaders.keys().next().value);
+    }
+  }
+
   getFrames() {
     return this.frames.values();
   }
@@ -260,6 +385,32 @@ export class TabHolder {
     return pages.length > 0 && !pages.some((frame) => frame.documentKey === opener);
   }
 
+  /**
+   * Whether a player may be taken for a child of the frame it names (PLAYER_LOADED's
+   * parentFrameId, from the player's own URL). The player page is web-accessible, so any
+   * page can frame it with any parent_frame_id: one naming the top frame made the top
+   * frame count as holding a player (FrameHolder.hasPlayer), and the background dropped
+   * every stream of the page and opened no player there until it navigated. content.js
+   * names its page in each player's URL (opener), a name only its content script knows,
+   * so that name must be the named frame's page, or the player frame's own (a page that
+   * went to the player).
+   * @param {FrameHolder} playerFrame - The player's frame.
+   * @param {*} parentFrameId - The frame it names.
+   * @param {?string} opener - The page its URL names.
+   * @return {'proven'|'refused'|'ask'} 'ask' when the named frame's page never named
+   *   itself to this background (it started again since): its content script can tell.
+   */
+  playerParentProof(playerFrame, parentFrameId, opener) {
+    if (!opener || !Number.isInteger(parentFrameId) || parentFrameId < 0) {
+      return 'refused';
+    }
+    const parent = this.getFrame(parentFrameId);
+    if ([playerFrame, parent].some((frame) => frame && frame.documentKey === opener)) {
+      return 'proven';
+    }
+    return parent && parent.documentKey ? 'refused' : 'ask';
+  }
+
   /**
    * Marks the page a frame shows gone, with the pages in the frames inside it, and keeps
    * what each had detected under its name. A frame whose page never named itself has
@@ -354,36 +505,18 @@ export class TabHolder {
 
   /**
    * Forgets a frame the page removed, with every frame inside it (FRAME_REMOVED).
-   * Whatever waits for one of them to load (WAIT_UNTIL_MAIN_LOADED) is answered with
-   * null, as it never will. A frame this background never knew - Firefox unloaded it
-   * while the page kept its frames - is nothing to forget; it used to throw here.
+   * A frame this background never knew - Firefox unloaded it while the page kept its
+   * frames - is nothing to forget; it used to throw here.
    * @param {FrameHolder|undefined} frame - The removed frame.
    */
   forgetFrame(frame) {
     if (!frame) {
       return;
     }
-    const gone = [];
-    const collect = (f) => {
-      gone.push(f);
-      f.children.forEach(collect);
-    };
-    collect(frame);
-
     this.playerCount = Math.max(0, (this.playerCount || 0) - frame.resetSelfAndChildren());
     if (frame.parent) {
       frame.parent.removeChildFrame(frame);
     }
-    for (const f of gone) {
-      f.loadedCallbacks.forEach((callback) => {
-        try {
-          callback(null);
-        } catch (e) {
-          console.error(e);
-        }
-      });
-      f.loadedCallbacks.clear();
-    }
     this.removeFrame(frame.frameId);
   }
 
@@ -410,10 +543,14 @@ const TabStateKeyPrefix = 'tabState:';
 // the same lifetime tab ids have) so a woken background still knows it.
 // mpvAutoOpened goes with it: without it the page's next stream request after a
 // wake opens a second mpv window for a page already handed off. mpvOnPlay too,
-// or a woken background forwards the page's first stream after all. The rest of a
+// or a woken background forwards the page's first stream after all. mpvError, or the
+// toolbar's "!" for a failed hand-off went at the wake. And a play still waiting for its
+// stream (mpvPlayPendingUntil, mpvPlayedVideo) and the last one sent (mpvLastPlaySend,
+// which keeps a player's second play() from opening a second window). The rest of a
 // TabHolder - frames, detected sources - describes the current page and is
 // rebuilt as that page makes requests.
-const PersistedTabFields = ['url', 'isOn', 'isMpv', 'mpvOnPlay', 'regexMatched', 'mpvMatched', 'mpvAutoOpened'];
+const PersistedTabFields = ['url', 'isOn', 'isMpv', 'mpvOnPlay', 'regexMatched', 'mpvMatched', 'mpvAutoOpened',
+  'mpvError', 'mpvPlayPendingUntil', 'mpvPlayedVideo', 'mpvLastPlaySend'];
 
 export class TabTracker {
   constructor() {
@@ -484,6 +621,17 @@ export class TabTracker {
     chrome.storage.session.remove(TabStateKeyPrefix + tabId).catch(() => {});
   }
 
+  /**
+   * Forgets a request's headers once its response or its error came. A tab this tracker
+   * does not know (closed, its requests cancelled after tabs.onRemoved) is not made again
+   * for it: Firefox never reuses a tab id, so it would stay for the background's life.
+   * @param {number} tabId - The request's tab.
+   * @param {string} requestId - Its id.
+   */
+  forgetRequestHeaders(tabId, requestId) {
+    this.getTab(tabId)?.requestHeaders.delete(requestId);
+  }
+
   getFrame(tabId, frameId) {
     const tab = this.getTab(tabId);
     return tab && tab.getFrame(frameId);
diff --git a/chrome/background/background.mjs b/chrome/background/background.mjs
index 10d6ef63..ed7c658c 100644
--- a/chrome/background/background.mjs
+++ b/chrome/background/background.mjs
@@ -9,7 +9,7 @@ import {BackgroundUtils} from './BackgroundUtils.mjs';
 import {parseCustomSourcePatterns} from './CustomSourcePatterns.mjs';
 import {sanitizeDownloadFilename} from './DownloadFilename.mjs';
 import {KeyShortcut} from './KeyShortcut.mjs';
-import {modeFromContentType} from './ManifestTypes.mjs';
+import {modeFromContentType, modeFromMediaType} from './ManifestTypes.mjs';
 import {MessageTypes} from '../player/enums/MessageTypes.mjs';
 import {MpvBackend} from './MpvBackend.mjs';
 import {MultiRegexMatcher} from './MultiRegexMatcher.mjs';
@@ -91,7 +91,12 @@ function ensureOptions() {
     OptionsLoadPromise = Promise.all([
       loadOptions(),
       Tabs.restoreTabStates(),
-    ]).catch(console.error);
+    ]).catch((e) => {
+      console.error('Loading the options failed', e);
+      // The next event tries again. Kept, the failure stood until the event page unloaded,
+      // and every event acted on no options: MPV mode and both URL lists off.
+      OptionsLoadPromise = null;
+    });
   }
   return OptionsLoadPromise;
 }
@@ -121,8 +126,6 @@ const SourceLengthWaitMs = 2500;
 // The page answers within milliseconds unless its own scripts keep it busy; then the
 // longest decides, as before the question.
 const PlayedVideoWaitMs = 1000;
-// Where this background's own requests come from.
-const OwnOrigin = chrome.runtime.getURL('');
 
 
 let CustomSourcePatternsMatcher = new MultiRegexMatcher();
@@ -230,6 +233,7 @@ async function startMpv(tab, onPlay = false) {
     tab.mpvLastPlaySend = null;
     tab.mpvPlayPendingUntil = 0;
     tab.mpvPlayedVideo = null;
+    tab.mpvPlayChecking = null;
     chrome.tabs.sendMessage(tab.tabId, {
       type: MessageTypes.MPV_REPORT_PLAYING,
     }, () => {
@@ -515,25 +519,34 @@ chrome.tabs.onUpdated.addListener(async (tabid, changeInfo, tabobj) => {
       tab.mpvMatched = false;
     }
 
+    // Only the fragment changed (an anchor, #t=...): still the same page, whose player
+    // plays on. Taken for a new page, the latch reset below let the page's next stream
+    // request (a quality switch) open a second mpv window, and the in-page player was
+    // taken down. content.js's link handler already keeps the player for such a link.
+    const samePage = BackgroundUtils.isSamePageUrlChange(tab.url, changeInfo.url);
     tab.url = changeInfo.url;
 
-    // The auto-open latch is per page, not per tab. The reset above only runs on
-    // a hostname change, so without this a second episode on the same site is
-    // detected and then dropped, because the tab still looks like it has
-    // already handed a stream to mpv.
-    tab.mpvAutoOpened = false;
-    tab.mpvSentUrls.clear();
-    tab.mpvError = null;
-    tab.mpvPlayPendingUntil = 0;
-    tab.mpvPlayedVideo = null;
-
-    chrome.tabs.sendMessage(tabid, {
-      type: MessageTypes.REMOVE_PLAYERS,
-    }, {
-      frameId: 0,
-    }, () => {
-      BackgroundUtils.checkMessageError('remove_players');
-    });
+    if (!samePage) {
+      // The auto-open latch is per page, not per tab. The reset above only runs on
+      // a hostname change, so without this a second episode on the same site is
+      // detected and then dropped, because the tab still looks like it has
+      // already handed a stream to mpv.
+      tab.mpvAutoOpened = false;
+      tab.mpvSentUrls.clear();
+      tab.mpvError = null;
+      tab.mpvPlayPendingUntil = 0;
+      tab.mpvPlayedVideo = null;
+      tab.mpvPlayChecking = null;
+      clearTimeout(tab.urlStartTimer);
+
+      chrome.tabs.sendMessage(tabid, {
+        type: MessageTypes.REMOVE_PLAYERS,
+      }, {
+        frameId: 0,
+      }, () => {
+        BackgroundUtils.checkMessageError('remove_players');
+      });
+    }
 
     const shouldAutoEnable = AutoEnableList.matches(changeInfo.url);
 
@@ -557,7 +570,8 @@ chrome.tabs.onUpdated.addListener(async (tabid, changeInfo, tabobj) => {
       tab.isMpv = true;
       // The allowlist's own rule, even if the shortcut armed this tab.
       tab.mpvOnPlay = false;
-      openMpvWithSources(tab);
+      startWithTrackedLater(tab, changeInfo.url, () => tab.isMpv && !tab.mpvOnPlay && !tab.mpvAutoOpened,
+          () => openMpvWithSources(tab));
     } else if (shouldAutoEnable && !tab.regexMatched && !(tab.isMpv && tab.mpvOnPlay)) {
       // Not for a tab armed with the MPV shortcut: the user's own choice for the tab
       // outranks the standing list, so the first video they start here still goes to mpv.
@@ -568,9 +582,11 @@ chrome.tabs.onUpdated.addListener(async (tabid, changeInfo, tabobj) => {
       tab.isMpv = mpvSite;
       tab.mpvOnPlay = false;
       if (tab.isMpv) {
-        openMpvWithSources(tab);
+        startWithTrackedLater(tab, changeInfo.url, () => tab.isMpv && !tab.mpvOnPlay && !tab.mpvAutoOpened,
+            () => openMpvWithSources(tab));
       } else {
-        openPlayersWithSources(tab);
+        startWithTrackedLater(tab, changeInfo.url, () => !tab.isMpv,
+            (foundBefore) => openPlayersWithSources(tab, foundBefore));
       }
     } else if (!shouldAutoEnable && !mpvSite && tab.regexMatched) {
       tab.isOn = false;
@@ -585,6 +601,35 @@ chrome.tabs.onUpdated.addListener(async (tabid, changeInfo, tabobj) => {
   BackgroundUtils.updateTabIcon(tab, true);
 });
 
+// How long a start by address (the MPV allowlist, the auto-enable list) waits before it
+// acts on the streams the tab already tracks (startWithTrackedLater).
+const UrlStartSettleMs = 500;
+
+/**
+ * Starts MPV or the in-page player for a tab whose address just matched a list, from the
+ * streams it tracks, once the new page had the time to name itself. tabs.onUpdated can come
+ * before the new page's FRAME_ADDED, which drops the page before's streams: the trailer a
+ * site's home page played went to mpv for the episode the user opened from it (an
+ * allowlist entry for its /watch path), the episode's own stream found the page handed off
+ * already, and was only tracked. A stream the new page asks for meanwhile goes by itself
+ * (onSourceRecieved), and the start leaves it to that: it acts only on streams found before
+ * the address changed (start gets that time). A page that changes its address itself
+ * (pushState) names no new page, and what the tab tracked then is that page's.
+ * @param {TabHolder} tab - The tab.
+ * @param {string} url - The address that matched.
+ * @param {() => boolean} stillWanted - Whether the start still applies then.
+ * @param {(foundBefore: number) => *} start - The start, given the address change's time.
+ */
+function startWithTrackedLater(tab, url, stillWanted, start) {
+  // The tab's next address change cancels it (tabs.onUpdated).
+  const changedAt = Date.now();
+  tab.urlStartTimer = setTimeout(() => {
+    if (Tabs.getTab(tab.tabId) === tab && tab.url === url && tab.isOn && stillWanted()) {
+      start(changedAt);
+    }
+  }, UrlStartSettleMs);
+}
+
 chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
   if (msg.type === MessageTypes.PING) {
     sendResponse(MessageTypes.PONG);
@@ -677,7 +722,8 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
   const frame = tab.getFrameOrCreate(sender.frameId);
 
   if (msg.type === MessageTypes.PLAYER_LOADED) {
-    if (tab.isPlayerOfGoneDocument(frame, msg.parentFrameId, playerOpener(msg.url || sender.url))) {
+    const opener = playerOpener(msg.url || sender.url);
+    if (tab.isPlayerOfGoneDocument(frame, msg.parentFrameId, opener)) {
       // Its page reloaded while it started (TabHolder.isPlayerOfGoneDocument): it goes
       // with that page, and is no player of the one there now.
       if (Logging) console.log('Ignoring a player whose page is gone', frame);
@@ -685,65 +731,27 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
       sendResponse(null);
       return;
     }
-    if (Logging) console.log('Found FastStream window', frame);
-    frame.isPlayer = true;
-
-    if (tab.downloadInfo) {
-      chrome.tabs.sendMessage(frame.tab.tabId, {
-        type: MessageTypes.HANDLE_DOWNLOAD,
-        url: tab.downloadInfo.url,
-        filename: tab.downloadInfo.filename,
-      }, {
-        frameId: frame.frameId,
-      }, (response) => {
-        BackgroundUtils.checkMessageError('download');
-        tab.downloadInfo.resolve(response);
-        tab.downloadInfo = null;
-
-        // Close tab
-        chrome.tabs.remove(frame.tab.tabId);
-      });
-      sendResponse(null);
-      return;
-    }
-
     if (!frame.parent && msg.parentFrameId !== undefined) {
-      const parentFrame = tab.getFrameOrCreate(msg.parentFrameId);
-      frame.setParentFrame(parentFrame);
-    }
-
-    if (frame.playerOpening) {
-      frame.playerOpening = false;
-    } else if (frame.parent) {
-      frame.parent.playerOpening = false;
-    }
-    tab.playerCount++;
-    const isMainPlayer = tab.playerCount === 1;
-
-    getPageFrame(frame).then((pageFrame) => {
-      if (pageFrame) {
-        frame.pageFrame = pageFrame;
-      } else {
-        frame.pageFrame = tab.getFrameOrCreate(0);
-      }
-
-      const response = {
-        mediaInfo: getMediaInfoFromTab(sender?.tab),
-        analyzerData: tab.analyzerData,
-        isMainPlayer,
-      };
-
-      sendResponse(response);
-    }).catch((e) => {
-      // The player waits for this answer before it starts; the top frame stands in.
-      console.error('Finding the page frame of a player failed', e);
-      frame.pageFrame = tab.getFrameOrCreate(0);
-      sendResponse({
-        mediaInfo: getMediaInfoFromTab(sender?.tab),
-        analyzerData: tab.analyzerData,
-        isMainPlayer,
+      // The player names the frame it is in (TabHolder.playerParentProof): taken on trust,
+      // a page framing the player page could make any frame of the tab hold a player.
+      isPlayerParentProven(tab, frame, msg.parentFrameId, opener).then((proven) => {
+        if (!proven) {
+          if (Logging) console.log('Ignoring a player whose page did not open it', frame);
+          tab.forgetFrame(frame);
+          sendResponse(null);
+          return;
+        }
+        frame.setParentFrame(tab.getFrameOrCreate(msg.parentFrameId));
+        acceptPlayer(tab, frame, sender, sendResponse);
+      }).catch((e) => {
+        // The player waits for an answer; without a proof it is no page's player.
+        console.error('Checking the page of a player failed', e);
+        tab.forgetFrame(frame);
+        sendResponse(null);
       });
-    });
+      return true;
+    }
+    acceptPlayer(tab, frame, sender, sendResponse);
     return true;
   } else if (msg.type === MessageTypes.FRAME_ADDED) {
     // Preserve sources key to this frame's new URL
@@ -771,15 +779,6 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
     tab.playerCount -= playerCount;
     tab.playerCount = Math.max(0, tab.playerCount);
     checkURLMatch(frame);
-
-    frame.loadedCallbacks.forEach((callback) => {
-      try {
-        callback('loaded');
-      } catch (e) {
-        console.error(e);
-      }
-    });
-    frame.loadedCallbacks.clear();
   } else if (msg.type === MessageTypes.FRAME_REMOVED) {
     tab.forgetRemovedFrame(msg.frameId !== undefined ? tab.getFrame(msg.frameId) : frame, msg.document);
   } else if (msg.type === MessageTypes.PLAYER_OPEN_GONE) {
@@ -788,22 +787,6 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
     if (frame.playerOpening && frame.playerOpeningAttempt === msg.attempt) {
       frame.playerOpening = false;
     }
-  } else if (msg.type === MessageTypes.WAIT_UNTIL_MAIN_LOADED) {
-    frame.loadedCallbacks.add(sendResponse);
-
-    // Try to ping tab
-    chrome.tabs.sendMessage(tab.tabId, {
-      type: MessageTypes.PING_TAB,
-    }, (response) => {
-      BackgroundUtils.checkMessageError('ping_tab');
-      if (response === MessageTypes.PONG_TAB) {
-        if (frame.loadedCallbacks.has(sendResponse)) {
-          frame.loadedCallbacks.delete(sendResponse);
-          sendResponse('loaded');
-        }
-      }
-    });
-    return true;
   } else if (msg.type === MessageTypes.SEND_TO_CONTENT) {
     chrome.tabs.sendMessage(tab.tabId, {
       type: MessageTypes.MESSAGE_FROM_CONTENT,
@@ -845,13 +828,15 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
       return true;
     }
   } else if (msg.type === MessageTypes.DETECTED_SOURCE) {
-    const mode = URLUtils.getModeFromExtension(msg.ext);
-    const headers = msg.headers || {};
-    onSourceRecieved({
-      url: msg.url,
-      requestId: -1,
-      customHeaders: headers,
-    }, frame, mode);
+    const mode = BackgroundUtils.detectedSourceMode(msg);
+    if (mode) {
+      const headers = msg.headers || {};
+      onSourceRecieved({
+        url: msg.url,
+        requestId: -1,
+        customHeaders: headers,
+      }, frame, mode);
+    }
   } else if (msg.type === MessageTypes.DOWNLOAD) {
     const url = msg.url;
     // Firefox refuses a name with a colon and some other characters, and the download then
@@ -869,17 +854,25 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
           return;
         }
         const tab2 = Tabs.getTabOrCreate(tabobj2.id);
+        // Answered once: by the player's HANDLE_DOWNLOAD answer, or by the timeout below.
+        let answered = false;
+        const answer = (value) => {
+          if (answered) return false;
+          answered = true;
+          sendResponse(value);
+          return true;
+        };
         tab2.downloadInfo = {
           url: url,
           filename: filename,
-          resolve: sendResponse,
+          resolve: answer,
         };
         // If the player in this hidden tab never sends PLAYER_LOADED (blocked
-        // page, redirect failure, site error before injection), the tab and
-        // the caller's sendResponse would otherwise hang forever.
+        // page, redirect failure, site error before injection), or never answers
+        // HANDLE_DOWNLOAD, the tab and the caller's sendResponse would otherwise
+        // hang forever.
         setTimeout(() => {
-          if (tab2.downloadInfo) {
-            tab2.downloadInfo.resolve(null);
+          if (answer(null)) {
             tab2.downloadInfo = null;
             chrome.tabs.remove(/** @type {number} */ (tabobj2.id)).catch(() => {});
           }
@@ -1348,8 +1341,8 @@ async function setupRedirectRule(ruleID, filetypes) {
     condition: {
       // exclude self
       excludedRequestDomains,
-      // only match m3u8 or mpds
-      regexFilter: '^.+\\.(' + filetypes.join('|') + ')([\\?|#].*)?$',
+      // only match m3u8 or mpds, up to a query or a fragment
+      regexFilter: '^.+\\.(' + filetypes.join('|') + ')([?#].*)?$',
       resourceTypes: ['main_frame'],
     },
   };
@@ -1403,7 +1396,7 @@ function handleSubtitles(url, frame, headers) {
   if (Logging) console.log('Found subtitle', url);
   const u = (new URL(url)).pathname.split('/').pop() || '';
 
-  subtitles.push({
+  frame.addSubtitle({
     source: url,
     headers: headers,
     label: u.split('.')[0],
@@ -1418,7 +1411,7 @@ function getSourceFromURL(frame, url) {
 }
 
 function addSource(frame, url, mode, headers, time = Date.now()) {
-  frame.getSources().push({
+  frame.addSource({
     url, mode, headers, time,
   });
 }
@@ -1653,6 +1646,29 @@ function collectSources(frame, remove = false) {
 async function sendSources(frame) {
   const continuationOptions = frame.tab.continuationOptions;
   frame.tab.continuationOptions = null;
+  const send = (subtitles, sources, video) => {
+    chrome.tabs.sendMessage(frame.tab.tabId, {
+      type: MessageTypes.SOURCES,
+      subtitles: subtitles,
+      sources: sources,
+      video,
+      autoSetSource: true,
+      continuationOptions: continuationOptions,
+    }, {
+      frameId: frame.frameId,
+    }, () => {
+      BackgroundUtils.checkMessageError('sources');
+    });
+  };
+
+  // A player loading again in its frame ("Reload Frame" on it) gets what its first load
+  // got: that was taken out of the page's frames (collectSources), and it sat on the
+  // welcome screen with nothing.
+  const handed = frame.parent ? frame.parent.handedTo(frame.frameId) : null;
+  if (handed && collectSources(frame).sources.length === 0) {
+    send(handed.subtitles, handed.sources, handed.video);
+    return;
+  }
 
   // The player plays the one the page's video played, or the longest of them: a little
   // time for the lengths still being read. The video is asked about after that, when the
@@ -1679,18 +1695,10 @@ async function sendSources(frame) {
     source.duration = lengths[i];
   });
 
-  chrome.tabs.sendMessage(frame.tab.tabId, {
-    type: MessageTypes.SOURCES,
-    subtitles: subtitles,
-    sources: sources,
-    video,
-    autoSetSource: true,
-    continuationOptions: continuationOptions,
-  }, {
-    frameId: frame.frameId,
-  }, () => {
-    BackgroundUtils.checkMessageError('sources');
-  });
+  if (frame.parent && sources.length) {
+    frame.parent.noteHandedToPlayer(frame.frameId, {subtitles, sources, video});
+  }
+  send(subtitles, sources, video);
 }
 
 async function scrapeCaptionsTags(frame) {
@@ -1763,6 +1771,109 @@ function playerOpener(url) {
   }
 }
 
+/**
+ * Whether the frame a player names (PLAYER_LOADED's parentFrameId) holds the page that
+ * opened it (TabHolder.playerParentProof). When this background does not know that page's
+ * name (it started again since the page loaded), the frame's content script is asked.
+ * @param {TabHolder} tab - The tab.
+ * @param {FrameHolder} frame - The player's frame.
+ * @param {*} parentFrameId - The frame it names.
+ * @param {?string} opener - The page its URL names.
+ * @return {Promise<boolean>}
+ */
+async function isPlayerParentProven(tab, frame, parentFrameId, opener) {
+  const proof = tab.playerParentProof(frame, parentFrameId, opener);
+  if (proof !== 'ask') {
+    return proof === 'proven';
+  }
+  const answer = await new Promise((resolve) => {
+    chrome.tabs.sendMessage(tab.tabId, {
+      type: MessageTypes.IS_PLAYER_OPENER,
+      document: opener,
+    }, {
+      frameId: parentFrameId,
+    }, (response) => {
+      BackgroundUtils.checkMessageError('is_player_opener');
+      resolve(response);
+    });
+  });
+  if (answer !== true) {
+    return false;
+  }
+  const parent = tab.getFrameOrCreate(parentFrameId);
+  if (!parent.documentKey) {
+    parent.documentKey = opener;
+  }
+  return true;
+}
+
+/**
+ * Takes a player that said it loaded (PLAYER_LOADED) for one, and answers it.
+ * @param {Object} tab - TabHolder of the player.
+ * @param {Object} frame - FrameHolder of the player, its parent set when it has one.
+ * @param {chrome.runtime.MessageSender} sender - The message's sender.
+ * @param {Function} sendResponse - The answer.
+ */
+function acceptPlayer(tab, frame, sender, sendResponse) {
+  if (Logging) console.log('Found FastStream window', frame);
+  frame.isPlayer = true;
+
+  if (tab.downloadInfo) {
+    // Taken now: the DOWNLOAD's 30 s timeout can end it while the player saves, and the
+    // answer then found no download to give it to (a TypeError, and no answer at all).
+    const info = tab.downloadInfo;
+    tab.downloadInfo = null;
+    chrome.tabs.sendMessage(frame.tab.tabId, {
+      type: MessageTypes.HANDLE_DOWNLOAD,
+      url: info.url,
+      filename: info.filename,
+    }, {
+      frameId: frame.frameId,
+    }, (response) => {
+      BackgroundUtils.checkMessageError('download');
+      info.resolve(response);
+
+      // Close tab
+      chrome.tabs.remove(frame.tab.tabId).catch(() => {});
+    });
+    sendResponse(null);
+    return;
+  }
+
+  if (frame.playerOpening) {
+    frame.playerOpening = false;
+  } else if (frame.parent) {
+    frame.parent.playerOpening = false;
+  }
+  tab.playerCount++;
+  const isMainPlayer = tab.playerCount === 1;
+
+  getPageFrame(frame).then((pageFrame) => {
+    if (pageFrame) {
+      frame.pageFrame = pageFrame;
+    } else {
+      frame.pageFrame = tab.getFrameOrCreate(0);
+    }
+
+    const response = {
+      mediaInfo: getMediaInfoFromTab(sender?.tab),
+      analyzerData: tab.analyzerData,
+      isMainPlayer,
+    };
+
+    sendResponse(response);
+  }).catch((e) => {
+    // The player waits for this answer before it starts; the top frame stands in.
+    console.error('Finding the page frame of a player failed', e);
+    frame.pageFrame = tab.getFrameOrCreate(0);
+    sendResponse({
+      mediaInfo: getMediaInfoFromTab(sender?.tab),
+      analyzerData: tab.analyzerData,
+      isMainPlayer,
+    });
+  });
+}
+
 async function openPlayer(frame) {
   if (frame.playerOpening || frame.hasPlayer()) {
     return;
@@ -1800,9 +1911,17 @@ async function openPlayer(frame) {
 async function sendSourcesToMainFramePlayers(frame) {
   // query all tabs
   const tabs = await BackgroundUtils.queryTabs();
+  // Only to player tabs on the same side of private browsing as the page: a private
+  // window's streams, with the requests' cookies, showed in an ordinary window's player
+  // tab, and the other way round. A tab no longer open says nothing of its side.
+  const from = tabs.find((t) => t.id === frame.tab.tabId);
+  if (!from) {
+    return;
+  }
 
   // for each tab
   for (let i = 0; i < tabs.length; i++) {
+    if (!!tabs[i].incognito !== !!from.incognito) continue;
     const tab = Tabs.getTab(tabs[i].id);
     if (!tab || !tab.isOn) continue;
     // if the tab is a faststream tab
@@ -1826,7 +1945,7 @@ async function onSourceRecieved(details, frame, mode) {
   // a second onHeadersReceived listener, so it runs the moment this function
   // yields at its first await; reading them after that always returns
   // undefined and the Referer/Origin the CDN needs is lost.
-  const customHeaders = details.customHeaders || frame.requestHeaders.get(details.requestId);
+  const customHeaders = details.customHeaders || frame.tab.requestHeaders.get(details.requestId);
 
   await ensureOptions();
 
@@ -1848,26 +1967,15 @@ async function onSourceRecieved(details, frame, mode) {
       // The shortcut's MPV: streams are only tracked, for onUserPlay to pick
       // from - unless the user already pressed play and the player asked
       // for its stream only afterwards, in which case this is that stream.
-      if (frame.tab.mpvPlayPendingUntil > Date.now()) {
-        const tab = frame.tab;
-        const until = tab.mpvPlayPendingUntil;
-        const page = {url: tab.url, document: frame.documentKey};
-        // Taken now, so another stream found while this one's length is read waits.
-        tab.mpvPlayPendingUntil = 0;
-        // Its length, read above, tells whether it is the video the user started: the
-        // first stream after the play went unchecked, a preview's or an ad's as well.
-        await Lengths.settle(() => [{url, mode, headers: customHeaders}], SourceLengthWaitMs);
-        if (tab.url !== page.url || frame.documentKey !== page.document) {
-          return;
-        }
-        if (StreamPick.conflicts(tab.mpvPlayedVideo, Lengths.lengthOf(url))) {
-          // Another video's: the next one may be the video's, while the wait lasts.
-          tab.mpvPlayPendingUntil = until;
-          return;
-        }
-        if (tab.isOn && tab.isMpv && tab.mpvOnPlay) {
-          sendPlayedToMpv(tab, {url, headers: customHeaders});
-        }
+      const tab = frame.tab;
+      const candidate = {frame, document: frame.documentKey, url, mode, headers: customHeaders};
+      if (tab.mpvPlayChecking) {
+        // Another stream is being checked for the play: this one is next, should that one
+        // be another video's. Dropped, an ad's manifest and then the episode's left the
+        // play with nothing sent.
+        tab.mpvPlayChecking.push(candidate);
+      } else if (tab.mpvPlayPendingUntil > Date.now()) {
+        await sendPendingPlay(tab, candidate);
       }
       return;
     }
@@ -1930,7 +2038,15 @@ async function onSourceRecieved(details, frame, mode) {
   return;
 }
 
-async function openPlayersWithSources(tab) {
+/**
+ * Opens the in-page player in each frame whose page has a video stream.
+ * @param {TabHolder} tab - The tab.
+ * @param {number} [foundBefore] - Only streams found before this time count (a start by
+ *   address, startWithTrackedLater): a later one opens the player by itself, after the
+ *   page's <track> captions are read (onSourceRecieved), and opened here as well it
+ *   beat them and opened a second player.
+ */
+async function openPlayersWithSources(tab, foundBefore = Infinity) {
   if (!tabHasSources(tab)) {
     // Streams the page asked for before this background knew of it (recoverSources). Each
     // one found opens the player as a stream detected now does (onSourceRecieved): opened
@@ -1942,7 +2058,7 @@ async function openPlayersWithSources(tab) {
 
   let framesWithSources = [];
   for (const frame of tab.getFrames()) {
-    if (!frame.isPlayer && frame.getSources().length > 0) {
+    if (!frame.isPlayer && frame.getSources().some((source) => !(source.time >= foundBefore))) {
       framesWithSources.push(frame);
     }
   }
@@ -1959,8 +2075,10 @@ async function openPlayersWithSources(tab) {
       return;
     }
 
+    // A frame that did not answer (no content script) has no size: 0, not undefined, whose
+    // NaN made the order arbitrary - and the first player opened is the one that plays.
     framesWithSources.sort((a, b) => {
-      return b.videoSize - a.videoSize;
+      return (b.videoSize || 0) - (a.videoSize || 0);
     });
 
     for (let i = 0; i < framesWithSources.length; i++) {
@@ -2043,6 +2161,7 @@ function setMpvError(tab, result) {
   if (tab.mpvError !== error) {
     tab.mpvError = error;
     BackgroundUtils.updateTabIcon(tab);
+    Tabs.saveTabState(tab);
   }
 }
 
@@ -2073,7 +2192,13 @@ async function tabTitle(tabId) {
  * @param {?Object} video - What it plays (content.js playedVideo).
  */
 function autoOpenKnownLater(tab, frameId, src, video) {
-  const waiting = () => tab.isOn && tab.isMpv && !tab.mpvOnPlay && !tab.mpvAutoOpened;
+  // The page the play came from, as onUserPlay checks it: within the wait the tab can show
+  // another page (Back once more gives one back with its streams), and that page's stream
+  // went to mpv for this page's play.
+  const documentIn = () => tab.getFrame(frameId)?.documentKey;
+  const page = {url: tab.url, document: documentIn()};
+  const waiting = () => tab.isOn && tab.isMpv && !tab.mpvOnPlay && !tab.mpvAutoOpened &&
+    tab.url === page.url && documentIn() === page.document;
   setTimeout(async () => {
     if (!waiting()) {
       return;
@@ -2153,6 +2278,56 @@ async function onUserPlay(sender, src, video) {
     // page asks for decides, when its length can be the video's (onSourceRecieved).
     tab.mpvPlayedVideo = video || null;
     tab.mpvPlayPendingUntil = Date.now() + MpvPlayPendingMs;
+    Tabs.saveTabState(tab);
+  }
+}
+
+/**
+ * The shortcut's MPV, after a play whose stream was not detected yet (onUserPlay): checks
+ * the streams detected since, in the order the page asked for them, and sends the first
+ * whose length can be the video's. The length tells: the first stream after the play
+ * went unchecked once, a preview's or an ad's as well. Streams found while one is checked
+ * wait their turn in tab.mpvPlayChecking. None that fits: the play waits on for the next,
+ * while its time lasts.
+ *
+ * @param {TabHolder} tab - The tab the video plays in.
+ * @param {{frame: FrameHolder, document: ?string, url: string, mode: string, headers: *}} first -
+ *   The stream that came first, and the page its frame showed then.
+ * @return {Promise<void>}
+ */
+async function sendPendingPlay(tab, first) {
+  const until = tab.mpvPlayPendingUntil;
+  const url = tab.url;
+  const queue = [first];
+  tab.mpvPlayChecking = queue;
+  tab.mpvPlayPendingUntil = 0;
+  Tabs.saveTabState(tab);
+  try {
+    while (queue.length > 0) {
+      const candidate = /** @type {typeof first} */ (queue.shift());
+      // Its length, being read since it was detected (onSourceRecieved's probe).
+      await Lengths.settle(() => [candidate], SourceLengthWaitMs);
+      // A new page, a reload or MPV started again drop the play (and this queue).
+      if (tab.mpvPlayChecking !== queue || tab.url !== url) {
+        return;
+      }
+      // Its frame went on to another page meanwhile, or its length is another video's.
+      if (candidate.frame.documentKey !== candidate.document ||
+          StreamPick.conflicts(tab.mpvPlayedVideo, Lengths.lengthOf(candidate.url))) {
+        continue;
+      }
+      if (tab.isOn && tab.isMpv && tab.mpvOnPlay) {
+        sendPlayedToMpv(tab, candidate);
+      }
+      return;
+    }
+    // Each was another video's: the next one may be the video's, while the wait lasts.
+    tab.mpvPlayPendingUntil = until;
+    Tabs.saveTabState(tab);
+  } finally {
+    if (tab.mpvPlayChecking === queue) {
+      tab.mpvPlayChecking = null;
+    }
   }
 }
 
@@ -2274,6 +2449,7 @@ function sendPlayedToMpv(tab, source) {
   }
 
   tab.mpvLastPlaySend = {url: source.url, time: now};
+  Tabs.saveTabState(tab);
   tabTitle(tab.tabId).then((title) =>
     Mpv.openStream(source.url, null, source.headers, resolveMpvContentType(null, tab.url), tab.url, title)).then((result) => {
     if (Logging) console.log('[MPV] user play result:', source.url, JSON.stringify(result));
@@ -2283,6 +2459,7 @@ function sendPlayedToMpv(tab, source) {
     } else if (tab.mpvLastPlaySend && tab.mpvLastPlaySend.url === source.url) {
       // The host never launched mpv, so let the next play try again.
       tab.mpvLastPlaySend = null;
+      Tabs.saveTabState(tab);
     }
   }).catch((e) => {
     console.error('Handing the played video to mpv failed', e);
@@ -2368,7 +2545,22 @@ function isHtmlResponse(headers) {
   return type === 'text/html' || type === 'application/xhtml+xml';
 }
 
+/**
+ * Whether a request belongs to no tab: a service worker's, or this background's own
+ * length reads (StreamLengths). No player opens there and nothing goes to mpv from it,
+ * and no tab event ever resets what is kept for it: the holder of tab -1 collected
+ * every stream such requests fetched, for the session, and sent the growing list, with
+ * the requests' headers, to every player tab - from a private window or a container as
+ * well, which it cannot tell.
+ * @param {{tabId: number}} details - webRequest's details.
+ * @return {boolean}
+ */
+function isTablessRequest(details) {
+  return details.tabId === chrome.tabs.TAB_ID_NONE;
+}
+
 chrome.webRequest.onBeforeRequest.addListener((details) => {
+  if (isTablessRequest(details)) return;
   const tab = Tabs.getTabOrCreate(details.tabId);
   const frame = tab.getFrameOrCreate(details.frameId);
   if (!frame.parent && details.parentFrameId !== -1) {
@@ -2380,17 +2572,15 @@ chrome.webRequest.onBeforeRequest.addListener((details) => {
 });
 
 chrome.webRequest.onBeforeSendHeaders.addListener((details) => {
-  const tab = Tabs.getTabOrCreate(details.tabId);
-  const frame = tab.getFrameOrCreate(details.frameId);
-  frame.requestHeaders.set(details.requestId, details.requestHeaders);
+  if (isTablessRequest(details)) return;
+  Tabs.getTabOrCreate(details.tabId).rememberRequestHeaders(details.requestId, details.requestHeaders);
 }, {
   urls: ['<all_urls>'],
 }, webRequestPerms);
 
 chrome.webRequest.onHeadersReceived.addListener(
     (details) => {
-      // This background's own reads (StreamLengths) are no page's stream.
-      if (details.tabId === chrome.tabs.TAB_ID_NONE && details.originUrl?.startsWith(OwnOrigin)) {
+      if (isTablessRequest(details)) {
         return;
       }
       const url = details.url;
@@ -2404,7 +2594,7 @@ chrome.webRequest.onHeadersReceived.addListener(
       const ext = urlType(url);
 
       if (BackgroundUtils.isSubtitles(ext)) {
-        handleSubtitles(url, frame, frame.requestHeaders.get(details.requestId));
+        handleSubtitles(url, frame, tab.requestHeaders.get(details.requestId));
         return;
       }
 
@@ -2415,7 +2605,10 @@ chrome.webRequest.onHeadersReceived.addListener(
       }
       if (!mode) {
         if (details.type === 'media') {
-          mode = PlayerModes.ACCELERATED_MP4;
+          mode = modeFromMediaType(details.responseHeaders);
+          if (!mode) {
+            return;
+          }
         } else if ((details.type === 'main_frame' || details.type === 'sub_frame') &&
             isHtmlResponse(details.responseHeaders)) {
           // A page is not a stream, even when its query string names one: an embed page
@@ -2454,9 +2647,7 @@ chrome.webRequest.onErrorOccurred.addListener(deleteHeaderCache, {
  * @return {undefined}
  */
 function deleteHeaderCache(details) {
-  const tab = Tabs.getTabOrCreate(details.tabId);
-  const frame = tab.getFrameOrCreate(details.frameId);
-  frame.requestHeaders.delete(details.requestId);
+  Tabs.forgetRequestHeaders(details.tabId, details.requestId);
 }
 
 ensureOptions();
diff --git a/chrome/content.js b/chrome/content.js
index 1d897e9c..0c5153b2 100644
--- a/chrome/content.js
+++ b/chrome/content.js
@@ -30,16 +30,19 @@
     REPORT_LOADED_MEDIA: 'REPORT_LOADED_MEDIA',
     LOADED_MEDIA: 'LOADED_MEDIA',
     PLAYER_OPEN_GONE: 'PLAYER_OPEN_GONE',
+    IS_PLAYER_OPENER: 'IS_PLAYER_OPENER',
   };
 
   const iframeMap = new Map();
   const replacedPlayerQueue = [];
   // Players laid over the whole page (a video that fills it), with their pause watchers.
   const overlayPlayers = [];
-  const elementsChangedByFillscreen = [];
+  // What fillScreenIframe changed: each element, with the style attribute it had. A Map,
+  // as each element is looked up in it: an array made a page of 30,000 elements take
+  // seconds on its main thread (an array lookup per element, and a splice per one undone).
+  const elementsChangedByFillscreen = new Map();
   const linkRequests = new Map();
   let MiniplayerCooldown = 0;
-  let Activated = false;
   // Set when this frame is sent to the player (handlePlayerOpen's redirect). The frame is
   // not going away: the player takes it over, and asks the background for the sources
   // detected in it.
@@ -103,6 +106,11 @@
         sendResponse(true);
       }
       return;
+    } else if (request.type === MessageTypes.IS_PLAYER_OPENER) {
+      // Whether a player naming this frame as its parent was opened by this page: only
+      // this content script knows the page's name (background.mjs, PLAYER_LOADED).
+      sendResponse(request.document === DocumentKey);
+      return;
     } else if (request.type === MessageTypes.PING_TAB) {
       sendResponse(MessageTypes.PONG_TAB);
     } else if (request.type === MessageTypes.OPEN_PLAYER) {
@@ -204,6 +212,11 @@
 
         if (oldFrameObj.iframe !== iframeElement) {
           iframeElement.addEventListener('load', frameLoadListener);
+        } else if (!newFrameObj.replacedData) {
+          // The same iframe again: its player loaded anew ("Reload Frame" on it). It still
+          // stands in for the page's element, which only the old entry knew how to give
+          // back: removePlayers left that element hidden, and its media paused, for good.
+          newFrameObj.replacedData = oldFrameObj.replacedData;
         }
       } else {
         iframeElement.addEventListener('load', frameLoadListener);
@@ -212,7 +225,7 @@
       iframeMap.set(request.frameId, newFrameObj);
       checkPendingPlayers();
 
-      updateReplacedPlayers();
+      updateReplacedPlayers(replacedData && replacedData.convertDue ? replacedData : null);
     }
   });
 
@@ -327,14 +340,6 @@
     });
   }
 
-  async function sendToOtherContents(message) {
-    notifyBackground({
-      type: 'SEND_TO_CONTENT',
-      data: message,
-      destination: 'custom',
-    });
-  }
-
   function handleContentMessage(request, sender, sendResponse) {
     const data = request.data;
     if (data.type === 'config') {
@@ -464,6 +469,12 @@
           for (let i = 1; i <= 8; i++) {
             ((i) => {
               setTimeout(() => {
+                // The check for a page element that collapsed (makeSoftIntoHard) sees only
+                // players that linked up. One that has not yet (a slow start) gets it when it
+                // does, in the link handler; it used to get none.
+                if (i == 4 && replacedPlayerQueue.includes(pobj)) {
+                  pobj.convertDue = true;
+                }
                 updateReplacedPlayers(i == 4 ? pobj : null);
               }, i * 250);
             })(i);
@@ -480,13 +491,6 @@
         });
         pobj.resizeObserver.observe(iframe.parentNode);
       }
-      if (!Activated) {
-        Activated = true;
-        sendToOtherContents({
-          type: 'active-state',
-          value: true,
-        });
-      }
     }).catch((e) => {
       // Whatever went wrong, the background hears back: without an answer it kept the
       // frame's player opening, and opened no player there again until a navigation. A
@@ -554,10 +558,17 @@
       miniplayerState.closeObserver = null;
     }
 
-    if ((request.force !== undefined && request.force === miniplayerState.active) || iframeObj.windowedFullscreenState.active || document.fullscreenElement) {
-      updateMiniPlayer(iframeObj);
-    } else {
-      toggleMiniPlayer(iframeObj);
+    try {
+      if ((request.force !== undefined && request.force === miniplayerState.active) || iframeObj.windowedFullscreenState.active || document.fullscreenElement) {
+        updateMiniPlayer(iframeObj);
+      } else {
+        toggleMiniPlayer(iframeObj);
+      }
+    } catch (e) {
+      // Whatever went wrong, the player hears back; a throw here left it unanswered.
+      console.error(e);
+      sendResponse('error');
+      return;
     }
 
     if (miniplayerState.active && request.autoExit) {
@@ -662,30 +673,31 @@
   const ScrapedTrackKinds = ['subtitles', 'captions'];
 
   function handleCaptionsScrape(request, sender, sendResponse) {
-    const trackElements = querySelectorAllIncludingShadows('track');
-    let pending = 0;
+    // Every track is counted before any is asked for: a request that fails at once (a src
+    // XMLHttpRequest refuses) answers inside the loop, and the answer went out then, with
+    // the tracks after it never asked for.
+    const trackElements = querySelectorAllIncludingShadows('track')
+        .filter((track) => track.src && ScrapedTrackKinds.includes(track.kind));
+    const pending = trackElements.length;
     let done = 0;
     const tracks = [];
     for (let i = 0; i < trackElements.length; i++) {
       const track = trackElements[i];
-      if (track.src && ScrapedTrackKinds.includes(track.kind)) {
-        pending++;
-        const source = track.src;
-        httpRequest(source, (err, req, body) => {
-          done++;
-          if (body) {
-            tracks.push({
-              data: body,
-              source: source,
-              label: track.label,
-              language: track.srclang,
-            });
-          }
-          if (done === pending) sendResponse(tracks);
-        });
-      }
+      const source = track.src;
+      httpRequest(source, (err, req, body) => {
+        done++;
+        if (body) {
+          tracks.push({
+            data: body,
+            source: source,
+            label: track.label,
+            language: track.srclang,
+          });
+        }
+        if (done === pending) sendResponse(tracks);
+      });
     }
-    if (done === pending) sendResponse(tracks);
+    if (pending === 0) sendResponse(tracks);
 
     return true;
   }
@@ -717,6 +729,11 @@
     OverlayGuard.releaseAll();
     iframeMap.forEach((iframeObj) => {
       unmakeMiniPlayer(iframeObj);
+      // The iframe's own style too, which only leaving windowed fullscreen gives back: an
+      // embed iframe holding the player stayed fixed over the whole page.
+      if (iframeObj.windowedFullscreenState.active) {
+        windowedFullscreenToggle(iframeObj);
+      }
       if (iframeObj.replacedData) {
         restoreReplaced(iframeObj.replacedData);
         iframeObj.replacedData = null;
@@ -747,14 +764,6 @@
         });
       }
     });
-
-    if (Activated) {
-      Activated = false;
-      sendToOtherContents({
-        type: 'active-state',
-        value: false,
-      });
-    }
   }
 
   /**
@@ -788,7 +797,12 @@
     if (miniplayerState.active) {
       const placeholder = miniplayerState.placeholder;
       const element = miniplayerState.element;
-      const aspectRatio = placeholder.clientWidth / placeholder.clientHeight;
+      // A placeholder without a size (inside a hidden part of the page) has no shape to
+      // keep: the sizes were NaN, or a miniplayer 0 px high.
+      let aspectRatio = placeholder.clientWidth / placeholder.clientHeight;
+      if (!(aspectRatio > 0 && aspectRatio < Infinity)) {
+        aspectRatio = 16 / 9;
+      }
       const newWidth = Math.min(Math.max(window.screen.width, window.screen.height * aspectRatio) * miniplayerState.size, document.body.clientWidth);
       const newHeight = newWidth / aspectRatio;
       element.style.setProperty('width', newWidth + 'px', 'important');
@@ -814,9 +828,18 @@
       return;
     }
 
+    // The page took the player's iframe out (a re-render): there is nothing to shrink, and
+    // the placeholder had no parent to go into.
+    if (!iframeObj.iframe.isConnected) {
+      return;
+    }
+
     miniplayerState.active = true;
 
-    const parentElementsWithSameBounds = getParentElementsWithSameBounds(iframeObj.iframe);
+    // Up to the body, not the body itself: a wrapper that came to fill it made the body the
+    // miniplayer, with a second <body> put in before it as its placeholder.
+    const parentElementsWithSameBounds = getParentElementsWithSameBounds(iframeObj.iframe)
+        .filter((parent) => parent.tagName !== 'BODY');
     const element = parentElementsWithSameBounds.length > 0 ? parentElementsWithSameBounds[parentElementsWithSameBounds.length - 1] : iframeObj.iframe;
     const placeholder = document.createElement(element.tagName);
 
@@ -908,18 +931,13 @@
   }
 
   function undoFillScreenIframe(whitelist) {
-    for (let i = 0; i < elementsChangedByFillscreen.length; i++) {
-      const [element, old] = elementsChangedByFillscreen[i];
-      if (!whitelist || whitelist.includes(element)) {
+    const only = whitelist ? new Set(whitelist) : null;
+    elementsChangedByFillscreen.forEach((old, element) => {
+      if (!only || only.has(element)) {
         element.setAttribute('style', old);
-        elementsChangedByFillscreen.splice(i, 1);
-        i--;
-
-        if (whitelist) {
-          whitelist.splice(whitelist.indexOf(element), 1);
-        }
+        elementsChangedByFillscreen.delete(element);
       }
-    }
+    });
   }
 
   function fillScreenIframe(iframe, skipHide = false) {
@@ -944,7 +962,7 @@
     if (!skipHide) {
       const elementsToHide = [];
       const elementsToExpand = [];
-      const trace = traceParents(iframe);
+      const trace = new Set(traceParents(iframe));
 
       // Gather all elements not parents of the iframe
       const elements = document.querySelectorAll('*');
@@ -962,7 +980,12 @@
           continue;
         }
 
-        if (trace.includes(element)) {
+        // Nothing in the <head> is shown: its <meta>, <script> and <style> are no layers.
+        if (document.head && document.head.contains(element)) {
+          continue;
+        }
+
+        if (trace.has(element)) {
           elementsToExpand.push(element);
         } else {
           elementsToHide.push(element);
@@ -973,13 +996,12 @@
         if (element === iframe) {
           return;
         }
-        const found = elementsChangedByFillscreen.find((e) => e[0] === element);
-        if (found) {
+        if (elementsChangedByFillscreen.has(element)) {
           return;
         }
         const oldstyle = element.getAttribute('style') || '';
         element.style.setProperty('display', 'none', 'important');
-        elementsChangedByFillscreen.push([element, oldstyle]);
+        elementsChangedByFillscreen.set(element, oldstyle);
         addedElements.push(element);
       });
 
@@ -987,13 +1009,12 @@
         if (element === iframe) {
           return;
         }
-        const found = elementsChangedByFillscreen.find((e) => e[0] === element);
-        if (found) {
+        if (elementsChangedByFillscreen.has(element)) {
           return;
         }
         const oldstyle = element.getAttribute('style') || '';
         element.setAttribute('style', expandStyle);
-        elementsChangedByFillscreen.push([element, oldstyle]);
+        elementsChangedByFillscreen.set(element, oldstyle);
         addedElements.push(element);
       });
     }
@@ -1790,12 +1811,39 @@
   // The requests a page's player makes for its stream, as Resource Timing names them.
   const LoadedMediaInitiators = ['xmlhttprequest', 'fetch', 'video', 'audio', 'other'];
 
+  // The page's Resource Timing buffer keeps its first 250 requests, and a streaming page has
+  // made that many (ads, trackers) before its video asks for its manifest: the manifest was
+  // never in it. An observer is told of every request, buffer full or not (Firefox's
+  // Performance::InsertResourceEntry queues each entry to observers first), from this
+  // script's start at document_start. The ones loadedMedia reports are kept here, the
+  // first ObservedMediaLimit of them (a URL once), past the buffer. Nothing the page can
+  // see changes, as it would with setResourceTimingBufferSize.
+  const ObservedMediaLimit = 1000;
+  const observedMedia = new Map();
+  try {
+    new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        if (observedMedia.size >= ObservedMediaLimit) break;
+        if (!LoadedMediaInitiators.includes(entry.initiatorType) || observedMedia.has(entry.name)) continue;
+        observedMedia.set(entry.name, {
+          name: entry.name,
+          initiatorType: entry.initiatorType,
+          responseStatus: entry.responseStatus,
+          startTime: entry.startTime,
+        });
+      }
+    }).observe({type: 'resource', buffered: true});
+  } catch (e) {
+    // No observer: the timeline's own buffer is all there is.
+  }
+
   /**
    * What this page loaded that may be a stream, for a background that did not see it load:
    * Firefox unloads the background after ~30 idle seconds, and the streams it detected with
    * it, while a page asks for its manifest once, when its video starts. The page's own
    * Resource Timing entries keep those requests for as long as it lives (the first 250 of
-   * them), and its videos tell the files they play.
+   * them, and what the observer above kept past those), and its videos tell the files
+   * they play.
    * @return {Array<{url: string, media: boolean, time: number}>} Each URL, whether a media
    *   element loaded it, and when the request started (ms since the epoch).
    */
@@ -1803,10 +1851,14 @@
     const found = [];
     let entries = [];
     try {
-      entries = performance.getEntriesByType('resource');
+      entries = Array.from(performance.getEntriesByType('resource'));
     } catch (e) {
       // No timeline: the videos still tell theirs.
     }
+    const inTimeline = new Set(entries.map((entry) => entry.name));
+    observedMedia.forEach((entry, url) => {
+      if (!inTimeline.has(url)) entries.push(entry);
+    });
     for (const entry of entries) {
       if (!LoadedMediaInitiators.includes(entry.initiatorType)) continue;
       // An error answer is no stream. The status is 0 when the server did not share it.
diff --git a/chrome/custom/bilibili_content.js b/chrome/custom/bilibili_content.js
index a3cfcbef..8151baca 100644
--- a/chrome/custom/bilibili_content.js
+++ b/chrome/custom/bilibili_content.js
@@ -83,6 +83,17 @@ class Bilibili2Dash {
   }
 }
 
+// btoa takes Latin-1 only: a manifest with any other character (a title, an address)
+// threw. This is the manifest's UTF-8, in base64.
+function base64Utf8(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i += 0x2000) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 0x2000));
+  }
+  return btoa(binary);
+}
+
 // look for script tag with "window.__playinfo__"
 const scriptTags = document.querySelectorAll('script');
 for (let i = 0; i < scriptTags.length; i++) {
@@ -90,10 +101,18 @@ for (let i = 0; i < scriptTags.length; i++) {
   if (script.textContent.includes('window.__playinfo__')) {
     const playInfo = script.textContent.match(/window\.__playinfo__\s*=\s*(\{.*\})/);
     if (playInfo) {
-      const playInfoObj = JSON.parse(playInfo[1]);
-      const converter = new Bilibili2Dash();
-      const mpd = converter.playInfoToDash(playInfoObj);
-      const url = `data:application/dash+xml;base64,${btoa(mpd)}`;
+      // Play info of another shape (FLV, data.durl, instead of data.dash), or more code
+      // after it on the line, threw here, uncaught, and nothing was detected.
+      let mpd;
+      try {
+        const playInfoObj = JSON.parse(playInfo[1]);
+        const converter = new Bilibili2Dash();
+        mpd = converter.playInfoToDash(playInfoObj);
+      } catch (e) {
+        console.error('No DASH play info', e);
+        continue;
+      }
+      const url = `data:application/dash+xml;base64,${base64Utf8(mpd)}`;
       chrome.runtime.sendMessage({
         type: 'DETECTED_SOURCE',
         url,
diff --git a/chrome/custom/facebook_content.js b/chrome/custom/facebook_content.js
index 16902d88..7c6c71fa 100644
--- a/chrome/custom/facebook_content.js
+++ b/chrome/custom/facebook_content.js
@@ -23,6 +23,17 @@ function findPropertyRecursive(obj, key, list = [], stack = []) {
   return list;
 }
 
+// btoa takes Latin-1 only: a manifest with any other character (a title, an address)
+// threw. This is the manifest's UTF-8, in base64.
+function base64Utf8(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i += 0x2000) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 0x2000));
+  }
+  return btoa(binary);
+}
+
 // look for script tag with "window.__playinfo__"
 const scriptTags = document.querySelectorAll('script');
 let datas = [];
@@ -50,11 +61,14 @@ datas = datas.filter((data)=>{
   return data.stack.includes('video');
 });
 
-if (datas.length === 0) {
+// The first one with its manifest: one without (playlist) was sent as a source whose
+// manifest was the word "undefined".
+const found = datas.find((data) => typeof data.value?.playlist === 'string' && data.value.playlist);
+if (!found) {
   console.error('No video found');
 } else {
-  const mpd = datas[0].value.playlist;
-  const url = `data:application/dash+xml;base64,${btoa(mpd)}`;
+  const mpd = found.value.playlist;
+  const url = `data:application/dash+xml;base64,${base64Utf8(mpd)}`;
   chrome.runtime.sendMessage({
     type: 'DETECTED_SOURCE',
     url,
@@ -65,6 +79,6 @@ if (datas.length === 0) {
     },
   });
 
-  console.log('Video found', datas[0].value);
+  console.log('Video found', found.value);
 }
 
diff --git a/chrome/custom/instagram_content.js b/chrome/custom/instagram_content.js
index f3a442b3..01eb0b38 100644
--- a/chrome/custom/instagram_content.js
+++ b/chrome/custom/instagram_content.js
@@ -1,3 +1,14 @@
+// btoa takes Latin-1 only: a manifest with any other character (a title, an address)
+// threw. This is the manifest's UTF-8, in base64.
+function base64Utf8(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i += 0x2000) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 0x2000));
+  }
+  return btoa(binary);
+}
+
 // Listen for messages
 window.addEventListener('message', (event) => {
   if (event.origin !== window.location.origin) {
@@ -12,8 +23,13 @@ window.addEventListener('message', (event) => {
   if (event.data?.type === 'fs_source_detected') {
     const value = (event.data?.value || '').toString();
     const ext = (event.data?.ext || '').toString();
+    // What instagram_inject.js posts. Any script in the page can post this too, and a
+    // type other than a DASH manifest was passed on as a source of no type.
+    if (!value || ext !== 'mpd') {
+      return;
+    }
     const mpd = value;
-    const url = `data:application/dash+xml;base64,${btoa(mpd)}`;
+    const url = `data:application/dash+xml;base64,${base64Utf8(mpd)}`;
     chrome.runtime.sendMessage({
       type: 'DETECTED_SOURCE',
       url,
diff --git a/chrome/custom/instagram_inject.js b/chrome/custom/instagram_inject.js
index 763c6b84..fad8040b 100644
--- a/chrome/custom/instagram_inject.js
+++ b/chrome/custom/instagram_inject.js
@@ -57,11 +57,11 @@
       }
 
       // video_dash_manifest
-      // Nothing for a response that is not an object (a JSON number or string).
+      // Nothing for a response that is not an object (a JSON number or string). Most
+      // responses have none, so that is no error: it filled the page's console.
       const objs = findPropertyRecursive(data, 'video_dash_manifest');
 
       if (!objs || objs.length === 0) {
-        console.error('No video_dash_manifest found');
         return;
       }
 
diff --git a/chrome/overlay-guard.js b/chrome/overlay-guard.js
index a6561d7c..f5e5ec5b 100644
--- a/chrome/overlay-guard.js
+++ b/chrome/overlay-guard.js
@@ -11,8 +11,12 @@
 // iframe does. An element counts as the player's when it is painted above the iframe and
 // at least 80% of it lies inside the iframe's box, or it covers half of that box: a bar or
 // a button on the player, or a layer over it, but not a page header that overlaps its top
-// edge. It is hidden with visibility, so it keeps its box and is given back as soon as it
-// no longer covers the player (the page scrolled, the player became the miniplayer).
+// edge. The box is the whole iframe's, on screen or not: measured by its part on screen,
+// a header over a player scrolled mostly out of view covered "half" of it. A site's own
+// dialog (sign-in, cookie consent, settings) is left alone, though it covers the player as
+// an ad layer does: hidden, the user saw no dialog, and clicks went through its backdrop.
+// It is hidden with visibility, so it keeps its box and is given back as soon as it no
+// longer covers the player (the page scrolled, the player became the miniplayer).
 // eslint-disable-next-line no-unused-vars
 const OverlayGuard = (() => {
   // How often a guarded frame looks again: sites add their overlays late (ads keep coming).
@@ -26,17 +30,18 @@ const OverlayGuard = (() => {
     return el.tagName === 'IFRAME' && (el.src || '').startsWith(PLAYER_URL);
   }
 
-  // The part of the iframe that is on screen, and its area.
-  function visibleBox(iframe) {
+  // The iframe's box (full) and the part of it that is on screen (visible), with their areas.
+  function boxesOf(iframe) {
     const r = iframe.getBoundingClientRect();
-    const box = {
+    const full = {left: r.left, top: r.top, right: r.right, bottom: r.bottom, area: r.width * r.height};
+    const visible = {
       left: Math.max(0, r.left),
       top: Math.max(0, r.top),
       right: Math.min(window.innerWidth, r.right),
       bottom: Math.min(window.innerHeight, r.bottom),
     };
-    box.area = Math.max(0, box.right - box.left) * Math.max(0, box.bottom - box.top);
-    return box;
+    visible.area = Math.max(0, visible.right - visible.left) * Math.max(0, visible.bottom - visible.top);
+    return {full, visible};
   }
 
   function overlap(r, box) {
@@ -44,16 +49,26 @@ const OverlayGuard = (() => {
         Math.max(0, Math.min(r.bottom, box.bottom) - Math.max(r.top, box.top));
   }
 
-  function belongsToPlayer(el, box) {
+  function belongsToPlayer(el, full) {
     const r = el.getBoundingClientRect();
     const area = r.width * r.height;
-    const inside = overlap(r, box);
-    return area > 0 && (inside >= 0.8 * area || inside >= 0.5 * box.area);
+    const inside = overlap(r, full);
+    return area > 0 && (inside >= 0.8 * area || inside >= 0.5 * full.area);
+  }
+
+  const DIALOGS = 'dialog[open], [role="dialog"], [role="alertdialog"], [aria-modal="true"]';
+
+  // A site's own dialog, or a layer holding one, or one the user is typing in: by what it
+  // says it is, or by the focus being in it. Geometry cannot tell it from an ad layer.
+  function isSiteDialog(el) {
+    const active = document.activeElement;
+    return el.matches(DIALOGS) || !!el.querySelector(DIALOGS) ||
+        (!!active && active !== document.body && el.contains(active));
   }
 
   // The elements painted over the iframe that belong to the player's area, each the
   // outermost one below the ancestor they share with the iframe.
-  function overlaysOf(iframe, box) {
+  function overlaysOf(iframe, {full, visible: box}) {
     const picks = new Set();
     const players = [...document.querySelectorAll(`iframe[src^="${PLAYER_URL}"]`)];
     // Every element, not only the body's: ad layers are often put straight into <html>.
@@ -77,7 +92,12 @@ const OverlayGuard = (() => {
       let pick = null;
       for (let a = el; a && !a.contains(iframe); a = a.parentElement) {
         if (stack.indexOf(a) > iframeAt) break;
-        if (belongsToPlayer(a, box) && !players.some((player) => a.contains(player))) {
+        // Nothing of a site's dialog goes: not the dialog, nor what holds it.
+        if (isSiteDialog(a)) {
+          pick = null;
+          break;
+        }
+        if (belongsToPlayer(a, full) && !players.some((player) => a.contains(player))) {
           pick = a;
         }
       }
@@ -119,12 +139,14 @@ const OverlayGuard = (() => {
       release(iframe);
       return;
     }
-    const box = visibleBox(iframe);
+    const boxes = boxesOf(iframe);
     for (const el of [...guard.hidden.keys()]) {
-      if (!el.isConnected || box.area === 0 || !belongsToPlayer(el, box)) show(guard, el);
+      if (!el.isConnected || boxes.visible.area === 0 || !belongsToPlayer(el, boxes.full) || isSiteDialog(el)) {
+        show(guard, el);
+      }
     }
-    if (box.area === 0) return;
-    for (const el of overlaysOf(iframe, box)) hide(guard, el);
+    if (boxes.visible.area === 0) return;
+    for (const el of overlaysOf(iframe, boxes)) hide(guard, el);
   }
 
   function release(iframe) {
diff --git a/chrome/player/enums/MessageTypes.mjs b/chrome/player/enums/MessageTypes.mjs
index 9da036f0..c0b04085 100644
--- a/chrome/player/enums/MessageTypes.mjs
+++ b/chrome/player/enums/MessageTypes.mjs
@@ -37,7 +37,6 @@ export const MessageTypes = {
   FRAME_REMOVED: 'FRAME_REMOVED',
   DOWNLOAD: 'DOWNLOAD',
   HANDLE_DOWNLOAD: 'HANDLE_DOWNLOAD',
-  WAIT_UNTIL_MAIN_LOADED: 'WAIT_UNTIL_MAIN_LOADED',
   SEND_TO_CONTENT: 'SEND_TO_CONTENT',
   MESSAGE_FROM_CONTENT: 'MESSAGE_FROM_CONTENT',
   PAUSE_MEDIA: 'PAUSE_MEDIA',
@@ -51,4 +50,5 @@ export const MessageTypes = {
   REPORT_LOADED_MEDIA: 'REPORT_LOADED_MEDIA',
   LOADED_MEDIA: 'LOADED_MEDIA',
   PLAYER_OPEN_GONE: 'PLAYER_OPEN_GONE',
+  IS_PLAYER_OPENER: 'IS_PLAYER_OPENER',
 };
diff --git a/tests/e2e/classic-specs/content-cleanup.e2e.mjs b/tests/e2e/classic-specs/content-cleanup.e2e.mjs
index df35f010..b25c129c 100644
--- a/tests/e2e/classic-specs/content-cleanup.e2e.mjs
+++ b/tests/e2e/classic-specs/content-cleanup.e2e.mjs
@@ -642,6 +642,44 @@ describe('content.js around an in-page player', function() {
     expect(await takeContentErrors()).toEqual([]);
   });
 
+  // "This Frame > Reload Frame" on the player loads its page again in the same frame. The
+  // background had handed the page's video to the first load only, so the reloaded player
+  // sat on its welcome screen; and the page's content script, linking the same iframe
+  // again, no longer knew how to give the page its element back (#288).
+  it('keeps the video, and the page\'s element, over a reload of the player\'s frame', async function() {
+    await openPage('/cleanup');
+    await openPlayer();
+    // What Reload Frame does: the player's page loads again in the same frame.
+    await inPage(() => {
+      window.__playerAnnounced = false;
+      const iframe = window.playerIframe();
+      iframe.src = iframe.src;
+    });
+    await browser.waitUntil(async () => inPage(() => window.__playerAnnounced === true),
+        {timeout: 15000, timeoutMsg: 'the reloaded player never announced itself'});
+    await browser.switchFrame(await browser.$('iframe[src*="player/index.html"]'));
+    let source;
+    try {
+      await browser.waitUntil(async () => {
+        source = await browser.execute(() => window.fastStream?.source?.url || null);
+        return !!source;
+      }, {timeout: 15000, interval: 250, timeoutMsg: 'the reloaded player never got a source'});
+    } finally {
+      await browser.switchFrame(null);
+    }
+    expect(source).toContain('/clip.mp4?main=');
+
+    await inPage(() => window.leave());
+    await browser.waitUntil(async () => !(await hasPlayer()),
+        {timeout: 15000, timeoutMsg: 'leaving the page left the player up'});
+    expect(await inPage(() => ({
+      id: window.wrap.id,
+      width: window.wrap.getBoundingClientRect().width,
+    }))).toEqual({id: 'wrap', width: 640});
+    expect(await playingAfterPlay(['main'])).toEqual({main: true});
+    expect(await takeContentErrors()).toEqual([]);
+  });
+
   it('keeps the player in the box the page\'s #id rule gives its element', async function() {
     await openPage('/cleanup');
     await openPlayer();
diff --git a/tests/e2e/classic-specs/content-overlays.e2e.mjs b/tests/e2e/classic-specs/content-overlays.e2e.mjs
index ef33327f..5a51f727 100644
--- a/tests/e2e/classic-specs/content-overlays.e2e.mjs
+++ b/tests/e2e/classic-specs/content-overlays.e2e.mjs
@@ -95,6 +95,32 @@ const veilPage = (t) => `<!doctype html><title>veil</title>
   window.leave = () => history.pushState({}, '', location.pathname + '/next');
 </script>`;
 
+// A site's own dialog, opened while the player is up: a backdrop over the whole page with
+// the dialog in it, the geometry of an ad layer. It stays (#226). The ad that opens with
+// it, over the player and above the dialog's layer, goes: that shows the guard looked
+// again after the dialog opened.
+const dialogPage = (t) => `<!doctype html><title>dialog</title>
+<style>
+  body { margin: 0; }
+  .stage, .stage video { width: 640px; height: 360px; display: block; }
+  #promo { position: absolute; left: 220px; top: 200px; width: 200px; height: 100px; z-index: 5; background: #c00; }
+  #modal { position: fixed; left: 0; top: 0; width: 100%; height: 100%; z-index: 100; display: none; }
+  #backdrop { position: absolute; left: 0; top: 0; width: 100%; height: 100%; background: rgba(0, 0, 0, 0.5); }
+  #dialog { position: absolute; left: 200px; top: 100px; width: 400px; height: 200px; background: #fff; }
+  #lateAd { position: absolute; left: 20px; top: 20px; width: 120px; height: 60px; z-index: 200; background: #c00; display: none; }
+</style>
+<div class="stage"><video id="main" muted preload="auto" src="/clip.mp4?dialog=${t}"></video></div>
+<div id="promo"></div>
+<div id="modal"><div id="backdrop"></div><div id="dialog" role="dialog" aria-modal="true"><input id="email"></div></div>
+<div id="lateAd"></div>
+<script>
+  window.openDialog = () => {
+    document.getElementById('modal').style.display = 'block';
+    document.getElementById('lateAd').style.display = 'block';
+  };
+  window.leave = () => history.pushState({}, '', location.pathname + '/next');
+</script>`;
+
 // The embedding page: the player's iframe fills it, and its bar lies on top.
 const embeddingPage = (t) => `<!doctype html><title>embedding</title>
 <style>
@@ -270,7 +296,7 @@ describe('A site\'s overlays around an in-page player', function() {
       server.listen(port, '127.0.0.1', () => resolve(server));
     });
     servers = [
-      await serve(SITE_PORT, {'/bar': barPage, '/stage': stagePage, '/veil': veilPage, '/embedding': embeddingPage}),
+      await serve(SITE_PORT, {'/bar': barPage, '/stage': stagePage, '/veil': veilPage, '/dialog': dialogPage, '/embedding': embeddingPage}),
       await serve(EMBED_PORT, {'/embed': embedPage}),
     ];
 
@@ -363,6 +389,21 @@ describe('A site\'s overlays around an in-page player', function() {
     expect(await takeContentErrors()).toEqual([]);
   });
 
+  it('leaves a dialog the site opens over the player alone', async function() {
+    await openPage('/dialog');
+    await clickToolbar();
+    await browser.waitUntil(async () => (await visibilities(['promo'])).promo === 'hidden',
+        {timeout: 15000, timeoutMsg: 'the ad stayed over the player'});
+    await inPage(() => window.openDialog());
+    await browser.waitUntil(async () => (await visibilities(['lateAd'])).lateAd === 'hidden',
+        {timeout: 15000, timeoutMsg: 'the guard never looked again after the dialog opened'});
+    // The whole page's layer with a dialog in it, hidden like an ad layer, left the user
+    // no dialog to see while clicks went through its backdrop.
+    expect(await visibilities(['modal', 'backdrop', 'dialog', 'promo'])).toEqual(
+        {modal: 'visible', backdrop: 'visible', dialog: 'visible', promo: 'hidden'});
+    expect(await takeContentErrors()).toEqual([]);
+  });
+
   it('hides the embedding page\'s bar over a full-page embed while its player is up', async function() {
     await openPage('/embedding', true);
     expect(await visibilities(['bar'])).toEqual({bar: 'visible'});
diff --git a/tests/e2e/classic-specs/mpv-shortcut.e2e.mjs b/tests/e2e/classic-specs/mpv-shortcut.e2e.mjs
index a3b85767..961b8757 100644
--- a/tests/e2e/classic-specs/mpv-shortcut.e2e.mjs
+++ b/tests/e2e/classic-specs/mpv-shortcut.e2e.mjs
@@ -521,12 +521,15 @@ describe('The MPV keyboard shortcut (Ctrl+Shift+U)', function() {
           </script>`);
         return;
       }
-      if (req.url.startsWith('/late')) {
+      if (req.url.startsWith('/late') || req.url.startsWith('/framed')) {
         // A player of a page that is gone: its URL names another page as its opener, as a
-        // player still starting when its page reloaded does. The page's own video loads
-        // only when the test says so, once the player has said it loaded.
+        // player still starting when its page reloaded does. Or (/framed) the player page
+        // framed by the page itself, naming the top frame as its parent and no opener. The
+        // page's own video loads only when the test says so, once the player has said it
+        // loaded.
+        const query = req.url.startsWith('/late') ? 'parent_frame_id=0&opener=gone' : 'parent_frame_id=0';
         res.end(`<!doctype html><title>mpv shortcut test, a late player</title>
-          <iframe id="late" src="${ORIGIN}/player/index.html?parent_frame_id=0&opener=gone"
+          <iframe id="late" src="${ORIGIN}/player/index.html?${query}"
             onload="this.dataset.loaded = 'yes'"></iframe>
           <video id="main" preload="auto" crossorigin="anonymous" style="width: 640px; height: 360px"></video>
           <button id="load">Load</button>
@@ -1139,14 +1142,14 @@ describe('The MPV keyboard shortcut (Ctrl+Shift+U)', function() {
     await expectMode('off', 'pressing Ctrl+Shift+U again');
   });
 
-  // Ctrl+Shift+U with the player just opened reloads the page (startMpv). On Windows CI a
-  // player still starting then said it loaded after the new page had, and counted as the
-  // new page's: the page's streams were dropped as the player's own, and no player opened
-  // on it - mpv got nothing on a play, and Ctrl+Shift+F showed nothing. Here the late
-  // player is one that names a page never in this tab, the state that race left.
-  it('takes a player whose page is gone for no player of the page there now', async function() {
+  /**
+   * Loads a page that frames a player FastStream did not open there (#late), waits until
+   * that player has started, and checks that the page's own video still opens a player.
+   * @param {string} pathname - The page: /late or /framed.
+   */
+  async function expectPagePlayerBesidePlanted(pathname) {
     await browser.switchToWindow(siteHandle);
-    await browser.url(`${SITE}/late`);
+    await browser.url(`${SITE}${pathname}`);
     await expectMode('off', 'the start of this test');
 
     // The late player has said it loaded: it marks its options applied just before.
@@ -1177,11 +1180,27 @@ describe('The MPV keyboard shortcut (Ctrl+Shift+U)', function() {
     await browser.waitUntil(async () => {
       await browser.switchToWindow(siteHandle);
       return await browser.execute(() => Array.from(document.querySelectorAll('iframe'))
-          .some((f) => f.src.includes('player/index.html') && !f.src.includes('opener=gone')));
+          .some((f) => f.src.includes('player/index.html') && f.id !== 'late'));
     }, {timeout: 15000, timeoutMsg: 'no player opened for the page\'s video'});
 
     await clickToolbar();
     await expectMode('off', 'clicking the toolbar button again');
+  }
+
+  // Ctrl+Shift+U with the player just opened reloads the page (startMpv). On Windows CI a
+  // player still starting then said it loaded after the new page had, and counted as the
+  // new page's: the page's streams were dropped as the player's own, and no player opened
+  // on it - mpv got nothing on a play, and Ctrl+Shift+F showed nothing. Here the late
+  // player is one that names a page never in this tab, the state that race left.
+  it('takes a player whose page is gone for no player of the page there now', async function() {
+    await expectPagePlayerBesidePlanted('/late');
+  });
+
+  // The player page is web-accessible, so a page (or an ad's iframe in it) can frame it
+  // and name any frame of the tab as its parent. Taken on trust, the top frame counted as
+  // holding a player: its streams were dropped, and no player opened on it (#225).
+  it('takes the player page a page framed itself for no player of the page', async function() {
+    await expectPagePlayerBesidePlanted('/framed');
   });
 
   // Back brings a page out of Firefox's back-forward cache without loading its video
diff --git a/tests/e2e/classic-specs/toolbar-recover.e2e.mjs b/tests/e2e/classic-specs/toolbar-recover.e2e.mjs
index fdfbc8b6..94408e0e 100644
--- a/tests/e2e/classic-specs/toolbar-recover.e2e.mjs
+++ b/tests/e2e/classic-specs/toolbar-recover.e2e.mjs
@@ -33,6 +33,10 @@ const CORS = {
 };
 
 let siteServer;
+// What the site was asked for, in order.
+const requested = [];
+// A 1x1 GIF, for the busy page's images.
+const PIXEL = Buffer.from('R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7', 'base64');
 
 /**
  * Runs an async function in Firefox's chrome context.
@@ -120,6 +124,7 @@ describe('Switching FastStream on after the page loaded its video', function() {
     const segmentDir = path.join(FIXTURES, 'hls-ts');
     siteServer = http.createServer((req, res) => {
       const {pathname} = new URL(req.url, SITE);
+      requested.push(req.url);
       if (req.method === 'OPTIONS') {
         res.writeHead(204, CORS);
         res.end();
@@ -129,6 +134,26 @@ describe('Switching FastStream on after the page loaded its video', function() {
         res.end(`<!doctype html><title>watching</title>
           <video muted preload="auto" style="width: 640px; height: 360px"></video>
           <script>fetch('/hls/clip.m3u8' + location.search);</script>`);
+      } else if (pathname === '/busy') {
+        // A page laden with ads: 300 images, more than its Resource Timing buffer keeps
+        // (250), before its player fetches the stream.
+        res.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
+        res.end(`<!doctype html><title>watching, among ads</title>
+          <video muted preload="auto" style="width: 640px; height: 360px"></video>
+          <script>
+            const loads = [];
+            for (let i = 0; i < 300; i++) {
+              const img = new Image();
+              loads.push(new Promise((resolve) => {
+                img.onload = img.onerror = resolve;
+              }));
+              img.src = '/px.gif?i=' + i + '&' + location.search.slice(1);
+            }
+            Promise.all(loads).then(() => fetch('/hls/clip.m3u8' + location.search));
+          </script>`);
+      } else if (pathname === '/px.gif') {
+        res.writeHead(200, {'Content-Type': 'image/gif', 'Content-Length': PIXEL.length});
+        res.end(PIXEL);
       } else if (pathname === '/hls/clip.m3u8') {
         res.writeHead(200, {...CORS, 'Content-Type': 'application/vnd.apple.mpegurl'});
         res.end(loopedPlaylist(270, '/hls-ts/'));
@@ -178,4 +203,31 @@ describe('Switching FastStream on after the page loaded its video', function() {
           {timeout: 10000, timeoutMsg: 'the player stayed after FastStream was switched off'});
     });
   }
+
+  // The page's Resource Timing entries keep its first 250 requests, and a page laden with
+  // ads makes that many before its player asks for the stream: the stream was never among
+  // them, and a suspended background found nothing to open (#231). content.js's observer
+  // is told of every request.
+  it('opens the player on the stream of a page that made 300 requests before it, the background suspended since', async function() {
+    const c = Date.now();
+    await browser.url(`${SITE}/busy?c=${c}`);
+    await browser.waitUntil(async () => requested.includes(`/hls/clip.m3u8?c=${c}`),
+        {timeout: 20000, timeoutMsg: 'the page never fetched its stream'});
+    await browser.pause(1500);
+    // The premise: the page's own timeline has no room left for the stream.
+    expect(await browser.execute(() => performance.getEntriesByType('resource')
+        .some((entry) => entry.name.includes('/hls/clip.m3u8')))).toBe(false);
+    expect(await browser.$(PLAYER).isExisting()).toBe(false);
+
+    await suspendBackground();
+    await browser.pause(1000);
+
+    await clickToolbar();
+    const state = await playerSource();
+    expect(state.source).toBe(`${SITE}/hls/clip.m3u8?c=${c}`);
+
+    await clickToolbar();
+    await browser.waitUntil(async () => !(await browser.$(PLAYER).isExisting()),
+        {timeout: 10000, timeoutMsg: 'the player stayed after FastStream was switched off'});
+  });
 });
diff --git a/tests/unit/ManifestTypes.test.mjs b/tests/unit/ManifestTypes.test.mjs
index a58ef726..d9e1e189 100644
--- a/tests/unit/ManifestTypes.test.mjs
+++ b/tests/unit/ManifestTypes.test.mjs
@@ -1,6 +1,6 @@
 import {describe, expect, it} from 'vitest';
 
-import {contentTypeOf, modeFromContentType} from '../../chrome/background/ManifestTypes.mjs';
+import {contentTypeOf, modeFromContentType, modeFromMediaType} from '../../chrome/background/ManifestTypes.mjs';
 import {PlayerModes} from '../../chrome/player/enums/PlayerModes.mjs';
 
 const typed = (value) => [{name: 'Server', value: 'nginx'}, {name: 'Content-Type', value}];
@@ -32,3 +32,26 @@ describe('ManifestTypes', () => {
     expect(modeFromContentType(undefined)).toBeUndefined();
   });
 });
+
+// A file a <video> or <audio> element loaded, with no type in its URL. All of them were
+// taken for MP4 videos: a notification sound went to mpv as an allowlisted page's first
+// stream, and a WebM went to the player's MP4 mode, which reads MP4 only.
+describe('modeFromMediaType', () => {
+  it('takes no audio file for a video', () => {
+    for (const type of ['audio/mpeg', 'audio/ogg', 'audio/mp4', 'Audio/WAV; codecs=1']) {
+      expect(modeFromMediaType(typed(type)), type).toBeNull();
+    }
+  });
+
+  it('plays a WebM or Ogg video as it is', () => {
+    expect(modeFromMediaType(typed('video/webm'))).toBe(PlayerModes.DIRECT);
+    expect(modeFromMediaType(typed('video/ogg'))).toBe(PlayerModes.DIRECT);
+  });
+
+  it('takes anything else for an MP4, as before', () => {
+    for (const type of ['video/mp4', 'application/octet-stream', 'binary/octet-stream', '']) {
+      expect(modeFromMediaType(typed(type)), type).toBe(PlayerModes.ACCELERATED_MP4);
+    }
+    expect(modeFromMediaType(undefined)).toBe(PlayerModes.ACCELERATED_MP4);
+  });
+});
diff --git a/tests/unit/MultiRegexMatcher.test.mjs b/tests/unit/MultiRegexMatcher.test.mjs
index 63bf5951..a9546256 100644
--- a/tests/unit/MultiRegexMatcher.test.mjs
+++ b/tests/unit/MultiRegexMatcher.test.mjs
@@ -126,3 +126,37 @@ describe('flags and empty patterns', () => {
     expect(() => new MultiRegexMatcher().addRegex('', '', 'hls')).toThrow(/Empty regex/);
   });
 });
+
+// A pattern that is valid on its own has to work the same once joined with the others. Two
+// ways it did not: a group of its own named like the joined form's (o0) made compile() throw,
+// so the background kept the patterns from before with no word; and a named group in
+// patterns of two outputs gave no output at all. A backreference meant another group.
+describe('patterns with groups of their own', () => {
+  it('compiles a pattern whose group is named like the matcher\'s own', () => {
+    const m = build([
+      ['\\/live\\/(?<o0>\\d+)', '', 'hls'],
+      ['\\.mpd', '', 'dash'],
+    ]);
+    expect(m.match('https://e.com/live/12')).toBe('hls');
+    expect(m.match('https://e.com/a.mpd')).toBe('dash');
+  });
+
+  it('routes a named group used by patterns of two outputs to each one\'s output', () => {
+    const m = build([
+      ['\\/a\\/(?<id>\\d+)', '', 'hls'],
+      ['\\/b\\/(?<id>\\d+)', '', 'dash'],
+    ]);
+    expect(m.match('https://e.com/a/1')).toBe('hls');
+    expect(m.match('https://e.com/b/2')).toBe('dash');
+  });
+
+  it('matches a pattern with a backreference as it does on its own', () => {
+    const m = build([
+      ['\\.mpd', '', 'dash'],
+      ['\\/(x+)-\\1\\.m3u8', '', 'hls'],
+    ]);
+    expect(m.match('https://e.com/xx-xx.m3u8')).toBe('hls');
+    expect(m.match('https://e.com/x-xx.m3u8')).toBeNull();
+    expect(m.match('https://e.com/a.mpd')).toBe('dash');
+  });
+});
diff --git a/tests/unit/NetRequestRuleManager.test.mjs b/tests/unit/NetRequestRuleManager.test.mjs
index 7c6b7b00..6b6d60a5 100644
--- a/tests/unit/NetRequestRuleManager.test.mjs
+++ b/tests/unit/NetRequestRuleManager.test.mjs
@@ -115,3 +115,76 @@ describe('RuleManager.getInsertionIndex', () => {
     expect(insertionIndex([10], 10)).toBe(-1);
   });
 });
+
+// Both of RuleManager's background promises went unhandled: the clearing of old rules at
+// start, and the removal of expired ones each second. A refused removal also took the rule
+// out of the list, so its id went to the next rule while the browser still held the old
+// one, and that rule was refused as a duplicate.
+describe('RuleManager when the browser refuses', () => {
+  let warn;
+  let refuseRemovals;
+  let removed;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    refuseRemovals = 0;
+    removed = [];
+    globalThis.chrome = {
+      runtime: {getURL: (path) => 'moz-extension://test-uuid' + path},
+      declarativeNetRequest: {
+        getSessionRules: async () => [],
+        updateSessionRules: async (update) => {
+          const ids = update.removeRuleIds || [];
+          if (ids.length > 0) {
+            if (refuseRemovals > 0) {
+              refuseRemovals--;
+              throw new Error('refused');
+            }
+            removed.push(...ids);
+          }
+        },
+      },
+    };
+  });
+
+  afterEach(() => {
+    warn.mockRestore();
+    vi.useRealTimers();
+    delete globalThis.chrome;
+  });
+
+  it('says so when the rules left from before cannot be cleared', async () => {
+    globalThis.chrome.declarativeNetRequest.getSessionRules = async () => {
+      throw new Error('not now');
+    };
+    new RuleManager();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(warn).toHaveBeenCalledWith('Could not clear the header rules left from before', expect.any(Error));
+  });
+
+  it('keeps an expired rule it could not remove, and removes it on the next round', async () => {
+    const manager = new RuleManager();
+    const rule = await manager.addHeaderRule('https://cdn.test/a.m3u8', 7, [{operation: 'set', header: 'referer', value: 'https://site.test/'}]);
+    refuseRemovals = 1;
+    // It expires after 5 s; the round after that is refused.
+    await vi.advanceTimersByTimeAsync(6000);
+    expect(removed).toEqual([]);
+    expect(warn).toHaveBeenCalledWith('Could not remove expired header rules', expect.any(Error));
+    expect(manager.getNextID()).not.toBe(rule.id);
+
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(removed).toEqual([rule.id]);
+    expect(manager.rules).toEqual([]);
+  });
+
+  it('gives a rule up after three refused removals', async () => {
+    const manager = new RuleManager();
+    const rule = await manager.addHeaderRule('https://cdn.test/a.m3u8', 7, [{operation: 'set', header: 'referer', value: 'https://site.test/'}]);
+    refuseRemovals = 100;
+    await vi.advanceTimersByTimeAsync(20000);
+    expect(manager.rules).toEqual([]);
+    expect(manager.isLoopRunning).toBe(false);
+    expect(manager.getNextID()).toBe(rule.id);
+  });
+});
diff --git a/tests/unit/TabTracker.test.mjs b/tests/unit/TabTracker.test.mjs
index 49e04bc4..522f3a5f 100644
--- a/tests/unit/TabTracker.test.mjs
+++ b/tests/unit/TabTracker.test.mjs
@@ -1,10 +1,8 @@
 import {beforeAll, describe, expect, it} from 'vitest';
 
 // FRAME_REMOVED: the page took a frame out. The background forgets it and the frames
-// inside it, gives back their player count, and answers whatever waited for one of them
-// to load - WAIT_UNTIL_MAIN_LOADED - with null, or that caller hangs for good. After
-// Firefox unloaded the idle background, the frame could be one it never knew, and the
-// message handler threw on it.
+// inside it, and gives back their player count. After Firefox unloaded the idle
+// background, the frame could be one it never knew, and the message handler threw on it.
 
 let TabTracker;
 
@@ -51,34 +49,6 @@ describe('forgetFrame', () => {
     tab.forgetFrame(player);
     expect(tab.playerCount).toBe(0);
   });
-
-  it('answers everything waiting for those frames to load with null', () => {
-    const {tab, player, inner} = tabWithFrames();
-    const answers = [];
-    player.loadedCallbacks.add((value) => answers.push(['player', value]));
-    inner.loadedCallbacks.add((value) => answers.push(['inner', value]));
-    tab.forgetFrame(player);
-    expect(answers).toEqual([['player', null], ['inner', null]]);
-    expect(player.loadedCallbacks.size).toBe(0);
-    expect(inner.loadedCallbacks.size).toBe(0);
-  });
-
-  it('answers the rest when one waiting caller throws', () => {
-    const {tab, player} = tabWithFrames();
-    const answers = [];
-    player.loadedCallbacks.add(() => {
-      throw new Error('a closed port');
-    });
-    player.loadedCallbacks.add((value) => answers.push(value));
-    const error = console.error;
-    console.error = () => {};
-    try {
-      tab.forgetFrame(player);
-    } finally {
-      console.error = error;
-    }
-    expect(answers).toEqual([null]);
-  });
 });
 
 // PLAYER_LOADED from a player whose page reloaded while it started: Ctrl+Shift+U with the
@@ -144,6 +114,68 @@ describe('isPlayerOfGoneDocument', () => {
   });
 });
 
+// The player page is web-accessible: a page (or an ad's iframe in it) that frames it can
+// put any parent_frame_id in its URL. Taken on trust, the frame it named counted as
+// holding a player, so the background dropped that page's streams and opened no player
+// there until it navigated (#225). The page that opened a player names itself in the
+// player's URL, with a name only its content script knows.
+describe('playerParentProof', () => {
+  /**
+   * A top frame (0) that named itself 'top', and a player frame (5) naming it.
+   * @return {{tab: Object, top: Object, player: Object}}
+   */
+  function topWithPlayer() {
+    const tab = new TabTracker().getTabOrCreate(7);
+    const top = tab.getFrameOrCreate(0);
+    top.documentKey = 'top';
+    const player = tab.getFrameOrCreate(5);
+    return {tab, top, player};
+  }
+
+  it('takes a player the named frame\'s page opened', () => {
+    const {tab, player} = topWithPlayer();
+    expect(tab.playerParentProof(player, 0, 'top')).toBe('proven');
+  });
+
+  it('takes a player a page sent its own frame to', () => {
+    // handlePlayerOpen's redirect: the player loads in the page's own frame.
+    const {tab} = topWithPlayer();
+    const embed = tab.getFrameOrCreate(3);
+    embed.documentKey = 'embed';
+    expect(tab.playerParentProof(embed, 0, 'embed')).toBe('proven');
+  });
+
+  it('refuses a player that names no page that opened it', () => {
+    // A page framing the player page itself: nothing in its URL but the frame it names.
+    const {tab, player} = topWithPlayer();
+    expect(tab.playerParentProof(player, 0, null)).toBe('refused');
+    expect(tab.playerParentProof(player, 0, '')).toBe('refused');
+  });
+
+  it('refuses a player whose opener is not the named frame\'s page', () => {
+    const {tab, player} = topWithPlayer();
+    expect(tab.playerParentProof(player, 0, 'made-up')).toBe('refused');
+  });
+
+  it('refuses a frame id that is no frame id', () => {
+    // parseInt of a made-up parent_frame_id: NaN became a frame of the tab.
+    const {tab, player} = topWithPlayer();
+    for (const id of [NaN, -1, 1.5, '0', null]) {
+      expect(tab.playerParentProof(player, id, 'top'), String(id)).toBe('refused');
+    }
+  });
+
+  it('asks the named frame when its page never named itself here', () => {
+    // The background started again after the page loaded: only the page's content script
+    // knows its name now.
+    const tab = new TabTracker().getTabOrCreate(7);
+    const player = tab.getFrameOrCreate(5);
+    expect(tab.playerParentProof(player, 0, 'top')).toBe('ask');
+    tab.getFrameOrCreate(0);
+    expect(tab.playerParentProof(player, 0, 'top')).toBe('ask');
+  });
+});
+
 /**
  * A tab with a main frame (0) named 'main' holding a frame (1) named 'embed', which
  * detected a stream and a subtitle.
@@ -427,3 +459,140 @@ describe('restoredFromCache', () => {
     expect(main.restoredFromCache).toBe(false);
   });
 });
+
+// "Reload Frame" on the player loads it again in the same frame, and it asks for its
+// sources again; sendSources had taken them out of the page's frames, so it got none and
+// sat on the welcome screen (#288). The page's frame keeps what it handed the player.
+describe('handedTo', () => {
+  /**
+   * A page frame (1) whose player (frame 2) was handed a stream.
+   * @return {{tab: Object, page: Object}}
+   */
+  function pageThatHanded() {
+    const tab = new TabTracker().getTabOrCreate(7);
+    const page = tab.getFrameOrCreate(1);
+    page.noteHandedToPlayer(2, {subtitles: [], sources: [{url: 'https://cdn.example.com/a.m3u8'}], video: null});
+    return {tab, page};
+  }
+
+  it('gives a player in the same frame what the last one there was handed', () => {
+    const {page} = pageThatHanded();
+    expect(page.handedTo(2).sources).toEqual([{url: 'https://cdn.example.com/a.m3u8'}]);
+  });
+
+  it('gives a player in another frame nothing', () => {
+    // A new player is a new iframe, so a new frame: it gets what the page has now.
+    const {page} = pageThatHanded();
+    expect(page.handedTo(3)).toBeNull();
+  });
+
+  it('forgets it when another page comes in the frame', () => {
+    const {page} = pageThatHanded();
+    page.resetSelfAndChildren();
+    expect(page.handedTo(2)).toBeNull();
+  });
+});
+
+// A request's headers wait for its response by request id, which is unique in the session:
+// on the tab, so the page's reset (FRAME_ADDED, a new site) does not lose those of a request
+// still in flight (backgroundDetection.test.mjs drives that through the background).
+describe('request headers', () => {
+  it('outlive the tab\'s resets', () => {
+    const tab = new TabTracker().getTabOrCreate(7);
+    tab.rememberRequestHeaders('r1', [{name: 'Referer', value: 'https://a.test/'}]);
+    tab.getFrameOrCreate(0).resetSelfAndChildren();
+    tab.resetForReload();
+    tab.resetForNewSite('https://b.test/');
+    expect(tab.requestHeaders.get('r1')).toEqual([{name: 'Referer', value: 'https://a.test/'}]);
+  });
+
+  it('go when their response comes', () => {
+    const tracker = new TabTracker();
+    tracker.getTabOrCreate(7).rememberRequestHeaders('r1', []);
+    tracker.forgetRequestHeaders(7, 'r1');
+    expect(tracker.getTab(7).requestHeaders.size).toBe(0);
+  });
+
+  it('do not bring back a closed tab', () => {
+    // A closing tab's requests are cancelled, and the errors can come after tabs.onRemoved.
+    const tracker = new TabTracker();
+    tracker.forgetRequestHeaders(7, 'r1');
+    expect(tracker.getTab(7)).toBeUndefined();
+  });
+
+  it('are kept for the latest 500 requests at most', () => {
+    const tab = new TabTracker().getTabOrCreate(7);
+    for (let i = 0; i < 520; i++) {
+      tab.rememberRequestHeaders('r' + i, []);
+    }
+    expect(tab.requestHeaders.size).toBe(500);
+    expect(tab.requestHeaders.has('r19')).toBe(false);
+    expect(tab.requestHeaders.has('r20')).toBe(true);
+  });
+});
+
+// A page that is never left kept every stream and subtitle file it asked for: an HLS or
+// DASH player's pieces are detected one by one, thousands in an evening, each with its
+// request's headers, sent again to each player tab, and read for their lengths when a
+// player opened. backgroundDetection.test.mjs checks the background keeps them through
+// these methods.
+describe('what a frame keeps of its streams', () => {
+  const manifest = {url: 'https://cdn.test/v/master.m3u8', mode: 'accelerated_hls'};
+  const piece = (n) => ({url: `https://cdn.test/v/seg-${n}.mp4`, mode: 'accelerated_mp4'});
+
+  it('keeps the manifest, the first piece and the newest of one stream\'s pieces', () => {
+    const frame = new TabTracker().getTabOrCreate(7).getFrameOrCreate(0);
+    frame.addSource(manifest);
+    for (let n = 1; n <= 300; n++) {
+      frame.addSource(piece(n));
+    }
+    const urls = frame.getSources().map((s) => s.url);
+    expect(urls).toHaveLength(21);
+    expect(urls[0]).toBe(manifest.url);
+    expect(urls[1]).toBe(piece(1).url);
+    expect(urls.slice(2)).toEqual(Array.from({length: 19}, (_, i) => piece(282 + i).url));
+  });
+
+  it('keeps every file of a shape up to 20', () => {
+    const frame = new TabTracker().getTabOrCreate(7).getFrameOrCreate(0);
+    for (let n = 1; n <= 20; n++) {
+      frame.addSource(piece(n));
+    }
+    expect(frame.getSources()).toHaveLength(20);
+  });
+
+  it('keeps 200 in all, dropping files before manifests', () => {
+    const frame = new TabTracker().getTabOrCreate(7).getFrameOrCreate(0);
+    frame.addSource(manifest);
+    // Names without digits: each its own shape.
+    const name = (n) => n.toString(26).replace(/[0-9]/g, (d) => 'qrstuvwxyz'[d]);
+    for (let n = 0; n < 250; n++) {
+      frame.addSource({url: `https://cdn.test/${name(n)}.mp4`, mode: 'accelerated_mp4'});
+    }
+    const urls = frame.getSources().map((s) => s.url);
+    expect(urls).toHaveLength(200);
+    expect(urls[0]).toBe(manifest.url);
+    expect(urls[199]).toBe(`https://cdn.test/${name(249)}.mp4`);
+  });
+
+  it('drops the oldest manifest once only manifests are left', () => {
+    const frame = new TabTracker().getTabOrCreate(7).getFrameOrCreate(0);
+    for (let n = 0; n < 205; n++) {
+      frame.addSource({url: `https://cdn.test/${n}/master.m3u8`, mode: 'accelerated_hls'});
+    }
+    const urls = frame.getSources().map((s) => s.url);
+    expect(urls).toHaveLength(200);
+    expect(urls[0]).toBe('https://cdn.test/5/master.m3u8');
+  });
+
+  it('keeps the first and the newest of a stream\'s subtitle pieces', () => {
+    const frame = new TabTracker().getTabOrCreate(7).getFrameOrCreate(0);
+    for (let n = 1; n <= 50; n++) {
+      frame.addSubtitle({source: `https://cdn.test/v/sub-${n}.vtt`});
+    }
+    const urls = frame.getSubtitles().map((s) => s.source);
+    expect(urls).toHaveLength(20);
+    expect(urls[0]).toBe('https://cdn.test/v/sub-1.vtt');
+    expect(urls[19]).toBe('https://cdn.test/v/sub-50.vtt');
+  });
+});
diff --git a/tests/unit/backgroundDetection.test.mjs b/tests/unit/backgroundDetection.test.mjs
new file mode 100644
index 00000000..358b1a65
--- /dev/null
+++ b/tests/unit/backgroundDetection.test.mjs
@@ -0,0 +1,140 @@
+import {afterEach, describe, expect, it} from 'vitest';
+
+import {loadBackground} from './backgroundHarness.mjs';
+
+// What the background detects from a page's requests (onBeforeSendHeaders, then
+// onHeadersReceived), and what it keeps of it, driven through its real listeners.
+
+const PAGE = 'https://site.test/watch/1';
+const PLAYER = 'moz-extension://bg-test/player/index.html';
+// A player in the page's frame names the page that opened it (content.js adds ?opener=),
+// or the background takes no parent frame from it (#225).
+const PLAYER_IN_PAGE = PLAYER + '?opener=page-1';
+
+let bg;
+
+afterEach(() => {
+  bg?.unload();
+  bg = null;
+});
+
+/**
+ * A player that opened in frame 5, inside the page's frame 0, asks for the page's streams.
+ * @return {Promise<Array<Object>>} The sources the background sent it.
+ */
+async function sourcesForPlayer() {
+  await bg.message({type: 'PLAYER_LOADED', url: PLAYER_IN_PAGE, parentFrameId: 0}, {tabId: 1, frameId: 5});
+  bg.sentToTabs.length = 0;
+  await bg.message({type: 'REQUEST_SOURCES'}, {tabId: 1, frameId: 5});
+  await bg.wait(3000);
+  const sent = bg.sent('SOURCES').filter((m) => m.frameId === 5);
+  expect(sent).toHaveLength(1);
+  return sent[0].message.sources;
+}
+
+// A player opened in a tab of its own lists the streams the other tabs' pages asked for
+// (sendSourcesToMainFramePlayers), with their requests' headers.
+describe('the streams a player tab lists from other tabs', () => {
+  /**
+   * Opens the player page in a tab of its own.
+   * @param {number} tabId - The tab.
+   * @return {Promise<void>}
+   */
+  async function openPlayerTab(tabId) {
+    await bg.navigated(tabId, PLAYER);
+    await bg.message({type: 'PLAYER_LOADED', url: PLAYER}, {tabId, frameId: 0});
+    bg.sentToTabs.length = 0;
+  }
+
+  /**
+   * The streams a player tab was sent from elsewhere.
+   * @param {number} tabId - The player's tab.
+   * @return {Array<string>} Their URLs, from the latest list it got.
+   */
+  function listed(tabId) {
+    const lists = bg.sent('SOURCES').filter((m) => m.tabId === tabId && m.message.autoSetSource === false);
+    return lists.length ? lists[lists.length - 1].message.sources.map((s) => s.url) : [];
+  }
+
+  it('include a stream a page in another tab asked for', async () => {
+    bg = await loadBackground({tabs: [{id: 1, url: PAGE}, {id: 2, url: PLAYER}]});
+    await openPlayerTab(2);
+    await bg.request({tabId: 1, url: 'https://cdn.test/v/master.m3u8'});
+    expect(listed(2)).toEqual(['https://cdn.test/v/master.m3u8']);
+  });
+
+  it('leave out what was fetched outside any tab', async () => {
+    // A service worker's requests have no tab (-1). Nothing ever reset what was kept for
+    // them, and every player tab got the growing list, from a private window too.
+    bg = await loadBackground({tabs: [{id: 2, url: PLAYER}]});
+    await openPlayerTab(2);
+    await bg.request({tabId: -1, url: 'https://cdn.test/sw/master.m3u8'});
+    expect(listed(2)).toEqual([]);
+  });
+
+  it('stay on their side of private browsing', async () => {
+    bg = await loadBackground({tabs: [
+      {id: 1, url: PAGE, incognito: true},
+      {id: 2, url: PLAYER, incognito: false},
+      {id: 3, url: PLAYER, incognito: true},
+    ]});
+    await openPlayerTab(2);
+    await openPlayerTab(3);
+    await bg.request({tabId: 1, url: 'https://cdn.test/private/master.m3u8'});
+    expect(listed(2)).toEqual([]);
+    expect(listed(3)).toEqual(['https://cdn.test/private/master.m3u8']);
+  });
+});
+
+describe('a page that is never left', () => {
+  it('keeps its manifest and a bounded number of its stream\'s pieces', async () => {
+    // Shaka Packager names a DASH stream's pieces .mp4 and its subtitle pieces .vtt: each
+    // is a source or a subtitle of its own (source-length.e2e.mjs), thousands in an evening.
+    bg = await loadBackground({tabs: [{id: 1, url: PAGE}]});
+    await bg.frameAdded(1, 0, PAGE, 'page-1');
+    await bg.request({tabId: 1, url: 'https://cdn.test/v/manifest.mpd'});
+    for (let n = 1; n <= 60; n++) {
+      await bg.request({tabId: 1, url: `https://cdn.test/v/video-${n}.mp4`});
+      await bg.request({tabId: 1, url: `https://cdn.test/v/text-${n}.vtt`});
+    }
+    await bg.message({type: 'PLAYER_LOADED', url: PLAYER_IN_PAGE, parentFrameId: 0}, {tabId: 1, frameId: 5});
+    bg.sentToTabs.length = 0;
+    await bg.message({type: 'REQUEST_SOURCES'}, {tabId: 1, frameId: 5});
+    await bg.wait(3000);
+    const {sources, subtitles} = bg.sent('SOURCES').find((m) => m.frameId === 5).message;
+    expect(sources.map((s) => s.url)).toEqual([
+      'https://cdn.test/v/manifest.mpd',
+      'https://cdn.test/v/video-1.mp4',
+      ...Array.from({length: 19}, (_, i) => `https://cdn.test/v/video-${42 + i}.mp4`),
+    ]);
+    expect(subtitles).toHaveLength(20);
+  });
+});
+
+describe('request headers', () => {
+  it('keeps those of a request the page sent before it named itself', async () => {
+    // A preload (Link: rel=preload, 103 Early Hints) goes out before the content script
+    // runs, and its response can come after the page's FRAME_ADDED. The headers the CDN
+    // checks (Referer) went with the page's reset, and the player's requests got a 403.
+    bg = await loadBackground({tabs: [{id: 1, url: PAGE}]});
+    const manifest = bg.requestSent({tabId: 1, url: 'https://cdn.test/v/master.m3u8'});
+    await bg.frameAdded(1, 0, PAGE, 'page-1');
+    await bg.responded(manifest);
+
+    const sources = await sourcesForPlayer();
+    expect(sources.map((s) => s.url)).toEqual(['https://cdn.test/v/master.m3u8']);
+    expect(sources[0].headers).toEqual([{name: 'Referer', value: 'https://site.test/'}]);
+  });
+
+  it('keeps them across the reset when the tab goes to another site', async () => {
+    bg = await loadBackground({tabs: [{id: 1, url: 'https://old.test/'}]});
+    await bg.navigated(1, 'https://old.test/');
+    const manifest = bg.requestSent({tabId: 1, url: 'https://cdn.test/v/master.m3u8'});
+    await bg.navigated(1, PAGE);
+    await bg.frameAdded(1, 0, PAGE, 'page-1');
+    await bg.responded(manifest);
+
+    const sources = await sourcesForPlayer();
+    expect(sources[0].headers).toEqual([{name: 'Referer', value: 'https://site.test/'}]);
+  });
+});
diff --git a/tests/unit/backgroundHarness.mjs b/tests/unit/backgroundHarness.mjs
new file mode 100644
index 00000000..07788ad7
--- /dev/null
+++ b/tests/unit/backgroundHarness.mjs
@@ -0,0 +1,406 @@
+import {vi} from 'vitest';
+
+// Runs chrome/background/background.mjs in Node against a stand-in for the WebExtension
+// API, for what its listeners do together: a page's request, the page naming itself, a
+// toolbar click, a play. The pure helpers have their own tests; these cover the order of
+// events between them, which no single function shows. Firefox itself is the e2e suites'.
+//
+// Each load is a fresh background (vi.resetModules), with fake timers: a test moves time
+// itself (bg.wait), and nothing left over from a load fires in the next test.
+
+/**
+ * An event a listener can be added to.
+ * @return {{addListener: function(Function): void, listeners: Array<Function>}}
+ */
+function event() {
+  const listeners = [];
+  return {
+    addListener: (fn) => listeners.push(fn),
+    removeListener: (fn) => {
+      const i = listeners.indexOf(fn);
+      if (i !== -1) listeners.splice(i, 1);
+    },
+    hasListener: (fn) => listeners.includes(fn),
+    listeners,
+  };
+}
+
+/**
+ * A response for the background's own reads of a stream's length (StreamLengths), which
+ * reads a body through arrayBuffer() when it has no stream.
+ * @param {string|Uint8Array} body - What the server sends.
+ * @param {number} [status] - Its status.
+ * @return {Object} A stand-in for fetch()'s Response.
+ */
+export function response(body, status = 200) {
+  const bytes = typeof body === 'string' ? new TextEncoder().encode(body) : body;
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    url: '',
+    body: null,
+    arrayBuffer: async () => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
+  };
+}
+
+/**
+ * An HLS media playlist that plays for the given seconds, in 10 s segments.
+ * @param {number} seconds - Its length.
+ * @return {string} The playlist.
+ */
+export function hlsPlaylist(seconds) {
+  const lines = ['#EXTM3U', '#EXT-X-TARGETDURATION:10', '#EXT-X-VERSION:3'];
+  for (let left = seconds; left > 0; left -= 10) {
+    lines.push(`#EXTINF:${Math.min(10, left)}.0,`, `seg-${left}.ts`);
+  }
+  lines.push('#EXT-X-ENDLIST');
+  return lines.join('\n');
+}
+
+let requestCounter = 0;
+
+/**
+ * Loads a fresh background.
+ * @param {Object} [setup]
+ * @param {Object} [setup.options] - The saved options (over the defaults).
+ * @param {Array<Object>} [setup.tabs] - What tabs.query answers: {id, url, incognito, ...}.
+ * @param {Object} [setup.session] - storage.session as the last background left it.
+ * @param {function(string): (Object|Promise<Object>)} [setup.fetch] - The network, for
+ *   the background's own reads; a 404 for everything by default.
+ * @param {function({tabId: number, frameId: (number|undefined), message: Object}): *} [setup.onTabMessage] -
+ *   A page's answer to a message the background sends it (tabs.sendMessage).
+ * @param {function(Object): *} [setup.onNative] - The mpv host's answer; {ok: true} by default.
+ * @param {function(): void} [setup.beforeImport] - Runs once the stand-in is in place,
+ *   before the background loads: to make an API fail from the start.
+ * @return {Promise<Object>} The background's handle.
+ */
+export async function loadBackground({
+  options = {},
+  tabs = [],
+  session = {},
+  fetch = async () => response('', 404),
+  onTabMessage = () => undefined,
+  onNative = () => ({ok: true}),
+  beforeImport = () => {},
+} = {}) {
+  vi.useFakeTimers();
+  vi.resetModules();
+
+  const bg = {
+    options: {...options},
+    tabs,
+    session,
+    sentToTabs: [],
+    native: [],
+    badges: new Map(),
+    titles: new Map(),
+    dynamicRules: [],
+    sessionRuleUpdates: [],
+    reloaded: [],
+    removedTabs: [],
+    createdTabs: [],
+    callbackErrors: [],
+  };
+
+  const onMessage = event();
+  const webRequest = {
+    onBeforeRequest: event(),
+    onBeforeSendHeaders: event(),
+    onHeadersReceived: event(),
+    onErrorOccurred: event(),
+  };
+  const tabEvents = {
+    onRemoved: event(),
+    onCreated: event(),
+    onUpdated: event(),
+  };
+
+  /**
+   * Answers a callback after the caller's own code has run, as the browser does.
+   * @param {Function|undefined} callback - The callback, if any.
+   * @param {*} value - What it gets, or a promise of it.
+   * @return {Promise<*>} The value.
+   */
+  const answer = (callback, value) => Promise.resolve(value).then((resolved) => {
+    if (typeof callback === 'function') {
+      try {
+        callback(resolved);
+      } catch (e) {
+        // The browser reports it on the console; a test can check none was thrown.
+        bg.callbackErrors.push(e);
+      }
+    }
+    return resolved;
+  });
+
+  const chrome = {
+    runtime: {
+      id: 'faststream@test',
+      lastError: undefined,
+      getURL: (file) => 'moz-extension://bg-test/' + file,
+      getManifest: () => ({version: '1.0.0'}),
+      onInstalled: event(),
+      onMessage,
+      sendNativeMessage: (name, message, callback) => {
+        bg.native.push(message);
+        answer(callback, onNative(message));
+      },
+    },
+    extension: {inIncognitoContext: false},
+    management: {getSelf: async () => ({installType: 'normal'})},
+    i18n: {getMessage: () => ''},
+    permissions: {contains: (query, callback) => answer(callback, true)},
+    storage: {
+      local: {
+        get: (key, callback) => answer(callback, {[key]: key === 'options' ? JSON.stringify(bg.options) : undefined}),
+        set: (items, callback) => answer(callback, undefined),
+      },
+      session: {
+        get: async () => structuredClone(session),
+        set: async (items) => {
+          Object.assign(session, structuredClone(items));
+        },
+        remove: async (key) => {
+          delete session[key];
+        },
+      },
+    },
+    action: {
+      onClicked: event(),
+      setBadgeText: ({text, tabId}) => bg.badges.set(tabId, text),
+      setTitle: ({title, tabId}) => bg.titles.set(tabId, title),
+      setIcon: () => {},
+    },
+    commands: {onCommand: event(), getAll: async () => []},
+    tabs: {
+      TAB_ID_NONE: -1,
+      ...tabEvents,
+      query: (query, callback) => answer(callback, bg.tabs.map((t) => ({...t}))),
+      get: async (tabId) => ({...(bg.tabs.find((t) => t.id === tabId) || {id: tabId})}),
+      sendMessage: (tabId, message, ...rest) => {
+        const callback = typeof rest[rest.length - 1] === 'function' ? rest.pop() : undefined;
+        const frameId = rest[0] && typeof rest[0].frameId === 'number' ? rest[0].frameId : undefined;
+        bg.sentToTabs.push({tabId, frameId, message});
+        return answer(callback, onTabMessage({tabId, frameId, message}));
+      },
+      reload: (tabId) => {
+        bg.reloaded.push(tabId);
+      },
+      update: (tabId, props, callback) => answer(callback, {id: tabId, ...props}),
+      create: (props, callback) => {
+        const tab = {id: 1000 + bg.createdTabs.length, ...props};
+        bg.createdTabs.push(tab);
+        return answer(callback, tab);
+      },
+      remove: async (tabId) => {
+        bg.removedTabs.push(tabId);
+      },
+    },
+    webRequest,
+    declarativeNetRequest: {
+      updateDynamicRules: async (update) => {
+        bg.dynamicRules.push(update);
+      },
+      updateSessionRules: async (update) => {
+        bg.sessionRuleUpdates.push(update);
+      },
+      getSessionRules: async () => [],
+    },
+    downloads: {download: async () => 1},
+  };
+
+  globalThis.chrome = chrome;
+  bg.chrome = chrome;
+  const realFetch = globalThis.fetch;
+  globalThis.fetch = async (url, init) => fetch(String(url), init);
+  beforeImport(chrome);
+
+  const log = console.log;
+  console.log = () => {};
+  try {
+    await import('../../chrome/background/background.mjs');
+    await settle();
+  } finally {
+    console.log = log;
+  }
+
+  /**
+   * Lets the background's pending work run: promises, and timers due by then.
+   * @param {number} [ms] - How far to move the clock.
+   * @return {Promise<void>}
+   */
+  async function settle(ms = 0) {
+    await vi.advanceTimersByTimeAsync(ms);
+    for (let i = 0; i < 50; i++) {
+      await Promise.resolve();
+    }
+    await vi.advanceTimersByTimeAsync(0);
+  }
+  bg.wait = settle;
+
+  /**
+   * Sends the background a message from a page.
+   * @param {Object} message - The message.
+   * @param {{tabId?: number, frameId?: number, url?: string, tab?: Object}} [from] - Its sender.
+   * @return {Promise<*>} The background's answer, once given (undefined for none).
+   */
+  bg.message = async (message, {tabId = 1, frameId = 0, url, tab} = {}) => {
+    const sender = {
+      tab: tab || {id: tabId, url: (bg.tabs.find((t) => t.id === tabId) || {}).url},
+      frameId,
+      url,
+    };
+    let reply;
+    const answered = new Promise((resolve) => {
+      reply = resolve;
+    });
+    let async = false;
+    for (const listener of onMessage.listeners) {
+      if (listener(message, sender, reply) === true) {
+        async = true;
+      }
+    }
+    if (!async) {
+      reply(undefined);
+    }
+    const result = await answered;
+    await settle();
+    return result;
+  };
+
+  /**
+   * A page names itself in a frame, as content.js does as it starts (FRAME_ADDED).
+   * @param {number} tabId - The tab.
+   * @param {number} frameId - The frame.
+   * @param {string} url - The page.
+   * @param {string} document - Its name.
+   * @return {Promise<*>}
+   */
+  bg.frameAdded = (tabId, frameId, url, document) =>
+    bg.message({type: 'FRAME_ADDED', url, document}, {tabId, frameId});
+
+  /**
+   * A request a page sends, up to the moment its headers are sent.
+   * @param {Object} details - webRequest's details; requestId is made up when missing.
+   * @return {Object} The details, for the response to the same request.
+   */
+  bg.requestSent = (details) => {
+    const full = {
+      requestId: String(++requestCounter),
+      frameId: 0,
+      parentFrameId: -1,
+      type: 'xmlhttprequest',
+      requestHeaders: [{name: 'Referer', value: 'https://site.test/'}],
+      ...details,
+    };
+    for (const listener of webRequest.onBeforeRequest.listeners) listener(full);
+    for (const listener of webRequest.onBeforeSendHeaders.listeners) listener(full);
+    return full;
+  };
+
+  /**
+   * The response to a request: its headers arrive.
+   * @param {Object} details - The request's details (bg.requestSent).
+   * @param {Object} [extra] - statusCode, responseHeaders.
+   * @return {Promise<void>}
+   */
+  bg.responded = async (details, extra = {}) => {
+    const full = {statusCode: 200, responseHeaders: [], ...details, ...extra};
+    for (const listener of webRequest.onHeadersReceived.listeners) listener(full);
+    await settle();
+  };
+
+  /**
+   * A request that fails, or is cancelled, before its response.
+   * @param {Object} details - The request's details (bg.requestSent).
+   * @return {Promise<void>}
+   */
+  bg.failed = async (details) => {
+    for (const listener of webRequest.onErrorOccurred.listeners) listener({...details, error: 'NS_BINDING_ABORTED'});
+    await settle();
+  };
+
+  /**
+   * A whole request: sent, then answered.
+   * @param {Object} details - webRequest's details.
+   * @param {Object} [extra] - statusCode, responseHeaders.
+   * @return {Promise<Object>} The details.
+   */
+  bg.request = async (details, extra) => {
+    const sent = bg.requestSent(details);
+    await bg.responded(sent, extra);
+    return sent;
+  };
+
+  /**
+   * The tab's address changes (tabs.onUpdated with a url).
+   * @param {number} tabId - The tab.
+   * @param {string} url - Its new address.
+   * @return {Promise<void>}
+   */
+  bg.navigated = async (tabId, url) => {
+    const tab = bg.tabs.find((t) => t.id === tabId);
+    if (tab) tab.url = url;
+    for (const listener of tabEvents.onUpdated.listeners) listener(tabId, {url}, {id: tabId, url});
+    await settle();
+  };
+
+  /**
+   * The tab is closed.
+   * @param {number} tabId - The tab.
+   * @return {Promise<void>}
+   */
+  bg.closed = async (tabId) => {
+    bg.tabs = bg.tabs.filter((t) => t.id !== tabId);
+    for (const listener of tabEvents.onRemoved.listeners) listener(tabId, {});
+    await settle();
+  };
+
+  /**
+   * The toolbar button is clicked in a tab.
+   * @param {number} tabId - The tab.
+   * @return {Promise<void>}
+   */
+  bg.click = async (tabId) => {
+    const tab = bg.tabs.find((t) => t.id === tabId) || {id: tabId};
+    for (const listener of chrome.action.onClicked.listeners) listener({...tab});
+    await settle();
+  };
+
+  /**
+   * A keyboard shortcut is pressed in a tab (commands.onCommand).
+   * @param {string} command - toggle_player or toggle_mpv.
+   * @param {number} tabId - The tab.
+   * @return {Promise<void>}
+   */
+  bg.command = async (command, tabId) => {
+    const tab = bg.tabs.find((t) => t.id === tabId) || {id: tabId};
+    for (const listener of chrome.commands.onCommand.listeners) listener(command, {...tab});
+    await settle();
+  };
+
+  /**
+   * The messages the background sent to tabs, of one type.
+   * @param {string} type - The message type.
+   * @return {Array<{tabId: number, frameId: (number|undefined), message: Object}>}
+   */
+  bg.sent = (type) => bg.sentToTabs.filter((m) => m.message.type === type);
+
+  /**
+   * The URLs the background handed to mpv.
+   * @return {Array<string>}
+   */
+  bg.toMpv = () => bg.native.filter((m) => m.type === 'open').map((m) => m.url);
+
+  /**
+   * Puts the real timers and network back.
+   */
+  bg.unload = () => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    globalThis.fetch = realFetch;
+    delete globalThis.chrome;
+  };
+
+  return bg;
+}
diff --git a/tests/unit/backgroundMpv.test.mjs b/tests/unit/backgroundMpv.test.mjs
new file mode 100644
index 00000000..4d962a6b
--- /dev/null
+++ b/tests/unit/backgroundMpv.test.mjs
@@ -0,0 +1,374 @@
+import {afterEach, describe, expect, it, vi} from 'vitest';
+
+import {hlsPlaylist, loadBackground, response} from './backgroundHarness.mjs';
+
+// MPV mode through the background's real listeners: the shortcut's MPV (only a video the
+// user starts goes to mpv), the allowlist's (a page's first stream goes by itself), and
+// what of it outlives the event page.
+
+const PAGE = 'https://site.test/watch/1';
+const AD = 'https://cdn.test/ad/master.m3u8';
+const EPISODE = 'https://cdn.test/episode/master.m3u8';
+
+let bg;
+
+afterEach(() => {
+  bg?.unload();
+  bg = null;
+  vi.restoreAllMocks();
+});
+
+/**
+ * The network: each playlist with its length, answered after a delay.
+ * @param {Object<string, number>} lengths - Seconds by URL.
+ * @param {number} [delayMs] - How long each answer takes.
+ * @return {function(string): Promise<Object>} fetch() for loadBackground.
+ */
+function playlists(lengths, delayMs = 300) {
+  return (url) => new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(url in lengths ? response(hlsPlaylist(lengths[url])) : response('', 404));
+    }, delayMs);
+  });
+}
+
+/**
+ * Turns on the shortcut's MPV in tab 1, and has the user start a video there that plays
+ * for the given time, whose stream the page has not asked for yet (an MSE player's blob:).
+ * @param {number} duration - The video's length.
+ * @return {Promise<void>}
+ */
+async function playWithShortcutMpv(duration) {
+  await bg.command('toggle_mpv', 1);
+  expect(bg.session['tabState:1']).toMatchObject({isOn: true, isMpv: true, mpvOnPlay: true});
+  await bg.message({type: 'MPV_USER_PLAY', src: 'blob:https://site.test/1', video: {src: 'blob:https://site.test/1', duration}},
+      {tabId: 1, frameId: 0});
+}
+
+describe('the shortcut\'s MPV, a play before its stream', () => {
+  it('sends the video\'s stream when an ad\'s came first and the video\'s while it was read', async () => {
+    // The ad's manifest took the play's slot while its length was read; the episode's,
+    // 200 ms later, found the slot taken and was only tracked. The ad was another video's
+    // length, the slot came back, and nothing looked at the episode again.
+    bg = await loadBackground({
+      options: {mpvMode: true},
+      tabs: [{id: 1, url: PAGE}],
+      fetch: playlists({[AD]: 30, [EPISODE]: 1400}),
+    });
+    await playWithShortcutMpv(1400);
+    await bg.request({tabId: 1, url: AD});
+    await bg.wait(200);
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.wait(3000);
+    expect(bg.toMpv()).toEqual([EPISODE]);
+  });
+
+  it('sends the first stream that can be the video, and only that one', async () => {
+    bg = await loadBackground({
+      options: {mpvMode: true},
+      tabs: [{id: 1, url: PAGE}],
+      fetch: playlists({[AD]: 1400, [EPISODE]: 1400}),
+    });
+    await playWithShortcutMpv(1400);
+    await bg.request({tabId: 1, url: AD});
+    await bg.wait(100);
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.wait(3000);
+    expect(bg.toMpv()).toEqual([AD]);
+  });
+
+  it('waits on when none of them can be the video, and takes the next', async () => {
+    const LATER = 'https://cdn.test/later/master.m3u8';
+    bg = await loadBackground({
+      options: {mpvMode: true},
+      tabs: [{id: 1, url: PAGE}],
+      fetch: playlists({[AD]: 30, [EPISODE]: 45, [LATER]: 1400}),
+    });
+    await playWithShortcutMpv(1400);
+    await bg.request({tabId: 1, url: AD});
+    await bg.wait(100);
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.wait(3000);
+    expect(bg.toMpv()).toEqual([]);
+    await bg.request({tabId: 1, url: LATER});
+    await bg.wait(3000);
+    expect(bg.toMpv()).toEqual([LATER]);
+  });
+
+  it('drops what was waiting when the tab goes to another page', async () => {
+    bg = await loadBackground({
+      options: {mpvMode: true},
+      tabs: [{id: 1, url: PAGE}],
+      fetch: playlists({[AD]: 30, [EPISODE]: 1400}),
+    });
+    await playWithShortcutMpv(1400);
+    await bg.request({tabId: 1, url: AD});
+    await bg.wait(100);
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.navigated(1, 'https://site.test/watch/2');
+    await bg.wait(3000);
+    expect(bg.toMpv()).toEqual([]);
+  });
+
+  it('still takes the video\'s stream after the event page restarted', async () => {
+    // Firefox stops an idle background, and a restart for any reason took the waiting
+    // play with it: the stream the player asked for next was only tracked.
+    bg = await loadBackground({
+      options: {mpvMode: true},
+      tabs: [{id: 1, url: PAGE}],
+      fetch: playlists({[EPISODE]: 1400}),
+    });
+    await playWithShortcutMpv(1400);
+    const session = bg.session;
+    bg.unload();
+
+    bg = await loadBackground({options: {mpvMode: true}, tabs: [{id: 1, url: PAGE}], session,
+      fetch: playlists({[EPISODE]: 1400})});
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.wait(3000);
+    expect(bg.toMpv()).toEqual([EPISODE]);
+  });
+
+  it('sends a video once when the player plays it again after a restart', async () => {
+    // A player calls play() twice, or resumes after the page was paused: within 10 s the
+    // same stream only pauses the page again. Forgotten at a restart, it opened a second
+    // mpv window.
+    bg = await loadBackground({
+      options: {mpvMode: true},
+      tabs: [{id: 1, url: PAGE}],
+      fetch: playlists({[EPISODE]: 1400}),
+    });
+    await playWithShortcutMpv(1400);
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.wait(1000);
+    expect(bg.toMpv()).toEqual([EPISODE]);
+    const session = bg.session;
+    bg.unload();
+
+    bg = await loadBackground({options: {mpvMode: true}, tabs: [{id: 1, url: PAGE}], session,
+      fetch: playlists({[EPISODE]: 1400})});
+    await bg.message({type: 'MPV_USER_PLAY', src: 'blob:https://site.test/1', video: {src: 'blob:https://site.test/1', duration: 1400}},
+        {tabId: 1, frameId: 0});
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.wait(1000);
+    expect(bg.toMpv()).toEqual([]);
+    expect(bg.sent('PAUSE_MEDIA')).toHaveLength(1);
+  });
+
+  it('takes the next page\'s play by itself while the last page\'s stream is still read', async () => {
+    bg = await loadBackground({
+      options: {mpvMode: true},
+      tabs: [{id: 1, url: PAGE}],
+      fetch: playlists({[AD]: 30, [EPISODE]: 1400}),
+    });
+    await playWithShortcutMpv(1400);
+    await bg.request({tabId: 1, url: AD});
+    await bg.navigated(1, 'https://site.test/watch/2');
+    await bg.frameAdded(1, 0, 'https://site.test/watch/2', 'page-2');
+    await bg.message({type: 'MPV_USER_PLAY', src: 'blob:https://site.test/2', video: {src: 'blob:https://site.test/2', duration: 1400}},
+        {tabId: 1, frameId: 0});
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.wait(3000);
+    expect(bg.toMpv()).toEqual([EPISODE]);
+  });
+});
+
+describe('the allowlist\'s MPV, a play on a page Back gave back', () => {
+  const A = 'https://site.test/watch/a';
+  const B = 'https://site.test/watch/b';
+  const SA = 'https://cdn.test/a/master.m3u8';
+  const SB = 'https://cdn.test/b/master.m3u8';
+
+  /**
+   * The tab shows page A, then page B, each sending its stream to mpv by itself, and goes
+   * Back to A, which Firefox's back-forward cache gives back without a request.
+   * @return {Promise<void>}
+   */
+  async function backToA() {
+    bg = await loadBackground({
+      options: {mpvMode: true, mpvAllowlist: ['https://site.test/']},
+      tabs: [{id: 1, url: A}],
+    });
+    await bg.navigated(1, A);
+    await bg.frameAdded(1, 0, A, 'page-a');
+    await bg.request({tabId: 1, url: SA});
+    await bg.message({type: 'FRAME_REMOVED', document: 'page-a'}, {tabId: 1, frameId: 0});
+    await bg.navigated(1, B);
+    await bg.frameAdded(1, 0, B, 'page-b');
+    await bg.request({tabId: 1, url: SB});
+    await bg.message({type: 'FRAME_REMOVED', document: 'page-b'}, {tabId: 1, frameId: 0});
+    await bg.navigated(1, A);
+    await bg.frameAdded(1, 0, A, 'page-a');
+    expect(bg.toMpv()).toEqual([SA, SB]);
+    // An MSE player: the video plays a blob:, no URL of the page's streams.
+    await bg.message({type: 'MPV_USER_PLAY', src: 'blob:https://site.test/a', video: {src: 'blob:https://site.test/a', duration: null}},
+        {tabId: 1, frameId: 0});
+  }
+
+  it('sends the page\'s known stream when no other went within 3 s', async () => {
+    await backToA();
+    await bg.wait(3500);
+    expect(bg.toMpv()).toEqual([SA, SB, SA]);
+  });
+
+  it('sends nothing when the tab went to another page within the 3 s', async () => {
+    // The timer was the tab's, not the page's: Back once more within 3 s gave page B back
+    // with its stream, and the play on page A sent B's stream.
+    await backToA();
+    await bg.message({type: 'FRAME_REMOVED', document: 'page-a'}, {tabId: 1, frameId: 0});
+    await bg.navigated(1, B);
+    await bg.frameAdded(1, 0, B, 'page-b');
+    await bg.wait(3500);
+    expect(bg.toMpv()).toEqual([SA, SB]);
+  });
+
+  it('sends nothing when another page came back at the same address within the 3 s', async () => {
+    // Two history entries of one URL: the address tells nothing, the page's name does.
+    await backToA();
+    await bg.message({type: 'FRAME_REMOVED', document: 'page-a'}, {tabId: 1, frameId: 0});
+    await bg.frameAdded(1, 0, A, 'page-b');
+    await bg.wait(3500);
+    expect(bg.toMpv()).toEqual([SA, SB]);
+  });
+});
+
+describe('a same-site link into an allowlisted or auto-enabled path', () => {
+  const HOME = 'https://site.test/';
+  const TRAILER = 'https://cdn.test/home/trailer.mp4';
+
+  /**
+   * The site's home page plays a trailer (a <video src>, detected while the tab is off),
+   * then the user opens an episode, and the address changes before the episode's page
+   * names itself (tabs.onUpdated and FRAME_ADDED come in either order).
+   * @param {Object} options - The saved options.
+   * @return {Promise<void>}
+   */
+  async function homeThenEpisode(options) {
+    bg = await loadBackground({options, tabs: [{id: 1, url: HOME}]});
+    await bg.navigated(1, HOME);
+    await bg.frameAdded(1, 0, HOME, 'home');
+    await bg.request({tabId: 1, url: TRAILER, type: 'media'});
+    expect(bg.session['tabState:1']).toMatchObject({isOn: false});
+    await bg.navigated(1, PAGE);
+    await bg.frameAdded(1, 0, PAGE, 'episode');
+  }
+
+  it('does not send the home page\'s trailer to mpv for the episode', async () => {
+    // The allowlist's MPV started at the address change, and handed off the streams the
+    // tab tracked at that moment: the home page's trailer. The episode's stream then found
+    // the page already handed off, and was only tracked.
+    await homeThenEpisode({mpvMode: true, mpvAllowlist: ['https://site.test/watch']});
+    await bg.wait(1000);
+    expect(bg.toMpv()).toEqual([]);
+    await bg.request({tabId: 1, url: EPISODE});
+    expect(bg.toMpv()).toEqual([EPISODE]);
+  });
+
+  it('does not open the in-page player for the home page\'s trailer', async () => {
+    await homeThenEpisode({autoEnableURLs: ['https://site.test/watch']});
+    await bg.wait(1000);
+    expect(bg.sent('OPEN_PLAYER')).toEqual([]);
+  });
+
+  it('leaves a stream the new page asks for during the wait to its own start, captions first', async () => {
+    // A stream found during the wait opens the player as any detected stream does
+    // (onSourceRecieved): the page's <track> captions are read first, then the player opens
+    // after replaceDelay. The start by address, half a second after the address changed,
+    // opened it straight away from that same stream, and the player got the stream's
+    // detected subtitle files without the page's labels (page-subtitles.e2e).
+    await homeThenEpisode({autoEnableURLs: ['https://site.test/watch']});
+    await bg.wait(100);
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.wait(5000);
+    const types = bg.sentToTabs.map((m) => m.message.type);
+    expect(types.filter((type) => type === 'OPEN_PLAYER')).toHaveLength(1);
+    expect(types.indexOf('SCRAPE_CAPTIONS')).toBeGreaterThan(-1);
+    expect(types.indexOf('SCRAPE_CAPTIONS')).toBeLessThan(types.indexOf('OPEN_PLAYER'));
+  });
+
+  it('drops the start when the address changes again meanwhile, and comes back', async () => {
+    bg = await loadBackground({options: {mpvMode: true, mpvAllowlist: ['https://site.test/watch']},
+      tabs: [{id: 1, url: HOME}]});
+    await bg.navigated(1, HOME);
+    await bg.request({tabId: 1, url: TRAILER, type: 'media'});
+    await bg.navigated(1, PAGE);
+    await bg.navigated(1, 'https://site.test/watch/2');
+    await bg.navigated(1, PAGE);
+    await bg.wait(1000);
+    expect(bg.toMpv()).toEqual([]);
+  });
+
+  it('still hands off a stream a page asked for before it changed its address itself', async () => {
+    // A page that changes its address with history.pushState names no new page: the
+    // streams the tab tracks are that page's.
+    bg = await loadBackground({options: {mpvMode: true, mpvAllowlist: ['https://site.test/watch']},
+      tabs: [{id: 1, url: HOME}]});
+    await bg.navigated(1, HOME);
+    await bg.frameAdded(1, 0, HOME, 'app');
+    await bg.request({tabId: 1, url: EPISODE});
+    await bg.navigated(1, PAGE);
+    await bg.wait(1000);
+    expect(bg.toMpv()).toEqual([EPISODE]);
+  });
+});
+
+describe('the allowlist\'s MPV, a page that plays a sound first', () => {
+  it('sends the video, not the sound', async () => {
+    // Every file a media element loaded was taken for an MP4 video, and the allowlist sends
+    // a page's first stream: a notification sound went to mpv, and the video stayed.
+    bg = await loadBackground({
+      options: {mpvMode: true, mpvAllowlist: ['https://site.test/']},
+      tabs: [{id: 1, url: PAGE}],
+    });
+    await bg.navigated(1, PAGE);
+    await bg.request({tabId: 1, url: 'https://site.test/sounds/ding', type: 'media'},
+        {responseHeaders: [{name: 'Content-Type', value: 'audio/mpeg'}]});
+    await bg.request({tabId: 1, url: EPISODE});
+    expect(bg.toMpv()).toEqual([EPISODE]);
+  });
+});
+
+describe('a failed hand-off', () => {
+  it('keeps the toolbar\'s "!" after the event page restarted', async () => {
+    // The badge is the browser's, but a woken background redraws every tab's button from
+    // what it knows, and it did not know of the failure any more.
+    bg = await loadBackground({
+      options: {mpvMode: true, mpvAllowlist: ['https://site.test/']},
+      tabs: [{id: 1, url: PAGE}],
+      onNative: () => ({ok: false, error: 'mpv executable not found'}),
+    });
+    await bg.navigated(1, PAGE);
+    await bg.request({tabId: 1, url: EPISODE});
+    expect(bg.toMpv()).toEqual([EPISODE]);
+    expect(bg.badges.get(1)).toBe('!');
+    const session = bg.session;
+    bg.unload();
+
+    bg = await loadBackground({options: {mpvMode: true, mpvAllowlist: ['https://site.test/']},
+      tabs: [{id: 1, url: PAGE}], session});
+    expect(bg.badges.get(1)).toBe('!');
+    expect(bg.titles.get(1)).toBe('FastStream - MPV - the stream did not open: mpv executable not found');
+  });
+
+  it('shows no "!" after a restart once a later hand-off worked', async () => {
+    let answer = {ok: false, error: 'mpv executable not found'};
+    bg = await loadBackground({
+      options: {mpvMode: true, mpvAllowlist: ['https://site.test/']},
+      tabs: [{id: 1, url: PAGE}],
+      onNative: () => answer,
+    });
+    await bg.navigated(1, PAGE);
+    await bg.request({tabId: 1, url: AD});
+    expect(bg.badges.get(1)).toBe('!');
+    answer = {ok: true};
+    await bg.request({tabId: 1, url: EPISODE});
+    expect(bg.toMpv()).toEqual([AD, EPISODE]);
+    expect(bg.badges.get(1)).toBe('');
+    const session = bg.session;
+    bg.unload();
+
+    bg = await loadBackground({options: {mpvMode: true, mpvAllowlist: ['https://site.test/']},
+      tabs: [{id: 1, url: PAGE}], session});
+    expect(bg.badges.get(1)).toBe('');
+  });
+});
diff --git a/tests/unit/backgroundRobustness.test.mjs b/tests/unit/backgroundRobustness.test.mjs
new file mode 100644
index 00000000..eae762c3
--- /dev/null
+++ b/tests/unit/backgroundRobustness.test.mjs
@@ -0,0 +1,139 @@
+import {afterEach, describe, expect, it, vi} from 'vitest';
+
+import {loadBackground} from './backgroundHarness.mjs';
+
+// Small defects of the background script (#144), each through its real listeners.
+
+const PAGE = 'https://site.test/watch/1';
+
+let bg;
+
+afterEach(() => {
+  bg?.unload();
+  bg = null;
+  vi.restoreAllMocks();
+});
+
+describe('the options', () => {
+  it('are read again after a load that failed', async () => {
+    // The failed first load was kept: until the event page unloaded, every event acted on
+    // no options at all - MPV mode and both URL lists off.
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    let failures = 1;
+    bg = await loadBackground({
+      options: {mpvMode: true, mpvAllowlist: ['https://site.test/']},
+      tabs: [{id: 1, url: 'about:blank'}],
+      beforeImport: (chrome) => {
+        const get = chrome.storage.local.get;
+        chrome.storage.local.get = (key, callback) => {
+          if (failures-- > 0) {
+            throw new Error('storage is not ready');
+          }
+          return get(key, callback);
+        };
+      },
+    });
+    await bg.navigated(1, PAGE);
+    expect(bg.session['tabState:1']).toMatchObject({isOn: true, isMpv: true});
+  });
+});
+
+describe('a download from a container tab', () => {
+  // A container tab's download goes through a hidden player tab in the same container,
+  // which the background gives 30 s.
+  const container = {id: 1, url: PAGE, cookieStoreId: 'firefox-container-1'};
+
+  /**
+   * Starts a download from the player in the container tab, and has the hidden tab's
+   * player load after the given time.
+   * @param {number} loadedAfterMs - When the hidden tab's player says it loaded.
+   * @return {Promise<Array<*>>} The answers the download got.
+   */
+  async function download(loadedAfterMs) {
+    const answers = [];
+    for (const listener of bg.chrome.runtime.onMessage.listeners) {
+      listener({type: 'DOWNLOAD', url: 'blob:moz-extension://bg-test/1', filename: 'a.mp4'},
+          {tab: container, frameId: 3}, (value) => answers.push(value));
+    }
+    await bg.wait(loadedAfterMs);
+    const hidden = bg.createdTabs[0];
+    expect(hidden.cookieStoreId).toBe('firefox-container-1');
+    for (const listener of bg.chrome.runtime.onMessage.listeners) {
+      listener({type: 'PLAYER_LOADED', url: 'moz-extension://bg-test/player/index.html'},
+          {tab: {id: hidden.id, url: hidden.url}, frameId: 0}, () => {});
+    }
+    return answers;
+  }
+
+  it('gets the player\'s answer, and the hidden tab is closed', async () => {
+    bg = await loadBackground({
+      tabs: [container],
+      onTabMessage: ({message}) => message.type === 'HANDLE_DOWNLOAD' ? 42 : undefined,
+    });
+    const answers = await download(1000);
+    await bg.wait(0);
+    expect(answers).toEqual([42]);
+    expect(bg.removedTabs).toEqual([bg.createdTabs[0].id]);
+    await bg.wait(30000);
+    expect(answers).toEqual([42]);
+  });
+
+  it('is answered once when the player answers after the 30 s ran out', async () => {
+    // The timeout cleared the download while the player saved it, and the player's answer
+    // then threw a TypeError on it.
+    bg = await loadBackground({
+      tabs: [container],
+      onTabMessage: ({message}) => message.type === 'HANDLE_DOWNLOAD' ?
+        new Promise((resolve) => setTimeout(() => resolve(42), 1000)) : undefined,
+    });
+    const answers = await download(29500);
+    await bg.wait(2000);
+    expect(bg.callbackErrors).toEqual([]);
+    expect(answers).toEqual([null]);
+  });
+
+  it('is answered when the player never answers', async () => {
+    bg = await loadBackground({
+      tabs: [container],
+      onTabMessage: ({message}) => message.type === 'HANDLE_DOWNLOAD' ? new Promise(() => {}) : undefined,
+    });
+    const answers = await download(1000);
+    await bg.wait(30000);
+    expect(answers).toEqual([null]);
+    expect(bg.removedTabs).toEqual([bg.createdTabs[0].id]);
+  });
+});
+
+describe('the toolbar\'s On with players for several frames', () => {
+  it('opens the one over the largest video first, also when a frame gives no size', async () => {
+    // A frame without a content script answers nothing: its size was undefined, the sort
+    // compared NaN, and the order came out arbitrary. The first player opened is the one
+    // that plays without a click (isMainPlayer).
+    const sizes = {1: 100, 2: undefined, 3: 300};
+    bg = await loadBackground({
+      tabs: [{id: 1, url: PAGE}],
+      onTabMessage: ({frameId, message}) => message.type === 'GET_VIDEO_SIZE' ? sizes[frameId] : undefined,
+    });
+    for (const frameId of [1, 2, 3]) {
+      await bg.request({tabId: 1, frameId, parentFrameId: 0, url: `https://cdn.test/${frameId}/master.m3u8`});
+    }
+    await bg.click(1);
+    await bg.wait(3000);
+    expect(bg.sent('OPEN_PLAYER').map((m) => m.frameId)).toEqual([3, 1, 2]);
+  });
+});
+
+describe('the "use the player for stream links" redirect', () => {
+  it('takes a link up to its query or fragment, and no other character', async () => {
+    // The rule's `[\?|#]` held a literal `|`: a.mp4|anything was redirected too.
+    bg = await loadBackground({options: {playMP4URLs: true, playStreamURLs: true}});
+    const rules = bg.dynamicRules.flatMap((update) => update.addRules || []);
+    const filter = (id) => new RegExp(rules.find((rule) => rule.id === id).condition.regexFilter);
+    expect(filter(1).test('https://cdn.test/a.mp4')).toBe(true);
+    expect(filter(1).test('https://cdn.test/a.mp4?t=1')).toBe(true);
+    expect(filter(1).test('https://cdn.test/a.mp4#t=1')).toBe(true);
+    expect(filter(1).test('https://cdn.test/a.mp4|t=1')).toBe(false);
+    expect(filter(2).test('https://cdn.test/a.m3u8?x=1')).toBe(true);
+    expect(filter(2).test('https://cdn.test/a.mpd|x')).toBe(false);
+  });
+});
diff --git a/tests/unit/contentDom.mjs b/tests/unit/contentDom.mjs
new file mode 100644
index 00000000..9163c13f
--- /dev/null
+++ b/tests/unit/contentDom.mjs
@@ -0,0 +1,547 @@
+// A small stand-in DOM for the content scripts (content.js, overlay-guard.js), which are
+// classic scripts written for a page: enough of a document, its elements and their inline
+// styles to run their message handlers in Node (vm), with layout given by each test. It
+// is no browser: what it proves is the scripts' own bookkeeping, not how Firefox lays a
+// page out. The e2e suites (tests/e2e/classic-specs) cover that.
+
+import vm from 'node:vm';
+import {webcrypto} from 'node:crypto';
+// The scripts' text, which vitest includes when it loads this module (?raw): read at run
+// time, the code run below was "user-provided" to CodeQL (js/code-injection).
+import overlayGuardSource from '../../chrome/overlay-guard.js?raw';
+import contentSource from '../../chrome/content.js?raw';
+
+const CAMEL_PROPERTIES = ['width', 'height', 'overflow', 'margin', 'contain', 'display', 'position',
+  'zIndex', 'border', 'borderRadius', 'boxShadow', 'transition', 'visibility', 'top', 'left',
+  'right', 'bottom', 'opacity', 'padding'];
+
+/** An element's inline style (CSSStyleDeclaration). */
+export class FakeStyle {
+  constructor(owner) {
+    this.owner = owner;
+    /** @type {Map<string, {value: string, priority: string}>} */
+    this.props = new Map();
+  }
+
+  setProperty(name, value, priority = '') {
+    this.owner.hasStyle = true;
+    if (value === null || value === undefined || value === '') {
+      this.props.delete(name);
+      return;
+    }
+    this.props.set(name, {value: String(value), priority: priority || ''});
+  }
+
+  getPropertyValue(name) {
+    return this.props.has(name) ? this.props.get(name).value : '';
+  }
+
+  getPropertyPriority(name) {
+    return this.props.has(name) ? this.props.get(name).priority : '';
+  }
+
+  removeProperty(name) {
+    const value = this.getPropertyValue(name);
+    this.props.delete(name);
+    return value;
+  }
+
+  get cssText() {
+    return Array.from(this.props, ([name, {value, priority}]) =>
+      `${name}: ${value}${priority ? ' !important' : ''};`).join(' ');
+  }
+
+  set cssText(text) {
+    this.props.clear();
+    for (const part of String(text).split(';')) {
+      const colon = part.indexOf(':');
+      if (colon === -1) continue;
+      const name = part.slice(0, colon).trim();
+      let value = part.slice(colon + 1).trim();
+      let priority = '';
+      if (value.endsWith('!important')) {
+        priority = 'important';
+        value = value.slice(0, -'!important'.length).trim();
+      }
+      if (name && value) this.props.set(name, {value, priority});
+    }
+  }
+}
+
+for (const camel of CAMEL_PROPERTIES) {
+  const name = camel.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase());
+  Object.defineProperty(FakeStyle.prototype, camel, {
+    get() {
+      return this.getPropertyValue(name);
+    },
+    set(value) {
+      this.setProperty(name, value);
+    },
+  });
+}
+
+/**
+ * Whether an element matches a selector: a tag or '*', with an optional [attr],
+ * [attr="value"] or [attr^="value"], or a comma-separated list of those.
+ * @param {FakeElement} el - The element.
+ * @param {string} selector - The selector.
+ * @return {boolean}
+ */
+function matches(el, selector) {
+  return selector.split(',').some((one) => {
+    const simple = /^\s*([a-zA-Z*]+)?(?:\[([a-z-]+)(?:(\^?=)"([^"]*)")?\])?\s*$/.exec(one);
+    if (!simple) throw new Error('contentDom: unsupported selector ' + one);
+    const [, tag, attr, operator, value] = simple;
+    if (tag && tag !== '*' && el.tagName !== tag.toUpperCase()) return false;
+    if (attr) {
+      const actual = el.getAttribute(attr);
+      if (actual === null) return false;
+      if (operator === '=' && actual !== value) return false;
+      if (operator === '^=' && !actual.startsWith(value)) return false;
+    }
+    return true;
+  });
+}
+
+/** An element. Its box is `rect` ({x, y, width, height}, or a function giving one). */
+export class FakeElement {
+  constructor(doc, tagName) {
+    this.ownerDocument = doc;
+    this.tagName = tagName.toUpperCase();
+    this.nodeType = 1;
+    this.parentNode = null;
+    this.children = [];
+    this.attrs = new Map();
+    this.hasStyle = false;
+    this.style = new FakeStyle(this);
+    this.dataset = {};
+    this.classList = [];
+    this.listeners = [];
+    this.shadowRoot = null;
+    this.id = '';
+    this.rect = {x: 0, y: 0, width: 0, height: 0};
+    // Paint order: later in the document is painted above, unless set.
+    this.z = doc.nextZ++;
+    if (this.tagName === 'IFRAME') {
+      this.contentWindow = {postMessage() {}};
+    }
+  }
+
+  get parentElement() {
+    return this.parentNode && this.parentNode.nodeType === 1 ? this.parentNode : null;
+  }
+
+  get isConnected() {
+    let node = this;
+    while (node.parentNode) node = node.parentNode;
+    return node === this.ownerDocument;
+  }
+
+  get src() {
+    return this.getAttribute('src') || '';
+  }
+
+  set src(value) {
+    this.setAttribute('src', value);
+  }
+
+  getAttribute(name) {
+    if (name === 'style') return this.hasStyle ? this.style.cssText : null;
+    if (name === 'id') return this.id || null;
+    return this.attrs.has(name) ? this.attrs.get(name) : null;
+  }
+
+  setAttribute(name, value) {
+    if (name === 'style') {
+      this.hasStyle = true;
+      this.style.cssText = value;
+    } else if (name === 'id') {
+      this.id = String(value);
+    } else {
+      this.attrs.set(name, String(value));
+    }
+  }
+
+  hasAttribute(name) {
+    return this.getAttribute(name) !== null;
+  }
+
+  removeAttribute(name) {
+    if (name === 'style') {
+      this.hasStyle = false;
+      this.style.props.clear();
+    } else {
+      this.attrs.delete(name);
+    }
+  }
+
+  getBoundingClientRect() {
+    const r = typeof this.rect === 'function' ? this.rect() : this.rect;
+    return {x: r.x, y: r.y, left: r.x, top: r.y, width: r.width, height: r.height,
+      right: r.x + r.width, bottom: r.y + r.height};
+  }
+
+  get clientWidth() {
+    return this.getBoundingClientRect().width;
+  }
+
+  get clientHeight() {
+    return this.getBoundingClientRect().height;
+  }
+
+  /** @return {Array<FakeElement>} Every element below this one, in document order. */
+  descendants() {
+    const found = [];
+    const walk = (el) => {
+      for (const child of el.children) {
+        found.push(child);
+        walk(child);
+      }
+    };
+    walk(this);
+    return found;
+  }
+
+  querySelectorAll(selector) {
+    return this.descendants().filter((el) => matches(el, selector));
+  }
+
+  querySelector(selector) {
+    return this.querySelectorAll(selector)[0] || null;
+  }
+
+  matches(selector) {
+    return matches(this, selector);
+  }
+
+  contains(other) {
+    for (let node = other; node; node = node.parentNode) {
+      if (node === this) return true;
+    }
+    return false;
+  }
+
+  appendChild(node) {
+    return this.insertBefore(node, null);
+  }
+
+  insertBefore(node, ref) {
+    if (node.parentNode) node.parentNode.removeChild(node);
+    const at = ref ? this.children.indexOf(ref) : this.children.length;
+    if (at === -1) throw new Error('contentDom: insertBefore a node that is not a child');
+    this.children.splice(at, 0, node);
+    node.parentNode = this;
+    this.ownerDocument.mutated();
+    return node;
+  }
+
+  removeChild(node) {
+    const at = this.children.indexOf(node);
+    if (at === -1) throw new Error('contentDom: removeChild of a node that is not a child');
+    this.children.splice(at, 1);
+    node.parentNode = null;
+    this.ownerDocument.mutated();
+    return node;
+  }
+
+  replaceChild(node, old) {
+    this.insertBefore(node, old);
+    return this.removeChild(old);
+  }
+
+  remove() {
+    if (this.parentNode) this.parentNode.removeChild(this);
+  }
+
+  replaceWith(node) {
+    if (this.parentNode) this.parentNode.replaceChild(node, this);
+  }
+
+  addEventListener(type, listener) {
+    this.listeners.push({type, listener});
+  }
+
+  removeEventListener(type, listener) {
+    this.listeners = this.listeners.filter((l) => l.type !== type || l.listener !== listener);
+  }
+
+  pause() {
+    this.paused = true;
+  }
+}
+
+/** A document: <html> with <head> and <body>. */
+export class FakeDocument {
+  constructor() {
+    this.nodeType = 9;
+    this.nextZ = 0;
+    this.listeners = [];
+    this.observers = new Set();
+    this.parentNode = null;
+    this.fullscreenEnabled = true;
+    this.fullscreenElement = null;
+    this.baseURI = 'https://site.example/page';
+    this.documentElement = this.createElement('html');
+    this.documentElement.parentNode = this;
+    this.head = this.createElement('head');
+    this.body = this.createElement('body');
+    this.documentElement.appendChild(this.head);
+    this.documentElement.appendChild(this.body);
+    this.activeElement = this.body;
+  }
+
+  createElement(tagName) {
+    return new FakeElement(this, tagName);
+  }
+
+  querySelectorAll(selector) {
+    return [this.documentElement, ...this.documentElement.descendants()].filter((el) => matches(el, selector));
+  }
+
+  /**
+   * The elements whose box holds a point, topmost first (by `z`); an element with
+   * pointer-events: none is left out, as Firefox's hit test leaves it out.
+   * @param {number} x - The point.
+   * @param {number} y - The point.
+   * @return {Array<FakeElement>}
+   */
+  elementsFromPoint(x, y) {
+    return this.querySelectorAll('*').filter((el) => {
+      if (el.style.getPropertyValue('pointer-events') === 'none' || el.pointerEventsNone) return false;
+      const r = el.getBoundingClientRect();
+      return x >= r.left && x < r.right && y >= r.top && y < r.bottom;
+    }).sort((a, b) => b.z - a.z);
+  }
+
+  addEventListener(type, listener) {
+    this.listeners.push({type, listener});
+  }
+
+  removeEventListener() {}
+
+  /**
+   * Runs the MutationObservers watching the document once the current task is done, as
+   * Firefox does (with no records: the scripts' own lists are what is tested).
+   */
+  mutated() {
+    if (this.mutationQueued) return;
+    this.mutationQueued = true;
+    queueMicrotask(() => {
+      this.mutationQueued = false;
+      for (const observer of [...this.observers]) observer.callback([], observer);
+    });
+  }
+}
+
+/**
+ * A page with content.js (and overlay-guard.js, which it uses) loaded in it.
+ * @param {Object} [options]
+ * @param {string} [options.hostname] - The page's host.
+ * @param {Array<Object>} [options.entries] - Its Resource Timing entries.
+ * @param {Object<string, string>} [options.responses] - What its requests get, by URL.
+ * @param {boolean} [options.observer] - Whether it has PerformanceObserver, which is told
+ *   of every entry, where the timeline (getEntriesByType) keeps the first 250.
+ * @return {Object} The page: its document, what content.js sent, and how to talk to it.
+ */
+export function loadContentScript({hostname = 'site.example', entries = [], responses = {}, observer = false} = {}) {
+  const document = new FakeDocument();
+  const sent = [];
+  let onMessage = null;
+  const windowListeners = [];
+  const timers = [];
+  const intervals = new Map();
+  let now = 0;
+
+  class FakeMutationObserver {
+    constructor(callback) {
+      this.callback = callback;
+    }
+    observe() {
+      document.observers.add(this);
+    }
+    disconnect() {
+      document.observers.delete(this);
+    }
+  }
+
+  class FakeResizeObserver {
+    constructor(callback) {
+      this.callback = callback;
+    }
+    observe() {}
+    disconnect() {}
+  }
+
+  class FakeIntersectionObserver {
+    constructor(callback) {
+      this.callback = callback;
+    }
+    observe(el) {
+      // Everything with a box is on screen.
+      const r = el.getBoundingClientRect();
+      Promise.resolve().then(() => this.callback([{intersectionRatio: r.width > 0 && r.height > 0 ? 1 : 0}], this));
+    }
+    disconnect() {}
+  }
+
+  const context = {
+    document,
+    location: {hostname, href: `https://${hostname}/page`, origin: `https://${hostname}`, pathname: '/page', search: ''},
+    navigator: {userActivation: {isActive: false}},
+    performance: {
+      timeOrigin: 1000,
+      getEntriesByType: (type) => (type === 'resource' ? entries.slice(0, 250) : []),
+    },
+    screen: {width: 1920, height: 1080},
+    innerWidth: 1280,
+    innerHeight: 720,
+    crypto: webcrypto,
+    URL,
+    URLSearchParams,
+    TextDecoder,
+    Node: {ELEMENT_NODE: 1},
+    ShadowRoot: class ShadowRoot {},
+    MutationObserver: FakeMutationObserver,
+    ResizeObserver: FakeResizeObserver,
+    IntersectionObserver: FakeIntersectionObserver,
+    // Answers with `responses` (URL -> text; 404 for any other), a moment after send(). A
+    // URL with a bad host makes open() throw, as Firefox's does. As there, a request for an
+    // arraybuffer gets the bytes as its response (the subtitle PR #302 asks for them), and
+    // reading responseText then throws.
+    XMLHttpRequest: class {
+      responseType = '';
+      open(method, url) {
+        if (url.startsWith('http://[')) throw new SyntaxError('An invalid or illegal string was specified');
+        this.url = url;
+      }
+      setRequestHeader() {}
+      getResponseHeader() {
+        return null;
+      }
+      abort() {}
+      send() {
+        Promise.resolve().then(() => {
+          this.readyState = 4;
+          this.status = this.url in responses ? 200 : 404;
+          const text = responses[this.url] || '';
+          if (this.responseType === 'arraybuffer') {
+            this.response = new TextEncoder().encode(text).buffer;
+            Object.defineProperty(this, 'responseText', {get() {
+              throw new DOMException('responseText is only available for a text response', 'InvalidStateError');
+            }});
+          } else {
+            this.response = this.responseText = text;
+          }
+          this.onreadystatechange();
+        });
+      }
+    },
+    console: {log() {}, error() {}, warn() {}, debug() {}, info() {}},
+    setTimeout: (fn, ms = 0) => {
+      timers.push({at: now + ms, fn});
+      return timers.length;
+    },
+    clearTimeout: () => {},
+    setInterval: (fn) => {
+      const id = intervals.size ? Math.max(...intervals.keys()) + 1 : 1;
+      intervals.set(id, fn);
+      return id;
+    },
+    clearInterval: (id) => intervals.delete(id),
+    addEventListener: (type, listener) => windowListeners.push({type, listener}),
+    removeEventListener: () => {},
+    parent: {postMessage() {}},
+    getComputedStyle: (el) => ({
+      display: el.style.getPropertyValue('display') || el.computed?.display || 'block',
+      position: el.style.getPropertyValue('position') || el.computed?.position || 'static',
+      overflow: el.computed?.overflow || 'visible',
+      zIndex: 'auto',
+      border: '',
+      borderRadius: '',
+      boxShadow: '',
+    }),
+    chrome: {
+      runtime: {
+        getURL: (file) => 'moz-extension://test/' + file,
+        lastError: undefined,
+        onMessage: {addListener: (listener) => {
+          onMessage = listener;
+        }},
+        sendMessage: (message, callback) => {
+          sent.push(message);
+          if (callback) {
+            callback(undefined);
+            return undefined;
+          }
+          return Promise.resolve(undefined);
+        },
+      },
+    },
+  };
+  if (observer) {
+    context.PerformanceObserver = class {
+      constructor(callback) {
+        this.callback = callback;
+      }
+      observe() {
+        queueMicrotask(() => this.callback({getEntries: () => entries}, this));
+      }
+    };
+  }
+  context.window = context;
+  vm.createContext(context);
+  for (const [file, source] of [['chrome/overlay-guard.js', overlayGuardSource], ['chrome/content.js', contentSource]]) {
+    vm.runInContext(source, context, {filename: file});
+  }
+
+  return {
+    document,
+    window: context,
+    sent,
+    timers,
+    /** overlay-guard.js's OverlayGuard. */
+    overlayGuard: vm.runInContext('OverlayGuard', context),
+    /** Runs every interval timer once (the overlay guard's checks). */
+    runIntervals() {
+      for (const fn of [...intervals.values()]) fn();
+    },
+    /**
+     * Sends content.js a message, as the background does.
+     * @param {Object} request - The message.
+     * @return {Promise<*>} Its answer; undefined when it gives none.
+     */
+    send(request) {
+      return new Promise((resolve) => {
+        // Copied when sent, as Firefox copies it: what the script changes after is not in it.
+        const sendResponse = (response) => resolve(response === undefined ? undefined : structuredClone(response));
+        const async = onMessage(request, {id: 'test'}, sendResponse);
+        if (async !== true) resolve(undefined);
+      });
+    },
+    /**
+     * Posts a message to the page's window, as a frame in it does.
+     * @param {*} data - The message.
+     * @param {Object} source - The window it comes from.
+     */
+    postMessage(data, source) {
+      for (const {type, listener} of windowListeners) {
+        if (type === 'message') listener({data, source});
+      }
+    },
+    /**
+     * Runs the timers due within this many milliseconds, in order.
+     * @param {number} ms - How far to move the clock.
+     */
+    advance(ms) {
+      const until = now + ms;
+      for (;;) {
+        const due = timers.filter((t) => !t.done && t.at <= until).sort((a, b) => a.at - b.at)[0];
+        if (!due) break;
+        due.done = true;
+        now = due.at;
+        due.fn();
+      }
+      now = until;
+    },
+  };
+}
diff --git a/tests/unit/contentScript.test.mjs b/tests/unit/contentScript.test.mjs
new file mode 100644
index 00000000..bee519f0
--- /dev/null
+++ b/tests/unit/contentScript.test.mjs
@@ -0,0 +1,387 @@
+import {describe, expect, it} from 'vitest';
+import {loadContentScript} from './contentDom.mjs';
+
+// content.js's message handlers, run against a stand-in page (contentDom.mjs).
+
+/**
+ * The name content.js gave its page (FRAME_ADDED's document).
+ * @param {Object} page - From loadContentScript.
+ * @return {string}
+ */
+function pageName(page) {
+  return page.sent.find((message) => message.type === 'FRAME_ADDED').document;
+}
+
+// A player naming a frame as its parent is taken for that frame's only when the frame's
+// page opened it (#225). The background asks the frame's content script when it does not
+// know the page's name itself.
+describe('IS_PLAYER_OPENER', () => {
+  it('answers yes for the name this page put in its players\' URLs', async () => {
+    const page = loadContentScript();
+    expect(await page.send({type: 'IS_PLAYER_OPENER', document: pageName(page)})).toBe(true);
+  });
+
+  it('answers no for any other name', async () => {
+    const page = loadContentScript();
+    for (const name of ['made-up', '', null, undefined]) {
+      expect(await page.send({type: 'IS_PLAYER_OPENER', document: name}), String(name)).toBe(false);
+    }
+  });
+
+  it('gives each page a name of its own', () => {
+    expect(pageName(loadContentScript())).not.toBe(pageName(loadContentScript()));
+  });
+});
+
+/**
+ * Puts a <track> in the page's body.
+ * @param {Object} page - From loadContentScript.
+ * @param {string} src - Its URL.
+ * @param {string} [kind] - Its kind.
+ * @return {Object} The track.
+ */
+function addTrack(page, src, kind = 'subtitles') {
+  const track = page.document.createElement('track');
+  Object.assign(track, {kind, label: src, srclang: 'en'});
+  track.src = src;
+  page.document.body.appendChild(track);
+  return track;
+}
+
+// SCRAPE_CAPTIONS reads the page's <track> files for the player. A request that failed at
+// once (a src XMLHttpRequest refuses) answered inside the loop, before the next track was
+// even asked for: the player opened without a track it could have had (#233).
+describe('SCRAPE_CAPTIONS', () => {
+  it('waits for every track when one request fails at once', async () => {
+    const page = loadContentScript({responses: {'https://cdn.example/en.vtt': 'WEBVTT'}});
+    addTrack(page, 'http://[bad');
+    addTrack(page, 'https://cdn.example/en.vtt');
+    const tracks = await page.send({type: 'SCRAPE_CAPTIONS'});
+    expect(tracks.map((track) => track.source)).toEqual(['https://cdn.example/en.vtt']);
+    expect(tracks[0].data).toBe('WEBVTT');
+  });
+
+  it('answers once, with nothing, for a page without tracks', async () => {
+    const page = loadContentScript();
+    expect(await page.send({type: 'SCRAPE_CAPTIONS'})).toEqual([]);
+  });
+
+  it('leaves out tracks that are not text to read', async () => {
+    const page = loadContentScript({responses: {'https://cdn.example/ch.vtt': 'WEBVTT', 'https://cdn.example/cc.vtt': 'WEBVTT'}});
+    addTrack(page, 'https://cdn.example/ch.vtt', 'chapters');
+    addTrack(page, 'https://cdn.example/cc.vtt', 'captions');
+    const tracks = await page.send({type: 'SCRAPE_CAPTIONS'});
+    expect(tracks.map((track) => track.source)).toEqual(['https://cdn.example/cc.vtt']);
+  });
+});
+
+const PLAYER_URL = 'moz-extension://test/player/index.html';
+
+/**
+ * A page with a 640x360 video in a wrapper of the same size (#wrap), which a player
+ * replaces.
+ * @param {Object} [options] - For loadContentScript.
+ * @return {{page: Object, wrap: Object, video: Object}}
+ */
+function pageWithVideo(options) {
+  const page = loadContentScript(options);
+  const {document} = page;
+  document.documentElement.rect = {x: 0, y: 0, width: 1280, height: 2000};
+  document.body.rect = {x: 0, y: 0, width: 1280, height: 2000};
+  const wrap = document.createElement('div');
+  wrap.id = 'wrap';
+  wrap.rect = {x: 0, y: 0, width: 640, height: 360};
+  const video = document.createElement('video');
+  video.rect = {x: 0, y: 0, width: 640, height: 360};
+  wrap.appendChild(video);
+  document.body.appendChild(wrap);
+  return {page, wrap, video};
+}
+
+/**
+ * Opens a player in the page, as the background does.
+ * @param {Object} page - From loadContentScript.
+ * @return {Promise<{answer: *, iframe: Object}>} content.js's answer, and the player's
+ *   iframe.
+ */
+async function openPlayer(page) {
+  const answer = await page.send({type: 'OPEN_PLAYER', url: PLAYER_URL, noRedirect: true, frameId: 0, parentFrameId: -1, attempt: 1});
+  const iframe = page.document.querySelectorAll('iframe').find((f) => f.src.startsWith(PLAYER_URL));
+  return {answer, iframe};
+}
+
+/**
+ * Links a player that loaded in an iframe to it, as the background and the player do
+ * (FRAME_LINK_RECEIVER here, then the player posts the key to its parent).
+ * @param {Object} page - From loadContentScript.
+ * @param {Object} iframe - The player's iframe.
+ * @param {number} frameId - The player's frame.
+ */
+async function linkPlayer(page, iframe, frameId) {
+  const key = 'key-' + Math.random();
+  await page.send({type: 'FRAME_LINK_RECEIVER', key, frameId});
+  page.postMessage(key, iframe.contentWindow);
+  await Promise.resolve();
+}
+
+// Opening a player sent the background a message for the site scripts' 'active-state',
+// and removing it another, which it passed back to the same frame, where nothing reads
+// them (the YouTube script that did is gone): two round trips per player for nothing.
+describe('OPEN_PLAYER', () => {
+  it('puts the player in place of the page\'s video', async () => {
+    const {page, wrap} = pageWithVideo();
+    const {answer, iframe} = await openPlayer(page);
+    expect(answer).toBe('replace');
+    expect(iframe.parentNode).toBe(page.document.body);
+    // The soft replace: the page's player is kept, at no size, and the iframe has its id.
+    expect(wrap.style.width).toBe('0px');
+    expect(iframe.id).toBe('wrap');
+  });
+
+  it('sends the background nothing for the site scripts on opening and removing a player', async () => {
+    const {page} = pageWithVideo();
+    const {iframe} = await openPlayer(page);
+    await linkPlayer(page, iframe, 5);
+    expect(await page.send({type: 'REMOVE_PLAYERS'})).toBe('ok');
+    expect(page.sent.map((message) => message.type).filter((type) => type === 'SEND_TO_CONTENT')).toEqual([]);
+  });
+});
+
+// types/messages.d.ts described the answer as {width, height}; it is the visible area, a
+// number the background sorts frames by (#233).
+describe('GET_VIDEO_SIZE', () => {
+  it('answers the largest video\'s visible area, as a number', async () => {
+    const {page} = pageWithVideo();
+    expect(await page.send({type: 'GET_VIDEO_SIZE'})).toBe(640 * 360);
+  });
+
+  it('answers 0 for a frame without a video', async () => {
+    const page = loadContentScript();
+    expect(await page.send({type: 'GET_VIDEO_SIZE'})).toBe(0);
+  });
+});
+
+/**
+ * A page with a linked player (frame 5) in place of its video.
+ * @return {Promise<{page: Object, wrap: Object, video: Object, iframe: Object}>}
+ */
+async function pageWithPlayer() {
+  const {page, wrap, video} = pageWithVideo();
+  const {iframe} = await openPlayer(page);
+  await linkPlayer(page, iframe, 5);
+  return {page, wrap, video, iframe};
+}
+
+/**
+ * Adds plain elements to the page's body, each with no style of its own.
+ * @param {Object} page - From loadContentScript.
+ * @param {number} count - How many.
+ * @return {Array<Object>} The elements.
+ */
+function addElements(page, count) {
+  const elements = [];
+  for (let i = 0; i < count; i++) {
+    const div = page.document.createElement('div');
+    page.document.body.appendChild(div);
+    elements.push(div);
+  }
+  return elements;
+}
+
+// Windowed fullscreen hides every other element of the page (fillScreenIframe). Each one
+// was looked up in an array of those already changed, and taken out of it with a splice:
+// both quadratic, seconds on the page's main thread for a page of 50,000 elements (#227).
+// The walk also styled the <head>'s <meta>, <script> and <style> elements.
+describe('windowed fullscreen', () => {
+  it('hides the rest of the page, and gives every element its style back', async () => {
+    const {page, iframe} = await pageWithPlayer();
+    const [plain, styled] = addElements(page, 2);
+    styled.setAttribute('style', 'color: red;');
+    expect(await page.send({type: 'TOGGLE_WINDOWED_FULLSCREEN', frameId: 5})).toBe('enter');
+    expect(plain.style.getPropertyValue('display')).toBe('none');
+    expect(styled.style.getPropertyValue('display')).toBe('none');
+    expect(iframe.style.getPropertyValue('position')).toBe('fixed');
+    expect(await page.send({type: 'TOGGLE_WINDOWED_FULLSCREEN', frameId: 5})).toBe('exit');
+    expect(plain.style.getPropertyValue('display')).toBe('');
+    expect(styled.getAttribute('style')).toBe('color: red;');
+  });
+
+  it('leaves the <head> alone', async () => {
+    const {page} = await pageWithPlayer();
+    const meta = page.document.createElement('meta');
+    page.document.head.appendChild(meta);
+    await page.send({type: 'TOGGLE_WINDOWED_FULLSCREEN', frameId: 5});
+    expect(meta.getAttribute('style')).toBeNull();
+  });
+
+  it('takes well under a second for a page of 50,000 elements', async () => {
+    const {page} = await pageWithPlayer();
+    const elements = addElements(page, 50000);
+    const start = performance.now();
+    await page.send({type: 'TOGGLE_WINDOWED_FULLSCREEN', frameId: 5});
+    await page.send({type: 'TOGGLE_WINDOWED_FULLSCREEN', frameId: 5});
+    const took = performance.now() - start;
+    expect(elements.every((el) => el.style.getPropertyValue('display') === '')).toBe(true);
+    expect(took).toBeLessThan(1000);
+  }, 60000);
+});
+
+// A player in a site's embed iframe: the top frame links the embed iframe, and windowed
+// fullscreen fixes it over the whole page. REMOVE_PLAYERS (a same-site navigation) gave
+// the rest of the page back, but not the embed's own style, which stayed fixed over the
+// page (#229).
+describe('REMOVE_PLAYERS', () => {
+  it('takes an embed holding the player out of windowed fullscreen', async () => {
+    const page = loadContentScript();
+    const embed = page.document.createElement('iframe');
+    embed.setAttribute('style', 'width: 640px;');
+    page.document.body.appendChild(embed);
+    await linkPlayer(page, embed, 7);
+    expect(await page.send({type: 'TOGGLE_WINDOWED_FULLSCREEN', frameId: 7})).toBe('enter');
+    expect(embed.style.getPropertyValue('position')).toBe('fixed');
+    await page.send({type: 'REMOVE_PLAYERS'});
+    expect(embed.getAttribute('style')).toBe('width: 640px;');
+    // And it knows it left: the next toggle enters again.
+    expect(await page.send({type: 'TOGGLE_WINDOWED_FULLSCREEN', frameId: 7})).toBe('enter');
+  });
+});
+
+/**
+ * Asks for the miniplayer, as the background does for the player.
+ * @param {Object} page - From loadContentScript.
+ * @return {Promise<*>} content.js's answer.
+ */
+function requestMiniplayer(page) {
+  return page.send({type: 'TOGGLE_MINIPLAYER', frameId: 5, playerFrameId: 5, force: true, size: 0.25, styles: {bottom: '0px', right: '0px'}});
+}
+
+// The miniplayer shrinks the player's iframe, or the outermost wrapper with its box, to a
+// corner, with a placeholder in its place (#229).
+describe('TOGGLE_MINIPLAYER', () => {
+  it('answers, and changes nothing, when the page took the player\'s iframe out', async () => {
+    // insertBefore on the missing parent threw inside the message handler.
+    const {page, iframe} = await pageWithPlayer();
+    iframe.remove();
+    const childrenBefore = page.document.body.children.length;
+    expect(await requestMiniplayer(page)).toBe('exit');
+    expect(page.document.body.children.length).toBe(childrenBefore);
+  });
+
+  it('never makes the body the miniplayer', async () => {
+    // A wrapper that came to fill the body: the body was the element with the player's
+    // box, a second <body> went in before it, and the page's body was fixed to a corner.
+    const {page, iframe} = await pageWithPlayer();
+    iframe.rect = {x: 0, y: 0, width: 1280, height: 2000};
+    expect(await requestMiniplayer(page)).toBe('enter');
+    expect(page.document.documentElement.children.map((el) => el.tagName)).toEqual(['HEAD', 'BODY']);
+    expect(page.document.body.getAttribute('style')).toBeNull();
+    expect(iframe.style.getPropertyValue('position')).toBe('fixed');
+  });
+
+  it('gives the miniplayer a size when its placeholder has none', async () => {
+    // Here the placeholder is laid out at 0x0: the sizes were NaN.
+    const {page, iframe} = await pageWithPlayer();
+    expect(await requestMiniplayer(page)).toBe('enter');
+    expect(iframe.style.getPropertyValue('width')).toMatch(/^[\d.]+px$/);
+    expect(iframe.style.getPropertyValue('height')).toMatch(/^[\d.]+px$/);
+  });
+});
+
+// A soft replace keeps the page's element, at no size, next to the player. When that
+// element collapses once shown (under 100 px square), the replace turns hard a second
+// after opening: the element leaves the page. The check only looked at players that had
+// linked up, and on a slow start the player linked after it: the element stayed (#229).
+describe('the soft replace turning hard', () => {
+  /**
+   * Opens a player on a page whose element collapses once it is replaced, and links the
+   * player up after the given time.
+   * @param {number} linkAfter - When the player links up, in ms after the open.
+   * @return {Promise<Object>} The page's element.
+   */
+  async function collapseAndLinkAfter(linkAfter) {
+    const {page, wrap} = pageWithVideo();
+    const {iframe} = await openPlayer(page);
+    wrap.rect = {x: 0, y: 0, width: 5, height: 5};
+    page.advance(linkAfter);
+    await linkPlayer(page, iframe, 5);
+    page.advance(3000);
+    return wrap;
+  }
+
+  it('turns hard when the player linked up within the second', async () => {
+    expect((await collapseAndLinkAfter(500)).isConnected).toBe(false);
+  });
+
+  it('turns hard when the player linked up later', async () => {
+    expect((await collapseAndLinkAfter(1500)).isConnected).toBe(false);
+  });
+
+  it('stays soft for an element that keeps its size', async () => {
+    const {page, wrap} = pageWithVideo();
+    const {iframe} = await openPlayer(page);
+    page.advance(1500);
+    await linkPlayer(page, iframe, 5);
+    page.advance(3000);
+    expect(wrap.isConnected).toBe(true);
+  });
+});
+
+// "This Frame > Reload Frame" on the player loads its page again in the same frame, which
+// links up with the same iframe again. The new entry had nothing to give back, so leaving
+// the page kept the page's element hidden and its media paused for good (#288).
+describe('a player that loads again in its frame', () => {
+  it('still gives the page its element back when the player goes', async () => {
+    const {page, wrap, video, iframe} = await pageWithPlayer();
+    await linkPlayer(page, iframe, 5);
+    await page.send({type: 'REMOVE_PLAYERS'});
+    expect(iframe.isConnected).toBe(false);
+    expect(wrap.style.width).toBe('');
+    expect(wrap.id).toBe('wrap');
+    expect(video.listeners.filter((l) => l.type === 'play')).toEqual([]);
+  });
+});
+
+// When the background was suspended and knows no stream of the tab, each frame reports
+// what its page loaded (REPORT_LOADED_MEDIA), from its Resource Timing entries. The page's
+// timeline keeps its first 250 requests, and a streaming page made that many (ads,
+// trackers) before its video asked for the manifest: the manifest was never reported (#231).
+describe('REPORT_LOADED_MEDIA', () => {
+  /**
+   * A page's requests: images, then its manifest last.
+   * @param {number} images - How many images before the manifest.
+   * @return {Array<Object>} Resource Timing entries.
+   */
+  function requests(images) {
+    const entries = [];
+    for (let i = 0; i < images; i++) {
+      entries.push({name: `https://ads.example/px${i}.gif`, initiatorType: 'img', responseStatus: 200, startTime: i});
+    }
+    entries.push({name: 'https://cdn.example/film.m3u8', initiatorType: 'fetch', responseStatus: 200, startTime: images});
+    return entries;
+  }
+
+  /**
+   * @param {Object} page - From loadContentScript.
+   * @return {Promise<Array<string>>} The URLs content.js reports.
+   */
+  async function reported(page) {
+    await Promise.resolve();
+    await page.send({type: 'REPORT_LOADED_MEDIA'});
+    return page.sent.find((message) => message.type === 'LOADED_MEDIA').resources.map((r) => r.url);
+  }
+
+  it('reports a manifest the page asked for after 300 other requests', async () => {
+    const page = loadContentScript({entries: requests(300), observer: true});
+    expect(await reported(page)).toEqual(['https://cdn.example/film.m3u8']);
+  });
+
+  it('reports it once when the timeline has it too', async () => {
+    const page = loadContentScript({entries: requests(10), observer: true});
+    expect(await reported(page)).toEqual(['https://cdn.example/film.m3u8']);
+  });
+
+  it('reports what the timeline has where there is no observer', async () => {
+    const page = loadContentScript({entries: requests(10)});
+    expect(await reported(page)).toEqual(['https://cdn.example/film.m3u8']);
+  });
+});
diff --git a/tests/unit/customSiteScripts.test.mjs b/tests/unit/customSiteScripts.test.mjs
new file mode 100644
index 00000000..071de459
--- /dev/null
+++ b/tests/unit/customSiteScripts.test.mjs
@@ -0,0 +1,153 @@
+import vm from 'node:vm';
+import {beforeAll, describe, expect, it} from 'vitest';
+
+// The site scripts (chrome/custom/*.js) read a stream's manifest out of Facebook's,
+// Bilibili's and Instagram's own pages and report it as a data: URL (DETECTED_SOURCE).
+// Issue #232: a report whose manifest was the word "undefined", uncaught throws on play
+// info of another shape and on any manifest with a character btoa refuses, and reports of
+// no type the background recorded anyway.
+
+// The site scripts' text, which vitest includes when it loads this file (?raw): read at run
+// time, the code run below was "user-provided" to CodeQL (js/code-injection).
+const SITE_SCRIPTS = import.meta.glob('../../chrome/custom/*.js', {query: '?raw', import: 'default', eager: true});
+
+/**
+ * Runs a site script on a stand-in page with these <script> elements.
+ * @param {string} file - The script, under chrome/custom.
+ * @param {Array<{type?: string, textContent: string}>} scripts - The page's scripts.
+ * @return {{sent: Array<Object>, listeners: Array<Function>}} What it sent the background,
+ *   and its window 'message' listeners.
+ */
+function runSiteScript(file, scripts = []) {
+  const sent = [];
+  const listeners = [];
+  const context = {
+    document: {
+      querySelectorAll: (selector) => (selector === 'script' ? scripts.map((s) => ({type: '', ...s})) : []),
+      createElement: () => ({remove() {}}),
+      documentElement: {appendChild() {}},
+    },
+    window: {
+      location: {origin: 'https://www.example.com'},
+      addEventListener: (type, listener) => {
+        if (type === 'message') listeners.push(listener);
+      },
+    },
+    location: {href: 'https://www.example.com/watch', origin: 'https://www.example.com'},
+    chrome: {runtime: {
+      sendMessage: (message) => sent.push(message),
+      getURL: (file) => 'moz-extension://test/' + file,
+    }},
+    console: {log() {}, error() {}},
+    TextEncoder,
+    btoa,
+  };
+  const source = SITE_SCRIPTS[`../../chrome/custom/${file}`];
+  if (source === undefined) {
+    throw new Error(`no site script chrome/custom/${file}`);
+  }
+  vm.runInNewContext(source, context);
+  return {sent, listeners};
+}
+
+/**
+ * @param {string} url - A report's data: URL.
+ * @return {string} Its manifest, read as UTF-8.
+ */
+function manifestOf(url) {
+  const prefix = 'data:application/dash+xml;base64,';
+  expect(url.startsWith(prefix)).toBe(true);
+  return Buffer.from(url.slice(prefix.length), 'base64').toString('utf8');
+}
+
+describe('facebook_content.js', () => {
+  /**
+   * @param {Object} video - A playback_video object.
+   * @return {{type: string, textContent: string}} A JSON script holding it.
+   */
+  function jsonScript(video) {
+    return {type: 'application/json', textContent: JSON.stringify({video: {playback_video: video}})};
+  }
+
+  it('reports the manifest of the video', () => {
+    const {sent} = runSiteScript('facebook_content.js', [jsonScript({playlist: '<MPD/>'})]);
+    expect(sent).toHaveLength(1);
+    expect(manifestOf(sent[0].url)).toBe('<MPD/>');
+  });
+
+  it('reports nothing for a video without its manifest', () => {
+    // btoa(undefined): a source whose manifest was the word "undefined".
+    const {sent} = runSiteScript('facebook_content.js', [jsonScript({id: 1})]);
+    expect(sent).toEqual([]);
+  });
+
+  it('reports a manifest with characters btoa refuses', () => {
+    const mpd = '<MPD><Title>Ünïcödé – 日本語</Title></MPD>';
+    const {sent} = runSiteScript('facebook_content.js', [jsonScript({playlist: mpd})]);
+    expect(manifestOf(sent[0].url)).toBe(mpd);
+  });
+});
+
+describe('bilibili_content.js', () => {
+  it('throws nothing on play info that has no DASH streams', () => {
+    // A page serving FLV (data.durl) instead of data.dash.
+    const text = 'window.__playinfo__={"data":{"durl":[{"url":"https://cdn.example.com/a.flv"}]}}';
+    expect(() => runSiteScript('bilibili_content.js', [{textContent: text}])).not.toThrow();
+  });
+
+  it('throws nothing when more code follows the play info on its line', () => {
+    const text = 'window.__playinfo__={"data":{}};window.__INITIAL_STATE__={"a":1}';
+    expect(() => runSiteScript('bilibili_content.js', [{textContent: text}])).not.toThrow();
+  });
+});
+
+describe('instagram_content.js', () => {
+  /**
+   * Posts a message to the page's window, from the page itself.
+   * @param {Array<Function>} listeners - The window's 'message' listeners.
+   * @param {Object} data - The message.
+   */
+  function post(listeners, data) {
+    for (const listener of listeners) listener({origin: 'https://www.example.com', data});
+  }
+
+  it('reports the manifest instagram_inject.js posts', () => {
+    const {sent, listeners} = runSiteScript('instagram_content.js');
+    post(listeners, {type: 'fs_source_detected', value: '<MPD>é</MPD>', ext: 'mpd'});
+    expect(sent).toHaveLength(1);
+    expect(sent[0].ext).toBe('mpd');
+    expect(manifestOf(sent[0].url)).toBe('<MPD>é</MPD>');
+  });
+
+  it('passes on no report of another type, or with no manifest', () => {
+    // Any script in the page can post one.
+    const {sent, listeners} = runSiteScript('instagram_content.js');
+    post(listeners, {type: 'fs_source_detected', value: '<MPD/>', ext: 'exe'});
+    post(listeners, {type: 'fs_source_detected', value: '<MPD/>'});
+    post(listeners, {type: 'fs_source_detected', value: '', ext: 'mpd'});
+    expect(sent).toEqual([]);
+  });
+});
+
+describe('BackgroundUtils.detectedSourceMode', () => {
+  let BackgroundUtils;
+
+  beforeAll(async () => {
+    // BackgroundUtils reads the player URL when it loads.
+    globalThis.chrome = {runtime: {getURL: (file) => 'moz-extension://test/' + file}};
+    ({BackgroundUtils} = await import('../../chrome/background/BackgroundUtils.mjs'));
+  });
+
+  it('gives the mode of a manifest a site script reports', () => {
+    expect(BackgroundUtils.detectedSourceMode({url: 'data:application/dash+xml;base64,PE1QRC8+', ext: 'mpd'})).toBeTruthy();
+  });
+
+  it('gives none for a report of no type, or with no address', () => {
+    // It was recorded as a source of mode undefined.
+    expect(BackgroundUtils.detectedSourceMode({url: 'data:,x', ext: 'exe'})).toBeNull();
+    expect(BackgroundUtils.detectedSourceMode({url: 'data:,x'})).toBeNull();
+    expect(BackgroundUtils.detectedSourceMode({url: {}, ext: 'mpd'})).toBeNull();
+    expect(BackgroundUtils.detectedSourceMode({ext: 'mpd'})).toBeNull();
+    expect(BackgroundUtils.detectedSourceMode(null)).toBeNull();
+  });
+});
diff --git a/tests/unit/instagramInject.test.mjs b/tests/unit/instagramInject.test.mjs
index 2d8ee64a..2c68e07c 100644
--- a/tests/unit/instagramInject.test.mjs
+++ b/tests/unit/instagramInject.test.mjs
@@ -13,10 +13,11 @@ const source = fs.readFileSync(
 
 /**
  * Runs the script against a stand-in XMLHttpRequest.
- * @return {{posted: Array<Object>, respond: function(string): void}}
+ * @return {{posted: Array<Object>, errors: Array<Array<*>>, respond: function(string): void}}
  */
 function load() {
   const posted = [];
+  const errors = [];
   class FakeXHR {
     constructor() {
       this.listeners = [];
@@ -32,11 +33,12 @@ function load() {
   const context = {
     XMLHttpRequest: FakeXHR,
     window: {postMessage: (data) => posted.push(data)},
-    console: {error() {}, log() {}},
+    console: {error: (...args) => errors.push(args), log() {}},
   };
   vm.runInNewContext(source, context);
   return {
     posted,
+    errors,
     respond(text) {
       const xhr = new context.XMLHttpRequest();
       xhr.open('GET', '/graphql');
@@ -75,4 +77,11 @@ describe('instagram_inject.js', () => {
     expect(() => page.respond('<html>')).not.toThrow();
     expect(page.posted).toEqual([]);
   });
+
+  it('logs no error for a response that has nothing to do with video', () => {
+    // Every JSON response of the page put "No video_dash_manifest found" in its console.
+    const page = load();
+    page.respond('{"data": {"user": 1}}');
+    expect(page.errors).toEqual([]);
+  });
 });
diff --git a/tests/unit/overlayGuard.test.mjs b/tests/unit/overlayGuard.test.mjs
new file mode 100644
index 00000000..4af57a25
--- /dev/null
+++ b/tests/unit/overlayGuard.test.mjs
@@ -0,0 +1,139 @@
+import {describe, expect, it} from 'vitest';
+import {loadContentScript} from './contentDom.mjs';
+
+// overlay-guard.js hides what a page lays over FastStream's player (a bar, a button, an
+// ad layer), by geometry: what is painted over the player's iframe and lies mostly inside
+// its box, or covers half of it. Run here on a stand-in page (contentDom.mjs) whose
+// window is 1280x720 and whose elements are placed by hand; later elements are painted
+// above earlier ones.
+
+/**
+ * A page with FastStream's player iframe in it.
+ * @param {{x: number, y: number, width: number, height: number}} rect - The iframe's box.
+ * @return {{page: Object, iframe: Object}}
+ */
+function pageWithPlayerAt(rect) {
+  const page = loadContentScript();
+  const {document} = page;
+  document.documentElement.rect = {x: 0, y: 0, width: 1280, height: 2000};
+  document.body.rect = {x: 0, y: 0, width: 1280, height: 2000};
+  const iframe = document.createElement('iframe');
+  iframe.src = 'moz-extension://test/player/index.html?opener=x';
+  iframe.rect = rect;
+  document.body.appendChild(iframe);
+  return {page, iframe};
+}
+
+/**
+ * Adds an element to the page, painted above everything added before it.
+ * @param {Object} page - From loadContentScript.
+ * @param {Object} parent - Where it goes.
+ * @param {{x: number, y: number, width: number, height: number}} rect - Its box.
+ * @param {Object<string, string>} [attributes] - Its attributes.
+ * @return {Object} The element.
+ */
+function addLayer(page, parent, rect, attributes = {}) {
+  const el = page.document.createElement('div');
+  el.rect = rect;
+  for (const [name, value] of Object.entries(attributes)) el.setAttribute(name, value);
+  parent.appendChild(el);
+  return el;
+}
+
+const VIEWPORT = {x: 0, y: 0, width: 1280, height: 720};
+const PLAYER = {x: 0, y: 0, width: 640, height: 360};
+
+/**
+ * @param {Object} el - An element.
+ * @return {string} Its inline visibility, '' when it has none.
+ */
+function visibility(el) {
+  return el.style.getPropertyValue('visibility');
+}
+
+describe('OverlayGuard', () => {
+  it('hides a layer over the whole page, and gives it back on release', () => {
+    // What the e2e's veil and stage pages pin: an ad layer goes.
+    const {page, iframe} = pageWithPlayerAt(PLAYER);
+    const layer = addLayer(page, page.document.body, VIEWPORT);
+    page.overlayGuard.guard(iframe);
+    expect(visibility(layer)).toBe('hidden');
+    page.overlayGuard.releaseAll();
+    expect(visibility(layer)).toBe('');
+  });
+
+  it('hides a bar on the player', () => {
+    const {page, iframe} = pageWithPlayerAt(PLAYER);
+    const bar = addLayer(page, page.document.body, {x: 0, y: 320, width: 640, height: 40});
+    page.overlayGuard.guard(iframe);
+    expect(visibility(bar)).toBe('hidden');
+  });
+
+  // A site's sign-in, cookie or settings dialog opened while the player was up: a backdrop
+  // over the whole page with the dialog in it, the same geometry as an ad layer. Hidden,
+  // the user saw no dialog, and clicks went through its backdrop (#226).
+  describe('a site\'s dialog over the player', () => {
+    it('leaves a layer holding a dialog alone, and all that is in it', () => {
+      const {page, iframe} = pageWithPlayerAt(PLAYER);
+      const modal = addLayer(page, page.document.body, VIEWPORT);
+      const backdrop = addLayer(page, modal, VIEWPORT);
+      const dialog = addLayer(page, modal, {x: 440, y: 200, width: 400, height: 300}, {'role': 'dialog'});
+      page.overlayGuard.guard(iframe);
+      expect([modal, backdrop, dialog].map(visibility)).toEqual(['', '', '']);
+    });
+
+    it('leaves alone a dialog that says it is one in any of the usual ways', () => {
+      for (const attributes of [{'role': 'alertdialog'}, {'aria-modal': 'true'}]) {
+        const {page, iframe} = pageWithPlayerAt(PLAYER);
+        const dialog = addLayer(page, page.document.body, VIEWPORT, attributes);
+        page.overlayGuard.guard(iframe);
+        expect(visibility(dialog), JSON.stringify(attributes)).toBe('');
+      }
+      const {page, iframe} = pageWithPlayerAt(PLAYER);
+      const dialog = page.document.createElement('dialog');
+      dialog.rect = VIEWPORT;
+      dialog.setAttribute('open', '');
+      page.document.body.appendChild(dialog);
+      page.overlayGuard.guard(iframe);
+      expect(visibility(dialog)).toBe('');
+    });
+
+    it('leaves alone a layer the user is typing in', () => {
+      const {page, iframe} = pageWithPlayerAt(PLAYER);
+      const form = addLayer(page, page.document.body, VIEWPORT);
+      const input = page.document.createElement('input');
+      input.rect = {x: 500, y: 300, width: 200, height: 30};
+      form.appendChild(input);
+      page.document.activeElement = input;
+      page.overlayGuard.guard(iframe);
+      expect(visibility(form)).toBe('');
+    });
+
+    it('gives back a layer that became a dialog after it was hidden', () => {
+      const {page, iframe} = pageWithPlayerAt(PLAYER);
+      const layer = addLayer(page, page.document.body, VIEWPORT);
+      page.overlayGuard.guard(iframe);
+      expect(visibility(layer)).toBe('hidden');
+      layer.setAttribute('aria-modal', 'true');
+      page.runIntervals();
+      expect(visibility(layer)).toBe('');
+    });
+  });
+
+  // A sticky header over a player scrolled mostly out of view: the header covered more than
+  // half of the player's part on screen, so it went, came back when the player left the
+  // screen, and went again on the way back (#226).
+  it('leaves a page header alone over a player scrolled mostly out of view', () => {
+    const {page, iframe} = pageWithPlayerAt({x: 0, y: -260, width: 640, height: 360});
+    const header = addLayer(page, page.document.body, {x: 0, y: 0, width: 1280, height: 60});
+    page.overlayGuard.guard(iframe);
+    expect(visibility(header)).toBe('');
+  });
+
+  it('still hides a bar on a player partly out of view', () => {
+    const {page, iframe} = pageWithPlayerAt({x: 0, y: -100, width: 640, height: 360});
+    const bar = addLayer(page, page.document.body, {x: 0, y: 220, width: 640, height: 40});
+    page.overlayGuard.guard(iframe);
+    expect(visibility(bar)).toBe('hidden');
+  });
+});
diff --git a/tests/unit/samePageUrlChange.test.mjs b/tests/unit/samePageUrlChange.test.mjs
new file mode 100644
index 00000000..abcb196f
--- /dev/null
+++ b/tests/unit/samePageUrlChange.test.mjs
@@ -0,0 +1,42 @@
+import {beforeAll, describe, expect, it} from 'vitest';
+
+// Firefox reports a change of a tab's URL fragment (tabs.onUpdated) as it reports a new
+// page. The background took it for one: the allowlist's per-page mpv latch was reset, so
+// the page's next stream request opened a second mpv window, and the in-page player was
+// taken down by an anchor link or a #t= update (#236). Only the fragment changing to
+// another anchor is the same page; a hash route is a page of its own.
+
+let BackgroundUtils;
+
+beforeAll(async () => {
+  // BackgroundUtils reads the player URL when it loads.
+  globalThis.chrome = {runtime: {getURL: (file) => 'moz-extension://test/' + file}};
+  ({BackgroundUtils} = await import('../../chrome/background/BackgroundUtils.mjs'));
+});
+
+describe('isSamePageUrlChange', () => {
+  it.each([
+    ['https://site.example/watch/1', 'https://site.example/watch/1#comments'],
+    ['https://site.example/watch/1#comments', 'https://site.example/watch/1#t=120'],
+    ['https://site.example/watch/1?v=2#a', 'https://site.example/watch/1?v=2'],
+  ])('%s -> %s: the same page', (from, to) => {
+    expect(BackgroundUtils.isSamePageUrlChange(from, to)).toBe(true);
+  });
+
+  it.each([
+    // Another path or query: a new page, or a single-page site's next episode.
+    ['https://site.example/watch/1', 'https://site.example/watch/2'],
+    ['https://site.example/watch?v=1', 'https://site.example/watch?v=2'],
+    // A hash route is the next page of a single-page site.
+    ['https://site.example/#/watch/1', 'https://site.example/#/watch/2'],
+    ['https://site.example/#!/watch/1', 'https://site.example/#!/watch/2'],
+    ['https://site.example/', 'https://site.example/#/watch/2'],
+    // The same URL again is a reload.
+    ['https://site.example/watch/1', 'https://site.example/watch/1'],
+    // The tab's first page.
+    [undefined, 'https://site.example/watch/1#a'],
+    ['', 'https://site.example/watch/1#a'],
+  ])('%s -> %s: a page of its own', (from, to) => {
+    expect(BackgroundUtils.isSamePageUrlChange(from, to)).toBe(false);
+  });
+});
diff --git a/types/firefox-chrome.d.ts b/types/firefox-chrome.d.ts
index 72a98c44..7ecb5bdc 100644
--- a/types/firefox-chrome.d.ts
+++ b/types/firefox-chrome.d.ts
@@ -20,10 +20,3 @@ declare namespace chrome.tabs {
     cookieStoreId?: string;
   }
 }
-
-declare namespace chrome.webRequest {
-  interface OnHeadersReceivedDetails {
-    /** The URL of the document or extension page that made the request. */
-    originUrl?: string;
-  }
-}
diff --git a/types/messages.d.ts b/types/messages.d.ts
index 673dd241..d66c340a 100644
--- a/types/messages.d.ts
+++ b/types/messages.d.ts
@@ -45,11 +45,17 @@ interface FSOpenPlayer extends FSMessageBase {
   type: 'OPEN_PLAYER';
   /** Extension URL of the player page. */
   url: string;
-  /** True only for the top frame, which navigates rather than redirects. */
+  /**
+   * True only for the top frame, which never goes to the player itself: it puts the
+   * player in place of its video, or lays it over the page. Another frame whose video
+   * fills it, and which cannot go fullscreen, navigates to the player instead.
+   */
   noRedirect: boolean;
   frameId: number;
   /** -1 when the frame has no parent. */
   parentFrameId: number;
+  /** Numbers this opening; content.js names it in PLAYER_OPEN_GONE. */
+  attempt: number;
 }
 
 /** The player announcing it has finished loading. */
@@ -58,10 +64,25 @@ interface FSPlayerLoaded extends FSMessageBase {
   url: string;
   /** False on faststream.online, true inside the extension. */
   isExt: boolean;
-  /** Absent when the player was not opened from a parent frame. */
+  /**
+   * The frame the player's URL names as its parent (parent_frame_id); absent when the
+   * player was not opened from a parent frame. The URL is the framing page's to write,
+   * so the background takes it only when the page its opener names is that frame's
+   * (TabHolder.playerParentProof, IS_PLAYER_OPENER).
+   */
   parentFrameId?: number;
 }
 
+/**
+ * Background asks a frame whether its page is the one a player names as its opener.
+ * content.js answers `true` or `false`.
+ */
+interface FSIsPlayerOpener extends FSMessageBase {
+  type: 'IS_PLAYER_OPENER';
+  /** The opener the player's URL names. */
+  document: string;
+}
+
 /**
  * Registers declarativeNetRequest rules that rewrite request headers.
  *
@@ -82,16 +103,17 @@ interface FSHeaderCommand {
   value?: string;
 }
 
-/** Background asks a frame for its video element dimensions. */
+/** Background asks a frame how big its largest visible video is. */
 interface FSGetVideoSize extends FSMessageBase {
   type: 'GET_VIDEO_SIZE';
 }
 
-/** Reply to GET_VIDEO_SIZE. */
-interface FSVideoSize {
-  width: number;
-  height: number;
-}
+/**
+ * Reply to GET_VIDEO_SIZE: the video's visible area in CSS pixels (width x height x the
+ * share of it on screen); 0 when the frame has none. The background opens the player in
+ * the frame with the biggest.
+ */
+type FSVideoSizeReply = number;
 
 /**
  * Any message crossing a context boundary.
@@ -107,6 +129,7 @@ type FSMessage =
   | FSUpdateOptions
   | FSOpenPlayer
   | FSPlayerLoaded
+  | FSIsPlayerOpener
   | FSSetHeaders
   | FSGetVideoSize
   | FSMpvTest