From dc1d4730ba47ce599a3d4db5922613470ffd34d5 Mon Sep 17 00:00:00 2001
From: Sean Rhodes <sean@starlabs.systems>
Date: Sat, 3 Oct 2026 10:16:40 +0100
Subject: [PATCH 1/8] Sound: Add noise cancellation controls

Add a noise cancellation switch for the selected input.

Let settings-daemon own processing so it continues after Settings closes.
Keep its internal streams out of Applications.

Test=Private PulseAudio/PipeWire: InputPanel switch and device changes.
---
 po/POTFILES                             |   1 +
 src/EchoCancellation.vala               | 111 +++++
 src/InputPanel.vala                     |  69 ++-
 src/PulseAudioManager.vala              | 636 +++++++++++++++++++-----
 src/meson.build                         |   1 +
 tests/aec-regression/audio-owner.vala   |  16 +
 tests/aec-regression/echo-client.vala   |  66 +++
 tests/aec-regression/run-functional.py  | 356 +++++++++++++
 tests/aec-regression/stream-client.vala |  65 +++
 tests/aec-regression/ui-client.vala     | 384 ++++++++++++++
 tests/run-aec.sh                        |  26 +
 vapi/libpulse-ext.vapi                  |   8 +
 12 files changed, 1601 insertions(+), 138 deletions(-)
 create mode 100644 src/EchoCancellation.vala
 create mode 100644 tests/aec-regression/audio-owner.vala
 create mode 100644 tests/aec-regression/echo-client.vala
 create mode 100644 tests/aec-regression/run-functional.py
 create mode 100644 tests/aec-regression/stream-client.vala
 create mode 100644 tests/aec-regression/ui-client.vala
 create mode 100755 tests/run-aec.sh

diff --git a/po/POTFILES b/po/POTFILES
index 22037789..cde11a67 100644
--- a/po/POTFILES
+++ b/po/POTFILES
@@ -5,6 +5,7 @@ src/TestPopover.vala
 src/PulseAudioManager.vala
 src/Plug.vala
 src/OutputPanel.vala
+src/EchoCancellation.vala
 src/InputPanel.vala
 src/InputDeviceMonitor.vala
 src/DeviceRow.vala
diff --git a/src/EchoCancellation.vala b/src/EchoCancellation.vala
new file mode 100644
index 00000000..240627dc
--- /dev/null
+++ b/src/EchoCancellation.vala
@@ -0,0 +1,111 @@
+/*
+ * SPDX-License-Identifier: LGPL-2.0-or-later
+ * SPDX-FileCopyrightText: 2026 elementary, Inc. (https://elementary.io)
+ */
+
+public class Sound.EchoCancellation : Object {
+    public const string SOURCE_NAME = "elementary_echo_cancel_source";
+    public const string SINK_NAME = "elementary_echo_cancel_sink";
+
+    public struct Status {
+        public bool enabled;
+        public bool available;
+        public bool busy;
+        public string error;
+        public string source_master;
+        public string sink_master;
+    }
+
+    [DBus (name = "io.elementary.settings_daemon.Audio")]
+    private interface Audio : DBusProxy {
+        public abstract async Status get_status () throws DBusError, IOError;
+        public signal void state_changed ();
+    }
+
+    public bool requested { get; set; }
+    public bool enabled { get; private set; }
+    public bool available { get; private set; }
+    public bool busy { get; private set; }
+    public string? error { get; private set; }
+    public string? source_master { get; private set; }
+    public string? sink_master { get; private set; }
+
+    private Settings? settings;
+    private Audio? audio;
+    private uint owner_generation;
+
+    construct {
+        var schema = SettingsSchemaSource.get_default ().lookup ("io.elementary.settings-daemon.audio", true);
+        if (schema == null) {
+            error = _("The settings audio service is unavailable.");
+            return;
+        }
+        settings = new Settings.full (schema, null, null);
+        settings.bind ("echo-cancellation", this, "requested", SettingsBindFlags.DEFAULT);
+        Bus.watch_name (SESSION, "io.elementary.settings-daemon", NONE, (connection) => {
+            var generation = ++owner_generation;
+            connection.get_proxy.begin<Audio> ("io.elementary.settings-daemon", "/io/elementary/settings_daemon", NONE,
+                null, (obj, res) => {
+                    try {
+                        var proxy = connection.get_proxy.end<Audio> (res);
+                        if (generation != owner_generation) {
+                            return;
+                        }
+                        audio = proxy;
+                        audio.state_changed.connect (() => refresh.begin ());
+                        refresh.begin ();
+                    } catch (Error e) {
+                        if (generation == owner_generation) {
+                            error = e.message;
+                        }
+                    }
+                });
+        }, () => {
+            owner_generation++;
+            audio = null;
+            source_master = sink_master = null;
+            enabled = available = busy = false;
+            error = _("The settings audio service is unavailable.");
+        });
+    }
+
+    public async void refresh () {
+        var generation = owner_generation;
+        var service = audio;
+        if (service == null) {
+            return;
+        }
+        try {
+            var status = yield service.get_status ();
+            if (generation != owner_generation || service != audio) {
+                return;
+            }
+            enabled = status.enabled;
+            available = status.available;
+            busy = status.busy;
+            error = status.error;
+            source_master = status.source_master == "" ? null : status.source_master;
+            sink_master = status.sink_master == "" ? null : status.sink_master;
+        } catch (Error e) {
+            if (generation != owner_generation || service != audio) {
+                return;
+            }
+            available = busy = false;
+            error = e.message;
+        }
+    }
+
+    public void request (bool enable) {
+        if (settings != null) {
+            requested = enable;
+        }
+    }
+
+    public string? resolve_source (string? name) {
+        return name == SOURCE_NAME ? source_master : name;
+    }
+
+    public string? resolve_sink (string? name) {
+        return name == SINK_NAME ? sink_master : name;
+    }
+}
diff --git a/src/InputPanel.vala b/src/InputPanel.vala
index 3fb0be1e..2a232be7 100644
--- a/src/InputPanel.vala
+++ b/src/InputPanel.vala
@@ -11,7 +11,12 @@ public class Sound.InputPanel : Gtk.Box {
     private Gtk.ListBox devices_listbox;
     private Gtk.Scale volume_scale;
     private Gtk.Switch volume_switch;
+    private Gtk.Switch echo_switch;
+    private Gtk.Label echo_status;
+    private ulong echo_switch_handler;
+    private EchoCancellation echo_cancellation;
     private InputDeviceMonitor device_monitor;
+    private bool monitor_visible;
     private unowned PulseAudioManager pam;
 
     construct {
@@ -74,10 +79,42 @@ public class Sound.InputPanel : Gtk.Box {
         volume_grid.attach (volume_scale, 0, 2);
         volume_grid.attach (volume_switch, 1, 1, 1, 2);
 
+        echo_switch = new Gtk.Switch () {
+            valign = START
+        };
+        echo_switch_handler = echo_switch.notify["active"].connect (() => {
+            echo_cancellation.request (echo_switch.active);
+        });
+
+        var echo_description = new Gtk.Label (
+            _("Reduce background noise and speaker echo in new applications using the default microphone.")
+        ) {
+            wrap = true,
+            xalign = 0,
+            hexpand = true
+        };
+        echo_description.add_css_class (Granite.STYLE_CLASS_DIM_LABEL);
+
+        echo_status = new Gtk.Label (null) {
+            wrap = true,
+            xalign = 0
+        };
+        echo_status.add_css_class (Granite.STYLE_CLASS_DIM_LABEL);
+
+        var echo_grid = new Gtk.Grid () {
+            column_spacing = 12,
+            row_spacing = 3
+        };
+        echo_grid.attach (new Granite.HeaderLabel (_("Noise Cancellation")), 0, 0);
+        echo_grid.attach (echo_description, 0, 1);
+        echo_grid.attach (echo_status, 0, 2);
+        echo_grid.attach (echo_switch, 1, 0, 1, 2);
+
         orientation = VERTICAL;
         spacing = 18;
         append (devices_frame);
         append (volume_grid);
+        append (echo_grid);
 
         device_monitor = new InputDeviceMonitor ();
         device_monitor.update_fraction.connect ((fraction) => {
@@ -85,6 +122,9 @@ public class Sound.InputPanel : Gtk.Box {
         });
 
         pam = PulseAudioManager.get_default ();
+        echo_cancellation = pam.echo_cancellation;
+        echo_cancellation.notify.connect (echo_status_changed);
+        echo_status_changed ();
         pam.new_device.connect (add_device);
         pam.notify["default-input"].connect (() => {
             default_changed ();
@@ -93,8 +133,23 @@ public class Sound.InputPanel : Gtk.Box {
         connect_signals ();
     }
 
+    private void echo_status_changed () {
+        SignalHandler.block (echo_switch, echo_switch_handler);
+        echo_switch.sensitive = !echo_cancellation.busy &&
+            (echo_cancellation.available || echo_cancellation.enabled || echo_cancellation.requested);
+        echo_switch.state = echo_cancellation.enabled;
+        // Setting active even to its current value cancels GTK's animation.
+        if (echo_switch.active != echo_cancellation.requested) {
+            echo_switch.active = echo_cancellation.requested;
+        }
+        SignalHandler.unblock (echo_switch, echo_switch_handler);
+        echo_status.label = echo_cancellation.error != null ? echo_cancellation.error : "";
+        echo_status.visible = echo_status.label != "";
+    }
+
     public void set_visibility (bool is_visible) {
-        if (is_visible) {
+        monitor_visible = is_visible;
+        if (is_visible && default_device != null) {
             device_monitor.start_record ();
         } else {
             device_monitor.stop_record ();
@@ -131,10 +186,18 @@ public class Sound.InputPanel : Gtk.Box {
             }
 
             default_device = pam.default_input;
+            volume_switch.sensitive = default_device != null;
+            volume_scale.sensitive = default_device != null && !default_device.is_muted;
+            if (default_device == null) {
+                device_monitor.stop_record ();
+            }
             if (default_device != null) {
                 device_monitor.set_device (default_device);
+                if (monitor_visible) {
+                    device_monitor.start_record ();
+                }
                 if (volume_switch.active == default_device.is_muted) {
-                    volume_switch.activate ();
+                    volume_switch.active = !default_device.is_muted;
                 }
                 volume_scale.set_value (default_device.volume);
                 default_device.notify.connect (device_notify);
@@ -149,7 +212,7 @@ public class Sound.InputPanel : Gtk.Box {
         switch (pspec.get_name ()) {
             case "is-muted":
                 if (volume_switch.active == default_device.is_muted) {
-                    volume_switch.activate ();
+                    volume_switch.active = !default_device.is_muted;
                 }
 
                 volume_scale.sensitive = !default_device.is_muted;
diff --git a/src/PulseAudioManager.vala b/src/PulseAudioManager.vala
index 7d5d9733..148c757d 100644
--- a/src/PulseAudioManager.vala
+++ b/src/PulseAudioManager.vala
@@ -41,6 +41,7 @@ public class Sound.PulseAudioManager : GLib.Object {
     public signal void new_device (Device dev);
 
     public PulseAudio.Context context { get; private set; }
+    public EchoCancellation echo_cancellation { get; private set; }
     public ListStore apps { get; construct; }
 
     private PulseAudio.GLibMainLoop loop;
@@ -52,6 +53,13 @@ public class Sound.PulseAudioManager : GLib.Object {
     public Device default_input { get; private set; }
     private string default_source_name;
     private string default_sink_name;
+    private string? physical_source_name;
+    private string? physical_sink_name;
+    private bool changing_device;
+    private signal void device_selection_finished ();
+    private uint sink_selection_generation;
+    private uint source_selection_generation;
+    private signal void physical_default_changed (bool input);
     private Gee.HashMap<uint32, PulseAudio.Operation> volume_operations;
 
     private PulseAudioManager () {
@@ -59,6 +67,22 @@ public class Sound.PulseAudioManager : GLib.Object {
     }
 
     construct {
+        echo_cancellation = new EchoCancellation ();
+        echo_cancellation.notify["source-master"].connect (() => {
+            if (is_ready) {
+                request_server_info.begin ();
+            }
+        });
+        echo_cancellation.notify["sink-master"].connect (() => {
+            if (is_ready) {
+                request_server_info.begin ();
+            }
+        });
+        echo_cancellation.notify["busy"].connect (() => {
+            if (is_ready && !echo_cancellation.busy) {
+                request_server_info.begin ();
+            }
+        });
         loop = new PulseAudio.GLibMainLoop ();
         apps = new ListStore (typeof (App));
         input_devices = new Gee.HashMap<string, Device> ();
@@ -80,135 +104,365 @@ public class Sound.PulseAudioManager : GLib.Object {
         debug ("\n");
         debug ("set_default_device: %s", device.id);
         debug ("\t%s", device.input? "input" : "output");
-        // #1 Set card profile
-        // Some sinks / sources are only available under certain card profiles,
-        // for example to switch between onboard speakers to hdmi
-        // the profile has to be switched from analog stereo to digital stereo.
-        // Attempt to find profiles that support both selected input and output
-        var other_device = device.input? default_output : default_input;
-
-        var profile_name = device.get_matching_profile (other_device);
-        // otherwise fall back to supporting this device only
-        if (profile_name == null) {
-            profile_name = device.profiles[0];
+        // Snapshot ordinary streams before a device change can rescue filtered
+        // streams onto their old physical master during an AEC rebuild.
+        while (changing_device || echo_cancellation.busy) {
+            if (!(yield wait_for_processing (device.input, null))) {
+                return;
+            }
         }
+        changing_device = true;
+        try {
+            var owner = context;
+            var streams = yield list_application_streams (device.input);
+            if (owner != context) {
+                return;
+            }
+            // #1 Set card profile
+            // Some sinks / sources are only available under certain card profiles,
+            // for example to switch between onboard speakers to hdmi
+            // the profile has to be switched from analog stereo to digital stereo.
+            // Attempt to find profiles that support both selected input and output
+            var other_device = device.input? default_output : default_input;
+
+            var profile_name = device.get_matching_profile (other_device);
+            // otherwise fall back to supporting this device only
+            if (profile_name == null) {
+                profile_name = device.profiles[0];
+            }
 
-        if (profile_name != device.card_active_profile_name) {
-            debug ("set card profile: %s > %s", device.card_active_profile_name, profile_name);
-            // switch profile to get sink for this device
-            yield set_card_profile_by_index (device.card_index, profile_name);
-            // wait for new card sink to appear
-            debug ("wait for card sink / source");
-            yield wait_for_update (device, device.input? "card-source-name" : "card-sink-name");
-        }
+            if (profile_name != device.card_active_profile_name) {
+                debug ("set card profile: %s > %s", device.card_active_profile_name, profile_name);
+                // switch profile to get sink for this device
+                if (!(yield set_card_profile_by_index (device.card_index, profile_name))) {
+                    return;
+                }
+                // wait for new card sink to appear
+                debug ("wait for card sink / source");
+                if (!(yield wait_for_update (device, device.input? "card-source-name" : "card-sink-name"))) {
+                    return;
+                }
+            }
 
-        // #2 Set sink / source port
-        // Speakers and headphones can be different ports on the same sink
-        if (!device.input && device.port_name != device.card_sink_port_name) {
-            debug ("set sink port: %s > %s", device.card_sink_port_name, device.port_name);
-            // set sink port (enables switching between headphones and speakers for example)
-            yield set_sink_port_by_name (device.card_sink_name, device.port_name);
-        }
+            // #2 Set sink / source port
+            // Speakers and headphones can be different ports on the same sink
+            if (!device.input && device.port_name != device.card_sink_port_name) {
+                debug ("set sink port: %s > %s", device.card_sink_port_name, device.port_name);
+                // set sink port (enables switching between headphones and speakers for example)
+                if (!(yield set_sink_port_by_name (device.card_sink_name, device.port_name))) {
+                    return;
+                }
+            }
 
-        if (device.input && device.port_name != device.card_source_port_name) {
-            debug ("set source port: %s > %s", device.card_source_port_name, device.port_name);
-            yield set_source_port_by_name (device.card_source_name, device.port_name);
-        }
+            if (device.input && device.port_name != device.card_source_port_name) {
+                debug ("set source port: %s > %s", device.card_source_port_name, device.port_name);
+                if (!(yield set_source_port_by_name (device.card_source_name, device.port_name))) {
+                    return;
+                }
+            }
+
+            // #3 Wait for sink / source to appear for this device
+            if (!device.input && device.sink_name == null ||
+                device.input && device.source_name == null) {
+                debug ("wait for sink / source");
+                if (!(yield wait_for_update (device, device.input? "source-name" : "sink-name"))) {
+                    return;
+                }
+            }
+
+            yield request_server_info ();
+            if (owner != context) {
+                return;
+            }
+            // #4 Set sink / source
+            // To for example switch between onboard speakers and bluetooth audio devices
+            if (!device.input && device.sink_name != default_sink_name) {
+                debug ("set sink: %s > %s", default_sink_name, device.sink_name);
+                if (!(yield set_default_sink (device.sink_name, streams))) {
+                    return;
+                }
+            }
 
-        // #3 Wait for sink / source to appear for this device
-        if (!device.input && device.sink_name == null ||
-            device.input && device.source_name == null) {
-            debug ("wait for sink / source");
-            yield wait_for_update (device, device.input? "source-name" : "sink-name");
+            if (device.input && device.source_name != default_source_name) {
+                debug ("set source: %s > %s", default_source_name, device.source_name);
+                if (!(yield set_default_source (device.source_name, streams))) {
+                    return;
+                }
+            }
+            yield wait_for_processing (device.input, device.input ? physical_source_name : physical_sink_name,
+                device.input ? source_selection_generation : sink_selection_generation);
+        } finally {
+            changing_device = false;
+            device_selection_finished ();
         }
+    }
 
-        // #4 Set sink / source
-        // To for example switch between onboard speakers and bluetooth audio devices
-        if (!device.input && device.sink_name != default_sink_name) {
-            debug ("set sink: %s > %s", default_sink_name, device.sink_name);
-            yield set_default_sink (device.sink_name);
+    // Completion, cancellation, disconnect and timeout all resume the caller.
+    // Cancel before releasing callback data on timeout (libpulse's contract).
+    private async bool wait_operation (PulseAudio.Operation? operation) {
+        if (operation == null) {
+            return false;
         }
 
-        if (device.input && device.source_name != default_source_name) {
-            debug ("set source: %s > %s", default_source_name, device.source_name);
-            yield set_default_source (device.source_name);
+        if (operation.get_state () != PulseAudio.Operation.State.RUNNING) {
+            return operation.get_state () == PulseAudio.Operation.State.DONE;
         }
-    }
 
-    private async void set_card_profile_by_index (uint32 card_index, string profile_name) {
-        context.set_card_profile_by_index (card_index, profile_name, (c, success) => {
-            if (success == 1) {
-                set_card_profile_by_index.callback ();
-            } else {
-                warning ("setting card %u profile to %s failed", card_index, profile_name);
+        bool timed_out = false;
+        var timeout = new TimeoutSource (5000);
+        timeout.set_callback (() => {
+            timed_out = true;
+            operation.cancel ();
+            wait_operation.callback ();
+            return Source.REMOVE;
+        });
+        PulseAudio.operation_set_state_callback (operation, (op) => {
+            if (!timed_out && op.get_state () != PulseAudio.Operation.State.RUNNING) {
+                timeout.destroy ();
+                wait_operation.callback ();
             }
         });
-
+        timeout.attach ();
         yield;
+        PulseAudio.operation_set_state_callback (operation, null);
+        return !timed_out && operation.get_state () == PulseAudio.Operation.State.DONE;
+    }
+
+    private async bool set_card_profile_by_index (uint32 card_index, string profile_name) {
+        bool selected = false;
+        var operation = context.set_card_profile_by_index (card_index, profile_name, (c, success) => {
+            selected = success == 1;
+        });
+        if (!(yield wait_operation (operation)) || !selected) {
+            warning ("setting card %u profile to %s failed", card_index, profile_name);
+            return false;
+        }
+        return true;
     }
 
-    // TODO make more robust. Add timeout? Prevent multiple connects?
-    private async void wait_for_update (Device device, string prop_name) {
-        debug ("wait_for_update: %s:%s", device.id, prop_name);
-        ulong handler_id = 0;
-        handler_id = device.notify[prop_name].connect ((s, p) => {
-            string prop_value;
-            device.get (prop_name, out prop_value);
-            if (prop_value != null) {
-                device.disconnect (handler_id);
+    private async bool wait_for_update (Device device, string prop_name) {
+        bool success = false;
+        bool finished = false;
+        var deadline = new TimeoutSource (5000);
+        SourceFunc finish = () => {
+            if (!finished) {
+                finished = true;
+                deadline.destroy ();
                 wait_for_update.callback ();
             }
+            return Source.REMOVE;
+        };
+        ulong changed = device.notify[prop_name].connect (() => {
+            string value;
+            device.get (prop_name, out value);
+            if (value != null) {
+                success = true;
+                finish ();
+            }
         });
-
+        ulong removed = device.removed.connect (() => finish ());
+        deadline.set_callback (finish);
+        deadline.attach ();
         yield;
+        device.disconnect (changed);
+        device.disconnect (removed);
+        return success;
     }
 
-    private async void set_sink_port_by_name (string sink_name, string port_name) {
-        context.set_sink_port_by_name (sink_name, port_name, (c, success) => {
-            if (success == 1) {
-                set_sink_port_by_name.callback ();
-            } else {
-                warning ("setting sink %s port to %s failed", sink_name, port_name);
-            }
+    private async bool set_sink_port_by_name (string sink_name, string port_name) {
+        bool selected = false;
+        var operation = context.set_sink_port_by_name (sink_name, port_name, (c, success) => {
+            selected = success == 1;
         });
+        if (!(yield wait_operation (operation)) || !selected) {
+            warning ("setting sink %s port to %s failed", sink_name, port_name);
+            return false;
+        }
+        return true;
+    }
 
-        yield;
+    private async bool set_source_port_by_name (string source_name, string port_name) {
+        bool selected = false;
+        var operation = context.set_source_port_by_name (source_name, port_name, (c, success) => {
+            selected = success == 1;
+        });
+        if (!(yield wait_operation (operation)) || !selected) {
+            warning ("setting source %s port to %s failed", source_name, port_name);
+            return false;
+        }
+        return true;
     }
 
-    private async void set_source_port_by_name (string source_name, string port_name) {
-        context.set_source_port_by_name (source_name, port_name, (c, success) => {
-            if (success == 1) {
-                set_source_port_by_name.callback ();
-            } else {
-                warning ("setting source %s port to %s failed", source_name, port_name);
-            }
+    private async bool set_default_sink (string sink_name, Gee.ArrayList<uint> streams) {
+        var owner = context;
+        var generation = ++sink_selection_generation;
+        bool selected = false;
+        var operation = owner.set_default_sink (sink_name, (c, success) => {
+            selected = success == 1;
         });
+        if (!(yield wait_operation (operation)) || !selected) {
+            warning ("setting default sink to %s failed", sink_name);
+            if (owner == context) {
+                request_server_info.begin ();
+            }
+            return false;
+        }
+        if (owner != context) {
+            return false;
+        }
+        if (!(yield wait_for_processing (false, sink_name, generation)) || owner != context) {
+            return false;
+        }
+        // An A -> B -> A change can coalesce without advancing the observer.
+        yield request_server_info ();
+        if (owner != context) {
+            return false;
+        }
+        if (generation == sink_selection_generation && physical_sink_name == sink_name) {
+            yield restore_application_routes (false, sink_name, generation, streams);
+        }
+        return true;
+    }
 
-        yield;
+    private async bool set_default_source (string source_name, Gee.ArrayList<uint> streams) {
+        var owner = context;
+        var generation = ++source_selection_generation;
+        bool selected = false;
+        var operation = owner.set_default_source (source_name, (c, success) => {
+            selected = success == 1;
+        });
+        if (!(yield wait_operation (operation)) || !selected) {
+            warning ("setting default source to %s failed", source_name);
+            if (owner == context) {
+                request_server_info.begin ();
+            }
+            return false;
+        }
+        if (owner != context) {
+            return false;
+        }
+        if (!(yield wait_for_processing (true, source_name, generation)) || owner != context) {
+            return false;
+        }
+        yield request_server_info ();
+        if (owner != context) {
+            return false;
+        }
+        if (generation == source_selection_generation && physical_source_name == source_name) {
+            yield restore_application_routes (true, source_name, generation, streams);
+        }
+        return true;
     }
 
-    private async void set_default_sink (string sink_name) {
-        context.set_default_sink (sink_name, (c, success) => {
-            if (success == 1) {
-                set_default_sink.callback ();
-            } else {
-                warning ("setting default sink to %s failed", sink_name);
+    private async void restore_application_routes (bool input, string target, uint generation, Gee.ArrayList<uint> streams) {
+        var owner = context;
+        var deadline = new TimeoutSource (2000);
+        var operation = PulseAudio.ext_stream_restore_read (context, (c, info, eol) => {
+            if (owner == context && generation == (input ? source_selection_generation : sink_selection_generation)) {
+                update_stream_route (c, info, eol, input, target);
+            }
+            if (eol != 0) {
+                deadline.destroy ();
+                restore_application_routes.callback ();
             }
         });
-
+        if (operation == null) {
+            return;
+        }
+        // Keep the callback's target alive until enumeration ends or is canceled.
+        deadline.set_callback (() => {
+            operation.cancel ();
+            restore_application_routes.callback ();
+            return Source.REMOVE;
+        });
+        deadline.attach ();
         yield;
+        do {
+            if (!(yield wait_for_processing (input, target, generation)) || owner != context ||
+                generation != (input ? source_selection_generation : sink_selection_generation)) {
+                return;
+            }
+        } while (echo_cancellation.busy);
+        // A client may have opted into processing since the initial snapshot.
+        var ordinary = yield list_application_streams (input);
+        if (owner == context && generation == (input ? source_selection_generation : sink_selection_generation)) {
+            foreach (uint index in streams) {
+                if (!ordinary.contains (index)) {
+                    continue;
+                }
+                if (input) {
+                    owner.move_source_output_by_name (index, target);
+                } else {
+                    owner.move_sink_input_by_name (index, target);
+                }
+            }
+        }
     }
 
-    private async void set_default_source (string source_name) {
-        context.set_default_source (source_name, (c, success) => {
-            if (success == 1) {
-                set_default_source.callback ();
-            } else {
-                warning ("setting default source to %s failed", source_name);
+    private async Gee.ArrayList<uint> list_application_streams (bool input) {
+        var streams = new Gee.ArrayList<uint> ();
+        if (echo_cancellation.busy) {
+            return streams;
+        }
+        var devices = new Gee.ArrayList<uint> ();
+        var deadline = new TimeoutSource (2000);
+        PulseAudio.Operation? operation = null;
+        SourceFunc finished = () => {
+            deadline.destroy ();
+            list_application_streams.callback ();
+            return Source.REMOVE;
+        };
+        if (input) {
+            operation = context.get_source_info_list ((c, info, eol) => {
+                if (info != null && info.name != EchoCancellation.SOURCE_NAME) {
+                    devices.add (info.index);
+                }
+                if (eol < 0) {
+                    finished ();
+                } else if (eol > 0) {
+                    operation = c.get_source_output_info_list ((owner, stream, end) => {
+                        if (stream != null && stream.client != PulseAudio.INVALID_INDEX && devices.contains (stream.source)) {
+                            streams.add (stream.index);
+                        }
+                        if (end != 0) {
+                            finished ();
+                        }
+                    });
+                }
+            });
+        } else {
+            operation = context.get_sink_info_list ((c, info, eol) => {
+                if (info != null && info.name != EchoCancellation.SINK_NAME) {
+                    devices.add (info.index);
+                }
+                if (eol < 0) {
+                    finished ();
+                } else if (eol > 0) {
+                    operation = c.get_sink_input_info_list ((owner, stream, end) => {
+                        if (stream != null && stream.client != PulseAudio.INVALID_INDEX && devices.contains (stream.sink)) {
+                            streams.add (stream.index);
+                        }
+                        if (end != 0) {
+                            finished ();
+                        }
+                    });
+                }
+            });
+        }
+        if (operation == null) {
+            return streams;
+        }
+        deadline.set_callback (() => {
+            if (operation != null) {
+                operation.cancel ();
             }
+            streams.clear ();
+            list_application_streams.callback ();
+            return Source.REMOVE;
         });
-
+        deadline.attach ();
         yield;
+        return streams;
     }
 
     public void change_device_mute (Device? device, bool mute = true) {
@@ -289,6 +543,7 @@ public class Sound.PulseAudioManager : GLib.Object {
 
         var props = new PulseAudio.Proplist ();
         props.sets (PulseAudio.Proplist.PROP_APPLICATION_ID, "io.elementary.settings.sound");
+        physical_source_name = physical_sink_name = null;
         context = new PulseAudio.Context (loop.get_api (), null, props);
         context.set_state_callback (context_state_callback);
 
@@ -307,7 +562,7 @@ public class Sound.PulseAudioManager : GLib.Object {
                              PulseAudio.Context.SubscriptionMask.SINK_INPUT |
                              PulseAudio.Context.SubscriptionMask.SOURCE_OUTPUT |
                              PulseAudio.Context.SubscriptionMask.CARD);
-                context.get_server_info (server_info_callback);
+                request_server_info.begin ();
                 context.get_sink_input_info_list (sink_input_info_callback);
 
                 is_ready = true;
@@ -392,7 +647,7 @@ public class Sound.PulseAudioManager : GLib.Object {
                 break;
 
             case PulseAudio.Context.SubscriptionEventType.SERVER:
-                context.get_server_info (server_info_callback);
+                request_server_info.begin ();
                 break;
 
             case PulseAudio.Context.SubscriptionEventType.CARD:
@@ -415,7 +670,6 @@ public class Sound.PulseAudioManager : GLib.Object {
                 break;
 
             case PulseAudio.Context.SubscriptionEventType.SOURCE:
-            case PulseAudio.Context.SubscriptionEventType.SOURCE_OUTPUT:
                 var event_type = t & PulseAudio.Context.SubscriptionEventType.TYPE_MASK;
                 switch (event_type) {
                     case PulseAudio.Context.SubscriptionEventType.NEW:
@@ -434,6 +688,9 @@ public class Sound.PulseAudioManager : GLib.Object {
                                 device.source_name = null;
                                 device.source_index = -1;
                                 device.is_default = false;
+                                if (default_input == device) {
+                                    default_input = null;
+                                }
                                 debug ("\t\tdevice.source_name: %s", device.source_name);
                             }
 
@@ -500,7 +757,7 @@ public class Sound.PulseAudioManager : GLib.Object {
                     device.source_name = source.name;
                     debug ("\t\t\tdevice.source_name: %s", device.card_source_name);
                     device.source_index = (int)source.index;
-                    device.is_default = (source.name == default_source_name);
+                    device.is_default = (source.name == echo_cancellation.resolve_source (default_source_name));
                     debug ("\t\t\tis_default: %s", device.is_default ? "true" : "false");
 
                     device.is_muted = (source.mute != 0);
@@ -527,6 +784,9 @@ public class Sound.PulseAudioManager : GLib.Object {
                     device.source_name = null;
                     device.source_index = -1;
                     device.is_default = false;
+                    if (default_input == device) {
+                        default_input = null;
+                    }
                 }
             }
         }
@@ -572,7 +832,7 @@ public class Sound.PulseAudioManager : GLib.Object {
                     device.sink_name = sink.name;
                     debug ("\t\t\tdevice.sink_name: %s", device.card_sink_name);
                     device.sink_index = (int)sink.index;
-                    device.is_default = (sink.name == default_sink_name);
+                    device.is_default = (sink.name == echo_cancellation.resolve_sink (default_sink_name));
                     debug ("\t\t\tis_default: %s", device.is_default ? "true" : "false");
                     device.is_muted = (sink.mute != 0);
                     device.cvolume = sink.volume;
@@ -610,6 +870,13 @@ public class Sound.PulseAudioManager : GLib.Object {
             return;
         }
 
+        // Server-side filters are processing streams, not applications.
+        if (sink_input.client == PulseAudio.INVALID_INDEX &&
+            (sink_input.proplist.gets (PulseAudio.Proplist.PROP_MEDIA_ROLE) == "filter" ||
+             sink_input.proplist.gets ("node.virtual") == "true")) {
+            return;
+        }
+
         App? app = null;
         for (uint i = 0; i < apps.get_n_items (); i++) {
             var _app = (App) apps.get_item (i);
@@ -780,6 +1047,9 @@ public class Sound.PulseAudioManager : GLib.Object {
 
             if (!found) {
                 debug ("\t\tremoving device: %s", device.id);
+                if (default_input == device) {
+                    default_input = null;
+                }
                 device.removed ();
                 iter.unset ();
             }
@@ -821,38 +1091,45 @@ public class Sound.PulseAudioManager : GLib.Object {
             var device = iter.get_value ();
             if (device.card_index == card_index) {
                 debug ("removing device: %s", device.id);
+                if (default_input == device) {
+                    default_input = null;
+                }
                 device.removed ();
                 iter.unset ();
             }
         }
     }
 
-    private void server_info_callback (PulseAudio.Context context, PulseAudio.ServerInfo? server) {
+    private async void request_server_info () {
+        uint sink_generation = sink_selection_generation;
+        uint source_generation = source_selection_generation;
+        var operation = context.get_server_info ((owner, server) => {
+            server_info_callback (owner, server, sink_generation, source_generation);
+        });
+        yield wait_operation (operation);
+    }
+
+    private void server_info_callback (PulseAudio.Context context, PulseAudio.ServerInfo? server, uint sink_generation, uint source_generation) {
         debug ("server info update");
-        if (server == null) {
+        if (context != this.context || server == null) {
             return;
         }
 
-        if (default_sink_name == null) {
+        if (sink_generation == sink_selection_generation) {
             default_sink_name = server.default_sink_name;
-            debug ("\tdefault_sink_name: %s", default_sink_name);
-        }
-
-        if (default_sink_name != server.default_sink_name) {
-            debug ("\tdefault_sink_name: %s > %s", default_sink_name, server.default_sink_name);
-            default_sink_name = server.default_sink_name;
-            PulseAudio.ext_stream_restore_read (context, ext_stream_restore_read_sink_callback);
-        }
-
-        if (default_source_name == null) {
-            default_source_name = server.default_source_name;
-            debug ("\tdefault_source_name: %s", default_source_name);
+            if (default_sink_name == EchoCancellation.SINK_NAME) {
+                resolve_physical_default.begin (false, sink_generation);
+            } else {
+                update_physical_default (false, default_sink_name);
+            }
         }
-
-        if (default_source_name != server.default_source_name) {
-            debug ("\tdefault_source_name: %s > %s", default_source_name, server.default_source_name);
+        if (source_generation == source_selection_generation) {
             default_source_name = server.default_source_name;
-            PulseAudio.ext_stream_restore_read (context, ext_stream_restore_read_source_callback);
+            if (default_source_name == EchoCancellation.SOURCE_NAME) {
+                resolve_physical_default.begin (true, source_generation);
+            } else {
+                update_physical_default (true, default_source_name);
+            }
         }
 
         // request info on cards and ports before requesting info on
@@ -862,42 +1139,131 @@ public class Sound.PulseAudioManager : GLib.Object {
         context.get_sink_info_list (sink_info_callback);
     }
 
-    /*
-     * Change the Source
-     */
+    private async void resolve_physical_default (bool input, uint generation) {
+        // Keep captured generations alive until the native request completes.
+        PulseAudio.Operation? operation;
+        if (input) {
+            operation = context.get_source_info_by_name (EchoCancellation.SOURCE_NAME, (owner, info, eol) => {
+                if (owner == context && generation == source_selection_generation && info != null &&
+                    default_source_name == EchoCancellation.SOURCE_NAME && !echo_cancellation.busy &&
+                    info.proplist.gets ("device.master_device") == echo_cancellation.source_master) {
+                    update_physical_default (true, info.proplist.gets ("device.master_device"));
+                }
+            });
+        } else {
+            operation = context.get_sink_info_by_name (EchoCancellation.SINK_NAME, (owner, info, eol) => {
+                if (owner == context && generation == sink_selection_generation && info != null &&
+                    default_sink_name == EchoCancellation.SINK_NAME && !echo_cancellation.busy &&
+                    info.proplist.gets ("device.master_device") == echo_cancellation.sink_master) {
+                    update_physical_default (false, info.proplist.gets ("device.master_device"));
+                }
+            });
+        }
+        yield wait_operation (operation);
+    }
 
-    private void ext_stream_restore_read_sink_callback (PulseAudio.Context c, PulseAudio.ExtStreamRestoreInfo? info, int eol) {
-        if (eol != 0 || !info.name.has_prefix ("sink-input-by")) {
+    private void update_physical_default (bool input, string? name) {
+        if (name == null) {
             return;
         }
+        var previous = input ? physical_source_name : physical_sink_name;
+        if (input) {
+            physical_source_name = name;
+        } else {
+            physical_sink_name = name;
+        }
+        if (previous == null || previous == name) {
+            return;
+        }
+        uint generation = input ? ++source_selection_generation : ++sink_selection_generation;
+        physical_default_changed (input);
+        restore_external_routes.begin (input, name, generation);
+    }
 
-        // We need to duplicate the info but with the right device name
-        var new_info = PulseAudio.ExtStreamRestoreInfo ();
-        new_info.name = info.name;
-        new_info.channel_map = info.channel_map;
-        new_info.volume = info.volume;
-        new_info.mute = info.mute;
-        new_info.device = default_sink_name;
-        PulseAudio.ext_stream_restore_write (c, PulseAudio.UpdateMode.REPLACE, {new_info}, 1, (c, success) => {
-            if (success != 1) {
-                warning ("Updating source failed");
+    private async bool wait_for_processing (bool input, string? target, uint? generation = null) {
+        SourceFunc settled = () => {
+            var current = target;
+            if (generation != null && generation != (input ? source_selection_generation : sink_selection_generation)) {
+                current = input ? physical_source_name : physical_sink_name;
+            }
+            return (target != null || !changing_device) && !echo_cancellation.busy &&
+                (current == null || !echo_cancellation.enabled ||
+                (input ? echo_cancellation.source_master : echo_cancellation.sink_master) == current);
+        };
+        if (settled ()) {
+            return true;
+        }
+        var deadline = new TimeoutSource (5000);
+        bool resumed = false;
+        bool expired = false;
+        SourceFunc finish = () => {
+            if (!resumed && settled ()) {
+                resumed = true;
+                deadline.destroy ();
+                wait_for_processing.callback ();
+            }
+            return Source.REMOVE;
+        };
+        ulong default_handler = physical_default_changed.connect ((changed_input) => {
+            if (changed_input == input) {
+                finish ();
             }
         });
+        ulong selection_handler = device_selection_finished.connect (() => finish ());
+        ulong busy_handler = echo_cancellation.notify["busy"].connect (() => finish ());
+        ulong master_handler = echo_cancellation.notify[input ? "source-master" : "sink-master"].connect (() => finish ());
+        deadline.set_callback (() => {
+            expired = true;
+            resumed = true;
+            wait_for_processing.callback ();
+            return Source.REMOVE;
+        });
+        deadline.attach ();
+        yield;
+        disconnect (default_handler);
+        disconnect (selection_handler);
+        echo_cancellation.disconnect (busy_handler);
+        echo_cancellation.disconnect (master_handler);
+        // A queued selector rechecks and reserves the guard without yielding.
+        return !expired && (target == null || settled ());
     }
 
-    private void ext_stream_restore_read_source_callback (PulseAudio.Context c, PulseAudio.ExtStreamRestoreInfo? info, int eol) {
-        if (eol != 0 || !info.name.has_prefix ("source-output-by")) {
+    private async void restore_external_routes (bool input, string target, uint generation) {
+        var owner = context;
+        // Rescued AEC streams must be reattached before we enumerate ordinary
+        // applications on the physical device.
+        do {
+            if (!(yield wait_for_processing (input, target, generation)) || owner != context ||
+                generation != (input ? source_selection_generation : sink_selection_generation)) {
+                return;
+            }
+        } while (echo_cancellation.busy);
+        var streams = yield list_application_streams (input);
+        if (owner == context) {
+            yield restore_application_routes (input, target, generation, streams);
+        }
+    }
+
+    private void update_stream_route (PulseAudio.Context c, PulseAudio.ExtStreamRestoreInfo? info, int eol, bool input, string? target) {
+        if (eol != 0 || info == null || target == null ||
+            target == (input ? EchoCancellation.SOURCE_NAME : EchoCancellation.SINK_NAME) ||
+            info.device == (input ? EchoCancellation.SOURCE_NAME : EchoCancellation.SINK_NAME) ||
+            (info.device == null && echo_cancellation.requested) ||
+            !info.name.has_prefix (input ? "source-output-by" : "sink-input-by")) {
             return;
         }
 
-        // We need to duplicate the info but with the right device name
         var new_info = PulseAudio.ExtStreamRestoreInfo ();
         new_info.name = info.name;
         new_info.channel_map = info.channel_map;
         new_info.volume = info.volume;
         new_info.mute = info.mute;
-        new_info.device = default_source_name;
-        PulseAudio.ext_stream_restore_write (c, PulseAudio.UpdateMode.REPLACE, {new_info}, 1, null);
+        new_info.device = target;
+        PulseAudio.ext_stream_restore_write (c, PulseAudio.UpdateMode.REPLACE, {new_info}, 0, (owner, success) => {
+            if (success != 1) {
+                warning ("Updating application route failed");
+            }
+        });
     }
 
     /*
diff --git a/src/meson.build b/src/meson.build
index 7e03abe1..0e1f62b1 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -5,6 +5,7 @@ plug_files = files(
     'CanberraGtk4.vala',
     'TestPopover.vala',
     'PulseAudioManager.vala',
+    'EchoCancellation.vala',
     'Plug.vala',
     'OutputPanel.vala',
     'InputPanel.vala',
diff --git a/tests/aec-regression/audio-owner.vala b/tests/aec-regression/audio-owner.vala
new file mode 100644
index 00000000..ba8d1d58
--- /dev/null
+++ b/tests/aec-regression/audio-owner.vala
@@ -0,0 +1,16 @@
+// Private component harness: owns the production backend on a private bus.
+int main () {
+    assert (Environment.get_variable ("PULSE_SERVER").has_prefix ("unix:/tmp/vale-sound-"));
+    var loop = new MainLoop ();
+    Bus.own_name (SESSION, "io.elementary.settings-daemon", NONE, (connection) => {
+        try {
+            var audio = new SettingsDaemon.Backends.Audio ();
+            connection.register_object ("/io/elementary/settings_daemon", audio);
+            audio.start ();
+        } catch (Error e) {
+            error (e.message);
+        }
+    });
+    loop.run ();
+    return 0;
+}
diff --git a/tests/aec-regression/echo-client.vala b/tests/aec-regression/echo-client.vala
new file mode 100644
index 00000000..d67590aa
--- /dev/null
+++ b/tests/aec-regression/echo-client.vala
@@ -0,0 +1,66 @@
+// Standalone native client for the production EchoCancellation class.
+// Run only with the explicitly private socket supplied by run-functional.py.
+private MainLoop main_loop;
+private Sound.EchoCancellation controller;
+
+
+private void snapshot () {
+    var builder = new Json.Builder ();
+    builder.begin_object ();
+    builder.set_member_name ("enabled");
+    builder.add_boolean_value (controller.enabled);
+    builder.set_member_name ("available");
+    builder.add_boolean_value (controller.available);
+    builder.set_member_name ("busy");
+    builder.add_boolean_value (controller.busy);
+    builder.set_member_name ("error");
+    builder.add_string_value (controller.error ?? "");
+    builder.set_member_name ("source");
+    builder.add_string_value (controller.source_master ?? "");
+    builder.set_member_name ("sink");
+    builder.add_string_value (controller.sink_master ?? "");
+    builder.end_object ();
+    var generator = new Json.Generator ();
+    generator.set_root (builder.get_root ());
+    stdout.printf ("%s\n", generator.to_data (null));
+    stdout.flush ();
+}
+
+private void start_client () {
+    controller = new Sound.EchoCancellation ();
+    var input = new IOChannel.unix_new (0);
+    input.add_watch (IOCondition.IN | IOCondition.HUP, (channel, condition) => {
+        if (IOCondition.HUP in condition) {
+            main_loop.quit ();
+            return Source.REMOVE;
+        }
+
+        try {
+            string line;
+            channel.read_line (out line, null, null);
+            switch (line.strip ()) {
+                case "enable": controller.request (true); break;
+                case "disable": controller.request (false); break;
+                case "reopen": controller = new Sound.EchoCancellation (); break;
+                case "refresh": controller.refresh.begin (); break;
+                case "quit": main_loop.quit (); return Source.REMOVE;
+            }
+        } catch (IOChannelError e) {
+            error ("stdin: %s", e.message);
+        } catch (ConvertError e) {
+            error ("stdin: %s", e.message);
+        }
+
+        return Source.CONTINUE;
+    });
+    Timeout.add (100, () => { snapshot (); return Source.CONTINUE; });
+}
+
+int main () {
+    var server = Environment.get_variable ("PULSE_SERVER");
+    assert (server != null && server.has_prefix ("unix:/tmp/vale-sound-"));
+    main_loop = new MainLoop ();
+    start_client ();
+    main_loop.run ();
+    return 0;
+}
diff --git a/tests/aec-regression/run-functional.py b/tests/aec-regression/run-functional.py
new file mode 100644
index 00000000..f5ffeba6
--- /dev/null
+++ b/tests/aec-regression/run-functional.py
@@ -0,0 +1,356 @@
+#!/usr/bin/env python3
+"""Private native Pulse/PipeWire tests; run inside vale-sound-sdk, never on host.
+Production code is exercised by echo-client, compiled from EchoCancellation.vala.
+The documented pactl client supplies fixtures and independently inspects state.
+"""
+import json, os, pathlib, queue, select as fd_select, signal, subprocess, sys, tempfile, threading, time
+
+ROOT = pathlib.Path(__file__).resolve().parents[2]
+FIXTURE = pathlib.Path(__file__).resolve().parent
+assert ROOT.joinpath('src/EchoCancellation.vala').exists()
+assert not pathlib.Path('/dev/snd').exists(), 'Refuse to run with hardware audio accessible'
+KIND = sys.argv[1]
+UI_ONLY = '--ui-only' in sys.argv
+RUN_NAME = KIND + ('-ui-only' if UI_ONLY else '')
+assert all(arg == '--ui-only' for arg in sys.argv[2:])
+assert KIND in ('pulse', 'pipewire', 'pulse-denied')
+TEMP = pathlib.Path(tempfile.mkdtemp(prefix='vale-sound-' + KIND + '-'))
+TEMP.chmod(0o700)
+ENV = dict(os.environ, XDG_RUNTIME_DIR=str(TEMP), XDG_CONFIG_HOME=str(TEMP/'user-config'),
+           XDG_STATE_HOME=str(TEMP/'state'), XDG_CACHE_HOME=str(TEMP/'cache'),
+           PULSE_SERVER='unix:' + str(TEMP/'native'), PIPEWIRE_RUNTIME_DIR=str(TEMP),
+           PIPEWIRE_REMOTE='pipewire-0', GSETTINGS_SCHEMA_DIR=str(ROOT/'tests/schemas'),
+           GSETTINGS_BACKEND='keyfile', ALSA_CONFIG_PATH=str(TEMP/'asound.conf'))
+ENV.pop('DBUS_SESSION_BUS_ADDRESS', None)
+ENV.pop('DISPLAY', None)
+ENV.pop('WAYLAND_DISPLAY', None)
+for key in ('PIPEWIRE_CONFIG_PREFIX', 'PIPEWIRE_CONFIG_NAME', 'PIPEWIRE_CORE'):
+    ENV.pop(key, None)
+TEMP.joinpath('asound.conf').write_text('pcm.!default { type null }\n')
+PROCESSES = []
+LOGS = []
+RESULTS = []
+
+def launch(args, **kwargs):
+    p = subprocess.Popen(args, env=ENV, **kwargs)
+    PROCESSES.append(p)
+    return p
+
+def daemon(name, args):
+    f = open(TEMP/(name+'.log'), 'w'); LOGS.append(f)
+    return launch(args, stdout=f, stderr=f)
+
+def pactl(*args, check=True):
+    p = subprocess.run(['pactl', *map(str,args)], env=ENV, text=True, capture_output=True, timeout=8)
+    if check and p.returncode: raise AssertionError((args,p.stderr))
+    return p.stdout.strip()
+
+def items(kind): return json.loads(pactl('-f','json','list',kind))
+def modules():
+    return [fields for line in pactl('list','short','modules').splitlines() if len(fields := line.split('\t',3)) >= 3 and fields[0].isdigit()]
+def owned(): return [x for x in modules() if x[1]=='module-echo-cancel' and 'device.echo_cancel.owner=io.elementary.settings.sound' in x[2]]
+def eventually(fn, limit=8):
+    end=time.monotonic()+limit
+    while time.monotonic()<end:
+        value=fn()
+        if value:return value
+        time.sleep(.03)
+    raise AssertionError('Timed out: '+repr(fn))
+
+def defaults():
+    text=pactl('info')
+    return tuple(next(line.split(': ',1)[1] for line in text.splitlines() if line.startswith('Default '+kind+':')) for kind in ('Source','Sink'))
+
+def select(source='physical_input', sink='physical_output'):
+    pactl('set-default-source',source);pactl('set-default-sink',sink)
+    eventually(lambda:defaults()==(source,sink))
+
+def volumes():
+    out={}
+    for kind,name in [('sources','physical_input'),('sinks','physical_output')]:
+        x=next(x for x in items(kind) if x['name']==name)
+        out[name]=(tuple(v['value'] for v in x['volume'].values()),x['mute'])
+    return out
+
+class Client:
+    def __init__(self):
+        self.errors=open(TEMP/('client-'+str(len(PROCESSES))+'.log'),'w');LOGS.append(self.errors)
+        self.p=launch([str(FIXTURE / 'echo-client')],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=self.errors,text=True)
+        self.q=queue.Queue(); self.last={}
+        def read():
+            for line in self.p.stdout:
+                self.q.put(json.loads(line))
+        threading.Thread(target=read,daemon=True).start()
+    def command(self,command):
+        while not self.q.empty():self.last=self.q.get()
+        self.p.stdin.write(command+'\n');self.p.stdin.flush()
+    def wait(self,fn,limit=10):
+        end=time.monotonic()+limit;stable=None
+        while time.monotonic()<end:
+            try:self.last=self.q.get(timeout=.2)
+            except queue.Empty:
+                assert self.p.poll() is None, 'Native client exited'
+                continue
+            if fn(self.last) and not self.last['busy']:
+                stable=stable or time.monotonic()
+                if time.monotonic()-stable>.15:return self.last
+            else:stable=None
+        raise AssertionError('Controller timeout: '+repr(self.last))
+    def stop(self):
+        if self.p.poll() is None:self.command('quit');self.p.wait(timeout=6)
+
+def ui_smoke():
+    ui=subprocess.run(['xvfb-run','-a',str(FIXTURE / 'ui-client')],env=ENV,
+                      capture_output=True,text=True,timeout=65)
+    FIXTURE.joinpath(RUN_NAME+'-ui.log').write_text(ui.stdout+ui.stderr)
+    if ui.returncode != 0:
+        status = subprocess.run(['gdbus','call','--session','--dest','io.elementary.settings-daemon',
+            '--object-path','/io/elementary/settings_daemon','--method','io.elementary.settings_daemon.Audio.GetStatus'],
+            env=ENV, text=True, capture_output=True, timeout=8)
+        FIXTURE.joinpath(RUN_NAME+'-ui-failure.json').write_text(json.dumps(
+            dict(status=status.stdout, error=status.stderr, modules=modules(), defaults=defaults()), indent=2)+'\n')
+    assert ui.returncode==0, (ui.stdout,ui.stderr)
+    assert not owned()
+    ok('real InputPanel GTK switch enables/disables through PulseAudioManager without notification feedback')
+
+def ok(message):
+    RESULTS.append(message);print('PASS',KIND,message,flush=True)
+
+def native_streams(source, sink, pinned):
+    p=launch([str(FIXTURE / 'stream-client'),source,sink,pinned if isinstance(pinned,str) else 'pinned' if pinned else 'active'],
+             stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
+    assert fd_select.select([p.stdout],[],[],6)[0], 'Native stream connection timeout'
+    line=p.stdout.readline()
+    assert line, p.stderr.read()
+    output,input_=map(int,line.split())
+    return [(p,'sink-inputs',output),(p,'source-outputs',input_)]
+
+def stream_target(kind,index):
+    return next(x['sink' if kind=='sink-inputs' else 'source'] for x in items(kind) if x['index']==index)
+
+def run():
+    bus=subprocess.check_output(['dbus-daemon','--session','--fork','--print-address=1','--print-pid=1'],env=ENV,text=True).splitlines()
+    ENV['DBUS_SESSION_BUS_ADDRESS']=bus[0];global BUS_PID;BUS_PID=int(bus[1])
+    if KIND.startswith('pulse'):
+        commands=['load-module module-native-protocol-unix socket='+str(TEMP/'native')+' auth-anonymous=1',
+                  'load-module module-stream-restore']
+        for suffix in ('','2'):
+            commands+=['load-module module-alsa-sink device=default sink_name=physical_output'+suffix+' tsched=0',
+                       'load-module module-alsa-source device=default source_name=physical_input'+suffix+' tsched=0']
+        commands+=['set-default-sink physical_output','set-default-source physical_input']
+        TEMP.joinpath('test.pa').write_text('\n'.join(commands)+'\n')
+        server=daemon('pulse',['pulseaudio','-nF',str(TEMP/'test.pa'),'--daemonize=no','--exit-idle-time=-1','--use-pid-file=no'] + (['--disallow-module-loading=yes'] if KIND=='pulse-denied' else []))
+    else:
+        config=TEMP/'config';(config/'pipewire.conf.d').mkdir(parents=True)
+        ENV['PIPEWIRE_CONFIG_DIR']=str(config)
+        config.joinpath('pipewire.conf').write_text(pathlib.Path('/usr/share/pipewire/pipewire.conf').read_text())
+        config.joinpath('client.conf').write_text(pathlib.Path('/usr/share/pipewire/client.conf').read_text())
+        config.joinpath('pipewire-pulse.conf').write_text(pathlib.Path('/usr/share/pipewire/pipewire-pulse.conf').read_text().replace('unix:native','unix:'+str(TEMP/'native')))
+        objects=[]
+        for suffix in ('','2'):
+            for direction,media in [('sink','Sink'),('source','Source')]:
+                name='physical_'+('output' if direction=='sink' else 'input')+suffix
+                objects.append('''{ factory = adapter args = {
+                    factory.name = api.alsa.pcm.%s node.name = %s node.description = "%s"
+                    priority.session = %s media.class = Audio/%s device.api = alsa device.class = sound api.alsa.path = default
+                    api.alsa.period-size = 480 api.alsa.headroom = 0 api.alsa.disable-mmap = true
+                    audio.rate = 48000 audio.channels = 2 audio.position = [ FL FR ]
+                } }'''%(direction,name,name,2000 if direction=='source' else 1000,media))
+        config.joinpath('pipewire.conf.d/10-synthetic.conf').write_text('context.objects = [\n'+'\n'.join(objects)+'\n]\n')
+        core=daemon('pipewire',['pipewire'])
+        eventually(lambda:(TEMP/'pipewire-0').exists())
+        server=daemon('pulse',['pipewire-pulse']);wireplumber=daemon('wireplumber',['wireplumber'])
+    eventually(lambda:(TEMP/'native').exists())
+    eventually(lambda:len(items('sinks'))>=2)
+    if KIND == 'pipewire':
+        # Default selection needs WirePlumber's metadata, not just sink discovery.
+        eventually(lambda:any(x['type'] == 'PipeWire:Interface:Metadata' and
+            x.get('props', {}).get('metadata.name') == 'default'
+            for x in json.loads(subprocess.check_output(['pw-dump'], env=ENV, text=True))))
+    select()
+    owner=daemon('audio-owner',[str(FIXTURE / 'audio-owner')])
+    ENV['PULSE_SERVER']='unix:'+str(TEMP/'native')
+    client=Client();client.wait(lambda x:x['available'])
+    api=subprocess.check_output(['gdbus','introspect','--session','--dest','io.elementary.settings-daemon',
+        '--object-path','/io/elementary/settings_daemon','--xml'],env=ENV,text=True)
+    FIXTURE.joinpath(KIND+'-audio-api.xml').write_text(api)
+    assert '<method name="GetStatus">' in api and '<method name="Start">' not in api
+
+
+    if UI_ONLY:
+        client.stop();ui_smoke();return
+    if KIND=='pulse-denied':
+        before=volumes()
+        client.command('enable');client.wait(lambda x:'not available' in x['error'])
+        assert not owned() and defaults()==('physical_input','physical_output') and volumes()==before
+        ok('native load-module rejection: error, preference rollback, no default/volume changes')
+        client.stop();return
+    pactl('set-source-volume','physical_input','44%','66%');pactl('set-sink-volume','physical_output','36%','52%')
+    pactl('set-source-mute','physical_input','1');pactl('set-sink-mute','physical_output','1')
+    before=volumes()
+    pinned=native_streams('physical_input','physical_output',True)
+    targets=[stream_target(kind,idx) for _,kind,idx in pinned]
+    client.command('enable');client.wait(lambda x:x['enabled'])
+    assert defaults()==('elementary_echo_cancel_source','elementary_echo_cancel_sink')
+    assert len(owned())==1 and volumes()==before
+    for (_,kind,idx),target in zip(pinned,targets):assert stream_target(kind,idx)==target
+    ok('enable: correct physical masters, both defaults, asymmetric native volume/mute, pinned streams untouched')
+    filtered=native_streams('elementary_echo_cancel_source','elementary_echo_cancel_sink',False)
+    module=int(owned()[0][0])
+    source_index=next(x['index'] for x in items('sources') if x['name']=='physical_input')
+    sink_index=next(x['index'] for x in items('sinks') if x['name']=='physical_output')
+    try:
+        eventually(lambda:any(int(x['owner_module'] or -1)==module and x['source']==source_index for x in items('source-outputs')))
+    except AssertionError:
+        FIXTURE.joinpath(KIND+'-reference-debug.json').write_text(json.dumps({'sources':items('source-outputs'),'sinks':items('sink-inputs')},indent=2))
+        raise
+    eventually(lambda:any(int(x['owner_module'] or -1)==module and x['sink']==sink_index for x in items('sink-inputs')))
+    FIXTURE.joinpath(KIND+'-native-references.json').write_text(json.dumps({
+        'module':module,'physical_source_index':source_index,'physical_sink_index':sink_index,
+        'capture':[x for x in items('source-outputs') if int(x['owner_module'] or -1)==module],
+        'playback':[x for x in items('sink-inputs') if int(x['owner_module'] or -1)==module]},indent=2)+'\n')
+    ok('native reference streams actually attach to the selected physical source and sink')
+    client.command('disable');client.wait(lambda x:not x['enabled'])
+    assert not owned() and defaults()==('physical_input','physical_output') and volumes()==before
+    for p,kind,idx in filtered:
+        assert p.poll() is None
+        expected=next(x['index'] for x in items('sinks' if kind=='sink-inputs' else 'sources') if x['name']==('physical_output' if kind=='sink-inputs' else 'physical_input'))
+        assert stream_target(kind,idx)==expected
+    ok('disable: owned streams rescued, physical defaults/volume/mute restored, no module left')
+    for p in {p for p,_,_ in filtered+pinned}:p.stdin.write("quit\n");p.stdin.flush();p.wait(timeout=5)
+    client.command('enable');client.wait(lambda x:x['enabled'])
+    movable=native_streams('elementary_echo_cancel_source','elementary_echo_cancel_sink',False)
+    own_pinned=native_streams('elementary_echo_cancel_source','elementary_echo_cancel_sink',True)
+    own_targets=[stream_target(kind,idx) for _,kind,idx in own_pinned]
+    client.command('disable');status=client.wait(lambda x:(x['enabled'] and bool(x['error'])) or not x['enabled'])
+    for (p,kind,idx),target in zip(own_pinned,own_targets):
+        assert p.poll() is None
+        if status['enabled']:assert stream_target(kind,idx)==target and owned()
+    if status['enabled']:
+        client.command('enable');client.wait(lambda x:x['enabled'] and not x['error'])
+        for _,kind,idx in movable:
+            endpoint = 'elementary_echo_cancel_sink' if kind == 'sink-inputs' else 'elementary_echo_cancel_source'
+            expected = next(x['index'] for x in items('sinks' if kind == 'sink-inputs' else 'sources') if x['name'] == endpoint)
+            assert stream_target(kind,idx) == expected
+        ok('partial disable recovery reattaches movable recordings and playback')
+    for p in {p for p,_,_ in own_pinned+movable}:p.stdin.write('quit\n');p.stdin.flush();p.wait(timeout=5)
+    client.command('disable');client.wait(lambda x:not x['enabled']);assert not owned()
+    ok('DONT_MOVE on owned endpoints: migration refusal retains filter and streams; retry after client closes')
+    client.command('enable');client.wait(lambda x:x['enabled']);old=owned()[0][0]
+    client.stop();client=Client();client.wait(lambda x:x['enabled'])
+    assert len(owned())==1 and owned()[0][0]==old
+    ok('close/reopen: saved preference and exact owned-module adoption, no duplicate')
+    pactl('set-source-volume','physical_input','33%','55%');pactl('set-source-mute','physical_input','0')
+    changed=volumes();client.command('disable');client.wait(lambda x:not x['enabled']);assert volumes()==changed
+    ok('user volume/mute changes while enabled survive disabling')
+    collision=pactl('load-module','module-null-sink','sink_name=elementary_echo_cancel_sink')
+    select();client.command('enable');client.wait(lambda x:'already in use' in x['error'])
+    assert not owned() and any(x[0]==collision for x in modules())
+    pactl('unload-module',collision);select()
+    ok('namespace collision: foreign endpoint untouched, error shown, preference rolled back')
+    client.command('disable');client.wait(lambda x:not x['enabled'])
+    pactl('set-default-source','physical_output.monitor');eventually(lambda:defaults()[0]=='physical_output.monitor')
+    client.command('enable');client.wait(lambda x:not x['available'])
+    assert not owned();ok('monitor source rejected')
+    client.command('disable');select();client.wait(lambda x:x['available'])
+    foreign=pactl('load-module','module-echo-cancel','source_master=physical_input sink_master=physical_output source_name=foreign_echo_source sink_name=foreign_echo_sink aec_method=webrtc aec_args="analog_gain_control=0 digital_gain_control=0"')
+    pactl('set-default-source','foreign_echo_source');pactl('set-default-sink','physical_output')
+    eventually(lambda:defaults()==('foreign_echo_source','physical_output'))
+    client.command('enable');client.wait(lambda x:not x['available']);assert not owned() and any(x[0]==foreign for x in modules())
+    client.command('disable');pactl('unload-module',foreign);select()
+    ok('processed source rejected; third-party echo module never adopted/unloaded')
+    client.command('enable');client.wait(lambda x:x['enabled'])
+    moving_streams = native_streams('elementary_echo_cancel_source', 'elementary_echo_cancel_sink', False)
+    pactl('set-default-source','physical_input2');pactl('set-default-sink','physical_output2')
+    client.wait(lambda x:x['enabled'] and x['source']=='physical_input2' and x['sink']=='physical_output2')
+    assert len(owned())==1
+    for proc,kind,index in moving_streams:
+        endpoint = next(x['index'] for x in items('sinks' if kind=='sink-inputs' else 'sources')
+                        if x['name'] == ('elementary_echo_cancel_sink' if kind=='sink-inputs' else 'elementary_echo_cancel_source'))
+        eventually(lambda:stream_target(kind,index)==endpoint)
+    for proc in {entry[0] for entry in moving_streams}:
+        proc.stdin.write('quit\n');proc.stdin.flush();proc.wait(timeout=4)
+    ok('active recording and playback remain processed across device changes')
+    ok('external input/output selection rebinds physical references without recursive masters')
+    # Settings/control process is absent throughout restart recovery.
+    client.stop()
+    owner.terminate();owner.wait(timeout=5)
+    old=owned()[0][0]
+    owner=daemon('audio-owner-restarted',[str(FIXTURE / 'audio-owner')])
+    eventually(lambda:len(owned())==1 and owned()[0][0]==old)
+    time.sleep(.5)
+    assert defaults()==('elementary_echo_cancel_source','elementary_echo_cancel_sink')
+    ok('session owner restart with Sound closed: exact module adoption without duplication')
+    # Destroy the server runtime, including the echo module; the surviving
+    # production owner must reconnect and apply its stored preference.
+    if KIND=='pulse':
+        server.terminate();server.wait(timeout=5)
+        server=daemon('pulse-restarted',['pulseaudio','-nF',str(TEMP/'test.pa'),'--daemonize=no','--exit-idle-time=-1','--use-pid-file=no'])
+    else:
+        for proc in (wireplumber,server,core):
+            proc.terminate();proc.wait(timeout=5)
+        core=daemon('pipewire-restarted',['pipewire'])
+        eventually(lambda:(TEMP/'pipewire-0').exists())
+        server=daemon('pulse-restarted',['pipewire-pulse'])
+        wireplumber=daemon('wireplumber-restarted',['wireplumber'])
+    eventually(lambda:(TEMP/'native').exists())
+    eventually(lambda:len(owned())==1 and defaults()==('elementary_echo_cancel_source','elementary_echo_cancel_sink'),limit=15)
+    ok('audio server restart with Sound closed: saved preference reapplied by surviving session owner')
+    owner.terminate();owner.wait(timeout=5)
+    pactl('unload-module',owned()[0][0]);select()
+    owner=daemon('audio-owner-fresh-session',[str(FIXTURE / 'audio-owner')])
+    eventually(lambda:len(owned())==1 and defaults()==('elementary_echo_cancel_source','elementary_echo_cancel_sink'),limit=15)
+    ok('fresh session owner with Sound closed: stored preference loads missing module and routes defaults')
+    client=Client();client.wait(lambda x:x['enabled'])
+    # Rebind to the second pair again for the original hot-removal invariant.
+    pactl('set-default-source','physical_input2');pactl('set-default-sink','physical_output2')
+    client.wait(lambda x:x['enabled'] and x['source']=='physical_input2' and x['sink']=='physical_output2')
+    # Remove current capture hardware entirely, using the native server tools.
+    if KIND=='pulse':
+        source=next(x for x in items('sources') if x['name']=='physical_input2')
+        pactl('unload-module',source['owner_module'])
+    else:
+        dump=json.loads(subprocess.check_output(['pw-dump'],env=ENV,text=True))
+        node=next(x['id'] for x in dump if x.get('info',{}).get('props',{}).get('node.name')=='physical_input2')
+        subprocess.run(['pw-cli','destroy',str(node)],env=ENV,check=True,capture_output=True,timeout=5)
+    client.wait(lambda x:x['enabled'] and x['source']=='physical_input')
+    assert len(owned())==1
+    ok('hot removal: old module released, surviving physical capture selected and filter rebound')
+    client.command('disable');client.wait(lambda x:not x['enabled'])
+    select();client.wait(lambda x:x['available'])
+    # Exercise cancellation of native operations; never leave busy stuck.
+    os.kill(server.pid,signal.SIGSTOP)
+    try:
+        client.command('enable');client.wait(lambda x:bool(x['error']) and not x['available'],limit=8)
+    finally:os.kill(server.pid,signal.SIGCONT)
+    client.command('refresh');client.wait(lambda x:x['enabled'])
+    client.command('disable');client.wait(lambda x:not x['enabled']);assert not owned()
+    ok('unresponsive server: bounded timeout, callback cancellation, recovery, no stuck busy state')
+    client.stop()
+    # The route regression selects the second microphone, removed above.
+    if KIND == 'pulse':
+        pactl('load-module', 'module-alsa-source', 'device=default', 'source_name=physical_input2', 'tsched=0')
+    else:
+        subprocess.run(['pw-cli','create-node','adapter',
+            '{ factory.name=api.alsa.pcm.source node.name=physical_input2 media.class=Audio/Source '
+            'device.api=alsa device.class=sound api.alsa.path=default api.alsa.disable-mmap=true '
+            'audio.rate=48000 audio.channels=2 audio.position=[ FL FR ] object.linger=true }'],
+            env=ENV, check=True, capture_output=True, timeout=5)
+    eventually(lambda:any(x['name'] == 'physical_input2' for x in items('sources')))
+    ui_smoke()
+
+BUS_PID=None
+try:
+    run()
+finally:
+    for p in reversed(PROCESSES):
+        if p.poll() is None:
+            p.send_signal(signal.SIGCONT);p.terminate()
+            try:p.wait(timeout=5)
+            except subprocess.TimeoutExpired:p.kill();p.wait()
+    if BUS_PID:os.kill(BUS_PID,signal.SIGTERM)
+    for f in LOGS:f.close()
+    dest=ROOT/'validation'/('logs-'+RUN_NAME);dest.mkdir(parents=True, exist_ok=True)
+    for f in TEMP.glob('*.log'):dest.joinpath(f.name).write_bytes(f.read_bytes())
+    FIXTURE.joinpath(RUN_NAME+'-results.json').write_text(json.dumps({'server':KIND,'passes':RESULTS,'runtime':str(TEMP)},indent=2)+'\n')
+    print('Isolated runtime (no host audio):',TEMP,flush=True)
diff --git a/tests/aec-regression/stream-client.vala b/tests/aec-regression/stream-client.vala
new file mode 100644
index 00000000..8d3c7a78
--- /dev/null
+++ b/tests/aec-regression/stream-client.vala
@@ -0,0 +1,65 @@
+// Real libpulse streams, explicitly pinned with PA_STREAM_DONT_MOVE.
+int main (string[] args) {
+    assert (Environment.get_variable ("PULSE_SERVER").has_prefix ("unix:/tmp/vale-sound-"));
+    assert (args.length == 4);
+    var loop = new MainLoop ();
+    var pulse_loop = new PulseAudio.GLibMainLoop ();
+    var context = new PulseAudio.Context (pulse_loop.get_api (), "vale-sound-native-streams");
+    PulseAudio.Stream? playback = null;
+    PulseAudio.Stream? capture = null;
+    var sample = PulseAudio.SampleSpec () { format = PulseAudio.SampleFormat.S16NE, rate = 48000, channels = 2 };
+    var flags = args[3] == "active" ? (PulseAudio.Stream.Flags) 0 : PulseAudio.Stream.Flags.START_CORKED;
+    var playback_flags = flags;
+    var capture_flags = flags;
+    if (args[3] == "pinned" || args[3] == "playback-pinned") {
+        playback_flags |= PulseAudio.Stream.Flags.DONT_MOVE;
+    }
+    if (args[3] == "pinned" || args[3] == "capture-pinned") {
+        capture_flags |= PulseAudio.Stream.Flags.DONT_MOVE;
+    }
+
+    bool printed = false;
+    context.set_state_callback ((c) => {
+        if (c.get_state () != PulseAudio.Context.State.READY) {
+            return;
+        }
+
+        playback = new PulseAudio.Stream (c, "vale-sound-output", sample);
+        capture = new PulseAudio.Stream (c, "vale-sound-input", sample);
+        playback.set_write_callback ((s, bytes) => {
+            uint8[] silence = new uint8[bytes];
+            s.write (silence, bytes);
+        });
+        capture.set_read_callback ((s, bytes) => {
+            void* data;
+            size_t length;
+            if (s.peek (out data, out length) == 0) {
+                s.drop ();
+            }
+        });
+        playback.set_state_callback ((s) => {
+            if (!printed && capture.get_state () == PulseAudio.Stream.State.READY && s.get_state () == PulseAudio.Stream.State.READY) {
+                stdout.printf ("%u %u\n", playback.get_index (), capture.get_index ());
+                stdout.flush ();
+                printed = true;
+            }
+        });
+        capture.set_state_callback ((s) => {
+            if (!printed && playback.get_state () == PulseAudio.Stream.State.READY && s.get_state () == PulseAudio.Stream.State.READY) {
+                stdout.printf ("%u %u\n", playback.get_index (), capture.get_index ());
+                stdout.flush ();
+                printed = true;
+            }
+        });
+        assert (playback.connect_playback (args[2], null, playback_flags) == 0);
+        assert (capture.connect_record (args[1], null, capture_flags) == 0);
+    });
+    assert (context.connect (Environment.get_variable ("PULSE_SERVER"), PulseAudio.Context.Flags.NOAUTOSPAWN) == 0);
+    var input = new IOChannel.unix_new (0);
+    input.add_watch (IOCondition.IN | IOCondition.HUP, () => { loop.quit (); return Source.REMOVE; });
+    loop.run ();
+    playback.disconnect ();
+    capture.disconnect ();
+    context.disconnect ();
+    return 0;
+}
diff --git a/tests/aec-regression/ui-client.vala b/tests/aec-regression/ui-client.vala
new file mode 100644
index 00000000..e484e53f
--- /dev/null
+++ b/tests/aec-regression/ui-client.vala
@@ -0,0 +1,384 @@
+async void subscribe (PulseAudio.Context context) {
+    context.subscribe (PulseAudio.Context.SubscriptionMask.SERVER, (c, success) => {
+        assert (success == 1);
+        subscribe.callback ();
+    });
+    yield;
+}
+
+async string[] defaults (PulseAudio.Context context) {
+    string[] names = {};
+    context.get_server_info ((c, info) => {
+        if (info != null) {
+            names = {info.default_sink_name, info.default_source_name};
+        }
+        defaults.callback ();
+    });
+    yield;
+    return names;
+}
+
+async void save_routes (PulseAudio.Context context, string suffix) {
+    var entries = new PulseAudio.ExtStreamRestoreInfo[4];
+    string sink = "physical_output" + suffix;
+    string source = "physical_input" + suffix;
+    for (int i = 0; i < entries.length; i++) {
+        entries[i].channel_map.init_stereo ();
+        entries[i].volume.set (2, PulseAudio.Volume.NORM);
+    }
+    entries[0].name = "sink-input-by-application-name:Unrelated saved route";
+    entries[0].device = sink;
+    entries[1].name = "source-output-by-application-name:Unrelated saved route";
+    entries[1].device = source;
+    entries[2].name = "sink-input-by-application-name:Processed saved route";
+    entries[2].device = Sound.EchoCancellation.SINK_NAME;
+    entries[3].name = "source-output-by-application-name:Processed saved route";
+    entries[3].device = Sound.EchoCancellation.SOURCE_NAME;
+    PulseAudio.ext_stream_restore_write (context, PulseAudio.UpdateMode.REPLACE, entries, 0, (c, success) => {
+        assert (success == 1);
+        save_routes.callback ();
+    });
+    yield;
+}
+
+async void check_routes (PulseAudio.Context context, string suffix, bool follow_default = false, bool preserve_processing = false) {
+    int64 deadline = get_monotonic_time () + 10000000;
+    string? sink = null;
+    string? source = null;
+    string? processed_sink = null;
+    string? processed_source = null;
+    do {
+        int found = 0;
+        bool matched = true;
+        PulseAudio.ext_stream_restore_read (context, (c, info, eol) => {
+            assert (eol >= 0);
+            if (eol > 0) {
+                check_routes.callback ();
+            } else if (info.name == "sink-input-by-application-name:Unrelated saved route") {
+                sink = info.device;
+                matched &= info.device == "physical_output" + suffix || (follow_default && info.device == null);
+                found++;
+            } else if (info.name == "source-output-by-application-name:Unrelated saved route") {
+                source = info.device;
+                matched &= info.device == "physical_input" + suffix || (follow_default && info.device == null);
+                found++;
+            } else if (preserve_processing && info.name == "sink-input-by-application-name:Processed saved route") {
+                processed_sink = info.device;
+                matched &= info.device == Sound.EchoCancellation.SINK_NAME || (follow_default && info.device == null);
+                found++;
+            } else if (preserve_processing && info.name == "source-output-by-application-name:Processed saved route") {
+                processed_source = info.device;
+                matched &= info.device == Sound.EchoCancellation.SOURCE_NAME || (follow_default && info.device == null);
+                found++;
+            }
+        });
+        yield;
+        if (found == (preserve_processing ? 4 : 2) && matched) {
+            return;
+        }
+        Timeout.add (25, () => {
+            check_routes.callback ();
+            return Source.REMOVE;
+        });
+        yield;
+    } while (get_monotonic_time () < deadline);
+    error ("Saved routes did not reach devices %s: sink %s, source %s, processed sink %s, processed source %s",
+        suffix, sink ?? "default", source ?? "default", processed_sink ?? "default", processed_source ?? "default");
+}
+
+Sound.Device other_device (bool input, string suffix = "2") {
+    var device = new Sound.Device ("fixture", 42, "fixture") {
+        input = input,
+        card_active_profile_name = "fixture",
+        card_sink_port_name = "fixture",
+        card_source_port_name = "fixture",
+        sink_name = "physical_output" + suffix,
+        source_name = "physical_input" + suffix
+    };
+    device.profiles.add ("fixture");
+    return device;
+}
+
+// Smoke test the real InputPanel's switch, including programmatic state updates.
+int main () {
+    assert (Environment.get_variable ("PULSE_SERVER").has_prefix ("unix:/tmp/vale-sound-"));
+    Gtk.init ();
+    var panel = new Sound.InputPanel ();
+    var window = new Gtk.Window () { child = panel, default_width = 700, default_height = 550 };
+    var grid = (Gtk.Grid) panel.get_last_child ();
+    var toggle = (Gtk.Switch) grid.get_child_at (1, 0);
+    var pam = Sound.PulseAudioManager.get_default ();
+    var loop = new MainLoop ();
+    var pulse_loop = new PulseAudio.GLibMainLoop ();
+    var context = new PulseAudio.Context (pulse_loop.get_api (), "Sound application test");
+    PulseAudio.Stream? playback = null;
+    PulseAudio.Stream? capture = null;
+    PulseAudio.Stream? ordinary_playback = null;
+    PulseAudio.Stream? ordinary_capture = null;
+    context.set_state_callback ((c) => {
+        if (c.get_state () == PulseAudio.Context.State.READY) {
+            var sample = PulseAudio.SampleSpec () {
+                format = PulseAudio.SampleFormat.S16NE,
+                rate = 48000,
+                channels = 2
+            };
+            playback = new PulseAudio.Stream (c, "Sound application test", sample);
+            playback.connect_playback (null, null, PulseAudio.Stream.Flags.START_CORKED);
+        }
+    });
+    uint phase = 0;
+    int64 clicked_at = 0;
+    bool external_sink = false;
+    bool external_source = false;
+    bool race_with_aec = false;
+    bool optout_external = false;
+    context.set_subscribe_callback ((c, event, index) => {
+        defaults.begin (c, (object, result) => {
+            var names = defaults.end (result);
+            if (phase != 70 || names.length != 2) {
+                return;
+            }
+            if (!external_sink && names[0] == "physical_output") {
+                external_sink = true;
+                context.set_default_sink ("physical_output2", null);
+            }
+            if (!external_source && names[1] == "physical_input") {
+                external_source = true;
+                context.set_default_source ("physical_input2", null);
+            }
+        });
+    });
+    pam.start ();
+    window.present ();
+    Timeout.add (25, () => {
+        var controller = pam.echo_cancellation;
+        if (controller == null || controller.busy || !controller.available) {
+            return Source.CONTINUE;
+        }
+
+        if (phase == 0) {
+            assert (!toggle.active && toggle.sensitive);
+            toggle.activate ();
+            clicked_at = get_monotonic_time ();
+            phase = 1;
+        } else if (phase == 1 && controller.enabled && get_monotonic_time () - clicked_at > 400000) {
+            assert (toggle.active);
+            assert (pam.apps.get_n_items () == 0);
+            context.connect (null, PulseAudio.Context.Flags.NOAUTOSPAWN);
+            phase = 2;
+        } else if (phase == 2 && pam.apps.get_n_items () == 1) {
+            assert (((Sound.App) pam.apps.get_item (0)).media_name == "Sound application test");
+            phase = 20;
+            save_routes.begin (pam.context, "2", () => {
+                var missing_sink = other_device (false);
+                missing_sink.sink_name = "missing_output";
+                pam.set_default_device.begin (missing_sink, (object, result) => {
+                    pam.set_default_device.end (result);
+                    var missing_source = other_device (true);
+                    missing_source.source_name = "missing_input";
+                    pam.set_default_device.begin (missing_source, (object, result) => {
+                        pam.set_default_device.end (result);
+                        phase = 30;
+                    });
+                });
+            });
+        } else if (phase == 30 && toggle.sensitive) {
+            toggle.activate ();
+            phase = 3;
+        } else if (phase == 3 && !controller.enabled) {
+            assert (pam.apps.get_n_items () == 1);
+            playback.disconnect ();
+            assert (!toggle.active);
+            phase = 21;
+            check_routes.begin (pam.context, "2", false, false, () => {
+                print ("PASS failed default selections and disabling preserve unrelated saved routes\n");
+                phase = 40;
+            });
+        } else if (phase == 40 && toggle.sensitive) {
+            toggle.activate ();
+            phase = 4;
+        } else if (phase == 4 && controller.enabled) {
+            var sample = PulseAudio.SampleSpec () {
+                format = PulseAudio.SampleFormat.S16NE, rate = 48000, channels = 2
+            };
+            playback = new PulseAudio.Stream (context, "Sound application test", sample);
+            capture = new PulseAudio.Stream (context, "Sound recording test", sample);
+            playback.set_write_callback ((stream, bytes) => {
+                uint8[] silence = new uint8[bytes];
+                stream.write (silence, bytes);
+            });
+            capture.set_read_callback ((stream, bytes) => {
+                void* data;
+                size_t length;
+                if (stream.peek (out data, out length) == 0) {
+                    stream.drop ();
+                }
+            });
+            // ALSA's null PCM has no capture clock. Keep Pulse streams corked
+            // while testing their native routing; PipeWire streams run normally.
+            var flags = Environment.get_variable ("PULSE_SERVER").has_prefix ("unix:/tmp/vale-sound-pulse-") ?
+                PulseAudio.Stream.Flags.START_CORKED : (PulseAudio.Stream.Flags) 0;
+            playback.connect_playback (Sound.EchoCancellation.SINK_NAME, null, flags);
+            capture.connect_record (Sound.EchoCancellation.SOURCE_NAME, null, flags);
+            var ordinary_props = new PulseAudio.Proplist ();
+            ordinary_props.sets (PulseAudio.Proplist.PROP_APPLICATION_NAME, "Unprocessed application");
+            ordinary_playback = new PulseAudio.Stream (context, "Raw playback", sample, null, ordinary_props);
+            ordinary_capture = new PulseAudio.Stream (context, "Raw capture", sample, null, ordinary_props);
+            ordinary_playback.connect_playback ("physical_output", null, PulseAudio.Stream.Flags.START_CORKED);
+            ordinary_capture.connect_record ("physical_input", null, PulseAudio.Stream.Flags.START_CORKED);
+            phase = 24;
+        } else if (phase == 24 && playback.get_state () == PulseAudio.Stream.State.READY &&
+                   capture.get_state () == PulseAudio.Stream.State.READY &&
+                   ordinary_playback.get_state () == PulseAudio.Stream.State.READY &&
+                   ordinary_capture.get_state () == PulseAudio.Stream.State.READY) {
+            phase = 22;
+            save_routes.begin (pam.context, "", () => {
+                var missing_card = other_device (false);
+                missing_card.card_active_profile_name = "old-profile";
+                pam.set_default_device.begin (missing_card, (object, result) => {
+                    pam.set_default_device.end (result);
+                    pam.set_default_device.begin (other_device (false));
+                    pam.set_default_device.begin (other_device (true));
+                    phase = 5;
+                });
+            });
+        } else if (phase == 5 && controller.enabled &&
+                   controller.source_master == "physical_input2" && controller.sink_master == "physical_output2" &&
+                   playback.get_device_name () == Sound.EchoCancellation.SINK_NAME &&
+                   capture.get_device_name () == Sound.EchoCancellation.SOURCE_NAME &&
+                   (ordinary_playback.get_device_name () == "physical_output2" ||
+                    ordinary_playback.get_device_name () == Sound.EchoCancellation.SINK_NAME) &&
+                   (ordinary_capture.get_device_name () == "physical_input2" ||
+                    ordinary_capture.get_device_name () == Sound.EchoCancellation.SOURCE_NAME)) {
+            // Servers may follow the new default into the owner's filter;
+            // either route must reach the newly selected physical master.
+            phase = 23;
+            defaults.begin (context, (object, result) => {
+                var names = defaults.end (result);
+                assert (names.length == 2 && names[0] == Sound.EchoCancellation.SINK_NAME &&
+                        names[1] == Sound.EchoCancellation.SOURCE_NAME);
+                check_routes.begin (pam.context, "2", true, true, () => {
+                    assert (capture.get_device_name () == Sound.EchoCancellation.SOURCE_NAME);
+                    assert (playback.get_device_name () == Sound.EchoCancellation.SINK_NAME);
+                    assert (ordinary_playback.get_device_name () == "physical_output2" ||
+                            (controller.enabled && controller.sink_master == "physical_output2" &&
+                             ordinary_playback.get_device_name () == Sound.EchoCancellation.SINK_NAME));
+                    assert (ordinary_capture.get_device_name () == "physical_input2" ||
+                            (controller.enabled && controller.source_master == "physical_input2" &&
+                             ordinary_capture.get_device_name () == Sound.EchoCancellation.SOURCE_NAME));
+                    print ("PASS failed selection releases the guard; valid selection preserves processing\n");
+                    phase = 80;
+                    context.move_sink_input_by_name (playback.get_index (), "physical_output2");
+                    context.move_source_output_by_name (capture.get_index (), "physical_input2");
+                });
+            });
+        } else if (phase == 80 && playback.get_device_name () == "physical_output2" &&
+                   capture.get_device_name () == "physical_input2") {
+            phase = 81;
+            if (optout_external) {
+                context.set_default_sink ("physical_output", null);
+                context.set_default_source ("physical_input", null);
+            } else {
+                pam.set_default_device.begin (other_device (false, ""));
+                pam.set_default_device.begin (other_device (true, ""));
+            }
+        } else if (phase == 81 && controller.sink_master == "physical_output" &&
+                   controller.source_master == "physical_input" &&
+                   (playback.get_device_name () == "physical_output" ||
+                    playback.get_device_name () == Sound.EchoCancellation.SINK_NAME) &&
+                   (capture.get_device_name () == "physical_input" ||
+                    capture.get_device_name () == Sound.EchoCancellation.SOURCE_NAME)) {
+            print ("PASS explicitly opted-out streams follow subsequent %s selections\n",
+                optout_external ? "external" : "Sound");
+            phase = 82;
+            context.move_sink_input_by_name (playback.get_index (), Sound.EchoCancellation.SINK_NAME);
+            context.move_source_output_by_name (capture.get_index (), Sound.EchoCancellation.SOURCE_NAME);
+        } else if (phase == 82 && playback.get_device_name () == Sound.EchoCancellation.SINK_NAME &&
+                   capture.get_device_name () == Sound.EchoCancellation.SOURCE_NAME) {
+            phase = 83;
+            pam.set_default_device.begin (other_device (false));
+            pam.set_default_device.begin (other_device (true));
+        } else if (phase == 83 && controller.sink_master == "physical_output2" &&
+                   controller.source_master == "physical_input2" &&
+                   playback.get_device_name () == Sound.EchoCancellation.SINK_NAME &&
+                   capture.get_device_name () == Sound.EchoCancellation.SOURCE_NAME) {
+            if (!optout_external) {
+                optout_external = true;
+                phase = 80;
+                context.move_sink_input_by_name (playback.get_index (), "physical_output2");
+                context.move_source_output_by_name (capture.get_index (), "physical_input2");
+            } else {
+                phase = 62;
+            }
+        } else if (phase == 60 && toggle.sensitive) {
+            toggle.activate ();
+            phase = 6;
+        } else if ((phase == 62 && controller.enabled) || (phase == 6 && !controller.enabled)) {
+            race_with_aec = controller.enabled;
+            external_sink = external_source = false;
+            phase = 70;
+            subscribe.begin (context, (object, result) => {
+                subscribe.end (result);
+                pam.set_default_device.begin (other_device (false, ""));
+                pam.set_default_device.begin (other_device (true, ""));
+                clicked_at = get_monotonic_time ();
+            });
+        } else if (phase == 70 && external_sink && external_source &&
+                   get_monotonic_time () - clicked_at > 1000000 && controller.enabled == race_with_aec) {
+            if (race_with_aec && (controller.source_master != "physical_input2" ||
+                                 controller.sink_master != "physical_output2")) {
+                return Source.CONTINUE;
+            }
+            // The owner and application connections receive moved events
+            // separately. Wait for both before inspecting saved routes.
+            if (playback.get_device_name () != (race_with_aec ? Sound.EchoCancellation.SINK_NAME : "physical_output2") ||
+                capture.get_device_name () != (race_with_aec ? Sound.EchoCancellation.SOURCE_NAME : "physical_input2") ||
+                (ordinary_playback.get_device_name () != "physical_output2" &&
+                 (!race_with_aec || ordinary_playback.get_device_name () != Sound.EchoCancellation.SINK_NAME)) ||
+                (ordinary_capture.get_device_name () != "physical_input2" &&
+                 (!race_with_aec || ordinary_capture.get_device_name () != Sound.EchoCancellation.SOURCE_NAME))) {
+                return Source.CONTINUE;
+            }
+            phase = 71;
+            defaults.begin (context, (object, result) => {
+                var names = defaults.end (result);
+                assert (names.length == 2 && names[0] ==
+                        (race_with_aec ? Sound.EchoCancellation.SINK_NAME : "physical_output2") &&
+                        names[1] == (race_with_aec ? Sound.EchoCancellation.SOURCE_NAME : "physical_input2"));
+                // A route may omit its device when it follows this verified default.
+                check_routes.begin (pam.context, "2", true, race_with_aec, () => {
+                    print ("PASS competing selections retain current routes and processing %s\n", race_with_aec.to_string ());
+                    if (race_with_aec) {
+                        phase = 60;
+                    } else {
+                        loop.quit ();
+                    }
+                });
+            });
+        }
+
+        return Source.CONTINUE;
+    });
+    // Four module transitions and a paired device selection each have bounded
+    // backend operations; the complete sequence needs more than one deadline.
+    Timeout.add_seconds (60, () => {
+        var controller = pam.echo_cancellation;
+        stderr.printf ("Streams at timeout: playback=%s capture=%s ordinary playback=%s capture=%s\n",
+            playback == null ? "none" : playback.get_device_name (),
+            capture == null ? "none" : capture.get_device_name (),
+            ordinary_playback == null ? "none" : ordinary_playback.get_device_name (),
+            ordinary_capture == null ? "none" : ordinary_capture.get_device_name ());
+        error ("InputPanel timeout: phase %u, enabled %s, busy %s, available %s, error %s, switch %s, preference %s",
+            phase, controller.enabled.to_string (), controller.busy.to_string (), controller.available.to_string (),
+            controller.error ?? "none", toggle.active.to_string (),
+            new Settings ("io.elementary.settings-daemon.audio").get_boolean ("echo-cancellation").to_string ());
+    });
+    loop.run ();
+    playback.disconnect ();
+    capture.disconnect ();
+    ordinary_playback.disconnect ();
+    ordinary_capture.disconnect ();
+    context.disconnect ();
+    window.destroy ();
+    return 0;
+}
diff --git a/tests/run-aec.sh b/tests/run-aec.sh
new file mode 100755
index 00000000..02794640
--- /dev/null
+++ b/tests/run-aec.sh
@@ -0,0 +1,26 @@
+#!/bin/sh
+# Run only in the existing private SDK, without host audio devices.
+set -eu
+test "${AEC_PRIVATE_TEST:-}" = 1
+test ! -e /dev/snd
+daemon_source=${1:?Pass the AEC-only daemon revision (without the dependent EQ changes)}
+cd "$(dirname "$0")/.."
+mkdir -p tests/schemas validation
+cp "$daemon_source/data/io.elementary.settings-daemon.gschema.xml" data/sound.gschema.xml tests/schemas/
+glib-compile-schemas tests/schemas
+valac --pkg libpulse --pkg libpulse-mainloop-glib --pkg gio-2.0 --pkg libpulse-operation \
+    --vapidir="$daemon_source/vapi" -X '-DGETTEXT_PACKAGE="io.elementary.settings-daemon"' \
+    -o tests/aec-regression/audio-owner "$daemon_source/src/Backends/EchoProcessor.vala" \
+    "$daemon_source/src/Backends/Audio.vala" tests/aec-regression/audio-owner.vala
+valac --pkg gio-2.0 --pkg json-glib-1.0 -X '-DGETTEXT_PACKAGE="io.elementary.settings.sound"' \
+    -o tests/aec-regression/echo-client src/EchoCancellation.vala tests/aec-regression/echo-client.vala
+valac --pkg libpulse --pkg libpulse-mainloop-glib -o tests/aec-regression/stream-client \
+    tests/aec-regression/stream-client.vala
+valac --pkg gtk4 --pkg granite-7 --pkg switchboard-3 --pkg gee-0.8 --pkg libpulse \
+    --pkg libpulse-mainloop-glib --pkg gio-2.0 --pkg libpulse-ext --vapidir=vapi \
+    -X '-DGETTEXT_PACKAGE="io.elementary.settings.sound"' -o tests/aec-regression/ui-client \
+    src/EchoCancellation.vala src/PulseAudioManager.vala src/InputPanel.vala \
+    src/InputDeviceMonitor.vala src/Device.vala src/DeviceRow.vala src/App.vala \
+    tests/aec-regression/ui-client.vala
+python3 tests/aec-regression/run-functional.py pulse
+python3 tests/aec-regression/run-functional.py pipewire
diff --git a/vapi/libpulse-ext.vapi b/vapi/libpulse-ext.vapi
index 91fea6ae..242d809f 100644
--- a/vapi/libpulse-ext.vapi
+++ b/vapi/libpulse-ext.vapi
@@ -15,3 +15,11 @@ namespace PulseAudio {
             public CVolume volume;
     }
 }
+
+[CCode (cheader_filename = "pulse/operation.h")]
+namespace PulseAudio {
+    [CCode (cname = "pa_operation_notify_cb_t")]
+    public delegate void OperationNotifyCb (Operation operation);
+    [CCode (cname = "pa_operation_set_state_callback")]
+    public static void operation_set_state_callback (Operation operation, OperationNotifyCb? cb);
+}

From 3b4c4c557c472d993cee12128a574cf6f0e4e555 Mon Sep 17 00:00:00 2001
From: Sean Rhodes <sean@starlabs.systems>
Date: Tue, 6 Oct 2026 13:59:19 +0100
Subject: [PATCH 2/8] Sound: Add equalizer controls

Show the selected output's five bands, with Reset below the sliders.

Keep the physical output in the device list and show processing errors
without adding routine confirmation messages.

Test=Private PipeWire: GTK sliders, Reset, On/Off and failure recovery.
---
 docs/speaker-equalizer.md              |  23 +
 po/POTFILES                            |   2 +
 src/OutputPanel.vala                   |   3 +
 src/SpeakerEqualizer.vala              | 198 +++++++
 src/SpeakerEqualizerPanel.vala         |  99 ++++
 src/meson.build                        |   2 +
 tests/active-bridge.py                 | 687 +++++++++++++++++++++++++
 tests/aec-regression/run-functional.py |   5 +
 tests/bridge-client.vala               | 112 ++++
 tests/generic-equalizer.vala           |  85 +++
 tests/gtk-controls.vala                | 120 +++++
 tests/run-active-bridge.sh             |  42 ++
 tests/run-components.sh                |  40 ++
 13 files changed, 1418 insertions(+)
 create mode 100644 docs/speaker-equalizer.md
 create mode 100644 src/SpeakerEqualizer.vala
 create mode 100644 src/SpeakerEqualizerPanel.vala
 create mode 100644 tests/active-bridge.py
 create mode 100644 tests/bridge-client.vala
 create mode 100644 tests/generic-equalizer.vala
 create mode 100644 tests/gtk-controls.vala
 create mode 100644 tests/run-active-bridge.sh
 create mode 100644 tests/run-components.sh

diff --git a/docs/speaker-equalizer.md b/docs/speaker-equalizer.md
new file mode 100644
index 00000000..56fa974c
--- /dev/null
+++ b/docs/speaker-equalizer.md
@@ -0,0 +1,23 @@
+# Speaker equalizer controls
+
+Sound consumes settings-daemon status and preferences; it does not own audio
+processing. Closing Settings leaves enabled EQ and noise cancellation running.
+
+The five gain controls are Bass, Low mids, Mids, Air and Upper balance. Their
+names are fixed here; the device profile supplies frequencies, Q, gain ranges
+and optional recommended gains. Frequencies appear in tooltips. Reset sits
+below the sliders and preserves On/Off. Sliders remain editable while Off.
+
+User preferences take precedence over recommendations. Invalid profiles remain
+unavailable; a supported operation failure can be recovered by an explicit
+changed preference after the daemon revalidates the graph.
+
+Private integration checks use the companion daemon source and vendor graph
+and profile, in the existing SDK without `/dev/snd`:
+
+```
+EQ_PRIVATE_TEST=1 EQ_OEM_RULE=<rule> EQ_OEM_PROFILE=<profile> \
+    sh tests/run-components.sh <daemon-source>
+```
+
+The native bridge uses synthetic card/route metadata and private audio servers.
diff --git a/po/POTFILES b/po/POTFILES
index cde11a67..016b5eb3 100644
--- a/po/POTFILES
+++ b/po/POTFILES
@@ -10,3 +10,5 @@ src/InputPanel.vala
 src/InputDeviceMonitor.vala
 src/DeviceRow.vala
 src/Device.vala
+src/SpeakerEqualizer.vala
+src/SpeakerEqualizerPanel.vala
diff --git a/src/OutputPanel.vala b/src/OutputPanel.vala
index 2a98b20a..83b9a522 100644
--- a/src/OutputPanel.vala
+++ b/src/OutputPanel.vala
@@ -17,6 +17,7 @@ public class Sound.OutputPanel : Gtk.Box {
     private unowned Canberra.Context? ca_context = null;
     private unowned PulseAudioManager pam;
     private Settings media_keys_settings;
+    private SpeakerEqualizerPanel equalizer = new SpeakerEqualizerPanel ();
 
     private string _screenreader_shortcut_label = "";
     private string screenreader_shortcut_label {
@@ -140,6 +141,7 @@ public class Sound.OutputPanel : Gtk.Box {
         spacing = 18;
         append (devices_frame);
         append (output_grid);
+        append (equalizer);
         append (alerts_box);
         append (screen_reader_box);
         append (test_button);
@@ -199,6 +201,7 @@ public class Sound.OutputPanel : Gtk.Box {
             }
 
             default_device = pam.default_output;
+            equalizer.set_device (default_device);
             if (default_device != null) {
                 if (volume_switch.active == default_device.is_muted) {
                     volume_switch.activate ();
diff --git a/src/SpeakerEqualizer.vala b/src/SpeakerEqualizer.vala
new file mode 100644
index 00000000..46a3338a
--- /dev/null
+++ b/src/SpeakerEqualizer.vala
@@ -0,0 +1,198 @@
+/*
+ * SPDX-License-Identifier: LGPL-2.0-or-later
+ * SPDX-FileCopyrightText: 2026 elementary, Inc. (https://elementary.io)
+ */
+
+public class Sound.SpeakerEqualizer : Object {
+    public struct Status {
+        public bool available;
+        public bool busy;
+        public bool applied;
+        public string error;
+        public string settings_path;
+        public string node;
+        public string route;
+        public double[] frequencies;
+        public string[] types;
+        public double[] defaults;
+        public double[] minimum;
+        public double[] maximum;
+    }
+
+    [DBus (name = "io.elementary.settings_daemon.Audio")]
+    private interface Audio : DBusProxy {
+        public abstract async Status get_equalizer_status () throws DBusError, IOError;
+        public signal void equalizer_changed ();
+    }
+
+    public SpeakerEqualizer () { clear (); }
+
+    public signal void changed ();
+    public Status status;
+    public bool requested {
+        get {
+            if (settings == null) {
+                return false;
+            }
+            var saved = settings.get_user_value ("enabled");
+            return saved != null ? saved.get_boolean () :
+                status.defaults.length == 5 && settings.get_boolean ("enabled");
+        }
+    }
+    public double[] get_gains () {
+        if (settings == null) {
+            return new double[0];
+        }
+        var value = settings.get_user_value ("gains");
+        if (value == null) {
+            return status.defaults.length == 5 ? status.defaults.copy () : new double[5];
+        }
+        if (value.n_children () != 5) {
+            return new double[0];
+        }
+        var values = new double[5];
+        for (int i = 0; i < 5; i++) {
+            values[i] = value.get_child_value (i).get_double ();
+            if (!values[i].is_finite () || values[i] < status.minimum[i] || values[i] > status.maximum[i]) {
+                return new double[0];
+            }
+        }
+        return values;
+    }
+
+    private Audio? audio;
+    private Settings? settings;
+    private uint watch;
+    private uint generation;
+    private bool reading;
+    private bool pending;
+
+    public void start () {
+        if (watch != 0) return;
+        clear ();
+        watch = Bus.watch_name (SESSION, "io.elementary.settings-daemon", NONE, (connection) => {
+            uint request = ++generation;
+            connection.get_proxy.begin<Audio> ("io.elementary.settings-daemon", "/io/elementary/settings_daemon", NONE,
+                null, (obj, res) => {
+                    try {
+                        var proxy = connection.get_proxy.end<Audio> (res);
+                        if (request != generation) return;
+                        proxy.g_default_timeout = 2000;
+                        audio = proxy;
+                        audio.equalizer_changed.connect (refresh);
+                        refresh ();
+                    } catch (Error e) {
+                        if (request == generation) clear ();
+                    }
+                });
+        }, () => {
+            generation++;
+            if (audio != null) audio.equalizer_changed.disconnect (refresh);
+            audio = null;
+            clear ();
+        });
+    }
+
+    public void stop () {
+        generation++;
+        if (watch != 0) Bus.unwatch_name (watch);
+        watch = 0;
+        if (audio != null) audio.equalizer_changed.disconnect (refresh);
+        audio = null;
+        clear ();
+    }
+
+    private void clear () {
+        if (settings != null) settings.changed.disconnect (preferences_changed);
+        settings = null;
+        status = { false, false, false, _("Speaker equalization is unavailable."), "", "", "",
+            new double[0], new string[0], new double[0], new double[0], new double[0] };
+        changed ();
+    }
+
+    private void preferences_changed () { changed (); }
+
+    private void refresh () {
+        pending = true;
+        if (!reading) read_status.begin ();
+    }
+
+    private async void read_status () {
+        var service = audio;
+        if (service == null) return;
+        reading = true;
+        pending = false;
+        uint request = generation;
+        try {
+            var result = yield service.get_equalizer_status ();
+            if (request == generation && service == audio) {
+                var schema = SettingsSchemaSource.get_default ().lookup (
+                    "io.elementary.settings-daemon.audio.equalizer", true);
+                if (schema == null || !valid_status (result)) {
+                    clear ();
+                } else {
+                    if (settings == null || status.settings_path != result.settings_path) {
+                        if (settings != null) settings.changed.disconnect (preferences_changed);
+                        settings = new Settings.full (schema, null, result.settings_path);
+                        settings.delay ();
+                        settings.changed.connect (preferences_changed);
+                    }
+                    status = result;
+                    changed ();
+                }
+            }
+        } catch (Error e) {
+            if (request == generation && service == audio) clear ();
+        }
+        reading = false;
+        if (pending && audio != null) read_status.begin ();
+    }
+
+    private static bool valid_status (Status value) {
+        const string PREFIX = "/io/elementary/settings-daemon/audio/equalizer/";
+        if (!value.settings_path.has_prefix (PREFIX) || value.settings_path.length != PREFIX.length + 65 ||
+            !value.settings_path.has_suffix ("/") || value.frequencies.length != 5 || value.types.length != 5 ||
+            (value.defaults.length != 0 && value.defaults.length != 5) || value.minimum.length != 5 || value.maximum.length != 5) return false;
+        foreach (char digit in value.settings_path.substring (PREFIX.length, 64).to_utf8 ()) {
+            if (digit != 0 && !digit.isxdigit ()) return false;
+        }
+        for (int i = 0; i < 5; i++) {
+            if ((value.types[i] != "low-shelf" && value.types[i] != "peak" && value.types[i] != "high-shelf") ||
+                !value.frequencies[i].is_finite () || value.frequencies[i] < 20 || value.frequencies[i] > 20000 ||
+                !value.minimum[i].is_finite () || !value.maximum[i].is_finite () ||
+                value.minimum[i] < -24 || value.minimum[i] > 0 || value.maximum[i] < 0 || value.maximum[i] > 12 ||
+                (value.defaults.length == 5 && (!value.defaults[i].is_finite () ||
+                    value.defaults[i] < value.minimum[i] || value.defaults[i] > value.maximum[i]))) return false;
+        }
+        return true;
+    }
+
+    public void enable (bool enabled) {
+        if (settings == null || (enabled && !status.available)) return;
+        settings.set_boolean ("enabled", enabled);
+        settings.apply ();
+    }
+
+    public void reset () {
+        if (settings == null || !status.available) {
+            return;
+        }
+        set_gains (status.defaults.length == 5 ? status.defaults : new double[5]);
+    }
+
+    public void set_band (int band, double gain) {
+        if (settings == null || !status.available || band < 0 || band >= 5 || !gain.is_finite () ||
+            gain < status.minimum[band] || gain > status.maximum[band]) return;
+        var values = get_gains ();
+        if (values.length != 5) return;
+        values[band] = gain;
+        set_gains (values);
+    }
+
+    private void set_gains (double[] values) {
+        var builder = new VariantBuilder (new VariantType ("ad"));
+        foreach (double gain in values) builder.add ("d", gain);
+        settings.set_value ("gains", builder.end ());
+        settings.apply ();
+    }
+}
diff --git a/src/SpeakerEqualizerPanel.vala b/src/SpeakerEqualizerPanel.vala
new file mode 100644
index 00000000..2b632ab6
--- /dev/null
+++ b/src/SpeakerEqualizerPanel.vala
@@ -0,0 +1,99 @@
+/*
+ * SPDX-License-Identifier: LGPL-2.0-or-later
+ * SPDX-FileCopyrightText: 2026 elementary, Inc. (https://elementary.io)
+ */
+
+public class Sound.SpeakerEqualizerPanel : Gtk.Box {
+    private SpeakerEqualizer equalizer = new SpeakerEqualizer ();
+    private Gtk.Switch enabled;
+    private Gtk.Button reset;
+    private Gtk.Label feedback;
+    private Gtk.Grid bands;
+    private Gtk.Scale[] sliders = {};
+    private Gtk.Label[] labels = {};
+    private Gtk.Label[] values = {};
+    private Device? device;
+    private bool updating;
+
+    construct {
+        orientation = VERTICAL;
+        spacing = 12;
+        var title = new Granite.HeaderLabel (_("Equalizer")) { hexpand = true };
+        enabled = new Gtk.Switch () { valign = CENTER };
+        var header = new Gtk.Box (HORIZONTAL, 12);
+        header.append (title);
+        header.append (enabled);
+        reset = new Gtk.Button.with_label (_("Reset")) { halign = END };
+        reset.tooltip_text = _("Restore recommended equalizer settings");
+        bands = new Gtk.Grid () { row_spacing = 6, column_spacing = 12 };
+        string[] band_names = { _("Bass"), _("Low mids"), _("Mids"), _("Air"), _("Upper balance") };
+        for (int i = 0; i < 5; i++) {
+            int band = i;
+            var label = new Gtk.Label (band_names[i]) { xalign = 0 };
+            var slider = new Gtk.Scale.with_range (HORIZONTAL, -12, 12, 0.5) { hexpand = true, draw_value = false };
+            var value = new Gtk.Label ("") { xalign = 1, width_chars = 8 };
+            label.mnemonic_widget = slider;
+            bands.attach (label, 0, i);
+            bands.attach (slider, 1, i);
+            bands.attach (value, 2, i);
+            labels += label;
+            sliders += slider;
+            values += value;
+            slider.value_changed.connect (() => {
+                if (!updating) equalizer.set_band (band, slider.get_value ());
+            });
+        }
+        feedback = new Gtk.Label ("") { wrap = true, xalign = 0 };
+        feedback.add_css_class ("dim-label");
+        append (header);
+        append (reset);
+        append (bands);
+        append (feedback);
+        enabled.notify["active"].connect (() => { if (!updating) equalizer.enable (enabled.active); });
+        reset.clicked.connect (equalizer.reset);
+        equalizer.changed.connect (update);
+        map.connect (() => equalizer.start ());
+        unmap.connect (() => equalizer.stop ());
+        update ();
+    }
+
+    public override void dispose () {
+        set_device (null);
+        equalizer.stop ();
+        base.dispose ();
+    }
+
+    public void set_device (Device? selected) {
+        if (device != null) device.notify.disconnect (update);
+        device = selected;
+        if (device != null) device.notify.connect (update);
+        update ();
+    }
+
+    private void update () {
+        updating = true;
+        var status = equalizer.status;
+        // Wait for the daemon to retire the old graph before showing controls
+        // for the newly selected physical output.
+        bool matches = device != null && status.node == device.card_sink_name && status.route == device.port_name;
+        enabled.visible = reset.visible = matches;
+        if (enabled.active != equalizer.requested) enabled.active = equalizer.requested;
+        enabled.sensitive = matches && (status.available || enabled.active);
+        reset.sensitive = matches && status.available;
+        bands.sensitive = matches && status.available;
+        var gains = equalizer.get_gains ();
+        bands.visible = matches && gains.length == 5;
+        if (bands.visible) {
+            for (int i = 0; i < 5; i++) {
+                labels[i].tooltip_text = _("%g Hz").printf (status.frequencies[i]);
+                sliders[i].set_range (status.minimum[i], status.maximum[i]);
+                sliders[i].set_value (gains[i]);
+                values[i].label = _("%+.1f dB").printf (gains[i]);
+            }
+        }
+        feedback.label = !matches ? _("Speaker equalization is unavailable for this output.") :
+            status.error;
+        feedback.visible = feedback.label != "";
+        updating = false;
+    }
+}
diff --git a/src/meson.build b/src/meson.build
index 0e1f62b1..8a17a060 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -1,4 +1,6 @@
 plug_files = files(
+    'SpeakerEqualizer.vala',
+    'SpeakerEqualizerPanel.vala',
     'App.vala',
     'ApplicationsPanel.vala',
     'AppRow.vala',
diff --git a/tests/active-bridge.py b/tests/active-bridge.py
new file mode 100644
index 00000000..45d48bf2
--- /dev/null
+++ b/tests/active-bridge.py
@@ -0,0 +1,687 @@
+#!/usr/bin/env python3
+"""Production Audio + EQ + Sound model over real private PW/Pulse/WP protocols.
+
+The exported card has synthetic speaker/headphone Route metadata; no hardware
+is exercised. Generic cases load the shipped WirePlumber graph policy.
+"""
+import json
+import os
+from pathlib import Path
+import queue
+import re
+import select
+import signal
+import shutil
+import subprocess
+import tempfile
+import threading
+import time
+
+assert os.environ.get('EQ_PRIVATE_TEST') == '1' and not Path('/dev/snd').exists()
+base = Path(__file__).resolve().parent
+generic_case = os.environ.get('EQ_GENERIC_CASE', '')
+generic = bool(generic_case)
+node_name = 'alsa_output.pci-0000_00_1f.3.analog-stereo' if generic else 'elementary.eq.test'
+legacy = os.environ.get('EQ_LEGACY') == '1'
+cache_probe = os.environ.get('EQ_TEST_CACHE_PARAMS') == '1'
+evidence = base / ('bridge-generic-'+generic_case if generic else 'bridge-cache-results' if cache_probe else 'bridge-legacy-results' if legacy else 'bridge-results')
+evidence.mkdir(exist_ok=True)
+runtime = Path(tempfile.mkdtemp(prefix='vale-sound-eq-bridge-'))
+profiles = Path(os.environ['EQ_TEST_PROFILE_DIR'])
+assert profiles.parent.parent == Path('/root') and profiles.parent.name.startswith('elementary-eq-bridge.')
+profiles.mkdir(exist_ok=True)
+daemon_source = Path(os.environ['EQ_DAEMON_SOURCE'])
+profile_id = 'generic-speakers-v1' if generic else 'fixture-v1'
+if generic_case.startswith('oem-'):
+    profile_id = Path(os.environ['EQ_OEM_PROFILE']).stem
+if generic:
+    generic_profile = profiles/'generic-speakers-v1.ini'
+    generic_profile.unlink(missing_ok=True)
+    shutil.copyfile(daemon_source/'data/generic-speakers-v1.ini', generic_profile)
+    profile_path = profiles/(profile_id+'.ini')
+    if profile_path != generic_profile:
+        profile_path.unlink(missing_ok=True)
+        shutil.copyfile(generic_profile, profile_path)
+    if generic_case in ('oem-valid', 'oem-independent-graph'):
+        shutil.copyfile(os.environ['EQ_OEM_PROFILE'], profiles/(profile_id+'.ini'))
+        if generic_case == 'oem-independent-graph':
+            generic_profile.write_text(generic_profile.read_text().replace('Node=*', 'Node=alsa_output.other'))
+    elif generic_case == 'oem-wildcard':
+        path = profiles/(profile_id+'.ini')
+        path.write_text(path.read_text().replace('DefaultGains=', 'DefaultGains=0;0;0;0;0;'))
+    elif generic_case == 'oem-untrusted':
+        path = profiles/(profile_id+'.ini')
+        path.write_text(path.read_text().replace('Node=*', 'Node='+node_name).replace(
+            'DefaultGains=', 'DefaultGains=0;0;0;0;0;'))
+        path.chmod(0o666)
+    elif generic_case == 'invalid-layout':
+        path = profiles/(profile_id+'.ini')
+        path.write_text(path.read_text().replace('Q=0.707;', 'Q=11;', 1))
+    elif generic_case == 'untrusted':
+        (profiles/(profile_id+'.ini')).chmod(0o666)
+else:
+    shutil.copyfile(os.environ['EQ_TEST_PROFILE'], profiles/'fixture-v1.ini')
+    shutil.copyfile(daemon_source/'data/generic-speakers-v1.ini', profiles/'generic-speakers-v1.ini')
+
+env = dict(os.environ, XDG_RUNTIME_DIR=str(runtime), PIPEWIRE_RUNTIME_DIR=str(runtime),
+           PIPEWIRE_REMOTE='elementary-eq-bridge', PULSE_SERVER='unix:'+str(runtime/'native'),
+           XDG_CONFIG_HOME=str(runtime/'user-config'), XDG_STATE_HOME=str(runtime/'state'),
+           XDG_CACHE_HOME=str(runtime/'cache'), GSETTINGS_BACKEND='keyfile',
+           GSETTINGS_SCHEMA_DIR=str(base/'schemas'))
+for key in ('DBUS_SESSION_BUS_ADDRESS', 'DISPLAY', 'WAYLAND_DISPLAY', 'PIPEWIRE_CONFIG_PREFIX', 'PIPEWIRE_CONFIG_NAME', 'PIPEWIRE_CORE'):
+    env.pop(key, None)
+config = runtime/'config'
+config.mkdir()
+env['PIPEWIRE_CONFIG_DIR'] = str(config)
+text = Path('/usr/share/pipewire/pipewire.conf').read_text()
+text = text.replace('context.spa-libs = {', 'context.spa-libs = {\n    audiotestsrc = audiotestsrc/libspa-audiotestsrc')
+text = re.sub(r'core.name\s*=\s*pipewire-0', 'core.name = elementary-eq-bridge', text)
+(config/'pipewire.conf').write_text(text)
+(config/'client.conf').write_text(Path('/usr/share/pipewire/client.conf').read_text())
+(config/'pipewire-pulse.conf').write_text(Path('/usr/share/pipewire/pipewire-pulse.conf').read_text().replace('unix:native', 'unix:'+str(runtime/'native')))
+if generic:
+    env['EQ_TEST_GENERIC'] = '1'
+    policy = Path(env['XDG_CONFIG_HOME'])/'wireplumber/wireplumber.conf.d'
+    policy.mkdir(parents=True)
+    shutil.copyfile(daemon_source/'data/50-elementary-speaker-equalizer.conf', policy/'50-elementary-speaker-equalizer.conf')
+    if generic_case.startswith('oem-'):
+        shutil.copyfile(os.environ['EQ_OEM_RULE'], policy/'51-vale-starfighter-physical-eq.conf')
+if generic_case == 'oem-valid':
+    schema_dir = runtime/'schemas'
+    schema_dir.mkdir()
+    shutil.copyfile(daemon_source/'data/io.elementary.settings-daemon.gschema.xml', schema_dir/'io.elementary.settings-daemon.gschema.xml')
+    (schema_dir/'91-vendor.gschema.override').write_text('[io.elementary.settings-daemon.audio.equalizer]\nenabled=true\n')
+    subprocess.run(['glib-compile-schemas', str(schema_dir)], check=True)
+    env['GSETTINGS_SCHEMA_DIR'] = str(schema_dir)
+processes, logs, commands, observations, checks = [], [], [], [], {}
+last, failure = {}, None
+
+def run(args, record=True):
+    p = subprocess.run(args, env=env, text=True, capture_output=True, timeout=8)
+    if record: commands.append(dict(argv=args, code=p.returncode, stdout=p.stdout, stderr=p.stderr))
+    if p.returncode: raise RuntimeError((args, p.stderr))
+    return p.stdout
+
+def backend_status(record=False):
+    return run(['gdbus', 'call', '--session', '--dest', 'io.elementary.settings-daemon',
+        '--object-path', '/io/elementary/settings_daemon',
+        '--method', 'io.elementary.settings_daemon.Audio.GetEqualizerStatus'], record)
+
+def start(name, args, **kwargs):
+    log = (evidence/(name+'.log')).open('w'); logs.append(log)
+    p = subprocess.Popen(args, env=(dict(env,G_MESSAGES_DEBUG='all') if name=='audio-owner' else env), stderr=log, start_new_session=True, **(dict(stdout=log) | kwargs))
+    processes.append(p)
+    return p
+
+def wait(fn, seconds=8):
+    end = time.monotonic()+seconds
+    while time.monotonic() < end:
+        value = fn()
+        if value: return value
+        time.sleep(.05)
+    raise TimeoutError((str(fn), last))
+
+def check(name, value):
+    checks[name] = bool(value)
+    assert value, name
+
+def objects(): return json.loads(run(['pw-dump'], False))
+def sinks(): return json.loads(run(['pactl', '-f', 'json', 'list', 'sinks'], False))
+
+def cli(lines):
+    # Noninteractive pw-cli waits for registry discovery before each command.
+    # A fresh interactive client can return zero despite "unknown global".
+    for line in lines:
+        args = line.split(' ', 3 if line.startswith('set-param ') else 2)
+        output = run(['pw-cli', *args])
+        assert 'Error:' not in output
+
+def props(identifier=None):
+    text = run(['pw-cli', 'enum-params', str(sink_id if identifier is None else identifier), 'Props'], False)
+    values = {k:float(v) for k,v in re.findall(r'String "(eos_eq_[^"]+)"\s+Float ([-\d.eE+]+)', text)}
+    return values
+
+def curve(gains, headroom, identifier=None):
+    values = props(identifier)
+    return all(abs(values.get(f'eos_eq_{i+1}:Gain', 999)-g) < .001 for i,g in enumerate(gains)) and abs(values.get('eos_eq_h:Mult', 999)-headroom) < .00001
+
+def receive():
+    global last
+    while not messages.empty(): last = messages.get_nowait()
+    return last
+
+def send(line):
+    commands.append(dict(client=line, status=dict(last)))
+    client.stdin.write(line+'\n'); client.stdin.flush()
+
+def linked(enabled):
+    for channel in ('FL', 'FR'):
+        run(['pw-link', *([] if enabled else ['-d']),
+             f'elementary.eq.tone:capture_{channel}', f'{node_name}:playback_{channel}'])
+
+def native_clients():
+    return [o for o in objects() if o['type']=='PipeWire:Interface:Client' and
+            str(o.get('info',{}).get('props',{}).get('application.process.id'))==str(owner.pid) and
+            o['info']['props'].get('client.api') != 'pipewire-pulse']
+
+try:
+    bus = start('bus', ['dbus-daemon', '--session', '--nofork', '--print-address=1'], stdout=subprocess.PIPE, text=True)
+    assert select.select([bus.stdout], [], [], 3)[0]
+    env['DBUS_SESSION_BUS_ADDRESS'] = bus.stdout.readline().strip()
+    server = start('pipewire', ['pipewire'])
+    wait(lambda:(runtime/'elementary-eq-bridge').exists())
+    card = start('card', [str(base/'bridge-device')], stdout=subprocess.PIPE, text=True)
+    assert select.select([card.stdout], [], [], 3)[0]
+    card_id = int(card.stdout.readline())
+    pulse = start('pulse', ['pipewire-pulse'])
+    start('wireplumber', ['wireplumber'])
+    wait(lambda:(runtime/'native').exists())
+    if generic:
+        marker = run([str(base/'graph-rules'), node_name]).strip()
+        check('native_rule_order_selects_expected_profile', marker == profile_id)
+        check('declared_invalid_profile_is_not_overridden',
+              run([str(base/'graph-rules'), 'alsa_output.other', 'invalid-oem-v1']).strip() == 'invalid-oem-v1')
+        check('non_alsa_output_has_no_generic_marker',
+              run([str(base/'graph-rules'), 'bluez_output.fixture']).strip() == '')
+    cli([
+        f'create-node adapter {{ factory.name = support.null-audio-sink node.name = {node_name} '
+        f'media.class = Audio/Sink device.id = {card_id} card.profile.device = 0 '
+        f'elementary.eq.profile = {profile_id} node.cache-params = '+('true' if cache_probe else 'false')+' audio.channels = 2 audio.position = [ FL FR ] '
+        'priority.session = 1000 object.linger = true }',
+        'create-node adapter { factory.name = audiotestsrc node.name = elementary.eq.tone '
+        f'device.id = {card_id} card.profile.device = 1 '
+        'media.class = Audio/Source audio.channels = 2 audio.position = [ FL FR ] '
+        'priority.session = 2000 object.linger = true }'
+    ])
+    wait(lambda:any(s['name']==node_name for s in sinks()))
+    if generic_case == 'oem-independent-graph':
+        run(['pw-cli','set-param',str(card_id),'Route','{ index = 1 device = 0 }'])
+        wait(lambda:any(s['name'] == node_name and s['active_port'] == 'analog-output-headphones' for s in sinks()))
+    sink = next(s for s in sinks() if s['name']==node_name)
+    (evidence/'pulse-physical-fixture.json').write_text(json.dumps(sink, indent=2)+'\n')
+    run(['pw-cli','info',str(card_id)])
+    run(['pw-cli','enum-params',str(card_id),'EnumRoute'])
+    run(['pw-cli','enum-params',str(card_id),'Route'])
+    run(['pactl','-f','json','list','cards'])
+    expected_route = 'analog-output-headphones' if generic_case == 'oem-independent-graph' else 'analog-output-speaker' if generic else 'fixture-speaker'
+    check('real_pulse_card_and_active_route', 'HARDWARE' in sink['flags'] and sink['active_port']==expected_route)
+    nodes = objects()
+    sink_id = next(n['id'] for n in nodes if n.get('info',{}).get('props',{}).get('node.name')==node_name)
+    tone_id = next(n['id'] for n in nodes if n.get('info',{}).get('props',{}).get('node.name')=='elementary.eq.tone')
+    labels = ['bq_lowshelf', 'bq_peaking', 'bq_peaking', 'bq_peaking', 'bq_highshelf']
+    graph_nodes = [dict(type='builtin', name=f'eos_eq_{i+1}', label=label, control=dict(Freq=freq, Q=q, Gain=0.0))
+                   for i,(label,freq,q) in enumerate(zip(labels,[200,240,1000,16000,200],[.707,.6,1,6.606,.707]))]
+    graph_nodes.append(dict(type='builtin', name='eos_eq_h', label='linear', control=dict(Mult=.25 if legacy else 1.0, Add=0.0)))
+    links = [dict(output=f'eos_eq_{i}:Out', input=f'eos_eq_{i+1}:In') for i in range(1,5)]
+    links.append(dict(output='eos_eq_5:Out', input='eos_eq_h:In'))
+    graph = json.dumps(dict(nodes=graph_nodes, links=links))
+    fmt = dict(mediaType='audio', mediaSubtype='raw', format='F32P', rate=48000, channels=2, position=['FL','FR'])
+    cli([f'set-param {tone_id} PortConfig '+json.dumps(dict(direction='Output', mode='dsp', format=fmt)),
+         f'set-param {sink_id} PortConfig '+json.dumps(dict(direction='Input', mode='dsp', format=fmt)),
+         *([] if generic else [f'set-param {sink_id} Props '+json.dumps(dict(params=['audioconvert.filter-graph.0', graph]))]),
+         f'set-param {sink_id} Props '+json.dumps(dict(channelVolumes=[.7,.35],mute=True))])
+    for channel in ('FL','FR'): run(['pw-link', f'elementary.eq.tone:capture_{channel}', f'{node_name}:playback_{channel}'])
+    run(['pw-cli','enum-params',str(sink_id),'PropInfo'])
+    run(['pw-cli','enum-params',str(sink_id),'Props'])
+    run(['pactl','set-default-sink',node_name])
+    run(['pactl','set-default-source','elementary.eq.tone'])
+    if generic_case == 'valid':
+        hdmi_card = start('hdmi-card', ['env', 'EQ_TEST_HDMI=1', str(base/'bridge-device'), 'elementary.eq.hdmi-card'],
+            stdout=subprocess.PIPE, text=True)
+        assert select.select([hdmi_card.stdout], [], [], 3)[0]
+        hdmi_card_id = int(hdmi_card.stdout.readline())
+        hdmi_name = 'alsa_output.pci-0000_01_00.1.hdmi-stereo'
+        check('native_hdmi_marker_is_generic', run([str(base/'graph-rules'), hdmi_name]).strip() == profile_id)
+        cli([f'create-node adapter {{ factory.name = support.null-audio-sink node.name = {hdmi_name} '
+             f'media.class = Audio/Sink device.id = {hdmi_card_id} card.profile.device = 0 '
+             f'elementary.eq.profile = {profile_id} node.cache-params = false audio.channels = 2 '
+             'audio.position = [ FL FR ] object.linger = true }'])
+        wait(lambda:any(sink['name'] == hdmi_name for sink in sinks()))
+        hdmi_id = next(o['id'] for o in objects() if o.get('info',{}).get('props',{}).get('node.name') == hdmi_name)
+        run(['pactl','set-default-sink',hdmi_name])
+    if generic:
+        wait(lambda:len(props()) == 48)
+        metadata = run(['pw-cli','enum-params',str(sink_id),'Props'])
+        check('only_one_shipped_neutral_graph', curve([0]*5,1) and
+              len(re.findall(r'String "(eos_eq_[^"]+)"', metadata)) == 48)
+    owner = start('audio-owner', [str(base/'bridge-audio-owner')])
+    run(['gdbus','wait','--session','--timeout=5','io.elementary.settings-daemon'])
+    env['GTK_A11Y']='none'
+    client = start('sound-model', ['xvfb-run','-a',str(base/'bridge-client')], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+    messages = queue.Queue()
+    def read():
+        for line in client.stdout:
+            item=json.loads(line); observations.append(item); messages.put(item)
+    threading.Thread(target=read, daemon=True).start()
+    if cache_probe:
+        wait(lambda:bool(receive().get('error')))
+        metadata = run(['pw-cli','enum-params',str(sink_id),'PropInfo'])
+        check('cached_metadata_omits_installed_controls', 'eos_eq_' not in metadata and len(props())==48)
+        check('cached_metadata_fails_closed', not last['applied'] and bool(last['error']))
+        raise SystemExit(0)
+    if generic:
+        if generic_case == 'oem-independent-graph':
+            wait(lambda:receive().get('available') and last.get('route') == 'analog-output-headphones')
+            check('oem_other_route_uses_own_graph_with_neutral_defaults',
+                  not last['enabled'] and last['gains'] == [0]*5 and last['defaults_count'] == 0)
+            send('on')
+            wait(lambda:receive().get('applied') and last.get('enabled') and curve([0]*5,1))
+            check('unrelated_generic_profile_does_not_control_oem_route', True)
+            # A valid new output must not be trapped by a removed old profile.
+            shutil.copyfile(daemon_source/'data/generic-speakers-v1.ini', generic_profile)
+            next_card = start('next-card', [str(base/'bridge-device'), 'elementary.eq.next-card'],
+                stdout=subprocess.PIPE, text=True)
+            assert select.select([next_card.stdout], [], [], 3)[0]
+            next_card_id = int(next_card.stdout.readline())
+            next_name = 'alsa_output.usb-next.analog-stereo'
+            cli([f'create-node adapter {{ factory.name = support.null-audio-sink node.name = {next_name} '
+                 f'media.class = Audio/Sink device.id = {next_card_id} card.profile.device = 0 '
+                 'elementary.eq.profile = generic-speakers-v1 node.cache-params = false audio.channels = 2 '
+                 'audio.position = [ FL FR ] object.linger = true }'])
+            wait(lambda:any(s['name'] == next_name for s in sinks()))
+            next_id = next(o['id'] for o in objects() if o.get('info',{}).get('props',{}).get('node.name') == next_name)
+            cli([f'set-param {next_id} PortConfig '+json.dumps(dict(direction='Input',mode='dsp',format=fmt))])
+            for channel in ('FL','FR'):
+                run(['pw-link', f'elementary.eq.tone:capture_{channel}', f'{next_name}:playback_{channel}'])
+            (profiles/(profile_id+'.ini')).unlink()
+            run(['pactl','set-default-sink',next_name])
+            wait(lambda:receive().get('node') == next_name and last.get('available') and last.get('applied'))
+            check('removed_previous_profile_does_not_block_new_output', curve([0]*5,1,next_id))
+            raise SystemExit(0)
+        if generic_case not in ('valid', 'oem-valid'):
+            expected_error = {
+                'untrusted': 'No valid root-installed equalizer profile is available.',
+                'oem-untrusted': 'No valid root-installed equalizer profile is available.',
+                'oem-empty': 'The equalizer profile is incomplete.',
+                'oem-wildcard': 'The equalizer profile does not match the physical output.',
+                'invalid-layout': 'An equalizer profile band is invalid.',
+            }[generic_case]
+            wait(lambda:expected_error in backend_status())
+            check('intended_backend_profile_rejection', expected_error in backend_status(True))
+            wait(lambda:bool(receive().get('error')) and not last['available'] and not last['applied'])
+            check('declared_oem_or_untrusted_profile_fails_closed', True)
+            send('on')
+            time.sleep(.3)
+            check('invalid_profile_enable_does_not_fallback', curve([0]*5,1) and not receive()['available'])
+            raise SystemExit(0)
+        if generic_case == 'oem-valid':
+            recommended = [7.5,8,-0.5,1.5,.5]
+            wait(lambda:receive().get('available') and last.get('applied') and last.get('enabled') and curve(recommended,1))
+            check('native_oem_recommendations_and_policy_start_on', last['gains'] == recommended)
+            run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-7.]))])
+            wait(lambda:receive().get('error') and last.get('available'))
+            send('gtk-reset')
+            time.sleep(.3)
+            check('unchanged_oem_reset_does_not_authorize_failed_audit',
+                  bool(receive().get('error')) and curve([-7,8,-0.5,1.5,.5],1))
+            send('zero')
+            wait(lambda:receive().get('applied') and last.get('gains') == [0]*5 and curve([0]*5,1))
+            check('native_oem_explicit_zero_applies_unity', last['enabled'])
+            send('gtk-reset')
+            wait(lambda:receive().get('applied') and curve(recommended,1))
+            send('gtk-gain 0 -6')
+            wait(lambda:receive().get('applied') and curve([-6,8,-0.5,1.5,.5],1))
+            send('gtk-toggle')
+            wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+            check('native_oem_off_retains_saved_gains', last['gains'] == [-6,8,-0.5,1.5,.5])
+            path = profiles/(profile_id+'.ini')
+            path.write_text(path.read_text().replace('DefaultGains=7.5;8;-0.5;1.5;0.5;', 'DefaultGains=0;0;0;0;0;'))
+            send('gtk-toggle')
+            wait(lambda:receive().get('enabled') and last.get('applied') and curve([-6,8,-0.5,1.5,.5],1))
+            check('native_policy_refresh_preserves_personal_gains', True)
+            send('gtk-reset')
+            wait(lambda:receive().get('enabled') and last.get('applied') and
+                 last.get('gains') == [0]*5 and curve([0]*5,1))
+            check('native_oem_zero_reset_preserves_on_and_unity', True)
+            raise SystemExit(0)
+        wait(lambda:receive().get('available') and last.get('node') == hdmi_name)
+        check('selected_hdmi_has_neutral_independent_preferences',
+              not last['enabled'] and last['gains'] == [0]*5 and last['route'] == 'hdmi-output-0')
+        run(['pactl','set-default-sink',node_name])
+        wait(lambda:receive().get('available') and last.get('applied'))
+        check('hdmi_default_to_speakers_discovers_generic_eq', last['node'] == node_name)
+        unused_card = start('unused-card', [str(base/'bridge-device'), 'elementary.eq.unused-card'],
+            stdout=subprocess.PIPE, text=True)
+        assert select.select([unused_card.stdout], [], [], 3)[0]
+        unused_card_id = int(unused_card.stdout.readline())
+        unused_name = 'alsa_output.usb-unused.analog-stereo'
+        cli([f'create-node adapter {{ factory.name = support.null-audio-sink node.name = {unused_name} '
+             f'media.class = Audio/Sink device.id = {unused_card_id} card.profile.device = 0 '
+             f'elementary.eq.profile = {profile_id} node.cache-params = false audio.channels = 2 '
+             'audio.position = [ FL FR ] object.linger = true }'])
+        wait(lambda:any(sink['name'] == unused_name for sink in sinks()))
+        unused_id = next(o['id'] for o in objects() if o.get('info',{}).get('props',{}).get('node.name') == unused_name)
+        check('never_started_output_has_no_initialized_controls', 'eos_eq_1:Gain' not in props(unused_id))
+        run(['pactl','set-default-sink',unused_name])
+        wait(lambda:receive().get('node') == unused_name and last.get('available') and not last.get('busy'))
+        check('never_started_output_waits_without_writing', not last['applied'] and not last['error'])
+        run(['pactl','set-default-sink',node_name])
+        wait(lambda:receive().get('node') == node_name and last.get('applied'))
+        check('never_started_default_switch_releases_untouched_graph', 'eos_eq_1:Gain' not in props(unused_id))
+        run(['pw-cli','destroy',str(unused_id)])
+        run(['pw-cli','destroy',str(hdmi_id)])
+        check('generic_defaults_are_empty', last['defaults_count'] == 0 and last['gains'] == [0]*5)
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-7.]))])
+        wait(lambda:receive().get('error') and last.get('available') and not last.get('applied'))
+        check('generic_off_failure_remains_supported', not last['enabled'] and last['gtk_switch_sensitive'])
+        send('gtk-toggle')
+        wait(lambda:receive().get('enabled') and last.get('applied') and curve([0]*5,1))
+        check('generic_explicit_on_from_off_failure_revalidates', True)
+        time.sleep(.5)
+        wait(lambda:receive().get('applied') and not last.get('busy'))
+        check('generic_flat_is_unity', curve([0]*5,1))
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-7.]))])
+        wait(lambda:receive().get('error') and last.get('gtk_switch_sensitive') and last.get('available') and not last.get('applied'))
+        check('generic_normalized_default_stays_failed', last['gains'] == [0]*5 and curve([-7,0,0,0,0],1))
+        send('gtk-toggle')
+        wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+        check('generic_failed_off_recovers_with_normalized_default', True)
+        send('on')
+        wait(lambda:receive().get('enabled') and last.get('applied'))
+        send('gtk-gain 0 3')
+        wait(lambda:receive().get('applied') and curve([3,0,0,0,0],1))
+        check('generic_custom_boost_keeps_unity_gain', True)
+        send('gtk-gain 1 12')
+        wait(lambda:receive().get('applied') and curve([3,12,0,0,0],1))
+        check('twelve_db_bass_boost_does_not_reduce_global_gain', True)
+        send('gtk-gain 1 0')
+        wait(lambda:receive().get('applied') and curve([3,0,0,0,0],1))
+        send('gtk-gain 0 0')
+        wait(lambda:receive().get('applied') and curve([0]*5,1))
+        check('generic_zero_custom_has_unity_headroom', True)
+        send('gtk-gain 0 -6')
+        wait(lambda:receive().get('applied') and curve([-6,0,0,0,0],1))
+        check('generic_cut_only_keeps_unity_gain', True)
+        send('gtk-gain 0 3')
+        wait(lambda:receive().get('applied') and curve([3,0,0,0,0],1))
+        run(['pw-cli','set-param',str(card_id),'Route','{ index = 1 device = 0 }'])
+        wait(lambda:receive().get('route')=='analog-output-headphones' and curve([0]*5,1))
+        send('select-output '+node_name+' analog-output-headphones')
+        wait(lambda:receive().get('gtk_switch_sensitive'))
+        check('generic_headphones_have_neutral_independent_preferences',
+              last['available'] and not last['enabled'] and last['gains'] == [0]*5)
+        send('gtk-toggle')
+        wait(lambda:receive().get('enabled') and last.get('applied'))
+        send('gtk-gain 0 -6')
+        wait(lambda:receive().get('applied') and last.get('gains') == [-6,0,0,0,0] and
+             curve([-6,0,0,0,0],1))
+        check('selected_headphone_slider_reaches_native_graph', True)
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-7.]))])
+        wait(lambda:receive().get('error') and last.get('available'))
+        send('gtk-toggle')
+        wait(lambda:not receive().get('enabled',True) and not last.get('error') and curve([0]*5,1))
+        check('explicit_off_on_headphones_revalidates_failed_bypass', last['gains'] == [-6,0,0,0,0])
+        run(['pw-cli','set-param',str(card_id),'Route','{ index = 0 device = 0 }'])
+        send('select-output '+node_name+' analog-output-speaker')
+        wait(lambda:receive().get('route') == 'analog-output-speaker' and last.get('enabled') and
+             last.get('applied') and last.get('gains') == [3,0,0,0,0] and curve([3,0,0,0,0],1))
+        check('speaker_route_keeps_its_enabled_preference_and_gains', True)
+        usb_card = start('usb-card', [str(base/'bridge-device'), 'elementary.eq.usb-card'],
+            stdout=subprocess.PIPE, text=True)
+        assert select.select([usb_card.stdout], [], [], 3)[0]
+        usb_card_id = int(usb_card.stdout.readline())
+        usb_name = 'alsa_output.usb-fixture.analog-stereo'
+        cli([f'create-node adapter {{ factory.name = support.null-audio-sink node.name = {usb_name} '
+             f'media.class = Audio/Sink device.id = {usb_card_id} card.profile.device = 0 '
+             f'elementary.eq.profile = {profile_id} node.cache-params = false audio.channels = 2 '
+             'audio.position = [ FL FR ] object.linger = true }'])
+        wait(lambda:any(sink['name'] == usb_name for sink in sinks()))
+        usb_id = next(o['id'] for o in objects() if o.get('info',{}).get('props',{}).get('node.name') == usb_name)
+        cli([f'set-param {usb_id} PortConfig '+json.dumps(dict(direction='Input',mode='dsp',format=fmt))])
+        for channel in ('FL','FR'):
+            run(['pw-link', f'elementary.eq.tone:capture_{channel}', f'{usb_name}:playback_{channel}'])
+        linked(False)
+        wait(lambda:any(o['id'] == sink_id and o.get('info',{}).get('state') == 'idle' for o in objects()))
+        owner.terminate()
+        owner.wait(timeout=3)
+        owner = start('restarted-audio-owner', [str(base/'bridge-audio-owner')])
+        run(['gdbus','wait','--session','--timeout=5','io.elementary.settings-daemon'])
+        wait(lambda:receive().get('node') == node_name and last.get('available') and not last.get('busy')
+             and not last.get('applied') and node_name in backend_status())
+        check('restarted_backend_preserves_idle_controls_before_explicit_switch',
+              not last['applied'] and curve([3,0,0,0,0],1))
+        run(['pactl','set-default-sink',usb_name])
+        wait(lambda:receive().get('node') == usb_name and last.get('available') and last.get('applied'))
+        check('two_speaker_defaults_retire_idle_old_graph', curve([0]*5,1) and curve([0]*5,1,usb_id))
+        check('new_output_hides_old_physical_panel', not last['gtk_switch_sensitive'])
+        send('on')
+        time.sleep(.5)
+        send('gain')
+        wait(lambda:receive().get('applied') and curve([-6,0,0,0,0],1,usb_id))
+        check('second_output_custom_uses_its_own_preferences', curve([0]*5,1))
+        linked(True)
+        run(['pactl','set-default-sink',node_name])
+        wait(lambda:receive().get('node') == node_name and last.get('applied') and curve([3,0,0,0,0],1))
+        check('return_to_first_output_restores_preferences_and_neutralizes_second', curve([0]*5,1,usb_id))
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Freq',201.]))])
+        wait(lambda:receive().get('error') and not last.get('applied'))
+        run(['pactl','set-default-sink',usb_name])
+        wait(lambda:receive().get('node') == usb_name and last.get('applied') and curve([-6,0,0,0,0],1,usb_id))
+        check('failed_retirement_does_not_block_another_output', curve([3,0,0,0,0],1) and props()['eos_eq_1:Freq'] == 201.)
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Freq',200.]))])
+        run(['pactl','set-default-sink',node_name])
+        wait(lambda:receive().get('node') == node_name and last.get('applied') and curve([3,0,0,0,0],1))
+        run(['pw-cli','destroy',str(usb_id)])
+        send('gtk-reset')
+        wait(lambda:receive().get('applied') and curve([0]*5,1))
+        check('generic_reset_to_flat_unity', True)
+        check('no_second_visible_output', len(sinks()) == 1)
+        raise SystemExit(0)
+    wait(lambda:receive().get('available') and last.get('applied'))
+    if not legacy: check('initial_off_is_flat_unity', curve([0]*5,1))
+    send('on')
+    wait(lambda:receive().get('enabled') and last.get('applied') and curve([-1,-2,-3,-4,-5],1))
+    check('model_daemon_pulse_native_default_applied', True)
+    settings_path = re.search(r'/io/elementary/settings-daemon/audio/equalizer/[0-9a-f]+/', backend_status()).group()
+    schema = 'io.elementary.settings-daemon.audio.equalizer:' + settings_path
+    run(['gsettings','set',schema,'gains','[1000., -2., -3., -4., -5.]'])
+    wait(lambda:receive().get('error') and not last.get('applied'))
+    run(['gsettings','set',schema,'gains','[-1., -2., -3., -4., -5.]'])
+    wait(lambda:receive().get('applied') and not last.get('error') and curve([-1,-2,-3,-4,-5],1))
+    check('repair_to_last_valid_gains_recovers_validation_failure', True)
+    subscriber = start('pulse-events', ['pactl','subscribe'], stdout=subprocess.PIPE, text=True)
+    events=[]
+    def read_events():
+        for line in subscriber.stdout: events.append(line.strip())
+    threading.Thread(target=read_events, daemon=True).start()
+    time.sleep(.2)
+    run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-7.0]))])
+    if not legacy:
+        wait(lambda:receive().get('error') and curve([-7,-2,-3,-4,-5],1))
+    for value in ('0','1','0','1'):
+        run(['pw-cli','set-param',str(sink_id),'Props','{ mute = '+('true' if value=='1' else 'false')+' }']); time.sleep(.15)
+    wait(lambda:any('sink #' in e for e in events))
+    time.sleep(2)
+    receive()
+    (evidence/'foreign-after-pulse-events.json').write_text(json.dumps(dict(status=last, controls=props(), events=events),indent=2)+'\n')
+    if legacy:
+        check('legacy_reproduces_foreign_gain_overwrite', curve([-1,-2,-3,-4,-5],1))
+    else:
+        check('foreign_gain_survives_real_sink_events', curve([-7,-2,-3,-4,-5],1))
+        check('native_failed_audit_survives_rediscovery', last['available'] and not last['applied'] and bool(last['error']))
+        send('on'); time.sleep(.3)
+        check('unchanged_enable_does_not_retry_failed_audit', curve([-7,-2,-3,-4,-5],1))
+        send('gain')
+        wait(lambda:receive().get('applied') and curve([-6,-2,-3,-4,-5],1))
+        check('explicit_gain_change_revalidates_supported_failed_output', True)
+        send('reset')
+        wait(lambda:receive().get('applied') and curve([-1,-2,-3,-4,-5],1))
+        send('off')
+        wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+        wait(lambda:receive().get('gtk_switch_sensitive') and last.get('aec_available'))
+        send('aec-on')
+        wait(lambda:receive().get('aec_enabled') and not last.get('aec_busy') and last.get('applied') and last.get('gtk_switch_sensitive'))
+        send('gtk-toggle')
+        wait(lambda:receive().get('gtk_on') and last.get('applied') and curve([-1,-2,-3,-4,-5],1))
+        check('real_gtk_enable_with_owned_aec', last['aec_enabled'] and not last['aec_error'])
+        for band in range(5): send(f'gtk-gain {band} {-7+band}')
+        wait(lambda:receive().get('applied') and curve([-7,-6,-5,-4,-3],1))
+        check('all_five_real_gtk_sliders_reach_native_controls', last['aec_enabled'])
+        send('gtk-zero')
+        wait(lambda:receive().get('applied') and curve([0]*5,1))
+        check('real_gtk_flat_unity_with_owned_aec', last['aec_enabled'])
+        send('gtk-reset')
+        wait(lambda:receive().get('applied') and curve([-1,-2,-3,-4,-5],1))
+        check('real_gtk_reset_with_owned_aec', last['aec_enabled'])
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-8.]))])
+        wait(lambda:receive().get('error') and last.get('gtk_switch_sensitive') and last.get('gtk_bands_sensitive'))
+        send('gtk-toggle')
+        wait(lambda:not receive().get('gtk_on',True) and last.get('applied') and curve([0]*5,1))
+        check('real_gtk_failed_off_recovers_unity_with_owned_aec', last['aec_enabled'])
+        send('aec-off')
+        wait(lambda:not receive().get('aec_enabled',True) and not last.get('aec_busy'))
+        check('owned_aec_disables_without_changing_eq_controls', curve([0]*5,1))
+        check('failed_off_withdraws_preference_and_bypasses', True)
+        send('on'); wait(lambda:receive().get('enabled') and last.get('applied') and curve([-1,-2,-3,-4,-5],1))
+        send('zero'); wait(lambda:receive().get('applied') and curve([0]*5,1))
+        check('enabled_flat_has_unity_headroom', True)
+        send('reset'); wait(lambda:receive().get('applied') and curve([-1,-2,-3,-4,-5],1))
+        send('gain'); wait(lambda:receive().get('applied') and curve([-6,-2,-3,-4,-5],1))
+        check('explicit_custom_keeps_unity_gain', True)
+        run(['pw-cli','set-param',str(card_id),'Route','{ index = 1 device = 0 }'])
+        wait(lambda:receive().get('route')=='fixture-headphones' and curve([0]*5,1))
+        check('headphones_do_not_inherit_oem_recommendations',
+              last['available'] and not last['enabled'] and last['defaults_count'] == 0 and last['gains'] == [0]*5)
+        run(['pw-cli','set-param',str(card_id),'Route','{ index = 0 device = 0 }'])
+        wait(lambda:receive().get('route')=='fixture-speaker' and last.get('applied') and curve([-6,-2,-3,-4,-5],1))
+        check('speaker_route_return_reapplies_preferences', True)
+        linked(False)
+        wait(lambda:not receive().get('applied'))
+        time.sleep(1.2)
+        linked(True)
+        wait(lambda:receive().get('applied') and curve([-6,-2,-3,-4,-5],1))
+        check('unchanged_idle_resume_confirms_read_only', True)
+        for control, value, expected, headroom in (
+                ('eos_eq_1:Gain', -7., [-7,-2,-3,-4,-5], 1),
+                ('eos_eq_h:Mult', .125, [-6,-2,-3,-4,-5], .125)):
+            linked(False)
+            wait(lambda:not receive().get('applied'))
+            time.sleep(1.2)
+            run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=[control,value]))])
+            linked(True)
+            wait(lambda:receive().get('error') and not last['applied'])
+            time.sleep(1.2)
+            check('foreign_idle_'+control.split(':')[1]+'_survives_resume', curve(expected,headroom))
+            send('off')
+            wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+            send('on')
+            wait(lambda:receive().get('enabled') and last.get('applied') and curve([-6,-2,-3,-4,-5],1))
+        clients = native_clients()
+        (evidence/'clients.json').write_text(json.dumps([o for o in objects() if o['type']=='PipeWire:Interface:Client'],indent=2)+'\n')
+        check('exactly_one_native_client', len(clients)==1)
+        run(['pw-cli','destroy',str(clients[0]['id'])])
+        wait(lambda:receive().get('error') and not last['applied'])
+        wait(lambda:receive().get('applied') and len(native_clients())==1)
+        check('native_disconnect_reconnect_same_owner', owner.poll() is None and curve([-6,-2,-3,-4,-5],1))
+        # A disconnected client must not regain write permission for its old request.
+        run(['pw-cli','destroy',str(native_clients()[0]['id'])])
+        wait(lambda:receive().get('error') and not last['applied'])
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-8.]))])
+        time.sleep(3.5)
+        receive()
+        check('foreign_gain_survives_reconnect', bool(last['error']) and not last['applied'] and curve([-8,-2,-3,-4,-5],1))
+        pulse.terminate()
+        pulse.wait(timeout=3)
+        wait(lambda:not receive().get('available'))
+        pulse = start('pulse-restarted', ['pipewire-pulse'])
+        wait(lambda:(runtime/'native').exists())
+        wait(lambda:receive().get('available') and bool(last['error']))
+        time.sleep(.5)
+        check('pulse_bridge_restart_retains_failure_and_foreign_gains',
+              owner.poll() is None and not last['applied'] and curve([-8,-2,-3,-4,-5],1))
+        send('off')
+        wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+        send('invalid-gains')
+        time.sleep(.3)
+        check('nonfinite_out_of_range_and_invalid_band_refused', curve([0]*5,1))
+        linked(False)
+        wait(lambda:not receive().get('applied'))
+        send('on')
+        wait(lambda:receive().get('enabled') and not last.get('busy'))
+        check('explicit_idle_request_waits_for_running_node', not last['applied'])
+        run(['pw-cli','destroy',str(native_clients()[0]['id'])])
+        wait(lambda:receive().get('error'))
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-8.]))])
+        linked(True)
+        wait(lambda:len(native_clients()) == 1 and receive().get('error') and not last.get('applied'))
+        time.sleep(.5)
+        check('idle_write_authority_is_revoked_on_disconnect', curve([-8,0,0,0,0],1))
+        send('off')
+        wait(lambda:receive().get('applied') and curve([0]*5,1))
+        linked(False)
+        wait(lambda:not receive().get('applied'))
+        send('on')
+        wait(lambda:receive().get('enabled') and not last.get('busy'))
+        send('off')
+        wait(lambda:not receive().get('enabled',True) and not last.get('busy'))
+        linked(True)
+        wait(lambda:receive().get('applied') and curve([0]*5,1))
+        check('superseded_idle_request_never_applies_old_gains', True)
+        # Queue a real Props notification while the owner is stopped, then stall
+        # the server before allowing its async audit to issue enumeration.
+        owner.send_signal(signal.SIGSTOP)
+        run(['pw-cli','set-param',str(sink_id),'Props','{ mute = false }'])
+        server.send_signal(signal.SIGSTOP)
+        started = time.monotonic()
+        owner.send_signal(signal.SIGCONT)
+        try:
+            wait(lambda:receive().get('error')=='The PipeWire equalizer connection failed.', 3.5)
+            elapsed = time.monotonic()-started
+            check('stalled_native_audit_deadline_disconnects', 1.8 <= elapsed < 3.5 and not last['applied'])
+            (evidence/'deadline.json').write_text(json.dumps(dict(seconds=elapsed,status=last),indent=2)+'\n')
+        finally:
+            server.send_signal(signal.SIGCONT)
+        wait(lambda:receive().get('applied') and len(native_clients())==1)
+        check('deadline_cancellation_reconnects_without_old_write', curve([0]*5,1))
+        run(['pw-cli','set-param',str(sink_id),'Props','{ mute = true }'])
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.1',graph]))])
+        wait(lambda:receive().get('error') and not last['applied'])
+        check('duplicate_reserved_namespace_fails_closed', not last['applied'])
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.1','']))])
+        # A real changed preference is required to recover a failed audit.
+        send('off')
+        time.sleep(.3)
+        check('unchanged_off_cannot_reset_failed_audit', bool(receive().get('error')))
+        actual = run(['pw-cli','enum-params',str(sink_id),'Props'])
+        check('physical_balance_preserved', re.search(r'Float 0.700000\s+Float 0.350000',actual))
+        check('physical_mute_preserved', re.search(r'Props:mute .*?\n\s+Bool true',actual))
+        old_serial = next(o['info']['props']['object.serial'] for o in objects() if o['id']==sink_id)
+        run(['pw-cli','destroy',str(sink_id)])
+        wait(lambda:not receive().get('available') and not last.get('applied'))
+        check('node_removal_revokes_confirmation', True)
+        cli(['create-node adapter { factory.name = support.null-audio-sink node.name = elementary.eq.test '
+             f'media.class = Audio/Sink device.id = {card_id} card.profile.device = 0 '
+             'elementary.eq.profile = fixture-v1 node.cache-params = false audio.channels = 2 '
+             'audio.position = [ FL FR ] priority.session = 1000 object.linger = true }'])
+        wait(lambda:any(s['name']==node_name for s in sinks()))
+        replacement = next(o for o in objects() if o.get('info',{}).get('props',{}).get('node.name')=='elementary.eq.test')
+        sink_id = replacement['id']
+        graph_nodes[0]['control']['Freq']=106.
+        bad_graph=json.dumps(dict(nodes=graph_nodes,links=links))
+        cli([f'set-param {sink_id} PortConfig '+json.dumps(dict(direction='Input',mode='dsp',format=fmt)),
+             f'set-param {sink_id} Props '+json.dumps(dict(params=['audioconvert.filter-graph.0',bad_graph]))])
+        run(['pactl','set-default-sink',node_name])
+        linked(True)
+        wait(lambda:receive().get('error')=='The equalizer does not match its installed profile.')
+        check('replacement_serial_with_mismatched_graph_refused', replacement['info']['props']['object.serial']!=old_serial and not last['applied'])
+except Exception as exc:
+    failure=repr(exc)
+    raise
+finally:
+    if failure and 'sink_id' in globals():
+        try:
+            run(['pw-cli','enum-params',str(sink_id),'PropInfo'])
+            run(['pw-cli','enum-params',str(sink_id),'Props'])
+        except Exception: pass
+    for p in reversed(processes):
+        if p.poll() is None:
+            os.killpg(p.pid, signal.SIGCONT)
+            os.killpg(p.pid, signal.SIGTERM)
+            try: p.wait(timeout=3)
+            except subprocess.TimeoutExpired: os.killpg(p.pid, signal.SIGKILL); p.wait()
+    for log in logs: log.close()
+    (evidence/'commands.json').write_text(json.dumps(commands,indent=2)+'\n')
+    (evidence/'observations.json').write_text(json.dumps(observations,indent=2)+'\n')
+    (evidence/'checks.json').write_text(json.dumps(dict(checks=checks,failure=failure,runtime=str(runtime)),indent=2)+'\n')
+    shutil.rmtree(runtime)
+print(json.dumps(checks))
diff --git a/tests/aec-regression/run-functional.py b/tests/aec-regression/run-functional.py
index f5ffeba6..7bb66fdd 100644
--- a/tests/aec-regression/run-functional.py
+++ b/tests/aec-regression/run-functional.py
@@ -176,6 +176,11 @@ def run():
     FIXTURE.joinpath(KIND+'-audio-api.xml').write_text(api)
     assert '<method name="GetStatus">' in api and '<method name="Start">' not in api
 
+    if os.environ.get("AEC_WITH_EQ") == "1":
+        eq = subprocess.check_output(['gdbus','call','--session','--dest','io.elementary.settings-daemon',
+            '--object-path','/io/elementary/settings_daemon','--method','io.elementary.settings_daemon.Audio.GetEqualizerStatus'],env=ENV,text=True)
+        assert eq.startswith('((false,'), eq
+        ok('EQ unavailable without a root profile; existing AEC API remains present')
 
     if UI_ONLY:
         client.stop();ui_smoke();return
diff --git a/tests/bridge-client.vala b/tests/bridge-client.vala
new file mode 100644
index 00000000..3f932b95
--- /dev/null
+++ b/tests/bridge-client.vala
@@ -0,0 +1,112 @@
+// Real Sound model on the private bridge's session bus and GSettings backend.
+private Sound.SpeakerEqualizer model;
+private MainLoop loop;
+private Sound.EchoCancellation echo;
+private Gtk.Switch toggle;
+private Gtk.Button reset;
+private Gtk.Grid bands;
+private Sound.SpeakerEqualizerPanel panel;
+
+private void snapshot () {
+    var s = model.status;
+    var b = new Json.Builder ();
+    b.begin_object ();
+    b.set_member_name ("available"); b.add_boolean_value (s.available);
+    b.set_member_name ("busy"); b.add_boolean_value (s.busy);
+    b.set_member_name ("applied"); b.add_boolean_value (s.applied);
+    b.set_member_name ("enabled"); b.add_boolean_value (model.requested);
+    b.set_member_name ("gains"); b.begin_array ();
+    foreach (double gain in model.get_gains ()) {
+        b.add_double_value (gain);
+    }
+    b.end_array ();
+    b.set_member_name ("error"); b.add_string_value (s.error);
+    b.set_member_name ("node"); b.add_string_value (s.node);
+    b.set_member_name ("route"); b.add_string_value (s.route);
+    b.set_member_name ("defaults_count"); b.add_int_value (s.defaults.length);
+    b.set_member_name ("gtk_on"); b.add_boolean_value (toggle.active);
+    b.set_member_name ("gtk_switch_sensitive"); b.add_boolean_value (toggle.sensitive);
+    b.set_member_name ("gtk_bands_sensitive"); b.add_boolean_value (bands.sensitive);
+    b.set_member_name ("aec_available"); b.add_boolean_value (echo.available);
+    b.set_member_name ("aec_enabled"); b.add_boolean_value (echo.enabled);
+    b.set_member_name ("aec_busy"); b.add_boolean_value (echo.busy);
+    b.set_member_name ("aec_error"); b.add_string_value (echo.error ?? "");
+    b.end_object ();
+    var generator = new Json.Generator ();
+    generator.set_root (b.get_root ());
+    print ("%s\n", generator.to_data (null));
+    stdout.flush ();
+}
+
+int main () {
+    assert (Environment.get_variable ("EQ_PRIVATE_TEST") == "1");
+    Gtk.init ();
+    model = new Sound.SpeakerEqualizer ();
+    echo = new Sound.EchoCancellation ();
+    panel = new Sound.SpeakerEqualizerPanel ();
+    bool generic = Environment.get_variable ("EQ_TEST_GENERIC") == "1";
+    var device = new Sound.Device ("fixture", 42, generic ? "analog-output-speaker" : "fixture-speaker") {
+        card_sink_name = generic ? "alsa_output.pci-0000_00_1f.3.analog-stereo" : "elementary.eq.test"
+    };
+    panel.set_device (device);
+    var window = new Gtk.Window () { child = panel, default_width = 600, default_height = 450 };
+    var header = (Gtk.Box) panel.get_first_child ();
+    toggle = (Gtk.Switch) header.get_last_child ();
+    reset = (Gtk.Button) header.get_next_sibling ();
+    bands = (Gtk.Grid) reset.get_next_sibling ();
+    window.present ();
+    loop = new MainLoop ();
+    model.changed.connect (snapshot);
+    var input = new IOChannel.unix_new (0);
+    input.add_watch (IOCondition.IN | IOCondition.HUP, (channel, condition) => {
+        if (IOCondition.HUP in condition) { loop.quit (); return Source.REMOVE; }
+        string line;
+        try { channel.read_line (out line, null, null); }
+        catch (Error e) { error (e.message); }
+        line = line.strip ();
+        if (line == "on") model.enable (true);
+        else if (line == "off") model.enable (false);
+        else if (line == "zero") {
+            for (int band = 0; band < 5; band++) {
+                model.set_band (band, 0);
+            }
+        }
+        else if (line == "reset") model.reset ();
+        else if (line == "gain") model.set_band (0, -6);
+        else if (line == "invalid-gains") {
+            model.set_band (0, double.parse ("nan"));
+            model.set_band (0, 1000);
+            model.set_band (-1, -6);
+        }
+        else if (line == "gtk-toggle") {
+            toggle.activate ();
+            device.notify_property ("description"); // Refresh must not cancel the user's pending toggle.
+        }
+        else if (line == "gtk-zero") {
+            for (int band = 0; band < 5; band++) {
+                ((Gtk.Scale) bands.get_child_at (1, band)).set_value (0);
+            }
+        }
+        else if (line == "gtk-reset") reset.clicked ();
+        else if (line.has_prefix ("gtk-gain ")) {
+            string[] words = line.split (" ");
+            ((Gtk.Scale) bands.get_child_at (1, int.parse (words[1]))).set_value (double.parse (words[2]));
+        }
+        else if (line.has_prefix ("select-output ")) {
+            string[] words = line.split (" ");
+            device = new Sound.Device ("fixture", 42, words[2]) { card_sink_name = words[1] };
+            panel.set_device (device);
+        }
+        else if (line == "aec-on") echo.request (true);
+        else if (line == "aec-off") echo.request (false);
+        else if (line == "quit") { loop.quit (); return Source.REMOVE; }
+        snapshot ();
+        return Source.CONTINUE;
+    });
+    model.start ();
+    Timeout.add (100, () => { snapshot (); return Source.CONTINUE; });
+    loop.run ();
+    window.destroy ();
+    model.stop ();
+    return 0;
+}
diff --git a/tests/generic-equalizer.vala b/tests/generic-equalizer.vala
new file mode 100644
index 00000000..40f3ec36
--- /dev/null
+++ b/tests/generic-equalizer.vala
@@ -0,0 +1,85 @@
+// Exercise the production model on a private session bus without audio devices.
+[DBus (name = "io.elementary.settings_daemon.Audio")]
+public class GenericEqualizerFixture : Object {
+    public bool oem;
+    public bool malformed;
+    public bool fresh;
+    public signal void equalizer_changed ();
+    public Sound.SpeakerEqualizer.Status get_equalizer_status () throws DBusError, IOError {
+        double[] defaults = new double[0];
+        if (malformed) {
+            defaults = new double[] { 1 };
+        } else if (oem) {
+            defaults = new double[] { 7.5, 8, -1.5, 1.5, 0.5 };
+        }
+        return { true, false, true, "",
+            "/io/elementary/settings-daemon/audio/equalizer/000000000000000000000000000000000000000000000000000000000000000" + (fresh ? "1/" : "0/"),
+            "fixture.output", "analog-output-speaker",
+            { 105, 190, 280, 2800, 8500 }, { "low-shelf", "low-shelf", "peak", "peak", "high-shelf" },
+            defaults,
+            { -12, -12, -12, -12, -12 }, { 8, 8, 8, 8, 8 } };
+    }
+}
+
+int main () {
+    assert (Environment.get_variable ("GSETTINGS_BACKEND") == "memory");
+    var loop = new MainLoop ();
+    var fixture = new GenericEqualizerFixture ();
+    uint owner = Bus.own_name (SESSION, "io.elementary.settings-daemon", NONE, (connection) => {
+        try {
+            connection.register_object ("/io/elementary/settings_daemon", fixture);
+        } catch (Error e) {
+            error (e.message);
+        }
+    });
+    var model = new Sound.SpeakerEqualizer ();
+    model.start ();
+    uint phase = 0;
+    Timeout.add (20, () => {
+        if (phase == 0 && model.status.available) {
+            assert (model.status.defaults.length == 0 && !model.requested);
+            assert (model.get_gains ().length == 5 && model.get_gains ()[0] == 0);
+            model.set_band (0, 8);
+            model.set_band (0, 9);
+            assert (model.get_gains ()[0] == 8 && !model.requested);
+            model.enable (true);
+            model.enable (false);
+            assert (!model.requested && model.get_gains ()[0] == 8);
+            print ("PASS generic zero/off defaults, bounded sliders and Off retains gains\n");
+            fixture.oem = true;
+            fixture.equalizer_changed ();
+            phase++;
+        } else if (phase == 1 && model.status.defaults.length == 5) {
+            assert (!model.requested && model.get_gains ()[0] == 8);
+            model.reset ();
+            assert (model.get_gains ()[0] == 7.5 && !model.requested);
+            print ("PASS policy does not overwrite user values; Reset restores recommendations without enabling\n");
+            fixture.fresh = true;
+            fixture.equalizer_changed ();
+            phase++;
+        } else if (phase == 2 && model.requested && model.get_gains ()[0] == 7.5) {
+            print ("PASS fresh OEM policy starts enabled with recommended gains\n");
+            model.enable (false);
+            model.set_band (0, -6);
+            fixture.equalizer_changed ();
+            phase++;
+        } else if (phase == 3 && !model.requested && model.get_gains ()[0] == -6) {
+            fixture.malformed = true;
+            fixture.equalizer_changed ();
+            phase++;
+        } else if (phase == 4 && !model.status.available) {
+            assert (!model.requested);
+            model.enable (true);
+            assert (!model.requested);
+            print ("PASS malformed declared recommendations fail closed\n");
+            model.stop ();
+            Bus.unown_name (owner);
+            loop.quit ();
+            return Source.REMOVE;
+        }
+        return Source.CONTINUE;
+    });
+    Timeout.add_seconds (5, () => { error ("Generic model timeout at phase %u", phase); });
+    loop.run ();
+    return 0;
+}
diff --git a/tests/gtk-controls.vala b/tests/gtk-controls.vala
new file mode 100644
index 00000000..30ce5747
--- /dev/null
+++ b/tests/gtk-controls.vala
@@ -0,0 +1,120 @@
+// Actual GTK controls and production model, with a private read-only Audio fixture.
+// This does not claim native audio integration or acoustic validation.
+[DBus (name = "io.elementary.settings_daemon.Audio")]
+public class EqualizerFixture : Object {
+    public bool failed { get; set; }
+    public bool generic { get; set; }
+    public signal void equalizer_changed ();
+    public Sound.SpeakerEqualizer.Status get_equalizer_status () throws DBusError, IOError {
+        return { !failed, false, false, failed ? "Fixture audit failure" : "",
+            "/io/elementary/settings-daemon/audio/equalizer/0000000000000000000000000000000000000000000000000000000000000000/",
+            "fixture.output", "fixture-speaker",
+            { 105, 190, 280, 2800, 8500 }, { "low-shelf", "low-shelf", "peak", "peak", "high-shelf" },
+            generic ? new double[0] : new double[] { -1, -2, -3, -4, -5 }, { -12, -12, -12, -12, -12 }, { 12, 12, 12, 12, 12 } };
+    }
+}
+
+int main () {
+    assert (Environment.get_variable ("GSETTINGS_BACKEND") == "memory");
+    assert (Environment.get_variable ("EQ_PRIVATE_TEST") == "1");
+    Gtk.init ();
+    var loop = new MainLoop ();
+    var service = new EqualizerFixture ();
+    uint owner = Bus.own_name (SESSION, "io.elementary.settings-daemon", NONE, (connection) => {
+        try { connection.register_object ("/io/elementary/settings_daemon", service); }
+        catch (Error e) { error (e.message); }
+    });
+    var prefs = new Settings.with_path ("io.elementary.settings-daemon.audio.equalizer",
+        "/io/elementary/settings-daemon/audio/equalizer/0000000000000000000000000000000000000000000000000000000000000000/");
+    var panel = new Sound.SpeakerEqualizerPanel ();
+    var device = new Sound.Device ("fixture", 42, "fixture-speaker") { card_sink_name = "fixture.output" };
+    panel.set_device (device);
+    var window = new Gtk.Window () { child = panel, default_width = 600, default_height = 450 };
+    var header = (Gtk.Box) panel.get_first_child ();
+    var toggle = (Gtk.Switch) header.get_last_child ();
+    var reset = (Gtk.Button) header.get_next_sibling ();
+    var bands = (Gtk.Grid) reset.get_next_sibling ();
+    var slider = (Gtk.Scale) bands.get_child_at (1, 0);
+    var feedback = (Gtk.Label) bands.get_next_sibling ();
+    uint phase = 0;
+    window.present ();
+    Timeout.add (50, () => {
+        if (phase == 0 && toggle.sensitive) {
+            assert (!toggle.active);
+            toggle.activate ();
+            device.notify_property ("description"); // Ordinary device refresh during the switch animation.
+            phase++;
+        } else if (phase == 1 && prefs.get_boolean ("enabled")) {
+            assert (toggle.active && bands.sensitive);
+            string[] expected_labels = { "Bass", "Low mids", "Mids", "Air", "Upper balance" };
+            string[] expected_tooltips = { "105 Hz", "190 Hz", "280 Hz", "2800 Hz", "8500 Hz" };
+            for (int i = 0; i < 5; i++) {
+                var scale = (Gtk.Scale) bands.get_child_at (1, i);
+                assert (scale.adjustment.lower == -12 && scale.adjustment.upper == 12);
+                var label = (Gtk.Label) bands.get_child_at (0, i);
+                assert (label.label == expected_labels[i]);
+                assert (label.tooltip_text == expected_tooltips[i]);
+            }
+            assert (!feedback.visible);
+            print ("PASS fixed names, profile frequency tooltips, symmetric ranges and no idle status message\n");
+            print ("PASS native GTK enable and sensitivity\n");
+            slider.set_value (-6);
+            assert (prefs.get_value ("gains").get_child_value (0).get_double () == -6);
+            print ("PASS gain slider writes the saved bounded array\n");
+            reset.clicked ();
+            assert (slider.get_value () == -1 && toggle.active);
+            print ("PASS Reset restores recommendations and preserves On\n");
+            device.card_sink_name = "other.output";
+            assert (!toggle.sensitive && !bands.sensitive);
+            device.card_sink_name = "fixture.output";
+            assert (toggle.sensitive);
+            print ("PASS physical output mismatch disables controls\n");
+            service.failed = true;
+            service.equalizer_changed ();
+            phase++;
+        } else if (phase == 2 && !reset.sensitive) {
+            assert (toggle.active && toggle.sensitive && !bands.sensitive && !reset.sensitive);
+            assert (feedback.visible && feedback.label == "Fixture audit failure");
+            slider.set_value (-6);
+            assert (prefs.get_value ("gains").get_child_value (0).get_double () == -1);
+            print ("PASS unsupported status permits withdrawal and refuses gain changes\n");
+            toggle.activate ();
+            device.notify_property ("description");
+            phase++;
+        } else if (phase == 3 && !prefs.get_boolean ("enabled")) {
+            assert (!toggle.active && !toggle.sensitive);
+            print ("PASS failed-status Off withdraws saved enable preference\n");
+            toggle.active = true;
+            assert (!prefs.get_boolean ("enabled"));
+            print ("PASS failed-status enable remains refused\n");
+            service.generic = true;
+            service.failed = false;
+            service.equalizer_changed ();
+            phase++;
+        } else if (phase == 4 && toggle.sensitive && !toggle.active) {
+            phase++;
+        } else if (phase == 5 && reset.sensitive && !toggle.active) {
+            reset.clicked ();
+            assert (slider.get_value () == 0 && !toggle.active);
+            toggle.active = true;
+            slider.set_value (-6);
+            assert (prefs.get_value ("gains").get_child_value (0).get_double () == -6);
+            toggle.active = false;
+            assert (slider.get_value () == -6 && bands.sensitive);
+            reset.clicked ();
+            assert (slider.get_value () == 0 && !toggle.active);
+            print ("PASS generic sliders, Off retains gains, Reset restores zero and preserves Off\n");
+            Bus.unown_name (owner);
+            phase++;
+        } else if (phase == 6 && !toggle.sensitive) {
+            print ("PASS service disappearance disables controls\n");
+            window.destroy ();
+            loop.quit ();
+            return Source.REMOVE;
+        }
+        return Source.CONTINUE;
+    });
+    Timeout.add_seconds (8, () => { error ("GTK controls timeout at phase %u", phase); });
+    loop.run ();
+    return 0;
+}
diff --git a/tests/run-active-bridge.sh b/tests/run-active-bridge.sh
new file mode 100644
index 00000000..f8120769
--- /dev/null
+++ b/tests/run-active-bridge.sh
@@ -0,0 +1,42 @@
+#!/bin/sh
+# Private SDK only. Never install a profile into the real system data directory.
+set -eu
+test "${EQ_PRIVATE_TEST:-}" = 1
+test ! -e /dev/snd
+test -f "${EQ_OEM_RULE:?Pass the reviewed OEM 51 WirePlumber rule for ordering checks}"
+test -f "${EQ_OEM_PROFILE:?Pass the matching reviewed OEM profile}"
+daemon_source=${1:?Pass the absolute companion EQ daemon source directory}
+cd "$(dirname "$0")/.."
+profile_root=$(mktemp -d /root/elementary-eq-bridge.XXXXXX)
+trap 'rm -rf "$profile_root"' EXIT
+mkdir -p tests/schemas
+cp "$daemon_source/data/io.elementary.settings-daemon.gschema.xml" tests/schemas/
+glib-compile-schemas tests/schemas
+wp_prefix=${EQ_WP_PREFIX:-/usr}
+mkdir -p tests/wp-vapi
+vapigen --library=wireplumber-0.5 --pkg=gio-2.0 --metadatadir="$daemon_source/vapi" \
+    --directory=tests/wp-vapi "$wp_prefix/share/gir-1.0/Wp-0.5.gir" > tests/wp-vapi/build.log 2>&1
+cc -g -fsanitize=address -fno-omit-frame-pointer -DGETTEXT_PACKAGE=\"io.elementary.settings-daemon\" "-DEQ_PROFILE_DIR=\"$profile_root/v1\"" \
+    -c "$daemon_source/src/Backends/speaker-equalizer-profile.c" \
+    $(pkg-config --cflags gio-2.0) -o tests/bridge-profile.o
+cc -g "$daemon_source/tests/graph-rules.c" $(pkg-config --cflags --libs wireplumber-0.5) -o tests/graph-rules
+cc -g "$daemon_source/tests/bridge-device.c" $(pkg-config --cflags --libs libpipewire-0.3) -o tests/bridge-device
+valac --pkg libpulse --pkg libpulse-mainloop-glib --pkg gio-2.0 --pkg libpulse-operation \
+    --pkg speaker-equalizer-profile --pkg wireplumber-0.5 --vapidir="$daemon_source/vapi" --vapidir=tests/wp-vapi \
+    -X '-DGETTEXT_PACKAGE="io.elementary.settings-daemon"' -X "-I$daemon_source/src" \
+    -X "-I$wp_prefix/include/wireplumber-0.5" -X "-L$wp_prefix/lib/x86_64-linux-gnu" \
+    -X -fsanitize=address -X -fno-omit-frame-pointer -X -g \
+    -X tests/bridge-profile.o -X -lwireplumber-0.5 -X -lm -o tests/bridge-audio-owner \
+    "$daemon_source/src/Backends/EchoProcessor.vala" "$daemon_source/src/Backends/Audio.vala" \
+    "$daemon_source/src/Backends/SpeakerEqualizer.vala" tests/aec-regression/audio-owner.vala \
+    > tests/bridge-owner-build.log 2>&1
+valac --pkg gtk4 --pkg granite-7 --pkg gee-0.8 --pkg libpulse --pkg gio-2.0 --pkg json-glib-1.0 \
+    -X '-DGETTEXT_PACKAGE="io.elementary.settings.sound"' -o tests/bridge-client \
+    src/SpeakerEqualizer.vala src/SpeakerEqualizerPanel.vala src/Device.vala src/EchoCancellation.vala \
+    tests/bridge-client.vala > tests/bridge-client-build.log 2>&1
+ASAN_OPTIONS=detect_leaks=0 EQ_DAEMON_SOURCE="$daemon_source" EQ_TEST_PROFILE_DIR="$profile_root/v1" EQ_TEST_PROFILE="$daemon_source/tests/fixture-v1.ini" \
+    python3 tests/active-bridge.py
+for scenario in valid oem-valid oem-independent-graph untrusted oem-empty oem-wildcard oem-untrusted invalid-layout; do
+    ASAN_OPTIONS=detect_leaks=0 EQ_DAEMON_SOURCE="$daemon_source" EQ_GENERIC_CASE="$scenario" \
+        EQ_TEST_PROFILE_DIR="$profile_root/v1" python3 tests/active-bridge.py
+done
diff --git a/tests/run-components.sh b/tests/run-components.sh
new file mode 100644
index 00000000..189e136c
--- /dev/null
+++ b/tests/run-components.sh
@@ -0,0 +1,40 @@
+#!/bin/sh
+# Run in an isolated SDK copy with the companion daemon source as argument.
+set -eu
+test "${EQ_PRIVATE_TEST:-}" = 1
+test ! -e /dev/snd
+daemon_source=${1:?Pass the absolute companion EQ daemon source directory}
+cd "$(dirname "$0")/.."
+mkdir -p tests/schemas validation
+cp "$daemon_source/data/io.elementary.settings-daemon.gschema.xml" data/sound.gschema.xml tests/schemas/
+glib-compile-schemas tests/schemas
+valac --pkg gio-2.0 -X '-DGETTEXT_PACKAGE="io.elementary.settings.sound"' \
+    -o tests/generic-equalizer src/SpeakerEqualizer.vala tests/generic-equalizer.vala
+mkdir -p tests/model-schemas
+cp "$daemon_source/data/io.elementary.settings-daemon.gschema.xml" tests/model-schemas/
+printf '[io.elementary.settings-daemon.audio.equalizer]\nenabled=true\n' > tests/model-schemas/91-vendor.gschema.override
+glib-compile-schemas tests/model-schemas
+GSETTINGS_BACKEND=memory GSETTINGS_SCHEMA_DIR="$PWD/tests/model-schemas" \
+    dbus-run-session -- tests/generic-equalizer
+valac --pkg gtk4 --pkg granite-7 --pkg gee-0.8 --pkg libpulse --pkg gio-2.0 \
+    -X '-DGETTEXT_PACKAGE="io.elementary.settings.sound"' -o tests/gtk-controls \
+    src/SpeakerEqualizer.vala src/SpeakerEqualizerPanel.vala src/Device.vala tests/gtk-controls.vala \
+    > tests/gtk-build.log 2>&1
+GSETTINGS_BACKEND=memory GSETTINGS_SCHEMA_DIR="$PWD/tests/schemas" GTK_A11Y=none \
+    dbus-run-session -- xvfb-run -a tests/gtk-controls > tests/gtk-controls.log 2>&1
+
+# The combined bridge builds the production owner through generated WP bindings.
+sh tests/run-active-bridge.sh "$daemon_source"
+cp tests/bridge-audio-owner tests/aec-regression/audio-owner
+valac --pkg gio-2.0 --pkg json-glib-1.0 -X '-DGETTEXT_PACKAGE="io.elementary.settings.sound"' \
+    -o tests/aec-regression/echo-client src/EchoCancellation.vala tests/aec-regression/echo-client.vala \
+    > tests/echo-client-build.log 2>&1
+valac --pkg libpulse --pkg libpulse-mainloop-glib -o tests/aec-regression/stream-client \
+    tests/aec-regression/stream-client.vala > tests/stream-client-build.log 2>&1
+valac --pkg gtk4 --pkg granite-7 --pkg switchboard-3 --pkg gee-0.8 --pkg libpulse --pkg libpulse-mainloop-glib --pkg gio-2.0 \
+    --pkg libpulse-ext --vapidir=vapi -X '-DGETTEXT_PACKAGE="io.elementary.settings.sound"' \
+    -o tests/aec-regression/ui-client src/EchoCancellation.vala src/PulseAudioManager.vala src/InputPanel.vala \
+    src/InputDeviceMonitor.vala src/Device.vala src/DeviceRow.vala src/App.vala tests/aec-regression/ui-client.vala \
+    > tests/aec-ui-build.log 2>&1
+AEC_WITH_EQ=1 python3 tests/aec-regression/run-functional.py pulse > tests/aec-pulse.log 2>&1
+AEC_WITH_EQ=1 python3 tests/aec-regression/run-functional.py pipewire > tests/aec-pipewire.log 2>&1

From efeecdf7f42047c840cce7ac6ac9d3bc3107bc6a Mon Sep 17 00:00:00 2001
From: Sean Rhodes <sean@starlabs.systems>
Date: Tue, 6 Oct 2026 07:14:37 +0100
Subject: [PATCH 3/8] Sound: Use sidebar navigation

The device list takes up most of the window, so on high resolution
displays it looks like a bug. Pilfer the layout from Mouse & Touchpad
and keep each page's controls together when scrolling.

Test=StarFighter MTL: Input/Output sidebars and scrolling.
---
 src/ApplicationsPanel.vala          | 25 +++++++-------
 src/InputPanel.vala                 | 30 +++++++++--------
 src/OutputPanel.vala                | 35 +++++++++++---------
 src/Plug.vala                       | 51 +++++++++++++----------------
 src/SpeakerEqualizerPanel.vala      |  2 +-
 tests/aec-regression/ui-client.vala |  2 +-
 tests/bridge-client.vala            |  4 +--
 tests/gtk-controls.vala             |  6 ++--
 8 files changed, 79 insertions(+), 76 deletions(-)

diff --git a/src/ApplicationsPanel.vala b/src/ApplicationsPanel.vala
index 1b0c4374..9203f24e 100644
--- a/src/ApplicationsPanel.vala
+++ b/src/ApplicationsPanel.vala
@@ -5,8 +5,16 @@
 * Authored by: Leonhard Kargl <leo.kargl@proton.me>
 */
 
-public class Sound.ApplicationsPanel : Gtk.Box {
+public class Sound.ApplicationsPanel : Switchboard.SettingsPage {
+    public ApplicationsPanel () {
+        Object (
+            title: _("Applications"),
+            icon: new ThemedIcon ("preferences-desktop-apps")
+        );
+    }
+
     construct {
+        show_end_title_buttons = true;
         var pulse_audio_manager = PulseAudioManager.get_default ();
 
         var placeholder = new Granite.Placeholder (_("No applications currently emitting sounds")) {
@@ -20,23 +28,18 @@ public class Sound.ApplicationsPanel : Gtk.Box {
         list_box.set_placeholder (placeholder);
         list_box.add_css_class (Granite.STYLE_CLASS_RICH_LIST);
 
-        var scrolled_window = new Gtk.ScrolledWindow () {
-            child = list_box,
-            vexpand = true
-        };
-
         var frame = new Gtk.Frame (null) {
-            child = scrolled_window
+            child = list_box
         };
 
         var reset_button = new Gtk.Button.with_label (_("Reset all apps to default")) {
             halign = END
         };
 
-        orientation = VERTICAL;
-        spacing = 12;
-        append (frame);
-        append (reset_button);
+        var content_box = new Gtk.Box (VERTICAL, 12);
+        content_box.append (frame);
+        content_box.append (reset_button);
+        child = content_box;
 
         // TODO: Reset also non active applications
         reset_button.clicked.connect (() => {
diff --git a/src/InputPanel.vala b/src/InputPanel.vala
index 2a232be7..735d631c 100644
--- a/src/InputPanel.vala
+++ b/src/InputPanel.vala
@@ -5,7 +5,7 @@
  * Authored by: Corentin Noël <corentin@elementary.io>
  */
 
-public class Sound.InputPanel : Gtk.Box {
+public class Sound.InputPanel : Switchboard.SettingsPage {
     private Device? default_device = null;
     private Gtk.LevelBar level_bar;
     private Gtk.ListBox devices_listbox;
@@ -19,8 +19,15 @@ public class Sound.InputPanel : Gtk.Box {
     private bool monitor_visible;
     private unowned PulseAudioManager pam;
 
+    public InputPanel () {
+        Object (
+            title: _("Input"),
+            icon: new ThemedIcon ("audio-input-microphone")
+        );
+    }
+
     construct {
-        margin_bottom = 12;
+        show_end_title_buttons = true;
 
         var no_device_grid = new Granite.Placeholder (
             _("No Connected Audio Devices Detected")
@@ -30,8 +37,7 @@ public class Sound.InputPanel : Gtk.Box {
         };
 
         devices_listbox = new Gtk.ListBox () {
-            activate_on_single_click = true,
-            vexpand = true
+            activate_on_single_click = true
         };
         devices_listbox.set_placeholder (no_device_grid);
         devices_listbox.add_css_class (Granite.STYLE_CLASS_RICH_LIST);
@@ -40,12 +46,8 @@ public class Sound.InputPanel : Gtk.Box {
             pam.set_default_device.begin (((Sound.DeviceRow) row).device);
         });
 
-        var scrolled = new Gtk.ScrolledWindow () {
-            child = devices_listbox
-        };
-
         var devices_frame = new Gtk.Frame (null) {
-            child = scrolled
+            child = devices_listbox
         };
 
         var volume_label = new Granite.HeaderLabel (_("Input Volume"));
@@ -110,11 +112,11 @@ public class Sound.InputPanel : Gtk.Box {
         echo_grid.attach (echo_status, 0, 2);
         echo_grid.attach (echo_switch, 1, 0, 1, 2);
 
-        orientation = VERTICAL;
-        spacing = 18;
-        append (devices_frame);
-        append (volume_grid);
-        append (echo_grid);
+        var content_box = new Gtk.Box (VERTICAL, 18);
+        content_box.append (devices_frame);
+        content_box.append (volume_grid);
+        content_box.append (echo_grid);
+        child = content_box;
 
         device_monitor = new InputDeviceMonitor ();
         device_monitor.update_fraction.connect ((fraction) => {
diff --git a/src/OutputPanel.vala b/src/OutputPanel.vala
index 83b9a522..a520aa47 100644
--- a/src/OutputPanel.vala
+++ b/src/OutputPanel.vala
@@ -5,7 +5,7 @@
  * Authored by: Corentin Noël <corentin@elementary.io>
  */
 
-public class Sound.OutputPanel : Gtk.Box {
+public class Sound.OutputPanel : Switchboard.SettingsPage {
     public bool screen_reader_active { get; set; }
 
     private Device default_device = null;
@@ -35,7 +35,15 @@ public class Sound.OutputPanel : Gtk.Box {
         }
     }
 
+    public OutputPanel () {
+        Object (
+            title: _("Output"),
+            icon: new ThemedIcon ("audio-speakers")
+        );
+    }
+
     construct {
+        show_end_title_buttons = true;
         var no_device_grid = new Granite.Placeholder (
             _("No Connected Output Devices Detected")
         ) {
@@ -44,18 +52,13 @@ public class Sound.OutputPanel : Gtk.Box {
         };
 
         devices_listbox = new Gtk.ListBox () {
-            activate_on_single_click = true,
-            vexpand = true
+            activate_on_single_click = true
         };
         devices_listbox.set_placeholder (no_device_grid);
         devices_listbox.add_css_class (Granite.STYLE_CLASS_RICH_LIST);
 
-        var scrolled = new Gtk.ScrolledWindow () {
-            child = devices_listbox
-        };
-
         var devices_frame = new Gtk.Frame (null) {
-            child = scrolled
+            child = devices_listbox
         };
 
         var volume_label = new Granite.HeaderLabel (_("Volume"));
@@ -137,14 +140,14 @@ public class Sound.OutputPanel : Gtk.Box {
         screen_reader_box.append (screen_reader_label);
         screen_reader_box.append (screen_reader_switch);
 
-        orientation = VERTICAL;
-        spacing = 18;
-        append (devices_frame);
-        append (output_grid);
-        append (equalizer);
-        append (alerts_box);
-        append (screen_reader_box);
-        append (test_button);
+        var content_box = new Gtk.Box (VERTICAL, 18);
+        content_box.append (devices_frame);
+        content_box.append (output_grid);
+        content_box.append (equalizer);
+        content_box.append (alerts_box);
+        content_box.append (screen_reader_box);
+        content_box.append (test_button);
+        child = content_box;
 
         var applications_settings = new GLib.Settings ("org.gnome.desktop.a11y.applications");
 
diff --git a/src/Plug.vala b/src/Plug.vala
index 0a763e22..ebfd7ea1 100644
--- a/src/Plug.vala
+++ b/src/Plug.vala
@@ -6,7 +6,7 @@
  */
 
 public class Sound.Plug : Switchboard.Plug {
-    private Gtk.Box box;
+    private Gtk.Paned paned;
     private Gtk.Stack stack;
     private InputPanel input_panel;
 
@@ -28,55 +28,50 @@ public class Sound.Plug : Switchboard.Plug {
     }
 
     public override Gtk.Widget get_widget () {
-        if (box == null) {
+        if (paned == null) {
             var output_panel = new OutputPanel ();
             input_panel = new InputPanel ();
             var applications_panel = new ApplicationsPanel ();
 
             stack = new Gtk.Stack () {
-                hexpand = true,
-                vexpand = true,
-                margin_start = 12,
-                margin_end = 12,
-                margin_bottom = 12
+                vhomogeneous = false
             };
-            stack.add_titled (output_panel, "output", _("Output"));
-            stack.add_titled (input_panel, "input", _("Input"));
-            stack.add_titled (applications_panel, "applications", _("Applications"));
+            stack.add_named (output_panel, "output");
+            stack.add_named (input_panel, "input");
+            stack.add_named (applications_panel, "applications");
 
-            var stack_switcher = new Gtk.StackSwitcher () {
-                halign = Gtk.Align.CENTER,
-                stack = stack
+            var sidebar = new Switchboard.SettingsSidebar (stack) {
+                show_title_buttons = true
             };
-            ((Gtk.BoxLayout) stack_switcher.layout_manager).homogeneous = true;
 
-            var clamp = new Adw.Clamp () {
-                child = stack
+            paned = new Gtk.Paned (HORIZONTAL) {
+                start_child = sidebar,
+                resize_start_child = false,
+                shrink_start_child = false,
+                end_child = stack,
+                shrink_end_child = false
             };
 
-            var headerbar = new Adw.HeaderBar () {
-                title_widget = stack_switcher
-            };
-            headerbar.add_css_class (Granite.STYLE_CLASS_FLAT);
-
-            box = new Gtk.Box (VERTICAL, 0);
-            box.append (headerbar);
-            box.append (clamp);
+            var schema = SettingsSchemaSource.get_default ().lookup ("io.elementary.settings", true);
+            if (schema != null && schema.has_key ("sidebar-position")) {
+                var settings = new Settings ("io.elementary.settings");
+                settings.bind ("sidebar-position", paned, "position", DEFAULT);
+            }
 
             var pam = PulseAudioManager.get_default ();
             pam.start ();
 
             stack.notify["visible-child"].connect (() => {
-                input_panel.set_visibility (stack.visible_child == input_panel);
+                input_panel.set_visibility (stack.visible_child_name == "input");
             });
         }
 
-        return box;
+        return paned;
     }
 
     public override void shown () {
-        box.show ();
-        if (stack.visible_child == input_panel) {
+        paned.show ();
+        if (stack.visible_child_name == "input") {
             input_panel.set_visibility (true);
         }
     }
diff --git a/src/SpeakerEqualizerPanel.vala b/src/SpeakerEqualizerPanel.vala
index 2b632ab6..9cb267fa 100644
--- a/src/SpeakerEqualizerPanel.vala
+++ b/src/SpeakerEqualizerPanel.vala
@@ -46,8 +46,8 @@ public class Sound.SpeakerEqualizerPanel : Gtk.Box {
         feedback = new Gtk.Label ("") { wrap = true, xalign = 0 };
         feedback.add_css_class ("dim-label");
         append (header);
-        append (reset);
         append (bands);
+        append (reset);
         append (feedback);
         enabled.notify["active"].connect (() => { if (!updating) equalizer.enable (enabled.active); });
         reset.clicked.connect (equalizer.reset);
diff --git a/tests/aec-regression/ui-client.vala b/tests/aec-regression/ui-client.vala
index e484e53f..6189e70b 100644
--- a/tests/aec-regression/ui-client.vala
+++ b/tests/aec-regression/ui-client.vala
@@ -105,7 +105,7 @@ int main () {
     Gtk.init ();
     var panel = new Sound.InputPanel ();
     var window = new Gtk.Window () { child = panel, default_width = 700, default_height = 550 };
-    var grid = (Gtk.Grid) panel.get_last_child ();
+    var grid = (Gtk.Grid) panel.child.get_last_child ();
     var toggle = (Gtk.Switch) grid.get_child_at (1, 0);
     var pam = Sound.PulseAudioManager.get_default ();
     var loop = new MainLoop ();
diff --git a/tests/bridge-client.vala b/tests/bridge-client.vala
index 3f932b95..873f1788 100644
--- a/tests/bridge-client.vala
+++ b/tests/bridge-client.vala
@@ -52,8 +52,8 @@ int main () {
     var window = new Gtk.Window () { child = panel, default_width = 600, default_height = 450 };
     var header = (Gtk.Box) panel.get_first_child ();
     toggle = (Gtk.Switch) header.get_last_child ();
-    reset = (Gtk.Button) header.get_next_sibling ();
-    bands = (Gtk.Grid) reset.get_next_sibling ();
+    bands = (Gtk.Grid) header.get_next_sibling ();
+    reset = (Gtk.Button) bands.get_next_sibling ();
     window.present ();
     loop = new MainLoop ();
     model.changed.connect (snapshot);
diff --git a/tests/gtk-controls.vala b/tests/gtk-controls.vala
index 30ce5747..530459ab 100644
--- a/tests/gtk-controls.vala
+++ b/tests/gtk-controls.vala
@@ -32,10 +32,10 @@ int main () {
     var window = new Gtk.Window () { child = panel, default_width = 600, default_height = 450 };
     var header = (Gtk.Box) panel.get_first_child ();
     var toggle = (Gtk.Switch) header.get_last_child ();
-    var reset = (Gtk.Button) header.get_next_sibling ();
-    var bands = (Gtk.Grid) reset.get_next_sibling ();
+    var bands = (Gtk.Grid) header.get_next_sibling ();
+    var reset = (Gtk.Button) bands.get_next_sibling ();
     var slider = (Gtk.Scale) bands.get_child_at (1, 0);
-    var feedback = (Gtk.Label) bands.get_next_sibling ();
+    var feedback = (Gtk.Label) reset.get_next_sibling ();
     uint phase = 0;
     window.present ();
     Timeout.add (50, () => {

From e8683bbec258aa2f9ccbd3cb78c801e217cdc75e Mon Sep 17 00:00:00 2001
From: Sean Rhodes <sean@starlabs.systems>
Date: Tue, 6 Oct 2026 16:12:12 +0100
Subject: [PATCH 4/8] Sound: Check equalizer graph removal when disabled

---
 docs/speaker-equalizer.md  |   2 +-
 tests/active-bridge.py     | 152 +++++++++++++++++++++++++------------
 tests/run-active-bridge.sh |  12 ++-
 3 files changed, 115 insertions(+), 51 deletions(-)

diff --git a/docs/speaker-equalizer.md b/docs/speaker-equalizer.md
index 56fa974c..dc8c9a06 100644
--- a/docs/speaker-equalizer.md
+++ b/docs/speaker-equalizer.md
@@ -12,7 +12,7 @@ User preferences take precedence over recommendations. Invalid profiles remain
 unavailable; a supported operation failure can be recovered by an explicit
 changed preference after the daemon revalidates the graph.
 
-Private integration checks use the companion daemon source and vendor graph
+Private integration checks use the companion daemon source and vendor marker policy
 and profile, in the existing SDK without `/dev/snd`:
 
 ```
diff --git a/tests/active-bridge.py b/tests/active-bridge.py
index 45d48bf2..eaeb32a9 100644
--- a/tests/active-bridge.py
+++ b/tests/active-bridge.py
@@ -24,11 +24,12 @@
 node_name = 'alsa_output.pci-0000_00_1f.3.analog-stereo' if generic else 'elementary.eq.test'
 legacy = os.environ.get('EQ_LEGACY') == '1'
 cache_probe = os.environ.get('EQ_TEST_CACHE_PARAMS') == '1'
-evidence = base / ('bridge-generic-'+generic_case if generic else 'bridge-cache-results' if cache_probe else 'bridge-legacy-results' if legacy else 'bridge-results')
+restart_probe = os.environ.get('EQ_SERVER_RESTART_TEST') == '1'
+evidence = base / ('bridge-server-restart-results' if restart_probe else 'bridge-generic-'+generic_case if generic else 'bridge-cache-results' if cache_probe else 'bridge-legacy-results' if legacy else 'bridge-results')
 evidence.mkdir(exist_ok=True)
 runtime = Path(tempfile.mkdtemp(prefix='vale-sound-eq-bridge-'))
 profiles = Path(os.environ['EQ_TEST_PROFILE_DIR'])
-assert profiles.parent.parent == Path('/root') and profiles.parent.name.startswith('elementary-eq-bridge.')
+assert profiles.parent.parent == Path.home() and profiles.parent.name.startswith('elementary-eq-bridge.')
 profiles.mkdir(exist_ok=True)
 daemon_source = Path(os.environ['EQ_DAEMON_SOURCE'])
 profile_id = 'generic-speakers-v1' if generic else 'fixture-v1'
@@ -141,6 +142,10 @@ def props(identifier=None):
     values = {k:float(v) for k,v in re.findall(r'String "(eos_eq_[^"]+)"\s+Float ([-\d.eE+]+)', text)}
     return values
 
+def bypassed(identifier=None):
+    node = sink_id if identifier is None else identifier
+    return not props(node) and 'eos_eq_' not in run(['pw-cli', 'enum-params', str(node), 'PropInfo'], False)
+
 def curve(gains, headroom, identifier=None):
     values = props(identifier)
     return all(abs(values.get(f'eos_eq_{i+1}:Gain', 999)-g) < .001 for i,g in enumerate(gains)) and abs(values.get('eos_eq_h:Mult', 999)-headroom) < .00001
@@ -164,6 +169,18 @@ def native_clients():
             str(o.get('info',{}).get('props',{}).get('application.process.id'))==str(owner.pid) and
             o['info']['props'].get('client.api') != 'pipewire-pulse']
 
+def create_fixture():
+    cli([
+        f'create-node adapter {{ factory.name = support.null-audio-sink node.name = {node_name} '
+        f'media.class = Audio/Sink device.id = {card_id} card.profile.device = 0 '
+        f'elementary.eq.profile = {profile_id} node.cache-params = '+('true' if cache_probe else 'false')+' audio.channels = 2 audio.position = [ FL FR ] '
+        'priority.session = 1000 object.linger = true }',
+        'create-node adapter { factory.name = audiotestsrc node.name = elementary.eq.tone '
+        f'device.id = {card_id} card.profile.device = 1 '
+        'media.class = Audio/Source audio.channels = 2 audio.position = [ FL FR ] '
+        'priority.session = 2000 object.linger = true }'
+    ])
+
 try:
     bus = start('bus', ['dbus-daemon', '--session', '--nofork', '--print-address=1'], stdout=subprocess.PIPE, text=True)
     assert select.select([bus.stdout], [], [], 3)[0]
@@ -173,8 +190,10 @@ def native_clients():
     card = start('card', [str(base/'bridge-device')], stdout=subprocess.PIPE, text=True)
     assert select.select([card.stdout], [], [], 3)[0]
     card_id = int(card.stdout.readline())
+    if restart_probe:
+        create_fixture()
     pulse = start('pulse', ['pipewire-pulse'])
-    start('wireplumber', ['wireplumber'])
+    wireplumber = start('wireplumber', ['wireplumber'])
     wait(lambda:(runtime/'native').exists())
     if generic:
         marker = run([str(base/'graph-rules'), node_name]).strip()
@@ -183,16 +202,8 @@ def native_clients():
               run([str(base/'graph-rules'), 'alsa_output.other', 'invalid-oem-v1']).strip() == 'invalid-oem-v1')
         check('non_alsa_output_has_no_generic_marker',
               run([str(base/'graph-rules'), 'bluez_output.fixture']).strip() == '')
-    cli([
-        f'create-node adapter {{ factory.name = support.null-audio-sink node.name = {node_name} '
-        f'media.class = Audio/Sink device.id = {card_id} card.profile.device = 0 '
-        f'elementary.eq.profile = {profile_id} node.cache-params = '+('true' if cache_probe else 'false')+' audio.channels = 2 audio.position = [ FL FR ] '
-        'priority.session = 1000 object.linger = true }',
-        'create-node adapter { factory.name = audiotestsrc node.name = elementary.eq.tone '
-        f'device.id = {card_id} card.profile.device = 1 '
-        'media.class = Audio/Source audio.channels = 2 audio.position = [ FL FR ] '
-        'priority.session = 2000 object.linger = true }'
-    ])
+    if not restart_probe:
+        create_fixture()
     wait(lambda:any(s['name']==node_name for s in sinks()))
     if generic_case == 'oem-independent-graph':
         run(['pw-cli','set-param',str(card_id),'Route','{ index = 1 device = 0 }'])
@@ -218,7 +229,7 @@ def native_clients():
     fmt = dict(mediaType='audio', mediaSubtype='raw', format='F32P', rate=48000, channels=2, position=['FL','FR'])
     cli([f'set-param {tone_id} PortConfig '+json.dumps(dict(direction='Output', mode='dsp', format=fmt)),
          f'set-param {sink_id} PortConfig '+json.dumps(dict(direction='Input', mode='dsp', format=fmt)),
-         *([] if generic else [f'set-param {sink_id} Props '+json.dumps(dict(params=['audioconvert.filter-graph.0', graph]))]),
+         *([ ] if not (legacy or cache_probe) else [f'set-param {sink_id} Props '+json.dumps(dict(params=['audioconvert.filter-graph.0', graph]))]),
          f'set-param {sink_id} Props '+json.dumps(dict(channelVolumes=[.7,.35],mute=True))])
     for channel in ('FL','FR'): run(['pw-link', f'elementary.eq.tone:capture_{channel}', f'{node_name}:playback_{channel}'])
     run(['pw-cli','enum-params',str(sink_id),'PropInfo'])
@@ -239,11 +250,8 @@ def native_clients():
         wait(lambda:any(sink['name'] == hdmi_name for sink in sinks()))
         hdmi_id = next(o['id'] for o in objects() if o.get('info',{}).get('props',{}).get('node.name') == hdmi_name)
         run(['pactl','set-default-sink',hdmi_name])
-    if generic:
-        wait(lambda:len(props()) == 48)
-        metadata = run(['pw-cli','enum-params',str(sink_id),'Props'])
-        check('only_one_shipped_neutral_graph', curve([0]*5,1) and
-              len(re.findall(r'String "(eos_eq_[^"]+)"', metadata)) == 48)
+    if not (legacy or cache_probe):
+        check('no_graph_before_processing_is_enabled', bypassed())
     owner = start('audio-owner', [str(base/'bridge-audio-owner')])
     run(['gdbus','wait','--session','--timeout=5','io.elementary.settings-daemon'])
     env['GTK_A11Y']='none'
@@ -286,7 +294,7 @@ def read():
             (profiles/(profile_id+'.ini')).unlink()
             run(['pactl','set-default-sink',next_name])
             wait(lambda:receive().get('node') == next_name and last.get('available') and last.get('applied'))
-            check('removed_previous_profile_does_not_block_new_output', curve([0]*5,1,next_id))
+            check('removed_previous_profile_does_not_block_new_output', bypassed(next_id))
             raise SystemExit(0)
         if generic_case not in ('valid', 'oem-valid'):
             expected_error = {
@@ -302,7 +310,7 @@ def read():
             check('declared_oem_or_untrusted_profile_fails_closed', True)
             send('on')
             time.sleep(.3)
-            check('invalid_profile_enable_does_not_fallback', curve([0]*5,1) and not receive()['available'])
+            check('invalid_profile_enable_does_not_fallback', bypassed() and not receive()['available'])
             raise SystemExit(0)
         if generic_case == 'oem-valid':
             recommended = [7.5,8,-0.5,1.5,.5]
@@ -322,7 +330,7 @@ def read():
             send('gtk-gain 0 -6')
             wait(lambda:receive().get('applied') and curve([-6,8,-0.5,1.5,.5],1))
             send('gtk-toggle')
-            wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+            wait(lambda:not receive().get('enabled',True) and last.get('applied') and bypassed())
             check('native_oem_off_retains_saved_gains', last['gains'] == [-6,8,-0.5,1.5,.5])
             path = profiles/(profile_id+'.ini')
             path.write_text(path.read_text().replace('DefaultGains=7.5;8;-0.5;1.5;0.5;', 'DefaultGains=0;0;0;0;0;'))
@@ -338,7 +346,7 @@ def read():
         check('selected_hdmi_has_neutral_independent_preferences',
               not last['enabled'] and last['gains'] == [0]*5 and last['route'] == 'hdmi-output-0')
         run(['pactl','set-default-sink',node_name])
-        wait(lambda:receive().get('available') and last.get('applied'))
+        wait(lambda:receive().get('node') == node_name and last.get('available') and last.get('applied'))
         check('hdmi_default_to_speakers_discovers_generic_eq', last['node'] == node_name)
         unused_card = start('unused-card', [str(base/'bridge-device'), 'elementary.eq.unused-card'],
             stdout=subprocess.PIPE, text=True)
@@ -354,13 +362,14 @@ def read():
         check('never_started_output_has_no_initialized_controls', 'eos_eq_1:Gain' not in props(unused_id))
         run(['pactl','set-default-sink',unused_name])
         wait(lambda:receive().get('node') == unused_name and last.get('available') and not last.get('busy'))
-        check('never_started_output_waits_without_writing', not last['applied'] and not last['error'])
+        check('never_started_off_output_needs_no_graph', last['applied'] and not last['error'] and bypassed(unused_id))
         run(['pactl','set-default-sink',node_name])
         wait(lambda:receive().get('node') == node_name and last.get('applied'))
         check('never_started_default_switch_releases_untouched_graph', 'eos_eq_1:Gain' not in props(unused_id))
         run(['pw-cli','destroy',str(unused_id)])
         run(['pw-cli','destroy',str(hdmi_id)])
         check('generic_defaults_are_empty', last['defaults_count'] == 0 and last['gains'] == [0]*5)
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.0',graph]))])
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-7.]))])
         wait(lambda:receive().get('error') and last.get('available') and not last.get('applied'))
         check('generic_off_failure_remains_supported', not last['enabled'] and last['gtk_switch_sensitive'])
@@ -374,7 +383,7 @@ def read():
         wait(lambda:receive().get('error') and last.get('gtk_switch_sensitive') and last.get('available') and not last.get('applied'))
         check('generic_normalized_default_stays_failed', last['gains'] == [0]*5 and curve([-7,0,0,0,0],1))
         send('gtk-toggle')
-        wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+        wait(lambda:not receive().get('enabled',True) and last.get('applied') and bypassed())
         check('generic_failed_off_recovers_with_normalized_default', True)
         send('on')
         wait(lambda:receive().get('enabled') and last.get('applied'))
@@ -395,7 +404,7 @@ def read():
         send('gtk-gain 0 3')
         wait(lambda:receive().get('applied') and curve([3,0,0,0,0],1))
         run(['pw-cli','set-param',str(card_id),'Route','{ index = 1 device = 0 }'])
-        wait(lambda:receive().get('route')=='analog-output-headphones' and curve([0]*5,1))
+        wait(lambda:receive().get('route')=='analog-output-headphones' and bypassed())
         send('select-output '+node_name+' analog-output-headphones')
         wait(lambda:receive().get('gtk_switch_sensitive'))
         check('generic_headphones_have_neutral_independent_preferences',
@@ -409,7 +418,7 @@ def read():
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-7.]))])
         wait(lambda:receive().get('error') and last.get('available'))
         send('gtk-toggle')
-        wait(lambda:not receive().get('enabled',True) and not last.get('error') and curve([0]*5,1))
+        wait(lambda:not receive().get('enabled',True) and not last.get('error') and bypassed())
         check('explicit_off_on_headphones_revalidates_failed_bypass', last['gains'] == [-6,0,0,0,0])
         run(['pw-cli','set-param',str(card_id),'Route','{ index = 0 device = 0 }'])
         send('select-output '+node_name+' analog-output-speaker')
@@ -442,17 +451,17 @@ def read():
               not last['applied'] and curve([3,0,0,0,0],1))
         run(['pactl','set-default-sink',usb_name])
         wait(lambda:receive().get('node') == usb_name and last.get('available') and last.get('applied'))
-        check('two_speaker_defaults_retire_idle_old_graph', curve([0]*5,1) and curve([0]*5,1,usb_id))
+        check('two_speaker_defaults_retire_idle_old_graph', bypassed() and bypassed(usb_id))
         check('new_output_hides_old_physical_panel', not last['gtk_switch_sensitive'])
         send('on')
         time.sleep(.5)
         send('gain')
         wait(lambda:receive().get('applied') and curve([-6,0,0,0,0],1,usb_id))
-        check('second_output_custom_uses_its_own_preferences', curve([0]*5,1))
+        check('second_output_custom_uses_its_own_preferences', bypassed())
         linked(True)
         run(['pactl','set-default-sink',node_name])
         wait(lambda:receive().get('node') == node_name and last.get('applied') and curve([3,0,0,0,0],1))
-        check('return_to_first_output_restores_preferences_and_neutralizes_second', curve([0]*5,1,usb_id))
+        check('return_to_first_output_restores_preferences_and_removes_second_graph', bypassed(usb_id))
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Freq',201.]))])
         wait(lambda:receive().get('error') and not last.get('applied'))
         run(['pactl','set-default-sink',usb_name])
@@ -468,10 +477,55 @@ def read():
         check('no_second_visible_output', len(sinks()) == 1)
         raise SystemExit(0)
     wait(lambda:receive().get('available') and last.get('applied'))
-    if not legacy: check('initial_off_is_flat_unity', curve([0]*5,1))
+    if not legacy: check('initial_off_has_no_graph', bypassed())
     send('on')
     wait(lambda:receive().get('enabled') and last.get('applied') and curve([-1,-2,-3,-4,-5],1))
     check('model_daemon_pulse_native_default_applied', True)
+    if restart_probe:
+        old_properties = next(o['info']['props'] for o in objects() if o['id'] == sink_id)
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-8.]))])
+        wait(lambda:receive().get('error') and not last.get('applied'))
+        for process in (wireplumber, pulse, card, server):
+            if process.poll() is None:
+                process.terminate()
+            process.wait(timeout=5)
+        wait(lambda:not receive().get('available'))
+        # Keep the reconnecting owner from allocating globals before the
+        # replacement fixture has recreated the original IDs.
+        owner.send_signal(signal.SIGSTOP)
+        try:
+            server = start('new-pipewire', ['pipewire'])
+            wait(lambda:(runtime/'elementary-eq-bridge').exists())
+            card = start('new-card', [str(base/'bridge-device')], stdout=subprocess.PIPE, text=True)
+            assert select.select([card.stdout], [], [], 3)[0]
+            card_id = int(card.stdout.readline())
+            create_fixture()
+            pulse = start('new-pulse', ['pipewire-pulse'])
+            wireplumber = start('new-wireplumber', ['wireplumber'])
+            wait(lambda:(runtime/'native').exists())
+            wait(lambda:any(s['name'] == node_name for s in sinks()))
+            nodes = objects()
+            sink_id = next(n['id'] for n in nodes if n.get('info',{}).get('props',{}).get('node.name') == node_name)
+            tone_id = next(n['id'] for n in nodes if n.get('info',{}).get('props',{}).get('node.name') == 'elementary.eq.tone')
+            cli([f'set-param {tone_id} PortConfig '+json.dumps(dict(direction='Output',mode='dsp',format=fmt)),
+                 f'set-param {sink_id} PortConfig '+json.dumps(dict(direction='Input',mode='dsp',format=fmt))])
+            linked(True)
+            run(['pactl','set-default-sink',node_name])
+        finally:
+            owner.send_signal(signal.SIGCONT)
+        wait(lambda:receive().get('enabled') and last.get('applied') and curve([-1,-2,-3,-4,-5],1), 15)
+        check('new_server_restores_saved_eq_after_failed_old_graph', owner.poll() is None)
+        new_properties = next(o['info']['props'] for o in objects() if o['id'] == sink_id)
+        identity_keys = ('object.serial', 'device.id')
+        (evidence/'server-restart.json').write_text(json.dumps(dict(
+            before={key:old_properties[key] for key in identity_keys},
+            after={key:new_properties[key] for key in identity_keys}))+'\n')
+        check('new_server_reuses_request_identifiers',
+              all(old_properties[key] == new_properties[key] for key in identity_keys))
+        send('off')
+        wait(lambda:receive().get('applied') and bypassed())
+        check('new_server_off_removes_graph', True)
+        raise SystemExit(0)
     settings_path = re.search(r'/io/elementary/settings-daemon/audio/equalizer/[0-9a-f]+/', backend_status()).group()
     schema = 'io.elementary.settings-daemon.audio.equalizer:' + settings_path
     run(['gsettings','set',schema,'gains','[1000., -2., -3., -4., -5.]'])
@@ -507,7 +561,7 @@ def read_events():
         send('reset')
         wait(lambda:receive().get('applied') and curve([-1,-2,-3,-4,-5],1))
         send('off')
-        wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+        wait(lambda:not receive().get('enabled',True) and last.get('applied') and bypassed())
         wait(lambda:receive().get('gtk_switch_sensitive') and last.get('aec_available'))
         send('aec-on')
         wait(lambda:receive().get('aec_enabled') and not last.get('aec_busy') and last.get('applied') and last.get('gtk_switch_sensitive'))
@@ -526,11 +580,11 @@ def read_events():
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-8.]))])
         wait(lambda:receive().get('error') and last.get('gtk_switch_sensitive') and last.get('gtk_bands_sensitive'))
         send('gtk-toggle')
-        wait(lambda:not receive().get('gtk_on',True) and last.get('applied') and curve([0]*5,1))
+        wait(lambda:not receive().get('gtk_on',True) and last.get('applied') and bypassed())
         check('real_gtk_failed_off_recovers_unity_with_owned_aec', last['aec_enabled'])
         send('aec-off')
         wait(lambda:not receive().get('aec_enabled',True) and not last.get('aec_busy'))
-        check('owned_aec_disables_without_changing_eq_controls', curve([0]*5,1))
+        check('owned_aec_disables_without_attaching_eq', bypassed())
         check('failed_off_withdraws_preference_and_bypasses', True)
         send('on'); wait(lambda:receive().get('enabled') and last.get('applied') and curve([-1,-2,-3,-4,-5],1))
         send('zero'); wait(lambda:receive().get('applied') and curve([0]*5,1))
@@ -539,7 +593,7 @@ def read_events():
         send('gain'); wait(lambda:receive().get('applied') and curve([-6,-2,-3,-4,-5],1))
         check('explicit_custom_keeps_unity_gain', True)
         run(['pw-cli','set-param',str(card_id),'Route','{ index = 1 device = 0 }'])
-        wait(lambda:receive().get('route')=='fixture-headphones' and curve([0]*5,1))
+        wait(lambda:receive().get('route')=='fixture-headphones' and bypassed())
         check('headphones_do_not_inherit_oem_recommendations',
               last['available'] and not last['enabled'] and last['defaults_count'] == 0 and last['gains'] == [0]*5)
         run(['pw-cli','set-param',str(card_id),'Route','{ index = 0 device = 0 }'])
@@ -563,7 +617,7 @@ def read_events():
             time.sleep(1.2)
             check('foreign_idle_'+control.split(':')[1]+'_survives_resume', curve(expected,headroom))
             send('off')
-            wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+            wait(lambda:not receive().get('enabled',True) and last.get('applied') and bypassed())
             send('on')
             wait(lambda:receive().get('enabled') and last.get('applied') and curve([-6,-2,-3,-4,-5],1))
         clients = native_clients()
@@ -590,32 +644,36 @@ def read_events():
         check('pulse_bridge_restart_retains_failure_and_foreign_gains',
               owner.poll() is None and not last['applied'] and curve([-8,-2,-3,-4,-5],1))
         send('off')
-        wait(lambda:not receive().get('enabled',True) and last.get('applied') and curve([0]*5,1))
+        wait(lambda:not receive().get('enabled',True) and last.get('applied') and bypassed())
         send('invalid-gains')
         time.sleep(.3)
-        check('nonfinite_out_of_range_and_invalid_band_refused', curve([0]*5,1))
+        check('nonfinite_out_of_range_and_invalid_band_refused', bypassed())
         linked(False)
-        wait(lambda:not receive().get('applied'))
+        wait(lambda:next(o['info']['state'] for o in objects() if o['id'] == sink_id) in ('idle', 'suspended'))
+        wait(lambda:receive().get('applied') and bypassed())
         send('on')
-        wait(lambda:receive().get('enabled') and not last.get('busy'))
-        check('explicit_idle_request_waits_for_running_node', not last['applied'])
+        # The preference arrives before the daemon has reconciled the request.
+        wait(lambda:receive().get('enabled') and not last.get('busy') and not last.get('applied'))
+        check('explicit_idle_request_waits_for_running_node', bypassed())
         run(['pw-cli','destroy',str(native_clients()[0]['id'])])
         wait(lambda:receive().get('error'))
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.0',graph]))])
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-8.]))])
         linked(True)
         wait(lambda:len(native_clients()) == 1 and receive().get('error') and not last.get('applied'))
         time.sleep(.5)
         check('idle_write_authority_is_revoked_on_disconnect', curve([-8,0,0,0,0],1))
         send('off')
-        wait(lambda:receive().get('applied') and curve([0]*5,1))
+        wait(lambda:receive().get('applied') and bypassed())
         linked(False)
-        wait(lambda:not receive().get('applied'))
+        wait(lambda:next(o['info']['state'] for o in objects() if o['id'] == sink_id) in ('idle', 'suspended'))
+        wait(lambda:receive().get('applied') and bypassed())
         send('on')
-        wait(lambda:receive().get('enabled') and not last.get('busy'))
+        wait(lambda:receive().get('enabled') and not last.get('busy') and not last.get('applied'))
         send('off')
         wait(lambda:not receive().get('enabled',True) and not last.get('busy'))
         linked(True)
-        wait(lambda:receive().get('applied') and curve([0]*5,1))
+        wait(lambda:receive().get('applied') and bypassed())
         check('superseded_idle_request_never_applies_old_gains', True)
         # Queue a real Props notification while the owner is stopped, then stall
         # the server before allowing its async audit to issue enumeration.
@@ -632,9 +690,9 @@ def read_events():
         finally:
             server.send_signal(signal.SIGCONT)
         wait(lambda:receive().get('applied') and len(native_clients())==1)
-        check('deadline_cancellation_reconnects_without_old_write', curve([0]*5,1))
+        check('deadline_cancellation_reconnects_without_old_write', bypassed())
         run(['pw-cli','set-param',str(sink_id),'Props','{ mute = true }'])
-        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.1',graph]))])
+        run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.0',graph,'audioconvert.filter-graph.1',graph]))])
         wait(lambda:receive().get('error') and not last['applied'])
         check('duplicate_reserved_namespace_fails_closed', not last['applied'])
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.1','']))])
diff --git a/tests/run-active-bridge.sh b/tests/run-active-bridge.sh
index f8120769..c9b169a2 100644
--- a/tests/run-active-bridge.sh
+++ b/tests/run-active-bridge.sh
@@ -3,16 +3,19 @@
 set -eu
 test "${EQ_PRIVATE_TEST:-}" = 1
 test ! -e /dev/snd
+test "$(id -u)" = 0
 test -f "${EQ_OEM_RULE:?Pass the reviewed OEM 51 WirePlumber rule for ordering checks}"
 test -f "${EQ_OEM_PROFILE:?Pass the matching reviewed OEM profile}"
 daemon_source=${1:?Pass the absolute companion EQ daemon source directory}
 cd "$(dirname "$0")/.."
-profile_root=$(mktemp -d /root/elementary-eq-bridge.XXXXXX)
+profile_root=$(mktemp -d "$HOME/elementary-eq-bridge.XXXXXX")
 trap 'rm -rf "$profile_root"' EXIT
 mkdir -p tests/schemas
 cp "$daemon_source/data/io.elementary.settings-daemon.gschema.xml" tests/schemas/
 glib-compile-schemas tests/schemas
-wp_prefix=${EQ_WP_PREFIX:-/usr}
+wp_prefix=$(pkg-config --variable=prefix wireplumber-0.5)
+wp_includedir=$(pkg-config --variable=includedir wireplumber-0.5)
+wp_libdir=$(pkg-config --variable=libdir wireplumber-0.5)
 mkdir -p tests/wp-vapi
 vapigen --library=wireplumber-0.5 --pkg=gio-2.0 --metadatadir="$daemon_source/vapi" \
     --directory=tests/wp-vapi "$wp_prefix/share/gir-1.0/Wp-0.5.gir" > tests/wp-vapi/build.log 2>&1
@@ -24,7 +27,7 @@ cc -g "$daemon_source/tests/bridge-device.c" $(pkg-config --cflags --libs libpip
 valac --pkg libpulse --pkg libpulse-mainloop-glib --pkg gio-2.0 --pkg libpulse-operation \
     --pkg speaker-equalizer-profile --pkg wireplumber-0.5 --vapidir="$daemon_source/vapi" --vapidir=tests/wp-vapi \
     -X '-DGETTEXT_PACKAGE="io.elementary.settings-daemon"' -X "-I$daemon_source/src" \
-    -X "-I$wp_prefix/include/wireplumber-0.5" -X "-L$wp_prefix/lib/x86_64-linux-gnu" \
+    -X "-I$wp_includedir/wireplumber-0.5" -X "-L$wp_libdir" \
     -X -fsanitize=address -X -fno-omit-frame-pointer -X -g \
     -X tests/bridge-profile.o -X -lwireplumber-0.5 -X -lm -o tests/bridge-audio-owner \
     "$daemon_source/src/Backends/EchoProcessor.vala" "$daemon_source/src/Backends/Audio.vala" \
@@ -36,6 +39,9 @@ valac --pkg gtk4 --pkg granite-7 --pkg gee-0.8 --pkg libpulse --pkg gio-2.0 --pk
     tests/bridge-client.vala > tests/bridge-client-build.log 2>&1
 ASAN_OPTIONS=detect_leaks=0 EQ_DAEMON_SOURCE="$daemon_source" EQ_TEST_PROFILE_DIR="$profile_root/v1" EQ_TEST_PROFILE="$daemon_source/tests/fixture-v1.ini" \
     python3 tests/active-bridge.py
+ASAN_OPTIONS=detect_leaks=0 EQ_DAEMON_SOURCE="$daemon_source" EQ_SERVER_RESTART_TEST=1 \
+    EQ_TEST_PROFILE_DIR="$profile_root/v1" EQ_TEST_PROFILE="$daemon_source/tests/fixture-v1.ini" \
+    python3 tests/active-bridge.py
 for scenario in valid oem-valid oem-independent-graph untrusted oem-empty oem-wildcard oem-untrusted invalid-layout; do
     ASAN_OPTIONS=detect_leaks=0 EQ_DAEMON_SOURCE="$daemon_source" EQ_GENERIC_CASE="$scenario" \
         EQ_TEST_PROFILE_DIR="$profile_root/v1" python3 tests/active-bridge.py

From 83ffdd90bc441278dbdac747f65bae86ccbca34a Mon Sep 17 00:00:00 2001
From: Sean Rhodes <sean@starlabs.systems>
Date: Tue, 6 Oct 2026 22:35:01 +0100
Subject: [PATCH 5/8] Sound: Check for device updates before waiting

The profile change may have already published its sink or source.
Read the current endpoints after switching profiles, then check the
property before waiting for another notification.
---
 src/PulseAudioManager.vala          | 18 +++++++++++++--
 tests/aec-regression/ui-client.vala | 34 ++++++++++++++++++++++++++++-
 2 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/src/PulseAudioManager.vala b/src/PulseAudioManager.vala
index 148c757d..efcaf416 100644
--- a/src/PulseAudioManager.vala
+++ b/src/PulseAudioManager.vala
@@ -137,7 +137,15 @@ public class Sound.PulseAudioManager : GLib.Object {
                 if (!(yield set_card_profile_by_index (device.card_index, profile_name))) {
                     return;
                 }
-                // wait for new card sink to appear
+                // Discard names from the old profile, then query the server's
+                // current endpoints. A subscription update may already be cached.
+                string endpoint_property = device.input ? "card-source-name" : "card-sink-name";
+                device.set (endpoint_property, null);
+                var endpoints = device.input ? context.get_source_info_list (source_info_callback) :
+                    context.get_sink_info_list (sink_info_callback);
+                if (!(yield wait_operation (endpoints))) {
+                    return;
+                }
                 debug ("wait for card sink / source");
                 if (!(yield wait_for_update (device, device.input? "card-source-name" : "card-sink-name"))) {
                     return;
@@ -240,7 +248,13 @@ public class Sound.PulseAudioManager : GLib.Object {
         return true;
     }
 
-    private async bool wait_for_update (Device device, string prop_name) {
+    internal async bool wait_for_update (Device device, string prop_name) {
+        string current_value;
+        device.get (prop_name, out current_value);
+        if (current_value != null) {
+            return true;
+        }
+
         bool success = false;
         bool finished = false;
         var deadline = new TimeoutSource (5000);
diff --git a/tests/aec-regression/ui-client.vala b/tests/aec-regression/ui-client.vala
index 6189e70b..81903168 100644
--- a/tests/aec-regression/ui-client.vala
+++ b/tests/aec-regression/ui-client.vala
@@ -99,6 +99,30 @@ Sound.Device other_device (bool input, string suffix = "2") {
     return device;
 }
 
+async void check_device_updates (Sound.PulseAudioManager pam) {
+    var device = other_device (false);
+    int64 start = get_monotonic_time ();
+    assert (yield pam.wait_for_update (device, "sink-name"));
+    assert (get_monotonic_time () - start < 500000);
+    print ("PASS device already published before waiting\n");
+
+    device.sink_name = null;
+    Timeout.add (20, () => {
+        device.sink_name = "physical_output2";
+        return Source.REMOVE;
+    });
+    assert (yield pam.wait_for_update (device, "sink-name"));
+    print ("PASS subsequent device notification completes waiting\n");
+
+    device.sink_name = null;
+    Timeout.add (20, () => {
+        device.removed ();
+        return Source.REMOVE;
+    });
+    assert (!(yield pam.wait_for_update (device, "sink-name")));
+    print ("PASS removed device cancels waiting\n");
+}
+
 // Smoke test the real InputPanel's switch, including programmatic state updates.
 int main () {
     assert (Environment.get_variable ("PULSE_SERVER").has_prefix ("unix:/tmp/vale-sound-"));
@@ -127,6 +151,7 @@ int main () {
         }
     });
     uint phase = 0;
+    bool updates_checked = false;
     int64 clicked_at = 0;
     bool external_sink = false;
     bool external_source = false;
@@ -156,7 +181,14 @@ int main () {
             return Source.CONTINUE;
         }
 
-        if (phase == 0) {
+        if (phase == 0 && !updates_checked) {
+            phase = 90;
+            check_device_updates.begin (pam, (obj, result) => {
+                check_device_updates.end (result);
+                updates_checked = true;
+                phase = 0;
+            });
+        } else if (phase == 0) {
             assert (!toggle.active && toggle.sensitive);
             toggle.activate ();
             clicked_at = get_monotonic_time ();

From f157ef397a4e83da6d346d1c26a21b42bab12e3e Mon Sep 17 00:00:00 2001
From: Sean Rhodes <sean@starlabs.systems>
Date: Tue, 6 Oct 2026 22:35:01 +0100
Subject: [PATCH 6/8] Sound: Confirm equalizer processing on the switch

Keep the saved request separate from the confirmed switch state.
Keep the last confirmed state until the daemon acknowledges the new
preference, and clear it when the output or service changes.

Test=StarFighter: switch, gain sliders and Reset reach the physical
     output and restore the saved curve.
Test=Private GTK regression covers delayed and failed removal, successful
     retry, output changes and service disappearance.
---
 src/SpeakerEqualizer.vala      |  7 +++-
 src/SpeakerEqualizerPanel.vala | 19 ++++++++-
 tests/gtk-controls.vala        | 74 +++++++++++++++++++++++++++++-----
 3 files changed, 88 insertions(+), 12 deletions(-)

diff --git a/src/SpeakerEqualizer.vala b/src/SpeakerEqualizer.vala
index 46a3338a..36f19c2a 100644
--- a/src/SpeakerEqualizer.vala
+++ b/src/SpeakerEqualizer.vala
@@ -110,7 +110,12 @@ public class Sound.SpeakerEqualizer : Object {
         changed ();
     }
 
-    private void preferences_changed () { changed (); }
+    private void preferences_changed () {
+        generation++;
+        pending = false;
+        status.applied = false;
+        changed ();
+    }
 
     private void refresh () {
         pending = true;
diff --git a/src/SpeakerEqualizerPanel.vala b/src/SpeakerEqualizerPanel.vala
index 9cb267fa..3a826d77 100644
--- a/src/SpeakerEqualizerPanel.vala
+++ b/src/SpeakerEqualizerPanel.vala
@@ -14,6 +14,8 @@ public class Sound.SpeakerEqualizerPanel : Gtk.Box {
     private Gtk.Label[] values = {};
     private Device? device;
     private bool updating;
+    private string confirmed_profile = "";
+    private bool confirmed_enabled;
 
     construct {
         orientation = VERTICAL;
@@ -50,6 +52,9 @@ public class Sound.SpeakerEqualizerPanel : Gtk.Box {
         append (reset);
         append (feedback);
         enabled.notify["active"].connect (() => { if (!updating) equalizer.enable (enabled.active); });
+        enabled.state_set.connect (() => {
+            return true;
+        });
         reset.clicked.connect (equalizer.reset);
         equalizer.changed.connect (update);
         map.connect (() => equalizer.start ());
@@ -77,8 +82,18 @@ public class Sound.SpeakerEqualizerPanel : Gtk.Box {
         // for the newly selected physical output.
         bool matches = device != null && status.node == device.card_sink_name && status.route == device.port_name;
         enabled.visible = reset.visible = matches;
-        if (enabled.active != equalizer.requested) enabled.active = equalizer.requested;
-        enabled.sensitive = matches && (status.available || enabled.active);
+        if (!matches || confirmed_profile != status.settings_path) {
+            confirmed_enabled = false;
+        }
+        confirmed_profile = matches ? status.settings_path : "";
+        if (matches && status.applied) {
+            confirmed_enabled = equalizer.requested;
+        }
+        enabled.state = confirmed_enabled;
+        if (enabled.active != equalizer.requested) {
+            enabled.active = equalizer.requested;
+        }
+        enabled.sensitive = matches && !status.busy && (status.available || enabled.active);
         reset.sensitive = matches && status.available;
         bands.sensitive = matches && status.available;
         var gains = equalizer.get_gains ();
diff --git a/tests/gtk-controls.vala b/tests/gtk-controls.vala
index 530459ab..74f588eb 100644
--- a/tests/gtk-controls.vala
+++ b/tests/gtk-controls.vala
@@ -4,9 +4,12 @@
 public class EqualizerFixture : Object {
     public bool failed { get; set; }
     public bool generic { get; set; }
+    public bool removal_failed { get; set; }
+    public bool busy { get; set; }
+    public bool applied { get; set; default = true; }
     public signal void equalizer_changed ();
     public Sound.SpeakerEqualizer.Status get_equalizer_status () throws DBusError, IOError {
-        return { !failed, false, false, failed ? "Fixture audit failure" : "",
+        return { !failed, busy, applied, failed || removal_failed ? "Fixture audit failure" : "",
             "/io/elementary/settings-daemon/audio/equalizer/0000000000000000000000000000000000000000000000000000000000000000/",
             "fixture.output", "fixture-speaker",
             { 105, 190, 280, 2800, 8500 }, { "low-shelf", "low-shelf", "peak", "peak", "high-shelf" },
@@ -40,12 +43,55 @@ int main () {
     window.present ();
     Timeout.add (50, () => {
         if (phase == 0 && toggle.sensitive) {
-            assert (!toggle.active);
+            assert (!toggle.active && !toggle.state);
             toggle.activate ();
             device.notify_property ("description"); // Ordinary device refresh during the switch animation.
             phase++;
         } else if (phase == 1 && prefs.get_boolean ("enabled")) {
+            assert (toggle.active && !toggle.state && bands.sensitive);
+            service.applied = false;
+            service.busy = true;
+            service.equalizer_changed ();
+            phase = 10;
+        } else if (phase == 10 && !toggle.sensitive) {
+            assert (toggle.active && !toggle.state && !feedback.visible);
+            service.busy = false;
+            service.applied = true;
+            service.equalizer_changed ();
+            phase = 11;
+        } else if (phase == 11 && toggle.state && toggle.sensitive) {
+            print ("PASS requested, busy and confirmed GTK switch states\n");
             assert (toggle.active && bands.sensitive);
+            toggle.activate ();
+            phase = 12;
+        } else if (phase == 12 && !prefs.get_boolean ("enabled")) {
+            assert (!toggle.active && toggle.state);
+            service.applied = false;
+            service.busy = true;
+            service.equalizer_changed ();
+            phase = 13;
+        } else if (phase == 13 && !toggle.sensitive) {
+            assert (!toggle.active && toggle.state);
+            service.busy = false;
+            service.removal_failed = true;
+            service.equalizer_changed ();
+            phase = 14;
+        } else if (phase == 14 && feedback.visible && toggle.sensitive) {
+            assert (!toggle.active && toggle.state);
+            print ("PASS pending and failed removal retain the confirmed On state\n");
+            toggle.active = true;
+            toggle.active = false;
+            service.removal_failed = false;
+            service.applied = true;
+            service.equalizer_changed ();
+            phase = 15;
+        } else if (phase == 15 && !toggle.state && !feedback.visible) {
+            assert (!toggle.active);
+            print ("PASS explicit retry confirms Off only after removal succeeds\n");
+            toggle.active = true;
+            service.equalizer_changed ();
+            phase = 16;
+        } else if (phase == 16 && toggle.state) {
             string[] expected_labels = { "Bass", "Low mids", "Mids", "Air", "Upper balance" };
             string[] expected_tooltips = { "105 Hz", "190 Hz", "280 Hz", "2800 Hz", "8500 Hz" };
             for (int i = 0; i < 5; i++) {
@@ -64,16 +110,20 @@ int main () {
             reset.clicked ();
             assert (slider.get_value () == -1 && toggle.active);
             print ("PASS Reset restores recommendations and preserves On\n");
+            toggle.active = false;
+            assert (toggle.state);
             device.card_sink_name = "other.output";
-            assert (!toggle.sensitive && !bands.sensitive);
+            assert (!toggle.sensitive && !bands.sensitive && !toggle.state);
             device.card_sink_name = "fixture.output";
-            assert (toggle.sensitive);
-            print ("PASS physical output mismatch disables controls\n");
+            assert (toggle.sensitive && !toggle.state);
+            toggle.active = true;
+            print ("PASS output change during removal clears confirmation and disables mismatched controls\n");
+            service.applied = false;
             service.failed = true;
             service.equalizer_changed ();
-            phase++;
+            phase = 2;
         } else if (phase == 2 && !reset.sensitive) {
-            assert (toggle.active && toggle.sensitive && !bands.sensitive && !reset.sensitive);
+            assert (toggle.active && !toggle.state && toggle.sensitive && !bands.sensitive && !reset.sensitive);
             assert (feedback.visible && feedback.label == "Fixture audit failure");
             slider.set_value (-6);
             assert (prefs.get_value ("gains").get_child_value (0).get_double () == -1);
@@ -104,10 +154,16 @@ int main () {
             reset.clicked ();
             assert (slider.get_value () == 0 && !toggle.active);
             print ("PASS generic sliders, Off retains gains, Reset restores zero and preserves Off\n");
+            toggle.active = true;
+            service.applied = true;
+            service.equalizer_changed ();
+            phase = 7;
+        } else if (phase == 7 && toggle.state) {
             Bus.unown_name (owner);
-            phase++;
+            phase = 6;
         } else if (phase == 6 && !toggle.sensitive) {
-            print ("PASS service disappearance disables controls\n");
+            assert (!toggle.state);
+            print ("PASS service disappearance clears confirmation and disables controls\n");
             window.destroy ();
             loop.quit ();
             return Source.REMOVE;

From 108fa936b5a4aa5af10583e11c62bbb21a136d4f Mon Sep 17 00:00:00 2001
From: Sean Rhodes <sean@starlabs.systems>
Date: Tue, 6 Oct 2026 22:35:01 +0100
Subject: [PATCH 7/8] Sound: Cover foreign output processing

Try enabling and disabling EQ with unrelated graphs already attached,
including a graph with no controls. Verify both requests preserve them.

Test=StarFighter: foreign graphs survive both requests; explicit
     recovery works after removing them.
---
 tests/active-bridge.py   | 25 ++++++++++++++++++++++++-
 tests/bridge-client.vala |  1 +
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/tests/active-bridge.py b/tests/active-bridge.py
index eaeb32a9..10aa57c1 100644
--- a/tests/active-bridge.py
+++ b/tests/active-bridge.py
@@ -371,7 +371,7 @@ def read():
         check('generic_defaults_are_empty', last['defaults_count'] == 0 and last['gains'] == [0]*5)
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.0',graph]))])
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['eos_eq_1:Gain',-7.]))])
-        wait(lambda:receive().get('error') and last.get('available') and not last.get('applied'))
+        wait(lambda:receive().get('error') and last.get('available') and not last.get('applied') and not last.get('busy'))
         check('generic_off_failure_remains_supported', not last['enabled'] and last['gtk_switch_sensitive'])
         send('gtk-toggle')
         wait(lambda:receive().get('enabled') and last.get('applied') and curve([0]*5,1))
@@ -691,6 +691,29 @@ def read_events():
             server.send_signal(signal.SIGCONT)
         wait(lambda:receive().get('applied') and len(native_clients())==1)
         check('deadline_cancellation_reconnects_without_old_write', bypassed())
+        # A profile marker does not grant ownership of an existing graph.
+        # Exercise both ordinary foreign controls and a graph with no controls.
+        for foreign in (
+            dict(nodes=[dict(type='builtin',name='foreign',label='linear',control=dict(Mult=.7))]),
+            dict(nodes=[dict(type='builtin',name='foreign',label='copy')]),
+        ):
+            run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.0',json.dumps(foreign)]))])
+            wait(lambda:receive().get('error') and not last['applied'])
+            before_foreign = run(['pw-cli','enum-params',str(sink_id),'Props'])
+            send('on')
+            wait(lambda:receive().get('enabled') and last.get('error') and not last['busy'])
+            time.sleep(.3)
+            check('foreign_graph_'+foreign['nodes'][0]['label']+'_survives_enable',
+                  before_foreign == run(['pw-cli','enum-params',str(sink_id),'Props']) and not last['applied'])
+            send('off')
+            wait(lambda:not receive().get('enabled') and last.get('error') and not last['busy'])
+            check('foreign_graph_'+foreign['nodes'][0]['label']+'_survives_disable',
+                  before_foreign == run(['pw-cli','enum-params',str(sink_id),'Props']))
+            run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.0','']))])
+            send('on')
+            wait(lambda:receive().get('applied') and not last['error'])
+            send('off')
+            wait(lambda:receive().get('applied') and bypassed())
         run(['pw-cli','set-param',str(sink_id),'Props','{ mute = true }'])
         run(['pw-cli','set-param',str(sink_id),'Props',json.dumps(dict(params=['audioconvert.filter-graph.0',graph,'audioconvert.filter-graph.1',graph]))])
         wait(lambda:receive().get('error') and not last['applied'])
diff --git a/tests/bridge-client.vala b/tests/bridge-client.vala
index 873f1788..12b6415d 100644
--- a/tests/bridge-client.vala
+++ b/tests/bridge-client.vala
@@ -25,6 +25,7 @@ private void snapshot () {
     b.set_member_name ("route"); b.add_string_value (s.route);
     b.set_member_name ("defaults_count"); b.add_int_value (s.defaults.length);
     b.set_member_name ("gtk_on"); b.add_boolean_value (toggle.active);
+    b.set_member_name ("gtk_switch_state"); b.add_boolean_value (toggle.state);
     b.set_member_name ("gtk_switch_sensitive"); b.add_boolean_value (toggle.sensitive);
     b.set_member_name ("gtk_bands_sensitive"); b.add_boolean_value (bands.sensitive);
     b.set_member_name ("aec_available"); b.add_boolean_value (echo.available);

From 5add2a457ac0fed51da7ac691bca198e679c5a75 Mon Sep 17 00:00:00 2001
From: Sean Rhodes <sean@starlabs.systems>
Date: Tue, 6 Oct 2026 22:46:09 +0100
Subject: [PATCH 8/8] Sound: Keep noise cancellation confirmation backend-owned

Let the daemon confirm processing instead of allowing GTK to confirm
it when the saved request changes.

Test=StarFighter: the input switch unloads and recreates one owned
     echo-cancel module.
---
 src/InputPanel.vala | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/InputPanel.vala b/src/InputPanel.vala
index 735d631c..cf91ad30 100644
--- a/src/InputPanel.vala
+++ b/src/InputPanel.vala
@@ -84,6 +84,9 @@ public class Sound.InputPanel : Switchboard.SettingsPage {
         echo_switch = new Gtk.Switch () {
             valign = START
         };
+        echo_switch.state_set.connect (() => {
+            return true;
+        });
         echo_switch_handler = echo_switch.notify["active"].connect (() => {
             echo_cancellation.request (echo_switch.active);
         });