fix(content): fake players refused, site dialogs left alone, a reloaded or anchored player keeps its video

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.

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

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

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

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