test(e2e): increase rpc test_available_widgets timout back to 100

Automatically generated by python-semantic-release

CHANGELOG.md

@@ -1,6 +1,126 @@
 # CHANGELOG
 
 
+## v3.13.5 (2026-06-02)
+
+### Bug Fixes
+
+- Change prints into proper logs
+  ([`c8275fc`](https://github.com/bec-project/bec_widgets/commit/c8275fcfd5c920393df3aa201c32a632ac8086a5))
+
+- **abort_button**: From __future__ import annotations
+  ([`3796984`](https://github.com/bec-project/bec_widgets/commit/37969841822c8c38c23a1d8fca8e38aec684957b))
+
+- **client_utils**: Increase default rpc timeout to 60s
+  ([`07515d2`](https://github.com/bec-project/bec_widgets/commit/07515d24be6e930b1b40170fc710255914cb7454))
+
+- **client_utils**: Stop output reader thread on shutdown
+  ([`4572760`](https://github.com/bec-project/bec_widgets/commit/4572760b56ca2ab6435db3a6a4ba0d270e9008d1))
+
+- **companion_app**: Disable logging of bec_lib.scan_items on widget side
+  ([`bd66afb`](https://github.com/bec-project/bec_widgets/commit/bd66afb98dcb76ca87b0db1334df3c1af0a9dbad))
+
+- **forms**: Gridlayout applied to widget which already has layout
+  ([`1427c70`](https://github.com/bec-project/bec_widgets/commit/1427c70cfb6f84bbced7f72ec5cfa55ac0b9b742))
+
+- **launch_window**: Exclude launcher check for non-parented widgets for BECMainWindow
+  ([`ed68eb5`](https://github.com/bec-project/bec_widgets/commit/ed68eb5ac6b20cfc7ca2c0b91864dc54fb579499))
+
+- **launcher**: Avoid orphan widgets detection and logging
+  ([`9f94ca7`](https://github.com/bec-project/bec_widgets/commit/9f94ca7748d73a30622ecbaef384f4bc73a3d2fb))
+
+- **logging**: Removed args/kwargs from logging messages
+  ([`2fb7fb2`](https://github.com/bec-project/bec_widgets/commit/2fb7fb2ff487863c3bc931498496da74b25e52d8))
+
+- **rpc**: Additional logs
+  ([`e41e609`](https://github.com/bec-project/bec_widgets/commit/e41e60956b54890b70b3390b981196c9477abd93))
+
+- **rpc**: Client/server rpc handshake for shutdown
+  ([`8a180ea`](https://github.com/bec-project/bec_widgets/commit/8a180eaa7be5c1603d893cf3b50585f88f9b0c83))
+
+- **rpc**: Log dispatcher receipt before qt callback
+  ([`878745b`](https://github.com/bec-project/bec_widgets/commit/878745b99ac1e22c0fbddecc294e599469a2adfe))
+
+- **rpc**: More robust shutdown section with PID logging
+  ([`e42a982`](https://github.com/bec-project/bec_widgets/commit/e42a9824ccd54b71a3141aaf2aa4e02af6a13782))
+
+- **rpc_server**: Log warning if rpc call is repeated
+  ([`859563a`](https://github.com/bec-project/bec_widgets/commit/859563abb3e94ff55886e72db3177522900a89b8))
+
+### Refactoring
+
+- **client_utils**: Simplify PID fetching
+  ([`154ae60`](https://github.com/bec-project/bec_widgets/commit/154ae6026a6471b7c1db42f7c2ff3dc7be4b4afb))
+
+- **rpc**: Share logging helpers
+  ([`8e1e282`](https://github.com/bec-project/bec_widgets/commit/8e1e282fac22ab6f726049758306c7ca17af70eb))
+
+
+## v3.13.4 (2026-05-29)
+
+### Bug Fixes
+
+- **positioner_box**: Fix STOP button
+  ([`9a58dba`](https://github.com/bec-project/bec_widgets/commit/9a58dba414d9eec32fd7de7fc64c97c38f020b84))
+
+
+## v3.13.3 (2026-05-22)
+
+### Bug Fixes
+
+- **tests**: Rename description attribute to _description in FakeDevice
+  ([`668b1bd`](https://github.com/bec-project/bec_widgets/commit/668b1bd9cd158fc12cff2c340d7317f30a212121))
+
+
+## v3.13.2 (2026-05-22)
+
+### Bug Fixes
+
+- **tests**: Rename description attribute to _description in FakePositioner
+  ([`c346bd0`](https://github.com/bec-project/bec_widgets/commit/c346bd0f18ce873ff5ca6c59150c9581c9edca8d))
+
+
+## v3.13.1 (2026-05-21)
+
+### Bug Fixes
+
+- Use .show instead of .start
+  ([`b4beb27`](https://github.com/bec-project/bec_widgets/commit/b4beb274da745da618f9b37ec241cd0109c088f1))
+
+- **gui**: Replace window.show() with window.raise_window() and add hide() method
+  ([`f7a48b5`](https://github.com/bec-project/bec_widgets/commit/f7a48b5f6a51d391dca26ca42d03bad4f278ff22))
+
+
+## v3.13.0 (2026-05-21)
+
+### Features
+
+- **rpc-base**: Set default RPC timeout and allow customization
+  ([`f03a5d9`](https://github.com/bec-project/bec_widgets/commit/f03a5d9e853bd62b8ec1bad1c1e112fe01befe70))
+
+
+## v3.12.2 (2026-05-21)
+
+### Bug Fixes
+
+- **toggle**: Disable styling implemented
+  ([`9eb0541`](https://github.com/bec-project/bec_widgets/commit/9eb05416ab68dcb88732dca8974c665030d34e0b))
+
+
+## v3.12.1 (2026-05-21)
+
+### Bug Fixes
+
+- **device_input**: Correct cleanup unsubscribe
+  ([`56427a7`](https://github.com/bec-project/bec_widgets/commit/56427a7f0c3a89fe847d415c8b45212e663434c4))
+
+- **device_input**: Ensure callback is removed after cleanup
+  ([`d99db7d`](https://github.com/bec-project/bec_widgets/commit/d99db7d04208945b86a39d65022b211ba093caed))
+
+- **signal_combobox**: Signature matched for update_signals_from_filters
+  ([`a976837`](https://github.com/bec-project/bec_widgets/commit/a976837cff612349f2a3f17900903c203bc3d250))
+
+
 ## v3.12.0 (2026-05-20)
 
 ### Bug Fixes

bec_widgets/applications/companion_app.py

@@ -5,6 +5,7 @@ import json
 import os
 import signal
 import sys
+import traceback
 from contextlib import redirect_stderr, redirect_stdout
 
 import darkdetect
@@ -63,6 +64,7 @@ class GUIServer:
         self.app: QApplication | None = None
         self.launcher_window: LaunchWindow | None = None
         self.dispatcher: BECDispatcher | None = None
+        self._shutdown_started = False
 
     def start(self):
         """
@@ -74,6 +76,7 @@ class GUIServer:
             bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
             bec_logger._update_sinks()
 
+        bec_logger.disabled_modules = ["bec_lib.scan_items"]
         with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):  # type: ignore
             with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):  # type: ignore
                 self._run()
@@ -122,17 +125,8 @@ class GUIServer:
         self.app.aboutToQuit.connect(self.shutdown)
         self.app.setQuitOnLastWindowClosed(True)
 
-        def sigint_handler(*args):
-            # display message, for people to let it terminate gracefully
-            print("Caught SIGINT, exiting")
-            # Widgets should be all closed.
-            with RPCRegister.delayed_broadcast():
-                for widget in QApplication.instance().topLevelWidgets():  # type: ignore
-                    widget.close()
-            self.shutdown()
-
-        signal.signal(signal.SIGINT, sigint_handler)
-        signal.signal(signal.SIGTERM, sigint_handler)
+        signal.signal(signal.SIGINT, self.request_shutdown)
+        signal.signal(signal.SIGTERM, self.request_shutdown)
 
         sys.exit(self.app.exec())
 
@@ -149,16 +143,67 @@ class GUIServer:
         )
         self.app.setWindowIcon(icon)
 
+    def request_shutdown(self, signum=None, _frame=None):
+        """
+        Request Qt application shutdown from an RPC call or OS signal.
+
+        Cleanup itself is handled by ``shutdown()``, which is connected to
+        ``QApplication.aboutToQuit``. Calling it directly here would run BEC/RPC
+        teardown before Qt has processed the widget close events.
+        """
+        signal_name = signal.Signals(signum).name if signum is not None else "shutdown"
+        pid = os.getpid()
+        if self.app is None:
+            logger.info(f"Caught {signal_name}, shutting down GUI server pid={pid} without app")
+            self.shutdown()
+            return
+
+        widgets = [
+            f"{widget.__class__.__name__}(objectName={widget.objectName()!r})"
+            for widget in self.app.topLevelWidgets()
+        ]
+        logger.info(
+            f"Caught {signal_name}, requesting GUI server shutdown pid={pid} "
+            f"top_level_widgets={widgets}"
+        )
+        with RPCRegister.delayed_broadcast():
+            for widget in self.app.topLevelWidgets():
+                widget.close()
+        self.app.quit()
+
+    @staticmethod
+    def _run_shutdown_step(step: str, callback):
+        try:
+            callback()
+        except Exception as exc:
+            logger.error(
+                f"GUIServer shutdown step failed pid={os.getpid()} step={step}: {exc}\n"
+                f"{traceback.format_exc()}"
+            )
+
     def shutdown(self):
-        logger.info("Shutdown GUIServer", repr(self))
-        if self.launcher_window and shiboken6.isValid(self.launcher_window):
-            self.launcher_window.close()
-            self.launcher_window.deleteLater()
-        if pylsp_server.is_running():
-            pylsp_server.stop()
-        if self.dispatcher:
-            self.dispatcher.stop_cli_server()
-            self.dispatcher.disconnect_all()
+        if self._shutdown_started:
+            return
+        self._shutdown_started = True
+        logger.info(f"Shutdown GUIServer pid={os.getpid()} {repr(self)}")
+
+        def close_launcher_window():
+            if self.launcher_window and shiboken6.isValid(self.launcher_window):
+                self.launcher_window.close()
+                self.launcher_window.deleteLater()
+
+        def stop_pylsp_server():
+            if pylsp_server.is_running():
+                pylsp_server.stop()
+
+        def stop_dispatcher():
+            if self.dispatcher:
+                self.dispatcher.stop_cli_server()
+                self.dispatcher.disconnect_all()
+
+        self._run_shutdown_step("close_launcher_window", close_launcher_window)
+        self._run_shutdown_step("stop_pylsp_server", stop_pylsp_server)
+        self._run_shutdown_step("stop_dispatcher", stop_dispatcher)
 
 
 def main():

bec_widgets/applications/launch_window.py

@@ -207,6 +207,7 @@ class LaunchWindow(BECMainWindow):
 
         self.app = QApplication.instance()
         self.tiles: dict[str, LaunchTile] = {}
+        self._logged_unparented_connections: set[str] = set()
         # Track the smallest main‑label font size chosen so far
         self._min_main_label_pt: int | None = None
 
@@ -655,53 +656,83 @@ class LaunchWindow(BECMainWindow):
         super().showEvent(event)
         self.setFixedSize(self.size())
 
-    def _launcher_is_last_widget(self, connections: dict) -> bool:
+    def _has_external_window(self, connections: dict) -> bool:
         """
-        Check if the launcher is the last widget in the application.
+        Check if any registered non-launcher connection owns a top-level Qt window.
         """
-
-        # get all parents of connections
         for connection in connections.values():
-            try:
-                parent = connection.parent()
-                if parent is None and connection.objectName() != self.objectName():
-                    # logger.info(
-                    #     f"Found non-launcher connection without parent: {connection.objectName()}"
-                    # ) #TODO disabled due to high count
-                    return False
-            except Exception as e:
-                logger.error(f"Error getting parent of connection: {e}")
-                return False
-        return True
+            if self._connection_belongs_to_launcher(connection):
+                continue
+            if isinstance(connection, QWidget) and connection.isWindow():
+                return True
+        return False
+
+    def _log_unparented_connections(self, connections: dict) -> None:
+        """
+        Log non-launcher RPC connections that remain without an active top-level window.
+        """
+        for connection in connections.values():
+            if self._connection_belongs_to_launcher(connection):
+                continue
+            if isinstance(connection, QWidget) and connection.isWindow():
+                continue
+
+            connection_description = (
+                f"type={type(connection).__name__} objectName={connection.objectName()!r} "
+                f"gui_id={connection.gui_id!r}"
+            )
+            if connection_description in self._logged_unparented_connections:
+                continue
+            self._logged_unparented_connections.add(connection_description)
+            logger.warning(
+                "Registered non-launcher RPC connection has no active top-level window: "
+                f"{connection_description}"
+            )
+
+    def _connection_belongs_to_launcher(self, connection: QObject) -> bool:
+        """
+        Check whether a registered connection is the launcher itself or part of its Qt hierarchy.
+        """
+        if connection is self or connection.gui_id == self.gui_id:
+            return True
+
+        parent = connection.parent()
+        while parent is not None:
+            if parent is self:
+                return True
+            parent = parent.parent()
+
+        return False
 
     def _turn_off_the_lights(self, connections: dict):
         """
         If there is only one connection remaining, it is the launcher, so we show it.
         Once the launcher is closed as the last window, we quit the application.
         """
-        if self._launcher_is_last_widget(connections):
-            self.show()
-            self.activateWindow()
-            self.raise_()
+        if self._has_external_window(connections):
+            self.hide()
             if self.app:
-                self.app.setQuitOnLastWindowClosed(True)  # type: ignore
+                self.app.setQuitOnLastWindowClosed(False)  # type: ignore
             return
 
-        self.hide()
+        self._log_unparented_connections(connections)
+        self.show()
+        self.activateWindow()
+        self.raise_()
         if self.app:
-            self.app.setQuitOnLastWindowClosed(False)  # type: ignore
+            self.app.setQuitOnLastWindowClosed(True)  # type: ignore
 
     def closeEvent(self, event):
         """
         Close the launcher window.
         """
         connections = self.register.list_all_connections()
-        if self._launcher_is_last_widget(connections):
-            event.accept()
+        if self._has_external_window(connections):
+            event.ignore()
+            self.hide()
             return
 
-        event.ignore()
-        self.hide()
+        event.accept()
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/cli/client_utils.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import select
+import signal
 import subprocess
 import threading
 import time
@@ -33,6 +34,12 @@ else:
 logger = bec_logger.logger
 
 IGNORE_WIDGETS = ["LaunchWindow"]
+PROCESS_TERMINATION_TIMEOUT = 10
+PROCESS_OUTPUT_THREAD_JOIN_TIMEOUT = 2
+PROCESS_OUTPUT_SELECT_TIMEOUT = 0.2
+GRACEFUL_SERVER_SHUTDOWN_RPC_TIMEOUT = 3
+GRACEFUL_SERVER_SHUTDOWN_TIMEOUT = 5
+OUTPUT_READER_STOP_EVENT_ATTR = "_bec_output_reader_stop_event"
 
 RegistryState: TypeAlias = dict[
     Literal["gui_id", "name", "widget_class", "config", "__rpc__", "container_proxy"],
@@ -53,14 +60,16 @@ def _filter_output(output: str) -> str:
     return output
 
 
-def _get_output(process, logger) -> None:
+def _get_output(process, logger, stop_event: threading.Event | None = None) -> None:
     log_func = {process.stdout: logger.debug, process.stderr: logger.info}
     stream_buffer = {process.stdout: [], process.stderr: []}
     try:
         os.set_blocking(process.stdout.fileno(), False)
         os.set_blocking(process.stderr.fileno(), False)
-        while process.poll() is None:
-            readylist, _, _ = select.select([process.stdout, process.stderr], [], [], 1)
+        while process.poll() is None and not (stop_event and stop_event.is_set()):
+            readylist, _, _ = select.select(
+                [process.stdout, process.stderr], [], [], PROCESS_OUTPUT_SELECT_TIMEOUT
+            )
             for stream in (process.stdout, process.stderr):
                 buf = stream_buffer[stream]
                 if stream in readylist:
@@ -75,6 +84,95 @@ def _get_output(process, logger) -> None:
         logger.error(f"Error reading process output: {str(e)}")
 
 
+def _process_group_snapshot(process) -> str:
+    try:
+        pgid = os.getpgid(process.pid)
+    except ProcessLookupError:
+        return "Process group snapshot unavailable: process already exited"
+    try:
+        result = subprocess.run(
+            ["ps", "-o", "pid,ppid,pgid,stat,command", "-g", str(pgid)],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+    except Exception as exc:
+        return f"Process group snapshot unavailable: {exc}"
+    output = result.stdout.strip()
+    if not output:
+        return f"Process group snapshot empty for pgid={pgid}"
+    return output
+
+
+def _terminate_plot_process(process, logger, timeout: float = PROCESS_TERMINATION_TIMEOUT) -> None:
+    if process.poll() is not None:
+        return
+
+    process_info = f"pid={process.pid} command={process.args}"
+    try:
+        pgid = os.getpgid(process.pid)
+        process_info = f"pid={process.pid} pgid={pgid} command={process.args}"
+        logger.info(f"Terminating GUI process group {process_info}")
+        os.killpg(pgid, signal.SIGTERM)
+    except ProcessLookupError:
+        process.wait(timeout=timeout)
+        return
+    except Exception as exc:
+        logger.warning("Failed to terminate GUI process group; terminating process only.")
+        logger.info(f"GUI process termination failure details: {exc}. pid={process.pid}")
+        process.terminate()
+
+    try:
+        process.wait(timeout=timeout)
+        return
+    except subprocess.TimeoutExpired:
+        logger.warning(f"GUI process did not stop within {timeout}s; killing it.")
+        logger.info(
+            f"GUI process force-kill details: {process_info}\n"
+            f"{_process_group_snapshot(process)}"
+        )
+
+    try:
+        os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+    except ProcessLookupError as e:
+        logger.error(f"Failed to kill GUI process group: {e}")
+        process.wait(timeout=timeout)
+        return
+    process.wait(timeout=timeout)
+
+
+def _wait_for_process_exit(process, timeout: float) -> bool:
+    try:
+        process.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        return False
+    return True
+
+
+def _join_process_output_thread(process, thread: threading.Thread | None, logger) -> None:
+    if thread is None:
+        return
+    thread.join(timeout=PROCESS_OUTPUT_THREAD_JOIN_TIMEOUT)
+    if not thread.is_alive():
+        return
+
+    if stop_event := getattr(thread, OUTPUT_READER_STOP_EVENT_ATTR, None):
+        stop_event.set()
+
+    for stream in (process.stdout, process.stderr):
+        if stream is None:
+            continue
+        try:
+            stream.close()
+        except OSError as e:
+            logger.error(f"Failed to close stream {str(e)}")
+    thread.join(timeout=PROCESS_OUTPUT_THREAD_JOIN_TIMEOUT)
+    if thread.is_alive():
+        logger.warning("GUI process output reader thread did not stop after process shutdown.")
+        logger.info(f"GUI process output reader thread details: pid={process.pid}")
+
+
 def _start_plot_process(
     gui_id: str,
     gui_class_id: str,
@@ -126,8 +224,14 @@ def _start_plot_process(
     if logger is None:
         process_output_processing_thread = None
     else:
+        process_output_stop_event = threading.Event()
         process_output_processing_thread = threading.Thread(
-            target=_get_output, args=(process, logger)
+            target=_get_output, args=(process, logger, process_output_stop_event)
+        )
+        setattr(
+            process_output_processing_thread,
+            OUTPUT_READER_STOP_EVENT_ATTR,
+            process_output_stop_event,
         )
         process_output_processing_thread.start()
     return process, process_output_processing_thread
@@ -222,6 +326,7 @@ class BECGuiClient(RPCBase):
         self._ipython_registry: dict[str, RPCReference] = {}
         self.available_widgets = AvailableWidgetsNamespace()
         register_serializer_extension()
+        self._rpc_timeout = 60
 
     ####################
     #### Client API ####
@@ -232,6 +337,16 @@ class BECGuiClient(RPCBase):
         """The launcher object."""
         return RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self, object_name="launcher")
 
+    def set_rpc_timeout(self, timeout: float):
+        """Set the timeout for RPC calls to the GUI server.
+
+        Args:
+            timeout(float): The timeout in seconds.
+        """
+        if not isinstance(timeout, (int, float)) or timeout < 0:
+            raise ValueError("Timeout must be a non-negative number.")
+        self._rpc_timeout = timeout
+
     def _safe_register_stream(self, endpoint: EndpointInfo, cb: Callable, **kwargs):
         """Check if already registered for registration in idempotent functions."""
         if not self._client.connector.any_stream_is_registered(endpoint, cb=cb):
@@ -358,7 +473,7 @@ class BECGuiClient(RPCBase):
             )
 
         if not self._check_if_server_is_alive():
-            self.start(wait=True)
+            self.show(wait=True)
         if wait:
             with wait_for_server(self):
                 return self._new_impl(
@@ -454,11 +569,13 @@ class BECGuiClient(RPCBase):
 
         if self._process:
             logger.success("Stopping GUI...")
-            self._process.terminate()
-            if self._process_output_processing_thread:
-                self._process_output_processing_thread.join()
-            self._process.wait()
+            if not self._request_server_shutdown():
+                _terminate_plot_process(self._process, logger)
+            _join_process_output_thread(
+                self._process, self._process_output_processing_thread, logger
+            )
             self._process = None
+            self._process_output_processing_thread = None
 
         # Unregister the registry state
         self._client.connector.unregister(
@@ -477,6 +594,37 @@ class BECGuiClient(RPCBase):
     #### Private methods ####
     #########################
 
+    def _request_server_shutdown(self) -> bool:
+        if self._process is None or self._process.poll() is not None:
+            return True
+        process_details = f"pid={self._process.pid} command={self._process.args}"
+        logger.info(f"Requesting graceful GUI shutdown {process_details}")
+        try:
+            self.launcher._run_rpc(  # pylint: disable=protected-access
+                "system.shutdown",
+                wait_for_rpc_response=True,
+                timeout=GRACEFUL_SERVER_SHUTDOWN_RPC_TIMEOUT,
+            )
+        except Exception as exc:
+            logger.warning(
+                "Could not confirm graceful GUI shutdown via RPC; "
+                "falling back to process termination."
+            )
+            logger.info(f"Graceful GUI shutdown RPC failure details: {exc}. {process_details}")
+            return False
+        if _wait_for_process_exit(self._process, GRACEFUL_SERVER_SHUTDOWN_TIMEOUT):
+            logger.info(f"GUI server exited after graceful shutdown {process_details}")
+            return True
+        logger.warning(
+            "GUI server did not exit after graceful shutdown request; "
+            "falling back to process termination."
+        )
+        logger.info(
+            f"Graceful GUI shutdown timeout details: {process_details}\n"
+            f"{_process_group_snapshot(self._process)}"
+        )
+        return False
+
     def _check_if_server_is_alive(self):
         """Checks if the process is alive"""
         if self._process is None:
@@ -550,7 +698,7 @@ class BECGuiClient(RPCBase):
         if self.launcher and len(self._top_level) == 0:
             self.launcher._run_rpc("show")  # pylint: disable=protected-access
         for window in self._top_level.values():
-            window.show()
+            window.raise_window()
 
     def _show_all(self):
         with wait_for_server(self):
@@ -569,7 +717,7 @@ class BECGuiClient(RPCBase):
         if self.launcher and len(self._top_level) == 0:
             self.launcher._run_rpc("raise")  # pylint: disable=protected-access
         for window in self._top_level.values():
-            window._run_rpc("raise")  # type: ignore[attr-defined]
+            window.raise_window()
 
     def _raise_all(self):
         with wait_for_server(self):

bec_widgets/cli/rpc/rpc_base.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import inspect
 import threading
+import time
 import uuid
 from functools import wraps
 from typing import TYPE_CHECKING, Any, cast
@@ -9,6 +10,7 @@ from typing import TYPE_CHECKING, Any, cast
 from bec_lib.client import BECClient
 from bec_lib.device import DeviceBaseWithConfig
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import, lazy_import_from
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -24,6 +26,9 @@ else:
 
 # pylint: disable=protected-access
 
+_DEFAULT_RPC_TIMEOUT = object()
+logger = bec_logger.logger
+
 
 def _name_arg(arg):
     if isinstance(arg, DeviceBaseWithConfig):
@@ -154,6 +159,7 @@ class RPCReference:
 
 
 class RPCBase:
+
     def __init__(
         self,
         gui_id: str | None = None,
@@ -207,12 +213,16 @@ class RPCBase:
         # Use explicit call to ensure action name is 'raise' (not 'raise_')
         return self._run_rpc("raise")
 
+    def hide(self):
+        """Hide this widget (or its container)."""
+        return self._run_rpc("hide")
+
     def _run_rpc(
         self,
         method,
         *args,
-        wait_for_rpc_response=True,
-        timeout=5,
+        wait_for_rpc_response: bool = True,
+        timeout: float | None | object = _DEFAULT_RPC_TIMEOUT,
         gui_id: str | None = None,
         **kwargs,
     ) -> Any:
@@ -223,13 +233,16 @@ class RPCBase:
             method: The method to call.
             args: The arguments to pass to the method.
             wait_for_rpc_response: Whether to wait for the RPC response.
-            timeout: The timeout for the RPC response.
+            timeout: The timeout for the RPC response. If omitted, the client's default RPC
+                timeout is used. If explicitly set to None, wait indefinitely.
             gui_id: The GUI ID to use for the RPC call. If None, the default GUI ID is used.
             kwargs: The keyword arguments to pass to the method.
 
         Returns:
             The result of the RPC call.
         """
+        if timeout is _DEFAULT_RPC_TIMEOUT:
+            timeout = self._root._rpc_timeout
         if method in ["show", "hide", "raise"] and gui_id is None:
             obj = self._root._server_registry.get(self._gui_id)
             if obj is None:
@@ -251,12 +264,39 @@ class RPCBase:
                 MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
             )
 
+        target_gui_id = gui_id or self._gui_id
+        sent_at = time.time()
+        deadline = sent_at + timeout if timeout is not None else None
+        rpc_msg.metadata.update(
+            {
+                "method": method,
+                "receiver": receiver,
+                "target_gui_id": target_gui_id,
+                "object_name": self.object_name,
+                "wait_for_response": wait_for_rpc_response,
+                "timeout": timeout,
+                "sent_at": sent_at,
+                "deadline": deadline,
+            }
+        )
+        logger.info(
+            "Sending GUI RPC request "
+            f"request_id={request_id} method={method} receiver={receiver} "
+            f"target_gui_id={target_gui_id} object_name={self.object_name} "
+            f"wait_for_response={wait_for_rpc_response} timeout={timeout}"
+        )
         self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
 
         if wait_for_rpc_response:
             try:
                 finished = self._msg_wait_event.wait(timeout)
                 if not finished:
+                    logger.error(
+                        "GUI RPC response timeout "
+                        f"request_id={request_id} method={method} receiver={receiver} "
+                        f"target_gui_id={target_gui_id} object_name={self.object_name} "
+                        f"timeout={timeout}"
+                    )
                     raise RPCResponseTimeoutError(request_id, timeout)
             finally:
                 self._msg_wait_event.clear()
@@ -268,6 +308,12 @@ class RPCBase:
             # the _on_rpc_response method
             assert isinstance(self._rpc_response, messages.RequestResponseMessage)
 
+            logger.info(
+                "Received GUI RPC response "
+                f"request_id={request_id} method={method} receiver={receiver} "
+                f"target_gui_id={target_gui_id} object_name={self.object_name} "
+                f"accepted={self._rpc_response.accepted}"
+            )
             if not self._rpc_response.accepted:
                 raise ValueError(self._rpc_response.message["error"])
             msg_result = self._rpc_response.message.get("result")
@@ -276,6 +322,7 @@ class RPCBase:
 
     def _on_rpc_response(self, msg_obj: MessageObject) -> None:
         msg = cast(messages.RequestResponseMessage, msg_obj.value)
+        logger.debug(f"GUI RPC response callback received: {msg}")
         self._rpc_response = msg
         self._msg_wait_event.set()
 

bec_widgets/tests/utils.py

@@ -15,7 +15,7 @@ class FakeDevice(BECDevice):
         super().__init__(name=name)
         self._enabled = enabled
         self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self._description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
         self._readout_priority = readout_priority
         self._config = {
             "readoutPriority": "baseline",
@@ -74,7 +74,7 @@ class FakeDevice(BECDevice):
         Returns:
             dict: Description of the device
         """
-        return self.description
+        return self._description
 
 
 class FakePositioner(BECPositioner):
@@ -96,7 +96,7 @@ class FakePositioner(BECPositioner):
         self._limits = limits
         self._readout_priority = readout_priority
         self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self._description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
         self._config = {
             "readoutPriority": "baseline",
             "deviceClass": "ophyd_devices.SimPositioner",
@@ -176,7 +176,7 @@ class FakePositioner(BECPositioner):
         Returns:
             dict: Description of the device
         """
-        return self.description
+        return self._description
 
     @property
     def precision(self):

bec_widgets/utils/bec_dispatcher.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import collections
 import random
 import string
+import time
 from collections.abc import Callable
-from typing import TYPE_CHECKING, DefaultDict, Hashable, Union
+from typing import TYPE_CHECKING, Any, DefaultDict, Hashable, Union
 
 import louie
 import redis
@@ -15,6 +16,7 @@ from bec_lib.service_config import ServiceConfig
 from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
+from bec_widgets.utils.rpc_logging import elapsed_seconds, format_elapsed
 from bec_widgets.utils.serialization import register_serializer_extension
 
 logger = bec_logger.logger
@@ -22,10 +24,42 @@ logger = bec_logger.logger
 if TYPE_CHECKING:  # pragma: no cover
     from bec_lib.endpoints import EndpointInfo
 
-    from bec_widgets.utils.bec_widget import BECWidget
     from bec_widgets.utils.rpc_server import RPCServer
 
 
+def _log_rpc_dispatcher_receive(msg_content: Any, metadata: Any) -> None:
+    if not isinstance(msg_content, dict) or not isinstance(metadata, dict):
+        return
+    request_id = metadata.get("request_id")
+    method = msg_content.get("action")
+    parameter = msg_content.get("parameter")
+    if request_id is None or method is None or not isinstance(parameter, dict):
+        return
+
+    dispatch_received_at = time.time()
+    sent_at = metadata.get("sent_at")
+    deadline = metadata.get("deadline")
+    timeout = metadata.get("timeout")
+    dispatch_latency = elapsed_seconds(sent_at, dispatch_received_at)
+    stale_on_dispatch = deadline is not None and dispatch_received_at > deadline
+    target_gui_id = parameter.get("gui_id") or metadata.get("target_gui_id")
+
+    logger.info(
+        "GUI RPC dispatcher received request before Qt callback emit "
+        f"request_id={request_id} method={method} receiver={metadata.get('receiver')} "
+        f"target_gui_id={target_gui_id} object_name={metadata.get('object_name')} "
+        f"timeout={timeout} dispatch_latency_s={format_elapsed(dispatch_latency)} "
+        f"stale_on_dispatch={stale_on_dispatch}"
+    )
+    if stale_on_dispatch:
+        logger.warning(
+            "GUI RPC dispatcher received request after client timeout deadline "
+            f"request_id={request_id} method={method} receiver={metadata.get('receiver')} "
+            f"target_gui_id={target_gui_id} object_name={metadata.get('object_name')} "
+            f"timeout={timeout} dispatch_latency_s={format_elapsed(dispatch_latency)}"
+        )
+
+
 class QtThreadSafeCallback(QObject):
     """QtThreadSafeCallback is a wrapper around a callback function to make it thread-safe for Qt."""
 
@@ -43,7 +77,6 @@ class QtThreadSafeCallback(QObject):
         self.cb_info = cb_info
 
         self.cb = cb
-        self.cb_owner = louie.saferef.safe_ref(cb.__self__) if hasattr(cb, "__self__") else None
         self.cb_ref = louie.saferef.safe_ref(cb)
         self.cb_signal.connect(self.cb)
         self.topics = set()
@@ -90,10 +123,12 @@ class QtRedisConnector(RedisConnector):
 
             # we can notice kwargs are lost when passed to Qt slot
             metadata = msg.metadata
+            _log_rpc_dispatcher_receive(msg.content, metadata)
             cb(msg.content, metadata)
         else:
             # from stream
             msg = msg["data"]
+            _log_rpc_dispatcher_receive(msg.content, msg.metadata)
             cb(msg.content, msg.metadata)
 
 
@@ -242,22 +277,6 @@ class BECDispatcher:
         # pylint: disable=protected-access
         self.disconnect_topics(self.client.connector._topics_cb)
 
-    def disconnect_owner(self, owner: BECWidget):
-        """
-        Disconnect all slots owned by a particular widget.
-
-        Args:
-            owner(BECWidget): The owner widget whose slots should be disconnected
-        """
-        slots_to_disconnect = []
-        for connected_slot in self._registered_slots.values():
-            if connected_slot.cb_owner is not None and connected_slot.cb_owner() == owner:
-                slots_to_disconnect.append(connected_slot)
-        for slot in slots_to_disconnect:
-            topics = slot.topics.copy()
-            for topic in topics:
-                self.disconnect_slot(slot.cb, topic)
-
     def start_cli_server(self, gui_id: str | None = None):
         """
         Start the CLI server.

bec_widgets/utils/bec_widget.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import threading
 from datetime import datetime
 from typing import TYPE_CHECKING
 
@@ -326,146 +325,46 @@ class BECWidget(BECConnector):
             return
         dock.setFloating()
 
-    def _debug_bec_parent_chain(self) -> list[str]:
-        """Return BECWidget ancestors for warning-level lifecycle diagnostics."""
-        chain: list[str] = []
-        parent = self.parent()
-        while parent is not None:
-            if not shiboken6.isValid(parent):
-                chain.append(f"<invalid parent py_id={id(parent)}>")
-                break
-            if isinstance(parent, BECWidget):
-                chain.append(
-                    f"{parent.__class__.__name__}"
-                    f"(object={parent.objectName()}, py_id={id(parent)}, "
-                    f"destroyed={getattr(parent, '_destroyed', None)})"
-                )
-            parent = parent.parent() if hasattr(parent, "parent") else None
-        return chain
-
     def cleanup(self):
         """Cleanup the widget."""
-        logger.warning(
-            "BEC WIDGET LIFECYCLE TRACE | "
-            f"event=cleanup:start | class={self.__class__.__name__} | "
-            f"object={self.objectName()} | py_id={id(self)} | "
-            f"thread={threading.current_thread().name}:{threading.get_ident()} | "
-            f"destroyed={getattr(self, '_destroyed', None)} | "
-            f"bec_parent_chain={self._debug_bec_parent_chain()}"
-        )
         with RPCRegister.delayed_broadcast():
             # All widgets need to call super().cleanup() in their cleanup method
             logger.info(f"Registry cleanup for widget {self.__class__.__name__}")
             self.rpc_register.remove_rpc(self)
-        children = self.findChildren(BECWidget)
-        logger.warning(
-            "BEC WIDGET LIFECYCLE TRACE | "
-            f"event=cleanup:children-found | class={self.__class__.__name__} | "
-            f"object={self.objectName()} | py_id={id(self)} | child_count={len(children)} | "
-            f"bec_parent_chain={self._debug_bec_parent_chain()}"
-        )
-        for child in children:
-            if not shiboken6.isValid(child):
-                # If the child is not valid, it means it has already been deleted
-                logger.warning(
-                    "BEC WIDGET LIFECYCLE TRACE | "
-                    f"event=cleanup:skip-invalid-child | parent={self.objectName()} | "
-                    f"parent_py_id={id(self)} | child_py_id={id(child)} | "
-                    f"parent_bec_parent_chain={self._debug_bec_parent_chain()}"
-                )
-                continue
-            logger.warning(
-                "BEC WIDGET LIFECYCLE TRACE | "
-                f"event=cleanup:closing-child | parent={self.objectName()} | "
-                f"parent_py_id={id(self)} | child_class={child.__class__.__name__} | "
-                f"child_object={child.objectName()} | child_py_id={id(child)} | "
-                f"child_destroyed={getattr(child, '_destroyed', None)} | "
-                f"parent_bec_parent_chain={self._debug_bec_parent_chain()} | "
-                f"child_bec_parent_chain={child._debug_bec_parent_chain()}"
-            )
-            child.close()
-            child.deleteLater()
-            logger.warning(
-                "BEC WIDGET LIFECYCLE TRACE | "
-                f"event=cleanup:child-deleteLater-called | parent={self.objectName()} | "
-                f"parent_py_id={id(self)} | child_class={child.__class__.__name__} | "
-                f"child_object={child.objectName()} | child_py_id={id(child)} | "
-                f"child_bec_parent_chain={child._debug_bec_parent_chain()}"
-            )
+            children = self.findChildren(BECWidget)
+            for child in children:
+                if not shiboken6.isValid(child):
+                    # If the child is not valid, it means it has already been deleted
+                    continue
+                child.close()
+                child.deleteLater()
 
-        # Tear down busy overlay explicitly to stop spinner and remove filters
-        overlay = getattr(self, "_busy_overlay", None)
-        if overlay is not None and shiboken6.isValid(overlay):
-            try:
-                overlay.hide()
-                filt = getattr(overlay, "_filter", None)
-                if filt is not None and shiboken6.isValid(filt):
-                    try:
-                        self.removeEventFilter(filt)
-                    except Exception as exc:
-                        logger.warning(f"Failed to remove event filter from busy overlay: {exc}")
+            # Tear down busy overlay explicitly to stop spinner and remove filters
+            overlay = getattr(self, "_busy_overlay", None)
+            if overlay is not None and shiboken6.isValid(overlay):
+                try:
+                    overlay.hide()
+                    filt = getattr(overlay, "_filter", None)
+                    if filt is not None and shiboken6.isValid(filt):
+                        try:
+                            self.removeEventFilter(filt)
+                        except Exception as exc:
+                            logger.warning(
+                                f"Failed to remove event filter from busy overlay: {exc}"
+                            )
 
-                # Cleanup the overlay widget. This will call cleanup on the custom widget if present.
+                    # Cleanup the overlay widget. This will call cleanup on the custom widget if present.
 
-                overlay.cleanup()
-                overlay.deleteLater()
-            except Exception as exc:
-                logger.warning(f"Failed to delete busy overlay: {exc}")
-        logger.warning(
-            "BEC WIDGET LIFECYCLE TRACE | "
-            f"event=cleanup:end | class={self.__class__.__name__} | "
-            f"object={self.objectName()} | py_id={id(self)} | "
-            f"destroyed={getattr(self, '_destroyed', None)} | "
-            f"bec_parent_chain={self._debug_bec_parent_chain()}"
-        )
+                    overlay.cleanup()
+                    overlay.deleteLater()
+                except Exception as exc:
+                    logger.warning(f"Failed to delete busy overlay: {exc}")
 
     def closeEvent(self, event):
         """Wrap the close even to ensure the rpc_register is cleaned up."""
-        logger.warning(
-            "BEC WIDGET LIFECYCLE TRACE | "
-            f"event=closeEvent:enter | class={self.__class__.__name__} | "
-            f"object={self.objectName()} | py_id={id(self)} | "
-            f"thread={threading.current_thread().name}:{threading.get_ident()} | "
-            f"destroyed={getattr(self, '_destroyed', None)} | "
-            f"bec_parent_chain={self._debug_bec_parent_chain()}"
-        )
         try:
             if not self._destroyed:
-                self.bec_dispatcher.disconnect_owner(self)
-                logger.warning(
-                    "BEC WIDGET LIFECYCLE TRACE | "
-                    f"event=closeEvent:before-cleanup | class={self.__class__.__name__} | "
-                    f"object={self.objectName()} | py_id={id(self)} | "
-                    f"bec_parent_chain={self._debug_bec_parent_chain()}"
-                )
                 self.cleanup()
                 self._destroyed = True
-                logger.warning(
-                    "BEC WIDGET LIFECYCLE TRACE | "
-                    f"event=closeEvent:after-cleanup-set-destroyed | "
-                    f"class={self.__class__.__name__} | object={self.objectName()} | "
-                    f"py_id={id(self)} | destroyed={self._destroyed} | "
-                    f"bec_parent_chain={self._debug_bec_parent_chain()}"
-                )
-            else:
-                logger.warning(
-                    "BEC WIDGET LIFECYCLE TRACE | "
-                    f"event=closeEvent:already-destroyed | class={self.__class__.__name__} | "
-                    f"object={self.objectName()} | py_id={id(self)} | "
-                    f"bec_parent_chain={self._debug_bec_parent_chain()}"
-                )
         finally:
-            logger.warning(
-                "BEC WIDGET LIFECYCLE TRACE | "
-                f"event=closeEvent:calling-super | class={self.__class__.__name__} | "
-                f"object={self.objectName()} | py_id={id(self)} | "
-                f"bec_parent_chain={self._debug_bec_parent_chain()}"
-            )
             super().closeEvent(event)  # pylint: disable=no-member
-            logger.warning(
-                "BEC WIDGET LIFECYCLE TRACE | "
-                f"event=closeEvent:exit | class={self.__class__.__name__} | "
-                f"object={self.objectName()} | py_id={id(self)} | "
-                f"destroyed={getattr(self, '_destroyed', None)} | "
-                f"bec_parent_chain={self._debug_bec_parent_chain()}"
-            )

bec_widgets/utils/forms_from_types/forms.py

@@ -150,7 +150,7 @@ class TypedForm(BECWidget, QWidget):
         self.adjustSize()
 
     def _new_grid_layout(self):
-        new_grid = QGridLayout(self)
+        new_grid = QGridLayout()
         new_grid.setContentsMargins(0, 0, 0, 0)
         return new_grid
 

bec_widgets/utils/rpc_logging.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+
+def elapsed_seconds(start: float | int | None, stop: float) -> float | None:
+    if start is None:
+        return None
+    try:
+        return max(0.0, stop - float(start))
+    except (TypeError, ValueError):
+        return None
+
+
+def format_elapsed(elapsed: float | None) -> str:
+    if elapsed is None:
+        return "unknown"
+    return f"{elapsed:.3f}"

bec_widgets/utils/rpc_server.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import functools
+import time
 import traceback
 import types
 from contextlib import contextmanager
@@ -11,13 +12,14 @@ from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import
 from qtpy.QtCore import Qt, QTimer
-from qtpy.QtWidgets import QWidget
+from qtpy.QtWidgets import QApplication, QWidget
 from redis.exceptions import RedisError
 
 from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.utils.container_utils import WidgetContainerUtils
 from bec_widgets.utils.error_popups import ErrorPopupUtility
+from bec_widgets.utils.rpc_logging import elapsed_seconds, format_elapsed
 from bec_widgets.utils.rpc_register import RPCRegister
 from bec_widgets.utils.screen_utils import apply_window_geometry
 from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
@@ -115,27 +117,107 @@ class RPCServer:
         if request_id is None:
             logger.error("Received RPC instruction without request_id")
             return
+        method = msg.get("action")
+        parameter = msg.get("parameter", {})
+        args = parameter.get("args", [])
+        kwargs = parameter.get("kwargs", {})
+        target_gui_id = parameter.get("gui_id")
+        sent_at = metadata.get("sent_at")
+        deadline = metadata.get("deadline")
+        timeout = metadata.get("timeout")
+        received_at = time.time()
+        receive_latency = elapsed_seconds(sent_at, received_at)
+        stale_on_receive = deadline is not None and received_at > deadline
+        logger.info(
+            "GUI RPC server received request "
+            f"request_id={request_id} method={method} gui_id={self.gui_id} "
+            f"target_gui_id={target_gui_id} timeout={timeout} "
+            f"receive_latency_s={format_elapsed(receive_latency)} "
+            f"stale_on_receive={stale_on_receive}"
+        )
+        if stale_on_receive:
+            logger.warning(
+                "GUI RPC server received request after client timeout deadline "
+                f"request_id={request_id} method={method} gui_id={self.gui_id} "
+                f"target_gui_id={target_gui_id} timeout={timeout} "
+                f"receive_latency_s={format_elapsed(receive_latency)}"
+            )
         logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
+
+        # Shutdown must acknowledge before teardown starts. The generic RPC path
+        # below publishes successful responses through QTimer.singleShot(0);
+        # for system.shutdown that would race with the queued app quit and
+        # dispatcher shutdown scheduled by _shutdown_gui_server().
+        if method == "system.shutdown":
+            execution_start = time.perf_counter()
+            try:
+                self.run_system_rpc(method, args, kwargs)
+            except Exception:
+                execution_duration = time.perf_counter() - execution_start
+                content = traceback.format_exc()
+                logger.error(
+                    "GUI RPC server shutdown request failed "
+                    f"request_id={request_id} method={method} gui_id={self.gui_id} "
+                    f"execution_duration_s={execution_duration:.3f}\n{content}"
+                )
+                self.send_response(request_id, False, {"error": content})
+            else:
+                execution_duration = time.perf_counter() - execution_start
+                logger.info(
+                    "GUI RPC server acknowledged shutdown request "
+                    f"request_id={request_id} method={method} gui_id={self.gui_id} "
+                    f"execution_duration_s={execution_duration:.3f}"
+                )
+                self.send_response(request_id, True, {"result": None})
+            return
+
+        execution_start = time.perf_counter()
         with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
             try:
-                method = msg["action"]
-                args = msg["parameter"].get("args", [])
-                kwargs = msg["parameter"].get("kwargs", {})
                 if method.startswith("system."):
                     res = self.run_system_rpc(method, args, kwargs)
                 else:
-                    obj = self.get_object_from_config(msg["parameter"])
+                    obj = self.get_object_from_config(parameter)
                     res = self.run_rpc(obj, method, args, kwargs)
             except Exception:
+                execution_duration = time.perf_counter() - execution_start
                 content = traceback.format_exc()
-                logger.error(f"Error while executing RPC instruction: {content}")
+                logger.error(
+                    "GUI RPC server execution failed "
+                    f"request_id={request_id} method={method} gui_id={self.gui_id} "
+                    f"target_gui_id={target_gui_id} execution_duration_s={execution_duration:.3f}\n"
+                    f"{content}"
+                )
                 self.send_response(request_id, False, {"error": content})
             else:
+                execution_duration = time.perf_counter() - execution_start
+                response_stale = deadline is not None and time.time() > deadline
+                logger.info(
+                    "GUI RPC server executed request "
+                    f"request_id={request_id} method={method} gui_id={self.gui_id} "
+                    f"target_gui_id={target_gui_id} execution_duration_s={execution_duration:.3f} "
+                    f"response_after_client_deadline={response_stale}"
+                )
+                if response_stale:
+                    logger.warning(
+                        "GUI RPC server response is late for client timeout "
+                        f"request_id={request_id} method={method} gui_id={self.gui_id} "
+                        f"target_gui_id={target_gui_id} timeout={timeout} "
+                        f"execution_duration_s={execution_duration:.3f}"
+                    )
                 logger.debug(f"RPC instruction executed successfully: {res}")
                 self._rpc_singleshot_repeats[request_id] = SingleshotRPCRepeat()
                 QTimer.singleShot(0, lambda: self.serialize_result_and_send(request_id, res))
 
     def send_response(self, request_id: str, accepted: bool, msg: dict):
+        log_message = (
+            "GUI RPC server publishing response "
+            f"request_id={request_id} gui_id={self.gui_id} accepted={accepted}"
+        )
+        if accepted:
+            logger.info(log_message)
+        else:
+            logger.error(log_message)
         self.client.connector.set_and_publish(
             MessageEndpoints.gui_instruction_response(request_id),
             messages.RequestResponseMessage(accepted=accepted, message=msg),
@@ -236,10 +318,23 @@ class RPCServer:
     def run_system_rpc(self, method: str, args: list, kwargs: dict):
         if method == "system.launch_dock_area":
             return self._launch_dock_area(*args, **kwargs)
+        if method == "system.shutdown":
+            return self._shutdown_gui_server()
         if method == "system.list_capabilities":
-            return {"system.launch_dock_area": True}
+            return {"system.launch_dock_area": True, "system.shutdown": True}
         raise ValueError(f"Unknown system RPC method: {method}")
 
+    @staticmethod
+    def _shutdown_gui_server() -> None:
+        app = QApplication.instance()
+        if app is None:
+            return
+        gui_server = getattr(app, "gui_server", None)
+        if gui_server is not None and hasattr(gui_server, "request_shutdown"):
+            QTimer.singleShot(0, gui_server.request_shutdown)
+            return
+        QTimer.singleShot(0, app.quit)
+
     @staticmethod
     def _launch_dock_area(
         name: str | None = None,
@@ -297,7 +392,14 @@ class RPCServer:
                 res = self.serialize_object(res)
         except RegistryNotReadyError:
             try:
-                self._rpc_singleshot_repeats[request_id] += retry_delay
+                repeat = self._rpc_singleshot_repeats[request_id]
+                repeat += retry_delay
+                logger.warning(
+                    "GUI RPC result serialization delayed; retrying "
+                    f"request_id={request_id} retry_delay_ms={retry_delay} "
+                    f"accumulated_delay_ms={repeat.accumulated_delay} "
+                    f"max_delay_ms={repeat.max_delay}"
+                )
                 QTimer.singleShot(
                     retry_delay, lambda: self.serialize_result_and_send(request_id, res)
                 )
@@ -407,8 +509,9 @@ class RPCServer:
                 container_proxy = parent.gui_id
             else:
                 container_proxy = None
-        except Exception:
+        except Exception as e:
             container_proxy = None
+            logger.error(f"Error while serializing RPC result: {e}")
 
         if wait and not self.rpc_register.object_is_registered(connector):
             raise RegistryNotReadyError(f"Connector {connector} not registered yet")

bec_widgets/utils/ui_loader.py

@@ -1,6 +1,6 @@
 from bec_lib.logger import bec_logger
 from qtpy import PYSIDE6
-from qtpy.QtCore import QEvent, QFile, QIODevice, QObject
+from qtpy.QtCore import QFile, QIODevice
 
 from bec_widgets.utils.plugin_utils import get_designer_plugin
 
@@ -9,56 +9,16 @@ logger = bec_logger.logger
 if PYSIDE6:
     from qtpy.QtUiTools import QUiLoader
 
-    class _LoadedUiCloser(QObject):
-        """Forward root close events to widgets instantiated by ``QUiLoader``.
-
-        Destroying a parent widget does not guarantee ``closeEvent`` is delivered to
-        every child widget. Some of our designer plugins rely on ``closeEvent`` /
-        ``cleanup`` to unregister callbacks, so explicitly close loaded descendants
-        when the loaded form itself is closed.
-        """
-
-        def __init__(self, root_widget):
-            super().__init__(root_widget)
-            self._root_widget = root_widget
-            self._widgets = []
-            root_widget.installEventFilter(self)
-
-        def register_widget(self, widget):
-            if widget is None or widget is self._root_widget:
-                return
-            self._widgets.append(widget)
-
-        def eventFilter(self, watched, event):
-            if watched is self._root_widget and event.type() == QEvent.Close:
-                for widget in reversed(self._widgets):
-                    try:
-                        widget.close()
-                    except RuntimeError:
-                        continue
-            return super().eventFilter(watched, event)
-
     class CustomUiLoader(QUiLoader):
         def __init__(self, baseinstance):
             super().__init__(baseinstance)
             self.baseinstance = baseinstance
-            self._closer = _LoadedUiCloser(baseinstance) if baseinstance is not None else None
 
         def createWidget(self, class_name, parent=None, name=""):
-            if parent is None and self.baseinstance is not None:
-                return self.baseinstance
-
-            widget_parent = parent if parent is not None else self.baseinstance
             widget = get_designer_plugin(class_name, raise_on_missing=False)
             if widget is not None:
-                created_widget = widget(widget_parent)
-                created_widget.setObjectName(name)
-            else:
-                created_widget = super().createWidget(class_name, widget_parent, name)
-
-            if self._closer is not None:
-                self._closer.register_widget(created_widget)
-            return created_widget
+                return widget(self.baseinstance)
+            return super().createWidget(class_name, self.baseinstance, name)
 
 
 class UILoader:

bec_widgets/widgets/containers/dock_area/basic_dock_area.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import inspect
-import threading
 from dataclasses import dataclass
 from typing import Any, Callable, Literal, Mapping, Sequence, cast
 
@@ -167,31 +166,9 @@ class DockAreaWidget(BECWidget, QWidget):
 
     def _default_close_handler(self, dock: CDockWidget, widget: QWidget) -> None:
         """Default dock close routine used when no custom handler is provided."""
-        logger.warning(
-            "DOCK AREA LIFECYCLE TRACE | "
-            f"event=default-close-handler:start | dock={dock.objectName()} | "
-            f"dock_py_id={id(dock)} | widget={widget.objectName()} | "
-            f"widget_class={widget.__class__.__name__} | widget_py_id={id(widget)} | "
-            f"thread={threading.current_thread().name}:{threading.get_ident()}"
-        )
         widget.close()
-        logger.warning(
-            "DOCK AREA LIFECYCLE TRACE | "
-            f"event=default-close-handler:after-widget-close | dock={dock.objectName()} | "
-            f"dock_valid={isValid(dock)} | widget={widget.objectName()} | "
-            f"widget_valid={isValid(widget)}"
-        )
         dock.closeDockWidget()
-        logger.warning(
-            "DOCK AREA LIFECYCLE TRACE | "
-            f"event=default-close-handler:after-closeDockWidget | dock={dock.objectName()} | "
-            f"dock_valid={isValid(dock)}"
-        )
         dock.deleteDockWidget()
-        logger.warning(
-            "DOCK AREA LIFECYCLE TRACE | "
-            f"event=default-close-handler:end | dock_py_id={id(dock)} | dock_valid={isValid(dock)}"
-        )
 
     def close_dock(self, dock: CDockWidget, widget: QWidget | None = None) -> None:
         """
@@ -395,45 +372,12 @@ class DockAreaWidget(BECWidget, QWidget):
         close_handler = self._resolve_close_handler(widget, on_close)
 
         def on_widget_destroyed():
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=widget_removed-signal:start | dock_py_id={id(dock)} | "
-                f"dock_valid={isValid(dock)} | widget={widget.objectName()} | "
-                f"widget_py_id={id(widget)} | thread={threading.current_thread().name}:{threading.get_ident()}"
-            )
             if not isValid(dock):
-                logger.warning(
-                    "DOCK AREA LIFECYCLE TRACE | "
-                    f"event=widget_removed-signal:dock-invalid-return | dock_py_id={id(dock)}"
-                )
                 return
             dock.closeDockWidget()
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=widget_removed-signal:after-closeDockWidget | dock={dock.objectName()} | "
-                f"dock_valid={isValid(dock)}"
-            )
             dock.deleteDockWidget()
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=widget_removed-signal:end | dock_py_id={id(dock)} | dock_valid={isValid(dock)}"
-            )
 
-        def on_close_requested():
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=closeRequested:start | dock={dock.objectName()} | dock_py_id={id(dock)} | "
-                f"widget={widget.objectName()} | widget_class={widget.__class__.__name__} | "
-                f"widget_py_id={id(widget)} | thread={threading.current_thread().name}:{threading.get_ident()}"
-            )
-            close_handler(dock)
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=closeRequested:end | dock_py_id={id(dock)} | dock_valid={isValid(dock)} | "
-                f"widget_py_id={id(widget)} | widget_valid={isValid(widget)}"
-            )
-
-        dock.closeRequested.connect(on_close_requested)
+        dock.closeRequested.connect(lambda: close_handler(dock))
         if hasattr(widget, "widget_removed"):
             widget.widget_removed.connect(on_widget_destroyed)
 
@@ -466,50 +410,13 @@ class DockAreaWidget(BECWidget, QWidget):
         return dock
 
     def _delete_dock(self, dock: CDockWidget) -> None:
-        logger.warning(
-            "DOCK AREA LIFECYCLE TRACE | "
-            f"event=delete-dock:start | dock={dock.objectName()} | dock_py_id={id(dock)} | "
-            f"dock_valid={isValid(dock)} | thread={threading.current_thread().name}:{threading.get_ident()}"
-        )
         widget = dock.widget()
-        logger.warning(
-            "DOCK AREA LIFECYCLE TRACE | "
-            f"event=delete-dock:widget-resolved | dock_py_id={id(dock)} | "
-            f"widget={widget.objectName() if widget else None} | "
-            f"widget_class={widget.__class__.__name__ if widget else None} | "
-            f"widget_py_id={id(widget) if widget else None} | "
-            f"widget_valid={isValid(widget) if widget else None}"
-        )
         if widget and isValid(widget):
             widget.close()
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=delete-dock:after-widget-close | dock_py_id={id(dock)} | "
-                f"widget={widget.objectName()} | widget_valid={isValid(widget)}"
-            )
             widget.deleteLater()
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=delete-dock:after-widget-deleteLater | dock_py_id={id(dock)} | "
-                f"widget_py_id={id(widget)} | widget_valid={isValid(widget)}"
-            )
         if isValid(dock):
             dock.closeDockWidget()
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=delete-dock:after-closeDockWidget | dock={dock.objectName()} | "
-                f"dock_valid={isValid(dock)}"
-            )
             dock.deleteDockWidget()
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=delete-dock:end | dock_py_id={id(dock)} | dock_valid={isValid(dock)}"
-            )
-        else:
-            logger.warning(
-                "DOCK AREA LIFECYCLE TRACE | "
-                f"event=delete-dock:dock-invalid-skip | dock_py_id={id(dock)}"
-            )
 
     def _resolve_dock_reference(
         self, ref: CDockWidget | QWidget | str | None, *, allow_none: bool = True

bec_widgets/widgets/control/buttons/button_abort/button_abort.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy.QtCore import Qt
 from qtpy.QtWidgets import QHBoxLayout, QPushButton, QToolButton, QWidget
@@ -5,6 +8,8 @@ from qtpy.QtWidgets import QHBoxLayout, QPushButton, QToolButton, QWidget
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
 
+logger = bec_logger.logger
+
 
 class AbortButton(BECWidget, QWidget):
     """A button that abort the scan."""
@@ -55,7 +60,7 @@ class AbortButton(BECWidget, QWidget):
             scan_id(str|None): The scan id to abort. If None, the current scan will be aborted.
         """
         if self.scan_id is not None:
-            print(f"Aborting scan with scan_id: {self.scan_id}")
+            logger.info(f"Aborting scan with scan_id: {self.scan_id}")
             self.queue.request_scan_abortion(scan_id=self.scan_id)
         else:
             self.queue.request_scan_abortion()

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/positioner_box_2d.py

@@ -429,7 +429,7 @@ class PositionerBox2D(PositionerBoxBase):
 
     @SafeSlot()
     def on_stop(self):
-        self._stop_device(f"{self.device_hor} or {self.device_ver}")
+        self._stop_device([self.device_hor, self.device_ver])
 
     @SafeProperty(float)
     def step_size_hor(self):

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_base.py

@@ -1,11 +1,10 @@
-import uuid
 from abc import abstractmethod
-from typing import Callable, TypedDict
+from typing import Callable, Sequence, TypedDict
 
 from bec_lib.device import Positioner
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
-from bec_lib.messages import ScanQueueMessage
+from bec_lib.messages import VariableMessage
 from qtpy.QtWidgets import (
     QDialog,
     QDoubleSpinBox,
@@ -116,17 +115,16 @@ class PositionerBoxBase(BECWidget, QWidget):
         else:
             ui["units"].setVisible(False)
 
-    def _stop_device(self, device: str):
+    def _stop_device(self, device: str | Sequence[str]):
         """Stop call"""
-        request_id = str(uuid.uuid4())
-        params = {"device": device, "rpc_id": request_id, "func": "stop", "args": [], "kwargs": {}}
-        msg = ScanQueueMessage(
-            scan_type="device_rpc",
-            parameter=params,
-            queue="emergency",
-            metadata={"RID": request_id, "response": False},
-        )
-        self.client.connector.send(MessageEndpoints.scan_queue_request(self.client.username), msg)
+        devices = [device] if isinstance(device, str) else list(device)
+        devices = [dev for dev in devices if dev]
+        if not devices:
+            logger.warning("Stop requested without a valid device.")
+            return
+
+        msg = VariableMessage(value=devices)
+        self.client.connector.send(MessageEndpoints.stop_devices(), msg)
 
     # pylint: disable=unused-argument
     def _on_device_readback(

bec_widgets/widgets/control/device_input/device_combobox/device_combobox.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import enum
-import threading
 
 from bec_lib.callback_handler import EventType
 from bec_lib.device import ComputedSignal, Device, Positioner, ReadoutPriority
@@ -217,28 +216,12 @@ class DeviceComboBox(BECWidget, QComboBox):
         else:
             self.setCurrentText("")
 
-        self._log_callback_state("init: before DEVICE_UPDATE register")
         self._callback_id = self.bec_dispatcher.client.callbacks.register(
             EventType.DEVICE_UPDATE, self.on_device_update
         )
-        self._log_callback_state("init: after DEVICE_UPDATE register")
         self.device_config_update.connect(self.update_devices_from_filters)
-        self._log_callback_state("init: device_config_update connected")
         self.currentTextChanged.connect(self.check_validity)
         self.check_validity(self.currentText())
-        self._log_callback_state("init: finished")
-
-    def _log_callback_state(self, event: str, **details) -> None:
-        logger.warning(
-            "DEVICE COMBOBOX CALLBACK TRACE | "
-            f"event={event} | object={self.objectName()} | py_id={id(self)} | "
-            f"thread={threading.current_thread().name}:{threading.get_ident()} | "
-            f"callback_id={getattr(self, '_callback_id', None)} | "
-            f"destroyed={getattr(self, '_destroyed', None)} | "
-            f"current={self.currentText()} | devices_count={len(getattr(self, '_devices', []))} | "
-            f"bec_parent_chain={self._debug_bec_parent_chain()} | "
-            f"details={details}"
-        )
 
     @staticmethod
     def _process_config(config: DeviceInputConfig | dict | None) -> DeviceInputConfig:
@@ -272,25 +255,16 @@ class DeviceComboBox(BECWidget, QComboBox):
     @SafeSlot()
     def update_devices_from_filters(self):
         """Refresh the available device list from current device/readout/signal filters."""
-        self._log_callback_state(
-            "update_devices_from_filters: enter",
-            apply_filter=self.apply_filter,
-            device_filter=[entry.value for entry in self.device_filter],
-            readout_filter=[entry.value for entry in self.readout_filter],
-            signal_class_filter=self.signal_class_filter,
-        )
         self.config.device_filter = [entry.value for entry in self.device_filter]
         self.config.readout_filter = [entry.value for entry in self.readout_filter]
         self.config.signal_class_filter = self.signal_class_filter
         if not self.apply_filter:
-            self._log_callback_state("update_devices_from_filters: apply-filter false return")
             return
 
         devices = self._filter_devices_by_signal_class(self.dev.enabled_devices)
         devices = [device for device in devices if self._check_device_filter(device)]
         devices = [device for device in devices if self._check_readout_filter(device)]
         self.devices = [device.name for device in devices]
-        self._log_callback_state("update_devices_from_filters: finished")
 
     @SafeSlot(list)
     def set_available_devices(self, devices: list[str]):
@@ -515,26 +489,18 @@ class DeviceComboBox(BECWidget, QComboBox):
             action: Device update action emitted by BEC.
             content: Device update payload. Currently unused.
         """
-        self._log_callback_state("on_device_update: enter", action=action, content=content)
+        if self._callback_id is None or getattr(self, "_destroyed", False):
+            return
         if action in ["add", "remove", "reload"]:
-            self._log_callback_state("on_device_update: emitting device_config_update")
             self.device_config_update.emit()
-            self._log_callback_state("on_device_update: emitted device_config_update")
-        else:
-            self._log_callback_state("on_device_update: ignored action", action=action)
 
     def cleanup(self):
         """Cleanup the widget."""
-        self._log_callback_state("cleanup: start")
         if self._callback_id is not None:
-            self._log_callback_state("cleanup: removing callback")
-            self.bec_dispatcher.client.callbacks.remove(self._callback_id)
+            callback_id = self._callback_id
             self._callback_id = None
-            self._log_callback_state("cleanup: callback removed")
-        else:
-            self._log_callback_state("cleanup: callback already None")
+            self.bec_dispatcher.client.callbacks.remove(callback_id)
         super().cleanup()
-        self._log_callback_state("cleanup: after super")
 
     def get_current_device(self) -> object:
         """Return the current BEC device object.

bec_widgets/widgets/control/device_input/signal_combobox/signal_combobox.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-import threading
-
 from bec_lib.callback_handler import EventType
 from bec_lib.device import Signal as BECSignal
 from bec_lib.logger import bec_logger
@@ -139,13 +137,10 @@ class SignalComboBox(BECWidget, QComboBox):
         if self.config.autocomplete:
             self.autocomplete = True
 
-        self._log_callback_state("init: before DEVICE_UPDATE register")
         self._device_update_register = self.bec_dispatcher.client.callbacks.register(
-            EventType.DEVICE_UPDATE, self.on_device_update
+            EventType.DEVICE_UPDATE, self.update_signals_from_filters
         )
-        self._log_callback_state("init: after DEVICE_UPDATE register")
         self.currentTextChanged.connect(self.on_text_changed)
-        self._log_callback_state("init: currentTextChanged connected")
 
         self.set_filter(signal_filter or [Kind.hinted, Kind.normal, Kind.config])
 
@@ -154,19 +149,6 @@ class SignalComboBox(BECWidget, QComboBox):
         if default is not None:
             self.set_signal(default)
         self.check_validity(self.currentText())
-        self._log_callback_state("init: finished")
-
-    def _log_callback_state(self, event: str, **details) -> None:
-        logger.warning(
-            "SIGNAL COMBOBOX CALLBACK TRACE | "
-            f"event={event} | object={self.objectName()} | py_id={id(self)} | "
-            f"thread={threading.current_thread().name}:{threading.get_ident()} | "
-            f"callback_id={getattr(self, '_device_update_register', None)} | "
-            f"destroyed={getattr(self, '_destroyed', None)} | "
-            f"device={getattr(self, '_device', None)} | current={self.currentText()} | "
-            f"bec_parent_chain={self._debug_bec_parent_chain()} | "
-            f"details={details}"
-        )
 
     @staticmethod
     def _process_config(config: SignalComboBoxConfig | dict | None) -> SignalComboBoxConfig:
@@ -208,18 +190,11 @@ class SignalComboBox(BECWidget, QComboBox):
         """
         previous_device = self._device
         valid_device = device if self.validate_device(device) else None
-        self._log_callback_state(
-            "set_device: before update_signals_from_filters",
-            requested_device=device,
-            previous_device=previous_device,
-            valid_device=valid_device,
-        )
         self._device = valid_device
         self.config.device = self._device
         if valid_device is None or valid_device != previous_device:
             self.setCurrentText("")
         self.update_signals_from_filters()
-        self._log_callback_state("set_device: after update_signals_from_filters")
 
     @SafeSlot()
     @SafeSlot(str, dict)
@@ -231,27 +206,19 @@ class SignalComboBox(BECWidget, QComboBox):
                 actions trigger a refresh.
             content: Optional callback payload from BEC device updates. Currently unused.
         """
-        if action is not None and action not in ["add", "remove", "reload"]:
-            self._log_callback_state("update_signals_from_filters: ignored action", action=action)
+        if self._device_update_register is None or getattr(self, "_destroyed", False):
+            return
+
+        if action is not None and action not in ["add", "remove", "reload"]:
             return
 
-        self._log_callback_state(
-            "update_signals_from_filters: enter",
-            action=action,
-            content=content,
-            signal_class_filter=self._signal_class_filter,
-            require_device=self._require_device,
-        )
         self.config.signal_filter = [kind.name for kind in self.signal_filter]
 
         if self._signal_class_filter:
-            self._log_callback_state("update_signals_from_filters: class-filter path")
             self.update_signals_from_signal_classes()
-            self._log_callback_state("update_signals_from_filters: class-filter return")
             return
 
         if not self.validate_device(self._device):
-            self._log_callback_state("update_signals_from_filters: invalid-device return")
             self._device = None
             self.config.device = None
             self._set_signal_groups([], [], [])
@@ -261,7 +228,6 @@ class SignalComboBox(BECWidget, QComboBox):
         device_info = device._info.get("signals", {})
 
         if isinstance(device, BECSignal):
-            self._log_callback_state("update_signals_from_filters: bec-signal return")
             self._set_signal_groups([(self._device, {})], [], [])
             return
 
@@ -285,20 +251,6 @@ class SignalComboBox(BECWidget, QComboBox):
                 device_name=self._device,
             ),
         )
-        self._log_callback_state(
-            "update_signals_from_filters: finished",
-            signal_count=len(self._signals),
-            hinted_count=len(self._hinted_signals),
-            normal_count=len(self._normal_signals),
-            config_count=len(self._config_signals),
-        )
-
-    def on_device_update(self, action: str, content: dict) -> None:
-        """Log BEC device-update callback entry before refreshing filters."""
-        self._log_callback_state("on_device_update: enter", action=action, content=content)
-        self._log_callback_state("on_device_update: before update_signals_from_filters")
-        self.update_signals_from_filters(action, content)
-        self._log_callback_state("on_device_update: after update_signals_from_filters")
 
     @Property(str)
     def device(self) -> str:
@@ -641,16 +593,11 @@ class SignalComboBox(BECWidget, QComboBox):
 
     def cleanup(self):
         """Cleanup the widget."""
-        self._log_callback_state("cleanup: start")
         if self._device_update_register is not None:
-            self._log_callback_state("cleanup: removing callback")
-            self.bec_dispatcher.client.callbacks.remove(self._device_update_register)
+            callback_id = self._device_update_register
             self._device_update_register = None
-            self._log_callback_state("cleanup: callback removed")
-        else:
-            self._log_callback_state("cleanup: callback already None")
+            self.bec_dispatcher.client.callbacks.remove(callback_id)
         super().cleanup()
-        self._log_callback_state("cleanup: after super")
 
     @staticmethod
     def _normalize_kind(value: Kind | str) -> Kind | None:

bec_widgets/widgets/plots/image/image_base.py

@@ -460,7 +460,7 @@ class ImageBase(PlotBase):
                 self._color_bar = None
 
             def disable_autorange():
-                print("Disabling autorange")
+                logger.info("Disabling autorange")
                 self.setProperty("autorange", False)
 
             if style == "simple":
@@ -928,7 +928,7 @@ class ImageBase(PlotBase):
                 # if sync:
                 self._sync_colorbar_levels()
         self._sync_autorange_switch()
-        print(f"Autorange set to {enabled}")
+        logger.info(f"Autorange set to {enabled}")
 
     @SafeProperty(str)
     def autorange_mode(self) -> str:

bec_widgets/widgets/plots/image/toolbar_components/device_selection.py

@@ -5,9 +5,6 @@ from bec_widgets.utils.toolbars.bundles import ToolbarBundle, ToolbarComponents
 from bec_widgets.utils.toolbars.connections import BundleConnection
 from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
-from bec_lib.logger import bec_logger
-
-logger = bec_logger.logger
 
 
 class DeviceSelection(QWidget):
@@ -17,7 +14,6 @@ class DeviceSelection(QWidget):
         super().__init__(parent=parent)
 
         self.client = client
-        self._cleanup_done = False
         self.supported_signals = [
             "PreviewSignal",
             "AsyncSignal",
@@ -142,12 +138,10 @@ class DeviceSelection(QWidget):
 
     def cleanup(self):
         """Clean up the widget resources."""
-        logger.error("Cleaning up DeviceSelection")
-        if self._cleanup_done:
-            return
-        self._cleanup_done = True
         self.device_combo_box.close()
+        self.device_combo_box.deleteLater()
         self.signal_combo_box.close()
+        self.signal_combo_box.deleteLater()
 
 
 def device_selection_bundle(components: ToolbarComponents, client=None) -> ToolbarBundle:

bec_widgets/widgets/plots/waveform/waveform.py

@@ -2449,7 +2449,7 @@ class Waveform(PlotBase):
                 first_key = next(iter(info))
                 mem_bytes = info[first_key]["value"]["mem_size"]
             size_mb = mem_bytes / (1024 * 1024)
-            print(f"Dataset size: {size_mb:.1f} MB")
+            logger.info(f"Dataset size: {size_mb:.1f} MB")
         except Exception as exc:  # noqa: BLE001
             logger.error(f"Unable to evaluate dataset size: {exc}")
             return True

bec_widgets/widgets/progress/scan_progressbar/scan_progressbar.py

@@ -155,7 +155,6 @@ class ScanProgressBar(BECWidget, QWidget):
         self._progress_device = None
         self.task = None
         self.scan_number = None
-        self.progress_started.connect(lambda: print("Scan progress started"))
 
     def connect_to_queue(self):
         """

bec_widgets/widgets/utility/toggle/toggle.py

@@ -1,6 +1,6 @@
 import sys
 
-from qtpy.QtCore import Property, QEasingCurve, QPointF, QPropertyAnimation, Qt, Signal
+from qtpy.QtCore import Property, QEasingCurve, QEvent, QPointF, QPropertyAnimation, Qt, Signal
 from qtpy.QtGui import QColor, QPainter
 from qtpy.QtWidgets import QApplication, QWidget
 
@@ -41,10 +41,22 @@ class ToggleSwitch(QWidget):
         theme = getattr(QApplication.instance(), "theme", None)
         colors = theme.colors if theme else {}
 
-        self._active_track_color = colors.get("PRIMARY", QColor(33, 150, 243))
-        self._active_thumb_color = colors.get("ON_PRIMARY", QColor(255, 255, 255))
-        self._inactive_track_color = colors.get("SEPARATOR", QColor(200, 200, 200))
-        self._inactive_thumb_color = colors.get("ON_PRIMARY", QColor(255, 255, 255))
+        self._active_track_color = self._theme_color(colors, "PRIMARY", QColor(33, 150, 243))
+        self._active_thumb_color = self._theme_color(colors, "ON_PRIMARY", QColor(255, 255, 255))
+        self._inactive_track_color = self._theme_color(colors, "SEPARATOR", QColor(200, 200, 200))
+        self._inactive_thumb_color = self._theme_color(colors, "ON_PRIMARY", QColor(255, 255, 255))
+        self._disabled_track_color = self._theme_color(colors, "DISABLED_BG", QColor(220, 220, 220))
+        self._disabled_thumb_color = self._theme_color(colors, "DISABLED_FG", QColor(150, 150, 150))
+        self._disabled_border_color = self._theme_color(
+            colors, "DISABLED_BORDER", QColor(170, 170, 170)
+        )
+        if hasattr(self, "_checked"):
+            self.update_colors()
+
+    @staticmethod
+    def _theme_color(colors: dict, key: str, fallback: QColor) -> QColor:
+        color = colors.get(key, fallback)
+        return color if isinstance(color, QColor) else QColor(color)
 
     @Property(bool)
     def checked(self):
@@ -119,29 +131,40 @@ class ToggleSwitch(QWidget):
 
     def paintEvent(self, event):
         painter = QPainter(self)
-        painter.setRenderHint(QPainter.Antialiasing)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
 
         # Draw track
         painter.setBrush(self._track_color)
-        painter.setPen(Qt.NoPen)
+        painter.setPen(self._disabled_border_color if not self.isEnabled() else Qt.PenStyle.NoPen)
         painter.drawRoundedRect(
             0, 0, self.width(), self.height(), self.height() / 2, self.height() / 2
         )
 
         # Draw thumb
         painter.setBrush(self._thumb_color)
+        painter.setPen(Qt.PenStyle.NoPen)
         diameter = int(self.height() * 0.8)
         painter.drawEllipse(int(self._thumb_pos.x()), int(self._thumb_pos.y()), diameter, diameter)
 
     def mousePressEvent(self, event):
-        if event.button() == Qt.LeftButton:
+        if self.isEnabled() and event.button() == Qt.MouseButton.LeftButton:
             self.checked = not self.checked
 
     def update_colors(self):
+        if not self.isEnabled():
+            self._thumb_color = self._disabled_thumb_color
+            self._track_color = self._disabled_track_color
+            return
 
         self._thumb_color = self.active_thumb_color if self._checked else self.inactive_thumb_color
         self._track_color = self.active_track_color if self._checked else self.inactive_track_color
 
+    def changeEvent(self, event):
+        if event.type() == QEvent.Type.EnabledChange:
+            self.update_colors()
+            self.update()
+        super().changeEvent(event)
+
     def get_thumb_pos(self, checked):
         return QPointF(self.width() - self.height() + 3, 2) if checked else QPointF(3, 2)
 
@@ -167,7 +190,7 @@ class ToggleSwitch(QWidget):
 
 
 if __name__ == "__main__":  # pragma: no cover
-    from qtpy.QtWidgets import QHBoxLayout, QVBoxLayout, QWidget
+    from qtpy.QtWidgets import QHBoxLayout, QWidget
 
     from bec_widgets.utils.colors import apply_theme
     from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
@@ -177,9 +200,12 @@ if __name__ == "__main__":  # pragma: no cover
     widget = QWidget()
     layout = QHBoxLayout(widget)
     toggle = ToggleSwitch()
+    toggle_disabled = ToggleSwitch()
     dark_mode_btn = DarkModeButton()
     layout.addWidget(toggle)
+    layout.addWidget(toggle_disabled)
     layout.addWidget(dark_mode_btn)
+    toggle_disabled.setEnabled(False)
     window = QWidget()
     window.setLayout(layout)
     window.show()

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bec_widgets"
-version = "3.12.0"
+version = "3.13.5"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [
@@ -65,6 +65,14 @@ qtermwidget = ["pyside6_qtermwidget"]
 
 
 
+
+
+
+
+
+
+
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

tests/end-2-end/conftest.py

@@ -45,7 +45,7 @@ def connected_client_gui_obj(qtbot, gui_id, bec_client_lib):
     """
     gui = BECGuiClient(gui_id=gui_id)
     try:
-        gui.start(wait=True)
+        gui.show(wait=True)
         qtbot.waitUntil(lambda: hasattr(gui, "bec"), timeout=5000)
         gui.bec.delete_all()  # ensure clean state
         qtbot.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -143,11 +143,11 @@ def test_rpc_gui_obj(connected_client_gui_obj: BECGuiClient, qtbot):
     qtbot.wait(500)
     gui.kill_server()
     assert not gui._gui_is_alive()
-    gui.start(wait=True)
+    gui.show(wait=True)
     assert gui._gui_is_alive()
-    # calling start multiple times should not change anything
-    gui.start(wait=True)
-    gui.start(wait=True)
+    # calling show multiple times should not change anything
+    gui.show(wait=True)
+    gui.show(wait=True)
 
     def wait_for_gui_started():
         return "bec" in gui.windows

tests/end-2-end/user_interaction/conftest.py

@@ -75,7 +75,7 @@ def connected_client_gui_obj(qtbot_scope_module, gui_id, bec_client_lib):
     """
     gui = BECGuiClient(gui_id=gui_id)
     try:
-        gui.start(wait=True)
+        gui.show(wait=True)
         qtbot_scope_module.waitUntil(lambda: hasattr(gui, "bec"), timeout=5000)
         gui.bec.delete_all()  # ensure clean state
         qtbot_scope_module.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)

tests/unit_tests/test_bec_connector.py

@@ -6,6 +6,7 @@ from qtpy.QtCore import QObject
 from qtpy.QtWidgets import QApplication, QWidget
 
 from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeProperty
 from bec_widgets.utils.error_popups import SafeSlot as Slot
 
@@ -15,6 +16,9 @@ from .client_mocks import mocked_client
 class BECConnectorQObject(BECConnector, QObject): ...
 
 
+class _CleanupBroadcastWidget(BECWidget, QWidget): ...
+
+
 @pytest.fixture
 def bec_connector(mocked_client):
     connector = BECConnectorQObject(client=mocked_client)
@@ -146,6 +150,28 @@ def test_bec_connector_change_object_name(bec_connector):
     assert not any(obj.objectName() == previous_name for obj in all_objects)
 
 
+def test_bec_widget_cleanup_broadcasts_after_children_are_unregistered(mocked_client, qtbot):
+    parent = _CleanupBroadcastWidget(client=mocked_client, object_name="cleanup_parent")
+    child = _CleanupBroadcastWidget(
+        parent=parent, client=mocked_client, object_name="cleanup_child"
+    )
+    qtbot.addWidget(parent)
+
+    observed_connections = []
+    parent.rpc_register.callbacks.append(
+        lambda connections: observed_connections.append(set(connections))
+    )
+
+    parent.close()
+
+    assert parent._destroyed is True
+    assert child.gui_id not in parent.rpc_register.list_all_connections()
+    assert all(
+        parent.gui_id in snapshot or child.gui_id not in snapshot
+        for snapshot in observed_connections
+    )
+
+
 def test_bec_connector_export_settings():
 
     class MyWidget(BECConnector, QWidget):

tests/unit_tests/test_bec_dispatcher.py

@@ -5,7 +5,7 @@ from unittest import mock
 
 import pytest
 from bec_lib import service_config
-from bec_lib.messages import ScanMessage
+from bec_lib.messages import GUIInstructionMessage, ScanMessage
 from bec_lib.serialization import MsgpackSerialization
 
 from bec_widgets.utils.bec_dispatcher import BECDispatcher, QtRedisConnector, QtThreadSafeCallback
@@ -213,3 +213,49 @@ def test_dispatcher_2_topic_same_cb_with_boundmethod(
 
     send_msg_event.set()
     qtbot.wait(10)
+
+
+def test_qt_redis_connector_logs_rpc_before_qt_callback(monkeypatch):
+    info_mock = mock.MagicMock()
+    warning_mock = mock.MagicMock()
+    monkeypatch.setattr("bec_widgets.utils.bec_dispatcher.logger.info", info_mock)
+    monkeypatch.setattr("bec_widgets.utils.bec_dispatcher.logger.warning", warning_mock)
+
+    def callback(_msg, _metadata):
+        pass
+
+    cb = QtThreadSafeCallback(callback)
+    connector = QtRedisConnector("localhost:1", mock.MagicMock())
+    rpc_msg = GUIInstructionMessage(
+        action="set_value",
+        parameter={"args": [1], "kwargs": {"source": "test"}, "gui_id": "ring"},
+        metadata={
+            "request_id": "dispatcher-request",
+            "receiver": "gui",
+            "object_name": "progressbar",
+            "timeout": 0.1,
+            "sent_at": 1.0,
+            "deadline": 1.1,
+        },
+    )
+
+    try:
+        connector._execute_callback(cb, {"data": rpc_msg}, {})
+
+        info_mock.assert_called_once()
+        info_message = info_mock.call_args.args[0]
+        assert "GUI RPC dispatcher received request before Qt callback emit" in info_message
+        assert "request_id=dispatcher-request" in info_message
+        assert "method=set_value" in info_message
+        assert "receiver=gui" in info_message
+        assert "target_gui_id=ring" in info_message
+        assert "object_name=progressbar" in info_message
+        assert "timeout=0.1" in info_message
+        assert "stale_on_dispatch=True" in info_message
+
+        warning_mock.assert_called_once()
+        warning_message = warning_mock.call_args.args[0]
+        assert "received request after client timeout deadline" in warning_message
+        assert "request_id=dispatcher-request" in warning_message
+    finally:
+        connector.shutdown()

tests/unit_tests/test_client_utils.py

@@ -1,10 +1,19 @@
+import signal
+import subprocess
 from contextlib import contextmanager
 from unittest import mock
 
 import pytest
 
 from bec_widgets.cli.client import BECDockArea
-from bec_widgets.cli.client_utils import BECGuiClient, _start_plot_process
+from bec_widgets.cli.client_utils import (
+    GRACEFUL_SERVER_SHUTDOWN_RPC_TIMEOUT,
+    OUTPUT_READER_STOP_EVENT_ATTR,
+    BECGuiClient,
+    _join_process_output_thread,
+    _start_plot_process,
+)
+from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCResponseTimeoutError, rpc_timeout
 
 
 @pytest.fixture
@@ -220,7 +229,7 @@ def test_client_utils_new_starts_server_when_not_alive():
         with mock.patch("bec_widgets.cli.client_utils.wait_for_server", _no_wait_for_server):
             with (
                 mock.patch.object(gui, "_check_if_server_is_alive", return_value=False),
-                mock.patch.object(gui, "start") as mock_start,
+                mock.patch.object(gui, "show") as mock_start,
             ):
                 gui.new(wait=False, startup_profile=None)
 
@@ -257,3 +266,109 @@ def test_client_utils_delete_falls_back_to_direct_close():
         gui.delete("dock")
 
     widget._run_rpc.assert_called_once_with("close")
+
+
+def test_client_utils_gui_client_set_rpc_timeout():
+    gui = BECGuiClient()
+    assert gui._rpc_timeout == 60
+
+    gui.set_rpc_timeout(10)
+    assert gui._rpc_timeout == 10
+
+
+def test_client_utils_kill_server_waits_for_process_before_joining_output_thread():
+    gui = BECGuiClient()
+    gui._client = mock.MagicMock()
+    gui._process = mock.MagicMock(pid=123, stdout=None, stderr=None)
+    gui._process.poll.return_value = None
+    order = []
+    gui._process.wait.side_effect = lambda timeout: order.append("wait")
+    gui._process_output_processing_thread = mock.MagicMock()
+    gui._process_output_processing_thread.join.side_effect = lambda timeout: order.append("join")
+    gui._process_output_processing_thread.is_alive.return_value = False
+
+    with (
+        mock.patch.object(gui, "_request_server_shutdown", return_value=False),
+        mock.patch("bec_widgets.cli.client_utils.os.getpgid", return_value=123),
+        mock.patch("bec_widgets.cli.client_utils.os.killpg") as killpg,
+    ):
+        gui.kill_server()
+
+    killpg.assert_called_once_with(123, signal.SIGTERM)
+    assert order == ["wait", "join"]
+    assert gui._process is None
+    assert gui._process_output_processing_thread is None
+
+
+def test_client_utils_kill_server_requests_graceful_shutdown_before_signal():
+    gui = BECGuiClient()
+    gui._client = mock.MagicMock()
+    process = mock.MagicMock(stdout=None, stderr=None)
+    process.poll.return_value = None
+    gui._process = process
+    gui._process_output_processing_thread = mock.MagicMock()
+    gui._process_output_processing_thread.is_alive.return_value = False
+    launcher = mock.MagicMock()
+
+    with (
+        mock.patch.object(
+            BECGuiClient, "launcher", new_callable=mock.PropertyMock
+        ) as launcher_prop,
+        mock.patch("bec_widgets.cli.client_utils.os.killpg") as killpg,
+    ):
+        launcher_prop.return_value = launcher
+        gui.kill_server()
+
+    launcher._run_rpc.assert_called_once_with(
+        "system.shutdown", wait_for_rpc_response=True, timeout=GRACEFUL_SERVER_SHUTDOWN_RPC_TIMEOUT
+    )
+    process.wait.assert_called_once_with(timeout=5)
+    killpg.assert_not_called()
+    assert gui._process is None
+    assert gui._process_output_processing_thread is None
+
+
+def test_client_utils_kill_server_kills_process_group_after_timeout():
+    gui = BECGuiClient()
+    gui._client = mock.MagicMock()
+    process = mock.MagicMock(pid=123, stdout=None, stderr=None, args=["bec-gui-server"])
+    process.poll.return_value = None
+    process.wait.side_effect = [subprocess.TimeoutExpired(cmd="bec-gui-server", timeout=10), None]
+    gui._process = process
+
+    with (
+        mock.patch.object(gui, "_request_server_shutdown", return_value=False),
+        mock.patch("bec_widgets.cli.client_utils.os.getpgid", return_value=123),
+        mock.patch("bec_widgets.cli.client_utils.os.killpg") as killpg,
+        mock.patch("bec_widgets.cli.client_utils.subprocess.run") as run,
+    ):
+        run.return_value.stdout = "PID PPID PGID STAT COMMAND\n123 1 123 S bec-gui-server"
+        gui.kill_server()
+
+    assert killpg.call_args_list == [mock.call(123, signal.SIGTERM), mock.call(123, signal.SIGKILL)]
+    assert process.wait.call_args_list == [mock.call(timeout=10), mock.call(timeout=10)]
+    run.assert_called_once_with(
+        ["ps", "-o", "pid,ppid,pgid,stat,command", "-g", "123"],
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=2,
+    )
+
+
+def test_join_process_output_thread_signals_reader_before_closing_streams():
+    process = mock.MagicMock(pid=123, args=["bec-gui-server"])
+    process.stdout = mock.MagicMock()
+    process.stderr = mock.MagicMock()
+    thread = mock.MagicMock()
+    stop_event = mock.MagicMock()
+    setattr(thread, OUTPUT_READER_STOP_EVENT_ATTR, stop_event)
+    thread.is_alive.side_effect = [True, False]
+    logger = mock.MagicMock()
+
+    _join_process_output_thread(process, thread, logger)
+
+    assert thread.join.call_args_list == [mock.call(timeout=2), mock.call(timeout=2)]
+    stop_event.set.assert_called_once_with()
+    process.stdout.close.assert_called_once_with()
+    process.stderr.close.assert_called_once_with()

tests/unit_tests/test_device_config_form_dialog.py

@@ -98,11 +98,15 @@ def test_waiting_display(update_dialog, qtbot):
         mock_spinner_stop.assert_called_once()
 
 
-def test_update_cycle(update_dialog, qtbot):
+def test_update_cycle(update_dialog):
     update = {"enabled": False, "readoutPriority": "baseline", "deviceTags": {"tag"}}
 
     def _mock_send(action="update", config=None, wait_for_response=True, timeout_s=None):
-        update_dialog.client.device_manager.devices["test_device"]._config = config["test_device"]  # type: ignore
+        device = update_dialog.client.device_manager.devices["test_device"]
+        device._config = {**device._config, **config["test_device"]}  # type: ignore
+
+    update_dialog._q_threadpool = MagicMock()
+    update_dialog._q_threadpool.start.side_effect = lambda runnable: runnable.run()
 
     update_dialog._config_helper.send_config_request = MagicMock(side_effect=_mock_send)
     for item in update_dialog._form.enumerate_form_widgets():
@@ -111,9 +115,7 @@ def test_update_cycle(update_dialog, qtbot):
 
     assert update_dialog.updated_config() == update
     update_dialog.apply()
-    qtbot.waitUntil(
-        lambda: update_dialog._config_helper.send_config_request.call_count == 1, timeout=100
-    )
+    update_dialog._q_threadpool.start.assert_called_once()
 
     update_dialog._config_helper.send_config_request.assert_called_with(
         action="update", config={"test_device": update}, wait_for_response=False

tests/unit_tests/test_device_input_widgets.py

@@ -139,6 +139,23 @@ def test_device_input_combobox_cleanup_unregisters_callback(qtbot, mocked_client
         assert widget._callback_id is None
 
 
+def test_device_input_combobox_cleanup_clears_callback_before_unregister(qtbot, mocked_client):
+    widget = DeviceComboBox(client=mocked_client)
+    qtbot.addWidget(widget)
+    callback_id = widget._callback_id
+
+    def assert_callback_cleared(removed_callback_id):
+        assert removed_callback_id == callback_id
+        assert widget._callback_id is None
+
+    with mock.patch.object(
+        mocked_client.callbacks, "remove", side_effect=assert_callback_cleared
+    ) as remove_mock:
+        widget.cleanup()
+
+    remove_mock.assert_called_once_with(callback_id)
+
+
 def test_get_device_from_input_combobox_init(device_input_combobox):
     device_input_combobox.setCurrentIndex(0)
     device_text = device_input_combobox.currentText()

tests/unit_tests/test_device_signal_input.py

@@ -196,6 +196,50 @@ def test_device_signal_input_base_cleanup(qtbot, mocked_client):
         assert widget._device_update_register is None
 
 
+def test_signal_combobox_cleanup_clears_callback_before_unregister(qtbot, mocked_client):
+    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
+    callback_id = widget._device_update_register
+
+    def assert_callback_cleared(removed_callback_id):
+        assert removed_callback_id == callback_id
+        assert widget._device_update_register is None
+
+    with mock.patch.object(
+        mocked_client.callbacks, "remove", side_effect=assert_callback_cleared
+    ) as remove_mock:
+        widget.cleanup()
+
+    remove_mock.assert_called_once_with(callback_id)
+
+
+def test_signal_combobox_cleanup_blocks_in_flight_device_update(qtbot, mocked_client):
+    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
+    callback_id = widget._device_update_register
+
+    def trigger_in_flight_update(_):
+        widget.update_signals_from_filters("reload", {})
+
+    with (
+        mock.patch.object(
+            mocked_client.callbacks, "remove", side_effect=trigger_in_flight_update
+        ) as remove_mock,
+        mock.patch.object(widget, "_set_signal_groups") as set_signal_groups,
+    ):
+        widget.cleanup()
+
+    remove_mock.assert_called_once_with(callback_id)
+    set_signal_groups.assert_not_called()
+
+
+def test_signal_combobox_device_update_ignores_update_action(qtbot, mocked_client):
+    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
+
+    with mock.patch.object(widget, "_set_signal_groups") as set_signal_groups:
+        widget.update_signals_from_filters("update", {})
+
+    set_signal_groups.assert_not_called()
+
+
 def test_signal_combobox_get_signal_name_with_item_data(qtbot, device_signal_combobox):
     """Test get_signal_name returns obj_name from item data when available."""
     device_signal_combobox.include_normal_signals = True

tests/unit_tests/test_image_view_next_gen.py

@@ -35,17 +35,6 @@ def test_initialization_defaults(qtbot, mocked_client):
     assert bec_image_view._color_bar is None
 
 
-def test_image_cleanup_cleans_toolbar_device_selection_callbacks(qtbot, mocked_client):
-    bec_image_view = create_widget(qtbot, Image, client=mocked_client)
-    device_selection = bec_image_view.toolbar.components.get_action("device_selection").widget
-
-    bec_image_view.cleanup()
-
-    assert device_selection._cleanup_done is True
-    assert device_selection.device_combo_box._callback_id is None
-    assert device_selection.signal_combo_box._device_update_register is None
-
-
 def test_setting_color_map(qtbot, mocked_client):
     bec_image_view = create_widget(qtbot, Image, client=mocked_client)
     bec_image_view.color_map = "viridis"

tests/unit_tests/test_launch_window.py

@@ -4,7 +4,9 @@ import os
 from unittest import mock
 
 import pytest
+from qtpy.QtCore import QObject
 from qtpy.QtGui import QFontMetrics
+from qtpy.QtWidgets import QWidget
 
 import bec_widgets
 from bec_widgets.applications.launch_window import START_EMPTY_PROFILE_OPTION, LaunchWindow
@@ -16,6 +18,28 @@ from .client_mocks import mocked_client
 base_path = os.path.dirname(bec_widgets.__file__)
 
 
+def _launcher_child_connection(launcher: LaunchWindow, name: str) -> QObject:
+    connection = QObject(parent=launcher)
+    connection.gui_id = f"{launcher.gui_id}:{name}"
+    connection.setObjectName(name)
+    return connection
+
+
+def _top_level_connection(qtbot, name: str) -> QWidget:
+    connection = QWidget()
+    connection.gui_id = name
+    connection.setObjectName(name)
+    qtbot.addWidget(connection)
+    return connection
+
+
+def _unparented_connection(name: str) -> QObject:
+    connection = QObject()
+    connection.gui_id = name
+    connection.setObjectName(name)
+    return connection
+
+
 @pytest.fixture
 def bec_launch_window(qtbot, mocked_client):
     widget = LaunchWindow(client=mocked_client)
@@ -117,20 +141,20 @@ def test_open_dock_area_with_start_empty_option_calls_launch(bec_launch_window):
         (["launcher", "dock_area", "scan_progress_simple", "scan_progress_full"], False),
         (
             ["launcher", "dock_area", "scan_progress_simple", "scan_progress_full", "hover_widget"],
-            True,
+            False,
         ),
+        (["launcher", "external_window"], True),
     ],
 )
-def test_gui_server_turns_off_the_lights(bec_launch_window, connection_names, hide):
+def test_gui_server_turns_off_the_lights(bec_launch_window, qtbot, connection_names, hide):
     connections = {}
     for name in connection_names:
-        conn = mock.MagicMock()
         if name == "hover_widget":
-            conn.parent.return_value = None
-            conn.objectName.return_value = "HoverWidget"
+            conn = _unparented_connection("HoverWidget")
+        elif name == "external_window":
+            conn = _top_level_connection(qtbot, "external_window")
         else:
-            conn.parent.return_value = mock.MagicMock()
-            conn.objectName.return_value = bec_launch_window.objectName()
+            conn = _launcher_child_connection(bec_launch_window, name)
         connections[name] = conn
     with (
         mock.patch.object(bec_launch_window, "show") as mock_show,
@@ -153,6 +177,23 @@ def test_gui_server_turns_off_the_lights(bec_launch_window, connection_names, hi
             mock_set_quit_on_last_window_closed.assert_called_once_with(True)
 
 
+def test_launcher_detects_external_main_window(bec_launch_window, qtbot):
+    connection = _top_level_connection(qtbot, "BECMainWindowNoRPC")
+
+    assert bec_launch_window._has_external_window({"window": connection})
+
+
+def test_launcher_logs_unparented_non_window_connection_once(bec_launch_window):
+    connection = _unparented_connection("HoverWidget")
+
+    with mock.patch("bec_widgets.applications.launch_window.logger.warning") as mock_warning:
+        bec_launch_window._turn_off_the_lights({"window": connection})
+        bec_launch_window._turn_off_the_lights({"window": connection})
+
+    mock_warning.assert_called_once()
+    assert "HoverWidget" in mock_warning.call_args.args[0]
+
+
 @pytest.mark.parametrize(
     "connection_names, close_called",
     [
@@ -163,11 +204,12 @@ def test_gui_server_turns_off_the_lights(bec_launch_window, connection_names, hi
         (["launcher", "dock_area", "scan_progress_simple", "scan_progress_full"], True),
         (
             ["launcher", "dock_area", "scan_progress_simple", "scan_progress_full", "hover_widget"],
-            False,
+            True,
         ),
+        (["launcher", "external_window"], False),
     ],
 )
-def test_launch_window_closes(bec_launch_window, connection_names, close_called):
+def test_launch_window_closes(bec_launch_window, qtbot, connection_names, close_called):
     """
     Test that the close event is handled correctly based on the connections.
     If there are no connections or only the launcher connection, the window should close.
@@ -175,13 +217,12 @@ def test_launch_window_closes(bec_launch_window, connection_names, close_called)
     """
     connections = {}
     for name in connection_names:
-        conn = mock.MagicMock()
         if name == "hover_widget":
-            conn.parent.return_value = None
-            conn.objectName.return_value = "HoverWidget"
+            conn = _unparented_connection("HoverWidget")
+        elif name == "external_window":
+            conn = _top_level_connection(qtbot, "external_window")
         else:
-            conn.parent.return_value = mock.MagicMock()
-            conn.objectName.return_value = bec_launch_window.objectName()
+            conn = _launcher_child_connection(bec_launch_window, name)
         connections[name] = conn
     close_event = mock.MagicMock()
     with mock.patch.object(

tests/unit_tests/test_positioner_box.py

@@ -2,7 +2,7 @@ from unittest import mock
 
 import pytest
 from bec_lib.endpoints import MessageEndpoints
-from bec_lib.messages import ScanQueueMessage
+from bec_lib.messages import VariableMessage
 from qtpy.QtCore import Qt, QTimer
 from qtpy.QtGui import QValidator
 from qtpy.QtWidgets import QPushButton
@@ -34,15 +34,11 @@ class PositionerWithoutPrecision(Positioner):
 def positioner_box(qtbot, mocked_client):
     """Fixture for PositionerBox widget"""
     with mock.patch(
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.uuid.uuid4"
-    ) as mock_uuid:
-        mock_uuid.return_value = "fake_uuid"
-        with mock.patch(
-            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.PositionerBoxBase._check_device_is_valid",
-            return_value=True,
-        ):
-            db = create_widget(qtbot, PositionerBox, device="samx", client=mocked_client)
-            yield db
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.PositionerBoxBase._check_device_is_valid",
+        return_value=True,
+    ):
+        db = create_widget(qtbot, PositionerBox, device="samx", client=mocked_client)
+        yield db
 
 
 def test_positioner_box(positioner_box):
@@ -89,16 +85,8 @@ def test_positioner_box_on_stop(positioner_box):
     """Test on stop button"""
     with mock.patch.object(positioner_box.client.connector, "send") as mock_send:
         positioner_box.on_stop()
-        params = {"device": "samx", "rpc_id": "fake_uuid", "func": "stop", "args": [], "kwargs": {}}
-        msg = ScanQueueMessage(
-            scan_type="device_rpc",
-            parameter=params,
-            queue="emergency",
-            metadata={"RID": "fake_uuid", "response": False},
-        )
-        mock_send.assert_called_once_with(
-            MessageEndpoints.scan_queue_request(positioner_box.client.username), msg
-        )
+        msg = VariableMessage(value=["samx"])
+        mock_send.assert_called_once_with(MessageEndpoints.stop_devices(), msg)
 
 
 def test_positioner_box_setpoint_change(positioner_box):
@@ -139,19 +127,15 @@ def test_positioner_control_line(qtbot, mocked_client):
     Inherits from PositionerBox, but the layout is changed. Check dimensions only
     """
     with mock.patch(
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.uuid.uuid4"
-    ) as mock_uuid:
-        mock_uuid.return_value = "fake_uuid"
-        with mock.patch(
-            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box.PositionerBox._check_device_is_valid",
-            return_value=True,
-        ):
-            db = PositionerControlLine(device="samx", client=mocked_client)
-            qtbot.addWidget(db)
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box.PositionerBox._check_device_is_valid",
+        return_value=True,
+    ):
+        db = PositionerControlLine(device="samx", client=mocked_client)
+        qtbot.addWidget(db)
 
-            assert db.ui.device_box.height() == db.height()
-            assert db.ui.device_box.height() >= db.dimensions[0]
-            assert db.ui.device_box.width() == 600
+        assert db.ui.device_box.height() == db.height()
+        assert db.ui.device_box.height() >= db.dimensions[0]
+        assert db.ui.device_box.width() == 600
 
 
 def test_positioner_box_open_dialog_selection(qtbot, positioner_box):

tests/unit_tests/test_positioner_box_2d.py

@@ -1,6 +1,8 @@
 from unittest import mock
 
 import pytest
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.messages import VariableMessage
 
 from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox2D
 
@@ -12,17 +14,13 @@ from .conftest import create_widget
 def positioner_box_2d(qtbot, mocked_client):
     """Fixture for PositionerBox widget"""
     with mock.patch(
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.uuid.uuid4"
-    ) as mock_uuid:
-        mock_uuid.return_value = "fake_uuid"
-        with mock.patch(
-            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.PositionerBoxBase._check_device_is_valid",
-            return_value=True,
-        ):
-            db = create_widget(
-                qtbot, PositionerBox2D, device_hor="samx", device_ver="samy", client=mocked_client
-            )
-            yield db
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.PositionerBoxBase._check_device_is_valid",
+        return_value=True,
+    ):
+        db = create_widget(
+            qtbot, PositionerBox2D, device_hor="samx", device_ver="samy", client=mocked_client
+        )
+        yield db
 
 
 def test_positioner_box_2d(positioner_box_2d):
@@ -82,6 +80,14 @@ def test_positioner_box_setpoint_changes(positioner_box_2d: PositionerBox2D):
         mock_move.assert_called_once_with(100, relative=False)
 
 
+def test_positioner_box_2d_on_stop(positioner_box_2d: PositionerBox2D):
+    """Stop button sends both positioners to the immediate stop endpoint."""
+    with mock.patch.object(positioner_box_2d.client.connector, "send") as mock_send:
+        positioner_box_2d.on_stop()
+        msg = VariableMessage(value=["samx", "samy"])
+        mock_send.assert_called_once_with(MessageEndpoints.stop_devices(), msg)
+
+
 def _hor_buttons(widget: PositionerBox2D):
     return [
         widget.ui.tweak_increase_hor,

tests/unit_tests/test_rpc_base.py

@@ -3,10 +3,12 @@ from unittest.mock import MagicMock
 import pytest
 from bec_lib.device import DeviceBaseWithConfig, Signal
 
+from bec_widgets.cli.rpc import rpc_base as rpc_base_module
 from bec_widgets.cli.rpc.rpc_base import (
     DeletedWidgetError,
     RPCBase,
     RPCReference,
+    RPCResponseTimeoutError,
     _transform_args_kwargs,
 )
 
@@ -51,3 +53,33 @@ def test_transform_args_kwargs():
     )
     assert args == ("full name", "short name", "string_arg", "full name")
     assert kwargs == {"a": "full name", "b": "short name", "c": "string_arg", "d": "full name"}
+
+
+def test_run_rpc_logs_response_timeout(monkeypatch):
+    rpc = RPCBase(gui_id="progress_widget", object_name="progressbar")
+    rpc._rpc_timeout = 0
+    rpc._client = MagicMock()
+
+    info_mock = MagicMock()
+    error_mock = MagicMock()
+    monkeypatch.setattr(rpc_base_module.logger, "info", info_mock)
+    monkeypatch.setattr(rpc_base_module.logger, "error", error_mock)
+
+    with pytest.raises(RPCResponseTimeoutError):
+        rpc._run_rpc("set_value", 42, precision=2, timeout=0)
+
+    publish_msg = rpc._client.connector.set_and_publish.call_args.args[1]
+    assert publish_msg.metadata["method"] == "set_value"
+    assert publish_msg.metadata["target_gui_id"] == "progress_widget"
+    assert publish_msg.metadata["object_name"] == "progressbar"
+    assert publish_msg.metadata["timeout"] == 0
+    assert publish_msg.metadata["deadline"] == publish_msg.metadata["sent_at"]
+    assert info_mock.call_count == 1
+    info_message = info_mock.call_args.args[0]
+    error_mock.assert_called_once()
+    error_message = error_mock.call_args.args[0]
+    assert "GUI RPC response timeout" in error_message
+    assert "method=set_value" in error_message
+    assert "target_gui_id=progress_widget" in error_message
+    assert "object_name=progressbar" in error_message
+    assert "timeout=0" in error_message

tests/unit_tests/test_rpc_server.py

@@ -1,11 +1,13 @@
 import argparse
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import pytest
 from bec_lib.service_config import ServiceConfig
 from qtpy.QtWidgets import QWidget
 
+from bec_widgets.applications import companion_app as companion_app_module
 from bec_widgets.applications.companion_app import GUIServer
+from bec_widgets.utils import rpc_server as rpc_server_module
 from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.utils.rpc_server import RegistryNotReadyError, RPCServer, SingleshotRPCRepeat
 
@@ -58,6 +60,68 @@ def test_gui_server_get_service_config(gui_server):
     assert gui_server._get_service_config().config == ServiceConfig().config
 
 
+def test_gui_server_signal_shutdown_closes_widgets_and_quits_app(gui_server):
+    widget = MagicMock()
+    gui_server.app = MagicMock()
+    gui_server.app.topLevelWidgets.return_value = [widget]
+
+    gui_server.request_shutdown()
+
+    widget.close.assert_called_once()
+    gui_server.app.quit.assert_called_once()
+
+
+def test_gui_server_shutdown_is_idempotent(gui_server):
+    gui_server.launcher_window = MagicMock()
+    gui_server.dispatcher = MagicMock()
+
+    with (
+        patch.object(companion_app_module.shiboken6, "isValid", return_value=True),
+        patch.object(companion_app_module.pylsp_server, "is_running", return_value=False),
+    ):
+        gui_server.shutdown()
+        gui_server.shutdown()
+
+    gui_server.launcher_window.close.assert_called_once()
+    gui_server.launcher_window.deleteLater.assert_called_once()
+    gui_server.dispatcher.stop_cli_server.assert_called_once()
+    gui_server.dispatcher.disconnect_all.assert_called_once()
+
+
+def test_rpc_server_system_capabilities_include_shutdown(rpc_server):
+    assert rpc_server.run_system_rpc("system.list_capabilities", [], {}) == {
+        "system.launch_dock_area": True,
+        "system.shutdown": True,
+    }
+
+
+def test_rpc_server_system_shutdown_requests_gui_server_shutdown(rpc_server, qapp):
+    gui_server = MagicMock()
+    qapp.gui_server = gui_server
+
+    rpc_server.run_system_rpc("system.shutdown", [], {})
+    qapp.processEvents()
+
+    gui_server.request_shutdown.assert_called_once()
+    del qapp.gui_server
+
+
+def test_on_rpc_update_system_shutdown_sends_response_before_return(rpc_server):
+    order = []
+    rpc_server.run_system_rpc = MagicMock(side_effect=lambda *_args: order.append("shutdown"))
+    rpc_server.send_response = MagicMock(side_effect=lambda *_args: order.append("response"))
+    rpc_server.serialize_result_and_send = MagicMock()
+
+    rpc_server.on_rpc_update(
+        {"action": "system.shutdown", "parameter": {"args": [], "kwargs": {}}},
+        {"request_id": "shutdown-request", "sent_at": 1.0, "deadline": 10.0, "timeout": 2},
+    )
+
+    assert order == ["shutdown", "response"]
+    rpc_server.send_response.assert_called_once_with("shutdown-request", True, {"result": None})
+    rpc_server.serialize_result_and_send.assert_not_called()
+
+
 def test_singleshot_rpc_repeat_raises_on_repeated_singleshot(rpc_server):
     """
     Test that a singleshot RPC method raises an error when called multiple times.
@@ -91,22 +155,34 @@ def test_serialize_result_and_send_with_singleshot_retry(rpc_server, qtbot, dumm
         # Third call succeeds
         return {"gui_id": dummy.gui_id, "success": True}
 
+    warning_mock = MagicMock()
+
     # Patch serialize_object to control when it raises RegistryNotReadyError
     with patch.object(rpc_server, "serialize_object", side_effect=serialize_side_effect):
         with patch.object(rpc_server, "send_response") as mock_send_response:
-            # Start the serialization process
-            rpc_server._rpc_singleshot_repeats[request_id] = SingleshotRPCRepeat()
-            rpc_server.serialize_result_and_send(request_id, dummy)
+            with patch.object(rpc_server_module.logger, "warning", warning_mock):
+                # Start the serialization process
+                rpc_server._rpc_singleshot_repeats[request_id] = SingleshotRPCRepeat()
+                rpc_server.serialize_result_and_send(request_id, dummy)
 
-            # Verify that serialize_object was called 3 times
-            qtbot.waitUntil(lambda: call_count >= 3, timeout=5000)
+                # Verify that serialize_object was called 3 times
+                qtbot.waitUntil(lambda: call_count >= 3, timeout=5000)
 
-            # Verify that send_response was called with success
-            mock_send_response.assert_called_once()
-            args = mock_send_response.call_args[0]
-            assert args[0] == request_id
-            assert args[1] is True  # accepted=True
-            assert "result" in args[2]
+                # Verify that send_response was called with success
+                mock_send_response.assert_called_once()
+                args = mock_send_response.call_args[0]
+                assert args[0] == request_id
+                assert args[1] is True  # accepted=True
+                assert "result" in args[2]
+
+    assert warning_mock.call_count == 2
+    warning_logs = "\n".join(call.args[0] for call in warning_mock.call_args_list)
+    assert "result serialization delayed; retrying" in warning_logs
+    assert "request_id=test_request_123" in warning_logs
+    assert "retry_delay_ms=100" in warning_logs
+    assert "accumulated_delay_ms=100" in warning_logs
+    assert "accumulated_delay_ms=200" in warning_logs
+    assert "max_delay_ms=2000" in warning_logs
 
 
 def test_serialize_result_and_send_max_delay_exceeded(rpc_server, qtbot, dummy_widget):
@@ -140,6 +216,56 @@ def test_serialize_result_and_send_max_delay_exceeded(rpc_server, qtbot, dummy_w
             assert "Max delay exceeded" in args[2]["error"]
 
 
+def test_send_response_logs_publish_status(rpc_server, monkeypatch):
+    info_mock = MagicMock()
+    error_mock = MagicMock()
+    monkeypatch.setattr(rpc_server_module.logger, "info", info_mock)
+    monkeypatch.setattr(rpc_server_module.logger, "error", error_mock)
+
+    with patch.object(rpc_server.client.connector, "set_and_publish") as publish_mock:
+        rpc_server.send_response("request-ok", True, {"result": None})
+        rpc_server.send_response("request-failed", False, {"error": "bad"})
+
+    assert publish_mock.call_count == 2
+    assert "request_id=request-ok" in info_mock.call_args.args[0]
+    assert "accepted=True" in info_mock.call_args.args[0]
+    assert "request_id=request-failed" in error_mock.call_args.args[0]
+    assert "accepted=False" in error_mock.call_args.args[0]
+
+
+def test_on_rpc_update_logs_late_client_deadline(rpc_server, monkeypatch):
+    info_mock = MagicMock()
+    warning_mock = MagicMock()
+    monkeypatch.setattr(rpc_server_module.logger, "info", info_mock)
+    monkeypatch.setattr(rpc_server_module.logger, "warning", warning_mock)
+
+    rpc_server.rpc_register.get_rpc_by_id = MagicMock()
+    rpc_server.run_rpc = MagicMock(return_value=None)
+    rpc_server.serialize_result_and_send = MagicMock()
+
+    rpc_server.on_rpc_update(
+        {
+            "action": "set_value",
+            "parameter": {"args": [1], "kwargs": {"source": "test"}, "gui_id": "ring"},
+        },
+        {"request_id": "late-request", "timeout": 0.1, "sent_at": 1.0, "deadline": 1.1},
+    )
+
+    received_log = info_mock.call_args_list[0].args[0]
+    executed_log = info_mock.call_args_list[1].args[0]
+    warning_logs = "\n".join(call.args[0] for call in warning_mock.call_args_list)
+
+    assert "GUI RPC server received request" in received_log
+    assert "request_id=late-request" in received_log
+    assert "method=set_value" in received_log
+    assert "target_gui_id=ring" in received_log
+    assert "timeout=0.1" in received_log
+    assert "stale_on_receive=True" in received_log
+    assert "response_after_client_deadline=True" in executed_log
+    assert "received request after client timeout deadline" in warning_logs
+    assert "response is late for client timeout" in warning_logs
+
+
 def test_run_rpc_delegates_to_rpc_content_class(rpc_server):
     class Content:
         USER_ACCESS = ["foo", "mode", "mode.setter"]

tests/unit_tests/test_toggle.py

@@ -36,3 +36,26 @@ def test_toggle_click(qtbot, toggle):
     qtbot.mouseClick(toggle, Qt.LeftButton)
     toggle.paintEvent(None)
     assert toggle.checked is not init_state
+
+
+def test_toggle_disabled_state_blocks_clicks_and_restores_colors(qtbot, toggle):
+    toggle.checked = True
+    assert toggle._track_color == toggle.active_track_color
+    assert toggle._thumb_color == toggle.active_thumb_color
+
+    toggle.setEnabled(False)
+
+    assert toggle._track_color == toggle._disabled_track_color
+    assert toggle._thumb_color == toggle._disabled_thumb_color
+
+    qtbot.mouseClick(toggle, Qt.LeftButton)
+
+    assert toggle.checked is True
+    assert toggle._track_color == toggle._disabled_track_color
+    assert toggle._thumb_color == toggle._disabled_thumb_color
+
+    toggle.setEnabled(True)
+
+    assert toggle.checked is True
+    assert toggle._track_color == toggle.active_track_color
+    assert toggle._thumb_color == toggle.active_thumb_color