mini-eq 0.3.1__tar.gz → 0.3.2__tar.gz

{mini_eq-0.3.1 → mini_eq-0.3.2}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.3.2 - 2026-05-04
+
+- Fix Flatpak system-wide routing by requesting PipeWire manager access from the WirePlumber client.
+- Restore partially routed streams when initial routing fails and reset the routing switch after failures.
+- Avoid restarting output routing during GTK close shutdown.
+- Add a local Flatpak runtime smoke test and an experimental manual CI job for routing checks.
+
 ## 0.3.1 - 2026-05-04
 
 - Improve adaptive layout spacing across compact, tall, and wide windows.

{mini_eq-0.3.1/src/mini_eq.egg-info → mini_eq-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-eq
-Version: 0.3.1
+Version: 0.3.2
 Summary: Compact PipeWire system-wide parametric equalizer for Linux desktops.
 Author: bhack
 License-Expression: GPL-3.0-or-later

{mini_eq-0.3.1 → mini_eq-0.3.2}/data/io.github.bhack.mini-eq.metainfo.xml

@@ -34,11 +34,11 @@
   </description>
   <screenshots>
     <screenshot type="default">
-      <image>https://raw.githubusercontent.com/bhack/mini-eq/v0.3.1/docs/screenshots/mini-eq.png</image>
+      <image>https://raw.githubusercontent.com/bhack/mini-eq/v0.3.2/docs/screenshots/mini-eq.png</image>
       <caption>Adjust sound output with equalizer controls</caption>
     </screenshot>
     <screenshot>
-      <image>https://raw.githubusercontent.com/bhack/mini-eq/v0.3.1/docs/screenshots/mini-eq-dark.png</image>
+      <image>https://raw.githubusercontent.com/bhack/mini-eq/v0.3.2/docs/screenshots/mini-eq-dark.png</image>
       <caption>Use the equalizer with dark style</caption>
     </screenshot>
   </screenshots>
@@ -46,6 +46,15 @@
   <url type="bugtracker">https://github.com/bhack/mini-eq/issues</url>
   <url type="vcs-browser">https://github.com/bhack/mini-eq</url>
   <releases>
+    <release version="0.3.2" date="2026-05-04">
+      <description>
+        <ul>
+          <li>Fix Flatpak system-wide routing access through WirePlumber.</li>
+          <li>Restore partially routed streams when initial routing fails.</li>
+          <li>Avoid restarting routing during window-close shutdown.</li>
+        </ul>
+      </description>
+    </release>
     <release version="0.3.1" date="2026-05-04">
       <description>
         <ul>

{mini_eq-0.3.1 → mini_eq-0.3.2}/docs/flathub.md

@@ -126,6 +126,14 @@ flatpak run --command=flathub-build org.flatpak.Builder --install io.github.bhac
 flatpak run io.github.bhack.mini-eq --check-deps
 ```
 
+When routing, WirePlumber access, Flatpak permissions, runtime dependencies, or
+shutdown behavior changed, also run the upstream runtime smoke test against the
+installed local build before opening or merging the Flathub PR:
+
+```bash
+python3 tools/check_flatpak_runtime.py --app-ref io.github.bhack.mini-eq//master
+```
+
 For a local source and full build check without installing the app:
 
 ```bash

{mini_eq-0.3.1 → mini_eq-0.3.2}/docs/release.md

@@ -94,6 +94,34 @@ If extensions.gnome.org asks for an extension screenshot, capture it from the
 nested fake-control Shell documented in `extensions/gnome-shell/README.md` so no
 real desktop, device, account, or path details are exposed.
 
+## Flatpak Runtime Smoke
+
+Run this after installing the local Flatpak build, and before release
+publication or Flathub handoff, whenever PipeWire routing, WirePlumber access,
+Flatpak permissions, runtime dependencies, or shutdown behavior changed. This
+check temporarily routes a silent host PipeWire stream through Mini EQ and then
+verifies that the stream is restored when the app exits, so keep it separate
+from the generic preflight.
+
+```bash
+flatpak remote-add --if-not-exists --user flathub https://dl.flathub.org/repo/flathub.flatpakrepo
+flatpak install --user -y flathub org.flatpak.Builder//stable
+flatpak run --command=flathub-build org.flatpak.Builder --install io.github.bhack.mini-eq.yaml
+python3 tools/check_flatpak_runtime.py --app-ref io.github.bhack.mini-eq//master
+```
+
+For shutdown changes, also run the installed Flatpak interactively, enable
+system-wide EQ, close the GTK window, and confirm that the app exits without a
+crash and streams are restored:
+
+```bash
+flatpak run io.github.bhack.mini-eq//master --auto-route
+```
+
+There is also an experimental non-blocking GitHub Actions path for this check:
+manually dispatch the `CI` workflow with `flatpak_runtime_smoke=true`. Treat it
+as extra signal only until it has proven stable in the hosted runner.
+
 ## Build
 
 ```bash

{mini_eq-0.3.1 → mini_eq-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mini-eq"
-version = "0.3.1"
+version = "0.3.2"
 description = "Compact PipeWire system-wide parametric equalizer for Linux desktops."
 readme = "README.md"
 requires-python = ">=3.11"

{mini_eq-0.3.1 → mini_eq-0.3.2}/src/mini_eq/window.py

@@ -352,7 +352,7 @@ class MiniEqWindow(
                 self.updating_ui = False
 
             try:
-                self.controller.route_system_audio(False, announce=False)
+                self.controller.route_system_audio(False, announce=False, refresh_output=False)
             except Exception:
                 pass
             finally:
@@ -780,6 +780,11 @@ class MiniEqWindow(
             self.controller.route_system_audio(enabled)
             route_changed = True
         except Exception as exc:
+            self.updating_ui = True
+            try:
+                switch.set_active(self.controller.routed)
+            finally:
+                self.updating_ui = False
             self.set_status(str(exc))
         finally:
             self.update_eq_power_indicator()

{mini_eq-0.3.1 → mini_eq-0.3.2}/src/mini_eq/wireplumber_backend.py

@@ -12,6 +12,8 @@ SPA_ID_TYPE = "Spa:Id"
 STREAM_OUTPUT_AUDIO = "Stream/Output/Audio"
 AUDIO_SINK = "Audio/Sink"
 FILTER_CHAIN_MODULE_NAME = "libpipewire-module-filter-chain"
+PIPEWIRE_CLIENT_NAME = "Mini EQ"
+PIPEWIRE_MEDIA_CATEGORY = "Manager"
 
 
 @dataclass(frozen=True)
@@ -367,7 +369,15 @@ class WirePlumberBackend:
         if not target.object_serial:
             raise WirePlumberError(f"audio sink has no object.serial: {target_node_name}")
 
-        self.set_metadata_and_wait(stream.bound_id, TARGET_OBJECT_KEY, SPA_ID_TYPE, target.object_serial)
+        moved = self.set_metadata_and_wait(stream.bound_id, TARGET_OBJECT_KEY, SPA_ID_TYPE, target.object_serial)
+        if moved:
+            return
+
+        target_object, target_type = self.stream_target_object(stream.bound_id)
+        if target_object != target.object_serial or target_type not in {None, SPA_ID_TYPE}:
+            raise WirePlumberError(
+                f"WirePlumber did not acknowledge moving {stream.display_name} to {target_node_name}"
+            )
 
     def stream_targets_node(self, stream_bound_id: int, target_node_name: str) -> bool:
         target = self.audio_sink_by_name(target_node_name)
@@ -468,8 +478,12 @@ class WirePlumberBackend:
 
     @staticmethod
     def _new_core(Wp):
+        properties = Wp.Properties.new_empty()
+        properties.set("application.name", PIPEWIRE_CLIENT_NAME)
+        properties.set("media.category", PIPEWIRE_MEDIA_CATEGORY)
+
         try:
-            return Wp.Core.new(None, None, None)
+            return Wp.Core.new(None, None, properties)
         except TypeError:
             return Wp.Core.new(None, None)
 

{mini_eq-0.3.1 → mini_eq-0.3.2}/src/mini_eq/wireplumber_stream_router.py

@@ -104,7 +104,7 @@ class WirePlumberStreamRouter:
         self.routed_stream_ids.clear()
         return restored
 
-    def refresh(self) -> bool:
+    def refresh(self, *, raise_errors: bool = False) -> bool:
         if not self.enabled:
             return False
 
@@ -114,6 +114,8 @@ class WirePlumberStreamRouter:
                 self.emit_status(f"routed {routed_now} stream(s) to {self.virtual_sink_name}")
         except Exception as exc:
             self.emit_status(f"routing warning: {exc}")
+            if raise_errors:
+                raise
 
         return False
 
@@ -140,14 +142,14 @@ class WirePlumberStreamRouter:
         if self.event_source_id == 0:
             self.event_source_id = GLib.idle_add(self.on_stream_event_idle)
 
-    def start_monitoring(self) -> None:
+    def start_monitoring(self, *, require_initial_route: bool = False) -> None:
         self.backend.connect()
         self.accept_stream_events = True
 
         if self.object_added_handler_id == 0:
             self.object_added_handler_id = self.backend.connect_object_added(self.handle_object_added)
 
-        self.refresh()
+        self.refresh(raise_errors=require_initial_route)
 
     def stop_monitoring(self) -> None:
         self.accept_stream_events = False
@@ -162,7 +164,13 @@ class WirePlumberStreamRouter:
 
     def enable(self) -> None:
         self.enabled = True
-        self.start_monitoring()
+        try:
+            self.start_monitoring(require_initial_route=True)
+        except Exception:
+            self.enabled = False
+            self.stop_monitoring()
+            self.restore_output_streams()
+            raise
 
     def disable(self, announce: bool = True) -> None:
         if not self.enabled and not self.routed_stream_ids:

{mini_eq-0.3.1 → mini_eq-0.3.2/src/mini_eq.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-eq
-Version: 0.3.1
+Version: 0.3.2
 Summary: Compact PipeWire system-wide parametric equalizer for Linux desktops.
 Author: bhack
 License-Expression: GPL-3.0-or-later

{mini_eq-0.3.1 → mini_eq-0.3.2}/src/mini_eq.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ tests/test_mini_eq_wireplumber_stream_router.py
 tests/test_version_metadata.py
 tools/benchmark_fader_drag.py
 tools/check_flathub_manifest_drift.py
+tools/check_flatpak_runtime.py
 tools/check_gnome_shell_extension.py
 tools/check_wireplumber_gi.py
 tools/demo_runtime.py

{mini_eq-0.3.1 → mini_eq-0.3.2}/tests/test_mini_eq_window.py

@@ -58,7 +58,9 @@ def test_begin_close_request_shutdown_restores_routing_before_delayed_quit(monke
         updating_ui=False,
         route_switch=FakeSwitch(True),
         controller=SimpleNamespace(
-            route_system_audio=lambda enabled, announce=True: calls.append(("route", enabled, announce))
+            route_system_audio=lambda enabled, announce=True, refresh_output=True: calls.append(
+                ("route", enabled, announce, refresh_output)
+            )
         ),
         update_info_label=lambda: calls.append("info"),
         update_status_summary=lambda: calls.append("summary"),
@@ -74,7 +76,7 @@ def test_begin_close_request_shutdown_restores_routing_before_delayed_quit(monke
     assert fake_window.updating_ui is False
     assert fake_window.close_finish_source_id == 321
     assert calls == [
-        ("route", False, False),
+        ("route", False, False, False),
         "info",
         "summary",
         ("visible", False),
@@ -86,3 +88,32 @@ def test_begin_close_request_shutdown_restores_routing_before_delayed_quit(monke
 
     assert fake_window.close_finish_source_id == 0
     assert application.quit_count == 1
+
+
+def test_on_route_changed_resets_switch_when_routing_fails() -> None:
+    calls: list[object] = []
+
+    def fail_route(_enabled: bool) -> None:
+        raise RuntimeError("metadata permission denied")
+
+    fake_window = SimpleNamespace(
+        updating_ui=False,
+        controller=SimpleNamespace(
+            eq_enabled=True,
+            routed=False,
+            route_system_audio=fail_route,
+        ),
+        update_eq_power_indicator=lambda: calls.append("power"),
+        update_info_label=lambda: calls.append("info"),
+        update_status_summary=lambda: calls.append("summary"),
+        update_focus_summary=lambda: calls.append("focus"),
+        set_status=lambda message: calls.append(("status", message)),
+        notify_control_state_changed=lambda: calls.append("notify"),
+    )
+    route_switch = FakeSwitch(True)
+
+    window.MiniEqWindow.on_route_changed(fake_window, route_switch, None)
+
+    assert route_switch.get_active() is False
+    assert fake_window.updating_ui is False
+    assert ("status", "metadata permission denied") in calls

{mini_eq-0.3.1 → mini_eq-0.3.2}/tests/test_mini_eq_wireplumber_backend.py

@@ -53,6 +53,32 @@ class FakeWp:
     ImplModule = FakeImplModule
 
 
+class FakeProperties:
+    def __init__(self) -> None:
+        self.values: dict[str, str] = {}
+
+    @classmethod
+    def new_empty(cls) -> FakeProperties:
+        return cls()
+
+    def set(self, key: str, value: str) -> None:
+        self.values[key] = value
+
+
+class FakeCore:
+    calls: list[tuple[object | None, object | None, FakeProperties | None]] = []
+
+    @classmethod
+    def new(cls, context, conf, properties=None):
+        cls.calls.append((context, conf, properties))
+        return object()
+
+
+class FakeCoreWp:
+    Core = FakeCore
+    Properties = FakeProperties
+
+
 class FakeNodeProxy:
     def __init__(self, bound_id: int, set_result: bool = True) -> None:
         self.bound_id = bound_id
@@ -214,6 +240,20 @@ def test_node_classification_and_display_name() -> None:
     assert stream.display_name == "spotify"
 
 
+def test_new_core_requests_pipewire_manager_access() -> None:
+    FakeCore.calls = []
+
+    wp_backend.WirePlumberBackend._new_core(FakeCoreWp)
+
+    assert len(FakeCore.calls) == 1
+    _context, _conf, properties = FakeCore.calls[0]
+    assert properties is not None
+    assert properties.values == {
+        "application.name": wp_backend.PIPEWIRE_CLIENT_NAME,
+        "media.category": wp_backend.PIPEWIRE_MEDIA_CATEGORY,
+    }
+
+
 def test_sync_core_removes_timeout_source_after_success() -> None:
     core = FakeSyncCore()
     glib = FakeSyncGLib(core)
@@ -263,6 +303,96 @@ def test_stream_targets_node_rejects_different_target_object_metadata() -> None:
     assert backend.stream_targets_node(126, "alsa_output.test") is False
 
 
+def test_move_stream_to_target_raises_when_metadata_change_is_not_acknowledged() -> None:
+    backend = wp_backend.WirePlumberBackend()
+    stream = wp_backend.WirePlumberNode(
+        bound_id=126,
+        object_serial="300",
+        media_class=wp_backend.STREAM_OUTPUT_AUDIO,
+        node_name="spotify",
+        node_description=None,
+        application_name="spotify",
+        node_dont_move=False,
+    )
+    sink = wp_backend.WirePlumberNode(
+        bound_id=39,
+        object_serial="67",
+        media_class=wp_backend.AUDIO_SINK,
+        node_name="alsa_output.test",
+        node_description="Test Sink",
+        application_name=None,
+        node_dont_move=False,
+    )
+
+    backend.output_stream_by_bound_id = lambda _bound_id: stream
+    backend.audio_sink_by_name = lambda _name: sink
+    backend.set_metadata_and_wait = lambda *_args: False
+    backend.stream_target_object = lambda _bound_id: ("64", wp_backend.SPA_ID_TYPE)
+
+    with pytest.raises(wp_backend.WirePlumberError, match="did not acknowledge"):
+        backend.move_stream_to_target(126, "alsa_output.test")
+
+
+def test_move_stream_to_target_skips_metadata_read_after_acknowledged_change() -> None:
+    backend = wp_backend.WirePlumberBackend()
+    stream = wp_backend.WirePlumberNode(
+        bound_id=126,
+        object_serial="300",
+        media_class=wp_backend.STREAM_OUTPUT_AUDIO,
+        node_name="spotify",
+        node_description=None,
+        application_name="spotify",
+        node_dont_move=False,
+    )
+    sink = wp_backend.WirePlumberNode(
+        bound_id=39,
+        object_serial="67",
+        media_class=wp_backend.AUDIO_SINK,
+        node_name="alsa_output.test",
+        node_description="Test Sink",
+        application_name=None,
+        node_dont_move=False,
+    )
+
+    backend.output_stream_by_bound_id = lambda _bound_id: stream
+    backend.audio_sink_by_name = lambda _name: sink
+    backend.set_metadata_and_wait = lambda *_args: True
+    backend.stream_target_object = lambda _bound_id: (_ for _ in ()).throw(
+        AssertionError("acknowledged moves should not need metadata readback")
+    )
+
+    backend.move_stream_to_target(126, "alsa_output.test")
+
+
+def test_move_stream_to_target_accepts_already_updated_metadata() -> None:
+    backend = wp_backend.WirePlumberBackend()
+    stream = wp_backend.WirePlumberNode(
+        bound_id=126,
+        object_serial="300",
+        media_class=wp_backend.STREAM_OUTPUT_AUDIO,
+        node_name="spotify",
+        node_description=None,
+        application_name="spotify",
+        node_dont_move=False,
+    )
+    sink = wp_backend.WirePlumberNode(
+        bound_id=39,
+        object_serial="67",
+        media_class=wp_backend.AUDIO_SINK,
+        node_name="alsa_output.test",
+        node_description="Test Sink",
+        application_name=None,
+        node_dont_move=False,
+    )
+
+    backend.output_stream_by_bound_id = lambda _bound_id: stream
+    backend.audio_sink_by_name = lambda _name: sink
+    backend.set_metadata_and_wait = lambda *_args: False
+    backend.stream_target_object = lambda _bound_id: ("67", wp_backend.SPA_ID_TYPE)
+
+    backend.move_stream_to_target(126, "alsa_output.test")
+
+
 def test_defaults_returns_cached_value_without_metadata_read(monkeypatch) -> None:
     backend = wp_backend.WirePlumberBackend()
     backend._cached_defaults = wp_backend.WirePlumberDefaults("cached.default", "cached.configured")

{mini_eq-0.3.1 → mini_eq-0.3.2}/tests/test_mini_eq_wireplumber_stream_router.py

@@ -36,6 +36,7 @@ class FakeWirePlumberBackend:
         self.closed = False
         self.disconnected_handlers: list[int] = []
         self.missing_stream_ids: set[int] = set()
+        self.move_failures: dict[int, Exception] = {}
 
     def connect(self) -> None:
         self.connected = True
@@ -49,6 +50,8 @@ class FakeWirePlumberBackend:
     def move_stream_to_target(self, stream_bound_id: int, target_node_name: str) -> None:
         if stream_bound_id in self.missing_stream_ids:
             raise wp_backend.WirePlumberError(f"output stream not found: {stream_bound_id}")
+        if stream_bound_id in self.move_failures:
+            raise self.move_failures[stream_bound_id]
 
         self.moves.append((stream_bound_id, target_node_name))
         self.target_nodes[stream_bound_id] = target_node_name
@@ -151,6 +154,49 @@ def test_wireplumber_router_drops_stream_that_disappears_during_route() -> None:
     assert router.routed_stream_ids == set()
 
 
+def test_wireplumber_router_enable_raises_and_stops_monitoring_on_initial_route_error() -> None:
+    backend = FakeWirePlumberBackend(
+        [make_node(1, wp_backend.STREAM_OUTPUT_AUDIO, "spotify", "Spotify")],
+    )
+    statuses: list[str] = []
+    router = wp_router.WirePlumberStreamRouter("mini_eq_sink", "mini_eq_sink_output", statuses.append, backend)
+
+    def fail_move(_stream_bound_id: int, _target_node_name: str) -> None:
+        raise RuntimeError("metadata permission denied")
+
+    backend.move_stream_to_target = fail_move
+
+    with pytest.raises(RuntimeError, match="metadata permission denied"):
+        router.enable()
+
+    assert router.enabled is False
+    assert router.accept_stream_events is False
+    assert backend.disconnected_handlers == [42]
+    assert statuses == ["routing warning: metadata permission denied"]
+
+
+def test_wireplumber_router_enable_restores_partial_initial_route_failure() -> None:
+    backend = FakeWirePlumberBackend(
+        [
+            make_node(1, wp_backend.STREAM_OUTPUT_AUDIO, "spotify", "Spotify"),
+            make_node(2, wp_backend.STREAM_OUTPUT_AUDIO, "browser", "Browser"),
+        ]
+    )
+    backend.move_failures = {2: RuntimeError("metadata permission denied")}
+    statuses: list[str] = []
+    router = wp_router.WirePlumberStreamRouter("mini_eq_sink", "mini_eq_sink_output", statuses.append, backend)
+    router.set_output_sink_name("speakers")
+
+    with pytest.raises(RuntimeError, match="metadata permission denied"):
+        router.enable()
+
+    assert router.enabled is False
+    assert router.routed_stream_ids == set()
+    assert backend.moves == [(1, "mini_eq_sink"), (1, "speakers")]
+    assert backend.target_nodes[1] == "speakers"
+    assert statuses == ["routing warning: metadata permission denied"]
+
+
 def test_wireplumber_router_always_writes_restore_move_for_tracked_streams() -> None:
     backend = FakeWirePlumberBackend(
         [make_node(1, wp_backend.STREAM_OUTPUT_AUDIO, "spotify", "Spotify")],

mini_eq-0.3.2/tools/check_flatpak_runtime.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import subprocess
+import sys
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+APP_ID = "io.github.bhack.mini-eq"
+DEFAULT_APP_REF = f"{APP_ID}//master"
+SMOKE_APPLICATION_NAME = "mini-eq-flatpak-smoke"
+VIRTUAL_SINK_NAME = "mini_eq_sink"
+PIPEWIRE_MANAGER_ACCESS = "flatpak-manager"
+TARGET_OBJECT_RE = re.compile(
+    r"update: id:(?P<id>\d+) key:'target\.object' value:'(?P<value>[^']*)' type:'(?P<type>[^']*)'"
+)
+
+
+def format_command(command: list[str | Path]) -> str:
+    return " ".join(str(part) for part in command)
+
+
+def run(command: list[str | Path], *, check: bool = True) -> subprocess.CompletedProcess[str]:
+    print(f"$ {format_command(command)}", flush=True)
+    return subprocess.run(
+        [str(part) for part in command],
+        check=check,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+
+
+def require_tools(*tools: str) -> None:
+    missing = [tool for tool in tools if shutil.which(tool) is None]
+    if missing:
+        raise RuntimeError(f"Missing required tool(s): {', '.join(missing)}")
+
+
+def read_pw_dump() -> list[dict[str, Any]]:
+    result = subprocess.run(["pw-dump"], check=True, text=True, stdout=subprocess.PIPE)
+    payload = json.loads(result.stdout)
+    if not isinstance(payload, list):
+        raise RuntimeError("pw-dump returned an unexpected JSON shape")
+    return payload
+
+
+def item_props(item: dict[str, Any]) -> dict[str, Any]:
+    props = item.get("info", {}).get("props", {})
+    return props if isinstance(props, dict) else {}
+
+
+def node_items() -> list[dict[str, Any]]:
+    return [item for item in read_pw_dump() if item.get("type") == "PipeWire:Interface:Node"]
+
+
+def client_items() -> list[dict[str, Any]]:
+    return [item for item in read_pw_dump() if item.get("type") == "PipeWire:Interface:Client"]
+
+
+def node_by_name(node_name: str) -> dict[str, Any] | None:
+    for node in node_items():
+        if item_props(node).get("node.name") == node_name:
+            return node
+    return None
+
+
+def smoke_stream_node() -> dict[str, Any] | None:
+    for node in node_items():
+        props = item_props(node)
+        if (
+            props.get("media.class") == "Stream/Output/Audio"
+            and props.get("application.name") == SMOKE_APPLICATION_NAME
+        ):
+            return node
+    return None
+
+
+def object_serial(node: dict[str, Any]) -> str:
+    serial = item_props(node).get("object.serial")
+    if serial is None:
+        raise RuntimeError(f"PipeWire node has no object.serial: {item_props(node).get('node.name')}")
+    return str(serial)
+
+
+def bound_id(node: dict[str, Any]) -> int:
+    node_id = node.get("id")
+    if not isinstance(node_id, int):
+        raise RuntimeError(f"PipeWire node has no integer id: {item_props(node).get('node.name')}")
+    return node_id
+
+
+def metadata_targets() -> dict[int, tuple[str, str]]:
+    result = subprocess.run(["pw-metadata", "-n", "default"], check=True, text=True, stdout=subprocess.PIPE)
+    targets: dict[int, tuple[str, str]] = {}
+
+    for line in result.stdout.splitlines():
+        match = TARGET_OBJECT_RE.search(line)
+        if match is not None:
+            targets[int(match.group("id"))] = (match.group("value"), match.group("type"))
+
+    return targets
+
+
+def wait_for(label: str, predicate: Callable[[], Any], timeout_seconds: float) -> Any:
+    deadline = time.monotonic() + timeout_seconds
+    last_error: Exception | None = None
+
+    while time.monotonic() < deadline:
+        try:
+            value = predicate()
+        except Exception as exc:
+            last_error = exc
+        else:
+            if value:
+                return value
+
+        time.sleep(0.1)
+
+    detail = f": {last_error}" if last_error is not None else ""
+    raise RuntimeError(f"Timed out waiting for {label}{detail}")
+
+
+def mini_eq_has_manager_access() -> bool:
+    for client in client_items():
+        props = item_props(client)
+        if (
+            props.get("application.name") == "Mini EQ"
+            and props.get("media.category") == "Manager"
+            and props.get("pipewire.access.effective") == PIPEWIRE_MANAGER_ACCESS
+        ):
+            return True
+    return False
+
+
+def start_smoke_stream() -> subprocess.Popen[str]:
+    command = [
+        "pw-cat",
+        "--playback",
+        "--raw",
+        "--rate",
+        "48000",
+        "--channels",
+        "2",
+        "--format",
+        "s16",
+        "--volume",
+        "0",
+        "--properties",
+        f"application.name={SMOKE_APPLICATION_NAME}",
+        "/dev/zero",
+    ]
+    print(f"$ {format_command(command)}", flush=True)
+    return subprocess.Popen(command, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+
+def stop_process(process: subprocess.Popen[str], label: str, timeout_seconds: float = 5.0) -> str:
+    if process.poll() is not None:
+        return process.stdout.read() if process.stdout is not None else ""
+
+    process.terminate()
+    try:
+        output, _stderr = process.communicate(timeout=timeout_seconds)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        output, _stderr = process.communicate(timeout=timeout_seconds)
+
+    if output:
+        print(f"{label} output:\n{output.rstrip()}", flush=True)
+    return output or ""
+
+
+def assert_no_existing_virtual_sink() -> None:
+    if node_by_name(VIRTUAL_SINK_NAME) is not None:
+        raise RuntimeError(
+            f"{VIRTUAL_SINK_NAME} already exists. Close Mini EQ and remove stale filter-chain state before rerunning."
+        )
+
+
+def run_runtime_smoke(app_ref: str, duration_seconds: float, timeout_seconds: float) -> None:
+    assert_no_existing_virtual_sink()
+
+    deps = run(["flatpak", "run", app_ref, "--check-deps"])
+    print(deps.stdout.rstrip(), flush=True)
+
+    smoke = start_smoke_stream()
+    app: subprocess.Popen[str] | None = None
+
+    try:
+        smoke_node = wait_for("silent PipeWire smoke stream", smoke_stream_node, timeout_seconds)
+        smoke_id = bound_id(smoke_node)
+        original_target = metadata_targets().get(smoke_id)
+
+        command = [
+            "flatpak",
+            "run",
+            app_ref,
+            "--headless",
+            "--auto-route",
+            "--duration",
+            str(duration_seconds),
+        ]
+        print(f"$ {format_command(command)}", flush=True)
+        app = subprocess.Popen(command, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+        wait_for("Mini EQ PipeWire manager access", mini_eq_has_manager_access, timeout_seconds)
+        virtual_sink = wait_for(
+            f"{VIRTUAL_SINK_NAME} PipeWire node", lambda: node_by_name(VIRTUAL_SINK_NAME), timeout_seconds
+        )
+        virtual_serial = object_serial(virtual_sink)
+
+        def smoke_stream_targets_virtual_sink() -> bool:
+            target = metadata_targets().get(smoke_id)
+            return target == (virtual_serial, "Spa:Id")
+
+        wait_for("smoke stream routed through Mini EQ", smoke_stream_targets_virtual_sink, timeout_seconds)
+
+        output, _stderr = app.communicate(timeout=max(duration_seconds + timeout_seconds, timeout_seconds))
+        print(output.rstrip(), flush=True)
+        if app.returncode != 0:
+            raise RuntimeError(f"Mini EQ Flatpak exited with status {app.returncode}")
+
+        def smoke_stream_restored() -> bool:
+            restored_target = metadata_targets().get(smoke_id)
+            if original_target is not None:
+                return restored_target == original_target
+            return restored_target != (virtual_serial, "Spa:Id")
+
+        wait_for("smoke stream restored after Mini EQ exits", smoke_stream_restored, timeout_seconds)
+
+        if original_target is not None:
+            restored_target = metadata_targets().get(smoke_id)
+            print(f"Smoke stream restored to {restored_target}.", flush=True)
+
+        print("Flatpak runtime smoke passed: manager access, stream routing, and restore behavior verified.")
+    finally:
+        if app is not None and app.poll() is None:
+            stop_process(app, "Mini EQ Flatpak")
+        stop_process(smoke, "pw-cat smoke stream")
+
+
+def parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Smoke-test Mini EQ Flatpak runtime routing against the live PipeWire session.",
+    )
+    parser.add_argument(
+        "--app-ref",
+        default=DEFAULT_APP_REF,
+        help=f"Flatpak app ref to test (default: {DEFAULT_APP_REF})",
+    )
+    parser.add_argument(
+        "--duration",
+        type=float,
+        default=8.0,
+        help="How long to keep the headless Mini EQ app running during the routing check.",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=8.0,
+        help="Timeout in seconds for each PipeWire state transition.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(sys.argv[1:] if argv is None else argv)
+
+    try:
+        require_tools("flatpak", "pw-cat", "pw-dump", "pw-metadata")
+        run_runtime_smoke(args.app_ref, args.duration, args.timeout)
+    except subprocess.CalledProcessError as exc:
+        if exc.stdout:
+            sys.stderr.write(exc.stdout)
+        return exc.returncode
+    except Exception as exc:
+        print(exc, file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{mini_eq-0.3.1 → mini_eq-0.3.2}/tools/check_wireplumber_gi.py

@@ -11,6 +11,7 @@ REQUIRED_WP_SYMBOLS = (
     "Core.new",
     "ObjectManager.new",
     "ObjectInterest.new_type",
+    "Properties.new_empty",
     "Node",
     "Metadata",
     "ProxyFeatures.PIPEWIRE_OBJECT_FEATURE_INFO",