diff --git a/docs/speaker-equalizer.md b/docs/speaker-equalizer.md
new file mode 100644
index 00000000..dc8c9a06
--- /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 marker policy
+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 22037789..016b5eb3 100644
--- a/po/POTFILES
+++ b/po/POTFILES
@@ -5,7 +5,10 @@ src/TestPopover.vala
 src/PulseAudioManager.vala
 src/Plug.vala
 src/OutputPanel.vala
+src/EchoCancellation.vala
 src/InputPanel.vala
 src/InputDeviceMonitor.vala
 src/DeviceRow.vala
 src/Device.vala
+src/SpeakerEqualizer.vala
+src/SpeakerEqualizerPanel.vala
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/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..cf91ad30 100644
--- a/src/InputPanel.vala
+++ b/src/InputPanel.vala
@@ -5,17 +5,29 @@
  * 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;
     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;
 
+    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")
@@ -25,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);
@@ -35,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"));
@@ -74,10 +81,45 @@ public class Sound.InputPanel : Gtk.Box {
         volume_grid.attach (volume_scale, 0, 2);
         volume_grid.attach (volume_switch, 1, 1, 1, 2);
 
-        orientation = VERTICAL;
-        spacing = 18;
-        append (devices_frame);
-        append (volume_grid);
+        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);
+        });
+
+        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);
+
+        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) => {
@@ -85,6 +127,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 +138,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 +191,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 +217,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/OutputPanel.vala b/src/OutputPanel.vala
index 2a98b20a..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;
@@ -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 {
@@ -34,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")
         ) {
@@ -43,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"));
@@ -136,13 +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 (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");
 
@@ -199,6 +204,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/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/PulseAudioManager.vala b/src/PulseAudioManager.vala
index 7d5d9733..efcaf416 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,379 @@ 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;
+                }
+                // 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;
+                }
+            }
 
-        // #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);
+    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);
+        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 +557,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 +576,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 +661,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 +684,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 +702,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 +771,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 +798,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 +846,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 +884,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 +1061,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 +1105,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 +1153,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/SpeakerEqualizer.vala b/src/SpeakerEqualizer.vala
new file mode 100644
index 00000000..36f19c2a
--- /dev/null
+++ b/src/SpeakerEqualizer.vala
@@ -0,0 +1,203 @@
+/*
+ * 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 () {
+        generation++;
+        pending = false;
+        status.applied = false;
+        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..3a826d77
--- /dev/null
+++ b/src/SpeakerEqualizerPanel.vala
@@ -0,0 +1,114 @@
+/*
+ * 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;
+    private string confirmed_profile = "";
+    private bool confirmed_enabled;
+
+    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 (bands);
+        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 ());
+        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 (!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 ();
+        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 7e03abe1..8a17a060 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -1,10 +1,13 @@
 plug_files = files(
+    'SpeakerEqualizer.vala',
+    'SpeakerEqualizerPanel.vala',
     'App.vala',
     'ApplicationsPanel.vala',
     'AppRow.vala',
     'CanberraGtk4.vala',
     'TestPopover.vala',
     'PulseAudioManager.vala',
+    'EchoCancellation.vala',
     'Plug.vala',
     'OutputPanel.vala',
     'InputPanel.vala',
diff --git a/tests/active-bridge.py b/tests/active-bridge.py
new file mode 100644
index 00000000..10aa57c1
--- /dev/null
+++ b/tests/active-bridge.py
@@ -0,0 +1,768 @@
+#!/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'
+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.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'
+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 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
+
+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']
+
+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]
+    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())
+    if restart_probe:
+        create_fixture()
+    pulse = start('pulse', ['pipewire-pulse'])
+    wireplumber = 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() == '')
+    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 }'])
+        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 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'])
+    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 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'
+    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', bypassed(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', bypassed() 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 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;'))
+            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('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)
+        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_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') 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))
+        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 bypassed())
+        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 bypassed())
+        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 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')
+        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', 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', 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_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])
+        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_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.]'])
+    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 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'))
+        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 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_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))
+        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 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 }'])
+        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 bypassed())
+            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 bypassed())
+        send('invalid-gains')
+        time.sleep(.3)
+        check('nonfinite_out_of_range_and_invalid_band_refused', bypassed())
+        linked(False)
+        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')
+        # 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 bypassed())
+        linked(False)
+        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') 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 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.
+        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', 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'])
+        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/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..7bb66fdd
--- /dev/null
+++ b/tests/aec-regression/run-functional.py
@@ -0,0 +1,361 @@
+#!/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 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
+    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..81903168
--- /dev/null
+++ b/tests/aec-regression/ui-client.vala
@@ -0,0 +1,416 @@
+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;
+}
+
+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-"));
+    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.child.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;
+    bool updates_checked = false;
+    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 && !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 ();
+            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/bridge-client.vala b/tests/bridge-client.vala
new file mode 100644
index 00000000..12b6415d
--- /dev/null
+++ b/tests/bridge-client.vala
@@ -0,0 +1,113 @@
+// 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_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);
+    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 ();
+    bands = (Gtk.Grid) header.get_next_sibling ();
+    reset = (Gtk.Button) bands.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..74f588eb
--- /dev/null
+++ b/tests/gtk-controls.vala
@@ -0,0 +1,176 @@
+// 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 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, 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" },
+            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 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) reset.get_next_sibling ();
+    uint phase = 0;
+    window.present ();
+    Timeout.add (50, () => {
+        if (phase == 0 && toggle.sensitive) {
+            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++) {
+                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");
+            toggle.active = false;
+            assert (toggle.state);
+            device.card_sink_name = "other.output";
+            assert (!toggle.sensitive && !bands.sensitive && !toggle.state);
+            device.card_sink_name = "fixture.output";
+            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 = 2;
+        } else if (phase == 2 && !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);
+            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");
+            toggle.active = true;
+            service.applied = true;
+            service.equalizer_changed ();
+            phase = 7;
+        } else if (phase == 7 && toggle.state) {
+            Bus.unown_name (owner);
+            phase = 6;
+        } else if (phase == 6 && !toggle.sensitive) {
+            assert (!toggle.state);
+            print ("PASS service disappearance clears confirmation and 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..c9b169a2
--- /dev/null
+++ b/tests/run-active-bridge.sh
@@ -0,0 +1,48 @@
+#!/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 "$(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 "$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=$(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
+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_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" \
+    "$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
+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
+done
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/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
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);
+}