diff --git a/changelog/v0.1.0-beta3.txt b/changelog/v0.1.0-beta3.txt
index 54740d0a..79c2257f 100644
--- a/changelog/v0.1.0-beta3.txt
+++ b/changelog/v0.1.0-beta3.txt
@@ -62,6 +62,8 @@ AUDIO
 - The music volume slider follows how loud it sounds, so each step changes the level by a similar amount. Your saved volume plays at the same level after the update.
 - Music loudness is measured the way Android does it, from the perceptual loudness first, and loud songs are never turned down by more than 20 dB.
 - An optional crossfade, off by default, fades the next song in over 1 to 12 seconds. Consecutive tracks from the same album and repeat-one keep their gapless joins.
+- The equalizer now also applies to videos, including the pop-out player, and opens from the video settings menu. Shorts are left as they are.
+- Videos only go through audio processing once the equalizer changes the sound, and only after a short silent self-test shows it works. Where it does not, as on some Linux setups, videos keep playing normally and the menu says the equalizer is not available.
 
 MACOS
 - Flow uses the native macOS window controls and titlebar again. Closing the window hides it and keeps playback and downloads running until you quit, and clicking the Dock icon brings it back.
diff --git a/src/components/music/eq/EqualizerDialog.tsx b/src/components/music/eq/EqualizerDialog.tsx
index f3907530..530393d7 100644
--- a/src/components/music/eq/EqualizerDialog.tsx
+++ b/src/components/music/eq/EqualizerDialog.tsx
@@ -35,6 +35,11 @@ export function EqualizerDialog() {
   const setPreview = useEqStore((s) => s.setPreview);
   const setBypass = useEqStore((s) => s.setBypass);
 
+  useEffect(() => {
+    useEqStore.setState({ editorHosted: true });
+    return () => useEqStore.setState({ editorHosted: false });
+  }, []);
+
   useEffect(() => {
     if (!open) return;
     const onKey = (event: KeyboardEvent) => {
diff --git a/src/components/player/FlowPlayerControls.tsx b/src/components/player/FlowPlayerControls.tsx
index 8bf76826..eabc1d9f 100644
--- a/src/components/player/FlowPlayerControls.tsx
+++ b/src/components/player/FlowPlayerControls.tsx
@@ -22,6 +22,7 @@ import {
   Volume2,
   VolumeX,
   Sliders,
+  SlidersHorizontal,
 } from "lucide-react";
 import { usePlayerStore, type PlaybackRate } from "../../store/usePlayerStore";
 import { useSettingsStore, type SponsorBlockCategory } from "../../store/useSettingsStore";
@@ -51,6 +52,9 @@ import { sponsorBlockCategoryLabel } from "../../lib/sponsorBlockCategories";
 import { getString } from "../../lib/i18n/index";
 import { SleepTimerLabel } from "../sleep/SleepTimerLabel";
 import { SleepTimerPanel } from "../sleep/SleepTimerPanel";
+import { useEqActive } from "../../lib/audio/eq/useEqualizer";
+import { videoEqAvailable } from "../../lib/audio/mediaEqEngine";
+import { useEqStore } from "../../store/useEqStore";
 import { Slider } from "../ui/Slider";
 import { videoCodecLabel } from "../../lib/settings/playerRuntime";
 
@@ -478,6 +482,10 @@ export const FlowPlayerControls: React.FC<FlowPlayerControlsProps> = ({
     updateHoverPreview(event.clientX, event.currentTarget);
   };
 
+  const eqActive = useEqActive();
+  const eqEditorHosted = useEqStore((s) => s.editorHosted);
+  const openEqEditor = useEqStore((s) => s.setEditorOpen);
+
   const renderSettingRow = (
     label: string,
     value: React.ReactNode,
@@ -952,6 +960,17 @@ export const FlowPlayerControls: React.FC<FlowPlayerControlsProps> = ({
               <Pause size={18} />,
               () => setSettingsPane("sleep")
             )}
+            {eqEditorHosted &&
+              renderSettingRow(
+                getString("music_equalizer"),
+                // Read when the menu draws: the self-test only settles once the equalizer is used.
+                getString(!videoEqAvailable() ? "eq_state_unavailable" : eqActive ? "eq_state_on" : "eq_state_off"),
+                <SlidersHorizontal size={18} />,
+                () => {
+                  setSettingsOpen(false);
+                  openEqEditor(true);
+                }
+              )}
           </div>
         )}
 
diff --git a/src/components/player/Player.tsx b/src/components/player/Player.tsx
index 2f44983c..be879332 100644
--- a/src/components/player/Player.tsx
+++ b/src/components/player/Player.tsx
@@ -28,6 +28,7 @@ import {
 import { SubtitleOverlay } from "./SubtitleOverlay";
 import { SETTINGS } from "../../lib/settings/schema";
 import { loudnessFactor } from "../../lib/loudness";
+import { useVideoEq } from "../../lib/audio/useVideoEq";
 import { IS_LINUX_RUNTIME } from "../../lib/platform";
 import {
   AUDIO_DRIFT_TOLERANCE_SECONDS,
@@ -595,6 +596,8 @@ export const Player: React.FC<PlayerProps> = ({
     !isHlsPlayback &&
     (hasSelectedAlternateAudio || (!!selectedQuality && !selectedQuality.hasAudio));
 
+  useVideoEq(videoRef, audioRef, usesExternalAudio ? selectedAudioTrack?.localUrl ?? null : null);
+
   const isPipMode = videoPlayerMode === "pip";
   const isTheaterSurface = isTheaterMode && !isPipMode;
   const shouldShowControls = controlsVisible || !isPlaying || settingsOpen || isScrubbing;
@@ -2510,6 +2513,8 @@ export const Player: React.FC<PlayerProps> = ({
 
       <video
         ref={videoRef}
+        // Set before src: the equalizer can only read cross-origin audio fetched with CORS.
+        crossOrigin="anonymous"
         src={isDashPlayback || isHlsPlayback ? undefined : src || undefined}
         poster={effectivePoster}
         loop={videoLoopEnabled && !isLive}
@@ -2581,6 +2586,7 @@ export const Player: React.FC<PlayerProps> = ({
       {usesExternalAudio && selectedAudioTrack?.localUrl && (
         <audio
           ref={audioRef}
+          crossOrigin="anonymous"
           src={selectedAudioTrack.localUrl}
           preload="auto"
           onLoadedMetadata={handleAudioLoadedMetadata}
diff --git a/src/lib/audio/mediaEqEngine.test.ts b/src/lib/audio/mediaEqEngine.test.ts
new file mode 100644
index 00000000..25b62335
--- /dev/null
+++ b/src/lib/audio/mediaEqEngine.test.ts
@@ -0,0 +1,159 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../diagnostics", () => ({ logToBackend: vi.fn(async () => {}) }));
+
+import { graphSpec } from "./eq/graphPlan";
+import { defaultEqState, selectPreset } from "./eq/stateOps";
+
+class FakeParam {
+  value = 1;
+  setTargetAtTime = vi.fn((v: number) => {
+    this.value = v;
+  });
+}
+class FakeNode {
+  connect = vi.fn((node: unknown) => node);
+  disconnect = vi.fn();
+}
+let probeSignal = 0.2;
+const contexts: FakeContext[] = [];
+class FakeContext extends EventTarget {
+  state: AudioContextState = "running";
+  currentTime = 0;
+  sampleRate = 48_000;
+  baseLatency = 0.005;
+  outputLatency = 0.02;
+  destination = new FakeNode();
+  sources: HTMLMediaElement[] = [];
+  resume = vi.fn(async () => {});
+  constructor() {
+    super();
+    contexts.push(this);
+  }
+  createGain() {
+    return Object.assign(new FakeNode(), { gain: new FakeParam() });
+  }
+  createBiquadFilter() {
+    return Object.assign(new FakeNode(), {
+      type: "peaking",
+      frequency: new FakeParam(),
+      Q: new FakeParam(),
+      gain: new FakeParam(),
+    });
+  }
+  createWaveShaper() {
+    return Object.assign(new FakeNode(), { curve: null });
+  }
+  createAnalyser() {
+    return Object.assign(new FakeNode(), {
+      fftSize: 64,
+      getFloatTimeDomainData: (data: Float32Array) => data.fill(probeSignal),
+    });
+  }
+  createMediaElementSource(el: HTMLMediaElement) {
+    this.sources.push(el);
+    return new FakeNode();
+  }
+}
+
+const media = <T extends HTMLMediaElement>(tag: "video" | "audio", cors = true): T => {
+  const el = document.createElement(tag) as T;
+  if (cors) el.crossOrigin = "anonymous";
+  return el;
+};
+
+const rock = graphSpec(selectPreset(defaultEqState(), "builtin:rock"), false);
+
+async function freshEngine() {
+  vi.resetModules();
+  const module = await import("./mediaEqEngine");
+  return { engine: new module.MediaEqEngine(), available: module.videoEqAvailable };
+}
+
+const settle = () => vi.advanceTimersByTimeAsync(2_000);
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  contexts.length = 0;
+  probeSignal = 0.2;
+  vi.stubGlobal("AudioContext", FakeContext);
+  vi.stubGlobal("URL", Object.assign(URL, { createObjectURL: () => "blob:tone", revokeObjectURL: () => {} }));
+  vi.spyOn(HTMLMediaElement.prototype, "play").mockResolvedValue(undefined);
+  vi.spyOn(HTMLMediaElement.prototype, "pause").mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe("MediaEqEngine", () => {
+  it("leaves the video alone until the equalizer changes the sound", async () => {
+    const { engine } = await freshEngine();
+    engine.setElements([media("video"), null]);
+    engine.setEq(rock, false);
+    await settle();
+    expect(contexts).toHaveLength(0);
+  });
+
+  it("routes the video and its separate audio once each, and follows a new audio element", async () => {
+    const { engine } = await freshEngine();
+    const video = media<HTMLVideoElement>("video");
+    const audio = media<HTMLAudioElement>("audio");
+    engine.setElements([video, audio]);
+    engine.setEq(rock, true);
+    await settle();
+
+    const ctx = contexts[0]!;
+    // The first source is the self-test's own element.
+    expect(ctx.sources.slice(1)).toEqual([video, audio]);
+
+    engine.setElements([video, audio]);
+    engine.setEq(rock, true);
+    await settle();
+    expect(ctx.sources).toHaveLength(3);
+
+    const nextAudio = media<HTMLAudioElement>("audio");
+    engine.setElements([video, nextAudio]);
+    await settle();
+    expect(ctx.sources.slice(1)).toEqual([video, audio, nextAudio]);
+  });
+
+  it("falls back to plain playback when WebAudio returns silence", async () => {
+    probeSignal = 0;
+    const { engine, available } = await freshEngine();
+    const video = media<HTMLVideoElement>("video");
+    engine.setElements([video, null]);
+    engine.setEq(rock, true);
+    await settle();
+
+    expect(contexts[0]!.sources).not.toContain(video);
+    expect(available()).toBe(false);
+  });
+
+  it("tries the self-test again when the video plays, if it could not run before", async () => {
+    const play = vi.spyOn(HTMLMediaElement.prototype, "play").mockRejectedValueOnce(new Error("NotAllowedError"));
+    const { engine, available } = await freshEngine();
+    const video = media<HTMLVideoElement>("video");
+    engine.setElements([video, null]);
+    engine.setEq(rock, true);
+    await settle();
+    expect(contexts[0]!.sources).not.toContain(video);
+    expect(available()).toBe(true);
+
+    play.mockResolvedValue(undefined);
+    video.dispatchEvent(new Event("play"));
+    await settle();
+    expect(contexts[0]!.sources).toContain(video);
+  });
+
+  it("never routes an element fetched without CORS, which would play silent", async () => {
+    const { engine } = await freshEngine();
+    const video = media<HTMLVideoElement>("video", false);
+    engine.setElements([video, null]);
+    engine.setEq(rock, true);
+    await settle();
+    expect(contexts[0]!.sources).not.toContain(video);
+  });
+});
diff --git a/src/lib/audio/mediaEqEngine.ts b/src/lib/audio/mediaEqEngine.ts
new file mode 100644
index 00000000..3d8d79a8
--- /dev/null
+++ b/src/lib/audio/mediaEqEngine.ts
@@ -0,0 +1,129 @@
+import { logToBackend } from "../diagnostics";
+import { createAudioContext, keepRunning, resumeWithin } from "./audioContext";
+import { EQ_GRAPH_OFF, type EqGraphSpec } from "./eq/graphPlan";
+import { EqChain } from "./eqChain";
+import { probeMediaElementRouting } from "./webAudioProbe";
+
+// One context for every video player in this window; each player keeps its own chain.
+let sharedContext: AudioContext | null = null;
+let routingWorks: Promise<boolean | null> | null = null;
+// WebAudio failed or delivered silence in this window: video plays from its elements alone.
+let unavailable = false;
+const routedElements = new Set<HTMLMediaElement>();
+
+function videoContext(): AudioContext | null {
+  if (!sharedContext) {
+    sharedContext = createAudioContext();
+    if (sharedContext) keepRunning(sharedContext, () => [...routedElements].some((el) => !el.paused));
+  }
+  return sharedContext;
+}
+
+/** Runs the routing self-test once per window; a test that could not run is tried again later. */
+function checkRouting(ctx: AudioContext): Promise<boolean | null> {
+  routingWorks ??= probeMediaElementRouting(ctx).then((works) => {
+    if (works === null) routingWorks = null;
+    if (works === false) {
+      unavailable = true;
+      void logToBackend("warn", "video equalizer off: WebAudio returned silence from a media element");
+    }
+    return works;
+  });
+  return routingWorks;
+}
+
+/**
+ * The equalizer for one video player: its <video> element and the separate <audio> element
+ * adaptive playback uses. Elements are routed through WebAudio only once the equalizer changes
+ * the sound, and each gets its source node exactly once in its life, as WebAudio requires.
+ */
+export class MediaEqEngine {
+  private chain: EqChain | null = null;
+  private elements: HTMLMediaElement[] = [];
+  private sources = new WeakMap<HTMLMediaElement, MediaElementAudioSourceNode>();
+  private watched = new WeakSet<HTMLMediaElement>();
+  private spec: EqGraphSpec = EQ_GRAPH_OFF;
+  private engaged = false;
+  private routing = false;
+
+  /** The player's current media elements; an element that left is let go. */
+  setElements(elements: (HTMLMediaElement | null)[]): void {
+    const next = elements.filter((el): el is HTMLMediaElement => el !== null);
+    for (const el of this.elements) {
+      if (next.includes(el)) continue;
+      this.sources.get(el)?.disconnect();
+      routedElements.delete(el);
+    }
+    this.elements = next;
+    for (const el of next) {
+      if (this.watched.has(el)) continue;
+      this.watched.add(el);
+      // A routed element needs its context running; one not routed yet gets another chance,
+      // since the self-test needs a context the webview lets run.
+      el.addEventListener("play", () => {
+        if (routedElements.has(el) && sharedContext) void resumeWithin(sharedContext);
+        else if (this.engaged) void this.route();
+      });
+    }
+    if (this.engaged) void this.route();
+  }
+
+  setEq(spec: EqGraphSpec, engaged: boolean): void {
+    this.spec = spec;
+    this.engaged = engaged;
+    if (engaged) void this.route();
+    this.chain?.apply(spec);
+  }
+
+  dispose(): void {
+    this.setElements([]);
+    this.chain?.output.disconnect();
+    this.chain = null;
+  }
+
+  private async route(): Promise<void> {
+    if (unavailable || this.routing) return;
+    const ctx = videoContext();
+    if (!ctx) {
+      unavailable = true;
+      return;
+    }
+    this.routing = true;
+    try {
+      if ((await checkRouting(ctx)) !== true || !this.engaged) return;
+      if (!this.chain) {
+        this.chain = new EqChain(ctx);
+        this.chain.output.connect(ctx.destination);
+        this.chain.apply(this.spec);
+      }
+      for (const el of this.elements) this.connect(ctx, this.chain, el);
+    } catch (error) {
+      unavailable = true;
+      console.warn("[mediaEqEngine] WebAudio unavailable, video plays without the equalizer", error);
+    } finally {
+      this.routing = false;
+    }
+  }
+
+  private connect(ctx: AudioContext, chain: EqChain, el: HTMLMediaElement): void {
+    if (this.sources.has(el) && routedElements.has(el)) return;
+    // Without CORS from the start the samples reach WebAudio as silence.
+    if (el.crossOrigin !== "anonymous") return;
+    let source = this.sources.get(el);
+    if (!source) {
+      source = ctx.createMediaElementSource(el);
+      this.sources.set(el, source);
+      void logToBackend("info", "video equalizer routed", {
+        element: el.tagName.toLowerCase(),
+        baseLatencyMs: Math.round(ctx.baseLatency * 1_000),
+        outputLatencyMs: Math.round((ctx.outputLatency ?? 0) * 1_000),
+      });
+    }
+    source.connect(chain.input);
+    routedElements.add(el);
+    if (!el.paused) void resumeWithin(ctx);
+  }
+}
+
+/** False once WebAudio failed or proved silent for video in this window. */
+export const videoEqAvailable = (): boolean => !unavailable;
diff --git a/src/lib/audio/useVideoEq.ts b/src/lib/audio/useVideoEq.ts
new file mode 100644
index 00000000..5784ab0f
--- /dev/null
+++ b/src/lib/audio/useVideoEq.ts
@@ -0,0 +1,46 @@
+import { useEffect, useRef, type RefObject } from "react";
+
+import { bindEqPersistence, useEqStore } from "../../store/useEqStore";
+import { REFERENCE_SAMPLE_RATE } from "./eq/filterMath";
+import { graphChangesSound, graphSpec } from "./eq/graphPlan";
+import { changesSound } from "./eq/stateOps";
+import { MediaEqEngine } from "./mediaEqEngine";
+
+/**
+ * Applies the shared equalizer to one video player. `audioKey` changes whenever the separate
+ * adaptive-playback <audio> element mounts, unmounts or changes, so the engine follows it.
+ */
+export function useVideoEq(
+  videoRef: RefObject<HTMLVideoElement | null>,
+  audioRef: RefObject<HTMLAudioElement | null>,
+  audioKey: string | null,
+): void {
+  const engineRef = useRef<MediaEqEngine | null>(null);
+
+  useEffect(() => {
+    // The pop-out window is its own JS context: it reads the equalizer from its settings.
+    bindEqPersistence();
+    const engine = new MediaEqEngine();
+    engineRef.current = engine;
+    const apply = () => {
+      const { state, bypass, preview } = useEqStore.getState();
+      const engaged =
+        changesSound(state) ||
+        (preview !== null && graphChangesSound(graphSpec(state, false, preview), REFERENCE_SAMPLE_RATE));
+      engine.setEq(graphSpec(state, bypass, preview), engaged);
+    };
+    apply();
+    const unsubscribe = useEqStore.subscribe((s, previous) => {
+      if (s.state !== previous.state || s.bypass !== previous.bypass || s.preview !== previous.preview) apply();
+    });
+    return () => {
+      unsubscribe();
+      engine.dispose();
+      engineRef.current = null;
+    };
+  }, []);
+
+  useEffect(() => {
+    engineRef.current?.setElements([videoRef.current, audioRef.current]);
+  }, [videoRef, audioRef, audioKey]);
+}
diff --git a/src/lib/audio/webAudioProbe.ts b/src/lib/audio/webAudioProbe.ts
new file mode 100644
index 00000000..efb8571c
--- /dev/null
+++ b/src/lib/audio/webAudioProbe.ts
@@ -0,0 +1,88 @@
+import { resumeWithin } from "./audioContext";
+
+const TONE_SECONDS = 0.5;
+const POLL_MS = 100;
+const GIVE_UP_MS = 1_500;
+const AUDIBLE = 1e-4;
+
+/**
+ * Half a second of a quiet 440 Hz tone as a WAV file, made in memory so it needs no network.
+ * It is written at the context's own rate: macOS WebKit hands a MediaElementAudioSourceNode
+ * silence for an 8 kHz file, which would read as broken routing.
+ */
+function toneWav(sampleRate: number): Blob {
+  const samples = Math.round(sampleRate * TONE_SECONDS);
+  const buffer = new ArrayBuffer(44 + samples * 2);
+  const view = new DataView(buffer);
+  const text = (offset: number, value: string) => {
+    for (let i = 0; i < value.length; i++) view.setUint8(offset + i, value.charCodeAt(i));
+  };
+  text(0, "RIFF");
+  view.setUint32(4, 36 + samples * 2, true);
+  text(8, "WAVE");
+  text(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  text(36, "data");
+  view.setUint32(40, samples * 2, true);
+  for (let i = 0; i < samples; i++) {
+    view.setInt16(44 + i * 2, Math.round(3_000 * Math.sin((2 * Math.PI * 440 * i) / sampleRate)), true);
+  }
+  return new Blob([buffer], { type: "audio/wav" });
+}
+
+const peak = (analyser: AnalyserNode, data: Float32Array<ArrayBuffer>): number => {
+  analyser.getFloatTimeDomainData(data);
+  let max = 0;
+  for (const v of data) max = Math.max(max, Math.abs(v));
+  return max;
+};
+
+/**
+ * Whether audio from a media element actually comes out of WebAudio here. WebKitGTK has shipped
+ * builds where a MediaElementAudioSourceNode delivers only silence, and an element handed to
+ * WebAudio can never play on its own again, so the real players are only routed once a throwaway
+ * element has proved it works. The tone goes to a muted sink and is never heard.
+ *
+ * Null when the test could not run (the element was not allowed to play), so it can be retried.
+ */
+export async function probeMediaElementRouting(ctx: AudioContext): Promise<boolean | null> {
+  const url = URL.createObjectURL(toneWav(ctx.sampleRate));
+  const el = new Audio();
+  el.loop = true;
+  el.src = url;
+  const source = ctx.createMediaElementSource(el);
+  const analyser = ctx.createAnalyser();
+  const sink = ctx.createGain();
+  sink.gain.value = 0;
+  source.connect(analyser);
+  analyser.connect(sink);
+  sink.connect(ctx.destination);
+  try {
+    await resumeWithin(ctx);
+    try {
+      await el.play();
+    } catch {
+      return null;
+    }
+    const data = new Float32Array(analyser.fftSize);
+    const started = Date.now();
+    while (Date.now() - started < GIVE_UP_MS) {
+      if (peak(analyser, data) > AUDIBLE) return true;
+      await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    }
+    // Only a running context that still delivered nothing proves the routing is broken.
+    return ctx.state === "running" ? false : null;
+  } finally {
+    el.pause();
+    source.disconnect();
+    sink.disconnect();
+    el.removeAttribute("src");
+    URL.revokeObjectURL(url);
+  }
+}
diff --git a/src/lib/i18n/strings.json b/src/lib/i18n/strings.json
index b0f526b2..ea2902ad 100644
--- a/src/lib/i18n/strings.json
+++ b/src/lib/i18n/strings.json
@@ -1154,6 +1154,9 @@
   "eq_preset_rock": "Rock",
   "eq_preset_vocal": "Vocal / Podcast",
   "eq_preset_custom": "Custom",
+  "eq_state_on": "On",
+  "eq_state_off": "Off",
+  "eq_state_unavailable": "Not available",
   "eq_presets": "Presets",
   "eq_edit": "Edit",
   "eq_edited": "Edited",
diff --git a/src/store/useEqStore.ts b/src/store/useEqStore.ts
index 74c33d9b..8ec64946 100644
--- a/src/store/useEqStore.ts
+++ b/src/store/useEqStore.ts
@@ -20,6 +20,8 @@ interface EqStoreState {
   /** Held Compare: the players hear the unprocessed sound. Never saved. */
   bypass: boolean;
   editorOpen: boolean;
+  /** Whether this window has the editor; the pop-out player window does not. */
+  editorHosted: boolean;
   /**
    * The unsaved curve each mode had before a preset replaced it, so it stays one click away as
    * Custom. Kept for the session: Android's saved state has no field for it.
@@ -59,6 +61,7 @@ export const useEqStore = create<EqStoreState>((set, get) => ({
   preview: null,
   bypass: false,
   editorOpen: false,
+  editorHosted: false,
   custom: {},
 
   update: (transform) => {
@@ -104,8 +107,15 @@ function adopt(raw: string): void {
   if (save || edits.length > 0) scheduleSave();
 }
 
-/** Loads the equalizer once settings have loaded, and follows restores and syncs after that. */
+let persistenceBound = false;
+
+/**
+ * Loads the equalizer once settings have loaded, and follows restores and syncs after that.
+ * Music and every video player call it; it binds once per window.
+ */
 export function bindEqPersistence(): void {
+  if (persistenceBound) return;
+  persistenceBound = true;
   const follow = () => {
     const settings = useAppSettingsStore.getState();
     if (!settings.loaded) return;